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