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