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: domain %s out of zone: %s", host, host.domain, origin)

    46

            continue

    47

    48

        if host.forward is None  :

    49

            pass

    50

        elif host.forward :

    52

    53

            log.info("%s: forward: %s", host, forward)

    54

    55

            yield pvl.dns.zone.ZoneRecord.CNAME(label, forward)

    56

            continue

    57

        else :

    58

            log.info("%s: skip forward", host)

    59

            continue

    60

    61

        if host.ip :

    62

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

    63

    64

        if host.alias4 :

    65

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

    66

    67

        if host.ip6 :

    68

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

    69

    70

        if host.alias6 :

    71

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

    72

    73

        for alias in host.alias :

    74

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

    75

    76

        for alias4 in host.alias4 :

    77

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

    78

    79

        for alias6 in host.alias6 :

    80

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

    81

    82

def process_hosts_forward (options, hosts, origin) :

    83

    """

    84

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

    85

    """

    86

    87

    if options.add_origin :

    88

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

    89

    90

    by_name = dict()

    91

    by_name_type = dict()

    92

    93

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

    94

    MULTI_TYPES = ('A', 'AAAA')

    95

    96

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

    97

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

    98

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

    99

        elif rr.type in MULTI_TYPES :

   100

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

   101

        elif rr.name in by_name :

   102

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

   103

   104

        # always check these

   105

        by_name[rr.name] = rr

   106

   107

        # preserve ordering

   108

        yield rr

   109

   110

def split_ipv6_parts (prefix) :

   111

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

   112

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

   113

            yield nibble

   114

   115

def build_ipv6_parts (parts) :

   116

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

   117

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

   118

   119

    # suffix ::

   120

    if len(parts) < 32 :

   121

        yield ''

   122

        yield ''

   123

   124

def parse_prefix (prefix) :

   125

    """

   126

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

   127

   128

        >>> parse_prefix('127.0.0.0/8')

   129

        IPv4Network('127.0.0.0/8')

   130

        >>> parse_prefix('127.')

   131

        IPv4Network('127.0.0.0/8')

   132

        >>> parse_prefix('10')

   133

        IPv4Network('10.0.0.0/8')

   134

        >>> parse_prefix('192.168')

   135

        IPv4Network('192.168.0.0/16')

   136

        >>> parse_prefix('fe80:')

   137

        IPv6Network('fe80::/16')

   138

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

   139

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

   140

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

   141

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

   142

    """

   143

   144

    if '/' in prefix :

   145

        return ipaddr.IPNetwork(prefix)

   146

   147

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

   148

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

   149

        prefixlen = len(parts) * 8

   150

   151

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

   152

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

   153

            prefixlen   = prefixlen,

   154

        ))

   155

   156

    elif ':' in prefix :

   157

        parts = list(split_ipv6_parts(prefix))

   158

        prefixlen = len(parts) * 4

   159

   160

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

   161

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

   162

            prefixlen   = prefixlen,

   163

        ))

   164

   165

    else :

   166

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

   167

   168

def process_hosts_ips (options, hosts, prefix) :

   169

    """

   170

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

   171

    """

   172

   173

    for host in hosts :

   174

        if prefix.version == 4 :

   175

            ip = host.ip

   176

        elif prefix.version == 6 :

   177

            ip = host.ip6

   178

        else :

   179

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

   180

   181

        if not ip :

   182

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

   183

            continue

   184

   185

        if ip not in prefix :

   186

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

   187

            continue

   188

   189

        label = pvl.dns.zone.reverse_label(prefix, ip)

   190

   191

        if host.reverse is None :

   192

            fqdn = host.fqdn()

   193

   194

            log.info("%s %s[%s]: PTR %s", host, prefix, ip, fqdn)

   195

   196

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

   197

   198

        elif host.reverse :

   200

   201

            log.info("%s %s[%s]: CNAME %s", host, prefix, ip, alias)

   202

   203

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

   204

   205

        else :

   206

            log.info("%s %s[%s]: omit", host, prefix, ip)

   207

            continue

   208

   209

   210

def process_hosts_reverse (options, hosts, prefix) :

   211

    """

   212

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

   213

    """

   214

   215

    # collect data for records

   216

    by_ip = dict()

   217

    for host, ip, rr in process_hosts_ips(options, hosts, prefix) :

   218

        if ip in by_ip :

   219

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

   220

        else :

   221

            by_ip[ip] = rr

   222

   223

    if options.unknown_host :

   224

        # enumerate all of them

   225

        iter_ips = prefix.iterhosts()

   226

    else :

   227

        iter_ips = sorted(by_ip)

   228

   229

    for ip in iter_ips :

   230

        if ip in by_ip :

   231

            yield by_ip[ip]

   232

        elif options.unknown_host :

   233

            label = pvl.dns.zone.reverse_label(prefix, ip)

   234

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

   235

   236

            log.info("%s %s[%s]: unused PTR %s", options.unknown_host, ip, prefix, fqdn)

   237

   238

            yield pvl.dns.zone.ZoneRecord.PTR(label, fqdn)

   239

        else :

   240

            continue

   241

   242

def apply_zone (options, zone) :

   243

    """

   244

        Output given ZoneRecord's

   245

    """

   246

   247

    for record in zone :

   248

        print unicode(record)

   249

   250

def main (argv) :

   251

    """

   252

        Generate bind zonefiles from host definitions.

   253

    """

   254

   255

    parser = optparse.OptionParser(main.__doc__)

   256

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

   257

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

   258

   259

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

   260

            help="Include $ORIGIN directive in zone")

   261

   262

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

   263

            help="Generate forward zone for domain")

   264

   265

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

   266

            help="Generate reverse zone for prefix")

   267

   268

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

   269

            help="Generate records for unused IPs")

   270

   271

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

   272

    pvl.args.apply(options)

   273

   274

    # input

   275

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

   276

   277

    # process

   278

    if options.forward_zone :

   279

        apply_zone(options, 

   280

                process_hosts_forward(options, hosts, options.forward_zone),

   281

        )

   282

   283

    if options.reverse_zone :

   284

        apply_zone(options, 

   285

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

   286

        )

   287

   288

if __name__ == '__main__':

   289

    pvl.args.main(main)