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