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