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