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