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

from datetime import datetime

    12

import logging

    13

    14

log = logging.getLogger('main')

    15

    16

# command-line options, global state

    17

options = None

    18

    19

def parse_options (argv) :

    20

    """

    21

        Parse command-line arguments.

    22

    """

    23

    24

    prog = argv[0]

    25

    26

    parser = optparse.OptionParser(

    27

            prog        = prog,

    28

            usage       = '%prog: [options]',

    29

            version     = __version__,

    30

    31

            # module docstring

    32

            description = __doc__,

    33

    )

    34

    35

    # logging

    36

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

    37

    38

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

    39

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

    40

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

    41

    42

    parser.add_option_group(general)

    43

    44

    # input/output

    45

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

    46

            help="Encoding used for input files")

    47

    48

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

    49

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

    50

    51

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

    52

            help="Encoding used for output files")

    53

    54

    # check stage

    55

    parser.add_option('--check-hosts',          action='store_true',

    56

            help="Check that host/IPs are unique. Use --quiet to silence warnings, and test exit status")

    57

    59

            help="Allow given names to have multiple records")

    60

    71

    # forward stage

    72

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

    73

            help="Generate forward zone")

    74

    75

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

    76

            help="Generate TXT records for forward zone")

    77

    78

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

    79

            help="Generate MX records for forward zone")

    80

    81

    # reverse stage

    82

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

    83

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

    84

    85

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

    86

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

    87

    88

    # defaults

    89

    parser.set_defaults(

    90

        loglevel            = logging.WARN,

    91

    93

        check_exempt        = [],

    95

    )

    96

    97

    # parse

    98

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

    99

   100

    # configure

   101

    logging.basicConfig(

   102

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

   103

        level   = options.loglevel,

   104

    )

   105

   106

    return options, args

   107

   108

class ZoneLine (object) :

   109

    """

   110

        A line in a zonefile.

   111

    """

   112

   113

    file = None

   114

    lineno = None

   115

   116

    # data

   117

    indent = None # was the line indented?

   118

    data = None

   119

    parts = None # split line fields

   120

   121

    # optional

   122

    timestamp = None

   123

    comment = None

   124

   125

    PARSE_DATETIME_FORMAT = '%Y-%m-%d'

   126

   127

    @classmethod

   128

    def parse (cls, file, lineno, line, line_timestamp_prefix=False) :

   129

        """

   130

            Parse out given line and build.

   131

        """

   132

   133

        log.debug("parse: %s:%d: %s", file, lineno, line)

   134

   135

        ts = None

   136

   137

        if line_timestamp_prefix :

   138

            if ': ' not in line :

   139

                raise Exception("Missing timestamp prefix on line: %s:%d: %s" % (file, lineno, line))

   140

   141

            # split prefix

   142

            prefix, line = line.split(': ', 1)

   143

   144

            # parse it out

   145

            ts = datetime.strptime(prefix, cls.PARSE_DATETIME_FORMAT)

   146

   147

            log.debug("  ts=%r", ts)

   148

   149

        # was line indented?

   150

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

   151

   152

        # strip

   153

        line = line.strip()

   154

   155

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

   156

   157

        # parse comment out?

   158

        if ';' in line :

   159

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

   160

   161

            line = line.strip()

   162

            comment = comment.strip()

   163

   164

        else :

   165

            line = line.strip()

   166

            comment = None

   167

   168

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

   169

   170

        # parse fields

   171

        if '"' in line :

   172

            pre, data, post = line.split('"', 2)

   173

            parts = pre.split() + [data] + post.split()

   174

   175

        else :

   176

            parts = line.split()

   177

   178

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

   179

   180

        # build

   181

        return cls(file, lineno, indent, line, parts, timestamp=ts, comment=comment)

   182

   183

    def __init__ (self, file, lineno, indent, data, parts, timestamp=None, comment=None) :

   184

        self.file = file

   185

        self.lineno = lineno

   186

   187

        self.indent = indent

   188

        self.data = data

   189

        self.parts = parts

   190

   191

        self.timestamp = timestamp

   192

        self.comment = comment

   193

   194

    def __str__ (self) :

   195

        return "{file}:{lineno}".format(file=self.file, lineno=self.lineno)

   196

   197

class ZoneRecord (object) :

   198

    """

   199

        A record from a zonefile.

   200

    """

   201

   202

    # the underlying line

   203

    line = None

   204

   205

    # record fields

   206

    name = None

   207

    type = None

   208

   209

    # list of data fields

   210

    data = None

   211

   212

    # optional

   213

    ttl = None

   214

    cls = None

   215

   216

    @classmethod

   217

    def parse (cls, line) :

   218

        """

   219

            Parse from ZoneLine. Returns None if there is no record on the line..

   220

        """

   221

   222

        if not line.parts :

   223

            # skip

   224

            return

   225

   226

        # consume parts

   227

        parts = list(line.parts)

   228

   229

        # indented lines don't have name

   230

        if line.indent :

   231

            name = None

   232

   233

        else :

   234

            name = parts.pop(0)

   235

   236

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

   237

   238

        # parse ttl/cls/type

   239

        ttl = _cls = None

   240

   241

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

   242

            ttl = parts.pop(0)

   243

   244

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

   245

            _cls = parts.pop(0)

   246

   247

        # always have type

   248

        type = parts.pop(0)

   249

   250

        # remaining parts are data

   251

        data = parts

   252

   253

        log.debug("  ttl=%r, cls=%r, type=%r, data=%r", ttl, _cls, type, data)

   254

   255

        return cls(name, type, data,

   256

            ttl     = ttl,

   257

            cls     = _cls,

   258

            line    = line,

   259

        )

   260

   261

    def __init__ (self, name, type, data, ttl=None, cls=None, line=None, comment=None) :

   262

        self.name = name

   263

        self.type = type

   264

        self.data = data

   265

   266

        self.ttl = ttl

   267

        self.cls = cls

   268

   269

        self.line = line

   270

   271

        # XXX: within line

   272

        self._comment = comment

   273

   274

    def build_line (self) :

   275

        """

   276

            Construct a zonefile-format line..."

   277

        """

   278

   279

        # XXX: comment?

   280

        if self._comment :

   281

            comment = '\t; ' + self._comment

   282

        else :

   283

            comment = ''

   284

   285

        return u"{name:25} {ttl:4} {cls:2} {type:5} {data}{comment}".format(

   286

                name    = self.name or '',

   287

                ttl     = self.ttl or '',

   288

                cls     = self.cls or '',

   289

                type    = self.type,

   290

                data    = ' '.join(unicode(data) for data in self.data),

   291

                comment = comment,

   292

        )

   293

   294

    def __str__ (self) :

   295

        return ' '.join((self.name, self.type, ' '.join(self.data)))

   296

   297

class TXTRecord (ZoneRecord) :

   298

    """

   299

        TXT record.

   300

    """

   301

   302

    def __init__ (self, name, text, **opts) :

   303

        return super(TXTRecord, self).__init__(name, 'TXT', 

   304

            [u'"{0}"'.format(text.replace('"', '\\"'))], 

   305

            **opts

   306

        )

   307

   308

def parse_record (path, lineno, line, **opts) :

   309

    """

   310

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

   311

   312

        Returns None for empty/comment lines.

   313

    """

   314

   315

    # line

   316

    line = ZoneLine.parse(path, lineno, line, **opts)

   317

    record = ZoneRecord.parse(line)

   318

   319

    if record :

   320

        return record

   321

   322

def parse_zone_records (file, **opts) :

   323

    """

   324

        Parse ZoneRecord items from the given zonefile, ignoring non-record lines.

   325

    """

   326

   327

    for lineno, line in enumerate(file) :

   328

        record = parse_record(file.name, lineno, line, **opts)

   329

   330

        if record :

   331

            yield record

   332

   333

def check_zone_hosts (zone, whitelist=None) :

   334

    """

   335

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

   336

   337

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

   338

    """

   339

   340

    by_name = {}

   341

    by_ip = {}

   342

   343

    fail = None

   344

   345

    for r in zone :

   346

        name = r.name

   347

   348

        # name

   349

        if name not in by_name :

   350

            by_name[name] = r

   351

   352

        elif r.name in whitelist :

   353

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

   354

   355

        else :

   356

            # fail!

   357

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

   358

            fail = True

   359

   360

        # ip

   361

        if r.type == 'A' :

   362

            ip, = r.data

   363

   364

            if ip not in by_ip :

   365

                by_ip[ip] = r

   366

   367

            else :

   368

                # fail!

   369

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

   370

                fail = True

   371

   372

    return fail

   373

   374

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

   375

    """

   376

        Process zone data -> forward zone data.

   377

    """

   378

   379

    for r in zone :

   380

        yield r

   381

   382

        if r.type == 'A' :

   383

            if txt :

   384

                # comment?

   385

                comment = r.line.comment

   386

   387

                if comment :

   388

                    yield TXTRecord(None, comment, ttl=r.ttl)

   389

   391

            # XXX: RP, do we need it?

   392

   393

            if mx :

   394

                # XXX: is this a good idea?

   395

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

   396

   418

def reverse_addr (ip) :

   419

    """

   420

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

   421

    """

   422

   423

    # parse

   424

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

   425

   426

    for octet in octets :

   427

        assert 0 <= octet <= 255

   428

   429

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

   430

   431

def fqdn (*parts) :

   432

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

   433

   434

   435

def process_zone_reverse (zone, origin, domain) :

   436

    """

   437

        Process zone data -> reverse zone data.

   438

    """

   439

   440

    for r in zone :

   441

        if r.type != 'A' :

   442

            continue

   443

   444

        ip, = r.data

   445

   446

        # generate reverse-addr

   447

        reverse = reverse_addr(ip)

   448

   449

        # verify

   450

        if zone and reverse.endswith(origin) :

   451

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

   452

   453

        else :

   454

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

   455

            continue

   456

   457

        # domain to use

   458

        host_domain = domain

   459

        host_fqdn = fqdn(r.name, domain)

   460

   461

        yield ZoneRecord(reverse, 'PTR', [host_fqdn])

   462

   463

def write_zone_records (file, zone) :

   464

    for r in zone :

   465

        file.write(r.build_line() + u'\n')

   466

   467

def open_file (path, mode, charset) :

   468

    """

   469

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

   470

    """

   471

   472

    if path == '-' :

   473

        # use stdin/out based on mode

   474

        stream, func = {

   475

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

   476

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

   477

        }[mode[0]]

   478

   479

        # wrap

   480

        return func(charset)(stream)

   481

   482

    else :

   483

        # open

   484

        return codecs.open(path, mode, charset)

   485

   486

def main (argv) :

   487

    global options

   488

   489

    options, args = parse_options(argv)

   490

   491

    if args :

   492

        # open files

   493

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

   494

   495

    else :

   496

        # default to stdout

   497

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

   498

   499

    # process zone data

   500

    zone = []

   501

   502

    for file in input_files :