gpg: Change sqlite3_stepx to pass the sqlite3_stmt * to the callback.
[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
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 occured, 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 and tofu.d.  Using split format for TOFU DB.\n"));
952           opt.tofu_db_format = TOFU_DB_SPLIT;
953         }
954       else if (have_tofu_db)
955         {
956           opt.tofu_db_format = TOFU_DB_FLAT;
957           if (DBG_TRUST)
958             log_debug ("Using flat format for TOFU DB.\n");
959         }
960       else if (have_tofu_d)
961         {
962           opt.tofu_db_format = TOFU_DB_SPLIT;
963           if (DBG_TRUST)
964             log_debug ("Using split format for TOFU DB.\n");
965         }
966       else
967         {
968           opt.tofu_db_format = TOFU_DB_SPLIT;
969           if (DBG_TRUST)
970             log_debug ("Using split format for TOFU DB.\n");
971         }
972     }
973
974   return xmalloc_clear (sizeof (struct dbs));
975 }
976
977 /* Release all of the resources associated with a DB meta-handle.  */
978 static void
979 closedbs (struct dbs *dbs)
980 {
981   if (dbs->db)
982     {
983       struct db *old_head = db_cache;
984       struct db *db;
985       int count;
986
987       /* Find the last DB.  */
988       for (db = dbs->db, count = 1; db->next; db = db->next, count ++)
989         {
990           /* When we leave batch mode we leave batch mode on any
991              cached connections.  */
992           if (! batch_update)
993             assert (! db->batch_update);
994         }
995       if (! batch_update)
996         assert (! db->batch_update);
997
998       /* Join the two lists.  */
999       db->next = db_cache;
1000       if (db_cache)
1001         db_cache->prevp = &db->next;
1002
1003       /* Update the (new) first element.  */
1004       db_cache = dbs->db;
1005       dbs->db->prevp = &db_cache;
1006
1007       db_cache_count += count;
1008
1009       /* Make sure that we don't have too many DBs on DB_CACHE.  If
1010          so, free some.  */
1011       if (db_cache_count > DB_CACHE_ENTRIES)
1012         {
1013           /* We need to find the (DB_CACHE_ENTRIES + 1)th entry.  It
1014              is easy to skip the first COUNT entries since we still
1015              have a handle on the old head.  */
1016           int skip = DB_CACHE_ENTRIES - count;
1017           while (-- skip > 0)
1018             old_head = old_head->next;
1019
1020           *old_head->prevp = NULL;
1021
1022           while (old_head)
1023             {
1024               db = old_head->next;
1025               closedb (old_head);
1026               old_head = db;
1027               db_cache_count --;
1028             }
1029         }
1030     }
1031
1032   xfree (dbs);
1033
1034 #if DEBUG_TOFU_CACHE
1035   log_debug ("Queries: %d (prepares saved: %d)\n",
1036              queries, prepares_saved);
1037 #endif
1038 }
1039
1040
1041 /* Collect results of a select min (foo) ...; style query.  Aborts if
1042    the argument is not a valid integer (or real of the form X.0).  */
1043 static int
1044 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
1045 {
1046   long *count = cookie;
1047   char *tail = NULL;
1048
1049   (void) azColName;
1050
1051   assert (argc == 1);
1052
1053   errno = 0;
1054   *count = strtol (argv[0], &tail, 0);
1055   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1056     /* Abort.  */
1057     return 1;
1058   return 0;
1059 }
1060
1061 static int
1062 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
1063                      sqlite3_stmt *stmt)
1064 {
1065   (void) stmt;
1066   return get_single_long_cb (cookie, argc, argv, azColName);
1067 }
1068
1069 /* Record (or update) a trust policy about a (possibly new)
1070    binding.
1071
1072    If SHOW_OLD is set, the binding's old policy is displayed.  */
1073 static gpg_error_t
1074 record_binding (struct dbs *dbs, const char *fingerprint, const char *email,
1075                 const char *user_id, enum tofu_policy policy, int show_old)
1076 {
1077   struct db *db_email = NULL, *db_key = NULL;
1078   int rc;
1079   char *err = NULL;
1080   enum tofu_policy policy_old = TOFU_POLICY_NONE;
1081
1082   if (! (policy == TOFU_POLICY_AUTO
1083          || policy == TOFU_POLICY_GOOD
1084          || policy == TOFU_POLICY_UNKNOWN
1085          || policy == TOFU_POLICY_BAD
1086          || policy == TOFU_POLICY_ASK))
1087     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
1088
1089   db_email = getdb (dbs, email, DB_EMAIL);
1090   if (! db_email)
1091     return gpg_error (GPG_ERR_GENERAL);
1092
1093   if (opt.tofu_db_format == TOFU_DB_SPLIT)
1094     /* In the split format, we need to update two DBs.  To keep them
1095        consistent, we start a transaction on each.  Note: this is the
1096        only place where we start two transaction and we always start
1097        transaction on the DB_KEY DB first, thus deadlock is not
1098        possible.  */
1099     {
1100       db_key = getdb (dbs, fingerprint, DB_KEY);
1101       if (! db_key)
1102         return gpg_error (GPG_ERR_GENERAL);
1103
1104       rc = begin_transaction (db_email, 0);
1105       if (rc)
1106         return gpg_error (GPG_ERR_GENERAL);
1107
1108       rc = begin_transaction (db_key, 0);
1109       if (rc)
1110         goto out_revert_one;
1111     }
1112   else
1113     {
1114       rc = begin_transaction (db_email, 1);
1115       if (rc)
1116         return gpg_error (GPG_ERR_GENERAL);
1117     }
1118
1119
1120   if (show_old)
1121     /* Get the old policy.  Since this is just for informational
1122        purposes, there is no need to start a transaction or to die if
1123        there is a failure.  */
1124     {
1125       rc = sqlite3_stepx
1126         (db_email->db, &db_email->s.record_binding_get_old_policy,
1127          get_single_long_cb2, &policy_old, &err,
1128          "select policy from bindings where fingerprint = ? and email = ?",
1129          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1130          SQLITE_ARG_END);
1131       if (rc)
1132         {
1133           log_debug ("TOFU: Error reading from binding database"
1134                      " (reading policy for <%s, %s>): %s\n",
1135                      fingerprint, email, err);
1136           sqlite3_free (err);
1137         }
1138     }
1139
1140   if (DBG_TRUST)
1141     {
1142       if (policy_old != TOFU_POLICY_NONE)
1143         log_debug ("Changing TOFU trust policy for binding <%s, %s>"
1144                    " from %s to %s.\n",
1145                    fingerprint, email,
1146                    tofu_policy_str (policy_old),
1147                    tofu_policy_str (policy));
1148       else
1149         log_debug ("Set TOFU trust policy for binding <%s, %s> to %s.\n",
1150                    fingerprint, email,
1151                    tofu_policy_str (policy));
1152     }
1153
1154   if (policy_old == policy)
1155     /* Nothing to do.  */
1156     goto out;
1157
1158   rc = sqlite3_stepx
1159     (db_email->db, &db_email->s.record_binding_update, NULL, NULL, &err,
1160      "insert or replace into bindings\n"
1161      " (oid, fingerprint, email, user_id, time, policy)\n"
1162      " values (\n"
1163      /* If we don't explicitly reuse the OID, then SQLite will
1164         reallocate a new one.  We just need to search for the OID
1165         based on the fingerprint and email since they are unique.  */
1166      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1167      "  ?, ?, ?, strftime('%s','now'), ?);",
1168      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1169      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1170      SQLITE_ARG_STRING, user_id, SQLITE_ARG_INT, (int) policy,
1171      SQLITE_ARG_END);
1172   if (rc)
1173     {
1174       log_error (_("error updating TOFU binding database"
1175                    " (inserting <%s, %s> = %s): %s\n"),
1176                  fingerprint, email, tofu_policy_str (policy),
1177                  err);
1178       sqlite3_free (err);
1179       goto out;
1180     }
1181
1182   if (db_key)
1183     /* We also need to update the key DB.  */
1184     {
1185       assert (opt.tofu_db_format == TOFU_DB_SPLIT);
1186
1187       rc = sqlite3_stepx
1188         (db_key->db, &db_key->s.record_binding_update2, NULL, NULL, &err,
1189          "insert or replace into bindings\n"
1190          " (oid, fingerprint, email, user_id)\n"
1191          " values (\n"
1192          /* If we don't explicitly reuse the OID, then SQLite will
1193             reallocate a new one.  We just need to search for the OID
1194             based on the fingerprint and email since they are unique.  */
1195          "  (select oid from bindings where fingerprint = ? and email = ?),\n"
1196          "  ?, ?, ?);",
1197          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1198          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
1199          SQLITE_ARG_STRING, user_id, SQLITE_ARG_END);
1200       if (rc)
1201         {
1202           log_error (_("error updating TOFU binding database"
1203                        " (inserting <%s, %s>): %s\n"),
1204                      fingerprint, email, err);
1205           sqlite3_free (err);
1206           goto out;
1207         }
1208     }
1209   else
1210     assert (opt.tofu_db_format == TOFU_DB_FLAT);
1211
1212  out:
1213   if (opt.tofu_db_format == TOFU_DB_SPLIT)
1214     /* We only need a transaction for the split format.  */
1215     {
1216       int rc2;
1217
1218       if (rc)
1219         rc2 = rollback_transaction (db_key);
1220       else
1221         rc2 = end_transaction (db_key, 0);
1222       if (rc2)
1223         {
1224           log_error (_("error ending transaction on TOFU database: %s\n"),
1225                      err);
1226           sqlite3_free (err);
1227         }
1228
1229     out_revert_one:
1230       if (rc)
1231         rc2 = rollback_transaction (db_email);
1232       else
1233         rc2 = end_transaction (db_email, 0);
1234       if (rc2)
1235         {
1236           log_error (_("error ending transaction on TOFU database: %s\n"),
1237                      err);
1238           sqlite3_free (err);
1239         }
1240     }
1241
1242   if (rc)
1243     return gpg_error (GPG_ERR_GENERAL);
1244   return 0;
1245 }
1246
1247
1248 /* Collect the strings returned by a query in a simply string list.
1249    Any NULL values are converted to the empty string.
1250
1251    If a result has 3 rows and each row contains two columns, then the
1252    results are added to the list as follows (the value is parentheses
1253    is the 1-based index in the final list):
1254
1255      row 1, col 2 (6)
1256      row 1, col 1 (5)
1257      row 2, col 2 (4)
1258      row 2, col 1 (3)
1259      row 3, col 2 (2)
1260      row 3, col 1 (1)
1261
1262    This is because add_to_strlist pushes the results onto the front of
1263    the list.  The end result is that the rows are backwards, but the
1264    columns are in the expected order.  */
1265 static int
1266 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
1267 {
1268   int i;
1269   strlist_t *strlist = cookie;
1270
1271   (void) azColName;
1272
1273   for (i = argc - 1; i >= 0; i --)
1274     add_to_strlist (strlist, argv[i] ? argv[i] : "");
1275
1276   return 0;
1277 }
1278
1279 static int
1280 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
1281                      sqlite3_stmt *stmt)
1282 {
1283   (void) stmt;
1284   return strings_collect_cb (cookie, argc, argv, azColName);
1285
1286 }
1287
1288 /* Auxiliary data structure to collect statistics about
1289    signatures.  */
1290 struct signature_stats
1291 {
1292   struct signature_stats *next;
1293
1294   /* The user-assigned policy for this binding.  */
1295   enum tofu_policy policy;
1296
1297   /* How long ago the signature was created (rounded to a multiple of
1298      TIME_AGO_UNIT_SMALL, etc.).  */
1299   long time_ago;
1300   /* Number of signatures during this time.  */
1301   unsigned long count;
1302
1303   /* The key that generated this signature.  */
1304   char fingerprint[1];
1305 };
1306
1307 static void
1308 signature_stats_free (struct signature_stats *stats)
1309 {
1310   while (stats)
1311     {
1312       struct signature_stats *next = stats->next;
1313       xfree (stats);
1314       stats = next;
1315     }
1316 }
1317
1318 static void
1319 signature_stats_prepend (struct signature_stats **statsp,
1320                          const char *fingerprint,
1321                          enum tofu_policy policy,
1322                          long time_ago,
1323                          unsigned long count)
1324 {
1325   struct signature_stats *stats =
1326     xmalloc (sizeof (*stats) + strlen (fingerprint));
1327
1328   stats->next = *statsp;
1329   *statsp = stats;
1330
1331   strcpy (stats->fingerprint, fingerprint);
1332   stats->policy = policy;
1333   stats->time_ago = time_ago;
1334   stats->count = count;
1335 }
1336
1337
1338 /* Process rows that contain the four columns:
1339
1340      <fingerprint, policy, time ago, count>.  */
1341 static int
1342 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1343                             char **azColName, sqlite3_stmt *stmt)
1344 {
1345   struct signature_stats **statsp = cookie;
1346   char *tail;
1347   int i = 0;
1348   enum tofu_policy policy;
1349   long time_ago;
1350   unsigned long count;
1351
1352   (void) azColName;
1353   (void) stmt;
1354
1355   i ++;
1356
1357   tail = NULL;
1358   errno = 0;
1359   policy = strtol (argv[i], &tail, 0);
1360   if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1361     {
1362       /* Abort.  */
1363       log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1364                  __func__, argv[i], tail);
1365       return 1;
1366     }
1367   i ++;
1368
1369   if (! argv[i])
1370     time_ago = 0;
1371   else
1372     {
1373       tail = NULL;
1374       errno = 0;
1375       time_ago = strtol (argv[i], &tail, 0);
1376       if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1377         {
1378           /* Abort.  */
1379           log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1380                      __func__, argv[i], tail);
1381           return 1;
1382         }
1383     }
1384   i ++;
1385
1386   /* If time_ago is NULL, then we had no messages, but we still have a
1387      single row, which count(*) turns into 1.  */
1388   if (! argv[i - 1])
1389     count = 0;
1390   else
1391     {
1392       tail = NULL;
1393       errno = 0;
1394       count = strtoul (argv[i], &tail, 0);
1395       if (errno || ! (strcmp (tail, ".0") == 0 || *tail == '\0'))
1396         {
1397           /* Abort.  */
1398           log_error ("%s: Error converting %s to an integer (tail = '%s')\n",
1399                      __func__, argv[i], tail);
1400           return 1;
1401         }
1402     }
1403   i ++;
1404
1405   assert (argc == i);
1406
1407   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1408
1409   return 0;
1410 }
1411
1412 /* Convert from seconds to time units.
1413
1414    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1415    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1416 signed long
1417 time_ago_scale (signed long t)
1418 {
1419   if (t < TIME_AGO_UNIT_MEDIUM)
1420     return t / TIME_AGO_UNIT_SMALL;
1421   if (t < TIME_AGO_UNIT_LARGE)
1422     return t / TIME_AGO_UNIT_MEDIUM;
1423   return t / TIME_AGO_UNIT_LARGE;
1424 }
1425
1426 /* Return the appropriate unit (respecting whether it is plural or
1427    singular).  */
1428 const char *
1429 time_ago_unit (signed long t)
1430 {
1431   signed long t_scaled = time_ago_scale (t);
1432
1433   if (t < TIME_AGO_UNIT_MEDIUM)
1434     {
1435       if (t_scaled == 1)
1436         return TIME_AGO_UNIT_SMALL_NAME;
1437       return TIME_AGO_UNIT_SMALL_NAME_PLURAL;
1438     }
1439   if (t < TIME_AGO_UNIT_LARGE)
1440     {
1441       if (t_scaled == 1)
1442         return TIME_AGO_UNIT_MEDIUM_NAME;
1443       return TIME_AGO_UNIT_MEDIUM_NAME_PLURAL;
1444     }
1445   if (t_scaled == 1)
1446     return TIME_AGO_UNIT_LARGE_NAME;
1447   return TIME_AGO_UNIT_LARGE_NAME_PLURAL;
1448 }
1449
1450
1451 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1452    already been normalized) and any conflict information in *CONFLICT
1453    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1454    occurs.  */
1455 static enum tofu_policy
1456 get_policy (struct dbs *dbs, const char *fingerprint, const char *email,
1457             char **conflict)
1458 {
1459   struct db *db;
1460   int rc;
1461   char *err = NULL;
1462   strlist_t strlist = NULL;
1463   char *tail = NULL;
1464   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1465
1466   db = getdb (dbs, email, DB_EMAIL);
1467   if (! db)
1468     return _tofu_GET_POLICY_ERROR;
1469
1470   /* Check if the <FINGERPRINT, EMAIL> binding is known
1471      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1472      still TOFU_POLICY_NONE after executing the query, then the
1473      result set was empty.)  */
1474   rc = sqlite3_stepx (db->db, &db->s.get_policy_select_policy_and_conflict,
1475                       strings_collect_cb2, &strlist, &err,
1476                       "select policy, conflict from bindings\n"
1477                       " where fingerprint = ? and email = ?",
1478                       SQLITE_ARG_STRING, fingerprint,
1479                       SQLITE_ARG_STRING, email,
1480                       SQLITE_ARG_END);
1481   if (rc)
1482     {
1483       log_error (_("error reading from TOFU database"
1484                    " (checking for existing bad bindings): %s\n"),
1485                  err);
1486       sqlite3_free (err);
1487       goto out;
1488     }
1489
1490   if (strlist_length (strlist) == 0)
1491     /* No results.  */
1492     {
1493       policy = TOFU_POLICY_NONE;
1494       goto out;
1495     }
1496   else if (strlist_length (strlist) != 2)
1497     /* The result has the wrong form.  */
1498     {
1499       log_error (_("error reading from TOFU database"
1500                    " (checking for existing bad bindings):"
1501                    " expected 2 results, got %d\n"),
1502                  strlist_length (strlist));
1503       goto out;
1504     }
1505
1506   /* The result has the right form.  */
1507
1508   errno = 0;
1509   policy = strtol (strlist->d, &tail, 0);
1510   if (errno || *tail != '\0')
1511     {
1512       log_error (_("error reading from TOFU database: bad value for policy: %s\n"),
1513                  strlist->d);
1514       goto out;
1515     }
1516
1517   if (! (policy == TOFU_POLICY_AUTO
1518          || policy == TOFU_POLICY_GOOD
1519          || policy == TOFU_POLICY_UNKNOWN
1520          || policy == TOFU_POLICY_BAD
1521          || policy == TOFU_POLICY_ASK))
1522     {
1523       log_error (_("TOFU DB is corrupted.  Invalid value for policy (%d).\n"),
1524                  policy);
1525       policy = _tofu_GET_POLICY_ERROR;
1526       goto out;
1527     }
1528
1529
1530   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1531      just in case, we do the check again here and ignore the conflict
1532      is POLICY is not TOFU_POLICY_ASK.  */
1533   if (conflict)
1534     {
1535       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1536         *conflict = xstrdup (strlist->next->d);
1537       else
1538         *conflict = NULL;
1539     }
1540
1541  out:
1542   assert (policy == _tofu_GET_POLICY_ERROR
1543           || policy == TOFU_POLICY_NONE
1544           || policy == TOFU_POLICY_AUTO
1545           || policy == TOFU_POLICY_GOOD
1546           || policy == TOFU_POLICY_UNKNOWN
1547           || policy == TOFU_POLICY_BAD
1548           || policy == TOFU_POLICY_ASK);
1549
1550   free_strlist (strlist);
1551
1552   return policy;
1553 }
1554
1555 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1556    <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1557    is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1558    returns _tofu_GET_TRUST_ERROR.
1559
1560    USER_ID is the unadultered user id.
1561
1562    If MAY_ASK is set, then we may interact with the user.  This is
1563    necessary if there is a conflict or the binding's policy is
1564    TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1565    conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1566    we return TRUST_UNDEFINED.  */
1567 static enum tofu_policy
1568 get_trust (struct dbs *dbs, const char *fingerprint, const char *email,
1569            const char *user_id, int may_ask)
1570 {
1571   struct db *db;
1572   enum tofu_policy policy;
1573   char *conflict = NULL;
1574   int rc;
1575   char *err = NULL;
1576   strlist_t bindings_with_this_email = NULL;
1577   int bindings_with_this_email_count;
1578   int change_conflicting_to_ask = 0;
1579   int trust_level = TRUST_UNKNOWN;
1580
1581   if (opt.batch)
1582     may_ask = 0;
1583
1584   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1585      levels.  */
1586   assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1587           && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1588           && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1589           && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1590           && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1591           && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1592           && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1593
1594   db = getdb (dbs, email, DB_EMAIL);
1595   if (! db)
1596     return _tofu_GET_TRUST_ERROR;
1597
1598   policy = get_policy (dbs, fingerprint, email, &conflict);
1599   if (policy == TOFU_POLICY_AUTO || policy == TOFU_POLICY_NONE)
1600     /* See if the key is ultimately trusted.  If so, we're done.  */
1601     {
1602       int i, j;
1603       char keyid[17];
1604       KEYDB_SEARCH_DESC desc;
1605
1606       /* We need to convert the fingerprint as a string to a long
1607          keyid.
1608
1609          FINGERPRINT has the form:
1610
1611            362D 3527 F53A AD19 71AA  FDE6 5885 9975 EE37 CF96
1612                                           -------------------
1613
1614          The last 16 characters are the long keyid.
1615       */
1616       assert (strlen (fingerprint) > 4 * 4 + 3);
1617       for (i = strlen (fingerprint) - (4 * 4 + 3), j = 0; j < 16; i ++, j ++)
1618         {
1619           if (fingerprint[i] == ' ')
1620             i ++;
1621           keyid[j] = fingerprint[i];
1622         }
1623       keyid[j] = 0;
1624
1625       rc = classify_user_id (keyid, &desc, 1);
1626       if (rc || desc.mode != KEYDB_SEARCH_MODE_LONG_KID)
1627         {
1628           log_error (_("'%s' is not a valid long keyID\n"), keyid);
1629           return _tofu_GET_TRUST_ERROR;
1630         }
1631
1632       if (tdb_keyid_is_utk (desc.u.kid))
1633         {
1634           if (policy == TOFU_POLICY_NONE)
1635             {
1636               if (record_binding (dbs, fingerprint, email, user_id,
1637                                   TOFU_POLICY_AUTO, 0) != 0)
1638                 {
1639                   log_error (_("error setting TOFU binding's trust level to %s\n"),
1640                              "auto");
1641                   trust_level = _tofu_GET_TRUST_ERROR;
1642                   goto out;
1643                 }
1644             }
1645
1646           trust_level = TRUST_ULTIMATE;
1647           goto out;
1648         }
1649     }
1650
1651   if (policy == TOFU_POLICY_AUTO)
1652     {
1653       policy = opt.tofu_default_policy;
1654       if (DBG_TRUST)
1655         log_debug ("TOFU: binding <%s, %s>'s policy is auto (default: %s).\n",
1656                    fingerprint, email,
1657                    tofu_policy_str (opt.tofu_default_policy));
1658     }
1659   switch (policy)
1660     {
1661     case TOFU_POLICY_AUTO:
1662     case TOFU_POLICY_GOOD:
1663     case TOFU_POLICY_UNKNOWN:
1664     case TOFU_POLICY_BAD:
1665       /* The saved judgement is auto -> auto, good, unknown or bad.
1666          We don't need to ask the user anything.  */
1667       if (DBG_TRUST)
1668         log_debug ("TOFU: Known binding <%s, %s>'s policy: %s\n",
1669                    fingerprint, email, tofu_policy_str (policy));
1670       trust_level = tofu_policy_to_trust_level (policy);
1671       goto out;
1672
1673     case TOFU_POLICY_ASK:
1674       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1675       if (! may_ask)
1676         {
1677           trust_level = TRUST_UNDEFINED;
1678           goto out;
1679         }
1680
1681       break;
1682
1683     case TOFU_POLICY_NONE:
1684       /* The binding is new, we need to check for conflicts.  Case #3
1685          below.  */
1686       break;
1687
1688     case _tofu_GET_POLICY_ERROR:
1689       trust_level = _tofu_GET_TRUST_ERROR;
1690       goto out;
1691
1692     default:
1693       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1694     }
1695
1696
1697   /* We get here if:
1698
1699        1. The saved policy is auto and the default policy is ask
1700           (get_policy() == TOFU_POLICY_AUTO
1701            && opt.tofu_default_policy == TOFU_POLICY_ASK)
1702
1703        2. The saved policy is ask (either last time the user selected
1704           accept once or reject once or there was a conflict and this
1705           binding's policy was changed from auto to ask)
1706           (policy == TOFU_POLICY_ASK), or,
1707
1708        3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1709           (need to check for a conflict).
1710    */
1711
1712   /* Look for conflicts.  This is needed in all 3 cases.
1713
1714      Get the fingerprints of any bindings that share the email
1715      address.  Note: if the binding in question is in the DB, it will
1716      also be returned.  Thus, if the result set is empty, then this is
1717      a new binding.  */
1718   rc = sqlite3_stepx
1719     (db->db, &db->s.get_trust_bindings_with_this_email,
1720      strings_collect_cb2, &bindings_with_this_email, &err,
1721      "select distinct fingerprint from bindings where email = ?;",
1722      SQLITE_ARG_STRING, email, SQLITE_ARG_END);
1723   if (rc)
1724     {
1725       log_error (_("error reading from TOFU database"
1726                    " (listing fingerprints): %s\n"),
1727                  err);
1728       sqlite3_free (err);
1729       goto out;
1730     }
1731
1732   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1733   if (bindings_with_this_email_count == 0
1734       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1735     /* New binding with no conflict and a concrete default policy.
1736
1737        We've never observed a binding with this email address
1738        (BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would return
1739        the current binding if it were in the DB) and we have a default
1740        policy, which is not to ask the user.  */
1741     {
1742       /* If we've seen this binding, then we've seen this email and
1743          policy couldn't possibly be TOFU_POLICY_NONE.  */
1744       assert (policy == TOFU_POLICY_NONE);
1745
1746       if (DBG_TRUST)
1747         log_debug ("TOFU: New binding <%s, %s>, no conflict.\n",
1748                    email, fingerprint);
1749
1750       if (record_binding (dbs, fingerprint, email, user_id,
1751                           TOFU_POLICY_AUTO, 0) != 0)
1752         {
1753           log_error (_("error setting TOFU binding's trust level to %s\n"),
1754                        "auto");
1755           trust_level = _tofu_GET_TRUST_ERROR;
1756           goto out;
1757         }
1758
1759       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1760       goto out;
1761     }
1762
1763   if (policy == TOFU_POLICY_NONE)
1764     /* This is a new binding and we have a conflict.  Mark any
1765        conflicting bindings that have an automatic policy as now
1766        requiring confirmation.  Note: we delay this until after we ask
1767        for confirmation so that when the current policy is printed, it
1768        is correct.  */
1769     change_conflicting_to_ask = 1;
1770
1771   if (! may_ask)
1772     /* We can only get here in the third case (no saved policy) and if
1773        there is a conflict.  (If the policy was ask (cases #1 and #2)
1774        and we weren't allowed to ask, we'd have already exited).  */
1775     {
1776       assert (policy == TOFU_POLICY_NONE);
1777
1778       if (record_binding (dbs, fingerprint, email, user_id,
1779                           TOFU_POLICY_ASK, 0) != 0)
1780         log_error (_("error setting TOFU binding's trust level to %s\n"),
1781                    "ask");
1782
1783       trust_level = TRUST_UNDEFINED;
1784       goto out;
1785     }
1786
1787   /* If we get here, we need to ask the user about the binding.  There
1788      are three ways we could end up here:
1789
1790        - This is a new binding and there is a conflict
1791          (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1792
1793        - This is a new binding and opt.tofu_default_policy is set to
1794          ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1795          TOFU_POLICY_ASK), or,
1796
1797        - The policy is ask (the user deferred last time) (policy ==
1798          TOFU_POLICY_ASK).
1799    */
1800   {
1801     int is_conflict =
1802       ((policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1803        || (policy == TOFU_POLICY_ASK && conflict));
1804     estream_t fp;
1805     char *binding;
1806     int binding_shown;
1807     strlist_t other_user_ids = NULL;
1808     struct signature_stats *stats = NULL;
1809     struct signature_stats *stats_iter = NULL;
1810     char *prompt;
1811     char *choices;
1812
1813     fp = es_fopenmem (0, "rw,samethread");
1814     if (! fp)
1815       log_fatal ("Error creating memory stream\n");
1816
1817     binding = xasprintf ("<%s, %s>", fingerprint, email);
1818     binding_shown = 0;
1819
1820     if (policy == TOFU_POLICY_NONE)
1821       {
1822         es_fprintf (fp, _("The binding %s is NOT known.  "), binding);
1823         binding_shown = 1;
1824       }
1825     else if (policy == TOFU_POLICY_ASK
1826              /* If there the conflict is with itself, then don't
1827                 display this message.  */
1828              && conflict && strcmp (conflict, fingerprint) != 0)
1829       {
1830         es_fprintf (fp,
1831                     _("The key %s raised a conflict with this binding (%s)."
1832                       "  Since this binding's policy was 'auto', it was"
1833                       "changed to 'ask'.  "),
1834                     conflict, binding);
1835         binding_shown = 1;
1836       }
1837     es_fprintf (fp,
1838                 _("Please indicate whether you believe the binding %s%s"
1839                   "is legitimate (the key belongs to the stated owner) "
1840                   "or a forgery (bad).\n\n"),
1841                 binding_shown ? "" : binding,
1842                 binding_shown ? "" : " ");
1843
1844     xfree (binding);
1845
1846     /* Find other user ids associated with this key and whether the
1847        bindings are marked as good or bad.  */
1848     {
1849       struct db *db_key;
1850
1851       if (opt.tofu_db_format == TOFU_DB_SPLIT)
1852         /* In the split format, we need to search in the fingerprint
1853            DB for all the emails associated with this key, not the
1854            email DB.  */
1855         db_key = getdb (dbs, fingerprint, DB_KEY);
1856       else
1857         db_key = db;
1858
1859       if (db_key)
1860         {
1861           rc = sqlite3_stepx
1862             (db_key->db, &db_key->s.get_trust_gather_other_user_ids,
1863              strings_collect_cb2, &other_user_ids, &err,
1864              opt.tofu_db_format == TOFU_DB_SPLIT
1865              ? "select user_id, email from bindings where fingerprint = ?;"
1866              : "select user_id, policy from bindings where fingerprint = ?;",
1867              SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_END);
1868           if (rc)
1869             {
1870               log_error (_("error gathering other user ids: %s.\n"), err);
1871               sqlite3_free (err);
1872               err = NULL;
1873             }
1874         }
1875     }
1876
1877     if (other_user_ids)
1878       {
1879         strlist_t strlist_iter;
1880
1881         es_fprintf (fp, _("Known user ids associated with this key:\n"));
1882         for (strlist_iter = other_user_ids;
1883              strlist_iter;
1884              strlist_iter = strlist_iter->next)
1885           {
1886             char *other_user_id = strlist_iter->d;
1887             char *other_thing;
1888             enum tofu_policy other_policy;
1889
1890             assert (strlist_iter->next);
1891             strlist_iter = strlist_iter->next;
1892             other_thing = strlist_iter->d;
1893
1894             if (opt.tofu_db_format == TOFU_DB_SPLIT)
1895               other_policy = get_policy (dbs, fingerprint, other_thing, NULL);
1896             else
1897               other_policy = atoi (other_thing);
1898
1899             es_fprintf (fp, _("  %s (policy: %s)\n"),
1900                         other_user_id,
1901                         tofu_policy_str (other_policy));
1902           }
1903         es_fprintf (fp, "\n");
1904
1905         free_strlist (other_user_ids);
1906       }
1907
1908     /* Find other keys associated with this email address.  */
1909     /* XXX: When generating the statistics, do we want the time
1910        embedded in the signature (column 'sig_time') or the time that
1911        we first verified the signature (column 'time').  */
1912     rc = sqlite3_stepx
1913       (db->db, &db->s.get_trust_gather_other_keys,
1914        signature_stats_collect_cb, &stats, &err,
1915        "select fingerprint, policy, time_ago, count(*)\n"
1916        " from (select bindings.*,\n"
1917        "        case\n"
1918        /* From the future (but if its just a couple of hours in the
1919           future don't turn it into a warning)?  Or should we use
1920           small, medium or large units?  (Note: whatever we do, we
1921           keep the value in seconds.  Then when we group, everything
1922           that rounds to the same number of seconds is grouped.)  */
1923        "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1924        "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1925        "          then max(0,\n"
1926        "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1927        "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1928        "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1929        "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1930        "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1931        "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1932        "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1933        "        end time_ago,\n"
1934        "        delta time_ago_raw\n"
1935        "       from bindings\n"
1936        "       left join\n"
1937        "         (select *,\n"
1938        "            cast(strftime('%s','now') - sig_time as real) delta\n"
1939        "           from signatures) ss\n"
1940        "        on ss.binding = bindings.oid)\n"
1941        " where email = ?\n"
1942        " group by fingerprint, time_ago\n"
1943        /* Make sure the current key is first.  */
1944        " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1945        SQLITE_ARG_STRING, email, SQLITE_ARG_STRING, fingerprint,
1946        SQLITE_ARG_END);
1947     if (rc)
1948       {
1949         strlist_t strlist_iter;
1950
1951         log_error (_("error gathering signature stats: %s.\n"),
1952                    err);
1953         sqlite3_free (err);
1954         err = NULL;
1955
1956         es_fprintf
1957           (fp, _("The email address (%s) is associated with %d keys:\n"),
1958            email, bindings_with_this_email_count);
1959         for (strlist_iter = bindings_with_this_email;
1960              strlist_iter;
1961              strlist_iter = strlist_iter->next)
1962           es_fprintf (fp, _("  %s\n"), strlist_iter->d);
1963       }
1964     else
1965       {
1966         char *key = NULL;
1967
1968         if (! stats || strcmp (stats->fingerprint, fingerprint) != 0)
1969           /* If we have already added this key to the DB, then it will
1970              be first (see the above select).  Since the first key on
1971              the list is not this key, we must not yet have verified
1972              any messages signed by this key.  Add a dummy entry.  */
1973           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1974
1975         es_fprintf (fp, _("Statistics for keys with the email '%s':\n"),
1976                     email);
1977         for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1978           {
1979             if (! key || strcmp (key, stats_iter->fingerprint) != 0)
1980               {
1981                 int this_key;
1982                 key = stats_iter->fingerprint;
1983                 this_key = strcmp (key, fingerprint) == 0;
1984                 if (this_key)
1985                   es_fprintf (fp, _("  %s (this key):"), key);
1986                 else
1987                   es_fprintf (fp, _("  %s (policy: %s):"),
1988                               key, tofu_policy_str (stats_iter->policy));
1989                 es_fprintf (fp, "\n");
1990               }
1991
1992             if (stats_iter->time_ago == -1)
1993               es_fprintf (fp, _("    %ld %s signed in the future.\n"),
1994                           stats_iter->count,
1995                           stats_iter->count == 1
1996                           ? _("message") : _("messages"));
1997             else if (stats_iter->count == 0)
1998               es_fprintf (fp, _("    0 signed messages.\n"));
1999             else
2000               es_fprintf (fp, _("    %ld %s signed over the past %ld %s.\n"),
2001                           stats_iter->count,
2002                           stats_iter->count == 1
2003                           ? _("message") : _("messages"),
2004                           time_ago_scale (stats_iter->time_ago),
2005                           time_ago_unit (stats_iter->time_ago));
2006           }
2007       }
2008
2009     if (is_conflict)
2010       {
2011         /* TRANSLATORS: translate the below text.  We don't directly
2012            internationalize that text so that we can tweak it without
2013            breaking translations.  */
2014         char *text = _("TOFU detected a binding conflict");
2015         if (strcmp (text, "TOFU detected a binding conflict") == 0)
2016           /* No translation.  Use the English text.  */
2017           text =
2018             "Normally, there is only a single key associated with an email "
2019             "address.  However, people sometimes generate a new key if "
2020             "their key is too old or they think it might be compromised.  "
2021             "Alternatively, a new key may indicate a man-in-the-middle"
2022             "attack!  Before accepting this key, you should talk to or "
2023             "call the person to make sure this new key is legitimate.";
2024         es_fprintf (fp, "\n%s\n", text);
2025       }
2026
2027     es_fputc ('\n', fp);
2028     /* TRANSLATORS: Two letters (normally the lower and upper case
2029        version of the hotkey) for each of the five choices.  If there
2030        is only one choice in your language, repeat it.  */
2031     choices = _("gG" "aA" "uU" "rR" "bB");
2032     es_fprintf (fp, _("(G)ood/(A)ccept once/(U)nknown/(R)eject once/(B)ad? "));
2033
2034     /* Add a NUL terminator.  */
2035     es_fputc (0, fp);
2036     if (es_fclose_snatch (fp, (void **) &prompt, NULL))
2037       log_fatal ("error snatching memory stream\n");
2038
2039     while (1)
2040       {
2041         char *response;
2042
2043         if (strlen (choices) != 10)
2044           log_bug ("Bad TOFU conflict translation!  Please report.");
2045
2046         response = cpr_get ("tofu conflict", prompt);
2047         trim_spaces (response);
2048         cpr_kill_prompt ();
2049         if (strlen (response) == 1)
2050           {
2051             char *choice = strchr (choices, *response);
2052             if (choice)
2053               {
2054                 int c = ((size_t) choice - (size_t) choices) / 2;
2055                 assert (0 <= c && c <= 4);
2056
2057                 switch (c)
2058                   {
2059                   case 0: /* Good.  */
2060                     policy = TOFU_POLICY_GOOD;
2061                     trust_level = tofu_policy_to_trust_level (policy);
2062                     break;
2063                   case 1: /* Accept once.  */
2064                     policy = TOFU_POLICY_ASK;
2065                     trust_level =
2066                       tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
2067                     break;
2068                   case 2: /* Unknown.  */
2069                     policy = TOFU_POLICY_UNKNOWN;
2070                     trust_level = tofu_policy_to_trust_level (policy);
2071                     break;
2072                   case 3: /* Reject once.  */
2073                     policy = TOFU_POLICY_ASK;
2074                     trust_level =
2075                       tofu_policy_to_trust_level (TOFU_POLICY_BAD);
2076                     break;
2077                   case 4: /* Bad.  */
2078                     policy = TOFU_POLICY_BAD;
2079                     trust_level = tofu_policy_to_trust_level (policy);
2080                     break;
2081                   default:
2082                     log_bug ("c should be between 0 and 4 but it is %d!", c);
2083                   }
2084
2085                 if (record_binding (dbs, fingerprint, email, user_id,
2086                                     policy, 0) != 0)
2087                   /* If there's an error registering the
2088                      binding, don't save the signature.  */
2089                   trust_level = _tofu_GET_TRUST_ERROR;
2090
2091                 break;
2092               }
2093           }
2094         xfree (response);
2095       }
2096
2097     xfree (prompt);
2098
2099     signature_stats_free (stats);
2100   }
2101
2102  out:
2103   if (change_conflicting_to_ask)
2104     {
2105       if (! may_ask)
2106         /* If we weren't allowed to ask, also update this key as
2107            conflicting with itself.  */
2108         rc = sqlite3_exec_printf
2109           (db->db, NULL, NULL, &err,
2110            "update bindings set policy = %d, conflict = %Q"
2111            " where email = %Q"
2112            "  and (policy = %d or (policy = %d and fingerprint = %Q));",
2113            TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
2114            TOFU_POLICY_ASK, fingerprint);
2115       else
2116         rc = sqlite3_exec_printf
2117           (db->db, NULL, NULL, &err,
2118            "update bindings set policy = %d, conflict = %Q"
2119            " where email = %Q and fingerprint != %Q and policy = %d;",
2120            TOFU_POLICY_ASK, fingerprint, email, fingerprint, TOFU_POLICY_AUTO);
2121       if (rc)
2122         {
2123           log_error (_("error changing TOFU policy: %s\n"), err);
2124           sqlite3_free (err);
2125           goto out;
2126         }
2127     }
2128
2129   xfree (conflict);
2130   free_strlist (bindings_with_this_email);
2131
2132   return trust_level;
2133 }
2134
2135 static void
2136 show_statistics (struct dbs *dbs, const char *fingerprint,
2137                  const char *email, const char *user_id,
2138                  const char *sig_exclude)
2139 {
2140   struct db *db;
2141   int rc;
2142   strlist_t strlist = NULL;
2143   char *err = NULL;
2144
2145   db = getdb (dbs, email, DB_EMAIL);
2146   if (! db)
2147     return;
2148
2149   rc = sqlite3_exec_printf
2150     (db->db, strings_collect_cb, &strlist, &err,
2151      "select count (*), strftime('%%s','now') - min (signatures.time)\n"
2152      " from signatures\n"
2153      " left join bindings on signatures.binding = bindings.oid\n"
2154      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
2155      fingerprint, email,
2156      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
2157         not NULL.  */
2158      sig_exclude ? "!= '" : "is not NULL",
2159      sig_exclude ? sig_exclude : "",
2160      sig_exclude ? "'" : "");
2161   if (rc)
2162     {
2163       log_error (_("error reading from TOFU database"
2164                    " (getting statistics): %s\n"),
2165                  err);
2166       sqlite3_free (err);
2167       goto out;
2168     }
2169
2170   if (! strlist)
2171     log_info (_("Have never verified a message signed by key %s!\n"),
2172               fingerprint);
2173   else
2174     {
2175       char *tail = NULL;
2176       signed long messages;
2177       signed long first_seen_ago;
2178
2179       assert (strlist_length (strlist) == 2);
2180
2181       errno = 0;
2182       messages = strtol (strlist->d, &tail, 0);
2183       if (errno || *tail != '\0')
2184         /* Abort.  */
2185         {
2186           log_debug ("%s:%d: Couldn't convert %s (messages) to an int: %s.\n",
2187                      __func__, __LINE__, strlist->d, strerror (errno));
2188           messages = -1;
2189         }
2190
2191       if (messages == 0 && *strlist->next->d == '\0')
2192         /* min(NULL) => NULL => "".  */
2193         first_seen_ago = -1;
2194       else
2195         {
2196           errno = 0;
2197           first_seen_ago = strtol (strlist->next->d, &tail, 0);
2198           if (errno || *tail != '\0')
2199             /* Abort.  */
2200             {
2201               log_debug ("%s:%d: Cound't convert %s (first_seen) to an int: %s.\n",
2202                          __func__, __LINE__,
2203                          strlist->next->d, strerror (errno));
2204               first_seen_ago = 0;
2205             }
2206         }
2207
2208       if (messages == -1 || first_seen_ago == 0)
2209         log_info (_("Failed to collect signature statistics for \"%s\" (key %s)\n"),
2210                   user_id, fingerprint);
2211       else
2212         {
2213           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2214           estream_t fp;
2215           char *msg;
2216
2217           fp = es_fopenmem (0, "rw,samethread");
2218           if (! fp)
2219             log_fatal ("error creating memory stream\n");
2220
2221           if (messages == 0)
2222             es_fprintf (fp,
2223                         _("Verified 0 messages signed by \"%s\""
2224                           " (key: %s, policy %s)."),
2225                         user_id, fingerprint, tofu_policy_str (policy));
2226           else
2227             {
2228               int years = 0;
2229               int months = 0;
2230               int days = 0;
2231               int hours = 0;
2232               int minutes = 0;
2233               int seconds = 0;
2234
2235               /* The number of units that we've printed so far.  */
2236               int count = 0;
2237               /* The first unit that we printed (year = 0, month = 1,
2238                  etc.).  */
2239               int first = -1;
2240               /* The current unit.  */
2241               int i = 0;
2242
2243               es_fprintf (fp,
2244                           _("Verified %ld messages signed by \"%s\""
2245                             " (key: %s, policy: %s) in the past "),
2246                           messages, user_id,
2247                           fingerprint, tofu_policy_str (policy));
2248
2249               /* It would be nice to use a macro to do this, but gettext
2250                  works on the unpreprocessed code.  */
2251 #define MIN_SECS (60)
2252 #define HOUR_SECS (60 * MIN_SECS)
2253 #define DAY_SECS (24 * HOUR_SECS)
2254 #define MONTH_SECS (30 * DAY_SECS)
2255 #define YEAR_SECS (365 * DAY_SECS)
2256
2257               if (first_seen_ago > YEAR_SECS)
2258                 {
2259                   years = first_seen_ago / YEAR_SECS;
2260                   first_seen_ago -= years * YEAR_SECS;
2261                 }
2262               if (first_seen_ago > MONTH_SECS)
2263                 {
2264                   months = first_seen_ago / MONTH_SECS;
2265                   first_seen_ago -= months * MONTH_SECS;
2266                 }
2267               if (first_seen_ago > DAY_SECS)
2268                 {
2269                   days = first_seen_ago / DAY_SECS;
2270                   first_seen_ago -= days * DAY_SECS;
2271                 }
2272               if (first_seen_ago > HOUR_SECS)
2273                 {
2274                   hours = first_seen_ago / HOUR_SECS;
2275                   first_seen_ago -= hours * HOUR_SECS;
2276                 }
2277               if (first_seen_ago > MIN_SECS)
2278                 {
2279                   minutes = first_seen_ago / MIN_SECS;
2280                   first_seen_ago -= minutes * MIN_SECS;
2281                 }
2282               seconds = first_seen_ago;
2283
2284 #undef MIN_SECS
2285 #undef HOUR_SECS
2286 #undef DAY_SECS
2287 #undef MONTH_SECS
2288 #undef YEAR_SECS
2289
2290               if (years)
2291                 {
2292                   if (years > 1)
2293                     es_fprintf (fp, _("%d years"), years);
2294                   else
2295                     es_fprintf (fp, _("%d year"), years);
2296                   count ++;
2297                   first = i;
2298                 }
2299               i ++;
2300               if ((first == -1 || i - first <= 3) && months)
2301                 {
2302                   if (count)
2303                     es_fprintf (fp, _(", "));
2304
2305                   if (months > 1)
2306                     es_fprintf (fp, _("%d months"), months);
2307                   else
2308                     es_fprintf (fp, _("%d month"), months);
2309                   count ++;
2310                   first = i;
2311                 }
2312               i ++;
2313               if ((first == -1 || i - first <= 3) && count < 2 && days)
2314                 {
2315                   if (count)
2316                     es_fprintf (fp, _(", "));
2317
2318                   if (days > 1)
2319                     es_fprintf (fp, _("%d days"), days);
2320                   else
2321                     es_fprintf (fp, _("%d day"), days);
2322                   count ++;
2323                   first = i;
2324                 }
2325               i ++;
2326               if ((first == -1 || i - first <= 3) && count < 2 && hours)
2327                 {
2328                   if (count)
2329                     es_fprintf (fp, _(", "));
2330
2331                   if (hours > 1)
2332                     es_fprintf (fp, _("%d hours"), hours);
2333                   else
2334                     es_fprintf (fp, _("%d hour"), hours);
2335                   count ++;
2336                   first = i;
2337                 }
2338               i ++;
2339               if ((first == -1 || i - first <= 3) && count < 2 && minutes)
2340                 {
2341                   if (count)
2342                     es_fprintf (fp, _(", "));
2343
2344                   if (minutes > 1)
2345                     es_fprintf (fp, _("%d minutes"), minutes);
2346                   else
2347                     es_fprintf (fp, _("%d minute"), minutes);
2348                   count ++;
2349                   first = i;
2350                 }
2351               i ++;
2352               if ((first == -1 || i - first <= 3) && count < 2)
2353                 {
2354                   if (count)
2355                     es_fprintf (fp, _(", "));
2356
2357                   if (seconds > 1)
2358                     es_fprintf (fp, _("%d seconds"), seconds);
2359                   else
2360                     es_fprintf (fp, _("%d second"), seconds);
2361                 }
2362
2363               es_fprintf (fp, _("."));
2364             }
2365
2366           es_fputc (0, fp);
2367           if (es_fclose_snatch (fp, (void **) &msg, NULL))
2368             log_fatal ("error snatching memory stream\n");
2369
2370           log_info ("%s\n", msg);
2371
2372           if (policy == TOFU_POLICY_AUTO && messages < 10)
2373             {
2374               char *set_policy_command;
2375               const char *text;
2376
2377               if (messages == 0)
2378                 log_info (_("Warning: we've have yet to see a message signed by this key!\n"));
2379               else if (messages == 1)
2380                 log_info (_("Warning: we've only seen a single message signed by this key!\n"));
2381
2382               set_policy_command =
2383                 xasprintf ("gpg --tofu-policy bad \"%s\"", fingerprint);
2384               /* TRANSLATORS: translate the below text.  We don't
2385                  directly internationalize that text so that we can
2386                  tweak it without breaking translations.  */
2387               text = _("TOFU: few signatures %d %s %s");
2388               if (strcmp (text, "TOFU: few signatures %d %s %s") == 0)
2389                 text =
2390                   "Warning: if you think you've seen more than %d %s "
2391                   "signed by this key, then this key might be a forgery!  "
2392                   "Carefully examine the email address for small variations "
2393                   "(e.g., additional white space).  If the key is suspect, "
2394                   "then use '%s' to mark it as being bad.\n";
2395               log_info (text,
2396                         messages, messages == 1 ? _("message") : _("message"),
2397                         set_policy_command);
2398               free (set_policy_command);
2399             }
2400         }
2401     }
2402
2403  out:
2404   free_strlist (strlist);
2405
2406   return;
2407 }
2408
2409 /* Extract the email address from a user id and normalize it.  If the
2410    user id doesn't contain an email address, then we use the whole
2411    user_id and normalize that.  The returned string must be freed.  */
2412 static char *
2413 email_from_user_id (const char *user_id)
2414 {
2415   char *email = mailbox_from_userid (user_id);
2416   if (! email)
2417     /* Hmm, no email address was provided.  Just take the lower-case
2418        version of the whole user id.  It could be a hostname, for
2419        instance.  */
2420     email = ascii_strlwr (xstrdup (user_id));
2421
2422   return email;
2423 }
2424
2425 /* Pretty print a MAX_FINGERPRINT_LEN-byte binary fingerprint into a
2426    malloc'd string.  */
2427 static char *
2428 fingerprint_pp (const byte *fingerprint_bin)
2429 {
2430   char fingerprint[MAX_FINGERPRINT_LEN * 2 + 1];
2431   char *fingerprint_pretty;
2432   int space = (/* The characters and the NUL.  */
2433                sizeof (fingerprint)
2434                /* After every fourth character, we add a space (except
2435                   the last).  */
2436                + (sizeof (fingerprint) - 1) / 4 - 1
2437                /* Half way through we add a second space.  */
2438                + 1);
2439   int i;
2440   int j;
2441
2442   bin2hex (fingerprint_bin, MAX_FINGERPRINT_LEN, fingerprint);
2443
2444   fingerprint_pretty = xmalloc (space);
2445
2446   for (i = 0, j = 0; i < MAX_FINGERPRINT_LEN * 2; i ++)
2447     {
2448       if (i && i % 4 == 0)
2449         fingerprint_pretty[j ++] = ' ';
2450       if (i == MAX_FINGERPRINT_LEN * 2 / 2)
2451         fingerprint_pretty[j ++] = ' ';
2452
2453       fingerprint_pretty[j ++] = fingerprint[i];
2454     }
2455   fingerprint_pretty[j ++] = 0;
2456   assert (j == space);
2457
2458   return fingerprint_pretty;
2459 }
2460
2461 /* Register the signature with the binding <FINGERPRINT_BIN, USER_ID>.
2462    FINGERPRINT must be MAX_FINGERPRINT_LEN bytes long.
2463
2464    SIG_DIGEST_BIN is the binary representation of the message's
2465    digest.  SIG_DIGEST_BIN_LEN is its length.
2466
2467    SIG_TIME is the time that the signature was generated.
2468
2469    ORIGIN is a free-formed string describing the origin of the
2470    signature.  If this was from an email and the Claws MUA was used,
2471    then this should be something like: "email:claws".  If this is
2472    NULL, the default is simply "unknown".
2473
2474    If MAY_ASK is 1, then this function may interact with the user.
2475    This is necessary if there is a conflict or the binding's policy is
2476    TOFU_POLICY_ASK.
2477
2478    This function returns the binding's trust level on return.  If an
2479    error occurs, this function returns TRUST_UNKNOWN.  */
2480 int
2481 tofu_register (const byte *fingerprint_bin, const char *user_id,
2482                const byte *sig_digest_bin, int sig_digest_bin_len,
2483                time_t sig_time, const char *origin, int may_ask)
2484 {
2485   struct dbs *dbs;
2486   struct db *db;
2487   char *fingerprint = NULL;
2488   char *email = NULL;
2489   char *err = NULL;
2490   int rc;
2491   int trust_level = TRUST_UNKNOWN;
2492   char *sig_digest;
2493   unsigned long c;
2494   int already_verified = 0;
2495
2496   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2497
2498   dbs = opendbs ();
2499   if (! dbs)
2500     {
2501       log_error (_("error opening TOFU DB.\n"));
2502       goto die;
2503     }
2504
2505   fingerprint = fingerprint_pp (fingerprint_bin);
2506
2507   if (! *user_id)
2508     {
2509       log_debug ("TOFU: user id is empty.  Can't continue.\n");
2510       goto die;
2511     }
2512
2513   email = email_from_user_id (user_id);
2514
2515   if (! origin)
2516     /* The default origin is simply "unknown".  */
2517     origin = "unknown";
2518
2519   /* It's necessary to get the trust so that we are certain that the
2520      binding has been registered.  */
2521   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2522   if (trust_level == _tofu_GET_TRUST_ERROR)
2523     /* An error.  */
2524     {
2525       trust_level = TRUST_UNKNOWN;
2526       goto die;
2527     }
2528
2529   /* Save the observed signature in the DB.  */
2530   db = getdb (dbs, email, DB_EMAIL);
2531   if (! db)
2532     {
2533       log_error (_("error opening TOFU DB.\n"));
2534       goto die;
2535     }
2536
2537   /* We do a query and then an insert.  Make sure they are atomic
2538      by wrapping them in a transaction.  */
2539   rc = begin_transaction (db, 0);
2540   if (rc)
2541     goto die;
2542
2543   /* If we've already seen this signature before, then don't add
2544      it again.  */
2545   rc = sqlite3_stepx
2546     (db->db, &db->s.register_already_seen,
2547      get_single_unsigned_long_cb2, &c, &err,
2548      "select count (*)\n"
2549      " from signatures left join bindings\n"
2550      "  on signatures.binding = bindings.oid\n"
2551      " where fingerprint = ? and email = ? and sig_time = ?\n"
2552      "  and sig_digest = ?",
2553      SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2554      SQLITE_ARG_LONG_LONG, (long long) sig_time,
2555      SQLITE_ARG_STRING, sig_digest,
2556      SQLITE_ARG_END);
2557   if (rc)
2558     {
2559       log_error (_("error reading from signatures database"
2560                    " (checking existence): %s\n"),
2561                  err);
2562       sqlite3_free (err);
2563     }
2564   else if (c > 1)
2565     /* Duplicates!  This should not happen.  In particular,
2566        because <fingerprint, email, sig_time, sig_digest> is the
2567        primary key!  */
2568     log_debug ("SIGNATURES DB contains duplicate records"
2569                " <key: %s, %s, time: 0x%lx, sig: %s, %s>."
2570                "  Please report.\n",
2571                fingerprint, email, (unsigned long) sig_time,
2572                sig_digest, origin);
2573   else if (c == 1)
2574     {
2575       already_verified = 1;
2576       if (DBG_TRUST)
2577         log_debug ("Already observed the signature"
2578                    " <key: %s, %s, time: 0x%lx, sig: %s, %s>\n",
2579                    fingerprint, email, (unsigned long) sig_time,
2580                    sig_digest, origin);
2581     }
2582   else
2583     /* This is the first time that we've seen this signature.
2584        Record it.  */
2585     {
2586       if (DBG_TRUST)
2587         log_debug ("TOFU: Saving signature <%s, %s, %s>\n",
2588                    fingerprint, email, sig_digest);
2589
2590       assert (c == 0);
2591
2592       rc = sqlite3_stepx
2593         (db->db, &db->s.register_insert, NULL, NULL, &err,
2594          "insert into signatures\n"
2595          " (binding, sig_digest, origin, sig_time, time)\n"
2596          " values\n"
2597          " ((select oid from bindings\n"
2598          "    where fingerprint = ? and email = ?),\n"
2599          "  ?, ?, ?, strftime('%s', 'now'));",
2600          SQLITE_ARG_STRING, fingerprint, SQLITE_ARG_STRING, email,
2601          SQLITE_ARG_STRING, sig_digest, SQLITE_ARG_STRING, origin,
2602          SQLITE_ARG_LONG_LONG, (long long) sig_time,
2603          SQLITE_ARG_END);
2604       if (rc)
2605         {
2606           log_error (_("error updating TOFU DB"
2607                        " (inserting into signatures table): %s\n"),
2608                      err);
2609           sqlite3_free (err);
2610         }
2611     }
2612
2613   /* It only matters whether we abort or commit the transaction
2614      (so long as we do something) if we execute the insert.  */
2615   if (rc)
2616     rc = rollback_transaction (db);
2617   else
2618     rc = end_transaction (db, 0);
2619   if (rc)
2620     {
2621       log_error (_("error ending transaction on TOFU database: %s\n"), err);
2622       sqlite3_free (err);
2623       goto die;
2624     }
2625
2626  die:
2627   if (may_ask && trust_level != TRUST_ULTIMATE)
2628     /* It's only appropriate to show the statistics in an interactive
2629        context.  */
2630     show_statistics (dbs, fingerprint, email, user_id,
2631                      already_verified ? NULL : sig_digest);
2632
2633   xfree (email);
2634   xfree (fingerprint);
2635   if (dbs)
2636     closedbs (dbs);
2637   xfree (sig_digest);
2638
2639   return trust_level;
2640 }
2641
2642 /* Combine a trust level returned from the TOFU trust model with a
2643    trust level returned by the PGP trust model.  This is primarily of
2644    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2645
2646    This function ors together the upper bits (the values not covered
2647    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2648 int
2649 tofu_wot_trust_combine (int tofu_base, int wot_base)
2650 {
2651   int tofu = tofu_base & TRUST_MASK;
2652   int wot = wot_base & TRUST_MASK;
2653   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2654
2655   assert (tofu == TRUST_UNKNOWN
2656           || tofu == TRUST_EXPIRED
2657           || tofu == TRUST_UNDEFINED
2658           || tofu == TRUST_NEVER
2659           || tofu == TRUST_MARGINAL
2660           || tofu == TRUST_FULLY
2661           || tofu == TRUST_ULTIMATE);
2662   assert (wot == TRUST_UNKNOWN
2663           || wot == TRUST_EXPIRED
2664           || wot == TRUST_UNDEFINED
2665           || wot == TRUST_NEVER
2666           || wot == TRUST_MARGINAL
2667           || wot == TRUST_FULLY
2668           || wot == TRUST_ULTIMATE);
2669
2670   /* We first consider negative trust policys.  These trump positive
2671      trust policies.  */
2672   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2673     /* TRUST_NEVER trumps everything else.  */
2674     return upper | TRUST_NEVER;
2675   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2676     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2677     return upper | TRUST_EXPIRED;
2678
2679   /* Now we only have positive or neutral trust policies.  We take
2680      the max.  */
2681   if (tofu == TRUST_ULTIMATE || wot == TRUST_ULTIMATE)
2682     return upper | TRUST_ULTIMATE;
2683   if (tofu == TRUST_FULLY || wot == TRUST_FULLY)
2684     return upper | TRUST_FULLY;
2685   if (tofu == TRUST_MARGINAL || wot == TRUST_MARGINAL)
2686     return upper | TRUST_MARGINAL;
2687   if (tofu == TRUST_UNDEFINED || wot == TRUST_UNDEFINED)
2688     return upper | TRUST_UNDEFINED;
2689   return upper | TRUST_UNKNOWN;
2690 }
2691
2692 /* Return the validity (TRUST_NEVER, etc.) of the binding
2693    <FINGERPRINT, USER_ID>.
2694
2695    FINGERPRINT must be a MAX_FINGERPRINT_LEN-byte fingerprint.
2696
2697    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2698    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2699    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2700
2701    Returns TRUST_UNDEFINED if an error occurs.  */
2702 int
2703 tofu_get_validity (const byte *fingerprint_bin, const char *user_id,
2704                    int may_ask)
2705 {
2706   struct dbs *dbs;
2707   char *fingerprint = NULL;
2708   char *email = NULL;
2709   int trust_level = TRUST_UNDEFINED;
2710
2711   dbs = opendbs ();
2712   if (! dbs)
2713     {
2714       log_error (_("error opening TOFU DB.\n"));
2715       goto die;
2716     }
2717
2718   fingerprint = fingerprint_pp (fingerprint_bin);
2719
2720   if (! *user_id)
2721     {
2722       log_debug ("user id is empty.  Can't get TOFU validity for this binding.\n");
2723       goto die;
2724     }
2725
2726   email = email_from_user_id (user_id);
2727
2728   trust_level = get_trust (dbs, fingerprint, email, user_id, may_ask);
2729   if (trust_level == _tofu_GET_TRUST_ERROR)
2730     /* An error.  */
2731     trust_level = TRUST_UNDEFINED;
2732
2733   if (may_ask && trust_level != TRUST_ULTIMATE)
2734     show_statistics (dbs, fingerprint, email, user_id, NULL);
2735
2736  die:
2737   xfree (email);
2738   xfree (fingerprint);
2739   if (dbs)
2740     closedbs (dbs);
2741
2742   return trust_level;
2743 }
2744
2745 /* Set the policy for all non-revoked user ids in the keyblock KB to
2746    POLICY.
2747
2748    If no key is available with the specified key id, then this
2749    function returns GPG_ERR_NO_PUBKEY.
2750
2751    Returns 0 on success and an error code otherwise.  */
2752 gpg_error_t
2753 tofu_set_policy (kbnode_t kb, enum tofu_policy policy)
2754 {
2755   struct dbs *dbs;
2756   PKT_public_key *pk;
2757   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2758   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2759   char *fingerprint = NULL;
2760
2761   assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2762   pk = kb->pkt->pkt.public_key;
2763
2764   dbs = opendbs ();
2765   if (! dbs)
2766     {
2767       log_error (_("error opening TOFU DB.\n"));
2768       return gpg_error (GPG_ERR_GENERAL);
2769     }
2770
2771   if (DBG_TRUST)
2772     log_debug ("Setting TOFU policy for %s to %s\n",
2773                keystr (pk->keyid), tofu_policy_str (policy));
2774   if (! (pk->main_keyid[0] == pk->keyid[0]
2775          && pk->main_keyid[1] == pk->keyid[1]))
2776     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2777
2778   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2779   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2780
2781   fingerprint = fingerprint_pp (fingerprint_bin);
2782
2783   for (; kb; kb = kb->next)
2784     {
2785       PKT_user_id *user_id;
2786       char *email;
2787
2788       if (kb->pkt->pkttype != PKT_USER_ID)
2789         continue;
2790
2791       user_id = kb->pkt->pkt.user_id;
2792       if (user_id->is_revoked)
2793         /* Skip revoked user ids.  (Don't skip expired user ids, the
2794            expiry can be changed.)  */
2795         continue;
2796
2797       email = email_from_user_id (user_id->name);
2798
2799       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2800
2801       xfree (email);
2802     }
2803
2804   xfree (fingerprint);
2805   closedbs (dbs);
2806
2807   return 0;
2808 }
2809
2810 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2811    the key id KEYID to POLICY.
2812
2813    If no key is available with the specified key id, then this
2814    function returns GPG_ERR_NO_PUBKEY.
2815
2816    Returns 0 on success and an error code otherwise.  */
2817 gpg_error_t
2818 tofu_set_policy_by_keyid (u32 *keyid, enum tofu_policy policy)
2819 {
2820   kbnode_t keyblock = get_pubkeyblock (keyid);
2821   if (! keyblock)
2822     return gpg_error (GPG_ERR_NO_PUBKEY);
2823
2824   return tofu_set_policy (keyblock, policy);
2825 }
2826
2827 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2828    policy has been set for the binding, sets *POLICY to
2829    TOFU_POLICY_NONE.
2830
2831    PK is a primary public key and USER_ID is a user id.
2832
2833    Returns 0 on success and an error code otherwise.  */
2834 gpg_error_t
2835 tofu_get_policy (PKT_public_key *pk, PKT_user_id *user_id,
2836                  enum tofu_policy *policy)
2837 {
2838   struct dbs *dbs;
2839   char fingerprint_bin[MAX_FINGERPRINT_LEN];
2840   size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2841   char *fingerprint;
2842   char *email;
2843
2844   /* Make sure PK is a primary key.  */
2845   assert (pk->main_keyid[0] == pk->keyid[0]
2846           && pk->main_keyid[1] == pk->keyid[1]);
2847
2848   dbs = opendbs ();
2849   if (! dbs)
2850     {
2851       log_error (_("error opening TOFU DB.\n"));
2852       return gpg_error (GPG_ERR_GENERAL);
2853     }
2854
2855   fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2856   assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2857
2858   fingerprint = fingerprint_pp (fingerprint_bin);
2859
2860   email = email_from_user_id (user_id->name);
2861
2862   *policy = get_policy (dbs, fingerprint, email, NULL);
2863
2864   xfree (email);
2865   xfree (fingerprint);
2866   closedbs (dbs);
2867
2868   if (*policy == _tofu_GET_POLICY_ERROR)
2869     return gpg_error (GPG_ERR_GENERAL);
2870   return 0;
2871 }