1

#!/usr/bin/env python

     2

     3

"""

     4

    Process bind zonefiles.

     5

"""

     6

     7

import codecs

     8

import optparse

     9

    10

import pvl.args

    11

import pvl.dns.zone

    12

from pvl.dns import __version__

    13

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

    14

    15

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

    16

    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='-',

    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

    # defaults

    82

    parser.set_defaults(

    83

        # XXX: combine

    84

        check_exempt        = [],

    85

        meta_ignore         = [],

    86

    )

    87

    88

    # parse

    89

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

    90

    91

    # apply

    92

    pvl.args.apply(options, prog)

    93

    94

    return options, args

    95

    96

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

    97

    """

    98

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

    99

   100

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

   101

    """

   102

   103

    by_name = {}

   104

    by_ip = {}

   105

   106

    fail = None

   107

   108

    last_name = None

   109

   110

    for r in zone :

   111

        name = r.name or last_name

   112

   113

        name = (r.origin, name)

   114

   115

        # name

   116

        if r.type not in whitelist_types :

   117

            if name not in by_name :

   118

                by_name[name] = r

   119

   120

            elif r.name in whitelist :

   121

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

   122

   123

            else :

   124

                # fail!

   125

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

   126

                fail = True

   127

   128

        # ip

   129

        if r.type == 'A' :

   130

            ip, = r.data

   131

   132

            if ip not in by_ip :

   133

                by_ip[ip] = r

   134

   135

            else :

   136

                # fail!

   137

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

   138

                fail = True

   139

   140

    return fail

   141

   142

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

   143

    """

   144

        Process zone data -> forward zone data.

   145

    """

   146

   147

    for r in zone :

   148

        yield r

   149

   150

        if r.type == 'A' :

   151

            if txt :

   152

                # comment?

   153

                comment = r.line.comment

   154

   155

                if comment :

   156

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

   157

   158

   159

            # XXX: RP, do we need it?

   160

   161

            if mx :

   162

                # XXX: is this even a good idea?

   163

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

   164

   165

def process_zone_meta (zone, ignore=None) :

   166

    """

   167

        Process zone metadata -> output.

   168

    """

   169

   170

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

   171

   172

    for r in zone :

   173

        if ignore and r.name in ignore :

   174

            # skip

   175

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

   176

            continue

   177

   178

        # for hosts..

   179

        if r.type == 'A' :

   180

            # timestamp?

   181

            timestamp = r.line.timestamp

   182

   183

            if timestamp :

   184

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

   185

   186

def process_zone_reverse (zone, origin, domain) :

   187

    """

   188

        Process zone data -> reverse zone data.

   189

    """

   190

   191

    name = None

   192

   193

    for r in zone :

   194

        # keep name from previous..

   195

        if r.name :

   196

            name = r.name

   197

   198

        if r.type == 'A' :

   199

            ip, = r.data

   200

            ptr = reverse_ipv4(ip)

   201

   202

        elif r.type == 'AAAA' :

   203

            ip, = r.data

   204

            ptr = reverse_ipv6(ip)

   205

   206

        else :

   207

            continue

   208

   209

        # verify

   210

        if zone and ptr.endswith(origin) :

   211

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

   212

   213

        else :

   214

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

   215

            continue

   216

   217

        # domain to use

   218

        host_domain = r.origin or domain

   219

        host_fqdn = fqdn(name, host_domain)

   220

   221

        yield ZoneRecord.PTR(ptr, host_fqdn)

   222

   223

def write_zone_records (file, zone) :

   224

    for r in zone :

   225

        file.write(unicode(r))

   226

        file.write('\n')

   227

   228

def open_file (path, mode, charset) :

   229

    """

   230

        Open unicode-enabled file from path, with - using stdio.

   231

    """

   232

   233

    if path == '-' :

   234

        # use stdin/out based on mode

   235

        stream, func = {

   236

            'r':    (sys.stdin, codecs.getreader),

   237

            'w':    (sys.stdout, codecs.getwriter),

   238

        }[mode[0]]

   239

   240

        # wrap

   241

        return func(charset)(stream)

   242

   243

    else :

   244

        # open

   245

        return codecs.open(path, mode, charset)

   246

   247

def main (argv) :

   248

    options, args = parse_options(argv)

   249

   250

    if args :

   251

        # open files

   252

        input_files = [open_file(path, 'r', options.input_charset) for path in args]

   253

   254

    else :

   255

        # default to stdout

   256

        input_files = [open_file('-', 'r', options.input_charset)]

   257

   258

    # process zone data

   259

    zone = []

   260

   261

    for file in input_files :

   262

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

   263

   265

            line_timestamp_prefix   = options.input_line_date,

   266

        ))

   267

   268

    # check?

   269

    if options.check_hosts :

   270

        whitelist = set(options.check_exempt)

   271

   272

        log.debug("checking hosts; whitelist=%r", whitelist)

   273

   274

        if check_zone_hosts(zone, whitelist=whitelist) :

   275

            log.warn("Hosts check failed")

   276

            return 2

   277

   278

        else :

   279

            log.info("Hosts check OK")

   280

   281

    # output file

   282

    output = open_file(options.output, 'w', options.output_charset)

   283

   284

    if options.forward_zone :

   285

        log.info("Write forward zone: %s", output)

   286

   287

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

   288

   289

    elif options.meta_zone :

   290

        log.info("Write metadata zone: %s", output)

   291

   292

        if not options.input_line_date :

   293

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

   294

            return 1

   295

   296

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

   297

   298

    elif options.reverse_zone :

   299

        if ':' in options.reverse_zone :

   300

            # IPv6

   301

            origin = reverse_ipv6(options.reverse_zone)

   302

   303

        else :

   304

            # IPv4

   305

            origin = reverse_ipv4(options.reverse_zone)

   306

   307

        domain = options.reverse_domain

   308

   309

        if not domain :

   310

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

   311

            return 1

   312

   313

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

   314

   315

    elif options.check_hosts :

   316

        # we only did that, done

   317

        return 0

   318

   319

    else :

   320

        # pass-through

   321

        log.warn("Nothing to do")

   322

   323

    write_zone_records(output, zone)

   324

   325

    return 0

   326

   327

if __name__ == '__main__':

   328

    import sys

   329

    sys.exit(main(sys.argv))