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