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