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