daklib/queue.py

   1 #!/usr/bin/env python
   2 # vim:set et sw=4:
   3
   4 """
   5 Queue utility functions for dak
   6
   7 @contact: Debian FTP Master <ftpmaster@debian.org>
   8 @copyright: 2001 - 2006 James Troup <james@nocrew.org>
   9 @copyright: 2009  Joerg Jaspert <joerg@debian.org>
  10 @license: GNU General Public License version 2 or later
  11 """
  12
  13 # This program is free software; you can redistribute it and/or modify
  14 # it under the terms of the GNU General Public License as published by
  15 # the Free Software Foundation; either version 2 of the License, or
  16 # (at your option) any later version.
  17
  18 # This program is distributed in the hope that it will be useful,
  19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 # GNU General Public License for more details.
  22
  23 # You should have received a copy of the GNU General Public License
  24 # along with this program; if not, write to the Free Software
  25 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26
  27 ###############################################################################
  28
  29 import errno
  30 import os
  31 import pg
  32 import stat
  33 import sys
  34 import time
  35 import apt_inst
  36 import apt_pkg
  37 import utils
  38 import commands
  39 import shutil
  40 import textwrap
  41 import tempfile
  42 from types import *
  43
  44 import yaml
  45
  46 from dak_exceptions import *
  47 from changes import *
  48 from regexes import *
  49 from config import Config
  50 from holding import Holding
  51 from dbconn import *
  52 from summarystats import SummaryStats
  53 from utils import parse_changes, check_dsc_files
  54 from textutils import fix_maintainer
  55 from binary import Binary
  56
  57 ###############################################################################
  58
  59 def get_type(f, session):
  60     """
  61     Get the file type of C{f}
  62
  63     @type f: dict
  64     @param f: file entry from Changes object
  65
  66     @type session: SQLA Session
  67     @param session: SQL Alchemy session object
  68
  69     @rtype: string
  70     @return: filetype
  71
  72     """
  73     # Determine the type
  74     if f.has_key("dbtype"):
  75         file_type = f["dbtype"]
  76     elif re_source_ext.match(f["type"]):
  77         file_type = "dsc"
  78     else:
  79         utils.fubar("invalid type (%s) for new.  Dazed, confused and sure as heck not continuing." % (file_type))
  80
  81     # Validate the override type
  82     type_id = get_override_type(file_type, session)
  83     if type_id is None:
  84         utils.fubar("invalid type (%s) for new.  Say wha?" % (file_type))
  85
  86     return file_type
  87
  88 ################################################################################
  89
  90 # Determine what parts in a .changes are NEW
  91
  92 def determine_new(changes, files, warn=1):
  93     """
  94     Determine what parts in a C{changes} file are NEW.
  95
  96     @type changes: Upload.Pkg.changes dict
  97     @param changes: Changes dictionary
  98
  99     @type files: Upload.Pkg.files dict
 100     @param files: Files dictionary
 101
 102     @type warn: bool
 103     @param warn: Warn if overrides are added for (old)stable
 104
 105     @rtype: dict
 106     @return: dictionary of NEW components.
 107
 108     """
 109     new = {}
 110
 111     session = DBConn().session()
 112
 113     # Build up a list of potentially new things
 114     for name, f in files.items():
 115         # Skip byhand elements
 116         if f["type"] == "byhand":
 117             continue
 118         pkg = f["package"]
 119         priority = f["priority"]
 120         section = f["section"]
 121         file_type = get_type(f, session)
 122         component = f["component"]
 123
 124         if file_type == "dsc":
 125             priority = "source"
 126
 127         if not new.has_key(pkg):
 128             new[pkg] = {}
 129             new[pkg]["priority"] = priority
 130             new[pkg]["section"] = section
 131             new[pkg]["type"] = file_type
 132             new[pkg]["component"] = component
 133             new[pkg]["files"] = []
 134         else:
 135             old_type = new[pkg]["type"]
 136             if old_type != file_type:
 137                 # source gets trumped by deb or udeb
 138                 if old_type == "dsc":
 139                     new[pkg]["priority"] = priority
 140                     new[pkg]["section"] = section
 141                     new[pkg]["type"] = file_type
 142                     new[pkg]["component"] = component
 143
 144         new[pkg]["files"].append(name)
 145
 146         if f.has_key("othercomponents"):
 147             new[pkg]["othercomponents"] = f["othercomponents"]
 148
 149     for suite in changes["suite"].keys():
 150         for pkg in new.keys():
 151             ql = get_override(pkg, suite, new[pkg]["component"], new[pkg]["type"], session)
 152             if len(ql) > 0:
 153                 for file_entry in new[pkg]["files"]:
 154                     if files[file_entry].has_key("new"):
 155                         del files[file_entry]["new"]
 156                 del new[pkg]
 157
 158     if warn:
 159         for s in ['stable', 'oldstable']:
 160             if changes["suite"].has_key(s):
 161                 print "WARNING: overrides will be added for %s!" % s
 162         for pkg in new.keys():
 163             if new[pkg].has_key("othercomponents"):
 164                 print "WARNING: %s already present in %s distribution." % (pkg, new[pkg]["othercomponents"])
 165
 166     session.close()
 167
 168     return new
 169
 170 ################################################################################
 171
 172 def check_valid(new):
 173     """
 174     Check if section and priority for NEW packages exist in database.
 175     Additionally does sanity checks:
 176       - debian-installer packages have to be udeb (or source)
 177       - non debian-installer packages can not be udeb
 178       - source priority can only be assigned to dsc file types
 179
 180     @type new: dict
 181     @param new: Dict of new packages with their section, priority and type.
 182
 183     """
 184     for pkg in new.keys():
 185         section_name = new[pkg]["section"]
 186         priority_name = new[pkg]["priority"]
 187         file_type = new[pkg]["type"]
 188
 189         section = get_section(section_name)
 190         if section is None:
 191             new[pkg]["section id"] = -1
 192         else:
 193             new[pkg]["section id"] = section.section_id
 194
 195         priority = get_priority(priority_name)
 196         if priority is None:
 197             new[pkg]["priority id"] = -1
 198         else:
 199             new[pkg]["priority id"] = priority.priority_id
 200
 201         # Sanity checks
 202         di = section_name.find("debian-installer") != -1
 203
 204         # If d-i, we must be udeb and vice-versa
 205         if     (di and file_type not in ("udeb", "dsc")) or \
 206            (not di and file_type == "udeb"):
 207             new[pkg]["section id"] = -1
 208
 209         # If dsc we need to be source and vice-versa
 210         if (priority == "source" and file_type != "dsc") or \
 211            (priority != "source" and file_type == "dsc"):
 212             new[pkg]["priority id"] = -1
 213
 214 ###############################################################################
 215
 216 def check_status(files):
 217     new = byhand = 0
 218     for f in files.keys():
 219         if files[f]["type"] == "byhand":
 220             byhand = 1
 221         elif files[f].has_key("new"):
 222             new = 1
 223     return (new, byhand)
 224
 225 ###############################################################################
 226
 227 # Used by Upload.check_timestamps
 228 class TarTime(object):
 229     def __init__(self, future_cutoff, past_cutoff):
 230         self.reset()
 231         self.future_cutoff = future_cutoff
 232         self.past_cutoff = past_cutoff
 233
 234     def reset(self):
 235         self.future_files = {}
 236         self.ancient_files = {}
 237
 238     def callback(self, Kind, Name, Link, Mode, UID, GID, Size, MTime, Major, Minor):
 239         if MTime > self.future_cutoff:
 240             self.future_files[Name] = MTime
 241         if MTime < self.past_cutoff:
 242             self.ancient_files[Name] = MTime
 243
 244 ###############################################################################
 245
 246 class Upload(object):
 247     """
 248     Everything that has to do with an upload processed.
 249
 250     """
 251     def __init__(self):
 252         self.logger = None
 253         self.pkg = Changes()
 254         self.reset()
 255
 256     ###########################################################################
 257
 258     def reset (self):
 259         """ Reset a number of internal variables."""
 260
 261         # Initialize the substitution template map
 262         cnf = Config()
 263         self.Subst = {}
 264         self.Subst["__ADMIN_ADDRESS__"] = cnf["Dinstall::MyAdminAddress"]
 265         self.Subst["__BUG_SERVER__"] = cnf["Dinstall::BugServer"]
 266         self.Subst["__DISTRO__"] = cnf["Dinstall::MyDistribution"]
 267         self.Subst["__DAK_ADDRESS__"] = cnf["Dinstall::MyEmailAddress"]
 268
 269         self.rejects = []
 270         self.warnings = []
 271         self.notes = []
 272
 273         self.pkg.reset()
 274
 275     def package_info(self):
 276         msg = ''
 277
 278         if len(self.rejects) > 0:
 279             msg += "Reject Reasons:\n"
 280             msg += "\n".join(self.rejects)
 281
 282         if len(self.warnings) > 0:
 283             msg += "Warnings:\n"
 284             msg += "\n".join(self.warnings)
 285
 286         if len(self.notes) > 0:
 287             msg += "Notes:\n"
 288             msg += "\n".join(self.notes)
 289
 290         return msg
 291
 292     ###########################################################################
 293     def update_subst(self):
 294         """ Set up the per-package template substitution mappings """
 295
 296         cnf = Config()
 297
 298         # If 'dak process-unchecked' crashed out in the right place, architecture may still be a string.
 299         if not self.pkg.changes.has_key("architecture") or not \
 300            isinstance(self.pkg.changes["architecture"], DictType):
 301             self.pkg.changes["architecture"] = { "Unknown" : "" }
 302
 303         # and maintainer2047 may not exist.
 304         if not self.pkg.changes.has_key("maintainer2047"):
 305             self.pkg.changes["maintainer2047"] = cnf["Dinstall::MyEmailAddress"]
 306
 307         self.Subst["__ARCHITECTURE__"] = " ".join(self.pkg.changes["architecture"].keys())
 308         self.Subst["__CHANGES_FILENAME__"] = os.path.basename(self.pkg.changes_file)
 309         self.Subst["__FILE_CONTENTS__"] = self.pkg.changes.get("filecontents", "")
 310
 311         # For source uploads the Changed-By field wins; otherwise Maintainer wins.
 312         if self.pkg.changes["architecture"].has_key("source") and \
 313            self.pkg.changes["changedby822"] != "" and \
 314            (self.pkg.changes["changedby822"] != self.pkg.changes["maintainer822"]):
 315
 316             self.Subst["__MAINTAINER_FROM__"] = self.pkg.changes["changedby2047"]
 317             self.Subst["__MAINTAINER_TO__"] = "%s, %s" % (self.pkg.changes["changedby2047"], self.pkg.changes["maintainer2047"])
 318             self.Subst["__MAINTAINER__"] = self.pkg.changes.get("changed-by", "Unknown")
 319         else:
 320             self.Subst["__MAINTAINER_FROM__"] = self.pkg.changes["maintainer2047"]
 321             self.Subst["__MAINTAINER_TO__"] = self.pkg.changes["maintainer2047"]
 322             self.Subst["__MAINTAINER__"] = self.pkg.changes.get("maintainer", "Unknown")
 323
 324         if "sponsoremail" in self.pkg.changes:
 325             self.Subst["__MAINTAINER_TO__"] += ", %s" % self.pkg.changes["sponsoremail"]
 326
 327         if cnf.has_key("Dinstall::TrackingServer") and self.pkg.changes.has_key("source"):
 328             self.Subst["__MAINTAINER_TO__"] += "\nBcc: %s@%s" % (self.pkg.changes["source"], cnf["Dinstall::TrackingServer"])
 329
 330         # Apply any global override of the Maintainer field
 331         if cnf.get("Dinstall::OverrideMaintainer"):
 332             self.Subst["__MAINTAINER_TO__"] = cnf["Dinstall::OverrideMaintainer"]
 333             self.Subst["__MAINTAINER_FROM__"] = cnf["Dinstall::OverrideMaintainer"]
 334
 335         self.Subst["__REJECT_MESSAGE__"] = self.package_info()
 336         self.Subst["__SOURCE__"] = self.pkg.changes.get("source", "Unknown")
 337         self.Subst["__VERSION__"] = self.pkg.changes.get("version", "Unknown")
 338
 339     ###########################################################################
 340     def load_changes(self, filename):
 341         """
 342         @rtype: boolean
 343         @rvalue: whether the changes file was valid or not.  We may want to
 344                  reject even if this is True (see what gets put in self.rejects).
 345                  This is simply to prevent us even trying things later which will
 346                  fail because we couldn't properly parse the file.
 347         """
 348         Cnf = Config()
 349         self.pkg.changes_file = filename
 350
 351         # Parse the .changes field into a dictionary
 352         try:
 353             self.pkg.changes.update(parse_changes(filename))
 354         except CantOpenError:
 355             self.rejects.append("%s: can't read file." % (filename))
 356             return False
 357         except ParseChangesError, line:
 358             self.rejects.append("%s: parse error, can't grok: %s." % (filename, line))
 359             return False
 360         except ChangesUnicodeError:
 361             self.rejects.append("%s: changes file not proper utf-8" % (filename))
 362             return False
 363
 364         # Parse the Files field from the .changes into another dictionary
 365         try:
 366             self.pkg.files.update(utils.build_file_list(self.pkg.changes))
 367         except ParseChangesError, line:
 368             self.rejects.append("%s: parse error, can't grok: %s." % (filename, line))
 369             return False
 370         except UnknownFormatError, format:
 371             self.rejects.append("%s: unknown format '%s'." % (filename, format))
 372             return False
 373
 374         # Check for mandatory fields
 375         for i in ("distribution", "source", "binary", "architecture",
 376                   "version", "maintainer", "files", "changes", "description"):
 377             if not self.pkg.changes.has_key(i):
 378                 # Avoid undefined errors later
 379                 self.rejects.append("%s: Missing mandatory field `%s'." % (filename, i))
 380                 return False
 381
 382         # Strip a source version in brackets from the source field
 383         if re_strip_srcver.search(self.pkg.changes["source"]):
 384             self.pkg.changes["source"] = re_strip_srcver.sub('', self.pkg.changes["source"])
 385
 386         # Ensure the source field is a valid package name.
 387         if not re_valid_pkg_name.match(self.pkg.changes["source"]):
 388             self.rejects.append("%s: invalid source name '%s'." % (filename, self.pkg.changes["source"]))
 389
 390         # Split multi-value fields into a lower-level dictionary
 391         for i in ("architecture", "distribution", "binary", "closes"):
 392             o = self.pkg.changes.get(i, "")
 393             if o != "":
 394                 del self.pkg.changes[i]
 395
 396             self.pkg.changes[i] = {}
 397
 398             for j in o.split():
 399                 self.pkg.changes[i][j] = 1
 400
 401         # Fix the Maintainer: field to be RFC822/2047 compatible
 402         try:
 403             (self.pkg.changes["maintainer822"],
 404              self.pkg.changes["maintainer2047"],
 405              self.pkg.changes["maintainername"],
 406              self.pkg.changes["maintaineremail"]) = \
 407                    fix_maintainer (self.pkg.changes["maintainer"])
 408         except ParseMaintError, msg:
 409             self.rejects.append("%s: Maintainer field ('%s') failed to parse: %s" \
 410                    % (filename, changes["maintainer"], msg))
 411
 412         # ...likewise for the Changed-By: field if it exists.
 413         try:
 414             (self.pkg.changes["changedby822"],
 415              self.pkg.changes["changedby2047"],
 416              self.pkg.changes["changedbyname"],
 417              self.pkg.changes["changedbyemail"]) = \
 418                    fix_maintainer (self.pkg.changes.get("changed-by", ""))
 419         except ParseMaintError, msg:
 420             self.pkg.changes["changedby822"] = ""
 421             self.pkg.changes["changedby2047"] = ""
 422             self.pkg.changes["changedbyname"] = ""
 423             self.pkg.changes["changedbyemail"] = ""
 424
 425             self.rejects.append("%s: Changed-By field ('%s') failed to parse: %s" \
 426                    % (filename, changes["changed-by"], msg))
 427
 428         # Ensure all the values in Closes: are numbers
 429         if self.pkg.changes.has_key("closes"):
 430             for i in self.pkg.changes["closes"].keys():
 431                 if re_isanum.match (i) == None:
 432                     self.rejects.append(("%s: `%s' from Closes field isn't a number." % (filename, i)))
 433
 434         # chopversion = no epoch; chopversion2 = no epoch and no revision (e.g. for .orig.tar.gz comparison)
 435         self.pkg.changes["chopversion"] = re_no_epoch.sub('', self.pkg.changes["version"])
 436         self.pkg.changes["chopversion2"] = re_no_revision.sub('', self.pkg.changes["chopversion"])
 437
 438         # Check there isn't already a changes file of the same name in one
 439         # of the queue directories.
 440         base_filename = os.path.basename(filename)
 441         for d in [ "Accepted", "Byhand", "Done", "New", "ProposedUpdates", "OldProposedUpdates" ]:
 442             if os.path.exists(os.path.join(Cnf["Dir::Queue::%s" % (d) ], base_filename)):
 443                 self.rejects.append("%s: a file with this name already exists in the %s directory." % (base_filename, d))
 444
 445         # Check the .changes is non-empty
 446         if not self.pkg.files:
 447             self.rejects.append("%s: nothing to do (Files field is empty)." % (base_filename))
 448             return False
 449
 450         # Changes was syntactically valid even if we'll reject
 451         return True
 452
 453     ###########################################################################
 454
 455     def check_distributions(self):
 456         "Check and map the Distribution field"
 457
 458         Cnf = Config()
 459
 460         # Handle suite mappings
 461         for m in Cnf.ValueList("SuiteMappings"):
 462             args = m.split()
 463             mtype = args[0]
 464             if mtype == "map" or mtype == "silent-map":
 465                 (source, dest) = args[1:3]
 466                 if self.pkg.changes["distribution"].has_key(source):
 467                     del self.pkg.changes["distribution"][source]
 468                     self.pkg.changes["distribution"][dest] = 1
 469                     if mtype != "silent-map":
 470                         self.notes.append("Mapping %s to %s." % (source, dest))
 471                 if self.pkg.changes.has_key("distribution-version"):
 472                     if self.pkg.changes["distribution-version"].has_key(source):
 473                         self.pkg.changes["distribution-version"][source]=dest
 474             elif mtype == "map-unreleased":
 475                 (source, dest) = args[1:3]
 476                 if self.pkg.changes["distribution"].has_key(source):
 477                     for arch in self.pkg.changes["architecture"].keys():
 478                         if arch not in [ a.arch_string for a in get_suite_architectures(source) ]:
 479                             self.notes.append("Mapping %s to %s for unreleased architecture %s." % (source, dest, arch))
 480                             del self.pkg.changes["distribution"][source]
 481                             self.pkg.changes["distribution"][dest] = 1
 482                             break
 483             elif mtype == "ignore":
 484                 suite = args[1]
 485                 if self.pkg.changes["distribution"].has_key(suite):
 486                     del self.pkg.changes["distribution"][suite]
 487                     self.warnings.append("Ignoring %s as a target suite." % (suite))
 488             elif mtype == "reject":
 489                 suite = args[1]
 490                 if self.pkg.changes["distribution"].has_key(suite):
 491                     self.rejects.append("Uploads to %s are not accepted." % (suite))
 492             elif mtype == "propup-version":
 493                 # give these as "uploaded-to(non-mapped) suites-to-add-when-upload-obsoletes"
 494                 #
 495                 # changes["distribution-version"] looks like: {'testing': 'testing-proposed-updates'}
 496                 if self.pkg.changes["distribution"].has_key(args[1]):
 497                     self.pkg.changes.setdefault("distribution-version", {})
 498                     for suite in args[2:]:
 499                         self.pkg.changes["distribution-version"][suite] = suite
 500
 501         # Ensure there is (still) a target distribution
 502         if len(self.pkg.changes["distribution"].keys()) < 1:
 503             self.rejects.append("No valid distribution remaining.")
 504
 505         # Ensure target distributions exist
 506         for suite in self.pkg.changes["distribution"].keys():
 507             if not Cnf.has_key("Suite::%s" % (suite)):
 508                 self.rejects.append("Unknown distribution `%s'." % (suite))
 509
 510     ###########################################################################
 511
 512     def binary_file_checks(self, f, session):
 513         cnf = Config()
 514         entry = self.pkg.files[f]
 515
 516         # Extract package control information
 517         deb_file = utils.open_file(f)
 518         try:
 519             control = apt_pkg.ParseSection(apt_inst.debExtractControl(deb_file))
 520         except:
 521             self.rejects.append("%s: debExtractControl() raised %s." % (f, sys.exc_type))
 522             deb_file.close()
 523             # Can't continue, none of the checks on control would work.
 524             return
 525
 526         # Check for mandantory "Description:"
 527         deb_file.seek(0)
 528         try:
 529             apt_pkg.ParseSection(apt_inst.debExtractControl(deb_file))["Description"] + '\n'
 530         except:
 531             self.rejects.append("%s: Missing Description in binary package" % (f))
 532             return
 533
 534         deb_file.close()
 535
 536         # Check for mandatory fields
 537         for field in [ "Package", "Architecture", "Version" ]:
 538             if control.Find(field) == None:
 539                 # Can't continue
 540                 self.rejects.append("%s: No %s field in control." % (f, field))
 541                 return
 542
 543         # Ensure the package name matches the one give in the .changes
 544         if not self.pkg.changes["binary"].has_key(control.Find("Package", "")):
 545             self.rejects.append("%s: control file lists name as `%s', which isn't in changes file." % (f, control.Find("Package", "")))
 546
 547         # Validate the package field
 548         package = control.Find("Package")
 549         if not re_valid_pkg_name.match(package):
 550             self.rejects.append("%s: invalid package name '%s'." % (f, package))
 551
 552         # Validate the version field
 553         version = control.Find("Version")
 554         if not re_valid_version.match(version):
 555             self.rejects.append("%s: invalid version number '%s'." % (f, version))
 556
 557         # Ensure the architecture of the .deb is one we know about.
 558         default_suite = cnf.get("Dinstall::DefaultSuite", "Unstable")
 559         architecture = control.Find("Architecture")
 560         upload_suite = self.pkg.changes["distribution"].keys()[0]
 561
 562         if      architecture not in [a.arch_string for a in get_suite_architectures(default_suite, session)] \
 563             and architecture not in [a.arch_string for a in get_suite_architectures(upload_suite, session)]:
 564             self.rejects.append("Unknown architecture '%s'." % (architecture))
 565
 566         # Ensure the architecture of the .deb is one of the ones
 567         # listed in the .changes.
 568         if not self.pkg.changes["architecture"].has_key(architecture):
 569             self.rejects.append("%s: control file lists arch as `%s', which isn't in changes file." % (f, architecture))
 570
 571         # Sanity-check the Depends field
 572         depends = control.Find("Depends")
 573         if depends == '':
 574             self.rejects.append("%s: Depends field is empty." % (f))
 575
 576         # Sanity-check the Provides field
 577         provides = control.Find("Provides")
 578         if provides:
 579             provide = re_spacestrip.sub('', provides)
 580             if provide == '':
 581                 self.rejects.append("%s: Provides field is empty." % (f))
 582             prov_list = provide.split(",")
 583             for prov in prov_list:
 584                 if not re_valid_pkg_name.match(prov):
 585                     self.rejects.append("%s: Invalid Provides field content %s." % (f, prov))
 586
 587         # Check the section & priority match those given in the .changes (non-fatal)
 588         if     control.Find("Section") and entry["section"] != "" \
 589            and entry["section"] != control.Find("Section"):
 590             self.warnings.append("%s control file lists section as `%s', but changes file has `%s'." % \
 591                                 (f, control.Find("Section", ""), entry["section"]))
 592         if control.Find("Priority") and entry["priority"] != "" \
 593            and entry["priority"] != control.Find("Priority"):
 594             self.warnings.append("%s control file lists priority as `%s', but changes file has `%s'." % \
 595                                 (f, control.Find("Priority", ""), entry["priority"]))
 596
 597         entry["package"] = package
 598         entry["architecture"] = architecture
 599         entry["version"] = version
 600         entry["maintainer"] = control.Find("Maintainer", "")
 601
 602         if f.endswith(".udeb"):
 603             self.pkg.files[f]["dbtype"] = "udeb"
 604         elif f.endswith(".deb"):
 605             self.pkg.files[f]["dbtype"] = "deb"
 606         else:
 607             self.rejects.append("%s is neither a .deb or a .udeb." % (f))
 608
 609         entry["source"] = control.Find("Source", entry["package"])
 610
 611         # Get the source version
 612         source = entry["source"]
 613         source_version = ""
 614
 615         if source.find("(") != -1:
 616             m = re_extract_src_version.match(source)
 617             source = m.group(1)
 618             source_version = m.group(2)
 619
 620         if not source_version:
 621             source_version = self.pkg.files[f]["version"]
 622
 623         entry["source package"] = source
 624         entry["source version"] = source_version
 625
 626         # Ensure the filename matches the contents of the .deb
 627         m = re_isadeb.match(f)
 628
 629         #  package name
 630         file_package = m.group(1)
 631         if entry["package"] != file_package:
 632             self.rejects.append("%s: package part of filename (%s) does not match package name in the %s (%s)." % \
 633                                 (f, file_package, entry["dbtype"], entry["package"]))
 634         epochless_version = re_no_epoch.sub('', control.Find("Version"))
 635
 636         #  version
 637         file_version = m.group(2)
 638         if epochless_version != file_version:
 639             self.rejects.append("%s: version part of filename (%s) does not match package version in the %s (%s)." % \
 640                                 (f, file_version, entry["dbtype"], epochless_version))
 641
 642         #  architecture
 643         file_architecture = m.group(3)
 644         if entry["architecture"] != file_architecture:
 645             self.rejects.append("%s: architecture part of filename (%s) does not match package architecture in the %s (%s)." % \
 646                                 (f, file_architecture, entry["dbtype"], entry["architecture"]))
 647
 648         # Check for existent source
 649         source_version = entry["source version"]
 650         source_package = entry["source package"]
 651         if self.pkg.changes["architecture"].has_key("source"):
 652             if source_version != self.pkg.changes["version"]:
 653                 self.rejects.append("source version (%s) for %s doesn't match changes version %s." % \
 654                                     (source_version, f, self.pkg.changes["version"]))
 655         else:
 656             # Check in the SQL database
 657             if not source_exists(source_package, source_version, self.pkg.changes["distribution"].keys(), session):
 658                 # Check in one of the other directories
 659                 source_epochless_version = re_no_epoch.sub('', source_version)
 660                 dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
 661                 if os.path.exists(os.path.join(cnf["Dir::Queue::Byhand"], dsc_filename)):
 662                     entry["byhand"] = 1
 663                 elif os.path.exists(os.path.join(cnf["Dir::Queue::New"], dsc_filename)):
 664                     entry["new"] = 1
 665                 else:
 666                     dsc_file_exists = False
 667                     for myq in ["Accepted", "Embargoed", "Unembargoed", "ProposedUpdates", "OldProposedUpdates"]:
 668                         if cnf.has_key("Dir::Queue::%s" % (myq)):
 669                             if os.path.exists(os.path.join(cnf["Dir::Queue::" + myq], dsc_filename)):
 670                                 dsc_file_exists = True
 671                                 break
 672
 673                     if not dsc_file_exists:
 674                         self.rejects.append("no source found for %s %s (%s)." % (source_package, source_version, f))
 675
 676         # Check the version and for file overwrites
 677         self.check_binary_against_db(f, session)
 678
 679         # Temporarily disable contents generation until we change the table storage layout
 680         #b = Binary(f)
 681         #b.scan_package()
 682         #if len(b.rejects) > 0:
 683         #    for j in b.rejects:
 684         #        self.rejects.append(j)
 685
 686     def source_file_checks(self, f, session):
 687         entry = self.pkg.files[f]
 688
 689         m = re_issource.match(f)
 690         if not m:
 691             return
 692
 693         entry["package"] = m.group(1)
 694         entry["version"] = m.group(2)
 695         entry["type"] = m.group(3)
 696
 697         # Ensure the source package name matches the Source filed in the .changes
 698         if self.pkg.changes["source"] != entry["package"]:
 699             self.rejects.append("%s: changes file doesn't say %s for Source" % (f, entry["package"]))
 700
 701         # Ensure the source version matches the version in the .changes file
 702         if re_is_orig_source.match(f):
 703             changes_version = self.pkg.changes["chopversion2"]
 704         else:
 705             changes_version = self.pkg.changes["chopversion"]
 706
 707         if changes_version != entry["version"]:
 708             self.rejects.append("%s: should be %s according to changes file." % (f, changes_version))
 709
 710         # Ensure the .changes lists source in the Architecture field
 711         if not self.pkg.changes["architecture"].has_key("source"):
 712             self.rejects.append("%s: changes file doesn't list `source' in Architecture field." % (f))
 713
 714         # Check the signature of a .dsc file
 715         if entry["type"] == "dsc":
 716             # check_signature returns either:
 717             #  (None, [list, of, rejects]) or (signature, [])
 718             (self.pkg.dsc["fingerprint"], rejects) = utils.check_signature(f)
 719             for j in rejects:
 720                 self.rejects.append(j)
 721
 722         entry["architecture"] = "source"
 723
 724     def per_suite_file_checks(self, f, suite, session):
 725         cnf = Config()
 726         entry = self.pkg.files[f]
 727         archive = utils.where_am_i()
 728
 729         # Skip byhand
 730         if entry.has_key("byhand"):
 731             return
 732
 733         # Check we have fields we need to do these checks
 734         oktogo = True
 735         for m in ['component', 'package', 'priority', 'size', 'md5sum']:
 736             if not entry.has_key(m):
 737                 self.rejects.append("file '%s' does not have field %s set" % (f, m))
 738                 oktogo = False
 739
 740         if not oktogo:
 741             return
 742
 743         # Handle component mappings
 744         for m in cnf.ValueList("ComponentMappings"):
 745             (source, dest) = m.split()
 746             if entry["component"] == source:
 747                 entry["original component"] = source
 748                 entry["component"] = dest
 749
 750         # Ensure the component is valid for the target suite
 751         if cnf.has_key("Suite:%s::Components" % (suite)) and \
 752            entry["component"] not in cnf.ValueList("Suite::%s::Components" % (suite)):
 753             self.rejects.append("unknown component `%s' for suite `%s'." % (entry["component"], suite))
 754             return
 755
 756         # Validate the component
 757         if not get_component(entry["component"], session):
 758             self.rejects.append("file '%s' has unknown component '%s'." % (f, component))
 759             return
 760
 761         # See if the package is NEW
 762         if not self.in_override_p(entry["package"], entry["component"], suite, entry.get("dbtype",""), f, session):
 763             entry["new"] = 1
 764
 765         # Validate the priority
 766         if entry["priority"].find('/') != -1:
 767             self.rejects.append("file '%s' has invalid priority '%s' [contains '/']." % (f, entry["priority"]))
 768
 769         # Determine the location
 770         location = cnf["Dir::Pool"]
 771         l = get_location(location, entry["component"], archive, session)
 772         if l is None:
 773             self.rejects.append("[INTERNAL ERROR] couldn't determine location (Component: %s, Archive: %s)" % (component, archive))
 774             entry["location id"] = -1
 775         else:
 776             entry["location id"] = l.location_id
 777
 778         # Check the md5sum & size against existing files (if any)
 779         entry["pool name"] = utils.poolify(self.pkg.changes["source"], entry["component"])
 780
 781         found, poolfile = check_poolfile(os.path.join(entry["pool name"], f),
 782                                          entry["size"], entry["md5sum"], entry["location id"])
 783
 784         if found is None:
 785             self.rejects.append("INTERNAL ERROR, get_files_id() returned multiple matches for %s." % (f))
 786         elif found is False and poolfile is not None:
 787             self.rejects.append("md5sum and/or size mismatch on existing copy of %s." % (f))
 788         else:
 789             if poolfile is None:
 790                 entry["files id"] = None
 791             else:
 792                 entry["files id"] = poolfile.file_id
 793
 794         # Check for packages that have moved from one component to another
 795         entry['suite'] = suite
 796         res = get_binary_components(self.pkg.files[f]['package'], suite, entry["architecture"], session)
 797         if res.rowcount > 0:
 798             entry["othercomponents"] = res.fetchone()[0]
 799
 800     def check_files(self, action=True):
 801         archive = utils.where_am_i()
 802         file_keys = self.pkg.files.keys()
 803         holding = Holding()
 804         cnf = Config()
 805
 806         # XXX: As far as I can tell, this can no longer happen - see
 807         #      comments by AJ in old revisions - mhy
 808         # if reprocess is 2 we've already done this and we're checking
 809         # things again for the new .orig.tar.gz.
 810         # [Yes, I'm fully aware of how disgusting this is]
 811         if action and self.reprocess < 2:
 812             cwd = os.getcwd()
 813             os.chdir(self.pkg.directory)
 814             for f in file_keys:
 815                 ret = holding.copy_to_holding(f)
 816                 if ret is not None:
 817                     # XXX: Should we bail out here or try and continue?
 818                     self.rejects.append(ret)
 819
 820             os.chdir(cwd)
 821
 822         # Check there isn't already a .changes or .dak file of the same name in
 823         # the proposed-updates "CopyChanges" or "CopyDotDak" storage directories.
 824         # [NB: this check must be done post-suite mapping]
 825         base_filename = os.path.basename(self.pkg.changes_file)
 826         dot_dak_filename = base_filename[:-8] + ".dak"
 827
 828         for suite in self.pkg.changes["distribution"].keys():
 829             copychanges = "Suite::%s::CopyChanges" % (suite)
 830             if cnf.has_key(copychanges) and \
 831                    os.path.exists(os.path.join(cnf[copychanges], base_filename)):
 832                 self.rejects.append("%s: a file with this name already exists in %s" \
 833                            % (base_filename, cnf[copychanges]))
 834
 835             copy_dot_dak = "Suite::%s::CopyDotDak" % (suite)
 836             if cnf.has_key(copy_dot_dak) and \
 837                    os.path.exists(os.path.join(cnf[copy_dot_dak], dot_dak_filename)):
 838                 self.rejects.append("%s: a file with this name already exists in %s" \
 839                            % (dot_dak_filename, Cnf[copy_dot_dak]))
 840
 841         self.reprocess = 0
 842         has_binaries = False
 843         has_source = False
 844
 845         session = DBConn().session()
 846
 847         for f, entry in self.pkg.files.items():
 848             # Ensure the file does not already exist in one of the accepted directories
 849             for d in [ "Accepted", "Byhand", "New", "ProposedUpdates", "OldProposedUpdates", "Embargoed", "Unembargoed" ]:
 850                 if not cnf.has_key("Dir::Queue::%s" % (d)): continue
 851                 if os.path.exists(cnf["Dir::Queue::%s" % (d) ] + '/' + f):
 852                     self.rejects.append("%s file already exists in the %s directory." % (f, d))
 853
 854             if not re_taint_free.match(f):
 855                 self.rejects.append("!!WARNING!! tainted filename: '%s'." % (f))
 856
 857             # Check the file is readable
 858             if os.access(f, os.R_OK) == 0:
 859                 # When running in -n, copy_to_holding() won't have
 860                 # generated the reject_message, so we need to.
 861                 if action:
 862                     if os.path.exists(f):
 863                         self.rejects.append("Can't read `%s'. [permission denied]" % (f))
 864                     else:
 865                         self.rejects.append("Can't read `%s'. [file not found]" % (f))
 866                 entry["type"] = "unreadable"
 867                 continue
 868
 869             # If it's byhand skip remaining checks
 870             if entry["section"] == "byhand" or entry["section"][:4] == "raw-":
 871                 entry["byhand"] = 1
 872                 entry["type"] = "byhand"
 873
 874             # Checks for a binary package...
 875             elif re_isadeb.match(f):
 876                 has_binaries = True
 877                 entry["type"] = "deb"
 878
 879                 # This routine appends to self.rejects/warnings as appropriate
 880                 self.binary_file_checks(f, session)
 881
 882             # Checks for a source package...
 883             elif re_issource.match(f):
 884                 has_source = True
 885
 886                 # This routine appends to self.rejects/warnings as appropriate
 887                 self.source_file_checks(f, session)
 888
 889             # Not a binary or source package?  Assume byhand...
 890             else:
 891                 entry["byhand"] = 1
 892                 entry["type"] = "byhand"
 893
 894             # Per-suite file checks
 895             entry["oldfiles"] = {}
 896             for suite in self.pkg.changes["distribution"].keys():
 897                 self.per_suite_file_checks(f, suite, session)
 898
 899         session.close()
 900
 901         # If the .changes file says it has source, it must have source.
 902         if self.pkg.changes["architecture"].has_key("source"):
 903             if not has_source:
 904                 self.rejects.append("no source found and Architecture line in changes mention source.")
 905
 906             if not has_binaries and cnf.FindB("Dinstall::Reject::NoSourceOnly"):
 907                 self.rejects.append("source only uploads are not supported.")
 908
 909     ###########################################################################
 910     def check_dsc(self, action=True, session=None):
 911         """Returns bool indicating whether or not the source changes are valid"""
 912         # Ensure there is source to check
 913         if not self.pkg.changes["architecture"].has_key("source"):
 914             return True
 915
 916         # Find the .dsc
 917         dsc_filename = None
 918         for f, entry in self.pkg.files.items():
 919             if entry["type"] == "dsc":
 920                 if dsc_filename:
 921                     self.rejects.append("can not process a .changes file with multiple .dsc's.")
 922                     return False
 923                 else:
 924                     dsc_filename = f
 925
 926         # If there isn't one, we have nothing to do. (We have reject()ed the upload already)
 927         if not dsc_filename:
 928             self.rejects.append("source uploads must contain a dsc file")
 929             return False
 930
 931         # Parse the .dsc file
 932         try:
 933             self.pkg.dsc.update(utils.parse_changes(dsc_filename, signing_rules=1))
 934         except CantOpenError:
 935             # if not -n copy_to_holding() will have done this for us...
 936             if not action:
 937                 self.rejects.append("%s: can't read file." % (dsc_filename))
 938         except ParseChangesError, line:
 939             self.rejects.append("%s: parse error, can't grok: %s." % (dsc_filename, line))
 940         except InvalidDscError, line:
 941             self.rejects.append("%s: syntax error on line %s." % (dsc_filename, line))
 942         except ChangesUnicodeError:
 943             self.rejects.append("%s: dsc file not proper utf-8." % (dsc_filename))
 944
 945         # Build up the file list of files mentioned by the .dsc
 946         try:
 947             self.pkg.dsc_files.update(utils.build_file_list(self.pkg.dsc, is_a_dsc=1))
 948         except NoFilesFieldError:
 949             self.rejects.append("%s: no Files: field." % (dsc_filename))
 950             return False
 951         except UnknownFormatError, format:
 952             self.rejects.append("%s: unknown format '%s'." % (dsc_filename, format))
 953             return False
 954         except ParseChangesError, line:
 955             self.rejects.append("%s: parse error, can't grok: %s." % (dsc_filename, line))
 956             return False
 957
 958         # Enforce mandatory fields
 959         for i in ("format", "source", "version", "binary", "maintainer", "architecture", "files"):
 960             if not self.pkg.dsc.has_key(i):
 961                 self.rejects.append("%s: missing mandatory field `%s'." % (dsc_filename, i))
 962                 return False
 963
 964         # Validate the source and version fields
 965         if not re_valid_pkg_name.match(self.pkg.dsc["source"]):
 966             self.rejects.append("%s: invalid source name '%s'." % (dsc_filename, self.pkg.dsc["source"]))
 967         if not re_valid_version.match(self.pkg.dsc["version"]):
 968             self.rejects.append("%s: invalid version number '%s'." % (dsc_filename, self.pkg.dsc["version"]))
 969
 970         # Only a limited list of source formats are allowed in each suite
 971         for dist in self.pkg.changes["distribution"].keys():
 972             allowed = [ x.format_name for x in get_suite_src_formats(dist, session) ]
 973             if self.pkg.dsc["format"] not in allowed:
 974                 self.rejects.append("%s: source format '%s' not allowed in %s (accepted: %s) " % (dsc_filename, self.pkg.dsc["format"], dist, ", ".join(allowed)))
 975
 976         # Validate the Maintainer field
 977         try:
 978             # We ignore the return value
 979             fix_maintainer(self.pkg.dsc["maintainer"])
 980         except ParseMaintError, msg:
 981             self.rejects.append("%s: Maintainer field ('%s') failed to parse: %s" \
 982                                  % (dsc_filename, self.pkg.dsc["maintainer"], msg))
 983
 984         # Validate the build-depends field(s)
 985         for field_name in [ "build-depends", "build-depends-indep" ]:
 986             field = self.pkg.dsc.get(field_name)
 987             if field:
 988                 # Have apt try to parse them...
 989                 try:
 990                     apt_pkg.ParseSrcDepends(field)
 991                 except:
 992                     self.rejects.append("%s: invalid %s field (can not be parsed by apt)." % (dsc_filename, field_name.title()))
 993
 994         # Ensure the version number in the .dsc matches the version number in the .changes
 995         epochless_dsc_version = re_no_epoch.sub('', self.pkg.dsc["version"])
 996         changes_version = self.pkg.files[dsc_filename]["version"]
 997
 998         if epochless_dsc_version != self.pkg.files[dsc_filename]["version"]:
 999             self.rejects.append("version ('%s') in .dsc does not match version ('%s') in .changes." % (epochless_dsc_version, changes_version))
1000
1001         # Ensure the Files field contain only what's expected
1002         self.rejects.extend(check_dsc_files(dsc_filename, self.pkg.dsc, self.pkg.dsc_files))
1003
1004         # Ensure source is newer than existing source in target suites
1005         session = DBConn().session()
1006         self.check_source_against_db(dsc_filename, session)
1007         self.check_dsc_against_db(dsc_filename, session)
1008         session.close()
1009
1010         return True
1011
1012     ###########################################################################
1013
1014     def get_changelog_versions(self, source_dir):
1015         """Extracts a the source package and (optionally) grabs the
1016         version history out of debian/changelog for the BTS."""
1017
1018         cnf = Config()
1019
1020         # Find the .dsc (again)
1021         dsc_filename = None
1022         for f in self.pkg.files.keys():
1023             if self.pkg.files[f]["type"] == "dsc":
1024                 dsc_filename = f
1025
1026         # If there isn't one, we have nothing to do. (We have reject()ed the upload already)
1027         if not dsc_filename:
1028             return
1029
1030         # Create a symlink mirror of the source files in our temporary directory
1031         for f in self.pkg.files.keys():
1032             m = re_issource.match(f)
1033             if m:
1034                 src = os.path.join(source_dir, f)
1035                 # If a file is missing for whatever reason, give up.
1036                 if not os.path.exists(src):
1037                     return
1038                 ftype = m.group(3)
1039                 if re_is_orig_source.match(f) and self.pkg.orig_files.has_key(f) and \
1040                    self.pkg.orig_files[f].has_key("path"):
1041                     continue
1042                 dest = os.path.join(os.getcwd(), f)
1043                 os.symlink(src, dest)
1044
1045         # If the orig files are not a part of the upload, create symlinks to the
1046         # existing copies.
1047         for orig_file in self.pkg.orig_files.keys():
1048             if not self.pkg.orig_files[orig_file].has_key("path"):
1049                 continue
1050             dest = os.path.join(os.getcwd(), os.path.basename(orig_file))
1051             os.symlink(self.pkg.orig_files[orig_file]["path"], dest)
1052
1053         # Extract the source
1054         cmd = "dpkg-source -sn -x %s" % (dsc_filename)
1055         (result, output) = commands.getstatusoutput(cmd)
1056         if (result != 0):
1057             self.rejects.append("'dpkg-source -x' failed for %s [return code: %s]." % (dsc_filename, result))
1058             self.rejects.append(utils.prefix_multi_line_string(output, " [dpkg-source output:] "))
1059             return
1060
1061         if not cnf.Find("Dir::Queue::BTSVersionTrack"):
1062             return
1063
1064         # Get the upstream version
1065         upstr_version = re_no_epoch.sub('', self.pkg.dsc["version"])
1066         if re_strip_revision.search(upstr_version):
1067             upstr_version = re_strip_revision.sub('', upstr_version)
1068
1069         # Ensure the changelog file exists
1070         changelog_filename = "%s-%s/debian/changelog" % (self.pkg.dsc["source"], upstr_version)
1071         if not os.path.exists(changelog_filename):
1072             self.rejects.append("%s: debian/changelog not found in extracted source." % (dsc_filename))
1073             return
1074
1075         # Parse the changelog
1076         self.pkg.dsc["bts changelog"] = ""
1077         changelog_file = utils.open_file(changelog_filename)
1078         for line in changelog_file.readlines():
1079             m = re_changelog_versions.match(line)
1080             if m:
1081                 self.pkg.dsc["bts changelog"] += line
1082         changelog_file.close()
1083
1084         # Check we found at least one revision in the changelog
1085         if not self.pkg.dsc["bts changelog"]:
1086             self.rejects.append("%s: changelog format not recognised (empty version tree)." % (dsc_filename))
1087
1088     def check_source(self):
1089         # XXX: I'm fairly sure reprocess == 2 can never happen
1090         #      AJT disabled the is_incoming check years ago - mhy
1091         #      We should probably scrap or rethink the whole reprocess thing
1092         # Bail out if:
1093         #    a) there's no source
1094         # or b) reprocess is 2 - we will do this check next time when orig
1095         #       tarball is in 'files'
1096         # or c) the orig files are MIA
1097         if not self.pkg.changes["architecture"].has_key("source") or self.reprocess == 2 \
1098            or len(self.pkg.orig_files) == 0:
1099             return
1100
1101         tmpdir = utils.temp_dirname()
1102
1103         # Move into the temporary directory
1104         cwd = os.getcwd()
1105         os.chdir(tmpdir)
1106
1107         # Get the changelog version history
1108         self.get_changelog_versions(cwd)
1109
1110         # Move back and cleanup the temporary tree
1111         os.chdir(cwd)
1112
1113         try:
1114             shutil.rmtree(tmpdir)
1115         except OSError, e:
1116             if e.errno != errno.EACCES:
1117                 print "foobar"
1118                 utils.fubar("%s: couldn't remove tmp dir for source tree." % (self.pkg.dsc["source"]))
1119
1120             self.rejects.append("%s: source tree could not be cleanly removed." % (self.pkg.dsc["source"]))
1121             # We probably have u-r or u-w directories so chmod everything
1122             # and try again.
1123             cmd = "chmod -R u+rwx %s" % (tmpdir)
1124             result = os.system(cmd)
1125             if result != 0:
1126                 utils.fubar("'%s' failed with result %s." % (cmd, result))
1127             shutil.rmtree(tmpdir)
1128         except Exception, e:
1129             print "foobar2 (%s)" % e
1130             utils.fubar("%s: couldn't remove tmp dir for source tree." % (self.pkg.dsc["source"]))
1131
1132     ###########################################################################
1133     def ensure_hashes(self):
1134         # Make sure we recognise the format of the Files: field in the .changes
1135         format = self.pkg.changes.get("format", "0.0").split(".", 1)
1136         if len(format) == 2:
1137             format = int(format[0]), int(format[1])
1138         else:
1139             format = int(float(format[0])), 0
1140
1141         # We need to deal with the original changes blob, as the fields we need
1142         # might not be in the changes dict serialised into the .dak anymore.
1143         orig_changes = utils.parse_deb822(self.pkg.changes['filecontents'])
1144
1145         # Copy the checksums over to the current changes dict.  This will keep
1146         # the existing modifications to it intact.
1147         for field in orig_changes:
1148             if field.startswith('checksums-'):
1149                 self.pkg.changes[field] = orig_changes[field]
1150
1151         # Check for unsupported hashes
1152         for j in utils.check_hash_fields(".changes", self.pkg.changes):
1153             self.rejects.append(j)
1154
1155         for j in utils.check_hash_fields(".dsc", self.pkg.dsc):
1156             self.rejects.append(j)
1157
1158         # We have to calculate the hash if we have an earlier changes version than
1159         # the hash appears in rather than require it exist in the changes file
1160         for hashname, hashfunc, version in utils.known_hashes:
1161             # TODO: Move _ensure_changes_hash into this class
1162             for j in utils._ensure_changes_hash(self.pkg.changes, format, version, self.pkg.files, hashname, hashfunc):
1163                 self.rejects.append(j)
1164             if "source" in self.pkg.changes["architecture"]:
1165                 # TODO: Move _ensure_dsc_hash into this class
1166                 for j in utils._ensure_dsc_hash(self.pkg.dsc, self.pkg.dsc_files, hashname, hashfunc):
1167                     self.rejects.append(j)
1168
1169     def check_hashes(self):
1170         for m in utils.check_hash(".changes", self.pkg.files, "md5", apt_pkg.md5sum):
1171             self.rejects.append(m)
1172
1173         for m in utils.check_size(".changes", self.pkg.files):
1174             self.rejects.append(m)
1175
1176         for m in utils.check_hash(".dsc", self.pkg.dsc_files, "md5", apt_pkg.md5sum):
1177             self.rejects.append(m)
1178
1179         for m in utils.check_size(".dsc", self.pkg.dsc_files):
1180             self.rejects.append(m)
1181
1182         self.ensure_hashes()
1183
1184     ###########################################################################
1185     def check_lintian(self):
1186         cnf = Config()
1187
1188         # Only check some distributions
1189         valid_dist = False
1190         for dist in ('unstable', 'experimental'):
1191             if dist in self.pkg.changes['distribution']:
1192                 valid_dist = True
1193                 break
1194
1195         if not valid_dist:
1196             return
1197
1198         tagfile = cnf.get("Dinstall::LintianTags")
1199         if tagfile is None:
1200             # We don't have a tagfile, so just don't do anything.
1201             return
1202
1203         # Parse the yaml file
1204         sourcefile = file(tagfile, 'r')
1205         sourcecontent = sourcefile.read()
1206         sourcefile.close()
1207         try:
1208             lintiantags = yaml.load(sourcecontent)['lintian']
1209         except yaml.YAMLError, msg:
1210             utils.fubar("Can not read the lintian tags file %s, YAML error: %s." % (tagfile, msg))
1211             return
1212
1213         # Try and find all orig mentioned in the .dsc
1214         target_dir = '.'
1215         symlinked = []
1216         for filename, entry in self.pkg.dsc_files.iteritems():
1217             if not re_is_orig_source.match(filename):
1218                 # File is not an orig; ignore
1219                 continue
1220
1221             if os.path.exists(filename):
1222                 # File exists, no need to continue
1223                 continue
1224
1225             def symlink_if_valid(path):
1226                 f = utils.open_file(path)
1227                 md5sum = apt_pkg.md5sum(f)
1228                 f.close()
1229
1230                 fingerprint = (os.stat(path)[stat.ST_SIZE], md5sum)
1231                 expected = (int(entry['size']), entry['md5sum'])
1232
1233                 if fingerprint != expected:
1234                     return False
1235
1236                 dest = os.path.join(target_dir, filename)
1237
1238                 os.symlink(path, dest)
1239                 symlinked.append(dest)
1240
1241                 return True
1242
1243             session = DBConn().session()
1244             found = False
1245
1246             # Look in the pool
1247             for poolfile in get_poolfile_like_name('/%s' % filename, session):
1248                 poolfile_path = os.path.join(
1249                     poolfile.location.path, poolfile.filename
1250                 )
1251
1252                 if symlink_if_valid(poolfile_path):
1253                     found = True
1254                     break
1255
1256             session.close()
1257
1258             if found:
1259                 continue
1260
1261             # Look in some other queues for the file
1262             queues = ('Accepted', 'New', 'Byhand', 'ProposedUpdates',
1263                 'OldProposedUpdates', 'Embargoed', 'Unembargoed')
1264
1265             for queue in queues:
1266                 if 'Dir::Queue::%s' % directory not in cnf:
1267                     continue
1268
1269                 queuefile_path = os.path.join(
1270                     cnf['Dir::Queue::%s' % directory], filename
1271                 )
1272
1273                 if not os.path.exists(queuefile_path):
1274                     # Does not exist in this queue
1275                     continue
1276
1277                 if symlink_if_valid(queuefile_path):
1278                     break
1279
1280         # Now setup the input file for lintian. lintian wants "one tag per line" only,
1281         # so put it together like it. We put all types of tags in one file and then sort
1282         # through lintians output later to see if its a fatal tag we detected, or not.
1283         # So we only run lintian once on all tags, even if we might reject on some, but not
1284         # reject on others.
1285         # Additionally build up a set of tags
1286         tags = set()
1287         (fd, temp_filename) = utils.temp_filename()
1288         temptagfile = os.fdopen(fd, 'w')
1289         for tagtype in lintiantags:
1290             for tag in lintiantags[tagtype]:
1291                 temptagfile.write("%s\n" % tag)
1292                 tags.add(tag)
1293         temptagfile.close()
1294
1295         # So now we should look at running lintian at the .changes file, capturing output
1296         # to then parse it.
1297         command = "lintian --show-overrides --tags-from-file %s %s" % (temp_filename, self.pkg.changes_file)
1298         (result, output) = commands.getstatusoutput(command)
1299
1300         # We are done with lintian, remove our tempfile and any symlinks we created
1301         os.unlink(temp_filename)
1302         for symlink in symlinked:
1303             os.unlink(symlink)
1304
1305         if (result == 2):
1306             utils.warn("lintian failed for %s [return code: %s]." % (self.pkg.changes_file, result))
1307             utils.warn(utils.prefix_multi_line_string(output, " [possible output:] "))
1308
1309         if len(output) == 0:
1310             return
1311
1312         def log(*txt):
1313             if self.logger:
1314                 self.logger.log([self.pkg.changes_file, "check_lintian"] + list(txt))
1315
1316         # We have output of lintian, this package isn't clean. Lets parse it and see if we
1317         # are having a victim for a reject.
1318         # W: tzdata: binary-without-manpage usr/sbin/tzconfig
1319         for line in output.split('\n'):
1320             m = re_parse_lintian.match(line)
1321             if m is None:
1322                 continue
1323
1324             etype = m.group(1)
1325             epackage = m.group(2)
1326             etag = m.group(3)
1327             etext = m.group(4)
1328
1329             # So lets check if we know the tag at all.
1330             if etag not in tags:
1331                 continue
1332
1333             if etype == 'O':
1334                 # We know it and it is overriden. Check that override is allowed.
1335                 if etag in lintiantags['warning']:
1336                     # The tag is overriden, and it is allowed to be overriden.
1337                     # Don't add a reject message.
1338                     pass
1339                 elif etag in lintiantags['error']:
1340                     # The tag is overriden - but is not allowed to be
1341                     self.rejects.append("%s: Overriden tag %s found, but this tag may not be overwritten." % (epackage, etag))
1342                     log("overidden tag is overridden", etag)
1343             else:
1344                 # Tag is known, it is not overriden, direct reject.
1345                 self.rejects.append("%s: Found lintian output: '%s %s', automatically rejected package." % (epackage, etag, etext))
1346                 log("auto rejecting", etag)
1347                 # Now tell if they *might* override it.
1348                 if etag in lintiantags['warning']:
1349                     self.rejects.append("%s: If you have a good reason, you may override this lintian tag." % (epackage))
1350
1351     ###########################################################################
1352     def check_urgency(self):
1353         cnf = Config()
1354         if self.pkg.changes["architecture"].has_key("source"):
1355             if not self.pkg.changes.has_key("urgency"):
1356                 self.pkg.changes["urgency"] = cnf["Urgency::Default"]
1357             self.pkg.changes["urgency"] = self.pkg.changes["urgency"].lower()
1358             if self.pkg.changes["urgency"] not in cnf.ValueList("Urgency::Valid"):
1359                 self.warnings.append("%s is not a valid urgency; it will be treated as %s by testing." % \
1360                                      (self.pkg.changes["urgency"], cnf["Urgency::Default"]))
1361                 self.pkg.changes["urgency"] = cnf["Urgency::Default"]
1362
1363     ###########################################################################
1364
1365     # Sanity check the time stamps of files inside debs.
1366     # [Files in the near future cause ugly warnings and extreme time
1367     #  travel can cause errors on extraction]
1368
1369     def check_timestamps(self):
1370         Cnf = Config()
1371
1372         future_cutoff = time.time() + int(Cnf["Dinstall::FutureTimeTravelGrace"])
1373         past_cutoff = time.mktime(time.strptime(Cnf["Dinstall::PastCutoffYear"],"%Y"))
1374         tar = TarTime(future_cutoff, past_cutoff)
1375
1376         for filename, entry in self.pkg.files.items():
1377             if entry["type"] == "deb":
1378                 tar.reset()
1379                 try:
1380                     deb_file = utils.open_file(filename)
1381                     apt_inst.debExtract(deb_file, tar.callback, "control.tar.gz")
1382                     deb_file.seek(0)
1383                     try:
1384                         apt_inst.debExtract(deb_file, tar.callback, "data.tar.gz")
1385                     except SystemError, e:
1386                         # If we can't find a data.tar.gz, look for data.tar.bz2 instead.
1387                         if not re.search(r"Cannot f[ui]nd chunk data.tar.gz$", str(e)):
1388                             raise
1389                         deb_file.seek(0)
1390                         apt_inst.debExtract(deb_file,tar.callback,"data.tar.bz2")
1391
1392                     deb_file.close()
1393
1394                     future_files = tar.future_files.keys()
1395                     if future_files:
1396                         num_future_files = len(future_files)
1397                         future_file = future_files[0]
1398                         future_date = tar.future_files[future_file]
1399                         self.rejects.append("%s: has %s file(s) with a time stamp too far into the future (e.g. %s [%s])."
1400                                % (filename, num_future_files, future_file, time.ctime(future_date)))
1401
1402                     ancient_files = tar.ancient_files.keys()
1403                     if ancient_files:
1404                         num_ancient_files = len(ancient_files)
1405                         ancient_file = ancient_files[0]
1406                         ancient_date = tar.ancient_files[ancient_file]
1407                         self.rejects.append("%s: has %s file(s) with a time stamp too ancient (e.g. %s [%s])."
1408                                % (filename, num_ancient_files, ancient_file, time.ctime(ancient_date)))
1409                 except:
1410                     self.rejects.append("%s: deb contents timestamp check failed [%s: %s]" % (filename, sys.exc_type, sys.exc_value))
1411
1412     def check_if_upload_is_sponsored(self, uid_email, uid_name):
1413         if uid_email in [self.pkg.changes["maintaineremail"], self.pkg.changes["changedbyemail"]]:
1414             sponsored = False
1415         elif uid_name in [self.pkg.changes["maintainername"], self.pkg.changes["changedbyname"]]:
1416             sponsored = False
1417             if uid_name == "":
1418                 sponsored = True
1419         else:
1420             sponsored = True
1421             if ("source" in self.pkg.changes["architecture"] and uid_email and utils.is_email_alias(uid_email)):
1422                 sponsor_addresses = utils.gpg_get_key_addresses(self.pkg.changes["fingerprint"])
1423                 if (self.pkg.changes["maintaineremail"] not in sponsor_addresses and
1424                     self.pkg.changes["changedbyemail"] not in sponsor_addresses):
1425                         self.pkg.changes["sponsoremail"] = uid_email
1426
1427         return sponsored
1428
1429
1430     ###########################################################################
1431     # check_signed_by_key checks
1432     ###########################################################################
1433
1434     def check_signed_by_key(self):
1435         """Ensure the .changes is signed by an authorized uploader."""
1436         session = DBConn().session()
1437
1438         # First of all we check that the person has proper upload permissions
1439         # and that this upload isn't blocked
1440         fpr = get_fingerprint(self.pkg.changes['fingerprint'], session=session)
1441
1442         if fpr is None:
1443             self.rejects.append("Cannot find fingerprint %s" % self.pkg.changes["fingerprint"])
1444             return
1445
1446         # TODO: Check that import-keyring adds UIDs properly
1447         if not fpr.uid:
1448             self.rejects.append("Cannot find uid for fingerprint %s.  Please contact ftpmaster@debian.org" % fpr.fingerprint)
1449             return
1450
1451         # Check that the fingerprint which uploaded has permission to do so
1452         self.check_upload_permissions(fpr, session)
1453
1454         # Check that this package is not in a transition
1455         self.check_transition(session)
1456
1457         session.close()
1458
1459
1460     def check_upload_permissions(self, fpr, session):
1461         # Check any one-off upload blocks
1462         self.check_upload_blocks(fpr, session)
1463
1464         # Start with DM as a special case
1465         # DM is a special case unfortunately, so we check it first
1466         # (keys with no source access get more access than DMs in one
1467         #  way; DMs can only upload for their packages whether source
1468         #  or binary, whereas keys with no access might be able to
1469         #  upload some binaries)
1470         if fpr.source_acl.access_level == 'dm':
1471             self.check_dm_source_upload(fpr, session)
1472         else:
1473             # Check source-based permissions for other types
1474             if self.pkg.changes["architecture"].has_key("source"):
1475                 if fpr.source_acl.access_level is None:
1476                     rej = 'Fingerprint %s may not upload source' % fpr.fingerprint
1477                     rej += '\nPlease contact ftpmaster if you think this is incorrect'
1478                     self.rejects.append(rej)
1479                     return
1480             else:
1481                 # If not a DM, we allow full upload rights
1482                 uid_email = "%s@debian.org" % (fpr.uid.uid)
1483                 self.check_if_upload_is_sponsored(uid_email, fpr.uid.name)
1484
1485
1486         # Check binary upload permissions
1487         # By this point we know that DMs can't have got here unless they
1488         # are allowed to deal with the package concerned so just apply
1489         # normal checks
1490         if fpr.binary_acl.access_level == 'full':
1491             return
1492
1493         # Otherwise we're in the map case
1494         tmparches = self.pkg.changes["architecture"].copy()
1495         tmparches.pop('source', None)
1496
1497         for bam in fpr.binary_acl_map:
1498             tmparches.pop(bam.architecture.arch_string, None)
1499
1500         if len(tmparches.keys()) > 0:
1501             if fpr.binary_reject:
1502                 rej = ".changes file contains files of architectures not permitted for fingerprint %s" % fpr.fingerprint
1503                 rej += "\narchitectures involved are: ", ",".join(tmparches.keys())
1504                 self.rejects.append(rej)
1505             else:
1506                 # TODO: This is where we'll implement reject vs throw away binaries later
1507                 rej = "Uhm.  I'm meant to throw away the binaries now but that's not implemented yet"
1508                 rej += "\nPlease complain to ftpmaster@debian.org as this shouldn't have been turned on"
1509                 rej += "\nFingerprint: %s", (fpr.fingerprint)
1510                 self.rejects.append(rej)
1511
1512
1513     def check_upload_blocks(self, fpr, session):
1514         """Check whether any upload blocks apply to this source, source
1515            version, uid / fpr combination"""
1516
1517         def block_rej_template(fb):
1518             rej = 'Manual upload block in place for package %s' % fb.source
1519             if fb.version is not None:
1520                 rej += ', version %s' % fb.version
1521             return rej
1522
1523         for fb in session.query(UploadBlock).filter_by(source = self.pkg.changes['source']).all():
1524             # version is None if the block applies to all versions
1525             if fb.version is None or fb.version == self.pkg.changes['version']:
1526                 # Check both fpr and uid - either is enough to cause a reject
1527                 if fb.fpr is not None:
1528                     if fb.fpr.fingerprint == fpr.fingerprint:
1529                         self.rejects.append(block_rej_template(fb) + ' for fingerprint %s\nReason: %s' % (fpr.fingerprint, fb.reason))
1530                 if fb.uid is not None:
1531                     if fb.uid == fpr.uid:
1532                         self.rejects.append(block_rej_template(fb) + ' for uid %s\nReason: %s' % (fb.uid.uid, fb.reason))
1533
1534
1535     def check_dm_upload(self, fpr, session):
1536         # Quoth the GR (http://www.debian.org/vote/2007/vote_003):
1537         ## none of the uploaded packages are NEW
1538         rej = False
1539         for f in self.pkg.files.keys():
1540             if self.pkg.files[f].has_key("byhand"):
1541                 self.rejects.append("%s may not upload BYHAND file %s" % (uid, f))
1542                 rej = True
1543             if self.pkg.files[f].has_key("new"):
1544                 self.rejects.append("%s may not upload NEW file %s" % (uid, f))
1545                 rej = True
1546
1547         if rej:
1548             return
1549
1550         ## the most recent version of the package uploaded to unstable or
1551         ## experimental includes the field "DM-Upload-Allowed: yes" in the source
1552         ## section of its control file
1553         q = session.query(DBSource).filter_by(source=self.pkg.changes["source"])
1554         q = q.join(SrcAssociation)
1555         q = q.join(Suite).filter(Suite.suite_name.in_(['unstable', 'experimental']))
1556         q = q.order_by(desc('source.version')).limit(1)
1557
1558         r = q.all()
1559
1560         if len(r) != 1:
1561             rej = "Could not find existing source package %s in unstable or experimental and this is a DM upload" % self.pkg.changes["source"]
1562             self.rejects.append(rej)
1563             return
1564
1565         r = r[0]
1566         if not r.dm_upload_allowed:
1567             rej = "Source package %s does not have 'DM-Upload-Allowed: yes' in its most recent version (%s)" % (self.pkg.changes["source"], r.version)
1568             self.rejects.append(rej)
1569             return
1570
1571         ## the Maintainer: field of the uploaded .changes file corresponds with
1572         ## the owner of the key used (ie, non-developer maintainers may not sponsor
1573         ## uploads)
1574         if self.check_if_upload_is_sponsored(fpr.uid.uid, fpr.uid.name):
1575             self.rejects.append("%s (%s) is not authorised to sponsor uploads" % (fpr.uid.uid, fpr.fingerprint))
1576
1577         ## the most recent version of the package uploaded to unstable or
1578         ## experimental lists the uploader in the Maintainer: or Uploaders: fields (ie,
1579         ## non-developer maintainers cannot NMU or hijack packages)
1580
1581         # srcuploaders includes the maintainer
1582         accept = False
1583         for sup in r.srcuploaders:
1584             (rfc822, rfc2047, name, email) = sup.maintainer.get_split_maintainer()
1585             # Eww - I hope we never have two people with the same name in Debian
1586             if email == fpr.uid.uid or name == fpr.uid.name:
1587                 accept = True
1588                 break
1589
1590         if not accept:
1591             self.rejects.append("%s is not in Maintainer or Uploaders of source package %s" % (fpr.uid.uid, self.pkg.changes["source"]))
1592             return
1593
1594         ## none of the packages are being taken over from other source packages
1595         for b in self.pkg.changes["binary"].keys():
1596             for suite in self.pkg.changes["distribution"].keys():
1597                 q = session.query(DBSource)
1598                 q = q.join(DBBinary).filter_by(package=b)
1599                 q = q.join(BinAssociation).join(Suite).filter_by(suite_name=suite)
1600
1601                 for s in q.all():
1602                     if s.source != self.pkg.changes["source"]:
1603                         self.rejects.append("%s may not hijack %s from source package %s in suite %s" % (fpr.uid.uid, b, s, suite))
1604
1605
1606
1607     def check_transition(self, session):
1608         cnf = Config()
1609
1610         sourcepkg = self.pkg.changes["source"]
1611
1612         # No sourceful upload -> no need to do anything else, direct return
1613         # We also work with unstable uploads, not experimental or those going to some
1614         # proposed-updates queue
1615         if "source" not in self.pkg.changes["architecture"] or \
1616            "unstable" not in self.pkg.changes["distribution"]:
1617             return
1618
1619         # Also only check if there is a file defined (and existant) with
1620         # checks.
1621         transpath = cnf.get("Dinstall::Reject::ReleaseTransitions", "")
1622         if transpath == "" or not os.path.exists(transpath):
1623             return
1624
1625         # Parse the yaml file
1626         sourcefile = file(transpath, 'r')
1627         sourcecontent = sourcefile.read()
1628         try:
1629             transitions = yaml.load(sourcecontent)
1630         except yaml.YAMLError, msg:
1631             # This shouldn't happen, there is a wrapper to edit the file which
1632             # checks it, but we prefer to be safe than ending up rejecting
1633             # everything.
1634             utils.warn("Not checking transitions, the transitions file is broken: %s." % (msg))
1635             return
1636
1637         # Now look through all defined transitions
1638         for trans in transitions:
1639             t = transitions[trans]
1640             source = t["source"]
1641             expected = t["new"]
1642
1643             # Will be None if nothing is in testing.
1644             current = get_source_in_suite(source, "testing", session)
1645             if current is not None:
1646                 compare = apt_pkg.VersionCompare(current.version, expected)
1647
1648             if current is None or compare < 0:
1649                 # This is still valid, the current version in testing is older than
1650                 # the new version we wait for, or there is none in testing yet
1651
1652                 # Check if the source we look at is affected by this.
1653                 if sourcepkg in t['packages']:
1654                     # The source is affected, lets reject it.
1655
1656                     rejectmsg = "%s: part of the %s transition.\n\n" % (
1657                         sourcepkg, trans)
1658
1659                     if current is not None:
1660                         currentlymsg = "at version %s" % (current.version)
1661                     else:
1662                         currentlymsg = "not present in testing"
1663
1664                     rejectmsg += "Transition description: %s\n\n" % (t["reason"])
1665
1666                     rejectmsg += "\n".join(textwrap.wrap("""Your package
1667 is part of a testing transition designed to get %s migrated (it is
1668 currently %s, we need version %s).  This transition is managed by the
1669 Release Team, and %s is the Release-Team member responsible for it.
1670 Please mail debian-release@lists.debian.org or contact %s directly if you
1671 need further assistance.  You might want to upload to experimental until this
1672 transition is done."""
1673                             % (source, currentlymsg, expected,t["rm"], t["rm"])))
1674
1675                     self.rejects.append(rejectmsg)
1676                     return
1677
1678     ###########################################################################
1679     # End check_signed_by_key checks
1680     ###########################################################################
1681
1682     def build_summaries(self):
1683         """ Build a summary of changes the upload introduces. """
1684
1685         (byhand, new, summary, override_summary) = self.pkg.file_summary()
1686
1687         short_summary = summary
1688
1689         # This is for direport's benefit...
1690         f = re_fdnic.sub("\n .\n", self.pkg.changes.get("changes", ""))
1691
1692         if byhand or new:
1693             summary += "Changes: " + f
1694
1695         summary += "\n\nOverride entries for your package:\n" + override_summary + "\n"
1696
1697         summary += self.announce(short_summary, 0)
1698
1699         return (summary, short_summary)
1700
1701     ###########################################################################
1702
1703     def close_bugs(self, summary, action):
1704         """
1705         Send mail to close bugs as instructed by the closes field in the changes file.
1706         Also add a line to summary if any work was done.
1707
1708         @type summary: string
1709         @param summary: summary text, as given by L{build_summaries}
1710
1711         @type action: bool
1712         @param action: Set to false no real action will be done.
1713
1714         @rtype: string
1715         @return: summary. If action was taken, extended by the list of closed bugs.
1716
1717         """
1718
1719         template = os.path.join(Config()["Dir::Templates"], 'process-unchecked.bug-close')
1720
1721         bugs = self.pkg.changes["closes"].keys()
1722
1723         if not bugs:
1724             return summary
1725
1726         bugs.sort()
1727         summary += "Closing bugs: "
1728         for bug in bugs:
1729             summary += "%s " % (bug)
1730             if action:
1731                 self.update_subst()
1732                 self.Subst["__BUG_NUMBER__"] = bug
1733                 if self.pkg.changes["distribution"].has_key("stable"):
1734                     self.Subst["__STABLE_WARNING__"] = """
1735 Note that this package is not part of the released stable Debian
1736 distribution.  It may have dependencies on other unreleased software,
1737 or other instabilities.  Please take care if you wish to install it.
1738 The update will eventually make its way into the next released Debian
1739 distribution."""
1740                 else:
1741                     self.Subst["__STABLE_WARNING__"] = ""
1742                 mail_message = utils.TemplateSubst(self.Subst, template)
1743                 utils.send_mail(mail_message)
1744
1745                 # Clear up after ourselves
1746                 del self.Subst["__BUG_NUMBER__"]
1747                 del self.Subst["__STABLE_WARNING__"]
1748
1749         if action and self.logger:
1750             self.logger.log(["closing bugs"] + bugs)
1751
1752         summary += "\n"
1753
1754         return summary
1755
1756     ###########################################################################
1757
1758     def announce(self, short_summary, action):
1759         """
1760         Send an announce mail about a new upload.
1761
1762         @type short_summary: string
1763         @param short_summary: Short summary text to include in the mail
1764
1765         @type action: bool
1766         @param action: Set to false no real action will be done.
1767
1768         @rtype: string
1769         @return: Textstring about action taken.
1770
1771         """
1772
1773         cnf = Config()
1774         announcetemplate = os.path.join(cnf["Dir::Templates"], 'process-unchecked.announce')
1775
1776         # Only do announcements for source uploads with a recent dpkg-dev installed
1777         if float(self.pkg.changes.get("format", 0)) < 1.6 or not \
1778            self.pkg.changes["architecture"].has_key("source"):
1779             return ""
1780
1781         lists_done = {}
1782         summary = ""
1783
1784         self.Subst["__SHORT_SUMMARY__"] = short_summary
1785
1786         for dist in self.pkg.changes["distribution"].keys():
1787             announce_list = cnf.Find("Suite::%s::Announce" % (dist))
1788             if announce_list == "" or lists_done.has_key(announce_list):
1789                 continue
1790
1791             lists_done[announce_list] = 1
1792             summary += "Announcing to %s\n" % (announce_list)
1793
1794             if action:
1795                 self.update_subst()
1796                 self.Subst["__ANNOUNCE_LIST_ADDRESS__"] = announce_list
1797                 if cnf.get("Dinstall::TrackingServer") and \
1798                    self.pkg.changes["architecture"].has_key("source"):
1799                     trackingsendto = "Bcc: %s@%s" % (self.pkg.changes["source"], cnf["Dinstall::TrackingServer"])
1800                     self.Subst["__ANNOUNCE_LIST_ADDRESS__"] += "\n" + trackingsendto
1801
1802                 mail_message = utils.TemplateSubst(self.Subst, announcetemplate)
1803                 utils.send_mail(mail_message)
1804
1805                 del self.Subst["__ANNOUNCE_LIST_ADDRESS__"]
1806
1807         if cnf.FindB("Dinstall::CloseBugs"):
1808             summary = self.close_bugs(summary, action)
1809
1810         del self.Subst["__SHORT_SUMMARY__"]
1811
1812         return summary
1813
1814     ###########################################################################
1815
1816     def accept (self, summary, short_summary, targetdir=None):
1817         """
1818         Accept an upload.
1819
1820         This moves all files referenced from the .changes into the I{accepted}
1821         queue, sends the accepted mail, announces to lists, closes bugs and
1822         also checks for override disparities. If enabled it will write out
1823         the version history for the BTS Version Tracking and will finally call
1824         L{queue_build}.
1825
1826         @type summary: string
1827         @param summary: Summary text
1828
1829         @type short_summary: string
1830         @param short_summary: Short summary
1831
1832         """
1833
1834         cnf = Config()
1835         stats = SummaryStats()
1836
1837         accepttemplate = os.path.join(cnf["Dir::Templates"], 'process-unchecked.accepted')
1838
1839         if targetdir is None:
1840             targetdir = cnf["Dir::Queue::Accepted"]
1841
1842         print "Accepting."
1843         if self.logger:
1844             self.logger.log(["Accepting changes", self.pkg.changes_file])
1845
1846         self.pkg.write_dot_dak(targetdir)
1847
1848         # Move all the files into the accepted directory
1849         utils.move(self.pkg.changes_file, targetdir)
1850
1851         for name, entry in sorted(self.pkg.files.items()):
1852             utils.move(name, targetdir)
1853             stats.accept_bytes += float(entry["size"])
1854
1855         stats.accept_count += 1
1856
1857         # Send accept mail, announce to lists, close bugs and check for
1858         # override disparities
1859         if not cnf["Dinstall::Options::No-Mail"]:
1860             self.update_subst()
1861             self.Subst["__SUITE__"] = ""
1862             self.Subst["__SUMMARY__"] = summary
1863             mail_message = utils.TemplateSubst(self.Subst, accepttemplate)
1864             utils.send_mail(mail_message)
1865             self.announce(short_summary, 1)
1866
1867         ## Helper stuff for DebBugs Version Tracking
1868         if cnf.Find("Dir::Queue::BTSVersionTrack"):
1869             # ??? once queue/* is cleared on *.d.o and/or reprocessed
1870             # the conditionalization on dsc["bts changelog"] should be
1871             # dropped.
1872
1873             # Write out the version history from the changelog
1874             if self.pkg.changes["architecture"].has_key("source") and \
1875                self.pkg.dsc.has_key("bts changelog"):
1876
1877                 (fd, temp_filename) = utils.temp_filename(cnf["Dir::Queue::BTSVersionTrack"], prefix=".")
1878                 version_history = os.fdopen(fd, 'w')
1879                 version_history.write(self.pkg.dsc["bts changelog"])
1880                 version_history.close()
1881                 filename = "%s/%s" % (cnf["Dir::Queue::BTSVersionTrack"],
1882                                       self.pkg.changes_file[:-8]+".versions")
1883                 os.rename(temp_filename, filename)
1884                 os.chmod(filename, 0644)
1885
1886             # Write out the binary -> source mapping.
1887             (fd, temp_filename) = utils.temp_filename(cnf["Dir::Queue::BTSVersionTrack"], prefix=".")
1888             debinfo = os.fdopen(fd, 'w')
1889             for name, entry in sorted(self.pkg.files.items()):
1890                 if entry["type"] == "deb":
1891                     line = " ".join([entry["package"], entry["version"],
1892                                      entry["architecture"], entry["source package"],
1893                                      entry["source version"]])
1894                     debinfo.write(line+"\n")
1895             debinfo.close()
1896             filename = "%s/%s" % (cnf["Dir::Queue::BTSVersionTrack"],
1897                                   self.pkg.changes_file[:-8]+".debinfo")
1898             os.rename(temp_filename, filename)
1899             os.chmod(filename, 0644)
1900
1901         # Its is Cnf["Dir::Queue::Accepted"] here, not targetdir!
1902         # <Ganneff> we do call queue_build too
1903         # <mhy> well yes, we'd have had to if we were inserting into accepted
1904         # <Ganneff> now. thats database only.
1905         # <mhy> urgh, that's going to get messy
1906         # <Ganneff> so i make the p-n call to it *also* using accepted/
1907         # <mhy> but then the packages will be in the queue_build table without the files being there
1908         # <Ganneff> as the buildd queue is only regenerated whenever unchecked runs
1909         # <mhy> ah, good point
1910         # <Ganneff> so it will work out, as unchecked move it over
1911         # <mhy> that's all completely sick
1912         # <Ganneff> yes
1913
1914         # This routine returns None on success or an error on failure
1915         res = get_or_set_queue('accepted').autobuild_upload(self.pkg, cnf["Dir::Queue::Accepted"])
1916         if res:
1917             utils.fubar(res)
1918
1919
1920     def check_override(self):
1921         """
1922         Checks override entries for validity. Mails "Override disparity" warnings,
1923         if that feature is enabled.
1924
1925         Abandons the check if
1926           - override disparity checks are disabled
1927           - mail sending is disabled
1928         """
1929
1930         cnf = Config()
1931
1932         # Abandon the check if:
1933         #  a) override disparity checks have been disabled
1934         #  b) we're not sending mail
1935         if not cnf.FindB("Dinstall::OverrideDisparityCheck") or \
1936            cnf["Dinstall::Options::No-Mail"]:
1937             return
1938
1939         summary = self.pkg.check_override()
1940
1941         if summary == "":
1942             return
1943
1944         overridetemplate = os.path.join(cnf["Dir::Templates"], 'process-unchecked.override-disparity')
1945
1946         self.update_subst()
1947         self.Subst["__SUMMARY__"] = summary
1948         mail_message = utils.TemplateSubst(self.Subst, overridetemplate)
1949         utils.send_mail(mail_message)
1950         del self.Subst["__SUMMARY__"]
1951
1952     ###########################################################################
1953
1954     def remove(self, dir=None):
1955         """
1956         Used (for instance) in p-u to remove the package from unchecked
1957         """
1958         if dir is None:
1959             os.chdir(self.pkg.directory)
1960         else:
1961             os.chdir(dir)
1962
1963         for f in self.pkg.files.keys():
1964             os.unlink(f)
1965         os.unlink(self.pkg.changes_file)
1966
1967     ###########################################################################
1968
1969     def move_to_dir (self, dest, perms=0660, changesperms=0664):
1970         """
1971         Move files to dest with certain perms/changesperms
1972         """
1973         utils.move(self.pkg.changes_file, dest, perms=changesperms)
1974         for f in self.pkg.files.keys():
1975             utils.move(f, dest, perms=perms)
1976
1977     ###########################################################################
1978
1979     def force_reject(self, reject_files):
1980         """
1981         Forcefully move files from the current directory to the
1982         reject directory.  If any file already exists in the reject
1983         directory it will be moved to the morgue to make way for
1984         the new file.
1985
1986         @type files: dict
1987         @param files: file dictionary
1988
1989         """
1990
1991         cnf = Config()
1992
1993         for file_entry in reject_files:
1994             # Skip any files which don't exist or which we don't have permission to copy.
1995             if os.access(file_entry, os.R_OK) == 0:
1996                 continue
1997
1998             dest_file = os.path.join(cnf["Dir::Queue::Reject"], file_entry)
1999
2000             try:
2001                 dest_fd = os.open(dest_file, os.O_RDWR | os.O_CREAT | os.O_EXCL, 0644)
2002             except OSError, e:
2003                 # File exists?  Let's try and move it to the morgue
2004                 if e.errno == errno.EEXIST:
2005                     morgue_file = os.path.join(cnf["Dir::Morgue"], cnf["Dir::MorgueReject"], file_entry)
2006                     try:
2007                         morgue_file = utils.find_next_free(morgue_file)
2008                     except NoFreeFilenameError:
2009                         # Something's either gone badly Pete Tong, or
2010                         # someone is trying to exploit us.
2011                         utils.warn("**WARNING** failed to move %s from the reject directory to the morgue." % (file_entry))
2012                         return
2013                     utils.move(dest_file, morgue_file, perms=0660)
2014                     try:
2015                         dest_fd = os.open(dest_file, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
2016                     except OSError, e:
2017                         # Likewise
2018                         utils.warn("**WARNING** failed to claim %s in the reject directory." % (file_entry))
2019                         return
2020                 else:
2021                     raise
2022             # If we got here, we own the destination file, so we can
2023             # safely overwrite it.
2024             utils.move(file_entry, dest_file, 1, perms=0660)
2025             os.close(dest_fd)
2026
2027     ###########################################################################
2028     def do_reject (self, manual=0, reject_message="", note=""):
2029         """
2030         Reject an upload. If called without a reject message or C{manual} is
2031         true, spawn an editor so the user can write one.
2032
2033         @type manual: bool
2034         @param manual: manual or automated rejection
2035
2036         @type reject_message: string
2037         @param reject_message: A reject message
2038
2039         @return: 0
2040
2041         """
2042         # If we weren't given a manual rejection message, spawn an
2043         # editor so the user can add one in...
2044         if manual and not reject_message:
2045             (fd, temp_filename) = utils.temp_filename()
2046             temp_file = os.fdopen(fd, 'w')
2047             if len(note) > 0:
2048                 for line in note:
2049                     temp_file.write(line)
2050             temp_file.close()
2051             editor = os.environ.get("EDITOR","vi")
2052             answer = 'E'
2053             while answer == 'E':
2054                 os.system("%s %s" % (editor, temp_filename))
2055                 temp_fh = utils.open_file(temp_filename)
2056                 reject_message = "".join(temp_fh.readlines())
2057                 temp_fh.close()
2058                 print "Reject message:"
2059                 print utils.prefix_multi_line_string(reject_message,"  ",include_blank_lines=1)
2060                 prompt = "[R]eject, Edit, Abandon, Quit ?"
2061                 answer = "XXX"
2062                 while prompt.find(answer) == -1:
2063                     answer = utils.our_raw_input(prompt)
2064                     m = re_default_answer.search(prompt)
2065                     if answer == "":
2066                         answer = m.group(1)
2067                     answer = answer[:1].upper()
2068             os.unlink(temp_filename)
2069             if answer == 'A':
2070                 return 1
2071             elif answer == 'Q':
2072                 sys.exit(0)
2073
2074         print "Rejecting.\n"
2075
2076         cnf = Config()
2077
2078         reason_filename = self.pkg.changes_file[:-8] + ".reason"
2079         reason_filename = os.path.join(cnf["Dir::Queue::Reject"], reason_filename)
2080
2081         # Move all the files into the reject directory
2082         reject_files = self.pkg.files.keys() + [self.pkg.changes_file]
2083         self.force_reject(reject_files)
2084
2085         # If we fail here someone is probably trying to exploit the race
2086         # so let's just raise an exception ...
2087         if os.path.exists(reason_filename):
2088             os.unlink(reason_filename)
2089         reason_fd = os.open(reason_filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
2090
2091         rej_template = os.path.join(cnf["Dir::Templates"], "queue.rejected")
2092
2093         self.update_subst()
2094         if not manual:
2095             self.Subst["__REJECTOR_ADDRESS__"] = cnf["Dinstall::MyEmailAddress"]
2096             self.Subst["__MANUAL_REJECT_MESSAGE__"] = ""
2097             self.Subst["__CC__"] = "X-DAK-Rejection: automatic (moo)"
2098             os.write(reason_fd, reject_message)
2099             reject_mail_message = utils.TemplateSubst(self.Subst, rej_template)
2100         else:
2101             # Build up the rejection email
2102             user_email_address = utils.whoami() + " <%s>" % (cnf["Dinstall::MyAdminAddress"])
2103             self.Subst["__REJECTOR_ADDRESS__"] = user_email_address
2104             self.Subst["__MANUAL_REJECT_MESSAGE__"] = reject_message
2105             self.Subst["__CC__"] = "Cc: " + cnf["Dinstall::MyEmailAddress"]
2106             reject_mail_message = utils.TemplateSubst(self.Subst, rej_template)
2107             # Write the rejection email out as the <foo>.reason file
2108             os.write(reason_fd, reject_mail_message)
2109
2110         del self.Subst["__REJECTOR_ADDRESS__"]
2111         del self.Subst["__MANUAL_REJECT_MESSAGE__"]
2112         del self.Subst["__CC__"]
2113
2114         os.close(reason_fd)
2115
2116         # Send the rejection mail if appropriate
2117         if not cnf["Dinstall::Options::No-Mail"]:
2118             utils.send_mail(reject_mail_message)
2119
2120         if self.logger:
2121             self.logger.log(["rejected", self.pkg.changes_file])
2122
2123         return 0
2124
2125     ################################################################################
2126     def in_override_p(self, package, component, suite, binary_type, file, session):
2127         """
2128         Check if a package already has override entries in the DB
2129
2130         @type package: string
2131         @param package: package name
2132
2133         @type component: string
2134         @param component: database id of the component
2135
2136         @type suite: int
2137         @param suite: database id of the suite
2138
2139         @type binary_type: string
2140         @param binary_type: type of the package
2141
2142         @type file: string
2143         @param file: filename we check
2144
2145         @return: the database result. But noone cares anyway.
2146
2147         """
2148
2149         cnf = Config()
2150
2151         if binary_type == "": # must be source
2152             file_type = "dsc"
2153         else:
2154             file_type = binary_type
2155
2156         # Override suite name; used for example with proposed-updates
2157         if cnf.Find("Suite::%s::OverrideSuite" % (suite)) != "":
2158             suite = cnf["Suite::%s::OverrideSuite" % (suite)]
2159
2160         result = get_override(package, suite, component, file_type, session)
2161
2162         # If checking for a source package fall back on the binary override type
2163         if file_type == "dsc" and len(result) < 1:
2164             result = get_override(package, suite, component, ['deb', 'udeb'], session)
2165
2166         # Remember the section and priority so we can check them later if appropriate
2167         if len(result) > 0:
2168             result = result[0]
2169             self.pkg.files[file]["override section"] = result.section.section
2170             self.pkg.files[file]["override priority"] = result.priority.priority
2171             return result
2172
2173         return None
2174
2175     ################################################################################
2176     def get_anyversion(self, sv_list, suite):
2177         """
2178         @type sv_list: list
2179         @param sv_list: list of (suite, version) tuples to check
2180
2181         @type suite: string
2182         @param suite: suite name
2183
2184         Description: TODO
2185         """
2186         Cnf = Config()
2187         anyversion = None
2188         anysuite = [suite] + Cnf.ValueList("Suite::%s::VersionChecks::Enhances" % (suite))
2189         for (s, v) in sv_list:
2190             if s in [ x.lower() for x in anysuite ]:
2191                 if not anyversion or apt_pkg.VersionCompare(anyversion, v) <= 0:
2192                     anyversion = v
2193
2194         return anyversion
2195
2196     ################################################################################
2197
2198     def cross_suite_version_check(self, sv_list, file, new_version, sourceful=False):
2199         """
2200         @type sv_list: list
2201         @param sv_list: list of (suite, version) tuples to check
2202
2203         @type file: string
2204         @param file: XXX
2205
2206         @type new_version: string
2207         @param new_version: XXX
2208
2209         Ensure versions are newer than existing packages in target
2210         suites and that cross-suite version checking rules as
2211         set out in the conf file are satisfied.
2212         """
2213
2214         cnf = Config()
2215
2216         # Check versions for each target suite
2217         for target_suite in self.pkg.changes["distribution"].keys():
2218             must_be_newer_than = [ i.lower() for i in cnf.ValueList("Suite::%s::VersionChecks::MustBeNewerThan" % (target_suite)) ]
2219             must_be_older_than = [ i.lower() for i in cnf.ValueList("Suite::%s::VersionChecks::MustBeOlderThan" % (target_suite)) ]
2220
2221             # Enforce "must be newer than target suite" even if conffile omits it
2222             if target_suite not in must_be_newer_than:
2223                 must_be_newer_than.append(target_suite)
2224
2225             for (suite, existent_version) in sv_list:
2226                 vercmp = apt_pkg.VersionCompare(new_version, existent_version)
2227
2228                 if suite in must_be_newer_than and sourceful and vercmp < 1:
2229                     self.rejects.append("%s: old version (%s) in %s >= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
2230
2231                 if suite in must_be_older_than and vercmp > -1:
2232                     cansave = 0
2233
2234                     if self.pkg.changes.get('distribution-version', {}).has_key(suite):
2235                         # we really use the other suite, ignoring the conflicting one ...
2236                         addsuite = self.pkg.changes["distribution-version"][suite]
2237
2238                         add_version = self.get_anyversion(sv_list, addsuite)
2239                         target_version = self.get_anyversion(sv_list, target_suite)
2240
2241                         if not add_version:
2242                             # not add_version can only happen if we map to a suite
2243                             # that doesn't enhance the suite we're propup'ing from.
2244                             # so "propup-ver x a b c; map a d" is a problem only if
2245                             # d doesn't enhance a.
2246                             #
2247                             # i think we could always propagate in this case, rather
2248                             # than complaining. either way, this isn't a REJECT issue
2249                             #
2250                             # And - we really should complain to the dorks who configured dak
2251                             self.warnings.append("%s is mapped to, but not enhanced by %s - adding anyways" % (suite, addsuite))
2252                             self.pkg.changes.setdefault("propdistribution", {})
2253                             self.pkg.changes["propdistribution"][addsuite] = 1
2254                             cansave = 1
2255                         elif not target_version:
2256                             # not targets_version is true when the package is NEW
2257                             # we could just stick with the "...old version..." REJECT
2258                             # for this, I think.
2259                             self.rejects.append("Won't propogate NEW packages.")
2260                         elif apt_pkg.VersionCompare(new_version, add_version) < 0:
2261                             # propogation would be redundant. no need to reject though.
2262                             self.warnings.append("ignoring versionconflict: %s: old version (%s) in %s <= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
2263                             cansave = 1
2264                         elif apt_pkg.VersionCompare(new_version, add_version) > 0 and \
2265                              apt_pkg.VersionCompare(add_version, target_version) >= 0:
2266                             # propogate!!
2267                             self.warnings.append("Propogating upload to %s" % (addsuite))
2268                             self.pkg.changes.setdefault("propdistribution", {})
2269                             self.pkg.changes["propdistribution"][addsuite] = 1
2270                             cansave = 1
2271
2272                     if not cansave:
2273                         self.reject.append("%s: old version (%s) in %s <= new version (%s) targeted at %s." % (file, existent_version, suite, new_version, target_suite))
2274
2275     ################################################################################
2276     def check_binary_against_db(self, file, session):
2277         # Ensure version is sane
2278         q = session.query(BinAssociation)
2279         q = q.join(DBBinary).filter(DBBinary.package==self.pkg.files[file]["package"])
2280         q = q.join(Architecture).filter(Architecture.arch_string.in_([self.pkg.files[file]["architecture"], 'all']))
2281
2282         self.cross_suite_version_check([ (x.suite.suite_name, x.binary.version) for x in q.all() ],
2283                                        file, self.pkg.files[file]["version"], sourceful=False)
2284
2285         # Check for any existing copies of the file
2286         q = session.query(DBBinary).filter_by(package=self.pkg.files[file]["package"])
2287         q = q.filter_by(version=self.pkg.files[file]["version"])
2288         q = q.join(Architecture).filter_by(arch_string=self.pkg.files[file]["architecture"])
2289
2290         if q.count() > 0:
2291             self.rejects.append("%s: can not overwrite existing copy already in the archive." % (file))
2292
2293     ################################################################################
2294
2295     def check_source_against_db(self, file, session):
2296         """
2297         """
2298         source = self.pkg.dsc.get("source")
2299         version = self.pkg.dsc.get("version")
2300
2301         # Ensure version is sane
2302         q = session.query(SrcAssociation)
2303         q = q.join(DBSource).filter(DBSource.source==source)
2304
2305         self.cross_suite_version_check([ (x.suite.suite_name, x.source.version) for x in q.all() ],
2306                                        file, version, sourceful=True)
2307
2308     ################################################################################
2309     def check_dsc_against_db(self, file, session):
2310         """
2311
2312         @warning: NB: this function can remove entries from the 'files' index [if
2313          the orig tarball is a duplicate of the one in the archive]; if
2314          you're iterating over 'files' and call this function as part of
2315          the loop, be sure to add a check to the top of the loop to
2316          ensure you haven't just tried to dereference the deleted entry.
2317
2318         """
2319
2320         Cnf = Config()
2321         self.pkg.orig_files = {} # XXX: do we need to clear it?
2322         orig_files = self.pkg.orig_files
2323
2324         # Try and find all files mentioned in the .dsc.  This has
2325         # to work harder to cope with the multiple possible
2326         # locations of an .orig.tar.gz.
2327         # The ordering on the select is needed to pick the newest orig
2328         # when it exists in multiple places.
2329         for dsc_name, dsc_entry in self.pkg.dsc_files.items():
2330             found = None
2331             if self.pkg.files.has_key(dsc_name):
2332                 actual_md5 = self.pkg.files[dsc_name]["md5sum"]
2333                 actual_size = int(self.pkg.files[dsc_name]["size"])
2334                 found = "%s in incoming" % (dsc_name)
2335
2336                 # Check the file does not already exist in the archive
2337                 ql = get_poolfile_like_name(dsc_name, session)
2338
2339                 # Strip out anything that isn't '%s' or '/%s$'
2340                 for i in ql:
2341                     if not i.filename.endswith(dsc_name):
2342                         ql.remove(i)
2343
2344                 # "[dak] has not broken them.  [dak] has fixed a
2345                 # brokenness.  Your crappy hack exploited a bug in
2346                 # the old dinstall.
2347                 #
2348                 # "(Come on!  I thought it was always obvious that
2349                 # one just doesn't release different files with
2350                 # the same name and version.)"
2351                 #                        -- ajk@ on d-devel@l.d.o
2352
2353                 if len(ql) > 0:
2354                     # Ignore exact matches for .orig.tar.gz
2355                     match = 0
2356                     if re_is_orig_source.match(dsc_name):
2357                         for i in ql:
2358                             if self.pkg.files.has_key(dsc_name) and \
2359                                int(self.pkg.files[dsc_name]["size"]) == int(i.filesize) and \
2360                                self.pkg.files[dsc_name]["md5sum"] == i.md5sum:
2361                                 self.warnings.append("ignoring %s, since it's already in the archive." % (dsc_name))
2362                                 # TODO: Don't delete the entry, just mark it as not needed
2363                                 # This would fix the stupidity of changing something we often iterate over
2364                                 # whilst we're doing it
2365                                 del self.pkg.files[dsc_name]
2366                                 if not orig_files.has_key(dsc_name):
2367                                     orig_files[dsc_name] = {}
2368                                 orig_files[dsc_name]["path"] = os.path.join(i.location.path, i.filename)
2369                                 match = 1
2370
2371                     if not match:
2372                         self.rejects.append("can not overwrite existing copy of '%s' already in the archive." % (dsc_name))
2373
2374             elif re_is_orig_source.match(dsc_name):
2375                 # Check in the pool
2376                 ql = get_poolfile_like_name(dsc_name, session)
2377
2378                 # Strip out anything that isn't '%s' or '/%s$'
2379                 # TODO: Shouldn't we just search for things which end with our string explicitly in the SQL?
2380                 for i in ql:
2381                     if not i.filename.endswith(dsc_name):
2382                         ql.remove(i)
2383
2384                 if len(ql) > 0:
2385                     # Unfortunately, we may get more than one match here if,
2386                     # for example, the package was in potato but had an -sa
2387                     # upload in woody.  So we need to choose the right one.
2388
2389                     # default to something sane in case we don't match any or have only one
2390                     x = ql[0]
2391
2392                     if len(ql) > 1:
2393                         for i in ql:
2394                             old_file = os.path.join(i.location.path, i.filename)
2395                             old_file_fh = utils.open_file(old_file)
2396                             actual_md5 = apt_pkg.md5sum(old_file_fh)
2397                             old_file_fh.close()
2398                             actual_size = os.stat(old_file)[stat.ST_SIZE]
2399                             if actual_md5 == dsc_entry["md5sum"] and actual_size == int(dsc_entry["size"]):
2400                                 x = i
2401
2402                     old_file = os.path.join(i.location.path, i.filename)
2403                     old_file_fh = utils.open_file(old_file)
2404                     actual_md5 = apt_pkg.md5sum(old_file_fh)
2405                     old_file_fh.close()
2406                     actual_size = os.stat(old_file)[stat.ST_SIZE]
2407                     found = old_file
2408                     suite_type = x.location.archive_type
2409                     # need this for updating dsc_files in install()
2410                     dsc_entry["files id"] = x.file_id
2411                     # See install() in process-accepted...
2412                     if not orig_files.has_key(dsc_name):
2413                         orig_files[dsc_name] = {}
2414                     orig_files[dsc_name]["id"] = x.file_id
2415                     orig_files[dsc_name]["path"] = old_file
2416                     orig_files[dsc_name]["location"] = x.location.location_id
2417                 else:
2418                     # TODO: Record the queues and info in the DB so we don't hardcode all this crap
2419                     # Not there? Check the queue directories...
2420                     for directory in [ "Accepted", "New", "Byhand", "ProposedUpdates", "OldProposedUpdates", "Embargoed", "Unembargoed" ]:
2421                         if not Cnf.has_key("Dir::Queue::%s" % (directory)):
2422                             continue
2423                         in_otherdir = os.path.join(Cnf["Dir::Queue::%s" % (directory)], dsc_name)
2424                         if os.path.exists(in_otherdir):
2425                             in_otherdir_fh = utils.open_file(in_otherdir)
2426                             actual_md5 = apt_pkg.md5sum(in_otherdir_fh)
2427                             in_otherdir_fh.close()
2428                             actual_size = os.stat(in_otherdir)[stat.ST_SIZE]
2429                             found = in_otherdir
2430                             if not orig_files.has_key(dsc_name):
2431                                 orig_files[dsc_name] = {}
2432                             orig_files[dsc_name]["path"] = in_otherdir
2433
2434                     if not found:
2435                         self.rejects.append("%s refers to %s, but I can't find it in the queue or in the pool." % (file, dsc_name))
2436                         continue
2437             else:
2438                 self.rejects.append("%s refers to %s, but I can't find it in the queue." % (file, dsc_name))
2439                 continue
2440             if actual_md5 != dsc_entry["md5sum"]:
2441                 self.rejects.append("md5sum for %s doesn't match %s." % (found, file))
2442             if actual_size != int(dsc_entry["size"]):
2443                 self.rejects.append("size for %s doesn't match %s." % (found, file))
2444
2445     ################################################################################
2446     # This is used by process-new and process-holding to recheck a changes file
2447     # at the time we're running.  It mainly wraps various other internal functions
2448     # and is similar to accepted_checks - these should probably be tidied up
2449     # and combined
2450     def recheck(self, session):
2451         cnf = Config()
2452         for f in self.pkg.files.keys():
2453             # The .orig.tar.gz can disappear out from under us is it's a
2454             # duplicate of one in the archive.
2455             if not self.pkg.files.has_key(f):
2456                 continue
2457
2458             entry = self.pkg.files[f]
2459
2460             # Check that the source still exists
2461             if entry["type"] == "deb":
2462                 source_version = entry["source version"]
2463                 source_package = entry["source package"]
2464                 if not self.pkg.changes["architecture"].has_key("source") \
2465                    and not source_exists(source_package, source_version, self.pkg.changes["distribution"].keys(), session):
2466                     source_epochless_version = re_no_epoch.sub('', source_version)
2467                     dsc_filename = "%s_%s.dsc" % (source_package, source_epochless_version)
2468                     found = False
2469                     for q in ["Accepted", "Embargoed", "Unembargoed", "Newstage"]:
2470                         if cnf.has_key("Dir::Queue::%s" % (q)):
2471                             if os.path.exists(cnf["Dir::Queue::%s" % (q)] + '/' + dsc_filename):
2472                                 found = True
2473                     if not found:
2474                         self.rejects.append("no source found for %s %s (%s)." % (source_package, source_version, f))
2475
2476             # Version and file overwrite checks
2477             if entry["type"] == "deb":
2478                 self.check_binary_against_db(f, session)
2479             elif entry["type"] == "dsc":
2480                 self.check_source_against_db(f, session)
2481                 self.check_dsc_against_db(f, session)
2482
2483     ################################################################################
2484     def accepted_checks(self, overwrite_checks, session):
2485         # Recheck anything that relies on the database; since that's not
2486         # frozen between accept and our run time when called from p-a.
2487
2488         # overwrite_checks is set to False when installing to stable/oldstable
2489
2490         propogate={}
2491         nopropogate={}
2492
2493         # Find the .dsc (again)
2494         dsc_filename = None
2495         for f in self.pkg.files.keys():
2496             if self.pkg.files[f]["type"] == "dsc":
2497                 dsc_filename = f
2498
2499         for checkfile in self.pkg.files.keys():
2500             # The .orig.tar.gz can disappear out from under us is it's a
2501             # duplicate of one in the archive.
2502             if not self.pkg.files.has_key(checkfile):
2503                 continue
2504
2505             entry = self.pkg.files[checkfile]
2506
2507             # Check that the source still exists
2508             if entry["type"] == "deb":
2509                 source_version = entry["source version"]
2510                 source_package = entry["source package"]
2511                 if not self.pkg.changes["architecture"].has_key("source") \
2512                    and not source_exists(source_package, source_version,  self.pkg.changes["distribution"].keys()):
2513                     self.rejects.append("no source found for %s %s (%s)." % (source_package, source_version, checkfile))
2514
2515             # Version and file overwrite checks
2516             if overwrite_checks:
2517                 if entry["type"] == "deb":
2518                     self.check_binary_against_db(checkfile, session)
2519                 elif entry["type"] == "dsc":
2520                     self.check_source_against_db(checkfile, session)
2521                     self.check_dsc_against_db(dsc_filename, session)
2522
2523             # propogate in the case it is in the override tables:
2524             for suite in self.pkg.changes.get("propdistribution", {}).keys():
2525                 if self.in_override_p(entry["package"], entry["component"], suite, entry.get("dbtype",""), checkfile, session):
2526                     propogate[suite] = 1
2527                 else:
2528                     nopropogate[suite] = 1
2529
2530         for suite in propogate.keys():
2531             if suite in nopropogate:
2532                 continue
2533             self.pkg.changes["distribution"][suite] = 1
2534
2535         for checkfile in self.pkg.files.keys():
2536             # Check the package is still in the override tables
2537             for suite in self.pkg.changes["distribution"].keys():
2538                 if not self.in_override_p(entry["package"], entry["component"], suite, entry.get("dbtype",""), checkfile, session):
2539                     self.rejects.append("%s is NEW for %s." % (checkfile, suite))
2540
2541     ################################################################################
2542     # This is not really a reject, but an unaccept, but since a) the code for
2543     # that is non-trivial (reopen bugs, unannounce etc.), b) this should be
2544     # extremely rare, for now we'll go with whining at our admin folks...
2545
2546     def do_unaccept(self):
2547         cnf = Config()
2548
2549         self.update_subst()
2550         self.Subst["__REJECTOR_ADDRESS__"] = cnf["Dinstall::MyEmailAddress"]
2551         self.Subst["__REJECT_MESSAGE__"] = self.package_info()
2552         self.Subst["__CC__"] = "Cc: " + cnf["Dinstall::MyEmailAddress"]
2553         self.Subst["__BCC__"] = "X-DAK: dak process-accepted"
2554         if cnf.has_key("Dinstall::Bcc"):
2555             self.Subst["__BCC__"] += "\nBcc: %s" % (cnf["Dinstall::Bcc"])
2556
2557         template = os.path.join(cnf["Dir::Templates"], "process-accepted.unaccept")
2558
2559         reject_mail_message = utils.TemplateSubst(self.Subst, template)
2560
2561         # Write the rejection email out as the <foo>.reason file
2562         reason_filename = os.path.basename(self.pkg.changes_file[:-8]) + ".reason"
2563         reject_filename = os.path.join(cnf["Dir::Queue::Reject"], reason_filename)
2564
2565         # If we fail here someone is probably trying to exploit the race
2566         # so let's just raise an exception ...
2567         if os.path.exists(reject_filename):
2568             os.unlink(reject_filename)
2569
2570         fd = os.open(reject_filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0644)
2571         os.write(fd, reject_mail_message)
2572         os.close(fd)
2573
2574         utils.send_mail(reject_mail_message)
2575
2576         del self.Subst["__REJECTOR_ADDRESS__"]
2577         del self.Subst["__REJECT_MESSAGE__"]
2578         del self.Subst["__CC__"]
2579
2580     ################################################################################
2581     # If any file of an upload has a recent mtime then chances are good
2582     # the file is still being uploaded.
2583
2584     def upload_too_new(self):
2585         cnf = Config()
2586         too_new = False
2587         # Move back to the original directory to get accurate time stamps
2588         cwd = os.getcwd()
2589         os.chdir(self.pkg.directory)
2590         file_list = self.pkg.files.keys()
2591         file_list.extend(self.pkg.dsc_files.keys())
2592         file_list.append(self.pkg.changes_file)
2593         for f in file_list:
2594             try:
2595                 last_modified = time.time()-os.path.getmtime(f)
2596                 if last_modified < int(cnf["Dinstall::SkipTime"]):
2597                     too_new = True
2598                     break
2599             except:
2600                 pass
2601
2602         os.chdir(cwd)
2603         return too_new