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