Better support unsigned time_t
[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
1948    Called by:
1949       crl_cache_load
1950          cmd_loadcrl
1951          --load-crl
1952       crl_cache_reload_crl
1953          cmd_isvalid
1954          cmd_checkcrl
1955       cmd_loadcrl
1956       --fetch-crl
1957       
1958  */
1959 gpg_error_t
1960 crl_cache_insert (ctrl_t ctrl, const char *url, ksba_reader_t reader)
1961 {
1962   crl_cache_t cache = get_current_cache ();
1963   gpg_error_t err, err2;
1964   ksba_crl_t crl;
1965   char *fname = NULL;
1966   char *newfname = NULL;
1967   struct cdb_make cdb;
1968   int fd_cdb = -1;
1969   char *issuer = NULL;
1970   char *issuer_hash = NULL;
1971   ksba_isotime_t thisupdate, nextupdate;
1972   crl_cache_entry_t entry = NULL;
1973   crl_cache_entry_t e;
1974   gnupg_isotime_t current_time;
1975   char *checksum = NULL;
1976   int invalidate_crl = 0;
1977   int idx;
1978   const char *oid;
1979   int critical;
1980   char *trust_anchor = NULL;
1981
1982   /* FIXME: We should acquire a mutex for the URL, so that we don't
1983      simultaneously enter the same CRL twice.  However this needs to be
1984      interweaved with the checking function.*/
1985  
1986   err2 = 0;
1987
1988   err = ksba_crl_new (&crl);
1989   if (err)
1990     {
1991       log_error (_("ksba_crl_new failed: %s\n"), gpg_strerror (err));
1992       goto leave;
1993     }
1994   
1995   err = ksba_crl_set_reader (crl, reader);
1996   if ( err )
1997     {
1998       log_error (_("ksba_crl_set_reader failed: %s\n"), gpg_strerror (err));
1999       goto leave;
2000     }
2001
2002   /* Create a temporary cache file to load the CRL into. */
2003   {
2004     char *tmpfname, *p;
2005     const char *nodename;
2006 #ifndef HAVE_W32_SYSTEM
2007     struct utsname utsbuf;
2008 #endif
2009
2010 #ifdef HAVE_W32_SYSTEM
2011     nodename = "unknown";
2012 #else
2013     if (uname (&utsbuf))
2014       nodename = "unknown";
2015     else
2016       nodename = utsbuf.nodename;
2017 #endif
2018
2019     estream_asprintf (&tmpfname, "crl-tmp-%s-%u-%p.db.tmp",
2020                       nodename, (unsigned int)getpid (), &tmpfname);
2021     if (!tmpfname)
2022       {
2023         err = gpg_error_from_syserror ();
2024         goto leave;
2025       }
2026     for (p=tmpfname; *p; p++)
2027       if (*p == '/')
2028         *p = '.';
2029     fname = make_filename (opt.homedir_cache, DBDIR_D, tmpfname, NULL);
2030     xfree (tmpfname);
2031     if (!gnupg_remove (fname))
2032       log_info (_("removed stale temporary cache file `%s'\n"), fname);
2033     else if (errno != ENOENT) 
2034       {
2035         err = gpg_error_from_syserror ();
2036         log_error (_("problem removing stale temporary cache file `%s': %s\n"),
2037                    fname, gpg_strerror (err));
2038         goto leave;
2039       }
2040   }
2041
2042   fd_cdb = open (fname, O_WRONLY | O_CREAT | O_TRUNC, 0644);
2043   if (fd_cdb == -1)
2044     {
2045       err = gpg_error_from_errno (errno);
2046       log_error (_("error creating temporary cache file `%s': %s\n"),
2047                  fname, strerror (errno));
2048       goto leave;
2049     }
2050   cdb_make_start(&cdb, fd_cdb);
2051
2052   err = crl_parse_insert (ctrl, crl, &cdb, fname,
2053                           &issuer, thisupdate, nextupdate, &trust_anchor);
2054   if (err)
2055     {
2056       log_error (_("crl_parse_insert failed: %s\n"), gpg_strerror (err));
2057       /* Error in cleanup ignored.  */
2058       cdb_make_finish (&cdb);
2059       goto leave;
2060     }
2061
2062   /* Finish the database. */
2063   if (cdb_make_finish (&cdb))
2064     {
2065       err = gpg_error_from_errno (errno);
2066       log_error (_("error finishing temporary cache file `%s': %s\n"),
2067                  fname, strerror (errno));
2068       goto leave;
2069     }
2070   if (close (fd_cdb))
2071     {
2072       err = gpg_error_from_errno (errno);
2073       log_error (_("error closing temporary cache file `%s': %s\n"),
2074                  fname, strerror (errno));
2075       goto leave;
2076     }
2077   fd_cdb = -1;
2078
2079
2080   /* Create a checksum. */
2081   {
2082     unsigned char md5buf[16];
2083
2084     if (hash_dbfile (fname, md5buf))
2085       {
2086         err = gpg_error (GPG_ERR_CHECKSUM);
2087         goto leave;
2088       }
2089     checksum = hexify_data (md5buf, 16);
2090   }
2091
2092
2093   /* Check whether that new CRL is still not expired. */
2094   gnupg_get_isotime (current_time);
2095   if (strcmp (nextupdate, current_time) < 0 )
2096     {
2097       if (opt.force)
2098         log_info (_("WARNING: new CRL still too old; it expired on %s "
2099                     "- loading anyway\n"),  nextupdate);
2100       else
2101         {
2102           log_error (_("new CRL still too old; it expired on %s\n"),
2103                      nextupdate);
2104           if (!err2)
2105             err2 = gpg_error (GPG_ERR_CRL_TOO_OLD);
2106           invalidate_crl |= 1;
2107         }
2108     }
2109
2110   /* Check for unknown critical extensions. */
2111   for (idx=0; !(err=ksba_crl_get_extension (crl, idx, &oid, &critical,
2112                                               NULL, NULL)); idx++)
2113     {
2114       if (!critical
2115           || !strcmp (oid, oidstr_authorityKeyIdentifier)
2116           || !strcmp (oid, oidstr_crlNumber) )
2117         continue;
2118       log_error (_("unknown critical CRL extension %s\n"), oid);
2119       if (!err2)
2120         err2 = gpg_error (GPG_ERR_INV_CRL);
2121       invalidate_crl |= 2;
2122     }
2123   if (gpg_err_code (err) == GPG_ERR_EOF 
2124       || gpg_err_code (err) == GPG_ERR_NO_DATA )
2125     err = 0;
2126   if (err)
2127     {
2128       log_error (_("error reading CRL extensions: %s\n"), gpg_strerror (err));
2129       err = gpg_error (GPG_ERR_INV_CRL);
2130     }
2131
2132
2133   /* Create an hex encoded SHA-1 hash of the issuer DN to be
2134      used as the key for the cache. */
2135   issuer_hash = hashify_data (issuer, strlen (issuer));
2136
2137   /* Create an ENTRY. */
2138   entry = xtrycalloc (1, sizeof *entry);
2139   if (!entry)
2140     {
2141       err = gpg_error_from_syserror ();
2142       goto leave;
2143     }
2144   entry->release_ptr = xtrymalloc (strlen (issuer_hash) + 1 
2145                                    + strlen (issuer) + 1
2146                                    + strlen (url) + 1 
2147                                    + strlen (checksum) + 1);
2148   if (!entry->release_ptr)
2149     {
2150       err = gpg_error_from_syserror ();
2151       xfree (entry);
2152       entry = NULL;
2153       goto leave;
2154     }
2155   entry->issuer_hash = entry->release_ptr;
2156   entry->issuer = stpcpy (entry->issuer_hash, issuer_hash) + 1;
2157   entry->url = stpcpy (entry->issuer, issuer) + 1;
2158   entry->dbfile_hash = stpcpy (entry->url, url) + 1;
2159   strcpy (entry->dbfile_hash, checksum);
2160   gnupg_copy_time (entry->this_update, thisupdate); 
2161   gnupg_copy_time (entry->next_update, nextupdate); 
2162   gnupg_copy_time (entry->last_refresh, current_time);
2163   entry->crl_number = get_crl_number (crl);
2164   entry->authority_issuer = get_auth_key_id (crl, &entry->authority_serialno);
2165   entry->invalid = invalidate_crl;
2166   entry->user_trust_req = !!trust_anchor;
2167   entry->check_trust_anchor = trust_anchor;
2168   trust_anchor = NULL;
2169
2170   /* Check whether we already have an entry for this issuer and mark
2171      it as deleted. We better use a loop, just in case duplicates got
2172      somehow into the list. */
2173   for (e = cache->entries; (e=find_entry (e, entry->issuer_hash)); e = e->next)
2174     e->deleted = 1;
2175   
2176   /* Rename the temporary DB to the real name. */
2177   newfname = make_db_file_name (entry->issuer_hash);
2178   if (opt.verbose)
2179     log_info (_("creating cache file `%s'\n"), newfname);
2180 #ifdef HAVE_W32_SYSTEM
2181   gnupg_remove (newfname);
2182 #endif
2183   if (rename (fname, newfname))
2184     {
2185       err = gpg_error_from_syserror ();
2186       log_error (_("problem renaming `%s' to `%s': %s\n"),
2187                  fname, newfname, gpg_strerror (err));
2188       goto leave;
2189     }
2190   xfree (fname); fname = NULL; /*(let the cleanup code not try to remove it)*/
2191
2192   /* Link the new entry in. */
2193   entry->next = cache->entries;
2194   cache->entries = entry;
2195   entry = NULL;
2196
2197   err = update_dir (cache);
2198   if (err)
2199     {
2200       log_error (_("updating the DIR file failed - "
2201                    "cache entry will get lost with the next program start\n"));
2202       err = 0; /* Keep on running. */
2203     }
2204
2205
2206  leave:
2207   release_one_cache_entry (entry);
2208   if (fd_cdb != -1)
2209     close (fd_cdb);
2210   if (fname)
2211     {
2212       gnupg_remove (fname);
2213       xfree (fname);
2214     }
2215   xfree (newfname);
2216   ksba_crl_release (crl);
2217   xfree (issuer);
2218   xfree (issuer_hash);
2219   xfree (checksum);
2220   xfree (trust_anchor);
2221   return err ? err : err2;
2222 }
2223
2224
2225 /* Print one cached entry E in a human readable format to stream
2226    FP. Return 0 on success. */
2227 static gpg_error_t
2228 list_one_crl_entry (crl_cache_t cache, crl_cache_entry_t e, estream_t fp)
2229 {
2230   struct cdb_find cdbfp;
2231   struct cdb *cdb;
2232   int rc;
2233   int warn = 0;
2234   const unsigned char *s;
2235
2236   es_fputs ("--------------------------------------------------------\n", fp );
2237   es_fprintf (fp, _("Begin CRL dump (retrieved via %s)\n"), e->url );
2238   es_fprintf (fp, " Issuer:\t%s\n", e->issuer );
2239   es_fprintf (fp, " Issuer Hash:\t%s\n", e->issuer_hash );
2240   es_fprintf (fp, " This Update:\t%s\n", e->this_update ); 
2241   es_fprintf (fp, " Next Update:\t%s\n", e->next_update ); 
2242   es_fprintf (fp, " CRL Number :\t%s\n", e->crl_number? e->crl_number: "none");
2243   es_fprintf (fp, " AuthKeyId  :\t%s\n",
2244               e->authority_serialno? e->authority_serialno:"none");
2245   if (e->authority_serialno && e->authority_issuer)
2246     {
2247       es_fputs ("             \t", fp);
2248       for (s=e->authority_issuer; *s; s++)
2249         if (*s == '\x01')
2250           es_fputs ("\n             \t", fp);
2251         else
2252           es_putc (*s, fp);
2253       es_putc ('\n', fp);
2254     }
2255   es_fprintf (fp, " Trust Check:\t%s\n", 
2256               !e->user_trust_req? "[system]" :
2257               e->check_trust_anchor? e->check_trust_anchor:"[missing]");
2258
2259   if ((e->invalid & 1))
2260     es_fprintf (fp, _(" ERROR: The CRL will not be used "
2261                       "because it was still too old after an update!\n"));
2262   if ((e->invalid & 2))
2263     es_fprintf (fp, _(" ERROR: The CRL will not be used "
2264                       "due to an unknown critical extension!\n"));
2265   if ((e->invalid & ~3))
2266     es_fprintf (fp, _(" ERROR: The CRL will not be used\n"));
2267
2268   cdb = lock_db_file (cache, e);
2269   if (!cdb)
2270     return gpg_error (GPG_ERR_GENERAL);
2271
2272   if (!e->dbfile_checked)
2273     es_fprintf (fp, _(" ERROR: This cached CRL may has been tampered with!\n"));
2274
2275   es_putc ('\n', fp);
2276
2277   rc = cdb_findinit (&cdbfp, cdb, NULL, 0);
2278   while (!rc && (rc=cdb_findnext (&cdbfp)) > 0 )
2279     {
2280       unsigned char keyrecord[256];
2281       unsigned char record[16];
2282       int reason;
2283       int any = 0;
2284       cdbi_t n;
2285       cdbi_t i;
2286
2287       rc = 0;
2288       n = cdb_datalen (cdb);
2289       if (n != 16)
2290         {
2291           log_error (_(" WARNING: invalid cache record length\n"));
2292           warn = 1;
2293           continue;
2294         }
2295
2296       if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
2297         {
2298           log_error (_("problem reading cache record: %s\n"),
2299                      strerror (errno));
2300           warn = 1;
2301           continue;
2302         }
2303     
2304       n = cdb_keylen (cdb);
2305       if (n > sizeof keyrecord)
2306         n = sizeof keyrecord;
2307       if (cdb_read (cdb, keyrecord, n, cdb_keypos (cdb)))
2308         {
2309           log_error (_("problem reading cache key: %s\n"), strerror (errno));
2310           warn = 1;
2311           continue;
2312         }
2313
2314       reason = *record;
2315       es_fputs ("  ", fp);
2316       for (i = 0; i < n; i++)
2317         es_fprintf (fp, "%02X", keyrecord[i]);
2318       es_fputs (":\t reasons( ", fp);
2319     
2320       if (reason & KSBA_CRLREASON_UNSPECIFIED)
2321         es_fputs( "unspecified ", fp ), any = 1;
2322       if (reason & KSBA_CRLREASON_KEY_COMPROMISE )
2323         es_fputs( "key_compromise ", fp ), any = 1; 
2324       if (reason & KSBA_CRLREASON_CA_COMPROMISE )
2325         es_fputs( "ca_compromise ", fp ), any = 1; 
2326       if (reason & KSBA_CRLREASON_AFFILIATION_CHANGED )
2327         es_fputs( "affiliation_changed ", fp ), any = 1; 
2328       if (reason & KSBA_CRLREASON_SUPERSEDED )
2329         es_fputs( "superseeded", fp ), any = 1; 
2330       if (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION )
2331         es_fputs( "cessation_of_operation", fp ), any = 1; 
2332       if (reason & KSBA_CRLREASON_CERTIFICATE_HOLD )
2333         es_fputs( "certificate_hold", fp ), any = 1; 
2334       if (reason && !any)
2335         es_fputs( "other", fp ); 
2336       
2337       es_fprintf (fp, ") rdate: %.15s\n", record+1);
2338     } 
2339   if (rc)
2340     log_error (_("error reading cache entry from db: %s\n"), strerror (rc));
2341
2342   unlock_db_file (cache, e);
2343   es_fprintf (fp, _("End CRL dump\n") );
2344   es_putc ('\n', fp);
2345
2346   return (rc||warn)? gpg_error (GPG_ERR_GENERAL) : 0;
2347 }
2348
2349
2350 /* Print the contents of the CRL CACHE in a human readable format to
2351    stream FP. */
2352 gpg_error_t 
2353 crl_cache_list (estream_t fp) 
2354 {
2355   crl_cache_t cache = get_current_cache ();
2356   crl_cache_entry_t entry;
2357   gpg_error_t err = 0;
2358
2359   for (entry = cache->entries;
2360        entry && !entry->deleted && !err;
2361        entry = entry->next ) 
2362     err = list_one_crl_entry (cache, entry, fp);
2363
2364   return err;
2365 }
2366
2367
2368 /* Load the CRL containing the file named FILENAME into our CRL cache. */
2369 gpg_error_t
2370 crl_cache_load (ctrl_t ctrl, const char *filename)
2371 {
2372   gpg_error_t err;
2373   estream_t fp;
2374   ksba_reader_t reader;
2375
2376   fp = es_fopen (filename, "r");
2377   if (!fp)
2378     {
2379       err = gpg_error_from_errno (errno);
2380       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2381       return err;
2382     }
2383
2384   err = create_estream_ksba_reader (&reader, fp);
2385   if (!err)
2386     {
2387       err = crl_cache_insert (ctrl, filename, reader);
2388       ksba_reader_release (reader);
2389     }
2390   es_fclose (fp);
2391   return err;
2392 }
2393
2394
2395 /* Locate the corresponding CRL for the certificate CERT, read and
2396    verify the CRL and store it in the cache.  */
2397 gpg_error_t
2398 crl_cache_reload_crl (ctrl_t ctrl, ksba_cert_t cert) 
2399 {
2400   gpg_error_t err;
2401   ksba_reader_t reader = NULL;
2402   char *issuer = NULL;
2403   ksba_name_t distpoint = NULL;
2404   ksba_name_t issuername = NULL;
2405   char *distpoint_uri = NULL;
2406   char *issuername_uri = NULL;
2407   int any_dist_point = 0;
2408   int seq;
2409
2410   /* Loop over all distribution points, get the CRLs and put them into
2411      the cache. */
2412   if (opt.verbose)
2413     log_info ("checking distribution points\n");
2414   seq = 0;
2415   while ( !(err = ksba_cert_get_crl_dist_point (cert, seq++,
2416                                                 &distpoint,
2417                                                 &issuername, NULL )))
2418     {
2419       int name_seq; 
2420       gpg_error_t last_err = 0;
2421
2422       if (!distpoint && !issuername)
2423         {
2424           if (opt.verbose)
2425             log_info ("no issuer name and no distribution point\n");
2426           break; /* Not allowed; i.e. an invalid certificate.  We give
2427                     up here and hope that the default method returns a
2428                     suitable CRL. */
2429         }
2430
2431       xfree (issuername_uri); issuername_uri = NULL;
2432
2433       /* Get the URIs.  We do this in a loop to iterate over all names
2434          in the crlDP. */
2435       for (name_seq=0; ksba_name_enum (distpoint, name_seq); name_seq++)
2436         {
2437           xfree (distpoint_uri); distpoint_uri = NULL;
2438           distpoint_uri = ksba_name_get_uri (distpoint, name_seq);
2439           if (!distpoint_uri)
2440             continue;
2441           
2442           if (!strncmp (distpoint_uri, "ldap:", 5)
2443               || !strncmp (distpoint_uri, "ldaps:", 6))
2444             {
2445               if (opt.ignore_ldap_dp)
2446                 continue;
2447             }
2448           else if (!strncmp (distpoint_uri, "http:", 5)
2449                    || !strncmp (distpoint_uri, "https:", 6))
2450             {
2451               if (opt.ignore_http_dp)
2452                 continue;
2453             }
2454           else
2455             continue; /* Skip unknown schemes. */
2456           
2457           any_dist_point = 1;
2458           
2459           if (opt.verbose)
2460             log_info ("fetching CRL from `%s'\n", distpoint_uri);
2461           err = crl_fetch (ctrl, distpoint_uri, &reader);
2462           if (err)
2463             {
2464               log_error (_("crl_fetch via DP failed: %s\n"),
2465                          gpg_strerror (err));
2466               last_err = err;
2467               continue; /* with the next name. */
2468             }
2469           
2470           if (opt.verbose)
2471             log_info ("inserting CRL (reader %p)\n", reader);
2472           err = crl_cache_insert (ctrl, distpoint_uri, reader); 
2473           if (err)
2474             {
2475               log_error (_("crl_cache_insert via DP failed: %s\n"),
2476                          gpg_strerror (err));
2477               last_err = err;
2478               continue; /* with the next name. */
2479             }
2480           last_err = 0;
2481           break; /* Ready. */
2482         }
2483       if (last_err)
2484         {
2485           err = last_err;
2486           goto leave;
2487         }
2488       
2489       ksba_name_release (distpoint); distpoint = NULL;
2490
2491       /* We don't do anything with issuername_uri yet but we keep the
2492          code for documentation. */
2493       issuername_uri =  ksba_name_get_uri (issuername, 0); 
2494       ksba_name_release (issuername); issuername = NULL;
2495
2496     }
2497   if (gpg_err_code (err) == GPG_ERR_EOF)
2498     err = 0;
2499
2500   /* If we did not found any distpoint, try something reasonable. */
2501   if (!any_dist_point )
2502     {
2503       if (opt.verbose)
2504         log_info ("no distribution point - trying issuer name\n");
2505       
2506       if (reader)
2507         {
2508           crl_close_reader (reader);
2509           reader = NULL;
2510         }
2511
2512       issuer = ksba_cert_get_issuer (cert, 0);
2513       if (!issuer) 
2514         {
2515           log_error ("oops: issuer missing in certificate\n");
2516           err = gpg_error (GPG_ERR_INV_CERT_OBJ); 
2517           goto leave;
2518         }
2519
2520       if (opt.verbose)
2521         log_info ("fetching CRL from default location\n");
2522       err = crl_fetch_default (ctrl, issuer, &reader);
2523       if (err)
2524           {
2525             log_error ("crl_fetch via issuer failed: %s\n",
2526                        gpg_strerror (err));
2527             goto leave;
2528           }
2529
2530       if (opt.verbose)
2531         log_info ("inserting CRL (reader %p)\n", reader);
2532       err = crl_cache_insert (ctrl, "default location(s)", reader);
2533       if (err)
2534         {
2535           log_error (_("crl_cache_insert via issuer failed: %s\n"),
2536                      gpg_strerror (err));
2537           goto leave;
2538         }
2539     }
2540
2541  leave:
2542   if (reader)
2543     crl_close_reader (reader);
2544   xfree (distpoint_uri);
2545   xfree (issuername_uri);
2546   ksba_name_release (distpoint); 
2547   ksba_name_release (issuername); 
2548   ksba_free (issuer);
2549   return err;
2550 }
2551