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 and host.domain.endswith('.' + origin) :

    42

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

    43

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

    44

        elif host.domain :

    45

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

    46

            continue

    47

        else :

    48

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

    49

            continue

    50

    51

        if host.forward is None  :

    52

            pass

    53

        elif host.forward :

    54

            forward = pvl.dns.zone.fqdn(host.forward)

    55

    56

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

    57

    58

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

    59

            continue

    60

        else :

    61

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

    62

            continue

    63

    64

        if host.ip :

    65

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

    66

    67

        if host.alias4 :

    68

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

    69

    70

        if host.ip6 :

    71

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

    72

    73

        if host.alias6 :

    74

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

    75

    76

        if host.location and host.location_domain:

    77

            yield process_hosts_alias(options, origin, host.location_domain, host.location, label)

    78

        elif host.location:

    79

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

    80

    81

        for alias in host.alias :

    82

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

    83

    84

        for alias4 in host.alias4 :

    85

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

    86

    87

        for alias6 in host.alias6 :

    88

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

    89

    90

def process_hosts_forward (options, hosts, origin) :

    91

    """

    92

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

    93

    """

    94

    95

    if options.add_origin :

    96

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

    97

    98

    by_name = dict()

    99

    by_name_type = dict()

   100

   101

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

   102

    MULTI_TYPES = ('A', 'AAAA')

   103

   104

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

   105

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

   106

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

   107

        elif rr.type in MULTI_TYPES :

   108

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

   109

        elif rr.name in by_name :

   110

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

   111

   112

        # always check these

   113

        by_name[rr.name] = rr

   114

   115

        # preserve ordering

   116

        yield rr

   117

   118

def split_ipv6_parts (prefix) :

   119

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

   120

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

   121

            yield nibble

   122

   123

def build_ipv6_parts (parts) :

   124

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

   125

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

   126

   127

    # suffix ::

   128

    if len(parts) < 32 :

   129

        yield ''

   130

        yield ''

   131

   132

def parse_prefix (prefix) :

   133

    """

   134

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

   135

   136

        >>> parse_prefix('127.0.0.0/8')

   137

        IPv4Network('127.0.0.0/8')

   138

        >>> parse_prefix('192.0.2.128/26')

   139

        IPv4Network('192.0.2.128/26')

   140

        >>> parse_prefix('192.0.2.128-26')

   141

        IPv4Network('192.0.2.128-26')

   142

        >>> parse_prefix('127.')

   143

        IPv4Network('127.0.0.0/8')

   144

        >>> parse_prefix('10')

   145

        IPv4Network('10.0.0.0/8')

   146

        >>> parse_prefix('192.168')

   147

        IPv4Network('192.168.0.0/16')

   148

        >>> parse_prefix('fe80:')

   149

        IPv6Network('fe80::/16')

   150

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

   151

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

   152

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

   153

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

   154

    """

   155

   156

    if '/' in prefix :

   157

        return ipaddr.IPNetwork(prefix)

   158

   159

    elif '-' in prefix :

   160

        return ipaddr.IPNetwork(prefix.replace('-', '/'))

   161

   162

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

   163

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

   164

        prefixlen = len(parts) * 8

   165

   166

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

   167

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

   168

            prefixlen   = prefixlen,

   169

        ))

   170

   171

    elif ':' in prefix :

   172

        parts = list(split_ipv6_parts(prefix))

   173

        prefixlen = len(parts) * 4

   174

   175

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

   176

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

   177

            prefixlen   = prefixlen,

   178

        ))

   179

   180

    else :

   181

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

   182

   183

def process_hosts_ips (options, hosts, prefix) :

   184

    """

   185

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

   186

    """

   187

   188

    for host in hosts :

   189

        if prefix.version == 4 :

   190

            ip = host.ip

   191

        elif prefix.version == 6 :

   192

            ip = host.ip6

   193

        else :

   194

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

   195

   196

        if not ip :

   197

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

   198

            continue

   199

   200

        if ip not in prefix :

   201

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

   202

            continue

   203

   204

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

   205

   206

        if host.reverse is None :

   207

            fqdn = host.fqdn()

   208

   209

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

   210

   211

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

   212

   213

        elif host.reverse :

   214

            alias = pvl.dns.zone.fqdn(host.reverse)

   215

   216

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

   217

   218

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

   219

   220

        else :

   221

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

   222

            continue

   223

   224

   225

def process_hosts_reverse (options, hosts, prefix) :

   226

    """

   227

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

   228

    """

   229

   230

    # collect data for records

   231

    by_ip = dict()

   232

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

   233

        if ip in by_ip :

   234

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

   235

        else :

   236

            by_ip[ip] = rr

   237

   238

    if options.unknown_host :

   239

        # enumerate all of them

   240

        iter_ips = prefix.iterhosts()

   241

    else :

   242

        iter_ips = sorted(by_ip)

   243

   244

    for ip in iter_ips :

   245

        if ip in by_ip :

   246

            yield by_ip[ip]

   247

        elif options.unknown_host :

   248

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

   249

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

   250

   251

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

   252

   253

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

   254

        else :

   255

            continue

   256

   257

def apply_zone (options, zone) :

   258

    """

   259

        Output given ZoneRecord's

   260

    """

   261

   262

    for record in zone :

   263

        print unicode(record)

   264

   265

def main (argv) :

   266

    """

   267

        Generate bind zonefiles from host definitions.

   268

    """

   269

   270

    parser = optparse.OptionParser(main.__doc__)

   271

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

   272

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

   273

   274

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

   275

            help="Include $ORIGIN directive in zone")

   276

   277

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

   278

            help="Generate forward zone for domain")

   279

   280

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

   281

            help="Generate reverse zone for prefix")

   282

   283

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

   284

            help="Generate records for unused IPs")

   285

   286

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

   287

    pvl.args.apply(options)

   288

   289

    # input

   290

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

   291

   292

    # process

   293

    if options.forward_zone :

   294

        apply_zone(options, 

   295

                process_hosts_forward(options, hosts, options.forward_zone),

   296

        )

   297

   298

    if options.reverse_zone :

   299

        apply_zone(options, 

   300

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

   301

        )

   302

   303

if __name__ == '__main__':

   304

    pvl.args.main(main)