1

import logging; log = logging.getLogger('pvl.dhcp.config')

     2

import shlex

     3

import string

     4

     5

# simplified model of lexer chars

     6

TOKEN_START = string.ascii_letters + string.digits + '-'

     7

TOKEN = TOKEN_START + '_'

     8

     9

# be far more lenient when parsing

    10

TOKEN_EXTRA = TOKEN + ':.'

    11

    12

UNQUOTED_CONTEXT = set((

    13

    ('host', ),

    14

    ('fixed-address', ),

    15

    ('next-server', ),

    16

    ('hardware', 'ethernet'),

    17

))

    18

    19

class DHCPConfigError(Exception):

    20

    def __init__ (self, parser, error, line=None):

    21

        self.parser = parser

    22

    23

        self.name = parser.name

    24

        self.line = line

    25

        self.error = error

    26

    27

    def __str__ (self):

    28

        return "{self.name}:{self.line}: {self.error}".format(self=self)

    29

    30

def split (line) :

    31

    """

    32

        Split given line-data into raw tokens.

    33

    34

        >>> list(split('foo'))

    35

        ['foo']

    36

        >>> list(split('foo bar'))

    37

        ['foo', 'bar']

    38

        >>> list(split('foo;'))

    39

        ['foo', ';']

    40

        >>> list(split('"foo"'))

    41

        ['foo']

    42

        >>> list(split('foo "asdf quux" bar'))

    43

        ['foo', 'asdf quux', 'bar']

    44

        >>> list(split('foo "asdf quux"'))

    45

        ['foo', 'asdf quux']

    46

        >>> list(split('# nevermind'))

    47

        []

    48

        >>> list(split(''))

    49

        []

    50

        >>> list(split('next-server foo'))

    51

        ['next-server', 'foo']

    52

        >>> list(split('include "foo/bar.conf";'))

    53

        ['include', 'foo/bar.conf', ';']

    54

    """

    55

    56

    if line is None:

    57

        raise TypeError(line)

    58

    59

    lexer = shlex.shlex(line, posix=True)

    60

    lexer.commenters = '#'

    61

    lexer.wordchars = TOKEN_EXTRA

    62

    63

    while True:

    64

        item = lexer.get_token()

    65

    66

        if item is None:

    67

            break

    68

    69

        yield item

    70

    71

class Field (object):

    72

    """

    73

        Pre-quoted fields for use in DHCP confs.

    74

    """

    75

    76

    def __init__(self, token):

    77

        self.token = token

    78

    79

    def __str__(self):

    80

        return self.token

    81

    94

def quote (value, context=None):

    95

    """

    96

        Build a single field as part of a dhcp.conf line.

    97

    98

        >>> print quote('foo')

    99

        foo

   100

        >>> print quote('foo bar')

   101

        "foo bar"

   102

        >>> print quote('foo/bar.conf')

   103

        "foo/bar.conf"

   104

        >>> print quote(5)

   105

        5

   106

        >>> print quote('5')

   107

        5

   108

        >>> print quote('foo.bar')

   109

        "foo.bar"

   110

        >>> print quote('foo.bar', context=('host', ))

   111

        foo.bar

   112

        >>> print quote('192.0.2.1', context=('fixed-address', ))

   113

        192.0.2.1

   114

        >>> print quote('00:11:22:33:44:55', context=('hardware', 'ethernet'))

   115

        00:11:22:33:44:55

   116

        >>> print quote(Field('1:00:11:22:33:44:55'))

   117

        1:00:11:22:33:44:55

   120

    """

   121

   122

    if isinstance(value, Field):

   123

        return str(value)

   124

    elif isinstance(value, int):

   125

        return str(value)

   126

    elif context in UNQUOTED_CONTEXT:

   127

        return str(value)

   128

    elif value[0] in TOKEN_START and all(c in TOKEN for c in value):

   129

        return str(value)

   130

    else:

   131

        # quoted

   132

        return '"{value}"'.format(value=value)

   133

   134

class Block (object):

   135

    """

   136

        A block in a dhcp conf includes parameters and sub-blocks.

   137

    """

   138

   139

    def __init__ (self, key, items=None, blocks=None, comment=None):

   140

        """

   141

            key: tuple      - name of block

   142

        """

   143

   144

        self.key = key

   145

        self.items = items or [ ]

   146

        self.blocks = blocks or [ ]

   147

        self.comment = comment

   148

   149

    def __str__ (self):

   150

        return ' '.join(self.key)

   151

   152

    def __repr__ (self):

   153

        return "Block({self.key!r}, items={self.items!r}, blocks={self.blocks!r})".format(self=self)

   154

   155

class DHCPConfigParser (object):

   156

    """

   157

        Simple parser for ISC dhcpd conf files.

   158

   159

        Supports iterative parsing as required for following a dhcpd.leases file.

   160

   161

        Doesn't implement the full spec, but a useful approximation.

   162

    """

   163

   164

    @classmethod

   165

    def load (cls, file, name=None):

   166

        """

   167

            Parse an complete file, returning the top-level Block.

   168

   169

            >>> DHCPConfigParser.load(['foo;', 'bar {', '\tasdf "quux";', '}'], name='test')

   170

            Block(None, items=[('foo',)], blocks=[Block(('bar',), items=[('asdf', 'quux')], blocks=[])])

   171

        """

   172

   173

        if name is None:

   174

            name = file.name

   175

   176

        parser = cls(name=name)

   177

   178

        for lineno, line in enumerate(file, 1):

   179

            try:

   180

                for item in parser.parse_line(line):

   181

                    log.debug("%s", item)

   182

            except DHCPConfigError as error:

   183

                error.line = lineno

   184

                raise

   185

   186

        if parser.token:

   187

            raise DHCPConfError(parser, "Trailing data: {token}".format(token=parser.token), line=lineno)

   188

   189

        if parser.stack:

   190

            raise DHCPConfError(parser, "Unterminated block: {stack}".format(stack=parser.stack), line=lineno)

   191

   192

        return parser.block 

   193

   194

    def __init__ (self, name=None):

   195

        self.name = name

   196

   197

        # lexer state

   198

        self.token = []

   199

   200

        # parser state

   201

        self.stack = []

   202

   203

        # top-level block

   204

        self.block = Block(None)

   205

   206

    def lex (self, line):

   207

        """

   208

            Lex one line of input into basic expressions:

   209

   210

                open:   [...] {

   211

                item:       [..];

   212

                close:  [] }

   213

   214

            Yields (event, (...)) tokens.

   215

   216

            Raises DHCPConfError.

   217

        """

   218

   219

        log.debug("%s", line)

   220

   221

        for word in split(line):

   222

            if word == '{':

   223

                yield 'open', tuple(self.token)

   224

   225

            elif word == ';':

   226

                yield 'item', tuple(self.token)

   227

   228

            elif word == '}':

   229

                if self.token:

   230

                    raise DHCPConfError(self, "Leading data on close: {token}".format(token=self.token))

   231

   232

                yield 'close', None

   233

   234

            else:

   235

                self.token.append(word)

   236

                continue

   237

   238

            self.token = [ ]

   239

   240

    def parse (self, tokens):

   241

        """

   242

            Parse given tokens, yielding any complete Blocks.

   243

   244

            Note that the Blocks yielded may be within some other Block which is still incomplete.

   245

        """

   246

   247

        for token, args in tokens:

   248

            if token == 'open':

   249

                block = Block(args)

   250

   251

                log.debug("open block: %s > %s", self.block, block)

   252

   253

                self.stack.append(self.block)

   254

                self.block.blocks.append(block)

   255

                self.block = block

   256

   257

            # must be within block!

   258

            elif token == 'item' :

   259

                log.debug("block %s item: %s", self.block, args)

   260

   261

                self.block.items.append(args)

   262

   263

            elif token == 'close' :

   264

                log.debug("close block: %s", self.block)

   265

   266

                block = self.block

   267

   268

                if self.stack:

   269

                    self.block = self.stack.pop()

   270

                else:

   271

                    raise DHCPConfigError(self, "Mismatched block close: {block}".format(block=block))

   272

   273

                yield block

   274

   275

            else:

   276

                raise ValueError(token, args)

   277

   278

    def parse_line (self, line):

   279

        """

   280

            Lex and parse line tokens.

   281

        """

   282

   283

        for block in self.parse(self.lex(line)):

   284

            yield block

   285

   286

    def parse_lines (self, lines) :

   287

        """

   288

            Trivial wrapper around parse to parse multiple lines.

   289

        """

   290

   291

        for line in lines:

   292

            for block in self.parse_line(line) :

   293

                yield block

   294

   295

def build_line (item, end, indent=0, context=None):

   296

    """

   297

        Build a structured line.

   298

   299

        >>> print build_line(('foo', ), ';')

   300

        foo;

   301

        >>> print build_line(('host', 'foo'), ' {')

   302

        host foo {

   303

        >>> print build_line(('foo', 'bar quux'), ';', indent=1)

   304

            foo "bar quux";

   305

    """

   306

   307

    return '    '*indent + ' '.join(quote(field, context=context) for field in item) + end

   308

   309

def build_item (item, **opts):

   310

    """

   311

        Build a single parameter line.

   312

   313

        >>> print build_item(('foo', ))

   314

        foo;

   315

    """

   316

   317

    return build_line(item, end=';',

   318

        context     = item[:-1],

   319

        **opts

   320

    )

   321

   322

def build_block (block, indent=0):

   323

    """

   324

        Build a complete Block, recursively, yielding output lines.

   325

   326

        >>> for line in build_block(Block(('host', 'foo'), [('hardware', 'ethernet', '00:11:22:33:44:55')], comment="Testing")): print line

   327

        # Testing

   328

        host foo {

   329

            hardware ethernet 00:11:22:33:44:55;

   330

        }

   331

        >>> for line in build_block(Block(('group', ), [('next-server', 'booter')], [ \

   332

                    Block(('host', 'foo'), [('hardware', 'ethernet', '00:11:22:33:44:55')]) \

   333

                ])): print line

   334

        group {

   335

            next-server booter;

   336

        <BLANKLINE>

   337

            host foo {

   338

                hardware ethernet 00:11:22:33:44:55;

   339

            }

   340

        }

   341

    """

   342

   343

    if block.comment:

   344

        yield build_line((), end="# {comment}".format(comment=block.comment), indent=indent)

   345

   346

    if block.key:

   347

        yield build_line(block.key, end=' {', indent=indent, context=block.key[0:1])

   348

        indent += 1

   349

   350

    for item in block.items:

   351

        yield build_item(item, indent=indent)

   352

   353

    for subblock in block.blocks:

   354

        if block.items:

   355

            yield ''

   356

   357

        for line in build_block(subblock, indent=indent):

   358

            yield line

   359

   360

    if block.key:

   361

        indent -= 1

   362

        yield build_line((), end='}', indent=indent)