Merged Dirmngr with GnuPG.
[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           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 (unlink (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 (FILE *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=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 FILE *
405 open_dir_file (const char *fname)
406 {
407   FILE *fp;
408
409   fp = 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 = 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       fprintf (fp, "v:%d:\n", DBDIRVERSION);
427       if (ferror (fp))
428         {
429           log_error (_("error writing new cache dir file `%s': %s\n"),
430                      fname, strerror (errno));
431           fclose (fp);
432           return NULL;
433         }
434       if (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 = 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 (FILE **fpadr, const char *fname,
458                          unsigned int *lineno,
459                          int cleanup_on_mismatch)
460 {
461   char *line;
462   gpg_error_t lineerr = 0;
463   FILE *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           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   FILE *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 (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   if (fp)
699     fclose (fp);
700   xfree (line);
701   xfree (fname);
702   if (err)
703     {
704       release_cache (cache);
705       cache = NULL;
706     }
707   *r_cache = cache;
708   return err;
709 }
710
711 static void
712 write_percented_string (const char *s, FILE *fp)
713 {
714   for (; *s; s++)
715     if (*s == ':')
716       fputs ("%3A", fp);
717     else if (*s == '\n')
718       fputs ("%0A", fp);
719     else if (*s == '\r')
720       fputs ("%0D", fp);
721     else
722       putc (*s, fp);
723 }
724
725
726 static void
727 write_dir_line_crl (FILE *fp, crl_cache_entry_t e)
728 {
729   if (e->invalid)
730     fprintf (fp, "i%d", e->invalid);
731   else if (e->user_trust_req)
732     putc ('u', fp);
733   else
734     putc ('c', fp);
735   putc (':', fp);
736   fputs (e->issuer_hash, fp);
737   putc (':', fp);
738   write_percented_string (e->issuer, fp);
739   putc (':', fp);
740   write_percented_string (e->url, fp);
741   putc (':', fp);
742   fwrite (e->this_update, 15, 1, fp); 
743   putc (':', fp);
744   fwrite (e->next_update, 15, 1, fp); 
745   putc (':', fp);
746   fputs (e->dbfile_hash, fp);
747   putc (':', fp);
748   if (e->crl_number)
749     fputs (e->crl_number, fp);
750   putc (':', fp);
751   if (e->authority_issuer)
752     write_percented_string (e->authority_issuer, fp);
753   putc (':', fp);
754   if (e->authority_serialno)
755     fputs (e->authority_serialno, fp);
756   putc (':', fp);
757   if (e->check_trust_anchor && e->user_trust_req)
758     fputs (e->check_trust_anchor, fp);
759   putc ('\n', fp);
760 }
761
762
763 /* Update the current dir file using the cache. */
764 static gpg_error_t
765 update_dir (crl_cache_t cache)
766 {
767   char *fname = NULL;
768   char *tmpfname = NULL;
769   char *line = NULL;
770   gpg_error_t lineerr = 0;
771   FILE *fp, *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 = 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   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 = 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                   fprintf (fpout, "# Next line added by "
872                            "another process; our pid is %lu\n", 
873                            (unsigned long)getpid ());
874                   fputs (line, fpout);
875                   putc ('\n', fpout);
876                 }
877             }
878           else
879             {
880               fputs ("# Invalid line detected: ", fpout);
881               fputs (line, fpout);
882               putc ('\n', fpout);
883             }
884         }
885       else 
886         {
887           /* Write out all non CRL lines as they are. */
888           fputs (line, fpout);
889           putc ('\n', fpout);
890         }
891
892       xfree (line);
893     }
894   if (!ferror (fp) && !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 (ferror (fp))
912     {
913       err = gpg_error_from_errno (errno);
914       log_error (_("error reading `%s': %s\n"), fname, strerror (errno));
915     }
916   if (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   fclose (fp);
926   fp = NULL;
927   if (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   unlink (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   if (fp)
951     fclose (fp);
952   xfree (fname);
953   if (fpout)
954     {
955       fclose (fpout);
956       if (err && tmpfname)
957         remove (tmpfname);
958     }
959   xfree (tmpfname);
960   return err;
961 }
962
963
964
965
966 /* Create the filename for the cache file from the 40 byte ISSUER_HASH
967    string. Caller must release the return string. */
968 static char *
969 make_db_file_name (const char *issuer_hash)
970 {
971   char bname[50];
972
973   assert (strlen (issuer_hash) == 40);
974   memcpy (bname, "crl-", 4);
975   memcpy (bname + 4, issuer_hash, 40);
976   strcpy (bname + 44, ".db");
977   return make_filename (opt.homedir_cache, DBDIR_D, bname, NULL);
978 }
979
980
981 /* Hash the file FNAME and return the MD5 digest in MD5BUFFER. The
982    caller must allocate MD%buffer wityh at least 16 bytes. Returns 0
983    on success. */
984 static int
985 hash_dbfile (const char *fname, unsigned char *md5buffer)
986 {
987   FILE *fp;
988   char *buffer;
989   size_t n;
990   gcry_md_hd_t md5;
991   gpg_err_code_t err;
992
993   buffer = xtrymalloc (65536);
994   fp = buffer? fopen (fname, "rb") : NULL;
995   if (!fp)
996     {
997       log_error (_("can't hash `%s': %s\n"), fname, strerror (errno));
998       xfree (buffer);
999       return -1;
1000     }
1001
1002   err = gcry_md_open (&md5, GCRY_MD_MD5, 0);
1003   if (err)
1004     {
1005       log_error (_("error setting up MD5 hash context: %s\n"),
1006                  gpg_strerror (err));
1007       xfree (buffer);
1008       fclose (fp);
1009       return -1;
1010     }
1011
1012   /* We better hash some information about the cache file layout in. */
1013   sprintf (buffer, "%.100s/%.100s:%d", DBDIR_D, DBDIRFILE, DBDIRVERSION);
1014   gcry_md_write (md5, buffer, strlen (buffer));
1015     
1016   for (;;)
1017     {
1018       n = fread (buffer, 1, 65536, fp);
1019       if (n < 65536 && ferror (fp))
1020         {
1021           log_error (_("error hashing `%s': %s\n"), fname, strerror (errno));
1022           xfree (buffer);
1023           fclose (fp);
1024           gcry_md_close (md5);
1025           return -1;
1026         }
1027       if (!n)
1028         break;
1029       gcry_md_write (md5, buffer, n);
1030     }
1031   fclose (fp);
1032   xfree (buffer);
1033   gcry_md_final (md5);
1034
1035   memcpy (md5buffer, gcry_md_read (md5, GCRY_MD_MD5), 16);
1036   gcry_md_close (md5);
1037   return 0;
1038 }
1039
1040 /* Compare the file FNAME against the dexified MD5 hash MD5HASH and
1041    return 0 if they match. */
1042 static int
1043 check_dbfile (const char *fname, const char *md5hexvalue)
1044 {
1045   unsigned char buffer1[16], buffer2[16];
1046
1047   if (strlen (md5hexvalue) != 32)
1048     {
1049       log_error (_("invalid formatted checksum for `%s'\n"), fname);
1050       return -1;
1051     }
1052   unhexify (buffer1, md5hexvalue);
1053
1054   if (hash_dbfile (fname, buffer2))
1055     return -1;
1056
1057   return memcmp (buffer1, buffer2, 16);
1058 }
1059
1060
1061 /* Open the cache file for ENTRY.  This function implements a caching
1062    strategy and might close unused cache files. It is required to use
1063    unlock_db_file after using the file. */ 
1064 static struct cdb *
1065 lock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
1066 {
1067   char *fname;
1068   int fd;
1069   int open_count;
1070   crl_cache_entry_t e;
1071
1072   if (entry->cdb)
1073     {
1074       entry->cdb_use_count++;
1075       return entry->cdb;
1076     }
1077
1078   for (open_count = 0, e = cache->entries; e; e = e->next)
1079     {
1080       if (e->cdb)
1081         open_count++;
1082 /*       log_debug ("CACHE: cdb=%p use_count=%u lru_count=%u\n", */
1083 /*                  e->cdb,e->cdb_use_count,e->cdb_lru_count); */
1084     }
1085
1086   /* If there are too many file open, find the least recent used DB
1087      file and close it.  Note that for Pth thread safeness we need to
1088      use a loop here. */
1089   while (open_count >= MAX_OPEN_DB_FILES )
1090     {
1091       crl_cache_entry_t last_e = NULL;
1092       unsigned int last_lru = (unsigned int)(-1);
1093
1094       for (e = cache->entries; e; e = e->next)
1095         if (e->cdb && !e->cdb_use_count && e->cdb_lru_count < last_lru)
1096           {
1097             last_lru = e->cdb_lru_count;
1098             last_e = e;
1099           }
1100       if (!last_e)
1101         {
1102           log_error (_("too many open cache files; can't open anymore\n"));
1103           return NULL;
1104         }
1105
1106 /*       log_debug ("CACHE: closing file at cdb=%p\n", last_e->cdb); */
1107
1108       fd = cdb_fileno (last_e->cdb);
1109       cdb_free (last_e->cdb);
1110       xfree (last_e->cdb);
1111       last_e->cdb = NULL;
1112       if (close (fd))
1113         log_error (_("error closing cache file: %s\n"), strerror(errno));
1114       open_count--;
1115     }
1116
1117
1118   fname = make_db_file_name (entry->issuer_hash);
1119   if (opt.verbose)
1120     log_info (_("opening cache file `%s'\n"), fname );
1121
1122   if (!entry->dbfile_checked)
1123     {
1124       if (!check_dbfile (fname, entry->dbfile_hash))
1125         entry->dbfile_checked = 1;
1126       /* Note, in case of an error we don't print an error here but
1127          let require the caller to do that check. */
1128     }
1129
1130   entry->cdb = xtrycalloc (1, sizeof *entry->cdb);
1131   if (!entry->cdb)
1132     {
1133       xfree (fname);
1134       return NULL;
1135     }
1136   fd = open (fname, O_RDONLY);
1137   if (fd == -1)
1138     {
1139       log_error (_("error opening cache file `%s': %s\n"),
1140                  fname, strerror (errno));
1141       xfree (entry->cdb);
1142       entry->cdb = NULL;
1143       xfree (fname);
1144       return NULL;
1145     }
1146   if (cdb_init (entry->cdb, fd))
1147     {
1148       log_error (_("error initializing cache file `%s' for reading: %s\n"),
1149                  fname, strerror (errno));
1150       xfree (entry->cdb);
1151       entry->cdb = NULL;
1152       close (fd);
1153       xfree (fname);
1154       return NULL;
1155     }
1156   xfree (fname);
1157
1158   entry->cdb_use_count = 1;
1159   entry->cdb_lru_count = 0;
1160
1161   return entry->cdb;
1162 }
1163
1164 /* Unlock a cache file, so that it can be reused. */
1165 static void
1166 unlock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
1167 {
1168   if (!entry->cdb)
1169     log_error (_("calling unlock_db_file on a closed file\n"));
1170   else if (!entry->cdb_use_count)
1171     log_error (_("calling unlock_db_file on an unlocked file\n"));
1172   else 
1173     {
1174       entry->cdb_use_count--;
1175       entry->cdb_lru_count++;
1176     }
1177
1178   /* If the entry was marked for deletion in the meantime do it now.
1179      We do this for the sake of Pth thread safeness. */
1180   if (!entry->cdb_use_count && entry->deleted)
1181     {
1182       crl_cache_entry_t eprev, enext;
1183
1184       enext = entry->next;
1185       for (eprev = cache->entries;
1186            eprev && eprev->next != entry; eprev = eprev->next)
1187         ;
1188       assert (eprev);
1189       if (eprev == cache->entries)
1190         cache->entries = enext;
1191       else
1192         eprev->next = enext;
1193     }
1194 }
1195
1196
1197 /* Find ISSUER_HASH in our cache FIRST. This may be used to enumerate
1198    the linked list we use to keep the CRLs of an issuer. */
1199 static crl_cache_entry_t 
1200 find_entry (crl_cache_entry_t first, const char *issuer_hash)
1201 {
1202   while (first && (first->deleted || strcmp (issuer_hash, first->issuer_hash)))
1203     first = first->next;
1204   return first;    
1205 }
1206
1207
1208
1209 /* Create a new CRL cache. This fucntion is usually called only once.
1210    never fail. */
1211 void
1212 crl_cache_init(void)
1213 {
1214   crl_cache_t cache = NULL;
1215   gpg_error_t err;
1216
1217   if (current_cache)
1218     {
1219       log_error ("crl cache has already been initialized - not doing twice\n");
1220       return;
1221     }
1222
1223   err = open_dir (&cache);
1224   if (err) 
1225     log_fatal (_("failed to create a new cache object: %s\n"),
1226                gpg_strerror (err));
1227   current_cache = cache;
1228 }
1229
1230
1231 /* Remove the cache information and all its resources.  Note that we
1232    still keep the cache on disk. */
1233 void 
1234 crl_cache_deinit (void)
1235 {
1236   if (current_cache)
1237     {
1238       release_cache (current_cache);
1239       current_cache = NULL;
1240     }
1241 }
1242
1243
1244 /* Delete the cache from disk. Return 0 on success.*/
1245 int 
1246 crl_cache_flush (void)
1247 {
1248   int rc;
1249
1250   rc = cleanup_cache_dir (0)? -1 : 0;
1251
1252   return rc;
1253 }
1254
1255
1256 /* Check whether the certificate identified by ISSUER_HASH and
1257    SN/SNLEN is valid; i.e. not listed in our cache.  With
1258    FORCE_REFRESH set to true, a new CRL will be retrieved even if the
1259    cache has not yet expired.  We use a 30 minutes threshold here so
1260    that invoking this function several times won't load the CRL over
1261    and over.  */
1262 static crl_cache_result_t 
1263 cache_isvalid (ctrl_t ctrl, const char *issuer_hash,
1264                const unsigned char *sn, size_t snlen,
1265                int force_refresh)
1266 {
1267   crl_cache_t cache = get_current_cache ();
1268   crl_cache_result_t retval;
1269   struct cdb *cdb;
1270   int rc;
1271   crl_cache_entry_t entry;
1272   gnupg_isotime_t current_time;
1273   size_t n;
1274
1275   (void)ctrl;
1276
1277   entry = find_entry (cache->entries, issuer_hash);
1278   if (!entry)
1279     {
1280       log_info (_("no CRL available for issuer id %s\n"), issuer_hash );
1281       return CRL_CACHE_DONTKNOW;
1282     }
1283
1284   gnupg_get_isotime (current_time);
1285   if (strcmp (entry->next_update, current_time) < 0 )
1286     {
1287       log_info (_("cached CRL for issuer id %s too old; update required\n"),
1288                 issuer_hash);
1289       return CRL_CACHE_DONTKNOW;
1290     }
1291   if (force_refresh)
1292     {
1293       gnupg_isotime_t tmptime;
1294       
1295       if (*entry->last_refresh)
1296         {
1297           gnupg_copy_time (tmptime, entry->last_refresh);
1298           add_seconds_to_isotime (tmptime, 30 * 60);
1299           if (strcmp (tmptime, current_time) < 0 )
1300             {
1301               log_info (_("force-crl-refresh active and %d minutes passed for"
1302                           " issuer id %s; update required\n"), 
1303                         30, issuer_hash);
1304               return CRL_CACHE_DONTKNOW;
1305             }
1306         }
1307       else
1308         {
1309           log_info (_("force-crl-refresh active for"
1310                       " issuer id %s; update required\n"), 
1311                     issuer_hash);
1312           return CRL_CACHE_DONTKNOW;
1313         }
1314     }
1315
1316   if (entry->invalid)
1317     {
1318       log_info (_("available CRL for issuer ID %s can't be used\n"),
1319                 issuer_hash);
1320       return CRL_CACHE_CANTUSE;
1321     }
1322
1323   cdb = lock_db_file (cache, entry);
1324   if (!cdb)
1325     return CRL_CACHE_DONTKNOW; /* Hmmm, not the best error code. */
1326   
1327   if (!entry->dbfile_checked)
1328     {
1329       log_error (_("cached CRL for issuer id %s tampered; we need to update\n")
1330                  , issuer_hash);
1331       unlock_db_file (cache, entry);
1332       return CRL_CACHE_DONTKNOW;
1333     }
1334
1335   rc = cdb_find (cdb, sn, snlen);
1336   if (rc == 1) 
1337     {
1338       n = cdb_datalen (cdb);
1339       if (n != 16)
1340         {
1341           log_error (_("WARNING: invalid cache record length for S/N "));
1342           log_printhex ("", sn, snlen);
1343         }
1344       else if (opt.verbose)
1345         {
1346           unsigned char record[16];
1347           char *tmp = hexify_data (sn, snlen);
1348
1349           if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
1350             log_error (_("problem reading cache record for S/N %s: %s\n"),
1351                        tmp, strerror (errno));
1352           else
1353             log_info (_("S/N %s is not valid; reason=%02X  date=%.15s\n"),
1354                       tmp, *record, record+1);
1355           xfree (tmp);
1356         }
1357       retval = CRL_CACHE_INVALID;
1358     }
1359   else if (!rc)
1360     {
1361       if (opt.verbose)
1362         {
1363           char *serialno = hexify_data (sn, snlen);
1364           log_info (_("S/N %s is valid, it is not listed in the CRL\n"),
1365                     serialno );
1366           xfree (serialno);
1367         }
1368       retval = CRL_CACHE_VALID;
1369     }
1370   else 
1371     {
1372       log_error (_("error getting data from cache file: %s\n"),
1373                  strerror (errno));
1374       retval = CRL_CACHE_DONTKNOW;
1375     }
1376
1377
1378   if (entry->user_trust_req
1379       && (retval == CRL_CACHE_VALID || retval == CRL_CACHE_INVALID))
1380     {
1381       if (!entry->check_trust_anchor)
1382         {
1383           log_error ("inconsistent data on user trust check\n");
1384           retval = CRL_CACHE_CANTUSE;
1385         }
1386       else if (get_istrusted_from_client (ctrl, entry->check_trust_anchor))
1387         {
1388           if (opt.verbose)
1389             log_info ("no system trust and client does not trust either\n");
1390           retval = CRL_CACHE_CANTUSE;
1391         }
1392       else
1393         {
1394           /* Okay, the CRL is considered valid by the client and thus
1395              we can return the result as is.  */
1396         }
1397     }
1398
1399   unlock_db_file (cache, entry);
1400
1401   return retval;
1402 }
1403
1404
1405 /* Check whether the certificate identified by ISSUER_HASH and
1406    SERIALNO is valid; i.e. not listed in our cache.  With
1407    FORCE_REFRESH set to true, a new CRL will be retrieved even if the
1408    cache has not yet expired.  We use a 30 minutes threshold here so
1409    that invoking this function several times won't load the CRL over
1410    and over.  */
1411 crl_cache_result_t 
1412 crl_cache_isvalid (ctrl_t ctrl, const char *issuer_hash, const char *serialno,
1413                    int force_refresh)
1414 {
1415   crl_cache_result_t result;
1416   unsigned char snbuf_buffer[50];
1417   unsigned char *snbuf;
1418   size_t n;
1419
1420   n = strlen (serialno)/2+1;
1421   if (n < sizeof snbuf_buffer - 1)
1422     snbuf = snbuf_buffer;
1423   else
1424     {
1425       snbuf = xtrymalloc (n);
1426       if (!snbuf)
1427         return CRL_CACHE_DONTKNOW;
1428     }
1429
1430   n = unhexify (snbuf, serialno);
1431
1432   result = cache_isvalid (ctrl, issuer_hash, snbuf, n, force_refresh);
1433
1434   if (snbuf != snbuf_buffer)
1435     xfree (snbuf);
1436
1437   return result;
1438 }  
1439
1440
1441 /* Check whether the certificate CERT is valid; i.e. not listed in our
1442    cache.  With FORCE_REFRESH set to true, a new CRL will be retrieved
1443    even if the cache has not yet expired.  We use a 30 minutes
1444    threshold here so that invoking this function several times won't
1445    load the CRL over and over.  */
1446 gpg_error_t
1447 crl_cache_cert_isvalid (ctrl_t ctrl, ksba_cert_t cert,
1448                         int force_refresh)
1449 {
1450   gpg_error_t err;
1451   crl_cache_result_t result;
1452   unsigned char issuerhash[20];
1453   char issuerhash_hex[41];
1454   ksba_sexp_t serial;
1455   unsigned char *sn;
1456   size_t snlen;
1457   char *endp, *tmp;
1458   int i;
1459
1460   /* Compute the hash value of the issuer name.  */
1461   tmp = ksba_cert_get_issuer (cert, 0);
1462   if (!tmp)
1463     {
1464       log_error ("oops: issuer missing in certificate\n");
1465       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1466     }
1467   gcry_md_hash_buffer (GCRY_MD_SHA1, issuerhash, tmp, strlen (tmp));
1468   xfree (tmp);
1469   for (i=0,tmp=issuerhash_hex; i < 20; i++, tmp += 2)
1470     sprintf (tmp, "%02X", issuerhash[i]);
1471   
1472   /* Get the serial number.  */
1473   serial = ksba_cert_get_serial (cert);
1474   if (!serial)
1475     {
1476       log_error ("oops: S/N missing in certificate\n");
1477       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1478     }
1479   sn = serial;
1480   if (*sn != '(')
1481     {
1482       log_error ("oops: invalid S/N\n");
1483       xfree (serial);
1484       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1485     }
1486   sn++;
1487   snlen = strtoul (sn, &endp, 10);
1488   sn = endp;
1489   if (*sn != ':')
1490     {
1491       log_error ("oops: invalid S/N\n");
1492       xfree (serial);
1493       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1494     }
1495   sn++;
1496
1497   /* Check the cache.  */
1498   result = cache_isvalid (ctrl, issuerhash_hex, sn, snlen, force_refresh);
1499   switch (result)
1500     {
1501     case CRL_CACHE_VALID:
1502       err = 0;
1503       break;
1504     case CRL_CACHE_INVALID:
1505       err = gpg_error (GPG_ERR_CERT_REVOKED);
1506       break;
1507     case CRL_CACHE_DONTKNOW: 
1508       err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1509     case CRL_CACHE_CANTUSE: 
1510       err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1511       break;
1512     default:
1513       log_fatal ("cache_isvalid returned invalid status code %d\n", result);
1514     }
1515
1516   xfree (serial);
1517   return err;
1518 }  
1519
1520
1521 /* Prepare a hash context for the signature verification.  Input is
1522    the CRL and the output is the hash context MD as well as the uses
1523    algorithm identifier ALGO. */
1524 static gpg_error_t
1525 start_sig_check (ksba_crl_t crl, gcry_md_hd_t *md, int *algo) 
1526 {
1527   gpg_error_t err;
1528   const char *algoid;
1529
1530   algoid = ksba_crl_get_digest_algo (crl);
1531   *algo = gcry_md_map_name (algoid);
1532   if (!*algo) 
1533     {
1534       log_error (_("unknown hash algorithm `%s'\n"), algoid? algoid:"?");
1535       return gpg_error (GPG_ERR_DIGEST_ALGO);
1536     }
1537
1538   err = gcry_md_open (md, *algo, 0);
1539   if (err)
1540     {
1541       log_error (_("gcry_md_open for algorithm %d failed: %s\n"),
1542                  *algo, gcry_strerror (err));
1543       return err;
1544     }
1545   if (DBG_HASHING)
1546     gcry_md_debug (*md, "hash.cert");
1547
1548   ksba_crl_set_hash_function (crl, HASH_FNC, *md);  
1549   return 0;
1550 }
1551
1552
1553 /* Finish a hash context and verify the signature.  This function
1554    should return 0 on a good signature, GPG_ERR_BAD_SIGNATURE if the
1555    signature does not verify or any other error code. CRL is the CRL
1556    object we are working on, MD the hash context and ISSUER_CERT the
1557    certificate of the CRL issuer.  This function closes MD.  */
1558 static gpg_error_t
1559 finish_sig_check (ksba_crl_t crl, gcry_md_hd_t md, int algo,
1560                   ksba_cert_t issuer_cert)
1561 {
1562   gpg_error_t err;
1563   ksba_sexp_t sigval = NULL, pubkey = NULL;
1564   const char *s;
1565   char algoname[50];
1566   size_t n;
1567   gcry_sexp_t s_sig = NULL, s_hash = NULL, s_pkey = NULL;
1568   unsigned int i;
1569
1570   /* This also stops debugging on the MD.  */
1571   gcry_md_final (md);
1572
1573   /* Get and convert the signature value. */
1574   sigval = ksba_crl_get_sig_val (crl);
1575   n = gcry_sexp_canon_len (sigval, 0, NULL, NULL);
1576   if (!n) 
1577     {
1578       log_error (_("got an invalid S-expression from libksba\n"));
1579       err = gpg_error (GPG_ERR_INV_SEXP);
1580       goto leave;
1581     }
1582   err = gcry_sexp_sscan (&s_sig, NULL, sigval, n);
1583   if (err) 
1584     {
1585       log_error (_("converting S-expression failed: %s\n"),
1586                  gcry_strerror (err));
1587       goto leave;
1588     }
1589         
1590   /* Get and convert the public key for the issuer certificate. */
1591   if (DBG_X509)
1592     dump_cert ("crl_issuer_cert", issuer_cert);
1593   pubkey = ksba_cert_get_public_key (issuer_cert);
1594   n = gcry_sexp_canon_len (pubkey, 0, NULL, NULL);
1595   if (!n) 
1596     {
1597       log_error (_("got an invalid S-expression from libksba\n"));
1598       err = gpg_error (GPG_ERR_INV_SEXP);
1599       goto leave;
1600     }
1601   err = gcry_sexp_sscan (&s_pkey, NULL, pubkey, n);
1602   if (err) 
1603     {
1604       log_error (_("converting S-expression failed: %s\n"),
1605                  gcry_strerror (err));
1606       goto leave;
1607     }
1608
1609   /* Create an S-expression with the actual hash value. */
1610   s = gcry_md_algo_name (algo);
1611   for (i = 0; *s && i < sizeof(algoname) - 1; s++, i++)
1612     algoname[i] = ascii_tolower (*s);
1613   algoname[i] = 0;
1614   err = gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))", 
1615                          algoname,
1616                          gcry_md_get_algo_dlen (algo), gcry_md_read (md, algo));
1617   if (err) 
1618     {
1619       log_error (_("creating S-expression failed: %s\n"), gcry_strerror (err));
1620       goto leave;
1621     }
1622
1623   /* Pass this on to the signature verification. */
1624   err = gcry_pk_verify (s_sig, s_hash, s_pkey);
1625   if (DBG_X509)
1626     log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
1627
1628  leave:
1629   xfree (sigval);
1630   xfree (pubkey);
1631   gcry_sexp_release (s_sig);
1632   gcry_sexp_release (s_hash);
1633   gcry_sexp_release (s_pkey);
1634   gcry_md_close (md);
1635
1636   return err;
1637 }
1638
1639
1640 /* Call this to match a start_sig_check that can not be completed
1641    normally.  */
1642 static void
1643 abort_sig_check (ksba_crl_t crl, gcry_md_hd_t md)
1644 {
1645   (void)crl;
1646   gcry_md_close (md);
1647 }
1648
1649
1650 /* Workhorse of the CRL loading machinery.  The CRL is read using the
1651    CRL object and stored in the data base file DB with the name FNAME
1652    (only used for printing error messages).  That DB should be a
1653    temporary one and not the actual one.  If the function fails the
1654    caller should delete this temporary database file.  CTRL is
1655    required to retrieve certificates using the general dirmngr
1656    callback service.  R_CRLISSUER returns an allocated string with the
1657    crl-issuer DN, THIS_UPDATE and NEXT_UPDATE are filled with the
1658    corresponding data from the CRL.  Note that these values might get
1659    set even if the CRL processing fails at a later step; thus the
1660    caller should free *R_ISSUER even if the function returns with an
1661    error.  R_TRUST_ANCHOR is set on exit to NULL or a string with the
1662    hexified fingerprint of the root certificate, if checking this
1663    certificate for trustiness is required.
1664 */ 
1665 static int 
1666 crl_parse_insert (ctrl_t ctrl, ksba_crl_t crl,
1667                   struct cdb_make *cdb, const char *fname,
1668                   char **r_crlissuer,
1669                   ksba_isotime_t thisupdate, ksba_isotime_t nextupdate,
1670                   char **r_trust_anchor)
1671 {  
1672   gpg_error_t err;
1673   ksba_stop_reason_t stopreason;
1674   ksba_cert_t crlissuer_cert = NULL;
1675   gcry_md_hd_t md = NULL;
1676   int algo = 0;
1677   size_t n;
1678   
1679   (void)fname;
1680
1681   *r_crlissuer = NULL;
1682   *thisupdate = *nextupdate = 0;
1683   *r_trust_anchor = NULL;
1684
1685   /* Start of the KSBA parser loop. */
1686   do
1687     {
1688       err = ksba_crl_parse (crl, &stopreason);
1689       if (err)
1690         {
1691           log_error (_("ksba_crl_parse failed: %s\n"), gpg_strerror (err) );
1692           goto failure;
1693         }
1694
1695       switch (stopreason)
1696         {
1697         case KSBA_SR_BEGIN_ITEMS:
1698           {
1699             if (start_sig_check (crl, &md, &algo ))
1700               goto failure;
1701           
1702             err = ksba_crl_get_update_times (crl, thisupdate, nextupdate);
1703             if (err)
1704               {
1705                 log_error (_("error getting update times of CRL: %s\n"),
1706                            gpg_strerror (err));   
1707                 err = gpg_error (GPG_ERR_INV_CRL);
1708                 goto failure;
1709               }
1710
1711             if (opt.verbose || !*nextupdate)
1712               log_info (_("update times of this CRL: this=%s next=%s\n"), 
1713                         thisupdate, nextupdate);   
1714             if (!*nextupdate)
1715               {
1716                 log_info (_("nextUpdate not given; "
1717                             "assuming a validity period of one day\n"));
1718                 gnupg_copy_time (nextupdate, thisupdate);
1719                 add_seconds_to_isotime (nextupdate, 86400);
1720               }
1721           }
1722           break;
1723       
1724         case KSBA_SR_GOT_ITEM:
1725           {
1726             ksba_sexp_t serial;
1727             const unsigned char *p;
1728             ksba_isotime_t rdate;
1729             ksba_crl_reason_t reason;
1730             int rc;
1731             unsigned char record[1+15];
1732
1733             err = ksba_crl_get_item (crl, &serial, rdate, &reason);
1734             if (err)
1735               {
1736                 log_error (_("error getting CRL item: %s\n"),
1737                            gpg_strerror (err));
1738                 err = gpg_error (GPG_ERR_INV_CRL);
1739                 ksba_free (serial);
1740                 goto failure;
1741               }
1742             p = serial_to_buffer (serial, &n);
1743             if (!p)
1744               BUG ();
1745             record[0] = (reason & 0xff);
1746             memcpy (record+1, rdate, 15); 
1747             rc = cdb_make_add (cdb, p, n, record, 1+15);
1748             if (rc)
1749               {
1750                 err = gpg_error_from_errno (errno);
1751                 log_error (_("error inserting item into "
1752                              "temporary cache file: %s\n"),
1753                            strerror (errno));
1754                 goto failure;
1755               }
1756
1757             ksba_free (serial);
1758           }
1759           break;
1760       
1761         case KSBA_SR_END_ITEMS:
1762           break;
1763       
1764         case KSBA_SR_READY:
1765           {
1766             char *crlissuer;
1767             ksba_name_t authid;
1768             ksba_sexp_t authidsn;
1769             ksba_sexp_t keyid;
1770
1771             /* We need to look for the issuer only after having read
1772                all items.  The issuer itselfs comes before the items
1773                but the optional authorityKeyIdentifier comes after the
1774                items. */
1775             err = ksba_crl_get_issuer (crl, &crlissuer);
1776             if( err )
1777               {
1778                 log_error (_("no CRL issuer found in CRL: %s\n"),
1779                            gpg_strerror (err) );
1780                 err = gpg_error (GPG_ERR_INV_CRL);
1781                 goto failure;
1782               }
1783             /* Note: This should be released by ksba_free, not xfree.
1784                May need a memory reallocation dance.  */
1785             *r_crlissuer = crlissuer; /* (Do it here so we don't need
1786                                          to free it later) */
1787
1788             if (!ksba_crl_get_auth_key_id (crl, &keyid, &authid, &authidsn))
1789               {
1790                 const char *s;
1791
1792                 if (opt.verbose)
1793                   log_info (_("locating CRL issuer certificate by "
1794                               "authorityKeyIdentifier\n"));
1795                 
1796                 s = ksba_name_enum (authid, 0);
1797                 if (s && *authidsn)
1798                   crlissuer_cert = find_cert_bysn (ctrl, s, authidsn);
1799                 if (!crlissuer_cert && keyid)
1800                   crlissuer_cert = find_cert_bysubject (ctrl,
1801                                                         crlissuer, keyid);
1802
1803                 if (!crlissuer_cert)
1804                   {
1805                     log_info ("CRL issuer certificate ");
1806                     if (keyid)
1807                       {
1808                         log_printf ("{");
1809                         dump_serial (keyid);
1810                         log_printf ("} ");
1811                       }
1812                     if (authidsn)
1813                       {
1814                         log_printf ("(#");
1815                         dump_serial (authidsn);
1816                         log_printf ("/");
1817                         dump_string (s);
1818                         log_printf (") ");
1819                       }
1820                     log_printf ("not found\n");
1821                   }
1822                 ksba_name_release (authid);
1823                 xfree (authidsn);
1824                 xfree (keyid);
1825               }
1826             else
1827               crlissuer_cert = find_cert_bysubject (ctrl, crlissuer, NULL);
1828             err = 0;
1829             if (!crlissuer_cert)
1830               {
1831                 err = gpg_error (GPG_ERR_MISSING_CERT);
1832                 goto failure;
1833               }
1834         
1835             err = finish_sig_check (crl, md, algo, crlissuer_cert);
1836             if (err)
1837               {
1838                 log_error (_("CRL signature verification failed: %s\n"), 
1839                            gpg_strerror (err));
1840                 goto failure;
1841               }
1842             md = NULL;
1843
1844             err = validate_cert_chain (ctrl, crlissuer_cert, NULL,
1845                                        VALIDATE_MODE_CRL_RECURSIVE,
1846                                        r_trust_anchor);
1847             if (err)
1848               {
1849                 log_error (_("error checking validity of CRL "
1850                              "issuer certificate: %s\n"), 
1851                            gpg_strerror (err));
1852                 goto failure;
1853               }
1854
1855           }
1856           break;
1857       
1858         default:
1859           log_debug ("crl_parse_insert: unknown stop reason\n");
1860           err = gpg_error (GPG_ERR_BUG);
1861           goto failure;
1862         }
1863     } 
1864   while (stopreason != KSBA_SR_READY);
1865   assert (!err);
1866
1867
1868  failure:
1869   if (md)
1870     abort_sig_check (crl, md);
1871   ksba_cert_release (crlissuer_cert);
1872   return err;
1873 }
1874
1875
1876
1877 /* Return the crlNumber extension as an allocated hex string or NULL
1878    if there is none. */
1879 static char *
1880 get_crl_number (ksba_crl_t crl)
1881 {
1882   gpg_error_t err;
1883   ksba_sexp_t number;
1884   char *string;
1885
1886   err = ksba_crl_get_crl_number (crl, &number);
1887   if (err)
1888     return NULL;
1889   string = serial_hex (number);
1890   ksba_free (number);
1891   return string;
1892 }
1893
1894
1895 /* Return the authorityKeyIdentifier or NULL if it is not available.
1896    The issuer name may consists of several parts - they are delimted by
1897    0x01. */
1898 static char *
1899 get_auth_key_id (ksba_crl_t crl, char **serialno)
1900 {
1901   gpg_error_t err;
1902   ksba_name_t name;
1903   ksba_sexp_t sn;
1904   int idx;
1905   const char *s;
1906   char *string;
1907   size_t length;
1908
1909   *serialno = NULL;
1910   err = ksba_crl_get_auth_key_id (crl, NULL, &name, &sn);
1911   if (err)
1912     return NULL;
1913   *serialno = serial_hex (sn);
1914   ksba_free (sn);
1915
1916   if (!name)
1917     return xstrdup ("");
1918   
1919   length = 0;
1920   for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
1921     {
1922       char *p = ksba_name_get_uri (name, idx);
1923       length += strlen (p?p:s) + 1;
1924       xfree (p);
1925     }
1926   string = xtrymalloc (length+1);
1927   if (string)
1928     {
1929       *string = 0;
1930       for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
1931         {
1932           char *p = ksba_name_get_uri (name, idx);
1933           if (*string)
1934             strcat (string, "\x01");
1935           strcat (string, p?p:s);
1936           xfree (p);
1937         }
1938     }
1939   ksba_name_release (name);
1940   return string;
1941 }
1942
1943
1944
1945 /* Insert the CRL retrieved using URL into the cache specified by
1946    CACHE.  The CRL itself will be read from the stream FP and is
1947    expected in binary format. */
1948 gpg_error_t
1949 crl_cache_insert (ctrl_t ctrl, const char *url, ksba_reader_t reader)
1950 {
1951   crl_cache_t cache = get_current_cache ();
1952   gpg_error_t err, err2;
1953   ksba_crl_t crl;
1954   char *fname = NULL;
1955   char *newfname = NULL;
1956   struct cdb_make cdb;
1957   int fd_cdb = -1;
1958   char *issuer = NULL;
1959   char *issuer_hash = NULL;
1960   ksba_isotime_t thisupdate, nextupdate;
1961   crl_cache_entry_t entry = NULL;
1962   crl_cache_entry_t e;
1963   gnupg_isotime_t current_time;
1964   char *checksum = NULL;
1965   int invalidate_crl = 0;
1966   int idx;
1967   const char *oid;
1968   int critical;
1969   char *trust_anchor = NULL;
1970
1971   /* FIXME: We should acquire a mutex for the URL, so that we don't
1972      simultaneously enter the same CRL twice.  However this needs to be
1973      interweaved with the checking function.*/
1974  
1975   err2 = 0;
1976
1977   err = ksba_crl_new (&crl);
1978   if (err)
1979     {
1980       log_error (_("ksba_crl_new failed: %s\n"), gpg_strerror (err));
1981       goto leave;
1982     }
1983   
1984   err = ksba_crl_set_reader (crl, reader);
1985   if ( err )
1986     {
1987       log_error (_("ksba_crl_set_reader failed: %s\n"), gpg_strerror (err));
1988       goto leave;
1989     }
1990
1991   /* Create a temporary cache file to load the CRL into. */
1992   {
1993     char *tmpfname, *p;
1994     const char *nodename;
1995 #ifndef HAVE_W32_SYSTEM
1996     struct utsname utsbuf;
1997 #endif
1998
1999 #ifdef HAVE_W32_SYSTEM
2000     nodename = "unknown";
2001 #else
2002     if (uname (&utsbuf))
2003       nodename = "unknown";
2004     else
2005       nodename = utsbuf.nodename;
2006 #endif
2007
2008     estream_asprintf (&tmpfname, "crl-tmp-%s-%u-%p.db.tmp",
2009                       nodename, (unsigned int)getpid (), &tmpfname);
2010     if (!tmpfname)
2011       {
2012         err = gpg_error_from_syserror ();
2013         goto leave;
2014       }
2015     for (p=tmpfname; *p; p++)
2016       if (*p == '/')
2017         *p = '.';
2018     fname = make_filename (opt.homedir_cache, DBDIR_D, tmpfname, NULL);
2019     xfree (tmpfname);
2020     if (!remove (fname))
2021       log_info (_("removed stale temporary cache file `%s'\n"), fname);
2022     else if (errno != ENOENT) 
2023       {
2024         err = gpg_error_from_syserror ();
2025         log_error (_("problem removing stale temporary cache file `%s': %s\n"),
2026                    fname, gpg_strerror (err));
2027         goto leave;
2028       }
2029   }
2030
2031   fd_cdb = open (fname, O_WRONLY | O_CREAT | O_TRUNC, 0644);
2032   if (fd_cdb == -1)
2033     {
2034       err = gpg_error_from_errno (errno);
2035       log_error (_("error creating temporary cache file `%s': %s\n"),
2036                  fname, strerror (errno));
2037       goto leave;
2038     }
2039   cdb_make_start(&cdb, fd_cdb);
2040
2041   err = crl_parse_insert (ctrl, crl, &cdb, fname,
2042                           &issuer, thisupdate, nextupdate, &trust_anchor);
2043   if (err)
2044     {
2045       log_error (_("crl_parse_insert failed: %s\n"), gpg_strerror (err));
2046       /* Error in cleanup ignored.  */
2047       cdb_make_finish (&cdb);
2048       goto leave;
2049     }
2050
2051   /* Finish the database. */
2052   if (cdb_make_finish (&cdb))
2053     {
2054       err = gpg_error_from_errno (errno);
2055       log_error (_("error finishing temporary cache file `%s': %s\n"),
2056                  fname, strerror (errno));
2057       goto leave;
2058     }
2059   if (close (fd_cdb))
2060     {
2061       err = gpg_error_from_errno (errno);
2062       log_error (_("error closing temporary cache file `%s': %s\n"),
2063                  fname, strerror (errno));
2064       goto leave;
2065     }
2066   fd_cdb = -1;
2067
2068
2069   /* Create a checksum. */
2070   {
2071     unsigned char md5buf[16];
2072
2073     if (hash_dbfile (fname, md5buf))
2074       {
2075         err = gpg_error (GPG_ERR_CHECKSUM);
2076         goto leave;
2077       }
2078     checksum = hexify_data (md5buf, 16);
2079   }
2080
2081
2082   /* Check whether that new CRL is still not expired. */
2083   gnupg_get_isotime (current_time);
2084   if (strcmp (nextupdate, current_time) < 0 )
2085     {
2086       if (opt.force)
2087         log_info (_("WARNING: new CRL still too old; it expired on %s "
2088                     "- loading anyway\n"),  nextupdate);
2089       else
2090         {
2091           log_error (_("new CRL still too old; it expired on %s\n"),
2092                      nextupdate);
2093           if (!err2)
2094             err2 = gpg_error (GPG_ERR_CRL_TOO_OLD);
2095           invalidate_crl |= 1;
2096         }
2097     }
2098
2099   /* Check for unknown critical extensions. */
2100   for (idx=0; !(err=ksba_crl_get_extension (crl, idx, &oid, &critical,
2101                                               NULL, NULL)); idx++)
2102     {
2103       if (!critical
2104           || !strcmp (oid, oidstr_authorityKeyIdentifier)
2105           || !strcmp (oid, oidstr_crlNumber) )
2106         continue;
2107       log_error (_("unknown critical CRL extension %s\n"), oid);
2108       if (!err2)
2109         err2 = gpg_error (GPG_ERR_INV_CRL);
2110       invalidate_crl |= 2;
2111     }
2112   if (gpg_err_code (err) == GPG_ERR_EOF 
2113       || gpg_err_code (err) == GPG_ERR_NO_DATA )
2114     err = 0;
2115   if (err)
2116     {
2117       log_error (_("error reading CRL extensions: %s\n"), gpg_strerror (err));
2118       err = gpg_error (GPG_ERR_INV_CRL);
2119     }
2120
2121
2122   /* Create an hex encoded SHA-1 hash of the issuer DN to be
2123      used as the key for the cache. */
2124   issuer_hash = hashify_data (issuer, strlen (issuer));
2125
2126   /* Create an ENTRY. */
2127   entry = xtrycalloc (1, sizeof *entry);
2128   if (!entry)
2129     {
2130       err = gpg_error_from_syserror ();
2131       goto leave;
2132     }
2133   entry->release_ptr = xtrymalloc (strlen (issuer_hash) + 1 
2134                                    + strlen (issuer) + 1
2135                                    + strlen (url) + 1 
2136                                    + strlen (checksum) + 1);
2137   if (!entry->release_ptr)
2138     {
2139       err = gpg_error_from_syserror ();
2140       xfree (entry);
2141       entry = NULL;
2142       goto leave;
2143     }
2144   entry->issuer_hash = entry->release_ptr;
2145   entry->issuer = stpcpy (entry->issuer_hash, issuer_hash) + 1;
2146   entry->url = stpcpy (entry->issuer, issuer) + 1;
2147   entry->dbfile_hash = stpcpy (entry->url, url) + 1;
2148   strcpy (entry->dbfile_hash, checksum);
2149   gnupg_copy_time (entry->this_update, thisupdate); 
2150   gnupg_copy_time (entry->next_update, nextupdate); 
2151   gnupg_copy_time (entry->last_refresh, current_time);
2152   entry->crl_number = get_crl_number (crl);
2153   entry->authority_issuer = get_auth_key_id (crl, &entry->authority_serialno);
2154   entry->invalid = invalidate_crl;
2155   entry->user_trust_req = !!trust_anchor;
2156   entry->check_trust_anchor = trust_anchor;
2157   trust_anchor = NULL;
2158
2159   /* Check whether we already have an entry for this issuer and mark
2160      it as deleted. We better use a loop, just in case duplicates got
2161      somehow into the list. */
2162   for (e = cache->entries; (e=find_entry (e, entry->issuer_hash)); e = e->next)
2163     e->deleted = 1;
2164   
2165   /* Rename the temporary DB to the real name. */
2166   newfname = make_db_file_name (entry->issuer_hash);
2167   if (opt.verbose)
2168     log_info (_("creating cache file `%s'\n"), newfname);
2169 #ifdef HAVE_W32_SYSTEM
2170   unlink (newfname);
2171 #endif
2172   if (rename (fname, newfname))
2173     {
2174       err = gpg_error_from_syserror ();
2175       log_error (_("problem renaming `%s' to `%s': %s\n"),
2176                  fname, newfname, gpg_strerror (err));
2177       goto leave;
2178     }
2179   xfree (fname); fname = NULL; /*(let the cleanup code not try to remove it)*/
2180
2181   /* Link the new entry in. */
2182   entry->next = cache->entries;
2183   cache->entries = entry;
2184   entry = NULL;
2185
2186   err = update_dir (cache);
2187   if (err)
2188     {
2189       log_error (_("updating the DIR file failed - "
2190                    "cache entry will get lost with the next program start\n"));
2191       err = 0; /* Keep on running. */
2192     }
2193
2194
2195  leave:
2196   release_one_cache_entry (entry);
2197   if (fd_cdb != -1)
2198     close (fd_cdb);
2199   if (fname)
2200     {
2201       remove (fname);
2202       xfree (fname);
2203     }
2204   xfree (newfname);
2205   ksba_crl_release (crl);
2206   xfree (issuer);
2207   xfree (issuer_hash);
2208   xfree (checksum);
2209   xfree (trust_anchor);
2210   return err ? err : err2;
2211 }
2212
2213
2214 /* Print one cached entry E in a human readable format to stream
2215    FP. Return 0 on success. */
2216 static gpg_error_t
2217 list_one_crl_entry (crl_cache_t cache, crl_cache_entry_t e, FILE *fp)
2218 {
2219   struct cdb_find cdbfp;
2220   struct cdb *cdb;
2221   int rc;
2222   int warn = 0;
2223   const unsigned char *s;
2224
2225   fputs ("--------------------------------------------------------\n", fp );
2226   fprintf (fp, _("Begin CRL dump (retrieved via %s)\n"), e->url );
2227   fprintf (fp, " Issuer:\t%s\n", e->issuer );
2228   fprintf (fp, " Issuer Hash:\t%s\n", e->issuer_hash );
2229   fprintf (fp, " This Update:\t%s\n", e->this_update ); 
2230   fprintf (fp, " Next Update:\t%s\n", e->next_update ); 
2231   fprintf (fp, " CRL Number :\t%s\n", e->crl_number? e->crl_number: "none");
2232   fprintf (fp, " AuthKeyId  :\t%s\n",
2233            e->authority_serialno? e->authority_serialno:"none");
2234   if (e->authority_serialno && e->authority_issuer)
2235     {
2236       fputs ("             \t", fp);
2237       for (s=e->authority_issuer; *s; s++)
2238         if (*s == '\x01')
2239           fputs ("\n             \t", fp);
2240         else
2241           putc (*s, fp);
2242       putc ('\n', fp);
2243     }
2244   fprintf (fp, " Trust Check:\t%s\n", 
2245            !e->user_trust_req? "[system]" :
2246            e->check_trust_anchor? e->check_trust_anchor:"[missing]");
2247
2248   if ((e->invalid & 1))
2249     fprintf (fp, _(" ERROR: The CRL will not be used because it was still too old after an update!\n"));
2250   if ((e->invalid & 2))
2251     fprintf (fp, _(" ERROR: The CRL will not be used due to an unknown critical extension!\n"));
2252   if ((e->invalid & ~3))
2253     fprintf (fp, _(" ERROR: The CRL will not be used\n"));
2254
2255   cdb = lock_db_file (cache, e);
2256   if (!cdb)
2257     return gpg_error (GPG_ERR_GENERAL);
2258
2259   if (!e->dbfile_checked)
2260     fprintf (fp, _(" ERROR: This cached CRL may has been tampered with!\n"));
2261
2262   putc ('\n', fp);
2263
2264   rc = cdb_findinit (&cdbfp, cdb, NULL, 0);
2265   while (!rc && (rc=cdb_findnext (&cdbfp)) > 0 )
2266     {
2267       unsigned char keyrecord[256];
2268       unsigned char record[16];
2269       int reason;
2270       int any = 0;
2271       cdbi_t n;
2272       cdbi_t i;
2273
2274       rc = 0;
2275       n = cdb_datalen (cdb);
2276       if (n != 16)
2277         {
2278           log_error (_(" WARNING: invalid cache record length\n"));
2279           warn = 1;
2280           continue;
2281         }
2282
2283       if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
2284         {
2285           log_error (_("problem reading cache record: %s\n"),
2286                      strerror (errno));
2287           warn = 1;
2288           continue;
2289         }
2290     
2291       n = cdb_keylen (cdb);
2292       if (n > sizeof keyrecord)
2293         n = sizeof keyrecord;
2294       if (cdb_read (cdb, keyrecord, n, cdb_keypos (cdb)))
2295         {
2296           log_error (_("problem reading cache key: %s\n"), strerror (errno));
2297           warn = 1;
2298           continue;
2299         }
2300
2301       reason = *record;
2302       fputs ("  ", fp);
2303       for (i = 0; i < n; i++)
2304         fprintf (fp, "%02X", keyrecord[i]);
2305       fputs (":\t reasons( ", fp);
2306     
2307       if (reason & KSBA_CRLREASON_UNSPECIFIED)
2308         fputs( "unspecified ", fp ), any = 1;
2309       if (reason & KSBA_CRLREASON_KEY_COMPROMISE )
2310         fputs( "key_compromise ", fp ), any = 1; 
2311       if (reason & KSBA_CRLREASON_CA_COMPROMISE )
2312         fputs( "ca_compromise ", fp ), any = 1; 
2313       if (reason & KSBA_CRLREASON_AFFILIATION_CHANGED )
2314         fputs( "affiliation_changed ", fp ), any = 1; 
2315       if (reason & KSBA_CRLREASON_SUPERSEDED )
2316         fputs( "superseeded", fp ), any = 1; 
2317       if (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION )
2318         fputs( "cessation_of_operation", fp ), any = 1; 
2319       if (reason & KSBA_CRLREASON_CERTIFICATE_HOLD )
2320         fputs( "certificate_hold", fp ), any = 1; 
2321       if (reason && !any)
2322         fputs( "other", fp ); 
2323       
2324       fprintf (fp, ") rdate: %.15s\n", record+1);
2325     } 
2326   if (rc)
2327     log_error (_("error reading cache entry from db: %s\n"), strerror (rc));
2328
2329   unlock_db_file (cache, e);
2330   fprintf (fp, _("End CRL dump\n") );
2331   putc ('\n', fp);
2332
2333   return (rc||warn)? gpg_error (GPG_ERR_GENERAL) : 0;
2334 }
2335
2336
2337 /* Print the contents of the CRL CACHE in a human readable format to
2338    stream FP. */
2339 gpg_error_t 
2340 crl_cache_list (FILE *fp) 
2341 {
2342   crl_cache_t cache = get_current_cache ();
2343   crl_cache_entry_t entry;
2344   gpg_error_t err = 0;
2345
2346   for (entry = cache->entries;
2347        entry && !entry->deleted && !err;
2348        entry = entry->next ) 
2349     err = list_one_crl_entry (cache, entry, fp);
2350
2351   return err;
2352 }
2353
2354
2355 /* Load the CRL containing the file named FILENAME into our CRL cache. */
2356 gpg_error_t
2357 crl_cache_load (ctrl_t ctrl, const char *filename)
2358 {
2359   gpg_error_t err;
2360   FILE *fp;
2361   ksba_reader_t reader;
2362
2363   fp = fopen (filename, "r");
2364   if (!fp)
2365     {
2366       err = gpg_error_from_errno (errno);
2367       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
2368       return err;
2369     }
2370
2371   err = ksba_reader_new (&reader);
2372   if (!err)
2373     err = ksba_reader_set_file (reader, fp);
2374   if (err)
2375     {
2376       log_error (_("error initializing reader object: %s\n"),
2377                  gpg_strerror (err));
2378       ksba_reader_release (reader);
2379       return err;
2380     }
2381   err = crl_cache_insert (ctrl, filename, reader);
2382   ksba_reader_release (reader);
2383   fclose (fp);
2384   return err;
2385 }
2386
2387
2388 /* Locate the corresponding CRL for the certificate CERT, read and
2389    verify the CRL and store it in the cache.  */
2390 gpg_error_t
2391 crl_cache_reload_crl (ctrl_t ctrl, ksba_cert_t cert) 
2392 {
2393   gpg_error_t err;
2394   ksba_reader_t reader = NULL;
2395   char *issuer = NULL;
2396   ksba_name_t distpoint = NULL;
2397   ksba_name_t issuername = NULL;
2398   char *distpoint_uri = NULL;
2399   char *issuername_uri = NULL;
2400   int any_dist_point = 0;
2401   int seq;
2402
2403   /* Loop over all distribution points, get the CRLs and put them into
2404      the cache. */
2405   if (opt.verbose)
2406     log_info ("checking distribution points\n");
2407   seq = 0;
2408   while ( !(err = ksba_cert_get_crl_dist_point (cert, seq++,
2409                                                 &distpoint,
2410                                                 &issuername, NULL )))
2411     {
2412       int name_seq; 
2413       gpg_error_t last_err = 0;
2414
2415       if (!distpoint && !issuername)
2416         {
2417           if (opt.verbose)
2418             log_info ("no issuer name and no distribution point\n");
2419           break; /* Not allowed; i.e. an invalid certificate.  We give
2420                     up here and hope that the default method returns a
2421                     suitable CRL. */
2422         }
2423
2424       xfree (issuername_uri); issuername_uri = NULL;
2425
2426       /* Get the URIs.  We do this in a loop to iterate over all names
2427          in the crlDP. */
2428       for (name_seq=0; ksba_name_enum (distpoint, name_seq); name_seq++)
2429         {
2430           xfree (distpoint_uri); distpoint_uri = NULL;
2431           distpoint_uri = ksba_name_get_uri (distpoint, name_seq);
2432           if (!distpoint_uri)
2433             continue;
2434           
2435           if (!strncmp (distpoint_uri, "ldap:", 5)
2436               || !strncmp (distpoint_uri, "ldaps:", 6))
2437             {
2438               if (opt.ignore_ldap_dp)
2439                 continue;
2440             }
2441           else if (!strncmp (distpoint_uri, "http:", 5)
2442                    || !strncmp (distpoint_uri, "https:", 6))
2443             {
2444               if (opt.ignore_http_dp)
2445                 continue;
2446             }
2447           else
2448             continue; /* Skip unknown schemes. */
2449           
2450           any_dist_point = 1;
2451           
2452           if (opt.verbose)
2453             log_info ("fetching CRL from `%s'\n", distpoint_uri);
2454           err = crl_fetch (ctrl, distpoint_uri, &reader);
2455           if (err)
2456             {
2457               log_error (_("crl_fetch via DP failed: %s\n"),
2458                          gpg_strerror (err));
2459               last_err = err;
2460               continue; /* with the next name. */
2461             }
2462           
2463           if (opt.verbose)
2464             log_info ("inserting CRL (reader %p)\n", reader);
2465           err = crl_cache_insert (ctrl, distpoint_uri, reader); 
2466           if (err)
2467             {
2468               log_error (_("crl_cache_insert via DP failed: %s\n"),
2469                          gpg_strerror (err));
2470               last_err = err;
2471               continue; /* with the next name. */
2472             }
2473           last_err = 0;
2474           break; /* Ready. */
2475         }
2476       if (last_err)
2477         {
2478           err = last_err;
2479           goto leave;
2480         }
2481       
2482       ksba_name_release (distpoint); distpoint = NULL;
2483
2484       /* We don't do anything with issuername_uri yet but we keep the
2485          code for documentation. */
2486       issuername_uri =  ksba_name_get_uri (issuername, 0); 
2487       ksba_name_release (issuername); issuername = NULL;
2488
2489     }
2490   if (gpg_err_code (err) == GPG_ERR_EOF)
2491     err = 0;
2492
2493   /* If we did not found any distpoint, try something reasonable. */
2494   if (!any_dist_point )
2495     {
2496       if (opt.verbose)
2497         log_info ("no distribution point - trying issuer name\n");
2498       
2499       if (reader)
2500         {
2501           crl_close_reader (reader);
2502           reader = NULL;
2503         }
2504
2505       issuer = ksba_cert_get_issuer (cert, 0);
2506       if (!issuer) 
2507         {
2508           log_error ("oops: issuer missing in certificate\n");
2509           err = gpg_error (GPG_ERR_INV_CERT_OBJ); 
2510           goto leave;
2511         }
2512
2513       if (opt.verbose)
2514         log_info ("fetching CRL from default location\n");
2515       err = crl_fetch_default (ctrl, issuer, &reader);
2516       if (err)
2517           {
2518             log_error ("crl_fetch via issuer failed: %s\n",
2519                        gpg_strerror (err));
2520             goto leave;
2521           }
2522
2523       if (opt.verbose)
2524         log_info ("inserting CRL (reader %p)\n", reader);
2525       err = crl_cache_insert (ctrl, "default location(s)", reader);
2526       if (err)
2527         {
2528           log_error (_("crl_cache_insert via issuer failed: %s\n"),
2529                      gpg_strerror (err));
2530           goto leave;
2531         }
2532     }
2533
2534  leave:
2535   if (reader)
2536     crl_close_reader (reader);
2537   xfree (distpoint_uri);
2538   xfree (issuername_uri);
2539   ksba_name_release (distpoint); 
2540   ksba_name_release (issuername); 
2541   ksba_free (issuer);
2542   return err;
2543 }
2544