g10: Add a convenience function for checking if a key is a primary key
[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 <https://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 #include <time.h>
32 #include <utime.h>
33 #include <fcntl.h>
34 #include <unistd.h>
35
36 #include "gpg.h"
37 #include "types.h"
38 #include "logging.h"
39 #include "stringhelp.h"
40 #include "options.h"
41 #include "mbox-util.h"
42 #include "i18n.h"
43 #include "ttyio.h"
44 #include "trustdb.h"
45 #include "mkdir_p.h"
46 #include "gpgsql.h"
47 #include "status.h"
48 #include "sqrtu32.h"
49
50 #include "tofu.h"
51
52
53 #define CONTROL_L ('L' - 'A' + 1)
54
55 /* Number of signed messages required to indicate that enough history
56  * is available for basic trust.  */
57 #define BASIC_TRUST_THRESHOLD  10
58 /* Number of signed messages required to indicate that a lot of
59  * history is available.  */
60 #define FULL_TRUST_THRESHOLD  100
61
62
63 /* An struct with data pertaining to the tofu DB.
64
65    To initialize this data structure, call opendbs().  Cleanup is done
66    when the CTRL object is released.  To get a handle to a database,
67    use the getdb() function.  This will either return an existing
68    handle or open a new DB connection, as appropriate.  */
69 struct tofu_dbs_s
70 {
71   sqlite3 *db;
72   char *want_lock_file;
73   time_t want_lock_file_ctime;
74
75   struct
76   {
77     sqlite3_stmt *savepoint_batch;
78     sqlite3_stmt *savepoint_batch_commit;
79
80     sqlite3_stmt *record_binding_get_old_policy;
81     sqlite3_stmt *record_binding_update;
82     sqlite3_stmt *record_binding_update2;
83     sqlite3_stmt *get_policy_select_policy_and_conflict;
84     sqlite3_stmt *get_trust_bindings_with_this_email;
85     sqlite3_stmt *get_trust_gather_other_user_ids;
86     sqlite3_stmt *get_trust_gather_signature_stats;
87     sqlite3_stmt *get_trust_gather_encryption_stats;
88     sqlite3_stmt *register_already_seen;
89     sqlite3_stmt *register_insert;
90   } s;
91
92   int in_batch_transaction;
93   int in_transaction;
94   time_t batch_update_started;
95 };
96
97
98 #define STRINGIFY(s) STRINGIFY2(s)
99 #define STRINGIFY2(s) #s
100
101 /* The grouping parameters when collecting signature statistics.  */
102
103 /* If a message is signed a couple of hours in the future, just assume
104    some clock skew.  */
105 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
106 /* Days.  */
107 #define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
108 #define TIME_AGO_SMALL_THRESHOLD (7 * TIME_AGO_UNIT_SMALL)
109 /* Months.  */
110 #define TIME_AGO_UNIT_MEDIUM (30 * 24 * 60 * 60)
111 #define TIME_AGO_MEDIUM_THRESHOLD (2 * TIME_AGO_UNIT_MEDIUM)
112 /* Years.  */
113 #define TIME_AGO_UNIT_LARGE (365 * 24 * 60 * 60)
114 #define TIME_AGO_LARGE_THRESHOLD (2 * TIME_AGO_UNIT_LARGE)
115
116 /* Local prototypes.  */
117 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
118 static char *email_from_user_id (const char *user_id);
119
120
121 \f
122 const char *
123 tofu_policy_str (enum tofu_policy policy)
124 {
125   switch (policy)
126     {
127     case TOFU_POLICY_NONE: return "none";
128     case TOFU_POLICY_AUTO: return "auto";
129     case TOFU_POLICY_GOOD: return "good";
130     case TOFU_POLICY_UNKNOWN: return "unknown";
131     case TOFU_POLICY_BAD: return "bad";
132     case TOFU_POLICY_ASK: return "ask";
133     default: return "???";
134     }
135 }
136
137 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
138    (e.g., TRUST_BAD) in light of the current configuration.  */
139 int
140 tofu_policy_to_trust_level (enum tofu_policy policy)
141 {
142   if (policy == TOFU_POLICY_AUTO)
143     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
144     policy = opt.tofu_default_policy;
145
146   switch (policy)
147     {
148     case TOFU_POLICY_AUTO:
149       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
150          to marginal trust.  */
151       return TRUST_MARGINAL;
152     case TOFU_POLICY_GOOD:
153       return TRUST_FULLY;
154     case TOFU_POLICY_UNKNOWN:
155       return TRUST_UNKNOWN;
156     case TOFU_POLICY_BAD:
157       return TRUST_NEVER;
158     case TOFU_POLICY_ASK:
159       return TRUST_UNKNOWN;
160     default:
161       log_bug ("Bad value for trust policy: %d\n",
162                opt.tofu_default_policy);
163       return 0;
164     }
165 }
166
167
168 \f
169 /* Start a transaction on DB.  If ONLY_BATCH is set, then this will
170    start a batch transaction if we haven't started a batch transaction
171    and one has been requested.  */
172 static gpg_error_t
173 begin_transaction (ctrl_t ctrl, int only_batch)
174 {
175   tofu_dbs_t dbs = ctrl->tofu.dbs;
176   int rc;
177   char *err = NULL;
178
179   log_assert (dbs);
180
181   /* If we've been in batch update mode for a while (on average, more
182    * than 500 ms), to prevent starving other gpg processes, we drop
183    * and retake the batch lock.
184    *
185    * Note: if we wanted higher resolution, we could use
186    * npth_clock_gettime.  */
187   if (/* No real transactions.  */
188       dbs->in_transaction == 0
189       /* There is an open batch transaction.  */
190       && dbs->in_batch_transaction
191       /* And some time has gone by since it was started.  */
192       && dbs->batch_update_started != gnupg_get_time ())
193     {
194       struct stat statbuf;
195
196       /* If we are in a batch update, then batch updates better have
197          been enabled.  */
198       log_assert (ctrl->tofu.batch_updated_wanted);
199
200       /* Check if another process wants to run.  (We just ignore any
201        * stat failure.  A waiter might have to wait a bit longer, but
202        * otherwise there should be no impact.)  */
203       if (stat (dbs->want_lock_file, &statbuf) == 0
204           && statbuf.st_ctime != dbs->want_lock_file_ctime)
205         {
206           end_transaction (ctrl, 2);
207
208           /* Yield to allow another process a chance to run.  Note:
209            * testing suggests that anything less than a 100ms tends to
210            * not result in the other process getting the lock.  */
211           gnupg_usleep (100000);
212         }
213       else
214         dbs->batch_update_started = gnupg_get_time ();
215     }
216
217   if (/* We don't have an open batch transaction.  */
218       !dbs->in_batch_transaction
219       && (/* Batch mode is enabled or we are starting a new transaction.  */
220           ctrl->tofu.batch_updated_wanted || dbs->in_transaction == 0))
221     {
222       struct stat statbuf;
223
224       /* We are in batch mode, but we don't have an open batch
225        * transaction.  Since the batch save point must be the outer
226        * save point, it must be taken before the inner save point.  */
227       log_assert (dbs->in_transaction == 0);
228
229       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
230                           NULL, NULL, &err,
231                           "begin immediate transaction;", GPGSQL_ARG_END);
232       if (rc)
233         {
234           log_error (_("error beginning transaction on TOFU database: %s\n"),
235                      err);
236           sqlite3_free (err);
237           return gpg_error (GPG_ERR_GENERAL);
238         }
239
240       dbs->in_batch_transaction = 1;
241       dbs->batch_update_started = gnupg_get_time ();
242
243       if (stat (dbs->want_lock_file, &statbuf) == 0)
244         dbs->want_lock_file_ctime = statbuf.st_ctime;
245     }
246
247   if (only_batch)
248     return 0;
249
250   log_assert (dbs->in_transaction >= 0);
251   dbs->in_transaction ++;
252
253   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
254                            "savepoint inner%d;",
255                            dbs->in_transaction);
256   if (rc)
257     {
258       log_error (_("error beginning transaction on TOFU database: %s\n"),
259                  err);
260       sqlite3_free (err);
261       return gpg_error (GPG_ERR_GENERAL);
262     }
263
264   return 0;
265 }
266
267
268 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
269  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
270  * this ends any open batch transaction even if we are still in batch
271  * mode.  */
272 static gpg_error_t
273 end_transaction (ctrl_t ctrl, int only_batch)
274 {
275   tofu_dbs_t dbs = ctrl->tofu.dbs;
276   int rc;
277   char *err = NULL;
278
279   if (only_batch || (! only_batch && dbs->in_transaction == 1))
280     {
281       if (!dbs)
282         return 0;  /* Shortcut to allow for easier cleanup code.  */
283
284       /* If we are releasing the batch transaction, then we better not
285          be in a normal transaction.  */
286       if (only_batch)
287         log_assert (dbs->in_transaction == 0);
288
289       if (/* Batch mode disabled?  */
290           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
291           /* But, we still have an open batch transaction?  */
292           && dbs->in_batch_transaction)
293         {
294           /* The batch transaction is still in open, but we've left
295            * batch mode.  */
296           dbs->in_batch_transaction = 0;
297           dbs->in_transaction = 0;
298
299           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
300                              NULL, NULL, &err,
301                              "commit transaction;", GPGSQL_ARG_END);
302           if (rc)
303             {
304               log_error (_("error committing transaction on TOFU database: %s\n"),
305                          err);
306               sqlite3_free (err);
307               return gpg_error (GPG_ERR_GENERAL);
308             }
309
310           return 0;
311         }
312
313       if (only_batch)
314         return 0;
315     }
316
317   log_assert (dbs);
318   log_assert (dbs->in_transaction > 0);
319
320   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
321                            "release inner%d;", dbs->in_transaction);
322
323   dbs->in_transaction --;
324
325   if (rc)
326     {
327       log_error (_("error committing transaction on TOFU database: %s\n"),
328                  err);
329       sqlite3_free (err);
330       return gpg_error (GPG_ERR_GENERAL);
331     }
332
333   return 0;
334 }
335
336
337 static gpg_error_t
338 rollback_transaction (ctrl_t ctrl)
339 {
340   tofu_dbs_t dbs = ctrl->tofu.dbs;
341   int rc;
342   char *err = NULL;
343
344   log_assert (dbs);
345   log_assert (dbs->in_transaction > 0);
346
347   /* Be careful to not any progress made by closed transactions in
348      batch mode.  */
349   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
350                            "rollback to inner%d;",
351                            dbs->in_transaction);
352
353   dbs->in_transaction --;
354
355   if (rc)
356     {
357       log_error (_("error rolling back transaction on TOFU database: %s\n"),
358                  err);
359       sqlite3_free (err);
360       return gpg_error (GPG_ERR_GENERAL);
361     }
362
363   return 0;
364 }
365
366 void
367 tofu_begin_batch_update (ctrl_t ctrl)
368 {
369   ctrl->tofu.batch_updated_wanted ++;
370 }
371
372 void
373 tofu_end_batch_update (ctrl_t ctrl)
374 {
375   log_assert (ctrl->tofu.batch_updated_wanted > 0);
376   ctrl->tofu.batch_updated_wanted --;
377   end_transaction (ctrl, 1);
378 }
379
380 /* Suspend any extant batch transaction (it is safe to call this even
381    no batch transaction has been started).  Note: you cannot suspend a
382    batch transaction if you are in a normal transaction.  The batch
383    transaction can be resumed explicitly by calling
384    tofu_resume_batch_transaction or implicitly by starting a normal
385    transaction.  */
386 static void
387 tofu_suspend_batch_transaction (ctrl_t ctrl)
388 {
389   end_transaction (ctrl, 2);
390 }
391
392 /* Resume a batch transaction if there is no extant batch transaction
393    and one has been requested using tofu_begin_batch_transaction.  */
394 static void
395 tofu_resume_batch_transaction (ctrl_t ctrl)
396 {
397   begin_transaction (ctrl, 1);
398 }
399
400
401 \f
402 /* Wrapper around strtol which prints a warning in case of a
403  * conversion error.  On success the converted value is stored at
404  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
405  * and an error code is returned.  */
406 static gpg_error_t
407 string_to_long (long *r_value, const char *string, long fallback, int line)
408 {
409   gpg_error_t err;
410   char *tail = NULL;
411
412   gpg_err_set_errno (0);
413   *r_value = strtol (string, &tail, 0);
414   if (errno || !(!strcmp (tail, ".0") || !*tail))
415     {
416       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
417       log_debug ("%s:%d: "
418                  "strtol failed for DB returned string (tail=%.10s): %s\n",
419                  __FILE__, line, tail, gpg_strerror (err));
420       *r_value = fallback;
421     }
422   else
423     err = 0;
424
425   return err;
426 }
427
428
429 /* Wrapper around strtoul which prints a warning in case of a
430  * conversion error.  On success the converted value is stored at
431  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
432  * and an error code is returned.  */
433 static gpg_error_t
434 string_to_ulong (unsigned long *r_value, const char *string,
435                  unsigned long fallback, int line)
436 {
437   gpg_error_t err;
438   char *tail = NULL;
439
440   gpg_err_set_errno (0);
441   *r_value = strtoul (string, &tail, 0);
442   if (errno || !(!strcmp (tail, ".0") || !*tail))
443     {
444       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
445       log_debug ("%s:%d: "
446                  "strtoul failed for DB returned string (tail=%.10s): %s\n",
447                  __FILE__, line, tail, gpg_strerror (err));
448       *r_value = fallback;
449     }
450   else
451     err = 0;
452
453   return err;
454 }
455
456
457
458 /* Collect results of a select count (*) ...; style query.  Aborts if
459    the argument is not a valid integer (or real of the form X.0).  */
460 static int
461 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
462                              char **azColName)
463 {
464   unsigned long int *count = cookie;
465
466   (void) azColName;
467
468   log_assert (argc == 1);
469
470   if (string_to_ulong (count, argv[0], 0, __LINE__))
471     return 1; /* Abort.  */
472   return 0;
473 }
474
475 static int
476 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
477                              char **azColName, sqlite3_stmt *stmt)
478 {
479   (void) stmt;
480   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
481 }
482
483 /* We expect a single integer column whose name is "version".  COOKIE
484    must point to an int.  This function always aborts.  On error or a
485    if the version is bad, sets *VERSION to -1.  */
486 static int
487 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
488 {
489   int *version = cookie;
490
491   if (argc != 1 || strcmp (azColName[0], "version") != 0)
492     {
493       *version = -1;
494       return 1;
495     }
496
497   if (strcmp (argv[0], "1") == 0)
498     *version = 1;
499   else
500     {
501       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
502       *version = -1;
503     }
504
505   /* Don't run again.  */
506   return 1;
507 }
508
509
510 /* If the DB is new, initialize it.  Otherwise, check the DB's
511    version.
512
513    Return 0 if the database is okay and 1 otherwise.  */
514 static int
515 initdb (sqlite3 *db)
516 {
517   char *err = NULL;
518   int rc;
519   unsigned long int count;
520   int version = -1;
521
522   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
523   if (rc)
524     {
525       log_error (_("error beginning transaction on TOFU database: %s\n"),
526                  err);
527       sqlite3_free (err);
528       return 1;
529     }
530
531   /* If the DB has no tables, then assume this is a new DB that needs
532      to be initialized.  */
533   rc = sqlite3_exec (db,
534                      "select count(*) from sqlite_master where type='table';",
535                      get_single_unsigned_long_cb, &count, &err);
536   if (rc)
537     {
538       log_error (_("error reading TOFU database: %s\n"), err);
539       print_further_info ("query available tables");
540       sqlite3_free (err);
541       goto out;
542     }
543   else if (count != 0)
544     /* Assume that the DB is already initialized.  Make sure the
545        version is okay.  */
546     {
547       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
548                          &version, &err);
549       if (rc == SQLITE_ABORT && version == 1)
550         /* Happy, happy, joy, joy.  */
551         {
552           sqlite3_free (err);
553           rc = 0;
554           goto out;
555         }
556       else if (rc == SQLITE_ABORT && version == -1)
557         /* Unsupported version.  */
558         {
559           /* An error message was already displayed.  */
560           sqlite3_free (err);
561           goto out;
562         }
563       else if (rc)
564         /* Some error.  */
565         {
566           log_error (_("error determining TOFU database's version: %s\n"), err);
567           sqlite3_free (err);
568           goto out;
569         }
570       else
571         {
572           /* Unexpected success.  This can only happen if there are no
573              rows.  (select returned 0, but expected ABORT.)  */
574           log_error (_("error determining TOFU database's version: %s\n"),
575                      gpg_strerror (GPG_ERR_NO_DATA));
576           rc = 1;
577           goto out;
578         }
579     }
580
581   /* Create the version table.  */
582   rc = sqlite3_exec (db,
583                      "create table version (version INTEGER);",
584                      NULL, NULL, &err);
585   if (rc)
586     {
587       log_error (_("error initializing TOFU database: %s\n"), err);
588       print_further_info ("create version");
589       sqlite3_free (err);
590       goto out;
591     }
592
593   /* Initialize the version table, which contains a single integer
594      value.  */
595   rc = sqlite3_exec (db,
596                      "insert into version values (1);",
597                      NULL, NULL, &err);
598   if (rc)
599     {
600       log_error (_("error initializing TOFU database: %s\n"), err);
601       print_further_info ("insert version");
602       sqlite3_free (err);
603       goto out;
604     }
605
606   /* The list of <fingerprint, email> bindings and auxiliary data.
607    *
608    *  OID is a unique ID identifying this binding (and used by the
609    *    signatures table, see below).  Note: OIDs will never be
610    *    reused.
611    *
612    *  FINGERPRINT: The key's fingerprint.
613    *
614    *  EMAIL: The normalized email address.
615    *
616    *  USER_ID: The unmodified user id from which EMAIL was extracted.
617    *
618    *  TIME: The time this binding was first observed.
619    *
620    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
621    *
622    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
623    *    a binding <0xdeadbeef, foo@example.com> and then we observe
624    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
625    *    (they have the same email address).  When we observe the
626    *    latter binding, we warn the user about the conflict and ask
627    *    for a policy decision about the new binding.  We also change
628    *    the old binding's policy to ask if it was auto.  So that we
629    *     know why this occurred, we also set conflict to 0xbaddecaf.
630    */
631   rc = gpgsql_exec_printf
632       (db, NULL, NULL, &err,
633        "create table bindings\n"
634        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
635        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
636        "  policy INTEGER CHECK (policy in (%d, %d, %d, %d, %d)),\n"
637        "  conflict STRING,\n"
638        "  unique (fingerprint, email));\n"
639        "create index bindings_fingerprint_email\n"
640        " on bindings (fingerprint, email);\n"
641        "create index bindings_email on bindings (email);\n",
642        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
643        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
644   if (rc)
645     {
646       log_error (_("error initializing TOFU database: %s\n"), err);
647       print_further_info ("create bindings");
648       sqlite3_free (err);
649       goto out;
650     }
651
652   /* The signatures that we have observed.
653    *
654    * BINDING refers to a record in the bindings table, which
655    * describes the binding (i.e., this is a foreign key that
656    * references bindings.oid).
657    *
658    * SIG_DIGEST is the digest stored in the signature.
659    *
660    * SIG_TIME is the timestamp stored in the signature.
661    *
662    * ORIGIN is a free-form string that describes who fed this
663    * signature to GnuPG (e.g., email:claws).
664    *
665    * TIME is the time this signature was registered.  */
666   rc = sqlite3_exec (db,
667                          "create table signatures "
668                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
669                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
670                          "  primary key (binding, sig_digest, origin));",
671                          NULL, NULL, &err);
672   if (rc)
673     {
674       log_error (_("error initializing TOFU database: %s\n"), err);
675       print_further_info ("create signatures");
676       sqlite3_free (err);
677       goto out;
678     }
679
680  out:
681   if (! rc)
682     {
683       /* Early version of the v1 format did not include the encryption
684          table.  Add it.  */
685       sqlite3_exec (db,
686                     "create table if not exists encryptions"
687                     " (binding INTEGER NOT NULL,"
688                     "  time INTEGER);"
689                     "create index if not exists encryptions_binding"
690                     " on encryptions (binding);\n",
691                     NULL, NULL, &err);
692     }
693
694   if (rc)
695     {
696       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
697       if (rc)
698         {
699           log_error (_("error rolling back transaction on TOFU database: %s\n"),
700                      err);
701           sqlite3_free (err);
702         }
703       return 1;
704     }
705   else
706     {
707       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
708       if (rc)
709         {
710           log_error (_("error committing transaction on TOFU database: %s\n"),
711                      err);
712           sqlite3_free (err);
713           return 1;
714         }
715       return 0;
716     }
717 }
718
719 static int
720 busy_handler (void *cookie, int call_count)
721 {
722   ctrl_t ctrl = cookie;
723   tofu_dbs_t dbs = ctrl->tofu.dbs;
724
725   (void) call_count;
726
727   /* Update the lock file time stamp so that the current owner knows
728      that we want the lock.  */
729   if (dbs)
730     {
731       /* Note: we don't fail if we can't create the lock file: this
732          process will have to wait a bit longer, but otherwise nothing
733          horrible should happen.  */
734
735       int fd = open (dbs->want_lock_file, O_CREAT|O_WRONLY|O_TRUNC,
736                      S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR);
737       if (fd == -1)
738         log_debug ("TOFU: Error opening '%s': %s\n",
739                    dbs->want_lock_file, strerror (errno));
740       else
741         close (fd);
742     }
743
744   /* Call again.  */
745   return 1;
746 }
747
748 /* Create a new DB handle.  Returns NULL on error.  */
749 /* FIXME: Change to return an error code for better reporting by the
750    caller.  */
751 static tofu_dbs_t
752 opendbs (ctrl_t ctrl)
753 {
754   char *filename;
755   sqlite3 *db;
756   int rc;
757
758   if (!ctrl->tofu.dbs)
759     {
760       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
761
762       rc = sqlite3_open (filename, &db);
763       if (rc)
764         {
765           log_error (_("error opening TOFU database '%s': %s\n"),
766                      filename, sqlite3_errmsg (db));
767           /* Even if an error occurs, DB is guaranteed to be valid.  */
768           sqlite3_close (db);
769           db = NULL;
770         }
771
772       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
773          before failing.  */
774       if (db)
775         {
776           sqlite3_busy_timeout (db, 5 * 1000);
777           sqlite3_busy_handler (db, busy_handler, ctrl);
778         }
779
780       if (db && initdb (db))
781         {
782           sqlite3_close (db);
783           db = NULL;
784         }
785
786       if (db)
787         {
788           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
789           ctrl->tofu.dbs->db = db;
790           ctrl->tofu.dbs->want_lock_file = xasprintf ("%s-want-lock", filename);
791         }
792
793       xfree (filename);
794     }
795   else
796     log_assert (ctrl->tofu.dbs->db);
797
798   return ctrl->tofu.dbs;
799 }
800
801
802 /* Release all of the resources associated with the DB handle.  */
803 void
804 tofu_closedbs (ctrl_t ctrl)
805 {
806   tofu_dbs_t dbs;
807   sqlite3_stmt **statements;
808
809   dbs = ctrl->tofu.dbs;
810   if (!dbs)
811     return;  /* Not initialized.  */
812
813   log_assert (dbs->in_transaction == 0);
814
815   end_transaction (ctrl, 2);
816
817   /* Arghh, that is a surprising use of the struct.  */
818   for (statements = (void *) &dbs->s;
819        (void *) statements < (void *) &(&dbs->s)[1];
820        statements ++)
821     sqlite3_finalize (*statements);
822
823   sqlite3_close (dbs->db);
824   xfree (dbs->want_lock_file);
825   xfree (dbs);
826   ctrl->tofu.dbs = NULL;
827 }
828
829
830 /* Collect results of a select min (foo) ...; style query.  Aborts if
831    the argument is not a valid integer (or real of the form X.0).  */
832 static int
833 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
834 {
835   long *count = cookie;
836
837   (void) azColName;
838
839   log_assert (argc == 1);
840
841   if (string_to_long (count, argv[0], 0, __LINE__))
842     return 1; /* Abort.  */
843
844   return 0;
845 }
846
847 static int
848 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
849                      sqlite3_stmt *stmt)
850 {
851   (void) stmt;
852   return get_single_long_cb (cookie, argc, argv, azColName);
853 }
854
855 /* Record (or update) a trust policy about a (possibly new)
856    binding.
857
858    If SHOW_OLD is set, the binding's old policy is displayed.  */
859 static gpg_error_t
860 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
861                 const char *user_id, enum tofu_policy policy,
862                 const char *conflict,
863                 int show_old, time_t now)
864 {
865   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
866   gpg_error_t rc;
867   char *err = NULL;
868
869   if (! (policy == TOFU_POLICY_AUTO
870          || policy == TOFU_POLICY_GOOD
871          || policy == TOFU_POLICY_UNKNOWN
872          || policy == TOFU_POLICY_BAD
873          || policy == TOFU_POLICY_ASK))
874     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
875
876
877   if (DBG_TRUST || show_old)
878     {
879       /* Get the old policy.  Since this is just for informational
880        * purposes, there is no need to start a transaction or to die
881        * if there is a failure.  */
882
883       /* policy_old needs to be a long and not an enum tofu_policy,
884          because we pass it by reference to get_single_long_cb2, which
885          expects a long.  */
886       long policy_old = TOFU_POLICY_NONE;
887
888       rc = gpgsql_stepx
889         (dbs->db, &dbs->s.record_binding_get_old_policy,
890          get_single_long_cb2, &policy_old, &err,
891          "select policy from bindings where fingerprint = ? and email = ?",
892          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
893          GPGSQL_ARG_END);
894       if (rc)
895         {
896           log_debug ("TOFU: Error reading from binding database"
897                      " (reading policy for <key: %s, user id: %s>): %s\n",
898                      fingerprint, email, err);
899           sqlite3_free (err);
900         }
901
902       if (policy_old != TOFU_POLICY_NONE)
903         (show_old ? log_info : log_debug)
904           ("Changing TOFU trust policy for binding"
905            " <key: %s, user id: %s> from %s to %s.\n",
906            fingerprint, show_old ? user_id : email,
907            tofu_policy_str (policy_old),
908            tofu_policy_str (policy));
909       else
910         (show_old ? log_info : log_debug)
911           ("Setting TOFU trust policy for new binding"
912            " <key: %s, user id: %s> to %s.\n",
913            fingerprint, show_old ? user_id : email,
914            tofu_policy_str (policy));
915     }
916
917   if (opt.dry_run)
918     {
919       log_info ("TOFU database update skipped due to --dry-run\n");
920       rc = 0;
921       goto leave;
922     }
923
924   rc = gpgsql_stepx
925     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
926      "insert or replace into bindings\n"
927      " (oid, fingerprint, email, user_id, time, policy, conflict)\n"
928      " values (\n"
929      /* If we don't explicitly reuse the OID, then SQLite will
930         reallocate a new one.  We just need to search for the OID
931         based on the fingerprint and email since they are unique.  */
932      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
933      "  ?, ?, ?, ?, ?, ?);",
934      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
935      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
936      GPGSQL_ARG_STRING, user_id,
937      GPGSQL_ARG_LONG_LONG, (long long) now,
938      GPGSQL_ARG_INT, (int) policy,
939      GPGSQL_ARG_STRING, conflict ? conflict : "",
940      GPGSQL_ARG_END);
941   if (rc)
942     {
943       log_error (_("error updating TOFU database: %s\n"), err);
944       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
945                           fingerprint, email, tofu_policy_str (policy));
946       sqlite3_free (err);
947       goto leave;
948     }
949
950  leave:
951   xfree (fingerprint_pp);
952   return rc;
953 }
954
955
956 /* Collect the strings returned by a query in a simply string list.
957    Any NULL values are converted to the empty string.
958
959    If a result has 3 rows and each row contains two columns, then the
960    results are added to the list as follows (the value is parentheses
961    is the 1-based index in the final list):
962
963      row 1, col 2 (6)
964      row 1, col 1 (5)
965      row 2, col 2 (4)
966      row 2, col 1 (3)
967      row 3, col 2 (2)
968      row 3, col 1 (1)
969
970    This is because add_to_strlist pushes the results onto the front of
971    the list.  The end result is that the rows are backwards, but the
972    columns are in the expected order.  */
973 static int
974 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
975 {
976   int i;
977   strlist_t *strlist = cookie;
978
979   (void) azColName;
980
981   for (i = argc - 1; i >= 0; i --)
982     add_to_strlist (strlist, argv[i] ? argv[i] : "");
983
984   return 0;
985 }
986
987 static int
988 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
989                      sqlite3_stmt *stmt)
990 {
991   (void) stmt;
992   return strings_collect_cb (cookie, argc, argv, azColName);
993
994 }
995
996 /* Auxiliary data structure to collect statistics about
997    signatures.  */
998 struct signature_stats
999 {
1000   struct signature_stats *next;
1001
1002   /* The user-assigned policy for this binding.  */
1003   enum tofu_policy policy;
1004
1005   /* How long ago the signature was created (rounded to a multiple of
1006      TIME_AGO_UNIT_SMALL, etc.).  */
1007   long time_ago;
1008   /* Number of signatures during this time.  */
1009   unsigned long count;
1010
1011   /* If the corresponding key/user id has been expired / revoked.  */
1012   int is_expired;
1013   int is_revoked;
1014
1015   /* The key that generated this signature.  */
1016   char fingerprint[1];
1017 };
1018
1019 static void
1020 signature_stats_free (struct signature_stats *stats)
1021 {
1022   while (stats)
1023     {
1024       struct signature_stats *next = stats->next;
1025       xfree (stats);
1026       stats = next;
1027     }
1028 }
1029
1030 static void
1031 signature_stats_prepend (struct signature_stats **statsp,
1032                          const char *fingerprint,
1033                          enum tofu_policy policy,
1034                          long time_ago,
1035                          unsigned long count)
1036 {
1037   struct signature_stats *stats =
1038     xmalloc_clear (sizeof (*stats) + strlen (fingerprint));
1039
1040   stats->next = *statsp;
1041   *statsp = stats;
1042
1043   strcpy (stats->fingerprint, fingerprint);
1044   stats->policy = policy;
1045   stats->time_ago = time_ago;
1046   stats->count = count;
1047 }
1048
1049
1050 /* Process rows that contain the four columns:
1051
1052      <fingerprint, policy, time ago, count>.  */
1053 static int
1054 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1055                             char **azColName, sqlite3_stmt *stmt)
1056 {
1057   struct signature_stats **statsp = cookie;
1058   int i = 0;
1059   enum tofu_policy policy;
1060   long time_ago;
1061   unsigned long count;
1062   long along;
1063
1064   (void) azColName;
1065   (void) stmt;
1066
1067   i ++;
1068
1069   if (string_to_long (&along, argv[i], 0, __LINE__))
1070     return 1;  /* Abort */
1071   policy = along;
1072   i ++;
1073
1074   if (! argv[i])
1075     time_ago = 0;
1076   else
1077     {
1078       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
1079         return 1; /* Abort.  */
1080     }
1081   i ++;
1082
1083   /* If time_ago is NULL, then we had no messages, but we still have a
1084      single row, which count(*) turns into 1.  */
1085   if (! argv[i - 1])
1086     count = 0;
1087   else
1088     {
1089       if (string_to_ulong (&count, argv[i], 0, __LINE__))
1090         return 1; /* Abort */
1091     }
1092   i ++;
1093
1094   log_assert (argc == i);
1095
1096   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1097
1098   return 0;
1099 }
1100
1101 /* Convert from seconds to time units.
1102
1103    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1104    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1105 signed long
1106 time_ago_scale (signed long t)
1107 {
1108   if (t < TIME_AGO_UNIT_MEDIUM)
1109     return t / TIME_AGO_UNIT_SMALL;
1110   if (t < TIME_AGO_UNIT_LARGE)
1111     return t / TIME_AGO_UNIT_MEDIUM;
1112   return t / TIME_AGO_UNIT_LARGE;
1113 }
1114
1115
1116 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1117    already been normalized) and any conflict information in *CONFLICT
1118    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1119    occurs.  */
1120 static enum tofu_policy
1121 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1122             char **conflict)
1123 {
1124   int rc;
1125   char *err = NULL;
1126   strlist_t strlist = NULL;
1127   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1128   long along;
1129
1130   /* Check if the <FINGERPRINT, EMAIL> binding is known
1131      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1132      still TOFU_POLICY_NONE after executing the query, then the
1133      result set was empty.)  */
1134   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1135                       strings_collect_cb2, &strlist, &err,
1136                       "select policy, conflict from bindings\n"
1137                       " where fingerprint = ? and email = ?",
1138                       GPGSQL_ARG_STRING, fingerprint,
1139                       GPGSQL_ARG_STRING, email,
1140                       GPGSQL_ARG_END);
1141   if (rc)
1142     {
1143       log_error (_("error reading TOFU database: %s\n"), err);
1144       print_further_info ("checking for existing bad bindings");
1145       sqlite3_free (err);
1146       rc = gpg_error (GPG_ERR_GENERAL);
1147       goto out;
1148     }
1149
1150   if (strlist_length (strlist) == 0)
1151     /* No results.  */
1152     {
1153       policy = TOFU_POLICY_NONE;
1154       goto out;
1155     }
1156   else if (strlist_length (strlist) != 2)
1157     /* The result has the wrong form.  */
1158     {
1159       log_error (_("error reading TOFU database: %s\n"),
1160                  gpg_strerror (GPG_ERR_BAD_DATA));
1161       print_further_info ("checking for existing bad bindings:"
1162                           " expected 2 results, got %d\n",
1163                           strlist_length (strlist));
1164       goto out;
1165     }
1166
1167   /* The result has the right form.  */
1168
1169   if (string_to_long (&along, strlist->d, 0, __LINE__))
1170     {
1171       log_error (_("error reading TOFU database: %s\n"),
1172                  gpg_strerror (GPG_ERR_BAD_DATA));
1173       print_further_info ("bad value for policy: %s", strlist->d);
1174       goto out;
1175     }
1176   policy = along;
1177
1178   if (! (policy == TOFU_POLICY_AUTO
1179          || policy == TOFU_POLICY_GOOD
1180          || policy == TOFU_POLICY_UNKNOWN
1181          || policy == TOFU_POLICY_BAD
1182          || policy == TOFU_POLICY_ASK))
1183     {
1184       log_error (_("error reading TOFU database: %s\n"),
1185                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1186       print_further_info ("invalid value for policy (%d)", policy);
1187       policy = _tofu_GET_POLICY_ERROR;
1188       goto out;
1189     }
1190
1191
1192   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1193      just in case, we do the check again here and ignore the conflict
1194      if POLICY is not TOFU_POLICY_ASK.  */
1195   if (conflict)
1196     {
1197       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1198         *conflict = xstrdup (strlist->next->d);
1199       else
1200         *conflict = NULL;
1201     }
1202
1203  out:
1204   log_assert (policy == _tofu_GET_POLICY_ERROR
1205               || policy == TOFU_POLICY_NONE
1206               || policy == TOFU_POLICY_AUTO
1207               || policy == TOFU_POLICY_GOOD
1208               || policy == TOFU_POLICY_UNKNOWN
1209               || policy == TOFU_POLICY_BAD
1210               || policy == TOFU_POLICY_ASK);
1211
1212   free_strlist (strlist);
1213
1214   return policy;
1215 }
1216
1217
1218 /* Format the first part of a conflict message and return that as a
1219  * malloced string.  */
1220 static char *
1221 format_conflict_msg_part1 (int policy, strlist_t conflict_set,
1222                            const char *email)
1223 {
1224   estream_t fp;
1225   char *fingerprint;
1226   char *tmpstr, *text;
1227
1228   log_assert (conflict_set);
1229   fingerprint = conflict_set->d;
1230
1231   fp = es_fopenmem (0, "rw,samethread");
1232   if (!fp)
1233     log_fatal ("error creating memory stream: %s\n",
1234                gpg_strerror (gpg_error_from_syserror()));
1235
1236   if (policy == TOFU_POLICY_NONE)
1237     {
1238       es_fprintf (fp,
1239                   _("This is the first time the email address \"%s\" is "
1240                     "being used with key %s."),
1241                   email, fingerprint);
1242       es_fputs ("  ", fp);
1243     }
1244   else if (policy == TOFU_POLICY_ASK && conflict_set->next)
1245     {
1246       int conflicts = strlist_length (conflict_set);
1247       es_fprintf (fp, _("The email address \"%s\" is associated with %d keys!"),
1248                   email, conflicts);
1249       if (opt.verbose)
1250         es_fprintf (fp,
1251                     _("  Since this binding's policy was 'auto', it has been "
1252                       "changed to 'ask'."));
1253       es_fputs ("  ", fp);
1254     }
1255
1256   es_fprintf (fp,
1257               _("Please indicate whether this email address should"
1258                 " be associated with key %s or whether you think someone"
1259                 " is impersonating \"%s\"."),
1260               fingerprint, email);
1261   es_fputc ('\n', fp);
1262
1263   es_fputc (0, fp);
1264   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1265     log_fatal ("error snatching memory stream\n");
1266   text = format_text (tmpstr, 0, 72, 80);
1267   es_free (tmpstr);
1268
1269   return text;
1270 }
1271
1272
1273 /* Return 1 if A signed B and B signed A.  */
1274 static int
1275 cross_sigs (const char *email, kbnode_t a, kbnode_t b)
1276 {
1277   int i;
1278
1279   PKT_public_key *a_pk = a->pkt->pkt.public_key;
1280   PKT_public_key *b_pk = b->pkt->pkt.public_key;
1281
1282   char a_keyid[33];
1283   char b_keyid[33];
1284
1285   if (DBG_TRUST)
1286     {
1287       format_keyid (pk_main_keyid (a_pk),
1288                     KF_LONG, a_keyid, sizeof (a_keyid));
1289       format_keyid (pk_main_keyid (b_pk),
1290                     KF_LONG, b_keyid, sizeof (b_keyid));
1291     }
1292
1293   for (i = 0; i < 2; i ++)
1294     {
1295       /* See if SIGNER signed SIGNEE.  */
1296
1297       kbnode_t signer = i == 0 ? a : b;
1298       kbnode_t signee = i == 0 ? b : a;
1299
1300       PKT_public_key *signer_pk = signer->pkt->pkt.public_key;
1301       u32 *signer_kid = pk_main_keyid (signer_pk);
1302       kbnode_t n;
1303
1304       int saw_email = 0;
1305
1306       /* Iterate over SIGNEE's keyblock and see if there is a valid
1307          signature from SIGNER.  */
1308       for (n = signee; n; n = n->next)
1309         {
1310           PKT_signature *sig;
1311
1312           if (n->pkt->pkttype == PKT_USER_ID)
1313             {
1314               if (saw_email)
1315                 /* We're done: we've processed all signatures on the
1316                    user id.  */
1317                 break;
1318               else
1319                 {
1320                   /* See if this is the matching user id.  */
1321                   PKT_user_id *user_id = n->pkt->pkt.user_id;
1322                   char *email2 = email_from_user_id (user_id->name);
1323
1324                   if (strcmp (email, email2) == 0)
1325                     saw_email = 1;
1326
1327                   xfree (email2);
1328                 }
1329             }
1330
1331           if (! saw_email)
1332             continue;
1333
1334           if (n->pkt->pkttype != PKT_SIGNATURE)
1335             continue;
1336
1337           sig = n->pkt->pkt.signature;
1338
1339           if (! (sig->sig_class == 0x10
1340                  || sig->sig_class == 0x11
1341                  || sig->sig_class == 0x12
1342                  || sig->sig_class == 0x13))
1343             /* Not a signature over a user id.  */
1344             continue;
1345
1346           /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1347              signer, then it's a match.  */
1348           if (keyid_cmp (sig->keyid, signer_kid) == 0)
1349             /* Match!  */
1350             break;
1351         }
1352       if (! n)
1353         /* We didn't find a signature from signer over signee.  */
1354         {
1355           if (DBG_TRUST)
1356             log_debug ("No cross sig between %s and %s\n",
1357                        a_keyid, b_keyid);
1358           return 0;
1359         }
1360     }
1361
1362   /* A signed B and B signed A.  */
1363   if (DBG_TRUST)
1364     log_debug ("Cross sig between %s and %s\n",
1365                a_keyid, b_keyid);
1366
1367   return 1;
1368 }
1369
1370 /* Return whether the key was signed by an ultimately trusted key.  */
1371 static int
1372 signed_by_utk (const char *email, kbnode_t a)
1373 {
1374   kbnode_t n;
1375   int saw_email = 0;
1376
1377   for (n = a; n; n = n->next)
1378     {
1379       PKT_signature *sig;
1380
1381       if (n->pkt->pkttype == PKT_USER_ID)
1382         {
1383           if (saw_email)
1384             /* We're done: we've processed all signatures on the
1385                user id.  */
1386             break;
1387           else
1388             {
1389               /* See if this is the matching user id.  */
1390               PKT_user_id *user_id = n->pkt->pkt.user_id;
1391               char *email2 = email_from_user_id (user_id->name);
1392
1393               if (strcmp (email, email2) == 0)
1394                 saw_email = 1;
1395
1396               xfree (email2);
1397             }
1398         }
1399
1400       if (! saw_email)
1401         continue;
1402
1403       if (n->pkt->pkttype != PKT_SIGNATURE)
1404         continue;
1405
1406       sig = n->pkt->pkt.signature;
1407
1408       if (! (sig->sig_class == 0x10
1409              || sig->sig_class == 0x11
1410              || sig->sig_class == 0x12
1411              || sig->sig_class == 0x13))
1412         /* Not a signature over a user id.  */
1413         continue;
1414
1415       /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1416          signer, then it's a match.  */
1417       if (tdb_keyid_is_utk (sig->keyid))
1418         {
1419           /* Match!  */
1420           if (DBG_TRUST)
1421             log_debug ("TOFU: %s is signed by an ultimately trusted key.\n",
1422                        pk_keyid_str (a->pkt->pkt.public_key));
1423
1424           return 1;
1425         }
1426     }
1427
1428   if (DBG_TRUST)
1429     log_debug ("TOFU: %s is NOT signed by an ultimately trusted key.\n",
1430                pk_keyid_str (a->pkt->pkt.public_key));
1431
1432   return 0;
1433 }
1434
1435
1436 enum
1437   {
1438     BINDING_NEW = 1 << 0,
1439     BINDING_CONFLICT = 1 << 1,
1440     BINDING_EXPIRED = 1 << 2,
1441     BINDING_REVOKED = 1 << 3
1442   };
1443
1444
1445 /* Ask the user about the binding.  There are three ways we could end
1446  * up here:
1447  *
1448  *   - This is a new binding and there is a conflict
1449  *     (policy == TOFU_POLICY_NONE && conflict_set_count > 1),
1450  *
1451  *   - This is a new binding and opt.tofu_default_policy is set to
1452  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1453  *     TOFU_POLICY_ASK), or,
1454  *
1455  *   - The policy is ask (the user deferred last time) (policy ==
1456  *     TOFU_POLICY_ASK).
1457  *
1458  * Note: this function must not be called while in a transaction!
1459  *
1460  * CONFLICT_SET includes all of the conflicting bindings
1461  * with FINGERPRINT first.  FLAGS is a bit-wise or of
1462  * BINDING_NEW, etc.
1463  */
1464 static void
1465 ask_about_binding (ctrl_t ctrl,
1466                    enum tofu_policy *policy,
1467                    int *trust_level,
1468                    strlist_t conflict_set,
1469                    const char *fingerprint,
1470                    const char *email,
1471                    const char *user_id,
1472                    time_t now)
1473 {
1474   tofu_dbs_t dbs;
1475   strlist_t iter;
1476   int conflict_set_count = strlist_length (conflict_set);
1477   char *sqerr = NULL;
1478   int rc;
1479   estream_t fp;
1480   strlist_t other_user_ids = NULL;
1481   struct signature_stats *stats = NULL;
1482   struct signature_stats *stats_iter = NULL;
1483   char *prompt = NULL;
1484   char *choices;
1485
1486   dbs = ctrl->tofu.dbs;
1487   log_assert (dbs);
1488   log_assert (dbs->in_transaction == 0);
1489
1490   fp = es_fopenmem (0, "rw,samethread");
1491   if (!fp)
1492     log_fatal ("error creating memory stream: %s\n",
1493                gpg_strerror (gpg_error_from_syserror()));
1494
1495   {
1496     char *text = format_conflict_msg_part1 (*policy, conflict_set, email);
1497     es_fputs (text, fp);
1498     es_fputc ('\n', fp);
1499     xfree (text);
1500   }
1501
1502   begin_transaction (ctrl, 0);
1503
1504   /* Find other user ids associated with this key and whether the
1505    * bindings are marked as good or bad.  */
1506   rc = gpgsql_stepx
1507     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1508      strings_collect_cb2, &other_user_ids, &sqerr,
1509      "select user_id, policy from bindings where fingerprint = ?;",
1510      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1511   if (rc)
1512     {
1513       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1514       sqlite3_free (sqerr);
1515       sqerr = NULL;
1516       rc = gpg_error (GPG_ERR_GENERAL);
1517     }
1518
1519   if (other_user_ids)
1520     {
1521       strlist_t strlist_iter;
1522
1523       es_fprintf (fp, _("This key's user IDs:\n"));
1524       for (strlist_iter = other_user_ids;
1525            strlist_iter;
1526            strlist_iter = strlist_iter->next)
1527         {
1528           char *other_user_id = strlist_iter->d;
1529           char *other_thing;
1530           enum tofu_policy other_policy;
1531
1532           log_assert (strlist_iter->next);
1533           strlist_iter = strlist_iter->next;
1534           other_thing = strlist_iter->d;
1535
1536           other_policy = atoi (other_thing);
1537
1538           es_fprintf (fp, "  %s (", other_user_id);
1539           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1540           es_fprintf (fp, ")\n");
1541         }
1542       es_fprintf (fp, "\n");
1543
1544       free_strlist (other_user_ids);
1545     }
1546
1547   /* Get the stats for all the keys in CONFLICT_SET.  */
1548   strlist_rev (&conflict_set);
1549   for (iter = conflict_set; iter && ! rc; iter = iter->next)
1550     {
1551 #define STATS_SQL(table, time, sign)                         \
1552          "select fingerprint, policy, time_ago, count(*)\n" \
1553          " from\n" \
1554          "  (select bindings.*,\n" \
1555          "     "sign" case\n" \
1556          "       when delta ISNULL then 1\n" \
1557          /* From the future (but if its just a couple of hours in the \
1558           * future don't turn it into a warning)?  Or should we use \
1559           * small, medium or large units?  (Note: whatever we do, we \
1560           * keep the value in seconds.  Then when we group, everything \
1561           * that rounds to the same number of seconds is grouped.)  */ \
1562          "      when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then 2\n" \
1563          "      when delta < ("STRINGIFY (TIME_AGO_SMALL_THRESHOLD)")\n" \
1564          "       then 3\n" \
1565          "      when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n" \
1566          "       then 4\n" \
1567          "      when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n" \
1568          "       then 5\n" \
1569          "      else 6\n" \
1570          "     end time_ago,\n" \
1571          "    delta time_ago_raw\n" \
1572          "   from bindings\n" \
1573          "   left join\n" \
1574          "     (select *,\n" \
1575          "        cast(? - " time " as real) delta\n" \
1576          "       from " table ") ss\n" \
1577          "    on ss.binding = bindings.oid)\n" \
1578          " where email = ? and fingerprint = ?\n" \
1579          " group by time_ago\n" \
1580          /* Make sure the current key is first.  */ \
1581          " order by time_ago desc;\n"
1582
1583       /* Use the time when we saw the signature, not when the
1584          signature was created as that can be forged.  */
1585       rc = gpgsql_stepx
1586         (dbs->db, &dbs->s.get_trust_gather_signature_stats,
1587          signature_stats_collect_cb, &stats, &sqerr,
1588          STATS_SQL ("signatures", "time", ""),
1589          GPGSQL_ARG_LONG_LONG, (long long) now,
1590          GPGSQL_ARG_STRING, email,
1591          GPGSQL_ARG_STRING, iter->d,
1592          GPGSQL_ARG_END);
1593       if (rc)
1594         {
1595           rc = gpg_error (GPG_ERR_GENERAL);
1596           break;
1597         }
1598
1599       if (!stats || strcmp (iter->d, stats->fingerprint) != 0)
1600         /* No stats for this binding.  Add a dummy entry.  */
1601         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, 1, 1);
1602
1603       rc = gpgsql_stepx
1604         (dbs->db, &dbs->s.get_trust_gather_encryption_stats,
1605          signature_stats_collect_cb, &stats, &sqerr,
1606          STATS_SQL ("encryptions", "time", "-"),
1607          GPGSQL_ARG_LONG_LONG, (long long) now,
1608          GPGSQL_ARG_STRING, email,
1609          GPGSQL_ARG_STRING, iter->d,
1610          GPGSQL_ARG_END);
1611       if (rc)
1612         {
1613           rc = gpg_error (GPG_ERR_GENERAL);
1614           break;
1615         }
1616
1617 #undef STATS_SQL
1618
1619       if (!stats || strcmp (iter->d, stats->fingerprint) != 0
1620           || stats->time_ago > 0)
1621         /* No stats for this binding.  Add a dummy entry.  */
1622         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, -1, 1);
1623     }
1624   end_transaction (ctrl, 0);
1625   strlist_rev (&conflict_set);
1626   if (rc)
1627     {
1628       strlist_t strlist_iter;
1629
1630       log_error (_("error gathering signature stats: %s\n"), sqerr);
1631       sqlite3_free (sqerr);
1632       sqerr = NULL;
1633
1634       es_fprintf (fp, ngettext("The email address \"%s\" is"
1635                                " associated with %d key:\n",
1636                                "The email address \"%s\" is"
1637                                " associated with %d keys:\n",
1638                                conflict_set_count),
1639                   email, conflict_set_count);
1640       for (strlist_iter = conflict_set;
1641            strlist_iter;
1642            strlist_iter = strlist_iter->next)
1643         es_fprintf (fp, "  %s\n", strlist_iter->d);
1644     }
1645   else
1646     {
1647       char *key = NULL;
1648       strlist_t binding;
1649       int seen_in_past = 0;
1650
1651       es_fprintf (fp, _("Statistics for keys"
1652                         " with the email address \"%s\":\n"),
1653                   email);
1654       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1655         {
1656 #if 0
1657           log_debug ("%s: time_ago: %ld; count: %ld\n",
1658                      stats_iter->fingerprint,
1659                      stats_iter->time_ago,
1660                      stats_iter->count);
1661 #endif
1662
1663           if (! key || strcmp (key, stats_iter->fingerprint))
1664             {
1665               int this_key;
1666               char *key_pp;
1667
1668               key = stats_iter->fingerprint;
1669               this_key = strcmp (key, fingerprint) == 0;
1670               key_pp = format_hexfingerprint (key, NULL, 0);
1671               es_fprintf (fp, "  %s (", key_pp);
1672
1673               /* Find the associated binding.  */
1674               for (binding = conflict_set;
1675                    binding;
1676                    binding = binding->next)
1677                 if (strcmp (key, binding->d) == 0)
1678                   break;
1679               log_assert (binding);
1680
1681               if ((binding->flags & BINDING_REVOKED))
1682                 {
1683                   es_fprintf (fp, _("revoked"));
1684                   es_fprintf (fp, _(", "));
1685                 }
1686               else if ((binding->flags & BINDING_EXPIRED))
1687                 {
1688                   es_fprintf (fp, _("expired"));
1689                   es_fprintf (fp, _(", "));
1690                 }
1691
1692               if (this_key)
1693                 es_fprintf (fp, _("this key"));
1694               else
1695                 es_fprintf (fp, _("policy: %s"),
1696                             tofu_policy_str (stats_iter->policy));
1697               es_fputs ("):\n", fp);
1698               xfree (key_pp);
1699
1700               seen_in_past = 0;
1701             }
1702
1703           if (labs(stats_iter->time_ago) == 1)
1704             {
1705               /* The 1 in this case is the NULL entry.  */
1706               log_assert (stats_iter->count == 1);
1707               stats_iter->count = 0;
1708             }
1709           seen_in_past += stats_iter->count;
1710
1711           es_fputs ("    ", fp);
1712           /* TANSLATORS: This string is concatenated with one of
1713            * the day/week/month strings to form one sentence.  */
1714           if (stats_iter->time_ago > 0)
1715             es_fprintf (fp, ngettext("Verified %d message",
1716                                      "Verified %d messages",
1717                                      seen_in_past), seen_in_past);
1718           else
1719             es_fprintf (fp, ngettext("Encrypted %d message",
1720                                      "Encrypted %d messages",
1721                                      seen_in_past), seen_in_past);
1722
1723           if (!stats_iter->count)
1724             es_fputs (".", fp);
1725           else if (labs(stats_iter->time_ago) == 2)
1726             {
1727               es_fprintf (fp, "in the future.");
1728               /* Reset it.  */
1729               seen_in_past = 0;
1730             }
1731           else
1732             {
1733               if (labs(stats_iter->time_ago) == 3)
1734                 es_fprintf (fp, ngettext(" over the past day.",
1735                                          " over the past %d days.",
1736                                          seen_in_past),
1737                             TIME_AGO_SMALL_THRESHOLD
1738                             / TIME_AGO_UNIT_SMALL);
1739               else if (labs(stats_iter->time_ago) == 4)
1740                 es_fprintf (fp, ngettext(" over the past month.",
1741                                          " over the past %d months.",
1742                                          seen_in_past),
1743                             TIME_AGO_MEDIUM_THRESHOLD
1744                             / TIME_AGO_UNIT_MEDIUM);
1745               else if (labs(stats_iter->time_ago) == 5)
1746                 es_fprintf (fp, ngettext(" over the past year.",
1747                                          " over the past %d years.",
1748                                          seen_in_past),
1749                             TIME_AGO_LARGE_THRESHOLD
1750                             / TIME_AGO_UNIT_LARGE);
1751               else if (labs(stats_iter->time_ago) == 6)
1752                 es_fprintf (fp, _(" in the past."));
1753               else
1754                 log_assert (! "Broken SQL.\n");
1755             }
1756           es_fputs ("\n", fp);
1757         }
1758     }
1759
1760   if (conflict_set_count > 1 || (conflict_set->flags & BINDING_CONFLICT))
1761     {
1762       /* This is a conflict.  */
1763
1764       /* TRANSLATORS: Please translate the text found in the source
1765        * file below.  We don't directly internationalize that text so
1766        * that we can tweak it without breaking translations.  */
1767       char *text = _("TOFU detected a binding conflict");
1768       char *textbuf;
1769       if (!strcmp (text, "TOFU detected a binding conflict"))
1770         {
1771           /* No translation.  Use the English text.  */
1772           text =
1773             "Normally, an email address is associated with a single key.  "
1774             "However, people sometimes generate a new key if "
1775             "their key is too old or they think it might be compromised.  "
1776             "Alternatively, a new key may indicate a man-in-the-middle "
1777             "attack!  Before accepting this association, you should talk to or "
1778             "call the person to make sure this new key is legitimate.";
1779         }
1780       textbuf = format_text (text, 0, 72, 80);
1781       es_fprintf (fp, "\n%s\n", textbuf);
1782       xfree (textbuf);
1783     }
1784
1785   es_fputc ('\n', fp);
1786
1787   /* Add a NUL terminator.  */
1788   es_fputc (0, fp);
1789   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1790     log_fatal ("error snatching memory stream\n");
1791
1792   /* I think showing the large message once is sufficient.  If we
1793    * would move it right before the cpr_get many lines will scroll
1794    * away and the user might not realize that he merely entered a
1795    * wrong choise (because he does not see that either).  As a small
1796    * benefit we allow C-L to redisplay everything.  */
1797   tty_printf ("%s", prompt);
1798
1799   /* Suspend any transaction: it could take a while until the user
1800      responds.  */
1801   tofu_suspend_batch_transaction (ctrl);
1802   while (1)
1803     {
1804       char *response;
1805
1806       /* TRANSLATORS: Two letters (normally the lower and upper case
1807        * version of the hotkey) for each of the five choices.  If
1808        * there is only one choice in your language, repeat it.  */
1809       choices = _("gG" "aA" "uU" "rR" "bB");
1810       if (strlen (choices) != 10)
1811         log_bug ("Bad TOFU conflict translation!  Please report.");
1812
1813       response = cpr_get
1814         ("tofu.conflict",
1815          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1816       trim_spaces (response);
1817       cpr_kill_prompt ();
1818       if (*response == CONTROL_L)
1819         tty_printf ("%s", prompt);
1820       else if (!response[0])
1821         /* Default to unknown.  Don't save it.  */
1822         {
1823           tty_printf (_("Defaulting to unknown."));
1824           *policy = TOFU_POLICY_UNKNOWN;
1825           break;
1826         }
1827       else if (!response[1])
1828         {
1829           char *choice = strchr (choices, *response);
1830
1831           if (choice)
1832             {
1833               int c = ((size_t) choice - (size_t) choices) / 2;
1834
1835               switch (c)
1836                 {
1837                 case 0: /* Good.  */
1838                   *policy = TOFU_POLICY_GOOD;
1839                   *trust_level = tofu_policy_to_trust_level (*policy);
1840                   break;
1841                 case 1: /* Accept once.  */
1842                   *policy = TOFU_POLICY_ASK;
1843                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1844                   break;
1845                 case 2: /* Unknown.  */
1846                   *policy = TOFU_POLICY_UNKNOWN;
1847                   *trust_level = tofu_policy_to_trust_level (*policy);
1848                   break;
1849                 case 3: /* Reject once.  */
1850                   *policy = TOFU_POLICY_ASK;
1851                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1852                   break;
1853                 case 4: /* Bad.  */
1854                   *policy = TOFU_POLICY_BAD;
1855                   *trust_level = tofu_policy_to_trust_level (*policy);
1856                   break;
1857                 default:
1858                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1859                 }
1860
1861               if (record_binding (dbs, fingerprint, email, user_id,
1862                                   *policy, NULL, 0, now))
1863                 {
1864                   /* If there's an error registering the
1865                    * binding, don't save the signature.  */
1866                   *trust_level = _tofu_GET_TRUST_ERROR;
1867                 }
1868               break;
1869             }
1870         }
1871       xfree (response);
1872     }
1873
1874   tofu_resume_batch_transaction (ctrl);
1875
1876   xfree (prompt);
1877
1878   signature_stats_free (stats);
1879 }
1880
1881 /* Return the set of keys that conflict with the binding <fingerprint,
1882    email> (including the binding itself, which will be first in the
1883    list).  For each returned key also sets BINDING_NEW, etc.  */
1884 static strlist_t
1885 build_conflict_set (tofu_dbs_t dbs,
1886                     PKT_public_key *pk, const char *fingerprint,
1887                     const char *email)
1888 {
1889   gpg_error_t rc;
1890   char *sqerr;
1891   strlist_t conflict_set = NULL;
1892   int conflict_set_count;
1893   strlist_t iter;
1894   kbnode_t *kb_all;
1895   KEYDB_HANDLE hd;
1896   int i;
1897
1898   /* Get the fingerprints of any bindings that share the email address
1899    * and whether the bindings have a known conflict.
1900    *
1901    * Note: if the binding in question is in the DB, it will also be
1902    * returned.  Thus, if the result set is empty, then <email,
1903    * fingerprint> is a new binding.  */
1904   rc = gpgsql_stepx
1905     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1906      strings_collect_cb2, &conflict_set, &sqerr,
1907      "select"
1908      /* A binding should only appear once, but try not to break in the
1909       * case of corruption.  */
1910      "  fingerprint || case sum(conflict NOTNULL) when 0 then '' else '!' end"
1911      " from bindings where email = ?"
1912      "  group by fingerprint"
1913      /* Make sure the current key comes first in the result list (if
1914         it is present).  */
1915      "  order by fingerprint = ? asc, fingerprint desc;",
1916      GPGSQL_ARG_STRING, email,
1917      GPGSQL_ARG_STRING, fingerprint,
1918      GPGSQL_ARG_END);
1919   if (rc)
1920     {
1921       log_error (_("error reading TOFU database: %s\n"), sqerr);
1922       print_further_info ("listing fingerprints");
1923       sqlite3_free (sqerr);
1924       rc = gpg_error (GPG_ERR_GENERAL);
1925       return NULL;
1926     }
1927
1928   /* Set BINDING_CONFLICT if the binding has a known conflict.  This
1929    * allows us to distinguish between bindings where the user
1930    * explicitly set the policy to ask and bindings where we set the
1931    * policy to ask due to a conflict.  */
1932   for (iter = conflict_set; iter; iter = iter->next)
1933     {
1934       int l = strlen (iter->d);
1935       if (!(l == 2 * MAX_FINGERPRINT_LEN
1936             || l == 2 * MAX_FINGERPRINT_LEN + 1))
1937         {
1938           log_error (_("TOFU db corruption detected.\n"));
1939           print_further_info ("fingerprint '%s' is not %d characters long",
1940                               iter->d, 2 * MAX_FINGERPRINT_LEN);
1941         }
1942
1943       if (l >= 1 && iter->d[l - 1] == '!')
1944         {
1945           iter->flags |= BINDING_CONFLICT;
1946           /* Remove the !.  */
1947           iter->d[l - 1] = 0;
1948         }
1949     }
1950
1951   /* If the current binding has not yet been recorded, add it to the
1952    * list.  (The order by above ensures that if it is present, it will
1953    * be first.)  */
1954   if (! (conflict_set && strcmp (conflict_set->d, fingerprint) == 0))
1955     {
1956       add_to_strlist (&conflict_set, fingerprint);
1957       conflict_set->flags |= BINDING_NEW;
1958     }
1959
1960   conflict_set_count = strlist_length (conflict_set);
1961
1962   /* Eliminate false conflicts.  */
1963
1964   if (conflict_set_count == 1)
1965     /* We only have a single key.  There are no false conflicts to
1966        eliminate.  But, we do need to set the flags.  */
1967     {
1968       if (pk->has_expired)
1969         conflict_set->flags |= BINDING_EXPIRED;
1970       if (pk->flags.revoked)
1971         conflict_set->flags |= BINDING_REVOKED;
1972
1973       return conflict_set;
1974     }
1975
1976   /* If two keys have cross signatures, then they are controlled by
1977    * the same person and thus are not in conflict.  */
1978   kb_all = xcalloc (sizeof (kb_all[0]), conflict_set_count);
1979   hd = keydb_new ();
1980   for (i = 0, iter = conflict_set;
1981        i < conflict_set_count;
1982        i ++, iter = iter->next)
1983     {
1984       char *fp = iter->d;
1985       KEYDB_SEARCH_DESC desc;
1986       kbnode_t kb;
1987       PKT_public_key *binding_pk;
1988       kbnode_t n;
1989       int found_user_id;
1990
1991       rc = keydb_search_reset (hd);
1992       if (rc)
1993         {
1994           log_error (_("resetting keydb: %s\n"),
1995                      gpg_strerror (rc));
1996           continue;
1997         }
1998
1999       rc = classify_user_id (fp, &desc, 0);
2000       if (rc)
2001         {
2002           log_error (_("error parsing key specification '%s': %s\n"),
2003                      fp, gpg_strerror (rc));
2004           continue;
2005         }
2006
2007       rc = keydb_search (hd, &desc, 1, NULL);
2008       if (rc)
2009         {
2010           /* Note: it is entirely possible that we don't have the key
2011              corresponding to an entry in the TOFU DB.  This can
2012              happen if we merge two TOFU DBs, but not the key
2013              rings.  */
2014           log_info (_("key \"%s\" not found: %s\n"),
2015                     fp, gpg_strerror (rc));
2016           continue;
2017         }
2018
2019       rc = keydb_get_keyblock (hd, &kb);
2020       if (rc)
2021         {
2022           log_error (_("error reading keyblock: %s\n"),
2023                      gpg_strerror (rc));
2024           print_further_info ("fingerprint: %s", fp);
2025           continue;
2026         }
2027
2028       merge_keys_and_selfsig (kb);
2029
2030       log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2031
2032       kb_all[i] = kb;
2033
2034       /* Since we have the key block, use this opportunity to figure
2035        * out if the binding is expired or revoked.  */
2036       binding_pk = kb->pkt->pkt.public_key;
2037
2038       /* The binding is always expired/revoked if the key is
2039        * expired/revoked.  */
2040       if (binding_pk->has_expired)
2041         iter->flags |= BINDING_EXPIRED;
2042       if (binding_pk->flags.revoked)
2043         iter->flags |= BINDING_REVOKED;
2044
2045       /* The binding is also expired/revoked if the user id is
2046        * expired/revoked.  */
2047       n = kb;
2048       found_user_id = 0;
2049       while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
2050         {
2051           PKT_user_id *user_id2 = n->pkt->pkt.user_id;
2052           char *email2;
2053
2054           if (user_id2->attrib_data)
2055             continue;
2056
2057           email2 = email_from_user_id (user_id2->name);
2058
2059           if (strcmp (email, email2) == 0)
2060             {
2061               found_user_id = 1;
2062
2063               if (user_id2->is_revoked)
2064                 iter->flags |= BINDING_REVOKED;
2065               if (user_id2->is_expired)
2066                 iter->flags |= BINDING_EXPIRED;
2067             }
2068
2069           xfree (email2);
2070         }
2071
2072       if (! found_user_id)
2073         {
2074           log_info (_("TOFU db corruption detected.\n"));
2075           print_further_info ("user id '%s' not on key block '%s'",
2076                               email, fingerprint);
2077         }
2078     }
2079   keydb_release (hd);
2080
2081   /* Now that we have the key blocks, check for cross sigs.  */
2082   {
2083     int j;
2084     strlist_t *prevp;
2085     strlist_t iter_next;
2086     int die[conflict_set_count];
2087
2088     memset (die, 0, sizeof (die));
2089
2090     for (i = 0; i < conflict_set_count; i ++)
2091       {
2092         /* Look for cross sigs between this key (i == 0) or a key
2093          * that has cross sigs with i == 0 (i.e., transitively) */
2094         if (! (i == 0 || die[i]))
2095           continue;
2096
2097         for (j = i + 1; j < conflict_set_count; j ++)
2098           /* Be careful: we might not have a key block for a key.  */
2099           if (kb_all[i] && kb_all[j] && cross_sigs (email, kb_all[i], kb_all[j]))
2100             die[j] = 1;
2101       }
2102
2103     /* Free unconflicting bindings (and all of the key blocks).  */
2104     for (iter = conflict_set, prevp = &conflict_set, i = 0;
2105          iter;
2106          iter = iter_next, i ++)
2107       {
2108         iter_next = iter->next;
2109
2110         release_kbnode (kb_all[i]);
2111
2112         if (die[i])
2113           {
2114             *prevp = iter_next;
2115             iter->next = NULL;
2116             free_strlist (iter);
2117             conflict_set_count --;
2118           }
2119         else
2120           {
2121             prevp = &iter->next;
2122           }
2123       }
2124
2125     /* We shouldn't have removed the head.  */
2126     log_assert (conflict_set);
2127     log_assert (conflict_set_count >= 1);
2128   }
2129   xfree (kb_all);
2130
2131   if (DBG_TRUST)
2132     {
2133       log_debug ("binding <key: %s, email: %s> conflicts:\n",
2134                  fingerprint, email);
2135       for (iter = conflict_set; iter; iter = iter->next)
2136         {
2137           log_debug ("  %s:%s%s%s%s\n",
2138                      iter->d,
2139                      (iter->flags & BINDING_NEW) ? " new" : "",
2140                      (iter->flags & BINDING_CONFLICT) ? " known_conflict" : "",
2141                      (iter->flags & BINDING_EXPIRED) ? " expired" : "",
2142                      (iter->flags & BINDING_REVOKED) ? " revoked" : "");
2143         }
2144     }
2145
2146   return conflict_set;
2147 }
2148
2149
2150 /* Return the trust level (TRUST_NEVER, etc.) for the binding
2151  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
2152  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
2153  * returns _tofu_GET_TRUST_ERROR.
2154  *
2155  * PK is the public key object for FINGERPRINT.
2156  *
2157  * USER_ID is the unadulterated user id.
2158  *
2159  * If MAY_ASK is set, then we may interact with the user.  This is
2160  * necessary if there is a conflict or the binding's policy is
2161  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
2162  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
2163  * we return TRUST_UNDEFINED.  Note: if MAY_ASK is set, then this
2164  * function must not be called while in a transaction!  */
2165 static enum tofu_policy
2166 get_trust (ctrl_t ctrl, PKT_public_key *pk,
2167            const char *fingerprint, const char *email,
2168            const char *user_id, int may_ask, time_t now)
2169 {
2170   tofu_dbs_t dbs = ctrl->tofu.dbs;
2171   int in_transaction = 0;
2172   enum tofu_policy policy;
2173   int rc;
2174   char *sqerr = NULL;
2175   int change_conflicting_to_ask = 0;
2176   strlist_t conflict_set = NULL;
2177   int conflict_set_count;
2178   int trust_level = TRUST_UNKNOWN;
2179   strlist_t iter;
2180
2181   log_assert (dbs);
2182
2183   if (may_ask)
2184     log_assert (dbs->in_transaction == 0);
2185
2186   if (opt.batch)
2187     may_ask = 0;
2188
2189   log_assert (pk_is_primary (pk));
2190
2191   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
2192      levels.  */
2193   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
2194               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
2195               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
2196               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
2197               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
2198               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
2199               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
2200
2201   begin_transaction (ctrl, 0);
2202   in_transaction = 1;
2203
2204   policy = get_policy (dbs, fingerprint, email, NULL);
2205   {
2206     /* See if the key is ultimately trusted.  If so, we're done.  */
2207     u32 kid[2];
2208
2209     keyid_from_pk (pk, kid);
2210
2211     if (tdb_keyid_is_utk (kid))
2212       {
2213         if (policy == TOFU_POLICY_NONE)
2214           /* New binding.  */
2215           {
2216             if (record_binding (dbs, fingerprint, email, user_id,
2217                                 TOFU_POLICY_GOOD, NULL, 0, now) != 0)
2218               {
2219                 log_error (_("error setting TOFU binding's trust level"
2220                              " to %s\n"), "good");
2221                 trust_level = _tofu_GET_TRUST_ERROR;
2222                 goto out;
2223               }
2224           }
2225
2226         trust_level = TRUST_ULTIMATE;
2227         goto out;
2228       }
2229   }
2230
2231   if (policy == TOFU_POLICY_AUTO)
2232     {
2233       policy = opt.tofu_default_policy;
2234       if (DBG_TRUST)
2235         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is"
2236                    " auto (default: %s).\n",
2237                    fingerprint, email,
2238                    tofu_policy_str (opt.tofu_default_policy));
2239     }
2240   switch (policy)
2241     {
2242     case TOFU_POLICY_AUTO:
2243     case TOFU_POLICY_GOOD:
2244     case TOFU_POLICY_UNKNOWN:
2245     case TOFU_POLICY_BAD:
2246       /* The saved judgement is auto -> auto, good, unknown or bad.
2247        * We don't need to ask the user anything.  */
2248       if (DBG_TRUST)
2249         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
2250                    fingerprint, email, tofu_policy_str (policy));
2251       trust_level = tofu_policy_to_trust_level (policy);
2252       goto out;
2253
2254     case TOFU_POLICY_ASK:
2255       /* We need to ask the user what to do.  Case #1 or #2 below.  */
2256       break;
2257
2258     case TOFU_POLICY_NONE:
2259       /* The binding is new, we need to check for conflicts.  Case #3
2260        * below.  */
2261       break;
2262
2263     case _tofu_GET_POLICY_ERROR:
2264       trust_level = _tofu_GET_TRUST_ERROR;
2265       goto out;
2266
2267     default:
2268       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
2269     }
2270
2271
2272   /* We get here if:
2273    *
2274    *   1. The saved policy is auto and the default policy is ask
2275    *      (get_policy() == TOFU_POLICY_AUTO
2276    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
2277    *
2278    *   2. The saved policy is ask (either last time the user selected
2279    *      accept once or reject once or there was a conflict and this
2280    *      binding's policy was changed from auto to ask)
2281    *      (policy == TOFU_POLICY_ASK), or,
2282    *
2283    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
2284    *      (need to check for a conflict).
2285    *
2286    * In summary: POLICY is ask or none.
2287    */
2288
2289   /* Before continuing, see if the key is signed by an ultimately
2290    * trusted key.  */
2291   {
2292     int fingerprint_raw_len = strlen (fingerprint) / 2;
2293     char fingerprint_raw[fingerprint_raw_len];
2294     int len = 0;
2295     int is_signed_by_utk = 0;
2296
2297     if (fingerprint_raw_len != 20
2298         || ((len = hex2bin (fingerprint,
2299                             fingerprint_raw, fingerprint_raw_len))
2300             != strlen (fingerprint)))
2301       {
2302         if (DBG_TRUST)
2303           log_debug ("TOFU: Bad fingerprint: %s (len: %zd, parsed: %d)\n",
2304                      fingerprint, strlen (fingerprint), len);
2305       }
2306     else
2307       {
2308         int lookup_err;
2309         kbnode_t kb;
2310
2311         lookup_err = get_pubkey_byfprint (NULL, &kb,
2312                                           fingerprint_raw,
2313                                           fingerprint_raw_len);
2314         if (lookup_err)
2315           {
2316             if (DBG_TRUST)
2317               log_debug ("TOFU: Looking up %s: %s\n",
2318                          fingerprint, gpg_strerror (lookup_err));
2319           }
2320         else
2321           {
2322             is_signed_by_utk = signed_by_utk (email, kb);
2323             release_kbnode (kb);
2324           }
2325       }
2326
2327     if (is_signed_by_utk)
2328       {
2329         if (record_binding (dbs, fingerprint, email, user_id,
2330                             TOFU_POLICY_GOOD, NULL, 0, now) != 0)
2331           {
2332             log_error (_("error setting TOFU binding's trust level"
2333                          " to %s\n"), "good");
2334             trust_level = _tofu_GET_TRUST_ERROR;
2335           }
2336         else
2337           trust_level = TRUST_FULLY;
2338
2339         goto out;
2340       }
2341   }
2342
2343
2344   /* Look for conflicts.  This is needed in all 3 cases.  */
2345   conflict_set = build_conflict_set (dbs, pk, fingerprint, email);
2346   conflict_set_count = strlist_length (conflict_set);
2347   if (conflict_set_count == 0)
2348     {
2349       /* We should always at least have the current binding.  */
2350       trust_level = _tofu_GET_TRUST_ERROR;
2351       goto out;
2352     }
2353
2354   if (conflict_set_count == 1
2355       && (conflict_set->flags & BINDING_NEW)
2356       && opt.tofu_default_policy != TOFU_POLICY_ASK)
2357     {
2358       /* We've never observed a binding with this email address and we
2359        * have a default policy, which is not to ask the user.  */
2360
2361       /* If we've seen this binding, then we've seen this email and
2362        * policy couldn't possibly be TOFU_POLICY_NONE.  */
2363       log_assert (policy == TOFU_POLICY_NONE);
2364
2365       if (DBG_TRUST)
2366         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
2367                    fingerprint, email);
2368
2369       if (record_binding (dbs, fingerprint, email, user_id,
2370                           TOFU_POLICY_AUTO, NULL, 0, now) != 0)
2371         {
2372           log_error (_("error setting TOFU binding's trust level to %s\n"),
2373                        "auto");
2374           trust_level = _tofu_GET_TRUST_ERROR;
2375           goto out;
2376         }
2377
2378       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
2379       goto out;
2380     }
2381
2382   if (conflict_set_count == 1
2383       && (conflict_set->flags & BINDING_CONFLICT))
2384     {
2385       /* No known conflicts now, but there was a conflict.  This means
2386        * at somepoint, there was a conflict and we changed this
2387        * binding's policy to ask and set the conflicting key.  The
2388        * conflict can go away if there is not a cross sig between the
2389        * two keys.  In this case, just silently clear the conflict and
2390        * reset the policy to auto.  */
2391
2392       log_assert (policy == TOFU_POLICY_ASK);
2393
2394       if (DBG_TRUST)
2395         log_debug ("TOFU: binding <key: %s, user id: %s> had a conflict, but it's been resolved (probably via  cross sig).\n",
2396                    fingerprint, email);
2397
2398       if (record_binding (dbs, fingerprint, email, user_id,
2399                           TOFU_POLICY_AUTO, NULL, 0, now) != 0)
2400         log_error (_("error setting TOFU binding's trust level to %s\n"),
2401                    "auto");
2402
2403       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
2404       goto out;
2405     }
2406
2407   /* We have a conflict.  Mark any conflicting bindings that have an
2408    * automatic policy as now requiring confirmation.  Note: we delay
2409    * this until after we ask for confirmation so that when the current
2410    * policy is printed, it is correct.  */
2411   change_conflicting_to_ask = 1;
2412
2413   if (! may_ask)
2414     {
2415       log_assert (policy == TOFU_POLICY_NONE || policy == TOFU_POLICY_ASK);
2416       if (policy == TOFU_POLICY_NONE)
2417         {
2418           /* We get here in the third case (no saved policy) and if
2419            * there is a conflict.  */
2420           if (record_binding (dbs, fingerprint, email, user_id,
2421                               TOFU_POLICY_ASK,
2422                               conflict_set && conflict_set->next
2423                               ? conflict_set->next->d : NULL,
2424                               0, now) != 0)
2425             log_error (_("error setting TOFU binding's trust level to %s\n"),
2426                        "ask");
2427         }
2428
2429       trust_level = TRUST_UNDEFINED;
2430       goto out;
2431     }
2432
2433   /* We can't be in a normal transaction in ask_about_binding.  */
2434   end_transaction (ctrl, 0);
2435   in_transaction = 0;
2436
2437   /* If we get here, we need to ask the user about the binding.  */
2438   ask_about_binding (ctrl,
2439                      &policy,
2440                      &trust_level,
2441                      conflict_set,
2442                      fingerprint,
2443                      email,
2444                      user_id,
2445                      now);
2446
2447  out:
2448
2449   if (change_conflicting_to_ask)
2450     {
2451       /* Mark any conflicting bindings that have an automatic policy as
2452        * now requiring confirmation.  */
2453
2454       if (! in_transaction)
2455         {
2456           begin_transaction (ctrl, 0);
2457           in_transaction = 1;
2458         }
2459
2460       /* If we weren't allowed to ask, also update this key as
2461        * conflicting with itself.  */
2462       for (iter = may_ask ? conflict_set->next : conflict_set;
2463            iter; iter = iter->next)
2464         {
2465           rc = gpgsql_exec_printf
2466             (dbs->db, NULL, NULL, &sqerr,
2467              "update bindings set policy = %d, conflict = %Q"
2468              " where email = %Q and fingerprint = %Q and policy = %d;",
2469              TOFU_POLICY_ASK, fingerprint,
2470              email, iter->d, TOFU_POLICY_AUTO);
2471           if (rc)
2472             {
2473               log_error (_("error changing TOFU policy: %s\n"), sqerr);
2474               print_further_info ("binding: <key: %s, user id: %s>",
2475                                   fingerprint, user_id);
2476               sqlite3_free (sqerr);
2477               sqerr = NULL;
2478               rc = gpg_error (GPG_ERR_GENERAL);
2479             }
2480           else if (DBG_TRUST)
2481             log_debug ("Set %s to conflict with %s\n",
2482                        iter->d, fingerprint);
2483         }
2484     }
2485
2486   if (in_transaction)
2487     end_transaction (ctrl, 0);
2488
2489   free_strlist (conflict_set);
2490
2491   return trust_level;
2492 }
2493
2494
2495 /* Return a malloced string of the form
2496  *    "7 months, 1 day, 5 minutes, 0 seconds"
2497  * The caller should replace all '~' in the returned string by a space
2498  * and also free the returned string.
2499  *
2500  * This is actually a bad hack which may not work correctly with all
2501  * languages.
2502  */
2503 static char *
2504 time_ago_str (long long int t)
2505 {
2506   estream_t fp;
2507   int years = 0;
2508   int months = 0;
2509   int days = 0;
2510   int hours = 0;
2511   int minutes = 0;
2512   int seconds = 0;
2513
2514   /* The number of units that we've printed so far.  */
2515   int count = 0;
2516   /* The first unit that we printed (year = 0, month = 1,
2517      etc.).  */
2518   int first = -1;
2519   /* The current unit.  */
2520   int i = 0;
2521
2522   char *str;
2523
2524   /* It would be nice to use a macro to do this, but gettext
2525      works on the unpreprocessed code.  */
2526 #define MIN_SECS (60)
2527 #define HOUR_SECS (60 * MIN_SECS)
2528 #define DAY_SECS (24 * HOUR_SECS)
2529 #define MONTH_SECS (30 * DAY_SECS)
2530 #define YEAR_SECS (365 * DAY_SECS)
2531
2532   if (t > YEAR_SECS)
2533     {
2534       years = t / YEAR_SECS;
2535       t -= years * YEAR_SECS;
2536     }
2537   if (t > MONTH_SECS)
2538     {
2539       months = t / MONTH_SECS;
2540       t -= months * MONTH_SECS;
2541     }
2542   if (t > DAY_SECS)
2543     {
2544       days = t / DAY_SECS;
2545       t -= days * DAY_SECS;
2546     }
2547   if (t > HOUR_SECS)
2548     {
2549       hours = t / HOUR_SECS;
2550       t -= hours * HOUR_SECS;
2551     }
2552   if (t > MIN_SECS)
2553     {
2554       minutes = t / MIN_SECS;
2555       t -= minutes * MIN_SECS;
2556     }
2557   seconds = t;
2558
2559 #undef MIN_SECS
2560 #undef HOUR_SECS
2561 #undef DAY_SECS
2562 #undef MONTH_SECS
2563 #undef YEAR_SECS
2564
2565   fp = es_fopenmem (0, "rw,samethread");
2566   if (! fp)
2567     log_fatal ("error creating memory stream: %s\n",
2568                gpg_strerror (gpg_error_from_syserror()));
2569
2570   if (years)
2571     {
2572       /* TRANSLATORS: The tilde ('~') is used here to indicate a
2573        * non-breakable space  */
2574       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
2575       count ++;
2576       first = i;
2577     }
2578   i ++;
2579   if ((first == -1 || i - first <= 3) && count <= 0 && months)
2580     {
2581       if (count)
2582         es_fprintf (fp, ", ");
2583       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
2584       count ++;
2585       first = i;
2586     }
2587   i ++;
2588   if ((first == -1 || i - first <= 3) && count <= 0 && days)
2589     {
2590       if (count)
2591         es_fprintf (fp, ", ");
2592       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
2593       count ++;
2594       first = i;
2595     }
2596   i ++;
2597   if ((first == -1 || i - first <= 3) && count <= 0 && hours)
2598     {
2599       if (count)
2600         es_fprintf (fp, ", ");
2601       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
2602       count ++;
2603       first = i;
2604     }
2605   i ++;
2606   if ((first == -1 || i - first <= 3) && count <= 0 && minutes)
2607     {
2608       if (count)
2609         es_fprintf (fp, ", ");
2610       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
2611       count ++;
2612       first = i;
2613     }
2614   i ++;
2615   if ((first == -1 || i - first <= 3) && count <= 0)
2616     {
2617       if (count)
2618         es_fprintf (fp, ", ");
2619       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
2620     }
2621
2622   es_fputc (0, fp);
2623   if (es_fclose_snatch (fp, (void **) &str, NULL))
2624     log_fatal ("error snatching memory stream\n");
2625
2626   return str;
2627 }
2628
2629
2630 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2631  * write a "tfs" record to that stream. */
2632 static void
2633 write_stats_status (estream_t fp,
2634                     enum tofu_policy policy,
2635                     unsigned long signature_count,
2636                     unsigned long signature_first_seen,
2637                     unsigned long signature_most_recent,
2638                     unsigned long encryption_count,
2639                     unsigned long encryption_first_done,
2640                     unsigned long encryption_most_recent)
2641 {
2642   const char *validity;
2643   unsigned long messages;
2644
2645   /* Use the euclidean distance (m = sqrt(a^2 + b^2)) rather then the
2646      sum of the magnitudes (m = a + b) to ensure a balance between
2647      verified signatures and encrypted messages.  */
2648   messages = sqrtu32 (signature_count * signature_count
2649                       + encryption_count * encryption_count);
2650
2651   if (messages < 1)
2652     validity = "1"; /* Key without history.  */
2653   else if (messages < 2 * BASIC_TRUST_THRESHOLD)
2654     validity = "2"; /* Key with too little history.  */
2655   else if (messages < 2 * FULL_TRUST_THRESHOLD)
2656     validity = "3"; /* Key with enough history for basic trust.  */
2657   else
2658     validity = "4"; /* Key with a lot of history.  */
2659
2660   if (fp)
2661     {
2662       es_fprintf (fp, "tfs:1:%s:%lu:%lu:%s:%lu:%lu:%lu:%lu:\n",
2663                   validity, signature_count, encryption_count,
2664                   tofu_policy_str (policy),
2665                   signature_first_seen, signature_most_recent,
2666                   encryption_first_done, encryption_most_recent);
2667     }
2668   else
2669     {
2670       write_status_printf (STATUS_TOFU_STATS,
2671                            "%s %lu %lu %s %lu %lu %lu %lu",
2672                            validity,
2673                            signature_count,
2674                            encryption_count,
2675                            tofu_policy_str (policy),
2676                            signature_first_seen,
2677                            signature_most_recent,
2678                            encryption_first_done,
2679                            encryption_most_recent);
2680     }
2681 }
2682
2683 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2684  * to OUTFP.  In this case USER_ID is not required.
2685  *
2686  * Returns whether the caller should call show_warning after iterating
2687  * over all user ids.
2688  */
2689 static int
2690 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
2691                  const char *email, const char *user_id,
2692                  estream_t outfp, time_t now)
2693 {
2694   enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2695
2696   char *fingerprint_pp;
2697   int rc;
2698   strlist_t strlist = NULL;
2699   char *err = NULL;
2700
2701   unsigned long signature_first_seen = 0;
2702   unsigned long signature_most_recent = 0;
2703   unsigned long signature_count = 0;
2704   unsigned long encryption_first_done = 0;
2705   unsigned long encryption_most_recent = 0;
2706   unsigned long encryption_count = 0;
2707
2708   int show_warning = 0;
2709
2710   (void) user_id;
2711
2712   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2713
2714   /* Get the signature stats.  */
2715   rc = gpgsql_exec_printf
2716     (dbs->db, strings_collect_cb, &strlist, &err,
2717      "select count (*), min (signatures.time), max (signatures.time)\n"
2718      " from signatures\n"
2719      " left join bindings on signatures.binding = bindings.oid\n"
2720      " where fingerprint = %Q and email = %Q;",
2721      fingerprint, email);
2722   if (rc)
2723     {
2724       log_error (_("error reading TOFU database: %s\n"), err);
2725       print_further_info ("getting signature statistics");
2726       sqlite3_free (err);
2727       rc = gpg_error (GPG_ERR_GENERAL);
2728       goto out;
2729     }
2730
2731   if (strlist)
2732     {
2733       /* We expect exactly 3 elements.  */
2734       log_assert (strlist->next);
2735       log_assert (strlist->next->next);
2736       log_assert (! strlist->next->next->next);
2737
2738       string_to_ulong (&signature_count, strlist->d, -1, __LINE__);
2739       string_to_ulong (&signature_first_seen, strlist->next->d, -1, __LINE__);
2740       string_to_ulong (&signature_most_recent,
2741                        strlist->next->next->d, -1, __LINE__);
2742
2743       free_strlist (strlist);
2744       strlist = NULL;
2745     }
2746
2747   /* Get the encryption stats.  */
2748   rc = gpgsql_exec_printf
2749     (dbs->db, strings_collect_cb, &strlist, &err,
2750      "select count (*), min (encryptions.time), max (encryptions.time)\n"
2751      " from encryptions\n"
2752      " left join bindings on encryptions.binding = bindings.oid\n"
2753      " where fingerprint = %Q and email = %Q;",
2754      fingerprint, email);
2755   if (rc)
2756     {
2757       log_error (_("error reading TOFU database: %s\n"), err);
2758       print_further_info ("getting encryption statistics");
2759       sqlite3_free (err);
2760       rc = gpg_error (GPG_ERR_GENERAL);
2761       goto out;
2762     }
2763
2764   if (strlist)
2765     {
2766       /* We expect exactly 3 elements.  */
2767       log_assert (strlist->next);
2768       log_assert (strlist->next->next);
2769       log_assert (! strlist->next->next->next);
2770
2771       string_to_ulong (&encryption_count, strlist->d, -1, __LINE__);
2772       string_to_ulong (&encryption_first_done, strlist->next->d, -1, __LINE__);
2773       string_to_ulong (&encryption_most_recent,
2774                        strlist->next->next->d, -1, __LINE__);
2775
2776       free_strlist (strlist);
2777       strlist = NULL;
2778     }
2779
2780   if (!outfp)
2781     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
2782                                   email, strlen (email), 0);
2783
2784   write_stats_status (outfp, policy,
2785                       signature_count,
2786                       signature_first_seen,
2787                       signature_most_recent,
2788                       encryption_count,
2789                       encryption_first_done,
2790                       encryption_most_recent);
2791
2792   if (!outfp)
2793     {
2794       estream_t fp;
2795       char *msg;
2796
2797       fp = es_fopenmem (0, "rw,samethread");
2798       if (! fp)
2799         log_fatal ("error creating memory stream: %s\n",
2800                    gpg_strerror (gpg_error_from_syserror()));
2801
2802       es_fprintf (fp, _("%s: "), email);
2803
2804       if (signature_count == 0)
2805         {
2806           es_fprintf (fp, _("Verified %ld signatures"), 0L);
2807           es_fputc ('\n', fp);
2808         }
2809       else
2810         {
2811           char *first_seen_ago_str = time_ago_str (now - signature_first_seen);
2812
2813           /* TRANSLATORS: The final %s is replaced by a string like
2814              "7 months, 1 day, 5 minutes, 0 seconds". */
2815           es_fprintf (fp,
2816                       ngettext("Verified %ld signature in the past %s",
2817                                "Verified %ld signatures in the past %s",
2818                                signature_count),
2819                       signature_count, first_seen_ago_str);
2820
2821           xfree (first_seen_ago_str);
2822         }
2823
2824       if (encryption_count == 0)
2825         {
2826           es_fprintf (fp, _(", and encrypted %ld messages"), 0L);
2827         }
2828       else
2829         {
2830           char *first_done_ago_str = time_ago_str (now - encryption_first_done);
2831
2832           /* TRANSLATORS: The final %s is replaced by a string like
2833              "7 months, 1 day, 5 minutes, 0 seconds". */
2834           es_fprintf (fp,
2835                       ngettext(", and encrypted %ld message in the past %s",
2836                                ", and encrypted %ld messages in the past %s",
2837                                encryption_count),
2838                       encryption_count, first_done_ago_str);
2839
2840           xfree (first_done_ago_str);
2841         }
2842
2843       if (opt.verbose)
2844         {
2845           es_fputs ("  ", fp);
2846           es_fputc ('(', fp);
2847           es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2848           es_fputs (").\n", fp);
2849         }
2850       else
2851         es_fputs (".\n", fp);
2852
2853
2854       {
2855         char *tmpmsg, *p;
2856         es_fputc (0, fp);
2857         if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2858           log_fatal ("error snatching memory stream\n");
2859         msg = format_text (tmpmsg, 0, 72, 80);
2860         es_free (tmpmsg);
2861
2862         /* Print a status line but suppress the trailing LF.
2863          * Spaces are not percent escaped. */
2864         if (*msg)
2865           write_status_buffer (STATUS_TOFU_STATS_LONG,
2866                                msg, strlen (msg)-1, -1);
2867
2868         /* Remove the non-breaking space markers.  */
2869         for (p=msg; *p; p++)
2870           if (*p == '~')
2871             *p = ' ';
2872       }
2873
2874       log_string (GPGRT_LOG_INFO, msg);
2875       xfree (msg);
2876
2877       if (policy == TOFU_POLICY_AUTO)
2878         {
2879           if (signature_count == 0)
2880             log_info (_("Warning: we have yet to see"
2881                         " a message signed using this key and user id!\n"));
2882           else if (signature_count == 1)
2883             log_info (_("Warning: we've only seen one message"
2884                         " signed using this key and user id!\n"));
2885
2886           if (encryption_count == 0)
2887             log_info (_("Warning: you have yet to encrypt"
2888                         " a message to this key!\n"));
2889           else if (encryption_count == 1)
2890             log_info (_("Warning: you have only encrypted"
2891                         " one message to this key!\n"));
2892
2893           /* Cf. write_stats_status  */
2894           if (sqrtu32 (encryption_count * encryption_count
2895                        + signature_count * signature_count)
2896               < 2 * BASIC_TRUST_THRESHOLD)
2897             show_warning = 1;
2898         }
2899     }
2900
2901  out:
2902   xfree (fingerprint_pp);
2903
2904   return show_warning;
2905 }
2906
2907 static void
2908 show_warning (const char *fingerprint, strlist_t user_id_list)
2909 {
2910   char *set_policy_command;
2911   char *text;
2912   char *tmpmsg;
2913
2914   set_policy_command =
2915     xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2916
2917   tmpmsg = xasprintf
2918     (ngettext
2919      ("Warning: if you think you've seen more signatures "
2920       "by this key and user id, then this key might be a "
2921       "forgery!  Carefully examine the email address for small "
2922       "variations.  If the key is suspect, then use\n"
2923       "  %s\n"
2924       "to mark it as being bad.\n",
2925       "Warning: if you think you've seen more signatures "
2926       "by this key and these user ids, then this key might be a "
2927       "forgery!  Carefully examine the email addresses for small "
2928       "variations.  If the key is suspect, then use\n"
2929       "  %s\n"
2930       "to mark it as being bad.\n",
2931       strlist_length (user_id_list)),
2932      set_policy_command);
2933
2934   text = format_text (tmpmsg, 0, 72, 80);
2935   xfree (tmpmsg);
2936   log_string (GPGRT_LOG_INFO, text);
2937   xfree (text);
2938
2939   es_free (set_policy_command);
2940 }
2941
2942
2943 /* Extract the email address from a user id and normalize it.  If the
2944    user id doesn't contain an email address, then we use the whole
2945    user_id and normalize that.  The returned string must be freed.  */
2946 static char *
2947 email_from_user_id (const char *user_id)
2948 {
2949   char *email = mailbox_from_userid (user_id);
2950   if (! email)
2951     {
2952       /* Hmm, no email address was provided or we are out of core.  Just
2953          take the lower-case version of the whole user id.  It could be
2954          a hostname, for instance.  */
2955       email = ascii_strlwr (xstrdup (user_id));
2956     }
2957
2958   return email;
2959 }
2960
2961 /* Register the signature with the bindings <fingerprint, USER_ID>,
2962    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2963    the primary key packet PK.
2964
2965    SIG_DIGEST_BIN is the binary representation of the message's
2966    digest.  SIG_DIGEST_BIN_LEN is its length.
2967
2968    SIG_TIME is the time that the signature was generated.
2969
2970    ORIGIN is a free-formed string describing the origin of the
2971    signature.  If this was from an email and the Claws MUA was used,
2972    then this should be something like: "email:claws".  If this is
2973    NULL, the default is simply "unknown".
2974
2975    If MAY_ASK is 1, then this function may interact with the user.
2976    This is necessary if there is a conflict or the binding's policy is
2977    TOFU_POLICY_ASK.
2978
2979    This function returns 0 on success and an error code if an error
2980    occurred.  */
2981 gpg_error_t
2982 tofu_register_signature (ctrl_t ctrl,
2983                          PKT_public_key *pk, strlist_t user_id_list,
2984                          const byte *sig_digest_bin, int sig_digest_bin_len,
2985                          time_t sig_time, const char *origin)
2986 {
2987   time_t now = gnupg_get_time ();
2988   gpg_error_t rc;
2989   tofu_dbs_t dbs;
2990   char *fingerprint = NULL;
2991   strlist_t user_id;
2992   char *email = NULL;
2993   char *err = NULL;
2994   char *sig_digest;
2995   unsigned long c;
2996
2997   dbs = opendbs (ctrl);
2998   if (! dbs)
2999     {
3000       rc = gpg_error (GPG_ERR_GENERAL);
3001       log_error (_("error opening TOFU database: %s\n"),
3002                  gpg_strerror (rc));
3003       return rc;
3004     }
3005
3006   /* We do a query and then an insert.  Make sure they are atomic
3007      by wrapping them in a transaction.  */
3008   rc = begin_transaction (ctrl, 0);
3009   if (rc)
3010     return rc;
3011
3012   log_assert (pk_is_primary (pk));
3013
3014   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
3015   fingerprint = hexfingerprint (pk, NULL, 0);
3016
3017   if (! origin)
3018     /* The default origin is simply "unknown".  */
3019     origin = "unknown";
3020
3021   for (user_id = user_id_list; user_id; user_id = user_id->next)
3022     {
3023       email = email_from_user_id (user_id->d);
3024
3025       if (DBG_TRUST)
3026         log_debug ("TOFU: Registering signature %s with binding"
3027                    " <key: %s, user id: %s>\n",
3028                    sig_digest, fingerprint, email);
3029
3030       /* Make sure the binding exists and record any TOFU
3031          conflicts.  */
3032       if (get_trust (ctrl, pk, fingerprint, email, user_id->d, 0, now)
3033           == _tofu_GET_TRUST_ERROR)
3034         {
3035           rc = gpg_error (GPG_ERR_GENERAL);
3036           xfree (email);
3037           break;
3038         }
3039
3040       /* If we've already seen this signature before, then don't add
3041          it again.  */
3042       rc = gpgsql_stepx
3043         (dbs->db, &dbs->s.register_already_seen,
3044          get_single_unsigned_long_cb2, &c, &err,
3045          "select count (*)\n"
3046          " from signatures left join bindings\n"
3047          "  on signatures.binding = bindings.oid\n"
3048          " where fingerprint = ? and email = ? and sig_time = ?\n"
3049          "  and sig_digest = ?",
3050          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3051          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3052          GPGSQL_ARG_STRING, sig_digest,
3053          GPGSQL_ARG_END);
3054       if (rc)
3055         {
3056           log_error (_("error reading TOFU database: %s\n"), err);
3057           print_further_info ("checking existence");
3058           sqlite3_free (err);
3059           rc = gpg_error (GPG_ERR_GENERAL);
3060         }
3061       else if (c > 1)
3062         /* Duplicates!  This should not happen.  In particular,
3063            because <fingerprint, email, sig_time, sig_digest> is the
3064            primary key!  */
3065         log_debug ("SIGNATURES DB contains duplicate records"
3066                    " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3067                    " origin: %s>."
3068                    "  Please report.\n",
3069                    fingerprint, email, (unsigned long) sig_time,
3070                    sig_digest, origin);
3071       else if (c == 1)
3072         {
3073           if (DBG_TRUST)
3074             log_debug ("Already observed the signature and binding"
3075                        " <key: %s, email: %s, time: 0x%lx, sig: %s,"
3076                        " origin: %s>\n",
3077                        fingerprint, email, (unsigned long) sig_time,
3078                        sig_digest, origin);
3079         }
3080       else if (opt.dry_run)
3081         {
3082           log_info ("TOFU database update skipped due to --dry-run\n");
3083         }
3084       else
3085         /* This is the first time that we've seen this signature and
3086            binding.  Record it.  */
3087         {
3088           if (DBG_TRUST)
3089             log_debug ("TOFU: Saving signature"
3090                        " <key: %s, user id: %s, sig: %s>\n",
3091                        fingerprint, email, sig_digest);
3092
3093           log_assert (c == 0);
3094
3095           rc = gpgsql_stepx
3096             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
3097              "insert into signatures\n"
3098              " (binding, sig_digest, origin, sig_time, time)\n"
3099              " values\n"
3100              " ((select oid from bindings\n"
3101              "    where fingerprint = ? and email = ?),\n"
3102              "  ?, ?, ?, ?);",
3103              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3104              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
3105              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
3106              GPGSQL_ARG_LONG_LONG, (long long) now,
3107              GPGSQL_ARG_END);
3108           if (rc)
3109             {
3110               log_error (_("error updating TOFU database: %s\n"), err);
3111               print_further_info ("insert signatures");
3112               sqlite3_free (err);
3113               rc = gpg_error (GPG_ERR_GENERAL);
3114             }
3115         }
3116
3117       xfree (email);
3118
3119       if (rc)
3120         break;
3121     }
3122
3123   if (rc)
3124     rollback_transaction (ctrl);
3125   else
3126     rc = end_transaction (ctrl, 0);
3127
3128   xfree (fingerprint);
3129   xfree (sig_digest);
3130
3131   return rc;
3132 }
3133
3134 gpg_error_t
3135 tofu_register_encryption (ctrl_t ctrl,
3136                           PKT_public_key *pk, strlist_t user_id_list,
3137                           int may_ask)
3138 {
3139   time_t now = gnupg_get_time ();
3140   gpg_error_t rc = 0;
3141   tofu_dbs_t dbs;
3142   kbnode_t kb = NULL;
3143   int free_user_id_list = 0;
3144   char *fingerprint = NULL;
3145   strlist_t user_id;
3146   char *err = NULL;
3147
3148   dbs = opendbs (ctrl);
3149   if (! dbs)
3150     {
3151       rc = gpg_error (GPG_ERR_GENERAL);
3152       log_error (_("error opening TOFU database: %s\n"),
3153                  gpg_strerror (rc));
3154       return rc;
3155     }
3156
3157   if (/* We need the key block to find the primary key.  */
3158       ! pk_is_primary (pk)
3159       /* We need the key block to find all user ids.  */
3160       || ! user_id_list)
3161     kb = get_pubkeyblock (pk->keyid);
3162
3163   /* Make sure PK is a primary key.  */
3164   if (! pk_is_primary (pk))
3165     pk = kb->pkt->pkt.public_key;
3166
3167   if (! user_id_list)
3168     {
3169       /* Use all non-revoked user ids.  Do use expired user ids.  */
3170       kbnode_t n = kb;
3171
3172       while ((n = find_next_kbnode (n, PKT_USER_ID)))
3173         {
3174           PKT_user_id *uid = n->pkt->pkt.user_id;
3175
3176           if (uid->is_revoked)
3177             continue;
3178
3179           add_to_strlist (&user_id_list, uid->name);
3180         }
3181
3182       free_user_id_list = 1;
3183
3184       if (! user_id_list)
3185         log_info (_("WARNING: Encrypting to %s, which has no"
3186                     "non-revoked user ids.\n"),
3187                   keystr (pk->keyid));
3188     }
3189
3190   fingerprint = hexfingerprint (pk, NULL, 0);
3191
3192   tofu_begin_batch_update (ctrl);
3193   tofu_resume_batch_transaction (ctrl);
3194
3195   for (user_id = user_id_list; user_id; user_id = user_id->next)
3196     {
3197       char *email = email_from_user_id (user_id->d);
3198
3199       /* Make sure the binding exists and that we recognize any
3200          conflicts.  */
3201       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3202                           may_ask, now);
3203       if (tl == _tofu_GET_TRUST_ERROR)
3204         {
3205           /* An error.  */
3206           rc = gpg_error (GPG_ERR_GENERAL);
3207           xfree (email);
3208           goto die;
3209         }
3210
3211       rc = gpgsql_stepx
3212         (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
3213          "insert into encryptions\n"
3214          " (binding, time)\n"
3215          " values\n"
3216          " ((select oid from bindings\n"
3217          "    where fingerprint = ? and email = ?),\n"
3218          "  ?);",
3219          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
3220          GPGSQL_ARG_LONG_LONG, (long long) now,
3221          GPGSQL_ARG_END);
3222       if (rc)
3223         {
3224           log_error (_("error updating TOFU database: %s\n"), err);
3225           print_further_info ("insert encryption");
3226           sqlite3_free (err);
3227           rc = gpg_error (GPG_ERR_GENERAL);
3228         }
3229
3230       xfree (email);
3231     }
3232
3233  die:
3234   tofu_end_batch_update (ctrl);
3235
3236   if (kb)
3237     release_kbnode (kb);
3238
3239   if (free_user_id_list)
3240     free_strlist (user_id_list);
3241
3242   xfree (fingerprint);
3243
3244   return rc;
3245 }
3246
3247
3248 /* Combine a trust level returned from the TOFU trust model with a
3249    trust level returned by the PGP trust model.  This is primarily of
3250    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
3251
3252    This function ors together the upper bits (the values not covered
3253    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
3254 int
3255 tofu_wot_trust_combine (int tofu_base, int wot_base)
3256 {
3257   int tofu = tofu_base & TRUST_MASK;
3258   int wot = wot_base & TRUST_MASK;
3259   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
3260
3261   log_assert (tofu == TRUST_UNKNOWN
3262               || tofu == TRUST_EXPIRED
3263               || tofu == TRUST_UNDEFINED
3264               || tofu == TRUST_NEVER
3265               || tofu == TRUST_MARGINAL
3266               || tofu == TRUST_FULLY
3267               || tofu == TRUST_ULTIMATE);
3268   log_assert (wot == TRUST_UNKNOWN
3269               || wot == TRUST_EXPIRED
3270               || wot == TRUST_UNDEFINED
3271               || wot == TRUST_NEVER
3272               || wot == TRUST_MARGINAL
3273               || wot == TRUST_FULLY
3274               || wot == TRUST_ULTIMATE);
3275
3276   /* We first consider negative trust policys.  These trump positive
3277      trust policies.  */
3278   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
3279     /* TRUST_NEVER trumps everything else.  */
3280     return upper | TRUST_NEVER;
3281   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
3282     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
3283     return upper | TRUST_EXPIRED;
3284
3285   /* Now we only have positive or neutral trust policies.  We take
3286      the max.  */
3287   if (tofu == TRUST_ULTIMATE)
3288     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
3289   if (wot == TRUST_ULTIMATE)
3290     return upper | TRUST_ULTIMATE;
3291
3292   if (tofu == TRUST_FULLY)
3293     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
3294   if (wot == TRUST_FULLY)
3295     return upper | TRUST_FULLY;
3296
3297   if (tofu == TRUST_MARGINAL)
3298     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
3299   if (wot == TRUST_MARGINAL)
3300     return upper | TRUST_MARGINAL;
3301
3302   if (tofu == TRUST_UNDEFINED)
3303     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
3304   if (wot == TRUST_UNDEFINED)
3305     return upper | TRUST_UNDEFINED;
3306
3307   return upper | TRUST_UNKNOWN;
3308 }
3309
3310
3311 /* Write a "tfs" record for a --with-colons listing.  */
3312 gpg_error_t
3313 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
3314                        PKT_public_key *pk, const char *user_id)
3315 {
3316   time_t now = gnupg_get_time ();
3317   gpg_error_t err;
3318   tofu_dbs_t dbs;
3319   char *fingerprint;
3320   char *email;
3321
3322   if (!*user_id)
3323     return 0;  /* No TOFU stats possible for an empty ID.  */
3324
3325   dbs = opendbs (ctrl);
3326   if (!dbs)
3327     {
3328       err = gpg_error (GPG_ERR_GENERAL);
3329       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
3330       return err;
3331     }
3332
3333   fingerprint = hexfingerprint (pk, NULL, 0);
3334   email = email_from_user_id (user_id);
3335
3336   show_statistics (dbs, fingerprint, email, user_id, fp, now);
3337
3338   xfree (email);
3339   xfree (fingerprint);
3340   return 0;
3341 }
3342
3343
3344 /* Return the validity (TRUST_NEVER, etc.) of the bindings
3345    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
3346    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
3347
3348    PK is the primary key packet.
3349
3350    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
3351    will be prompted to choose a policy.  If MAY_ASK is 0 and the
3352    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
3353
3354    Returns TRUST_UNDEFINED if an error occurs.  */
3355 int
3356 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
3357                    int may_ask)
3358 {
3359   time_t now = gnupg_get_time ();
3360   tofu_dbs_t dbs;
3361   char *fingerprint = NULL;
3362   strlist_t user_id;
3363   int trust_level = TRUST_UNKNOWN;
3364   int bindings = 0;
3365   int bindings_valid = 0;
3366   int need_warning = 0;
3367
3368   dbs = opendbs (ctrl);
3369   if (! dbs)
3370     {
3371       log_error (_("error opening TOFU database: %s\n"),
3372                  gpg_strerror (GPG_ERR_GENERAL));
3373       return TRUST_UNDEFINED;
3374     }
3375
3376   fingerprint = hexfingerprint (pk, NULL, 0);
3377
3378   tofu_begin_batch_update (ctrl);
3379   /* Start the batch transaction now.  */
3380   tofu_resume_batch_transaction (ctrl);
3381
3382   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
3383     {
3384       char *email = email_from_user_id (user_id->d);
3385
3386       /* Always call get_trust to make sure the binding is
3387          registered.  */
3388       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d,
3389                           may_ask, now);
3390       if (tl == _tofu_GET_TRUST_ERROR)
3391         {
3392           /* An error.  */
3393           trust_level = TRUST_UNDEFINED;
3394           xfree (email);
3395           goto die;
3396         }
3397
3398       if (DBG_TRUST)
3399         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
3400                    fingerprint, email,
3401                    trust_value_to_string (tl),
3402                    user_id->flags ? " (but expired)" : "");
3403
3404       if (user_id->flags)
3405         tl = TRUST_EXPIRED;
3406
3407       if (tl != TRUST_EXPIRED)
3408         bindings_valid ++;
3409
3410       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
3411         need_warning |=
3412           show_statistics (dbs, fingerprint, email, user_id->d, NULL, now);
3413
3414       if (tl == TRUST_NEVER)
3415         trust_level = TRUST_NEVER;
3416       else if (tl == TRUST_EXPIRED)
3417         /* Ignore expired bindings in the trust calculation.  */
3418         ;
3419       else if (tl > trust_level)
3420         {
3421           /* The expected values: */
3422           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
3423                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
3424                       || tl == TRUST_ULTIMATE);
3425
3426           /* We assume the following ordering:  */
3427           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
3428           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
3429           log_assert (TRUST_MARGINAL < TRUST_FULLY);
3430           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
3431
3432           trust_level = tl;
3433         }
3434
3435       xfree (email);
3436     }
3437
3438   if (need_warning)
3439     show_warning (fingerprint, user_id_list);
3440
3441  die:
3442   tofu_end_batch_update (ctrl);
3443
3444   xfree (fingerprint);
3445
3446   if (bindings_valid == 0)
3447     {
3448       if (DBG_TRUST)
3449         log_debug ("no (of %d) valid bindings."
3450                    "  Can't get TOFU validity for this set of user ids.\n",
3451                    bindings);
3452       return TRUST_NEVER;
3453     }
3454
3455   return trust_level;
3456 }
3457
3458 /* Set the policy for all non-revoked user ids in the keyblock KB to
3459    POLICY.
3460
3461    If no key is available with the specified key id, then this
3462    function returns GPG_ERR_NO_PUBKEY.
3463
3464    Returns 0 on success and an error code otherwise.  */
3465 gpg_error_t
3466 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
3467 {
3468   gpg_error_t err;
3469   time_t now = gnupg_get_time ();
3470   tofu_dbs_t dbs;
3471   PKT_public_key *pk;
3472   char *fingerprint = NULL;
3473
3474   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
3475   pk = kb->pkt->pkt.public_key;
3476
3477   dbs = opendbs (ctrl);
3478   if (! dbs)
3479     {
3480       log_error (_("error opening TOFU database: %s\n"),
3481                  gpg_strerror (GPG_ERR_GENERAL));
3482       return gpg_error (GPG_ERR_GENERAL);
3483     }
3484
3485   if (DBG_TRUST)
3486     log_debug ("Setting TOFU policy for %s to %s\n",
3487                keystr (pk->keyid), tofu_policy_str (policy));
3488   if (! pk_is_primary (pk))
3489     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
3490
3491   fingerprint = hexfingerprint (pk, NULL, 0);
3492
3493   begin_transaction (ctrl, 0);
3494
3495   for (; kb; kb = kb->next)
3496     {
3497       PKT_user_id *user_id;
3498       char *email;
3499
3500       if (kb->pkt->pkttype != PKT_USER_ID)
3501         continue;
3502
3503       user_id = kb->pkt->pkt.user_id;
3504       if (user_id->is_revoked)
3505         /* Skip revoked user ids.  (Don't skip expired user ids, the
3506            expiry can be changed.)  */
3507         continue;
3508
3509       email = email_from_user_id (user_id->name);
3510
3511       err = record_binding (dbs, fingerprint, email, user_id->name,
3512                             policy, NULL, 1, now);
3513       if (err)
3514         {
3515           log_error (_("error setting policy for key %s, user id \"%s\": %s"),
3516                      fingerprint, email, gpg_strerror (err));
3517           xfree (email);
3518           break;
3519         }
3520
3521       xfree (email);
3522     }
3523
3524   if (err)
3525     rollback_transaction (ctrl);
3526   else
3527     end_transaction (ctrl, 0);
3528
3529   xfree (fingerprint);
3530   return err;
3531 }
3532
3533 /* Set the TOFU policy for all non-revoked user ids in the KEY with
3534    the key id KEYID to POLICY.
3535
3536    If no key is available with the specified key id, then this
3537    function returns GPG_ERR_NO_PUBKEY.
3538
3539    Returns 0 on success and an error code otherwise.  */
3540 gpg_error_t
3541 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
3542 {
3543   kbnode_t keyblock = get_pubkeyblock (keyid);
3544   if (! keyblock)
3545     return gpg_error (GPG_ERR_NO_PUBKEY);
3546
3547   return tofu_set_policy (ctrl, keyblock, policy);
3548 }
3549
3550 /* Return the TOFU policy for the specified binding in *POLICY.  If no
3551    policy has been set for the binding, sets *POLICY to
3552    TOFU_POLICY_NONE.
3553
3554    PK is a primary public key and USER_ID is a user id.
3555
3556    Returns 0 on success and an error code otherwise.  */
3557 gpg_error_t
3558 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
3559                  enum tofu_policy *policy)
3560 {
3561   tofu_dbs_t dbs;
3562   char *fingerprint;
3563   char *email;
3564
3565   /* Make sure PK is a primary key.  */
3566   log_assert (pk_is_primary (pk));
3567
3568   dbs = opendbs (ctrl);
3569   if (! dbs)
3570     {
3571       log_error (_("error opening TOFU database: %s\n"),
3572                  gpg_strerror (GPG_ERR_GENERAL));
3573       return gpg_error (GPG_ERR_GENERAL);
3574     }
3575
3576   fingerprint = hexfingerprint (pk, NULL, 0);
3577
3578   email = email_from_user_id (user_id->name);
3579
3580   *policy = get_policy (dbs, fingerprint, email, NULL);
3581
3582   xfree (email);
3583   xfree (fingerprint);
3584   if (*policy == _tofu_GET_POLICY_ERROR)
3585     return gpg_error (GPG_ERR_GENERAL);
3586   return 0;
3587 }