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