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