1

#!/usr/bin/env python

     2

     3

"""

     4

    Process zonefiles.

     5

"""

     6

     7

import codecs

     8

import datetime

     9

import logging

    10

import math

    11

import os.path

    12

    13

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

    14

    15

class ZoneError (Exception) :

    16

    pass

    17

    18

class ZoneLineError (ZoneError) :

    19

    """

    20

        ZoneLine-related error

    21

    """

    22

    23

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

    24

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

    25

    26

class ZoneLine (object) :

    27

    """

    28

        A line parsed from a zonefile.

    29

    """

    30

    31

    @classmethod

    32

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

    33

        """

    34

            Parse ZoneLine, ZoneRecord items from the given zonefile.

    35

        """

    36

    37

        name = None

    38

    39

        for line in cls.parse(file, **opts) :

    40

            if not line.parts :

    41

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

    42

    43

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

    44

                # control record

    45

                args = list(line.parts)

    46

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

    47

    48

                if directive == 'ORIGIN' :

    49

                    # update

    50

                    origin, = args

    51

    52

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

    53

    54

                elif directive == 'TTL' :

    55

                    ttl, = args

    56

    57

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

    58

    59

                elif directive == 'GENERATE' :

    60

                    if expand_generate :

    61

                        # process...

    62

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

    63

    64

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

    65

                            yield line, record

    66

                    else :

    67

                        yield line, None

    68

    69

                elif directive == 'INCLUDE' :

    70

                    if expand_include :

    71

                        include, = args

    72

    73

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

    74

    75

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

    76

    77

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

    78

                            yield line, record

    79

                    else :

    80

                        yield line, None

    81

    82

                else :

    83

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

    84

                    yield line, None

    85

    86

            else :

    87

                # normal record?

    88

                record = ZoneRecord.parse(line,

    89

                        name    = name,

    90

                        origin  = origin,

    91

                        ttl     = ttl,

    92

                        comment = line.comment,

    93

                )

    94

    95

                if record :

    96

                    yield line, record

    97

    98

                    # keep name across lines

    99

                    name = record.name

   100

   101

                else :

   102

                    # unknown

   103

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

   104

   105

                    yield line, None

   106

   107

   108

    @classmethod

   109

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

   110

        """

   111

            Yield ZoneLines lexed from a file.

   112

        """

   113

   114

        if not filename :

   115

            filename = file.name

   116

   117

        multiline_start = None

   118

        multiline_parts = None

   119

   120

        for lineno, raw_line in enumerate(file) :

   121

            raw_line = raw_line.rstrip('\n')

   122

   123

            # possible mtime prefix for line

   124

            timestamp = None

   125

   126

            if line_timestamp_prefix :

   127

                if ': ' not in raw_line :

   128

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

   129

   130

                # split prefix

   131

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

   132

   133

                # parse it out

   134

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

   135

   136

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

   137

   138

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

   139

   140

            # capture indent from raw line

   141

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

   142

            line = raw_line.strip()

   143

   144

            # parse comment

   145

            if ';' in line:

   146

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

   147

   148

                line = line.strip()

   149

                comment = comment.strip()

   150

            else :

   151

                comment = None

   152

   153

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

   154

   155

            # split (quoted) fields

   156

            if '"' in line :

   157

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

   158

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

   159

   160

            else :

   161

                parts = line.split()

   162

   163

            # handle multi-line statements...

   164

            if '(' in parts :

   165

                assert not multiline_start

   166

   167

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

   168

   169

                multiline_start = (lineno, timestamp, indent, comment)

   170

                multiline_line = raw_line

   171

                multiline_parts = []

   172

   173

            if multiline_start:

   174

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

   175

   176

                # XXX: some better way to do this

   177

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

   178

                multiline_line += raw_line

   179

   180

            if ')' in parts :

   181

                assert multiline_start

   182

   183

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

   184

   185

                lineno, timestamp, indent, comment = multiline_start

   186

                raw_line = multiline_line

   187

                parts = multiline_parts

   188

   189

                multiline_start = multiline_line = multiline_parts = None

   190

   191

            # parse

   192

            if multiline_start:

   193

                pass

   194

            else:

   195

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

   196

   197

    file = None

   198

    lineno = None

   199

   200

    # data

   201

    indent = None # was the line indented?

   202

    parts = None # split line fields

   203

   204

    # optional

   205

    timestamp = None

   206

    comment = None

   207

   208

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

   209

   210

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

   211

        # source

   212

        self.file = file

   213

        self.lineno = lineno

   214

        self.line = line

   215

   216

        # parse data

   217

        self.indent = indent

   218

        self.parts = parts

   219

   220

        # metadata

   221

        self.timestamp = timestamp

   222

        self.comment = comment

   223

   224

    def __str__ (self) :

   225

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

   226

   227

class ZoneRecord (object) :

   228

    """

   229

        A record from a zonefile.

   230

    """

   231

   232

    # context

   233

    line = None # the underlying line

   234

    origin = None # possible $ORIGIN context

   235

   236

    # record fields

   237

    name = None

   238

    ttl = None  # optional

   239

    cls = None  # optional

   240

    type = None

   241

    data = None # list of data fields

   242

   243

    @classmethod

   244

    def load (cls, file, **opts) :

   245

        """

   246

            Yield ZoneRecords from a file.

   247

        """

   248

   249

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

   250

            if record :

   251

                yield record

   252

            else :

   253

                log.warn("%s: %s", file, line)

   254

   255

    @classmethod

   256

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

   257

        """

   258

            Build a ZoneRecord from a ZoneLine.

   259

   260

                name        - default for name, if continuing previous line

   261

   262

            Return: (name, ZoneRecord)

   263

        """

   264

   265

        if parts is None :

   266

            parts = list(line.parts)

   267

   268

        if not parts :

   269

            # skip

   270

            return

   271

   272

        if line.indent :

   273

            # indented lines keep name from previous record

   274

            pass

   275

   276

        else :

   277

            name = parts.pop(0)

   278

   279

        if len(parts) < 2 :

   280

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

   281

   282

        # parse ttl/cls/type

   283

        _cls = None

   284

   285

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

   286

            ttl = parts.pop(0)

   287

   288

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

   289

            _cls = parts.pop(0)

   290

   291

        # always have type

   292

        type = parts.pop(0)

   293

   294

        # remaining parts are data

   295

        data = parts

   296

   297

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

   298

   299

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

   300

   301

    @classmethod

   302

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

   303

        return cls(name, type, data,

   304

            ttl     = ttl,

   305

            cls     = _cls,

   306

            line    = line,

   307

            **opts

   308

        )

   309

   310

    @classmethod

   311

    def A (cls, name, ip, **opts) :

   312

        return cls(str(name), 'A', [str(ip)], **opts)

   313

   314

    @classmethod

   315

    def CNAME (cls, name, host, **opts) :

   316

        return cls(str(name), 'CNAME', [str(host)], **opts)

   317

   318

    @classmethod

   319

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

   320

        return cls(str(name), 'TXT',

   321

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

   322

            **opts

   323

        )

   324

   325

    @classmethod

   326

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

   327

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

   328

   329

    @classmethod

   330

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

   331

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

   332

   333

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

   334

        self.name = name

   335

        self.type = type

   336

        self.data = data

   337

   338

        self.ttl = ttl

   339

        self.cls = cls

   340

   341

        self.line = line

   342

        self.origin = origin

   343

        self.comment = comment

   344

   345

    def __unicode__ (self) :

   346

        """

   347

            Construct a zonefile-format line..."

   348

        """

   349

   350

        if self.comment :

   351

            comment = '\t; ' + self._comment

   352

        else :

   353

            comment = ''

   354

   355

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

   356

                name    = self.name or '',

   357

                ttl     = self.ttl or '',

   358

                cls     = self.cls or '',

   359

                type    = self.type,

   360

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

   361

                comment = comment,

   362

        )

   363

   364

    def __repr__ (self) :

   365

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

   366

            self.name, self.type, self.data

   367

        )))

   368

   369

class SOA (ZoneRecord) :

   370

    @classmethod

   371

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

   372

        assert name == '@'

   373

   374

        return cls(*data,

   375

            ttl     = ttl,

   376

            cls     = cls,

   377

            line    = line,

   378

            **opts

   379

        )

   380

   381

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

   382

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

   383

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

   384

            **opts

   385

        )

   386

   387

        self.master = master

   388

        self.contact = contact

   389

        self.serial = serial

   390

        self.refresh = refresh

   391

        self.retry = retry

   392

        self.expire = expire

   393

        self.nxttl = nxttl

   394

   395

class OffsetValue (object) :

   396

    """

   397

        Magic for $GENERATE offsets.

   398

   399

        >>> OffsetValue(0)[1]

   400

        1

   401

        >>> OffsetValue(10)[5]

   402

        15

   403

    """

   404

   405

    def __init__ (self, base) :

   406

        self.base = base

   407

   408

    def __getitem__ (self, offset) :

   409

        return self.base + offset

   410

   411

def parse_generate_field (field, line=None) :

   412

    """

   413

        Parse a $GENERATE lhs/rhs field:

   414

            $

   415

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

   416

            \$

   417

            $$

   418

   419

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

   420

   421

        >>> parse_generate_field("foo")(1)

   422

        'foo'

   423

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

   424

        'foo-1'

   425

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

   426

        'foo-$'

   427

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

   428

        '$'

   429

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

   430

        '10.0.0.101'

   431

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

   432

        'foo-01'

   433

   434

    """

   435

   436

    input = field

   437

    expr = []

   438

   439

    while '$' in field :

   440

        # defaults

   441

        offset = 0

   442

        width = 0

   443

        base = 'd'

   444

        escape = False

   445

   446

        # different forms

   447

        if '${' in field :

   448

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

   449

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

   450

   451

            # parse body

   452

            parts = body.split(',')

   453

   454

            # offset

   455

            offset = int(parts.pop(0))

   456

   457

            # width

   458

            if parts :

   459

                width = int(parts.pop(0))

   460

   461

            # base

   462

            if parts :

   463

                base = parts.pop(0)

   464

   465

            if parts:

   466

                # fail

   467

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

   468

   469

        elif '$$' in field :

   470

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

   471

            escape = True

   472

   473

        elif '\\$' in field :

   474

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

   475

            escape = True

   476

   477

        else :

   478

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

   479

   480

        expr.append(pre)

   481

   482

        if escape :

   483

            expr.append('$')

   484

   485

        else :

   486

            # meta-format

   487

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

   488

   489

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

   490

   491

            expr.append(fmt)

   492

   493

        field = post

   494

   495

    # final

   496

    if field :

   497

        expr.append(field)

   498

   499

    # combine

   500

    expr = ''.join(expr)

   501

   502

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

   503

   504

    # processed

   505

    def value_func (value) :

   506

        # magic wrapper to implement offsets