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 pvl.args

    10

import pvl.dns.zone

    11

from pvl.dns import __version__

    12

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

    13

    14

import optparse

    15

import os.path

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

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

    86

            help="Rewrite includes to given absolute path")

    87

    88

    # defaults

    89

    parser.set_defaults(

    90

        # XXX: combine

    91

        check_exempt        = [],

    92

        meta_ignore         = [],

    93

    )

    94

    95

    # parse

    96

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

    97

    98

    # apply

    99

    pvl.args.apply(options, prog)

   100

   101

    return options, args

   102

   103

def apply_zone_input (options, args) :

   104

    """

   105

        Yield ZoneLine, ZoneRecord pairs from files.

   106

    """

   107

   108

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

   109

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

   110

   111

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

   112

                line_timestamp_prefix   = options.input_line_date,

   113

        ) :

   114

            yield line, record

   115

   116

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

   117

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

   118

    """

   119

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

   120

   121

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

   122

    """

   123

   124

    by_name = {}

   125

    by_ip = {}

   126

   127

    fail = None

   128

   129

    last_name = None

   130

   131

    for l, r in zone :

   132

        if r :

   133

            name = r.name or last_name

   134

   135

            name = (r.origin, name)

   136

   137

            # name

   138

            if r.type not in whitelist_types :

   139

                if name not in by_name :

   140

                    by_name[name] = r

   141

   142

                elif r.name in whitelist :

   143

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

   144

   145

                else :

   146

                    # fail!

   147

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

   148

                    fail = True

   149

   150

            # ip

   151

            if r.type == 'A' :

   152

                ip, = r.data

   153

   154

                if ip not in by_ip :

   155

                    by_ip[ip] = r

   156

   157

                else :

   158

                    # fail!

   159

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

   160

                    fail = True

   161

   162

    if fail :

   163

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

   164

        sys.exit(2)

   165

   166

    yield l, r

   167

   168

def process_zone_serial (zone, serial) :

   169

    """

   170

        Update the serial in the SOA record.

   171

    """

   172

   173

    for line, rr in zone :

   174

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

   175

            # XXX: as SOA record..

   176

            try :

   177

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

   178

            except TypeError as error :

   179

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

   180

                sys.exit(2)

   181

   182

            yield line, pvl.dns.zone.SOA(

   183

                    soa.master, soa.contact,

   184

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

   185

            )

   186

        else :

   187

            yield line, rr

   188

   189

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

   190

    """

   191

        Process zone data -> forward zone data.

   192

    """

   193

   194

    for line, r in zone :

   195

        yield line, r

   196

   197

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

   198

            if txt :

   199

                # comment?

   200

                comment = r.line.comment

   201

   202

                if comment :

   203

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

   204

   205

   206

            # XXX: RP, do we need it?

   207

   208

            if mx :

   209

                # XXX: is this even a good idea?

   210

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

   211

   212

def process_zone_meta (zone, ignore=None) :

   213

    """

   214

        Process zone metadata -> output.

   215

    """

   216

   217

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

   218

   219

    for line, r in zone :

   220

        if ignore and r.name in ignore :

   221

            # skip

   222

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

   223

            continue

   224

   225

        # for hosts..

   226

        if r.type == 'A' :

   227

            # timestamp?

   228

            timestamp = r.line.timestamp

   229

   230

            if timestamp :

   231

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

   232

   233

def process_zone_reverse (zone, origin, domain) :

   234

    """

   235

        Process zone data -> reverse zone data.

   236

    """

   237

   238

    for line, r in zone :

   239

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

   240

            ip, = r.data

   241

            ptr = reverse_ipv4(ip)

   242

   243

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

   244

            ip, = r.data

   245

            ptr = reverse_ipv6(ip)

   246

   247

        else :

   248

            yield line, r

   249

            continue

   250

   251

        # verify

   252

        if zone and ptr.endswith(origin) :

   253

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

   254

   255

        else :

   256

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

   257

            continue

   258

   259

        # domain to use

   260

        host_domain = r.origin or domain

   261

        host_fqdn = fqdn(name, host_domain)

   262

   263

        yield line, ZoneRecord.PTR(ptr, host_fqdn)

   264

   265

def process_zone_includes (options, zone, path) :

   266

    """

   267

        Rewrite include paths in zones.

   268

    """

   269

   270

    for line, rr in zone :

   271

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

   272

            _, include = line.parts

   273

   274

            yield pvl.dns.zone.ZoneLine(

   275

                    line.file,

   276

                    line.lineno, 

   277

                    line.line,

   278

                    line.indent,

   279

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

   280

            ), rr

   281

        else :

   282

            yield line, rr

   283

   284

   285

def apply_zone_output (options, zone) :

   286

    """

   287

        Write out the resulting zonefile.

   288

    """

   289

   290

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

   291

   292

    for line, r in zone :

   293

        if r :

   294

            file.write(unicode(r))

   295

        else :

   296

            file.write(unicode(line))

   297

        file.write('\n')

   298

   299

def main (argv) :

   300

    options, args = parse_options(argv)

   301

   302

    # input

   303

    zone = apply_zone_input(options, args)

   304

   305

    if options.check_hosts :

   306

        whitelist = set(options.check_exempt)

   307

   308

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

   309

   310

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

   311

   312

    if options.serial :

   313

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

   314

   315

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

   316

   317

    if options.forward_zone :

   318

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

   319

   320

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

   321

   322

    if options.meta_zone :

   323

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

   324

   325

        if not options.input_line_date :

   326

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

   327

            return 1

   328

   329

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

   330

   331

    if options.reverse_zone :

   332

        if ':' in options.reverse_zone :

   333

            # IPv6

   334

            origin = reverse_ipv6(options.reverse_zone)

   335

   336

        else :

   337

            # IPv4

   338

            origin = reverse_ipv4(options.reverse_zone)

   339

   340

        domain = options.reverse_domain

   341

   342

        if not domain :

   343

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

   344

            return 1

   345

   346

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

   347

   348

    if options.include_path :

   349

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

   350

   351

    # output

   352

    apply_zone_output(options, zone)

   353

   354

    return 0

   355

   356

if __name__ == '__main__':

   357

    import sys

   358

    sys.exit(main(sys.argv))