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

    17

    if origin:

    18

        origin = pvl.dns.fqdn(origin)

    19

    20

    if domain:

    21

        fqdn = pvl.dns.fqdn(name, domain)

    22

    else:

    23

        fqdn = pvl.dns.fqdn(name)

    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

    41

def host_forward (host, origin) :

    42

    """

    43

        Yield ZoneRecords for hosts within the given zone origin

    44

    """

    45

    46

    try:

    47

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

    48

    except HostZoneError as error:

    49

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

    50

        return

    51

    52

    if host.forward:

    53

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

    54

    55

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

    56

    57

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

    58

    59

    elif host.forward is None:

    60

        # forward

    61

        if host.ip :

    62

            log.info("%s: forward %s[%s]: A %s", host, origin, label, host.ip)

    63

    64

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

    65

    66

        if host.ip6 :

    67

            log.info("%s: forward %s[%s]: AAAA %s", host, origin, label, host.ip6)

    68

    69

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

    70

    71

    else:

    72

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

    73

        return

    74

    75

    if host.location:

    76

        location_alias, location_domain = host.location

    78

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

    79

    80

    for alias in host.alias:

    81

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

    82

    83

    for alias in host.alias4:

    84

        if not host.ip:

    85

            raise HostZoneError(host, "alias4={host.alias4} without ip=".format(host=host))

    86

    87

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

    88

    89

    for alias in host.alias6:

    90

        if not host.ip6:

    91

            raise HostZoneError(host, "alias6={host.alias6} without ip6=".format(host=host))

    92

    93

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

    94

    95

def host_reverse (host, prefix) :

    96

    """

    97

        Yield (ipaddr.IPAddress, ZoneRecord) tuples for host within given prefix's reverse-dns zone.

    98

    """

    99

   100

    if prefix.version == 4 :

   101

        ip = host.ip

   102

   103

        # reverse= is IPv4-only

   104

        reverse = host.reverse

   105

   106

    elif prefix.version == 6 :

   107

        ip = host.ip6

   108

   109

        # if reverse= is set, always omit, for lack of reverse6=

   110

        reverse = None if host.reverse is None else False

   111

   112

    else :

   113

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

   114

   115

    if not ip :

   116

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

   117

        return

   118

   119

    if ip not in prefix :

   120

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

   121

        return

   122

   123

    # relative label

   124

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

   125

   126

    if reverse:

   127

        alias = pvl.dns.fqdn(reverse)

   128

   129

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

   130

   131

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

   132

   133

    elif reverse is None :

   134

        fqdn = host.fqdn()

   135

   136

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

   137

   138

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

   139

   140

    else:

   141

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

   142

   143

def apply_hosts_forward (options, hosts, origin) :

   144

    """

   145

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

   146

   147

        Yields ZoneRecords in Host-order

   148

    """

   149

   150

    if options.add_origin :

   151

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

   152

   153

    by_name = dict()

   154

    by_cname = dict()

   155

   156

    for host in hosts:

   157

        if not host.domain:

   158

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

   159

   160

        for rr in host_forward(host, origin) :

   161

            if rr.name in by_cname:

   162

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

   163

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

   164

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

   165

   166

            by_name[rr.name] = rr

   167

   168

            if rr.type == 'CNAME':

   169

                by_cname[rr.name] = rr

   170

   171

            # preserve ordering

   172

            yield rr

   173

   174

def apply_hosts_reverse (options, hosts, prefix) :

   175

    """

   176

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

   177

   178

        Yields ZoneRecords in IPAddress-order

   179

    """

   180

   181

    # collect data for records

   182

    by_ip = dict()

   183

   184

    for host in hosts:

   185

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

   186

            if ip in by_ip :

   187

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

   188

   189

            # do not retain order

   190

            by_ip[ip] = rr

   191

   192

    if options.unknown_host :

   193

        # enumerate all of them

   194

        iter_ips = prefix.iterhosts()

   195

    else :

   196

        iter_ips = sorted(by_ip)

   197

   198

    for ip in iter_ips :

   199

        if ip in by_ip :

   200

            yield by_ip[ip]

   201

   202

        elif options.unknown_host:

   203

            # synthesize a record

   204

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

   205

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

   206

   207

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

   208

   209

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

   210

   211

        else :

   212

            continue

   213

   214

import pvl.args

   215

import pvl.hosts.config

   216

   217

import optparse 

   218

   219

def forward_main () :

   220

    """

   221

        Generate bind zonefiles from host definitions.

   222

    """

   223

   224

    parser = optparse.OptionParser(forward_main.__doc__)

   225

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

   226

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

   227

   228

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

   229

            help="Include $ORIGIN directive in zone")

   230

   231

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

   232

            help="Generate forward zone for domain")

   233

   234

    # input

   235

    options, args = parser.parse_args()

   236

   237

    pvl.args.apply(options)

   238

   239

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

   240

   241

    # process

   242

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

   243

        print unicode(rr)

   244

   245

    return 0

   246

   247

def reverse_main () :

   248

    """

   249

        Generate bind zonefiles from host definitions.

   250

    """

   251

   252

    parser = optparse.OptionParser(reverse_main.__doc__)

   253

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

   254

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

   255

   256

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

   257

            help="Generate reverse zone for prefix")

   258

   259

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

   260

            help="Generate records for unused IPs")

   261

   262

    # input

   263

    options, args = parser.parse_args()

   264

   265

    pvl.args.apply(options)

   266

   267

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

   268

   269

    # process

   270

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

   271

        print unicode(rr)

   272

   273

    return 0