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