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

import pvl.hosts.host

     9

    10

class HostZoneError(pvl.hosts.host.HostError):

    11

    pass

    12

    13

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

    14

def host_forward (host, origin):

    15

    """

    16

        Yield ZoneRecords for hosts within the given zone origin

    17

    """

    18

    19

    try:

    20

        label = pvl.dns.relative(origin, host.domain, host.name)

    21

    except ValueError as error:

    22

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

    23

        return

    24

    25

    if host.forward:

    26

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

    27

    28

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

    29

    30

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

    31

    32

    elif host.forward is None:

    33

        # forward

    34

        for sublabel, ip in host.addresses():

    35

            if sublabel:

    36

                sublabel = pvl.dns.join(sublabel, label)

    37

            else:

    38

                sublabel = label

    39

    40

            if ip.version == 4:

    41

                log.info("%s: ip: %s@%s A %s", host, sublabel, origin, ip)

    42

    43

                yield pvl.dns.ZoneRecord.A(sublabel, ip)

    44

    45

            elif ip.version == 6:

    46

                log.info("%s: ip6: %s@%s AAAA %s", host, label, origin, ip)

    47

    48

                yield pvl.dns.ZoneRecord.AAAA(sublabel, ip)

    49

    50

            else:

    51

                raise ValueError(ip)

    52

    53

    else:

    54

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

    55

        return

    56

    57

    if host.location:

    58

        location_alias, location_domain = host.location

    59

    60

        try:

    61

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

    62

        except ValueError as error:

    63

            raise HostZoneError(host, error)

    64

    65

    for alias in host.alias:

    66

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

    67

    68

    for alias in host.alias4:

    69

        if not host.ip4:

    70

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

    71

    72

        yield pvl.dns.ZoneRecord.A(pvl.dns.relative(origin, host.domain, alias), host.ip4)

    73

    74

    for alias in host.alias6:

    75

        if not host.ip6:

    76

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

    77

    78

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

    79

    80

def host_reverse (host, prefix) :

    81

    """

    82

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

    83

    """

    84

    85

    for sublabel, ip in host.addresses():

    86

        if ip.version != prefix.version:

    87

            continue

    88

    89

        if ip not in prefix:

    90

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

    91

            continue

    92

    93

        if ip.version == 4:

    94

            # reverse= is IPv4-only

    95

            reverse = host.reverse

    96

    97

        elif prefix.version == 6:

    98

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

    99

            reverse = None if host.reverse is None else False

   100

   101

        # relative label

   102

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

   103

   104

        if reverse:

   105

            alias = pvl.dns.fqdn(reverse)

   106

   107

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

   108

   109

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

   110

   111

        elif reverse is None:

   112

            fqdn = host.fqdn()

   113

   114

            if sublabel:

   115

                fqdn = pvl.dns.join(sublabel, fqdn)

   116

   117

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

   118

   119

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

   120

   121

        else:

   122

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

   123

   124

def apply_hosts_forward (hosts, origin,

   125

        add_origin      = False,

   126

        check_conflicts = False,

   127

) :

   128

    """

   129

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

   130

   131

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

   132

   133

            hosts: [Host]       - Host's to render

   134

            origin: str         - generate records relative to given zone origin

   135

            add_origin: bool    - generate an explicit $ORIGIN directive

   136

            check_conflits: bool- raise HostZoneError on dupliate records for the same name/type

   137

                                  overlapping CNAME records will always raise

   138

   139

        Yields ZoneRecords in Host-order

   140

    """

   141

   142

    if add_origin:

   143

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

   144

   145

    by_name = dict()

   146

    by_name_type = dict()

   147

   148

    for host in hosts:

   149

        for rr in host_forward(host, origin) :

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

   157

            by_name[rr.name] = host

   158

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

   159

   160

            # preserve ordering

   161

            yield rr

   162

   163

def apply_hosts_reverse (hosts, prefix,

   164

        unknown_host    = None,

   165

        unknown_domain  = None,

   166

) :

   167

    """

   168

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

   169

   170

            hosts: [Host]               - Host's to render PTRs for

   171

            prefix: ipaddr.IPNetwork    - IPv4/IPv6 prefix to render PTRs for within associated in-addr.arpa/ip6.arpa zone

   172

            unknown_host: str           - render a PTR to the given host @unknown_domain for unassigned IPs within prefix

   173

            unknown_domain: str         - required if unknown_host is given

   174

   175

        Yields ZoneRecords in IPAddress-order

   176

    """

   177

   178

    if unknown_host and not unknown_domain:

   179

        raise ValueError("unknown_host requires unknown_domain=")

   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 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 unknown_host:

   203

            # synthesize a record

   204

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

   205

            fqdn = pvl.dns.fqdn(unknown_host, unknown_domain)

   206

   207

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

   208

   209

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

   210

   211

        else:

   212

            continue

   213