gpg: Fix NULL-segv for missing tofu DB.
[gnupg.git] / g10 / tofu.c
1 /* tofu.c - TOFU trust model.
2  * Copyright (C) 2015 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* TODO:
21
22    - Format the fingerprints nicely when printing (similar to gpg
23      --list-keys)
24  */
25
26 #include <config.h>
27 #include <stdio.h>
28 #include <sys/stat.h>
29 #include <assert.h>
30 #include <stdarg.h>
31 #include <sched.h>
32 #include <sqlite3.h>
33
34 #include "gpg.h"
35 #include "types.h"
36 #include "logging.h"
37 #include "stringhelp.h"
38 #include "options.h"
39 #include "mbox-util.h"
40 #include "i18n.h"
41 #include "ttyio.h"
42 #include "trustdb.h"
43 #include "mkdir_p.h"
44 #include "sqlite.h"
45
46 #include "tofu.h"
47
48
49 #define CONTROL_L ('L' - 'A' + 1)
50
51
52 #define DEBUG_TOFU_CACHE 0
53 #if DEBUG_TOFU_CACHE
54 static int prepares_saved;
55 static int queries;
56 #endif
57
58 /* The TOFU data can be saved in two different formats: either in a
59    single combined database (opt.tofu_db_format == TOFU_DB_FLAT) or in
60    a split file format (opt.tofu_db_format == TOFU_DB_SPLIT).  In the
61    split format, there is one database per normalized email address
62    (DB_EMAIL) and one per key (DB_KEY).  */
63 enum db_type
64   {
65     DB_COMBINED,
66     DB_EMAIL,
67     DB_KEY
68   };
69
70 /* A list of open DBs.
71
72    In the flat format, this consists of a single element with the type
73    DB_COMBINED and whose name is the empty string.
74
75    In the split format, the first element is a dummy element (DB is
76    NULL) whose type is DB_COMBINED and whose name is the empty string.
77    Any following elements describe either DB_EMAIL or DB_KEY DBs.  In
78    theis case, NAME is either the normalized email address or the
79    fingerprint.
80
81    To initialize this data structure, call opendbs().  When you are
82    done, clean it up using closedbs().  To get a handle to a database,
83    use the getdb() function.  This will either return an existing
84    handle or open a new DB connection, as appropriate.  */
85 struct db
86 {
87   struct db *next;
88   struct db **prevp;
89
90   enum db_type type;
91
92   sqlite3 *db;
93
94   struct
95   {
96     sqlite3_stmt *savepoint_batch;
97     sqlite3_stmt *savepoint_batch_commit;
98
99     sqlite3_stmt *savepoint_inner;
100     sqlite3_stmt *savepoint_inner_commit;
101
102     sqlite3_stmt *record_binding_get_old_policy;
103     sqlite3_stmt *record_binding_update;
104     sqlite3_stmt *record_binding_update2;
105     sqlite3_stmt *get_policy_select_policy_and_conflict;
106     sqlite3_stmt *get_trust_bindings_with_this_email;
107     sqlite3_stmt *get_trust_gather_other_user_ids;
108     sqlite3_stmt *get_trust_gather_other_keys;
109     sqlite3_stmt *register_already_seen;
110     sqlite3_stmt *register_insert;
111   } s;
112
113 #if DEBUG_TOFU_CACHE
114   int hits;
115 #endif
116
117   int batch_update;
118
119   /* If TYPE is DB_COMBINED, this is "".  Otherwise, it is either the
120      fingerprint (type == DB_KEY) or the normalized email address
121      (type == DB_EMAIL).  */
122   char name[1];
123 };
124
125 static struct db *db_cache;
126 static int db_cache_count;
127 #define DB_CACHE_ENTRIES 16
128
129 static void tofu_cache_dump (struct db *db) GPGRT_ATTR_USED;
130
131 static void
132 tofu_cache_dump (struct db *db)
133 {
134   log_info ("Connection %p:\n", db);
135   for (; db; db = db->next)
136     log_info ("  %s: %sbatch mode\n", db->name, db->batch_update ? "" : "NOT ");
137   log_info ("Cache:\n");
138   for (db = db_cache; db; db = db->next)
139     log_info ("  %s: %sbatch mode\n", db->name, db->batch_update ? "" : "NOT ");
140 }
141
142 #define STRINGIFY(s) STRINGIFY2(s)
143 #define STRINGIFY2(s) #s
144
145 /* The grouping parameters when collecting signature statistics.  */
146
147 /* If a message is signed a couple of hours in the future, just assume
148    some clock skew.  */
149 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
150 #if 0
151 #  define TIME_AGO_UNIT_SMALL 60
152 #  define TIME_AGO_MEDIUM_THRESHOLD (60 * TIME_AGO_UNIT_SMALL)
153 #  define TIME_AGO_UNIT_MEDIUM (60 * 60)
154 #  define TIME_AGO_LARGE_THRESHOLD (24 * 60 * TIME_AGO_UNIT_SMALL)
155 #  define TIME_AGO_UNIT_LARGE (24 * 60 * 60)
156 #else
157 #  define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
158 #  define TIME_AGO_MEDIUM_THRESHOLD (4 * TIME_AGO_UNIT_SMALL)
159 #  define TIME_AGO_UNIT_MEDIUM (7 * 24 * 60 * 60)
160 #  define TIME_AGO_LARGE_THRESHOLD (28 * TIME_AGO_UNIT_SMALL)
161 #  define TIME_AGO_UNIT_LARGE (30 * 24 * 60 * 60)
162 #endif
163
164 \f
165
166 const char *
167 tofu_policy_str (enum tofu_policy policy)
168 {
169   switch (policy)
170     {
171     case TOFU_POLICY_NONE: return "none";
172     case TOFU_POLICY_AUTO: return "auto";
173     case TOFU_POLICY_GOOD: return "good";
174     case TOFU_POLICY_UNKNOWN: return "unknown";
175     case TOFU_POLICY_BAD: return "bad";
176     case TOFU_POLICY_ASK: return "ask";
177     default: return "???";
178     }
179 }
180
181 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
182    (e.g., TRUST_BAD) in light of the current configuration.  */
183 int
184 tofu_policy_to_trust_level (enum tofu_policy policy)
185 {
186   if (policy == TOFU_POLICY_AUTO)
187     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
188     policy = opt.tofu_default_policy;
189
190   switch (policy)
191     {
192     case TOFU_POLICY_AUTO:
193       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
194          to marginal trust.  */
195       return TRUST_MARGINAL;
196     case TOFU_POLICY_GOOD:
197       return TRUST_FULLY;
198     case TOFU_POLICY_UNKNOWN:
199       return TRUST_UNKNOWN;
200     case TOFU_POLICY_BAD:
201       return TRUST_NEVER;
202     case TOFU_POLICY_ASK:
203       return TRUST_UNKNOWN;
204     default:
205       log_bug ("Bad value for trust policy: %d\n",
206                opt.tofu_default_policy);
207       return 0;
208     }
209 }
210 \f
211 static int batch_update;
212 static time_t batch_update_started;
213
214 static gpg_error_t end_transaction (struct db *db, int only_batch);
215
216 /* Start a transaction on DB.  */
217 static gpg_error_t
218 begin_transaction (struct db *db, int only_batch)
219 {
220   int rc;
221   char *err = NULL;
222
223   if (batch_update && batch_update_started != gnupg_get_time ())
224     /* We've been in batch update mode for a while (on average, more
225        than 500 ms).  To prevent starving other gpg processes, we drop
226        and retake the batch lock.
227
228        Note: if we wanted higher resolution, we could use
229        npth_clock_gettime.  */
230     {
231       struct db *t;
232
233       for (t = db_cache; t; t = t->next)
234         if (t->batch_update)
235           end_transaction (t, 1);
236       for (t = db; t; t = t->next)
237         if (t->batch_update)
238           end_transaction (t, 1);
239
240       batch_update_started = gnupg_get_time ();
241
242       /* Yield to allow another process a chance to run.  */
243       sched_yield ();
244     }
245
246   /* XXX: In split mode, this can end in deadlock.
247
248      Consider: we have two gpg processes running simultaneously and
249      they each want to lock DB A and B, but in different orders.  This
250      will be automatically resolved by causing one of them to return
251      EBUSY and aborting.
252
253      A more intelligent approach would be to commit and retake the
254      batch transaction.  This requires a list of all DBs that are
255      currently in batch mode.  */
256
257   if (batch_update && ! db->batch_update)
258     {
259       rc = sqlite3_stepx (db->db, &db->s.savepoint_batch,
260                           NULL, NULL, &err,
261                           "savepoint batch;", SQLITE_ARG_END);
262       if (rc)
263         {
264           log_error (_("error beginning transaction on TOFU database: %s\n"),
265                      err);
266           print_further_info ("batch, database '%s'",
267                               *db->name ? db->name : "[combined]");
268           sqlite3_free (err);
269           return gpg_error (GPG_ERR_GENERAL);
270         }
271
272       db->batch_update = 1;
273     }
274
275   if (only_batch)
276     return 0;
277
278   rc = sqlite3_stepx (db->db, &db->s.savepoint_inner,
279                       NULL, NULL, &err,
280                       "savepoint inner;", SQLITE_ARG_END);
281   if (rc)
282     {
283       log_error (_("error beginning transaction on TOFU database: %s\n"),
284                  err);
285       print_further_info ("inner, database '%s'",
286                           *db->name ? db->name : "[combined]");
287       sqlite3_free (err);
288       return gpg_error (GPG_ERR_GENERAL);
289     }
290
291   return 0;
292 }
293
294 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
295    batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
296    this ends any open batch transaction even if we are still in batch
297    mode.  */
298 static gpg_error_t
299 end_transaction (struct db *db, int only_batch)
300 {
301   int rc;
302   char *err = NULL;
303
304   if (!db)
305     return 0;  /* Shortcut to allow for easier cleanup code.  */
306
307   if ((! batch_update || only_batch == 2) && db->batch_update)
308     /* The batch transaction is still in open, but we left batch
309        mode.  */
310     {
311       db->batch_update = 0;
312
313       rc = sqlite3_stepx (db->db, &db->s.savepoint_batch_commit,
314                           NULL, NULL, &err,
315                           "release batch;", SQLITE_ARG_END);
316       if (rc)
317         {
318           log_error (_("error committing transaction on TOFU database: %s\n"),
319                      err);
320           print_further_info ("batch, database '%s'",
321                               *db->name ? db->name : "[combined]");
322           sqlite3_free (err);
323           return gpg_error (GPG_ERR_GENERAL);
324         }
325
326       /* Releasing an outer transaction releases an open inner
327          transactions.  We're done.  */
328       return 0;
329     }
330
331   if (only_batch)
332     return 0;
333
334   rc = sqlite3_stepx (db->db, &db->s.savepoint_inner_commit,
335                       NULL, NULL, &err,
336                       "release inner;", SQLITE_ARG_END);
337   if (rc)
338     {
339       log_error (_("error committing transaction on TOFU database: %s\n"),
340                  err);
341       print_further_info ("inner, database '%s'",
342                           *db->name ? db->name : "[combined]");
343       sqlite3_free (err);
344       return gpg_error (GPG_ERR_GENERAL);
345     }
346
347   return 0;
348 }
349
350 static gpg_error_t
351 rollback_transaction (struct db *db)
352 {
353   int rc;
354   char *err = NULL;
355
356   if (!db)
357     return 0;  /* Shortcut to allow for easier cleanup code.  */
358
359   if (db->batch_update)
360     /* Just undo the most recent update; don't revert any progress
361        made by the batch transaction.  */
362     rc = sqlite3_exec (db->db, "rollback to inner;", NULL, NULL, &err);
363   else
364     /* Rollback the whole she-bang.  */
365     rc = sqlite3_exec (db->db, "rollback;", NULL, NULL, &err);
366
367   if (rc)
368     {
369       log_error (_("error rolling back transaction on TOFU database: %s\n"),
370                  err);
371       print_further_info ("inner, database '%s'",
372                           *db->name ? db->name : "[combined]");
373       sqlite3_free (err);
374       return gpg_error (GPG_ERR_GENERAL);
375     }
376
377   return 0;
378 }
379
380 void
381 tofu_begin_batch_update (void)
382 {
383   if (! batch_update)
384     batch_update_started = gnupg_get_time ();
385
386   batch_update ++;
387 }
388
389 void
390 tofu_end_batch_update (void)
391 {
392   assert (batch_update > 0);
393   batch_update --;
394
395   if (batch_update == 0)
396     {
397       struct db *db;
398
399       for (db = db_cache; db; db = db->next)
400         end_transaction (db, 1);
401     }
402 }
403 \f
404 /* Collect results of a select count (*) ...; style query.  Aborts if
405    the argument is not a valid integer (or real of the form X.0).  */
406 static int
407 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
408                              char **azColName)
409 {
410   unsigned long int *count = cookie;
411   char *tail = NULL;
412
413   (void) azColName;
414
415   assert (argc == 1);
416
417   errno = 0;
418   *count = strtoul (argv[0], &tail, 0);
419   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
420     /* Abort.  */
421     return 1;
422   return 0;
423 }
424
425 static int
426 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
427                              char **azColName, sqlite3_stmt *stmt)
428 {
429   (void) stmt;
430   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
431 }
432
433 /* We expect a single integer column whose name is "version".  COOKIE
434    must point to an int.  This function always aborts.  On error or a
435    if the version is bad, sets *VERSION to -1.  */
436 static int
437 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
438 {
439   int *version = cookie;
440
441   if (argc != 1 || strcmp (azColName[0], "version") != 0)
442     {
443       *version = -1;
444       return 1;
445     }
446
447   if (strcmp (argv[0], "1") == 0)
448     *version = 1;
449   else
450     {
451       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
452       *version = -1;
453     }
454
455   /* Don't run again.  */
456   return 1;
457 }
458
459
460 /* If the DB is new, initialize it.  Otherwise, check the DB's
461    version.
462
463    Return 0 if the database is okay and 1 otherwise.  */
464 static int
465 initdb (sqlite3 *db, enum db_type type)
466 {
467   char *err = NULL;
468   int rc;
469   unsigned long int count;
470   int version = -1;
471
472   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
473   if (rc)
474     {
475       log_error (_("error beginning transaction on TOFU database: %s\n"),
476                  err);
477       sqlite3_free (err);
478       return 1;
479     }
480
481   /* If the DB has no tables, then assume this is a new DB that needs
482      to be initialized.  */
483   rc = sqlite3_exec (db,
484                      "select count(*) from sqlite_master where type='table';",
485                      get_single_unsigned_long_cb, &count, &err);
486   if (rc)
487     {
488       log_error (_("error reading TOFU database: %s\n"), err);
489       print_further_info ("query available tables");
490       sqlite3_free (err);
491       goto out;
492     }
493   else if (count != 0)
494     /* Assume that the DB is already initialized.  Make sure the
495        version is okay.  */
496     {
497       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
498                          &version, &err);
499       if (rc == SQLITE_ABORT && version == 1)
500         /* Happy, happy, joy, joy.  */
501         {
502           sqlite3_free (err);
503           rc = 0;
504           goto out;
505         }
506       else if (rc == SQLITE_ABORT && version == -1)
507         /* Unsupported version.  */
508         {
509           /* An error message was already displayed.  */
510           sqlite3_free (err);
511           goto out;
512         }
513       else if (rc)
514         /* Some error.  */
515         {
516           log_error (_("error determining TOFU database's version: %s\n"), err);
517           sqlite3_free (err);
518           goto out;
519         }
520       else
521         {
522           /* Unexpected success.  This can only happen if there are no
523              rows.  (select returned 0, but expected ABORT.)  */
524           log_error (_("error determining TOFU database's version: %s\n"),
525                      gpg_strerror (GPG_ERR_NO_DATA));
526           rc = 1;
527           goto out;
528         }
529     }
530
531   /* Create the version table.  */
532   rc = sqlite3_exec (db,
533                      "create table version (version INTEGER);",
534                      NULL, NULL, &err);
535   if (rc)
536     {
537       log_error (_("error initializing TOFU database: %s\n"), err);
538       print_further_info ("create version");
539       sqlite3_free (err);
540       goto out;
541     }
542
543   /* Initialize the version table, which contains a single integer
544      value.  */
545   rc = sqlite3_exec (db,
546                      "insert into version values (1);",
547                      NULL, NULL, &err);
548   if (rc)
549     {
550       log_error (_("error initializing TOFU database: %s\n"), err);
551       print_further_info ("insert version");
552       sqlite3_free (err);
553       goto out;
554     }
555
556   /* The list of <fingerprint, email> bindings and auxiliary data.
557    *
558    *  OID is a unique ID identifying this binding (and used by the
559    *    signatures table, see below).  Note: OIDs will never be
560    *    reused.
561    *
562    *  FINGERPRINT: The key's fingerprint.
563    *
564    *  EMAIL: The normalized email address.
565    *
566    *  USER_ID: The unmodified user id from which EMAIL was extracted.
567    *
568    *  TIME: The time this binding was first observed.
569    *
570    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
571    *
572    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
573    *    a binding <0xdeadbeef, foo@example.com> and then we observe
574    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
575    *    (they have the same email address).  When we observe the
576    *    latter binding, we warn the user about the conflict and ask
577    *    for a policy decision about the new binding.  We also change
578    *    the old binding's policy to ask if it was auto.  So that we
579    *     know why this occurred, we also set conflict to 0xbaddecaf.
580    */
581   if (type == DB_EMAIL || type == DB_COMBINED)
582     rc = sqlite3_exec_printf
583       (db, NULL, NULL, &err,
584        "create table bindings\n"
585        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
586        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
587        "  policy BOOLEAN CHECK (policy in (%d, %d, %d, %d, %d)),\n"
588        "  conflict STRING,\n"
589        "  unique (fingerprint, email));\n"
590        "create index bindings_fingerprint_email\n"
591        " on bindings (fingerprint, email);\n"
592        "create index bindings_email on bindings (email);\n",
593        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
594        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
595   else
596     /* In the split DB case, the fingerprint DB only contains a subset
597        of the fields.  This reduces the amount of duplicated data.
598
599        Note: since the data is split on the email address, there is no
600        need to index the email column.  */
601     rc = sqlite3_exec_printf
602       (db, NULL, NULL, &err,
603        "create table bindings\n"
604        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
605        "  fingerprint TEXT, email TEXT, user_id,\n"
606        "  unique (fingerprint, email));\n"
607        "create index bindings_fingerprint\n"
608        " on bindings (fingerprint);\n");
609   if (rc)
610     {
611       log_error (_("error initializing TOFU database: %s\n"), err);
612       print_further_info ("create bindings");
613       sqlite3_free (err);
614       goto out;
615     }
616
617   if (type != DB_KEY)
618     {
619       /* The signatures that we have observed.
620
621          BINDING refers to a record in the bindings table, which
622          describes the binding (i.e., this is a foreign key that
623          references bindings.oid).
624
625          SIG_DIGEST is the digest stored in the signature.
626
627          SIG_TIME is the timestamp stored in the signature.
628
629          ORIGIN is a free-form string that describes who fed this
630          signature to GnuPG (e.g., email:claws).
631
632          TIME is the time this signature was registered.  */
633       rc = sqlite3_exec (db,
634                          "create table signatures "
635                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
636                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
637                          "  primary key (binding, sig_digest, origin));",
638                          NULL, NULL, &err);
639       if (rc)
640         {
641           log_error (_("error initializing TOFU database: %s\n"), err);
642           print_further_info ("create signatures");
643           sqlite3_free (err);
644           goto out;
645         }
646     }
647
648  out:
649   if (rc)
650     {
651       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
652       if (rc)
653         {
654           log_error (_("error rolling back transaction on TOFU database: %s\n"),
655                      err);
656           sqlite3_free (err);
657         }
658       return 1;
659     }
660   else
661     {
662       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
663       if (rc)
664         {
665           log_error (_("error committing transaction on TOFU database: %s\n"),
666                      err);
667           sqlite3_free (err);
668           return 1;
669         }
670       return 0;
671     }
672 }
673
674 /* Open and initialize a low-level TOFU database.  Returns NULL on
675    failure.  This function should not normally be directly called to
676    get a database handle.  Instead, use getdb().  */
677 static sqlite3 *
678 opendb (char *filename, enum db_type type)
679 {
680   sqlite3 *db;
681   int filename_free = 0;
682   int rc;
683
684   if (opt.tofu_db_format == TOFU_DB_FLAT)
685     {
686       assert (! filename);
687       assert (type == DB_COMBINED);
688
689       filename = make_filename (opt.homedir, "tofu.db", NULL);
690       filename_free = 1;
691     }
692   else
693     assert (type == DB_EMAIL || type == DB_KEY);
694
695   assert (filename);
696
697   rc = sqlite3_open (filename, &db);
698   if (rc)
699     {
700       log_error (_("error opening TOFU database '%s': %s\n"),
701                  filename, sqlite3_errmsg (db));
702       /* Even if an error occurs, DB is guaranteed to be valid.  */
703       sqlite3_close (db);
704       db = NULL;
705     }
706
707   /* If a DB is locked wait up to 5 seconds for the lock to be cleared
708      before failing.  */
709   if (db)
710     sqlite3_busy_timeout (db, 5 * 1000);
711
712   if (filename_free)
713     xfree (filename);
714
715   if (db && initdb (db, type))
716     {
717       sqlite3_close (db);
718       db = NULL;
719     }
720
721   return db;
722 }
723
724 struct dbs
725 {
726   struct db *db;
727 };
728
729 static void
730 unlink_db (struct db *db)
731 {
732   *db->prevp = db->next;
733   if (db->next)
734     db->next->prevp = db->prevp;
735 }
736
737 static void
738 link_db (struct db **head, struct db *db)
739 {
740   db->next = *head;
741   if (db->next)
742     db->next->prevp = &db->next;
743   db->prevp = head;
744   *head = db;
745 }
746
747 /* Return a database handle.  <type, name> describes the required
748    database.  If there is a cached handle in DBS, that handle is
749    returned.  Otherwise, the database is opened and cached in DBS.
750
751    NAME is the name of the DB and may not be NULL.
752
753    TYPE must be either DB_MAIL or DB_KEY.  In the combined format, the
754    combined DB is always returned.  */
755 static struct db *
756 getdb (struct dbs *dbs, const char *name, enum db_type type)
757 {
758   struct db *t = NULL;
759   char *name_sanitized = NULL;
760   int count;
761   char *filename = NULL;
762   int need_link = 1;
763   sqlite3 *sqlitedb = NULL;
764   gpg_error_t rc;
765
766   assert (dbs);
767   assert (name);
768   assert (type == DB_EMAIL || type == DB_KEY);
769
770   if (opt.tofu_db_format == TOFU_DB_FLAT)
771     /* When using the flat format, we only have a single DB, the
772        combined DB.  */
773     {
774       if (dbs->db)
775         {
776           assert (dbs->db->type == DB_COMBINED);
777           assert (! dbs->db->next);
778           return dbs->db;
779         }
780
781       type = DB_COMBINED;
782     }
783
784   if (type != DB_COMBINED)
785     /* Only allow alpha-numeric characters in the name.  */
786     {
787       int i;
788
789       name_sanitized = xstrdup (name);
790       for (i = 0; name[i]; i ++)
791         {
792           char c = name_sanitized[i];
793           if (! (('a' <= c && c <= 'z')
794                  || ('A' <= c && c <= 'Z')
795                  || ('0' <= c && c <= '9')))
796             name_sanitized[i] = '_';
797         }
798     }
799
800   /* See if the DB is cached.  */
801   for (t = dbs->db; t; t = t->next)
802     if (t->type == type
803         && (type == DB_COMBINED || strcmp (t->name, name_sanitized) == 0))
804       {
805         need_link = 0;
806         goto out;
807       }
808
809   for (t = db_cache, count = 0; t; t = t->next, count ++)
810     if (type == t->type
811         && (type == DB_COMBINED || strcmp (t->name, name_sanitized) == 0))
812       {
813         unlink_db (t);
814         db_cache_count --;
815         goto out;
816       }
817
818   assert (db_cache_count == count);
819
820   if (type == DB_COMBINED)
821     filename = NULL;
822   else
823     {
824       /* Open the DB.  The filename has the form:
825
826          tofu.d/TYPE/PREFIX/NAME.db
827
828          We use a short prefix to try to avoid having many files in a
829          single directory.  */
830       {
831         char *type_str = type == DB_EMAIL ? "email" : "key";
832         char prefix[3] = { name_sanitized[0], name_sanitized[1], 0 };
833         char *name_db;
834
835         /* Make the directory.  */
836         rc = gnupg_mkdir_p (opt.homedir, "tofu.d", type_str, prefix, NULL);
837         if (rc)
838           {
839             name_db = xstrconcat (opt.homedir, "tofu.d",
840                                   type_str, prefix, NULL);
841             log_error (_("can't create directory '%s': %s\n"),
842                        name_db, gpg_strerror (rc));
843             xfree (name_db);
844             goto out;
845           }
846
847         name_db = xstrconcat (name_sanitized, ".db", NULL);
848         filename = make_filename
849           (opt.homedir, "tofu.d", type_str, prefix, name_db, NULL);
850         xfree (name_db);
851       }
852     }
853
854   sqlitedb = opendb (filename, type);
855   if (! sqlitedb)
856     goto out;
857
858   t = xmalloc_clear (sizeof (struct db)
859                      + (name_sanitized ? strlen (name_sanitized) : 0));
860   t->type = type;
861   t->db = sqlitedb;
862   if (name_sanitized)
863     strcpy (t->name, name_sanitized);
864
865  out:
866   if (t && need_link)
867     link_db (&dbs->db, t);
868
869 #if DEBUG_TOFU_CACHE
870   if (t)
871     t->hits ++;
872 #endif
873
874   xfree (filename);
875   xfree (name_sanitized);
876   return t;
877 }
878
879 static void
880 closedb (struct db *db)
881 {
882   sqlite3_stmt **statements;
883
884   if (opt.tofu_db_format == TOFU_DB_FLAT)
885     /* If we are using the flat format, then there is only ever the
886        combined DB.  */
887     assert (! db->next);
888
889   if (db->type == DB_COMBINED)
890     {
891       assert (opt.tofu_db_format == TOFU_DB_FLAT);
892       assert (! db->name[0]);
893     }
894   else
895     {
896       assert (opt.tofu_db_format == TOFU_DB_SPLIT);
897       assert (db->type != DB_COMBINED);
898       assert (db->name[0]);
899     }
900
901   if (db->batch_update)
902     end_transaction (db, 2);
903
904   for (statements = (void *) &db->s;
905        (void *) statements < (void *) &(&db->s)[1];
906        statements ++)
907     sqlite3_finalize (*statements);
908
909   sqlite3_close (db->db);
910
911 #if DEBUG_TOFU_CACHE
912   log_debug ("Freeing db.  Used %d times.\n", db->hits);
913 #endif
914
915   xfree (db);
916 }
917
918
919 /* Create a new DB meta-handle.  Returns NULL on error.  */
920 /* FIXME: Change to return an error code for better reporting by the
921    caller.  */
922 static struct dbs *
923 opendbs (void)
924 {
925   if (opt.tofu_db_format == TOFU_DB_AUTO)
926     {
927       char *filename = make_filename (opt.homedir, "tofu.db", NULL);
928       struct stat s;
929       int have_tofu_db = 0;
930       int have_tofu_d = 0;
931
932       if (stat (filename, &s) == 0)
933         {
934           have_tofu_db = 1;
935           if (DBG_TRUST)
936             log_debug ("%s exists.\n", filename);
937         }
938       else
939         {
940           if (DBG_TRUST)
941             log_debug ("%s does not exist.\n", filename);
942         }
943
944       /* We now have tofu.d.  */
945       filename[strlen (filename) - 1] = '\0';
946       if (stat (filename, &s) == 0)
947         {
948           have_tofu_d = 1;
949           if (DBG_TRUST)
950             log_debug ("%s exists.\n", filename);
951         }
952       else
953         {
954           if (DBG_TRUST)
955             log_debug ("%s does not exist.\n", filename);
956         }
957
958       xfree (filename);
959
960       if (have_tofu_db && have_tofu_d)
961         {
962           log_info (_("Warning: Home directory contains both tofu.db"
963                       " and tofu.d.\n"));
964           log_info (_("Using split format for TOFU database\n"));
965           opt.tofu_db_format = TOFU_DB_SPLIT;
966         }
967       else if (have_tofu_db)
968         {
969           opt.tofu_db_format = TOFU_DB_FLAT;
970           if (DBG_TRUST)
971             log_debug ("Using flat format for TOFU database.\n");
972         }
973       else if (have_tofu_d)
974         {
975           opt.tofu_db_format = TOFU_DB_SPLIT;
976           if (DBG_TRUST)
977             log_debug ("Using split format for TOFU database.\n");
978         }
979       else
980         {
981           opt.tofu_db_format = TOFU_DB_FLAT;
982           if (DBG_TRUST)
983             log_debug ("Using flat format for TOFU database.\n");
984         }
985     }
986
987   return xmalloc_clear (sizeof (struct dbs));
988 }
989
990 /* Release all of the resources associated with a DB meta-handle.  */
991 static void
992 closedbs (struct dbs *dbs)
993 {
994   if (dbs->db)
995     {
996       struct db *old_head = db_cache;
997       struct db *db;
998       int count;
999
1000       /* Find the last DB.  */
1001       for (db = dbs->db, count = 1; db->next; db = db->next, count ++)
1002         {
1003           /* When we leave batch mode we leave batch mode on any
1004              cached connections.  */
1005           if (! batch_update)
1006             assert (! db->batch_update);
1007         }
1008       if (! batch_update)
1009         assert (! db->batch_update);
1010
1011       /* Join the two lists.  */
1012       db->next = db_cache;
1013       if (db_cache)
1014         db_cache->prevp = &db->next;
1015
1016       /* Update the (new) first element.  */
1017       db_cache = dbs->db;
1018       dbs->db->prevp = &db_cache;
1019
1020       db_cache_count += count;
1021
1022       /* Make sure that we don't have too many DBs on DB_CACHE.  If
1023          so, free some.  */
1024       if (db_cache_count > DB_CACHE_ENTRIES)
1025         {
1026           /* We need to find the (DB_CACHE_ENTRIES + 1)th entry.  It
1027              is easy to skip the first COUNT entries since we still
1028              have a handle on the old head.  */
1029           int skip = DB_CACHE_ENTRIES - count;
1030           while (-- skip > 0)
1031             old_head = old_head->next;
1032
1033           *old_head->prevp = NULL;
1034
1035           while (old_head)
1036             {
1037               db = old_head->next;
1038               closedb (old_head);
1039               old_head = db;
1040               db_cache_count --;
1041             }
1042         }
1043     }
1044
1045   xfree (dbs);
1046
1047 #if DEBUG_TOFU_CACHE
1048   log_debug ("Queries: %d (prepares saved: %d)\n",
1049              queries, prepares_saved);
1050 #endif
1051 }
1052
1053
1054 /* Collect results of a select min (foo) ...; style query.  Aborts if
1055    the argument is not a valid integer (or real of the form X.0).  */
1056 static int
1057 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
1058 {
1059   long *count = cookie;
1060   char *tail = NULL;
1061
1062   (void) azColName;
1063
1064   assert (argc == 1);
1065
1066   errno = 0;
1067   *count = strtol (argv[0], &tail, 0);
1068   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1069     /* Abort.  */
1070     return 1;
1071   return 0;
1072 }
1073
1074 static int
1075 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
1076                      sqlite3_stmt *stmt)
1077 {
1078   (void) stmt;
1079   return get_single_long_cb (cookie, argc, argv, azColName);
1080 }
1081
1082 /* Record (or update) a trust policy about a (possibly new)
1083    binding.
1084
1085    If SHOW_OLD is set, the binding's old policy is displayed.  */
1086 static gpg_error_t
1087 record_binding (struct dbs *dbs, const char *fingerprint, const char *email,
1088                 const char *user_id, enum tofu_policy policy, int show_old)
1089 {
1090   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1091   struct db *db_email = NULL, *db_key = NULL;
1092   gpg_error_t rc;
1093   char *err = NULL;
1094   /* policy_old needs to be a long and not an enum tofu_policy,
1095      because we pass it by reference to get_single_long_cb2, which
1096      expects a long.  */
1097   long policy_old = TOFU_POLICY_NONE;
1098
1099   if (! (policy == TOFU_POLICY_AUTO
1100          || policy == TOFU_POLICY_GOOD
1101          || policy == TOFU_POLICY_UNKNOWN
1102          || policy == TOFU_POLICY_BAD
1103          || policy == TOFU_POLICY_ASK))
1104     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
1105
1106   db_email = getdb (dbs, email, DB_EMAIL);
1107   if (! db_email)
1108     {
1109       rc = gpg_error (GPG_ERR_GENERAL);
1110       goto leave;
1111     }
1112
1113   if (opt.tofu_db_format == TOFU_DB_SPLIT)
1114     /* In the split format, we need to update two DBs.  To keep them
1115        consistent, we start a transaction on each.  Note: this is the
1116        only place where we start two transaction and we always start
1117        transaction on the DB_KEY DB first, thus deadlock is not
1118        possible.  */
1119     {
1120       db_key = getdb (dbs, fingerprint, DB_KEY);
1121       if (! db_key)
1122         {
1123           rc = gpg_error (GPG_ERR_GENERAL);
1124           goto leave;
1125         }
1126
1127       rc = begin_transaction (db_email, 0);
1128       if (rc)
1129         goto leave;
1130
1131       rc = begin_transaction (db_key, 0);
1132       if (rc)
1133         goto out_revert_one;
1134     }
1135   else
1136     {
1137       rc = begin_transaction (db_email, 1);
1138       if (rc)
1139         goto leave;
1140     }
1141
1142
1143   if (show_old)
1144     /* Get the old policy.  Since this is just for informational
1145        purposes, there is no need to start a transaction or to die if
1146        there is a failure.  */
1147     {
1148       rc = sqlite3_stepx
1149         (db_email->db, &db_email->s.record_binding_get_old_policy,
1150          get_single_long_cb2, &policy_old, &err,
1151          "select policy from bindings where fingerprint = ? and email = ?",
1152          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1153          SQLITE_ARG_END);
1154       if (rc)
1155         {
1156           log_debug ("TOFU: Error reading from binding database"
1157                      " (reading policy for <%s, %s>): %s\n",
1158                      fingerprint_pp, email, err);
1159           sqlite3_free (err);
1160         }
1161     }
1162
1163   if (DBG_TRUST)
1164     {
1165       if (policy_old != TOFU_POLICY_NONE)
1166         log_debug ("Changing TOFU trust policy for binding <%s, %s>"
1167                    " from %s to %s.\n",
1168                    fingerprint_pp, email,
1169                    tofu_policy_str (policy_old),
1170                    tofu_policy_str (policy));
1171       else
1172         log_debug ("Set TOFU trust policy for binding <%s, %s> to %s.\n",
1173                    fingerprint_pp, email,
1174                    tofu_policy_str (policy));
1175     }
1176
1177   if (policy_old == policy)
1178     /* Nothing to do.  */
1179     goto out;
1180
1181   rc = sqlite3_stepx
1182     (db_email->db, &db_email->s.record_binding_update, NULL, NULL, &err,
1183      "insert or replace into bindings\n"
1184      " (oid, fingerprint, email, user_id, time, policy)\n"
1185      " values (\n"
1186      /* If we don't explicitly reuse the OID, then SQLite will
1187         reallocate a new one.  We just need to search for the OID
1188         based on the fingerprint and email since they are unique.  */
1189      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1190      "  ?, ?, ?, strftime('%s','now'), ?);",
1191      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1192      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1193      SQLITE_ARG_STRING, user_id, SQLITE_ARG_INT, (int) policy,
1194      SQLITE_ARG_END);
1195   if (rc)
1196     {
1197       log_error (_("error updating TOFU database: %s\n"), err);
1198       print_further_info (" insert bindings <%s, %s> = %s",
1199                           fingerprint_pp, email, tofu_policy_str (policy));
1200       sqlite3_free (err);
1201       goto out;
1202     }
1203
1204   if (db_key)
1205     /* We also need to update the key DB.  */
1206     {
1207       assert (opt.tofu_db_format == TOFU_DB_SPLIT);
1208
1209       rc = sqlite3_stepx
1210         (db_key->db, &db_key->s.record_binding_update2, NULL, NULL, &err,
1211          "insert or replace into bindings\n"
1212          " (oid, fingerprint, email, user_id)\n"
1213          " values (\n"
1214          /* If we don't explicitly reuse the OID, then SQLite will
1215             reallocate a new one.  We just need to search for the OID
1216             based on the fingerprint and email since they are unique.  */
1217          "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1218          "  ?, ?, ?);",
1219          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1220          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1221          SQLITE_ARG_STRING, user_id, SQLITE_ARG_END);
1222       if (rc)
1223         {
1224           log_error (_("error updating TOFU database: %s\n"), err);
1225           print_further_info ("insert bindings <%s, %s>",
1226                               fingerprint_pp, email);
1227           sqlite3_free (err);
1228           goto out;
1229         }
1230     }
1231   else
1232     assert (opt.tofu_db_format == TOFU_DB_FLAT);
1233
1234  out:
1235   if (opt.tofu_db_format == TOFU_DB_SPLIT)
1236     /* We only need a transaction for the split format.  */
1237     {
1238       gpg_error_t rc2;
1239
1240       if (rc)
1241         rc2 = rollback_transaction (db_key);
1242       else
1243         rc2 = end_transaction (db_key, 0);
1244       if (rc2)
1245         sqlite3_free (err);
1246
1247     out_revert_one:
1248       if (rc)
1249         rc2 = rollback_transaction (db_email);
1250       else
1251         rc2 = end_transaction (db_email, 0);
1252       if (rc2)
1253         sqlite3_free (err);
1254     }
1255
1256  leave:
1257   xfree (fingerprint_pp);
1258
1259   return rc;
1260 }
1261
1262
1263 /* Collect the strings returned by a query in a simply string list.
1264    Any NULL values are converted to the empty string.
1265
1266    If a result has 3 rows and each row contains two columns, then the
1267    results are added to the list as follows (the value is parentheses
1268    is the 1-based index in the final list):
1269
1270      row 1, col 2 (6)
1271      row 1, col 1 (5)
1272      row 2, col 2 (4)
1273      row 2, col 1 (3)
1274      row 3, col 2 (2)
1275      row 3, col 1 (1)
1276
1277    This is because add_to_strlist pushes the results onto the front of
1278    the list.  The end result is that the rows are backwards, but the
1279    columns are in the expected order.  */
1280 static int
1281 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
1282 {
1283   int i;
1284   strlist_t *strlist = cookie;
1285
1286   (void) azColName;
1287
1288   for (i = argc - 1; i >= 0; i --)
1289     add_to_strlist (strlist, argv[i] ? argv[i] : "");
1290
1291   return 0;
1292 }
1293
1294 static int
1295 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
1296                      sqlite3_stmt *stmt)
1297 {
1298   (void) stmt;
1299   return strings_collect_cb (cookie, argc, argv, azColName);
1300
1301 }
1302
1303 /* Auxiliary data structure to collect statistics about
1304    signatures.  */
1305 struct signature_stats
1306 {
1307   struct signature_stats *next;
1308
1309   /* The user-assigned policy for this binding.  */
1310   enum tofu_policy policy;
1311
1312   /* How long ago the signature was created (rounded to a multiple of
1313      TIME_AGO_UNIT_SMALL, etc.).  */
1314   long time_ago;
1315   /* Number of signatures during this time.  */
1316   unsigned long count;
1317
1318   /* The key that generated this signature.  */
1319   char fingerprint[1];
1320 };
1321
1322 static void
1323 signature_stats_free (struct signature_stats *stats)
1324 {
1325   while (stats)
1326     {
1327       struct signature_stats *next = stats->next;
1328       xfree (stats);
1329       stats = next;
1330     }
1331 }
1332
1333 static void
1334 signature_stats_prepend (struct signature_stats **statsp,
1335                          const char *fingerprint,
1336                          enum tofu_policy policy,
1337                          long time_ago,
1338                          unsigned long count)
1339 {
1340   struct signature_stats *stats =
1341     xmalloc (sizeof (*stats) + strlen (fingerprint));
1342
1343   stats->next = *statsp;
1344   *statsp = stats;
1345
1346   strcpy (stats->fingerprint, fingerprint);
1347   stats->policy = policy;
1348   stats->time_ago = time_ago;
1349   stats->count = count;
1350 }
1351
1352
1353 /* Process rows that contain the four columns:
1354
1355      <fingerprint, policy, time ago, count>.  */
1356 static int
1357 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1358                             char **azColName, sqlite3_stmt *stmt)
1359 {
1360   struct signature_stats **statsp = cookie;
1361   char *tail;
1362   int i = 0;
1363   enum tofu_policy policy;
1364   long time_ago;
1365   unsigned long count;
1366
1367   (void) azColName;
1368   (void) stmt;
1369
1370   i ++;
1371
1372   tail = NULL;
1373   errno = 0;
1374   policy = strtol (argv[i], &tail, 0);
1375   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1376     {
1377       /* Abort.  */
1378       log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1379                  __func__, argv[i], tail);
1380       return 1;
1381     }
1382   i ++;
1383
1384   if (! argv[i])
1385     time_ago = 0;
1386   else
1387     {
1388       tail = NULL;
1389       errno = 0;
1390       time_ago = strtol (argv[i], &tail, 0);
1391       if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1392         {
1393           /* Abort.  */
1394           log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1395                      __func__, argv[i], tail);
1396           return 1;
1397         }
1398     }
1399   i ++;
1400
1401   /* If time_ago is NULL, then we had no messages, but we still have a
1402      single row, which count(*) turns into 1.  */
1403   if (! argv[i - 1])
1404     count = 0;
1405   else
1406     {
1407       tail = NULL;
1408       errno = 0;
1409       count = strtoul (argv[i], &tail, 0);
1410       if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1411         {
1412           /* Abort.  */
1413           log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1414                      __func__, argv[i], tail);
1415           return 1;
1416         }
1417     }
1418   i ++;
1419
1420   assert (argc == i);
1421
1422   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1423
1424   return 0;
1425 }
1426
1427 /* Convert from seconds to time units.
1428
1429    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1430    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1431 signed long
1432 time_ago_scale (signed long t)
1433 {
1434   if (t < TIME_AGO_UNIT_MEDIUM)
1435     return t / TIME_AGO_UNIT_SMALL;
1436   if (t < TIME_AGO_UNIT_LARGE)
1437     return t / TIME_AGO_UNIT_MEDIUM;
1438   return t / TIME_AGO_UNIT_LARGE;
1439 }
1440
1441
1442 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1443    already been normalized) and any conflict information in *CONFLICT
1444    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1445    occurs.  */
1446 static enum tofu_policy
1447 get_policy (struct dbs *dbs, const char *fingerprint, const char *email,
1448             char **conflict)
1449 {
1450   struct db *db;
1451   int rc;
1452   char *err = NULL;
1453   strlist_t strlist = NULL;
1454   char *tail = NULL;
1455   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1456
1457   db = getdb (dbs, email, DB_EMAIL);
1458   if (! db)
1459     return _tofu_GET_POLICY_ERROR;
1460
1461   /* Check if the <FINGERPRINT, EMAIL> binding is known
1462      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1463      still TOFU_POLICY_NONE after executing the query, then the
1464      result set was empty.)  */
1465   rc = sqlite3_stepx (db->db, &db->s.get_policy_select_policy_and_conflict,
1466                       strings_collect_cb2, &strlist, &err,
1467                       "select policy, conflict from bindings\n"
1468                       " where fingerprint = ? and email = ?",
1469                       SQLITE_ARG_STRING, fingerprint,
1470                       SQLITE_ARG_STRING, email,
1471                       SQLITE_ARG_END);
1472   if (rc)
1473     {
1474       log_error (_("error reading TOFU database: %s\n"), err);
1475       print_further_info ("checking for existing bad bindings");
1476       sqlite3_free (err);
1477       goto out;
1478     }
1479
1480   if (strlist_length (strlist) == 0)
1481     /* No results.  */
1482     {
1483       policy = TOFU_POLICY_NONE;
1484       goto out;
1485     }
1486   else if (strlist_length (strlist) != 2)
1487     /* The result has the wrong form.  */
1488     {
1489       log_error (_("error reading TOFU database: %s\n"),
1490                  gpg_strerror (GPG_ERR_BAD_DATA));
1491       print_further_info ("checking for existing bad bindings:"
1492                           " expected 2 results, got %d\n",
1493                           strlist_length (strlist));
1494       goto out;
1495     }
1496
1497   /* The result has the right form.  */
1498
1499   errno = 0;
1500   policy = strtol (strlist->d, &tail, 0);
1501   if (errno || *tail != '\0')
1502     {
1503       log_error (_("error reading TOFU database: %s\n"),
1504                  gpg_strerror (GPG_ERR_BAD_DATA));
1505       print_further_info ("bad value for policy: %s", strlist->d);
1506       goto out;
1507     }
1508
1509   if (! (policy == TOFU_POLICY_AUTO
1510          || policy == TOFU_POLICY_GOOD
1511          || policy == TOFU_POLICY_UNKNOWN
1512          || policy == TOFU_POLICY_BAD
1513          || policy == TOFU_POLICY_ASK))
1514     {
1515       log_error (_("error reading TOFU database: %s\n"),
1516                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1517       print_further_info ("invalid value for policy (%d)", policy);
1518       policy = _tofu_GET_POLICY_ERROR;
1519       goto out;
1520     }
1521
1522
1523   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1524      just in case, we do the check again here and ignore the conflict
1525      is POLICY is not TOFU_POLICY_ASK.  */
1526   if (conflict)
1527     {
1528       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1529         *conflict = xstrdup (strlist->next->d);
1530       else
1531         *conflict = NULL;
1532     }
1533
1534  out:
1535   assert (policy == _tofu_GET_POLICY_ERROR
1536           || policy == TOFU_POLICY_NONE
1537           || policy == TOFU_POLICY_AUTO
1538           || policy == TOFU_POLICY_GOOD
1539           || policy == TOFU_POLICY_UNKNOWN
1540           || policy == TOFU_POLICY_BAD
1541           || policy == TOFU_POLICY_ASK);
1542
1543   free_strlist (strlist);
1544
1545   return policy;
1546 }
1547
1548 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1549    <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1550    is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1551    returns _tofu_GET_TRUST_ERROR.
1552
1553    USER_ID is the unadultered user id.
1554
1555    If MAY_ASK is set, then we may interact with the user.  This is
1556    necessary if there is a conflict or the binding's policy is
1557    TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1558    conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1559    we return TRUST_UNDEFINED.  */
1560 static enum tofu_policy
1561 get_trust (struct dbs *dbs, const char *fingerprint, const char *email,
1562            const char *user_id, int may_ask)
1563 {
1564   char *fingerprint_pp;
1565   struct db *db;
1566   enum tofu_policy policy;
1567   char *conflict = NULL;
1568   int rc;
1569   char *err = NULL;
1570   strlist_t bindings_with_this_email = NULL;
1571   int bindings_with_this_email_count;
1572   int change_conflicting_to_ask = 0;
1573   int trust_level = TRUST_UNKNOWN;
1574
1575   if (opt.batch)
1576     may_ask = 0;
1577
1578   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1579      levels.  */
1580   assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1581           && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1582           && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1583           && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1584           && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1585           && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1586           && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1587
1588   db = getdb (dbs, email, DB_EMAIL);
1589   if (! db)
1590     return _tofu_GET_TRUST_ERROR;
1591
1592   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1593
1594   policy = get_policy (dbs, fingerprint, email, &conflict);
1595   if (policy == TOFU_POLICY_AUTO || policy == TOFU_POLICY_NONE)
1596     /* See if the key is ultimately trusted.  If so, we're done.  */
1597     {
1598       PKT_public_key *pk;
1599       u32 kid[2];
1600       char fpr_bin[MAX_FINGERPRINT_LEN+1];
1601       size_t fpr_bin_len;
1602
1603       if (!hex2str (fingerprint, fpr_bin, sizeof fpr_bin, &fpr_bin_len))
1604         {
1605           log_error ("error converting fingerprint: %s\n",
1606                      gpg_strerror (gpg_error_from_syserror ()));
1607           return _tofu_GET_TRUST_ERROR;
1608         }
1609
1610       /* We need to lookup the key by fingerprint again so that we can
1611          properly extract the keyid.  Extracting direct from the
1612          fingerprint works only for v4 keys and would assume that
1613          there is no collision in the low 64 bit.  We can't guarantee
1614          the latter in case the Tofu DB is used with a different
1615          keyring.  In any case the UTK stuff needs to be changed to
1616          use only fingerprints.  */
1617       pk = xtrycalloc (1, sizeof *pk);
1618       if (!pk)
1619          {
1620            log_error (_("out of core\n"));
1621            return _tofu_GET_TRUST_ERROR;
1622          }
1623       rc = get_pubkey_byfprint_fast (pk, fpr_bin, fpr_bin_len);
1624       if (rc)
1625         {
1626           log_error (_("public key %s not found: %s\n"),
1627                      fingerprint, gpg_strerror (rc));
1628           return _tofu_GET_TRUST_ERROR;
1629         }
1630       keyid_from_pk (pk, kid);
1631       free_public_key (pk);
1632
1633       if (tdb_keyid_is_utk (kid))
1634         {
1635           if (policy == TOFU_POLICY_NONE)
1636             {
1637               if (record_binding (dbs, fingerprint, email, user_id,
1638                                   TOFU_POLICY_AUTO, 0) != 0)
1639                 {
1640                   log_error (_("error setting TOFU binding's trust level"
1641                                " to %s\n"), "auto");
1642                   trust_level = _tofu_GET_TRUST_ERROR;
1643                   goto out;
1644                 }
1645             }
1646
1647           trust_level = TRUST_ULTIMATE;
1648           goto out;
1649         }
1650     }
1651
1652   if (policy == TOFU_POLICY_AUTO)
1653     {
1654       policy = opt.tofu_default_policy;
1655       if (DBG_TRUST)
1656         log_debug ("TOFU: binding <%s, %s>'s policy is auto (default: %s).\n",
1657                    fingerprint_pp, email,
1658                    tofu_policy_str (opt.tofu_default_policy));
1659     }
1660   switch (policy)
1661     {
1662     case TOFU_POLICY_AUTO:
1663     case TOFU_POLICY_GOOD:
1664     case TOFU_POLICY_UNKNOWN:
1665     case TOFU_POLICY_BAD:
1666       /* The saved judgement is auto -> auto, good, unknown or bad.
1667          We don't need to ask the user anything.  */
1668       if (DBG_TRUST)
1669         log_debug ("TOFU: Known binding <%s, %s>'s policy: %s\n",
1670                    fingerprint_pp, email, tofu_policy_str (policy));
1671       trust_level = tofu_policy_to_trust_level (policy);
1672       goto out;
1673
1674     case TOFU_POLICY_ASK:
1675       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1676       if (! may_ask)
1677         {
1678           trust_level = TRUST_UNDEFINED;
1679           goto out;
1680         }
1681
1682       break;
1683
1684     case TOFU_POLICY_NONE:
1685       /* The binding is new, we need to check for conflicts.  Case #3
1686          below.  */
1687       break;
1688
1689     case _tofu_GET_POLICY_ERROR:
1690       trust_level = _tofu_GET_TRUST_ERROR;
1691       goto out;
1692
1693     default:
1694       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1695     }
1696
1697
1698   /* We get here if:
1699
1700        1. The saved policy is auto and the default policy is ask
1701           (get_policy() == TOFU_POLICY_AUTO
1702            && opt.tofu_default_policy == TOFU_POLICY_ASK)
1703
1704        2. The saved policy is ask (either last time the user selected
1705           accept once or reject once or there was a conflict and this
1706           binding's policy was changed from auto to ask)
1707           (policy == TOFU_POLICY_ASK), or,
1708
1709        3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1710           (need to check for a conflict).
1711    */
1712
1713   /* Look for conflicts.  This is needed in all 3 cases.
1714
1715      Get the fingerprints of any bindings that share the email
1716      address.  Note: if the binding in question is in the DB, it will
1717      also be returned.  Thus, if the result set is empty, then this is
1718      a new binding.  */
1719   rc = sqlite3_stepx
1720     (db->db, &db->s.get_trust_bindings_with_this_email,
1721      strings_collect_cb2, &bindings_with_this_email, &err,
1722      "select distinct fingerprint from bindings where email = ?;",
1723      SQLITE_ARG_STRING, email, SQLITE_ARG_END);
1724   if (rc)
1725     {
1726       log_error (_("error reading TOFU database: %s\n"), err);
1727       print_further_info ("listing fingerprints");
1728       sqlite3_free (err);
1729       goto out;
1730     }
1731
1732   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1733   if (bindings_with_this_email_count == 0
1734       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1735     /* New binding with no conflict and a concrete default policy.
1736
1737        We've never observed a binding with this email address
1738        (BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would return
1739        the current binding if it were in the DB) and we have a default
1740        policy, which is not to ask the user.  */
1741     {
1742       /* If we've seen this binding, then we've seen this email and
1743          policy couldn't possibly be TOFU_POLICY_NONE.  */
1744       assert (policy == TOFU_POLICY_NONE);
1745
1746       if (DBG_TRUST)
1747         log_debug ("TOFU: New binding <%s, %s>, no conflict.\n",
1748                    email, fingerprint_pp);
1749
1750       if (record_binding (dbs, fingerprint, email, user_id,
1751                           TOFU_POLICY_AUTO, 0) != 0)
1752         {
1753           log_error (_("error setting TOFU binding's trust level to %s\n"),
1754                        "auto");
1755           trust_level = _tofu_GET_TRUST_ERROR;
1756           goto out;
1757         }
1758
1759       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1760       goto out;
1761     }
1762
1763   if (policy == TOFU_POLICY_NONE)
1764     /* This is a new binding and we have a conflict.  Mark any
1765        conflicting bindings that have an automatic policy as now
1766        requiring confirmation.  Note: we delay this until after we ask
1767        for confirmation so that when the current policy is printed, it
1768        is correct.  */
1769     change_conflicting_to_ask = 1;
1770
1771   if (! may_ask)
1772     /* We can only get here in the third case (no saved policy) and if
1773        there is a conflict.  (If the policy was ask (cases #1 and #2)
1774        and we weren't allowed to ask, we'd have already exited).  */
1775     {
1776       assert (policy == TOFU_POLICY_NONE);
1777
1778       if (record_binding (dbs, fingerprint, email, user_id,
1779                           TOFU_POLICY_ASK, 0) != 0)
1780         log_error (_("error setting TOFU binding's trust level to %s\n"),
1781                    "ask");
1782
1783       trust_level = TRUST_UNDEFINED;
1784       goto out;
1785     }
1786
1787   /* If we get here, we need to ask the user about the binding.  There
1788      are three ways we could end up here:
1789
1790        - This is a new binding and there is a conflict
1791          (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1792
1793        - This is a new binding and opt.tofu_default_policy is set to
1794          ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1795          TOFU_POLICY_ASK), or,
1796
1797        - The policy is ask (the user deferred last time) (policy ==
1798          TOFU_POLICY_ASK).
1799    */
1800   {
1801     int is_conflict =
1802       ((policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1803        || (policy == TOFU_POLICY_ASK && conflict));
1804     estream_t fp;
1805     char *binding;
1806     int binding_shown;
1807     strlist_t other_user_ids = NULL;
1808     struct signature_stats *stats = NULL;
1809     struct signature_stats *stats_iter = NULL;
1810     char *prompt;
1811     char *choices;
1812
1813     fp = es_fopenmem (0, "rw,samethread");
1814     if (! fp)
1815       log_fatal ("Error creating memory stream\n");
1816
1817     binding = xasprintf ("<%s, %s>", fingerprint_pp, email);
1818     binding_shown = 0;
1819
1820     if (policy == TOFU_POLICY_NONE)
1821       {
1822         es_fprintf (fp, _("The binding %s is NOT known."), binding);
1823         es_fputs ("  ", fp);
1824         binding_shown = 1;
1825       }
1826     else if (policy == TOFU_POLICY_ASK
1827              /* If there the conflict is with itself, then don't
1828                 display this message.  */
1829              && conflict && strcmp (conflict, fingerprint) != 0)
1830       {
1831         char *conflict_pp = format_hexfingerprint (conflict, NULL, 0);
1832         es_fprintf (fp,
1833                     _("The key %s raised a conflict with this binding (%s)."
1834                       "  Since this binding's policy was 'auto', it was "
1835                       "changed to 'ask'."),
1836                     conflict_pp, binding);
1837         es_fputs ("  ", fp);
1838         xfree (conflict_pp);
1839         binding_shown = 1;
1840       }
1841     /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1842        blank or by two empty strings.  */
1843     es_fprintf (fp,
1844                 _("Please indicate whether you believe the binding %s%s"
1845                   "is legitimate (the key belongs to the stated owner) "
1846                   "or a forgery (bad)."),
1847                 binding_shown ? "" : binding,
1848                 binding_shown ? "" : " ");
1849     es_fputs ("\n\n", fp);
1850
1851     xfree (binding);
1852
1853     /* Find other user ids associated with this key and whether the
1854        bindings are marked as good or bad.  */
1855     {
1856       struct db *db_key;
1857
1858       if (opt.tofu_db_format == TOFU_DB_SPLIT)
1859         /* In the split format, we need to search in the fingerprint
1860            DB for all the emails associated with this key, not the
1861            email DB.  */
1862         db_key = getdb (dbs, fingerprint, DB_KEY);
1863       else
1864         db_key = db;
1865
1866       if (db_key)
1867         {
1868           rc = sqlite3_stepx
1869             (db_key->db, &db_key->s.get_trust_gather_other_user_ids,
1870              strings_collect_cb2, &other_user_ids, &err,
1871              opt.tofu_db_format == TOFU_DB_SPLIT
1872              ? "select user_id, email from bindings where fingerprint = ?;"
1873              : "select user_id, policy from bindings where fingerprint = ?;",
1874              SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_END);
1875           if (rc)
1876             {
1877               log_error (_("error gathering other user IDs: %s\n"), err);
1878               sqlite3_free (err);
1879               err = NULL;
1880             }
1881         }
1882     }
1883
1884     if (other_user_ids)
1885       {
1886         strlist_t strlist_iter;
1887
1888         es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1889         for (strlist_iter = other_user_ids;
1890              strlist_iter;
1891              strlist_iter = strlist_iter->next)
1892           {
1893             char *other_user_id = strlist_iter->d;
1894             char *other_thing;
1895             enum tofu_policy other_policy;
1896
1897             assert (strlist_iter->next);
1898             strlist_iter = strlist_iter->next;
1899             other_thing = strlist_iter->d;
1900
1901             if (opt.tofu_db_format == TOFU_DB_SPLIT)
1902               other_policy = get_policy (dbs, fingerprint, other_thing, NULL);
1903             else
1904               other_policy = atoi (other_thing);
1905
1906             es_fprintf (fp, "  %s (", other_user_id);
1907             es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1908             es_fprintf (fp, ")\n");
1909           }
1910         es_fprintf (fp, "\n");
1911
1912         free_strlist (other_user_ids);
1913       }
1914
1915     /* Find other keys associated with this email address.  */
1916     /* XXX: When generating the statistics, do we want the time
1917        embedded in the signature (column 'sig_time') or the time that
1918        we first verified the signature (column 'time').  */
1919     rc = sqlite3_stepx
1920       (db->db, &db->s.get_trust_gather_other_keys,
1921        signature_stats_collect_cb, &stats, &err,
1922        "select fingerprint, policy, time_ago, count(*)\n"
1923        " from (select bindings.*,\n"
1924        "        case\n"
1925        /* From the future (but if its just a couple of hours in the
1926           future don't turn it into a warning)?  Or should we use
1927           small, medium or large units?  (Note: whatever we do, we
1928           keep the value in seconds.  Then when we group, everything
1929           that rounds to the same number of seconds is grouped.)  */
1930        "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1931        "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1932        "          then max(0,\n"
1933        "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1934        "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1935        "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1936        "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1937        "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1938        "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1939        "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1940        "        end time_ago,\n"
1941        "        delta time_ago_raw\n"
1942        "       from bindings\n"
1943        "       left join\n"
1944        "         (select *,\n"
1945        "            cast(strftime('%s','now') - sig_time as real) delta\n"
1946        "           from signatures) ss\n"
1947        "        on ss.binding = bindings.oid)\n"
1948        " where email = ?\n"
1949        " group by fingerprint, time_ago\n"
1950        /* Make sure the current key is first.  */
1951        " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1952        SQLITE_ARG_STRING, email, SQLITE_ARG_STRING, fingerprint,
1953        SQLITE_ARG_END);
1954     if (rc)
1955       {
1956         strlist_t strlist_iter;
1957
1958         log_error (_("error gathering signature stats: %s\n"), err);
1959         sqlite3_free (err);
1960         err = NULL;
1961
1962         es_fprintf (fp, ngettext("The email address \"%s\" is"
1963                                  " associated with %d key:\n",
1964                                  "The email address \"%s\" is"
1965                                  " associated with %d keys:\n",
1966                                  bindings_with_this_email_count),
1967                     email, bindings_with_this_email_count);
1968         for (strlist_iter = bindings_with_this_email;
1969              strlist_iter;
1970              strlist_iter = strlist_iter->next)
1971           es_fprintf (fp, "  %s\n", strlist_iter->d);
1972       }
1973     else
1974       {
1975         char *key = NULL;
1976
1977         if (! stats || strcmp (stats->fingerprint, fingerprint) != 0)
1978           /* If we have already added this key to the DB, then it will
1979              be first (see the above select).  Since the first key on
1980              the list is not this key, we must not yet have verified
1981              any messages signed by this key.  Add a dummy entry.  */
1982           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1983
1984         es_fprintf
1985           (fp, _("Statistics for keys with the email address \"%s\":\n"),
1986            email);
1987         for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1988           {
1989             if (! key || strcmp (key, stats_iter->fingerprint) != 0)
1990               {
1991                 int this_key;
1992                 char *key_pp;
1993                 key = stats_iter->fingerprint;
1994                 this_key = strcmp (key, fingerprint) == 0;
1995                 key_pp = format_hexfingerprint (key, NULL, 0);
1996                 es_fprintf (fp, "  %s (", key_pp);
1997                 if (this_key)
1998                   es_fprintf (fp, _("this key"));
1999                 else
2000                   es_fprintf (fp, _("policy: %s"),
2001                               tofu_policy_str (stats_iter->policy));
2002                 es_fputs ("):\n", fp);
2003                 xfree (key_pp);
2004               }
2005
2006             es_fputs ("    ", fp);
2007             if (stats_iter->time_ago == -1)
2008               es_fprintf (fp, ngettext("%ld message signed in the future.",
2009                                        "%ld messages signed in the future.",
2010                                        stats_iter->count), stats_iter->count);
2011             else
2012               {
2013                 long t_scaled = time_ago_scale (stats_iter->time_ago);
2014
2015                 /* TANSLATORS: This string is concatenated with one of
2016                  * the day/week/month strings to form one sentence.  */
2017                 es_fprintf (fp, ngettext("%ld message signed",
2018                                          "%ld messages signed",
2019                                          stats_iter->count), stats_iter->count);
2020                 if (!stats_iter->count)
2021                   es_fputs (".", fp);
2022                 else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
2023                   es_fprintf (fp, ngettext(" over the past %ld day.",
2024                                            " over the past %ld days.",
2025                                            t_scaled), t_scaled);
2026                 else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
2027                   es_fprintf (fp, ngettext(" over the past %ld week.",
2028                                            " over the past %ld weeks.",
2029                                            t_scaled), t_scaled);
2030                 else
2031                   es_fprintf (fp, ngettext(" over the past %ld month.",
2032                                            " over the past %ld months.",
2033                                            t_scaled), t_scaled);
2034               }
2035             es_fputs ("\n", fp);
2036           }
2037       }
2038
2039     if (is_conflict)
2040       {
2041         /* TRANSLATORS: Please translate the text found in the source
2042            file below.  We don't directly internationalize that text
2043            so that we can tweak it without breaking translations.  */
2044         char *text = _("TOFU detected a binding conflict");
2045         if (strcmp (text, "TOFU detected a binding conflict") == 0)
2046           /* No translation.  Use the English text.  */
2047           text =
2048             "Normally, there is only a single key associated with an email "
2049             "address.  However, people sometimes generate a new key if "
2050             "their key is too old or they think it might be compromised.  "
2051             "Alternatively, a new key may indicate a man-in-the-middle "
2052             "attack!  Before accepting this key, you should talk to or "
2053             "call the person to make sure this new key is legitimate.";
2054         text = format_text (text, 0, 72, 80);
2055         es_fprintf (fp, "\n%s\n", text);
2056         xfree (text);
2057       }
2058
2059     es_fputc ('\n', fp);
2060
2061     /* Add a NUL terminator.  */
2062     es_fputc (0, fp);
2063     if (es_fclose_snatch (fp, (void **) &prompt, NULL))
2064       log_fatal ("error snatching memory stream\n");
2065
2066     /* I think showing the large message once is sufficient.  If we
2067        would move it right before the cpr_get many lines will scroll
2068        away and the user might not realize that he merely entered a
2069        wrong choise (because he does not see that either).  As a small
2070        benefit we allow C-L to redisplay everything.  */
2071     tty_printf ("%s", prompt);
2072     while (1)
2073       {
2074         char *response;
2075
2076         /* TRANSLATORS: Two letters (normally the lower and upper case
2077            version of the hotkey) for each of the five choices.  If
2078            there is only one choice in your language, repeat it.  */
2079         choices = _("gG" "aA" "uU" "rR" "bB");
2080         if (strlen (choices) != 10)
2081           log_bug ("Bad TOFU conflict translation!  Please report.");
2082
2083         response = cpr_get
2084           ("tofu.conflict",
2085            _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
2086         trim_spaces (response);
2087         cpr_kill_prompt ();
2088         if (*response == CONTROL_L)
2089           tty_printf ("%s", prompt);
2090         else if (strlen (response) == 1)
2091           {
2092             char *choice = strchr (choices, *response);
2093             if (choice)
2094               {
2095                 int c = ((size_t) choice - (size_t) choices) / 2;
2096
2097                 switch (c)
2098                   {
2099                   case 0: /* Good.  */
2100                     policy = TOFU_POLICY_GOOD;
2101                     trust_level = tofu_policy_to_trust_level (policy);
2102                     break;
2103                   case 1: /* Accept once.  */
2104                     policy = TOFU_POLICY_ASK;
2105                     trust_level =
2106                       tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
2107                     break;
2108                   case 2: /* Unknown.  */
2109                     policy = TOFU_POLICY_UNKNOWN;
2110                     trust_level = tofu_policy_to_trust_level (policy);
2111                     break;
2112                   case 3: /* Reject once.  */
2113                     policy = TOFU_POLICY_ASK;
2114                     trust_level =
2115                       tofu_policy_to_trust_level (TOFU_POLICY_BAD);
2116                     break;
2117                   case 4: /* Bad.  */
2118                     policy = TOFU_POLICY_BAD;
2119                     trust_level = tofu_policy_to_trust_level (policy);
2120                     break;
2121                   default:
2122                     log_bug ("c should be between 0 and 4 but it is %d!", c);
2123                   }
2124
2125                 if (record_binding (dbs, fingerprint, email, user_id,
2126                                     policy, 0) != 0)
2127                   /* If there's an error registering the
2128                      binding, don't save the signature.  */
2129                   trust_level = _tofu_GET_TRUST_ERROR;
2130
2131                 break;
2132               }
2133           }
2134         xfree (response);
2135       }
2136
2137     xfree (prompt);
2138
2139     signature_stats_free (stats);
2140   }
2141
2142  out:
2143   if (change_conflicting_to_ask)
2144     {
2145       if (! may_ask)
2146         /* If we weren't allowed to ask, also update this key as
2147            conflicting with itself.  */
2148         rc = sqlite3_exec_printf
2149           (db->db, NULL, NULL, &err,
2150            "update bindings set policy = %d, conflict = %Q"
2151            " where email = %Q"
2152            "  and (policy = %d or (policy = %d and fingerprint = %Q));",
2153            TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
2154            TOFU_POLICY_ASK, fingerprint);
2155       else
2156         rc = sqlite3_exec_printf
2157           (db->db, NULL, NULL, &err,
2158            "update bindings set policy = %d, conflict = %Q"
2159            " where email = %Q and fingerprint != %Q and policy = %d;",
2160            TOFU_POLICY_ASK, fingerprint, email, fingerprint, TOFU_POLICY_AUTO);
2161       if (rc)
2162         {
2163           log_error (_("error changing TOFU policy: %s\n"), err);
2164           sqlite3_free (err);
2165           goto out;
2166         }
2167     }
2168
2169   xfree (conflict);
2170   free_strlist (bindings_with_this_email);
2171   xfree (fingerprint_pp);
2172
2173   return trust_level;
2174 }
2175
2176
2177 /* Return a malloced string of the form
2178  *    "7 months, 1 day, 5 minutes, 0 seconds"
2179  * The caller must free that string.
2180  *
2181  * This is actually a bad hack which may not work correctly with all
2182  * languages.
2183  */
2184 static char *
2185 time_ago_str (long long int t)
2186 {
2187   estream_t fp;
2188   int years = 0;
2189   int months = 0;
2190   int days = 0;
2191   int hours = 0;
2192   int minutes = 0;
2193   int seconds = 0;
2194
2195   /* The number of units that we've printed so far.  */
2196   int count = 0;
2197   /* The first unit that we printed (year = 0, month = 1,
2198      etc.).  */
2199   int first = -1;
2200   /* The current unit.  */
2201   int i = 0;
2202
2203   char *str;
2204
2205   /* It would be nice to use a macro to do this, but gettext
2206      works on the unpreprocessed code.  */
2207 #define MIN_SECS (60)
2208 #define HOUR_SECS (60 * MIN_SECS)
2209 #define DAY_SECS (24 * HOUR_SECS)
2210 #define MONTH_SECS (30 * DAY_SECS)
2211 #define YEAR_SECS (365 * DAY_SECS)
2212
2213   if (t > YEAR_SECS)
2214     {
2215       years = t / YEAR_SECS;
2216       t -= years * YEAR_SECS;
2217     }
2218   if (t > MONTH_SECS)
2219     {
2220       months = t / MONTH_SECS;
2221       t -= months * MONTH_SECS;
2222     }
2223   if (t > DAY_SECS)
2224     {
2225       days = t / DAY_SECS;
2226       t -= days * DAY_SECS;
2227     }
2228   if (t > HOUR_SECS)
2229     {
2230       hours = t / HOUR_SECS;
2231       t -= hours * HOUR_SECS;
2232     }
2233   if (t > MIN_SECS)
2234     {
2235       minutes = t / MIN_SECS;
2236       t -= minutes * MIN_SECS;
2237     }
2238   seconds = t;
2239
2240 #undef MIN_SECS
2241 #undef HOUR_SECS
2242 #undef DAY_SECS
2243 #undef MONTH_SECS
2244 #undef YEAR_SECS
2245
2246   fp = es_fopenmem (0, "rw,samethread");
2247   if (! fp)
2248     log_fatal ("error creating memory stream: %s\n",
2249                gpg_strerror (gpg_error_from_syserror()));
2250
2251   if (years)
2252     {
2253       es_fprintf (fp, ngettext("%d year", "%d years", years), years);
2254       count ++;
2255       first = i;
2256     }
2257   i ++;
2258   if ((first == -1 || i - first <= 3) && months)
2259     {
2260       if (count)
2261         es_fprintf (fp, ", ");
2262       es_fprintf (fp, ngettext("%d month", "%d months", months), months);
2263       count ++;
2264       first = i;
2265     }
2266   i ++;
2267   if ((first == -1 || i - first <= 3) && count < 2 && days)
2268     {
2269       if (count)
2270         es_fprintf (fp, ", ");
2271       es_fprintf (fp, ngettext("%d day", "%d days", days), days);
2272       count ++;
2273       first = i;
2274     }
2275   i ++;
2276   if ((first == -1 || i - first <= 3) && count < 2 && hours)
2277     {
2278       if (count)
2279         es_fprintf (fp, ", ");
2280       es_fprintf (fp, ngettext("%d hour", "%d hours", hours), hours);
2281       count ++;
2282       first = i;
2283     }
2284   i ++;
2285   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
2286     {
2287       if (count)
2288         es_fprintf (fp, ", ");
2289       es_fprintf (fp, ngettext("%d minute", "%d minutes", minutes), minutes);
2290       count ++;
2291       first = i;
2292     }
2293   i ++;
2294   if ((first == -1 || i - first <= 3) && count < 2)
2295     {
2296       if (count)
2297         es_fprintf (fp, ", ");
2298       es_fprintf (fp, ngettext("%d second", "%d seconds", seconds), seconds);
2299     }
2300
2301   es_fputc (0, fp);
2302   if (es_fclose_snatch (fp, (void **) &str, NULL))
2303     log_fatal ("error snatching memory stream\n");
2304
2305   return str;
2306 }
2307
2308
2309 static void
2310 show_statistics (struct dbs *dbs, const char *fingerprint,
2311                  const char *email, const char *user_id,
2312                  const char *sig_exclude)
2313 {
2314   struct db *db;
2315   char *fingerprint_pp;
2316   int rc;
2317   strlist_t strlist = NULL;
2318   char *err = NULL;
2319
2320   db = getdb (dbs, email, DB_EMAIL);
2321   if (! db)
2322     return;
2323
2324   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2325
2326   rc = sqlite3_exec_printf
2327     (db->db, strings_collect_cb, &strlist, &err,
2328      "select count (*), strftime('%%s','now') - min (signatures.time),\n"
2329      "  strftime('%%s','now') - max (signatures.time)\n"
2330      " from signatures\n"
2331      " left join bindings on signatures.binding = bindings.oid\n"
2332      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
2333      fingerprint, email,
2334      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
2335         not NULL.  */
2336      sig_exclude ? "!= '" : "is not NULL",
2337      sig_exclude ? sig_exclude : "",
2338      sig_exclude ? "'" : "");
2339   if (rc)
2340     {
2341       log_error (_("error reading TOFU database: %s\n"), err);
2342       print_further_info ("getting statistics");
2343       sqlite3_free (err);
2344       goto out;
2345     }
2346
2347   if (! strlist)
2348     log_info (_("Have never verified a message signed by key %s!\n"),
2349               fingerprint_pp);
2350   else
2351     {
2352       char *tail = NULL;
2353       signed long messages;
2354       signed long first_seen_ago;
2355       signed long most_recent_seen_ago;
2356
2357       assert (strlist_length (strlist) == 3);
2358
2359       errno = 0;
2360       messages = strtol (strlist->d, &tail, 0);
2361       if (errno || *tail != '\0')
2362         /* Abort.  */
2363         {
2364           log_debug ("%s:%d: Couldn't convert %s (messages) to an int: %s.\n",
2365                      __func__, __LINE__, strlist->d, strerror (errno));
2366           messages = -1;
2367         }
2368
2369       if (messages == 0 && *strlist->next->d == '\0')
2370         /* min(NULL) => NULL => "".  */
2371         {
2372           first_seen_ago = -1;
2373           most_recent_seen_ago = -1;
2374         }
2375       else
2376         {
2377           errno = 0;
2378           first_seen_ago = strtol (strlist->next->d, &tail, 0);
2379           if (errno || *tail != '\0')
2380             /* Abort.  */
2381             {
2382               log_debug ("%s:%d: Couldn't convert %s (first_seen) to an int: %s.\n",
2383                          __func__, __LINE__,
2384                          strlist->next->d, strerror (errno));
2385               first_seen_ago = 0;
2386             }
2387
2388           errno = 0;
2389           most_recent_seen_ago = strtol (strlist->next->next->d, &tail, 0);
2390           if (errno || *tail != '\0')
2391             /* Abort.  */
2392             {
2393               log_debug ("%s:%d: Couldn't convert %s (most_recent_seen) to an int: %s.\n",
2394                          __func__, __LINE__,
2395                          strlist->next->next->d, strerror (errno));
2396               most_recent_seen_ago = 0;
2397             }
2398         }
2399
2400       if (messages == -1 || first_seen_ago == 0)
2401         log_info (_("Failed to collect signature statistics"
2402                     " for \"%s\" (key %s)\n"),
2403                   user_id, fingerprint_pp);
2404       else
2405         {
2406           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2407           estream_t fp;
2408           char *msg;
2409
2410           fp = es_fopenmem (0, "rw,samethread");
2411           if (! fp)
2412             log_fatal ("error creating memory stream\n");
2413
2414           if (messages == 0)
2415             es_fprintf (fp,
2416                         _("Verified 0 messages signed by \"%s\""
2417                           " (key: %s, policy: %s)."),
2418                         user_id, fingerprint_pp, tofu_policy_str (policy));
2419           else
2420             {
2421               char *first_seen_ago_str =
2422                 time_ago_str (first_seen_ago);
2423               char *most_recent_seen_ago_str =
2424                 time_ago_str (most_recent_seen_ago);
2425
2426               /* TRANSLATORS: The final %s is replaced by a string like
2427                  "7 months, 1 day, 5 minutes, 0 seconds". */
2428               es_fprintf (fp, ngettext("Verified %ld message signed by \"%s\""
2429                                        " (key: %s, policy: %s) in the past %s.",
2430                                        "Verified %ld messages signed by \"%s\""
2431                                        " (key: %s, policy: %s) in the past %s.",
2432                                        messages),
2433                           messages, user_id,
2434                           fingerprint_pp, tofu_policy_str (policy),
2435                           first_seen_ago_str);
2436
2437               if (messages > 1)
2438                 {
2439                   es_fputs ("  ", fp);
2440                   es_fprintf (fp,
2441                               _("The most recent message was verified %s ago."),
2442                               most_recent_seen_ago_str);
2443                 }
2444
2445               xfree (first_seen_ago_str);
2446               xfree (most_recent_seen_ago_str);
2447             }
2448
2449           es_fputc (0, fp);
2450           if (es_fclose_snatch (fp, (void **) &msg, NULL))
2451             log_fatal ("error snatching memory stream\n");
2452
2453           log_info ("%s\n", msg);
2454           xfree (msg);
2455
2456           if (policy == TOFU_POLICY_AUTO && messages < 10)
2457             {
2458               char *set_policy_command;
2459               char *text;
2460               char *tmp;
2461
2462               if (messages == 0)
2463                 log_info (_("Warning: we've have yet to see"
2464                             " a message signed by this key!\n"));
2465               else if (messages == 1)
2466                 log_info (_("Warning: we've only seen a"
2467                             " single message signed by this key!\n"));
2468
2469               set_policy_command =
2470                 xasprintf ("gpg --tofu-policy bad \"%s\"", fingerprint);
2471               /* TRANSLATORS: translate the below text.  We don't
2472                  directly internationalize that text so that we can
2473                  tweak it without breaking translations.  */
2474               text = ngettext("TOFU: few signatures %d message %s",
2475                               "TOFU: few signatures %d messages %s", 1);
2476               if (strcmp (text, "TOFU: few signatures %d message %s") == 0)
2477                 {
2478                   text =
2479                     (messages == 1?
2480                      "Warning: if you think you've seen more than %d message "
2481                      "signed by this key, then this key might be a forgery!  "
2482                      "Carefully examine the email address for small variations "
2483                      "(e.g., additional white space).  If the key is suspect, "
2484                      "then use '%s' to mark it as being bad.\n"
2485                      :
2486                      "Warning: if you think you've seen more than %d messages "
2487                      "signed by this key, then this key might be a forgery!  "
2488                      "Carefully examine the email address for small variations "
2489                      "(e.g., additional white space).  If the key is suspect, "
2490                      "then use '%s' to mark it as being bad.\n");
2491                 }
2492
2493               tmp = xasprintf (text, messages, set_policy_command);
2494               text = format_text (tmp, 0, 72, 80);
2495               xfree (tmp);
2496               log_info ("%s", text);
2497               xfree (text);
2498               free (set_policy_command);
2499             }
2500         }
2501     }
2502
2503  out:
2504   free_strlist (strlist);
2505   xfree (fingerprint_pp);
2506
2507   return;
2508 }
2509
2510 /* Extract the email address from a user id and normalize it.  If the
2511    user id doesn't contain an email address, then we use the whole
2512    user_id and normalize that.  The returned string must be freed.  */
2513 static char *
2514 email_from_user_id (const char *user_id)
2515 {
2516   char *email = mailbox_from_userid (user_id);
2517   if (! email)
2518     {
2519       /* Hmm, no email address was provided or we are out of core.  Just
2520          take the lower-case version of the whole user id.  It could be
2521          a hostname, for instance.  */
2522       email = ascii_strlwr (xstrdup (user_id));
2523     }
2524
2525   return email;
2526 }
2527
2528 /* Register the signature with the binding <fingerprint, USER_ID>.
2529    The fingerprint is taken from the primary key packet PK.
2530
2531    SIG_DIGEST_BIN is the binary representation of the message's
2532    digest.  SIG_DIGEST_BIN_LEN is its length.
2533
2534    SIG_TIME is the time that the signature was generated.
2535
2536    ORIGIN is a free-formed string describing the origin of the
2537    signature.  If this was from an email and the Claws MUA was used,
2538    then this should be something like: "email:claws".  If this is
2539    NULL, the default is simply "unknown".
2540
2541    If MAY_ASK is 1, then this function may interact with the user.
2542    This is necessary if there is a conflict or the binding's policy is
2543    TOFU_POLICY_ASK.
2544
2545    This function returns the binding's trust level on return.  If an
2546    error occurs, this function returns TRUST_UNKNOWN.  */
2547 int
2548 tofu_register (PKT_public_key *pk, const char *user_id,
2549                const byte *sig_digest_bin, int sig_digest_bin_len,
2550                time_t sig_time, const char *origin, int may_ask)
2551 {
2552   struct dbs *dbs;
2553   struct db *db;
2554   char *fingerprint = NULL;
2555   char *fingerprint_pp = NULL;
2556   char *email = NULL;
2557   char *err = NULL;
2558   int rc;
2559   int trust_level = TRUST_UNKNOWN;
2560   char *sig_digest;
2561   unsigned long c;
2562   int already_verified = 0;
2563
2564   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2565
2566   dbs = opendbs ();
2567   if (! dbs)
2568     {
2569       log_error (_("error opening TOFU database: %s\n"),
2570                  gpg_strerror (GPG_ERR_GENERAL));
2571       goto die;
2572     }
2573
2574   fingerprint = hexfingerprint (pk, NULL, 0);
2575   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2576
2577   if (! *user_id)
2578     {
2579       log_debug ("TOFU: user id is empty.  Can't continue.\n");
2580       goto die;
2581     }
2582
2583   email = email_from_user_id (user_id);
2584
2585   if (! origin)
2586     /* The default origin is simply "unknown".  */
2587     origin = "unknown";
2588
2589   /* It's necessary to get the trust so that we are certain that the
2590      binding has been registered.  */
2591   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2592   if (trust_level == _tofu_GET_TRUST_ERROR)
2593     /* An error.  */
2594     {
2595       trust_level = TRUST_UNKNOWN;
2596       goto die;
2597     }
2598
2599   /* Save the observed signature in the DB.  */
2600   db = getdb (dbs, email, DB_EMAIL);
2601   if (! db)
2602     {
2603       log_error (_("error opening TOFU database: %s\n"),
2604                  gpg_strerror (GPG_ERR_GENERAL));
2605       goto die;
2606     }
2607
2608   /* We do a query and then an insert.  Make sure they are atomic
2609      by wrapping them in a transaction.  */
2610   rc = begin_transaction (db, 0);
2611   if (rc)
2612     goto die;
2613
2614   /* If we've already seen this signature before, then don't add
2615      it again.  */
2616   rc = sqlite3_stepx
2617     (db->db, &db->s.register_already_seen,
2618      get_single_unsigned_long_cb2, &c, &err,
2619      "select count (*)\n"
2620      " from signatures left join bindings\n"
2621      "  on signatures.binding = bindings.oid\n"
2622      " where fingerprint = ? and email = ? and sig_time = ?\n"
2623      "  and sig_digest = ?",
2624      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2625      SQLITE_ARG_LONG_LONG, (long long) sig_time,
2626      SQLITE_ARG_STRING, sig_digest,
2627      SQLITE_ARG_END);
2628   if (rc)
2629     {
2630       log_error (_("error reading TOFU database: %s\n"), err);
2631       print_further_info ("checking existence");
2632       sqlite3_free (err);
2633     }
2634   else if (c > 1)
2635     /* Duplicates!  This should not happen.  In particular,
2636        because <fingerprint, email, sig_time, sig_digest> is the
2637        primary key!  */
2638     log_debug ("SIGNATURES DB contains duplicate records"
2639                " <key: %s, %s, time: 0x%lx, sig: %s, %s>."
2640                "  Please report.\n",
2641                fingerprint_pp, email, (unsigned long) sig_time,
2642                sig_digest, origin);
2643   else if (c == 1)
2644     {
2645       already_verified = 1;
2646       if (DBG_TRUST)
2647         log_debug ("Already observed the signature"
2648                    " <key: %s, %s, time: 0x%lx, sig: %s, %s>\n",
2649                    fingerprint_pp, email, (unsigned long) sig_time,
2650                    sig_digest, origin);
2651     }
2652   else
2653     /* This is the first time that we've seen this signature.
2654        Record it.  */
2655     {
2656       if (DBG_TRUST)
2657         log_debug ("TOFU: Saving signature <%s, %s, %s>\n",
2658                    fingerprint_pp, email, sig_digest);
2659
2660       assert (c == 0);
2661
2662       rc = sqlite3_stepx
2663         (db->db, &db->s.register_insert, NULL, NULL, &err,
2664          "insert into signatures\n"
2665          " (binding, sig_digest, origin, sig_time, time)\n"
2666          " values\n"
2667          " ((select oid from bindings\n"
2668          "    where fingerprint = ? and email = ?),\n"
2669          "  ?, ?, ?, strftime('%s', 'now'));",
2670          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2671          SQLITE_ARG_STRING, sig_digest, SQLITE_ARG_STRING, origin,
2672          SQLITE_ARG_LONG_LONG, (long long) sig_time,
2673          SQLITE_ARG_END);
2674       if (rc)
2675         {
2676           log_error (_("error updating TOFU database: %s\n"), err);
2677           print_further_info ("insert signatures");
2678           sqlite3_free (err);
2679         }
2680     }
2681
2682   /* It only matters whether we abort or commit the transaction
2683      (so long as we do something) if we execute the insert.  */
2684   if (rc)
2685     rc = rollback_transaction (db);
2686   else
2687     rc = end_transaction (db, 0);
2688   if (rc)
2689     {
2690       sqlite3_free (err);
2691       goto die;
2692     }
2693
2694  die:
2695   if (may_ask && trust_level != TRUST_ULTIMATE)
2696     /* It's only appropriate to show the statistics in an interactive
2697        context.  */
2698     show_statistics (dbs, fingerprint, email, user_id,
2699                      already_verified ? NULL : sig_digest);
2700
2701   xfree (email);
2702   xfree (fingerprint_pp);
2703   xfree (fingerprint);
2704   if (dbs)
2705     closedbs (dbs);
2706   xfree (sig_digest);
2707
2708   return trust_level;
2709 }
2710
2711 /* Combine a trust level returned from the TOFU trust model with a
2712    trust level returned by the PGP trust model.  This is primarily of
2713    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2714
2715    This function ors together the upper bits (the values not covered
2716    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2717 int
2718 tofu_wot_trust_combine (int tofu_base, int wot_base)
2719 {
2720   int tofu = tofu_base & TRUST_MASK;
2721   int wot = wot_base & TRUST_MASK;
2722   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2723
2724   assert (tofu == TRUST_UNKNOWN
2725           || tofu == TRUST_EXPIRED
2726           || tofu == TRUST_UNDEFINED
2727           || tofu == TRUST_NEVER
2728           || tofu == TRUST_MARGINAL
2729           || tofu == TRUST_FULLY
2730           || tofu == TRUST_ULTIMATE);
2731   assert (wot == TRUST_UNKNOWN
2732           || wot == TRUST_EXPIRED
2733           || wot == TRUST_UNDEFINED
2734           || wot == TRUST_NEVER
2735           || wot == TRUST_MARGINAL
2736           || wot == TRUST_FULLY
2737           || wot == TRUST_ULTIMATE);
2738
2739   /* We first consider negative trust policys.  These trump positive
2740      trust policies.  */
2741   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2742     /* TRUST_NEVER trumps everything else.  */
2743     return upper | TRUST_NEVER;
2744   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2745     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2746     return upper | TRUST_EXPIRED;
2747
2748   /* Now we only have positive or neutral trust policies.  We take
2749      the max.  */
2750   if (tofu == TRUST_ULTIMATE || wot == TRUST_ULTIMATE)
2751     return upper | TRUST_ULTIMATE;
2752   if (tofu == TRUST_FULLY || wot == TRUST_FULLY)
2753     return upper | TRUST_FULLY;
2754   if (tofu == TRUST_MARGINAL || wot == TRUST_MARGINAL)
2755     return upper | TRUST_MARGINAL;
2756   if (tofu == TRUST_UNDEFINED || wot == TRUST_UNDEFINED)
2757     return upper | TRUST_UNDEFINED;
2758   return upper | TRUST_UNKNOWN;
2759 }
2760
2761 /* Return the validity (TRUST_NEVER, etc.) of the binding
2762    <FINGERPRINT, USER_ID>.
2763
2764    PK is the primary key packet.
2765
2766    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2767    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2768    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2769
2770    Returns TRUST_UNDEFINED if an error occurs.  */
2771 int
2772 tofu_get_validity (PKT_public_key *pk, const char *user_id,
2773                    int may_ask)
2774 {
2775   struct dbs *dbs;
2776   char *fingerprint = NULL;
2777   char *email = NULL;
2778   int trust_level = TRUST_UNDEFINED;
2779
2780   dbs = opendbs ();
2781   if (! dbs)
2782     {
2783       log_error (_("error opening TOFU database: %s\n"),
2784                  gpg_strerror (GPG_ERR_GENERAL));
2785       goto die;
2786     }
2787
2788   fingerprint = hexfingerprint (pk, NULL, 0);
2789
2790   if (! *user_id)
2791     {
2792       log_debug ("user id is empty."
2793                  "  Can't get TOFU validity for this binding.\n");
2794       goto die;
2795     }
2796
2797   email = email_from_user_id (user_id);
2798
2799   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2800   if (trust_level == _tofu_GET_TRUST_ERROR)
2801     /* An error.  */
2802     trust_level = TRUST_UNDEFINED;
2803
2804   if (may_ask && trust_level != TRUST_ULTIMATE)
2805     show_statistics (dbs, fingerprint, email, user_id, NULL);
2806
2807  die:
2808   xfree (email);
2809   xfree (fingerprint);
2810   if (dbs)
2811     closedbs (dbs);
2812
2813   return trust_level;
2814 }
2815
2816 /* Set the policy for all non-revoked user ids in the keyblock KB to
2817    POLICY.
2818
2819    If no key is available with the specified key id, then this
2820    function returns GPG_ERR_NO_PUBKEY.
2821
2822    Returns 0 on success and an error code otherwise.  */
2823 gpg_error_t
2824 tofu_set_policy (kbnode_t kb, enum tofu_policy policy)
2825 {
2826   struct dbs *dbs;
2827   PKT_public_key *pk;
2828   char *fingerprint = NULL;
2829
2830   assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2831   pk = kb->pkt->pkt.public_key;
2832
2833   dbs = opendbs ();
2834   if (! dbs)
2835     {
2836       log_error (_("error opening TOFU database: %s\n"),
2837                  gpg_strerror (GPG_ERR_GENERAL));
2838       return gpg_error (GPG_ERR_GENERAL);
2839     }
2840
2841   if (DBG_TRUST)
2842     log_debug ("Setting TOFU policy for %s to %s\n",
2843                keystr (pk->keyid), tofu_policy_str (policy));
2844   if (! (pk->main_keyid[0] == pk->keyid[0]
2845          && pk->main_keyid[1] == pk->keyid[1]))
2846     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2847
2848   fingerprint = hexfingerprint (pk, NULL, 0);
2849
2850   for (; kb; kb = kb->next)
2851     {
2852       PKT_user_id *user_id;
2853       char *email;
2854
2855       if (kb->pkt->pkttype != PKT_USER_ID)
2856         continue;
2857
2858       user_id = kb->pkt->pkt.user_id;
2859       if (user_id->is_revoked)
2860         /* Skip revoked user ids.  (Don't skip expired user ids, the
2861            expiry can be changed.)  */
2862         continue;
2863
2864       email = email_from_user_id (user_id->name);
2865
2866       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2867
2868       xfree (email);
2869     }
2870
2871   xfree (fingerprint);
2872   closedbs (dbs);
2873
2874   return 0;
2875 }
2876
2877 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2878    the key id KEYID to POLICY.
2879
2880    If no key is available with the specified key id, then this
2881    function returns GPG_ERR_NO_PUBKEY.
2882
2883    Returns 0 on success and an error code otherwise.  */
2884 gpg_error_t
2885 tofu_set_policy_by_keyid (u32 *keyid, enum tofu_policy policy)
2886 {
2887   kbnode_t keyblock = get_pubkeyblock (keyid);
2888   if (! keyblock)
2889     return gpg_error (GPG_ERR_NO_PUBKEY);
2890
2891   return tofu_set_policy (keyblock, policy);
2892 }
2893
2894 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2895    policy has been set for the binding, sets *POLICY to
2896    TOFU_POLICY_NONE.
2897
2898    PK is a primary public key and USER_ID is a user id.
2899
2900    Returns 0 on success and an error code otherwise.  */
2901 gpg_error_t
2902 tofu_get_policy (PKT_public_key *pk, PKT_user_id *user_id,
2903                  enum tofu_policy *policy)
2904 {
2905   struct dbs *dbs;
2906   char *fingerprint;
2907   char *email;
2908
2909   /* Make sure PK is a primary key.  */
2910   assert (pk->main_keyid[0] == pk->keyid[0]
2911           && pk->main_keyid[1] == pk->keyid[1]);
2912
2913   dbs = opendbs ();
2914   if (! dbs)
2915     {
2916       log_error (_("error opening TOFU database: %s\n"),
2917                  gpg_strerror (GPG_ERR_GENERAL));
2918       return gpg_error (GPG_ERR_GENERAL);
2919     }
2920
2921   fingerprint = hexfingerprint (pk, NULL, 0);
2922
2923   email = email_from_user_id (user_id->name);
2924
2925   *policy = get_policy (dbs, fingerprint, email, NULL);
2926
2927   xfree (email);
2928   xfree (fingerprint);
2929   closedbs (dbs);
2930
2931   if (*policy == _tofu_GET_POLICY_ERROR)
2932     return gpg_error (GPG_ERR_GENERAL);
2933   return 0;
2934 }