1

#!/usr/bin/env python

     2

     3

"""

     4

    Process bind zonefiles.

     5

     6

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

     7

"""

     8

     9

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

    10

import optparse

    11

import os.path

    12

import pvl.args

    13

import pvl.dns

    14

import pvl.dns.zone

    15

    16

from pvl.hosts import __version__

    17

    18

def parse_options (argv) :

    19

    """

    20

        Parse command-line arguments.

    21

    """

    22

    23

    prog = argv[0]

    24

    25

    parser = optparse.OptionParser(

    26

            prog        = prog,

    27

            usage       = '%prog: [options]',

    28

            version     = __version__,

    29

    30

            # module docstring

    31

            description = __doc__,

    32

    )

    33

    34

    # logging

    35

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

    36

    37

    # input/output

    38

    parser.add_option('--input-charset',        metavar='CHARSET',  default='utf-8', 

    39

            help="Encoding used for input files")

    40

    41

    parser.add_option('-o', '--output',         metavar='FILE',     default=None,

    42

            help="Write to output file; default stdout")

    43

    44

    parser.add_option('--output-charset',       metavar='CHARSET',  default='utf-8', 

    45

            help="Encoding used for output files")

    46

    47

    # check stage

    48

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

    49

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

    50

    51

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

    52

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

    53

    54

    # forward stage

    55

    parser.add_option('--forward-zone',         action='store_true', 

    56

            help="Generate forward zone")

    57

    58

    parser.add_option('--forward-txt',          action='store_true',

    59

            help="Generate TXT records for forward zone")

    60

    61

    parser.add_option('--forward-mx',           metavar='MX',

    62

            help="Generate MX records for forward zone")

    63

    64

    # reverse stage

    65

    parser.add_option('--reverse-domain',       metavar='DOMAIN',

    66

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

    67

    68

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

    69

            help="Generate forward zone for given subnet (x.z.y | a:b:c:d)")

    70

    71

    # other

    72

    parser.add_option('--serial',               metavar='YYMMDDXX',

    73

            help="Set serial for SOA record")

    74

    75

    parser.add_option('--include-path',         metavar='PATH',

    76

            help="Rewrite includes to given absolute path")

    77

    78

    # defaults

    79

    parser.set_defaults(

    80

        # XXX: combine

    81

        check_exempt        = [],

    82

    )

    83

    84

    # parse

    85

    options, args = parser.parse_args(argv[1:])

    86

    87

    # apply

    88

    pvl.args.apply(options, prog)

    89

    90

    return options, args

    91

    92

def apply_zone_input (options, args) :

    93

    """

    94

        Yield ZoneLine, ZoneRecord pairs from files.

    95

    """

    96

    97

    for file in pvl.args.apply_files(args, 'r', options.input_charset) :

    98

        log.info("Reading zone: %s", file)

    99

   101

            yield line, record

   102

   103

# TODO: --check-types to limit this to A/AAAA/CNAME etc

   104

def check_zone_hosts (zone, whitelist=None, whitelist_types=set(['TXT'])) :

   105

    """

   106

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

   107

   108

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

   109

    """

   110

   111

    by_name = {}

   112

    by_ip = {}

   113

   114

    fail = None

   115

   116

    last_name = None

   117

   118

    for l, r in zone :

   119

        if r :

   120

            name = r.name or last_name

   121

   122

            name = (r.origin, name)

   123

   124

            # name

   125

            if r.type not in whitelist_types :

   126

                if name not in by_name :

   127

                    by_name[name] = r

   128

   129

                elif r.name in whitelist :

   130

                    log.debug("Duplicate whitelist entry: %s", r)

   131

   132

                else :

   133

                    # fail!

   134

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

   135

                    fail = True

   136

   137

            # ip

   138

            if r.type == 'A' :

   139

                ip, = r.data

   140

   141

                if ip not in by_ip :

   142

                    by_ip[ip] = r

   143

   144

                else :

   145

                    # fail!

   146

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

   147

                    fail = True

   148

   149

    if fail :

   150

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

   151

        sys.exit(2)

   152

   153

    yield l, r

   154

   155

def process_zone_serial (zone, serial) :

   156

    """

   157

        Update the serial in the SOA record.

   158

    """

   159

   160

    for line, rr in zone :

   161

        if rr and rr.type == 'SOA' :

   162

            # XXX: as SOA record..

   163

            try :

   164

                soa = pvl.dns.zone.SOA.parse(line)

   165

            except TypeError as error :

   166

                log.exception("%s: unable to parse SOA: %s", rr.name, rr)

   167

                sys.exit(2)

   168

   169

            yield line, pvl.dns.zone.SOA(

   170

                    soa.master, soa.contact,

   171

                    serial, soa.refresh, soa.retry, soa.expire, soa.nxttl

   172

            )

   173

        else :

   174

            yield line, rr

   175

   176

def process_zone_forwards (zone, txt=False, mx=False) :

   177

    """

   178

        Process zone data -> forward zone data.

   179

    """

   180

   181

    for line, r in zone :

   182

        yield line, r

   183

   184

        if r and r.type == 'A' :

   185

            if txt :

   186

                # comment?

   187

                comment = r.line.comment

   188

   189

                if comment :

   190

                    yield line, ZoneRecord.TXT(None, comment, ttl=r.ttl)

   191

   192

   193

            # XXX: RP, do we need it?

   194

   195

            if mx :

   196

                # XXX: is this even a good idea?

   197

                yield line, ZoneRecord.MX(None, 10, mx, ttl=r.ttl)

   198

   199

def process_zone_reverse (zone, origin, domain) :

   200

    """

   201

        Process zone data -> reverse zone data.

   202

    """

   203

   204

    for line, r in zone :

   205

        if r and r.type == 'A' :

   206

            ip, = r.data

   207

            ptr = reverse_ipv4(ip)

   208

   209

        elif r and r.type == 'AAAA' :

   210

            ip, = r.data

   211

            ptr = reverse_ipv6(ip)

   212

   213

        else :

   214

            yield line, r

   215

            continue

   216

   217

        # verify

   218

        if zone and ptr.endswith(origin) :

   219

            ptr = ptr[:-(len(origin) + 1)]

   220

   221

        else :

   222

            log.warning("Reverse does not match zone origin, skipping: (%s) -> %s <-> %s", ip, ptr, origin)

   223

            continue

   224

   225

        # domain to use

   226

        host_domain = r.origin or domain

   227

        host_fqdn = fqdn(name, host_domain)

   228

   229

        yield line, ZoneRecord.PTR(ptr, host_fqdn)

   230

   231

def process_zone_includes (options, zone, path) :

   232

    """

   233

        Rewrite include paths in zones.

   234

    """

   235

   236

    for line, rr in zone :

   237

        if line.parts[0] == '$INCLUDE' :

   238

            _, include = line.parts

   239

   240

            yield pvl.dns.zone.ZoneLine(

   241

                    line.file,

   242

                    line.lineno, 

   243

                    line.line,

   244

                    line.indent,

   245

                    ['$INCLUDE', '"{path}"'.format(path=os.path.join(path, include))],

   246

            ), rr

   247

        else :

   248

            yield line, rr

   249

   250

   251

def apply_zone_output (options, zone) :

   252

    """

   253

        Write out the resulting zonefile.

   254

    """

   255

   256

    file = pvl.args.apply_file(options.output, 'w', options.output_charset)

   257

   258

    for line, r in zone :

   259

        if r :

   260

            file.write(unicode(r))

   261

        else :

   262

            file.write(unicode(line))

   263

        file.write('\n')

   264

   265

def main (argv) :

   266

    options, args = parse_options(argv)

   267

   268

    # input

   269

    zone = apply_zone_input(options, args)

   270

   271

    if options.check_hosts :

   272

        whitelist = set(options.check_exempt)

   273

   274

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

   275

   276

        zone = list(check_zone_hosts(zone, whitelist=whitelist))

   277

   278

    if options.serial :

   279

        log.info("Set zone serial: %s", options.serial)

   280

   281

        zone = list(process_zone_serial(zone, serial=options.serial))

   282

   283

    if options.forward_zone :

   284

        log.info("Generate forward zone...")

   285

   286

        zone = list(process_zone_forwards(zone, txt=options.forward_txt, mx=options.forward_mx))

   287

   288

    if options.reverse_zone :

   289

        if ':' in options.reverse_zone :

   290

            # IPv6

   291

            origin = reverse_ipv6(options.reverse_zone)

   292

   293

        else :

   294

            # IPv4

   295

            origin = reverse_ipv4(options.reverse_zone)

   296

   297

        domain = options.reverse_domain

   298

   299

        if not domain :

   300

            log.error("--reverse-zone requires --reverse-domain")

   301

            return 1

   302

   303

        zone = list(process_zone_reverse(zone, origin=origin, domain=domain))

   304

   305

    if options.include_path :

   306

        zone = list(process_zone_includes(options, zone, options.include_path))

   307

   308

    # output

   309

    apply_zone_output(options, zone)

   310

   311

    return 0

   312

   313

if __name__ == '__main__':

   314

    import sys

   315

    sys.exit(main(sys.argv))