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