1

#!/usr/bin/env python

     2

     3

"""

     4

    Process zonefiles.

     5

"""

     6

     7

__version__ = '0.0.1-dev'

     8

     9

import optparse

    10

import codecs

    11

import logging

    12

    14

    15

# command-line options, global state

    16

options = None

    17

    18

def parse_options (argv) :

    19

    """

    20

        Parse command-line arguments.

    21

    """

    22

    25

    parser = optparse.OptionParser(

    27

            usage       = '%prog: [options]',

    28

            version     = __version__,

    29

    30

            # module docstring

    31

            description = __doc__,

    32

    )

    33

    34

    # logging

    35

    general = optparse.OptionGroup(parser, "General Options")

    36

    37

    general.add_option('-q', '--quiet',     dest='loglevel', action='store_const', const=logging.ERROR, help="Less output")

    38

    general.add_option('-v', '--verbose',   dest='loglevel', action='store_const', const=logging.INFO,  help="More output")

    39

    general.add_option('-D', '--debug',     dest='loglevel', action='store_const', const=logging.DEBUG, help="Even more output")

    40

    41

    parser.add_option_group(general)

    42

    44

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

    45

            help="Encoding used for input files")

    46

    47

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

    48

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

    49

    50

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

    51

            help="Encoding used for output files")

    52

    61

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

    62

            help="Generate forward zone")

    63

    64

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

    65

            help="Generate TXT records for forward zone")

    66

    67

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

    68

            help="Generate MX records for forward zone")

    69

    71

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

    72

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

    73

    74

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

    75

            help="Generate forward zone for given subnet (x.z.y)")

    76

    77

    # defaults

    78

    parser.set_defaults(

    79

        loglevel            = logging.WARN,

    82

    )

    83

    84

    # parse

    85

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

    86

    87

    # configure

    88

    logging.basicConfig(

    90

        level   = options.loglevel,

    91

    )

    92

    93

    return options, args

    94

    95

def parse_record (line) :

    96

    """

    97

        Parse (name, ttl, type, data, comment) from bind zonefile.

    98

    99

        Returns None for empty/comment lines.

   100

    """

   101

   102

    # was line indented?

   103

    indent = line.startswith(' ') or line.startswith('\t')

   104

   105

    # strip

   106

    line = line.strip()

   107

   108

    if not line or line.startswith(';') :

   109

        # skip

   110

        return

   111

   112

    #log.debug("line=%r", line)

   113

   114

    # parse comment out

   115

    parts = line.split(';', 1)

   116

   117

    if ';' in line :

   118

        data, comment = line.split(';', 1)

   119

   120

        line = data.rstrip()

   121

        comment = comment.strip()

   122

   123

    else :

   124

        line = line.rstrip()

   125

        comment = None

   126

   127

    #log.debug("line=%r, comment=%r", line, comment)

   128

   129

    # parse data out?

   130

    if '"' in line :

   131

        line, data, end = line.split('"')

   132

        parts = line.split()

   133

   134

    else :

   135

        parts = line.split()

   136

        data = parts.pop(-1)

   137

   138

    #log.debug("parts=%r, data=%r", parts, data)

   139

   140

    # indented lines don't have name

   141

    if indent :

   142

        name = None

   143

   144

    else :

   145

        name = parts.pop(0)

   146

   147

    #log.debug("name=%r", name)

   148

   149

    # parse ttl/cls/type

   150

    ttl = cls = None

   151

   152

    if parts and parts[0][0].isdigit() :

   153

        ttl = parts.pop(0)

   154

   155

    if parts and parts[0].upper() in ('IN', 'CH') :

   156

        cls = parts.pop(0)

   157

   158

    type = parts.pop(0)

   159

   160

    #log.debug("ttl=%r, cls=%r, parts=%r", ttl, cls, parts)

   161

   162

    if parts :

   163

        log.debug("extra data: %r + %r", parts, data)

   164

   165

        # extra data

   166

        data = ' '.join(parts + [data])

   167

   168

   169

    return name, ttl, type, data, comment

   170

   171

def parse_zone (file) :

   172

    """

   173

        Parse

   174

            (name, ttl, type, data, comment) 

   175

        data from zonefile.

   176

    """

   177

   178

    for lineno, line in enumerate(file) :

   179

        data = parse_record(line)

   180

   181

        if data :

   182

            yield data

   183

   226

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

   227

    """

   228

        Process zone data -> forward zone data.

   229

    """

   230

   231

    for name, ttl, type, data, comment in zone :

   232

        yield name, ttl, type, data

   233

   234

        if type == 'A' :

   235

            if txt and comment :

   236

                # name

   237

                yield None, ttl, 'TXT', u'"{0}"'.format(comment)

   238

   239

            # XXX: RP, do we need it?

   240

   241

            if mx :

   242

                # XXX: is this a good idea?

   243

                yield None, ttl, 'MX', '10 {mx}'.format(mx=mx)

   244

   245

def reverse_addr (ip) :

   246

    """

   247

        Return in-addr.arpa reverse for given IPv4 IP.

   248

    """

   249

   250

    # parse

   251

    octets = tuple(int(part) for part in ip.split('.'))

   252

   253

    for octet in octets :

   254

        assert 0 <= octet <= 255

   255

   256

    return '.'.join([str(octet) for octet in reversed(octets)] + ['in-addr', 'arpa'])

   257

   258

def fqdn (*parts) :

   259

    return '.'.join(parts) + '.'

   260

   261

   262

def process_zone_reverse (zone, origin, domain) :

   263

    """

   264

        Process zone data -> reverse zone data.

   265

    """

   266

   267

    for name, ttl, type, data, comment in zone :

   268

        if type != 'A' :

   269

            continue

   270

   271

        ip = data

   272

   273

        # generate reverse-addr

   274

        reverse = reverse_addr(ip)

   275

   276

        # verify

   277

        if zone and reverse.endswith(origin) :

   278

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

   279

   280

        else :

   281

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

   282

            continue

   283

   284

        # domain to use

   285

        host_domain = domain

   286

        host_fqdn = fqdn(name, domain)

   287

   288

        yield reverse, 'PTR', host_fqdn

   289

   290

def build_zone (zone) :

   291

    for item in zone :

   292

        ttl = cls = comment = None

   293

   294

        if len(item) == 3 :

   295

            name, type, data = item

   296

   297

        elif len(item) == 4 :

   298

            name, ttl, type, data = item

   299

   300

        elif len(item) == 5 :

   301

            name, ttl, type, data, comment = item

   302

   303

        else :

   304

            raise Exception("Weird zone entry: {0}".format(item))

   305

   306

        if not name :

   307

            name = ''

   308

   309

        if not ttl :

   310

            ttl = ''

   311

   312

        if not cls :

   313

            cls = ''

   314

   315

        if comment :

   316

            comment = '\t;' + comment

   317

        else :

   318

            comment = ''

   319

   320

        yield u"{name:25} {ttl:4} {cls:2} {type:5} {data}{comment}".format(name=name, ttl=ttl, cls=cls, type=type, data=data, comment=comment)

   321

   322

def write_zone (file, zone) :

   323

    for line in build_zone(zone) :

   324

        file.write(line + u'\n')

   325

   326

def open_file (path, mode, charset) :

   327

    """

   328

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

   329

    """

   330

   331

    if path == '-' :

   332

        # use stdin/out based on mode

   333

        stream, func = {

   334

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

   335

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

   336

        }[mode[0]]

   337

   338

        # wrap

   339

        return func(charset)(stream)

   340

   341

    else :

   342

        # open

   343

        return codecs.open(path, mode, charset)

   344

   345

def main (argv) :

   346

    global options

   347

   348

    options, args = parse_options(argv)

   349

   350

    if args :

   351

        # open files

   352

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

   353

   354

    else :

   355

        # default to stdout

   356

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

   357

   358

    # process zone data

   359

    zone = []

   360

   361

    for file in input_files :

   362

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

   363

   364

        zone += list(parse_zone(file))

   365

   379

    # output file

   380

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

   381

   382

    if options.forward_zone :

   383

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

   384

   385

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

   386

   387

    elif options.reverse_zone :

   388

        origin = reverse_addr(options.reverse_zone)

   389

        domain = options.reverse_domain

   390

   391

        if not domain :

   392

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

   393

            return 1

   394

   395

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

   396

   401

    else :

   402

        log.warn("Nothing to do")

   404

   405

    write_zone(output, zone)

   406

   407

    return 0

   408

   409

if __name__ == '__main__':

   410

    import sys

   411

   412

    sys.exit(main(sys.argv))