1

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

     2

import shlex

     3

import string

     4

     5

# simplified model of lexer chars

     7

     8

class DHCPConfigError(Exception):

     9

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

    10

        self.parser = parser

    11

    12

        self.name = parser.name

    13

        self.line = line

    14

        self.error = error

    15

    16

    def __str__ (self):

    17

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

    18

    19

def split (line) :

    20

    """

    21

        Split given line-data into raw tokens.

    22

    23

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

    24

        ['foo']

    25

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

    26

        ['foo', 'bar']

    27

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

    28

        ['foo', ';']

    29

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

    30

        ['foo']

    31

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

    32

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

    33

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

    34

        ['foo', 'asdf quux']

    35

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

    36

        []

    37

        >>> list(split(''))

    38

        []

    39

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

    40

        ['next-server', 'foo']

    41

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

    42

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

    43

    """

    44

    45

    if line is None:

    46

        raise TypeError(line)

    47

    48

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

    49

    lexer.commenters = '#'

    50

    lexer.wordchars = TOKEN

    51

    52

    while True:

    53

        item = lexer.get_token()

    54

    55

        if item is None:

    56

            break

    57

    58

        yield item

    59

    60

def quote (value):

    61

    """

    62

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

    63

    64

        >>> print quote('foo')

    65

        foo

    66

        >>> print quote('foo bar')

    67

        "foo bar"

    68

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

    69

        "foo/bar.conf"

    70

        >>> print quote(5)

    71

        5

    72

        >>> print quote('5')

    73

        "5"

    74

    """

    75

    76

    if isinstance(value, int):

    77

        return str(value)

    79

        return str(value)

    80

    else:

    81

        # quoted

    82

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

    83

    84

class Block (object):

    85

    """

    86

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

    87

    """

    88

    89

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

    90

        """

    91

            key: tuple      - name of block

    92

        """

    93

    94

        self.key = key

    95

        self.items = items or [ ]

    96

        self.blocks = blocks or [ ]

    97

        self.comment = comment

    98

    99

    def __str__ (self):

   100

        return ' '.join(self.key)

   101

   102

    def __repr__ (self):

   103

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

   104

   105

class DHCPConfigParser (object):

   106

    """

   107

        Simple parser for ISC dhcpd conf files.

   108

   109

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

   110

   111

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

   112

    """

   113

   114

    @classmethod

   115

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

   116

        """

   117

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

   118

   119

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

   120

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

   121

        """

   122

   123

        if name is None:

   124

            name = file.name

   125

   126

        parser = cls(name=name)

   127

   128

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

   129

            try:

   130

                for item in parser.parse_line(line):

   131

                    log.debug("%s", item)

   132

            except DHCPConfigError as error:

   133

                error.line = lineno

   134

                raise

   135

   136

        if parser.token:

   137

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

   138

   139

        return parser.block 

   140

   141

    def __init__ (self, name=None):

   142

        self.name = name

   143

   144

        # lexer state

   145

        self.token = []

   146

   147

        # parser state

   148

        self.stack = []

   149

   150

        # top-level block

   151

        self.block = Block(None)

   152

   153

    def lex (self, line):

   154

        """

   155

            Lex one line of input into basic expressions:

   156

   157

                open:   [...] {

   158

                item:       [..];

   159

                close:  [] }

   160

   161

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

   162

   163

            Raises DHCPConfError.

   164

        """

   165

   166

        log.debug("%s", line)

   167

   168

        for word in split(line):

   169

            if word == '{':

   170

                yield 'open', tuple(self.token)

   171

   172

            elif word == ';':

   173

                yield 'item', tuple(self.token)

   174

   175

            elif word == '}':

   176

                if self.token:

   177

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

   178

   179

                yield 'close', None

   180

   181

            else:

   182

                self.token.append(word)

   183

                continue

   184

   185

            self.token = [ ]

   186

   187

    def parse (self, tokens):

   188

        """

   189

            Parse given tokens, yielding any complete Blocks.

   190

   191

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

   192

        """

   193

   194

        for token, args in tokens:

   195

            if token == 'open':

   196

                block = Block(args)

   197

   198

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

   199

   200

                self.block.blocks.append(block)

   201

                self.block = block

   202

                self.stack.append(block)

   203

   204

            # must be within block!

   205

            elif token == 'item' :

   206

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

   207

   208

                self.block.items.append(args)

   209

   210

            elif token == 'close' :

   211

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

   212

   213

                block = self.block

   214

   215

                if self.stack:

   216

                    self.block = self.stack.pop()

   217

                else:

   218

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

   219

   220

                yield block

   221

   222

            else:

   223

                raise ValueError(token, args)

   224

   225

    def parse_line (self, line):

   226

        """

   227

            Lex and parse line tokens.

   228

        """

   229

   230

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

   231

            yield block

   232

   233

    def parse_lines (self, lines) :

   234

        """

   235

            Trivial wrapper around parse to parse multiple lines.

   236

        """

   237

   238

        for line in lines:

   239

            for block in self.parse_line(line) :

   240

                yield block

   241

   242

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

   243

    """

   244

        Build a structured line.

   245

   246

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

   247

        foo;

   248

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

   249

        host foo {

   250

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

   251

            foo "bar quux";

   252

    """

   253

   254

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

   255

   256

def build_item (item, **opts):

   257

    """

   258

        Build a single parameter line.

   259

   260

        >>> print build_item(['foo'])

   261

        foo;

   262

    """

   263

   264

    return build_line(item, end=';', **opts)

   265

   266

def build_block (block, indent=0):

   267

    """

   268

        Build a complete Block, recursively, yielding output lines.

   269

   270

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

   271

        # Testing

   272

        host foo {

   273

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

   274

        }

   275

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

   276

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

   277

                ])): print line

   278

        group {

   279

            next-server booter;

   280

        <BLANKLINE>

   281

            host foo {

   282

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

   283

            }

   284

        }

   285

    """

   286

   287

    if block.comment:

   288

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

   289

   290

    yield build_line(block.key, end=' {', indent=indent)

   291

   292

    for item in block.items:

   293

        yield build_item(item, indent=indent+1)

   294

   295

    for subblock in block.blocks:

   296

        yield ''

   297

   298

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

   299

            yield line

   300

   301

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

   302