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

def quote (value, context=None):

    72

    """

    73

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

    74

    75

        >>> print quote('foo')

    76

        foo

    77

        >>> print quote('foo bar')

    78

        "foo bar"

    79

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

    80

        "foo/bar.conf"

    81

        >>> print quote(5)

    82

        5

    83

        >>> print quote('5')

    84

        5

    85

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

    86

        "foo.bar"

    87

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

    88

        foo.bar

    89

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

    90

        192.0.2.1

    91

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

    92

        00:11:22:33:44:55

    93

    """

    94

    95

    if isinstance(value, int):

    96

        return str(value)

    97

    elif context in UNQUOTED_CONTEXT:

    98

        return str(value)

    99

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

   100

        return str(value)

   101

    else:

   102

        # quoted

   103

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

   104

   105

class Block (object):

   106

    """

   107

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

   108

    """

   109

   110

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

   111

        """

   112

            key: tuple      - name of block

   113

        """

   114

   115

        self.key = key

   116

        self.items = items or [ ]

   117

        self.blocks = blocks or [ ]

   118

        self.comment = comment

   119

   120

    def __str__ (self):

   121

        return ' '.join(self.key)

   122

   123

    def __repr__ (self):

   124

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

   125

   126

class DHCPConfigParser (object):

   127

    """

   128

        Simple parser for ISC dhcpd conf files.

   129

   130

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

   131

   132

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

   133

    """

   134

   135

    @classmethod

   136

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

   137

        """

   138

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

   139

   140

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

   141

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

   142

        """

   143

   144

        if name is None:

   145

            name = file.name

   146

   147

        parser = cls(name=name)

   148

   149

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

   150

            try:

   151

                for item in parser.parse_line(line):

   152

                    log.debug("%s", item)

   153

            except DHCPConfigError as error:

   154

                error.line = lineno

   155

                raise

   156

   157

        if parser.token:

   158

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

   159

   160

        if parser.stack:

   161

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

   162

   163

        return parser.block 

   164

   165

    def __init__ (self, name=None):

   166

        self.name = name

   167

   168

        # lexer state

   169

        self.token = []

   170

   171

        # parser state

   172

        self.stack = []

   173

   174

        # top-level block

   175

        self.block = Block(None)

   176

   177

    def lex (self, line):

   178

        """

   179

            Lex one line of input into basic expressions:

   180

   181

                open:   [...] {

   182

                item:       [..];

   183

                close:  [] }

   184

   185

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

   186

   187

            Raises DHCPConfError.

   188

        """

   189

   190

        log.debug("%s", line)

   191

   192

        for word in split(line):

   193

            if word == '{':

   194

                yield 'open', tuple(self.token)

   195

   196

            elif word == ';':

   197

                yield 'item', tuple(self.token)

   198

   199

            elif word == '}':

   200

                if self.token:

   201

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

   202

   203

                yield 'close', None

   204

   205

            else:

   206

                self.token.append(word)

   207

                continue

   208

   209

            self.token = [ ]

   210

   211

    def parse (self, tokens):

   212

        """

   213

            Parse given tokens, yielding any complete Blocks.

   214

   215

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

   216

        """

   217

   218

        for token, args in tokens:

   219

            if token == 'open':

   220

                block = Block(args)

   221

   222

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

   223

   224

                self.stack.append(self.block)

   225

                self.block.blocks.append(block)

   226

                self.block = block

   227

   228

            # must be within block!

   229

            elif token == 'item' :

   230

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

   231

   232

                self.block.items.append(args)

   233

   234

            elif token == 'close' :

   235

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

   236

   237

                block = self.block

   238

   239

                if self.stack:

   240

                    self.block = self.stack.pop()

   241

                else:

   242

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

   243

   244

                yield block

   245

   246

            else:

   247

                raise ValueError(token, args)

   248

   249

    def parse_line (self, line):

   250

        """

   251

            Lex and parse line tokens.

   252

        """

   253

   254

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

   255

            yield block

   256

   257

    def parse_lines (self, lines) :

   258

        """

   259

            Trivial wrapper around parse to parse multiple lines.

   260

        """

   261

   262

        for line in lines:

   263

            for block in self.parse_line(line) :

   264

                yield block

   265

   266

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

   267

    """

   268

        Build a structured line.

   269

   270

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

   271

        foo;

   272

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

   273

        host foo {

   274

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

   275

            foo "bar quux";

   276

    """

   277

   278

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

   279

   280

def build_item (item, **opts):

   281

    """

   282

        Build a single parameter line.

   283

   284

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

   285

        foo;

   286

    """

   287

   288

    return build_line(item, end=';',

   289

        context     = item[:-1],

   290

        **opts

   291

    )

   292

   293

def build_block (block, indent=0):

   294

    """

   295

        Build a complete Block, recursively, yielding output lines.

   296

   297

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

   298

        # Testing

   299

        host foo {

   300

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

   301

        }

   302

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

   303

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

   304

                ])): print line

   305

        group {

   306

            next-server booter;

   307

        <BLANKLINE>

   308

            host foo {

   309

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

   310

            }

   311

        }

   312

    """

   313

   314

    if block.comment:

   315

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

   320

   321

    for item in block.items:

   323

   324

    for subblock in block.blocks:

   327

   329

            yield line