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