Fix dirmngr problems on CE.
[gnupg.git] / dirmngr / crlcache.c
1 /* crlcache.c - LDAP access
2  * Copyright (C) 2002 Klarälvdalens Datakonsult AB
3  * Copyright (C) 2003, 2004, 2005, 2008 g10 Code GmbH
4  *
5  * This file is part of DirMngr.
6  *
7  * DirMngr is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * DirMngr is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* 
22
23    1. To keep track of the CRLs actually cached and to store the meta
24       information of the CRLs a simple record oriented text file is
25       used.  Fields in the file are colon (':') separated and values
26       containing colons or linefeeds are percent escaped (e.g. a colon
27       itself is represented as "%3A"). 
28
29       The first field is a record type identifier, so that the file is
30       useful to keep track of other meta data too.  
31
32       The name of the file is "DIR.txt".
33
34
35    1.1. Comment record
36
37         Field 1: Constant beginning with "#".
38
39         Other fields are not defined and such a record is simply
40         skipped during processing.
41
42    1.2. Version record
43
44         Field 1: Constant "v"
45         Field 2: Version number of this file.  Must be 1.
46
47         This record must be the first non-comment record record and
48         there shall only exist one record of this type.
49
50    1.3. CRL cache record
51
52         Field 1: Constant "c", "u" or "i".
53                  A "c" or "u" indicate a valid cache entry, however
54                  "u" requires that a user root certificate check needs
55                  to be done.
56                  An "i" indicates an invalid Cache entry which should
57                  not be used but still exists so that it can be
58                  updated at NEXT_UPDATE. 
59         Field 2: Hexadecimal encoded SHA-1 hash of the issuer DN using
60                  uppercase letters.
61         Field 3: Issuer DN in RFC-2253 notation.
62         Field 4: URL used to retrieve the corresponding CRL.
63         Field 5: 15 character ISO timestamp with THIS_UPDATE.
64         Field 6: 15 character ISO timestamp with NEXT_UPDATE.
65         Field 7: Hexadecimal encoded MD-5 hash of the DB file to detect
66                  accidental modified (i.e. deleted and created) cache files.
67         Field 8: optional CRL number as a hex string.
68         Field 9:  AuthorityKeyID.issuer, each Name separated by 0x01
69         Field 10: AuthorityKeyID.serial
70         Field 11: Hex fingerprint of trust anchor if field 1 is 'u'.
71
72    2. Layout of the standard CRL Cache DB file:
73
74       We use records of variable length with this structure
75
76       n  bytes  Serialnumber (binary) used as key
77                 thus there is no need to store the length explicitly with DB2.
78       1  byte   Reason for revocation 
79                 (currently the KSBA reason flags are used)
80       15 bytes  ISO date of revocation (e.g. 19980815T142000)
81                 Note that there is no terminating 0 stored.
82
83       The filename used is the hexadecimal (using uppercase letters)
84       SHA-1 hash value of the issuer DN prefixed with a "crl-" and
85       suffixed with a ".db".  Thus the length of the filename is 47.
86       
87
88 */
89
90 #include <config.h>
91
92 #include <stdio.h>
93 #include <stdlib.h>
94 #include <errno.h>
95 #include <string.h>
96 #include <sys/stat.h>
97 #include <assert.h>
98 #include <dirent.h>
99 #include <fcntl.h>
100 #include <unistd.h>
101 #ifndef HAVE_W32_SYSTEM
102 #include <sys/utsname.h>
103 #endif
104 #ifdef MKDIR_TAKES_ONE_ARG
105 #undef mkdir
106 #define mkdir(a,b) mkdir(a)
107 #endif
108
109 #include "dirmngr.h"
110 #include "validate.h"
111 #include "certcache.h"
112 #include "crlcache.h"
113 #include "crlfetch.h"
114 #include "misc.h"
115 #include "cdb.h"
116 #include "estream-printf.h"
117
118 /* Change this whenever the format changes */
119 #define DBDIR_D (opt.system_daemon? "crls.d" : "dirmngr-cache.d")
120 #define DBDIRFILE "DIR.txt"
121 #define DBDIRVERSION 1
122
123 /* The number of DB files we may have open at one time.  We need to
124    limit this because there is no guarantee that the number of issuers
125    has a upper limit.  We are currently using mmap, so it is a good
126    idea anyway to limit the number of opened cache files. */
127 #define MAX_OPEN_DB_FILES 5
128
129
130 static const char oidstr_crlNumber[] = "2.5.29.20";
131 static const char oidstr_issuingDistributionPoint[] = "2.5.29.28";
132 static const char oidstr_authorityKeyIdentifier[] = "2.5.29.35";
133
134
135 /* Definition of one cached item. */
136 struct crl_cache_entry_s 
137 {
138   struct crl_cache_entry_s *next;
139   int deleted;        /* True if marked for deletion. */
140   int mark;           /* Internally used by update_dir. */
141   unsigned int lineno;/* A 0 indicates a new entry. */
142   char *release_ptr;  /* The actual allocated memory. */
143   char *url;          /* Points into RELEASE_PTR. */
144   char *issuer;       /* Ditto. */
145   char *issuer_hash;  /* Ditto. */
146   char *dbfile_hash;  /* MD5 sum of the cache file, points into RELEASE_PTR.*/
147   int invalid;        /* Can't use this CRL. */
148   int user_trust_req; /* User supplied root certificate required.  */
149   char *check_trust_anchor;  /* Malloced fingerprint.  */
150   ksba_isotime_t this_update;
151   ksba_isotime_t next_update;
152   ksba_isotime_t last_refresh; /* Use for the force_crl_refresh feature. */
153   char *crl_number;
154   char *authority_issuer;
155   char *authority_serialno;
156
157   struct cdb *cdb;             /* The cache file handle or NULL if not open. */
158
159   unsigned int cdb_use_count;  /* Current use count. */
160   unsigned int cdb_lru_count;  /* Used for LRU purposes. */
161   int dbfile_checked;          /* Set to true if the dbfile_hash value has
162                                   been checked one. */
163 };
164
165
166 /* Definition of the entire cache object. */
167 struct crl_cache_s 
168 {
169   crl_cache_entry_t entries;
170 };
171
172 typedef struct crl_cache_s *crl_cache_t;
173
174
175 /* Prototypes.  */
176 static crl_cache_entry_t find_entry (crl_cache_entry_t first,
177                                      const char *issuer_hash);
178
179
180
181 /* The currently loaded cache object.  This isi usually initialized
182    right at startup.  */
183 static crl_cache_t current_cache;
184
185
186
187
188 \f
189 /* Return the current cache object or bail out if it is has not yet
190    been initialized.  */
191 static crl_cache_t
192 get_current_cache (void)
193 {
194   if (!current_cache)
195     log_fatal ("CRL cache has not yet been initialized\n");
196   return current_cache;
197 }
198
199
200 /* 
201    Create ae directory if it does not yet exists.  Returns on
202    success, or -1 on error.
203  */
204 static int
205 create_directory_if_needed (const char *name)
206 {
207   DIR *dir;
208   char *fname;
209
210   fname = make_filename (opt.homedir_cache, name, NULL);
211   dir = opendir (fname);
212   if (!dir)
213     {
214       log_info (_("creating directory `%s'\n"), fname);
215       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR) )
216         {
217           int save_errno = errno;
218           log_error (_("error creating directory `%s': %s\n"),
219                      fname, strerror (errno));
220           xfree (fname);
221           gpg_err_set_errno (save_errno);
222           return -1;
223         }
224     } 
225   else
226     closedir (dir);
227   xfree (fname);
228   return 0;
229 }
230
231 /* Remove all files from the cache directory.  If FORCE is not true,
232    some sanity checks on the filenames are done. Return 0 if
233    everything went fine. */
234 static int
235 cleanup_cache_dir (int force)
236 {
237   char *dname = make_filename (opt.homedir_cache, DBDIR_D, NULL);
238   DIR *dir;
239   struct dirent *de;
240   int problem = 0;
241
242   if (!force)
243     { /* Very minor sanity checks. */
244       if (!strcmp (dname, "~/") || !strcmp (dname, "/" ))
245         {
246           log_error (_("ignoring database dir `%s'\n"), dname);
247           xfree (dname);
248           return -1;
249         }
250     }
251
252   dir = opendir (dname);
253   if (!dir)
254     {
255       log_error (_("error reading directory `%s': %s\n"),
256                  dname, strerror (errno));
257       xfree (dname);
258       return -1;
259     }
260
261   while ((de = readdir (dir)))
262     {
263       if (strcmp (de->d_name, "." ) && strcmp (de->d_name, ".."))
264         {
265           char *cdbname = make_filename (dname, de->d_name, NULL);
266           int okay;
267           struct stat sbuf;
268      
269           if (force)
270             okay = 1;
271           else
272             okay = (!stat (cdbname, &sbuf) && S_ISREG (sbuf.st_mode));
273
274           if (okay)
275             {
276               log_info (_("removing cache file `%s'\n"), cdbname);
277               if (gnupg_remove (cdbname))
278                 {
279                   log_error ("failed to remove `%s': %s\n",
280                              cdbname, strerror (errno));
281                   problem = -1;
282                 }
283             }
284           else
285             log_info (_("not removing file `%s'\n"), cdbname);
286           xfree (cdbname);
287         }
288     }     
289   xfree (dname);
290   closedir (dir);
291   return problem;
292 }
293
294
295 /* Read the next line from the file FP and return the line in an
296    malloced buffer.  Return NULL on error or EOF.  There is no
297    limitation os the line length.  The trailing linefeed has been
298    removed, the function will read the last line of a file, even if
299    that is not terminated by a LF. */
300 static char *
301 next_line_from_file (estream_t fp, gpg_error_t *r_err)
302 {
303   char buf[300];
304   char *largebuf = NULL;
305   size_t buflen;
306   size_t len = 0;
307   unsigned char *p;
308   int c;
309   char *tmpbuf;
310
311   *r_err = 0;
312   p = buf;
313   buflen = sizeof buf - 1;
314   while ((c=es_getc (fp)) != EOF && c != '\n')
315     {
316       if (len >= buflen)
317         {
318           if (!largebuf)
319             {
320               buflen += 1024;
321               largebuf = xtrymalloc ( buflen + 1 );
322               if (!largebuf)
323                 {
324                   *r_err = gpg_error_from_syserror ();
325                   return NULL;
326                 }
327               memcpy (largebuf, buf, len);
328             }
329           else
330             {
331               buflen += 1024;
332               tmpbuf = xtryrealloc (largebuf, buflen + 1);
333               if (!tmpbuf)
334                 {
335                   *r_err = gpg_error_from_syserror ();
336                   xfree (largebuf);
337                   return NULL;
338                 }
339               largebuf = tmpbuf;
340             }
341           p = largebuf;
342         }
343       p[len++] = c;
344     }
345   if (c == EOF && !len)
346     return NULL;
347   p[len] = 0;
348       
349   if (largebuf)
350     tmpbuf = xtryrealloc (largebuf, len+1);
351   else
352     tmpbuf = xtrystrdup (buf);
353   if (!tmpbuf)
354     {
355       *r_err = gpg_error_from_syserror ();
356       xfree (largebuf);
357     }
358   return tmpbuf;
359 }
360
361
362 /* Release one cache entry.  */
363 static void
364 release_one_cache_entry (crl_cache_entry_t entry)
365 {
366   if (entry)
367     {
368       if (entry->cdb)
369         {
370           int fd = cdb_fileno (entry->cdb);
371           cdb_free (entry->cdb);
372           xfree (entry->cdb);
373           if (close (fd))
374             log_error (_("error closing cache file: %s\n"), strerror(errno));
375         }
376       xfree (entry->release_ptr);
377       xfree (entry->check_trust_anchor);
378       xfree (entry);
379     }
380 }
381
382
383 /* Release the CACHE object. */
384 static void
385 release_cache (crl_cache_t cache)
386 {
387   crl_cache_entry_t entry, entry2;
388
389   if (!cache)
390     return;
391
392   for (entry = cache->entries; entry; entry = entry2)
393     {
394       entry2 = entry->next;
395       release_one_cache_entry (entry);
396   }
397   cache->entries = NULL;
398   xfree (cache);
399 }
400
401
402 /* Open the dir file FNAME or create a new one if it does not yet
403    exist. */
404 static estream_t
405 open_dir_file (const char *fname)
406 {
407   estream_t fp;
408
409   fp = es_fopen (fname, "r");
410   if (!fp)
411     {
412       log_error (_("failed to open cache dir file `%s': %s\n"),
413                  fname, strerror (errno));
414
415       /* Make sure that the directory exists, try to create if otherwise. */
416       if (create_directory_if_needed (NULL) 
417           || create_directory_if_needed (DBDIR_D)) 
418         return NULL;
419       fp = es_fopen (fname, "w");
420       if (!fp)
421         {
422           log_error (_("error creating new cache dir file `%s': %s\n"),
423                      fname, strerror (errno));
424           return NULL;
425         }
426       es_fprintf (fp, "v:%d:\n", DBDIRVERSION);
427       if (es_ferror (fp))
428         {
429           log_error (_("error writing new cache dir file `%s': %s\n"),
430                      fname, strerror (errno));
431           es_fclose (fp);
432           return NULL;
433         }
434       if (es_fclose (fp))
435         {
436           log_error (_("error closing new cache dir file `%s': %s\n"),
437                      fname, strerror (errno));
438           return NULL;
439         }
440
441       log_info (_("new cache dir file `%s' created\n"), fname);
442
443       fp = es_fopen (fname, "r");
444       if (!fp)
445         {
446           log_error (_("failed to re-open cache dir file `%s': %s\n"),
447                      fname, strerror (errno));
448           return NULL;
449         }
450     }
451
452   return fp;
453 }
454
455 /* Helper for open_dir. */
456 static gpg_error_t
457 check_dir_version (estream_t *fpadr, const char *fname,
458                          unsigned int *lineno,
459                          int cleanup_on_mismatch)
460 {
461   char *line;
462   gpg_error_t lineerr = 0;
463   estream_t fp = *fpadr;
464   int created = 0;
465
466  retry:
467   while ((line = next_line_from_file (fp, &lineerr)))
468     {
469       ++*lineno;
470       if (*line == 'v' && line[1] == ':')
471         break;
472       else if (*line != '#')
473         {
474           log_error (_("first record of `%s' is not the version\n"), fname);
475           xfree (line);
476           return gpg_error (GPG_ERR_CONFIGURATION);
477         }
478       xfree (line);
479     }
480   if (lineerr)
481     return lineerr;
482
483   if (strtol (line+2, NULL, 10) != DBDIRVERSION)
484     {
485       if (!created && cleanup_on_mismatch)
486         {
487           log_error (_("old version of cache directory - cleaning up\n"));
488           es_fclose (fp);
489           *fpadr = NULL;
490           if (!cleanup_cache_dir (1))
491             {
492               *lineno = 0;
493               fp = *fpadr = open_dir_file (fname);
494               if (!fp)
495                 {
496                   xfree (line);
497                   return gpg_error (GPG_ERR_CONFIGURATION);
498                 }
499               created = 1;
500               goto retry;
501             }
502         }
503       log_error (_("old version of cache directory - giving up\n"));
504       xfree (line);
505       return gpg_error (GPG_ERR_CONFIGURATION);
506     }
507   xfree (line);
508   return 0;
509 }
510
511
512 /* Open the dir file and read in all available information.  Store
513    that in a newly allocated cache object and return that if
514    everything worked out fine.  Create the cache directory and the dir
515    if it does not yet exist.  Remove all files in that directory if
516    the version does not match. */
517 static gpg_error_t
518 open_dir (crl_cache_t *r_cache)
519 {
520   crl_cache_t cache;
521   char *fname; 
522   char *line = NULL;
523   gpg_error_t lineerr = 0;
524   estream_t fp;
525   crl_cache_entry_t entry, *entrytail;
526   unsigned int lineno;
527   gpg_error_t err = 0;
528   int anyerr = 0;
529
530   cache = xtrycalloc (1, sizeof *cache); 
531   if (!cache)
532     return gpg_error_from_syserror ();
533
534   fname = make_filename (opt.homedir_cache, DBDIR_D, DBDIRFILE, NULL);
535
536   lineno = 0;
537   fp = open_dir_file (fname);
538   if (!fp)
539     {
540       err = gpg_error (GPG_ERR_CONFIGURATION);
541       goto leave;
542     }
543
544   err = check_dir_version (&fp, fname, &lineno, 1);
545   if (err)
546     goto leave;
547
548
549   /* Read in all supported entries from the dir file. */
550   cache->entries = NULL;
551   entrytail = &cache->entries;
552   xfree (line);
553   while ((line = next_line_from_file (fp, &lineerr)))
554     {
555       int fieldno;
556       char *p, *endp;
557
558       lineno++;
559       if ( *line == 'c' || *line == 'u' || *line == 'i' )
560         {
561           entry = xtrycalloc (1, sizeof *entry);
562           if (!entry)
563             {
564               err = gpg_error_from_syserror ();
565               goto leave;
566             }
567           entry->lineno = lineno;
568           entry->release_ptr = line;
569           if (*line == 'i')
570             {
571               entry->invalid = atoi (line+1);
572               if (entry->invalid < 1)
573                 entry->invalid = 1;
574             }
575           else if (*line == 'u')
576             entry->user_trust_req = 1;
577
578           for (fieldno=1, p = line; p; p = endp, fieldno++)
579             {
580               endp = strchr (p, ':');
581               if (endp)
582                 *endp++ = '\0';
583
584               switch (fieldno)
585                 {
586                 case 1: /* record type */ break;
587                 case 2: entry->issuer_hash = p; break;
588                 case 3: entry->issuer = unpercent_string (p); break;
589                 case 4: entry->url = unpercent_string (p); break;
590                 case 5: strncpy (entry->this_update, p, 15); break;
591                 case 6: strncpy (entry->next_update, p, 15); break;
592                 case 7: entry->dbfile_hash = p; break;
593                 case 8: if (*p) entry->crl_number = p; break;
594                 case 9: 
595                   if (*p)
596                     entry->authority_issuer = unpercent_string (p);
597                   break;
598                 case 10: 
599                   if (*p)
600                     entry->authority_serialno = unpercent_string (p);
601                   break;
602                 case 11: 
603                   if (*p)
604                     entry->check_trust_anchor = xtrystrdup (p);
605                   break;
606                 default:
607                   if (*p)
608                     log_info (_("extra field detected in crl record of "
609                                 "`%s' line %u\n"), fname, lineno);
610                   break;
611                 }
612             }
613
614           if (!entry->issuer_hash)
615             {
616               log_info (_("invalid line detected in `%s' line %u\n"),
617                         fname, lineno);
618               xfree (entry);
619               entry = NULL;
620             }
621           else if (find_entry (cache->entries, entry->issuer_hash))
622             {
623               /* Fixme: The duplicate checking used is not very
624                  effective for large numbers of issuers. */
625               log_info (_("duplicate entry detected in `%s' line %u\n"),
626                         fname, lineno);
627               xfree (entry);
628               entry = NULL;
629             }
630           else
631             {
632               line = NULL; 
633               *entrytail = entry;
634               entrytail = &entry->next;
635             }
636         }
637       else if (*line == '#')
638         ;
639       else
640         log_info (_("unsupported record type in `%s' line %u skipped\n"),
641                   fname, lineno);
642
643       if (line)
644         xfree (line);
645     }
646   if (lineerr)
647     {
648       err = lineerr;
649       log_error (_("error reading `%s': %s\n"), fname, gpg_strerror (err));
650       goto leave;
651     }
652   if (es_ferror (fp))
653     {
654       log_error (_("error reading `%s': %s\n"), fname, strerror (errno));
655       err = gpg_error (GPG_ERR_CONFIGURATION);
656       goto leave;
657     }
658
659   /* Now do some basic checks on the data. */
660   for (entry = cache->entries; entry; entry = entry->next)
661     {
662       assert (entry->lineno);
663       if (strlen (entry->issuer_hash) != 40)
664         {
665           anyerr++;
666           log_error (_("invalid issuer hash in `%s' line %u\n"),
667                      fname, entry->lineno);
668         }
669       else if ( !*entry->issuer )
670         {
671           anyerr++;
672           log_error (_("no issuer DN in `%s' line %u\n"),
673                      fname, entry->lineno);
674         }
675       else if ( check_isotime (entry->this_update)
676                 || check_isotime (entry->next_update))
677         {
678           anyerr++;
679           log_error (_("invalid timestamp in `%s' line %u\n"),
680                      fname, entry->lineno);
681         }
682
683       /* Checks not leading to an immediate fail. */
684       if (strlen (entry->dbfile_hash) != 32)
685         log_info (_("WARNING: invalid cache file hash in `%s' line %u\n"),
686                   fname, entry->lineno); 
687     }
688      
689   if (anyerr)
690     {
691       log_error (_("detected errors in cache dir file\n"));
692       log_info (_("please check the reason and manually delete that file\n"));
693       err = gpg_error (GPG_ERR_CONFIGURATION);
694     }
695
696
697  leave:
698   es_fclose (fp);
699   xfree (line);
700   xfree (fname);
701   if (err)
702     {
703       release_cache (cache);
704       cache = NULL;
705     }
706   *r_cache = cache;
707   return err;
708 }
709
710 static void
711 write_percented_string (const char *s, estream_t fp)
712 {
713   for (; *s; s++)
714     if (*s == ':')
715       es_fputs ("%3A", fp);
716     else if (*s == '\n')
717       es_fputs ("%0A", fp);
718     else if (*s == '\r')
719       es_fputs ("%0D", fp);
720     else
721       es_putc (*s, fp);
722 }
723
724
725 static void
726 write_dir_line_crl (estream_t fp, crl_cache_entry_t e)
727 {
728   if (e->invalid)
729     es_fprintf (fp, "i%d", e->invalid);
730   else if (e->user_trust_req)
731     es_putc ('u', fp);
732   else
733     es_putc ('c', fp);
734   es_putc (':', fp);
735   es_fputs (e->issuer_hash, fp);
736   es_putc (':', fp);
737   write_percented_string (e->issuer, fp);
738   es_putc (':', fp);
739   write_percented_string (e->url, fp);
740   es_putc (':', fp);
741   es_fwrite (e->this_update, 15, 1, fp); 
742   es_putc (':', fp);
743   es_fwrite (e->next_update, 15, 1, fp); 
744   es_putc (':', fp);
745   es_fputs (e->dbfile_hash, fp);
746   es_putc (':', fp);
747   if (e->crl_number)
748     es_fputs (e->crl_number, fp);
749   es_putc (':', fp);
750   if (e->authority_issuer)
751     write_percented_string (e->authority_issuer, fp);
752   es_putc (':', fp);
753   if (e->authority_serialno)
754     es_fputs (e->authority_serialno, fp);
755   es_putc (':', fp);
756   if (e->check_trust_anchor && e->user_trust_req)
757     es_fputs (e->check_trust_anchor, fp);
758   es_putc ('\n', fp);
759 }
760
761
762 /* Update the current dir file using the cache. */
763 static gpg_error_t
764 update_dir (crl_cache_t cache)
765 {
766   char *fname = NULL;
767   char *tmpfname = NULL;
768   char *line = NULL;
769   gpg_error_t lineerr = 0;
770   estream_t fp;
771   estream_t fpout = NULL;
772   crl_cache_entry_t e;
773   unsigned int lineno;
774   gpg_error_t err = 0;
775
776   fname = make_filename (opt.homedir_cache, DBDIR_D, DBDIRFILE, NULL);
777
778   /* Fixme: Take an update file lock here. */
779
780   for (e= cache->entries; e; e = e->next)
781     e->mark = 1;
782
783   lineno = 0;
784   fp = es_fopen (fname, "r");
785   if (!fp)
786     {
787       err = gpg_error_from_errno (errno);
788       log_error (_("failed to open cache dir file `%s': %s\n"),
789                  fname, strerror (errno));
790       goto leave;
791     }
792   err = check_dir_version (&fp, fname, &lineno, 0);
793   if (err)
794     goto leave;
795   es_rewind (fp);
796   lineno = 0;
797
798   /* Create a temporary DIR file. */
799   {
800     char *tmpbuf, *p;
801     const char *nodename;
802 #ifndef HAVE_W32_SYSTEM
803     struct utsname utsbuf;
804 #endif
805     
806 #ifdef HAVE_W32_SYSTEM
807     nodename = "unknown";
808 #else
809     if (uname (&utsbuf))
810       nodename = "unknown";
811     else
812       nodename = utsbuf.nodename;
813 #endif
814
815     estream_asprintf (&tmpbuf, "DIR-tmp-%s-%u-%p.txt.tmp",
816                       nodename, (unsigned int)getpid (), &tmpbuf);
817     if (!tmpbuf)
818       {
819         err = gpg_error_from_errno (errno);
820         log_error (_("failed to create temporary cache dir file `%s': %s\n"),
821                    tmpfname, strerror (errno));
822         goto leave;
823       }
824     for (p=tmpbuf; *p; p++)
825       if (*p == '/')
826         *p = '.';
827     tmpfname = make_filename (opt.homedir_cache, DBDIR_D, tmpbuf, NULL);
828     xfree (tmpbuf);
829   }
830   fpout = es_fopen (tmpfname, "w");
831   if (!fpout)
832     {
833       err = gpg_error_from_errno (errno);
834       log_error (_("failed to create temporary cache dir file `%s': %s\n"),
835                  tmpfname, strerror (errno));
836       goto leave;
837     }
838
839   while ((line = next_line_from_file (fp, &lineerr)))
840     {
841       lineno++;
842       if (*line == 'c' || *line == 'u' || *line == 'i')
843         {
844           /* Extract the issuer hash field. */
845           char *fieldp, *endp;
846
847           fieldp = strchr (line, ':');
848           endp = fieldp? strchr (++fieldp, ':') : NULL;
849           if (endp)
850             {
851               /* There should be no percent within the issuer hash
852                  field, thus we can compare it pretty easily. */
853               *endp = 0;
854               e = find_entry ( cache->entries, fieldp);
855               *endp = ':'; /* Restore orginal line. */
856               if (e && e->deleted) 
857                 {
858                   /* Marked for deletion, so don't write it. */
859                   e->mark = 0; 
860                 }
861               else if (e)
862                 {
863                   /* Yep, this is valid entry we know about; write it out */
864                   write_dir_line_crl (fpout, e);
865                   e->mark = 0;
866                 }
867               else
868                 { /* We ignore entries we don't have in our cache
869                      because they may have been added in the meantime
870                      by other instances of dirmngr. */
871                   es_fprintf (fpout, "# Next line added by "
872                               "another process; our pid is %lu\n", 
873                               (unsigned long)getpid ());
874                   es_fputs (line, fpout);
875                   es_putc ('\n', fpout);
876                 }
877             }
878           else
879             {
880               es_fputs ("# Invalid line detected: ", fpout);
881               es_fputs (line, fpout);
882               es_putc ('\n', fpout);
883             }
884         }
885       else 
886         {
887           /* Write out all non CRL lines as they are. */
888           es_fputs (line, fpout);
889           es_putc ('\n', fpout);
890         }
891
892       xfree (line);
893     }
894   if (!es_ferror (fp) && !es_ferror (fpout) && !lineerr)
895     {
896       /* Write out the remaining entries. */
897       for (e= cache->entries; e; e = e->next)
898         if (e->mark)
899           {
900             if (!e->deleted)
901               write_dir_line_crl (fpout, e);
902             e->mark = 0;
903           }
904     }
905   if (lineerr)
906     {
907       err = lineerr;
908       log_error (_("error reading `%s': %s\n"), fname, gpg_strerror (err));
909       goto leave;
910     }
911   if (es_ferror (fp))
912     {
913       err = gpg_error_from_errno (errno);
914       log_error (_("error reading `%s': %s\n"), fname, strerror (errno));
915     }
916   if (es_ferror (fpout))
917     {
918       err = gpg_error_from_errno (errno);
919       log_error (_("error writing `%s': %s\n"), tmpfname, strerror (errno));
920     }
921   if (err)
922     goto leave;
923
924   /* Rename the files. */
925   es_fclose (fp);
926   fp = NULL;
927   if (es_fclose (fpout))
928     {
929       err = gpg_error_from_errno (errno);
930       log_error (_("error closing `%s': %s\n"), tmpfname, strerror (errno));
931       goto leave;
932     }
933   fpout = NULL;
934
935 #ifdef HAVE_W32_SYSTEM
936   /* No atomic mv on W32 systems.  */
937   gnupg_remove (fname);
938 #endif
939   if (rename (tmpfname, fname))
940     {
941       err = gpg_error_from_errno (errno);
942       log_error (_("error renaming `%s' to `%s': %s\n"),
943                  tmpfname, fname, strerror (errno));
944       goto leave;
945     }
946
947  leave:
948   /* Fixme: Relinquish update lock. */
949   xfree (line);
950   es_fclose (fp);
951   xfree (fname);
952   if (fpout)
953     {
954       es_fclose (fpout);
955       if (err && tmpfname)
956         gnupg_remove (tmpfname);
957     }
958   xfree (tmpfname);
959   return err;
960 }
961
962
963
964
965 /* Create the filename for the cache file from the 40 byte ISSUER_HASH
966    string. Caller must release the return string. */
967 static char *
968 make_db_file_name (const char *issuer_hash)
969 {
970   char bname[50];
971
972   assert (strlen (issuer_hash) == 40);
973   memcpy (bname, "crl-", 4);
974   memcpy (bname + 4, issuer_hash, 40);
975   strcpy (bname + 44, ".db");
976   return make_filename (opt.homedir_cache, DBDIR_D, bname, NULL);
977 }
978
979
980 /* Hash the file FNAME and return the MD5 digest in MD5BUFFER. The
981    caller must allocate MD%buffer wityh at least 16 bytes. Returns 0
982    on success. */
983 static int
984 hash_dbfile (const char *fname, unsigned char *md5buffer)
985 {
986   estream_t fp;
987   char *buffer;
988   size_t n;
989   gcry_md_hd_t md5;
990   gpg_err_code_t err;
991
992   buffer = xtrymalloc (65536);
993   fp = buffer? es_fopen (fname, "rb") : NULL;
994   if (!fp)
995     {
996       log_error (_("can't hash `%s': %s\n"), fname, strerror (errno));
997       xfree (buffer);
998       return -1;
999     }
1000
1001   err = gcry_md_open (&md5, GCRY_MD_MD5, 0);
1002   if (err)
1003     {
1004       log_error (_("error setting up MD5 hash context: %s\n"),
1005                  gpg_strerror (err));
1006       xfree (buffer);
1007       es_fclose (fp);
1008       return -1;
1009     }
1010
1011   /* We better hash some information about the cache file layout in. */
1012   sprintf (buffer, "%.100s/%.100s:%d", DBDIR_D, DBDIRFILE, DBDIRVERSION);
1013   gcry_md_write (md5, buffer, strlen (buffer));
1014     
1015   for (;;)
1016     {
1017       n = es_fread (buffer, 1, 65536, fp);
1018       if (n < 65536 && es_ferror (fp))
1019         {
1020           log_error (_("error hashing `%s': %s\n"), fname, strerror (errno));
1021           xfree (buffer);
1022           es_fclose (fp);
1023           gcry_md_close (md5);
1024           return -1;
1025         }
1026       if (!n)
1027         break;
1028       gcry_md_write (md5, buffer, n);
1029     }
1030   es_fclose (fp);
1031   xfree (buffer);
1032   gcry_md_final (md5);
1033
1034   memcpy (md5buffer, gcry_md_read (md5, GCRY_MD_MD5), 16);
1035   gcry_md_close (md5);
1036   return 0;
1037 }
1038
1039 /* Compare the file FNAME against the dexified MD5 hash MD5HASH and
1040    return 0 if they match. */
1041 static int
1042 check_dbfile (const char *fname, const char *md5hexvalue)
1043 {
1044   unsigned char buffer1[16], buffer2[16];
1045
1046   if (strlen (md5hexvalue) != 32)
1047     {
1048       log_error (_("invalid formatted checksum for `%s'\n"), fname);
1049       return -1;
1050     }
1051   unhexify (buffer1, md5hexvalue);
1052
1053   if (hash_dbfile (fname, buffer2))
1054     return -1;
1055
1056   return memcmp (buffer1, buffer2, 16);
1057 }
1058
1059
1060 /* Open the cache file for ENTRY.  This function implements a caching
1061    strategy and might close unused cache files. It is required to use
1062    unlock_db_file after using the file. */ 
1063 static struct cdb *
1064 lock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
1065 {
1066   char *fname;
1067   int fd;
1068   int open_count;
1069   crl_cache_entry_t e;
1070
1071   if (entry->cdb)
1072     {
1073       entry->cdb_use_count++;
1074       return entry->cdb;
1075     }
1076
1077   for (open_count = 0, e = cache->entries; e; e = e->next)
1078     {
1079       if (e->cdb)
1080         open_count++;
1081 /*       log_debug ("CACHE: cdb=%p use_count=%u lru_count=%u\n", */
1082 /*                  e->cdb,e->cdb_use_count,e->cdb_lru_count); */
1083     }
1084
1085   /* If there are too many file open, find the least recent used DB
1086      file and close it.  Note that for Pth thread safeness we need to
1087      use a loop here. */
1088   while (open_count >= MAX_OPEN_DB_FILES )
1089     {
1090       crl_cache_entry_t last_e = NULL;
1091       unsigned int last_lru = (unsigned int)(-1);
1092
1093       for (e = cache->entries; e; e = e->next)
1094         if (e->cdb && !e->cdb_use_count && e->cdb_lru_count < last_lru)
1095           {
1096             last_lru = e->cdb_lru_count;
1097             last_e = e;
1098           }
1099       if (!last_e)
1100         {
1101           log_error (_("too many open cache files; can't open anymore\n"));
1102           return NULL;
1103         }
1104
1105 /*       log_debug ("CACHE: closing file at cdb=%p\n", last_e->cdb); */
1106
1107       fd = cdb_fileno (last_e->cdb);
1108       cdb_free (last_e->cdb);
1109       xfree (last_e->cdb);
1110       last_e->cdb = NULL;
1111       if (close (fd))
1112         log_error (_("error closing cache file: %s\n"), strerror(errno));
1113       open_count--;
1114     }
1115
1116
1117   fname = make_db_file_name (entry->issuer_hash);
1118   if (opt.verbose)
1119     log_info (_("opening cache file `%s'\n"), fname );
1120
1121   if (!entry->dbfile_checked)
1122     {
1123       if (!check_dbfile (fname, entry->dbfile_hash))
1124         entry->dbfile_checked = 1;
1125       /* Note, in case of an error we don't print an error here but
1126          let require the caller to do that check. */
1127     }
1128
1129   entry->cdb = xtrycalloc (1, sizeof *entry->cdb);
1130   if (!entry->cdb)
1131     {
1132       xfree (fname);
1133       return NULL;
1134     }
1135   fd = open (fname, O_RDONLY);
1136   if (fd == -1)
1137     {
1138       log_error (_("error opening cache file `%s': %s\n"),
1139                  fname, strerror (errno));
1140       xfree (entry->cdb);
1141       entry->cdb = NULL;
1142       xfree (fname);
1143       return NULL;
1144     }
1145   if (cdb_init (entry->cdb, fd))
1146     {
1147       log_error (_("error initializing cache file `%s' for reading: %s\n"),
1148                  fname, strerror (errno));
1149       xfree (entry->cdb);
1150       entry->cdb = NULL;
1151       close (fd);
1152       xfree (fname);
1153       return NULL;
1154     }
1155   xfree (fname);
1156
1157   entry->cdb_use_count = 1;
1158   entry->cdb_lru_count = 0;
1159
1160   return entry->cdb;
1161 }
1162
1163 /* Unlock a cache file, so that it can be reused. */
1164 static void
1165 unlock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
1166 {
1167   if (!entry->cdb)
1168     log_error (_("calling unlock_db_file on a closed file\n"));
1169   else if (!entry->cdb_use_count)
1170     log_error (_("calling unlock_db_file on an unlocked file\n"));
1171   else 
1172     {
1173       entry->cdb_use_count--;
1174       entry->cdb_lru_count++;
1175     }
1176
1177   /* If the entry was marked for deletion in the meantime do it now.
1178      We do this for the sake of Pth thread safeness. */
1179   if (!entry->cdb_use_count && entry->deleted)
1180     {
1181       crl_cache_entry_t eprev, enext;
1182
1183       enext = entry->next;
1184       for (eprev = cache->entries;
1185            eprev && eprev->next != entry; eprev = eprev->next)
1186         ;
1187       assert (eprev);
1188       if (eprev == cache->entries)
1189         cache->entries = enext;
1190       else
1191         eprev->next = enext;
1192     }
1193 }
1194
1195
1196 /* Find ISSUER_HASH in our cache FIRST. This may be used to enumerate
1197    the linked list we use to keep the CRLs of an issuer. */
1198 static crl_cache_entry_t 
1199 find_entry (crl_cache_entry_t first, const char *issuer_hash)
1200 {
1201   while (first && (first->deleted || strcmp (issuer_hash, first->issuer_hash)))
1202     first = first->next;
1203   return first;    
1204 }
1205
1206
1207
1208 /* Create a new CRL cache. This fucntion is usually called only once.
1209    never fail. */
1210 void
1211 crl_cache_init(void)
1212 {
1213   crl_cache_t cache = NULL;
1214   gpg_error_t err;
1215
1216   if (current_cache)
1217     {
1218       log_error ("crl cache has already been initialized - not doing twice\n");
1219       return;
1220     }
1221
1222   err = open_dir (&cache);
1223   if (err) 
1224     log_fatal (_("failed to create a new cache object: %s\n"),
1225                gpg_strerror (err));
1226   current_cache = cache;
1227 }
1228
1229
1230 /* Remove the cache information and all its resources.  Note that we
1231    still keep the cache on disk. */
1232 void 
1233 crl_cache_deinit (void)
1234 {
1235   if (current_cache)
1236     {
1237       release_cache (current_cache);
1238       current_cache = NULL;
1239     }
1240 }
1241
1242
1243 /* Delete the cache from disk. Return 0 on success.*/
1244 int 
1245 crl_cache_flush (void)
1246 {
1247   int rc;
1248
1249   rc = cleanup_cache_dir (0)? -1 : 0;
1250
1251   return rc;
1252 }
1253
1254
1255 /* Check whether the certificate identified by ISSUER_HASH and
1256    SN/SNLEN is valid; i.e. not listed in our cache.  With
1257    FORCE_REFRESH set to true, a new CRL will be retrieved even if the
1258    cache has not yet expired.  We use a 30 minutes threshold here so
1259    that invoking this function several times won't load the CRL over
1260    and over.  */
1261 static crl_cache_result_t 
1262 cache_isvalid (ctrl_t ctrl, const char *issuer_hash,
1263                const unsigned char *sn, size_t snlen,
1264                int force_refresh)
1265 {
1266   crl_cache_t cache = get_current_cache ();
1267   crl_cache_result_t retval;
1268   struct cdb *cdb;
1269   int rc;
1270   crl_cache_entry_t entry;
1271   gnupg_isotime_t current_time;
1272   size_t n;
1273
1274   (void)ctrl;
1275
1276   entry = find_entry (cache->entries, issuer_hash);
1277   if (!entry)
1278     {
1279       log_info (_("no CRL available for issuer id %s\n"), issuer_hash );
1280       return CRL_CACHE_DONTKNOW;
1281     }
1282
1283   gnupg_get_isotime (current_time);
1284   if (strcmp (entry->next_update, current_time) < 0 )
1285     {
1286       log_info (_("cached CRL for issuer id %s too old; update required\n"),
1287                 issuer_hash);
1288       return CRL_CACHE_DONTKNOW;
1289     }
1290   if (force_refresh)
1291     {
1292       gnupg_isotime_t tmptime;
1293       
1294       if (*entry->last_refresh)
1295         {
1296           gnupg_copy_time (tmptime, entry->last_refresh);
1297           add_seconds_to_isotime (tmptime, 30 * 60);
1298           if (strcmp (tmptime, current_time) < 0 )
1299             {
1300               log_info (_("force-crl-refresh active and %d minutes passed for"
1301                           " issuer id %s; update required\n"), 
1302                         30, issuer_hash);
1303               return CRL_CACHE_DONTKNOW;
1304             }
1305         }
1306       else
1307         {
1308           log_info (_("force-crl-refresh active for"
1309                       " issuer id %s; update required\n"), 
1310                     issuer_hash);
1311           return CRL_CACHE_DONTKNOW;
1312         }
1313     }
1314
1315   if (entry->invalid)
1316     {
1317       log_info (_("available CRL for issuer ID %s can't be used\n"),
1318                 issuer_hash);
1319       return CRL_CACHE_CANTUSE;
1320     }
1321
1322   cdb = lock_db_file (cache, entry);
1323   if (!cdb)
1324     return CRL_CACHE_DONTKNOW; /* Hmmm, not the best error code. */
1325   
1326   if (!entry->dbfile_checked)
1327     {
1328       log_error (_("cached CRL for issuer id %s tampered; we need to update\n")
1329                  , issuer_hash);
1330       unlock_db_file (cache, entry);
1331       return CRL_CACHE_DONTKNOW;
1332     }
1333
1334   rc = cdb_find (cdb, sn, snlen);
1335   if (rc == 1) 
1336     {
1337       n = cdb_datalen (cdb);
1338       if (n != 16)
1339         {
1340           log_error (_("WARNING: invalid cache record length for S/N "));
1341           log_printhex ("", sn, snlen);
1342         }
1343       else if (opt.verbose)
1344         {
1345           unsigned char record[16];
1346           char *tmp = hexify_data (sn, snlen);
1347
1348           if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
1349             log_error (_("problem reading cache record for S/N %s: %s\n"),
1350                        tmp, strerror (errno));
1351           else
1352             log_info (_("S/N %s is not valid; reason=%02X  date=%.15s\n"),
1353                       tmp, *record, record+1);
1354           xfree (tmp);
1355         }
1356       retval = CRL_CACHE_INVALID;
1357     }
1358   else if (!rc)
1359     {
1360       if (opt.verbose)
1361         {
1362           char *serialno = hexify_data (sn, snlen);
1363           log_info (_("S/N %s is valid, it is not listed in the CRL\n"),
1364                     serialno );
1365           xfree (serialno);
1366         }
1367       retval = CRL_CACHE_VALID;
1368     }
1369   else 
1370     {
1371       log_error (_("error getting data from cache file: %s\n"),
1372                  strerror (errno));
1373       retval = CRL_CACHE_DONTKNOW;
1374     }
1375
1376
1377   if (entry->user_trust_req
1378       && (retval == CRL_CACHE_VALID || retval == CRL_CACHE_INVALID))
1379     {
1380       if (!entry->check_trust_anchor)
1381         {
1382           log_error ("inconsistent data on user trust check\n");
1383           retval = CRL_CACHE_CANTUSE;
1384         }
1385       else if (get_istrusted_from_client (ctrl, entry->check_trust_anchor))
1386         {
1387           if (opt.verbose)
1388             log_info ("no system trust and client does not trust either\n");
1389           retval = CRL_CACHE_CANTUSE;
1390         }
1391       else
1392         {
1393           /* Okay, the CRL is considered valid by the client and thus
1394              we can return the result as is.  */
1395         }
1396     }
1397
1398   unlock_db_file (cache, entry);
1399
1400   return retval;
1401 }
1402
1403
1404 /* Check whether the certificate identified by ISSUER_HASH and
1405    SERIALNO is valid; i.e. not listed in our cache.  With
1406    FORCE_REFRESH set to true, a new CRL will be retrieved even if the
1407    cache has not yet expired.  We use a 30 minutes threshold here so
1408    that invoking this function several times won't load the CRL over
1409    and over.  */
1410 crl_cache_result_t 
1411 crl_cache_isvalid (ctrl_t ctrl, const char *issuer_hash, const char *serialno,
1412                    int force_refresh)
1413 {
1414   crl_cache_result_t result;
1415   unsigned char snbuf_buffer[50];
1416   unsigned char *snbuf;
1417   size_t n;
1418
1419   n = strlen (serialno)/2+1;
1420   if (n < sizeof snbuf_buffer - 1)
1421     snbuf = snbuf_buffer;
1422   else
1423     {
1424       snbuf = xtrymalloc (n);
1425       if (!snbuf)
1426         return CRL_CACHE_DONTKNOW;
1427     }
1428
1429   n = unhexify (snbuf, serialno);
1430
1431   result = cache_isvalid (ctrl, issuer_hash, snbuf, n, force_refresh);
1432
1433   if (snbuf != snbuf_buffer)
1434     xfree (snbuf);
1435
1436   return result;
1437 }  
1438
1439
1440 /* Check whether the certificate CERT is valid; i.e. not listed in our
1441    cache.  With FORCE_REFRESH set to true, a new CRL will be retrieved
1442    even if the cache has not yet expired.  We use a 30 minutes
1443    threshold here so that invoking this function several times won't
1444    load the CRL over and over.  */
1445 gpg_error_t
1446 crl_cache_cert_isvalid (ctrl_t ctrl, ksba_cert_t cert,
1447                         int force_refresh)
1448 {
1449   gpg_error_t err;
1450   crl_cache_result_t result;
1451   unsigned char issuerhash[20];
1452   char issuerhash_hex[41];
1453   ksba_sexp_t serial;
1454   unsigned char *sn;
1455   size_t snlen;
1456   char *endp, *tmp;
1457   int i;
1458
1459   /* Compute the hash value of the issuer name.  */
1460   tmp = ksba_cert_get_issuer (cert, 0);
1461   if (!tmp)
1462     {
1463       log_error ("oops: issuer missing in certificate\n");
1464       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1465     }
1466   gcry_md_hash_buffer (GCRY_MD_SHA1, issuerhash, tmp, strlen (tmp));
1467   xfree (tmp);
1468   for (i=0,tmp=issuerhash_hex; i < 20; i++, tmp += 2)
1469     sprintf (tmp, "%02X", issuerhash[i]);
1470   
1471   /* Get the serial number.  */
1472   serial = ksba_cert_get_serial (cert);
1473   if (!serial)
1474     {
1475       log_error ("oops: S/N missing in certificate\n");
1476       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1477     }
1478   sn = serial;
1479   if (*sn != '(')
1480     {
1481       log_error ("oops: invalid S/N\n");
1482       xfree (serial);
1483       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1484     }
1485   sn++;
1486   snlen = strtoul (sn, &endp, 10);
1487   sn = endp;
1488   if (*sn != ':')
1489     {
1490       log_error ("oops: invalid S/N\n");
1491       xfree (serial);
1492       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1493     }
1494   sn++;
1495
1496   /* Check the cache.  */
1497   result = cache_isvalid (ctrl, issuerhash_hex, sn, snlen, force_refresh);
1498   switch (result)
1499     {
1500     case CRL_CACHE_VALID:
1501       err = 0;
1502       break;
1503     case CRL_CACHE_INVALID:
1504       err = gpg_error (GPG_ERR_CERT_REVOKED);
1505       break;
1506     case CRL_CACHE_DONTKNOW: 
1507       err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1508     case CRL_CACHE_CANTUSE: 
1509       err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1510       break;
1511     default:
1512       log_fatal ("cache_isvalid returned invalid status code %d\n", result);
1513     }
1514
1515   xfree (serial);
1516   return err;
1517 }  
1518
1519
1520 /* Prepare a hash context for the signature verification.  Input is
1521    the CRL and the output is the hash context MD as well as the uses
1522    algorithm identifier ALGO. */
1523 static gpg_error_t
1524 start_sig_check (ksba_crl_t crl, gcry_md_hd_t *md, int *algo) 
1525 {
1526   gpg_error_t err;
1527   const char *algoid;
1528
1529   algoid = ksba_crl_get_digest_algo (crl);
1530   *algo = gcry_md_map_name (algoid);
1531   if (!*algo) 
1532     {
1533       log_error (_("unknown hash algorithm `%s'\n"), algoid? algoid:"?");
1534       return gpg_error (GPG_ERR_DIGEST_ALGO);
1535     }
1536
1537   err = gcry_md_open (md, *algo, 0);
1538   if (err)
1539     {
1540       log_error (_("gcry_md_open for algorithm %d failed: %s\n"),
1541                  *algo, gcry_strerror (err));
1542       return err;
1543     }
1544   if (DBG_HASHING)
1545     gcry_md_debug (*md, "hash.cert");
1546
1547   ksba_crl_set_hash_function (crl, HASH_FNC, *md);  
1548   return 0;
1549 }
1550
1551
1552 /* Finish a hash context and verify the signature.  This function
1553    should return 0 on a good signature, GPG_ERR_BAD_SIGNATURE if the
1554    signature does not verify or any other error code. CRL is the CRL
1555    object we are working on, MD the hash context and ISSUER_CERT the
1556    certificate of the CRL issuer.  This function closes MD.  */
1557 static gpg_error_t
1558 finish_sig_check (ksba_crl_t crl, gcry_md_hd_t md, int algo,
1559                   ksba_cert_t issuer_cert)
1560 {
1561   gpg_error_t err;
1562   ksba_sexp_t sigval = NULL, pubkey = NULL;
1563   const char *s;
1564   char algoname[50];
1565   size_t n;
1566   gcry_sexp_t s_sig = NULL, s_hash = NULL, s_pkey = NULL;
1567   unsigned int i;
1568
1569   /* This also stops debugging on the MD.  */
1570   gcry_md_final (md);
1571
1572   /* Get and convert the signature value. */
1573   sigval = ksba_crl_get_sig_val (crl);
1574   n = gcry_sexp_canon_len (sigval, 0, NULL, NULL);
1575   if (!n) 
1576     {
1577       log_error (_("got an invalid S-expression from libksba\n"));
1578       err = gpg_error (GPG_ERR_INV_SEXP);
1579       goto leave;
1580     }
1581   err = gcry_sexp_sscan (&s_sig, NULL, sigval, n);
1582   if (err) 
1583     {
1584       log_error (_("converting S-expression failed: %s\n"),
1585                  gcry_strerror (err));
1586       goto leave;
1587     }
1588         
1589   /* Get and convert the public key for the issuer certificate. */
1590   if (DBG_X509)
1591     dump_cert ("crl_issuer_cert", issuer_cert);
1592   pubkey = ksba_cert_get_public_key (issuer_cert);
1593   n = gcry_sexp_canon_len (pubkey, 0, NULL, NULL);
1594   if (!n) 
1595     {
1596       log_error (_("got an invalid S-expression from libksba\n"));
1597       err = gpg_error (GPG_ERR_INV_SEXP);
1598       goto leave;
1599     }
1600   err = gcry_sexp_sscan (&s_pkey, NULL, pubkey, n);
1601   if (err) 
1602     {
1603       log_error (_("converting S-expression failed: %s\n"),
1604                  gcry_strerror (err));
1605       goto leave;
1606     }
1607
1608   /* Create an S-expression with the actual hash value. */
1609   s = gcry_md_algo_name (algo);
1610   for (i = 0; *s && i < sizeof(algoname) - 1; s++, i++)
1611     algoname[i] = ascii_tolower (*s);
1612   algoname[i] = 0;
1613   err = gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))", 
1614                          algoname,
1615                          gcry_md_get_algo_dlen (algo), gcry_md_read (md, algo));
1616   if (err) 
1617     {
1618       log_error (_("creating S-expression failed: %s\n"), gcry_strerror (err));
1619       goto leave;
1620     }
1621
1622   /* Pass this on to the signature verification. */
1623   err = gcry_pk_verify (s_sig, s_hash, s_pkey);
1624   if (DBG_X509)
1625     log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
1626
1627  leave:
1628   xfree (sigval);
1629   xfree (pubkey);
1630   gcry_sexp_release (s_sig);
1631   gcry_sexp_release (s_hash);
1632   gcry_sexp_release (s_pkey);
1633   gcry_md_close (md);
1634
1635   return err;
1636 }
1637
1638
1639 /* Call this to match a start_sig_check that can not be completed
1640    normally.  */
1641 static void
1642 abort_sig_check (ksba_crl_t crl, gcry_md_hd_t md)
1643 {
1644   (void)crl;
1645   gcry_md_close (md);
1646 }
1647
1648
1649 /* Workhorse of the CRL loading machinery.  The CRL is read using the
1650    CRL object and stored in the data base file DB with the name FNAME
1651    (only used for printing error messages).  That DB should be a
1652    temporary one and not the actual one.  If the function fails the
1653    caller should delete this temporary database file.  CTRL is
1654    required to retrieve certificates using the general dirmngr
1655    callback service.  R_CRLISSUER returns an allocated string with the
1656    crl-issuer DN, THIS_UPDATE and NEXT_UPDATE are filled with the
1657    corresponding data from the CRL.  Note that these values might get
1658    set even if the CRL processing fails at a later step; thus the
1659    caller should free *R_ISSUER even if the function returns with an
1660    error.  R_TRUST_ANCHOR is set on exit to NULL or a string with the
1661    hexified fingerprint of the root certificate, if checking this
1662    certificate for trustiness is required.
1663 */ 
1664 static int 
1665 crl_parse_insert (ctrl_t ctrl, ksba_crl_t crl,
1666                   struct cdb_make *cdb, const char *fname,
1667                   char **r_crlissuer,
1668                   ksba_isotime_t thisupdate, ksba_isotime_t nextupdate,
1669                   char **r_trust_anchor)
1670 {  
1671   gpg_error_t err;
1672   ksba_stop_reason_t stopreason;
1673   ksba_cert_t crlissuer_cert = NULL;
1674   gcry_md_hd_t md = NULL;
1675   int algo = 0;
1676   size_t n;
1677   
1678   (void)fname;
1679
1680   *r_crlissuer = NULL;
1681   *thisupdate = *nextupdate = 0;
1682   *r_trust_anchor = NULL;
1683
1684   /* Start of the KSBA parser loop. */
1685   do
1686     {
1687       err = ksba_crl_parse (crl, &stopreason);
1688       if (err)
1689         {
1690           log_error (_("ksba_crl_parse failed: %s\n"), gpg_strerror (err) );
1691           goto failure;
1692         }
1693
1694       switch (stopreason)
1695         {
1696         case KSBA_SR_BEGIN_ITEMS:
1697           {
1698             if (start_sig_check (crl, &md, &algo ))
1699               goto failure;
1700           
1701             err = ksba_crl_get_update_times (crl, thisupdate, nextupdate);
1702             if (err)
1703               {
1704                 log_error (_("error getting update times of CRL: %s\n"),
1705                            gpg_strerror (err));   
1706                 err = gpg_error (GPG_ERR_INV_CRL);
1707                 goto failure;
1708               }
1709
1710             if (opt.verbose || !*nextupdate)
1711               log_info (_("update times of this CRL: this=%s next=%s\n"), 
1712                         thisupdate, nextupdate);   
1713             if (!*nextupdate)
1714               {
1715                 log_info (_("nextUpdate not given; "
1716                             "assuming a validity period of one day\n"));
1717                 gnupg_copy_time (nextupdate, thisupdate);
1718                 add_seconds_to_isotime (nextupdate, 86400);
1719               }
1720           }
1721           break;
1722       
1723         case KSBA_SR_GOT_ITEM:
1724           {
1725             ksba_sexp_t serial;
1726             const unsigned char *p;
1727             ksba_isotime_t rdate;
1728             ksba_crl_reason_t reason;
1729             int rc;
1730             unsigned char record[1+15];
1731
1732             err = ksba_crl_get_item (crl, &serial, rdate, &reason);
1733             if (err)
1734               {
1735                 log_error (_("error getting CRL item: %s\n"),
1736                            gpg_strerror (err));
1737                 err = gpg_error (GPG_ERR_INV_CRL);
1738                 ksba_free (serial);
1739                 goto failure;
1740               }
1741             p = serial_to_buffer (serial, &n);
1742             if (!p)
1743               BUG ();
1744             record[0] = (reason & 0xff);
1745             memcpy (record+1, rdate, 15); 
1746             rc = cdb_make_add (cdb, p, n, record, 1+15);
1747             if (rc)
1748               {
1749                 err = gpg_error_from_errno (errno);
1750                 log_error (_("error inserting item into "
1751                              "temporary cache file: %s\n"),
1752                            strerror (errno));
1753                 goto failure;
1754               }
1755
1756             ksba_free (serial);
1757           }
1758           break;
1759       
1760         case KSBA_SR_END_ITEMS:
1761           break;
1762       
1763         case KSBA_SR_READY:
1764           {
1765             char *crlissuer;
1766             ksba_name_t authid;
1767             ksba_sexp_t authidsn;
1768             ksba_sexp_t keyid;
1769
1770             /* We need to look for the issuer only after having read
1771                all items.  The issuer itselfs comes before the items
1772                but the optional authorityKeyIdentifier comes after the
1773                items. */
1774             err = ksba_crl_get_issuer (crl, &crlissuer);
1775             if( err )
1776               {
1777                 log_error (_("no CRL issuer found in CRL: %s\n"),
1778                            gpg_strerror (err) );
1779                 err = gpg_error (GPG_ERR_INV_CRL);
1780                 goto failure;
1781               }
1782             /* Note: This should be released by ksba_free, not xfree.
1783                May need a memory reallocation dance.  */
1784             *r_crlissuer = crlissuer; /* (Do it here so we don't need
1785                                          to free it later) */
1786
1787             if (!ksba_crl_get_auth_key_id (crl, &keyid, &authid, &authidsn))
1788               {
1789                 const char *s;
1790
1791                 if (opt.verbose)
1792                   log_info (_("locating CRL issuer certificate by "
1793                               "authorityKeyIdentifier\n"));
1794                 
1795                 s = ksba_name_enum (authid, 0);
1796                 if (s && *authidsn)
1797                   crlissuer_cert = find_cert_bysn (ctrl, s, authidsn);
1798                 if (!crlissuer_cert && keyid)
1799                   crlissuer_cert = find_cert_bysubject (ctrl,
1800                                                         crlissuer, keyid);
1801
1802                 if (!crlissuer_cert)
1803                   {
1804                     log_info ("CRL issuer certificate ");
1805                     if (keyid)
1806                       {
1807                         log_printf ("{");
1808                         dump_serial (keyid);
1809                         log_printf ("} ");
1810                       }
1811                     if (authidsn)
1812                       {
1813                         log_printf ("(#");
1814                         dump_serial (authidsn);
1815                         log_printf ("/");
1816                         dump_string (s);
1817                         log_printf (") ");
1818                       }
1819                     log_printf ("not found\n");
1820                   }
1821                 ksba_name_release (authid);
1822                 xfree (authidsn);
1823                 xfree (keyid);
1824               }
1825             else
1826               crlissuer_cert = find_cert_bysubject (ctrl, crlissuer, NULL);
1827             err = 0;
1828             if (!crlissuer_cert)
1829               {
1830                 err = gpg_error (GPG_ERR_MISSING_CERT);
1831                 goto failure;
1832               }
1833         
1834             err = finish_sig_check (crl, md, algo, crlissuer_cert);
1835             if (err)
1836               {
1837                 log_error (_("CRL signature verification failed: %s\n"), 
1838                            gpg_strerror (err));
1839                 goto failure;
1840               }
1841             md = NULL;
1842
1843             err = validate_cert_chain (ctrl, crlissuer_cert, NULL,
1844                                        VALIDATE_MODE_CRL_RECURSIVE,
1845                                        r_trust_anchor);
1846             if (err)
1847               {
1848                 log_error (_("error checking validity of CRL "
1849                              "issuer certificate: %s\n"), 
1850                            gpg_strerror (err));
1851                 goto failure;
1852               }
1853
1854           }
1855           break;
1856       
1857         default:
1858           log_debug ("crl_parse_insert: unknown stop reason\n");
1859           err = gpg_error (GPG_ERR_BUG);
1860           goto failure;
1861         }
1862     } 
1863   while (stopreason != KSBA_SR_READY);
1864   assert (!err);
1865
1866
1867  failure:
1868   if (md)
1869     abort_sig_check (crl, md);
1870   ksba_cert_release (crlissuer_cert);
1871   return err;
1872 }
1873
1874
1875
1876 /* Return the crlNumber extension as an allocated hex string or NULL
1877    if there is none. */
1878 static char *
1879 get_crl_number (ksba_crl_t crl)
1880 {
1881   gpg_error_t err;
1882   ksba_sexp_t number;
1883   char *string;
1884
1885   err = ksba_crl_get_crl_number (crl, &number);
1886   if (err)
1887     return NULL;
1888   string = serial_hex (number);
1889   ksba_free (number);
1890   return string;
1891 }
1892
1893
1894 /* Return the authorityKeyIdentifier or NULL if it is not available.
1895    The issuer name may consists of several parts - they are delimted by
1896    0x01. */
1897 static char *
1898 get_auth_key_id (ksba_crl_t crl, char **serialno)
1899 {
1900   gpg_error_t err;
1901   ksba_name_t name;
1902   ksba_sexp_t sn;
1903   int idx;
1904   const char *s;
1905   char *string;
1906   size_t length;
1907
1908   *serialno = NULL;
1909   err = ksba_crl_get_auth_key_id (crl, NULL, &name, &sn);
1910   if (err)
1911     return NULL;
1912   *serialno = serial_hex (sn);
1913   ksba_free (sn);
1914
1915   if (!name)
1916     return xstrdup ("");
1917   
1918   length = 0;
1919   for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
1920     {
1921       char *p = ksba_name_get_uri (name, idx);
1922       length += strlen (p?p:s) + 1;
1923       xfree (p);
1924     }
1925   string = xtrymalloc (length+1);
1926   if (string)
1927     {
1928       *string = 0;
1929       for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
1930         {
1931           char *p = ksba_name_get_uri (name, idx);
1932           if (*string)
1933             strcat (string, "\x01");
1934           strcat (string, p?p:s);
1935           xfree (p);
1936         }
1937     }
1938   ksba_name_release (name);
1939   return string;
1940 }
1941
1942
1943
1944 /* Insert the CRL retrieved using URL into the cache specified by
1945    CACHE.  The CRL itself will be read from the stream FP and is
1946    expected in binary format. */
1947 gpg_error_t
1948 crl_cache_insert (ctrl_t ctrl, const char *url, ksba_reader_t reader)
1949 {
1950   crl_cache_t cache = get_current_cache ();
1951   gpg_error_t err, err2;
1952   ksba_crl_t crl;
1953   char *fname = NULL;
1954   char *newfname = NULL;
1955   struct cdb_make cdb;
1956   int fd_cdb = -1;
1957   char *issuer = NULL;
1958   char *issuer_hash = NULL;
1959   ksba_isotime_t thisupdate, nextupdate;
1960   crl_cache_entry_t entry = NULL;
1961   crl_cache_entry_t e;
1962   gnupg_isotime_t current_time;
1963   char *checksum = NULL;
1964   int invalidate_crl = 0;
1965   int idx;
1966   const char *oid;
1967   int critical;
1968   char *trust_anchor = NULL;
1969
1970   /* FIXME: We should acquire a mutex for the URL, so that we don't
1971      simultaneously enter the same CRL twice.  However this needs to be
1972      interweaved with the checking function.*/
1973  
1974   err2 = 0;
1975
1976   err = ksba_crl_new (&crl);
1977   if (err)
1978     {
1979       log_error (_("ksba_crl_new failed: %s\n"), gpg_strerror (err));
1980       goto leave;
1981     }
1982   
1983   err = ksba_crl_set_reader (crl, reader);
1984   if ( err )
1985     {
1986       log_error (_("ksba_crl_set_reader failed: %s\n"), gpg_strerror (err));
1987       goto leave;
1988     }
1989
1990   /* Create a temporary cache file to load the CRL into. */
1991   {
1992     char *tmpfname, *p;
1993     const char *nodename;
1994 #ifndef HAVE_W32_SYSTEM
1995     struct utsname utsbuf;
1996 #endif
1997
1998 #ifdef HAVE_W32_SYSTEM
1999     nodename = "unknown";
2000 #else
2001     if (uname (&utsbuf))
2002       nodename = "unknown";
2003     else
2004       nodename = utsbuf.nodename;
2005 #endif
2006
2007     estream_asprintf (&tmpfname, "crl-tmp-%s-%u-%p.db.tmp",
2008                       nodename, (unsigned int)getpid (), &tmpfname);
2009     if (!tmpfname)
2010       {
2011         err = gpg_error_from_syserror ();
2012         goto leave;
2013       }
2014     for (p=tmpfname; *p; p++)
2015       if (*p == '/')
2016         *p = '.';
2017     fname = make_filename (opt.homedir_cache, DBDIR_D, tmpfname, NULL);
2018     xfree (tmpfname);
2019     if (!gnupg_remove (fname))
2020       log_info (_("removed stale temporary cache file `%s'\n"), fname);
2021     else if (errno != ENOENT) 
2022       {
2023         err = gpg_error_from_syserror ();
2024         log_error (_("problem removing stale temporary cache file `%s': %s\n"),
2025                    fname, gpg_strerror (err));
2026         goto leave;
2027       }
2028   }
2029
2030   fd_cdb = open (fname, O_WRONLY | O_CREAT | O_TRUNC, 0644);
2031   if (fd_cdb == -1)
2032     {
2033       err = gpg_error_from_errno (errno);
2034       log_error (_("error creating temporary cache file `%s': %s\n"),
2035                  fname, strerror (errno));
2036       goto leave;
2037     }
2038   cdb_make_start(&cdb, fd_cdb);
2039
2040   err = crl_parse_insert (ctrl, crl, &cdb, fname,
2041                           &issuer, thisupdate, nextupdate, &trust_anchor);
2042   if (err)
2043     {
2044       log_error (_("crl_parse_insert failed: %s\n"), gpg_strerror (err));
2045       /* Error in cleanup ignored.  */
2046       cdb_make_finish (&cdb);
2047       goto leave;
2048     }
2049
2050   /* Finish the database. */
2051   if (cdb_make_finish (&cdb))
2052     {
2053       err = gpg_error_from_errno (errno);
2054       log_error (_("error finishing temporary cache file `%s': %s\n"),
2055                  fname, strerror (errno));
2056       goto leave;
2057     }
2058   if (close (fd_cdb))
2059     {
2060       err = gpg_error_from_errno (errno);
2061       log_error (_("error closing temporary cache file `%s': %s\n"),
2062                  fname, strerror (errno));
2063       goto leave;
2064     }
2065   fd_cdb = -1;
2066
2067
2068   /* Create a checksum. */
2069   {
2070     unsigned char md5buf[16];
2071
2072     if (hash_dbfile (fname, md5buf))
2073       {
2074         err = gpg_error (GPG_ERR_CHECKSUM);
2075         goto leave;
2076       }
2077     checksum = hexify_data (md5buf, 16);
2078   }
2079
2080
2081   /* Check whether that new CRL is still not expired. */
2082   gnupg_get_isotime (current_time);
2083   if (strcmp (nextupdate, current_time) < 0 )
2084     {
2085       if (opt.force)
2086         log_info (_("WARNING: new CRL still too old; it expired on %s "
2087                     "- loading anyway\n"),  nextupdate);
2088       else
2089         {
2090           log_error (_("new CRL still too old; it expired on %s\n"),
2091                      nextupdate);
2092           if (!err2)
2093             err2 = gpg_error (GPG_ERR_CRL_TOO_OLD);
2094           invalidate_crl |= 1;
2095         }
2096     }
2097
2098   /* Check for unknown critical extensions. */
2099   for (idx=0; !(err=ksba_crl_get_extension (crl, idx, &oid, &critical,
2100                                               NULL, NULL)); idx++)
2101     {
2102       if (!critical
2103           || !strcmp (oid, oidstr_authorityKeyIdentifier)
2104           || !strcmp (oid, oidstr_crlNumber) )
2105         continue;
2106       log_error (_("unknown critical CRL extension %s\n"), oid);
2107       if (!err2)
2108         err2 = gpg_error (GPG_ERR_INV_CRL);
2109       invalidate_crl |= 2;
2110     }
2111   if (gpg_err_code (err) == GPG_ERR_EOF 
2112       || gpg_err_code (err) == GPG_ERR_NO_DATA )
2113     err = 0;
2114   if (err)
2115     {
2116       log_error (_("error reading CRL extensions: %s\n"), gpg_strerror (err));
2117       err = gpg_error (GPG_ERR_INV_CRL);
2118     }
2119
2120
2121   /* Create an hex encoded SHA-1 hash of the issuer DN to be
2122      used as the key for the cache. */
2123   issuer_hash = hashify_data (issuer, strlen (issuer));
2124
2125   /* Create an ENTRY. */
2126   entry = xtrycalloc (1, sizeof *entry);
2127   if (!entry)
2128     {
2129       err = gpg_error_from_syserror ();
2130       goto leave;
2131     }
2132   entry->release_ptr = xtrymalloc (strlen (issuer_hash) + 1 
2133                                    + strlen (issuer) + 1
2134                                    + strlen (url) + 1 
2135                                    + strlen (checksum) + 1);
2136   if (!entry->release_ptr)
2137     {
2138       err = gpg_error_from_syserror ();
2139       xfree (entry);
2140       entry = NULL;
2141       goto leave;
2142     }
2143   entry->issuer_hash = entry->release_ptr;
2144   entry->issuer = stpcpy (entry->issuer_hash, issuer_hash) + 1;
2145   entry->url = stpcpy (entry->issuer, issuer) + 1;
2146   entry->dbfile_hash = stpcpy (entry->url, url) + 1;
2147   strcpy (entry->dbfile_hash, checksum);
2148   gnupg_copy_time (entry->this_update, thisupdate); 
2149   gnupg_copy_time (entry->next_update, nextupdate); 
2150   gnupg_copy_time (entry->last_refresh, current_time);
2151   entry->crl_number = get_crl_number (crl);
2152   entry->authority_issuer = get_auth_key_id (crl, &entry->authority_serialno);
2153   entry->invalid = invalidate_crl;
2154   entry->user_trust_req = !!trust_anchor;
2155   entry->check_trust_anchor = trust_anchor;
2156   trust_anchor = NULL;
2157
2158   /* Check whether we already have an entry for this issuer and mark
2159      it as deleted. We better use a loop, just in case duplicates got
2160      somehow into the list. */
2161   for (e = cache->entries; (e=find_entry (e, entry->issuer_hash)); e = e->next)
2162     e->deleted = 1;
2163   
2164   /* Rename the temporary DB to the real name. */
2165   newfname = make_db_file_name (entry->issuer_hash);
2166   if (opt.verbose)
2167     log_info (_("creating cache file `%s'\n"), newfname);
2168 #ifdef HAVE_W32_SYSTEM
2169   gnupg_remove (newfname);
2170 #endif
2171   if (rename (fname, newfname))
2172     {
2173       err = gpg_error_from_syserror ();
2174       log_error (_("problem renaming `%s' to `%s': %s\n"),
2175                  fname, newfname, gpg_strerror (err));
2176       goto leave;
2177     }
2178   xfree (fname); fname = NULL; /*(let the cleanup code not try to remove it)*/
2179
2180   /* Link the new entry in. */
2181   entry->next = cache->entries;
2182   cache->entries = entry;
2183   entry = NULL;
2184
2185   err = update_dir (cache);
2186   if (err)
2187     {
2188       log_error (_("updating the DIR file failed - "
2189                    "cache entry will get lost with the next program start\n"));
2190       err = 0; /* Keep on running. */
2191     }
2192
2193
2194  leave:
2195   release_one_cache_entry (entry);
2196   if (fd_cdb != -1)
2197     close (fd_cdb);
2198   if (fname)
2199     {
2200       gnupg_remove (fname);
2201       xfree (fname);
2202     }
2203   xfree (newfname);
2204   ksba_crl_release (crl);
2205   xfree (issuer);
2206   xfree (issuer_hash);
2207   xfree (checksum);
2208   xfree (trust_anchor);
2209   return err ? err : err2;
2210 }
2211
2212
2213 /* Print one cached entry E in a human readable format to stream
2214    FP. Return 0 on success. */
2215 static gpg_error_t
2216 list_one_crl_entry (crl_cache_t cache, crl_cache_entry_t e, estream_t fp)
2217 {
2218   struct cdb_find cdbfp;
2219   struct cdb *cdb;
2220   int rc;
2221   int warn = 0;
2222   const unsigned char *s;
2223
2224   es_fputs ("--------------------------------------------------------\n", fp );
2225   es_fprintf (fp, _("Begin CRL dump (retrieved via %s)\n"), e->url );
2226   es_fprintf (fp, " Issuer:\t%s\n", e->issuer );
2227   es_fprintf (fp, " Issuer Hash:\t%s\n", e->issuer_hash );
2228   es_fprintf (fp, " This Update:\t%s\n", e->this_update ); 
2229   es_fprintf (fp, " Next Update:\t%s\n", e->next_update ); 
2230   es_fprintf (fp, " CRL Number :\t%s\n", e->crl_number? e->crl_number: "none");
2231   es_fprintf (fp, " AuthKeyId  :\t%s\n",
2232               e->authority_serialno? e->authority_serialno:"none");
2233   if (e->authority_serialno && e->authority_issuer)
2234     {
2235       es_fputs ("             \t", fp);
2236       for (s=e->authority_issuer; *s; s++)
2237         if (*s == '\x01')
2238           es_fputs ("\n             \t", fp);
2239         else
2240           es_putc (*s, fp);
2241       es_putc ('\n', fp);
2242     }
2243   es_fprintf (fp, " Trust Check:\t%s\n", 
2244               !e->user_trust_req? "[system]" :
2245               e->check_trust_anchor? e->check_trust_anchor:"[missing]");
2246
2247   if ((e->invalid & 1))
2248     es_fprintf (fp, _(" ERROR: The CRL will not be used "
2249                       "because it was still too old after an update!\n"));
2250   if ((e->invalid & 2))
2251     es_fprintf (fp, _(" ERROR: The CRL will not be used "
2252                       "due to an unknown critical extension!\n"));
2253   if ((e->invalid & ~3))
2254     es_fprintf (fp, _(" ERROR: The CRL will not be used\n"));
2255
2256   cdb = lock_db_file (cache, e);
2257   if (!cdb)
2258     return gpg_error (GPG_ERR_GENERAL);
2259
2260   if (!e->dbfile_checked)
2261     es_fprintf (fp, _(" ERROR: This cached CRL may has been tampered with!\n"));
2262
2263   es_putc ('\n', fp);
2264
2265   rc = cdb_findinit (&cdbfp, cdb, NULL, 0);
2266   while (!rc && (rc=cdb_findnext (&cdbfp)) > 0 )
2267     {
2268       unsigned char keyrecord[256];
2269       unsigned char record[16];
2270       int reason;
2271       int any = 0;
2272       cdbi_t n;
2273       cdbi_t i;
2274
2275       rc = 0;
2276       n = cdb_datalen (cdb);
2277       if (n != 16)
2278         {
2279           log_error (_(" WARNING: invalid cache record length\n"));
2280           warn = 1;
2281           continue;
2282         }
2283
2284       if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
2285         {
2286           log_error (_("problem reading cache record: %s\n"),
2287                      strerror (errno));
2288           warn = 1;
2289           continue;
2290         }
2291     
2292       n = cdb_keylen (cdb);
2293       if (n > sizeof keyrecord)
2294         n = sizeof keyrecord;
2295       if (cdb_read (cdb, keyrecord, n, cdb_keypos (cdb)))
2296         {
2297           log_error (_("problem reading cache key: %s\n"), strerror (errno));
2298           warn = 1;
2299           continue;
2300         }
2301
2302       reason = *record;
2303       es_fputs ("  ", fp);
2304       for (i = 0; i < n; i++)
2305         es_fprintf (fp, "%02X", keyrecord[i]);
2306       es_fputs (":\t reasons( ", fp);
2307     
2308       if (reason & KSBA_CRLREASON_UNSPECIFIED)
2309         es_fputs( "unspecified ", fp ), any = 1;
2310       if (reason & KSBA_CRLREASON_KEY_COMPROMISE )
2311         es_fputs( "key_compromise ", fp ), any = 1; 
2312       if (reason & KSBA_CRLREASON_CA_COMPROMISE )
2313         es_fputs( "ca_compromise ", fp ), any = 1; 
2314       if (reason & KSBA_CRLREASON_AFFILIATION_CHANGED )
2315         es_fputs( "affiliation_changed ", fp ), any = 1; 
2316       if (reason & KSBA_CRLREASON_SUPERSEDED )
2317         es_fputs( "superseeded", fp ), any = 1; 
2318       if (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION )
2319         es_fputs( "cessation_of_operation", fp ), any = 1; 
2320       if (reason & KSBA_CRLREASON_CERTIFICATE_HOLD )
2321         es_fputs( "certificate_hold", fp ), any = 1; 
2322       if (reason && !any)
2323         es_fputs( "other", fp ); 
2324       
2325       es_fprintf (fp, ") rdate: %.15s\n", record+1);
2326     } 
2327   if (rc)
2328     log_error (_("error reading cache entry from db: %s\n"), strerror (rc));
2329
2330   unlock_db_file (cache, e);
2331   es_fprintf (fp, _("End CRL dump\n") );
2332   es_putc ('\n', fp);
2333
2334   return (rc||warn)? gpg_error (GPG_ERR_GENERAL) : 0;
2335 }
2336
2337
2338 /* Print the contents of the CRL CACHE in a human readable format to
2339    stream FP. */
2340 gpg_error_t 
2341 crl_cache_list (estream_t fp) 
2342 {
2343   crl_cache_t cache = get_current_cache ();
2344   crl_cache_entry_t entry;
2345   gpg_error_t err = 0;
2346
2347   for (entry = cache->entries;
2348        entry && !entry->deleted && !err;
2349        entry = entry->next ) 
2350     err = list_one_crl_entry (cache, entry, fp);
2351
2352   return err;
2353 }
2354
2355
2356 /* Load the CRL containing the file named FILENAME into our CRL cache. */
2357 gpg_error_t
2358 crl_cache_load (ctrl_t ctrl, const char *filename)
2359 {
2360   gpg_error_t err;
2361   estream_t fp;
2362   ksba_reader_t reader;
2363
2364   fp = es_fopen (filename, "r");
2365   if (!fp)
2366     {
2367       err = gpg_error_from_errno (errno);
2368       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2369       return err;
2370     }
2371
2372   err = create_estream_ksba_reader (&reader, fp);
2373   if (!err)
2374     {
2375       err = crl_cache_insert (ctrl, filename, reader);
2376       ksba_reader_release (reader);
2377     }
2378   es_fclose (fp);
2379   return err;
2380 }
2381
2382
2383 /* Locate the corresponding CRL for the certificate CERT, read and
2384    verify the CRL and store it in the cache.  */
2385 gpg_error_t
2386 crl_cache_reload_crl (ctrl_t ctrl, ksba_cert_t cert) 
2387 {
2388   gpg_error_t err;
2389   ksba_reader_t reader = NULL;
2390   char *issuer = NULL;
2391   ksba_name_t distpoint = NULL;
2392   ksba_name_t issuername = NULL;
2393   char *distpoint_uri = NULL;
2394   char *issuername_uri = NULL;
2395   int any_dist_point = 0;
2396   int seq;
2397
2398   /* Loop over all distribution points, get the CRLs and put them into
2399      the cache. */
2400   if (opt.verbose)
2401     log_info ("checking distribution points\n");
2402   seq = 0;
2403   while ( !(err = ksba_cert_get_crl_dist_point (cert, seq++,
2404                                                 &distpoint,
2405                                                 &issuername, NULL )))
2406     {
2407       int name_seq; 
2408       gpg_error_t last_err = 0;
2409
2410       if (!distpoint && !issuername)
2411         {
2412           if (opt.verbose)
2413             log_info ("no issuer name and no distribution point\n");
2414           break; /* Not allowed; i.e. an invalid certificate.  We give
2415                     up here and hope that the default method returns a
2416                     suitable CRL. */
2417         }
2418
2419       xfree (issuername_uri); issuername_uri = NULL;
2420
2421       /* Get the URIs.  We do this in a loop to iterate over all names
2422          in the crlDP. */
2423       for (name_seq=0; ksba_name_enum (distpoint, name_seq); name_seq++)
2424         {
2425           xfree (distpoint_uri); distpoint_uri = NULL;
2426           distpoint_uri = ksba_name_get_uri (distpoint, name_seq);
2427           if (!distpoint_uri)
2428             continue;
2429           
2430           if (!strncmp (distpoint_uri, "ldap:", 5)
2431               || !strncmp (distpoint_uri, "ldaps:", 6))
2432             {
2433               if (opt.ignore_ldap_dp)
2434                 continue;
2435             }
2436           else if (!strncmp (distpoint_uri, "http:", 5)
2437                    || !strncmp (distpoint_uri, "https:", 6))
2438             {
2439               if (opt.ignore_http_dp)
2440                 continue;
2441             }
2442           else
2443             continue; /* Skip unknown schemes. */
2444           
2445           any_dist_point = 1;
2446           
2447           if (opt.verbose)
2448             log_info ("fetching CRL from `%s'\n", distpoint_uri);
2449           err = crl_fetch (ctrl, distpoint_uri, &reader);
2450           if (err)
2451             {
2452               log_error (_("crl_fetch via DP failed: %s\n"),
2453                          gpg_strerror (err));
2454               last_err = err;
2455               continue; /* with the next name. */
2456             }
2457           
2458           if (opt.verbose)
2459             log_info ("inserting CRL (reader %p)\n", reader);
2460           err = crl_cache_insert (ctrl, distpoint_uri, reader); 
2461           if (err)
2462             {
2463               log_error (_("crl_cache_insert via DP failed: %s\n"),
2464                          gpg_strerror (err));
2465               last_err = err;
2466               continue; /* with the next name. */
2467             }
2468           last_err = 0;
2469           break; /* Ready. */
2470         }
2471       if (last_err)
2472         {
2473           err = last_err;
2474           goto leave;
2475         }
2476       
2477       ksba_name_release (distpoint); distpoint = NULL;
2478
2479       /* We don't do anything with issuername_uri yet but we keep the
2480          code for documentation. */
2481       issuername_uri =  ksba_name_get_uri (issuername, 0); 
2482       ksba_name_release (issuername); issuername = NULL;
2483
2484     }
2485   if (gpg_err_code (err) == GPG_ERR_EOF)
2486     err = 0;
2487
2488   /* If we did not found any distpoint, try something reasonable. */
2489   if (!any_dist_point )
2490     {
2491       if (opt.verbose)
2492         log_info ("no distribution point - trying issuer name\n");
2493       
2494       if (reader)
2495         {
2496           crl_close_reader (reader);
2497           reader = NULL;
2498         }
2499
2500       issuer = ksba_cert_get_issuer (cert, 0);
2501       if (!issuer) 
2502         {
2503           log_error ("oops: issuer missing in certificate\n");
2504           err = gpg_error (GPG_ERR_INV_CERT_OBJ); 
2505           goto leave;
2506         }
2507
2508       if (opt.verbose)
2509         log_info ("fetching CRL from default location\n");
2510       err = crl_fetch_default (ctrl, issuer, &reader);
2511       if (err)
2512           {
2513             log_error ("crl_fetch via issuer failed: %s\n",
2514                        gpg_strerror (err));
2515             goto leave;
2516           }
2517
2518       if (opt.verbose)
2519         log_info ("inserting CRL (reader %p)\n", reader);
2520       err = crl_cache_insert (ctrl, "default location(s)", reader);
2521       if (err)
2522         {
2523           log_error (_("crl_cache_insert via issuer failed: %s\n"),
2524                      gpg_strerror (err));
2525           goto leave;
2526         }
2527     }
2528
2529  leave:
2530   if (reader)
2531     crl_close_reader (reader);
2532   xfree (distpoint_uri);
2533   xfree (issuername_uri);
2534   ksba_name_release (distpoint); 
2535   ksba_name_release (issuername); 
2536   ksba_free (issuer);
2537   return err;
2538 }
2539