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