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