9

import ipaddr

    13

import pvl.dns.labels

    28

def zone_quote (field):

    30

        Quote a value for inclusion into TXT record.

    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"

    40

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

    49

    def load (cls, file) :

    51

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

    52

    53

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

    56

        for line in cls.parse(file) :

    57

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

    58

                # control directive

    59

                line_type = ZoneDirective

    62

                # normal record

    63

                line_type = ZoneRecord

    65

            yield line_type.parse(line.parts,

    66

                    line        = line,

    67

                    comment     = line.comment,

    68

            )

    91

            if not line:

    92

                # empty line

    93

                continue

    94

   107

            if indent and not multiline_start:

   108

                parts = ['']

   109

            else:

   110

                parts = []

   111

   114

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

   117

                parts.extend(line.split())

   125

                multiline_start = (lineno, comment)

   141

                lineno, comment = multiline_start

   151

                yield ZoneLine(parts,

   152

                        file    = filename,

   153

                        lineno  = lineno,

   154

                        line    = raw_line,

   155

                        comment = comment,

   156

                )

   158

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

   159

        """

   160

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

   161

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

   162

        """

   164

        self.parts = parts

   165

   170

   171

        # meta

   175

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

   177

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

   183

   198

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

   199

        """

   200

            Parse from ZoneLine.parts

   201

        """

   203

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

   204

        arguments = parts[1:]

   205

   206

        return cls(directive, arguments, **opts)

   209

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

   210

        """

   211

            Build directive from optional parts

   212

        """

   214

        return cls(directive, arguments, **opts)

   215

   216

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

   217

        """

   218

            directive       - uppercase directive name, withtout leading $

   219

            arguments [str] - list of directive arguments

   220

            comment         - optional trailing comment

   221

            line            - optional associated ZoneLine

   222

            origin          - context origin

   223

        """

   224

   228

        self.comment = comment

   232

    def __unicode__ (self):

   237

        if self.comment:

   250

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

   254

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

   255

    """

   256

        Parse a

   257

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

   258

        directive and yield expanded ZoneRecords.

   259

   260

        Raises ZoneLineError

   261

    """

   262

   263

   264

    try:

   265

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

   266

   267

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

   268

        body = parts[1:-1]

   269

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

   270

   271

    except ValueError as error:

   272

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

   273

   274

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

   275

   276

    for i in range :

   277

        # build

   278

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

   279

   280

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

   281

   282

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

   283

   284

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

   285

    """

   286

        Parse a

   287

            $INCLUDE filename [ origin ]

   288

        directive and yield expanded ZoneRecords.

   289

   290

        Raises ZoneLineError.

   291

    """

   292

   293

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

   294

   295

    if include_origin:

   296

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

   297

   298

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

   299

        yield line, record

   300

   307

    def load (cls, file, origin,

   308

            ttl=None,

   309

    ):

   311

            Yield ZoneRecords from a file. Processes any ZoneDirectives.

   312

        """

   313

   314

        name = None

   316

        for line in ZoneLine.parse(file):

   317

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

   318

                directive = ZoneDirective.parse(line.parts,

   319

                        origin      = origin,

   320

                        line        = line,

   321

                        comment     = line.comment,

   322

                )

   323

   324

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

   325

   326

                if directive.directive == 'ORIGIN':

   327

                    directive_origin, = directive.arguments

   328

   329

                    log.info("%s: $ORIGIN %s -> %s", file, origin, directive_origin)

   330

   331

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

   332

   333

                elif directive.directive == 'TTL' :

   334

                    directive_ttl, = directive.arguments

   335

   336

                    log.info("%s: $TTL %d -> %s", file, ttl, directive_ttl)

   337

   338

                    ttl = int(directive_ttl)

   339

   340

                elif directive.directive == 'GENERATE' :

   341

                    for record in process_generate(line, directive.arguments,

   342

                            name        = name,

   343

                            ttl         = ttl,

   344

                            origin      = origin,

   345

                    ) :

   346

                        yield record

   347

   348

                elif directive.directive == 'INCLUDE' :

   349

                    for record in process_include(line, origin, 

   350

                            ttl         = ttl,

   351

                            *directive.arguments

   352

                    ):

   353

                        yield record

   354

   355

                else :

   356

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

   357

                    yield line, None

   358

   359

            else:

   360

                record = ZoneRecord.parse(line.parts,

   361

                        name        = name,

   362

                        ttl         = ttl,

   363

                        comment     = line.comment,

   364

                        line        = line,

   365

                        origin      = origin,

   366

                )

   367

   368

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

   369

   370

                # keep name across lines

   371

                name = record.name

   372

   373

                yield record

   374

   375

    @classmethod

   376

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

   377

        """

   378

            Build a ZoneRecord from ZoneLine.parts.

   379

   380

                name    - context for name, if continuing previous line

   381

                ttl     - context for ttl, if using $TTL

   386

        parts = list(parts)

   388

        # first field is either name or leading whitespace

   389

        leading = parts.pop(0)

   391

        if leading:

   392

            name = leading

   393

   395

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

   401

            ttl = int(parts.pop(0))

   404

            _cls = parts.pop(0).upper()

   407

        type = parts.pop(0).upper()

   414

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

   417

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

   418

        """

   419

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

   421

            Normalizes all fields to strs.

   422

        """

   423

   424

        # keyword-only arguments

   425

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

   426

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

   428

        if name:

   429

            name = str(name)

   430

        else:

   431

            name = None

   432

   433

        if ttl or ttl == 0:

   434

            ttl = int(ttl)

   435

        else:

   436

            ttl = None

   437

   438

        if cls:

   439

            cls = cls.upper()

   440

        else:

   441

            cls = None

   442

   443

        type = type.upper()

   444

   445

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

   446

   447

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

   450

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

   451

        """

   452

            Build from ipaddr.IPv4Address.

   453

        """

   454

   455

        return _cls.build(name, 'A', ipaddr.IPv4Address(ip4), **opts)

   458

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

   459

        """

   460

            Build from ipaddr.IPv6Address.

   461

        """

   462

   463

        return _cls.build(name, 'AAAA', ipaddr.IPv6Address(ip6), **opts)

   466

    def CNAME (_cls, name, alias, **opts):

   467

        return _cls.build(name, 'CNAME', alias, **opts)

   470

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

   471

        """

   472

            Build from quoted (unicode) value.

   473

        """

   475

        return _cls.build(name, 'TXT', zone_quote(unicode(text)), **opts)

   476

   477

    @classmethod

   478

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

   479

        return _cls.build(name, 'PTR', ptr, **opts)

   480

   481

    @classmethod

   482

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

   483

        """

   484

                priority    : int

   485

                mx          : str       - hostname

   486

        """

   487

   488

        return _cls.build(name, 'MX', int(priority), str(mx), **opts)

   489

   490

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

   491

        """

   492

            Using strict field ordering.