1 #!/usr/bin/env python

     2 

     3 

     4 import pvl.args

     5 import pvl.dns.zone

     6 

     7 import configobj

     8 import ipaddr

     9 import logging; log = logging.getLogger('pvl.hosts-dns')

    10 import math

    11 import optparse

    12 

    13 def apply_hosts_file (options, file) :

    14     """

    15         Load hosts from a file.

    16     """

    17     config = configobj.ConfigObj(file,

    18             encoding    = options.hosts_charset,

    19     )

    20 

    21     for host in config.sections :

    22         yield host, config[host]

    23 

    24 def apply_hosts (options, args) :

    25     """

    26         Load hosts from arguments.

    27     """

    28 

    29     for file in pvl.args.apply_files(args, 'r') :

    30         for host in apply_hosts_file(options, file) :

    31             yield host

    32 

    33 def process_hosts_forward (options, hosts) :

    34     for host, fields in hosts :

    35         domain = fields.get('domain', options.hosts_domain)

    36 

    37         if options.forward_zone and domain != options.forward_zone :

    38             continue

    39         

    40         ip = fields.get('ip')

    41 

    42         if ip :

    43             yield pvl.dns.zone.ZoneRecord.A(host, value)

    44         

    45         # aliases

    46         for field, value in fields.iteritems() :

    47             if field.startswith('alias.') :

    48                 yield pvl.dns.zone.ZoneRecord.CNAME(value, host)

    49 

    50 def apply_reverse_zone (options, prefix, address) :

    51     """

    52         Determine the correct reverse-dns name for the given address with the reverse zone for the given prefix.

    53     """

    54 

    55     assert prefix.version == address.version

    56     

    57     hostbits = prefix.max_prefixlen - prefix.prefixlen

    58 

    59     if prefix.version == 4 :

    60         labelbytes = int(math.ceil(hostbits / 8.0))

    61         labelraw = address.packed[-labelbytes:]

    62 

    63         return '.'.join(reversed([str(ord(x)) for x in labelraw]))

    64     else :

    65         raise ValueError("unsupported address version: %s" % (prefix, ))

    66 

    67 def process_hosts_reverse (options, hosts) :

    68     for host, fields in hosts :

    69         domain = fields.get('domain', options.hosts_domain)

    70         ip = fields.get('ip')

    71 

    72         if ip :

    73             ip = ipaddr.IPAddress(ip)

    74 

    75         if not ip or ip not in options.reverse_zone :

    76             continue

    77         

    78         # reverse against the prefix origin

    79         ptr = apply_reverse_zone(options, options.reverse_zone, ip)

    80         

    81         yield pvl.dns.zone.ZoneRecord.PTR(ptr, pvl.dns.zone.fqdn(host, domain))

    82 

    83 def main (argv) :

    84     """

    85         Generate bind zonefiles from host definitions.

    86     """

    87 

    88     parser = optparse.OptionParser(main.__doc__)

    89     parser.add_option_group(pvl.args.parser(parser))

    90     

    91     hosts = optparse.OptionGroup(parser, "Hosts input")

    92     hosts.add_option('--hosts-charset',         metavar='CHARSET',  default='utf-8', 

    93             help="Encoding used for host files")

    94 

    95     hosts.add_option('--hosts-domain',          metavar='DOMAIN',

    96             help="Default domain for hosts")

    97     

    98     parser.add_option_group(hosts)

    99 

   100     parser.add_option('--forward-zone',         metavar='DOMAIN',

   101             help="Generate forward zone for domain")

   102 

   103     parser.add_option('--reverse-zone',         metavar='PREFIX',

   104             help="Generate reverse zone for prefx")

   105 

   106     options, args = parser.parse_args(argv[1:])

   107     pvl.args.apply(options)

   108 

   109     # input

   110     hosts = list(apply_hosts(options, args))

   111 

   112 

   113     if options.forward_zone :

   114         zone = process_hosts_forward(options, hosts)

   115     

   116     elif options.reverse_zone :

   117         options.reverse_zone = ipaddr.IPNetwork(options.reverse_zone)

   118 

   119         zone = process_hosts_reverse(options, hosts)

   120 

   121     else :

   122         log.error("nothing to do")

   123         return 1

   124     

   125     for record in zone :

   126         print unicode(record)

   127 

   128 if __name__ == '__main__':

   129     pvl.args.main(main)