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