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