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