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