g10/tdbdump.c

   1 /* tdbdump.c
   2  * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   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 #include <config.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <ctype.h>
  26 #include <assert.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31
  32 #include "gpg.h"
  33 #include "status.h"
  34 #include "iobuf.h"
  35 #include "keydb.h"
  36 #include "util.h"
  37 #include "trustdb.h"
  38 #include "options.h"
  39 #include "packet.h"
  40 #include "main.h"
  41 #include "i18n.h"
  42 #include "tdbio.h"
  43
  44
  45 #define HEXTOBIN(x) ( (x) >= '0' && (x) <= '9' ? ((x)-'0') : \
  46                       (x) >= 'A' && (x) <= 'F' ? ((x)-'A'+10) : ((x)-'a'+10))
  47
  48
  49 /****************
  50  * Wirte a record but die on error
  51  */
  52 static void
  53 write_record( TRUSTREC *rec )
  54 {
  55     int rc = tdbio_write_record( rec );
  56     if( !rc )
  57         return;
  58     log_error(_("trust record %lu, type %d: write failed: %s\n"),
  59                             rec->recnum, rec->rectype, g10_errstr(rc) );
  60     tdbio_invalid();
  61 }
  62
  63
  64 /****************
  65  * Dump the entire trustdb or only the entries of one key.
  66  */
  67 void
  68 list_trustdb( const char *username )
  69 {
  70   TRUSTREC rec;
  71
  72   (void)username;
  73
  74   init_trustdb();
  75   /* For now we ignore the user ID. */
  76   if (1)
  77     {
  78       ulong recnum;
  79       int i;
  80
  81       printf("TrustDB: %s\n", tdbio_get_dbname() );
  82       for(i=9+strlen(tdbio_get_dbname()); i > 0; i-- )
  83         putchar('-');
  84       putchar('\n');
  85       for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ )
  86         tdbio_dump_record( &rec, stdout );
  87     }
  88 }
  89
  90
  91
  92
  93
  94 /****************
  95  * Print a list of all defined owner trust value.
  96  */
  97 void
  98 export_ownertrust()
  99 {
 100     TRUSTREC rec;
 101     ulong recnum;
 102     int i;
 103     byte *p;
 104
 105     init_trustdb();
 106     printf(_("# List of assigned trustvalues, created %s\n"
 107              "# (Use \"gpg --import-ownertrust\" to restore them)\n"),
 108            asctimestamp( make_timestamp() ) );
 109     for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ ) {
 110         if( rec.rectype == RECTYPE_TRUST ) {
 111             if( !rec.r.trust.ownertrust )
 112                 continue;
 113             p = rec.r.trust.fingerprint;
 114             for(i=0; i < 20; i++, p++ )
 115                 printf("%02X", *p );
 116             printf(":%u:\n", (unsigned int)rec.r.trust.ownertrust );
 117         }
 118     }
 119 }
 120
 121
 122 void
 123 import_ownertrust( const char *fname )
 124 {
 125     FILE *fp;
 126     int is_stdin=0;
 127     char line[256];
 128     char *p;
 129     size_t n, fprlen;
 130     unsigned int otrust;
 131     byte fpr[20];
 132     int any = 0;
 133     int rc;
 134
 135     init_trustdb();
 136     if( iobuf_is_pipe_filename (fname) ) {
 137         fp = stdin;
 138         fname = "[stdin]";
 139         is_stdin = 1;
 140     }
 141     else if( !(fp = fopen( fname, "r" )) ) {
 142         log_error ( _("can't open `%s': %s\n"), fname, strerror(errno) );
 143         return;
 144     }
 145
 146     if (is_secured_file (fileno (fp)))
 147       {
 148         fclose (fp);
 149         errno = EPERM;
 150         log_error (_("can't open `%s': %s\n"), fname, strerror(errno) );
 151         return;
 152       }
 153
 154     while( fgets( line, DIM(line)-1, fp ) ) {
 155         TRUSTREC rec;
 156
 157         if( !*line || *line == '#' )
 158             continue;
 159         n = strlen(line);
 160         if( line[n-1] != '\n' ) {
 161             log_error (_("error in `%s': %s\n"), fname, _("line too long") );
 162             /* ... or last line does not have a LF */
 163             break; /* can't continue */
 164         }
 165         for(p = line; *p && *p != ':' ; p++ )
 166             if( !hexdigitp(p) )
 167                 break;
 168         if( *p != ':' ) {
 169             log_error (_("error in `%s': %s\n"), fname, _("colon missing") );
 170             continue;
 171         }
 172         fprlen = p - line;
 173         if( fprlen != 32 && fprlen != 40 ) {
 174             log_error (_("error in `%s': %s\n"),
 175                        fname, _("invalid fingerprint") );
 176             continue;
 177         }
 178         if( sscanf(p, ":%u:", &otrust ) != 1 ) {
 179             log_error (_("error in `%s': %s\n"),
 180                        fname, _("ownertrust value missing"));
 181             continue;
 182         }
 183         if( !otrust )
 184             continue; /* no otrust defined - no need to update or insert */
 185         /* convert the ascii fingerprint to binary */
 186         for(p=line, fprlen=0; fprlen < 20 && *p != ':'; p += 2 )
 187             fpr[fprlen++] = HEXTOBIN(p[0]) * 16 + HEXTOBIN(p[1]);
 188         while (fprlen < 20)
 189             fpr[fprlen++] = 0;
 190
 191         rc = tdbio_search_trust_byfpr (fpr, &rec);
 192         if( !rc ) { /* found: update */
 193             if (rec.r.trust.ownertrust != otrust)
 194               {
 195                 if( rec.r.trust.ownertrust )
 196                   log_info("changing ownertrust from %u to %u\n",
 197                            rec.r.trust.ownertrust, otrust );
 198                 else
 199                   log_info("setting ownertrust to %u\n", otrust );
 200                 rec.r.trust.ownertrust = otrust;
 201                 write_record (&rec );
 202                 any = 1;
 203               }
 204         }
 205         else if( rc == -1 ) { /* not found: insert */
 206             log_info("inserting ownertrust of %u\n", otrust );
 207             memset (&rec, 0, sizeof rec);
 208             rec.recnum = tdbio_new_recnum ();
 209             rec.rectype = RECTYPE_TRUST;
 210             memcpy (rec.r.trust.fingerprint, fpr, 20);
 211             rec.r.trust.ownertrust = otrust;
 212             write_record (&rec );
 213             any = 1;
 214         }
 215         else /* error */
 216             log_error (_("error finding trust record in `%s': %s\n"),
 217                        fname, g10_errstr(rc));
 218     }
 219     if( ferror(fp) )
 220         log_error ( _("read error in `%s': %s\n"), fname, strerror(errno) );
 221     if( !is_stdin )
 222         fclose(fp);
 223
 224     if (any)
 225       {
 226         revalidation_mark ();
 227         rc = tdbio_sync ();
 228         if (rc)
 229           log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
 230       }
 231
 232 }
 233
 234