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

    # read line mtimes?

    55

    parser.add_option('--input-line-date',      action='store_true',

    56

            help="Parse timestamp prefix from each input line (e.g. `hg blame | ...`)")

    57

    58

    # check stage

    59

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

    60

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

    61

    62

    parser.add_option('--check-exempt',         action='append',

    63

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

    64

    65

    # forward stage

    66

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

    67

            help="Generate forward zone")

    68

    69

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

    70

            help="Generate TXT records for forward zone")

    71

    72

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

    73

            help="Generate MX records for forward zone")

    74

    75

    # reverse stage

    76

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

    77

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

    78

    79

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

    80

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

    81

    82

    # defaults

    83

    parser.set_defaults(

    84

        loglevel            = logging.WARN,

    85

    86

        check_exempt        = [],

    87

    )

    88

    89

    # parse

    90

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

    91

    92

    # configure

    93

    logging.basicConfig(

    94

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

    95

        level   = options.loglevel,

    96

    )

    97

    98

    return options, args

    99

   100

class ZoneLine (object) :

   101

    """

   102

        A line in a zonefile.

   103

    """

   104

   105

    file = None

   106

    lineno = None

   107

   108

    # data

   109

    indent = None # was the line indented?

   110

    data = None

   111

    parts = None # split line fields

   112

   113

    # optional

   114

    timestamp = None

   115

    comment = None

   116

   117

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

   118

   119

    @classmethod

   120

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

   121

        """

   122

            Parse out given line and build.

   123

        """

   124

   125

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

   126

   127

        ts = None

   128

   129

        if line_timestamp_prefix :

   130

            if ': ' not in line :

   131

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

   132

   133

            # split prefix

   134

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

   135

   136

            # parse it out

   137

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

   138

   139

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

   140

   141

        # was line indented?

   142

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

   143

   144

        # strip

   145

        line = line.strip()

   146

   147

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

   148

   149

        # parse comment out?

   150

        if ';' in line :

   151

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

   152

   153

            line = line.strip()

   154

            comment = comment.strip()

   155

   156

        else :

   157

            line = line.strip()

   158

            comment = None

   159

   160

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

   161

   162

        # parse fields

   163

        if '"' in line :

   164

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

   165

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

   166

   167

        else :

   168

            parts = line.split()

   169

   170

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

   171

   172

        # build

   173

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

   174

   175

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

   176

        self.file = file

   177

        self.lineno = lineno

   178

   179

        self.indent = indent

   180

        self.data = data

   181

        self.parts = parts

   182

   183

        self.timestamp = timestamp

   184

        self.comment = comment

   185

   186

    def __str__ (self) :

   187

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

   188

   189

class ZoneRecord (object) :

   190

    """

   191

        A record from a zonefile.

   192

    """

   193

   194

    # the underlying line

   195

    line = None

   196

   197

    # record fields

   198

    name = None

   199

    type = None

   200

   201

    # list of data fields

   202

    data = None

   203

   204

    # optional

   205

    ttl = None

   206

    cls = None

   207

   208

    @classmethod

   209

    def parse (cls, line) :

   210

        """

   211

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

   212

        """

   213

   214

        if not line.parts :

   215

            # skip

   216

            return

   217

   218

        # consume parts

   219

        parts = list(line.parts)

   220

   221

        # indented lines don't have name

   222

        if line.indent :

   223

            name = None

   224

   225

        else :

   226

            name = parts.pop(0)

   227

   228

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

   229

   230

        # parse ttl/cls/type

   231

        ttl = _cls = None

   232

   233

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

   234

            ttl = parts.pop(0)

   235

   236

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

   237

            _cls = parts.pop(0)

   238

   239

        # always have type

   240

        type = parts.pop(0)

   241

   242

        # remaining parts are data

   243

        data = parts

   244

   245

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

   246

   247

        return cls(name, type, data,

   248

            ttl     = ttl,

   249

            cls     = _cls,

   250

            line    = line,

   251

        )

   252

   253

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

   254

        self.name = name

   255

        self.type = type

   256

        self.data = data

   257

   258

        self.ttl = ttl

   259

        self.cls = cls

   260

   261

        self.line = line

   262

   263

        # XXX: within line

   264

        self._comment = comment

   265

   266

    def build_line (self) :

   267

        """

   268

            Construct a zonefile-format line..."

   269

        """

   270

   271

        # XXX: comment?

   272

        if self._comment :

   273

            comment = '\t; ' + self._comment

   274

        else :

   275

            comment = ''

   276

   277

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

   278

                name    = self.name or '',

   279

                ttl     = self.ttl or '',

   280

                cls     = self.cls or '',

   281

                type    = self.type,

   282

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

   283

                comment = comment,

   284

        )

   285

   286

    def __str__ (self) :

   287

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

   288

   300

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

   301

    """

   302

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

   303

   304

        Returns None for empty/comment lines.

   305

    """

   306

   307

    # line

   308

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

   309

    record = ZoneRecord.parse(line)

   310

   311

    if record :

   312

        return record

   313

   314

def parse_zone_records (file, **opts) :

   315

    """

   316

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

   317

    """

   318

   319

    for lineno, line in enumerate(file) :

   320

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

   321

   322

        if record :

   323

            yield record

   324

   325

def check_zone_hosts (zone, whitelist=None) :

   326

    """

   327

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

   328

   329

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

   330

    """

   331

   332

    by_name = {}

   333

    by_ip = {}

   334

   335

    fail = None

   336

   337

    for r in zone :

   338

        name = r.name

   339

   340

        # name

   341

        if name not in by_name :

   342

            by_name[name] = r

   343

   344

        elif r.name in whitelist :

   345

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

   346

   347

        else :

   348

            # fail!

   349

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

   350

            fail = True

   351

   352

        # ip

   353

        if r.type == 'A' :

   354

            ip, = r.data

   355

   356

            if ip not in by_ip :

   357

                by_ip[ip] = r

   358

   359

            else :

   360

                # fail!

   361

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

   362

                fail = True

   363

   364

    return fail

   365

   366

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

   367

    """

   368

        Process zone data -> forward zone data.

   369

    """

   370

   373

    for r in zone :

   374

        yield r

   375

   376

        if r.type == 'A' :

   389

   390

            # XXX: RP, do we need it?

   391

   392

            if mx :

   393

                # XXX: is this a good idea?

   394

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

   395

   396

def reverse_addr (ip) :

   397

    """

   398

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

   399

    """

   400

   401

    # parse

   402

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

   403

   404

    for octet in octets :

   405

        assert 0 <= octet <= 255

   406

   407

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

   408

   409

def fqdn (*parts) :

   410

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

   411

   412

   413

def process_zone_reverse (zone, origin, domain) :

   414

    """

   415

        Process zone data -> reverse zone data.

   416

    """

   417

   418

    for r in zone :

   419

        if r.type != 'A' :

   420

            continue

   421

   422

        ip, = r.data

   423

   424

        # generate reverse-addr

   425

        reverse = reverse_addr(ip)

   426

   427

        # verify

   428

        if zone and reverse.endswith(origin) :

   429

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

   430

   431

        else :

   432

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

   433

            continue

   434

   435

        # domain to use

   436

        host_domain = domain

   437

        host_fqdn = fqdn(r.name, domain)

   438

   439

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

   440

   441

def write_zone_records (file, zone) :

   442

    for r in zone :

   443

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

   444

   445

def open_file (path, mode, charset) :

   446

    """

   447

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

   448

    """

   449

   450

    if path == '-' :

   451

        # use stdin/out based on mode

   452

        stream, func = {

   453

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

   454

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

   455

        }[mode[0]]

   456

   457

        # wrap

   458

        return func(charset)(stream)

   459

   460

    else :

   461

        # open

   462

        return codecs.open(path, mode, charset)

   463

   464

def main (argv) :

   465

    global options

   466

   467

    options, args = parse_options(argv)

   468

   469

    if args :

   470

        # open files

   471

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

   472

   473

    else :

   474

        # default to stdout

   475

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

   476

   477

    # process zone data

   478

    zone = []

   479

   480

    for file in input_files :

   481

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

   482

   483

        zone += list(parse_zone_records(file, 

   484

            line_timestamp_prefix   = options.input_line_date,

   485

        ))

   486

   487

    # check?

   488

    if options.check_hosts :

   489

        whitelist = set(options.check_exempt)

   490

   491

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

   492

   493

        if check_zone_hosts(zone, whitelist=whitelist) :

   494

            log.warn("Hosts check failed")

   495

            return 2

   496

   497

        else :

   498

            log.info("Hosts check OK")

   499

   500

    # output file

   501

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

   502

   503

    if options.forward_zone :