gpg: Don't store formatting fingerprints in the TOFU DB.
[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 void
2188 show_statistics (struct dbs *dbs, const char *fingerprint,
2189                  const char *email, const char *user_id,
2190                  const char *sig_exclude)
2191 {
2192   struct db *db;
2193   char *fingerprint_pp;
2194   int rc;
2195   strlist_t strlist = NULL;
2196   char *err = NULL;
2197
2198   db = getdb (dbs, email, DB_EMAIL);
2199   if (! db)
2200     return;
2201
2202   fingerprint_pp = fingerprint_format (fingerprint);
2203
2204   rc = sqlite3_exec_printf
2205     (db->db, strings_collect_cb, &strlist, &err,
2206      "select count (*), strftime('%%s','now') - min (signatures.time)\n"
2207      " from signatures\n"
2208      " left join bindings on signatures.binding = bindings.oid\n"
2209      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
2210      fingerprint, email,
2211      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
2212         not NULL.  */
2213      sig_exclude ? "!= '" : "is not NULL",
2214      sig_exclude ? sig_exclude : "",
2215      sig_exclude ? "'" : "");
2216   if (rc)
2217     {
2218       log_error (_("error reading from TOFU database"
2219                    " (getting statistics): %s\n"),
2220                  err);
2221       sqlite3_free (err);
2222       goto out;
2223     }
2224
2225   if (! strlist)
2226     log_info (_("Have never verified a message signed by key %s!\n"),
2227               fingerprint_pp);
2228   else
2229     {
2230       char *tail = NULL;
2231       signed long messages;
2232       signed long first_seen_ago;
2233
2234       assert (strlist_length (strlist) == 2);
2235
2236       errno = 0;
2237       messages = strtol (strlist->d, &tail, 0);
2238       if (errno || *tail != '\0')
2239         /* Abort.  */
2240         {
2241           log_debug ("%s:%d: Couldn't convert %s (messages) to an int: %s.\n",
2242                      __func__, __LINE__, strlist->d, strerror (errno));
2243           messages = -1;
2244         }
2245
2246       if (messages == 0 && *strlist->next->d == '\0')
2247         /* min(NULL) => NULL => "".  */
2248         first_seen_ago = -1;
2249       else
2250         {
2251           errno = 0;
2252           first_seen_ago = strtol (strlist->next->d, &tail, 0);
2253           if (errno || *tail != '\0')
2254             /* Abort.  */
2255             {
2256               log_debug ("%s:%d: Cound't convert %s (first_seen) to an int: %s.\n",
2257                          __func__, __LINE__,
2258                          strlist->next->d, strerror (errno));
2259               first_seen_ago = 0;
2260             }
2261         }
2262
2263       if (messages == -1 || first_seen_ago == 0)
2264         log_info (_("Failed to collect signature statistics for \"%s\" (key %s)\n"),
2265                   user_id, fingerprint_pp);
2266       else
2267         {
2268           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2269           estream_t fp;
2270           char *msg;
2271
2272           fp = es_fopenmem (0, "rw,samethread");
2273           if (! fp)
2274             log_fatal ("error creating memory stream\n");
2275
2276           if (messages == 0)
2277             es_fprintf (fp,
2278                         _("Verified 0 messages signed by \"%s\""
2279                           " (key: %s, policy %s)."),
2280                         user_id, fingerprint_pp, tofu_policy_str (policy));
2281           else
2282             {
2283               int years = 0;
2284               int months = 0;
2285               int days = 0;
2286               int hours = 0;
2287               int minutes = 0;
2288               int seconds = 0;
2289
2290               /* The number of units that we've printed so far.  */
2291               int count = 0;
2292               /* The first unit that we printed (year = 0, month = 1,
2293                  etc.).  */
2294               int first = -1;
2295               /* The current unit.  */
2296               int i = 0;
2297
2298               es_fprintf (fp,
2299                           _("Verified %ld messages signed by \"%s\""
2300                             " (key: %s, policy: %s) in the past "),
2301                           messages, user_id,
2302                           fingerprint_pp, tofu_policy_str (policy));
2303
2304               /* It would be nice to use a macro to do this, but gettext
2305                  works on the unpreprocessed code.  */
2306 #define MIN_SECS (60)
2307 #define HOUR_SECS (60 * MIN_SECS)
2308 #define DAY_SECS (24 * HOUR_SECS)
2309 #define MONTH_SECS (30 * DAY_SECS)
2310 #define YEAR_SECS (365 * DAY_SECS)
2311
2312               if (first_seen_ago > YEAR_SECS)
2313                 {
2314                   years = first_seen_ago / YEAR_SECS;
2315                   first_seen_ago -= years * YEAR_SECS;
2316                 }
2317               if (first_seen_ago > MONTH_SECS)
2318                 {
2319                   months = first_seen_ago / MONTH_SECS;
2320                   first_seen_ago -= months * MONTH_SECS;
2321                 }
2322               if (first_seen_ago > DAY_SECS)
2323                 {
2324                   days = first_seen_ago / DAY_SECS;
2325                   first_seen_ago -= days * DAY_SECS;
2326                 }
2327               if (first_seen_ago > HOUR_SECS)
2328                 {
2329                   hours = first_seen_ago / HOUR_SECS;
2330                   first_seen_ago -= hours * HOUR_SECS;
2331                 }
2332               if (first_seen_ago > MIN_SECS)
2333                 {
2334                   minutes = first_seen_ago / MIN_SECS;
2335                   first_seen_ago -= minutes * MIN_SECS;
2336                 }
2337               seconds = first_seen_ago;
2338
2339 #undef MIN_SECS
2340 #undef HOUR_SECS
2341 #undef DAY_SECS
2342 #undef MONTH_SECS
2343 #undef YEAR_SECS
2344
2345               if (years)
2346                 {
2347                   if (years > 1)
2348                     es_fprintf (fp, _("%d years"), years);
2349                   else
2350                     es_fprintf (fp, _("%d year"), years);
2351                   count ++;
2352                   first = i;
2353                 }
2354               i ++;
2355               if ((first == -1 || i - first <= 3) && months)
2356                 {
2357                   if (count)
2358                     es_fprintf (fp, _(", "));
2359
2360                   if (months > 1)
2361                     es_fprintf (fp, _("%d months"), months);
2362                   else
2363                     es_fprintf (fp, _("%d month"), months);
2364                   count ++;
2365                   first = i;
2366                 }
2367               i ++;
2368               if ((first == -1 || i - first <= 3) && count < 2 && days)
2369                 {
2370                   if (count)
2371                     es_fprintf (fp, _(", "));
2372
2373                   if (days > 1)
2374                     es_fprintf (fp, _("%d days"), days);
2375                   else
2376                     es_fprintf (fp, _("%d day"), days);
2377                   count ++;
2378                   first = i;
2379                 }
2380               i ++;
2381               if ((first == -1 || i - first <= 3) && count < 2 && hours)
2382                 {
2383                   if (count)
2384                     es_fprintf (fp, _(", "));
2385
2386                   if (hours > 1)
2387                     es_fprintf (fp, _("%d hours"), hours);
2388                   else
2389                     es_fprintf (fp, _("%d hour"), hours);
2390                   count ++;
2391                   first = i;
2392                 }
2393               i ++;
2394               if ((first == -1 || i - first <= 3) && count < 2 && minutes)
2395                 {
2396                   if (count)
2397                     es_fprintf (fp, _(", "));
2398
2399                   if (minutes > 1)
2400                     es_fprintf (fp, _("%d minutes"), minutes);
2401                   else
2402                     es_fprintf (fp, _("%d minute"), minutes);
2403                   count ++;
2404                   first = i;
2405                 }
2406               i ++;
2407               if ((first == -1 || i - first <= 3) && count < 2)
2408                 {
2409                   if (count)
2410                     es_fprintf (fp, _(", "));
2411
2412                   if (seconds > 1)
2413                     es_fprintf (fp, _("%d seconds"), seconds);
2414                   else
2415                     es_fprintf (fp, _("%d second"), seconds);
2416                 }
2417
2418               es_fprintf (fp, _("."));
2419             }
2420
2421           es_fputc (0, fp);
2422           if (es_fclose_snatch (fp, (void **) &msg, NULL))
2423             log_fatal ("error snatching memory stream\n");
2424
2425           log_info ("%s\n", msg);
2426
2427           if (policy == TOFU_POLICY_AUTO && messages < 10)
2428             {
2429               char *set_policy_command;
2430               const char *text;
2431
2432               if (messages == 0)
2433                 log_info (_("Warning: we've have yet to see a message signed by this key!\n"));
2434               else if (messages == 1)
2435                 log_info (_("Warning: we've only seen a single message signed by this key!\n"));
2436
2437               set_policy_command =
2438                 xasprintf ("gpg --tofu-policy bad \"%s\"", fingerprint);
2439               /* TRANSLATORS: translate the below text.  We don't
2440                  directly internationalize that text so that we can
2441                  tweak it without breaking translations.  */
2442               text = _("TOFU: few signatures %d %s %s");
2443               if (strcmp (text, "TOFU: few signatures %d %s %s") == 0)
2444                 text =
2445                   "Warning: if you think you've seen more than %d %s "
2446                   "signed by this key, then this key might be a forgery!  "
2447                   "Carefully examine the email address for small variations "
2448                   "(e.g., additional white space).  If the key is suspect, "
2449                   "then use '%s' to mark it as being bad.\n";
2450               log_info (text,
2451                         messages, messages == 1 ? _("message") : _("message"),
2452                         set_policy_command);
2453               free (set_policy_command);
2454             }
2455         }
2456     }
2457
2458  out:
2459   free_strlist (strlist);
2460   xfree (fingerprint_pp);
2461
2462   return;
2463 }
2464
2465 /* Extract the email address from a user id and normalize it.  If the
2466    user id doesn't contain an email address, then we use the whole
2467    user_id and normalize that.  The returned string must be freed.  */
2468 static char *
2469 email_from_user_id (const char *user_id)
2470 {
2471   char *email = mailbox_from_userid (user_id);
2472   if (! email)
2473     /* Hmm, no email address was provided.  Just take the lower-case
2474        version of the whole user id.  It could be a hostname, for
2475        instance.  */
2476     email = ascii_strlwr (xstrdup (user_id));
2477
2478   return email;
2479 }
2480
2481 /* Register the signature with the binding <FINGERPRINT_BIN, USER_ID>.
2482    FINGERPRINT must be MAX_FINGERPRINT_LEN bytes long.
2483
2484    SIG_DIGEST_BIN is the binary representation of the message's
2485    digest.  SIG_DIGEST_BIN_LEN is its length.
2486
2487    SIG_TIME is the time that the signature was generated.
2488
2489    ORIGIN is a free-formed string describing the origin of the
2490    signature.  If this was from an email and the Claws MUA was used,
2491    then this should be something like: "email:claws".  If this is
2492    NULL, the default is simply "unknown".
2493
2494    If MAY_ASK is 1, then this function may interact with the user.
2495    This is necessary if there is a conflict or the binding's policy is
2496    TOFU_POLICY_ASK.
2497
2498    This function returns the binding's trust level on return.  If an
2499    error occurs, this function returns TRUST_UNKNOWN.  */
2500 int
2501 tofu_register (const byte *fingerprint_bin, const char *user_id,
2502                const byte *sig_digest_bin, int sig_digest_bin_len,
2503                time_t sig_time, const char *origin, int may_ask)
2504 {
2505   struct dbs *dbs;
2506   struct db *db;
2507   char *fingerprint = NULL;
2508   char *fingerprint_pp = NULL;
2509   char *email = NULL;
2510   char *err = NULL;
2511   int rc;
2512   int trust_level = TRUST_UNKNOWN;
2513   char *sig_digest;
2514   unsigned long c;
2515   int already_verified = 0;
2516
2517   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2518
2519   dbs = opendbs ();
2520   if (! dbs)
2521     {
2522       log_error (_("error opening TOFU DB.\n"));
2523       goto die;
2524     }
2525
2526   fingerprint = fingerprint_str (fingerprint_bin);
2527   fingerprint_pp = fingerprint_format (fingerprint);
2528
2529   if (! *user_id)
2530     {
2531       log_debug ("TOFU: user id is empty.  Can't continue.\n");
2532       goto die;
2533     }
2534
2535   email = email_from_user_id (user_id);
2536
2537   if (! origin)
2538     /* The default origin is simply "unknown".  */
2539     origin = "unknown";
2540
2541   /* It's necessary to get the trust so that we are certain that the
2542      binding has been registered.  */
2543   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2544   if (trust_level == _tofu_GET_TRUST_ERROR)
2545     /* An error.  */
2546     {
2547       trust_level = TRUST_UNKNOWN;
2548       goto die;
2549     }
2550
2551   /* Save the observed signature in the DB.  */
2552   db = getdb (dbs, email, DB_EMAIL);
2553   if (! db)
2554     {
2555       log_error (_("error opening TOFU DB.\n"));
2556       goto die;
2557     }
2558
2559   /* We do a query and then an insert.  Make sure they are atomic
2560      by wrapping them in a transaction.  */
2561   rc = begin_transaction (db, 0);
2562   if (rc)
2563     goto die;
2564
2565   /* If we've already seen this signature before, then don't add
2566      it again.  */
2567   rc = sqlite3_stepx
2568     (db->db, &db->s.register_already_seen,
2569      get_single_unsigned_long_cb2, &c, &err,
2570      "select count (*)\n"
2571      " from signatures left join bindings\n"
2572      "  on signatures.binding = bindings.oid\n"
2573      " where fingerprint = ? and email = ? and sig_time = ?\n"
2574      "  and sig_digest = ?",
2575      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2576      SQLITE_ARG_LONG_LONG, (long long) sig_time,
2577      SQLITE_ARG_STRING, sig_digest,
2578      SQLITE_ARG_END);
2579   if (rc)
2580     {
2581       log_error (_("error reading from signatures database"
2582                    " (checking existence): %s\n"),
2583                  err);
2584       sqlite3_free (err);
2585     }
2586   else if (c > 1)
2587     /* Duplicates!  This should not happen.  In particular,
2588        because <fingerprint, email, sig_time, sig_digest> is the
2589        primary key!  */
2590     log_debug ("SIGNATURES DB contains duplicate records"
2591                " <key: %s, %s, time: 0x%lx, sig: %s, %s>."
2592                "  Please report.\n",
2593                fingerprint_pp, email, (unsigned long) sig_time,
2594                sig_digest, origin);
2595   else if (c == 1)
2596     {
2597       already_verified = 1;
2598       if (DBG_TRUST)
2599         log_debug ("Already observed the signature"
2600                    " <key: %s, %s, time: 0x%lx, sig: %s, %s>\n",
2601                    fingerprint_pp, email, (unsigned long) sig_time,
2602                    sig_digest, origin);
2603     }
2604   else
2605     /* This is the first time that we've seen this signature.
2606        Record it.  */
2607     {
2608       if (DBG_TRUST)
2609         log_debug ("TOFU: Saving signature <%s, %s, %s>\n",
2610                    fingerprint_pp, email, sig_digest);
2611
2612       assert (c == 0);
2613
2614       rc = sqlite3_stepx
2615         (db->db, &db->s.register_insert, NULL, NULL, &err,
2616          "insert into signatures\n"
2617          " (binding, sig_digest, origin, sig_time, time)\n"
2618          " values\n"
2619          " ((select oid from bindings\n"
2620          "    where fingerprint = ? and email = ?),\n"
2621          "  ?, ?, ?, strftime('%s', 'now'));",
2622          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2623          SQLITE_ARG_STRING, sig_digest, SQLITE_ARG_STRING, origin,
2624          SQLITE_ARG_LONG_LONG, (long long) sig_time,
2625          SQLITE_ARG_END);
2626       if (rc)
2627         {
2628           log_error (_("error updating TOFU DB"
2629                        " (inserting into signatures table): %s\n"),
2630                      err);
2631           sqlite3_free (err);
2632         }
2633     }
2634
2635   /* It only matters whether we abort or commit the transaction
2636      (so long as we do something) if we execute the insert.  */
2637   if (rc)
2638     rc = rollback_transaction (db);
2639   else
2640     rc = end_transaction (db, 0);
2641   if (rc)
2642     {
2643       log_error (_("error ending transaction on TOFU database: %s\n"), err);
2644       sqlite3_free (err);
2645       goto die;
2646     }
2647
2648  die:
2649   if (may_ask && trust_level != TRUST_ULTIMATE)
2650     /* It's only appropriate to show the statistics in an interactive
2651        context.  */
2652     show_statistics (dbs, fingerprint, email, user_id,
2653                      already_verified ? NULL : sig_digest);
2654
2655   xfree (email);
2656   xfree (fingerprint_pp);
2657   xfree (fingerprint);
2658   if (dbs)
2659     closedbs (dbs);
2660   xfree (sig_digest);
2661
2662   return trust_level;
2663 }
2664
2665 /* Combine a trust level returned from the TOFU trust model with a
2666    trust level returned by the PGP trust model.  This is primarily of
2667    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2668
2669    This function ors together the upper bits (the values not covered
2670    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2671 int
2672 tofu_wot_trust_combine (int tofu_base, int wot_base)
2673 {
2674   int tofu = tofu_base & TRUST_MASK;
2675   int wot = wot_base & TRUST_MASK;
2676   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2677
2678   assert (tofu == TRUST_UNKNOWN
2679           || tofu == TRUST_EXPIRED
2680           || tofu == TRUST_UNDEFINED
2681           || tofu == TRUST_NEVER
2682           || tofu == TRUST_MARGINAL
2683           || tofu == TRUST_FULLY
2684           || tofu == TRUST_ULTIMATE);
2685   assert (wot == TRUST_UNKNOWN
2686           || wot == TRUST_EXPIRED
2687           || wot == TRUST_UNDEFINED
2688           || wot == TRUST_NEVER
2689           || wot == TRUST_MARGINAL
2690           || wot == TRUST_FULLY
2691           || wot == TRUST_ULTIMATE);
2692
2693   /* We first consider negative trust policys.  These trump positive
2694      trust policies.  */
2695   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2696     /* TRUST_NEVER trumps everything else.  */
2697     return upper | TRUST_NEVER;
2698   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2699     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2700     return upper | TRUST_EXPIRED;
2701
2702   /* Now we only have positive or neutral trust policies.  We take
2703      the max.  */
2704   if (tofu == TRUST_ULTIMATE || wot == TRUST_ULTIMATE)
2705     return upper | TRUST_ULTIMATE;
2706   if (tofu == TRUST_FULLY || wot == TRUST_FULLY)
2707     return upper | TRUST_FULLY;
2708   if (tofu == TRUST_MARGINAL || wot == TRUST_MARGINAL)
2709     return upper | TRUST_MARGINAL;
2710   if (tofu == TRUST_UNDEFINED || wot == TRUST_UNDEFINED)
2711     return upper | TRUST_UNDEFINED;
2712   return upper | TRUST_UNKNOWN;
2713 }
2714
2715 /* Return the validity (TRUST_NEVER, etc.) of the binding
2716    <FINGERPRINT, USER_ID>.
2717
2718    FINGERPRINT must be a MAX_FINGERPRINT_LEN-byte fingerprint.
2719
2720    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2721    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2722    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2723
2724    Returns TRUST_UNDEFINED if an error occurs.  */
2725 int
2726 tofu_get_validity (const byte *fingerprint_bin, const char *user_id,
2727                    int may_ask)
2728 {
2729   struct dbs *dbs;
2730   char *fingerprint = NULL;
2731   char *email = NULL;
2732   int trust_level = TRUST_UNDEFINED;
2733
2734   dbs = opendbs ();
2735   if (! dbs)
2736     {
2737       log_error (_("error opening TOFU DB.\n"));
2738       goto die;
2739     }
2740
2741   fingerprint = fingerprint_str (fingerprint_bin);
2742
2743   if (! *user_id)
2744     {
2745       log_debug ("user id is empty.  Can't get TOFU validity for this binding.\n");
2746       goto die;
2747     }
2748
2749   email = email_from_user_id (user_id);
2750
2751   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2752   if (trust_level == _tofu_GET_TRUST_ERROR)
2753     /* An error.  */
2754     trust_level = TRUST_UNDEFINED;
2755
2756   if (may_ask && trust_level != TRUST_ULTIMATE)
2757     show_statistics (dbs, fingerprint, email, user_id, NULL);
2758
2759  die:
2760   xfree (email);
2761   xfree (fingerprint);
2762   if (dbs)
2763     closedbs (dbs);
2764
2765   return trust_level;
2766 }
2767
2768 /* Set the policy for all non-revoked user ids in the keyblock KB to
2769    POLICY.
2770
2771    If no key is available with the specified key id, then this
2772    function returns GPG_ERR_NO_PUBKEY.
2773
2774    Returns 0 on success and an error code otherwise.  */
2775 gpg_error_t
2776 tofu_set_policy (kbnode_t kb, enum tofu_policy policy)
2777 {
2778   struct dbs *dbs;
2779   PKT_public_key *pk;
2780   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2781   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2782   char *fingerprint = NULL;
2783
2784   assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2785   pk = kb->pkt->pkt.public_key;
2786
2787   dbs = opendbs ();
2788   if (! dbs)
2789     {
2790       log_error (_("error opening TOFU DB.\n"));
2791       return gpg_error (GPG_ERR_GENERAL);
2792     }
2793
2794   if (DBG_TRUST)
2795     log_debug ("Setting TOFU policy for %s to %s\n",
2796                keystr (pk->keyid), tofu_policy_str (policy));
2797   if (! (pk->main_keyid[0] == pk->keyid[0]
2798          && pk->main_keyid[1] == pk->keyid[1]))
2799     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2800
2801   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2802   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2803
2804   fingerprint = fingerprint_str (fingerprint_bin);
2805
2806   for (; kb; kb = kb->next)
2807     {
2808       PKT_user_id *user_id;
2809       char *email;
2810
2811       if (kb->pkt->pkttype != PKT_USER_ID)
2812         continue;
2813
2814       user_id = kb->pkt->pkt.user_id;
2815       if (user_id->is_revoked)
2816         /* Skip revoked user ids.  (Don't skip expired user ids, the
2817            expiry can be changed.)  */
2818         continue;
2819
2820       email = email_from_user_id (user_id->name);
2821
2822       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2823
2824       xfree (email);
2825     }
2826
2827   xfree (fingerprint);
2828   closedbs (dbs);
2829
2830   return 0;
2831 }
2832
2833 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2834    the key id KEYID to POLICY.
2835
2836    If no key is available with the specified key id, then this
2837    function returns GPG_ERR_NO_PUBKEY.
2838
2839    Returns 0 on success and an error code otherwise.  */
2840 gpg_error_t
2841 tofu_set_policy_by_keyid (u32 *keyid, enum tofu_policy policy)
2842 {
2843   kbnode_t keyblock = get_pubkeyblock (keyid);
2844   if (! keyblock)
2845     return gpg_error (GPG_ERR_NO_PUBKEY);
2846
2847   return tofu_set_policy (keyblock, policy);
2848 }
2849
2850 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2851    policy has been set for the binding, sets *POLICY to
2852    TOFU_POLICY_NONE.
2853
2854    PK is a primary public key and USER_ID is a user id.
2855
2856    Returns 0 on success and an error code otherwise.  */
2857 gpg_error_t
2858 tofu_get_policy (PKT_public_key *pk, PKT_user_id *user_id,
2859                  enum tofu_policy *policy)
2860 {
2861   struct dbs *dbs;
2862   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2863   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2864   char *fingerprint;
2865   char *email;
2866
2867   /* Make sure PK is a primary key.  */
2868   assert (pk->main_keyid[0] == pk->keyid[0]
2869           && pk->main_keyid[1] == pk->keyid[1]);
2870
2871   dbs = opendbs ();
2872   if (! dbs)
2873     {
2874       log_error (_("error opening TOFU DB.\n"));
2875       return gpg_error (GPG_ERR_GENERAL);
2876     }
2877
2878   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2879   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2880
2881   fingerprint = fingerprint_str (fingerprint_bin);
2882
2883   email = email_from_user_id (user_id->name);
2884
2885   *policy = get_policy (dbs, fingerprint, email, NULL);
2886
2887   xfree (email);
2888   xfree (fingerprint);
2889   closedbs (dbs);
2890
2891   if (*policy == _tofu_GET_POLICY_ERROR)
2892     return gpg_error (GPG_ERR_GENERAL);
2893   return 0;
2894 }