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