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

                directive = ZoneDirective.parse(line,

    46

                        origin      = origin,

    47

                        comment     = line.comment,

    48

                )

    49

    50

                if directive.directive == 'ORIGIN' :

    51

                    # update

    52

                    origin, = directive.arguments

    53

    54

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

    55

    56

                    yield line, None

    57

    58

                elif directive.directive == 'TTL' :

    59

                    ttl, = directive.arguments

    60

    61

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

    62

    63

                    yield line, None

    64

    65

                elif directive.directive == 'GENERATE' :

    66

                    if expand_generate :

    67

                        # process...

    68

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

    69

    70

                        for record in process_generate(line, origin, directive.arguments) :

    71

                            yield line, record

    72

                    else :

    73

                        yield line, None

    74

    75

                elif directive.directive == 'INCLUDE' :

    76

                    if expand_include :

    77

                        include, = directive.arguments

    78

    79

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

    80

    81

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

    82

    83

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

    84

                            yield line, record

    85

                    else :

    86

                        yield line, None

    87

    88

                else :

    89

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

    90

                    yield line, None

    91

    92

            else :

    93

                # normal record?

    94

                record = ZoneRecord.parse(line,

    95

                        name    = name,

    96

                        origin  = origin,

    97

                        ttl     = ttl,

    98

                        comment = line.comment,

    99

                )

   100

   101

                if record :

   102

                    yield line, record

   103

   104

                    # keep name across lines

   105

                    name = record.name

   106

   107

                else :

   108

                    # unknown

   109

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

   110

   111

                    yield line, None

   112

   113

   114

    @classmethod

   115

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

   116

        """

   117

            Yield ZoneLines lexed from a file.

   118

        """

   119

   120

        if not filename :

   121

            filename = file.name

   122

   123

        multiline_start = None

   124

        multiline_parts = None

   125

   126

        for lineno, raw_line in enumerate(file) :

   127

            raw_line = raw_line.rstrip('\n')

   128

   129

            # possible mtime prefix for line

   130

            timestamp = None

   131

   132

            if line_timestamp_prefix :

   133

                if ': ' not in raw_line :

   134

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

   135

   136

                # split prefix

   137

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

   138

   139

                # parse it out

   140

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

   141

   142

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

   143

   144

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

   145

   146

            # capture indent from raw line

   147

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

   148

            line = raw_line.strip()

   149

   150

            # parse comment

   151

            if ';' in line:

   152

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

   153

   154

                line = line.strip()

   155

                comment = comment.strip()

   156

            else :

   157

                comment = None

   158

   159

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

   160

   161

            # split (quoted) fields

   162

            if '"' in line :

   163

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

   164

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

   165

   166

            else :

   167

                parts = line.split()

   168

   169

            # handle multi-line statements...

   170

            if '(' in parts :

   171

                assert not multiline_start

   172

   173

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

   174

   175

                multiline_start = (lineno, timestamp, indent, comment)

   176

                multiline_line = raw_line

   177

                multiline_parts = []

   178

   179

            if multiline_start:

   180

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

   181

   182

                # XXX: some better way to do this

   183

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

   184

                multiline_line += raw_line

   185

   186

            if ')' in parts :

   187

                assert multiline_start

   188

   189

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

   190

   191

                lineno, timestamp, indent, comment = multiline_start

   192

                raw_line = multiline_line

   193

                parts = multiline_parts

   194

   195

                multiline_start = multiline_line = multiline_parts = None

   196

   197

            # parse

   198

            if multiline_start:

   199

                pass

   200

            else:

   201

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

   202

   203

    file = None

   204

    lineno = None

   205

   206

    # data

   207

    indent = None # was the line indented?

   208

    parts = None # split line fields

   209

   210

    # optional

   211

    timestamp = None

   212

    comment = None

   213

   214

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

   215

   216

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

   217

        # source

   218

        self.file = file

   219

        self.lineno = lineno

   220

        self.line = line

   221

   222

        # parse data

   223

        self.indent = indent

   224

        self.parts = parts

   225

   226

        # metadata

   227

        self.timestamp = timestamp

   228

        self.comment = comment

   229

   230

    def __unicode__ (self) :

   231

        return u"{indent}{parts}".format(

   232

                indent      = u"\t" if self.indent else '',

   233

                parts       = u'\t'.join(self.parts),

   234

        )

   235

   236

    def __repr__ (self) :

   237

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

   238

   239

class ZoneDirective (object) :

   240

    """

   241

        An $DIRECTIVE in a zonefile.

   242

    """

   243

   244

    # context

   245

    line    = None

   246

    origin  = None

   247

   248

    # fields

   249

    directive   = None

   250

    arguments   = None

   251

   252

    @classmethod

   253

    def parse (cls, line, **opts) :

   254

        # control record

   255

        args = list(line.parts)

   256

        directive = args[0][1:]

   257

        arguments = args[1:]

   258

   259

        return cls.build(line, directive, *arguments, **opts)

   260

   261

    @classmethod

   262

    def build (cls, line, directive, *arguments, **opts) :

   263

        return cls(directive, arguments,

   264

                line        = line,

   265

                **opts

   266

        )

   267

   268

    def __init__ (self, directive, arguments, line=None, origin=None, comment=None) :

   269

        self.directive  = directive

   270

        self.arguments  = arguments

   271

   272

        self.line = line

   273

        self.origin = origin

   274

        self.comment = comment

   275

   276

    def __unicode__ (self) :

   277

        """

   278

            Construct a zonefile-format line...

   279

        """

   280

   281

        if self.comment :

   282

            comment = '\t; ' + self.comment

   283

        else :

   284

            comment = ''

   285

   286

        return u"${directive}\t{arguments}{comment}".format(

   287

                directive   = self.directive,

   288

                arguments   = '\t'.join(self.arguments),

   289

                comment     = comment,

   290

        )

   291

   292

    def __repr__ (self) :

   293

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

   294

            (self.directive) + tuple(self.arguments)

   295

        )))

   296

   297

   298

class ZoneRecord (object) :

   299

    """

   300

        A record from a zonefile.

   301

    """

   302

   303

    # context

   304

    line = None # the underlying line

   305

    origin = None # possible $ORIGIN context

   306

   307

    # record fields

   308

    name = None

   309

    ttl = None  # optional

   310

    cls = None  # optional

   311

    type = None

   312

    data = None # list of data fields

   313

   314

    @classmethod

   315

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

   316

        """

   317

            Yield ZoneRecords from a file.

   318

        """

   319

   320

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

   321

            if record :

   322

                yield record

   323

            else :

   324

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

   325

   326

    @classmethod

   327

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

   328

        """

   329

            Build a ZoneRecord from a ZoneLine.

   330

   331

                name        - default for name, if continuing previous line

   332

   333

            Return: (name, ZoneRecord)

   334

        """

   335

   336

        if parts is None :

   337

            parts = list(line.parts)

   338

   339

        if not parts :

   340

            # skip

   341

            return

   342

   343

        if line.indent :

   344

            # indented lines keep name from previous record

   345

            pass

   346

   347

        else :

   348

            name = parts.pop(0)

   349

   350

        if len(parts) < 2 :

   351

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

   352

   353

        # parse ttl/cls/type

   354

        _cls = None

   355

   356

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

   357

            ttl = parts.pop(0)

   358

   359

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

   360

            _cls = parts.pop(0)

   361

   362

        # always have type

   363

        type = parts.pop(0)

   364

   365

        # remaining parts are data

   366

        data = parts

   367

   368

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

   369

   370

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

   371

   372

    @classmethod

   373

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

   374

        return cls(name, type, data,

   375

            ttl     = ttl,

   376

            cls     = _cls,

   377

            line    = line,

   378

            **opts

   379

        )

   380

   381

    @classmethod

   382

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

   383

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

   384

   385

    @classmethod

   386

    def AAAA (cls, name, ip6, **opts) :

   387

        return cls(str(name), 'AAAA', [str(ip6)], **opts)

   388

   389

    @classmethod

   390

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

   391

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

   392

   393

    @classmethod

   394

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

   395

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

   396

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

   397

            **opts

   398

        )

   399

   400

    @classmethod

   401

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

   402

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

   403

   404

    @classmethod

   405

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

   406

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

   407

   408

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

   409

        self.name = name

   410

        self.type = type

   411

        self.data = data

   412

   413

        self.ttl = ttl

   414

        self.cls = cls

   415

   416

        self.line = line

   417

        self.origin = origin

   418

        self.comment = comment

   419

   420

    def __unicode__ (self) :

   421

        """

   422

            Construct a zonefile-format line..."

   423

        """

   424

   425

        if self.comment :

   426

            comment = '\t; ' + self._comment

   427

        else :

   428

            comment = ''

   429

   430

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

   431

                name    = self.name or '',

   432

                ttl     = self.ttl or '',

   433

                cls     = self.cls or '',

   434

                type    = self.type,

   435

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

   436

                comment = comment,

   437

        )

   438

   439

    def __repr__ (self) :

   440

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

   441

            self.name, self.type, self.data

   442

        )))

   443

   444

class SOA (ZoneRecord) :

   445

    @classmethod

   446

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

   447

        assert name == '@'

   448

   449

        return cls(*data,

   450

            ttl     = ttl,

   451

            cls     = cls,

   452

            line    = line,

   453

            **opts

   454

        )

   455

   456

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

   457

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

   458

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

   459

            **opts

   460

        )

   461

   462

        self.master = master

   463

        self.contact = contact

   464

        self.serial = serial

   465

        self.refresh = refresh

   466

        self.retry = retry

   467

        self.expire = expire

   468

        self.nxttl = nxttl

   469

   470

class OffsetValue (object) :

   471

    """

   472

        Magic for $GENERATE offsets.

   473

   474

        >>> OffsetValue(0)[1]

   475

        1

   476

        >>> OffsetValue(10)[5]

   477

        15

   478

    """

   479

   480

    def __init__ (self, base) :

   481

        self.base = base

   482

   483

    def __getitem__ (self, offset) :

   484

        return self.base + offset

   485

   486

def parse_generate_field (field, line=None) :

   487

    """

   488

        Parse a $GENERATE lhs/rhs field:

   489

            $

   490

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

   491

            \$

   492

            $$

   493

   494

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

   495

   496

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

   497

        'foo'

   498

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

   499

        'foo-1'