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