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

    13

log = logging.getLogger()

    14

    15

# command-line options, global state

    16

options = None

    17

    18

def parse_options (argv) :

    19

    """

    20

        Parse command-line arguments.

    21

    """

    22

    23

    parser = optparse.OptionParser(

    24

            prog        = argv[0],

    25

            usage       = '%prog: [options]',

    26

            version     = __version__,

    27

    28

            # module docstring

    29

            description = __doc__,

    30

    )

    31

    32

    # logging

    33

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

    34

    36

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

    37

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

    38

    39

    parser.add_option_group(general)

    40

    41

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

    42

            help="Encoding used for input files")

    43

    44

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

    45

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

    46

    47

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

    48

            help="Encoding used for output files")

    49

    50

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

    51

            help="Generate forward zone")

    52

    53

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

    54

            help="Generate TXT records for forward zone")

    55

    56

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

    57

            help="Generate MX records for forward zone")

    58

    59

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

    60

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

    61

    62

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

    63

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

    64

    65

    # defaults

    66

    parser.set_defaults(

    68

    )

    69

    70

    # parse

    71

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

    72

    73

    # configure

    74

    logging.basicConfig(

    75

        format  = '%(processName)s: %(name)s: %(levelname)s %(funcName)s : %(message)s',

    76

        level   = options.loglevel,

    77

    )

    78

    79

    return options, args

    80

    81

def parse_record (line) :

    82

    """

    83

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

    84

    85

        Returns None for empty/comment lines.

    86

    """

    87

    88

    # was line indented?

    89

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

    90

    91

    # strip

    92

    line = line.strip()

    93

    94

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

    95

        # skip

    96

        return

    97

    98

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

    99

   100

    # parse comment out

   101

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

   102

   103

    if ';' in line :

   104

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

   105

   106

        line = data.rstrip()

   107

        comment = comment.strip()

   108

   109

    else :

   110

        line = line.rstrip()

   111

        comment = None

   112

   113

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

   114

   115

    # parse data out?

   116

    if '"' in line :

   117

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

   118

        parts = line.split()

   119

   120

    else :

   121

        parts = line.split()

   122

        data = parts.pop(-1)

   123

   124

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

   125

   126

    # indented lines don't have name

   127

    if indent :

   128

        name = None

   129

   130

    else :

   131

        name = parts.pop(0)

   132

   133

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

   134

   135

    # parse ttl/cls/type

   136

    ttl = cls = None

   137

   138

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

   139

        ttl = parts.pop(0)

   140

   142

        cls = parts.pop(0)

   143

   146

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

   147

   148

    if parts :

   154

   155

    return name, ttl, type, data, comment

   156

   157

def parse_zone (file) :

   158

    """

   159

        Parse

   160

            (name, ttl, type, data, comment) 

   161

        data from zonefile.

   162

    """

   163

   164

    for lineno, line in enumerate(file) :

   165

        data = parse_record(line)

   166

   167

        if data :

   168

            yield data

   169

   170

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

   171

    """

   172

        Process zone data -> forward zone data.

   173

    """

   174

   175

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

   176

        yield name, ttl, type, data

   177

   178

        if type == 'A' :

   179

            if txt and comment :

   180

                # name

   181

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

   182

   183

            # XXX: RP, do we need it?

   184

   185

            if mx :

   186

                # XXX: is this a good idea?

   187

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

   188

   189

def reverse_addr (ip) :

   190

    """

   191

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

   192

    """

   193

   194

    # parse

   195

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

   196

   197

    for octet in octets :

   198

        assert 0 <= octet <= 255

   199

   200

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

   201

   202

def fqdn (*parts) :

   203

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

   204

   205

   206

def process_zone_reverse (zone, origin, domain) :

   207

    """

   208

        Process zone data -> reverse zone data.

   209

    """

   210

   211

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

   212

        if type != 'A' :

   213

            continue

   214

   215

        ip = data

   216

   217

        # generate reverse-addr

   218

        reverse = reverse_addr(ip)

   219

   220

        # verify

   221

        if zone and reverse.endswith(origin) :

   222

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

   223

   224

        else :

   226

            continue

   227

   228

        # domain to use

   229

        host_domain = domain

   230

        host_fqdn = fqdn(name, domain)

   231

   232

        yield reverse, 'PTR', host_fqdn

   233

   234

def build_zone (zone) :

   235

    for item in zone :

   236

        ttl = cls = comment = None

   237

   238

        if len(item) == 3 :

   239

            name, type, data = item

   240

   241

        elif len(item) == 4 :

   242

            name, ttl, type, data = item

   243

   244

        elif len(item) == 5 :

   245

            name, ttl, type, data, comment = item

   246

   247

        else :

   248

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

   249

   250

        if not name :

   251

            name = ''

   252

   253

        if not ttl :

   254

            ttl = ''

   255

   256

        if not cls :

   257

            cls = ''

   258

   259

        if comment :

   260

            comment = '\t;' + comment

   261

        else :

   262

            comment = ''

   263

   264

        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)

   265

   266

def write_zone (file, zone) :

   267

    for line in build_zone(zone) :

   269

   270

def open_file (path, mode, charset) :

   271

    """

   272

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

   273

    """

   274

   275

    if path == '-' :

   276

        # use stdin/out based on mode

   277

        stream, func = {

   278

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

   279

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

   280

        }[mode[0]]

   281

   282

        # wrap

   283

        return func(charset)(stream)

   284

   285

    else :

   286

        # open

   287

        return codecs.open(path, mode, charset)

   288

   289

def main (argv) :

   290

    global options

   291

   292

    options, args = parse_options(argv)

   293

   294

    if args :

   295

        # open files

   296

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

   297

   298

    else :

   299

        # default to stdout

   300

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

   301

   302

    # process zone data

   303

    zone = []

   304

   305

    for file in input_files :

   306

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

   307

   308

        zone += list(parse_zone(file))

   309

   310

    # output file

   311

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

   312

   313

    if options.forward_zone :

   314

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

   315

   316

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

   317

   318

    elif options.reverse_zone :

   319

        origin = reverse_addr(options.reverse_zone)

   320

        domain = options.reverse_domain

   321

   322

        if not domain :

   323

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

   324

            return 1

   325

   326

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

   327

   328

    else :

   329

        log.warn("Nothing to do")

   330

   331

    write_zone(output, zone)

   332

   333

    return 0

   334

   335

if __name__ == '__main__':

   336

    import sys

   337

   338

    sys.exit(main(sys.argv))