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