a2732ff6371e5e5b19ff1782475fef6d5996cbce
[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 "gpgsql.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().  Cleanup is done
88    when the CTRL object is released.  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 = gpgsql_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 = gpgsql_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 = gpgsql_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 = gpgsql_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 = gpgsql_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 = gpgsql_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 (gnupg_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 /* Definition of the Tofu dabase meta handle.  */
786 struct tofu_dbs_s
787 {
788   struct db *db;
789 };
790
791 static void
792 unlink_db (struct db *db)
793 {
794   *db->prevp = db->next;
795   if (db->next)
796     db->next->prevp = db->prevp;
797 }
798
799 static void
800 link_db (struct db **head, struct db *db)
801 {
802   db->next = *head;
803   if (db->next)
804     db->next->prevp = &db->next;
805   db->prevp = head;
806   *head = db;
807 }
808
809 /* Return a database handle.  <type, name> describes the required
810    database.  If there is a cached handle in DBS, that handle is
811    returned.  Otherwise, the database is opened and cached in DBS.
812
813    NAME is the name of the DB and may not be NULL.
814
815    TYPE must be either DB_MAIL or DB_KEY.  In the combined format, the
816    combined DB is always returned.  */
817 static struct db *
818 getdb (tofu_dbs_t dbs, const char *name, enum db_type type)
819 {
820   struct db *t = NULL;
821   char *name_sanitized = NULL;
822   int count;
823   char *filename = NULL;
824   int need_link = 1;
825   sqlite3 *sqlitedb = NULL;
826   gpg_error_t rc;
827
828   log_assert (dbs);
829   log_assert (name);
830   log_assert (type == DB_EMAIL || type == DB_KEY);
831
832   if (opt.tofu_db_format == TOFU_DB_FLAT)
833     /* When using the flat format, we only have a single DB, the
834        combined DB.  */
835     {
836       if (dbs->db)
837         {
838           log_assert (dbs->db->type == DB_COMBINED);
839           log_assert (! dbs->db->next);
840           return dbs->db;
841         }
842
843       type = DB_COMBINED;
844     }
845
846   if (type != DB_COMBINED)
847     /* Only allow alpha-numeric characters in the name.  */
848     {
849       int i;
850
851       name_sanitized = xstrdup (name);
852       for (i = 0; name[i]; i ++)
853         {
854           char c = name_sanitized[i];
855           if (! (('a' <= c && c <= 'z')
856                  || ('A' <= c && c <= 'Z')
857                  || ('0' <= c && c <= '9')))
858             name_sanitized[i] = '_';
859         }
860     }
861
862   /* See if the DB is cached.  */
863   for (t = dbs->db; t; t = t->next)
864     if (t->type == type
865         && (type == DB_COMBINED || strcmp (t->name, name_sanitized) == 0))
866       {
867         need_link = 0;
868         goto out;
869       }
870
871   for (t = db_cache, count = 0; t; t = t->next, count ++)
872     if (type == t->type
873         && (type == DB_COMBINED || strcmp (t->name, name_sanitized) == 0))
874       {
875         unlink_db (t);
876         db_cache_count --;
877         goto out;
878       }
879
880   log_assert (db_cache_count == count);
881
882   if (type == DB_COMBINED)
883     filename = NULL;
884   else
885     {
886       /* Open the DB.  The filename has the form:
887
888          tofu.d/TYPE/PREFIX/NAME.db
889
890          We use a short prefix to try to avoid having many files in a
891          single directory.  */
892       {
893         char *type_str = type == DB_EMAIL ? "email" : "key";
894         char prefix[3] = { name_sanitized[0], name_sanitized[1], 0 };
895         char *name_db;
896
897         /* Make the directory.  */
898         rc = gnupg_mkdir_p (gnupg_homedir (), "tofu.d", type_str, prefix, NULL);
899         if (rc)
900           {
901             name_db = xstrconcat (gnupg_homedir (), "tofu.d",
902                                   type_str, prefix, NULL);
903             log_error (_("can't create directory '%s': %s\n"),
904                        name_db, gpg_strerror (rc));
905             xfree (name_db);
906             goto out;
907           }
908
909         name_db = xstrconcat (name_sanitized, ".db", NULL);
910         filename = make_filename
911           (gnupg_homedir (), "tofu.d", type_str, prefix, name_db, NULL);
912         xfree (name_db);
913       }
914     }
915
916   sqlitedb = opendb (filename, type);
917   if (! sqlitedb)
918     goto out;
919
920   t = xmalloc_clear (sizeof (struct db)
921                      + (name_sanitized ? strlen (name_sanitized) : 0));
922   t->type = type;
923   t->db = sqlitedb;
924   if (name_sanitized)
925     strcpy (t->name, name_sanitized);
926
927  out:
928   if (t && need_link)
929     link_db (&dbs->db, t);
930
931 #if DEBUG_TOFU_CACHE
932   if (t)
933     t->hits ++;
934 #endif
935
936   xfree (filename);
937   xfree (name_sanitized);
938   return t;
939 }
940
941 static void
942 closedb (struct db *db)
943 {
944   sqlite3_stmt **statements;
945
946   if (opt.tofu_db_format == TOFU_DB_FLAT)
947     /* If we are using the flat format, then there is only ever the
948        combined DB.  */
949     log_assert (! db->next);
950
951   if (db->type == DB_COMBINED)
952     {
953       log_assert (opt.tofu_db_format == TOFU_DB_FLAT);
954       log_assert (! db->name[0]);
955     }
956   else
957     {
958       log_assert (opt.tofu_db_format == TOFU_DB_SPLIT);
959       log_assert (db->type != DB_COMBINED);
960       log_assert (db->name[0]);
961     }
962
963   if (db->batch_update)
964     end_transaction (db, 2);
965
966   for (statements = (void *) &db->s;
967        (void *) statements < (void *) &(&db->s)[1];
968        statements ++)
969     sqlite3_finalize (*statements);
970
971   sqlite3_close (db->db);
972
973 #if DEBUG_TOFU_CACHE
974   log_debug ("Freeing db.  Used %d times.\n", db->hits);
975 #endif
976
977   xfree (db);
978 }
979
980
981 /* Create a new DB meta-handle.  Returns NULL on error.  */
982 /* FIXME: Change to return an error code for better reporting by the
983    caller.  */
984 static tofu_dbs_t
985 opendbs (ctrl_t ctrl)
986 {
987   if (ctrl->tofu.dbs)
988     return ctrl->tofu.dbs;
989
990   if (opt.tofu_db_format == TOFU_DB_AUTO)
991     {
992       char *filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
993       struct stat s;
994       int have_tofu_db = 0;
995       int have_tofu_d = 0;
996
997       if (stat (filename, &s) == 0)
998         {
999           have_tofu_db = 1;
1000           if (DBG_TRUST)
1001             log_debug ("%s exists.\n", filename);
1002         }
1003       else
1004         {
1005           if (DBG_TRUST)
1006             log_debug ("%s does not exist.\n", filename);
1007         }
1008
1009       /* We now have tofu.d.  */
1010       filename[strlen (filename) - 1] = '\0';
1011       if (stat (filename, &s) == 0)
1012         {
1013           have_tofu_d = 1;
1014           if (DBG_TRUST)
1015             log_debug ("%s exists.\n", filename);
1016         }
1017       else
1018         {
1019           if (DBG_TRUST)
1020             log_debug ("%s does not exist.\n", filename);
1021         }
1022
1023       xfree (filename);
1024
1025       if (have_tofu_db && have_tofu_d)
1026         {
1027           log_info (_("Warning: Home directory contains both tofu.db"
1028                       " and tofu.d.\n"));
1029           log_info (_("Using split format for TOFU database\n"));
1030           opt.tofu_db_format = TOFU_DB_SPLIT;
1031         }
1032       else if (have_tofu_db)
1033         {
1034           opt.tofu_db_format = TOFU_DB_FLAT;
1035           if (DBG_TRUST)
1036             log_debug ("Using flat format for TOFU database.\n");
1037         }
1038       else if (have_tofu_d)
1039         {
1040           opt.tofu_db_format = TOFU_DB_SPLIT;
1041           if (DBG_TRUST)
1042             log_debug ("Using split format for TOFU database.\n");
1043         }
1044       else
1045         {
1046           opt.tofu_db_format = TOFU_DB_FLAT;
1047           if (DBG_TRUST)
1048             log_debug ("Using flat format for TOFU database.\n");
1049         }
1050     }
1051
1052   ctrl->tofu.dbs = xmalloc_clear (sizeof (struct tofu_dbs_s));
1053   return ctrl->tofu.dbs;
1054 }
1055
1056
1057 /* Release all of the resources associated with a DB meta-handle.  */
1058 void
1059 tofu_closedbs (ctrl_t ctrl)
1060 {
1061   tofu_dbs_t dbs = ctrl->tofu.dbs;
1062
1063   if (!dbs)
1064     return;  /* Not initialized.  */
1065
1066   if (dbs->db && dbs->db->type == DB_COMBINED)
1067     {
1068       log_assert (!dbs->db->next);
1069       closedb (dbs->db);
1070     }
1071   else if (dbs->db)
1072     {
1073       struct db *old_head = db_cache;
1074       struct db *db;
1075       int count;
1076
1077       /* Find the last DB.  */
1078       for (db = dbs->db, count = 1; db->next; db = db->next, count ++)
1079         {
1080           /* When we leave batch mode we leave batch mode on any
1081              cached connections.  */
1082           if (! batch_update)
1083             log_assert (! db->batch_update);
1084         }
1085       if (! batch_update)
1086         log_assert (! db->batch_update);
1087
1088       /* Join the two lists.  */
1089       db->next = db_cache;
1090       if (db_cache)
1091         db_cache->prevp = &db->next;
1092
1093       /* Update the (new) first element.  */
1094       db_cache = dbs->db;
1095       dbs->db->prevp = &db_cache;
1096
1097       db_cache_count += count;
1098
1099       /* Make sure that we don't have too many DBs on DB_CACHE.  If
1100          so, free some.  */
1101       if (db_cache_count > DB_CACHE_ENTRIES)
1102         {
1103           /* We need to find the (DB_CACHE_ENTRIES + 1)th entry.  It
1104              is easy to skip the first COUNT entries since we still
1105              have a handle on the old head.  */
1106           int skip = DB_CACHE_ENTRIES - count;
1107           if (skip < 0)
1108             for (old_head = db_cache, skip = DB_CACHE_ENTRIES;
1109                  skip > 0;
1110                  old_head = old_head->next, skip--)
1111               { /* Do nothing.  */ }
1112           else
1113             while (-- skip > 0)
1114               old_head = old_head->next;
1115
1116           *old_head->prevp = NULL;
1117
1118           while (old_head)
1119             {
1120               db = old_head->next;
1121               closedb (old_head);
1122               old_head = db;
1123               db_cache_count --;
1124             }
1125
1126           log_assert (db_cache_count == DB_CACHE_ENTRIES);
1127         }
1128     }
1129
1130   xfree (ctrl->tofu.dbs);
1131   ctrl->tofu.dbs = NULL;
1132
1133 #if DEBUG_TOFU_CACHE
1134   log_debug ("Queries: %d (prepares saved: %d)\n",
1135              queries, prepares_saved);
1136 #endif
1137 }
1138
1139
1140 /* Collect results of a select min (foo) ...; style query.  Aborts if
1141    the argument is not a valid integer (or real of the form X.0).  */
1142 static int
1143 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
1144 {
1145   long *count = cookie;
1146
1147   (void) azColName;
1148
1149   log_assert (argc == 1);
1150
1151   if (string_to_long (count, argv[0], 0, __LINE__))
1152     return 1; /* Abort.  */
1153
1154   return 0;
1155 }
1156
1157 static int
1158 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
1159                      sqlite3_stmt *stmt)
1160 {
1161   (void) stmt;
1162   return get_single_long_cb (cookie, argc, argv, azColName);
1163 }
1164
1165 /* Record (or update) a trust policy about a (possibly new)
1166    binding.
1167
1168    If SHOW_OLD is set, the binding's old policy is displayed.  */
1169 static gpg_error_t
1170 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1171                 const char *user_id, enum tofu_policy policy, int show_old)
1172 {
1173   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
1174   struct db *db_email = NULL, *db_key = NULL;
1175   gpg_error_t rc;
1176   char *err = NULL;
1177   /* policy_old needs to be a long and not an enum tofu_policy,
1178      because we pass it by reference to get_single_long_cb2, which
1179      expects a long.  */
1180   long policy_old = TOFU_POLICY_NONE;
1181
1182   if (! (policy == TOFU_POLICY_AUTO
1183          || policy == TOFU_POLICY_GOOD
1184          || policy == TOFU_POLICY_UNKNOWN
1185          || policy == TOFU_POLICY_BAD
1186          || policy == TOFU_POLICY_ASK))
1187     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
1188
1189   db_email = getdb (dbs, email, DB_EMAIL);
1190   if (! db_email)
1191     {
1192       rc = gpg_error (GPG_ERR_GENERAL);
1193       goto leave;
1194     }
1195
1196   if (opt.tofu_db_format == TOFU_DB_SPLIT)
1197     /* In the split format, we need to update two DBs.  To keep them
1198        consistent, we start a transaction on each.  Note: this is the
1199        only place where we start two transaction and we always start
1200        transaction on the DB_KEY DB first, thus deadlock is not
1201        possible.  */
1202     /* We only need a transaction for the split format.  */
1203     {
1204       db_key = getdb (dbs, fingerprint, DB_KEY);
1205       if (! db_key)
1206         {
1207           rc = gpg_error (GPG_ERR_GENERAL);
1208           goto leave;
1209         }
1210
1211       rc = begin_transaction (db_email, 0);
1212       if (rc)
1213         goto leave;
1214
1215       rc = begin_transaction (db_key, 0);
1216       if (rc)
1217         goto out_revert_one;
1218     }
1219
1220   if (show_old)
1221     /* Get the old policy.  Since this is just for informational
1222        purposes, there is no need to start a transaction or to die if
1223        there is a failure.  */
1224     {
1225       rc = gpgsql_stepx
1226         (db_email->db, &db_email->s.record_binding_get_old_policy,
1227          get_single_long_cb2, &policy_old, &err,
1228          "select policy from bindings where fingerprint = ? and email = ?",
1229          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1230          SQLITE_ARG_END);
1231       if (rc)
1232         {
1233           log_debug ("TOFU: Error reading from binding database"
1234                      " (reading policy for <%s, %s>): %s\n",
1235                      fingerprint, email, err);
1236           sqlite3_free (err);
1237         }
1238     }
1239
1240   if (DBG_TRUST)
1241     {
1242       if (policy_old != TOFU_POLICY_NONE)
1243         log_debug ("Changing TOFU trust policy for binding <%s, %s>"
1244                    " from %s to %s.\n",
1245                    fingerprint, email,
1246                    tofu_policy_str (policy_old),
1247                    tofu_policy_str (policy));
1248       else
1249         log_debug ("Set TOFU trust policy for binding <%s, %s> to %s.\n",
1250                    fingerprint, email,
1251                    tofu_policy_str (policy));
1252     }
1253
1254   if (policy_old == policy)
1255     /* Nothing to do.  */
1256     goto out;
1257
1258   if (opt.dry_run)
1259     {
1260       log_info ("TOFU database update skipped due to --dry-run\n");
1261       goto out;
1262     }
1263
1264   rc = gpgsql_stepx
1265     (db_email->db, &db_email->s.record_binding_update, NULL, NULL, &err,
1266      "insert or replace into bindings\n"
1267      " (oid, fingerprint, email, user_id, time, policy)\n"
1268      " values (\n"
1269      /* If we don't explicitly reuse the OID, then SQLite will
1270         reallocate a new one.  We just need to search for the OID
1271         based on the fingerprint and email since they are unique.  */
1272      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1273      "  ?, ?, ?, strftime('%s','now'), ?);",
1274      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1275      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1276      SQLITE_ARG_STRING, user_id, SQLITE_ARG_INT, (int) policy,
1277      SQLITE_ARG_END);
1278   if (rc)
1279     {
1280       log_error (_("error updating TOFU database: %s\n"), err);
1281       print_further_info (" insert bindings <%s, %s> = %s",
1282                           fingerprint, email, tofu_policy_str (policy));
1283       sqlite3_free (err);
1284       goto out;
1285     }
1286
1287   if (db_key)
1288     /* We also need to update the key DB.  */
1289     {
1290       log_assert (opt.tofu_db_format == TOFU_DB_SPLIT);
1291
1292       rc = gpgsql_stepx
1293         (db_key->db, &db_key->s.record_binding_update2, NULL, NULL, &err,
1294          "insert or replace into bindings\n"
1295          " (oid, fingerprint, email, user_id)\n"
1296          " values (\n"
1297          /* If we don't explicitly reuse the OID, then SQLite will
1298             reallocate a new one.  We just need to search for the OID
1299             based on the fingerprint and email since they are unique.  */
1300          "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1301          "  ?, ?, ?);",
1302          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1303          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1304          SQLITE_ARG_STRING, user_id, SQLITE_ARG_END);
1305       if (rc)
1306         {
1307           log_error (_("error updating TOFU database: %s\n"), err);
1308           print_further_info ("insert bindings <%s, %s>",
1309                               fingerprint, email);
1310           sqlite3_free (err);
1311           goto out;
1312         }
1313     }
1314   else
1315     log_assert (opt.tofu_db_format == TOFU_DB_FLAT);
1316
1317  out:
1318   if (opt.tofu_db_format == TOFU_DB_SPLIT)
1319     /* We only need a transaction for the split format.  */
1320     {
1321       gpg_error_t rc2;
1322
1323       if (rc)
1324         rc2 = rollback_transaction (db_key);
1325       else
1326         rc2 = end_transaction (db_key, 0);
1327       if (rc2)
1328         sqlite3_free (err);
1329
1330     out_revert_one:
1331       if (rc)
1332         rc2 = rollback_transaction (db_email);
1333       else
1334         rc2 = end_transaction (db_email, 0);
1335       if (rc2)
1336         sqlite3_free (err);
1337     }
1338
1339  leave:
1340   xfree (fingerprint_pp);
1341
1342   return rc;
1343 }
1344
1345
1346 /* Collect the strings returned by a query in a simply string list.
1347    Any NULL values are converted to the empty string.
1348
1349    If a result has 3 rows and each row contains two columns, then the
1350    results are added to the list as follows (the value is parentheses
1351    is the 1-based index in the final list):
1352
1353      row 1, col 2 (6)
1354      row 1, col 1 (5)
1355      row 2, col 2 (4)
1356      row 2, col 1 (3)
1357      row 3, col 2 (2)
1358      row 3, col 1 (1)
1359
1360    This is because add_to_strlist pushes the results onto the front of
1361    the list.  The end result is that the rows are backwards, but the
1362    columns are in the expected order.  */
1363 static int
1364 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
1365 {
1366   int i;
1367   strlist_t *strlist = cookie;
1368
1369   (void) azColName;
1370
1371   for (i = argc - 1; i >= 0; i --)
1372     add_to_strlist (strlist, argv[i] ? argv[i] : "");
1373
1374   return 0;
1375 }
1376
1377 static int
1378 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
1379                      sqlite3_stmt *stmt)
1380 {
1381   (void) stmt;
1382   return strings_collect_cb (cookie, argc, argv, azColName);
1383
1384 }
1385
1386 /* Auxiliary data structure to collect statistics about
1387    signatures.  */
1388 struct signature_stats
1389 {
1390   struct signature_stats *next;
1391
1392   /* The user-assigned policy for this binding.  */
1393   enum tofu_policy policy;
1394
1395   /* How long ago the signature was created (rounded to a multiple of
1396      TIME_AGO_UNIT_SMALL, etc.).  */
1397   long time_ago;
1398   /* Number of signatures during this time.  */
1399   unsigned long count;
1400
1401   /* The key that generated this signature.  */
1402   char fingerprint[1];
1403 };
1404
1405 static void
1406 signature_stats_free (struct signature_stats *stats)
1407 {
1408   while (stats)
1409     {
1410       struct signature_stats *next = stats->next;
1411       xfree (stats);
1412       stats = next;
1413     }
1414 }
1415
1416 static void
1417 signature_stats_prepend (struct signature_stats **statsp,
1418                          const char *fingerprint,
1419                          enum tofu_policy policy,
1420                          long time_ago,
1421                          unsigned long count)
1422 {
1423   struct signature_stats *stats =
1424     xmalloc (sizeof (*stats) + strlen (fingerprint));
1425
1426   stats->next = *statsp;
1427   *statsp = stats;
1428
1429   strcpy (stats->fingerprint, fingerprint);
1430   stats->policy = policy;
1431   stats->time_ago = time_ago;
1432   stats->count = count;
1433 }
1434
1435
1436 /* Process rows that contain the four columns:
1437
1438      <fingerprint, policy, time ago, count>.  */
1439 static int
1440 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1441                             char **azColName, sqlite3_stmt *stmt)
1442 {
1443   struct signature_stats **statsp = cookie;
1444   int i = 0;
1445   enum tofu_policy policy;
1446   long time_ago;
1447   unsigned long count;
1448   long along;
1449
1450   (void) azColName;
1451   (void) stmt;
1452
1453   i ++;
1454
1455   if (string_to_long (&along, argv[i], 0, __LINE__))
1456     return 1;  /* Abort */
1457   policy = along;
1458   i ++;
1459
1460   if (! argv[i])
1461     time_ago = 0;
1462   else
1463     {
1464       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
1465         return 1; /* Abort.  */
1466     }
1467   i ++;
1468
1469   /* If time_ago is NULL, then we had no messages, but we still have a
1470      single row, which count(*) turns into 1.  */
1471   if (! argv[i - 1])
1472     count = 0;
1473   else
1474     {
1475       if (string_to_ulong (&count, argv[i], 0, __LINE__))
1476         return 1; /* Abort */
1477     }
1478   i ++;
1479
1480   log_assert (argc == i);
1481
1482   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1483
1484   return 0;
1485 }
1486
1487 /* Convert from seconds to time units.
1488
1489    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1490    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1491 signed long
1492 time_ago_scale (signed long t)
1493 {
1494   if (t < TIME_AGO_UNIT_MEDIUM)
1495     return t / TIME_AGO_UNIT_SMALL;
1496   if (t < TIME_AGO_UNIT_LARGE)
1497     return t / TIME_AGO_UNIT_MEDIUM;
1498   return t / TIME_AGO_UNIT_LARGE;
1499 }
1500
1501
1502 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1503    already been normalized) and any conflict information in *CONFLICT
1504    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1505    occurs.  */
1506 static enum tofu_policy
1507 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1508             char **conflict)
1509 {
1510   struct db *db;
1511   int rc;
1512   char *err = NULL;
1513   strlist_t strlist = NULL;
1514   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1515   long along;
1516
1517   db = getdb (dbs, email, DB_EMAIL);
1518   if (! db)
1519     return _tofu_GET_POLICY_ERROR;
1520
1521   /* Check if the <FINGERPRINT, EMAIL> binding is known
1522      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1523      still TOFU_POLICY_NONE after executing the query, then the
1524      result set was empty.)  */
1525   rc = gpgsql_stepx (db->db, &db->s.get_policy_select_policy_and_conflict,
1526                       strings_collect_cb2, &strlist, &err,
1527                       "select policy, conflict from bindings\n"
1528                       " where fingerprint = ? and email = ?",
1529                       SQLITE_ARG_STRING, fingerprint,
1530                       SQLITE_ARG_STRING, email,
1531                       SQLITE_ARG_END);
1532   if (rc)
1533     {
1534       log_error (_("error reading TOFU database: %s\n"), err);
1535       print_further_info ("checking for existing bad bindings");
1536       sqlite3_free (err);
1537       goto out;
1538     }
1539
1540   if (strlist_length (strlist) == 0)
1541     /* No results.  */
1542     {
1543       policy = TOFU_POLICY_NONE;
1544       goto out;
1545     }
1546   else if (strlist_length (strlist) != 2)
1547     /* The result has the wrong form.  */
1548     {
1549       log_error (_("error reading TOFU database: %s\n"),
1550                  gpg_strerror (GPG_ERR_BAD_DATA));
1551       print_further_info ("checking for existing bad bindings:"
1552                           " expected 2 results, got %d\n",
1553                           strlist_length (strlist));
1554       goto out;
1555     }
1556
1557   /* The result has the right form.  */
1558
1559   if (string_to_long (&along, strlist->d, 0, __LINE__))
1560     {
1561       log_error (_("error reading TOFU database: %s\n"),
1562                  gpg_strerror (GPG_ERR_BAD_DATA));
1563       print_further_info ("bad value for policy: %s", strlist->d);
1564       goto out;
1565     }
1566   policy = along;
1567
1568   if (! (policy == TOFU_POLICY_AUTO
1569          || policy == TOFU_POLICY_GOOD
1570          || policy == TOFU_POLICY_UNKNOWN
1571          || policy == TOFU_POLICY_BAD
1572          || policy == TOFU_POLICY_ASK))
1573     {
1574       log_error (_("error reading TOFU database: %s\n"),
1575                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1576       print_further_info ("invalid value for policy (%d)", policy);
1577       policy = _tofu_GET_POLICY_ERROR;
1578       goto out;
1579     }
1580
1581
1582   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1583      just in case, we do the check again here and ignore the conflict
1584      is POLICY is not TOFU_POLICY_ASK.  */
1585   if (conflict)
1586     {
1587       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1588         *conflict = xstrdup (strlist->next->d);
1589       else
1590         *conflict = NULL;
1591     }
1592
1593  out:
1594   log_assert (policy == _tofu_GET_POLICY_ERROR
1595               || policy == TOFU_POLICY_NONE
1596               || policy == TOFU_POLICY_AUTO
1597               || policy == TOFU_POLICY_GOOD
1598               || policy == TOFU_POLICY_UNKNOWN
1599               || policy == TOFU_POLICY_BAD
1600               || policy == TOFU_POLICY_ASK);
1601
1602   free_strlist (strlist);
1603
1604   return policy;
1605 }
1606
1607
1608 /* Format the first part of a conflict message and return that as a
1609  * malloced string.  */
1610 static char *
1611 format_conflict_msg_part1 (int policy, const char *conflict,
1612                            const char *fingerprint, const char *email)
1613 {
1614   estream_t fp;
1615   char *binding;
1616   int binding_shown = 0;
1617   char *tmpstr, *text;
1618
1619   binding = xasprintf ("<%s, %s>", fingerprint, email);
1620
1621   fp = es_fopenmem (0, "rw,samethread");
1622   if (!fp)
1623     log_fatal ("error creating memory stream: %s\n",
1624                gpg_strerror (gpg_error_from_syserror()));
1625
1626   if (policy == TOFU_POLICY_NONE)
1627     {
1628       es_fprintf (fp, _("The binding %s is NOT known."), binding);
1629       es_fputs ("  ", fp);
1630       binding_shown = 1;
1631     }
1632   else if (policy == TOFU_POLICY_ASK
1633            /* If there the conflict is with itself, then don't
1634             * display this message.  */
1635            && conflict && strcmp (conflict, fingerprint))
1636     {
1637       es_fprintf (fp,
1638                   _("The key with fingerprint %s raised a conflict "
1639                     "with the binding %s."
1640                     "  Since this binding's policy was 'auto', it was "
1641                     "changed to 'ask'."),
1642                   conflict, binding);
1643       es_fputs ("  ", fp);
1644       binding_shown = 1;
1645     }
1646
1647   /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1648      blank or by two empty strings.  */
1649   es_fprintf (fp,
1650               _("Please indicate whether you believe the binding %s%s"
1651                 "is legitimate (the key belongs to the stated owner) "
1652                 "or a forgery (bad)."),
1653               binding_shown ? "" : binding,
1654               binding_shown ? "" : " ");
1655   es_fputc ('\n', fp);
1656
1657   xfree (binding);
1658
1659   es_fputc (0, fp);
1660   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1661     log_fatal ("error snatching memory stream\n");
1662   text = format_text (tmpstr, 0, 72, 80);
1663   es_free (tmpstr);
1664
1665   return text;
1666 }
1667
1668
1669 /* Ask the user about the binding.  There are three ways we could end
1670  * up here:
1671  *
1672  *   - This is a new binding and there is a conflict
1673  *     (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1674  *
1675  *   - This is a new binding and opt.tofu_default_policy is set to
1676  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1677  *     TOFU_POLICY_ASK), or,
1678  *
1679  *   - The policy is ask (the user deferred last time) (policy ==
1680  *     TOFU_POLICY_ASK).
1681  */
1682 static void
1683 ask_about_binding (tofu_dbs_t dbs,
1684                    struct db *db,
1685                    enum tofu_policy *policy,
1686                    int *trust_level,
1687                    int bindings_with_this_email_count,
1688                    strlist_t bindings_with_this_email,
1689                    char *conflict,
1690                    const char *fingerprint,
1691                    const char *email,
1692                    const char *user_id)
1693 {
1694   char *sqerr = NULL;
1695   int rc;
1696   estream_t fp;
1697   strlist_t other_user_ids = NULL;
1698   struct signature_stats *stats = NULL;
1699   struct signature_stats *stats_iter = NULL;
1700   char *prompt;
1701   char *choices;
1702   struct db *db_key;
1703
1704   fp = es_fopenmem (0, "rw,samethread");
1705   if (!fp)
1706     log_fatal ("error creating memory stream: %s\n",
1707                gpg_strerror (gpg_error_from_syserror()));
1708
1709   {
1710     char *text = format_conflict_msg_part1 (*policy, conflict,
1711                                             fingerprint, email);
1712     es_fputs (text, fp);
1713     es_fputc ('\n', fp);
1714     xfree (text);
1715   }
1716
1717   /* Find other user ids associated with this key and whether the
1718    * bindings are marked as good or bad.  */
1719   if (opt.tofu_db_format == TOFU_DB_SPLIT)
1720     {
1721       /* In the split format, we need to search in the fingerprint DB
1722        * for all the emails associated with this key, not the email DB.  */
1723       db_key = getdb (dbs, fingerprint, DB_KEY);
1724     }
1725   else
1726     db_key = db;
1727
1728   if (db_key)
1729     {
1730       rc = gpgsql_stepx
1731         (db_key->db, &db_key->s.get_trust_gather_other_user_ids,
1732          strings_collect_cb2, &other_user_ids, &sqerr,
1733          opt.tofu_db_format == TOFU_DB_SPLIT
1734          ? "select user_id, email from bindings where fingerprint = ?;"
1735          : "select user_id, policy from bindings where fingerprint = ?;",
1736          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_END);
1737       if (rc)
1738         {
1739           log_error (_("error gathering other user IDs: %s\n"), sqerr);
1740           sqlite3_free (sqerr);
1741           sqerr = NULL;
1742         }
1743     }
1744
1745   if (other_user_ids)
1746     {
1747       strlist_t strlist_iter;
1748
1749       es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1750       for (strlist_iter = other_user_ids;
1751            strlist_iter;
1752            strlist_iter = strlist_iter->next)
1753         {
1754           char *other_user_id = strlist_iter->d;
1755           char *other_thing;
1756           enum tofu_policy other_policy;
1757
1758           log_assert (strlist_iter->next);
1759           strlist_iter = strlist_iter->next;
1760           other_thing = strlist_iter->d;
1761
1762           if (opt.tofu_db_format == TOFU_DB_SPLIT)
1763             other_policy = get_policy (dbs, fingerprint, other_thing, NULL);
1764           else
1765             other_policy = atoi (other_thing);
1766
1767           es_fprintf (fp, "  %s (", other_user_id);
1768           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1769           es_fprintf (fp, ")\n");
1770         }
1771       es_fprintf (fp, "\n");
1772
1773       free_strlist (other_user_ids);
1774     }
1775
1776   /* Find other keys associated with this email address.  */
1777   /* FIXME: When generating the statistics, do we want the time
1778      embedded in the signature (column 'sig_time') or the time that
1779      we first verified the signature (column 'time').  */
1780   rc = gpgsql_stepx
1781     (db->db, &db->s.get_trust_gather_other_keys,
1782      signature_stats_collect_cb, &stats, &sqerr,
1783      "select fingerprint, policy, time_ago, count(*)\n"
1784      " from (select bindings.*,\n"
1785      "        case\n"
1786      /* From the future (but if its just a couple of hours in the
1787       * future don't turn it into a warning)?  Or should we use
1788       * small, medium or large units?  (Note: whatever we do, we
1789       * keep the value in seconds.  Then when we group, everything
1790       * that rounds to the same number of seconds is grouped.)  */
1791      "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1792      "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1793      "          then max(0,\n"
1794      "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1795      "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1796      "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1797      "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1798      "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1799      "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1800      "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1801      "        end time_ago,\n"
1802      "        delta time_ago_raw\n"
1803      "       from bindings\n"
1804      "       left join\n"
1805      "         (select *,\n"
1806      "            cast(strftime('%s','now') - sig_time as real) delta\n"
1807      "           from signatures) ss\n"
1808      "        on ss.binding = bindings.oid)\n"
1809      " where email = ?\n"
1810      " group by fingerprint, time_ago\n"
1811      /* Make sure the current key is first.  */
1812      " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1813      SQLITE_ARG_STRING, email, SQLITE_ARG_STRING, fingerprint,
1814      SQLITE_ARG_END);
1815   if (rc)
1816     {
1817       strlist_t strlist_iter;
1818
1819       log_error (_("error gathering signature stats: %s\n"), sqerr);
1820       sqlite3_free (sqerr);
1821       sqerr = NULL;
1822
1823       es_fprintf (fp, ngettext("The email address \"%s\" is"
1824                                " associated with %d key:\n",
1825                                "The email address \"%s\" is"
1826                                " associated with %d keys:\n",
1827                                bindings_with_this_email_count),
1828                   email, bindings_with_this_email_count);
1829       for (strlist_iter = bindings_with_this_email;
1830            strlist_iter;
1831            strlist_iter = strlist_iter->next)
1832         es_fprintf (fp, "  %s\n", strlist_iter->d);
1833     }
1834   else
1835     {
1836       char *key = NULL;
1837
1838       if (! stats || strcmp (stats->fingerprint, fingerprint))
1839         {
1840           /* If we have already added this key to the DB, then it will
1841            * be first (see the above select).  Since the first key on
1842            * the list is not this key, we must not yet have verified any
1843            * messages signed by this key.  Add a dummy entry.  */
1844           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1845         }
1846
1847       es_fprintf (fp, _("Statistics for keys with the email address \"%s\":\n"),
1848                   email);
1849       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1850         {
1851           if (! key || strcmp (key, stats_iter->fingerprint))
1852             {
1853               int this_key;
1854               char *key_pp;
1855
1856               key = stats_iter->fingerprint;
1857               this_key = strcmp (key, fingerprint) == 0;
1858               key_pp = format_hexfingerprint (key, NULL, 0);
1859               es_fprintf (fp, "  %s (", key_pp);
1860               if (this_key)
1861                 es_fprintf (fp, _("this key"));
1862               else
1863                 es_fprintf (fp, _("policy: %s"),
1864                             tofu_policy_str (stats_iter->policy));
1865               es_fputs ("):\n", fp);
1866               xfree (key_pp);
1867             }
1868
1869           es_fputs ("    ", fp);
1870           if (stats_iter->time_ago == -1)
1871             es_fprintf (fp, ngettext("%ld message signed in the future.",
1872                                      "%ld messages signed in the future.",
1873                                      stats_iter->count), stats_iter->count);
1874           else
1875             {
1876               long t_scaled = time_ago_scale (stats_iter->time_ago);
1877
1878               /* TANSLATORS: This string is concatenated with one of
1879                * the day/week/month strings to form one sentence.  */
1880               es_fprintf (fp, ngettext("%ld message signed",
1881                                        "%ld messages signed",
1882                                        stats_iter->count), stats_iter->count);
1883               if (!stats_iter->count)
1884                 es_fputs (".", fp);
1885               else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
1886                 es_fprintf (fp, ngettext(" over the past %ld day.",
1887                                          " over the past %ld days.",
1888                                          t_scaled), t_scaled);
1889               else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
1890                 es_fprintf (fp, ngettext(" over the past %ld week.",
1891                                          " over the past %ld weeks.",
1892                                          t_scaled), t_scaled);
1893               else
1894                 es_fprintf (fp, ngettext(" over the past %ld month.",
1895                                          " over the past %ld months.",
1896                                          t_scaled), t_scaled);
1897             }
1898           es_fputs ("\n", fp);
1899         }
1900     }
1901
1902
1903   if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1904       || (*policy == TOFU_POLICY_ASK && conflict))
1905     {
1906       /* This is a conflict.  */
1907
1908       /* TRANSLATORS: Please translate the text found in the source
1909        * file below.  We don't directly internationalize that text so
1910        * that we can tweak it without breaking translations.  */
1911       char *text = _("TOFU detected a binding conflict");
1912       char *textbuf;
1913       if (!strcmp (text, "TOFU detected a binding conflict"))
1914         {
1915           /* No translation.  Use the English text.  */
1916           text =
1917             "Normally, there is only a single key associated with an email "
1918             "address.  However, people sometimes generate a new key if "
1919             "their key is too old or they think it might be compromised.  "
1920             "Alternatively, a new key may indicate a man-in-the-middle "
1921             "attack!  Before accepting this key, you should talk to or "
1922             "call the person to make sure this new key is legitimate.";
1923         }
1924       textbuf = format_text (text, 0, 72, 80);
1925       es_fprintf (fp, "\n%s\n", text);
1926       xfree (textbuf);
1927     }
1928
1929   es_fputc ('\n', fp);
1930
1931   /* Add a NUL terminator.  */
1932   es_fputc (0, fp);
1933   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1934     log_fatal ("error snatching memory stream\n");
1935
1936   /* I think showing the large message once is sufficient.  If we
1937    * would move it right before the cpr_get many lines will scroll
1938    * away and the user might not realize that he merely entered a
1939    * wrong choise (because he does not see that either).  As a small
1940    * benefit we allow C-L to redisplay everything.  */
1941   tty_printf ("%s", prompt);
1942   while (1)
1943     {
1944       char *response;
1945
1946       /* TRANSLATORS: Two letters (normally the lower and upper case
1947        * version of the hotkey) for each of the five choices.  If
1948        * there is only one choice in your language, repeat it.  */
1949       choices = _("gG" "aA" "uU" "rR" "bB");
1950       if (strlen (choices) != 10)
1951         log_bug ("Bad TOFU conflict translation!  Please report.");
1952
1953       response = cpr_get
1954         ("tofu.conflict",
1955          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1956       trim_spaces (response);
1957       cpr_kill_prompt ();
1958       if (*response == CONTROL_L)
1959         tty_printf ("%s", prompt);
1960       else if (strlen (response) == 1)
1961         {
1962           char *choice = strchr (choices, *response);
1963           if (choice)
1964             {
1965               int c = ((size_t) choice - (size_t) choices) / 2;
1966
1967               switch (c)
1968                 {
1969                 case 0: /* Good.  */
1970                   *policy = TOFU_POLICY_GOOD;
1971                   *trust_level = tofu_policy_to_trust_level (*policy);
1972                   break;
1973                 case 1: /* Accept once.  */
1974                   *policy = TOFU_POLICY_ASK;
1975                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1976                   break;
1977                 case 2: /* Unknown.  */
1978                   *policy = TOFU_POLICY_UNKNOWN;
1979                   *trust_level = tofu_policy_to_trust_level (*policy);
1980                   break;
1981                 case 3: /* Reject once.  */
1982                   *policy = TOFU_POLICY_ASK;
1983                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1984                   break;
1985                 case 4: /* Bad.  */
1986                   *policy = TOFU_POLICY_BAD;
1987                   *trust_level = tofu_policy_to_trust_level (*policy);
1988                   break;
1989                 default:
1990                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1991                 }
1992
1993               if (record_binding (dbs, fingerprint, email, user_id,
1994                                   *policy, 0))
1995                 {
1996                   /* If there's an error registering the
1997                    * binding, don't save the signature.  */
1998                   *trust_level = _tofu_GET_TRUST_ERROR;
1999                 }
2000               break;
2001             }
2002         }
2003       xfree (response);
2004     }
2005
2006   xfree (prompt);
2007
2008   signature_stats_free (stats);
2009 }
2010
2011
2012 /* Return the trust level (TRUST_NEVER, etc.) for the binding
2013  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
2014  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
2015  * returns _tofu_GET_TRUST_ERROR.
2016  *
2017  * PK is the public key object for FINGERPRINT.
2018  *
2019  * USER_ID is the unadulterated user id.
2020  *
2021  * If MAY_ASK is set, then we may interact with the user.  This is
2022  * necessary if there is a conflict or the binding's policy is
2023  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
2024  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
2025  * we return TRUST_UNDEFINED.  */
2026 static enum tofu_policy
2027 get_trust (tofu_dbs_t dbs, PKT_public_key *pk,
2028            const char *fingerprint, const char *email,
2029            const char *user_id, int may_ask)
2030 {
2031   struct db *db;
2032   enum tofu_policy policy;
2033   char *conflict = NULL;
2034   int rc;
2035   char *sqerr = NULL;
2036   strlist_t bindings_with_this_email = NULL;
2037   int bindings_with_this_email_count;
2038   int change_conflicting_to_ask = 0;
2039   int trust_level = TRUST_UNKNOWN;
2040
2041   if (opt.batch)
2042     may_ask = 0;
2043
2044   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
2045      levels.  */
2046   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
2047               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
2048               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
2049               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
2050               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
2051               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
2052               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
2053
2054   db = getdb (dbs, email, DB_EMAIL);
2055   if (! db)
2056     return _tofu_GET_TRUST_ERROR;
2057
2058   policy = get_policy (dbs, fingerprint, email, &conflict);
2059   if (policy == TOFU_POLICY_AUTO || policy == TOFU_POLICY_NONE)
2060     { /* See if the key is ultimately trusted.  If so, we're done.  */
2061       u32 kid[2];
2062
2063       keyid_from_pk (pk, kid);
2064
2065       if (tdb_keyid_is_utk (kid))
2066         {
2067           if (policy == TOFU_POLICY_NONE)
2068             {
2069               if (record_binding (dbs, fingerprint, email, user_id,
2070                                   TOFU_POLICY_AUTO, 0) != 0)
2071                 {
2072                   log_error (_("error setting TOFU binding's trust level"
2073                                " to %s\n"), "auto");
2074                   trust_level = _tofu_GET_TRUST_ERROR;
2075                   goto out;
2076                 }
2077             }
2078
2079           trust_level = TRUST_ULTIMATE;
2080           goto out;
2081         }
2082     }
2083
2084   if (policy == TOFU_POLICY_AUTO)
2085     {
2086       policy = opt.tofu_default_policy;
2087       if (DBG_TRUST)
2088         log_debug ("TOFU: binding <%s, %s>'s policy is auto (default: %s).\n",
2089                    fingerprint, email,
2090                    tofu_policy_str (opt.tofu_default_policy));
2091     }
2092   switch (policy)
2093     {
2094     case TOFU_POLICY_AUTO:
2095     case TOFU_POLICY_GOOD:
2096     case TOFU_POLICY_UNKNOWN:
2097     case TOFU_POLICY_BAD:
2098       /* The saved judgement is auto -> auto, good, unknown or bad.
2099        * We don't need to ask the user anything.  */
2100       if (DBG_TRUST)
2101         log_debug ("TOFU: Known binding <%s, %s>'s policy: %s\n",
2102                    fingerprint, email, tofu_policy_str (policy));
2103       trust_level = tofu_policy_to_trust_level (policy);
2104       goto out;
2105
2106     case TOFU_POLICY_ASK:
2107       /* We need to ask the user what to do.  Case #1 or #2 below.  */
2108       if (! may_ask)
2109         {
2110           trust_level = TRUST_UNDEFINED;
2111           goto out;
2112         }
2113
2114       break;
2115
2116     case TOFU_POLICY_NONE:
2117       /* The binding is new, we need to check for conflicts.  Case #3
2118        * below.  */
2119       break;
2120
2121     case _tofu_GET_POLICY_ERROR:
2122       trust_level = _tofu_GET_TRUST_ERROR;
2123       goto out;
2124
2125     default:
2126       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
2127     }
2128
2129
2130   /* We get here if:
2131    *
2132    *   1. The saved policy is auto and the default policy is ask
2133    *      (get_policy() == TOFU_POLICY_AUTO
2134    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
2135    *
2136    *   2. The saved policy is ask (either last time the user selected
2137    *      accept once or reject once or there was a conflict and this
2138    *      binding's policy was changed from auto to ask)
2139    *      (policy == TOFU_POLICY_ASK), or,
2140    *
2141    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
2142    *      (need to check for a conflict).
2143    */
2144
2145   /* Look for conflicts.  This is needed in all 3 cases.
2146    *
2147    * Get the fingerprints of any bindings that share the email
2148    * address.  Note: if the binding in question is in the DB, it will
2149    * also be returned.  Thus, if the result set is empty, then this is
2150    * a new binding.  */
2151   rc = gpgsql_stepx
2152     (db->db, &db->s.get_trust_bindings_with_this_email,
2153      strings_collect_cb2, &bindings_with_this_email, &sqerr,
2154      "select distinct fingerprint from bindings where email = ?;",
2155      SQLITE_ARG_STRING, email, SQLITE_ARG_END);
2156   if (rc)
2157     {
2158       log_error (_("error reading TOFU database: %s\n"), sqerr);
2159       print_further_info ("listing fingerprints");
2160       sqlite3_free (sqerr);
2161       goto out;
2162     }
2163
2164   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
2165   if (bindings_with_this_email_count == 0
2166       && opt.tofu_default_policy != TOFU_POLICY_ASK)
2167     {
2168       /* New binding with no conflict and a concrete default policy.
2169        *
2170        * We've never observed a binding with this email address
2171        * BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would
2172        * return the current binding if it were in the DB) and we have
2173        * a default policy, which is not to ask the user.
2174        */
2175
2176       /* If we've seen this binding, then we've seen this email and
2177          policy couldn't possibly be TOFU_POLICY_NONE.  */
2178       log_assert (policy == TOFU_POLICY_NONE);
2179
2180       if (DBG_TRUST)
2181         log_debug ("TOFU: New binding <%s, %s>, no conflict.\n",
2182                    email, fingerprint);
2183
2184       if (record_binding (dbs, fingerprint, email, user_id,
2185                           TOFU_POLICY_AUTO, 0) != 0)
2186         {
2187           log_error (_("error setting TOFU binding's trust level to %s\n"),
2188                        "auto");
2189           trust_level = _tofu_GET_TRUST_ERROR;
2190           goto out;
2191         }
2192
2193       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
2194       goto out;
2195     }
2196
2197   if (policy == TOFU_POLICY_NONE)
2198     {
2199       /* This is a new binding and we have a conflict.  Mark any
2200        * conflicting bindings that have an automatic policy as now
2201        * requiring confirmation.  Note: we delay this until after we
2202        * ask for confirmation so that when the current policy is
2203        * printed, it is correct.  */
2204       change_conflicting_to_ask = 1;
2205     }
2206
2207   if (! may_ask)
2208     {
2209       /* We can only get here in the third case (no saved policy) and
2210        * if there is a conflict.  (If the policy was ask (cases #1 and
2211        * #2) and we weren't allowed to ask, we'd have already exited).  */
2212       log_assert (policy == TOFU_POLICY_NONE);
2213
2214       if (record_binding (dbs, fingerprint, email, user_id,
2215                           TOFU_POLICY_ASK, 0) != 0)
2216         log_error (_("error setting TOFU binding's trust level to %s\n"),
2217                    "ask");
2218
2219       trust_level = TRUST_UNDEFINED;
2220       goto out;
2221     }
2222
2223   /* If we get here, we need to ask the user about the binding.  */
2224   ask_about_binding (dbs, db,
2225                      &policy,
2226                      &trust_level,
2227                      bindings_with_this_email_count,
2228                      bindings_with_this_email,
2229                      conflict,
2230                      fingerprint,
2231                      email,
2232                      user_id);
2233
2234  out:
2235   if (change_conflicting_to_ask)
2236     {
2237       if (! may_ask)
2238         {
2239           /* If we weren't allowed to ask, also update this key as
2240              conflicting with itself.  */
2241           rc = gpgsql_exec_printf
2242             (db->db, NULL, NULL, &sqerr,
2243              "update bindings set policy = %d, conflict = %Q"
2244              " where email = %Q"
2245              "  and (policy = %d or (policy = %d and fingerprint = %Q));",
2246              TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
2247              TOFU_POLICY_ASK, fingerprint);
2248         }
2249       else
2250         {
2251           rc = gpgsql_exec_printf
2252             (db->db, NULL, NULL, &sqerr,
2253              "update bindings set policy = %d, conflict = %Q"
2254              " where email = %Q and fingerprint != %Q and policy = %d;",
2255              TOFU_POLICY_ASK, fingerprint, email, fingerprint,
2256              TOFU_POLICY_AUTO);
2257         }
2258
2259       if (rc)
2260         {
2261           log_error (_("error changing TOFU policy: %s\n"), sqerr);
2262           sqlite3_free (sqerr);
2263           sqerr = NULL;
2264         }
2265     }
2266
2267   xfree (conflict);
2268   free_strlist (bindings_with_this_email);
2269
2270   return trust_level;
2271 }
2272
2273
2274 /* Return a malloced string of the form
2275  *    "7 months, 1 day, 5 minutes, 0 seconds"
2276  * The caller should replace all '~' in the returned string by a space
2277  * and also free the returned string.
2278  *
2279  * This is actually a bad hack which may not work correctly with all
2280  * languages.
2281  */
2282 static char *
2283 time_ago_str (long long int t)
2284 {
2285   estream_t fp;
2286   int years = 0;
2287   int months = 0;
2288   int days = 0;
2289   int hours = 0;
2290   int minutes = 0;
2291   int seconds = 0;
2292
2293   /* The number of units that we've printed so far.  */
2294   int count = 0;
2295   /* The first unit that we printed (year = 0, month = 1,
2296      etc.).  */
2297   int first = -1;
2298   /* The current unit.  */
2299   int i = 0;
2300
2301   char *str;
2302
2303   /* It would be nice to use a macro to do this, but gettext
2304      works on the unpreprocessed code.  */
2305 #define MIN_SECS (60)
2306 #define HOUR_SECS (60 * MIN_SECS)
2307 #define DAY_SECS (24 * HOUR_SECS)
2308 #define MONTH_SECS (30 * DAY_SECS)
2309 #define YEAR_SECS (365 * DAY_SECS)
2310
2311   if (t > YEAR_SECS)
2312     {
2313       years = t / YEAR_SECS;
2314       t -= years * YEAR_SECS;
2315     }
2316   if (t > MONTH_SECS)
2317     {
2318       months = t / MONTH_SECS;
2319       t -= months * MONTH_SECS;
2320     }
2321   if (t > DAY_SECS)
2322     {
2323       days = t / DAY_SECS;
2324       t -= days * DAY_SECS;
2325     }
2326   if (t > HOUR_SECS)
2327     {
2328       hours = t / HOUR_SECS;
2329       t -= hours * HOUR_SECS;
2330     }
2331   if (t > MIN_SECS)
2332     {
2333       minutes = t / MIN_SECS;
2334       t -= minutes * MIN_SECS;
2335     }
2336   seconds = t;
2337
2338 #undef MIN_SECS
2339 #undef HOUR_SECS
2340 #undef DAY_SECS
2341 #undef MONTH_SECS
2342 #undef YEAR_SECS
2343
2344   fp = es_fopenmem (0, "rw,samethread");
2345   if (! fp)
2346     log_fatal ("error creating memory stream: %s\n",
2347                gpg_strerror (gpg_error_from_syserror()));
2348
2349   if (years)
2350     {
2351       /* TRANSLATORS: The tilde ('~') is used here to indicate a
2352        * non-breakable space  */
2353       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
2354       count ++;
2355       first = i;
2356     }
2357   i ++;
2358   if ((first == -1 || i - first <= 3) && months)
2359     {
2360       if (count)
2361         es_fprintf (fp, ", ");
2362       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
2363       count ++;
2364       first = i;
2365     }
2366   i ++;
2367   if ((first == -1 || i - first <= 3) && count < 2 && days)
2368     {
2369       if (count)
2370         es_fprintf (fp, ", ");
2371       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
2372       count ++;
2373       first = i;
2374     }
2375   i ++;
2376   if ((first == -1 || i - first <= 3) && count < 2 && hours)
2377     {
2378       if (count)
2379         es_fprintf (fp, ", ");
2380       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
2381       count ++;
2382       first = i;
2383     }
2384   i ++;
2385   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
2386     {
2387       if (count)
2388         es_fprintf (fp, ", ");
2389       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
2390       count ++;
2391       first = i;
2392     }
2393   i ++;
2394   if ((first == -1 || i - first <= 3) && count < 2)
2395     {
2396       if (count)
2397         es_fprintf (fp, ", ");
2398       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
2399     }
2400
2401   es_fputc (0, fp);
2402   if (es_fclose_snatch (fp, (void **) &str, NULL))
2403     log_fatal ("error snatching memory stream\n");
2404
2405   return str;
2406 }
2407
2408
2409 /* Write TOFU_STATS status line.  */
2410 static void
2411 write_stats_status (long messages, enum tofu_policy policy,
2412                     long first_seen_ago, long most_recent_seen_ago)
2413 {
2414   char numbuf1[35];
2415   char numbuf2[35];
2416   char numbuf3[35];
2417   const char *validity;
2418
2419   if (messages < 1)
2420     validity = "1"; /* Key without history.  */
2421   else if (messages < BASIC_TRUST_THRESHOLD)
2422     validity = "2"; /* Key with too little history.  */
2423   else if (messages < FULL_TRUST_THRESHOLD)
2424     validity = "3"; /* Key with enough history for basic trust.  */
2425   else
2426     validity = "4"; /* Key with a lot of history.  */
2427
2428   snprintf (numbuf1, sizeof numbuf1, " %ld", messages);
2429   *numbuf2 = *numbuf3 = 0;
2430   if (first_seen_ago >= 0 && most_recent_seen_ago >= 0)
2431     {
2432       snprintf (numbuf2, sizeof numbuf2, " %ld", first_seen_ago);
2433       snprintf (numbuf3, sizeof numbuf3, " %ld", most_recent_seen_ago);
2434     }
2435
2436   write_status_strings (STATUS_TOFU_STATS,
2437                         validity, numbuf1, " 0",
2438                         " ", tofu_policy_str (policy),
2439                         numbuf2, numbuf3,
2440                         NULL);
2441 }
2442
2443 static void
2444 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
2445                  const char *email, const char *user_id,
2446                  const char *sig_exclude)
2447 {
2448   struct db *db;
2449   char *fingerprint_pp;
2450   int rc;
2451   strlist_t strlist = NULL;
2452   char *err = NULL;
2453
2454   db = getdb (dbs, email, DB_EMAIL);
2455   if (! db)
2456     return;
2457
2458   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2459
2460   rc = gpgsql_exec_printf
2461     (db->db, strings_collect_cb, &strlist, &err,
2462      "select count (*), strftime('%%s','now') - min (signatures.time),\n"
2463      "  strftime('%%s','now') - max (signatures.time)\n"
2464      " from signatures\n"
2465      " left join bindings on signatures.binding = bindings.oid\n"
2466      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
2467      fingerprint, email,
2468      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
2469         not NULL.  */
2470      sig_exclude ? "!= '" : "is not NULL",
2471      sig_exclude ? sig_exclude : "",
2472      sig_exclude ? "'" : "");
2473   if (rc)
2474     {
2475       log_error (_("error reading TOFU database: %s\n"), err);
2476       print_further_info ("getting statistics");
2477       sqlite3_free (err);
2478       goto out;
2479     }
2480
2481   write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
2482                                 email, strlen (email), 0);
2483
2484   if (! strlist)
2485     {
2486       log_info (_("Have never verified a message signed by key %s!\n"),
2487                 fingerprint_pp);
2488       write_stats_status (0,  TOFU_POLICY_NONE, -1, -1);
2489     }
2490   else
2491     {
2492       signed long messages;
2493       signed long first_seen_ago;
2494       signed long most_recent_seen_ago;
2495
2496       log_assert (strlist_length (strlist) == 3);
2497
2498       string_to_long (&messages, strlist->d, -1, __LINE__);
2499
2500       if (messages == 0 && *strlist->next->d == '\0')
2501         { /* min(NULL) => NULL => "".  */
2502           first_seen_ago = -1;
2503           most_recent_seen_ago = -1;
2504         }
2505       else
2506         {
2507           string_to_long (&first_seen_ago, strlist->next->d, -1, __LINE__);
2508           string_to_long (&most_recent_seen_ago, strlist->next->next->d, -1,
2509                           __LINE__);
2510         }
2511
2512       if (messages == -1 || first_seen_ago == -1)
2513         {
2514           write_stats_status (0, TOFU_POLICY_NONE, -1, -1);
2515           log_info (_("Failed to collect signature statistics for \"%s\"\n"
2516                       "(key %s)\n"),
2517                     user_id, fingerprint_pp);
2518         }
2519       else
2520         {
2521           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2522           estream_t fp;
2523           char *msg;
2524
2525           write_stats_status (messages, policy,
2526                               first_seen_ago, most_recent_seen_ago);
2527
2528           fp = es_fopenmem (0, "rw,samethread");
2529           if (! fp)
2530             log_fatal ("error creating memory stream: %s\n",
2531                        gpg_strerror (gpg_error_from_syserror()));
2532
2533           if (messages == 0)
2534             {
2535               es_fprintf (fp, _("Verified %ld messages signed by \"%s\"."),
2536                           0L, user_id);
2537               es_fputc ('\n', fp);
2538             }
2539           else
2540             {
2541               char *first_seen_ago_str = time_ago_str (first_seen_ago);
2542
2543               /* TRANSLATORS: The final %s is replaced by a string like
2544                  "7 months, 1 day, 5 minutes, 0 seconds". */
2545               es_fprintf (fp,
2546                           ngettext("Verified %ld message signed by \"%s\"\n"
2547                                    "in the past %s.",
2548                                    "Verified %ld messages signed by \"%s\"\n"
2549                                    "in the past %s.",
2550                                    messages),
2551                           messages, user_id, first_seen_ago_str);
2552
2553               if (messages > 1)
2554                 {
2555                   char *tmpstr = time_ago_str (most_recent_seen_ago);
2556                   es_fputs ("  ", fp);
2557                   es_fprintf (fp, _("The most recent message was"
2558                                     " verified %s ago."), tmpstr);
2559                   xfree (tmpstr);
2560                 }
2561               xfree (first_seen_ago_str);
2562
2563               if (opt.verbose)
2564                 {
2565                   es_fputs ("  ", fp);
2566                   es_fputc ('(', fp);
2567                   es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2568                   es_fputs (")\n", fp);
2569                 }
2570               else
2571                 es_fputs ("\n", fp);
2572             }
2573
2574           {
2575             char *tmpmsg, *p;
2576             es_fputc (0, fp);
2577             if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2578               log_fatal ("error snatching memory stream\n");
2579             msg = format_text (tmpmsg, 0, 72, 80);
2580             es_free (tmpmsg);
2581
2582             /* Print a status line but suppress the trailing LF.
2583              * Spaces are not percent escaped. */
2584             if (*msg)
2585               write_status_buffer (STATUS_TOFU_STATS_LONG,
2586                                    msg, strlen (msg)-1, -1);
2587
2588             /* Remove the non-breaking space markers.  */
2589             for (p=msg; *p; p++)
2590               if (*p == '~')
2591                 *p = ' ';
2592
2593           }
2594
2595           log_string (GPGRT_LOG_INFO, msg);
2596           xfree (msg);
2597
2598           if (policy == TOFU_POLICY_AUTO && messages < BASIC_TRUST_THRESHOLD)
2599             {
2600               char *set_policy_command;
2601               char *text;
2602               char *tmpmsg;
2603
2604               if (messages == 0)
2605                 log_info (_("Warning: we've have yet to see"
2606                             " a message signed by this key!\n"));
2607               else if (messages == 1)
2608                 log_info (_("Warning: we've only seen a"
2609                             " single message signed by this key!\n"));
2610
2611               set_policy_command =
2612                 xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2613
2614               tmpmsg = xasprintf
2615                 (ngettext
2616                  ("Warning: if you think you've seen more than %ld message "
2617                   "signed by this key, then this key might be a forgery!  "
2618                   "Carefully examine the email address for small "
2619                   "variations.  If the key is suspect, then use\n"
2620                   "  %s\n"
2621                   "to mark it as being bad.\n",
2622                   "Warning: if you think you've seen more than %ld messages "
2623                   "signed by this key, then this key might be a forgery!  "
2624                       "Carefully examine the email address for small "
2625                   "variations.  If the key is suspect, then use\n"
2626                   "  %s\n"
2627                   "to mark it as being bad.\n",
2628                   messages),
2629                   messages, set_policy_command);
2630               text = format_text (tmpmsg, 0, 72, 80);
2631               xfree (tmpmsg);
2632               log_string (GPGRT_LOG_INFO, text);
2633               xfree (text);
2634
2635               es_free (set_policy_command);
2636             }
2637         }
2638     }
2639
2640  out:
2641   free_strlist (strlist);
2642   xfree (fingerprint_pp);
2643
2644   return;
2645 }
2646
2647 /* Extract the email address from a user id and normalize it.  If the
2648    user id doesn't contain an email address, then we use the whole
2649    user_id and normalize that.  The returned string must be freed.  */
2650 static char *
2651 email_from_user_id (const char *user_id)
2652 {
2653   char *email = mailbox_from_userid (user_id);
2654   if (! email)
2655     {
2656       /* Hmm, no email address was provided or we are out of core.  Just
2657          take the lower-case version of the whole user id.  It could be
2658          a hostname, for instance.  */
2659       email = ascii_strlwr (xstrdup (user_id));
2660     }
2661
2662   return email;
2663 }
2664
2665 /* Register the signature with the binding <fingerprint, USER_ID>.
2666    The fingerprint is taken from the primary key packet PK.
2667
2668    SIG_DIGEST_BIN is the binary representation of the message's
2669    digest.  SIG_DIGEST_BIN_LEN is its length.
2670
2671    SIG_TIME is the time that the signature was generated.
2672
2673    ORIGIN is a free-formed string describing the origin of the
2674    signature.  If this was from an email and the Claws MUA was used,
2675    then this should be something like: "email:claws".  If this is
2676    NULL, the default is simply "unknown".
2677
2678    If MAY_ASK is 1, then this function may interact with the user.
2679    This is necessary if there is a conflict or the binding's policy is
2680    TOFU_POLICY_ASK.
2681
2682    This function returns the binding's trust level on return.  If an
2683    error occurs, this function returns TRUST_UNKNOWN.  */
2684 int
2685 tofu_register (ctrl_t ctrl, PKT_public_key *pk, const char *user_id,
2686                const byte *sig_digest_bin, int sig_digest_bin_len,
2687                time_t sig_time, const char *origin, int may_ask)
2688 {
2689   tofu_dbs_t dbs;
2690   struct db *db;
2691   char *fingerprint = NULL;
2692   char *email = NULL;
2693   char *err = NULL;
2694   int rc;
2695   int trust_level = TRUST_UNKNOWN;
2696   char *sig_digest;
2697   unsigned long c;
2698   int already_verified = 0;
2699
2700   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2701
2702   dbs = opendbs (ctrl);
2703   if (! dbs)
2704     {
2705       log_error (_("error opening TOFU database: %s\n"),
2706                  gpg_strerror (GPG_ERR_GENERAL));
2707       goto die;
2708     }
2709
2710   fingerprint = hexfingerprint (pk, NULL, 0);
2711
2712   if (! *user_id)
2713     {
2714       log_debug ("TOFU: user id is empty.  Can't continue.\n");
2715       goto die;
2716     }
2717
2718   email = email_from_user_id (user_id);
2719
2720   if (! origin)
2721     /* The default origin is simply "unknown".  */
2722     origin = "unknown";
2723
2724   /* It's necessary to get the trust so that we are certain that the
2725      binding has been registered.  */
2726   trust_level = get_trust (dbs, pk, fingerprint, email, user_id, may_ask);
2727   if (trust_level == _tofu_GET_TRUST_ERROR)
2728     /* An error.  */
2729     {
2730       trust_level = TRUST_UNKNOWN;
2731       goto die;
2732     }
2733
2734   /* Save the observed signature in the DB.  */
2735   db = getdb (dbs, email, DB_EMAIL);
2736   if (! db)
2737     {
2738       log_error (_("error opening TOFU database: %s\n"),
2739                  gpg_strerror (GPG_ERR_GENERAL));
2740       goto die;
2741     }
2742
2743   /* We do a query and then an insert.  Make sure they are atomic
2744      by wrapping them in a transaction.  */
2745   rc = begin_transaction (db, 0);
2746   if (rc)
2747     goto die;
2748
2749   /* If we've already seen this signature before, then don't add
2750      it again.  */
2751   rc = gpgsql_stepx
2752     (db->db, &db->s.register_already_seen,
2753      get_single_unsigned_long_cb2, &c, &err,
2754      "select count (*)\n"
2755      " from signatures left join bindings\n"
2756      "  on signatures.binding = bindings.oid\n"
2757      " where fingerprint = ? and email = ? and sig_time = ?\n"
2758      "  and sig_digest = ?",
2759      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2760      SQLITE_ARG_LONG_LONG, (long long) sig_time,
2761      SQLITE_ARG_STRING, sig_digest,
2762      SQLITE_ARG_END);
2763   if (rc)
2764     {
2765       log_error (_("error reading TOFU database: %s\n"), err);
2766       print_further_info ("checking existence");
2767       sqlite3_free (err);
2768     }
2769   else if (c > 1)
2770     /* Duplicates!  This should not happen.  In particular,
2771        because <fingerprint, email, sig_time, sig_digest> is the
2772        primary key!  */
2773     log_debug ("SIGNATURES DB contains duplicate records"
2774                " <%s, %s, 0x%lx, %s, %s>."
2775                "  Please report.\n",
2776                fingerprint, email, (unsigned long) sig_time,
2777                sig_digest, origin);
2778   else if (c == 1)
2779     {
2780       already_verified = 1;
2781       if (DBG_TRUST)
2782         log_debug ("Already observed the signature"
2783                    " <%s, %s, 0x%lx, %s, %s>\n",
2784                    fingerprint, email, (unsigned long) sig_time,
2785                    sig_digest, origin);
2786     }
2787   else if (opt.dry_run)
2788     {
2789       log_info ("TOFU database update skipped due to --dry-run\n");
2790     }
2791   else
2792     /* This is the first time that we've seen this signature.
2793        Record it.  */
2794     {
2795       if (DBG_TRUST)
2796         log_debug ("TOFU: Saving signature <%s, %s, %s>\n",
2797                    fingerprint, email, sig_digest);
2798
2799       log_assert (c == 0);
2800
2801       rc = gpgsql_stepx
2802         (db->db, &db->s.register_insert, NULL, NULL, &err,
2803          "insert into signatures\n"
2804          " (binding, sig_digest, origin, sig_time, time)\n"
2805          " values\n"
2806          " ((select oid from bindings\n"
2807          "    where fingerprint = ? and email = ?),\n"
2808          "  ?, ?, ?, strftime('%s', 'now'));",
2809          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2810          SQLITE_ARG_STRING, sig_digest, SQLITE_ARG_STRING, origin,
2811          SQLITE_ARG_LONG_LONG, (long long) sig_time,
2812          SQLITE_ARG_END);
2813       if (rc)
2814         {
2815           log_error (_("error updating TOFU database: %s\n"), err);
2816           print_further_info ("insert signatures");
2817           sqlite3_free (err);
2818         }
2819     }
2820
2821   /* It only matters whether we abort or commit the transaction
2822      (so long as we do something) if we execute the insert.  */
2823   if (rc)
2824     rc = rollback_transaction (db);
2825   else
2826     rc = end_transaction (db, 0);
2827   if (rc)
2828     {
2829       sqlite3_free (err);
2830       goto die;
2831     }
2832
2833  die:
2834   if (may_ask && trust_level != TRUST_ULTIMATE)
2835     /* It's only appropriate to show the statistics in an interactive
2836        context.  */
2837     show_statistics (dbs, fingerprint, email, user_id,
2838                      already_verified ? NULL : sig_digest);
2839
2840   xfree (email);
2841   xfree (fingerprint);
2842   xfree (sig_digest);
2843
2844   return trust_level;
2845 }
2846
2847 /* Combine a trust level returned from the TOFU trust model with a
2848    trust level returned by the PGP trust model.  This is primarily of
2849    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2850
2851    This function ors together the upper bits (the values not covered
2852    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2853 int
2854 tofu_wot_trust_combine (int tofu_base, int wot_base)
2855 {
2856   int tofu = tofu_base & TRUST_MASK;
2857   int wot = wot_base & TRUST_MASK;
2858   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2859
2860   log_assert (tofu == TRUST_UNKNOWN
2861               || tofu == TRUST_EXPIRED
2862               || tofu == TRUST_UNDEFINED
2863               || tofu == TRUST_NEVER
2864               || tofu == TRUST_MARGINAL
2865               || tofu == TRUST_FULLY
2866               || tofu == TRUST_ULTIMATE);
2867   log_assert (wot == TRUST_UNKNOWN
2868               || wot == TRUST_EXPIRED
2869               || wot == TRUST_UNDEFINED
2870               || wot == TRUST_NEVER
2871               || wot == TRUST_MARGINAL
2872               || wot == TRUST_FULLY
2873               || wot == TRUST_ULTIMATE);
2874
2875   /* We first consider negative trust policys.  These trump positive
2876      trust policies.  */
2877   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2878     /* TRUST_NEVER trumps everything else.  */
2879     return upper | TRUST_NEVER;
2880   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2881     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2882     return upper | TRUST_EXPIRED;
2883
2884   /* Now we only have positive or neutral trust policies.  We take
2885      the max.  */
2886   if (tofu == TRUST_ULTIMATE)
2887     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
2888   if (wot == TRUST_ULTIMATE)
2889     return upper | TRUST_ULTIMATE;
2890
2891   if (tofu == TRUST_FULLY)
2892     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
2893   if (wot == TRUST_FULLY)
2894     return upper | TRUST_FULLY;
2895
2896   if (tofu == TRUST_MARGINAL)
2897     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
2898   if (wot == TRUST_MARGINAL)
2899     return upper | TRUST_MARGINAL;
2900
2901   if (tofu == TRUST_UNDEFINED)
2902     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
2903   if (wot == TRUST_UNDEFINED)
2904     return upper | TRUST_UNDEFINED;
2905
2906   return upper | TRUST_UNKNOWN;
2907 }
2908
2909
2910 /* Return the validity (TRUST_NEVER, etc.) of the binding
2911    <FINGERPRINT, USER_ID>.
2912
2913    PK is the primary key packet.
2914
2915    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2916    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2917    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2918
2919    Returns TRUST_UNDEFINED if an error occurs.  */
2920 int
2921 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, const char *user_id,
2922                    int may_ask)
2923 {
2924   tofu_dbs_t dbs;
2925   char *fingerprint = NULL;
2926   char *email = NULL;
2927   int trust_level = TRUST_UNDEFINED;
2928
2929   dbs = opendbs (ctrl);
2930   if (! dbs)
2931     {
2932       log_error (_("error opening TOFU database: %s\n"),
2933                  gpg_strerror (GPG_ERR_GENERAL));
2934       goto die;
2935     }
2936
2937   fingerprint = hexfingerprint (pk, NULL, 0);
2938
2939   if (! *user_id)
2940     {
2941       log_debug ("user id is empty."
2942                  "  Can't get TOFU validity for this binding.\n");
2943       goto die;
2944     }
2945
2946   email = email_from_user_id (user_id);
2947
2948   trust_level = get_trust (dbs, pk, fingerprint, email, user_id, may_ask);
2949   if (trust_level == _tofu_GET_TRUST_ERROR)
2950     /* An error.  */
2951     trust_level = TRUST_UNDEFINED;
2952
2953   if (may_ask && trust_level != TRUST_ULTIMATE)
2954     show_statistics (dbs, fingerprint, email, user_id, NULL);
2955
2956  die:
2957   xfree (email);
2958   xfree (fingerprint);
2959   return trust_level;
2960 }
2961
2962 /* Set the policy for all non-revoked user ids in the keyblock KB to
2963    POLICY.
2964
2965    If no key is available with the specified key id, then this
2966    function returns GPG_ERR_NO_PUBKEY.
2967
2968    Returns 0 on success and an error code otherwise.  */
2969 gpg_error_t
2970 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
2971 {
2972   tofu_dbs_t dbs;
2973   PKT_public_key *pk;
2974   char *fingerprint = NULL;
2975
2976   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2977   pk = kb->pkt->pkt.public_key;
2978
2979   dbs = opendbs (ctrl);
2980   if (! dbs)
2981     {
2982       log_error (_("error opening TOFU database: %s\n"),
2983                  gpg_strerror (GPG_ERR_GENERAL));
2984       return gpg_error (GPG_ERR_GENERAL);
2985     }
2986
2987   if (DBG_TRUST)
2988     log_debug ("Setting TOFU policy for %s to %s\n",
2989                keystr (pk->keyid), tofu_policy_str (policy));
2990   if (! (pk->main_keyid[0] == pk->keyid[0]
2991          && pk->main_keyid[1] == pk->keyid[1]))
2992     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2993
2994   fingerprint = hexfingerprint (pk, NULL, 0);
2995
2996   for (; kb; kb = kb->next)
2997     {
2998       PKT_user_id *user_id;
2999       char *email;
3000
3001       if (kb->pkt->pkttype != PKT_USER_ID)
3002         continue;
3003
3004       user_id = kb->pkt->pkt.user_id;
3005       if (user_id->is_revoked)
3006         /* Skip revoked user ids.  (Don't skip expired user ids, the
3007            expiry can be changed.)  */
3008         continue;
3009
3010       email = email_from_user_id (user_id->name);
3011
3012       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
3013
3014       xfree (email);
3015     }
3016
3017   xfree (fingerprint);
3018   return 0;
3019 }
3020
3021 /* Set the TOFU policy for all non-revoked user ids in the KEY with
3022    the key id KEYID to POLICY.
3023
3024    If no key is available with the specified key id, then this
3025    function returns GPG_ERR_NO_PUBKEY.
3026
3027    Returns 0 on success and an error code otherwise.  */
3028 gpg_error_t
3029 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
3030 {
3031   kbnode_t keyblock = get_pubkeyblock (keyid);
3032   if (! keyblock)
3033     return gpg_error (GPG_ERR_NO_PUBKEY);
3034
3035   return tofu_set_policy (ctrl, keyblock, policy);
3036 }
3037
3038 /* Return the TOFU policy for the specified binding in *POLICY.  If no
3039    policy has been set for the binding, sets *POLICY to
3040    TOFU_POLICY_NONE.
3041
3042    PK is a primary public key and USER_ID is a user id.
3043
3044    Returns 0 on success and an error code otherwise.  */
3045 gpg_error_t
3046 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
3047                  enum tofu_policy *policy)
3048 {
3049   tofu_dbs_t dbs;
3050   char *fingerprint;
3051   char *email;
3052
3053   /* Make sure PK is a primary key.  */
3054   log_assert (pk->main_keyid[0] == pk->keyid[0]
3055               && pk->main_keyid[1] == pk->keyid[1]);
3056
3057   dbs = opendbs (ctrl);
3058   if (! dbs)
3059     {
3060       log_error (_("error opening TOFU database: %s\n"),
3061                  gpg_strerror (GPG_ERR_GENERAL));
3062       return gpg_error (GPG_ERR_GENERAL);
3063     }
3064
3065   fingerprint = hexfingerprint (pk, NULL, 0);
3066
3067   email = email_from_user_id (user_id->name);
3068
3069   *policy = get_policy (dbs, fingerprint, email, NULL);
3070
3071   xfree (email);
3072   xfree (fingerprint);
3073   if (*policy == _tofu_GET_POLICY_ERROR)
3074     return gpg_error (GPG_ERR_GENERAL);
3075   return 0;
3076 }