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