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

    40

# TODO: generate location alias CNAMEs even if host itself is outside origin?

    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

    77

    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

        Verifies that there are no overlapping name/type records, or CNAME records from aliases.

   148

   149

        Yields ZoneRecords in Host-order

   150

    """

   151

   152

    if options.add_origin :

   153

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

   154

   155

    by_name = dict()

   156

    by_name_type = dict()

   157

   158

    for host in hosts:

   159

        if not host.domain:

   160

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

   161

   162

        for rr in host_forward(host, origin) :

   163

            if (rr.name, 'CNAME') in by_name_type:

   164

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

   165

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

   166

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

   167

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

   168

                raise HostZoneError(host, "{host}: {type} {name} conflict: {rr}".format(host=host, type=rr.type, name=rr.name, rr=by_name_type[rr.name, rr.type]))

   169

   170

            by_name[rr.name] = rr

   171

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

   172

   173

            # preserve ordering

   174

            yield rr

   175

   176

def apply_hosts_reverse (options, hosts, prefix) :

   177

    """

   178

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

   179

   180

        Yields ZoneRecords in IPAddress-order

   181

    """

   182

   183

    if options.unknown_host and not options.hosts_domain:

   184

        raise Exception("--unknown-host requires --hosts-domain")

   185

   186

    # collect data for records

   187

    by_ip = dict()

   188

   189

    for host in hosts:

   190

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

   191

            if ip in by_ip :

   192

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

   193

   194

            # do not retain order

   195

            by_ip[ip] = rr

   196

   197

    if options.unknown_host :

   198

        # enumerate all of them

   199

        iter_ips = prefix.iterhosts()

   200

    else :

   201

        iter_ips = sorted(by_ip)

   202

   203

    for ip in iter_ips :

   204

        if ip in by_ip :

   205

            yield by_ip[ip]

   206

   207

        elif options.unknown_host:

   208

            # synthesize a record

   209

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

   210

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

   211

   212

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

   213

   214

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

   215

   216

        else:

   217

            continue

   218