daklib/utils.py

   1 #!/usr/bin/env python
   2
   3 # Utility functions
   4 # Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006  James Troup <james@nocrew.org>
   5
   6 ################################################################################
   7
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21
  22 ################################################################################
  23
  24 import codecs, commands, email.Header, os, pwd, re, select, socket, shutil, \
  25        sys, tempfile, traceback, stat
  26 import apt_pkg
  27 import database
  28 from dak_exceptions import *
  29
  30 ################################################################################
  31
  32 re_comments = re.compile(r"\#.*")
  33 re_no_epoch = re.compile(r"^\d+\:")
  34 re_no_revision = re.compile(r"-[^-]+$")
  35 re_arch_from_filename = re.compile(r"/binary-[^/]+/")
  36 re_extract_src_version = re.compile (r"(\S+)\s*\((.*)\)")
  37 re_isadeb = re.compile (r"(.+?)_(.+?)_(.+)\.u?deb$")
  38 re_issource = re.compile (r"(.+)_(.+?)\.(orig\.tar\.gz|diff\.gz|tar\.gz|dsc)$")
  39
  40 re_single_line_field = re.compile(r"^(\S*)\s*:\s*(.*)")
  41 re_multi_line_field = re.compile(r"^\s(.*)")
  42 re_taint_free = re.compile(r"^[-+~/\.\w]+$")
  43
  44 re_parse_maintainer = re.compile(r"^\s*(\S.*\S)\s*\<([^\>]+)\>")
  45 re_gpg_uid = re.compile('^uid.*<([^>]*)>')
  46
  47 re_srchasver = re.compile(r"^(\S+)\s+\((\S+)\)$")
  48 re_verwithext = re.compile(r"^(\d+)(?:\.(\d+))(?:\s+\((\S+)\))?$")
  49
  50 re_srchasver = re.compile(r"^(\S+)\s+\((\S+)\)$")
  51
  52 default_config = "/etc/dak/dak.conf"
  53 default_apt_config = "/etc/dak/apt.conf"
  54
  55 alias_cache = None
  56 key_uid_email_cache = {}
  57
  58 # (hashname, function, earliest_changes_version)
  59 known_hashes = [("sha1", apt_pkg.sha1sum, (1, 8)),
  60                 ("sha256", apt_pkg.sha256sum, (1, 8))]
  61
  62 ################################################################################
  63
  64 def open_file(filename, mode='r'):
  65     try:
  66         f = open(filename, mode)
  67     except IOError:
  68         raise CantOpenError, filename
  69     return f
  70
  71 ################################################################################
  72
  73 def our_raw_input(prompt=""):
  74     if prompt:
  75         sys.stdout.write(prompt)
  76     sys.stdout.flush()
  77     try:
  78         ret = raw_input()
  79         return ret
  80     except EOFError:
  81         sys.stderr.write("\nUser interrupt (^D).\n")
  82         raise SystemExit
  83
  84 ################################################################################
  85
  86 def extract_component_from_section(section):
  87     component = ""
  88
  89     if section.find('/') != -1:
  90         component = section.split('/')[0]
  91
  92     # Expand default component
  93     if component == "":
  94         if Cnf.has_key("Component::%s" % section):
  95             component = section
  96         else:
  97             component = "main"
  98
  99     return (section, component)
 100
 101 ################################################################################
 102
 103 def parse_changes(filename, signing_rules=0):
 104     """Parses a changes file and returns a dictionary where each field is a
 105 key.  The mandatory first argument is the filename of the .changes
 106 file.
 107
 108 signing_rules is an optional argument:
 109
 110  o If signing_rules == -1, no signature is required.
 111  o If signing_rules == 0 (the default), a signature is required.
 112  o If signing_rules == 1, it turns on the same strict format checking
 113    as dpkg-source.
 114
 115 The rules for (signing_rules == 1)-mode are:
 116
 117   o The PGP header consists of "-----BEGIN PGP SIGNED MESSAGE-----"
 118     followed by any PGP header data and must end with a blank line.
 119
 120   o The data section must end with a blank line and must be followed by
 121     "-----BEGIN PGP SIGNATURE-----".
 122 """
 123
 124     error = ""
 125     changes = {}
 126
 127     changes_in = open_file(filename)
 128     lines = changes_in.readlines()
 129
 130     if not lines:
 131         raise ParseChangesError, "[Empty changes file]"
 132
 133     # Reindex by line number so we can easily verify the format of
 134     # .dsc files...
 135     index = 0
 136     indexed_lines = {}
 137     for line in lines:
 138         index += 1
 139         indexed_lines[index] = line[:-1]
 140
 141     inside_signature = 0
 142
 143     num_of_lines = len(indexed_lines.keys())
 144     index = 0
 145     first = -1
 146     while index < num_of_lines:
 147         index += 1
 148         line = indexed_lines[index]
 149         if line == "":
 150             if signing_rules == 1:
 151                 index += 1
 152                 if index > num_of_lines:
 153                     raise InvalidDscError, index
 154                 line = indexed_lines[index]
 155                 if not line.startswith("-----BEGIN PGP SIGNATURE"):
 156                     raise InvalidDscError, index
 157                 inside_signature = 0
 158                 break
 159             else:
 160                 continue
 161         if line.startswith("-----BEGIN PGP SIGNATURE"):
 162             break
 163         if line.startswith("-----BEGIN PGP SIGNED MESSAGE"):
 164             inside_signature = 1
 165             if signing_rules == 1:
 166                 while index < num_of_lines and line != "":
 167                     index += 1
 168                     line = indexed_lines[index]
 169             continue
 170         # If we're not inside the signed data, don't process anything
 171         if signing_rules >= 0 and not inside_signature:
 172             continue
 173         slf = re_single_line_field.match(line)
 174         if slf:
 175             field = slf.groups()[0].lower()
 176             changes[field] = slf.groups()[1]
 177             first = 1
 178             continue
 179         if line == " .":
 180             changes[field] += '\n'
 181             continue
 182         mlf = re_multi_line_field.match(line)
 183         if mlf:
 184             if first == -1:
 185                 raise ParseChangesError, "'%s'\n [Multi-line field continuing on from nothing?]" % (line)
 186             if first == 1 and changes[field] != "":
 187                 changes[field] += '\n'
 188             first = 0
 189             changes[field] += mlf.groups()[0] + '\n'
 190             continue
 191         error += line
 192
 193     if signing_rules == 1 and inside_signature:
 194         raise InvalidDscError, index
 195
 196     changes_in.close()
 197     changes["filecontents"] = "".join(lines)
 198
 199     if changes.has_key("source"):
 200         # Strip the source version in brackets from the source field,
 201         # put it in the "source-version" field instead.
 202         srcver = re_srchasver.search(changes["source"])
 203         if srcver:
 204             changes["source"] = srcver.group(1)
 205             changes["source-version"] = srcver.group(2)
 206
 207     if error:
 208         raise ParseChangesError, error
 209
 210     return changes
 211
 212 ################################################################################
 213
 214 def create_hash (lfiles, key, testfn, basedict = None):
 215     rejmsg = []
 216     for f in lfiles.keys():
 217         try:
 218             file_handle = open_file(f)
 219         except CantOpenError:
 220             rejmsg.append("Could not open file %s for checksumming" % (f))
 221
 222         # Check hash
 223         if basedict and basedict.has_key(f):
 224             basedict[f]['%ssum' % key] = testfn(file_handle)
 225         file_handle.close()
 226
 227     return rejmsg
 228
 229 ################################################################################
 230
 231 def check_hash (where, lfiles, key, testfn, basedict = None):
 232     rejmsg = []
 233     if basedict:
 234         for f in basedict.keys():
 235             if f not in lfiles:
 236                 rejmsg.append("%s: no %s checksum" % (f, key))
 237
 238     for f in lfiles.keys():
 239         if basedict and f not in basedict:
 240             rejmsg.append("%s: extraneous entry in %s checksums" % (f, key))
 241
 242         try:
 243             file_handle = open_file(f)
 244         except CantOpenError:
 245             continue
 246
 247         # Check hash
 248         if testfn(file_handle) != lfiles[f][key]:
 249             rejmsg.append("%s: %s check failed." % (f, key))
 250         file_handle.close()
 251         # Store the hashes for later use
 252         if basedict:
 253             basedict[f]['%ssum' % key] = lfiles[f][key]
 254         # Check size
 255         actual_size = os.stat(f)[stat.ST_SIZE]
 256         size = int(lfiles[f]["size"])
 257         if size != actual_size:
 258             rejmsg.append("%s: actual file size (%s) does not match size (%s) in %s"
 259                    % (f, actual_size, size, where))
 260
 261     return rejmsg
 262
 263 ################################################################################
 264
 265 def ensure_hashes(changes, dsc, files, dsc_files):
 266     # Make sure we recognise the format of the Files: field
 267     format = changes.get("format", "0.0").split(".",1)
 268     if len(format) == 2:
 269         format = int(format[0]), int(format[1])
 270     else:
 271         format = int(float(format[0])), 0
 272
 273     rejmsg = []
 274     for x in changes:
 275         if x.startswith("checksum-"):
 276             h = x.split("-",1)[1]
 277             if h not in dict(known_hashes):
 278                 rejmsg.append("Unsupported checksum field in .changes" % (h))
 279
 280     for x in dsc:
 281         if x.startswith("checksum-"):
 282             h = x.split("-",1)[1]
 283             if h not in dict(known_hashes):
 284                 rejmsg.append("Unsupported checksum field in .dsc" % (h))
 285
 286     # We have to calculate the hash if we have an earlier changes version than
 287     # the hash appears in rather than require it exist in the changes file
 288     # I hate backwards compatibility
 289     for h,f,v in known_hashes:
 290         try:
 291             if format < v:
 292                 for m in create_hash(files, h, f, files):
 293                     rejmsg.append(m)
 294             else:
 295                 for m in check_hash(".changes %s" % (h), files, h, f, files):
 296                     rejmsg.append(m)
 297         except NoFilesFieldError:
 298             rejmsg.append("No Checksums-%s: field in .changes" % (h))
 299         except UnknownFormatError, format:
 300             rejmsg.append("%s: unknown format of .changes" % (format))
 301         except ParseChangesError, line:
 302             rejmsg.append("parse error for Checksums-%s in .changes, can't grok: %s." % (h, line))
 303
 304         if "source" not in changes["architecture"]: continue
 305
 306         try:
 307             if format < v:
 308                 for m in create_hash(dsc_files, h, f, dsc_files):
 309                     rejmsg.append(m)
 310             else:
 311                 for m in check_hash(".dsc %s" % (h), dsc_files, h, f, dsc_files):
 312                     rejmsg.append(m)
 313         except UnknownFormatError, format:
 314             rejmsg.append("%s: unknown format of .dsc" % (format))
 315         except NoFilesFieldError:
 316             rejmsg.append("No Checksums-%s: field in .dsc" % (h))
 317         except ParseChangesError, line:
 318             rejmsg.append("parse error for Checksums-%s in .dsc, can't grok: %s." % (h, line))
 319
 320     return rejmsg
 321
 322 ################################################################################
 323
 324 # Dropped support for 1.4 and ``buggy dchanges 3.4'' (?!) compared to di.pl
 325
 326 def build_file_list(changes, is_a_dsc=0, field="files", hashname="md5sum"):
 327     files = {}
 328
 329     # Make sure we have a Files: field to parse...
 330     if not changes.has_key(field):
 331         raise NoFilesFieldError
 332
 333     # Make sure we recognise the format of the Files: field
 334     format = re_verwithext.search(changes.get("format", "0.0"))
 335     if not format:
 336         raise UnknownFormatError, "%s" % (changes.get("format","0.0"))
 337
 338     format = format.groups()
 339     if format[1] == None:
 340         format = int(float(format[0])), 0, format[2]
 341     else:
 342         format = int(format[0]), int(format[1]), format[2]
 343     if format[2] == None:
 344         format = format[:2]
 345
 346     if is_a_dsc:
 347         if format != (1,0):
 348             raise UnknownFormatError, "%s" % (changes.get("format","0.0"))
 349     else:
 350         if (format < (1,5) or format > (1,8)):
 351             raise UnknownFormatError, "%s" % (changes.get("format","0.0"))
 352         if field != "files" and format < (1,8):
 353             raise UnknownFormatError, "%s" % (changes.get("format","0.0"))
 354
 355     includes_section = (not is_a_dsc) and field == "files"
 356
 357     # Parse each entry/line:
 358     for i in changes[field].split('\n'):
 359         if not i:
 360             break
 361         s = i.split()
 362         section = priority = ""
 363         try:
 364             if includes_section:
 365                 (md5, size, section, priority, name) = s
 366             else:
 367                 (md5, size, name) = s
 368         except ValueError:
 369             raise ParseChangesError, i
 370
 371         if section == "":
 372             section = "-"
 373         if priority == "":
 374             priority = "-"
 375
 376         (section, component) = extract_component_from_section(section)
 377
 378         files[name] = Dict(size=size, section=section,
 379                            priority=priority, component=component)
 380         files[name][hashname] = md5
 381
 382     return files
 383
 384 ################################################################################
 385
 386 def force_to_utf8(s):
 387     """Forces a string to UTF-8.  If the string isn't already UTF-8,
 388 it's assumed to be ISO-8859-1."""
 389     try:
 390         unicode(s, 'utf-8')
 391         return s
 392     except UnicodeError:
 393         latin1_s = unicode(s,'iso8859-1')
 394         return latin1_s.encode('utf-8')
 395
 396 def rfc2047_encode(s):
 397     """Encodes a (header) string per RFC2047 if necessary.  If the
 398 string is neither ASCII nor UTF-8, it's assumed to be ISO-8859-1."""
 399     try:
 400         codecs.lookup('ascii')[1](s)
 401         return s
 402     except UnicodeError:
 403         pass
 404     try:
 405         codecs.lookup('utf-8')[1](s)
 406         h = email.Header.Header(s, 'utf-8', 998)
 407         return str(h)
 408     except UnicodeError:
 409         h = email.Header.Header(s, 'iso-8859-1', 998)
 410         return str(h)
 411
 412 ################################################################################
 413
 414 # <Culus> 'The standard sucks, but my tool is supposed to interoperate
 415 #          with it. I know - I'll fix the suckage and make things
 416 #          incompatible!'
 417
 418 def fix_maintainer (maintainer):
 419     """Parses a Maintainer or Changed-By field and returns:
 420   (1) an RFC822 compatible version,
 421   (2) an RFC2047 compatible version,
 422   (3) the name
 423   (4) the email
 424
 425 The name is forced to UTF-8 for both (1) and (3).  If the name field
 426 contains '.' or ',' (as allowed by Debian policy), (1) and (2) are
 427 switched to 'email (name)' format."""
 428     maintainer = maintainer.strip()
 429     if not maintainer:
 430         return ('', '', '', '')
 431
 432     if maintainer.find("<") == -1:
 433         email = maintainer
 434         name = ""
 435     elif (maintainer[0] == "<" and maintainer[-1:] == ">"):
 436         email = maintainer[1:-1]
 437         name = ""
 438     else:
 439         m = re_parse_maintainer.match(maintainer)
 440         if not m:
 441             raise ParseMaintError, "Doesn't parse as a valid Maintainer field."
 442         name = m.group(1)
 443         email = m.group(2)
 444
 445     # Get an RFC2047 compliant version of the name
 446     rfc2047_name = rfc2047_encode(name)
 447
 448     # Force the name to be UTF-8
 449     name = force_to_utf8(name)
 450
 451     if name.find(',') != -1 or name.find('.') != -1:
 452         rfc822_maint = "%s (%s)" % (email, name)
 453         rfc2047_maint = "%s (%s)" % (email, rfc2047_name)
 454     else:
 455         rfc822_maint = "%s <%s>" % (name, email)
 456         rfc2047_maint = "%s <%s>" % (rfc2047_name, email)
 457
 458     if email.find("@") == -1 and email.find("buildd_") != 0:
 459         raise ParseMaintError, "No @ found in email address part."
 460
 461     return (rfc822_maint, rfc2047_maint, name, email)
 462
 463 ################################################################################
 464
 465 # sendmail wrapper, takes _either_ a message string or a file as arguments
 466 def send_mail (message, filename=""):
 467         # If we've been passed a string dump it into a temporary file
 468     if message:
 469         filename = tempfile.mktemp()
 470         fd = os.open(filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0700)
 471         os.write (fd, message)
 472         os.close (fd)
 473
 474     # Invoke sendmail
 475     (result, output) = commands.getstatusoutput("%s < %s" % (Cnf["Dinstall::SendmailCommand"], filename))
 476     if (result != 0):
 477         raise SendmailFailedError, output
 478
 479     # Clean up any temporary files
 480     if message:
 481         os.unlink (filename)
 482
 483 ################################################################################
 484
 485 def poolify (source, component):
 486     if component:
 487         component += '/'
 488     if source[:3] == "lib":
 489         return component + source[:4] + '/' + source + '/'
 490     else:
 491         return component + source[:1] + '/' + source + '/'
 492
 493 ################################################################################
 494
 495 def move (src, dest, overwrite = 0, perms = 0664):
 496     if os.path.exists(dest) and os.path.isdir(dest):
 497         dest_dir = dest
 498     else:
 499         dest_dir = os.path.dirname(dest)
 500     if not os.path.exists(dest_dir):
 501         umask = os.umask(00000)
 502         os.makedirs(dest_dir, 02775)
 503         os.umask(umask)
 504     #print "Moving %s to %s..." % (src, dest)
 505     if os.path.exists(dest) and os.path.isdir(dest):
 506         dest += '/' + os.path.basename(src)
 507     # Don't overwrite unless forced to
 508     if os.path.exists(dest):
 509         if not overwrite:
 510             fubar("Can't move %s to %s - file already exists." % (src, dest))
 511         else:
 512             if not os.access(dest, os.W_OK):
 513                 fubar("Can't move %s to %s - can't write to existing file." % (src, dest))
 514     shutil.copy2(src, dest)
 515     os.chmod(dest, perms)
 516     os.unlink(src)
 517
 518 def copy (src, dest, overwrite = 0, perms = 0664):
 519     if os.path.exists(dest) and os.path.isdir(dest):
 520         dest_dir = dest
 521     else:
 522         dest_dir = os.path.dirname(dest)
 523     if not os.path.exists(dest_dir):
 524         umask = os.umask(00000)
 525         os.makedirs(dest_dir, 02775)
 526         os.umask(umask)
 527     #print "Copying %s to %s..." % (src, dest)
 528     if os.path.exists(dest) and os.path.isdir(dest):
 529         dest += '/' + os.path.basename(src)
 530     # Don't overwrite unless forced to
 531     if os.path.exists(dest):
 532         if not overwrite:
 533             raise FileExistsError
 534         else:
 535             if not os.access(dest, os.W_OK):
 536                 raise CantOverwriteError
 537     shutil.copy2(src, dest)
 538     os.chmod(dest, perms)
 539
 540 ################################################################################
 541
 542 def where_am_i ():
 543     res = socket.gethostbyaddr(socket.gethostname())
 544     database_hostname = Cnf.get("Config::" + res[0] + "::DatabaseHostname")
 545     if database_hostname:
 546         return database_hostname
 547     else:
 548         return res[0]
 549
 550 def which_conf_file ():
 551     res = socket.gethostbyaddr(socket.gethostname())
 552     if Cnf.get("Config::" + res[0] + "::DakConfig"):
 553         return Cnf["Config::" + res[0] + "::DakConfig"]
 554     else:
 555         return default_config
 556
 557 def which_apt_conf_file ():
 558     res = socket.gethostbyaddr(socket.gethostname())
 559     if Cnf.get("Config::" + res[0] + "::AptConfig"):
 560         return Cnf["Config::" + res[0] + "::AptConfig"]
 561     else:
 562         return default_apt_config
 563
 564 def which_alias_file():
 565     hostname = socket.gethostbyaddr(socket.gethostname())[0]
 566     aliasfn = '/var/lib/misc/'+hostname+'/forward-alias'
 567     if os.path.exists(aliasfn):
 568         return aliasfn
 569     else:
 570         return None
 571
 572 ################################################################################
 573
 574 # Escape characters which have meaning to SQL's regex comparison operator ('~')
 575 # (woefully incomplete)
 576
 577 def regex_safe (s):
 578     s = s.replace('+', '\\\\+')
 579     s = s.replace('.', '\\\\.')
 580     return s
 581
 582 ################################################################################
 583
 584 # Perform a substition of template
 585 def TemplateSubst(map, filename):
 586     file = open_file(filename)
 587     template = file.read()
 588     for x in map.keys():
 589         template = template.replace(x,map[x])
 590     file.close()
 591     return template
 592
 593 ################################################################################
 594
 595 def fubar(msg, exit_code=1):
 596     sys.stderr.write("E: %s\n" % (msg))
 597     sys.exit(exit_code)
 598
 599 def warn(msg):
 600     sys.stderr.write("W: %s\n" % (msg))
 601
 602 ################################################################################
 603
 604 # Returns the user name with a laughable attempt at rfc822 conformancy
 605 # (read: removing stray periods).
 606 def whoami ():
 607     return pwd.getpwuid(os.getuid())[4].split(',')[0].replace('.', '')
 608
 609 ################################################################################
 610
 611 def size_type (c):
 612     t  = " B"
 613     if c > 10240:
 614         c = c / 1024
 615         t = " KB"
 616     if c > 10240:
 617         c = c / 1024
 618         t = " MB"
 619     return ("%d%s" % (c, t))
 620
 621 ################################################################################
 622
 623 def cc_fix_changes (changes):
 624     o = changes.get("architecture", "")
 625     if o:
 626         del changes["architecture"]
 627     changes["architecture"] = {}
 628     for j in o.split():
 629         changes["architecture"][j] = 1
 630
 631 # Sort by source name, source version, 'have source', and then by filename
 632 def changes_compare (a, b):
 633     try:
 634         a_changes = parse_changes(a)
 635     except:
 636         return -1
 637
 638     try:
 639         b_changes = parse_changes(b)
 640     except:
 641         return 1
 642
 643     cc_fix_changes (a_changes)
 644     cc_fix_changes (b_changes)
 645
 646     # Sort by source name
 647     a_source = a_changes.get("source")
 648     b_source = b_changes.get("source")
 649     q = cmp (a_source, b_source)
 650     if q:
 651         return q
 652
 653     # Sort by source version
 654     a_version = a_changes.get("version", "0")
 655     b_version = b_changes.get("version", "0")
 656     q = apt_pkg.VersionCompare(a_version, b_version)
 657     if q:
 658         return q
 659
 660     # Sort by 'have source'
 661     a_has_source = a_changes["architecture"].get("source")
 662     b_has_source = b_changes["architecture"].get("source")
 663     if a_has_source and not b_has_source:
 664         return -1
 665     elif b_has_source and not a_has_source:
 666         return 1
 667
 668     # Fall back to sort by filename
 669     return cmp(a, b)
 670
 671 ################################################################################
 672
 673 def find_next_free (dest, too_many=100):
 674     extra = 0
 675     orig_dest = dest
 676     while os.path.exists(dest) and extra < too_many:
 677         dest = orig_dest + '.' + repr(extra)
 678         extra += 1
 679     if extra >= too_many:
 680         raise NoFreeFilenameError
 681     return dest
 682
 683 ################################################################################
 684
 685 def result_join (original, sep = '\t'):
 686     list = []
 687     for i in xrange(len(original)):
 688         if original[i] == None:
 689             list.append("")
 690         else:
 691             list.append(original[i])
 692     return sep.join(list)
 693
 694 ################################################################################
 695
 696 def prefix_multi_line_string(str, prefix, include_blank_lines=0):
 697     out = ""
 698     for line in str.split('\n'):
 699         line = line.strip()
 700         if line or include_blank_lines:
 701             out += "%s%s\n" % (prefix, line)
 702     # Strip trailing new line
 703     if out:
 704         out = out[:-1]
 705     return out
 706
 707 ################################################################################
 708
 709 def validate_changes_file_arg(filename, require_changes=1):
 710     """'filename' is either a .changes or .dak file.  If 'filename' is a
 711 .dak file, it's changed to be the corresponding .changes file.  The
 712 function then checks if the .changes file a) exists and b) is
 713 readable and returns the .changes filename if so.  If there's a
 714 problem, the next action depends on the option 'require_changes'
 715 argument:
 716
 717  o If 'require_changes' == -1, errors are ignored and the .changes
 718                                filename is returned.
 719  o If 'require_changes' == 0, a warning is given and 'None' is returned.
 720  o If 'require_changes' == 1, a fatal error is raised.
 721 """
 722     error = None
 723
 724     orig_filename = filename
 725     if filename.endswith(".dak"):
 726         filename = filename[:-4]+".changes"
 727
 728     if not filename.endswith(".changes"):
 729         error = "invalid file type; not a changes file"
 730     else:
 731         if not os.access(filename,os.R_OK):
 732             if os.path.exists(filename):
 733                 error = "permission denied"
 734             else:
 735                 error = "file not found"
 736
 737     if error:
 738         if require_changes == 1:
 739             fubar("%s: %s." % (orig_filename, error))
 740         elif require_changes == 0:
 741             warn("Skipping %s - %s" % (orig_filename, error))
 742             return None
 743         else: # We only care about the .dak file
 744             return filename
 745     else:
 746         return filename
 747
 748 ################################################################################
 749
 750 def real_arch(arch):
 751     return (arch != "source" and arch != "all")
 752
 753 ################################################################################
 754
 755 def join_with_commas_and(list):
 756     if len(list) == 0: return "nothing"
 757     if len(list) == 1: return list[0]
 758     return ", ".join(list[:-1]) + " and " + list[-1]
 759
 760 ################################################################################
 761
 762 def pp_deps (deps):
 763     pp_deps = []
 764     for atom in deps:
 765         (pkg, version, constraint) = atom
 766         if constraint:
 767             pp_dep = "%s (%s %s)" % (pkg, constraint, version)
 768         else:
 769             pp_dep = pkg
 770         pp_deps.append(pp_dep)
 771     return " |".join(pp_deps)
 772
 773 ################################################################################
 774
 775 def get_conf():
 776     return Cnf
 777
 778 ################################################################################
 779
 780 # Handle -a, -c and -s arguments; returns them as SQL constraints
 781 def parse_args(Options):
 782     # Process suite
 783     if Options["Suite"]:
 784         suite_ids_list = []
 785         for suite in split_args(Options["Suite"]):
 786             suite_id = database.get_suite_id(suite)
 787             if suite_id == -1:
 788                 warn("suite '%s' not recognised." % (suite))
 789             else:
 790                 suite_ids_list.append(suite_id)
 791         if suite_ids_list:
 792             con_suites = "AND su.id IN (%s)" % ", ".join([ str(i) for i in suite_ids_list ])
 793         else:
 794             fubar("No valid suite given.")
 795     else:
 796         con_suites = ""
 797
 798     # Process component
 799     if Options["Component"]:
 800         component_ids_list = []
 801         for component in split_args(Options["Component"]):
 802             component_id = database.get_component_id(component)
 803             if component_id == -1:
 804                 warn("component '%s' not recognised." % (component))
 805             else:
 806                 component_ids_list.append(component_id)
 807         if component_ids_list:
 808             con_components = "AND c.id IN (%s)" % ", ".join([ str(i) for i in component_ids_list ])
 809         else:
 810             fubar("No valid component given.")
 811     else:
 812         con_components = ""
 813
 814     # Process architecture
 815     con_architectures = ""
 816     if Options["Architecture"]:
 817         arch_ids_list = []
 818         check_source = 0
 819         for architecture in split_args(Options["Architecture"]):
 820             if architecture == "source":
 821                 check_source = 1
 822             else:
 823                 architecture_id = database.get_architecture_id(architecture)
 824                 if architecture_id == -1:
 825                     warn("architecture '%s' not recognised." % (architecture))
 826                 else:
 827                     arch_ids_list.append(architecture_id)
 828         if arch_ids_list:
 829             con_architectures = "AND a.id IN (%s)" % ", ".join([ str(i) for i in arch_ids_list ])
 830         else:
 831             if not check_source:
 832                 fubar("No valid architecture given.")
 833     else:
 834         check_source = 1
 835
 836     return (con_suites, con_architectures, con_components, check_source)
 837
 838 ################################################################################
 839
 840 # Inspired(tm) by Bryn Keller's print_exc_plus (See
 841 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52215)
 842
 843 def print_exc():
 844     tb = sys.exc_info()[2]
 845     while tb.tb_next:
 846         tb = tb.tb_next
 847     stack = []
 848     frame = tb.tb_frame
 849     while frame:
 850         stack.append(frame)
 851         frame = frame.f_back
 852     stack.reverse()
 853     traceback.print_exc()
 854     for frame in stack:
 855         print "\nFrame %s in %s at line %s" % (frame.f_code.co_name,
 856                                              frame.f_code.co_filename,
 857                                              frame.f_lineno)
 858         for key, value in frame.f_locals.items():
 859             print "\t%20s = " % key,
 860             try:
 861                 print value
 862             except:
 863                 print "<unable to print>"
 864
 865 ################################################################################
 866
 867 def try_with_debug(function):
 868     try:
 869         function()
 870     except SystemExit:
 871         raise
 872     except:
 873         print_exc()
 874
 875 ################################################################################
 876
 877 # Function for use in sorting lists of architectures.
 878 # Sorts normally except that 'source' dominates all others.
 879
 880 def arch_compare_sw (a, b):
 881     if a == "source" and b == "source":
 882         return 0
 883     elif a == "source":
 884         return -1
 885     elif b == "source":
 886         return 1
 887
 888     return cmp (a, b)
 889
 890 ################################################################################
 891
 892 # Split command line arguments which can be separated by either commas
 893 # or whitespace.  If dwim is set, it will complain about string ending
 894 # in comma since this usually means someone did 'dak ls -a i386, m68k
 895 # foo' or something and the inevitable confusion resulting from 'm68k'
 896 # being treated as an argument is undesirable.
 897
 898 def split_args (s, dwim=1):
 899     if s.find(",") == -1:
 900         return s.split()
 901     else:
 902         if s[-1:] == "," and dwim:
 903             fubar("split_args: found trailing comma, spurious space maybe?")
 904         return s.split(",")
 905
 906 ################################################################################
 907
 908 def Dict(**dict): return dict
 909
 910 ########################################
 911
 912 # Our very own version of commands.getouputstatus(), hacked to support
 913 # gpgv's status fd.
 914 def gpgv_get_status_output(cmd, status_read, status_write):
 915     cmd = ['/bin/sh', '-c', cmd]
 916     p2cread, p2cwrite = os.pipe()
 917     c2pread, c2pwrite = os.pipe()
 918     errout, errin = os.pipe()
 919     pid = os.fork()
 920     if pid == 0:
 921         # Child
 922         os.close(0)
 923         os.close(1)
 924         os.dup(p2cread)
 925         os.dup(c2pwrite)
 926         os.close(2)
 927         os.dup(errin)
 928         for i in range(3, 256):
 929             if i != status_write:
 930                 try:
 931                     os.close(i)
 932                 except:
 933                     pass
 934         try:
 935             os.execvp(cmd[0], cmd)
 936         finally:
 937             os._exit(1)
 938
 939     # Parent
 940     os.close(p2cread)
 941     os.dup2(c2pread, c2pwrite)
 942     os.dup2(errout, errin)
 943
 944     output = status = ""
 945     while 1:
 946         i, o, e = select.select([c2pwrite, errin, status_read], [], [])
 947         more_data = []
 948         for fd in i:
 949             r = os.read(fd, 8196)
 950             if len(r) > 0:
 951                 more_data.append(fd)
 952                 if fd == c2pwrite or fd == errin:
 953                     output += r
 954                 elif fd == status_read:
 955                     status += r
 956                 else:
 957                     fubar("Unexpected file descriptor [%s] returned from select\n" % (fd))
 958         if not more_data:
 959             pid, exit_status = os.waitpid(pid, 0)
 960             try:
 961                 os.close(status_write)
 962                 os.close(status_read)
 963                 os.close(c2pread)
 964                 os.close(c2pwrite)
 965                 os.close(p2cwrite)
 966                 os.close(errin)
 967                 os.close(errout)
 968             except:
 969                 pass
 970             break
 971
 972     return output, status, exit_status
 973
 974 ################################################################################
 975
 976 def process_gpgv_output(status):
 977     # Process the status-fd output
 978     keywords = {}
 979     internal_error = ""
 980     for line in status.split('\n'):
 981         line = line.strip()
 982         if line == "":
 983             continue
 984         split = line.split()
 985         if len(split) < 2:
 986             internal_error += "gpgv status line is malformed (< 2 atoms) ['%s'].\n" % (line)
 987             continue
 988         (gnupg, keyword) = split[:2]
 989         if gnupg != "[GNUPG:]":
 990             internal_error += "gpgv status line is malformed (incorrect prefix '%s').\n" % (gnupg)
 991             continue
 992         args = split[2:]
 993         if keywords.has_key(keyword) and keyword not in [ "NODATA", "SIGEXPIRED", "KEYEXPIRED" ]:
 994             internal_error += "found duplicate status token ('%s').\n" % (keyword)
 995             continue
 996         else:
 997             keywords[keyword] = args
 998
 999     return (keywords, internal_error)
1000
1001 ################################################################################
1002
1003 def retrieve_key (filename, keyserver=None, keyring=None):
1004     """Retrieve the key that signed 'filename' from 'keyserver' and
1005 add it to 'keyring'.  Returns nothing on success, or an error message
1006 on error."""
1007
1008     # Defaults for keyserver and keyring
1009     if not keyserver:
1010         keyserver = Cnf["Dinstall::KeyServer"]
1011     if not keyring:
1012         keyring = Cnf.ValueList("Dinstall::GPGKeyring")[0]
1013
1014     # Ensure the filename contains no shell meta-characters or other badness
1015     if not re_taint_free.match(filename):
1016         return "%s: tainted filename" % (filename)
1017
1018     # Invoke gpgv on the file
1019     status_read, status_write = os.pipe();
1020     cmd = "gpgv --status-fd %s --keyring /dev/null %s" % (status_write, filename)
1021     (_, status, _) = gpgv_get_status_output(cmd, status_read, status_write)
1022
1023     # Process the status-fd output
1024     (keywords, internal_error) = process_gpgv_output(status)
1025     if internal_error:
1026         return internal_error
1027
1028     if not keywords.has_key("NO_PUBKEY"):
1029         return "didn't find expected NO_PUBKEY in gpgv status-fd output"
1030
1031     fingerprint = keywords["NO_PUBKEY"][0]
1032     # XXX - gpg sucks.  You can't use --secret-keyring=/dev/null as
1033     # it'll try to create a lockfile in /dev.  A better solution might
1034     # be a tempfile or something.
1035     cmd = "gpg --no-default-keyring --secret-keyring=%s --no-options" \
1036           % (Cnf["Dinstall::SigningKeyring"])
1037     cmd += " --keyring %s --keyserver %s --recv-key %s" \
1038            % (keyring, keyserver, fingerprint)
1039     (result, output) = commands.getstatusoutput(cmd)
1040     if (result != 0):
1041         return "'%s' failed with exit code %s" % (cmd, result)
1042
1043     return ""
1044
1045 ################################################################################
1046
1047 def gpg_keyring_args(keyrings=None):
1048     if not keyrings:
1049         keyrings = Cnf.ValueList("Dinstall::GPGKeyring")
1050
1051     return " ".join(["--keyring %s" % x for x in keyrings])
1052
1053 ################################################################################
1054
1055 def check_signature (sig_filename, reject, data_filename="", keyrings=None, autofetch=None):
1056     """Check the signature of a file and return the fingerprint if the
1057 signature is valid or 'None' if it's not.  The first argument is the
1058 filename whose signature should be checked.  The second argument is a
1059 reject function and is called when an error is found.  The reject()
1060 function must allow for two arguments: the first is the error message,
1061 the second is an optional prefix string.  It's possible for reject()
1062 to be called more than once during an invocation of check_signature().
1063 The third argument is optional and is the name of the files the
1064 detached signature applies to.  The fourth argument is optional and is
1065 a *list* of keyrings to use.  'autofetch' can either be None, True or
1066 False.  If None, the default behaviour specified in the config will be
1067 used."""
1068
1069     # Ensure the filename contains no shell meta-characters or other badness
1070     if not re_taint_free.match(sig_filename):
1071         reject("!!WARNING!! tainted signature filename: '%s'." % (sig_filename))
1072         return None
1073
1074     if data_filename and not re_taint_free.match(data_filename):
1075         reject("!!WARNING!! tainted data filename: '%s'." % (data_filename))
1076         return None
1077
1078     if not keyrings:
1079         keyrings = Cnf.ValueList("Dinstall::GPGKeyring")
1080
1081     # Autofetch the signing key if that's enabled
1082     if autofetch == None:
1083         autofetch = Cnf.get("Dinstall::KeyAutoFetch")
1084     if autofetch:
1085         error_msg = retrieve_key(sig_filename)
1086         if error_msg:
1087             reject(error_msg)
1088             return None
1089
1090     # Build the command line
1091     status_read, status_write = os.pipe();
1092     cmd = "gpgv --status-fd %s %s %s %s" % (
1093         status_write, gpg_keyring_args(keyrings), sig_filename, data_filename)
1094
1095     # Invoke gpgv on the file
1096     (output, status, exit_status) = gpgv_get_status_output(cmd, status_read, status_write)
1097
1098     # Process the status-fd output
1099     (keywords, internal_error) = process_gpgv_output(status)
1100
1101     # If we failed to parse the status-fd output, let's just whine and bail now
1102     if internal_error:
1103         reject("internal error while performing signature check on %s." % (sig_filename))
1104         reject(internal_error, "")
1105         reject("Please report the above errors to the Archive maintainers by replying to this mail.", "")
1106         return None
1107
1108     bad = ""
1109     # Now check for obviously bad things in the processed output
1110     if keywords.has_key("KEYREVOKED"):
1111         reject("The key used to sign %s has been revoked." % (sig_filename))
1112         bad = 1
1113     if keywords.has_key("BADSIG"):
1114         reject("bad signature on %s." % (sig_filename))
1115         bad = 1
1116     if keywords.has_key("ERRSIG") and not keywords.has_key("NO_PUBKEY"):
1117         reject("failed to check signature on %s." % (sig_filename))
1118         bad = 1
1119     if keywords.has_key("NO_PUBKEY"):
1120         args = keywords["NO_PUBKEY"]
1121         if len(args) >= 1:
1122             key = args[0]
1123         reject("The key (0x%s) used to sign %s wasn't found in the keyring(s)." % (key, sig_filename))
1124         bad = 1
1125     if keywords.has_key("BADARMOR"):
1126         reject("ASCII armour of signature was corrupt in %s." % (sig_filename))
1127         bad = 1
1128     if keywords.has_key("NODATA"):
1129         reject("no signature found in %s." % (sig_filename))
1130         bad = 1
1131     if keywords.has_key("KEYEXPIRED") and not keywords.has_key("GOODSIG"):
1132         args = keywords["KEYEXPIRED"]
1133         if len(args) >= 1:
1134             key = args[0]
1135         reject("The key (0x%s) used to sign %s has expired." % (key, sig_filename))
1136         bad = 1
1137
1138     if bad:
1139         return None
1140
1141     # Next check gpgv exited with a zero return code
1142     if exit_status:
1143         reject("gpgv failed while checking %s." % (sig_filename))
1144         if status.strip():
1145             reject(prefix_multi_line_string(status, " [GPG status-fd output:] "), "")
1146         else:
1147             reject(prefix_multi_line_string(output, " [GPG output:] "), "")
1148         return None
1149
1150     # Sanity check the good stuff we expect
1151     if not keywords.has_key("VALIDSIG"):
1152         reject("signature on %s does not appear to be valid [No VALIDSIG]." % (sig_filename))
1153         bad = 1
1154     else:
1155         args = keywords["VALIDSIG"]
1156         if len(args) < 1:
1157             reject("internal error while checking signature on %s." % (sig_filename))
1158             bad = 1
1159         else:
1160             fingerprint = args[0]
1161     if not keywords.has_key("GOODSIG"):
1162         reject("signature on %s does not appear to be valid [No GOODSIG]." % (sig_filename))
1163         bad = 1
1164     if not keywords.has_key("SIG_ID"):
1165         reject("signature on %s does not appear to be valid [No SIG_ID]." % (sig_filename))
1166         bad = 1
1167
1168     # Finally ensure there's not something we don't recognise
1169     known_keywords = Dict(VALIDSIG="",SIG_ID="",GOODSIG="",BADSIG="",ERRSIG="",
1170                           SIGEXPIRED="",KEYREVOKED="",NO_PUBKEY="",BADARMOR="",
1171                           NODATA="",NOTATION_DATA="",NOTATION_NAME="",KEYEXPIRED="")
1172
1173     for keyword in keywords.keys():
1174         if not known_keywords.has_key(keyword):
1175             reject("found unknown status token '%s' from gpgv with args '%r' in %s." % (keyword, keywords[keyword], sig_filename))
1176             bad = 1
1177
1178     if bad:
1179         return None
1180     else:
1181         return fingerprint
1182
1183 ################################################################################
1184
1185 def gpg_get_key_addresses(fingerprint):
1186     """retreive email addresses from gpg key uids for a given fingerprint"""
1187     addresses = key_uid_email_cache.get(fingerprint)
1188     if addresses != None:
1189         return addresses
1190     addresses = set()
1191     cmd = "gpg --no-default-keyring %s --fingerprint %s" \
1192                 % (gpg_keyring_args(), fingerprint)
1193     (result, output) = commands.getstatusoutput(cmd)
1194     if result == 0:
1195         for l in output.split('\n'):
1196             m = re_gpg_uid.match(l)
1197             if m:
1198                 addresses.add(m.group(1))
1199     key_uid_email_cache[fingerprint] = addresses
1200     return addresses
1201
1202 ################################################################################
1203
1204 # Inspired(tm) by http://www.zopelabs.com/cookbook/1022242603
1205
1206 def wrap(paragraph, max_length, prefix=""):
1207     line = ""
1208     s = ""
1209     have_started = 0
1210     words = paragraph.split()
1211
1212     for word in words:
1213         word_size = len(word)
1214         if word_size > max_length:
1215             if have_started:
1216                 s += line + '\n' + prefix
1217             s += word + '\n' + prefix
1218         else:
1219             if have_started:
1220                 new_length = len(line) + word_size + 1
1221                 if new_length > max_length:
1222                     s += line + '\n' + prefix
1223                     line = word
1224                 else:
1225                     line += ' ' + word
1226             else:
1227                 line = word
1228         have_started = 1
1229
1230     if have_started:
1231         s += line
1232
1233     return s
1234
1235 ################################################################################
1236
1237 # Relativize an absolute symlink from 'src' -> 'dest' relative to 'root'.
1238 # Returns fixed 'src'
1239 def clean_symlink (src, dest, root):
1240     src = src.replace(root, '', 1)
1241     dest = dest.replace(root, '', 1)
1242     dest = os.path.dirname(dest)
1243     new_src = '../' * len(dest.split('/'))
1244     return new_src + src
1245
1246 ################################################################################
1247
1248 def temp_filename(directory=None, dotprefix=None, perms=0700):
1249     """Return a secure and unique filename by pre-creating it.
1250 If 'directory' is non-null, it will be the directory the file is pre-created in.
1251 If 'dotprefix' is non-null, the filename will be prefixed with a '.'."""
1252
1253     if directory:
1254         old_tempdir = tempfile.tempdir
1255         tempfile.tempdir = directory
1256
1257     filename = tempfile.mktemp()
1258
1259     if dotprefix:
1260         filename = "%s/.%s" % (os.path.dirname(filename), os.path.basename(filename))
1261     fd = os.open(filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, perms)
1262     os.close(fd)
1263
1264     if directory:
1265         tempfile.tempdir = old_tempdir
1266
1267     return filename
1268
1269 ################################################################################
1270
1271 # checks if the user part of the email is listed in the alias file
1272
1273 def is_email_alias(email):
1274     global alias_cache
1275     if alias_cache == None:
1276         aliasfn = which_alias_file()
1277         alias_cache = set()
1278         if aliasfn:
1279             for l in open(aliasfn):
1280                 alias_cache.add(l.split(':')[0])
1281     uid = email.split('@')[0]
1282     return uid in alias_cache
1283
1284 ################################################################################
1285
1286 apt_pkg.init()
1287
1288 Cnf = apt_pkg.newConfiguration()
1289 apt_pkg.ReadConfigFileISC(Cnf,default_config)
1290
1291 if which_conf_file() != default_config:
1292     apt_pkg.ReadConfigFileISC(Cnf,which_conf_file())
1293
1294 ################################################################################