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