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 optparse

    10

    11

import pvl.args

    12

import pvl.dns.zone

    13

from pvl.dns import __version__

    14

from pvl.dns.zone import ZoneRecord, reverse_ipv4, reverse_ipv6, fqdn

    15

    16

import logging; log = logging.getLogger('main')

    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('-c', '--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

    # meta stage

    55

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

    56

            help="Generate host metadata zone; requires --input-line-date")

    57

    58

    parser.add_option('--meta-ignore',          metavar='HOST', action='append',

    59

            help="Ignore given hostnames in metadata output")

    60

    61

    parser.add_option('--input-line-date',      action='store_true',

    62

            help="Parse timestamp prefix from each input line (e.g. `hg blame | ...`)")

    63

    64

    # forward stage

    65

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

    66

            help="Generate forward zone")

    67

    68

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

    69

            help="Generate TXT records for forward zone")

    70

    71

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

    72

            help="Generate MX records for forward zone")

    73

    74

    # reverse stage

    75

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

    76

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

    77

    78

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

    79

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

    80

    81

    # other

    82

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

    83

            help="Set serial for SOA record")

    84

    85

    # defaults

    86

    parser.set_defaults(

    87

        # XXX: combine

    88

        check_exempt        = [],

    89

        meta_ignore         = [],

    90

    )

    91

    92

    # parse

    93

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

    94

    95

    # apply

    96

    pvl.args.apply(options, prog)

    97

    98

    return options, args

    99

   100

def apply_zone_input (options, args) :

   101

    """

   102

        Yield ZoneLine, ZoneRecord pairs from files.

   103

    """

   104

   105

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

   106

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

   107

   108

        for line, record in pvl.dns.zone.ZoneLine.load(file, 

   109

                line_timestamp_prefix   = options.input_line_date,

   110

        ) :

   111

            yield line, record

   112

   113

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

   114

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

   115

    """

   116

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

   117

   118

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

   119

    """

   120

   121

    by_name = {}

   122

    by_ip = {}

   123

   124

    fail = None

   125

   126

    last_name = None

   127

   128

    for l, r in zone :

   129

        if r :

   130

            name = r.name or last_name

   131

   132

            name = (r.origin, name)

   133

   134

            # name

   135

            if r.type not in whitelist_types :

   136

                if name not in by_name :

   137

                    by_name[name] = r

   138

   139

                elif r.name in whitelist :

   140

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

   141

   142

                else :

   143

                    # fail!

   144

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

   145

                    fail = True

   146

   147

            # ip

   148

            if r.type == 'A' :

   149

                ip, = r.data

   150

   151

                if ip not in by_ip :

   152

                    by_ip[ip] = r

   153

   154

                else :

   155

                    # fail!

   156

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

   157

                    fail = True

   158

   159

    if fail :

   160

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

   161

        sys.exit(2)

   162

   163

    yield l, r

   164

   165

def process_zone_serial (zone, serial) :

   166

    """

   167

        Update the serial in the SOA record.

   168

    """

   169

   170

    for line, rr in zone :

   171

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

   172

            # XXX: as SOA record..

   173

            try :

   174

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

   175

            except TypeError as error :

   176

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

   177

                sys.exit(2)

   178

   179

            yield line, pvl.dns.zone.SOA(

   180

                    soa.master, soa.contact,

   181

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

   182

            )

   183

        else :

   184

            yield line, rr

   185

   186

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

   187

    """

   188

        Process zone data -> forward zone data.

   189

    """

   190

   191

    for line, r in zone :

   192

        yield line, r

   193

   194

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

   195

            if txt :

   196

                # comment?

   197

                comment = r.line.comment

   198

   199

                if comment :

   200

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

   201

   202

   203

            # XXX: RP, do we need it?

   204

   205

            if mx :

   206

                # XXX: is this even a good idea?

   207

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

   208

   209

def process_zone_meta (zone, ignore=None) :

   210

    """

   211

        Process zone metadata -> output.

   212

    """

   213

   214

    TIMESTAMP_FORMAT = '%Y/%m/%d'

   215

   216

    for line, r in zone :

   217

        if ignore and r.name in ignore :

   218

            # skip

   219

            log.debug("Ignore record: %s", r)

   220

            continue

   221

   222

        # for hosts..

   223

        if r.type == 'A' :

   224

            # timestamp?

   225

            timestamp = r.line.timestamp

   226

   227

            if timestamp :

   228

                yield line, ZoneRecord.TXT(r.name, timestamp.strftime(TIMESTAMP_FORMAT), ttl=r.ttl)

   229

   230

def process_zone_reverse (zone, origin, domain) :

   231

    """

   232

        Process zone data -> reverse zone data.

   233

    """

   234

   235

    for line, r in zone :

   236

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

   237

            ip, = r.data

   238

            ptr = reverse_ipv4(ip)

   239

   240

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

   241

            ip, = r.data

   242

            ptr = reverse_ipv6(ip)

   243

   244

        else :

   245

            yield line, r

   246

            continue

   247

   248

        # verify

   249

        if zone and ptr.endswith(origin) :

   250

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

   251

   252

        else :

   253

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

   254

            continue

   255

   256

        # domain to use

   257

        host_domain = r.origin or domain

   258

        host_fqdn = fqdn(name, host_domain)

   259

   260

        yield line, ZoneRecord.PTR(ptr, host_fqdn)

   261

   262

def apply_zone_output (options, zone) :

   263

    """

   264

        Write out the resulting zonefile.

   265

    """

   266

   267

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

   268

   269

    for line, r in zone :

   270

        if r :

   271

            file.write(unicode(r))

   272

        else :

   273

            file.write(line.line)

   274

        file.write('\n')

   275

   276

def main (argv) :

   277

    options, args = parse_options(argv)

   278

   279

    # input

   280

    zone = apply_zone_input(options, args)

   281

   282

    if options.check_hosts :

   283

        whitelist = set(options.check_exempt)

   284

   285

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

   286

   287

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

   288

   289

    if options.serial :

   290

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

   291

   292

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

   293

   294

    if options.forward_zone :

   295

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

   296

   297

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

   298

   299

    if options.meta_zone :

   300

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

   301

   302

        if not options.input_line_date :

   303

            log.error("--meta-zone requires --input-line-date")

   304

            return 1

   305

   306

        zone = list(process_zone_meta(zone, ignore=set(options.meta_ignore)))

   307

   308

    if options.reverse_zone :

   309

        if ':' in options.reverse_zone :

   310

            # IPv6

   311

            origin = reverse_ipv6(options.reverse_zone)

   312

   313

        else :

   314

            # IPv4

   315

            origin = reverse_ipv4(options.reverse_zone)

   316

   317

        domain = options.reverse_domain

   318

   319

        if not domain :

   320

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

   321

            return 1

   322

   323

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

   324

   325

    # output

   326

    apply_zone_output(options, zone)

   327

   328

    return 0

   329

   330

if __name__ == '__main__':

   331

    import sys

   332

    sys.exit(main(sys.argv))