LCOV - code coverage report
Current view: top level - g10 - tdbdump.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 44 97 45.4 %
Date: 2016-11-29 15:00:56 Functions: 2 4 50.0 %

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

Generated by: LCOV version 1.11