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