ud-generate

   1 #!/usr/bin/env python
   2 # -*- mode: python -*-
   3 # Generates passwd, shadow and group files from the ldap directory.
   4
   5 #   Copyright (c) 2000-2001  Jason Gunthorpe <jgg@debian.org>
   6 #   Copyright (c) 2003-2004  James Troup <troup@debian.org>
   7 #   Copyright (c) 2004-2005,7  Joey Schulze <joey@infodrom.org>
   8 #   Copyright (c) 2001-2007  Ryan Murray <rmurray@debian.org>
   9 #   Copyright (c) 2008,2009,2010,2011 Peter Palfrader <peter@palfrader.org>
  10 #   Copyright (c) 2008 Andreas Barth <aba@not.so.argh.org>
  11 #   Copyright (c) 2008 Mark Hymers <mhy@debian.org>
  12 #   Copyright (c) 2008 Luk Claes <luk@debian.org>
  13 #   Copyright (c) 2008 Thomas Viehmann <tv@beamnet.de>
  14 #   Copyright (c) 2009 Stephen Gran <steve@lobefin.net>
  15 #   Copyright (c) 2010 Helmut Grohne <helmut@subdivi.de>
  16 #
  17 #   This program is free software; you can redistribute it and/or modify
  18 #   it under the terms of the GNU General Public License as published by
  19 #   the Free Software Foundation; either version 2 of the License, or
  20 #   (at your option) any later version.
  21 #
  22 #   This program is distributed in the hope that it will be useful,
  23 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 #   GNU General Public License for more details.
  26 #
  27 #   You should have received a copy of the GNU General Public License
  28 #   along with this program; if not, write to the Free Software
  29 #   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  30
  31 from dsa_mq.connection import Connection
  32 from dsa_mq.config import Config
  33
  34 import string, re, time, ldap, optparse, sys, os, pwd, posix, socket, base64, hashlib, shutil, errno, tarfile, grp, fcntl, dbm
  35 from userdir_ldap import *
  36 from userdir_exceptions import *
  37 import UDLdap
  38 from xml.etree.ElementTree import Element, SubElement, Comment
  39 from xml.etree import ElementTree
  40 from xml.dom import minidom
  41 try:
  42    from cStringIO import StringIO
  43 except ImportError:
  44    from StringIO import StringIO
  45 try:
  46    import simplejson as json
  47 except ImportError:
  48    import json
  49    if not '__author__' in json.__dict__:
  50       sys.stderr.write("Warning: This is probably the wrong json module.  We want python 2.6's json\n")
  51       sys.stderr.write("module, or simplejson on pytyon 2.5.  Let's see if/how stuff blows up.\n")
  52
  53 if os.getuid() == 0:
  54    sys.stderr.write("You should probably not run ud-generate as root.\n")
  55    sys.exit(1)
  56
  57
  58 #
  59 # GLOBAL STATE
  60 #
  61 GroupIDMap = None
  62 SubGroupMap = None
  63
  64
  65
  66 UUID_FORMAT = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
  67 MAX_UD_AGE = 3600*24
  68
  69 EmailCheck = re.compile("^([^ <>@]+@[^ ,<>@]+)(,\s*([^ <>@]+@[^ ,<>@]+))*$")
  70 BSMTPCheck = re.compile(".*mx 0 (master)\.debian\.org\..*",re.DOTALL)
  71 PurposeHostField = re.compile(r".*\[\[([\*\-]?[a-z0-9.\-]*)(?:\|.*)?\]\]")
  72 IsDebianHost = re.compile(ConfModule.dns_hostmatch)
  73 isSSHFP = re.compile("^\s*IN\s+SSHFP")
  74 DNSZone = ".debian.net"
  75 Keyrings = ConfModule.sync_keyrings.split(":")
  76 GitoliteSSHRestrictions = getattr(ConfModule, "gitolitesshrestrictions", None)
  77 GitoliteSSHCommand = getattr(ConfModule, "gitolitesshcommand", None)
  78 GitoliteExportHosts = re.compile(getattr(ConfModule, "gitoliteexporthosts", "."))
  79 MX_remap = json.loads(ConfModule.MX_remap)
  80
  81 rtc_realm = getattr(ConfModule, "rtc_realm", None)
  82 rtc_append = getattr(ConfModule, "rtc_append", None)
  83
  84 def prettify(elem):
  85    """Return a pretty-printed XML string for the Element.
  86    """
  87    rough_string = ElementTree.tostring(elem, 'utf-8')
  88    reparsed = minidom.parseString(rough_string)
  89    return reparsed.toprettyxml(indent="  ")
  90
  91 def safe_makedirs(dir):
  92    try:
  93       os.makedirs(dir)
  94    except OSError, e:
  95       if e.errno == errno.EEXIST:
  96          pass
  97       else:
  98          raise e
  99
 100 def safe_rmtree(dir):
 101    try:
 102       shutil.rmtree(dir)
 103    except OSError, e:
 104       if e.errno == errno.ENOENT:
 105          pass
 106       else:
 107          raise e
 108
 109 def get_lock(fn, wait=5*60):
 110    f = open(fn, "w")
 111    sl = 0.1
 112    ends = time.time() + wait
 113
 114    while True:
 115       success = False
 116       try:
 117          fcntl.flock(f.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
 118          return f
 119       except IOError:
 120          pass
 121       if time.time() >= ends:
 122          return None
 123       sl = min(sl*2, 10, ends - time.time())
 124       time.sleep(sl)
 125    return None
 126
 127
 128 def Sanitize(Str):
 129    return Str.translate(string.maketrans("\n\r\t", "$$$"))
 130
 131 def DoLink(From, To, File):
 132    try:
 133       posix.remove(To + File)
 134    except:
 135       pass
 136    posix.link(From + File, To + File)
 137
 138 def IsRetired(account):
 139    """
 140    Looks for accountStatus in the LDAP record and tries to
 141    match it against one of the known retired statuses
 142    """
 143
 144    status = account['accountStatus']
 145
 146    line = status.split()
 147    status = line[0]
 148
 149    if status == "inactive":
 150       return True
 151
 152    elif status == "memorial":
 153       return True
 154
 155    elif status == "retiring":
 156       # We'll give them a few extra days over what we said
 157       age = 6 * 31 * 24 * 60 * 60
 158       try:
 159          return (time.time() - time.mktime(time.strptime(line[1], "%Y-%m-%d"))) > age
 160       except IndexError:
 161          return False
 162       except ValueError:
 163          return False
 164
 165    return False
 166
 167 # See if this user is in the group list
 168 def IsInGroup(account, allowed, current_host):
 169   # See if the primary group is in the list
 170   if str(account['gidNumber']) in allowed: return True
 171
 172   # Check the host based ACL
 173   if account.is_allowed_by_hostacl(current_host): return True
 174
 175   # See if there are supplementary groups
 176   if not 'supplementaryGid' in account: return False
 177
 178   supgroups=[]
 179   addGroups(supgroups, account['supplementaryGid'], account['uid'], current_host)
 180   for g in supgroups:
 181      if g in allowed:
 182         return True
 183   return False
 184
 185 def Die(File, F, Fdb):
 186    if F != None:
 187       F.close()
 188    if Fdb != None:
 189       Fdb.close()
 190    try:
 191       os.remove(File + ".tmp")
 192    except:
 193       pass
 194    try:
 195       os.remove(File + ".tdb.tmp")
 196    except:
 197       pass
 198
 199 def Done(File, F, Fdb):
 200    if F != None:
 201       F.close()
 202       os.rename(File + ".tmp", File)
 203    if Fdb != None:
 204       Fdb.close()
 205       os.rename(File + ".tdb.tmp", File + ".tdb")
 206
 207 # Generate the password list
 208 def GenPasswd(accounts, File, HomePrefix, PwdMarker):
 209    F = None
 210    try:
 211       F = open(File + ".tdb.tmp", "w")
 212
 213       userlist = {}
 214       i = 0
 215       for a in accounts:
 216          # Do not let people try to buffer overflow some busted passwd parser.
 217          if len(a['gecos']) > 100 or len(a['loginShell']) > 50: continue
 218
 219          userlist[a['uid']] = a['gidNumber']
 220          line = "%s:%s:%d:%d:%s:%s%s:%s" % (
 221                  a['uid'],
 222                  PwdMarker,
 223                  a['uidNumber'],
 224                  a['gidNumber'],
 225                  a['gecos'],
 226                  HomePrefix, a['uid'],
 227                  a['loginShell'])
 228          line = Sanitize(line) + "\n"
 229          F.write("0%u %s" % (i, line))
 230          F.write(".%s %s" % (a['uid'], line))
 231          F.write("=%d %s" % (a['uidNumber'], line))
 232          i = i + 1
 233
 234    # Oops, something unspeakable happened.
 235    except:
 236       Die(File, None, F)
 237       raise
 238    Done(File, None, F)
 239
 240    # Return the list of users so we know which keys to export
 241    return userlist
 242
 243 def GenAllUsers(accounts, file):
 244    f = None
 245    try:
 246       OldMask = os.umask(0022)
 247       f = open(file + ".tmp", "w", 0644)
 248       os.umask(OldMask)
 249
 250       all = []
 251       for a in accounts:
 252          all.append( { 'uid': a['uid'],
 253                        'uidNumber': a['uidNumber'],
 254                        'active': a.pw_active() and a.shadow_active() } )
 255       json.dump(all, f)
 256
 257    # Oops, something unspeakable happened.
 258    except:
 259       Die(file, f, None)
 260       raise
 261    Done(file, f, None)
 262
 263 # Generate the shadow list
 264 def GenShadow(accounts, File):
 265    F = None
 266    try:
 267       OldMask = os.umask(0077)
 268       F = open(File + ".tdb.tmp", "w", 0600)
 269       os.umask(OldMask)
 270
 271       i = 0
 272       for a in accounts:
 273          # If the account is locked, mark it as such in shadow
 274          # See Debian Bug #308229 for why we set it to 1 instead of 0
 275          if not a.pw_active():     ShadowExpire = '1'
 276          elif 'shadowExpire' in a: ShadowExpire = str(a['shadowExpire'])
 277          else:                     ShadowExpire = ''
 278
 279          values = []
 280          values.append(a['uid'])
 281          values.append(a.get_password())
 282          for key in 'shadowLastChange', 'shadowMin', 'shadowMax', 'shadowWarning', 'shadowInactive':
 283             if key in a: values.append(a[key])
 284             else:        values.append('')
 285          values.append(ShadowExpire)
 286          line = ':'.join(values)+':'
 287          line = Sanitize(line) + "\n"
 288          F.write("0%u %s" % (i, line))
 289          F.write(".%s %s" % (a['uid'], line))
 290          i = i + 1
 291
 292    # Oops, something unspeakable happened.
 293    except:
 294       Die(File, None, F)
 295       raise
 296    Done(File, None, F)
 297
 298 # Generate the sudo passwd file
 299 def GenShadowSudo(accounts, File, untrusted, current_host):
 300    F = None
 301    try:
 302       OldMask = os.umask(0077)
 303       F = open(File + ".tmp", "w", 0600)
 304       os.umask(OldMask)
 305
 306       for a in accounts:
 307          Pass = '*'
 308          if 'sudoPassword' in a:
 309             for entry in a['sudoPassword']:
 310                Match = re.compile('^('+UUID_FORMAT+') (confirmed:[0-9a-f]{40}|unconfirmed) ([a-z0-9.,*-]+) ([^ ]+)$').match(entry)
 311                if Match == None:
 312                   continue
 313                uuid = Match.group(1)
 314                status = Match.group(2)
 315                hosts = Match.group(3)
 316                cryptedpass = Match.group(4)
 317
 318                if status != 'confirmed:'+make_passwd_hmac('password-is-confirmed', 'sudo', a['uid'], uuid, hosts, cryptedpass):
 319                   continue
 320                for_all = hosts == "*"
 321                for_this_host = current_host in hosts.split(',')
 322                if not (for_all or for_this_host):
 323                   continue
 324                # ignore * passwords for untrusted hosts, but copy host specific passwords
 325                if for_all and untrusted:
 326                   continue
 327                Pass = cryptedpass
 328                if for_this_host: # this makes sure we take a per-host entry over the for-all entry
 329                   break
 330             if len(Pass) > 50:
 331                Pass = '*'
 332
 333          Line = "%s:%s" % (a['uid'], Pass)
 334          Line = Sanitize(Line) + "\n"
 335          F.write("%s" % (Line))
 336
 337    # Oops, something unspeakable happened.
 338    except:
 339       Die(File, F, None)
 340       raise
 341    Done(File, F, None)
 342
 343 # Generate the sudo passwd file
 344 def GenSSHGitolite(accounts, hosts, File, sshcommand=None, current_host=None):
 345    F = None
 346    if sshcommand is None:
 347       sshcommand = GitoliteSSHCommand
 348    try:
 349       OldMask = os.umask(0022)
 350       F = open(File + ".tmp", "w", 0600)
 351       os.umask(OldMask)
 352
 353       if not GitoliteSSHRestrictions is None and GitoliteSSHRestrictions != "":
 354          for a in accounts:
 355             if not 'sshRSAAuthKey' in a: continue
 356
 357             User = a['uid']
 358             prefix = GitoliteSSHRestrictions
 359             prefix = prefix.replace('@@COMMAND@@', sshcommand)
 360             prefix = prefix.replace('@@USER@@', User)
 361             for I in a["sshRSAAuthKey"]:
 362                if I.startswith("allowed_hosts=") and ' ' in line:
 363                   if current_host is None:
 364                      continue
 365                   machines, I = I.split('=', 1)[1].split(' ', 1)
 366                   if current_host not in machines.split(','):
 367                      continue # skip this key
 368
 369                if I.startswith('ssh-'):
 370                   line = "%s %s"%(prefix, I)
 371                else:
 372                   continue # do not allow keys with other restrictions that might conflict
 373                line = Sanitize(line) + "\n"
 374                F.write(line)
 375
 376          for dn, attrs in hosts:
 377             if not 'sshRSAHostKey' in attrs: continue
 378             hostname = "host-" + attrs['hostname'][0]
 379             prefix = GitoliteSSHRestrictions
 380             prefix = prefix.replace('@@COMMAND@@', sshcommand)
 381             prefix = prefix.replace('@@USER@@', hostname)
 382             for I in attrs["sshRSAHostKey"]:
 383                line = "%s %s"%(prefix, I)
 384                line = Sanitize(line) + "\n"
 385                F.write(line)
 386
 387    # Oops, something unspeakable happened.
 388    except:
 389       Die(File, F, None)
 390       raise
 391    Done(File, F, None)
 392
 393 # Generate the shadow list
 394 def GenSSHShadow(global_dir, accounts):
 395    # Fetch all the users
 396    userkeys = {}
 397
 398    for a in accounts:
 399       if not 'sshRSAAuthKey' in a: continue
 400
 401       contents = []
 402       for I in a['sshRSAAuthKey']:
 403          MultipleLine = "%s" % I
 404          MultipleLine = Sanitize(MultipleLine)
 405          contents.append(MultipleLine)
 406       userkeys[a['uid']] = contents
 407    return userkeys
 408
 409 # Generate the webPassword list
 410 def GenWebPassword(accounts, File):
 411    F = None
 412    try:
 413       OldMask = os.umask(0077)
 414       F = open(File, "w", 0600)
 415       os.umask(OldMask)
 416
 417       for a in accounts:
 418          if not 'webPassword' in a: continue
 419          if not a.pw_active(): continue
 420
 421          Pass = str(a['webPassword'])
 422          Line = "%s:%s" % (a['uid'], Pass)
 423          Line = Sanitize(Line) + "\n"
 424          F.write("%s" % (Line))
 425
 426    except:
 427       Die(File, None, F)
 428       raise
 429
 430 # Generate the rtcPassword list
 431 def GenRtcPassword(accounts, File):
 432    F = None
 433    try:
 434       OldMask = os.umask(0077)
 435       F = open(File, "w", 0600)
 436       os.umask(OldMask)
 437
 438       for a in accounts:
 439          if not 'rtcPassword' in a: continue
 440          if not a.pw_active(): continue
 441
 442          Line = "%s%s:%s:%s:AUTHORIZED" % (a['uid'], rtc_append, str(a['rtcPassword']), rtc_realm)
 443          Line = Sanitize(Line) + "\n"
 444          F.write("%s" % (Line))
 445
 446    except:
 447       Die(File, None, F)
 448       raise
 449
 450 def GenSSHtarballs(global_dir, userlist, ssh_userkeys, grouprevmap, target, current_host):
 451    OldMask = os.umask(0077)
 452    tf = tarfile.open(name=os.path.join(global_dir, 'ssh-keys-%s.tar.gz' % current_host), mode='w:gz')
 453    os.umask(OldMask)
 454    for f in userlist:
 455       if f not in ssh_userkeys:
 456          continue
 457       # If we're not exporting their primary group, don't export
 458       # the key and warn
 459       grname = None
 460       if userlist[f] in grouprevmap.keys():
 461          grname = grouprevmap[userlist[f]]
 462       else:
 463          try:
 464             if int(userlist[f]) <= 100:
 465                # In these cases, look it up in the normal way so we
 466                # deal with cases where, for instance, users are in group
 467                # users as their primary group.
 468                grname = grp.getgrgid(userlist[f])[0]
 469          except Exception, e:
 470             pass
 471
 472       if grname is None:
 473          print "User %s is supposed to have their key exported to host %s but their primary group (gid: %d) isn't in LDAP" % (f, current_host, userlist[f])
 474          continue
 475
 476       lines = []
 477       for line in ssh_userkeys[f]:
 478          if line.startswith("allowed_hosts=") and ' ' in line:
 479             machines, line = line.split('=', 1)[1].split(' ', 1)
 480             if current_host not in machines.split(','):
 481                continue # skip this key
 482          lines.append(line)
 483       if not lines:
 484          continue # no keys for this host
 485       contents = "\n".join(lines) + "\n"
 486
 487       to = tarfile.TarInfo(name=f)
 488       # These will only be used where the username doesn't
 489       # exist on the target system for some reason; hence,
 490       # in those cases, the safest thing is for the file to
 491       # be owned by root but group nobody.  This deals with
 492       # the bloody obscure case where the group fails to exist
 493       # whilst the user does (in which case we want to avoid
 494       # ending up with a file which is owned user:root to avoid
 495       # a fairly obvious attack vector)
 496       to.uid = 0
 497       to.gid = 65534
 498       # Using the username / groupname fields avoids any need
 499       # to give a shit^W^W^Wcare about the UIDoffset stuff.
 500       to.uname = f
 501       to.gname = grname
 502       to.mode  = 0400
 503       to.mtime = int(time.time())
 504       to.size = len(contents)
 505
 506       tf.addfile(to, StringIO(contents))
 507
 508    tf.close()
 509    os.rename(os.path.join(global_dir, 'ssh-keys-%s.tar.gz' % current_host), target)
 510
 511 # add a list of groups to existing groups,
 512 # including all subgroups thereof, recursively.
 513 # basically this proceduces the transitive hull of the groups in
 514 # addgroups.
 515 def addGroups(existingGroups, newGroups, uid, current_host):
 516    for group in newGroups:
 517       # if it's a <group>@host, split it and verify it's on the current host.
 518       s = group.split('@', 1)
 519       if len(s) == 2 and s[1] != current_host:
 520          continue
 521       group = s[0]
 522
 523       # let's see if we handled this group already
 524       if group in existingGroups:
 525          continue
 526
 527       if not GroupIDMap.has_key(group):
 528          print "Group", group, "does not exist but", uid, "is in it"
 529          continue
 530
 531       existingGroups.append(group)
 532
 533       if SubGroupMap.has_key(group):
 534          addGroups(existingGroups, SubGroupMap[group], uid, current_host)
 535
 536 # Generate the group list
 537 def GenGroup(accounts, File, current_host):
 538    grouprevmap = {}
 539    F = None
 540    try:
 541       F = open(File + ".tdb.tmp", "w")
 542
 543       # Generate the GroupMap
 544       GroupMap = {}
 545       for x in GroupIDMap:
 546          GroupMap[x] = []
 547       GroupHasPrimaryMembers = {}
 548
 549       # Sort them into a list of groups having a set of users
 550       for a in accounts:
 551          GroupHasPrimaryMembers[ a['gidNumber'] ] = True
 552          if not 'supplementaryGid' in a: continue
 553
 554          supgroups=[]
 555          addGroups(supgroups, a['supplementaryGid'], a['uid'], current_host)
 556          for g in supgroups:
 557             GroupMap[g].append(a['uid'])
 558
 559       # Output the group file.
 560       J = 0
 561       for x in GroupMap.keys():
 562          if not x in GroupIDMap:
 563             continue
 564
 565          if len(GroupMap[x]) == 0 and GroupIDMap[x] not in GroupHasPrimaryMembers:
 566             continue
 567
 568          grouprevmap[GroupIDMap[x]] = x
 569
 570          Line = "%s:x:%u:" % (x, GroupIDMap[x])
 571          Comma = ''
 572          for I in GroupMap[x]:
 573             Line = Line + ("%s%s" % (Comma, I))
 574             Comma = ','
 575          Line = Sanitize(Line) + "\n"
 576          F.write("0%u %s" % (J, Line))
 577          F.write(".%s %s" % (x, Line))
 578          F.write("=%u %s" % (GroupIDMap[x], Line))
 579          J = J + 1
 580
 581    # Oops, something unspeakable happened.
 582    except:
 583       Die(File, None, F)
 584       raise
 585    Done(File, None, F)
 586
 587    return grouprevmap
 588
 589 def CheckForward(accounts):
 590    for a in accounts:
 591       if not 'emailForward' in a: continue
 592
 593       delete = False
 594
 595       # Do not allow people to try to buffer overflow busted parsers
 596       if len(a['emailForward']) > 200: delete = True
 597       # Check the forwarding address
 598       elif EmailCheck.match(a['emailForward']) is None: delete = True
 599
 600       if delete:
 601          a.delete_mailforward()
 602
 603 # Generate the email forwarding list
 604 def GenForward(accounts, File):
 605    F = None
 606    try:
 607       OldMask = os.umask(0022)
 608       F = open(File + ".tmp", "w", 0644)
 609       os.umask(OldMask)
 610
 611       for a in accounts:
 612          if not 'emailForward' in a: continue
 613          Line = "%s: %s" % (a['uid'], a['emailForward'])
 614          Line = Sanitize(Line) + "\n"
 615          F.write(Line)
 616
 617    # Oops, something unspeakable happened.
 618    except:
 619       Die(File, F, None)
 620       raise
 621    Done(File, F, None)
 622
 623 def GenCDB(accounts, File, key):
 624    Fdb = None
 625    try:
 626       OldMask = os.umask(0022)
 627       # nothing else does the fsync stuff, so why do it here?
 628       prefix = "/usr/bin/eatmydata " if os.path.exists('/usr/bin/eatmydata') else ''
 629       Fdb = os.popen("%scdbmake %s %s.tmp"%(prefix, File, File), "w")
 630       os.umask(OldMask)
 631
 632       # Write out the email address for each user
 633       for a in accounts:
 634          if not key in a: continue
 635          value = a[key]
 636          user = a['uid']
 637          Fdb.write("+%d,%d:%s->%s\n" % (len(user), len(value), user, value))
 638
 639       Fdb.write("\n")
 640    # Oops, something unspeakable happened.
 641    except:
 642       Fdb.close()
 643       raise
 644    if Fdb.close() != None:
 645       raise "cdbmake gave an error"
 646
 647 def GenDBM(accounts, File, key):
 648    Fdb = None
 649    OldMask = os.umask(0022)
 650    fn = os.path.join(File).encode('ascii', 'ignore')
 651    try:
 652       posix.remove(fn)
 653    except:
 654       pass
 655
 656    try:
 657       Fdb = dbm.open(fn, "c")
 658       os.umask(OldMask)
 659
 660       # Write out the email address for each user
 661       for a in accounts:
 662          if not key in a: continue
 663          value = a[key]
 664          user = a['uid']
 665          Fdb[user] = value
 666
 667       Fdb.close()
 668    except:
 669       # python-dbm names the files Fdb.db.db so we want to them to be Fdb.db
 670       os.remove(File + ".db")
 671       raise
 672    # python-dbm names the files Fdb.db.db so we want to them to be Fdb.db
 673    os.rename (File + ".db", File)
 674
 675 # Generate the anon XEarth marker file
 676 def GenMarkers(accounts, File):
 677    F = None
 678    try:
 679       F = open(File + ".tmp", "w")
 680
 681       # Write out the position for each user
 682       for a in accounts:
 683          if not ('latitude' in a and 'longitude' in a): continue
 684          try:
 685             Line = "%8s %8s \"\""%(a.latitude_dec(True), a.longitude_dec(True))
 686             Line = Sanitize(Line) + "\n"
 687             F.write(Line)
 688          except:
 689             pass
 690
 691    # Oops, something unspeakable happened.
 692    except:
 693       Die(File, F, None)
 694       raise
 695    Done(File, F, None)
 696
 697 # Generate the debian-private subscription list
 698 def GenPrivate(accounts, File):
 699    F = None
 700    try:
 701       F = open(File + ".tmp", "w")
 702
 703       # Write out the position for each user
 704       for a in accounts:
 705          if not a.is_active_user(): continue
 706          if a.is_guest_account(): continue
 707          if not 'privateSub' in a: continue
 708          try:
 709             Line = "%s"%(a['privateSub'])
 710             Line = Sanitize(Line) + "\n"
 711             F.write(Line)
 712          except:
 713             pass
 714
 715    # Oops, something unspeakable happened.
 716    except:
 717       Die(File, F, None)
 718       raise
 719    Done(File, F, None)
 720
 721 # Generate a list of locked accounts
 722 def GenDisabledAccounts(accounts, File):
 723    F = None
 724    try:
 725       F = open(File + ".tmp", "w")
 726       disabled_accounts = []
 727
 728       # Fetch all the users
 729       for a in accounts:
 730          if a.pw_active(): continue
 731          Line = "%s:%s" % (a['uid'], "Account is locked")
 732          disabled_accounts.append(a)
 733          F.write(Sanitize(Line) + "\n")
 734
 735    # Oops, something unspeakable happened.
 736    except:
 737       Die(File, F, None)
 738       raise
 739    Done(File, F, None)
 740    return disabled_accounts
 741
 742 # Generate the list of local addresses that refuse all mail
 743 def GenMailDisable(accounts, File):
 744    F = None
 745    try:
 746       F = open(File + ".tmp", "w")
 747
 748       for a in accounts:
 749          if not 'mailDisableMessage' in a: continue
 750          Line = "%s: %s"%(a['uid'], a['mailDisableMessage'])
 751          Line = Sanitize(Line) + "\n"
 752          F.write(Line)
 753
 754    # Oops, something unspeakable happened.
 755    except:
 756       Die(File, F, None)
 757       raise
 758    Done(File, F, None)
 759
 760 # Generate a list of uids that should have boolean affects applied
 761 def GenMailBool(accounts, File, key):
 762    F = None
 763    try:
 764       F = open(File + ".tmp", "w")
 765
 766       for a in accounts:
 767          if not key in a: continue
 768          if not a[key] == 'TRUE': continue
 769          Line = "%s"%(a['uid'])
 770          Line = Sanitize(Line) + "\n"
 771          F.write(Line)
 772
 773    # Oops, something unspeakable happened.
 774    except:
 775       Die(File, F, None)
 776       raise
 777    Done(File, F, None)
 778
 779 # Generate a list of hosts for RBL or whitelist purposes.
 780 def GenMailList(accounts, File, key):
 781    F = None
 782    try:
 783       F = open(File + ".tmp", "w")
 784
 785       if key == "mailWhitelist": validregex = re.compile('^[-\w.]+(/[\d]+)?$')
 786       else:                      validregex = re.compile('^[-\w.]+$')
 787
 788       for a in accounts:
 789          if not key in a: continue
 790
 791          filtered = filter(lambda z: validregex.match(z), a[key])
 792          if len(filtered) == 0: continue
 793          if key == "mailRHSBL": filtered = map(lambda z: z+"/$sender_address_domain", filtered)
 794          line = a['uid'] + ': ' + ' : '.join(filtered)
 795          line = Sanitize(line) + "\n"
 796          F.write(line)
 797
 798    # Oops, something unspeakable happened.
 799    except:
 800       Die(File, F, None)
 801       raise
 802    Done(File, F, None)
 803
 804 def isRoleAccount(account):
 805    return 'debianRoleAccount' in account['objectClass']
 806
 807 # Generate the DNS Zone file
 808 def GenDNS(accounts, File):
 809    F = None
 810    try:
 811       F = open(File + ".tmp", "w")
 812
 813       # Fetch all the users
 814       RRs = {}
 815
 816       # Write out the zone file entry for each user
 817       for a in accounts:
 818          if not 'dnsZoneEntry' in a: continue
 819          if not a.is_active_user() and not isRoleAccount(a): continue
 820          if a.is_guest_account(): continue
 821
 822          try:
 823             F.write("; %s\n"%(a.email_address()))
 824             for z in a["dnsZoneEntry"]:
 825                Split = z.lower().split()
 826                if Split[1].lower() == 'in':
 827                   Line = " ".join(Split) + "\n"
 828                   F.write(Line)
 829
 830                   Host = Split[0] + DNSZone
 831                   if BSMTPCheck.match(Line) != None:
 832                      F.write("; Has BSMTP\n")
 833
 834                   # Write some identification information
 835                   if not RRs.has_key(Host):
 836                      if Split[2].lower() in ["a", "aaaa"]:
 837                         Line = "%s IN TXT \"%s\"\n"%(Split[0], a.email_address())
 838                         for y in a["keyFingerPrint"]:
 839                            Line = Line + "%s IN TXT \"PGP %s\"\n"%(Split[0], FormatPGPKey(y))
 840                            F.write(Line)
 841                         RRs[Host] = 1
 842                else:
 843                   Line = "; Err %s"%(str(Split))
 844                   F.write(Line)
 845
 846             F.write("\n")
 847          except Exception, e:
 848             F.write("; Errors:\n")
 849             for line in str(e).split("\n"):
 850                F.write("; %s\n"%(line))
 851             pass
 852
 853    # Oops, something unspeakable happened.
 854    except:
 855       Die(File, F, None)
 856       raise
 857    Done(File, F, None)
 858
 859 def is_ipv6_addr(i):
 860    try:
 861       socket.inet_pton(socket.AF_INET6, i)
 862    except socket.error:
 863       return False
 864    return True
 865
 866 def ExtractDNSInfo(x):
 867
 868    TTLprefix="\t"
 869    if 'dnsTTL' in x[1]:
 870       TTLprefix="%s\t"%(x[1]["dnsTTL"][0])
 871
 872    DNSInfo = []
 873    if x[1].has_key("ipHostNumber"):
 874       for I in x[1]["ipHostNumber"]:
 875          if is_ipv6_addr(I):
 876             DNSInfo.append("%sIN\tAAAA\t%s" % (TTLprefix, I))
 877          else:
 878             DNSInfo.append("%sIN\tA\t%s" % (TTLprefix, I))
 879
 880    Algorithm = None
 881
 882    if 'sshRSAHostKey' in x[1]:
 883       for I in x[1]["sshRSAHostKey"]:
 884          Split = I.split()
 885          if Split[0] == 'ssh-rsa':
 886             Algorithm = 1
 887          if Split[0] == 'ssh-dss':
 888             Algorithm = 2
 889          if Split[0] == 'ssh-ed25519':
 890             Algorithm = 4
 891          if Algorithm == None:
 892             continue
 893          Fingerprint = hashlib.new('sha1', base64.decodestring(Split[1])).hexdigest()
 894          DNSInfo.append("%sIN\tSSHFP\t%u 1 %s" % (TTLprefix, Algorithm, Fingerprint))
 895          Fingerprint = hashlib.new('sha256', base64.decodestring(Split[1])).hexdigest()
 896          DNSInfo.append("%sIN\tSSHFP\t%u 2 %s" % (TTLprefix, Algorithm, Fingerprint))
 897
 898    if 'architecture' in x[1]:
 899       Arch = GetAttr(x, "architecture")
 900       Mach = ""
 901       if x[1].has_key("machine"):
 902          Mach = " " + GetAttr(x, "machine")
 903       DNSInfo.append("%sIN\tHINFO\t\"%s%s\" \"%s\"" % (TTLprefix, Arch, Mach, "Debian GNU/Linux"))
 904
 905    if x[1].has_key("mXRecord"):
 906       for I in x[1]["mXRecord"]:
 907          if I in MX_remap:
 908             for e in MX_remap[I]:
 909                DNSInfo.append("%sIN\tMX\t%s" % (TTLprefix, e))
 910          else:
 911             DNSInfo.append("%sIN\tMX\t%s" % (TTLprefix, I))
 912
 913    return DNSInfo
 914
 915 # Generate the DNS records
 916 def GenZoneRecords(host_attrs, File):
 917    F = None
 918    try:
 919       F = open(File + ".tmp", "w")
 920
 921       # Fetch all the hosts
 922       for x in host_attrs:
 923          if x[1].has_key("hostname") == 0:
 924             continue
 925
 926          if IsDebianHost.match(GetAttr(x, "hostname")) is None:
 927             continue
 928
 929          DNSInfo = ExtractDNSInfo(x)
 930          start = True
 931          for Line in DNSInfo:
 932             if start == True:
 933                Line = "%s.\t%s" % (GetAttr(x, "hostname"), Line)
 934                start = False
 935             else:
 936                Line = "\t\t\t%s" % (Line)
 937
 938             F.write(Line + "\n")
 939
 940         # this would write sshfp lines for services on machines
 941         # but we can't yet, since some are cnames and we'll make
 942         # an invalid zonefile
 943         #
 944         # for i in x[1].get("purpose", []):
 945         #    m = PurposeHostField.match(i)
 946         #    if m:
 947         #       m = m.group(1)
 948         #       # we ignore [[*..]] entries
 949         #       if m.startswith('*'):
 950         #          continue
 951         #       if m.startswith('-'):
 952         #          m = m[1:]
 953         #       if m:
 954         #          if not m.endswith(HostDomain):
 955         #             continue
 956         #          if not m.endswith('.'):
 957         #             m = m + "."
 958         #          for Line in DNSInfo:
 959         #             if isSSHFP.match(Line):
 960         #                Line = "%s\t%s" % (m, Line)
 961         #                F.write(Line + "\n")
 962
 963    # Oops, something unspeakable happened.
 964    except:
 965       Die(File, F, None)
 966       raise
 967    Done(File, F, None)
 968
 969 # Generate the BSMTP file
 970 def GenBSMTP(accounts, File, HomePrefix):
 971    F = None
 972    try:
 973       F = open(File + ".tmp", "w")
 974
 975       # Write out the zone file entry for each user
 976       for a in accounts:
 977          if not 'dnsZoneEntry' in a: continue
 978          if not a.is_active_user(): continue
 979
 980          try:
 981             for z in a["dnsZoneEntry"]:
 982                Split = z.lower().split()
 983                if Split[1].lower() == 'in':
 984                   for y in range(0, len(Split)):
 985                      if Split[y] == "$":
 986                         Split[y] = "\n\t"
 987                   Line = " ".join(Split) + "\n"
 988
 989                   Host = Split[0] + DNSZone
 990                   if BSMTPCheck.match(Line) != None:
 991                       F.write("%s: user=%s group=Debian file=%s%s/bsmtp/%s\n"%(Host,
 992                                   a['uid'], HomePrefix, a['uid'], Host))
 993
 994          except:
 995             F.write("; Errors\n")
 996             pass
 997
 998    # Oops, something unspeakable happened.
 999    except:
1000       Die(File, F, None)
1001       raise
1002    Done(File, F, None)
1003
1004 def HostToIP(Host, mapped=True):
1005
1006    IPAdresses = []
1007
1008    if Host[1].has_key("ipHostNumber"):
1009       for addr in Host[1]["ipHostNumber"]:
1010          IPAdresses.append(addr)
1011          if not is_ipv6_addr(addr) and mapped == "True":
1012             IPAdresses.append("::ffff:"+addr)
1013
1014    return IPAdresses
1015
1016 # Generate the ssh known hosts file
1017 def GenSSHKnown(host_attrs, File, mode=None, lockfilename=None):
1018    F = None
1019    try:
1020       OldMask = os.umask(0022)
1021       F = open(File + ".tmp", "w", 0644)
1022       os.umask(OldMask)
1023
1024       for x in host_attrs:
1025          if x[1].has_key("hostname") == 0 or \
1026             x[1].has_key("sshRSAHostKey") == 0:
1027             continue
1028          Host = GetAttr(x, "hostname")
1029          HostNames = [ Host ]
1030          if Host.endswith(HostDomain):
1031             HostNames.append(Host[:-(len(HostDomain) + 1)])
1032
1033          # in the purpose field [[host|some other text]] (where some other text is optional)
1034          # makes a hyperlink on the web thing. we now also add these hosts to the ssh known_hosts
1035          # file.  But so that we don't have to add everything we link we can add an asterisk
1036          # and say [[*... to ignore it.  In order to be able to add stuff to ssh without
1037          # http linking it we also support [[-hostname]] entries.
1038          for i in x[1].get("purpose", []):
1039             m = PurposeHostField.match(i)
1040             if m:
1041                m = m.group(1)
1042                # we ignore [[*..]] entries
1043                if m.startswith('*'):
1044                   continue
1045                if m.startswith('-'):
1046                   m = m[1:]
1047                if m:
1048                   HostNames.append(m)
1049                   if m.endswith(HostDomain):
1050                      HostNames.append(m[:-(len(HostDomain) + 1)])
1051
1052          for I in x[1]["sshRSAHostKey"]:
1053             if mode and mode == 'authorized_keys':
1054                hosts = HostToIP(x)
1055                if 'sshdistAuthKeysHost' in x[1]:
1056                   hosts += x[1]['sshdistAuthKeysHost']
1057                clientcommand='rsync --server --sender -pr . /var/cache/userdir-ldap/hosts/%s'%(Host)
1058                clientcommand="flock -s %s -c '%s'"%(lockfilename, clientcommand)
1059                Line = 'command="%s",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,from="%s" %s' % (clientcommand, ",".join(hosts), I)
1060             else:
1061                Line = "%s %s" %(",".join(HostNames + HostToIP(x, False)), I)
1062             Line = Sanitize(Line) + "\n"
1063             F.write(Line)
1064    # Oops, something unspeakable happened.
1065    except:
1066       Die(File, F, None)
1067       raise
1068    Done(File, F, None)
1069
1070 # Generate the debianhosts file (list of all IP addresses)
1071 def GenHosts(host_attrs, File):
1072    F = None
1073    try:
1074       OldMask = os.umask(0022)
1075       F = open(File + ".tmp", "w", 0644)
1076       os.umask(OldMask)
1077
1078       seen = set()
1079
1080       for x in host_attrs:
1081
1082          if IsDebianHost.match(GetAttr(x, "hostname")) is None:
1083             continue
1084
1085          if not 'ipHostNumber' in x[1]:
1086             continue
1087
1088          addrs = x[1]["ipHostNumber"]
1089          for addr in addrs:
1090             if addr not in seen:
1091                seen.add(addr)
1092                addr = Sanitize(addr) + "\n"
1093                F.write(addr)
1094
1095    # Oops, something unspeakable happened.
1096    except:
1097       Die(File, F, None)
1098       raise
1099    Done(File, F, None)
1100
1101 def replaceTree(src, dst_basedir):
1102    bn = os.path.basename(src)
1103    dst = os.path.join(dst_basedir, bn)
1104    safe_rmtree(dst)
1105    shutil.copytree(src, dst)
1106
1107 def GenKeyrings(OutDir):
1108    for k in Keyrings:
1109       if os.path.isdir(k):
1110          replaceTree(k, OutDir)
1111       else:
1112          shutil.copy(k, OutDir)
1113
1114
1115 def get_accounts(ldap_conn):
1116    # Fetch all the users
1117    passwd_attrs = ldap_conn.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "(&(uid=*)(!(uidNumber=0))(objectClass=shadowAccount))",\
1118                    ["uid", "uidNumber", "gidNumber", "supplementaryGid",\
1119                     "gecos", "loginShell", "userPassword", "shadowLastChange",\
1120                     "shadowMin", "shadowMax", "shadowWarning", "shadowInactive",
1121                     "shadowExpire", "emailForward", "latitude", "longitude",\
1122                     "allowedHost", "sshRSAAuthKey", "dnsZoneEntry", "cn", "sn",\
1123                     "keyFingerPrint", "privateSub", "mailDisableMessage",\
1124                     "mailGreylisting", "mailCallout", "mailRBL", "mailRHSBL",\
1125                     "mailWhitelist", "sudoPassword", "objectClass", "accountStatus",\
1126                     "mailContentInspectionAction", "webPassword", "rtcPassword",\
1127                     "bATVToken"])
1128
1129    if passwd_attrs is None:
1130       raise UDEmptyList, "No Users"
1131    accounts = map(lambda x: UDLdap.Account(x[0], x[1]), passwd_attrs)
1132    accounts.sort(lambda x,y: cmp(x['uid'].lower(), y['uid'].lower()))
1133
1134    return accounts
1135
1136 def get_hosts(ldap_conn):
1137    # Fetch all the hosts
1138    HostAttrs    = ldap_conn.search_s(HostBaseDn, ldap.SCOPE_ONELEVEL, "objectClass=debianServer",\
1139                    ["hostname", "sshRSAHostKey", "purpose", "allowedGroups", "exportOptions",\
1140                     "mXRecord", "ipHostNumber", "dnsTTL", "machine", "architecture"])
1141
1142    if HostAttrs == None:
1143       raise UDEmptyList, "No Hosts"
1144
1145    HostAttrs.sort(lambda x, y: cmp((GetAttr(x, "hostname")).lower(), (GetAttr(y, "hostname")).lower()))
1146
1147    return HostAttrs
1148
1149
1150 def make_ldap_conn():
1151    # Connect to the ldap server
1152    l = connectLDAP()
1153    # for testing purposes it's sometimes useful to pass username/password
1154    # via the environment
1155    if 'UD_CREDENTIALS' in os.environ:
1156       Pass = os.environ['UD_CREDENTIALS'].split()
1157    else:
1158       F = open(PassDir + "/pass-" + pwd.getpwuid(os.getuid())[0], "r")
1159       Pass = F.readline().strip().split(" ")
1160       F.close()
1161    l.simple_bind_s("uid=" + Pass[0] + "," + BaseDn, Pass[1])
1162
1163    return l
1164
1165
1166
1167 def setup_group_maps(l):
1168    # Fetch all the groups
1169    group_id_map = {}
1170    subgroup_map = {}
1171    attrs = l.search_s(BaseDn, ldap.SCOPE_ONELEVEL, "gid=*",\
1172                      ["gid", "gidNumber", "subGroup"])
1173
1174    # Generate the subgroup_map and group_id_map
1175    for x in attrs:
1176       if x[1].has_key("accountStatus") and x[1]['accountStatus'] == "disabled":
1177          continue
1178       if x[1].has_key("gidNumber") == 0:
1179          continue
1180       group_id_map[x[1]["gid"][0]] = int(x[1]["gidNumber"][0])
1181       if x[1].has_key("subGroup") != 0:
1182          subgroup_map.setdefault(x[1]["gid"][0], []).extend(x[1]["subGroup"])
1183
1184    global SubGroupMap
1185    global GroupIDMap
1186    SubGroupMap = subgroup_map
1187    GroupIDMap = group_id_map
1188
1189 def generate_all(global_dir, ldap_conn):
1190    accounts = get_accounts(ldap_conn)
1191    host_attrs = get_hosts(ldap_conn)
1192
1193    global_dir += '/'
1194    # Generate global things
1195    accounts_disabled = GenDisabledAccounts(accounts, global_dir + "disabled-accounts")
1196
1197    accounts = filter(lambda x: not IsRetired(x), accounts)
1198
1199    CheckForward(accounts)
1200
1201    GenMailDisable(accounts, global_dir + "mail-disable")
1202    GenCDB(accounts, global_dir + "mail-forward.cdb", 'emailForward')
1203    GenDBM(accounts, global_dir + "mail-forward.db", 'emailForward')
1204    GenCDB(accounts, global_dir + "mail-contentinspectionaction.cdb", 'mailContentInspectionAction')
1205    GenDBM(accounts, global_dir + "mail-contentinspectionaction.db", 'mailContentInspectionAction')
1206    GenPrivate(accounts, global_dir + "debian-private")
1207    GenSSHKnown(host_attrs, global_dir+"authorized_keys", 'authorized_keys', global_dir+'ud-generate.lock')
1208    GenMailBool(accounts, global_dir + "mail-greylist", "mailGreylisting")
1209    GenMailBool(accounts, global_dir + "mail-callout", "mailCallout")
1210    GenMailList(accounts, global_dir + "mail-rbl", "mailRBL")
1211    GenMailList(accounts, global_dir + "mail-rhsbl", "mailRHSBL")
1212    GenMailList(accounts, global_dir + "mail-whitelist", "mailWhitelist")
1213    GenWebPassword(accounts, global_dir + "web-passwords")
1214    GenRtcPassword(accounts, global_dir + "rtc-passwords")
1215    GenKeyrings(global_dir)
1216
1217    # Compatibility.
1218    GenForward(accounts, global_dir + "forward-alias")
1219
1220    GenAllUsers(accounts, global_dir + 'all-accounts.json')
1221    accounts = filter(lambda a: not a in accounts_disabled, accounts)
1222
1223    ssh_userkeys = GenSSHShadow(global_dir, accounts)
1224    GenMarkers(accounts, global_dir + "markers")
1225    GenSSHKnown(host_attrs, global_dir + "ssh_known_hosts")
1226    GenHosts(host_attrs, global_dir + "debianhosts")
1227    GenSSHGitolite(accounts, host_attrs, global_dir + "ssh-gitolite")
1228
1229    GenDNS(accounts, global_dir + "dns-zone")
1230    GenZoneRecords(host_attrs, global_dir + "dns-sshfp")
1231
1232    setup_group_maps(ldap_conn)
1233
1234    for host in host_attrs:
1235       if not "hostname" in host[1]:
1236          continue
1237       generate_host(host, global_dir, accounts, host_attrs, ssh_userkeys)
1238
1239 def generate_host(host, global_dir, all_accounts, all_hosts, ssh_userkeys):
1240    current_host = host[1]['hostname'][0]
1241    OutDir = global_dir + current_host + '/'
1242    if not os.path.isdir(OutDir):
1243       os.mkdir(OutDir)
1244
1245    # Get the group list and convert any named groups to numerics
1246    GroupList = {}
1247    for groupname in AllowedGroupsPreload.strip().split(" "):
1248       GroupList[groupname] = True
1249    if 'allowedGroups' in host[1]:
1250       for groupname in host[1]['allowedGroups']:
1251          GroupList[groupname] = True
1252    for groupname in GroupList.keys():
1253       if groupname in GroupIDMap:
1254          GroupList[str(GroupIDMap[groupname])] = True
1255
1256    ExtraList = {}
1257    if 'exportOptions' in host[1]:
1258       for extra in host[1]['exportOptions']:
1259          ExtraList[extra.upper()] = True
1260
1261    if GroupList != {}:
1262       accounts = filter(lambda x: IsInGroup(x, GroupList, current_host), all_accounts)
1263
1264    DoLink(global_dir, OutDir, "debianhosts")
1265    DoLink(global_dir, OutDir, "ssh_known_hosts")
1266    DoLink(global_dir, OutDir, "disabled-accounts")
1267
1268    sys.stdout.flush()
1269    if 'NOPASSWD' in ExtraList:
1270       userlist = GenPasswd(accounts, OutDir + "passwd", HomePrefix, "*")
1271    else:
1272       userlist = GenPasswd(accounts, OutDir + "passwd", HomePrefix, "x")
1273    sys.stdout.flush()
1274    grouprevmap = GenGroup(accounts, OutDir + "group", current_host)
1275    GenShadowSudo(accounts, OutDir + "sudo-passwd", ('UNTRUSTED' in ExtraList) or ('NOPASSWD' in ExtraList), current_host)
1276
1277    # Now we know who we're allowing on the machine, export
1278    # the relevant ssh keys
1279    GenSSHtarballs(global_dir, userlist, ssh_userkeys, grouprevmap, os.path.join(OutDir, 'ssh-keys.tar.gz'), current_host)
1280
1281    if not 'NOPASSWD' in ExtraList:
1282       GenShadow(accounts, OutDir + "shadow")
1283
1284    # Link in global things
1285    if not 'NOMARKERS' in ExtraList:
1286       DoLink(global_dir, OutDir, "markers")
1287    DoLink(global_dir, OutDir, "mail-forward.cdb")
1288    DoLink(global_dir, OutDir, "mail-forward.db")
1289    DoLink(global_dir, OutDir, "mail-contentinspectionaction.cdb")
1290    DoLink(global_dir, OutDir, "mail-contentinspectionaction.db")
1291    DoLink(global_dir, OutDir, "mail-disable")
1292    DoLink(global_dir, OutDir, "mail-greylist")
1293    DoLink(global_dir, OutDir, "mail-callout")
1294    DoLink(global_dir, OutDir, "mail-rbl")
1295    DoLink(global_dir, OutDir, "mail-rhsbl")
1296    DoLink(global_dir, OutDir, "mail-whitelist")
1297    DoLink(global_dir, OutDir, "all-accounts.json")
1298    GenCDB(accounts, OutDir + "user-forward.cdb", 'emailForward')
1299    GenDBM(accounts, OutDir + "user-forward.db", 'emailForward')
1300    GenCDB(accounts, OutDir + "batv-tokens.cdb", 'bATVToken')
1301    GenDBM(accounts, OutDir + "batv-tokens.db", 'bATVToken')
1302    GenCDB(accounts, OutDir + "default-mail-options.cdb", 'mailDefaultOptions')
1303    GenDBM(accounts, OutDir + "default-mail-options.db", 'mailDefaultOptions')
1304
1305    # Compatibility.
1306    DoLink(global_dir, OutDir, "forward-alias")
1307
1308    if 'DNS' in ExtraList:
1309       DoLink(global_dir, OutDir, "dns-zone")
1310       DoLink(global_dir, OutDir, "dns-sshfp")
1311
1312    if 'AUTHKEYS' in ExtraList:
1313       DoLink(global_dir, OutDir, "authorized_keys")
1314
1315    if 'BSMTP' in ExtraList:
1316       GenBSMTP(accounts, OutDir + "bsmtp", HomePrefix)
1317
1318    if 'PRIVATE' in ExtraList:
1319       DoLink(global_dir, OutDir, "debian-private")
1320
1321    if 'GITOLITE' in ExtraList:
1322       DoLink(global_dir, OutDir, "ssh-gitolite")
1323    if 'exportOptions' in host[1]:
1324       for entry in host[1]['exportOptions']:
1325          v = entry.split('=',1)
1326          if v[0] != 'GITOLITE' or len(v) != 2: continue
1327          options = v[1].split(',')
1328          group = options.pop(0);
1329          gitolite_accounts = filter(lambda x: IsInGroup(x, [group], current_host), all_accounts)
1330          if not 'nohosts' in options:
1331             gitolite_hosts = filter(lambda x: GitoliteExportHosts.match(x[1]["hostname"][0]), all_hosts)
1332          else:
1333             gitolite_hosts = []
1334          command = None
1335          for opt in options:
1336             if opt.startswith('sshcmd='):
1337                command = opt.split('=',1)[1]
1338          GenSSHGitolite(gitolite_accounts, gitolite_hosts, OutDir + "ssh-gitolite-%s"%(group,), sshcommand=command, current_host=current_host)
1339
1340    if 'WEB-PASSWORDS' in ExtraList:
1341       DoLink(global_dir, OutDir, "web-passwords")
1342
1343    if 'RTC-PASSWORDS' in ExtraList:
1344       DoLink(global_dir, OutDir, "rtc-passwords")
1345
1346    if 'KEYRING' in ExtraList:
1347       for k in Keyrings:
1348          bn = os.path.basename(k)
1349          if os.path.isdir(k):
1350             src = os.path.join(global_dir, bn)
1351             replaceTree(src, OutDir)
1352          else:
1353             DoLink(global_dir, OutDir, bn)
1354    else:
1355       for k in Keyrings:
1356          try:
1357             bn = os.path.basename(k)
1358             target = os.path.join(OutDir, bn)
1359             if os.path.isdir(target):
1360                safe_rmtree(dst)
1361             else:
1362                posix.remove(target)
1363          except:
1364             pass
1365    DoLink(global_dir, OutDir, "last_update.trace")
1366
1367
1368 def getLastLDAPChangeTime(l):
1369    mods = l.search_s('cn=log',
1370          ldap.SCOPE_ONELEVEL,
1371          '(&(&(!(reqMod=activity-from*))(!(reqMod=activity-pgp*)))(|(reqType=add)(reqType=delete)(reqType=modify)(reqType=modrdn)))',
1372          ['reqEnd'])
1373
1374    last = 0
1375
1376    # Sort the list by reqEnd
1377    sorted_mods = sorted(mods, key=lambda mod: mod[1]['reqEnd'][0].split('.')[0])
1378    # Take the last element in the array
1379    last = sorted_mods[-1][1]['reqEnd'][0].split('.')[0]
1380
1381    return last
1382
1383 def getLastKeyringChangeTime():
1384    krmod = 0
1385    for k in Keyrings:
1386       mt = os.path.getmtime(k)
1387       if mt > krmod:
1388          krmod = mt
1389
1390    return int(krmod)
1391
1392 def getLastBuildTime(gdir):
1393    cache_last_ldap_mod = 0
1394    cache_last_unix_mod = 0
1395    cache_last_run = 0
1396
1397    try:
1398       fd = open(os.path.join(gdir, "last_update.trace"), "r")
1399       cache_last_mod=fd.read().split()
1400       try:
1401          cache_last_ldap_mod = cache_last_mod[0]
1402          cache_last_unix_mod = int(cache_last_mod[1])
1403          cache_last_run = int(cache_last_mod[2])
1404       except IndexError, ValueError:
1405          pass
1406       fd.close()
1407    except IOError, e:
1408       if e.errno == errno.ENOENT:
1409          pass
1410       else:
1411          raise e
1412
1413    return (cache_last_ldap_mod, cache_last_unix_mod, cache_last_run)
1414
1415 def mq_notify(options, message):
1416    options.section = 'dsa-udgenerate'
1417    options.config = '/etc/dsa/pubsub.conf'
1418
1419    config = Config(options)
1420    conf = {
1421       'rabbit_userid': config.username,
1422       'rabbit_password': config.password,
1423       'rabbit_virtual_host': config.vhost,
1424       'rabbit_hosts': ['pubsub02.debian.org', 'pubsub01.debian.org'],
1425       'use_ssl': False
1426    }
1427
1428    msg = {
1429       'message': message,
1430       'timestamp': int(time.time())
1431    }
1432    conn = None
1433    try:
1434       conn = Connection(conf=conf)
1435       conn.topic_send(config.topic,
1436             json.dumps(msg),
1437             exchange_name=config.exchange,
1438             timeout=5)
1439    finally:
1440       if conn:
1441          conn.close()
1442
1443 def ud_generate():
1444    parser = optparse.OptionParser()
1445    parser.add_option("-g", "--generatedir", dest="generatedir", metavar="DIR",
1446      help="Output directory.")
1447    parser.add_option("-f", "--force", dest="force", action="store_true",
1448      help="Force generation, even if no update to LDAP has happened.")
1449
1450    (options, args) = parser.parse_args()
1451    if len(args) > 0:
1452       parser.print_help()
1453       sys.exit(1)
1454
1455    if options.generatedir is not None:
1456       generate_dir = os.environ['UD_GENERATEDIR']
1457    elif 'UD_GENERATEDIR' in os.environ:
1458       generate_dir = os.environ['UD_GENERATEDIR']
1459    else:
1460       generate_dir = GenerateDir
1461
1462
1463    lockf = os.path.join(generate_dir, 'ud-generate.lock')
1464    lock = get_lock( lockf )
1465    if lock is None:
1466       sys.stderr.write("Could not acquire lock %s.\n"%(lockf))
1467       sys.exit(1)
1468
1469    l = make_ldap_conn()
1470
1471    time_started = int(time.time())
1472    ldap_last_mod = getLastLDAPChangeTime(l)
1473    unix_last_mod = getLastKeyringChangeTime()
1474    cache_last_ldap_mod, cache_last_unix_mod, last_run = getLastBuildTime(generate_dir)
1475
1476    need_update = (ldap_last_mod > cache_last_ldap_mod) or (unix_last_mod > cache_last_unix_mod) or (time_started - last_run > MAX_UD_AGE)
1477
1478    fd = open(os.path.join(generate_dir, "last_update.trace"), "w")
1479    if need_update or options.force:
1480       msg = 'Update forced' if options.force else 'Update needed'
1481       generate_all(generate_dir, l)
1482       mq_notify(options, msg)
1483       last_run = int(time.time())
1484    fd.write("%s\n%s\n%s\n" % (ldap_last_mod, unix_last_mod, last_run))
1485    fd.close()
1486    sys.exit(0)
1487
1488
1489 if __name__ == "__main__":
1490    if 'UD_PROFILE' in os.environ:
1491       import cProfile
1492       import pstats
1493       cProfile.run('ud_generate()', "udg_prof")
1494       p = pstats.Stats('udg_prof')
1495       ##p.sort_stats('time').print_stats()
1496       p.sort_stats('cumulative').print_stats()
1497    else:
1498       ud_generate()
1499
1500 # vim:set et:
1501 # vim:set ts=3:
1502 # vim:set shiftwidth=3: