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

def process_generate (line, origin, parts) :

    27

    """

    28

        Process a 

    29

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

    30

        directive into a series of ZoneResource's.

    31

    32

        Raises ZoneLineError

    33

    """

    34

    35

    parts = list(parts)

    36

    37

    try:

    38

        range = parse_generate_range(parts.pop(0))

    39

    40

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

    41

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

    42

    except ValueError as error:

    43

        raise ZoneLineError(line, "{error}", error=error)

    44

    45

    body = parts

    46

    47

    for i in range :

    48

        # build

    49

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

    50

    51

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

    52

    53

        # parse

    54

        yield ZoneRecord.parse(line, parts=parts, origin=origin)

    55

    56

    57

class ZoneLine (object) :

    58

    """

    59

        A line parsed from a zonefile.

    60

    """

    61

    62

    @classmethod

    63

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

    64

        """

    65

            Parse ZoneLine, ZoneRecord items from the given zonefile.

    66

        """

    67

    68

        name = None

    69

    70

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

    71

            if not line.parts :

    72

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

    73

    74

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

    75

                # control record

    76

                directive = ZoneDirective.parse(line,

    77

                        origin      = origin,

    78

                        comment     = line.comment,

    79

                )

    80

    81

                if directive.directive == 'ORIGIN' :

    82

                    # update

    83

                    origin, = directive.arguments

    84

    85

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

    86

    87

                    yield line, None

    88

    89

                elif directive.directive == 'TTL' :

    90

                    ttl, = directive.arguments

    91

    92

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

    93

    94

                    yield line, None

    95

    96

                elif directive.directive == 'GENERATE' :

    97

                    if expand_generate :

    98

                        # process...

    99

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

   100

   101

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

   102

                            yield line, record

   103

                    else :

   104

                        yield line, None

   105

   106

                elif directive.directive == 'INCLUDE' :

   107

                    if expand_include :

   108

                        include, = directive.arguments

   109

   110

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

   111

   112

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

   113

   114

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

   115

                            yield line, record

   116

                    else :

   117

                        yield line, None

   118

   119

                else :

   120

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

   121

                    yield line, None

   122

   123

            else :

   124

                # normal record?

   125

                record = ZoneRecord.parse(line,

   126

                        name    = name,

   127

                        origin  = origin,

   128

                        ttl     = ttl,

   129

                        comment = line.comment,

   130

                )

   131

   132

                if record :

   133

                    yield line, record

   134

   135

                    # keep name across lines

   136

                    name = record.name

   137

   138

                else :

   139

                    # unknown

   140

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

   141

   142

                    yield line, None

   143

   144

   145

    @classmethod

   146

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

   147

        """

   148

            Yield ZoneLines lexed from a file.

   149

        """

   150

   151

        if not filename :

   152

            filename = file.name

   153

   154

        multiline_start = None

   155

        multiline_parts = None

   156

   157

        for lineno, raw_line in enumerate(file) :

   158

            raw_line = raw_line.rstrip('\n')

   159

   160

            # possible mtime prefix for line

   161

            timestamp = None

   162

   163

            if line_timestamp_prefix :

   164

                if ': ' not in raw_line :

   165

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

   166

   167

                # split prefix

   168

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

   169

   170

                # parse it out

   171

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

   172

   173

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

   174

   175

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

   176

   177

            # capture indent from raw line

   178

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

   179

            line = raw_line.strip()

   180

   181

            # parse comment

   182

            if ';' in line:

   183

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

   184

   185

                line = line.strip()

   186

                comment = comment.strip()

   187

            else :

   188

                comment = None

   189

   190

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

   191

   192

            # split (quoted) fields

   193

            if '"' in line :

   194

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

   195

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

   196

   197

            else :

   198

                parts = line.split()

   199

   200

            # handle multi-line statements...

   201

            if '(' in parts :

   202

                assert not multiline_start

   203

   204

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

   205

   206

                multiline_start = (lineno, timestamp, indent, comment)

   207

                multiline_line = raw_line

   208

                multiline_parts = []

   209

   210

            if multiline_start:

   211

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

   212

   213

                # XXX: some better way to do this

   214

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

   215

                multiline_line += raw_line

   216

   217

            if ')' in parts :

   218

                assert multiline_start

   219

   220

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

   221

   222

                lineno, timestamp, indent, comment = multiline_start

   223

                raw_line = multiline_line

   224

                parts = multiline_parts

   225

   226

                multiline_start = multiline_line = multiline_parts = None

   227

   228

            # parse

   229

            if multiline_start:

   230

                pass

   231

            else:

   232

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

   233

   234

    file = None

   235

    lineno = None

   236

   237

    # data

   238

    indent = None # was the line indented?

   239

    parts = None # split line fields

   240

   241

    # optional

   242

    timestamp = None

   243

    comment = None

   244

   245

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

   246

   247

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

   248

        # source

   249

        self.file = file

   250

        self.lineno = lineno

   251

        self.line = line

   252

   253

        # parse data

   254

        self.indent = indent

   255

        self.parts = parts

   256

   257

        # metadata

   258

        self.timestamp = timestamp

   259

        self.comment = comment

   260

   261

    def __unicode__ (self) :

   262

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

   263

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

   264

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

   265

        )

   266

   267

    def __repr__ (self) :

   268

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

   269

   270

class ZoneDirective (object) :

   271

    """

   272

        An $DIRECTIVE in a zonefile.

   273

    """

   274

   275

    # context

   276

    line    = None

   277

    origin  = None

   278

   279

    # fields

   280

    directive   = None

   281

    arguments   = None

   282

   283

    @classmethod

   284

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

   285

        # control record

   286

        args = list(line.parts)

   287

        directive = args[0][1:]

   288

        arguments = args[1:]

   289

   290

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

   291

   292

    @classmethod

   293

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

   294

        return cls(directive, arguments,

   295

                line        = line,

   296

                **opts

   297

        )

   298

   299

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

   300

        self.directive  = directive

   301

        self.arguments  = arguments

   302

   303

        self.line = line

   304

        self.origin = origin

   305

        self.comment = comment

   306

   307

    def __unicode__ (self) :

   308

        """

   309

            Construct a zonefile-format line...

   310

        """

   311

   312

        if self.comment :

   313

            comment = '\t; ' + self.comment

   314

        else :

   315

            comment = ''

   316

   317

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

   318

                directive   = self.directive,

   319

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

   320

                comment     = comment,

   321

        )

   322

   323

    def __repr__ (self) :

   324

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

   325

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

   326

        )))

   327

   328

   329

class ZoneRecord (object) :

   330

    """

   331

        A record from a zonefile.

   332

    """

   333

   334

    # context

   335

    line = None # the underlying line

   336

    origin = None # possible $ORIGIN context

   337

   338

    # record fields

   339

    name = None

   340

    ttl = None  # optional

   341

    cls = None  # optional

   342

    type = None

   343

    data = None # list of data fields

   344

   345

    @classmethod

   346

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

   347

        """

   348

            Yield ZoneRecords from a file.

   349

        """

   350

   351

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

   352

            if record :

   353

                yield record

   354

            else :

   355

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

   356

   357

    @classmethod

   358

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

   359

        """

   360

            Build a ZoneRecord from a ZoneLine.

   361

   362

                name        - default for name, if continuing previous line

   363

   364

            Return: (name, ZoneRecord)

   365

        """

   366

   367

        if parts is None :

   368

            parts = list(line.parts)

   369

   370

        if not parts :

   371

            # skip

   372

            return

   373

   374

        if line.indent :

   375

            # indented lines keep name from previous record

   376

            pass

   377

   378

        else :

   379

            name = parts.pop(0)

   380

   381

        if len(parts) < 2 :

   382

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

   383

   384

        # parse ttl/cls/type

   385

        _cls = None

   386

   387

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

   388

            ttl = parts.pop(0)

   389

   390

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

   391

            _cls = parts.pop(0)

   392

   393

        # always have type

   394

        type = parts.pop(0)

   395

   396

        # remaining parts are data

   397

        data = parts

   398

   399

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

   400

   401

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

   402

   403

    @classmethod

   404

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

   405

        return cls(name, type, data,

   406

            ttl     = ttl,

   407

            cls     = _cls,

   408

            line    = line,

   409

            **opts

   410

        )

   411

   412

    @classmethod

   413

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

   414

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

   415

   416

    @classmethod

   417

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

   418

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

   419

   420

    @classmethod

   421

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

   422

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

   423

   424

    @classmethod

   425

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

   426

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

   427

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

   428

            **opts

   429

        )

   430

   431

    @classmethod

   432

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

   433

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

   434

   435

    @classmethod

   436

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

   437

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

   438

   439

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

   440

        self.name = name

   441

        self.type = type

   442

        self.data = data

   443

   444

        self.ttl = ttl

   445

        self.cls = cls

   446

   447

        self.line = line

   448

        self.origin = origin

   449

        self.comment = comment

   450

   451

    def __unicode__ (self) :

   452

        """

   453

            Construct a zonefile-format line..."

   454

        """

   455

   456

        if self.comment :

   457

            comment = '\t; ' + self.comment

   458

        else :

   459

            comment = ''

   460

   461

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

   462

                name    = self.name or '',

   463

                ttl     = self.ttl or '',

   464

                cls     = self.cls or '',

   465

                type    = self.type,

   466

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

   467

                comment = comment,

   468

        )

   469

   470

    def __repr__ (self) :

   471

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

   472

            self.name, self.type, self.data

   473

        )))

   474

   475

class SOA (ZoneRecord) :

   476

    @classmethod

   477

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

   478

        assert name == '@'

   479

   480

        return cls(*data,

   481

            ttl     = ttl,

   482

            cls     = cls,

   483

            line    = line,

   484

            **opts

   485

        )

   486

   487

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

   488

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

   489

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

   490

            **opts

   491

        )

   492

   493

        self.master = master

   494

        self.contact = contact

   495

        self.serial = serial

   496

        self.refresh = refresh

   497

        self.retry = retry

   498

        self.expire = expire