1

"""

     2

    Generate zonefile records from hosts

     3

"""

     4

     5

import ipaddr

     6

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

     7

import pvl.dns

     8

     9

class HostZoneError(Exception):

    10

    pass

    11

    12

def resolve (origin, domain, name) :

    13

    """

    14

        Resolve relative CNAME for label@origin -> alias@domain

    15

    """

    16

    24

    25

    if not origin:

    26

        return fqdn

    27

    28

    elif domain == origin:

    29

         return name

    30

    31

    elif fqdn.endswith('.' + origin):

    32

        return pvl.dns.relative(origin, fqdn)

    33

    34

    elif domain:

    35

        raise HostZoneError("{name}: domain {domain} out of zone {origin}".format(name=name, domain=domain, origin=origin))

    36

    37

    else:

    38

        raise HostZoneError("{name}: fqdn {fqdn} out of zone {origin}".format(name=name, fqdn=fqdn, origin=origin))

    39

    40

def host_forward (host, origin) :

    41

    """

    42

        Yield ZoneRecords for hosts within the given zone origin

    43

    """

    44

    45

    try:

    46

        label = resolve(origin, host.domain, host.name)

    47

    except HostZoneError as error:

    48

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

    49

        return

    50

    51

    if host.forward:

    52

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

    53

    54

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

    55

    56

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

    57

        return

    58

    59

    elif host.forward is not None:

    60

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

    61

        return

    62

    63

    # forward

    64

    if host.ip :

    65

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

    66

    67

    if host.ip6 :

    68

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

    69

    70

    if host.location:

    71

        location_alias, location_domain = host.location

    72

    73

        if not location_domain:

    74

            location_domain = host.domain

    75

    76

        yield pvl.dns.ZoneRecord.CNAME(resolve(origin, location_domain, location_alias), label)

    77

    78

    for alias in host.alias4:

    79

        yield pvl.dns.ZoneRecord.CNAME(resolve(origin, host.domain, alias), label)

    80

    81

    for alias in host.alias4:

    82

        yield pvl.dns.ZoneRecord.A(resolve(origin, host.domain, alias), host.ip)

    83

    84

    for alias in host.alias6:

    85

         yield pvl.dns.ZoneRecord.AAAA(resolve(origin, host.domain, alias), host.ip6)

    86

    87

def host_reverse (host, prefix) :

    88

    """

    89

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

    90

    """

    91

    92

    if prefix.version == 4 :

    93

        ip = host.ip

    94

    elif prefix.version == 6 :

    95

        ip = host.ip6

    96

    else :

    97

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

    98

    99

    if not ip :

   100

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

   101

        return

   102

   103

    if ip not in prefix :

   104

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

   105

        return

   106

   107

    # relative label

   108

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

   109

   110

    if host.reverse :

   111

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

   112

   113

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

   114

   115

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

   116

   117

    elif host.reverse is None :

   118

        fqdn = host.fqdn()

   119

   120

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

   121

   122

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

   123

   124

    else :

   125

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

   126

   127

def apply_hosts_forward (options, hosts, origin) :

   128

    """

   129

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

   130

   131

        Yields ZoneRecords in Host-order

   132

    """

   133

   134

    if options.add_origin :

   135

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

   136

   137

    by_name = dict()

   138

    by_cname = dict()

   139

   140

    for host in hosts:

   141

        if not host.domain:

   142

            log.debug("%s: skip without domain", host)

   143

   144

        for rr in host_forward(host, origin) :

   145

            if rr.name in by_cname:

   146

                raise HostZoneError(host, "{host}: CNAME {cname} conflict: {rr}".format(host=host, cname=by_cname[rr.name].name, rr=rr))

   147

            elif rr.type == 'CNAME' and rr.name in by_name:

   148

                raise HostZoneError(host, "{host}: CNAME {cname} conflict: {rr}".format(host=host, cname=rr.name, rr=by_name[rr.name]))

   149

   150

            by_name[rr.name] = rr

   151

   152

            if rr.type == 'CNAME':

   153

                by_cname[rr.name] = rr

   154

   155

            # preserve ordering

   156

            yield rr

   157

   158

def apply_hosts_reverse (options, hosts, prefix) :

   159

    """

   160

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

   161

   162

        Yields ZoneRecords in IPAddress-order

   163

    """

   164

   165

    # collect data for records

   166

    by_ip = dict()

   167

   168

    for host in hosts:

   169

        for ip, rr in host_reverse(host, prefix) :

   170

            if ip in by_ip :

   171

                raise HostZoneError(host, "{host}: IP {ip} conflict: {other}".format(host=host, ip=ip, other=by_ip[ip]))

   172

   173

            # do not retain order

   174

            by_ip[ip] = rr

   175

   176

    if options.unknown_host :

   177

        # enumerate all of them

   178

        iter_ips = prefix.iterhosts()

   179

    else :

   180

        iter_ips = sorted(by_ip)

   181

   182

    for ip in iter_ips :

   183

        if ip in by_ip :

   184

            yield by_ip[ip]

   185

   186

        elif options.unknown_host:

   187

            # synthesize a record

   188

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

   189

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

   190

   191

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

   192

   193

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

   194

   195

        else :

   196

            continue

   197

   198

import pvl.args

   199

import pvl.hosts.config

   200

   201

import optparse 

   202

   203

def forward_main () :

   204

    """

   205

        Generate bind zonefiles from host definitions.

   206

    """

   207

   208

    parser = optparse.OptionParser(forward_main.__doc__)

   209

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

   210

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

   211

   212

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

   213

            help="Include $ORIGIN directive in zone")

   214

   215

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

   216

            help="Generate forward zone for domain")

   217

   218

    # input

   219

    options, args = parser.parse_args()

   220

   221

    pvl.args.apply(options)

   222

   223

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

   224

   225

    # process

   226

    for rr in apply_hosts_forward(options, hosts, options.forward_zone):

   227

        print unicode(rr)

   228

   229

    return 0

   230

   231

def reverse_main () :

   232

    """

   233

        Generate bind zonefiles from host definitions.

   234

    """

   235

   236

    parser = optparse.OptionParser(reverse_main.__doc__)

   237

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

   238

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

   239

   240

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

   241

            help="Generate reverse zone for prefix")

   242

   243

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

   244

            help="Generate records for unused IPs")

   245

   246

    # input

   247

    options, args = parser.parse_args()

   248

   249

    pvl.args.apply(options)

   250

   251

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

   252

   253

    # process

   254

    for rr in apply_hosts_reverse(options, hosts, pvl.dns.parse_prefix(options.reverse_zone)):

   255

        print unicode(rr)

   256

   257

    return 0