started with trust stuff
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 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 2 of the License, or
9  * (at your option) any later version.
10  *
11  * G10 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <assert.h>
28
29 #include "errors.h"
30 #include "iobuf.h"
31 #include "keydb.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "options.h"
36
37
38 #define TRUST_RECORD_LEN 40
39
40 struct trust_record {
41     byte rectype;
42     byte reserved;
43     union {
44         byte raw[TRUST_RECORD_LEN-2];
45         struct {            /* version record: */
46             byte magic[2];
47             byte version;   /* should be 1 */
48             byte reserved[3];
49             u32  locked;    /* pid of process which holds a lock */
50             u32  created;   /* timestamp of trustdb creation  */
51             u32  modified;  /* timestamp of last modification */
52             u32  validated; /* timestamp of last validation   */
53             u32  local_id_counter;
54             byte marginals_needed;
55             byte completes_needed;
56             byte max_cert_depth;
57         } version;
58         struct {            /* public key record */
59             u32 local_id;
60             u32 keyid[2];
61             byte algo;
62             byte reserved;
63             byte fingerprint[20];
64             byte ownertrust;
65         } pubkey;
66         struct {            /* cache record */
67             u32 local_id;
68             u32 keyid[2];
69             byte valid;
70             byte reserved;
71             byte blockhash[20];
72             byte n_untrusted;
73             byte n_marginal;
74             byte n_fully;
75             byte trustlevel;
76         } cache;
77     } r;
78 };
79
80
81
82 static char *db_name;
83
84 /**************************************************
85  ************** read and write helpers ************
86  **************************************************/
87
88 static void
89 fwrite_8(FILE *fp, byte a)
90 {
91     if( putc( a & 0xff, fp ) == EOF )
92         log_fatal("error writing byte to trustdb: %s\n", strerror(errno) );
93 }
94
95 static void
96 fwrite_16(FILE *fp, u16 a)
97 {
98     putc( (a>>8) & 0x0ff , fp );
99     if( putc( a & 0xff, fp ) == EOF )
100         log_fatal("error writing u16 to trustdb: %s\n", strerror(errno) );
101 }
102
103 static int
104 fwrite_32( FILE*fp, u32 a)
105 {
106     putc( (a>>24) & 0xff, fp );
107     putc( (a>>16) & 0xff, fp );
108     putc( (a>> 8) & 0xff, fp );
109     if( putc( a & 0xff, fp ) == EOF )
110         log_fatal("error writing u32 to trustdb: %s\n", strerror(errno) );
111 }
112
113 static int
114 fwrite_zeros( FILE *fp, size_t n)
115 {
116     while( n-- )
117         if( putc( 0, fp ) == EOF )
118             log_fatal("error writing zeros to trustdb: %s\n", strerror(errno) );
119 }
120
121
122 /**************************************************
123  ************** read and write stuff **************
124  **************************************************/
125
126
127 /****************
128  * Create a new trustdb
129  */
130 static void
131 create_db( const char *fname )
132 {
133     FILE *fp;
134     u32 along;
135     u16 ashort;
136
137     fp =fopen( fname, "w" );
138     if( !fp )
139         log_fatal("can't create %s: %s\n", fname, strerror(errno) );
140     fwrite_8( fp, 1 );
141     fwrite_8( fp, 'g' );
142     fwrite_8( fp, '1' );
143     fwrite_8( fp, '0' );
144     fwrite_8( fp, 1 );  /* version */
145     fwrite_zeros( fp, 3 ); /* reserved */
146     fwrite_32( fp, 0 ); /* not locked */
147     fwrite_32( fp, make_timestamp() ); /* created */
148     fwrite_32( fp, 0 ); /* not yet modified */
149     fwrite_32( fp, 0 ); /* not yet validated*/
150     fwrite_32( fp, 0 ); /* local-id-counter */
151     fwrite_8( fp, 3 );  /* marginals needed */
152     fwrite_8( fp, 1 );  /* completes needed */
153     fwrite_8( fp, 4 );  /* max_cet_depth */
154     fwrite_zeros( fp, 9 ); /* filler */
155     fclose(fp);
156 }
157
158
159
160
161
162
163
164
165
166
167
168
169
170 /***********************************************
171  *************  trust logic  *******************
172  ***********************************************/
173
174
175
176
177
178 /*********************************************************
179  ****************  API Interface  ************************
180  *********************************************************/
181
182 /****************
183  * Perform some checks over the trustdb
184  *  level 0: used on initial program startup
185  */
186 int
187 check_trustdb( int level )
188 {
189     if( !level ) {
190         char *fname = make_filename("~/.g10", "trustDB", NULL );
191         if( access( fname, R_OK ) ) {
192             if( errno != ENOENT ) {
193                 log_error("can't access %s: %s\n", fname, strerror(errno) );
194                 m_free(fname);
195                 return G10ERR_TRUSTDB;
196             }
197             create_db( fname );
198         }
199         m_free(db_name);
200         db_name = fname;
201
202         /* we can verify a signature about our local data (secring and trustdb)
203          * in ~/.g10/ here
204          */
205     }
206     else
207         log_bug(NULL);
208
209     return 0;
210 }
211
212
213 /****************
214  * Get the trustlevel for this PKC.
215  * Note: This does not ask any questions
216  * Returns: 0 okay of an errorcode
217  *
218  * It operates this way:
219  *  locate the pkc in the trustdb
220  *      found:
221  *          Do we have a valid cache record for it?
222  *              yes: return trustlevel from cache
223  *              no:  make a cache record
224  *      not found:
225  *          Return with a trustlevel, saying that we do not have
226  *          a trust record for it. The caller may use insert_trust_record()
227  *          and then call this function here again.
228  *
229  * Problems: How do we get the complete keyblock to check that the
230  *           cache record is actually valid?  Think we need a clever
231  *           cache in getkey.c  to keep track of this stuff. Maybe it
232  *           is not necessary to check this if we use a local pubring. Hmmmm.
233  */
234 int
235 check_pkc_trust( PKT_public_cert *pkc, int *r_trustlevel )
236 {
237     int trustlevel = 0;
238
239     if( opt.verbose )
240         log_info("check_pkc_trust() called.\n");
241
242     *r_trustlevel = trustlevel;
243     return 0;
244 }
245