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