1

#!/usr/bin/env python

     2

     3

"""

     4

    Generate bind zonefiles from a given input zonefile.

     5

     6

    Takes a zonefile as input, and gives a new zonefile as output.

     7

"""

     8

     9

import ipaddr

    10

import logging; log = logging.getLogger('pvl.dns-generate')

    11

import optparse

    12

import pvl.args

    13

import pvl.dns.reverse

    14

import pvl.dns.process

    15

    16

def check_zone (rrs, whitelist_names=set(), whitelist_types=set()):

    17

    """

    18

        Parse host/IP pairs from the zone, and verify that they are unique.

    19

    20

        As an exception, names listed in the given whitelist may have multiple IPs.

    21

    """

    22

    23

    by_name = {}

    24

    by_ip = {}

    25

    26

    check = True

    27

    28

    for rr in rrs:

    29

        name = (rr.origin, rr.name)

    30

    31

        # name

    32

        if name not in by_name:

    33

            pass

    34

    35

        elif rr.type in whitelist_types:

    36

            log.debug("%s: Whitelist type duplicate: %s", rr, by_name[name])

    37

    38

        elif rr.name in whitelist_names:

    39

            log.debug("%s: Whitelist name duplicate: %s", rr, by_name[name])

    40

    41

        else:

    42

            log.warn("%s: Duplicate name: %s <-> %s", rr.line, rr, by_name[name])

    43

            check = False

    44

    45

        by_name[name] = rr

    46

    47

        # ip

    48

        if rr.type in ('A', 'AAAA'):

    49

            ip, = rr.data

    50

    51

            if ip in by_ip:

    52

                log.warn("%s: Duplicate IP: %s <-> %s", rr.line, rr, by_ip[ip])

    53

                check = False

    54

    55

            by_ip[ip] = rr

    56

    57

    return check

    58

    59

def process_zone_reverse (rrs, prefix):

    60

    """

    61

        Process zone data -> reverse zone data.

    62

    """

    63

    64

    for r in rrs:

    65

        if r.type == 'A':

    66

            ip, = r.data

    67

    68

            ip = ipaddr.IPv4Address(ip)

    69

    70

        elif r.type == 'AAAA':

    71

            ip, = r.data

    72

    73

            ip = ipaddr.IPv6Address(ip)

    74

    75

        else:

    76

            continue

    77

    78

        if ip not in prefix:

    79

            log.debug("%s: skip: %s not in %s", rr, ip, prefix)

    80

            continue

    81

    82

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

    83

        fqdn = pvl.dns.fqdn(r.name, r.origin)

    84

    85

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

    86

    87

def main (argv):

    88

    parser = optparse.OptionParser(main.__doc__)

    89

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

    90

    parser.add_option_group(pvl.dns.process.optparser(parser))

    91

    92

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

    93

            help="Domain to use for hosts in zone")

    94

    95

    # check stage

    96

    parser.add_option('--check-hosts',          action='store_true',

    97

            help="Check that host/IPs are unique. Use --quiet to silence warnings, and test exit status")

    98

    99

    parser.add_option('--check-exempt',         metavar='HOST', action='append',

   100

            help="Allow given names to have multiple records")

   101

   102

    # reverse stage

   103

    parser.add_option('--reverse-prefix',         metavar='NET',

   104

            help="Generate forward zone for given subnet (192.0.2, 2001:db8)")

   105

   106

   107

    parser.set_defaults(

   108

        check_exempt        = [

   109

            '@'

   110

        ],

   111

    )

   112

   113

    # input

   114

    options, args = pvl.args.parse(parser, argv)

   115

   116

    if options.reverse_prefix and not options.zone_origin:

   117

        log.error("--reverse-prefix requires --zone-origin")

   118

   119

    zone = list(pvl.dns.process.apply_zone_records(options, options.zone_origin, args))

   120

   121

    # check

   122

    if options.check_hosts:

   123

        whitelist_names = set(options.check_exempt)

   124

   125

        log.info("Checking hosts: whitelist_names=%r", whitelist_names)

   126

   127

        if not check_zone(zone, whitelist_names=whitelist_names):

   128

            log.error("Check zone failed, see warnings")

   129

            return 2

   130

   131

    # transform

   132

    if options.reverse_prefix:

   133

        prefix = pvl.dns.reverse.parse_prefix(options.reverse_prefix)

   134

   135

        zone = list(process_zone_reverse(zone, prefix))

   136

    else:

   137

        # pass through

   138

        pass

   139

   140

    pvl.dns.process.apply_zone_output(options, zone)

   141

   142

    return 0

   143

   144

if __name__ == '__main__':

   145

    pvl.args.main(main)

   146