1

#!/usr/bin/env python

     2

     3

"""

     4

    Process zonefiles.

     5

"""

     6

     7

import codecs

     8

import datetime

     9

import logging

    10

import os.path

    11

    12

log = logging.getLogger('pvl.dns.zone')

    13

    14

class ZoneError (Exception) :

    15

    pass

    16

    17

class ZoneLineError (ZoneError) :

    18

    """

    19

        ZoneLine-related error

    20

    """

    21

    22

    def __init__ (self, line, msg, *args, **kwargs) :

    23

        super(ZoneLineError, self).__init__("%s: %s" % (line, msg.format(*args, **kwargs)))

    24

    25

class ZoneLine (object) :

    26

    """

    27

        A line parsed from a zonefile.

    28

    """

    29

    30

    @classmethod

    31

    def load (cls, file, filename=None, line_timestamp_prefix=None) :

    32

        """

    33

            Yield ZoneLines lexed from a file.

    34

        """

    35

    36

        if not filename :

    37

            filename = file.name

    38

    39

        multiline_start = None

    40

        multiline_parts = None

    41

    42

        for lineno, raw_line in enumerate(file) :

    43

            # possible mtime prefix for line

    44

            timestamp = None

    45

    46

            if line_timestamp_prefix :

    47

                if ': ' not in raw_line :

    48

                    raise ZoneError("%s:%d: Missing timestamp prefix: %s" % (filename, lineno, raw_line))

    49

    50

                # split prefix

    51

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

    52

    53

                # parse it out

    54

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

    55

    56

                log.debug("%s:%d: ts=%r", filename, lineno, ts)

    57

    58

            log.debug("%s:%d: %s", filename, lineno, raw_line)

    59

    60

            # capture indent from raw line

    61

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

    62

            line = raw_line.strip()

    63

    64

            # parse comment

    65

            if ';' in line:

    66

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

    67

    68

                line = line.strip()

    69

                comment = comment.strip()

    70

            else :

    71

                comment = None

    72

    73

            log.debug("%s:%d: indent=%r, line=%r, comment=%r", filename, lineno, indent, line, comment)

    74

    75

            # split (quoted) fields

    76

            if '"' in line :

    77

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

    78

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

    79

    80

            else :

    81

                parts = line.split()

    82

    83

            # handle multi-line statements...

    84

            if '(' in parts :

    85

                assert not multiline_start

    86

    87

                log.warn("%s:%d: Start of multi-line statement: %s", filename, lineno, line)

    88

    89

                multiline_start = (lineno, timestamp, indent, comment)

    90

                multiline_line = raw_line

    91

                multiline_parts = []

    92

    93

            if multiline_start:

    94

                log.warn("%s:%d: Multi-line statement: %s", filename, lineno, line)

    95

    96

                # XXX: some better way to do this

    97

                multiline_parts.extend([part for part in parts if part not in set('()')])

    98

                multiline_line += raw_line

    99

   100

            if ')' in parts :

   101

                assert multiline_start

   102

   103

                log.warn("%s:%d: End of multi-line statement: %s", filename, lineno, line)

   104

   105

                lineno, timestamp, indent, comment = multiline_start

   106

                raw_line = multiline_line

   107

                parts = multiline_parts

   108

   109

                multiline_start = multiline_line = multiline_parts = None

   110

   111

            # parse

   112

            if multiline_start:

   113

                pass

   114

            else:

   115

                yield ZoneLine(filename, lineno, raw_line, indent, parts, comment, timestamp=timestamp)

   116

   117

    file = None

   118

    lineno = None

   119

   120

    # data

   121

    indent = None # was the line indented?

   122

    parts = None # split line fields

   123

   124

    # optional

   125

    timestamp = None

   126

    comment = None

   127

   128

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

   129

   130

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

   131

        # source

   132

        self.file = file

   133

        self.lineno = lineno

   134

        self.line = line

   135

   136

        # parse data

   137

        self.indent = indent

   138

        self.parts = parts

   139

   140

        # metadata

   141

        self.timestamp = timestamp

   142

        self.comment = comment

   143

   144

    def __str__ (self) :

   145

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

   146

   147

class ZoneRecord (object) :

   148

    """

   149

        A record from a zonefile.

   150

    """

   151

   152

    # context

   153

    line = None # the underlying line

   154

    origin = None # possible $ORIGIN context

   155

   156

    # record fields

   157

    name = None

   158

    ttl = None  # optional

   159

    cls = None  # optional

   160

    type = None

   161

    data = None # list of data fields

   162

   163

    @classmethod

   164

    def load (cls, file, ttl=None, origin=None, **opts) :

   165

        """

   166

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

   167

        """

   168

   169

        for line in ZoneLine.load(file, **opts) :

   170

            if not line.parts :

   171

                log.debug("%s: skip empty line", line)

   172

   173

            elif line.line.startswith('$') :

   174

                # control record

   175

                args = list(line.parts)

   176

                directive = args.pop(0)[1:]

   177

   178

                if directive == 'ORIGIN' :

   179

                    # update

   180

                    origin, = args

   181

   182

                    log.info("%s: origin: %s", line, origin)

   183

   184

                if directive == 'TTL' :

   185

                    ttl, = args

   186

   187

                    log.info("%s: ttl: %s", line, ttl)

   188

   189

                elif directive == 'GENERATE' :

   190

                    # process...

   191

                    log.info("%s: generate: %s", line, args)

   192

   193

                    for record in process_generate(line, origin, args) :

   194

                        yield record

   195

   196

                elif directive == 'INCLUDE' :

   197

                    include, = args

   198

   199

                    # XXX: this is probably not what we want...

   200

                    path = os.path.join(os.path.dirname(file.name), include)

   201

   202

                    log.info("%s: include: %s: %s", line, include, path)

   203

   204

                    for record in cls.load(open(path)) :

   205

                        yield record

   206

   207

                else :

   208

                    log.warning("%s: skip control record: %s", line, line.line)

   209

   210

            else :

   211

                # normal record?

   212

                record = ZoneRecord.parse(line, origin=origin, ttl=ttl,

   213

                        comment = line.comment

   214

                )

   215

   216

                if record :

   217

                    yield record

   218

   219

                else :

   220

                    # unknown

   221

                    log.warning("%s: skip unknown line: %s", line, line.line)

   222

   223

    @classmethod

   224

    def parse (cls, line, parts=None, ttl=None, **opts) :

   225

        """

   226

            Build a ZoneRecord from a ZoneLine.

   227

        """

   228

   229

        if parts is None :

   230

            parts = list(line.parts)

   231

   232

        if not parts :

   233

            # skip

   234

            return

   235

   236

        # XXX: indented lines keep name from previous record

   237

        if line.indent :

   238

            name = None

   239

   240

        else :

   241

            name = parts.pop(0)

   242

   243

        if len(parts) < 2 :

   244

            raise ZoneLineError(line, "Too few parts to parse: {0!r}", line.data)

   245

   246

        # parse ttl/cls/type

   247

        _cls = None

   248

   249

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

   250

            ttl = parts.pop(0)

   251

   252

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

   253

            _cls = parts.pop(0)

   254

   255

        # always have type

   256

        type = parts.pop(0)

   257

   258

        # remaining parts are data

   259

        data = parts

   260

   261

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

   262

   263

        return cls.build(line, name, ttl, _cls, type, data, **opts)

   264

   265

    @classmethod

   266

    def build (_cls, line, name, ttl, cls, type, data, **opts) :

   267

        return _cls(name, type, data,

   268

            ttl     = ttl,

   269

            cls     = cls,

   270

            line    = line,

   271

            **opts

   272

        )

   273

   274

    @classmethod

   283

    def TXT (cls, name, text, **opts) :

   284

        return cls(name, 'TXT',

   285

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

   286

            **opts

   287

        )

   288

   289

    @classmethod

   290

    def PTR (cls, name, ptr, **opts) :

   291

        return cls(name, 'PTR', [ptr], **opts)

   292

   293

    @classmethod

   294

    def MX (cls, name, priority, mx, **opts) :

   295

        return cls(name, 'MX', [priority, mx], **opts)

   296

   297

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

   298

        self.name = name

   299

        self.type = type

   300

        self.data = data

   301

   302

        self.ttl = ttl

   303

        self.cls = cls

   304

   305

        self.origin = origin

   306

        self.line = line

   307

   308

        self.comment = comment

   309

   310

    def __unicode__ (self) :

   311

        """

   312

            Construct a zonefile-format line..."

   313

        """

   314

   315

        if self.comment :

   316

            comment = '\t; ' + self._comment

   317

        else :

   318

            comment = ''

   319

   320

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

   321

                name    = self.name or '',

   322

                ttl     = self.ttl or '',

   323

                cls     = self.cls or '',

   324

                type    = self.type,

   325

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

   326

                comment = comment,

   327

        )

   328

   329

    def __repr__ (self) :

   330

        return '%s(%s)' % (self.__class__.__name__, ', '.join(repr(arg) for arg in (

   331

            self.name, self.type, self.data

   332

        )))

   333

   334

class SOA (ZoneRecord) :

   335

    @classmethod

   336

    def build (_cls, line, name, ttl, cls, type, data, **opts) :

   337

        assert name == '@'

   338

   339

        return _cls(*data,

   340

            ttl     = ttl,

   341

            cls     = cls,

   342

            line    = line,

   343

            **opts

   344

        )

   345

   346

    def __init__ (self, master, contact, serial, refresh, retry, expire, nxttl, **opts) :

   347

        super(SOA, self).__init__('@', 'SOA',

   348

            [master, contact, serial, refresh, retry, expire, nxttl],

   349

            **opts

   350

        )

   351

   352

        self.master = master

   353

        self.contact = contact

   354

        self.serial = serial

   355

        self.refresh = refresh

   356

        self.retry = retry

   357

        self.expire = expire

   358

        self.nxttl = nxttl

   359

   360

class OffsetValue (object) :

   361

    """

   362

        Magic for $GENERATE offsets.

   363

   364

        >>> OffsetValue(0)[1]

   365

        1

   366

        >>> OffsetValue(10)[5]

   367

        15

   368

    """

   369

   370

    def __init__ (self, base) :

   371

        self.base = base

   372

   373

    def __getitem__ (self, offset) :

   374

        return self.base + offset

   375

   376

def parse_generate_field (line, field) :

   377

    """

   378

        Parse a $GENERATE lhs/rhs field:

   379

            $

   380

            ${<offset>[,<width>[,<base>]]}

   381

            \$

   382

            $$

   383

   384

        Returns a wrapper that builds the field-value when called with the index.

   385

   386

        >>> parse_generate_field(None, "foo")(1)

   387

        'foo'

   388

        >>> parse_generate_field(None, "foo-$")(1)

   389

        'foo-1'

   390

        >>> parse_generate_field(None, "foo-$$")(1)

   391

        'foo-$'

   392

        >>> parse_generate_field(None, "\$")(1)

   393

        '$'

   394

        >>> parse_generate_field(None, "10.0.0.${100}")(1)

   395

        '10.0.0.101'

   396

        >>> parse_generate_field(None, "foo-${0,2,d}")(1)

   397

        'foo-01'

   398

   399

    """

   400

   401

    input = field

   402

    expr = []

   403

   404

    while '$' in field :

   405

        # defaults

   406

        offset = 0

   407

        width = 0

   408

        base = 'd'

   409

        escape = False

   410

   411

        # different forms

   412

        if '${' in field :

   413

            pre, body = field.split('${', 1)

   414

            body, post = body.split('}', 1)

   415

   416

            # parse body

   417

            parts = body.split(',')

   418

   419

            # offset

   420

            offset = int(parts.pop(0))

   421

   422

            # width

   423

            if parts :

   424

                width = int(parts.pop(0))

   425

   426

            # base

   427

            if parts :

   428

                base = parts.pop(0)

   429

   430

            if parts:

   431

                # fail

   432

                raise ZoneLineError(line, "extra data in ${...} body: {0!r}", parts)

   433

   434

        elif '$$' in field :

   435

            pre, post = field.split('$$', 1)

   436

            escape = True

   437

   438

        elif '\\$' in field :

   439

            pre, post = field.split('\\$', 1)

   440

            escape = True

   441

   442

        else :

   443

            pre, post = field.split('$', 1)

   444

   445

        expr.append(pre)

   446

   447

        if escape :

   448

            expr.append('$')

   449

   450

        else :

   451

            # meta-format

   452

            fmt = '{value[%d]:0%d%s}' % (offset, width, base)

   453

   454

            log.debug("field=%r -> pre=%r, fmt=%r, post=%r", field, expr, fmt, post)

   455

   456

            expr.append(fmt)

   457

   458

        field = post

   459

   460

    # final

   461

    if field :

   462

        expr.append(field)

   463

   464

    # combine

   465

    expr = ''.join(expr)

   466

   467

    log.debug("%s: %s", input, expr)

   468

   469

    # processed

   470

    def value_func (value) :

   471

        # magic wrapper to implement offsets

   472

        return expr.format(value=OffsetValue(value))

   473

   474

    return value_func

   475

   476

def process_generate (line, origin, parts) :

   477

    """

   478

        Process a 

   479

            $GENERATE <start>-<stop>[/<step>] lhs [ttl] [class] type rhs [comment]

   480

        directive into a series of ZoneResource's.

   481

    """

   482

   483

    range = parts.pop(0)

   484

   485

    # parse range

   486

    if '/' in range :

   487

        range, step = range.split('/')

   488

        step = int(step)

   489

    else :

   490

        step = 1

   491

   492

    start, stop = range.split('-')

   493

    start = int(start)

   494

    stop = int(stop)

   495

   496

    log.debug("  range: start=%r, stop=%r, step=%r", start, stop, step)

   497

   498

    # inclusive

   499

    range = xrange(start, stop + 1, step)

   500

   501

    lhs_func = parse_generate_field(line, parts.pop(0))

   502

    rhs_func = parse_generate_field(line, parts.pop(-1))

   503

    body = parts

   504

   505

    for i in range :

   506

        # build

   507

        parts = [lhs_func(i)] + body + [rhs_func(i)]

   508

   509

        log.debug(" %03d: %r", i, parts)

   510

   511

        # parse