1

#!/usr/bin/env python

     2

     3

"""

     4

    Import hosts from existing BIND or dhcpd files.

     5

"""

     6

     7

import pvl.args

     8

import pvl.dns.zone

     9

import pvl.dhcp.config

    10

import pvl.ldap.args

    11

    13

import ipaddr

    15

import optparse

    17

import re

    18

    19

__version__ = '0.1'

    20

    21

def parse_options (argv) :

    22

    """

    23

        Parse command-line arguments.

    24

    """

    25

    26

    parser = optparse.OptionParser(

    27

            prog        = argv[0],

    28

            usage       = '%prog: [options]',

    29

            version     = __version__,

    30

    31

            # module docstring

    32

            description = __doc__,

    33

    )

    34

    35

    # logging

    36

    parser.add_option_group(pvl.args.parser(parser))

    37

    parser.add_option_group(pvl.ldap.args.parser(parser))

    38

    39

    parser.add_option('-c', '--input-charset',  metavar='CHARSET',  default='utf-8', 

    40

            help="Encoding used for input files")

    41

    42

    parser.add_option('--output-charset',       metavar='CHARSET',  default='utf-8', 

    43

            help="Encoding used for output files")

    44

    45

    # input

    46

    parser.add_option('--import-zone-hosts',    metavar='FILE',     action='append',

    47

            help="Load hosts from DNS zone")

    48

    51

    52

    parser.add_option('--import-zone-comments-owner',  action='store_const',

    53

            dest='import_zone_comments', const='owner',

    54

            help="Import DNS zone comment as owner comment")

    55

    56

    parser.add_option('--import-zone-comments-host',   action='store_const',

    57

            dest='import_zone_comments', const='host',

    58

            help="Import DNS zone comment as host comment")

    59

    67

    parser.add_option('--dump-host-comments',   action='store_true',

    68

            help="Dump out info on imported host comments")

    69

    70

    # defaults

    71

    parser.add_option('--hosts-domain',         metavar='DOMAIN',

    72

            help="Default domain for hosts")

    73

    74

    parser.add_option('--zone-unused',          metavar='HOST',

    75

            help="DNS name for unallocated hosts")

    76

    77

    # output

    78

    parser.add_option('--output-hosts',         metavar='FILE',

    79

            help="Output hosts file")

    80

    81

    parser.add_option('--output-prefix',        metavar='PREFIX',

    82

            help="Select hosts by ip prefix")

    83

    84

    # defaults

    85

    parser.set_defaults(

    86

        import_zone_hosts   = [],

    87

        import_dhcp_hosts   = [],

    88

    )

    89

    90

    # parse

    91

    options, args = parser.parse_args(argv[1:])

    92

    93

    # apply

    94

    pvl.args.apply(options, argv[0])

    95

    96

    return options, args

    97

   120

def import_zone_hosts (options, file) :

   121

    """

   122

        Yield host info from zonefile records.

   123

    """

   124

   127

    for rr in pvl.dns.zone.ZoneRecord.load(file,

   131

            # generated hosts need to imported by hand...

   132

            expand_generate = False,

   133

    ) :

   136

        if options.zone_unused and rr.name == options.zone_unused :

   137

            log.debug("%s: skip %s", rr.name, rr)

   138

            continue

   139

   140

        elif rr.type in ('A', 'AAAA') :

   141

            ip, = rr.data

   142

   143

            type = { 'A': 'ip', 'AAAA': 'ip6' }[rr.type]

   144

   147

   148

            if rr.comment :

   150

   151

   152

        elif rr.type == 'CNAME' :

   160

   161

        elif rr.type == 'TXT' :

   162

            txt, = rr.data

   163

   164

            yield host, 'comment', txt

   165

   166

        else :

   168

   169

def import_dhcp_host (options, host, items) :

   170

    """

   171

        Yield host infos from a dhcp host ... { ... }

   172

    """

   173

   174

    hostname = None

   175

    ethernet = []

   176

    fixed_address = None

   177

   178

    boot_server = options.import_dhcp_boot_server

   179

    boot_filename = None

   180

   181

    for item in items :

   182

        item, args = item[0], item[1:]

   183

   184

        if item == 'hardware' :

   185

            _ethernet, ethernet = args

   186

            assert _ethernet == 'ethernet'

   187

        elif item == 'fixed-address' :

   188

            fixed_address, = args

   189

        elif item == 'option' :

   190

            option = args.pop(0)

   191

   192

            if option == 'host-name' :

   193

                hostname, = args

   194

            else :

   195

                log.warn("host %s: ignore unknown option: %s", host, option)

   196

        elif item == 'next-sever' :

   197

            boot_server, = args

   198

        elif item == 'filename' :

   199

            boot_filename, = args

   200

        else :

   201

            log.warn("host %s: ignore unknown item: %s", host, item)

   202

   203

    # determine hostname

   204

    suffix = None

   205

   206

    if '-' in host :

   207

        hostname, suffix = host.rsplit('-', 1)

   208

    else :

   209

        hostname = host

   210

   211

    if fixed_address and not re.match(r'\d+\.\d+\.\d+.\d+', fixed_address) :

   212

        hostname, domain = fixed_address.split('.', 1)

   213

   214

    if not (hostname or ethernet) :

   215

        log.warn("%s: no hostname/ethernet: %s/%s", host, hostname, ethernet)

   216

        return

   217

   218

    yield hostname, 'ethernet', ethernet

   219

    #if suffix :

   220

    #    yield hostname, ('ethernet', suffix), ethernet

   221

   222

    if boot_server and boot_filename :

   223

        yield hostname, 'boot', "{server}:{filename}".format(

   224

                server      = boot_server,

   225

                filename    = boot_filename,

   226

        )

   227

    elif boot_filename :

   228

        yield hostname, 'boot', "{filename}".format(filename=boot_filename)

   229

   230

def import_dhcp_hosts (options, blocks) :

   231

    """

   232

        Process hosts from a parsed block

   233

    """

   234

   235

    for block, items, blocks in blocks :

   236

   237

        block, args = block[0], block[1:]

   238

   239

        if block == 'group' :

   240

            log.info("group")

   241

            for info in import_dhcp_hosts(options, blocks) :

   242

                yield info

   243

        elif block == 'host' :

   244

            host, = args

   245

   246

            log.info("host: %s", host)

   247

   248

            try :

   249

                for info in import_dhcp_host(options, host, items) :

   250

                    yield info

   251

            except ValueError as error :

   252

                log.exception("%s: invalid host: %s", host, error)

   253

        else:

   254

            log.warn("ignore unknown block: %s", block)

   255

   256

def import_dhcp_conf (options, file) :

   257

    items, blocks = pvl.dhcp.config.DHCPConfigParser().load(file)

   258

   259

    for item in items :

   260

        item, args = item[0], item[1:]

   261

   262

        if item == 'include' :

   263

            include, = args

   264

            for info in import_dhcp_conf(options, pvl.args.apply_file(include)) :

   265

                yield info

   266

        else :

   267

            log.warn("ignore unknown item: %s", item)

   268

   269

    for info in import_dhcp_hosts(options, blocks) :

   270

        yield info

   271

   272

ZONE_COMMENTS = (

   273

        re.compile(r'(?P<owner>[^/]+)\s*-\s+(?P<host>.+)'),

   274

        re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)\s+[/-]\s+(?P<host>.+)'),

   275

        re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)\s+[(]\s*(?P<host>.+)[)]'),

   276

        re.compile(r'(?P<group>.+?)\s*/\s*(?P<owner>.+)'),

   277

)

   278

   279

ZONE_OWNER_MAIL = re.compile(r'(?P<owner>.*?)\s*<(?P<mail>.+?)>')

   280

   281

def process_zone_comment (options, hostname, comment) :

   282

    """

   283

        Attempt to parse a host comment field... :D

   284

   285

        Yields (field, value) bits

   286

    """

   287

   288

    for regex in ZONE_COMMENTS :

   289

        match = regex.match(comment)

   290

   291

        if match :

   292

            matches = match.groupdict()

   293

   294

            log.info("%s: matched comment: %s", hostname, comment)

   295

            break

   296

    else :

   297

        if options.import_zone_comments :

   298

            log.info("%s: default comment: %s", hostname, comment)

   299

            matches = { options.import_zone_comments: comment }

   300

        else :

   301

            log.warn("%s: unknown comment: %s", hostname, comment)

   302

            return

   303

   304

    owner = matches.pop('owner', None)

   305

   306

    if owner :

   307

        mail_match = ZONE_OWNER_MAIL.match(owner)

   308

   309

        if mail_match :

   310

            mail_matches = mail_match.groupdict()

   311

   312

            owner = mail_matches['owner']

   313

            yield 'mail', mail_matches['mail'].strip()

   314

   315

        yield 'owner', owner.strip()

   316

   317

    for field, value in matches.iteritems() :

   318

        if value :

   319

            yield field, value.strip()

   320

   321

NONE_OWNERS = set((

   322

    u'tech',

   323

    u'atk',

   324

    u'toimisto',

   325

))

   326

   327

def process_host_owner_ldap (options, host, info) :

   328

    """

   329

        Yield guesses for user from LDAP.

   330

    """

   331

   332

    if info.get('mail') :

   333

        for user in options.ldap.users.filter(

   334

                { 'mailLocalAddress': info['mail'] },

   335

                { 'uid': info['mail'] },

   336

        ) :

   337

            yield user, None

   338

   339

    if info.get('group') and info.get('owner') :

   340

        groups = options.ldap.groups.filter(cn=info['group'])

   341

   342

        for group in groups :

   343

            for user in options.ldap.users.filter({

   344

                'gidNumber': group['gidNumber'],

   345

                'cn': info['owner'],

   346

            }) :

   347

                yield user, group

   348

   349

    if info.get('owner') :

   350

            for user in options.ldap.users.filter({

   351

                'cn': info['owner'],

   352

            }) :

   353

                yield user, None

   354

   355

def process_host_owner (options, host, info) :

   356

    """

   357

        Return (owner, comment) for host based on info, or None.

   358

    """

   359

   360

    owner = info.get('owner')

   361

   362

    if owner and owner.lower() in NONE_OWNERS :

   363

        return False

   364

   365

    # from ldap?

   366

    for ldap in process_host_owner_ldap(options, host, info) :

   367

        user, group = ldap

   368

   369

        if not group :

   370

            # get group from ldap

   371

            group = options.ldap.users.group(user)

   372

   373

        return user['uid'], u"{group} / {user}".format(

   374

                user    = user.getunicode('cn'),

   375

                group   = group.getunicode('cn'),

   376

        )

   377

   378

def process_host_comments (options, host, info) :

   379

    """

   380

        Process host fields from comment.

   381

   382

        Attempts to find owner from LDAP..

   383

    """

   384

   385

    log.debug("%s: %s", host, info)

   386

   387

    owner = process_host_owner(options, host, info) 

   388

   389

    if owner is False :

   390

        # do not mark any owner

   391

        pass

   392

   393

    elif owner :

   394

        owner, comment = owner

   395

   396

        log.info("%s: %s (%s)", host, owner, comment)

   397

   398

        yield 'comment-owner', comment

   399

        yield 'owner', owner,

   400

   401

    elif 'group' in info or 'owner' in info :

   402

        log.warn("%s: unknown owner: %s", host, info)

   403

        yield 'comment-owner', "{group} / {owner}".format(

   404

                group   = info.get('group', ''),

   405

                owner   = info.get('owner', ''),

   406

        )

   407

   408

    if info.get('host') :

   409

        yield 'comment-host', info['host']

   410

   411

def process_hosts_comments (options, import_hosts) :

   412

    """

   413

        Parse out comments from host imports..

   414

    """

   415

   416

    for host, field, value in import_hosts :

   417

        if field != 'comment':

   418

            yield host, field, value

   419

            continue

   420

   421

        fields = dict(process_zone_comment(options, host, value))

   422

   423

        if options.dump_host_comments :

   424

            print u"{host:20} {comment:80} = {group:15} / {owner:20} <{mail:20}> / {hostinfo}".format(

   425

                    host        = host,

   426

                    comment     = value,

   427

                    group       = fields.get('group', ''),

   428

                    owner       = fields.get('owner', ''),

   429

                    mail        = fields.get('mail', ''),

   430

                    hostinfo    = fields.get('host', ''),

   431

            ).encode('utf-8')

   432

   433

   434

        for field, value in process_host_comments(options, host, fields) :

   435

            yield host, field, value

   436

   437

def apply_hosts_import (options) :

   438

    """

   439

        Import host infos from given files.

   440

    """

   441

   442

    for zone_file in options.import_zone_hosts:

   443

        file = pvl.args.apply_file(zone_file, 'r', options.input_charset)

   444

        for info in import_zone_hosts(options, file) :

   445

            yield info

   446

   447

    for dhcp_file in options.import_dhcp_hosts:

   448

        file = pvl.args.apply_file(dhcp_file, 'r', options.input_charset)

   449

        for info in import_dhcp_conf(options, file) :

   450

            yield info

   451

   452

def import_hosts (options) :

   453

    """

   454

        Import hosts from dns/dhcp.

   455

    """

   456

   457

    import_hosts = apply_hosts_import(options)

   458

    import_hosts = process_hosts_comments(options, import_hosts)

   459

   460

    # gather

   461

    hosts = collections.defaultdict(lambda: collections.defaultdict(list))

   462

   463

    for host, field, value in import_hosts :

   464

        hosts[host][field].append(value)

   465

   466

    return hosts.iteritems()

   467

   468

def check_hosts (options, hosts) :

   469

    by_name = dict(hosts)

   470

   471

    for host, fields in hosts :

   472

        if set(fields) == set(['alias']) :

   473

            log.warn("%s: nonexistant alias target: %s", host, ' '.join(fields['alias']))

   474

   475

def sort_export_hosts (options, hosts) :

   476

    if options.output_prefix :

   477

        prefix = ipaddr.IPNetwork(options.output_prefix)

   478

    else :

   479

        prefix = None

   480

   481

    for host, fields in hosts :

   482

        ip = fields.get('ip')

   483

   484

        # sort by IP

   485

        if ip :

   486

            sort = ip[0]

   487

        else :

   488

            # fake, to sort correctly

   489

            sort = ipaddr.IPAddress(0)

   490

   491

        # select

   492

        if prefix:

   493

            if not (ip and ip in prefix) :

   494

                continue

   495

   496

        yield sort, host, fields

   497