daklib/utils.py

   1 #!/usr/bin/env python
   2 # vim:set et ts=4 sw=4:
   3
   4 """Utility functions
   5
   6 @contact: Debian FTP Master <ftpmaster@debian.org>
   7 @copyright: 2000, 2001, 2002, 2003, 2004, 2005, 2006  James Troup <james@nocrew.org>
   8 @license: GNU General Public License version 2 or later
   9 """
  10
  11 # This program is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2 of the License, or
  14 # (at your option) any later version.
  15
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program; if not, write to the Free Software
  23 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24
  25 import commands
  26 import datetime
  27 import email.Header
  28 import os
  29 import pwd
  30 import grp
  31 import select
  32 import socket
  33 import shutil
  34 import sys
  35 import tempfile
  36 import traceback
  37 import stat
  38 import apt_inst
  39 import apt_pkg
  40 import time
  41 import re
  42 import email as modemail
  43 import subprocess
  44 import ldap
  45
  46 import daklib.config as config
  47 from dbconn import DBConn, get_architecture, get_component, get_suite, \
  48                    get_override_type, Keyring, session_wrapper, \
  49                    get_active_keyring_paths, get_primary_keyring_path, \
  50                    get_suite_architectures, get_or_set_metadatakey, DBSource, \
  51                    Component, Override, OverrideType
  52 from sqlalchemy import desc
  53 from dak_exceptions import *
  54 from gpg import SignedFile
  55 from textutils import fix_maintainer
  56 from regexes import re_html_escaping, html_escaping, re_single_line_field, \
  57                     re_multi_line_field, re_srchasver, re_taint_free, \
  58                     re_gpg_uid, re_re_mark, re_whitespace_comment, re_issource, \
  59                     re_is_orig_source, re_build_dep_arch
  60
  61 from formats import parse_format, validate_changes_format
  62 from srcformats import get_format_from_string
  63 from collections import defaultdict
  64
  65 ################################################################################
  66
  67 default_config = "/etc/dak/dak.conf"     #: default dak config, defines host properties
  68 default_apt_config = "/etc/dak/apt.conf" #: default apt config, not normally used
  69
  70 alias_cache = None        #: Cache for email alias checks
  71 key_uid_email_cache = {}  #: Cache for email addresses from gpg key uids
  72
  73 # (hashname, function, earliest_changes_version)
  74 known_hashes = [("sha1", apt_pkg.sha1sum, (1, 8)),
  75                 ("sha256", apt_pkg.sha256sum, (1, 8))] #: hashes we accept for entries in .changes/.dsc
  76
  77 # Monkeypatch commands.getstatusoutput as it may not return the correct exit
  78 # code in lenny's Python. This also affects commands.getoutput and
  79 # commands.getstatus.
  80 def dak_getstatusoutput(cmd):
  81     pipe = subprocess.Popen(cmd, shell=True, universal_newlines=True,
  82         stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
  83
  84     output = pipe.stdout.read()
  85
  86     pipe.wait()
  87
  88     if output[-1:] == '\n':
  89         output = output[:-1]
  90
  91     ret = pipe.wait()
  92     if ret is None:
  93         ret = 0
  94
  95     return ret, output
  96 commands.getstatusoutput = dak_getstatusoutput
  97
  98 ################################################################################
  99
 100 def html_escape(s):
 101     """ Escape html chars """
 102     return re_html_escaping.sub(lambda x: html_escaping.get(x.group(0)), s)
 103
 104 ################################################################################
 105
 106 def open_file(filename, mode='r'):
 107     """
 108     Open C{file}, return fileobject.
 109
 110     @type filename: string
 111     @param filename: path/filename to open
 112
 113     @type mode: string
 114     @param mode: open mode
 115
 116     @rtype: fileobject
 117     @return: open fileobject
 118
 119     @raise CantOpenError: If IOError is raised by open, reraise it as CantOpenError.
 120
 121     """
 122     try:
 123         f = open(filename, mode)
 124     except IOError:
 125         raise CantOpenError(filename)
 126     return f
 127
 128 ################################################################################
 129
 130 def our_raw_input(prompt=""):
 131     if prompt:
 132         while 1:
 133             try:
 134                 sys.stdout.write(prompt)
 135                 break
 136             except IOError:
 137                 pass
 138     sys.stdout.flush()
 139     try:
 140         ret = raw_input()
 141         return ret
 142     except EOFError:
 143         sys.stderr.write("\nUser interrupt (^D).\n")
 144         raise SystemExit
 145
 146 ################################################################################
 147
 148 def extract_component_from_section(section, session=None):
 149     component = ""
 150
 151     if section.find('/') != -1:
 152         component = section.split('/')[0]
 153
 154     # Expand default component
 155     if component == "":
 156         comp = get_component(section, session)
 157         if comp is None:
 158             component = "main"
 159         else:
 160             component = comp.component_name
 161
 162     return (section, component)
 163
 164 ################################################################################
 165
 166 def parse_deb822(armored_contents, signing_rules=0, keyrings=None, session=None):
 167     require_signature = True
 168     if keyrings == None:
 169         keyrings = []
 170         require_signature = False
 171
 172     signed_file = SignedFile(armored_contents, keyrings=keyrings, require_signature=require_signature)
 173     contents = signed_file.contents
 174
 175     error = ""
 176     changes = {}
 177
 178     # Split the lines in the input, keeping the linebreaks.
 179     lines = contents.splitlines(True)
 180
 181     if len(lines) == 0:
 182         raise ParseChangesError("[Empty changes file]")
 183
 184     # Reindex by line number so we can easily verify the format of
 185     # .dsc files...
 186     index = 0
 187     indexed_lines = {}
 188     for line in lines:
 189         index += 1
 190         indexed_lines[index] = line[:-1]
 191
 192     num_of_lines = len(indexed_lines.keys())
 193     index = 0
 194     first = -1
 195     while index < num_of_lines:
 196         index += 1
 197         line = indexed_lines[index]
 198         if line == "" and signing_rules == 1:
 199             if index != num_of_lines:
 200                 raise InvalidDscError(index)
 201             break
 202         slf = re_single_line_field.match(line)
 203         if slf:
 204             field = slf.groups()[0].lower()
 205             changes[field] = slf.groups()[1]
 206             first = 1
 207             continue
 208         if line == " .":
 209             changes[field] += '\n'
 210             continue
 211         mlf = re_multi_line_field.match(line)
 212         if mlf:
 213             if first == -1:
 214                 raise ParseChangesError("'%s'\n [Multi-line field continuing on from nothing?]" % (line))
 215             if first == 1 and changes[field] != "":
 216                 changes[field] += '\n'
 217             first = 0
 218             changes[field] += mlf.groups()[0] + '\n'
 219             continue
 220         error += line
 221
 222     changes["filecontents"] = armored_contents
 223
 224     if changes.has_key("source"):
 225         # Strip the source version in brackets from the source field,
 226         # put it in the "source-version" field instead.
 227         srcver = re_srchasver.search(changes["source"])
 228         if srcver:
 229             changes["source"] = srcver.group(1)
 230             changes["source-version"] = srcver.group(2)
 231
 232     if error:
 233         raise ParseChangesError(error)
 234
 235     return changes
 236
 237 ################################################################################
 238
 239 def parse_changes(filename, signing_rules=0, dsc_file=0, keyrings=None):
 240     """
 241     Parses a changes file and returns a dictionary where each field is a
 242     key.  The mandatory first argument is the filename of the .changes
 243     file.
 244
 245     signing_rules is an optional argument:
 246
 247       - If signing_rules == -1, no signature is required.
 248       - If signing_rules == 0 (the default), a signature is required.
 249       - If signing_rules == 1, it turns on the same strict format checking
 250         as dpkg-source.
 251
 252     The rules for (signing_rules == 1)-mode are:
 253
 254       - The PGP header consists of "-----BEGIN PGP SIGNED MESSAGE-----"
 255         followed by any PGP header data and must end with a blank line.
 256
 257       - The data section must end with a blank line and must be followed by
 258         "-----BEGIN PGP SIGNATURE-----".
 259     """
 260
 261     changes_in = open_file(filename)
 262     content = changes_in.read()
 263     changes_in.close()
 264     try:
 265         unicode(content, 'utf-8')
 266     except UnicodeError:
 267         raise ChangesUnicodeError("Changes file not proper utf-8")
 268     changes = parse_deb822(content, signing_rules, keyrings=keyrings)
 269
 270
 271     if not dsc_file:
 272         # Finally ensure that everything needed for .changes is there
 273         must_keywords = ('Format', 'Date', 'Source', 'Binary', 'Architecture', 'Version',
 274                          'Distribution', 'Maintainer', 'Description', 'Changes', 'Files')
 275
 276         missingfields=[]
 277         for keyword in must_keywords:
 278             if not changes.has_key(keyword.lower()):
 279                 missingfields.append(keyword)
 280
 281                 if len(missingfields):
 282                     raise ParseChangesError("Missing mandantory field(s) in changes file (policy 5.5): %s" % (missingfields))
 283
 284     return changes
 285
 286 ################################################################################
 287
 288 def hash_key(hashname):
 289     return '%ssum' % hashname
 290
 291 ################################################################################
 292
 293 def create_hash(where, files, hashname, hashfunc):
 294     """
 295     create_hash extends the passed files dict with the given hash by
 296     iterating over all files on disk and passing them to the hashing
 297     function given.
 298     """
 299
 300     rejmsg = []
 301     for f in files.keys():
 302         try:
 303             file_handle = open_file(f)
 304         except CantOpenError:
 305             rejmsg.append("Could not open file %s for checksumming" % (f))
 306             continue
 307
 308         files[f][hash_key(hashname)] = hashfunc(file_handle)
 309
 310         file_handle.close()
 311     return rejmsg
 312
 313 ################################################################################
 314
 315 def check_hash(where, files, hashname, hashfunc):
 316     """
 317     check_hash checks the given hash in the files dict against the actual
 318     files on disk.  The hash values need to be present consistently in
 319     all file entries.  It does not modify its input in any way.
 320     """
 321
 322     rejmsg = []
 323     for f in files.keys():
 324         file_handle = None
 325         try:
 326             try:
 327                 file_handle = open_file(f)
 328
 329                 # Check for the hash entry, to not trigger a KeyError.
 330                 if not files[f].has_key(hash_key(hashname)):
 331                     rejmsg.append("%s: misses %s checksum in %s" % (f, hashname,
 332                         where))
 333                     continue
 334
 335                 # Actually check the hash for correctness.
 336                 if hashfunc(file_handle) != files[f][hash_key(hashname)]:
 337                     rejmsg.append("%s: %s check failed in %s" % (f, hashname,
 338                         where))
 339             except CantOpenError:
 340                 # TODO: This happens when the file is in the pool.
 341                 # warn("Cannot open file %s" % f)
 342                 continue
 343         finally:
 344             if file_handle:
 345                 file_handle.close()
 346     return rejmsg
 347
 348 ################################################################################
 349
 350 def check_size(where, files):
 351     """
 352     check_size checks the file sizes in the passed files dict against the
 353     files on disk.
 354     """
 355
 356     rejmsg = []
 357     for f in files.keys():
 358         try:
 359             entry = os.stat(f)
 360         except OSError as exc:
 361             if exc.errno == 2:
 362                 # TODO: This happens when the file is in the pool.
 363                 continue
 364             raise
 365
 366         actual_size = entry[stat.ST_SIZE]
 367         size = int(files[f]["size"])
 368         if size != actual_size:
 369             rejmsg.append("%s: actual file size (%s) does not match size (%s) in %s"
 370                    % (f, actual_size, size, where))
 371     return rejmsg
 372
 373 ################################################################################
 374
 375 def check_dsc_files(dsc_filename, dsc, dsc_files):
 376     """
 377     Verify that the files listed in the Files field of the .dsc are
 378     those expected given the announced Format.
 379
 380     @type dsc_filename: string
 381     @param dsc_filename: path of .dsc file
 382
 383     @type dsc: dict
 384     @param dsc: the content of the .dsc parsed by C{parse_changes()}
 385
 386     @type dsc_files: dict
 387     @param dsc_files: the file list returned by C{build_file_list()}
 388
 389     @rtype: list
 390     @return: all errors detected
 391     """
 392     rejmsg = []
 393
 394     # Ensure .dsc lists proper set of source files according to the format
 395     # announced
 396     has = defaultdict(lambda: 0)
 397
 398     ftype_lookup = (
 399         (r'orig.tar.gz',               ('orig_tar_gz', 'orig_tar')),
 400         (r'diff.gz',                   ('debian_diff',)),
 401         (r'tar.gz',                    ('native_tar_gz', 'native_tar')),
 402         (r'debian\.tar\.(gz|bz2|xz)',  ('debian_tar',)),
 403         (r'orig\.tar\.(gz|bz2|xz)',    ('orig_tar',)),
 404         (r'tar\.(gz|bz2|xz)',          ('native_tar',)),
 405         (r'orig-.+\.tar\.(gz|bz2|xz)', ('more_orig_tar',)),
 406     )
 407
 408     for f in dsc_files:
 409         m = re_issource.match(f)
 410         if not m:
 411             rejmsg.append("%s: %s in Files field not recognised as source."
 412                           % (dsc_filename, f))
 413             continue
 414
 415         # Populate 'has' dictionary by resolving keys in lookup table
 416         matched = False
 417         for regex, keys in ftype_lookup:
 418             if re.match(regex, m.group(3)):
 419                 matched = True
 420                 for key in keys:
 421                     has[key] += 1
 422                 break
 423
 424         # File does not match anything in lookup table; reject
 425         if not matched:
 426             reject("%s: unexpected source file '%s'" % (dsc_filename, f))
 427
 428     # Check for multiple files
 429     for file_type in ('orig_tar', 'native_tar', 'debian_tar', 'debian_diff'):
 430         if has[file_type] > 1:
 431             rejmsg.append("%s: lists multiple %s" % (dsc_filename, file_type))
 432
 433     # Source format specific tests
 434     try:
 435         format = get_format_from_string(dsc['format'])
 436         rejmsg.extend([
 437             '%s: %s' % (dsc_filename, x) for x in format.reject_msgs(has)
 438         ])
 439
 440     except UnknownFormatError:
 441         # Not an error here for now
 442         pass
 443
 444     return rejmsg
 445
 446 ################################################################################
 447
 448 def check_hash_fields(what, manifest):
 449     """
 450     check_hash_fields ensures that there are no checksum fields in the
 451     given dict that we do not know about.
 452     """
 453
 454     rejmsg = []
 455     hashes = map(lambda x: x[0], known_hashes)
 456     for field in manifest:
 457         if field.startswith("checksums-"):
 458             hashname = field.split("-",1)[1]
 459             if hashname not in hashes:
 460                 rejmsg.append("Unsupported checksum field for %s "\
 461                     "in %s" % (hashname, what))
 462     return rejmsg
 463
 464 ################################################################################
 465
 466 def _ensure_changes_hash(changes, format, version, files, hashname, hashfunc):
 467     if format >= version:
 468         # The version should contain the specified hash.
 469         func = check_hash
 470
 471         # Import hashes from the changes
 472         rejmsg = parse_checksums(".changes", files, changes, hashname)
 473         if len(rejmsg) > 0:
 474             return rejmsg
 475     else:
 476         # We need to calculate the hash because it can't possibly
 477         # be in the file.
 478         func = create_hash
 479     return func(".changes", files, hashname, hashfunc)
 480
 481 # We could add the orig which might be in the pool to the files dict to
 482 # access the checksums easily.
 483
 484 def _ensure_dsc_hash(dsc, dsc_files, hashname, hashfunc):
 485     """
 486     ensure_dsc_hashes' task is to ensure that each and every *present* hash
 487     in the dsc is correct, i.e. identical to the changes file and if necessary
 488     the pool.  The latter task is delegated to check_hash.
 489     """
 490
 491     rejmsg = []
 492     if not dsc.has_key('Checksums-%s' % (hashname,)):
 493         return rejmsg
 494     # Import hashes from the dsc
 495     parse_checksums(".dsc", dsc_files, dsc, hashname)
 496     # And check it...
 497     rejmsg.extend(check_hash(".dsc", dsc_files, hashname, hashfunc))
 498     return rejmsg
 499
 500 ################################################################################
 501
 502 def parse_checksums(where, files, manifest, hashname):
 503     rejmsg = []
 504     field = 'checksums-%s' % hashname
 505     if not field in manifest:
 506         return rejmsg
 507     for line in manifest[field].split('\n'):
 508         if not line:
 509             break
 510         clist = line.strip().split(' ')
 511         if len(clist) == 3:
 512             checksum, size, checkfile = clist
 513         else:
 514             rejmsg.append("Cannot parse checksum line [%s]" % (line))
 515             continue
 516         if not files.has_key(checkfile):
 517         # TODO: check for the file's entry in the original files dict, not
 518         # the one modified by (auto)byhand and other weird stuff
 519         #    rejmsg.append("%s: not present in files but in checksums-%s in %s" %
 520         #        (file, hashname, where))
 521             continue
 522         if not files[checkfile]["size"] == size:
 523             rejmsg.append("%s: size differs for files and checksums-%s entry "\
 524                 "in %s" % (checkfile, hashname, where))
 525             continue
 526         files[checkfile][hash_key(hashname)] = checksum
 527     for f in files.keys():
 528         if not files[f].has_key(hash_key(hashname)):
 529             rejmsg.append("%s: no entry in checksums-%s in %s" % (f, hashname, where))
 530     return rejmsg
 531
 532 ################################################################################
 533
 534 # Dropped support for 1.4 and ``buggy dchanges 3.4'' (?!) compared to di.pl
 535
 536 def build_file_list(changes, is_a_dsc=0, field="files", hashname="md5sum"):
 537     files = {}
 538
 539     # Make sure we have a Files: field to parse...
 540     if not changes.has_key(field):
 541         raise NoFilesFieldError
 542
 543     # Validate .changes Format: field
 544     if not is_a_dsc:
 545         validate_changes_format(parse_format(changes['format']), field)
 546
 547     includes_section = (not is_a_dsc) and field == "files"
 548
 549     # Parse each entry/line:
 550     for i in changes[field].split('\n'):
 551         if not i:
 552             break
 553         s = i.split()
 554         section = priority = ""
 555         try:
 556             if includes_section:
 557                 (md5, size, section, priority, name) = s
 558             else:
 559                 (md5, size, name) = s
 560         except ValueError:
 561             raise ParseChangesError(i)
 562
 563         if section == "":
 564             section = "-"
 565         if priority == "":
 566             priority = "-"
 567
 568         (section, component) = extract_component_from_section(section)
 569
 570         files[name] = dict(size=size, section=section,
 571                            priority=priority, component=component)
 572         files[name][hashname] = md5
 573
 574     return files
 575
 576 ################################################################################
 577
 578 # see http://bugs.debian.org/619131
 579 def build_package_list(dsc, session = None):
 580     if not dsc.has_key("package-list"):
 581         return {}
 582
 583     packages = {}
 584
 585     for line in dsc["package-list"].split("\n"):
 586         if not line:
 587             break
 588
 589         fields = line.split()
 590         name = fields[0]
 591         package_type = fields[1]
 592         (section, component) = extract_component_from_section(fields[2])
 593         priority = fields[3]
 594
 595         # Validate type if we have a session
 596         if session and get_override_type(package_type, session) is None:
 597             # Maybe just warn and ignore? exit(1) might be a bit hard...
 598             utils.fubar("invalid type (%s) in Package-List." % (package_type))
 599
 600         if name not in packages or packages[name]["type"] == "dsc":
 601             packages[name] = dict(priority=priority, section=section, type=package_type, component=component, files=[])
 602
 603     return packages
 604
 605 ################################################################################
 606
 607 def send_mail (message, filename="", whitelists=None):
 608     """sendmail wrapper, takes _either_ a message string or a file as arguments
 609
 610     @type  whitelists: list of (str or None)
 611     @param whitelists: path to whitelists. C{None} or an empty list whitelists
 612                        everything, otherwise an address is whitelisted if it is
 613                        included in any of the lists.
 614                        In addition a global whitelist can be specified in
 615                        Dinstall::MailWhiteList.
 616     """
 617
 618     maildir = Cnf.get('Dir::Mail')
 619     if maildir:
 620         path = os.path.join(maildir, datetime.datetime.now().isoformat())
 621         path = find_next_free(path)
 622         fh = open(path, 'w')
 623         print >>fh, message,
 624         fh.close()
 625
 626     # Check whether we're supposed to be sending mail
 627     if Cnf.has_key("Dinstall::Options::No-Mail") and Cnf["Dinstall::Options::No-Mail"]:
 628         return
 629
 630     # If we've been passed a string dump it into a temporary file
 631     if message:
 632         (fd, filename) = tempfile.mkstemp()
 633         os.write (fd, message)
 634         os.close (fd)
 635
 636     if whitelists is None or None in whitelists:
 637         whitelists = []
 638     if Cnf.get('Dinstall::MailWhiteList', ''):
 639         whitelists.append(Cnf['Dinstall::MailWhiteList'])
 640     if len(whitelists) != 0:
 641         message_in = open_file(filename)
 642         message_raw = modemail.message_from_file(message_in)
 643         message_in.close();
 644
 645         whitelist = [];
 646         for path in whitelists:
 647           with open_file(path, 'r') as whitelist_in:
 648             for line in whitelist_in:
 649                 if not re_whitespace_comment.match(line):
 650                     if re_re_mark.match(line):
 651                         whitelist.append(re.compile(re_re_mark.sub("", line.strip(), 1)))
 652                     else:
 653                         whitelist.append(re.compile(re.escape(line.strip())))
 654
 655         # Fields to check.
 656         fields = ["To", "Bcc", "Cc"]
 657         for field in fields:
 658             # Check each field
 659             value = message_raw.get(field, None)
 660             if value != None:
 661                 match = [];
 662                 for item in value.split(","):
 663                     (rfc822_maint, rfc2047_maint, name, email) = fix_maintainer(item.strip())
 664                     mail_whitelisted = 0
 665                     for wr in whitelist:
 666                         if wr.match(email):
 667                             mail_whitelisted = 1
 668                             break
 669                     if not mail_whitelisted:
 670                         print "Skipping {0} since it's not whitelisted".format(item)
 671                         continue
 672                     match.append(item)
 673
 674                 # Doesn't have any mail in whitelist so remove the header
 675                 if len(match) == 0:
 676                     del message_raw[field]
 677                 else:
 678                     message_raw.replace_header(field, ', '.join(match))
 679
 680         # Change message fields in order if we don't have a To header
 681         if not message_raw.has_key("To"):
 682             fields.reverse()
 683             for field in fields:
 684                 if message_raw.has_key(field):
 685                     message_raw[fields[-1]] = message_raw[field]
 686                     del message_raw[field]
 687                     break
 688             else:
 689                 # Clean up any temporary files
 690                 # and return, as we removed all recipients.
 691                 if message:
 692                     os.unlink (filename);
 693                 return;
 694
 695         fd = os.open(filename, os.O_RDWR|os.O_EXCL, 0o700);
 696         os.write (fd, message_raw.as_string(True));
 697         os.close (fd);
 698
 699     # Invoke sendmail
 700     (result, output) = commands.getstatusoutput("%s < %s" % (Cnf["Dinstall::SendmailCommand"], filename))
 701     if (result != 0):
 702         raise SendmailFailedError(output)
 703
 704     # Clean up any temporary files
 705     if message:
 706         os.unlink (filename)
 707
 708 ################################################################################
 709
 710 def poolify (source, component=None):
 711     if source[:3] == "lib":
 712         return source[:4] + '/' + source + '/'
 713     else:
 714         return source[:1] + '/' + source + '/'
 715
 716 ################################################################################
 717
 718 def move (src, dest, overwrite = 0, perms = 0o664):
 719     if os.path.exists(dest) and os.path.isdir(dest):
 720         dest_dir = dest
 721     else:
 722         dest_dir = os.path.dirname(dest)
 723     if not os.path.exists(dest_dir):
 724         umask = os.umask(00000)
 725         os.makedirs(dest_dir, 0o2775)
 726         os.umask(umask)
 727     #print "Moving %s to %s..." % (src, dest)
 728     if os.path.exists(dest) and os.path.isdir(dest):
 729         dest += '/' + os.path.basename(src)
 730     # Don't overwrite unless forced to
 731     if os.path.exists(dest):
 732         if not overwrite:
 733             fubar("Can't move %s to %s - file already exists." % (src, dest))
 734         else:
 735             if not os.access(dest, os.W_OK):
 736                 fubar("Can't move %s to %s - can't write to existing file." % (src, dest))
 737     shutil.copy2(src, dest)
 738     os.chmod(dest, perms)
 739     os.unlink(src)
 740
 741 def copy (src, dest, overwrite = 0, perms = 0o664):
 742     if os.path.exists(dest) and os.path.isdir(dest):
 743         dest_dir = dest
 744     else:
 745         dest_dir = os.path.dirname(dest)
 746     if not os.path.exists(dest_dir):
 747         umask = os.umask(00000)
 748         os.makedirs(dest_dir, 0o2775)
 749         os.umask(umask)
 750     #print "Copying %s to %s..." % (src, dest)
 751     if os.path.exists(dest) and os.path.isdir(dest):
 752         dest += '/' + os.path.basename(src)
 753     # Don't overwrite unless forced to
 754     if os.path.exists(dest):
 755         if not overwrite:
 756             raise FileExistsError
 757         else:
 758             if not os.access(dest, os.W_OK):
 759                 raise CantOverwriteError
 760     shutil.copy2(src, dest)
 761     os.chmod(dest, perms)
 762
 763 ################################################################################
 764
 765 def where_am_i ():
 766     res = socket.getfqdn()
 767     database_hostname = Cnf.get("Config::" + res + "::DatabaseHostname")
 768     if database_hostname:
 769         return database_hostname
 770     else:
 771         return res
 772
 773 def which_conf_file ():
 774     if os.getenv('DAK_CONFIG'):
 775         return os.getenv('DAK_CONFIG')
 776
 777     res = socket.getfqdn()
 778     # In case we allow local config files per user, try if one exists
 779     if Cnf.find_b("Config::" + res + "::AllowLocalConfig"):
 780         homedir = os.getenv("HOME")
 781         confpath = os.path.join(homedir, "/etc/dak.conf")
 782         if os.path.exists(confpath):
 783             apt_pkg.ReadConfigFileISC(Cnf,confpath)
 784
 785     # We are still in here, so there is no local config file or we do
 786     # not allow local files. Do the normal stuff.
 787     if Cnf.get("Config::" + res + "::DakConfig"):
 788         return Cnf["Config::" + res + "::DakConfig"]
 789
 790     return default_config
 791
 792 def which_alias_file():
 793     hostname = socket.getfqdn()
 794     aliasfn = '/var/lib/misc/'+hostname+'/forward-alias'
 795     if os.path.exists(aliasfn):
 796         return aliasfn
 797     else:
 798         return None
 799
 800 ################################################################################
 801
 802 def TemplateSubst(subst_map, filename):
 803     """ Perform a substition of template """
 804     templatefile = open_file(filename)
 805     template = templatefile.read()
 806     for k, v in subst_map.iteritems():
 807         template = template.replace(k, str(v))
 808     templatefile.close()
 809     return template
 810
 811 ################################################################################
 812
 813 def fubar(msg, exit_code=1):
 814     sys.stderr.write("E: %s\n" % (msg))
 815     sys.exit(exit_code)
 816
 817 def warn(msg):
 818     sys.stderr.write("W: %s\n" % (msg))
 819
 820 ################################################################################
 821
 822 # Returns the user name with a laughable attempt at rfc822 conformancy
 823 # (read: removing stray periods).
 824 def whoami ():
 825     return pwd.getpwuid(os.getuid())[4].split(',')[0].replace('.', '')
 826
 827 def getusername ():
 828     return pwd.getpwuid(os.getuid())[0]
 829
 830 ################################################################################
 831
 832 def size_type (c):
 833     t  = " B"
 834     if c > 10240:
 835         c = c / 1024
 836         t = " KB"
 837     if c > 10240:
 838         c = c / 1024
 839         t = " MB"
 840     return ("%d%s" % (c, t))
 841
 842 ################################################################################
 843
 844 def cc_fix_changes (changes):
 845     o = changes.get("architecture", "")
 846     if o:
 847         del changes["architecture"]
 848     changes["architecture"] = {}
 849     for j in o.split():
 850         changes["architecture"][j] = 1
 851
 852 def changes_compare (a, b):
 853     """ Sort by source name, source version, 'have source', and then by filename """
 854     try:
 855         a_changes = parse_changes(a)
 856     except:
 857         return -1
 858
 859     try:
 860         b_changes = parse_changes(b)
 861     except:
 862         return 1
 863
 864     cc_fix_changes (a_changes)
 865     cc_fix_changes (b_changes)
 866
 867     # Sort by source name
 868     a_source = a_changes.get("source")
 869     b_source = b_changes.get("source")
 870     q = cmp (a_source, b_source)
 871     if q:
 872         return q
 873
 874     # Sort by source version
 875     a_version = a_changes.get("version", "0")
 876     b_version = b_changes.get("version", "0")
 877     q = apt_pkg.version_compare(a_version, b_version)
 878     if q:
 879         return q
 880
 881     # Sort by 'have source'
 882     a_has_source = a_changes["architecture"].get("source")
 883     b_has_source = b_changes["architecture"].get("source")
 884     if a_has_source and not b_has_source:
 885         return -1
 886     elif b_has_source and not a_has_source:
 887         return 1
 888
 889     # Fall back to sort by filename
 890     return cmp(a, b)
 891
 892 ################################################################################
 893
 894 def find_next_free (dest, too_many=100):
 895     extra = 0
 896     orig_dest = dest
 897     while os.path.exists(dest) and extra < too_many:
 898         dest = orig_dest + '.' + repr(extra)
 899         extra += 1
 900     if extra >= too_many:
 901         raise NoFreeFilenameError
 902     return dest
 903
 904 ################################################################################
 905
 906 def result_join (original, sep = '\t'):
 907     resultlist = []
 908     for i in xrange(len(original)):
 909         if original[i] == None:
 910             resultlist.append("")
 911         else:
 912             resultlist.append(original[i])
 913     return sep.join(resultlist)
 914
 915 ################################################################################
 916
 917 def prefix_multi_line_string(str, prefix, include_blank_lines=0):
 918     out = ""
 919     for line in str.split('\n'):
 920         line = line.strip()
 921         if line or include_blank_lines:
 922             out += "%s%s\n" % (prefix, line)
 923     # Strip trailing new line
 924     if out:
 925         out = out[:-1]
 926     return out
 927
 928 ################################################################################
 929
 930 def validate_changes_file_arg(filename, require_changes=1):
 931     """
 932     'filename' is either a .changes or .dak file.  If 'filename' is a
 933     .dak file, it's changed to be the corresponding .changes file.  The
 934     function then checks if the .changes file a) exists and b) is
 935     readable and returns the .changes filename if so.  If there's a
 936     problem, the next action depends on the option 'require_changes'
 937     argument:
 938
 939       - If 'require_changes' == -1, errors are ignored and the .changes
 940         filename is returned.
 941       - If 'require_changes' == 0, a warning is given and 'None' is returned.
 942       - If 'require_changes' == 1, a fatal error is raised.
 943
 944     """
 945     error = None
 946
 947     orig_filename = filename
 948     if filename.endswith(".dak"):
 949         filename = filename[:-4]+".changes"
 950
 951     if not filename.endswith(".changes"):
 952         error = "invalid file type; not a changes file"
 953     else:
 954         if not os.access(filename,os.R_OK):
 955             if os.path.exists(filename):
 956                 error = "permission denied"
 957             else:
 958                 error = "file not found"
 959
 960     if error:
 961         if require_changes == 1:
 962             fubar("%s: %s." % (orig_filename, error))
 963         elif require_changes == 0:
 964             warn("Skipping %s - %s" % (orig_filename, error))
 965             return None
 966         else: # We only care about the .dak file
 967             return filename
 968     else:
 969         return filename
 970
 971 ################################################################################
 972
 973 def real_arch(arch):
 974     return (arch != "source" and arch != "all")
 975
 976 ################################################################################
 977
 978 def join_with_commas_and(list):
 979     if len(list) == 0: return "nothing"
 980     if len(list) == 1: return list[0]
 981     return ", ".join(list[:-1]) + " and " + list[-1]
 982
 983 ################################################################################
 984
 985 def pp_deps (deps):
 986     pp_deps = []
 987     for atom in deps:
 988         (pkg, version, constraint) = atom
 989         if constraint:
 990             pp_dep = "%s (%s %s)" % (pkg, constraint, version)
 991         else:
 992             pp_dep = pkg
 993         pp_deps.append(pp_dep)
 994     return " |".join(pp_deps)
 995
 996 ################################################################################
 997
 998 def get_conf():
 999     return Cnf
1000
1001 ################################################################################
1002
1003 def parse_args(Options):
1004     """ Handle -a, -c and -s arguments; returns them as SQL constraints """
1005     # XXX: This should go away and everything which calls it be converted
1006     #      to use SQLA properly.  For now, we'll just fix it not to use
1007     #      the old Pg interface though
1008     session = DBConn().session()
1009     # Process suite
1010     if Options["Suite"]:
1011         suite_ids_list = []
1012         for suitename in split_args(Options["Suite"]):
1013             suite = get_suite(suitename, session=session)
1014             if not suite or suite.suite_id is None:
1015                 warn("suite '%s' not recognised." % (suite and suite.suite_name or suitename))
1016             else:
1017                 suite_ids_list.append(suite.suite_id)
1018         if suite_ids_list:
1019             con_suites = "AND su.id IN (%s)" % ", ".join([ str(i) for i in suite_ids_list ])
1020         else:
1021             fubar("No valid suite given.")
1022     else:
1023         con_suites = ""
1024
1025     # Process component
1026     if Options["Component"]:
1027         component_ids_list = []
1028         for componentname in split_args(Options["Component"]):
1029             component = get_component(componentname, session=session)
1030             if component is None:
1031                 warn("component '%s' not recognised." % (componentname))
1032             else:
1033                 component_ids_list.append(component.component_id)
1034         if component_ids_list:
1035             con_components = "AND c.id IN (%s)" % ", ".join([ str(i) for i in component_ids_list ])
1036         else:
1037             fubar("No valid component given.")
1038     else:
1039         con_components = ""
1040
1041     # Process architecture
1042     con_architectures = ""
1043     check_source = 0
1044     if Options["Architecture"]:
1045         arch_ids_list = []
1046         for archname in split_args(Options["Architecture"]):
1047             if archname == "source":
1048                 check_source = 1
1049             else:
1050                 arch = get_architecture(archname, session=session)
1051                 if arch is None:
1052                     warn("architecture '%s' not recognised." % (archname))
1053                 else:
1054                     arch_ids_list.append(arch.arch_id)
1055         if arch_ids_list:
1056             con_architectures = "AND a.id IN (%s)" % ", ".join([ str(i) for i in arch_ids_list ])
1057         else:
1058             if not check_source:
1059                 fubar("No valid architecture given.")
1060     else:
1061         check_source = 1
1062
1063     return (con_suites, con_architectures, con_components, check_source)
1064
1065 ################################################################################
1066
1067 def arch_compare_sw (a, b):
1068     """
1069     Function for use in sorting lists of architectures.
1070
1071     Sorts normally except that 'source' dominates all others.
1072     """
1073
1074     if a == "source" and b == "source":
1075         return 0
1076     elif a == "source":
1077         return -1
1078     elif b == "source":
1079         return 1
1080
1081     return cmp (a, b)
1082
1083 ################################################################################
1084
1085 def split_args (s, dwim=1):
1086     """
1087     Split command line arguments which can be separated by either commas
1088     or whitespace.  If dwim is set, it will complain about string ending
1089     in comma since this usually means someone did 'dak ls -a i386, m68k
1090     foo' or something and the inevitable confusion resulting from 'm68k'
1091     being treated as an argument is undesirable.
1092     """
1093
1094     if s.find(",") == -1:
1095         return s.split()
1096     else:
1097         if s[-1:] == "," and dwim:
1098             fubar("split_args: found trailing comma, spurious space maybe?")
1099         return s.split(",")
1100
1101 ################################################################################
1102
1103 def gpgv_get_status_output(cmd, status_read, status_write):
1104     """
1105     Our very own version of commands.getouputstatus(), hacked to support
1106     gpgv's status fd.
1107     """
1108
1109     cmd = ['/bin/sh', '-c', cmd]
1110     p2cread, p2cwrite = os.pipe()
1111     c2pread, c2pwrite = os.pipe()
1112     errout, errin = os.pipe()
1113     pid = os.fork()
1114     if pid == 0:
1115         # Child
1116         os.close(0)
1117         os.close(1)
1118         os.dup(p2cread)
1119         os.dup(c2pwrite)
1120         os.close(2)
1121         os.dup(errin)
1122         for i in range(3, 256):
1123             if i != status_write:
1124                 try:
1125                     os.close(i)
1126                 except:
1127                     pass
1128         try:
1129             os.execvp(cmd[0], cmd)
1130         finally:
1131             os._exit(1)
1132
1133     # Parent
1134     os.close(p2cread)
1135     os.dup2(c2pread, c2pwrite)
1136     os.dup2(errout, errin)
1137
1138     output = status = ""
1139     while 1:
1140         i, o, e = select.select([c2pwrite, errin, status_read], [], [])
1141         more_data = []
1142         for fd in i:
1143             r = os.read(fd, 8196)
1144             if len(r) > 0:
1145                 more_data.append(fd)
1146                 if fd == c2pwrite or fd == errin:
1147                     output += r
1148                 elif fd == status_read:
1149                     status += r
1150                 else:
1151                     fubar("Unexpected file descriptor [%s] returned from select\n" % (fd))
1152         if not more_data:
1153             pid, exit_status = os.waitpid(pid, 0)
1154             try:
1155                 os.close(status_write)
1156                 os.close(status_read)
1157                 os.close(c2pread)
1158                 os.close(c2pwrite)
1159                 os.close(p2cwrite)
1160                 os.close(errin)
1161                 os.close(errout)
1162             except:
1163                 pass
1164             break
1165
1166     return output, status, exit_status
1167
1168 ################################################################################
1169
1170 def process_gpgv_output(status):
1171     # Process the status-fd output
1172     keywords = {}
1173     internal_error = ""
1174     for line in status.split('\n'):
1175         line = line.strip()
1176         if line == "":
1177             continue
1178         split = line.split()
1179         if len(split) < 2:
1180             internal_error += "gpgv status line is malformed (< 2 atoms) ['%s'].\n" % (line)
1181             continue
1182         (gnupg, keyword) = split[:2]
1183         if gnupg != "[GNUPG:]":
1184             internal_error += "gpgv status line is malformed (incorrect prefix '%s').\n" % (gnupg)
1185             continue
1186         args = split[2:]
1187         if keywords.has_key(keyword) and keyword not in [ "NODATA", "SIGEXPIRED", "KEYEXPIRED" ]:
1188             internal_error += "found duplicate status token ('%s').\n" % (keyword)
1189             continue
1190         else:
1191             keywords[keyword] = args
1192
1193     return (keywords, internal_error)
1194
1195 ################################################################################
1196
1197 def retrieve_key (filename, keyserver=None, keyring=None):
1198     """
1199     Retrieve the key that signed 'filename' from 'keyserver' and
1200     add it to 'keyring'.  Returns nothing on success, or an error message
1201     on error.
1202     """
1203
1204     # Defaults for keyserver and keyring
1205     if not keyserver:
1206         keyserver = Cnf["Dinstall::KeyServer"]
1207     if not keyring:
1208         keyring = get_primary_keyring_path()
1209
1210     # Ensure the filename contains no shell meta-characters or other badness
1211     if not re_taint_free.match(filename):
1212         return "%s: tainted filename" % (filename)
1213
1214     # Invoke gpgv on the file
1215     status_read, status_write = os.pipe()
1216     cmd = "gpgv --status-fd %s --keyring /dev/null %s" % (status_write, filename)
1217     (_, status, _) = gpgv_get_status_output(cmd, status_read, status_write)
1218
1219     # Process the status-fd output
1220     (keywords, internal_error) = process_gpgv_output(status)
1221     if internal_error:
1222         return internal_error
1223
1224     if not keywords.has_key("NO_PUBKEY"):
1225         return "didn't find expected NO_PUBKEY in gpgv status-fd output"
1226
1227     fingerprint = keywords["NO_PUBKEY"][0]
1228     # XXX - gpg sucks.  You can't use --secret-keyring=/dev/null as
1229     # it'll try to create a lockfile in /dev.  A better solution might
1230     # be a tempfile or something.
1231     cmd = "gpg --no-default-keyring --secret-keyring=%s --no-options" \
1232           % (Cnf["Dinstall::SigningKeyring"])
1233     cmd += " --keyring %s --keyserver %s --recv-key %s" \
1234            % (keyring, keyserver, fingerprint)
1235     (result, output) = commands.getstatusoutput(cmd)
1236     if (result != 0):
1237         return "'%s' failed with exit code %s" % (cmd, result)
1238
1239     return ""
1240
1241 ################################################################################
1242
1243 def gpg_keyring_args(keyrings=None):
1244     if not keyrings:
1245         keyrings = get_active_keyring_paths()
1246
1247     return " ".join(["--keyring %s" % x for x in keyrings])
1248
1249 ################################################################################
1250 @session_wrapper
1251 def check_signature (sig_filename, data_filename="", keyrings=None, autofetch=None, session=None):
1252     """
1253     Check the signature of a file and return the fingerprint if the
1254     signature is valid or 'None' if it's not.  The first argument is the
1255     filename whose signature should be checked.  The second argument is a
1256     reject function and is called when an error is found.  The reject()
1257     function must allow for two arguments: the first is the error message,
1258     the second is an optional prefix string.  It's possible for reject()
1259     to be called more than once during an invocation of check_signature().
1260     The third argument is optional and is the name of the files the
1261     detached signature applies to.  The fourth argument is optional and is
1262     a *list* of keyrings to use.  'autofetch' can either be None, True or
1263     False.  If None, the default behaviour specified in the config will be
1264     used.
1265     """
1266
1267     rejects = []
1268
1269     # Ensure the filename contains no shell meta-characters or other badness
1270     if not re_taint_free.match(sig_filename):
1271         rejects.append("!!WARNING!! tainted signature filename: '%s'." % (sig_filename))
1272         return (None, rejects)
1273
1274     if data_filename and not re_taint_free.match(data_filename):
1275         rejects.append("!!WARNING!! tainted data filename: '%s'." % (data_filename))
1276         return (None, rejects)
1277
1278     if not keyrings:
1279         keyrings = [ x.keyring_name for x in session.query(Keyring).filter(Keyring.active == True).all() ]
1280
1281     # Autofetch the signing key if that's enabled
1282     if autofetch == None:
1283         autofetch = Cnf.get("Dinstall::KeyAutoFetch")
1284     if autofetch:
1285         error_msg = retrieve_key(sig_filename)
1286         if error_msg:
1287             rejects.append(error_msg)
1288             return (None, rejects)
1289
1290     # Build the command line
1291     status_read, status_write = os.pipe()
1292     cmd = "gpgv --status-fd %s %s %s %s" % (
1293         status_write, gpg_keyring_args(keyrings), sig_filename, data_filename)
1294
1295     # Invoke gpgv on the file
1296     (output, status, exit_status) = gpgv_get_status_output(cmd, status_read, status_write)
1297
1298     # Process the status-fd output
1299     (keywords, internal_error) = process_gpgv_output(status)
1300
1301     # If we failed to parse the status-fd output, let's just whine and bail now
1302     if internal_error:
1303         rejects.append("internal error while performing signature check on %s." % (sig_filename))
1304         rejects.append(internal_error, "")
1305         rejects.append("Please report the above errors to the Archive maintainers by replying to this mail.", "")
1306         return (None, rejects)
1307
1308     # Now check for obviously bad things in the processed output
1309     if keywords.has_key("KEYREVOKED"):
1310         rejects.append("The key used to sign %s has been revoked." % (sig_filename))
1311     if keywords.has_key("BADSIG"):
1312         rejects.append("bad signature on %s." % (sig_filename))
1313     if keywords.has_key("ERRSIG") and not keywords.has_key("NO_PUBKEY"):
1314         rejects.append("failed to check signature on %s." % (sig_filename))
1315     if keywords.has_key("NO_PUBKEY"):
1316         args = keywords["NO_PUBKEY"]
1317         if len(args) >= 1:
1318             key = args[0]
1319         rejects.append("The key (0x%s) used to sign %s wasn't found in the keyring(s)." % (key, sig_filename))
1320     if keywords.has_key("BADARMOR"):
1321         rejects.append("ASCII armour of signature was corrupt in %s." % (sig_filename))
1322     if keywords.has_key("NODATA"):
1323         rejects.append("no signature found in %s." % (sig_filename))
1324     if keywords.has_key("EXPKEYSIG"):
1325         args = keywords["EXPKEYSIG"]
1326         if len(args) >= 1:
1327             key = args[0]
1328         rejects.append("Signature made by expired key 0x%s" % (key))
1329     if keywords.has_key("KEYEXPIRED") and not keywords.has_key("GOODSIG"):
1330         args = keywords["KEYEXPIRED"]
1331         expiredate=""
1332         if len(args) >= 1:
1333             timestamp = args[0]
1334             if timestamp.count("T") == 0:
1335                 try:
1336                     expiredate = time.strftime("%Y-%m-%d", time.gmtime(float(timestamp)))
1337                 except ValueError:
1338                     expiredate = "unknown (%s)" % (timestamp)
1339             else:
1340                 expiredate = timestamp
1341         rejects.append("The key used to sign %s has expired on %s" % (sig_filename, expiredate))
1342
1343     if len(rejects) > 0:
1344         return (None, rejects)
1345
1346     # Next check gpgv exited with a zero return code
1347     if exit_status:
1348         rejects.append("gpgv failed while checking %s." % (sig_filename))
1349         if status.strip():
1350             rejects.append(prefix_multi_line_string(status, " [GPG status-fd output:] "))
1351         else:
1352             rejects.append(prefix_multi_line_string(output, " [GPG output:] "))
1353         return (None, rejects)
1354
1355     # Sanity check the good stuff we expect
1356     if not keywords.has_key("VALIDSIG"):
1357         rejects.append("signature on %s does not appear to be valid [No VALIDSIG]." % (sig_filename))
1358     else:
1359         args = keywords["VALIDSIG"]
1360         if len(args) < 1:
1361             rejects.append("internal error while checking signature on %s." % (sig_filename))
1362         else:
1363             fingerprint = args[0]
1364     if not keywords.has_key("GOODSIG"):
1365         rejects.append("signature on %s does not appear to be valid [No GOODSIG]." % (sig_filename))
1366     if not keywords.has_key("SIG_ID"):
1367         rejects.append("signature on %s does not appear to be valid [No SIG_ID]." % (sig_filename))
1368
1369     # Finally ensure there's not something we don't recognise
1370     known_keywords = dict(VALIDSIG="",SIG_ID="",GOODSIG="",BADSIG="",ERRSIG="",
1371                           SIGEXPIRED="",KEYREVOKED="",NO_PUBKEY="",BADARMOR="",
1372                           NODATA="",NOTATION_DATA="",NOTATION_NAME="",KEYEXPIRED="",POLICY_URL="")
1373
1374     for keyword in keywords.keys():
1375         if not known_keywords.has_key(keyword):
1376             rejects.append("found unknown status token '%s' from gpgv with args '%r' in %s." % (keyword, keywords[keyword], sig_filename))
1377
1378     if len(rejects) > 0:
1379         return (None, rejects)
1380     else:
1381         return (fingerprint, [])
1382
1383 ################################################################################
1384
1385 def gpg_get_key_addresses(fingerprint):
1386     """retreive email addresses from gpg key uids for a given fingerprint"""
1387     addresses = key_uid_email_cache.get(fingerprint)
1388     if addresses != None:
1389         return addresses
1390     addresses = list()
1391     cmd = "gpg --no-default-keyring %s --fingerprint %s" \
1392                 % (gpg_keyring_args(), fingerprint)
1393     (result, output) = commands.getstatusoutput(cmd)
1394     if result == 0:
1395         for l in output.split('\n'):
1396             m = re_gpg_uid.match(l)
1397             if not m:
1398                 continue
1399             address = m.group(1)
1400             if address.endswith('@debian.org'):
1401                 # prefer @debian.org addresses
1402                 # TODO: maybe not hardcode the domain
1403                 addresses.insert(0, address)
1404             else:
1405                 addresses.append(m.group(1))
1406     key_uid_email_cache[fingerprint] = addresses
1407     return addresses
1408
1409 ################################################################################
1410
1411 def get_logins_from_ldap(fingerprint='*'):
1412     """retrieve login from LDAP linked to a given fingerprint"""
1413
1414     LDAPDn = Cnf['Import-LDAP-Fingerprints::LDAPDn']
1415     LDAPServer = Cnf['Import-LDAP-Fingerprints::LDAPServer']
1416     l = ldap.open(LDAPServer)
1417     l.simple_bind_s('','')
1418     Attrs = l.search_s(LDAPDn, ldap.SCOPE_ONELEVEL,
1419                        '(keyfingerprint=%s)' % fingerprint,
1420                        ['uid', 'keyfingerprint'])
1421     login = {}
1422     for elem in Attrs:
1423         login[elem[1]['keyFingerPrint'][0]] = elem[1]['uid'][0]
1424     return login
1425
1426 ################################################################################
1427
1428 def clean_symlink (src, dest, root):
1429     """
1430     Relativize an absolute symlink from 'src' -> 'dest' relative to 'root'.
1431     Returns fixed 'src'
1432     """
1433     src = src.replace(root, '', 1)
1434     dest = dest.replace(root, '', 1)
1435     dest = os.path.dirname(dest)
1436     new_src = '../' * len(dest.split('/'))
1437     return new_src + src
1438
1439 ################################################################################
1440
1441 def temp_filename(directory=None, prefix="dak", suffix="", mode=None, group=None):
1442     """
1443     Return a secure and unique filename by pre-creating it.
1444
1445     @type directory: str
1446     @param directory: If non-null it will be the directory the file is pre-created in.
1447
1448     @type prefix: str
1449     @param prefix: The filename will be prefixed with this string
1450
1451     @type suffix: str
1452     @param suffix: The filename will end with this string
1453
1454     @type mode: str
1455     @param mode: If set the file will get chmodded to those permissions
1456
1457     @type group: str
1458     @param group: If set the file will get chgrped to the specified group.
1459
1460     @rtype: list
1461     @return: Returns a pair (fd, name)
1462     """
1463
1464     (tfd, tfname) = tempfile.mkstemp(suffix, prefix, directory)
1465     if mode:
1466         os.chmod(tfname, mode)
1467     if group:
1468         gid = grp.getgrnam(group).gr_gid
1469         os.chown(tfname, -1, gid)
1470     return (tfd, tfname)
1471
1472 ################################################################################
1473
1474 def temp_dirname(parent=None, prefix="dak", suffix="", mode=None, group=None):
1475     """
1476     Return a secure and unique directory by pre-creating it.
1477
1478     @type parent: str
1479     @param parent: If non-null it will be the directory the directory is pre-created in.
1480
1481     @type prefix: str
1482     @param prefix: The filename will be prefixed with this string
1483
1484     @type suffix: str
1485     @param suffix: The filename will end with this string
1486
1487     @type mode: str
1488     @param mode: If set the file will get chmodded to those permissions
1489
1490     @type group: str
1491     @param group: If set the file will get chgrped to the specified group.
1492
1493     @rtype: list
1494     @return: Returns a pair (fd, name)
1495
1496     """
1497
1498     tfname = tempfile.mkdtemp(suffix, prefix, parent)
1499     if mode:
1500         os.chmod(tfname, mode)
1501     if group:
1502         gid = grp.getgrnam(group).gr_gid
1503         os.chown(tfname, -1, gid)
1504     return tfname
1505
1506 ################################################################################
1507
1508 def is_email_alias(email):
1509     """ checks if the user part of the email is listed in the alias file """
1510     global alias_cache
1511     if alias_cache == None:
1512         aliasfn = which_alias_file()
1513         alias_cache = set()
1514         if aliasfn:
1515             for l in open(aliasfn):
1516                 alias_cache.add(l.split(':')[0])
1517     uid = email.split('@')[0]
1518     return uid in alias_cache
1519
1520 ################################################################################
1521
1522 def get_changes_files(from_dir):
1523     """
1524     Takes a directory and lists all .changes files in it (as well as chdir'ing
1525     to the directory; this is due to broken behaviour on the part of p-u/p-a
1526     when you're not in the right place)
1527
1528     Returns a list of filenames
1529     """
1530     try:
1531         # Much of the rest of p-u/p-a depends on being in the right place
1532         os.chdir(from_dir)
1533         changes_files = [x for x in os.listdir(from_dir) if x.endswith('.changes')]
1534     except OSError as e:
1535         fubar("Failed to read list from directory %s (%s)" % (from_dir, e))
1536
1537     return changes_files
1538
1539 ################################################################################
1540
1541 Cnf = config.Config().Cnf
1542
1543 ################################################################################
1544
1545 def parse_wnpp_bug_file(file = "/srv/ftp-master.debian.org/scripts/masterfiles/wnpp_rm"):
1546     """
1547     Parses the wnpp bug list available at http://qa.debian.org/data/bts/wnpp_rm
1548     Well, actually it parsed a local copy, but let's document the source
1549     somewhere ;)
1550
1551     returns a dict associating source package name with a list of open wnpp
1552     bugs (Yes, there might be more than one)
1553     """
1554
1555     line = []
1556     try:
1557         f = open(file)
1558         lines = f.readlines()
1559     except IOError as e:
1560         print "Warning:  Couldn't open %s; don't know about WNPP bugs, so won't close any." % file
1561         lines = []
1562     wnpp = {}
1563
1564     for line in lines:
1565         splited_line = line.split(": ", 1)
1566         if len(splited_line) > 1:
1567             wnpp[splited_line[0]] = splited_line[1].split("|")
1568
1569     for source in wnpp.keys():
1570         bugs = []
1571         for wnpp_bug in wnpp[source]:
1572             bug_no = re.search("(\d)+", wnpp_bug).group()
1573             if bug_no:
1574                 bugs.append(bug_no)
1575         wnpp[source] = bugs
1576     return wnpp
1577
1578 ################################################################################
1579
1580 def get_packages_from_ftp(root, suite, component, architecture):
1581     """
1582     Returns an object containing apt_pkg-parseable data collected by
1583     aggregating Packages.gz files gathered for each architecture.
1584
1585     @type root: string
1586     @param root: path to ftp archive root directory
1587
1588     @type suite: string
1589     @param suite: suite to extract files from
1590
1591     @type component: string
1592     @param component: component to extract files from
1593
1594     @type architecture: string
1595     @param architecture: architecture to extract files from
1596
1597     @rtype: TagFile
1598     @return: apt_pkg class containing package data
1599     """
1600     filename = "%s/dists/%s/%s/binary-%s/Packages.gz" % (root, suite, component, architecture)
1601     (fd, temp_file) = temp_filename()
1602     (result, output) = commands.getstatusoutput("gunzip -c %s > %s" % (filename, temp_file))
1603     if (result != 0):
1604         fubar("Gunzip invocation failed!\n%s\n" % (output), result)
1605     filename = "%s/dists/%s/%s/debian-installer/binary-%s/Packages.gz" % (root, suite, component, architecture)
1606     if os.path.exists(filename):
1607         (result, output) = commands.getstatusoutput("gunzip -c %s >> %s" % (filename, temp_file))
1608         if (result != 0):
1609             fubar("Gunzip invocation failed!\n%s\n" % (output), result)
1610     packages = open_file(temp_file)
1611     Packages = apt_pkg.ParseTagFile(packages)
1612     os.unlink(temp_file)
1613     return Packages
1614
1615 ################################################################################
1616
1617 def deb_extract_control(fh):
1618     """extract DEBIAN/control from a binary package"""
1619     return apt_inst.DebFile(fh).control.extractdata("control")
1620
1621 ################################################################################
1622
1623 def mail_addresses_for_upload(maintainer, changed_by, fingerprint):
1624     """mail addresses to contact for an upload
1625
1626     @type  maintainer: str
1627     @param maintainer: Maintainer field of the .changes file
1628
1629     @type  changed_by: str
1630     @param changed_by: Changed-By field of the .changes file
1631
1632     @type  fingerprint: str
1633     @param fingerprint: fingerprint of the key used to sign the upload
1634
1635     @rtype:  list of str
1636     @return: list of RFC 2047-encoded mail addresses to contact regarding
1637              this upload
1638     """
1639     addresses = [maintainer]
1640     if changed_by != maintainer:
1641         addresses.append(changed_by)
1642
1643     fpr_addresses = gpg_get_key_addresses(fingerprint)
1644     if len(fpr_addresses) > 0 and fix_maintainer(changed_by)[3] not in fpr_addresses and fix_maintainer(maintainer)[3] not in fpr_addresses:
1645         addresses.append(fpr_addresses[0])
1646
1647     encoded_addresses = [ fix_maintainer(e)[1] for e in addresses ]
1648     return encoded_addresses
1649
1650 ################################################################################
1651
1652 def call_editor(text="", suffix=".txt"):
1653     """run editor and return the result as a string
1654
1655     @type  text: str
1656     @param text: initial text
1657
1658     @type  suffix: str
1659     @param suffix: extension for temporary file
1660
1661     @rtype:  str
1662     @return: string with the edited text
1663     """
1664     editor = os.environ.get('VISUAL', os.environ.get('EDITOR', 'vi'))
1665     tmp = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
1666     try:
1667         print >>tmp, text,
1668         tmp.close()
1669         subprocess.check_call([editor, tmp.name])
1670         return open(tmp.name, 'r').read()
1671     finally:
1672         os.unlink(tmp.name)
1673
1674 ################################################################################
1675
1676 def check_reverse_depends(removals, suite, arches=None, session=None, cruft=False):
1677     dbsuite = get_suite(suite, session)
1678     overridesuite = dbsuite
1679     if dbsuite.overridesuite is not None:
1680         overridesuite = get_suite(dbsuite.overridesuite, session)
1681     dep_problem = 0
1682     p2c = {}
1683     all_broken = {}
1684     if arches:
1685         all_arches = set(arches)
1686     else:
1687         all_arches = set([x.arch_string for x in get_suite_architectures(suite)])
1688     all_arches -= set(["source", "all"])
1689     metakey_d = get_or_set_metadatakey("Depends", session)
1690     metakey_p = get_or_set_metadatakey("Provides", session)
1691     params = {
1692         'suite_id':     dbsuite.suite_id,
1693         'metakey_d_id': metakey_d.key_id,
1694         'metakey_p_id': metakey_p.key_id,
1695     }
1696     for architecture in all_arches | set(['all']):
1697         deps = {}
1698         sources = {}
1699         virtual_packages = {}
1700         params['arch_id'] = get_architecture(architecture, session).arch_id
1701
1702         statement = '''
1703             SELECT b.id, b.package, s.source, c.name as component,
1704                 (SELECT bmd.value FROM binaries_metadata bmd WHERE bmd.bin_id = b.id AND bmd.key_id = :metakey_d_id) AS depends,
1705                 (SELECT bmp.value FROM binaries_metadata bmp WHERE bmp.bin_id = b.id AND bmp.key_id = :metakey_p_id) AS provides
1706                 FROM binaries b
1707                 JOIN bin_associations ba ON b.id = ba.bin AND ba.suite = :suite_id
1708                 JOIN source s ON b.source = s.id
1709                 JOIN files_archive_map af ON b.file = af.file_id
1710                 JOIN component c ON af.component_id = c.id
1711                 WHERE b.architecture = :arch_id'''
1712         query = session.query('id', 'package', 'source', 'component', 'depends', 'provides'). \
1713             from_statement(statement).params(params)
1714         for binary_id, package, source, component, depends, provides in query:
1715             sources[package] = source
1716             p2c[package] = component
1717             if depends is not None:
1718                 deps[package] = depends
1719             # Maintain a counter for each virtual package.  If a
1720             # Provides: exists, set the counter to 0 and count all
1721             # provides by a package not in the list for removal.
1722             # If the counter stays 0 at the end, we know that only
1723             # the to-be-removed packages provided this virtual
1724             # package.
1725             if provides is not None:
1726                 for virtual_pkg in provides.split(","):
1727                     virtual_pkg = virtual_pkg.strip()
1728                     if virtual_pkg == package: continue
1729                     if not virtual_packages.has_key(virtual_pkg):
1730                         virtual_packages[virtual_pkg] = 0
1731                     if package not in removals:
1732                         virtual_packages[virtual_pkg] += 1
1733
1734         # If a virtual package is only provided by the to-be-removed
1735         # packages, treat the virtual package as to-be-removed too.
1736         for virtual_pkg in virtual_packages.keys():
1737             if virtual_packages[virtual_pkg] == 0:
1738                 removals.append(virtual_pkg)
1739
1740         # Check binary dependencies (Depends)
1741         for package in deps.keys():
1742             if package in removals: continue
1743             parsed_dep = []
1744             try:
1745                 parsed_dep += apt_pkg.ParseDepends(deps[package])
1746             except ValueError as e:
1747                 print "Error for package %s: %s" % (package, e)
1748             for dep in parsed_dep:
1749                 # Check for partial breakage.  If a package has a ORed
1750                 # dependency, there is only a dependency problem if all
1751                 # packages in the ORed depends will be removed.
1752                 unsat = 0
1753                 for dep_package, _, _ in dep:
1754                     if dep_package in removals:
1755                         unsat += 1
1756                 if unsat == len(dep):
1757                     component = p2c[package]
1758                     source = sources[package]
1759                     if component != "main":
1760                         source = "%s/%s" % (source, component)
1761                     all_broken.setdefault(source, {}).setdefault(package, set()).add(architecture)
1762                     dep_problem = 1
1763
1764     if all_broken:
1765         if cruft:
1766             print "  - broken Depends:"
1767         else:
1768             print "# Broken Depends:"
1769         for source, bindict in sorted(all_broken.items()):
1770             lines = []
1771             for binary, arches in sorted(bindict.items()):
1772                 if arches == all_arches or 'all' in arches:
1773                     lines.append(binary)
1774                 else:
1775                     lines.append('%s [%s]' % (binary, ' '.join(sorted(arches))))
1776             if cruft:
1777                 print '    %s: %s' % (source, lines[0])
1778             else:
1779                 print '%s: %s' % (source, lines[0])
1780             for line in lines[1:]:
1781                 if cruft:
1782                     print '    ' + ' ' * (len(source) + 2) + line
1783                 else:
1784                     print ' ' * (len(source) + 2) + line
1785         if not cruft:
1786             print
1787
1788     # Check source dependencies (Build-Depends and Build-Depends-Indep)
1789     all_broken.clear()
1790     metakey_bd = get_or_set_metadatakey("Build-Depends", session)
1791     metakey_bdi = get_or_set_metadatakey("Build-Depends-Indep", session)
1792     params = {
1793         'suite_id':    dbsuite.suite_id,
1794         'metakey_ids': (metakey_bd.key_id, metakey_bdi.key_id),
1795     }
1796     statement = '''
1797         SELECT s.id, s.source, string_agg(sm.value, ', ') as build_dep
1798            FROM source s
1799            JOIN source_metadata sm ON s.id = sm.src_id
1800            WHERE s.id in
1801                (SELECT source FROM src_associations
1802                    WHERE suite = :suite_id)
1803                AND sm.key_id in :metakey_ids
1804            GROUP BY s.id, s.source'''
1805     query = session.query('id', 'source', 'build_dep').from_statement(statement). \
1806         params(params)
1807     for source_id, source, build_dep in query:
1808         if source in removals: continue
1809         parsed_dep = []
1810         if build_dep is not None:
1811             # Remove [arch] information since we want to see breakage on all arches
1812             build_dep = re_build_dep_arch.sub("", build_dep)
1813             try:
1814                 parsed_dep += apt_pkg.ParseDepends(build_dep)
1815             except ValueError as e:
1816                 print "Error for source %s: %s" % (source, e)
1817         for dep in parsed_dep:
1818             unsat = 0
1819             for dep_package, _, _ in dep:
1820                 if dep_package in removals:
1821                     unsat += 1
1822             if unsat == len(dep):
1823                 component, = session.query(Component.component_name) \
1824                     .join(Component.overrides) \
1825                     .filter(Override.suite == overridesuite) \
1826                     .filter(Override.package == re.sub('/(contrib|non-free)$', '', source)) \
1827                     .join(Override.overridetype).filter(OverrideType.overridetype == 'dsc') \
1828                     .first()
1829                 if component != "main":
1830                     source = "%s/%s" % (source, component)
1831                 all_broken.setdefault(source, set()).add(pp_deps(dep))
1832                 dep_problem = 1
1833
1834     if all_broken:
1835         if cruft:
1836             print "  - broken Build-Depends:"
1837         else:
1838             print "# Broken Build-Depends:"
1839         for source, bdeps in sorted(all_broken.items()):
1840             bdeps = sorted(bdeps)
1841             if cruft:
1842                 print '    %s: %s' % (source, bdeps[0])
1843             else:
1844                 print '%s: %s' % (source, bdeps[0])
1845             for bdep in bdeps[1:]:
1846                 if cruft:
1847                     print '    ' + ' ' * (len(source) + 2) + bdep
1848                 else:
1849                     print ' ' * (len(source) + 2) + bdep
1850         if not cruft:
1851             print
1852
1853     return dep_problem