g10: End transaction earlier.
[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, const char *conflict,
1150                            const char *fingerprint, const char *email)
1151 {
1152   estream_t fp;
1153   char *binding;
1154   int binding_shown = 0;
1155   char *tmpstr, *text;
1156
1157   binding = xasprintf ("<%s, %s>", fingerprint, email);
1158
1159   fp = es_fopenmem (0, "rw,samethread");
1160   if (!fp)
1161     log_fatal ("error creating memory stream: %s\n",
1162                gpg_strerror (gpg_error_from_syserror()));
1163
1164   if (policy == TOFU_POLICY_NONE)
1165     {
1166       es_fprintf (fp, _("The binding %s is NOT known."), binding);
1167       es_fputs ("  ", fp);
1168       binding_shown = 1;
1169     }
1170   else if (policy == TOFU_POLICY_ASK
1171            /* If there the conflict is with itself, then don't
1172             * display this message.  */
1173            && conflict && strcmp (conflict, fingerprint))
1174     {
1175       es_fprintf (fp,
1176                   _("The key with fingerprint %s raised a conflict "
1177                     "with the binding %s."
1178                     "  Since this binding's policy was 'auto', it was "
1179                     "changed to 'ask'."),
1180                   conflict, binding);
1181       es_fputs ("  ", fp);
1182       binding_shown = 1;
1183     }
1184
1185   /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1186      blank or by two empty strings.  */
1187   es_fprintf (fp,
1188               _("Please indicate whether you believe the binding %s%s"
1189                 "is legitimate (the key belongs to the stated owner) "
1190                 "or a forgery (bad)."),
1191               binding_shown ? "" : binding,
1192               binding_shown ? "" : " ");
1193   es_fputc ('\n', fp);
1194
1195   xfree (binding);
1196
1197   es_fputc (0, fp);
1198   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1199     log_fatal ("error snatching memory stream\n");
1200   text = format_text (tmpstr, 0, 72, 80);
1201   es_free (tmpstr);
1202
1203   return text;
1204 }
1205
1206
1207 /* Return 1 if A signed B and B signed A.  */
1208 int
1209 cross_sigs (kbnode_t a, kbnode_t b)
1210 {
1211   int i;
1212
1213   PKT_public_key *a_pk = a->pkt->pkt.public_key;
1214   PKT_public_key *b_pk = b->pkt->pkt.public_key;
1215
1216   char a_keyid[33];
1217   char b_keyid[33];
1218
1219   if (DBG_TRUST)
1220     {
1221       format_keyid (pk_main_keyid (a_pk),
1222                     KF_DEFAULT, a_keyid, sizeof (a_keyid));
1223       format_keyid (pk_main_keyid (b_pk),
1224                     KF_DEFAULT, b_keyid, sizeof (b_keyid));
1225     }
1226
1227   for (i = 0; i < 2; i ++)
1228     {
1229       /* See if SIGNER signed SIGNEE.  */
1230
1231       kbnode_t signer = i == 0 ? a : b;
1232       kbnode_t signee = i == 0 ? b : a;
1233
1234       PKT_public_key *signer_pk = signer->pkt->pkt.public_key;
1235       u32 *signer_kid = pk_main_keyid (signer_pk);
1236       kbnode_t n;
1237
1238       /* Iterate over SIGNEE's keyblock and see if there is a valid
1239          signature from SIGNER.  */
1240       for (n = signee; n; n = n->next)
1241         {
1242           PKT_signature *sig;
1243
1244           if (n->pkt->pkttype != PKT_SIGNATURE)
1245             continue;
1246
1247           sig = n->pkt->pkt.signature;
1248
1249           if (! (sig->sig_class == 0x10
1250                  || sig->sig_class == 0x11
1251                  || sig->sig_class == 0x12
1252                  || sig->sig_class == 0x13))
1253             /* Not a signature over a user id.  */
1254             continue;
1255
1256           /* SIG is on SIGNEE's keyblock.  If SIG was generated by the
1257              signer, then it's a match.  */
1258           if (keyid_cmp (sig->keyid, signer_kid) == 0)
1259             /* Match!  */
1260             break;
1261         }
1262       if (! n)
1263         /* We didn't find a signature from signer over signee.  */
1264         {
1265           if (DBG_TRUST)
1266             log_info ("No cross sig between %s and %s\n",
1267                       a_keyid, b_keyid);
1268           return 0;
1269         }
1270     }
1271
1272   /* A signed B and B signed A.  */
1273   if (DBG_TRUST)
1274     log_info ("Cross sig between %s and %s\n",
1275               a_keyid, b_keyid);
1276
1277   return 1;
1278 }
1279
1280
1281 /* Ask the user about the binding.  There are three ways we could end
1282  * up here:
1283  *
1284  *   - This is a new binding and there is a conflict
1285  *     (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1286  *
1287  *   - This is a new binding and opt.tofu_default_policy is set to
1288  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1289  *     TOFU_POLICY_ASK), or,
1290  *
1291  *   - The policy is ask (the user deferred last time) (policy ==
1292  *     TOFU_POLICY_ASK).
1293  *
1294  * Note: this function must not be called while in a transaction!
1295  */
1296 static void
1297 ask_about_binding (ctrl_t ctrl,
1298                    enum tofu_policy *policy,
1299                    int *trust_level,
1300                    int bindings_with_this_email_count,
1301                    strlist_t bindings_with_this_email,
1302                    char *conflict,
1303                    const char *fingerprint,
1304                    const char *email,
1305                    const char *user_id)
1306 {
1307   tofu_dbs_t dbs;
1308   char *sqerr = NULL;
1309   int rc;
1310   estream_t fp;
1311   strlist_t other_user_ids = NULL;
1312   struct signature_stats *stats = NULL;
1313   struct signature_stats *stats_iter = NULL;
1314   char *prompt = NULL;
1315   char *choices;
1316
1317   dbs = ctrl->tofu.dbs;
1318   log_assert (dbs);
1319   log_assert (dbs->in_transaction == 0);
1320
1321   fp = es_fopenmem (0, "rw,samethread");
1322   if (!fp)
1323     log_fatal ("error creating memory stream: %s\n",
1324                gpg_strerror (gpg_error_from_syserror()));
1325
1326   {
1327     char *text = format_conflict_msg_part1 (*policy, conflict,
1328                                             fingerprint, email);
1329     es_fputs (text, fp);
1330     es_fputc ('\n', fp);
1331     xfree (text);
1332   }
1333
1334   begin_transaction (ctrl, 0);
1335
1336   /* Find other user ids associated with this key and whether the
1337    * bindings are marked as good or bad.  */
1338   rc = gpgsql_stepx
1339     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1340      strings_collect_cb2, &other_user_ids, &sqerr,
1341      "select user_id, policy from bindings where fingerprint = ?;",
1342      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1343   if (rc)
1344     {
1345       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1346       sqlite3_free (sqerr);
1347       sqerr = NULL;
1348     }
1349
1350   if (other_user_ids)
1351     {
1352       strlist_t strlist_iter;
1353
1354       es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1355       for (strlist_iter = other_user_ids;
1356            strlist_iter;
1357            strlist_iter = strlist_iter->next)
1358         {
1359           char *other_user_id = strlist_iter->d;
1360           char *other_thing;
1361           enum tofu_policy other_policy;
1362
1363           log_assert (strlist_iter->next);
1364           strlist_iter = strlist_iter->next;
1365           other_thing = strlist_iter->d;
1366
1367           other_policy = atoi (other_thing);
1368
1369           es_fprintf (fp, "  %s (", other_user_id);
1370           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1371           es_fprintf (fp, ")\n");
1372         }
1373       es_fprintf (fp, "\n");
1374
1375       free_strlist (other_user_ids);
1376     }
1377
1378   /* Find other keys associated with this email address.  */
1379   /* FIXME: When generating the statistics, do we want the time
1380      embedded in the signature (column 'sig_time') or the time that
1381      we first verified the signature (column 'time').  */
1382   rc = gpgsql_stepx
1383     (dbs->db, &dbs->s.get_trust_gather_other_keys,
1384      signature_stats_collect_cb, &stats, &sqerr,
1385      "select fingerprint, policy, time_ago, count(*)\n"
1386      " from (select bindings.*,\n"
1387      "        case\n"
1388      /* From the future (but if its just a couple of hours in the
1389       * future don't turn it into a warning)?  Or should we use
1390       * small, medium or large units?  (Note: whatever we do, we
1391       * keep the value in seconds.  Then when we group, everything
1392       * that rounds to the same number of seconds is grouped.)  */
1393      "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1394      "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1395      "          then max(0,\n"
1396      "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1397      "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1398      "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1399      "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1400      "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1401      "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1402      "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1403      "        end time_ago,\n"
1404      "        delta time_ago_raw\n"
1405      "       from bindings\n"
1406      "       left join\n"
1407      "         (select *,\n"
1408      "            cast(strftime('%s','now') - sig_time as real) delta\n"
1409      "           from signatures) ss\n"
1410      "        on ss.binding = bindings.oid)\n"
1411      " where email = ?\n"
1412      " group by fingerprint, time_ago\n"
1413      /* Make sure the current key is first.  */
1414      " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1415      GPGSQL_ARG_STRING, email, GPGSQL_ARG_STRING, fingerprint,
1416      GPGSQL_ARG_END);
1417   end_transaction (ctrl, 0);
1418   if (rc)
1419     {
1420       strlist_t strlist_iter;
1421
1422       log_error (_("error gathering signature stats: %s\n"), sqerr);
1423       sqlite3_free (sqerr);
1424       sqerr = NULL;
1425
1426       es_fprintf (fp, ngettext("The email address \"%s\" is"
1427                                " associated with %d key:\n",
1428                                "The email address \"%s\" is"
1429                                " associated with %d keys:\n",
1430                                bindings_with_this_email_count),
1431                   email, bindings_with_this_email_count);
1432       for (strlist_iter = bindings_with_this_email;
1433            strlist_iter;
1434            strlist_iter = strlist_iter->next)
1435         es_fprintf (fp, "  %s\n", strlist_iter->d);
1436     }
1437   else
1438     {
1439       int stats_count = 0;
1440       kbnode_t *kb_all;
1441       KEYDB_HANDLE hd;
1442       int i;
1443       char *key = NULL;
1444
1445       /* Get the keyblock for each key.  */
1446       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1447         stats_count ++;
1448       kb_all = xcalloc (sizeof (kb_all[0]), stats_count);
1449
1450       if (! stats || strcmp (stats->fingerprint, fingerprint))
1451         {
1452           /* If we have already added this key to the DB, then it will
1453            * be first (see the above select).  Since the first key on
1454            * the list is not this key, we must not yet have verified any
1455            * messages signed by this key.  Add a dummy entry.  */
1456           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1457         }
1458
1459       /* Figure out which user ids are revoked or expired.  */
1460       hd = keydb_new ();
1461       for (stats_iter = stats, i = 0;
1462            stats_iter;
1463            stats_iter = stats_iter->next, i ++)
1464         {
1465           KEYDB_SEARCH_DESC desc;
1466           kbnode_t kb;
1467           PKT_public_key *pk;
1468           kbnode_t n;
1469           int found_user_id;
1470
1471           rc = keydb_search_reset (hd);
1472           if (rc)
1473             {
1474               log_error (_("resetting keydb: %s\n"),
1475                          gpg_strerror (rc));
1476               continue;
1477             }
1478
1479           rc = classify_user_id (stats_iter->fingerprint, &desc, 0);
1480           if (rc)
1481             {
1482               log_error (_("error parsing key specification '%s': %s\n"),
1483                          stats_iter->fingerprint, gpg_strerror (rc));
1484               continue;
1485             }
1486
1487           rc = keydb_search (hd, &desc, 1, NULL);
1488           if (rc)
1489             {
1490               log_error (_("key \"%s\" not found: %s\n"),
1491                          stats_iter->fingerprint,
1492                          gpg_strerror (rc));
1493               continue;
1494             }
1495
1496           rc = keydb_get_keyblock (hd, &kb);
1497           if (rc)
1498             {
1499               log_error (_("error reading keyblock: %s\n"),
1500                          gpg_strerror (rc));
1501               print_further_info ("fingerprint: %s", stats_iter->fingerprint);
1502               continue;
1503             }
1504
1505           merge_keys_and_selfsig (kb);
1506
1507           log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
1508
1509           kb_all[i] = kb;
1510
1511           pk = kb->pkt->pkt.public_key;
1512
1513           if (pk->has_expired)
1514             stats_iter->is_expired = 1;
1515           if (pk->flags.revoked)
1516             stats_iter->is_revoked = 1;
1517
1518           n = kb;
1519           found_user_id = 0;
1520           while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
1521             {
1522               PKT_user_id *user_id2 = n->pkt->pkt.user_id;
1523               char *email2;
1524
1525               if (user_id2->attrib_data)
1526                 continue;
1527
1528               email2 = email_from_user_id (user_id2->name);
1529
1530               if (strcmp (email, email2) == 0)
1531                 {
1532                   found_user_id = 1;
1533
1534                   if (user_id2->is_revoked)
1535                     stats_iter->is_revoked = 1;
1536                   if (user_id2->is_expired)
1537                     stats_iter->is_expired = 1;
1538                 }
1539
1540               xfree (email2);
1541             }
1542
1543           if (! found_user_id)
1544             log_info (_("TOFU db may be corrupted: user id (%s)"
1545                         " not on key block (%s)\n"),
1546                       email, fingerprint);
1547         }
1548       keydb_release (hd);
1549
1550       {
1551         int j;
1552         struct signature_stats **stats_prevp;
1553         struct signature_stats *stats_iter_next;
1554         int die[stats_count];
1555
1556         memset (die, 0, sizeof (die));
1557
1558         for (i = 0; i < stats_count; i ++)
1559           {
1560             /* i or a key that has cross sigs with i (possible
1561                indirectly)?  */
1562             if (! (i == 0 || die[i]))
1563               continue;
1564
1565             for (j = i + 1; j < stats_count; j ++)
1566               if (cross_sigs (kb_all[i], kb_all[j]))
1567                 die[j] = 1;
1568           }
1569
1570         /* Free the dead stat structures.  */
1571         for (stats_iter = stats, stats_prevp = &stats, i = 0;
1572              stats_iter;
1573              stats_iter = stats_iter_next, i ++)
1574           {
1575             stats_iter_next = stats_iter->next;
1576
1577             release_kbnode (kb_all[i]);
1578
1579             if (die[i])
1580               {
1581                 *stats_prevp = stats_iter_next;
1582                 stats_iter->next = NULL;
1583                 signature_stats_free (stats_iter);
1584
1585                 bindings_with_this_email_count --;
1586               }
1587             else
1588               {
1589                 stats_prevp = &stats_iter->next;
1590               }
1591           }
1592       }
1593
1594       log_assert (stats);
1595       log_assert (bindings_with_this_email_count >= 1);
1596
1597       if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count == 1)
1598           || (*policy == TOFU_POLICY_ASK && conflict))
1599       if (bindings_with_this_email_count == 1)
1600         {
1601           /* All "conflicts" were not really conflicts.  */
1602           log_assert (! stats->next);
1603
1604           if (DBG_TRUST)
1605             log_debug ("%s: all apparent TOFU conflicts are legitimate "
1606                        "(cross sigs), setting policy to auto.\n",
1607                        stats_iter->fingerprint);
1608
1609           *policy = TOFU_POLICY_AUTO;
1610           record_binding (dbs, fingerprint, email, user_id, *policy, 0);
1611           *trust_level = tofu_policy_to_trust_level (*policy);
1612
1613           goto out;
1614         }
1615
1616       es_fprintf (fp, _("Statistics for potentially conflicting keys"
1617                         " with the email address \"%s\":\n"),
1618                   email);
1619       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1620         {
1621           if (! key || strcmp (key, stats_iter->fingerprint))
1622             {
1623               int this_key;
1624               char *key_pp;
1625
1626               key = stats_iter->fingerprint;
1627               this_key = strcmp (key, fingerprint) == 0;
1628               key_pp = format_hexfingerprint (key, NULL, 0);
1629               es_fprintf (fp, "  %s (", key_pp);
1630
1631               if (stats_iter->is_revoked)
1632                 {
1633                   es_fprintf (fp, _("revoked"));
1634                   es_fprintf (fp, _(", "));
1635                 }
1636               else if (stats_iter->is_expired)
1637                 {
1638                   es_fprintf (fp, _("expired"));
1639                   es_fprintf (fp, _(", "));
1640                 }
1641
1642               if (this_key)
1643                 es_fprintf (fp, _("this key"));
1644               else
1645                 es_fprintf (fp, _("policy: %s"),
1646                             tofu_policy_str (stats_iter->policy));
1647               es_fputs ("):\n", fp);
1648               xfree (key_pp);
1649             }
1650
1651           es_fputs ("    ", fp);
1652           if (stats_iter->time_ago == -1)
1653             es_fprintf (fp, ngettext("%ld message signed in the future.",
1654                                      "%ld messages signed in the future.",
1655                                      stats_iter->count), stats_iter->count);
1656           else
1657             {
1658               long t_scaled = time_ago_scale (stats_iter->time_ago);
1659
1660               /* TANSLATORS: This string is concatenated with one of
1661                * the day/week/month strings to form one sentence.  */
1662               es_fprintf (fp, ngettext("%ld message signed",
1663                                        "%ld messages signed",
1664                                        stats_iter->count), stats_iter->count);
1665               if (!stats_iter->count)
1666                 es_fputs (".", fp);
1667               else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
1668                 es_fprintf (fp, ngettext(" over the past %ld day.",
1669                                          " over the past %ld days.",
1670                                          t_scaled), t_scaled);
1671               else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
1672                 es_fprintf (fp, ngettext(" over the past %ld week.",
1673                                          " over the past %ld weeks.",
1674                                          t_scaled), t_scaled);
1675               else
1676                 es_fprintf (fp, ngettext(" over the past %ld month.",
1677                                          " over the past %ld months.",
1678                                          t_scaled), t_scaled);
1679             }
1680           es_fputs ("\n", fp);
1681         }
1682     }
1683
1684   if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1685       || (*policy == TOFU_POLICY_ASK
1686           && (conflict || bindings_with_this_email_count > 0)))
1687     {
1688       /* This is a conflict.  */
1689
1690       /* TRANSLATORS: Please translate the text found in the source
1691        * file below.  We don't directly internationalize that text so
1692        * that we can tweak it without breaking translations.  */
1693       char *text = _("TOFU detected a binding conflict");
1694       char *textbuf;
1695       if (!strcmp (text, "TOFU detected a binding conflict"))
1696         {
1697           /* No translation.  Use the English text.  */
1698           text =
1699             "Normally, there is only a single key associated with an email "
1700             "address.  However, people sometimes generate a new key if "
1701             "their key is too old or they think it might be compromised.  "
1702             "Alternatively, a new key may indicate a man-in-the-middle "
1703             "attack!  Before accepting this key, you should talk to or "
1704             "call the person to make sure this new key is legitimate.";
1705         }
1706       textbuf = format_text (text, 0, 72, 80);
1707       es_fprintf (fp, "\n%s\n", textbuf);
1708       xfree (textbuf);
1709     }
1710
1711   es_fputc ('\n', fp);
1712
1713   /* Add a NUL terminator.  */
1714   es_fputc (0, fp);
1715   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1716     log_fatal ("error snatching memory stream\n");
1717
1718   /* I think showing the large message once is sufficient.  If we
1719    * would move it right before the cpr_get many lines will scroll
1720    * away and the user might not realize that he merely entered a
1721    * wrong choise (because he does not see that either).  As a small
1722    * benefit we allow C-L to redisplay everything.  */
1723   tty_printf ("%s", prompt);
1724
1725   /* Suspend any transaction: it could take a while until the user
1726      responds.  */
1727   tofu_suspend_batch_transaction (ctrl);
1728   while (1)
1729     {
1730       char *response;
1731
1732       /* TRANSLATORS: Two letters (normally the lower and upper case
1733        * version of the hotkey) for each of the five choices.  If
1734        * there is only one choice in your language, repeat it.  */
1735       choices = _("gG" "aA" "uU" "rR" "bB");
1736       if (strlen (choices) != 10)
1737         log_bug ("Bad TOFU conflict translation!  Please report.");
1738
1739       response = cpr_get
1740         ("tofu.conflict",
1741          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1742       trim_spaces (response);
1743       cpr_kill_prompt ();
1744       if (*response == CONTROL_L)
1745         tty_printf ("%s", prompt);
1746       else if (!response[0])
1747         /* Default to unknown.  Don't save it.  */
1748         {
1749           tty_printf (_("Defaulting to unknown."));
1750           *policy = TOFU_POLICY_UNKNOWN;
1751           break;
1752         }
1753       else if (!response[1])
1754         {
1755           char *choice = strchr (choices, *response);
1756
1757           if (choice)
1758             {
1759               int c = ((size_t) choice - (size_t) choices) / 2;
1760
1761               switch (c)
1762                 {
1763                 case 0: /* Good.  */
1764                   *policy = TOFU_POLICY_GOOD;
1765                   *trust_level = tofu_policy_to_trust_level (*policy);
1766                   break;
1767                 case 1: /* Accept once.  */
1768                   *policy = TOFU_POLICY_ASK;
1769                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1770                   break;
1771                 case 2: /* Unknown.  */
1772                   *policy = TOFU_POLICY_UNKNOWN;
1773                   *trust_level = tofu_policy_to_trust_level (*policy);
1774                   break;
1775                 case 3: /* Reject once.  */
1776                   *policy = TOFU_POLICY_ASK;
1777                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1778                   break;
1779                 case 4: /* Bad.  */
1780                   *policy = TOFU_POLICY_BAD;
1781                   *trust_level = tofu_policy_to_trust_level (*policy);
1782                   break;
1783                 default:
1784                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1785                 }
1786
1787               if (record_binding (dbs, fingerprint, email, user_id,
1788                                   *policy, 0))
1789                 {
1790                   /* If there's an error registering the
1791                    * binding, don't save the signature.  */
1792                   *trust_level = _tofu_GET_TRUST_ERROR;
1793                 }
1794               break;
1795             }
1796         }
1797       xfree (response);
1798     }
1799  out:
1800   tofu_resume_batch_transaction (ctrl);
1801
1802   xfree (prompt);
1803
1804   signature_stats_free (stats);
1805 }
1806
1807
1808 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1809  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1810  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1811  * returns _tofu_GET_TRUST_ERROR.
1812  *
1813  * PK is the public key object for FINGERPRINT.
1814  *
1815  * USER_ID is the unadulterated user id.
1816  *
1817  * If MAY_ASK is set, then we may interact with the user.  This is
1818  * necessary if there is a conflict or the binding's policy is
1819  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1820  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1821  * we return TRUST_UNDEFINED.  Note: if MAY_ASK is set, then this
1822  * function must not be called while in a transaction!  */
1823 static enum tofu_policy
1824 get_trust (ctrl_t ctrl, PKT_public_key *pk,
1825            const char *fingerprint, const char *email,
1826            const char *user_id, int may_ask)
1827 {
1828   tofu_dbs_t dbs = ctrl->tofu.dbs;
1829   int in_transaction = 0;
1830   enum tofu_policy policy;
1831   char *conflict = NULL;
1832   int rc;
1833   char *sqerr = NULL;
1834   strlist_t bindings_with_this_email = NULL;
1835   int bindings_with_this_email_count;
1836   int change_conflicting_to_ask = 0;
1837   int trust_level = TRUST_UNKNOWN;
1838
1839   log_assert (dbs);
1840
1841   if (may_ask)
1842     log_assert (dbs->in_transaction == 0);
1843
1844   if (opt.batch)
1845     may_ask = 0;
1846
1847   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1848      levels.  */
1849   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1850               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1851               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1852               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1853               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1854               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1855               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1856
1857   begin_transaction (ctrl, 0);
1858   in_transaction = 1;
1859
1860   policy = get_policy (dbs, fingerprint, email, &conflict);
1861   {
1862     /* See if the key is ultimately trusted.  If so, we're done.  */
1863     u32 kid[2];
1864
1865     keyid_from_pk (pk, kid);
1866
1867     if (tdb_keyid_is_utk (kid))
1868       {
1869         if (policy == TOFU_POLICY_NONE)
1870           {
1871             if (record_binding (dbs, fingerprint, email, user_id,
1872                                 TOFU_POLICY_AUTO, 0) != 0)
1873               {
1874                 log_error (_("error setting TOFU binding's trust level"
1875                              " to %s\n"), "auto");
1876                 trust_level = _tofu_GET_TRUST_ERROR;
1877                 goto out;
1878               }
1879           }
1880
1881         trust_level = TRUST_ULTIMATE;
1882         goto out;
1883       }
1884   }
1885
1886   if (policy == TOFU_POLICY_AUTO)
1887     {
1888       policy = opt.tofu_default_policy;
1889       if (DBG_TRUST)
1890         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is "
1891                    " auto (default: %s).\n",
1892                    fingerprint, email,
1893                    tofu_policy_str (opt.tofu_default_policy));
1894     }
1895   switch (policy)
1896     {
1897     case TOFU_POLICY_AUTO:
1898     case TOFU_POLICY_GOOD:
1899     case TOFU_POLICY_UNKNOWN:
1900     case TOFU_POLICY_BAD:
1901       /* The saved judgement is auto -> auto, good, unknown or bad.
1902        * We don't need to ask the user anything.  */
1903       if (DBG_TRUST)
1904         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
1905                    fingerprint, email, tofu_policy_str (policy));
1906       trust_level = tofu_policy_to_trust_level (policy);
1907       goto out;
1908
1909     case TOFU_POLICY_ASK:
1910       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1911       if (! may_ask)
1912         {
1913           trust_level = TRUST_UNDEFINED;
1914           goto out;
1915         }
1916
1917       break;
1918
1919     case TOFU_POLICY_NONE:
1920       /* The binding is new, we need to check for conflicts.  Case #3
1921        * below.  */
1922       break;
1923
1924     case _tofu_GET_POLICY_ERROR:
1925       trust_level = _tofu_GET_TRUST_ERROR;
1926       goto out;
1927
1928     default:
1929       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1930     }
1931
1932
1933   /* We get here if:
1934    *
1935    *   1. The saved policy is auto and the default policy is ask
1936    *      (get_policy() == TOFU_POLICY_AUTO
1937    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
1938    *
1939    *   2. The saved policy is ask (either last time the user selected
1940    *      accept once or reject once or there was a conflict and this
1941    *      binding's policy was changed from auto to ask)
1942    *      (policy == TOFU_POLICY_ASK), or,
1943    *
1944    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1945    *      (need to check for a conflict).
1946    */
1947
1948   /* Look for conflicts.  This is needed in all 3 cases.
1949    *
1950    * Get the fingerprints of any bindings that share the email
1951    * address.  Note: if the binding in question is in the DB, it will
1952    * also be returned.  Thus, if the result set is empty, then this is
1953    * a new binding.  */
1954   rc = gpgsql_stepx
1955     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1956      strings_collect_cb2, &bindings_with_this_email, &sqerr,
1957      "select distinct fingerprint from bindings where email = ?;",
1958      GPGSQL_ARG_STRING, email, GPGSQL_ARG_END);
1959   if (rc)
1960     {
1961       log_error (_("error reading TOFU database: %s\n"), sqerr);
1962       print_further_info ("listing fingerprints");
1963       sqlite3_free (sqerr);
1964       goto out;
1965     }
1966
1967   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1968   if (bindings_with_this_email_count == 0
1969       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1970     {
1971       /* New binding with no conflict and a concrete default policy.
1972        *
1973        * We've never observed a binding with this email address
1974        * BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would
1975        * return the current binding if it were in the DB) and we have
1976        * a default policy, which is not to ask the user.
1977        */
1978
1979       /* If we've seen this binding, then we've seen this email and
1980          policy couldn't possibly be TOFU_POLICY_NONE.  */
1981       log_assert (policy == TOFU_POLICY_NONE);
1982
1983       if (DBG_TRUST)
1984         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
1985                    fingerprint, email);
1986
1987       if (record_binding (dbs, fingerprint, email, user_id,
1988                           TOFU_POLICY_AUTO, 0) != 0)
1989         {
1990           log_error (_("error setting TOFU binding's trust level to %s\n"),
1991                        "auto");
1992           trust_level = _tofu_GET_TRUST_ERROR;
1993           goto out;
1994         }
1995
1996       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1997       goto out;
1998     }
1999
2000   if (policy == TOFU_POLICY_NONE)
2001     {
2002       /* This is a new binding and we have a conflict.  Mark any
2003        * conflicting bindings that have an automatic policy as now
2004        * requiring confirmation.  Note: we delay this until after we
2005        * ask for confirmation so that when the current policy is
2006        * printed, it is correct.  */
2007       change_conflicting_to_ask = 1;
2008     }
2009
2010   if (! may_ask)
2011     {
2012       /* We can only get here in the third case (no saved policy) and
2013        * if there is a conflict.  (If the policy was ask (cases #1 and
2014        * #2) and we weren't allowed to ask, we'd have already exited).  */
2015       log_assert (policy == TOFU_POLICY_NONE);
2016
2017       if (record_binding (dbs, fingerprint, email, user_id,
2018                           TOFU_POLICY_ASK, 0) != 0)
2019         log_error (_("error setting TOFU binding's trust level to %s\n"),
2020                    "ask");
2021
2022       trust_level = TRUST_UNDEFINED;
2023       goto out;
2024     }
2025
2026   /* We can't be in a normal transaction in ask_about_binding.  */
2027   end_transaction (ctrl, 0);
2028   in_transaction = 0;
2029
2030   /* If we get here, we need to ask the user about the binding.  */
2031   ask_about_binding (ctrl,
2032                      &policy,
2033                      &trust_level,
2034                      bindings_with_this_email_count,
2035                      bindings_with_this_email,
2036                      conflict,
2037                      fingerprint,
2038                      email,
2039                      user_id);
2040
2041  out:
2042   if (in_transaction)
2043     end_transaction (ctrl, 0);
2044
2045   if (change_conflicting_to_ask)
2046     {
2047       if (! may_ask)
2048         {
2049           /* If we weren't allowed to ask, also update this key as
2050              conflicting with itself.  */
2051           rc = gpgsql_exec_printf
2052             (dbs->db, NULL, NULL, &sqerr,
2053              "update bindings set policy = %d, conflict = %Q"
2054              " where email = %Q"
2055              "  and (policy = %d or (policy = %d and fingerprint = %Q));",
2056              TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
2057              TOFU_POLICY_ASK, fingerprint);
2058         }
2059       else
2060         {
2061           rc = gpgsql_exec_printf
2062             (dbs->db, NULL, NULL, &sqerr,
2063              "update bindings set policy = %d, conflict = %Q"
2064              " where email = %Q and fingerprint != %Q and policy = %d;",
2065              TOFU_POLICY_ASK, fingerprint, email, fingerprint,
2066              TOFU_POLICY_AUTO);
2067         }
2068
2069       if (rc)
2070         {
2071           log_error (_("error changing TOFU policy: %s\n"), sqerr);
2072           sqlite3_free (sqerr);
2073           sqerr = NULL;
2074         }
2075     }
2076
2077   xfree (conflict);
2078   free_strlist (bindings_with_this_email);
2079
2080   return trust_level;
2081 }
2082
2083
2084 /* Return a malloced string of the form
2085  *    "7 months, 1 day, 5 minutes, 0 seconds"
2086  * The caller should replace all '~' in the returned string by a space
2087  * and also free the returned string.
2088  *
2089  * This is actually a bad hack which may not work correctly with all
2090  * languages.
2091  */
2092 static char *
2093 time_ago_str (long long int t)
2094 {
2095   estream_t fp;
2096   int years = 0;
2097   int months = 0;
2098   int days = 0;
2099   int hours = 0;
2100   int minutes = 0;
2101   int seconds = 0;
2102
2103   /* The number of units that we've printed so far.  */
2104   int count = 0;
2105   /* The first unit that we printed (year = 0, month = 1,
2106      etc.).  */
2107   int first = -1;
2108   /* The current unit.  */
2109   int i = 0;
2110
2111   char *str;
2112
2113   /* It would be nice to use a macro to do this, but gettext
2114      works on the unpreprocessed code.  */
2115 #define MIN_SECS (60)
2116 #define HOUR_SECS (60 * MIN_SECS)
2117 #define DAY_SECS (24 * HOUR_SECS)
2118 #define MONTH_SECS (30 * DAY_SECS)
2119 #define YEAR_SECS (365 * DAY_SECS)
2120
2121   if (t > YEAR_SECS)
2122     {
2123       years = t / YEAR_SECS;
2124       t -= years * YEAR_SECS;
2125     }
2126   if (t > MONTH_SECS)
2127     {
2128       months = t / MONTH_SECS;
2129       t -= months * MONTH_SECS;
2130     }
2131   if (t > DAY_SECS)
2132     {
2133       days = t / DAY_SECS;
2134       t -= days * DAY_SECS;
2135     }
2136   if (t > HOUR_SECS)
2137     {
2138       hours = t / HOUR_SECS;
2139       t -= hours * HOUR_SECS;
2140     }
2141   if (t > MIN_SECS)
2142     {
2143       minutes = t / MIN_SECS;
2144       t -= minutes * MIN_SECS;
2145     }
2146   seconds = t;
2147
2148 #undef MIN_SECS
2149 #undef HOUR_SECS
2150 #undef DAY_SECS
2151 #undef MONTH_SECS
2152 #undef YEAR_SECS
2153
2154   fp = es_fopenmem (0, "rw,samethread");
2155   if (! fp)
2156     log_fatal ("error creating memory stream: %s\n",
2157                gpg_strerror (gpg_error_from_syserror()));
2158
2159   if (years)
2160     {
2161       /* TRANSLATORS: The tilde ('~') is used here to indicate a
2162        * non-breakable space  */
2163       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
2164       count ++;
2165       first = i;
2166     }
2167   i ++;
2168   if ((first == -1 || i - first <= 3) && months)
2169     {
2170       if (count)
2171         es_fprintf (fp, ", ");
2172       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
2173       count ++;
2174       first = i;
2175     }
2176   i ++;
2177   if ((first == -1 || i - first <= 3) && count < 2 && days)
2178     {
2179       if (count)
2180         es_fprintf (fp, ", ");
2181       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
2182       count ++;
2183       first = i;
2184     }
2185   i ++;
2186   if ((first == -1 || i - first <= 3) && count < 2 && hours)
2187     {
2188       if (count)
2189         es_fprintf (fp, ", ");
2190       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
2191       count ++;
2192       first = i;
2193     }
2194   i ++;
2195   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
2196     {
2197       if (count)
2198         es_fprintf (fp, ", ");
2199       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
2200       count ++;
2201       first = i;
2202     }
2203   i ++;
2204   if ((first == -1 || i - first <= 3) && count < 2)
2205     {
2206       if (count)
2207         es_fprintf (fp, ", ");
2208       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
2209     }
2210
2211   es_fputc (0, fp);
2212   if (es_fclose_snatch (fp, (void **) &str, NULL))
2213     log_fatal ("error snatching memory stream\n");
2214
2215   return str;
2216 }
2217
2218
2219 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2220  * write a "tfs" record to that stream. */
2221 static void
2222 write_stats_status (estream_t fp, long messages, enum tofu_policy policy,
2223                     unsigned long first_seen,
2224                     unsigned long most_recent_seen)
2225 {
2226   const char *validity;
2227
2228   if (messages < 1)
2229     validity = "1"; /* Key without history.  */
2230   else if (messages < BASIC_TRUST_THRESHOLD)
2231     validity = "2"; /* Key with too little history.  */
2232   else if (messages < FULL_TRUST_THRESHOLD)
2233     validity = "3"; /* Key with enough history for basic trust.  */
2234   else
2235     validity = "4"; /* Key with a lot of history.  */
2236
2237   if (fp)
2238     {
2239       es_fprintf (fp, "tfs:1:%s:%ld:0:%s:%lu:%lu:\n",
2240                   validity, messages,
2241                   tofu_policy_str (policy),
2242                   first_seen, most_recent_seen);
2243     }
2244   else
2245     {
2246       char numbuf1[35];
2247       char numbuf2[35];
2248       char numbuf3[35];
2249
2250       snprintf (numbuf1, sizeof numbuf1, " %ld", messages);
2251       *numbuf2 = *numbuf3 = 0;
2252       if (first_seen && most_recent_seen)
2253         {
2254           snprintf (numbuf2, sizeof numbuf2, " %lu", first_seen);
2255           snprintf (numbuf3, sizeof numbuf3, " %lu", most_recent_seen);
2256         }
2257
2258       write_status_strings (STATUS_TOFU_STATS,
2259                             validity, numbuf1, " 0",
2260                             " ", tofu_policy_str (policy),
2261                             numbuf2, numbuf3,
2262                             NULL);
2263     }
2264 }
2265
2266
2267 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2268  * to OUTFP.  In this case USER_ID is not required.  */
2269 static void
2270 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
2271                  const char *email, const char *user_id,
2272                  estream_t outfp)
2273 {
2274   char *fingerprint_pp;
2275   int rc;
2276   strlist_t strlist = NULL;
2277   char *err = NULL;
2278
2279   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2280
2281   rc = gpgsql_exec_printf
2282     (dbs->db, strings_collect_cb, &strlist, &err,
2283      "select count (*), min (signatures.time), max (signatures.time)\n"
2284      " from signatures\n"
2285      " left join bindings on signatures.binding = bindings.oid\n"
2286      " where fingerprint = %Q and email = %Q;",
2287      fingerprint, email);
2288   if (rc)
2289     {
2290       log_error (_("error reading TOFU database: %s\n"), err);
2291       print_further_info ("getting statistics");
2292       sqlite3_free (err);
2293       goto out;
2294     }
2295
2296   if (!outfp)
2297     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
2298                                   email, strlen (email), 0);
2299
2300   if (! strlist)
2301     {
2302       if (!outfp)
2303         log_info (_("Have never verified a message signed by key %s!\n"),
2304                   fingerprint_pp);
2305       write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
2306     }
2307   else
2308     {
2309       unsigned long now = gnupg_get_time ();
2310       signed long messages;
2311       unsigned long first_seen;
2312       unsigned long most_recent_seen;
2313
2314       log_assert (strlist_length (strlist) == 3);
2315
2316       string_to_long (&messages, strlist->d, -1, __LINE__);
2317
2318       if (messages == 0 && *strlist->next->d == '\0')
2319         { /* min(NULL) => NULL => "".  */
2320           first_seen = 0;
2321           most_recent_seen = 0;
2322         }
2323       else
2324         {
2325           string_to_ulong (&first_seen, strlist->next->d, -1, __LINE__);
2326           if (first_seen > now)
2327             {
2328               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2329                          first_seen, now);
2330               first_seen = now;
2331             }
2332           string_to_ulong (&most_recent_seen, strlist->next->next->d, -1,
2333                            __LINE__);
2334           if (most_recent_seen > now)
2335             {
2336               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2337                          most_recent_seen, now);
2338               most_recent_seen = now;
2339             }
2340
2341         }
2342
2343       if (messages == -1 || first_seen == -1)
2344         {
2345           write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
2346           if (!outfp)
2347             log_info (_("Failed to collect signature statistics for \"%s\"\n"
2348                         "(key %s)\n"),
2349                       user_id, fingerprint_pp);
2350         }
2351       else if (outfp)
2352         {
2353           write_stats_status (outfp, messages,
2354                               get_policy (dbs, fingerprint, email, NULL),
2355                               first_seen, most_recent_seen);
2356         }
2357       else
2358         {
2359           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2360           estream_t fp;
2361           char *msg;
2362
2363           write_stats_status (NULL, messages,
2364                               policy,
2365                               first_seen, most_recent_seen);
2366
2367           fp = es_fopenmem (0, "rw,samethread");
2368           if (! fp)
2369             log_fatal ("error creating memory stream: %s\n",
2370                        gpg_strerror (gpg_error_from_syserror()));
2371
2372           if (messages == 0)
2373             {
2374               es_fprintf (fp, _("Verified %ld messages signed by \"%s\"."),
2375                           0L, user_id);
2376               es_fputc ('\n', fp);
2377             }
2378           else
2379             {
2380               char *first_seen_ago_str = time_ago_str (now - first_seen);
2381
2382               /* TRANSLATORS: The final %s is replaced by a string like
2383                  "7 months, 1 day, 5 minutes, 0 seconds". */
2384               es_fprintf (fp,
2385                           ngettext("Verified %ld message signed by \"%s\"\n"
2386                                    "in the past %s.",
2387                                    "Verified %ld messages signed by \"%s\"\n"
2388                                    "in the past %s.",
2389                                    messages),
2390                           messages, user_id, first_seen_ago_str);
2391
2392               if (messages > 1)
2393                 {
2394                   char *tmpstr = time_ago_str (now - most_recent_seen);
2395                   es_fputs ("  ", fp);
2396                   es_fprintf (fp, _("The most recent message was"
2397                                     " verified %s ago."), tmpstr);
2398                   xfree (tmpstr);
2399                 }
2400               xfree (first_seen_ago_str);
2401
2402               if (opt.verbose)
2403                 {
2404                   es_fputs ("  ", fp);
2405                   es_fputc ('(', fp);
2406                   es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2407                   es_fputs (")\n", fp);
2408                 }
2409               else
2410                 es_fputs ("\n", fp);
2411             }
2412
2413           {
2414             char *tmpmsg, *p;
2415             es_fputc (0, fp);
2416             if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2417               log_fatal ("error snatching memory stream\n");
2418             msg = format_text (tmpmsg, 0, 72, 80);
2419             es_free (tmpmsg);
2420
2421             /* Print a status line but suppress the trailing LF.
2422              * Spaces are not percent escaped. */
2423             if (*msg)
2424               write_status_buffer (STATUS_TOFU_STATS_LONG,
2425                                    msg, strlen (msg)-1, -1);
2426
2427             /* Remove the non-breaking space markers.  */
2428             for (p=msg; *p; p++)
2429               if (*p == '~')
2430                 *p = ' ';
2431
2432           }
2433
2434           log_string (GPGRT_LOG_INFO, msg);
2435           xfree (msg);
2436
2437           if (policy == TOFU_POLICY_AUTO && messages < BASIC_TRUST_THRESHOLD)
2438             {
2439               char *set_policy_command;
2440               char *text;
2441               char *tmpmsg;
2442
2443               if (messages == 0)
2444                 log_info (_("Warning: we have yet to see"
2445                             " a message signed by this key and user id!\n"));
2446               else if (messages == 1)
2447                 log_info (_("Warning: we've only seen a single message"
2448                             " signed by this key and user id!\n"));
2449
2450               set_policy_command =
2451                 xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2452
2453               tmpmsg = xasprintf
2454                 (ngettext
2455                  ("Warning: if you think you've seen more than %ld message "
2456                   "signed by this key and user id, then this key might be a "
2457                   "forgery!  Carefully examine the email address for small "
2458                   "variations.  If the key is suspect, then use\n"
2459                   "  %s\n"
2460                   "to mark it as being bad.\n",
2461                   "Warning: if you think you've seen more than %ld messages "
2462                   "signed by this key, then this key might be a forgery!  "
2463                       "Carefully examine the email address for small "
2464                   "variations.  If the key is suspect, then use\n"
2465                   "  %s\n"
2466                   "to mark it as being bad.\n",
2467                   messages),
2468                   messages, set_policy_command);
2469               text = format_text (tmpmsg, 0, 72, 80);
2470               xfree (tmpmsg);
2471               log_string (GPGRT_LOG_INFO, text);
2472               xfree (text);
2473
2474               es_free (set_policy_command);
2475             }
2476         }
2477     }
2478
2479  out:
2480   free_strlist (strlist);
2481   xfree (fingerprint_pp);
2482
2483   return;
2484 }
2485
2486 /* Extract the email address from a user id and normalize it.  If the
2487    user id doesn't contain an email address, then we use the whole
2488    user_id and normalize that.  The returned string must be freed.  */
2489 static char *
2490 email_from_user_id (const char *user_id)
2491 {
2492   char *email = mailbox_from_userid (user_id);
2493   if (! email)
2494     {
2495       /* Hmm, no email address was provided or we are out of core.  Just
2496          take the lower-case version of the whole user id.  It could be
2497          a hostname, for instance.  */
2498       email = ascii_strlwr (xstrdup (user_id));
2499     }
2500
2501   return email;
2502 }
2503
2504 /* Register the signature with the bindings <fingerprint, USER_ID>,
2505    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2506    the primary key packet PK.
2507
2508    SIG_DIGEST_BIN is the binary representation of the message's
2509    digest.  SIG_DIGEST_BIN_LEN is its length.
2510
2511    SIG_TIME is the time that the signature was generated.
2512
2513    ORIGIN is a free-formed string describing the origin of the
2514    signature.  If this was from an email and the Claws MUA was used,
2515    then this should be something like: "email:claws".  If this is
2516    NULL, the default is simply "unknown".
2517
2518    If MAY_ASK is 1, then this function may interact with the user.
2519    This is necessary if there is a conflict or the binding's policy is
2520    TOFU_POLICY_ASK.
2521
2522    This function returns 0 on success and an error code if an error
2523    occured.  */
2524 gpg_error_t
2525 tofu_register (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2526                const byte *sig_digest_bin, int sig_digest_bin_len,
2527                time_t sig_time, const char *origin)
2528 {
2529   gpg_error_t rc;
2530   tofu_dbs_t dbs;
2531   char *fingerprint = NULL;
2532   strlist_t user_id;
2533   char *email = NULL;
2534   char *err = NULL;
2535   char *sig_digest;
2536   unsigned long c;
2537
2538   dbs = opendbs (ctrl);
2539   if (! dbs)
2540     {
2541       rc = gpg_error (GPG_ERR_GENERAL);
2542       log_error (_("error opening TOFU database: %s\n"),
2543                  gpg_strerror (rc));
2544       return rc;
2545     }
2546
2547   /* We do a query and then an insert.  Make sure they are atomic
2548      by wrapping them in a transaction.  */
2549   rc = begin_transaction (ctrl, 0);
2550   if (rc)
2551     return rc;
2552
2553   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2554   fingerprint = hexfingerprint (pk, NULL, 0);
2555
2556   if (! origin)
2557     /* The default origin is simply "unknown".  */
2558     origin = "unknown";
2559
2560   for (user_id = user_id_list; user_id; user_id = user_id->next)
2561     {
2562       email = email_from_user_id (user_id->d);
2563
2564       if (DBG_TRUST)
2565         log_debug ("TOFU: Registering signature %s with binding"
2566                    " <key: %s, user id: %s>\n",
2567                    sig_digest, fingerprint, email);
2568
2569       /* Make sure the binding exists and record any TOFU
2570          conflicts.  */
2571       if (get_trust (ctrl, pk, fingerprint, email, user_id->d, 0)
2572           == _tofu_GET_TRUST_ERROR)
2573         {
2574           rc = gpg_error (GPG_ERR_GENERAL);
2575           xfree (email);
2576           break;
2577         }
2578
2579       /* If we've already seen this signature before, then don't add
2580          it again.  */
2581       rc = gpgsql_stepx
2582         (dbs->db, &dbs->s.register_already_seen,
2583          get_single_unsigned_long_cb2, &c, &err,
2584          "select count (*)\n"
2585          " from signatures left join bindings\n"
2586          "  on signatures.binding = bindings.oid\n"
2587          " where fingerprint = ? and email = ? and sig_time = ?\n"
2588          "  and sig_digest = ?",
2589          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2590          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2591          GPGSQL_ARG_STRING, sig_digest,
2592          GPGSQL_ARG_END);
2593       if (rc)
2594         {
2595           log_error (_("error reading TOFU database: %s\n"), err);
2596           print_further_info ("checking existence");
2597           sqlite3_free (err);
2598         }
2599       else if (c > 1)
2600         /* Duplicates!  This should not happen.  In particular,
2601            because <fingerprint, email, sig_time, sig_digest> is the
2602            primary key!  */
2603         log_debug ("SIGNATURES DB contains duplicate records"
2604                    " <key: %s, fingerprint: %s, time: 0x%lx, sig: %s,"
2605                    " origin: %s>."
2606                    "  Please report.\n",
2607                    fingerprint, email, (unsigned long) sig_time,
2608                    sig_digest, origin);
2609       else if (c == 1)
2610         {
2611           if (DBG_TRUST)
2612             log_debug ("Already observed the signature and binding"
2613                        " <key: %s, user id: %s, time: 0x%lx, sig: %s,"
2614                        " origin: %s>\n",
2615                        fingerprint, email, (unsigned long) sig_time,
2616                        sig_digest, origin);
2617         }
2618       else if (opt.dry_run)
2619         {
2620           log_info ("TOFU database update skipped due to --dry-run\n");
2621         }
2622       else
2623         /* This is the first time that we've seen this signature and
2624            binding.  Record it.  */
2625         {
2626           if (DBG_TRUST)
2627             log_debug ("TOFU: Saving signature"
2628                        " <key: %s, user id: %s, sig: %s>\n",
2629                        fingerprint, email, sig_digest);
2630
2631           log_assert (c == 0);
2632
2633           rc = gpgsql_stepx
2634             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2635              "insert into signatures\n"
2636              " (binding, sig_digest, origin, sig_time, time)\n"
2637              " values\n"
2638              " ((select oid from bindings\n"
2639              "    where fingerprint = ? and email = ?),\n"
2640              "  ?, ?, ?, strftime('%s', 'now'));",
2641              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2642              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
2643              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2644              GPGSQL_ARG_END);
2645           if (rc)
2646             {
2647               log_error (_("error updating TOFU database: %s\n"), err);
2648               print_further_info ("insert signatures");
2649               sqlite3_free (err);
2650             }
2651         }
2652
2653       xfree (email);
2654
2655       if (rc)
2656         break;
2657     }
2658
2659   if (rc)
2660     rollback_transaction (ctrl);
2661   else
2662     rc = end_transaction (ctrl, 0);
2663
2664   xfree (fingerprint);
2665   xfree (sig_digest);
2666
2667   return rc;
2668 }
2669
2670 /* Combine a trust level returned from the TOFU trust model with a
2671    trust level returned by the PGP trust model.  This is primarily of
2672    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2673
2674    This function ors together the upper bits (the values not covered
2675    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2676 int
2677 tofu_wot_trust_combine (int tofu_base, int wot_base)
2678 {
2679   int tofu = tofu_base & TRUST_MASK;
2680   int wot = wot_base & TRUST_MASK;
2681   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2682
2683   log_assert (tofu == TRUST_UNKNOWN
2684               || tofu == TRUST_EXPIRED
2685               || tofu == TRUST_UNDEFINED
2686               || tofu == TRUST_NEVER
2687               || tofu == TRUST_MARGINAL
2688               || tofu == TRUST_FULLY
2689               || tofu == TRUST_ULTIMATE);
2690   log_assert (wot == TRUST_UNKNOWN
2691               || wot == TRUST_EXPIRED
2692               || wot == TRUST_UNDEFINED
2693               || wot == TRUST_NEVER
2694               || wot == TRUST_MARGINAL
2695               || wot == TRUST_FULLY
2696               || wot == TRUST_ULTIMATE);
2697
2698   /* We first consider negative trust policys.  These trump positive
2699      trust policies.  */
2700   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2701     /* TRUST_NEVER trumps everything else.  */
2702     return upper | TRUST_NEVER;
2703   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2704     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2705     return upper | TRUST_EXPIRED;
2706
2707   /* Now we only have positive or neutral trust policies.  We take
2708      the max.  */
2709   if (tofu == TRUST_ULTIMATE)
2710     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
2711   if (wot == TRUST_ULTIMATE)
2712     return upper | TRUST_ULTIMATE;
2713
2714   if (tofu == TRUST_FULLY)
2715     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
2716   if (wot == TRUST_FULLY)
2717     return upper | TRUST_FULLY;
2718
2719   if (tofu == TRUST_MARGINAL)
2720     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
2721   if (wot == TRUST_MARGINAL)
2722     return upper | TRUST_MARGINAL;
2723
2724   if (tofu == TRUST_UNDEFINED)
2725     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
2726   if (wot == TRUST_UNDEFINED)
2727     return upper | TRUST_UNDEFINED;
2728
2729   return upper | TRUST_UNKNOWN;
2730 }
2731
2732
2733 /* Write a "tfs" record for a --with-colons listing.  */
2734 gpg_error_t
2735 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
2736                        PKT_public_key *pk, const char *user_id)
2737 {
2738   gpg_error_t err;
2739   tofu_dbs_t dbs;
2740   char *fingerprint;
2741   char *email;
2742
2743   if (!*user_id)
2744     return 0;  /* No TOFU stats possible for an empty ID.  */
2745
2746   dbs = opendbs (ctrl);
2747   if (!dbs)
2748     {
2749       err = gpg_error (GPG_ERR_GENERAL);
2750       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
2751       return err;
2752     }
2753
2754   fingerprint = hexfingerprint (pk, NULL, 0);
2755   email = email_from_user_id (user_id);
2756
2757   show_statistics (dbs, fingerprint, email, user_id, fp);
2758
2759   xfree (email);
2760   xfree (fingerprint);
2761   return 0;
2762 }
2763
2764
2765 /* Return the validity (TRUST_NEVER, etc.) of the bindings
2766    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
2767    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
2768
2769    PK is the primary key packet.
2770
2771    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2772    will be prompted to choose a policy.  If MAY_ASK is 0 and the
2773    policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2774
2775    Returns TRUST_UNDEFINED if an error occurs.  */
2776 int
2777 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2778                    int may_ask)
2779 {
2780   tofu_dbs_t dbs;
2781   char *fingerprint = NULL;
2782   strlist_t user_id;
2783   int trust_level = TRUST_UNKNOWN;
2784   int bindings = 0;
2785   int bindings_valid = 0;
2786
2787   dbs = opendbs (ctrl);
2788   if (! dbs)
2789     {
2790       log_error (_("error opening TOFU database: %s\n"),
2791                  gpg_strerror (GPG_ERR_GENERAL));
2792       return TRUST_UNDEFINED;
2793     }
2794
2795   fingerprint = hexfingerprint (pk, NULL, 0);
2796
2797   tofu_begin_batch_update (ctrl);
2798   tofu_resume_batch_transaction (ctrl);
2799
2800   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
2801     {
2802       char *email = email_from_user_id (user_id->d);
2803
2804       /* Always call get_trust to make sure the binding is
2805          registered.  */
2806       int tl = get_trust (ctrl, pk, fingerprint, email, user_id->d, may_ask);
2807       if (tl == _tofu_GET_TRUST_ERROR)
2808         {
2809           /* An error.  */
2810           trust_level = TRUST_UNDEFINED;
2811           xfree (email);
2812           goto die;
2813         }
2814
2815       if (DBG_TRUST)
2816         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
2817                    fingerprint, email,
2818                    trust_value_to_string (tl),
2819                    user_id->flags ? " (but expired)" : "");
2820
2821       if (user_id->flags)
2822         tl = TRUST_EXPIRED;
2823
2824       if (tl != TRUST_EXPIRED)
2825         bindings_valid ++;
2826
2827       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
2828         show_statistics (dbs, fingerprint, email, user_id->d, NULL);
2829
2830       if (tl == TRUST_NEVER)
2831         trust_level = TRUST_NEVER;
2832       else if (tl == TRUST_EXPIRED)
2833         /* Ignore expired bindings in the trust calculation.  */
2834         ;
2835       else if (tl > trust_level)
2836         {
2837           /* The expected values: */
2838           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
2839                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
2840                       || tl == TRUST_ULTIMATE);
2841
2842           /* We assume the following ordering:  */
2843           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
2844           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
2845           log_assert (TRUST_MARGINAL < TRUST_FULLY);
2846           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
2847
2848           trust_level = tl;
2849         }
2850
2851       xfree (email);
2852     }
2853
2854  die:
2855   tofu_end_batch_update (ctrl);
2856
2857   xfree (fingerprint);
2858
2859   if (bindings_valid == 0)
2860     {
2861       if (DBG_TRUST)
2862         log_debug ("no (of %d) valid bindings."
2863                    "  Can't get TOFU validity for this set of user ids.\n",
2864                    bindings);
2865       return TRUST_NEVER;
2866     }
2867
2868   return trust_level;
2869 }
2870
2871 /* Set the policy for all non-revoked user ids in the keyblock KB to
2872    POLICY.
2873
2874    If no key is available with the specified key id, then this
2875    function returns GPG_ERR_NO_PUBKEY.
2876
2877    Returns 0 on success and an error code otherwise.  */
2878 gpg_error_t
2879 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
2880 {
2881   tofu_dbs_t dbs;
2882   PKT_public_key *pk;
2883   char *fingerprint = NULL;
2884
2885   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2886   pk = kb->pkt->pkt.public_key;
2887
2888   dbs = opendbs (ctrl);
2889   if (! dbs)
2890     {
2891       log_error (_("error opening TOFU database: %s\n"),
2892                  gpg_strerror (GPG_ERR_GENERAL));
2893       return gpg_error (GPG_ERR_GENERAL);
2894     }
2895
2896   if (DBG_TRUST)
2897     log_debug ("Setting TOFU policy for %s to %s\n",
2898                keystr (pk->keyid), tofu_policy_str (policy));
2899   if (! (pk->main_keyid[0] == pk->keyid[0]
2900          && pk->main_keyid[1] == pk->keyid[1]))
2901     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2902
2903   fingerprint = hexfingerprint (pk, NULL, 0);
2904
2905   begin_transaction (ctrl, 0);
2906
2907   for (; kb; kb = kb->next)
2908     {
2909       PKT_user_id *user_id;
2910       char *email;
2911
2912       if (kb->pkt->pkttype != PKT_USER_ID)
2913         continue;
2914
2915       user_id = kb->pkt->pkt.user_id;
2916       if (user_id->is_revoked)
2917         /* Skip revoked user ids.  (Don't skip expired user ids, the
2918            expiry can be changed.)  */
2919         continue;
2920
2921       email = email_from_user_id (user_id->name);
2922
2923       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2924
2925       xfree (email);
2926     }
2927
2928   end_transaction (ctrl, 0);
2929
2930   xfree (fingerprint);
2931   return 0;
2932 }
2933
2934 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2935    the key id KEYID to POLICY.
2936
2937    If no key is available with the specified key id, then this
2938    function returns GPG_ERR_NO_PUBKEY.
2939
2940    Returns 0 on success and an error code otherwise.  */
2941 gpg_error_t
2942 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
2943 {
2944   kbnode_t keyblock = get_pubkeyblock (keyid);
2945   if (! keyblock)
2946     return gpg_error (GPG_ERR_NO_PUBKEY);
2947
2948   return tofu_set_policy (ctrl, keyblock, policy);
2949 }
2950
2951 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2952    policy has been set for the binding, sets *POLICY to
2953    TOFU_POLICY_NONE.
2954
2955    PK is a primary public key and USER_ID is a user id.
2956
2957    Returns 0 on success and an error code otherwise.  */
2958 gpg_error_t
2959 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
2960                  enum tofu_policy *policy)
2961 {
2962   tofu_dbs_t dbs;
2963   char *fingerprint;
2964   char *email;
2965
2966   /* Make sure PK is a primary key.  */
2967   log_assert (pk->main_keyid[0] == pk->keyid[0]
2968               && pk->main_keyid[1] == pk->keyid[1]);
2969
2970   dbs = opendbs (ctrl);
2971   if (! dbs)
2972     {
2973       log_error (_("error opening TOFU database: %s\n"),
2974                  gpg_strerror (GPG_ERR_GENERAL));
2975       return gpg_error (GPG_ERR_GENERAL);
2976     }
2977
2978   fingerprint = hexfingerprint (pk, NULL, 0);
2979
2980   email = email_from_user_id (user_id->name);
2981
2982   *policy = get_policy (dbs, fingerprint, email, NULL);
2983
2984   xfree (email);
2985   xfree (fingerprint);
2986   if (*policy == _tofu_GET_POLICY_ERROR)
2987     return gpg_error (GPG_ERR_GENERAL);
2988   return 0;
2989 }