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