1

#!/usr/bin/env python

     2

     3

"""

     4

    Process zonefiles.

     5

"""

     6

     7

import codecs

     8

import datetime

    10

import logging

    11

import math

    12

import os.path

    13

import pvl.dns.labels

    14

    15

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

    16

    17

class ZoneError (Exception) :

    18

    pass

    19

    20

class ZoneLineError (ZoneError) :

    21

    """

    22

        ZoneLine-related error

    23

    """

    24

    25

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

    26

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

    27

    28

def zone_quote (field):

    29

    """

    30

        Quote a value for inclusion into TXT record.

    31

    32

        >>> print zone_quote("foo")

    33

        foo

    34

        >>> print zone_quote("foo\\bar")

    35

        "foo\\bar"

    36

        >>> print zone_quote("foo \"bar\" quux")

    37

        "foo \"bar\" quux"

    38

    """

    39

    40

    if any(c.isspace() or c == '\\' for c in field):

    41

        return u'"' + field.replace('\\', '\\\\').replace('"', '\\"') + u'"'

    42

    else:

    43

        return field

    44

    45

    46

class ZoneLine (object) :

    47

    """

    48

        A line parsed from a zonefile.

    49

    """

    50

    51

    @classmethod

    52

    def load (cls, file) :

    53

        """

    54

            Load (ZoneDirective or ZoneRecord) items from the given zonefile.

    55

    56

            Tracks $ORIGIN and $TTL state for ZoneRecords/ZoneDirectives.

    57

        """

    58

    59

        for line in cls.parse(file) :

    60

            if not line.parts:

    61

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

    62

                continue

    63

    64

            elif line.parts[0].startswith('$'):

    65

                # control directive

    66

                line_type = ZoneDirective

    67

    68

            else :

    69

                # normal record

    70

                line_type = ZoneRecord

    71

    72

            yield line_type.parse(line.parts,

    73

                    line        = line,

    74

                    comment     = line.comment,

    75

            )

    76

    77

    @classmethod

    78

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

    79

        """

    80

            Yield ZoneLines lexed from a file.

    81

        """

    82

    83

        if not filename :

    84

            filename = file.name

    85

    86

        multiline_start = None

    87

        multiline_parts = None

    88

    89

        for lineno, raw_line in enumerate(file) :

    90

            raw_line = raw_line.rstrip('\n')

    91

    92

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

    93

    94

            # capture indent from raw line

    95

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

    96

            line = raw_line.strip()

    97

    98

            if not line:

    99

                # empty line

   100

                continue

   101

   102

            # parse comment

   103

            if ';' in line:

   104

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

   105

   106

                line = line.strip()

   107

                comment = comment.strip()

   108

            else :

   109

                comment = None

   110

   111

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

   112

   113

            # split (quoted) fields

   114

            if indent and not multiline_start:

   115

                parts = ['']

   116

            else:

   117

                parts = []

   118

   119

            if '"' in line :

   120

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

   121

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

   122

   123

            else :

   124

                parts.extend(line.split())

   125

   126

            # handle multi-line statements...

   127

            if '(' in parts :

   128

                assert not multiline_start

   129

   130

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

   131

   132

                multiline_start = (lineno, comment)

   133

                multiline_line = raw_line

   134

                multiline_parts = []

   135

   136

            if multiline_start:

   137

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

   138

   139

                # XXX: some better way to do this

   140

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

   141

                multiline_line += raw_line

   142

   143

            if ')' in parts :

   144

                assert multiline_start

   145

   146

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

   147

   148

                lineno, comment = multiline_start

   149

                raw_line = multiline_line

   150

                parts = multiline_parts

   151

   152

                multiline_start = multiline_line = multiline_parts = None

   153

   154

            # parse

   155

            if multiline_start:

   156

                pass

   157

            else:

   158

                yield ZoneLine(parts,

   159

                        file    = filename,

   160

                        lineno  = lineno,

   161

                        line    = raw_line,

   162

                        comment = comment,

   163

                )

   164

   165

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

   166

        """

   167

            parts : [str]       - list of parsed (quoted) fields

   168

                                  if the line has a leading indent, the first field should be an empty string

   169

        """

   170

   171

        self.parts = parts

   172

   173

        # source

   174

        self.file = file

   175

        self.lineno = lineno

   176

        self.line = line

   177

   178

        # meta

   179

        self.comment = comment

   180

   181

    def __unicode__ (self) :

   182

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

   183

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

   184

                comment     = u'\t; ' + self.comment if self.comment is not None else '',

   185

        )

   186

   187

    def __repr__ (self) :

   188

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

   189

   190

   191

class ZoneDirective (object) :

   192

    """

   193

        An $DIRECTIVE in a zonefile.

   194

    """

   195

   196

    # context

   197

    line    = None

   198

    origin  = None

   199

   200

    # fields

   201

    directive   = None

   202

    arguments   = None

   203

   204

    @classmethod

   205

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

   206

        """

   207

            Parse from ZoneLine.parts

   208

        """

   209

   210

        directive = parts[0][1:].upper()

   211

        arguments = parts[1:]

   212

   213

        return cls(directive, arguments, **opts)

   214

   215

    @classmethod

   216

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

   217

        """

   218

            Build directive from optional parts

   219

        """

   220

   221

        return cls(directive, arguments, **opts)

   222

   223

    @classmethod

   224

    def INCLUDE (cls, path, origin=None, **opts):

   225

        """

   226

            Build $INCLUDE "path" [origin]

   227

   228

            Note that origin should be a FQDN, or it will be interpreted relative to the current origin!

   229

        """

   230

   231

        if origin:

   232

            return cls.build('INCLUDE', path, origin, **opts)

   233

        else:

   234

            return cls.build('INCLUDE', path, **opts)

   235

   236

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

   237

        """

   238

            directive       - uppercase directive name, withtout leading $

   239

            arguments [str] - list of directive arguments

   240

            comment         - optional trailing comment

   241

            line            - optional associated ZoneLine

   242

            origin          - context origin

   243

        """

   244

   245

        self.directive  = directive

   246

        self.arguments  = arguments

   247

   248

        self.comment = comment

   249

        self.line = line

   250

        self.origin = origin

   251

   252

    def __unicode__ (self):

   253

        """

   254

            Construct a zonefile-format line...

   255

        """

   256

   257

        if self.comment:

   258

            comment = '\t; ' + self.comment

   259

        else :

   260

            comment = ''

   261

   262

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

   263

                directive   = self.directive,

   264

                arguments   = '\t'.join(zone_quote(argument) for argument in self.arguments),

   265

                comment     = comment,

   266

        )

   267

   268

    def __repr__ (self) :

   269

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

   270

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

   271

        )))

   272

   273

   274

def process_generate (line, range, parts, **opts) :

   275

    """

   276

        Parse a

   277

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

   278

        directive and yield expanded ZoneRecords.

   279

   280

        Raises ZoneLineError

   281

    """

   282

   283

   284

    try:

   285

        range = pvl.dns.generate.parse_generate_range(range)

   286

   287

        lhs_func = pvl.dns.generate.parse_generate_field(parts[0], line=line)

   288

        body = parts[1:-1]

   289

        rhs_func = pvl.dns.generate.parse_generate_field(parts[-1], line=line)

   290

   291

    except ValueError as error:

   292

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

   293

   294

    log.info("%s: generate %s: %s ... %s", line, range, lhs_func, rhs_func)

   295

   296

    for i in range :

   297

        # build

   298

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

   299

   300

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

   301

   302

        yield ZoneRecord.parse(parts, line=line, **opts)

   303

   304

def process_include (line, origin, include_filename, include_origin=None, **opts):

   305

    """

   306

        Parse a

   307

            $INCLUDE filename [ origin ]

   308

        directive and yield expanded ZoneRecords.

   309

   310

        Raises ZoneLineError.

   311

    """

   312

   313

    path = os.path.join(os.path.dirname(line.file), include_filename)

   314

   315

    if include_origin:

   316

        origin = pvl.dns.labels.join(include_origin, origin)

   317

   318

    for record in ZoneRecord.load(open(path), origin, **opts) :

   319

        yield record

   320

   321

class ZoneRecord (object) :

   322

    """

   323

        A record from a zonefile.

   324

    """

   325

   326

    @classmethod

   327

    def load (cls, file, origin,

   328

            ttl=None,

   329

    ):

   330

        """

   331

            Yield ZoneRecords from a file. Processes any ZoneDirectives.

   332

        """

   333

   334

        name = None

   335

   336

        for line in ZoneLine.parse(file):

   337

            if not line.parts:

   338

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

   339

                continue

   340

   341

            elif line.parts[0].startswith('$'):

   342

                directive = ZoneDirective.parse(line.parts,

   343

                        origin      = origin,

   344

                        line        = line,

   345

                        comment     = line.comment,

   346

                )

   347

   348

                log.debug("%s: %s", line, directive)

   349

   350

                if directive.directive == 'ORIGIN':

   351

                    directive_origin, = directive.arguments

   352

   353

                    log.info("%s: $ORIGIN %s <- %s", line, directive_origin, origin)

   354

   355

                    origin = pvl.dns.labels.join(origin, directive_origin)

   356

   357

                elif directive.directive == 'TTL' :

   358

                    directive_ttl, = directive.arguments

   359

   360

                    log.info("%s: $TTL %s <- %s", line, directive_ttl, ttl)

   361

   362

                    ttl = int(directive_ttl)

   363

   364

                elif directive.directive == 'GENERATE' :

   365

                    for record in process_generate(line, directive.arguments,

   366

                            name        = name,

   367

                            ttl         = ttl,

   368

                            origin      = origin,

   369

                    ) :

   370

                        yield record

   371

   372

                elif directive.directive == 'INCLUDE' :

   373

                    for record in process_include(line, origin, 

   374

                            ttl         = ttl,

   375

                            *directive.arguments

   376

                    ):

   377

                        yield record

   378

   379

                else :

   380

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

   381

                    yield line, None

   382

   383

            else:

   384

                record = ZoneRecord.parse(line.parts,

   385

                        name        = name,

   386

                        ttl         = ttl,

   387

                        comment     = line.comment,

   388

                        line        = line,

   389

                        origin      = origin,

   390

                )

   391

   392

                log.debug("%s: %s", line, record)

   393

   394

                # keep name across lines

   395

                name = record.name

   396

   397

                yield record

   398

   399

    @classmethod

   400

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

   401

        """

   402

            Build a ZoneRecord from ZoneLine.parts.

   403

   404

                name    - context for name, if continuing previous line

   405

                ttl     - context for ttl, if using $TTL

   406

   407

            Return: (name, ZoneRecord)

   408

        """

   409

   410

        parts = list(parts)

   411

   412

        # first field is either name or leading whitespace

   413

        leading = parts.pop(0)

   414

   415

        if leading:

   416

            name = leading

   417

   418

        if len(parts) < 2 :

   419

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

   420

   421

        # parse ttl/cls/type

   422

        _cls = None

   423

   424

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

   425

            ttl = parts.pop(0)

   426

   427

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

   428

            _cls = parts.pop(0)

   429

   430

        # always have type

   431

        type = parts.pop(0)

   432

   433

        # remaining parts are data

   434

        data = parts

   435

   436

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

   437

   438

        # optional subclass for build()

   439

        cls = ZONE_RECORD_TYPES.get(type.upper(), cls)

   440

   441

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

   442

   443

    @classmethod

   444

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

   445

        """

   446

            Simple interface to build ZoneRecord from required parts. All optional fields must be given as keyword arguments.

   447

   448

            Normalizes all fields to strs.

   449

        """

   450

   451

        # keyword-only arguments

   452

        ttl = opts.pop('ttl', None)

   453

        cls = opts.pop('cls', None)

   454

   455

        if name:

   456

            name = str(name)

   457

        else:

   458

            name = None

   459

   460

        if ttl or ttl == 0:

   461

            ttl = int(ttl)

   462

        else:

   463

            ttl = None

   464

   465

        if cls:

   466

            cls = cls.upper()

   467

        else:

   468

            cls = None

   469

   470

        type = type.upper()

   471

   472

        data = [unicode(item) for item in data]

   473

   474

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

   475

   476

    @classmethod

   477

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

   478

        """

   480

        """

   481

   483

   484

    @classmethod

   485

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

   486

        """

   488

        """

   489

   491