1

#!/usr/bin/env python

     2

     3

import pvl.args

     4

import pvl.hosts

     5

import pvl.dns.zone

     6

     7

import fnmatch

     8

import ipaddr

     9

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

    10

import optparse 

    11

    12

def process_hosts_alias (options, origin, host_domain, alias, host) :

    13

    """

    14

        Resolve alias@domain within given zone.

    15

    """

    16

    17

    if host_domain :

    18

        alias = pvl.dns.join(alias, host_domain)

    19

    else :

    20

        raise ValueError("no domain given for host %s alias %s" % (host, alias, ))

    21

    22

    if alias.endswith('.' + origin) :

    23

        # strip

    24

        alias = alias[:(len(alias) - len(origin) - 1)]

    25

    else:

    26

        raise ValueError("alias domain outside of origin: %s / %s" % (alias, origin))

    27

    28

    return pvl.dns.zone.ZoneRecord.CNAME(alias, host)

    29

    30

def process_hosts_names (options, hosts, origin) :

    31

    """

    32

        Yield ZoneRecords for hosts within the given zone.

    33

    """

    34

    35

    for host in hosts :

    36

        # determine label within zone

    37

        if not origin :

    38

            label = pvl.dns.join(host, host.domain)

    39

        elif host.domain == origin :

    40

            label = str(host)

    41

        elif host.domain.endswith('.' + origin) :

    42

            fqdn = pvl.dns.join(host, host.domain)

    43

            label = fqdn[:(len(fqdn) - len(origin) - 1)]

    44

        else :

    45

            log.debug("%s: %s out of zone: %s", host, host.domain, origin)

    46

            continue

    47

    48

        if host.ip :

    49

            yield pvl.dns.zone.ZoneRecord.A(label, host.ip)

    50

    51

        if host.alias4 :

    52

            yield pvl.dns.zone.ZoneRecord.A(host.ALIAS4_FMT.format(host=label), host.ip)

    53

    54

        if host.ip6 :

    55

            yield pvl.dns.zone.ZoneRecord.AAAA(label, host.ip6)

    56

    57

        if host.alias6 :

    58

            yield pvl.dns.zone.ZoneRecord.AAAA(label.ALIAS6_FMT.format(host=host), host.ip6)

    59

    60

        for alias in host.alias :

    61

            yield process_hosts_alias(options, origin, host.domain, alias, label)

    62

    63

        for alias4 in host.alias4 :

    64

            yield process_hosts_alias(options, origin, host.domain, alias4, host.ALIAS4_FMT.format(host=label))

    65

    66

        for alias6 in host.alias6 :

    67

            yield process_hosts_alias(options, origin, host.domain,  alias6, host.ALIAS6_FMT.format(host=label))

    68

    69

def process_hosts_forward (options, hosts, origin) :

    70

    """

    71

        Generate DNS ZoneRecords for for hosts within the given zone origin.

    72

    """

    73

    74

    if options.add_origin :

    75

        yield pvl.dns.zone.ZoneDirective.build(None, 'ORIGIN', origin)

    76

    77

    by_name = dict()

    78

    by_name_type = dict()

    79

    80

    # list of types thare are allowed to be present for a host

    81

    MULTI_TYPES = ('A', 'AAAA')

    82

    83

    for rr in process_hosts_names(options, hosts, origin) :

    84

        if (rr.name, rr.type) in by_name_type :

    85

            raise ValueError("%s: duplicate name/type: %s: %s" % (rr.name, rr, by_name_type[(rr.name, rr.type)]))

    86

        elif rr.type in MULTI_TYPES :

    87

            by_name_type[(rr.name, rr.type)] = rr

    88

        elif rr.name in by_name :

    89

            raise ValueError("%s: duplicate name: %s: %s" % (rr.name, rr, by_name[rr.name]))

    90

    91

        # always check these

    92

        by_name[rr.name] = rr

    93

    94

        # preserve ordering

    95

        yield rr

    96

    97

def split_ipv6_parts (prefix) :

    98

    for hextet in prefix.rstrip(':').split(':') :

    99

        for nibble in hextet.rjust(4, '0') :

   100

            yield nibble

   101

   102

def build_ipv6_parts (parts) :

   103

    for i in xrange(0, len(parts), 4) :

   104

        yield ''.join(parts[i:i+4])

   105

   106

    # suffix ::

   107

    if len(parts) < 32 :

   108

        yield ''

   109

        yield ''

   110

   111

def parse_prefix (prefix) :

   112

    """

   113

        Return an ipaddr.IPNetwork from given IPv4/IPv6 prefix.

   114

   115

        >>> parse_prefix('127.0.0.0/8')

   116

        IPv4Network('127.0.0.0/8')

   117

        >>> parse_prefix('127.')

   118

        IPv4Network('127.0.0.0/8')

   119

        >>> parse_prefix('10')

   120

        IPv4Network('10.0.0.0/8')

   121

        >>> parse_prefix('192.168')

   122

        IPv4Network('192.168.0.0/16')

   123

        >>> parse_prefix('fe80:')

   124

        IPv6Network('fe80::/16')

   125

        >>> parse_prefix('2001:db8::')

   126

        IPv6Network('2001:db8::/32')

   127

        >>> parse_prefix('2001:db8:1:2')

   128

        IPv6Network('2001:db8:1:2::/64')

   129

    """

   130

   131

    if '/' in prefix :

   132

        return ipaddr.IPNetwork(prefix)

   133

   134

    elif '.' in prefix or prefix.isdigit() :

   135

        parts = prefix.rstrip('.').split('.')

   136

        prefixlen = len(parts) * 8

   137

   138

        return ipaddr.IPv4Network('{prefix}/{prefixlen}'.format(

   139

            prefix      = '.'.join(parts + ['0' for i in xrange(4 - len(parts))]),

   140

            prefixlen   = prefixlen,

   141

        ))

   142

   143

    elif ':' in prefix :

   144

        parts = list(split_ipv6_parts(prefix))

   145

        prefixlen = len(parts) * 4

   146

   147

        return ipaddr.IPv6Network('{prefix}/{prefixlen}'.format(

   148

            prefix      = ':'.join(build_ipv6_parts(parts)),

   149

            prefixlen   = prefixlen,

   150

        ))

   151

   152

    else :

   153

        raise ValueError("Unrecognized IP prefix string: %s" % (prefix, ))

   154

   155

def process_hosts_ips (options, hosts, prefix) :

   156

    """

   157

        Yield (ip, fqnd) for hosts within given prefix.

   158

    """

   159

   160

    for host in hosts :

   161

        if prefix.version == 4 :

   162

            ip = host.ip

   163

        elif prefix.version == 6 :

   164

            ip = host.ip6

   165

        else :

   166

            raise ValueError("%s: unknown ip version: %s" % (prefix, prefix.version))

   167

   168

        if not ip :

   169

            log.debug("%s: no ip%d", host, prefix.version)

   170

            continue

   171

   172

        if ip not in prefix :

   173

            log.debug("%s: %s out of prefix: %s", host, ip, prefix)

   174

            continue

   175

   176

        fqdn = host.fqdn()

   177

   178

        log.debug("%s: ip=%s domain=%s: %s", host, ip, host.domain, fqdn)

   179

   180

        yield ip, fqdn

   181

   182

def process_hosts_reverse (options, hosts, prefix) :

   183

    """

   184

        Generate DNS ZoneRecords within the given prefix's reverse-dns zone for hosts.

   185

    """

   186

   187

    # collect data for records

   188

    by_ip = dict()

   189

    for ip, fqdn in process_hosts_ips(options, hosts, prefix) :

   190

        if ip in by_ip :

   191

            raise ValueError("%s: duplicate ip: %s: %s" % (fqdn, ip, by_ip[ip]))

   192

        else :

   193

            by_ip[ip] = fqdn

   194

   195

    if options.unknown_host :

   196

        # enumerate all of them

   197

        iter_ips = prefix.iterhosts()

   198

    else :

   199

        iter_ips = sorted(by_ip)

   200

   201

    for ip in iter_ips :

   202

        if ip in by_ip :

   203

            fqdn = by_ip[ip]

   204

        elif options.unknown_host :

   205

            fqdn = pvl.dns.zone.fqdn(options.unknown_host, options.hosts_domain)

   206

        else :

   207

            fqdn = None

   208

   209

        log.info("%s: %s", ip, fqdn)

   210

   211

        if fqdn :

   212

            # reverse against the reverse-dns zone origin

   213

            yield pvl.dns.zone.ZoneRecord.PTR(pvl.dns.zone.reverse_label(prefix, ip), fqdn)

   214

   215

def apply_zone (options, zone) :

   216

    """

   217

        Output given ZoneRecord's

   218

    """

   219

   220

    for record in zone :

   221

        print unicode(record)

   222

   223

def main (argv) :

   224

    """

   225

        Generate bind zonefiles from host definitions.

   226

    """

   227

   228

    parser = optparse.OptionParser(main.__doc__)

   229

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

   230

    parser.add_option_group(pvl.hosts.optparser(parser))

   231

   232

    parser.add_option('--add-origin',           action='store_true',

   233

            help="Include $ORIGIN directive in zone")

   234

   235

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

   236

            help="Generate forward zone for domain")

   237

   238

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

   239

            help="Generate reverse zone for prefix")

   240

   241

    parser.add_option('--unknown-host',         metavar='NAME',

   242

            help="Generate records for unused IPs")

   243

   244

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

   245

    pvl.args.apply(options)

   246

   247

    # input

   248

    hosts = pvl.hosts.apply(options, args)

   249

   250

    # process

   251

    if options.forward_zone :

   252

        apply_zone(options, 

   253

                process_hosts_forward(options, hosts, options.forward_zone),

   254

        )

   255

   256

    if options.reverse_zone :

   257

        apply_zone(options, 

   258

                process_hosts_reverse(options, hosts, parse_prefix(options.reverse_zone)),

   259

        )

   260

   261

if __name__ == '__main__':

   262

    pvl.args.main(main)