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

    82

class String (Field):

    83

    """

    84

        A quoted string

    85

    """

    86

    87

    def __init__(self, string):

    88

        self.string = string

    89

    90

    def __str__(self):

    91

        # TODO: escape

    92

        return '"{self.string}"'.format(self=self)

    93

    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

   118

        >>> print quote(String('foobar'))

   119

        "foobar"

   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):

   155

   156

    def __repr__ (self):

   157

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

   158

   159

class DHCPConfigParser (object):

   160

    """

   161

        Simple parser for ISC dhcpd conf files.

   162

   163

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

   164

   165

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

   166

    """

   167

   168

    @classmethod

   169

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

   170

        """

   171

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

   172

   173

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

   174

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

   175

        """

   176

   177

        if name is None:

   178

            name = file.name

   179

   180

        parser = cls(name=name)

   181

   182

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

   183

            try:

   184

                for item in parser.parse_line(line):

   185

                    log.debug("%s", item)

   186

            except DHCPConfigError as error:

   187

                error.line = lineno

   188

                raise

   189

   190

        if parser.token:

   191

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

   192

   193

        if parser.stack:

   194

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

   195

   196

        return parser.block 

   197

   198

    def __init__ (self, name=None):

   199

        self.name = name

   200

   201

        # lexer state

   202

        self.token = []

   203

   204

        # parser state

   205

        self.stack = []

   206

   207

        # top-level block

   208

        self.block = Block(None)

   209

   210

    def lex (self, line):

   211

        """

   212

            Lex one line of input into basic expressions:

   213

   214

                open:   [...] {

   215

                item:       [..];

   216

                close:  [] }

   217

   218

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

   219

   220

            Raises DHCPConfError.

   221

        """

   222

   223

        log.debug("%s", line)

   224

   225

        for word in split(line):

   226

            if word == '{':

   227

                yield 'open', tuple(self.token)

   228

   229

            elif word == ';':

   230

                yield 'item', tuple(self.token)

   231

   232

            elif word == '}':

   233

                if self.token:

   234

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

   235

   236

                yield 'close', None

   237

   238

            else:

   239

                self.token.append(word)

   240

                continue

   241

   242

            self.token = [ ]

   243

   244

    def parse (self, tokens):

   245

        """

   246

            Parse given tokens, yielding any complete Blocks.

   247

   248

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

   249

        """

   250

   251

        for token, args in tokens:

   252

            if token == 'open':

   253

                block = Block(args)

   254

   255

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

   256

   257

                self.stack.append(self.block)

   258

                self.block.blocks.append(block)

   259

                self.block = block

   260

   261

            # must be within block!

   262

            elif token == 'item' :

   263

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

   264

   265

                self.block.items.append(args)

   266

   267

            elif token == 'close' :

   268

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

   269

   270

                block = self.block

   271

   272

                if self.stack:

   273

                    self.block = self.stack.pop()

   274

                else:

   275

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

   276

   277

                yield block

   278

   279

            else:

   280

                raise ValueError(token, args)

   281

   282

    def parse_line (self, line):

   283

        """

   284

            Lex and parse line tokens.

   285

        """

   286

   287

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

   288

            yield block

   289

   290

    def parse_lines (self, lines) :

   291

        """

   292

            Trivial wrapper around parse to parse multiple lines.

   293

        """

   294

   295

        for line in lines:

   296

            for block in self.parse_line(line) :

   297

                yield block

   298

   299

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

   300

    """

   301

        Build a structured line.

   302

   303

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

   304

        foo;

   305

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

   306

        host foo {

   307

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

   308

            foo "bar quux";

   309

    """

   310

   311

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

   312

   313

def build_item (item, **opts):

   314

    """

   315

        Build a single parameter line.

   316

   317

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

   318

        foo;

   319

    """

   320

   321

    return build_line(item, end=';',

   322

        context     = item[:-1],

   323

        **opts

   324

    )

   325

   326

def build_block (block, indent=0):

   327

    """

   328

        Build a complete Block, recursively, yielding output lines.

   329

   330

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

   331

        # Testing

   332

        host foo {

   333

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

   334

        }

   335

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

   336

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

   337

                ])): print line

   338

        group {

   339

            next-server booter;

   340

        <BLANKLINE>

   341

            host foo {

   342

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

   343

            }

   344

        }

   345

    """

   346

   347

    if block.comment:

   348

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

   349

   350

    if block.key:

   351

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

   352

        indent += 1

   353

   354

    for item in block.items:

   355

        yield build_item(item, indent=indent)

   356

   357

    for subblock in block.blocks:

   358

        if block.items:

   359

            yield ''

   360

   361

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

   362

            yield line

   363

   364

    if block.key:

   365

        indent -= 1

   366

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