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