g10: Correctly parameterize ngettext.
[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 *get_policy_select_policy_and_conflict;
83     sqlite3_stmt *get_trust_bindings_with_this_email;
84     sqlite3_stmt *get_trust_gather_other_user_ids;
85     sqlite3_stmt *get_trust_gather_signature_stats;
86     sqlite3_stmt *get_trust_gather_encryption_stats;
87     sqlite3_stmt *register_already_seen;
88     sqlite3_stmt *register_signature;
89     sqlite3_stmt *register_encryption;
90   } s;
91
92   int in_batch_transaction;
93   int in_transaction;
94   time_t batch_update_started;
95 };
96
97
98 #define STRINGIFY(s) STRINGIFY2(s)
99 #define STRINGIFY2(s) #s
100
101 /* The grouping parameters when collecting signature statistics.  */
102
103 /* If a message is signed a couple of hours in the future, just assume
104    some clock skew.  */
105 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
106 /* Days.  */
107 #define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
108 #define TIME_AGO_SMALL_THRESHOLD (7 * TIME_AGO_UNIT_SMALL)
109 /* Months.  */
110 #define TIME_AGO_UNIT_MEDIUM (30 * 24 * 60 * 60)
111 #define TIME_AGO_MEDIUM_THRESHOLD (2 * TIME_AGO_UNIT_MEDIUM)
112 /* Years.  */
113 #define TIME_AGO_UNIT_LARGE (365 * 24 * 60 * 60)
114 #define TIME_AGO_LARGE_THRESHOLD (2 * TIME_AGO_UNIT_LARGE)
115
116 /* Local prototypes.  */
117 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
118 static char *email_from_user_id (const char *user_id);
119
120
121 \f
122 const char *
123 tofu_policy_str (enum tofu_policy policy)
124 {
125   switch (policy)
126     {
127     case TOFU_POLICY_NONE: return "none";
128     case TOFU_POLICY_AUTO: return "auto";
129     case TOFU_POLICY_GOOD: return "good";
130     case TOFU_POLICY_UNKNOWN: return "unknown";
131     case TOFU_POLICY_BAD: return "bad";
132     case TOFU_POLICY_ASK: return "ask";
133     default: return "???";
134     }
135 }
136
137 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
138    (e.g., TRUST_BAD) in light of the current configuration.  */
139 int
140 tofu_policy_to_trust_level (enum tofu_policy policy)
141 {
142   if (policy == TOFU_POLICY_AUTO)
143     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
144     policy = opt.tofu_default_policy;
145
146   switch (policy)
147     {
148     case TOFU_POLICY_AUTO:
149       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
150          to marginal trust.  */
151       return TRUST_MARGINAL;
152     case TOFU_POLICY_GOOD:
153       return TRUST_FULLY;
154     case TOFU_POLICY_UNKNOWN:
155       return TRUST_UNKNOWN;
156     case TOFU_POLICY_BAD:
157       return TRUST_NEVER;
158     case TOFU_POLICY_ASK:
159       return TRUST_UNKNOWN;
160     default:
161       log_bug ("Bad value for trust policy: %d\n",
162                opt.tofu_default_policy);
163       return 0;
164     }
165 }
166
167
168 \f
169 /* Start a transaction on DB.  If ONLY_BATCH is set, then this will
170    start a batch transaction if we haven't started a batch transaction
171    and one has been requested.  */
172 static gpg_error_t
173 begin_transaction (ctrl_t ctrl, int only_batch)
174 {
175   tofu_dbs_t dbs = ctrl->tofu.dbs;
176   int rc;
177   char *err = NULL;
178
179   log_assert (dbs);
180
181   /* If we've been in batch update mode for a while (on average, more
182    * than 500 ms), to prevent starving other gpg processes, we drop
183    * and retake the batch lock.
184    *
185    * Note: if we wanted higher resolution, we could use
186    * npth_clock_gettime.  */
187   if (/* No real transactions.  */
188       dbs->in_transaction == 0
189       /* There is an open batch transaction.  */
190       && dbs->in_batch_transaction
191       /* And some time has gone by since it was started.  */
192       && dbs->batch_update_started != gnupg_get_time ())
193     {
194       struct stat statbuf;
195
196       /* If we are in a batch update, then batch updates better have
197          been enabled.  */
198       log_assert (ctrl->tofu.batch_updated_wanted);
199
200       /* Check if another process wants to run.  (We just ignore any
201        * stat failure.  A waiter might have to wait a bit longer, but
202        * otherwise there should be no impact.)  */
203       if (stat (dbs->want_lock_file, &statbuf) == 0
204           && statbuf.st_ctime != dbs->want_lock_file_ctime)
205         {
206           end_transaction (ctrl, 2);
207
208           /* Yield to allow another process a chance to run.  Note:
209            * testing suggests that anything less than a 100ms tends to
210            * not result in the other process getting the lock.  */
211           gnupg_usleep (100000);
212         }
213       else
214         dbs->batch_update_started = gnupg_get_time ();
215     }
216
217   if (/* We don't have an open batch transaction.  */
218       !dbs->in_batch_transaction
219       && (/* Batch mode is enabled or we are starting a new transaction.  */
220           ctrl->tofu.batch_updated_wanted || dbs->in_transaction == 0))
221     {
222       struct stat statbuf;
223
224       /* We are in batch mode, but we don't have an open batch
225        * transaction.  Since the batch save point must be the outer
226        * save point, it must be taken before the inner save point.  */
227       log_assert (dbs->in_transaction == 0);
228
229       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
230                           NULL, NULL, &err,
231                           "begin immediate transaction;", GPGSQL_ARG_END);
232       if (rc)
233         {
234           log_error (_("error beginning transaction on TOFU database: %s\n"),
235                      err);
236           sqlite3_free (err);
237           return gpg_error (GPG_ERR_GENERAL);
238         }
239
240       dbs->in_batch_transaction = 1;
241       dbs->batch_update_started = gnupg_get_time ();
242
243       if (stat (dbs->want_lock_file, &statbuf) == 0)
244         dbs->want_lock_file_ctime = statbuf.st_ctime;
245     }
246
247   if (only_batch)
248     return 0;
249
250   log_assert (dbs->in_transaction >= 0);
251   dbs->in_transaction ++;
252
253   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
254                            "savepoint inner%d;",
255                            dbs->in_transaction);
256   if (rc)
257     {
258       log_error (_("error beginning transaction on TOFU database: %s\n"),
259                  err);
260       sqlite3_free (err);
261       return gpg_error (GPG_ERR_GENERAL);
262     }
263
264   return 0;
265 }
266
267
268 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
269  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
270  * this ends any open batch transaction even if we are still in batch
271  * mode.  */
272 static gpg_error_t
273 end_transaction (ctrl_t ctrl, int only_batch)
274 {
275   tofu_dbs_t dbs = ctrl->tofu.dbs;
276   int rc;
277   char *err = NULL;
278
279   if (only_batch || (! only_batch && dbs->in_transaction == 1))
280     {
281       if (!dbs)
282         return 0;  /* Shortcut to allow for easier cleanup code.  */
283
284       /* If we are releasing the batch transaction, then we better not
285          be in a normal transaction.  */
286       if (only_batch)
287         log_assert (dbs->in_transaction == 0);
288
289       if (/* Batch mode disabled?  */
290           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
291           /* But, we still have an open batch transaction?  */
292           && dbs->in_batch_transaction)
293         {
294           /* The batch transaction is still in open, but we've left
295            * batch mode.  */
296           dbs->in_batch_transaction = 0;
297           dbs->in_transaction = 0;
298
299           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
300                              NULL, NULL, &err,
301                              "commit transaction;", GPGSQL_ARG_END);
302           if (rc)
303             {
304               log_error (_("error committing transaction on TOFU database: %s\n"),
305                          err);
306               sqlite3_free (err);
307               return gpg_error (GPG_ERR_GENERAL);
308             }
309
310           return 0;
311         }
312
313       if (only_batch)
314         return 0;
315     }
316
317   log_assert (dbs);
318   log_assert (dbs->in_transaction > 0);
319
320   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
321                            "release inner%d;", dbs->in_transaction);
322
323   dbs->in_transaction --;
324
325   if (rc)
326     {
327       log_error (_("error committing transaction on TOFU database: %s\n"),
328                  err);
329       sqlite3_free (err);
330       return gpg_error (GPG_ERR_GENERAL);
331     }
332
333   return 0;
334 }
335
336
337 static gpg_error_t
338 rollback_transaction (ctrl_t ctrl)
339 {
340   tofu_dbs_t dbs = ctrl->tofu.dbs;
341   int rc;
342   char *err = NULL;
343
344   log_assert (dbs);
345   log_assert (dbs->in_transaction > 0);
346
347   /* Be careful to not any progress made by closed transactions in
348      batch mode.  */
349   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
350                            "rollback to inner%d;",
351                            dbs->in_transaction);
352
353   dbs->in_transaction --;
354
355   if (rc)
356     {
357       log_error (_("error rolling back transaction on TOFU database: %s\n"),
358                  err);
359       sqlite3_free (err);
360       return gpg_error (GPG_ERR_GENERAL);
361     }
362
363   return 0;
364 }
365
366 void
367 tofu_begin_batch_update (ctrl_t ctrl)
368 {
369   ctrl->tofu.batch_updated_wanted ++;
370 }
371
372 void
373 tofu_end_batch_update (ctrl_t ctrl)
374 {
375   log_assert (ctrl->tofu.batch_updated_wanted > 0);
376   ctrl->tofu.batch_updated_wanted --;
377   end_transaction (ctrl, 1);
378 }
379
380 /* Suspend any extant batch transaction (it is safe to call this even
381    no batch transaction has been started).  Note: you cannot suspend a
382    batch transaction if you are in a normal transaction.  The batch
383    transaction can be resumed explicitly by calling
384    tofu_resume_batch_transaction or implicitly by starting a normal
385    transaction.  */
386 static void
387 tofu_suspend_batch_transaction (ctrl_t ctrl)
388 {
389   end_transaction (ctrl, 2);
390 }
391
392 /* Resume a batch transaction if there is no extant batch transaction
393    and one has been requested using tofu_begin_batch_transaction.  */
394 static void
395 tofu_resume_batch_transaction (ctrl_t ctrl)
396 {
397   begin_transaction (ctrl, 1);
398 }
399
400
401 \f
402 /* Wrapper around strtol which prints a warning in case of a
403  * conversion error.  On success the converted value is stored at
404  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
405  * and an error code is returned.  */
406 static gpg_error_t
407 string_to_long (long *r_value, const char *string, long fallback, int line)
408 {
409   gpg_error_t err;
410   char *tail = NULL;
411
412   gpg_err_set_errno (0);
413   *r_value = strtol (string, &tail, 0);
414   if (errno || !(!strcmp (tail, ".0") || !*tail))
415     {
416       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
417       log_debug ("%s:%d: "
418                  "strtol failed for DB returned string (tail=%.10s): %s\n",
419                  __FILE__, line, tail, gpg_strerror (err));
420       *r_value = fallback;
421     }
422   else
423     err = 0;
424
425   return err;
426 }
427
428
429 /* Wrapper around strtoul which prints a warning in case of a
430  * conversion error.  On success the converted value is stored at
431  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
432  * and an error code is returned.  */
433 static gpg_error_t
434 string_to_ulong (unsigned long *r_value, const char *string,
435                  unsigned long fallback, int line)
436 {
437   gpg_error_t err;
438   char *tail = NULL;
439
440   gpg_err_set_errno (0);
441   *r_value = strtoul (string, &tail, 0);
442   if (errno || !(!strcmp (tail, ".0") || !*tail))
443     {
444       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
445       log_debug ("%s:%d: "
446                  "strtoul failed for DB returned string (tail=%.10s): %s\n",
447                  __FILE__, line, tail, gpg_strerror (err));
448       *r_value = fallback;
449     }
450   else
451     err = 0;
452
453   return err;
454 }
455
456
457
458 /* Collect results of a select count (*) ...; style query.  Aborts if
459    the argument is not a valid integer (or real of the form X.0).  */
460 static int
461 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
462                              char **azColName)
463 {
464   unsigned long int *count = cookie;
465
466   (void) azColName;
467
468   log_assert (argc == 1);
469
470   if (string_to_ulong (count, argv[0], 0, __LINE__))
471     return 1; /* Abort.  */
472   return 0;
473 }
474
475 static int
476 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
477                              char **azColName, sqlite3_stmt *stmt)
478 {
479   (void) stmt;
480   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
481 }
482
483 /* We expect a single integer column whose name is "version".  COOKIE
484    must point to an int.  This function always aborts.  On error or a
485    if the version is bad, sets *VERSION to -1.  */
486 static int
487 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
488 {
489   int *version = cookie;
490
491   if (argc != 1 || strcmp (azColName[0], "version") != 0)
492     {
493       *version = -1;
494       return 1;
495     }
496
497   if (strcmp (argv[0], "1") == 0)
498     *version = 1;
499   else
500     {
501       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
502       *version = -1;
503     }
504
505   /* Don't run again.  */
506   return 1;
507 }
508
509
510 /* If the DB is new, initialize it.  Otherwise, check the DB's
511    version.
512
513    Return 0 if the database is okay and 1 otherwise.  */
514 static int
515 initdb (sqlite3 *db)
516 {
517   char *err = NULL;
518   int rc;
519   unsigned long int count;
520   int version = -1;
521
522   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
523   if (rc)
524     {
525       log_error (_("error beginning transaction on TOFU database: %s\n"),
526                  err);
527       sqlite3_free (err);
528       return 1;
529     }
530
531   /* If the DB has no tables, then assume this is a new DB that needs
532      to be initialized.  */
533   rc = sqlite3_exec (db,
534                      "select count(*) from sqlite_master where type='table';",
535                      get_single_unsigned_long_cb, &count, &err);
536   if (rc)
537     {
538       log_error (_("error reading TOFU database: %s\n"), err);
539       print_further_info ("query available tables");
540       sqlite3_free (err);
541       goto out;
542     }
543   else if (count != 0)
544     /* Assume that the DB is already initialized.  Make sure the
545        version is okay.  */
546     {
547       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
548                          &version, &err);
549       if (rc == SQLITE_ABORT && version == 1)
550         /* Happy, happy, joy, joy.  */
551         {
552           sqlite3_free (err);
553           rc = 0;
554           goto out;
555         }
556       else if (rc == SQLITE_ABORT && version == -1)
557         /* Unsupported version.  */
558         {
559           /* An error message was already displayed.  */
560           sqlite3_free (err);
561           goto out;
562         }
563       else if (rc)
564         /* Some error.  */
565         {
566           log_error (_("error determining TOFU database's version: %s\n"), err);
567           sqlite3_free (err);
568           goto out;
569         }
570       else
571         {
572           /* Unexpected success.  This can only happen if there are no
573              rows.  (select returned 0, but expected ABORT.)  */
574           log_error (_("error determining TOFU database's version: %s\n"),
575                      gpg_strerror (GPG_ERR_NO_DATA));
576           rc = 1;
577           goto out;
578         }
579     }
580
581   /* Create the version table.  */
582   rc = sqlite3_exec (db,
583                      "create table version (version INTEGER);",
584                      NULL, NULL, &err);
585   if (rc)
586     {
587       log_error (_("error initializing TOFU database: %s\n"), err);
588       print_further_info ("create version");
589       sqlite3_free (err);
590       goto out;
591     }
592
593   /* Initialize the version table, which contains a single integer
594      value.  */
595   rc = sqlite3_exec (db,
596                      "insert into version values (1);",
597                      NULL, NULL, &err);
598   if (rc)
599     {
600       log_error (_("error initializing TOFU database: %s\n"), err);
601       print_further_info ("insert version");
602       sqlite3_free (err);
603       goto out;
604     }
605
606   /* The list of <fingerprint, email> bindings and auxiliary data.
607    *
608    *  OID is a unique ID identifying this binding (and used by the
609    *    signatures table, see below).  Note: OIDs will never be
610    *    reused.
611    *
612    *  FINGERPRINT: The key's fingerprint.
613    *
614    *  EMAIL: The normalized email address.
615    *
616    *  USER_ID: The unmodified user id from which EMAIL was extracted.
617    *
618    *  TIME: The time this binding was first observed.
619    *
620    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
621    *
622    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
623    *    a binding <0xdeadbeef, foo@example.com> and then we observe
624    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
625    *    (they have the same email address).  When we observe the
626    *    latter binding, we warn the user about the conflict and ask
627    *    for a policy decision about the new binding.  We also change
628    *    the old binding's policy to ask if it was auto.  So that we
629    *     know why this occurred, we also set conflict to 0xbaddecaf.
630    */
631   rc = gpgsql_exec_printf
632       (db, NULL, NULL, &err,
633        "create table bindings\n"
634        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
635        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
636        "  policy INTEGER CHECK (policy in (%d, %d, %d, %d, %d)),\n"
637        "  conflict STRING,\n"
638        "  unique (fingerprint, email));\n"
639        "create index bindings_fingerprint_email\n"
640        " on bindings (fingerprint, email);\n"
641        "create index bindings_email on bindings (email);\n",
642        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
643        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
644   if (rc)
645     {
646       log_error (_("error initializing TOFU database: %s\n"), err);
647       print_further_info ("create bindings");
648       sqlite3_free (err);
649       goto out;
650     }
651
652   /* The signatures that we have observed.
653    *
654    * BINDING refers to a record in the bindings table, which
655    * describes the binding (i.e., this is a foreign key that
656    * references bindings.oid).
657    *
658    * SIG_DIGEST is the digest stored in the signature.
659    *
660    * SIG_TIME is the timestamp stored in the signature.
661    *
662    * ORIGIN is a free-form string that describes who fed this
663    * signature to GnuPG (e.g., email:claws).
664    *
665    * TIME is the time this signature was registered.  */
666   rc = sqlite3_exec (db,
667                          "create table signatures "
668                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
669                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
670                          "  primary key (binding, sig_digest, origin));",
671                          NULL, NULL, &err);
672   if (rc)
673     {
674       log_error (_("error initializing TOFU database: %s\n"), err);
675       print_further_info ("create signatures");
676       sqlite3_free (err);
677       goto out;
678     }
679
680  out:
681   if (! rc)
682     {
683       /* Early version of the v1 format did not include the encryption
684          table.  Add it.  */
685       sqlite3_exec (db,
686                     "create table if not exists encryptions"
687                     " (binding INTEGER NOT NULL,"
688                     "  time INTEGER);"
689                     "create index if not exists encryptions_binding"
690                     " on encryptions (binding);\n",
691                     NULL, NULL, &err);
692     }
693
694   if (rc)
695     {
696       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
697       if (rc)
698         {
699           log_error (_("error rolling back transaction on TOFU database: %s\n"),
700                      err);
701           sqlite3_free (err);
702         }
703       return 1;
704     }
705   else
706     {
707       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
708       if (rc)
709         {
710           log_error (_("error committing transaction on TOFU database: %s\n"),
711                      err);
712           sqlite3_free (err);
713           return 1;
714         }
715       return 0;
716     }
717 }
718
719 static int
720 busy_handler (void *cookie, int call_count)
721 {
722   ctrl_t ctrl = cookie;
723   tofu_dbs_t dbs = ctrl->tofu.dbs;
724
725   (void) call_count;
726
727   /* Update the lock file time stamp so that the current owner knows
728      that we want the lock.  */
729   if (dbs)
730     {
731       /* Note: we don't fail if we can't create the lock file: this
732          process will have to wait a bit longer, but otherwise nothing
733          horrible should happen.  */
734
735       int fd = open (dbs->want_lock_file, O_CREAT|O_WRONLY|O_TRUNC,
736                      S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR);
737       if (fd == -1)
738         log_debug ("TOFU: Error opening '%s': %s\n",
739                    dbs->want_lock_file, strerror (errno));
740       else
741         close (fd);
742     }
743
744   /* Call again.  */
745   return 1;
746 }
747
748 /* Create a new DB handle.  Returns NULL on error.  */
749 /* FIXME: Change to return an error code for better reporting by the
750    caller.  */
751 static tofu_dbs_t
752 opendbs (ctrl_t ctrl)
753 {
754   char *filename;
755   sqlite3 *db;
756   int rc;
757
758   if (!ctrl->tofu.dbs)
759     {
760       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
761
762       rc = sqlite3_open (filename, &db);
763       if (rc)
764         {
765           log_error (_("error opening TOFU database '%s': %s\n"),
766                      filename, sqlite3_errmsg (db));
767           /* Even if an error occurs, DB is guaranteed to be valid.  */
768           sqlite3_close (db);
769           db = NULL;
770         }
771
772       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
773          before failing.  */
774       if (db)
775         {
776           sqlite3_busy_timeout (db, 5 * 1000);
777           sqlite3_busy_handler (db, busy_handler, ctrl);
778         }
779
780       if (db && initdb (db))
781         {
782           sqlite3_close (db);
783           db = NULL;
784         }
785
786       if (db)
787         {
788           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
789           ctrl->tofu.dbs->db = db;
790           ctrl->tofu.dbs->want_lock_file = xasprintf ("%s-want-lock", filename);
791         }
792
793       xfree (filename);
794     }
795   else
796     log_assert (ctrl->tofu.dbs->db);
797
798   return ctrl->tofu.dbs;
799 }
800
801
802 /* Release all of the resources associated with the DB handle.  */
803 void
804 tofu_closedbs (ctrl_t ctrl)
805 {
806   tofu_dbs_t dbs;
807   sqlite3_stmt **statements;
808
809   dbs = ctrl->tofu.dbs;
810   if (!dbs)
811     return;  /* Not initialized.  */
812
813   log_assert (dbs->in_transaction == 0);
814
815   end_transaction (ctrl, 2);
816
817   /* Arghh, that is a surprising use of the struct.  */
818   for (statements = (void *) &dbs->s;
819        (void *) statements < (void *) &(&dbs->s)[1];
820        statements ++)
821     sqlite3_finalize (*statements);
822
823   sqlite3_close (dbs->db);
824   xfree (dbs->want_lock_file);
825   xfree (dbs);
826   ctrl->tofu.dbs = NULL;
827 }
828
829
830 /* Collect results of a select min (foo) ...; style query.  Aborts if
831    the argument is not a valid integer (or real of the form X.0).  */
832 static int
833 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
834 {
835   long *count = cookie;
836
837   (void) azColName;
838
839   log_assert (argc == 1);
840
841   if (string_to_long (count, argv[0], 0, __LINE__))
842     return 1; /* Abort.  */
843
844   return 0;
845 }
846
847 static int
848 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
849                      sqlite3_stmt *stmt)
850 {
851   (void) stmt;
852   return get_single_long_cb (cookie, argc, argv, azColName);
853 }
854
855 /* Record (or update) a trust policy about a (possibly new)
856    binding.
857
858    If SHOW_OLD is set, the binding's old policy is displayed.  */
859 static gpg_error_t
860 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
861                 const char *user_id, enum tofu_policy policy,
862                 const char *conflict,
863                 int show_old, time_t now)
864 {
865   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
866   gpg_error_t rc;
867   char *err = NULL;
868
869   if (! (policy == TOFU_POLICY_AUTO
870          || policy == TOFU_POLICY_GOOD
871          || policy == TOFU_POLICY_UNKNOWN
872          || policy == TOFU_POLICY_BAD
873          || policy == TOFU_POLICY_ASK))
874     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
875
876
877   if (DBG_TRUST || show_old)
878     {
879       /* Get the old policy.  Since this is just for informational
880        * purposes, there is no need to start a transaction or to die
881        * if there is a failure.  */
882
883       /* policy_old needs to be a long and not an enum tofu_policy,
884          because we pass it by reference to get_single_long_cb2, which
885          expects a long.  */
886       long policy_old = TOFU_POLICY_NONE;
887
888       rc = gpgsql_stepx
889         (dbs->db, &dbs->s.record_binding_get_old_policy,
890          get_single_long_cb2, &policy_old, &err,
891          "select policy from bindings where fingerprint = ? and email = ?",
892          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
893          GPGSQL_ARG_END);
894       if (rc)
895         {
896           log_debug ("TOFU: Error reading from binding database"
897                      " (reading policy for <key: %s, user id: %s>): %s\n",
898                      fingerprint, email, err);
899           sqlite3_free (err);
900         }
901
902       if (policy_old != TOFU_POLICY_NONE)
903         (show_old ? log_info : log_debug)
904           ("Changing TOFU trust policy for binding"
905            " <key: %s, user id: %s> from %s to %s.\n",
906            fingerprint, show_old ? user_id : email,
907            tofu_policy_str (policy_old),
908            tofu_policy_str (policy));
909       else
910         (show_old ? log_info : log_debug)
911           ("Setting TOFU trust policy for new binding"
912            " <key: %s, user id: %s> to %s.\n",
913            fingerprint, show_old ? user_id : email,
914            tofu_policy_str (policy));
915     }
916
917   if (opt.dry_run)
918     {
919       log_info ("TOFU database update skipped due to --dry-run\n");
920       rc = 0;
921       goto leave;
922     }
923
924   rc = gpgsql_stepx
925     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
926      "insert or replace into bindings\n"
927      " (oid, fingerprint, email, user_id, time, policy, conflict)\n"
928      " values (\n"
929      /* If we don't explicitly reuse the OID, then SQLite will
930         reallocate a new one.  We just need to search for the OID
931         based on the fingerprint and email since they are unique.  */
932      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
933      "  ?, ?, ?, ?, ?, ?);",
934      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
935      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
936      GPGSQL_ARG_STRING, user_id,
937      GPGSQL_ARG_LONG_LONG, (long long) now,
938      GPGSQL_ARG_INT, (int) policy,
939      GPGSQL_ARG_STRING, conflict ? conflict : "",
940      GPGSQL_ARG_END);
941   if (rc)
942     {
943       log_error (_("error updating TOFU database: %s\n"), err);
944       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
945                           fingerprint, email, tofu_policy_str (policy));
946       sqlite3_free (err);
947       goto leave;
948     }
949
950  leave:
951   xfree (fingerprint_pp);
952   return rc;
953 }
954
955
956 /* Collect the strings returned by a query in a simply string list.
957    Any NULL values are converted to the empty string.
958
959    If a result has 3 rows and each row contains two columns, then the
960    results are added to the list as follows (the value is parentheses
961    is the 1-based index in the final list):
962
963      row 1, col 2 (6)
964      row 1, col 1 (5)
965      row 2, col 2 (4)
966      row 2, col 1 (3)
967      row 3, col 2 (2)
968      row 3, col 1 (1)
969
970    This is because add_to_strlist pushes the results onto the front of
971    the list.  The end result is that the rows are backwards, but the
972    columns are in the expected order.  */
973 static int
974 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
975 {
976   int i;
977   strlist_t *strlist = cookie;
978
979   (void) azColName;
980
981   for (i = argc - 1; i >= 0; i --)
982     add_to_strlist (strlist, argv[i] ? argv[i] : "");
983
984   return 0;
985 }
986
987 static int
988 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
989                      sqlite3_stmt *stmt)
990 {
991   (void) stmt;
992   return strings_collect_cb (cookie, argc, argv, azColName);
993
994 }
995
996 /* Auxiliary data structure to collect statistics about
997    signatures.  */
998 struct signature_stats
999 {
1000   struct signature_stats *next;
1001
1002   /* The user-assigned policy for this binding.  */
1003   enum tofu_policy policy;
1004
1005   /* How long ago the signature was created (rounded to a multiple of
1006      TIME_AGO_UNIT_SMALL, etc.).  */
1007   long time_ago;
1008   /* Number of signatures during this time.  */
1009   unsigned long count;
1010
1011   /* If the corresponding key/user id has been expired / revoked.  */
1012   int is_expired;
1013   int is_revoked;
1014
1015   /* The key that generated this signature.  */
1016   char fingerprint[1];
1017 };
1018
1019 static void
1020 signature_stats_free (struct signature_stats *stats)
1021 {
1022   while (stats)
1023     {
1024       struct signature_stats *next = stats->next;
1025       xfree (stats);
1026       stats = next;
1027     }
1028 }
1029
1030 static void
1031 signature_stats_prepend (struct signature_stats **statsp,
1032                          const char *fingerprint,
1033                          enum tofu_policy policy,
1034                          long time_ago,
1035                          unsigned long count)
1036 {
1037   struct signature_stats *stats =
1038     xmalloc_clear (sizeof (*stats) + strlen (fingerprint));
1039
1040   stats->next = *statsp;
1041   *statsp = stats;
1042
1043   strcpy (stats->fingerprint, fingerprint);
1044   stats->policy = policy;
1045   stats->time_ago = time_ago;
1046   stats->count = count;
1047 }
1048
1049
1050 /* Process rows that contain the four columns:
1051
1052      <fingerprint, policy, time ago, count>.  */
1053 static int
1054 signature_stats_collect_cb (void *cookie, int argc, char **argv,
1055                             char **azColName, sqlite3_stmt *stmt)
1056 {
1057   struct signature_stats **statsp = cookie;
1058   int i = 0;
1059   enum tofu_policy policy;
1060   long time_ago;
1061   unsigned long count;
1062   long along;
1063
1064   (void) azColName;
1065   (void) stmt;
1066
1067   i ++;
1068
1069   if (string_to_long (&along, argv[i], 0, __LINE__))
1070     return 1;  /* Abort */
1071   policy = along;
1072   i ++;
1073
1074   if (! argv[i])
1075     time_ago = 0;
1076   else
1077     {
1078       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
1079         return 1; /* Abort.  */
1080     }
1081   i ++;
1082
1083   /* If time_ago is NULL, then we had no messages, but we still have a
1084      single row, which count(*) turns into 1.  */
1085   if (! argv[i - 1])
1086     count = 0;
1087   else
1088     {
1089       if (string_to_ulong (&count, argv[i], 0, __LINE__))
1090         return 1; /* Abort */
1091     }
1092   i ++;
1093
1094   log_assert (argc == i);
1095
1096   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1097
1098   return 0;
1099 }
1100
1101 /* Convert from seconds to time units.
1102
1103    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1104    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1105 signed long
1106 time_ago_scale (signed long t)
1107 {
1108   if (t < TIME_AGO_UNIT_MEDIUM)
1109     return t / TIME_AGO_UNIT_SMALL;
1110   if (t < TIME_AGO_UNIT_LARGE)
1111     return t / TIME_AGO_UNIT_MEDIUM;
1112   return t / TIME_AGO_UNIT_LARGE;
1113 }
1114
1115
1116 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1117    already been normalized) and any conflict information in *CONFLICT
1118    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1119    occurs.  */
1120 static enum tofu_policy
1121 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1122             char **conflict)
1123 {
1124   int rc;
1125   char *err = NULL;
1126   strlist_t strlist = NULL;
1127   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1128   long along;
1129
1130   /* Check if the <FINGERPRINT, EMAIL> binding is known
1131      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1132      still TOFU_POLICY_NONE after executing the query, then the
1133      result set was empty.)  */
1134   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1135                       strings_collect_cb2, &strlist, &err,
1136                       "select policy, conflict from bindings\n"
1137                       " where fingerprint = ? and email = ?",
1138                       GPGSQL_ARG_STRING, fingerprint,
1139                       GPGSQL_ARG_STRING, email,
1140                       GPGSQL_ARG_END);
1141   if (rc)
1142     {
1143       log_error (_("error reading TOFU database: %s\n"), err);
1144       print_further_info ("checking for existing bad bindings");
1145       sqlite3_free (err);
1146       rc = gpg_error (GPG_ERR_GENERAL);
1147       goto out;
1148     }
1149
1150   if (strlist_length (strlist) == 0)
1151     /* No results.  */
1152     {
1153       policy = TOFU_POLICY_NONE;
1154       goto out;
1155     }
1156   else if (strlist_length (strlist) != 2)
1157     /* The result has the wrong form.  */
1158     {
1159       log_error (_("error reading TOFU database: %s\n"),
1160                  gpg_strerror (GPG_ERR_BAD_DATA));
1161       print_further_info ("checking for existing bad bindings:"
1162                           " expected 2 results, got %d\n",
1163                           strlist_length (strlist));
1164       goto out;
1165     }
1166
1167   /* The result has the right form.  */
1168
1169   if (string_to_long (&along, strlist->d, 0, __LINE__))
1170     {
1171       log_error (_("error reading TOFU database: %s\n"),
1172                  gpg_strerror (GPG_ERR_BAD_DATA));
1173       print_further_info ("bad value for policy: %s", strlist->d);
1174       goto out;
1175     }
1176   policy = along;
1177
1178   if (! (policy == TOFU_POLICY_AUTO
1179          || policy == TOFU_POLICY_GOOD
1180          || policy == TOFU_POLICY_UNKNOWN
1181          || policy == TOFU_POLICY_BAD
1182          || policy == TOFU_POLICY_ASK))
1183     {
1184       log_error (_("error reading TOFU database: %s\n"),
1185                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1186       print_further_info ("invalid value for policy (%d)", policy);
1187       policy = _tofu_GET_POLICY_ERROR;
1188       goto out;
1189     }
1190
1191
1192   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1193      just in case, we do the check again here and ignore the conflict
1194      if POLICY is not TOFU_POLICY_ASK.  */
1195   if (conflict)
1196     {
1197       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1198         *conflict = xstrdup (strlist->next->d);
1199       else
1200         *conflict = NULL;
1201     }
1202
1203  out:
1204   log_assert (policy == _tofu_GET_POLICY_ERROR
1205               || policy == TOFU_POLICY_NONE
1206               || policy == TOFU_POLICY_AUTO
1207               || policy == TOFU_POLICY_GOOD
1208               || policy == TOFU_POLICY_UNKNOWN
1209               || policy == TOFU_POLICY_BAD
1210               || policy == TOFU_POLICY_ASK);
1211
1212   free_strlist (strlist);
1213
1214   return policy;
1215 }
1216
1217
1218 /* Format the first part of a conflict message and return that as a
1219  * malloced string.  */
1220 static char *
1221 format_conflict_msg_part1 (int policy, strlist_t conflict_set,
1222                            const char *email)
1223 {
1224   estream_t fp;
1225   char *fingerprint;
1226   char *tmpstr, *text;
1227
1228   log_assert (conflict_set);
1229   fingerprint = conflict_set->d;
1230
1231   fp = es_fopenmem (0, "rw,samethread");
1232   if (!fp)
1233     log_fatal ("error creating memory stream: %s\n",
1234                gpg_strerror (gpg_error_from_syserror()));
1235
1236   if (policy == TOFU_POLICY_NONE)
1237     {
1238       es_fprintf (fp,
1239                   _("This is the first time the email address \"%s\" is "
1240                     "being used with key %s."),
1241                   email, fingerprint);
1242       es_fputs ("  ", fp);
1243     }
1244   else if (policy == TOFU_POLICY_ASK && conflict_set->next)
1245     {
1246       int conflicts = strlist_length (conflict_set);
1247       es_fprintf (fp, _("The email address \"%s\" is associated with %d keys!"),
1248                   email, conflicts);
1249       if (opt.verbose)
1250         es_fprintf (fp,
1251                     _("  Since this binding's policy was 'auto', it has been "
1252                       "changed to 'ask'."));
1253       es_fputs ("  ", fp);
1254     }
1255
1256   es_fprintf (fp,
1257               _("Please indicate whether this email address should"
1258                 " be associated with key %s or whether you think someone"
1259                 " is impersonating \"%s\"."),
1260               fingerprint, email);
1261   es_fputc ('\n', fp);
1262
1263   es_fputc (0, fp);
1264   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1265     log_fatal ("error snatching memory stream\n");
1266   text = format_text (tmpstr, 0, 72, 80);
1267   es_free (tmpstr);
1268
1269   return text;
1270 }
1271
1272
1273 /* Return 1 if A signed B and B signed A.  */
1274 static int
1275 cross_sigs (const char *email, kbnode_t a, kbnode_t b)
1276 {
1277   int i;
1278
1279   PKT_public_key *a_pk = a->pkt->pkt.public_key;
1280   PKT_public_key *b_pk = b->pkt->pkt.public_key;
1281
1282   char a_keyid[33];
1283   char b_keyid[33];
1284
1285   if (DBG_TRUST)
1286     {
1287       format_keyid (pk_main_keyid (a_pk),
1288                     KF_LONG, a_keyid, sizeof (a_keyid));
1289       format_keyid (pk_main_keyid (b_pk),
1290                     KF_LONG, b_keyid, sizeof (b_keyid));
1291     }
1292
1293   for (i = 0; i < 2; i ++)
1294     {
1295       /* See if SIGNER signed SIGNEE.  */
1296
1297       kbnode_t signer = i == 0 ? a : b;
1298       kbnode_t signee = i == 0 ? b : a;
1299
1300       PKT_public_key *signer_pk = signer->pkt->pkt.public_key;
1301       u32 *signer_kid = pk_main_keyid (signer_pk);
1302       kbnode_t n;
1303
1304       int saw_email = 0;
1305
1306       /* Iterate over SIGNEE's keyblock and see if there is a valid
1307          signature from SIGNER.  */
1308       for (n = signee; n; n = n->next)
1309         {
1310           PKT_signature *sig;
1311
1312           if (n->pkt->pkttype == PKT_USER_ID)
1313             {
1314               if (saw_email)
1315                 /* We're done: we've processed all signatures on the
1316                    user id.  */
1317                 break;
1318               else
1319                 {
1320                   /* See if this is the matching user id.  */
1321                   PKT_user_id *user_id = n->pkt->pkt.user_id;
1322                   char *email2 = email_from_user_id (user_id->name);
1323
1324                   if (strcmp (email, email2) == 0)
1325                     saw_email = 1;
1326
1327                   xfree (email2);
1328                 }
1329             }
1330
1331           if (! saw_email)
1332             continue;
1333
1334           if (n->pkt->pkttype != PKT_SIGNATURE)
1335             continue;
1336
1337           sig = n->pkt->pkt.signature;
1338
1339           if (! (sig->sig_class == 0x10
1340                  || sig->sig_class == 0x11
1341                  || sig->sig_class == 0x12
1342                  || sig->sig_class == 0x13))
1343             /* Not a signature over a user id.  */
1344             continue;
1345
1346           /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1347              signer, then it's a match.  */
1348           if (keyid_cmp (sig->keyid, signer_kid) == 0)
1349             /* Match!  */
1350             break;
1351         }
1352       if (! n)
1353         /* We didn't find a signature from signer over signee.  */
1354         {
1355           if (DBG_TRUST)
1356             log_debug ("No cross sig between %s and %s\n",
1357                        a_keyid, b_keyid);
1358           return 0;
1359         }
1360     }
1361
1362   /* A signed B and B signed A.  */
1363   if (DBG_TRUST)
1364     log_debug ("Cross sig between %s and %s\n",
1365                a_keyid, b_keyid);
1366
1367   return 1;
1368 }
1369
1370 /* Return whether the key was signed by an ultimately trusted key.  */
1371 static int
1372 signed_by_utk (const char *email, kbnode_t a)
1373 {
1374   kbnode_t n;
1375   int saw_email = 0;
1376
1377   for (n = a; n; n = n->next)
1378     {
1379       PKT_signature *sig;
1380
1381       if (n->pkt->pkttype == PKT_USER_ID)
1382         {
1383           if (saw_email)
1384             /* We're done: we've processed all signatures on the
1385                user id.  */
1386             break;
1387           else
1388             {
1389               /* See if this is the matching user id.  */
1390               PKT_user_id *user_id = n->pkt->pkt.user_id;
1391               char *email2 = email_from_user_id (user_id->name);
1392
1393               if (strcmp (email, email2) == 0)
1394                 saw_email = 1;
1395
1396               xfree (email2);
1397             }
1398         }
1399
1400       if (! saw_email)
1401         continue;
1402
1403       if (n->pkt->pkttype != PKT_SIGNATURE)
1404         continue;
1405
1406       sig = n->pkt->pkt.signature;
1407
1408       if (! (sig->sig_class == 0x10
1409              || sig->sig_class == 0x11
1410              || sig->sig_class == 0x12
1411              || sig->sig_class == 0x13))
1412         /* Not a signature over a user id.  */
1413         continue;
1414
1415       /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1416          signer, then it's a match.  */
1417       if (tdb_keyid_is_utk (sig->keyid))
1418         {
1419           /* Match!  */
1420           if (DBG_TRUST)
1421             log_debug ("TOFU: %s is signed by an ultimately trusted key.\n",
1422                        pk_keyid_str (a->pkt->pkt.public_key));
1423
1424           return 1;
1425         }
1426     }
1427
1428   if (DBG_TRUST)
1429     log_debug ("TOFU: %s is NOT signed by an ultimately trusted key.\n",
1430                pk_keyid_str (a->pkt->pkt.public_key));
1431
1432   return 0;
1433 }
1434
1435
1436 enum
1437   {
1438     BINDING_NEW = 1 << 0,
1439     BINDING_CONFLICT = 1 << 1,
1440     BINDING_EXPIRED = 1 << 2,
1441     BINDING_REVOKED = 1 << 3
1442   };
1443
1444
1445 /* Ask the user about the binding.  There are three ways we could end
1446  * up here:
1447  *
1448  *   - This is a new binding and there is a conflict
1449  *     (policy == TOFU_POLICY_NONE && conflict_set_count > 1),
1450  *
1451  *   - This is a new binding and opt.tofu_default_policy is set to
1452  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1453  *     TOFU_POLICY_ASK), or,
1454  *
1455  *   - The policy is ask (the user deferred last time) (policy ==
1456  *     TOFU_POLICY_ASK).
1457  *
1458  * Note: this function must not be called while in a transaction!
1459  *
1460  * CONFLICT_SET includes all of the conflicting bindings
1461  * with FINGERPRINT first.  FLAGS is a bit-wise or of
1462  * BINDING_NEW, etc.
1463  */
1464 static void
1465 ask_about_binding (ctrl_t ctrl,
1466                    enum tofu_policy *policy,
1467                    int *trust_level,
1468                    strlist_t conflict_set,
1469                    const char *fingerprint,
1470                    const char *email,
1471                    const char *user_id,
1472                    time_t now)
1473 {
1474   tofu_dbs_t dbs;
1475   strlist_t iter;
1476   int conflict_set_count = strlist_length (conflict_set);
1477   char *sqerr = NULL;
1478   int rc;
1479   estream_t fp;
1480   strlist_t other_user_ids = NULL;
1481   struct signature_stats *stats = NULL;
1482   struct signature_stats *stats_iter = NULL;
1483   char *prompt = NULL;
1484   char *choices;
1485
1486   dbs = ctrl->tofu.dbs;
1487   log_assert (dbs);
1488   log_assert (dbs->in_transaction == 0);
1489
1490   fp = es_fopenmem (0, "rw,samethread");
1491   if (!fp)
1492     log_fatal ("error creating memory stream: %s\n",
1493                gpg_strerror (gpg_error_from_syserror()));
1494
1495   {
1496     char *text = format_conflict_msg_part1 (*policy, conflict_set, email);
1497     es_fputs (text, fp);
1498     es_fputc ('\n', fp);
1499     xfree (text);
1500   }
1501
1502   begin_transaction (ctrl, 0);
1503
1504   /* Find other user ids associated with this key and whether the
1505    * bindings are marked as good or bad.  */
1506   rc = gpgsql_stepx
1507     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1508      strings_collect_cb2, &other_user_ids, &sqerr,
1509      "select user_id, policy from bindings where fingerprint = ?;",
1510      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1511   if (rc)
1512     {
1513       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1514       sqlite3_free (sqerr);
1515       sqerr = NULL;
1516       rc = gpg_error (GPG_ERR_GENERAL);
1517     }
1518
1519   if (other_user_ids)
1520     {
1521       strlist_t strlist_iter;
1522
1523       es_fprintf (fp, _("This key's user IDs:\n"));
1524       for (strlist_iter = other_user_ids;
1525            strlist_iter;
1526            strlist_iter = strlist_iter->next)
1527         {
1528           char *other_user_id = strlist_iter->d;
1529           char *other_thing;
1530           enum tofu_policy other_policy;
1531
1532           log_assert (strlist_iter->next);
1533           strlist_iter = strlist_iter->next;
1534           other_thing = strlist_iter->d;
1535
1536           other_policy = atoi (other_thing);
1537
1538           es_fprintf (fp, "  %s (", other_user_id);
1539           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1540           es_fprintf (fp, ")\n");
1541         }
1542       es_fprintf (fp, "\n");
1543
1544       free_strlist (other_user_ids);
1545     }
1546
1547   /* Get the stats for all the keys in CONFLICT_SET.  */
1548   strlist_rev (&conflict_set);
1549   for (iter = conflict_set; iter && ! rc; iter = iter->next)
1550     {
1551 #define STATS_SQL(table, time, sign)                         \
1552          "select fingerprint, policy, time_ago, count(*)\n" \
1553          " from\n" \
1554          "  (select bindings.*,\n" \
1555          "     "sign" case\n" \
1556          "       when delta ISNULL then 1\n" \
1557          /* From the future (but if its just a couple of hours in the \
1558           * future don't turn it into a warning)?  Or should we use \
1559           * small, medium or large units?  (Note: whatever we do, we \
1560           * keep the value in seconds.  Then when we group, everything \
1561           * that rounds to the same number of seconds is grouped.)  */ \
1562          "      when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then 2\n" \
1563          "      when delta < ("STRINGIFY (TIME_AGO_SMALL_THRESHOLD)")\n" \
1564          "       then 3\n" \
1565          "      when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n" \
1566          "       then 4\n" \
1567          "      when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n" \
1568          "       then 5\n" \
1569          "      else 6\n" \
1570          "     end time_ago,\n" \
1571          "    delta time_ago_raw\n" \
1572          "   from bindings\n" \
1573          "   left join\n" \
1574          "     (select *,\n" \
1575          "        cast(? - " time " as real) delta\n" \
1576          "       from " table ") ss\n" \
1577          "    on ss.binding = bindings.oid)\n" \
1578          " where email = ? and fingerprint = ?\n" \
1579          " group by time_ago\n" \
1580          /* Make sure the current key is first.  */ \
1581          " order by time_ago desc;\n"
1582
1583       /* Use the time when we saw the signature, not when the
1584          signature was created as that can be forged.  */
1585       rc = gpgsql_stepx
1586         (dbs->db, &dbs->s.get_trust_gather_signature_stats,
1587          signature_stats_collect_cb, &stats, &sqerr,
1588          STATS_SQL ("signatures", "time", ""),
1589          GPGSQL_ARG_LONG_LONG, (long long) now,
1590          GPGSQL_ARG_STRING, email,
1591          GPGSQL_ARG_STRING, iter->d,
1592          GPGSQL_ARG_END);
1593       if (rc)
1594         {
1595           rc = gpg_error (GPG_ERR_GENERAL);
1596           break;
1597         }
1598
1599       if (!stats || strcmp (iter->d, stats->fingerprint) != 0)
1600         /* No stats for this binding.  Add a dummy entry.  */
1601         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, 1, 1);
1602
1603       rc = gpgsql_stepx
1604         (dbs->db, &dbs->s.get_trust_gather_encryption_stats,
1605          signature_stats_collect_cb, &stats, &sqerr,
1606          STATS_SQL ("encryptions", "time", "-"),
1607          GPGSQL_ARG_LONG_LONG, (long long) now,
1608          GPGSQL_ARG_STRING, email,
1609          GPGSQL_ARG_STRING, iter->d,
1610          GPGSQL_ARG_END);
1611       if (rc)
1612         {
1613           rc = gpg_error (GPG_ERR_GENERAL);
1614           break;
1615         }
1616
1617 #undef STATS_SQL
1618
1619       if (!stats || strcmp (iter->d, stats->fingerprint) != 0
1620           || stats->time_ago > 0)
1621         /* No stats for this binding.  Add a dummy entry.  */
1622         signature_stats_prepend (&stats, iter->d, TOFU_POLICY_AUTO, -1, 1);
1623     }
1624   end_transaction (ctrl, 0);
1625   strlist_rev (&conflict_set);
1626   if (rc)
1627     {
1628       strlist_t strlist_iter;
1629
1630       log_error (_("error gathering signature stats: %s\n"), sqerr);
1631       sqlite3_free (sqerr);
1632       sqerr = NULL;
1633
1634       es_fprintf (fp, ngettext("The email address \"%s\" is"
1635                                " associated with %d key:\n",
1636                                "The email address \"%s\" is"
1637                                " associated with %d keys:\n",
1638                                conflict_set_count),
1639                   email, conflict_set_count);
1640       for (strlist_iter = conflict_set;
1641            strlist_iter;
1642            strlist_iter = strlist_iter->next)
1643         es_fprintf (fp, "  %s\n", strlist_iter->d);
1644     }
1645   else
1646     {
1647       char *key = NULL;
1648       strlist_t binding;
1649       int seen_in_past = 0;
1650
1651       es_fprintf (fp, _("Statistics for keys"
1652                         " with the email address \"%s\":\n"),
1653                   email);
1654       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1655         {
1656 #if 0
1657           log_debug ("%s: time_ago: %ld; count: %ld\n",
1658                      stats_iter->fingerprint,
1659                      stats_iter->time_ago,
1660                      stats_iter->count);
1661 #endif
1662
1663           if (! key || strcmp (key, stats_iter->fingerprint))
1664             {
1665               int this_key;
1666               char *key_pp;
1667
1668               key = stats_iter->fingerprint;
1669               this_key = strcmp (key, fingerprint) == 0;
1670               key_pp = format_hexfingerprint (key, NULL, 0);
1671               es_fprintf (fp, "  %s (", key_pp);
1672
1673               /* Find the associated binding.  */
1674               for (binding = conflict_set;
1675                    binding;
1676                    binding = binding->next)
1677                 if (strcmp (key, binding->d) == 0)
1678                   break;
1679               log_assert (binding);
1680
1681               if ((binding->flags & BINDING_REVOKED))
1682                 {
1683                   es_fprintf (fp, _("revoked"));
1684                   es_fprintf (fp, _(", "));
1685                 }
1686               else if ((binding->flags & BINDING_EXPIRED))
1687                 {
1688                   es_fprintf (fp, _("expired"));
1689                   es_fprintf (fp, _(", "));
1690                 }
1691
1692               if (this_key)
1693                 es_fprintf (fp, _("this key"));
1694               else
1695                 es_fprintf (fp, _("policy: %s"),
1696                             tofu_policy_str (stats_iter->policy));
1697               es_fputs ("):\n", fp);
1698               xfree (key_pp);
1699
1700               seen_in_past = 0;
1701             }
1702
1703           if (labs(stats_iter->time_ago) == 1)
1704             {
1705               /* The 1 in this case is the NULL entry.  */
1706               log_assert (stats_iter->count == 1);
1707               stats_iter->count = 0;
1708             }
1709           seen_in_past += stats_iter->count;
1710
1711           es_fputs ("    ", fp);
1712           /* TANSLATORS: This string is concatenated with one of
1713            * the day/week/month strings to form one sentence.  */
1714           if (stats_iter->time_ago > 0)
1715             es_fprintf (fp, ngettext("Verified %d message",
1716                                      "Verified %d messages",
1717                                      seen_in_past), seen_in_past);
1718           else
1719             es_fprintf (fp, ngettext("Encrypted %d message",
1720                                      "Encrypted %d messages",
1721                                      seen_in_past), seen_in_past);
1722
1723           if (!stats_iter->count)
1724             es_fputs (".", fp);
1725           else if (labs(stats_iter->time_ago) == 2)
1726             {
1727               es_fprintf (fp, "in the future.");
1728               /* Reset it.  */
1729               seen_in_past = 0;
1730             }
1731           else
1732             {
1733               if (labs(stats_iter->time_ago) == 3)
1734                 es_fprintf (fp, ngettext(" over the past day.",
1735                                          " over the past %d days.",
1736                                          TIME_AGO_SMALL_THRESHOLD
1737                                          / TIME_AGO_UNIT_SMALL),
1738                             TIME_AGO_SMALL_THRESHOLD
1739                             / TIME_AGO_UNIT_SMALL);
1740               else if (labs(stats_iter->time_ago) == 4)
1741                 es_fprintf (fp, ngettext(" over the past month.",
1742                                          " over the past %d months.",
1743                                          TIME_AGO_MEDIUM_THRESHOLD
1744                                          / TIME_AGO_UNIT_MEDIUM),
1745                             TIME_AGO_MEDIUM_THRESHOLD
1746                             / TIME_AGO_UNIT_MEDIUM);
1747               else if (labs(stats_iter->time_ago) == 5)
1748                 es_fprintf (fp, ngettext(" over the past year.",
1749                                          " over the past %d years.",
1750                                          TIME_AGO_LARGE_THRESHOLD
1751                                          / TIME_AGO_UNIT_LARGE),
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 (pk_is_primary (pk));
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 (pk_is_primary (pk));
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_signature, 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       ! pk_is_primary (pk)
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 (! pk_is_primary (pk))
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_encryption, 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 (! pk_is_primary (pk))
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_is_primary (pk));
3570
3571   dbs = opendbs (ctrl);
3572   if (! dbs)
3573     {
3574       log_error (_("error opening TOFU database: %s\n"),
3575                  gpg_strerror (GPG_ERR_GENERAL));
3576       return gpg_error (GPG_ERR_GENERAL);
3577     }
3578
3579   fingerprint = hexfingerprint (pk, NULL, 0);
3580
3581   email = email_from_user_id (user_id->name);
3582
3583   *policy = get_policy (dbs, fingerprint, email, NULL);
3584
3585   xfree (email);
3586   xfree (fingerprint);
3587   if (*policy == _tofu_GET_POLICY_ERROR)
3588     return gpg_error (GPG_ERR_GENERAL);
3589   return 0;
3590 }