Marked all unused args on non-W32 platforms.
[gnupg.git] / g10 / gpgv.c
1 /* gpgv.c - The GnuPG signature verify utility
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2005,
3  *               2006 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #ifdef HAVE_DOSISH_SYSTEM
29 #include <fcntl.h> /* for setmode() */
30 #endif
31 #ifdef HAVE_LIBREADLINE
32 #define GNUPG_LIBREADLINE_H_INCLUDED
33 #include <readline/readline.h>
34 #endif
35
36 #define INCLUDED_BY_MAIN_MODULE 1
37 #include "gpg.h"
38 #include "packet.h"
39 #include "iobuf.h"
40 #include "util.h"
41 #include "main.h"
42 #include "options.h"
43 #include "keydb.h"
44 #include "trustdb.h"
45 #include "cipher.h"
46 #include "filter.h"
47 #include "ttyio.h"
48 #include "i18n.h"
49 #include "sysutils.h"
50 #include "status.h"
51 #include "call-agent.h"
52
53
54 enum cmd_and_opt_values { aNull = 0,
55     oQuiet        = 'q',
56     oVerbose      = 'v',
57     oBatch        = 500,
58     oKeyring,
59     oIgnoreTimeConflict,                      
60     oStatusFD,
61     oLoggerFD,
62     oHomedir,
63 aTest };
64
65
66 static ARGPARSE_OPTS opts[] = {
67
68     { 301, NULL, 0, N_("@\nOptions:\n ") },
69
70     { oVerbose, "verbose",   0, N_("verbose") },
71     { oQuiet,   "quiet",     0, N_("be somewhat more quiet") },
72     { oKeyring, "keyring"   ,2, N_("take the keys from this keyring")},
73     { oIgnoreTimeConflict, "ignore-time-conflict", 0, 
74                            N_("make timestamp conflicts only a warning") },
75     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
76     { oLoggerFD, "logger-fd",1, "@" },
77     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
78
79 {0} };
80
81
82
83 int g10_errors_seen = 0;
84
85 static const char *
86 my_strusage( int level )
87 {
88     const char *p;
89     switch( level ) {
90       case 11: p = "gpgv (GnuPG)";
91         break;
92       case 13: p = VERSION; break;
93       case 17: p = PRINTABLE_OS_NAME; break;
94       case 19: p =
95             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
96         break;
97       case 1:
98       case 40:  p =
99             _("Usage: gpgv [options] [files] (-h for help)");
100         break;
101       case 41:  p =
102             _("Syntax: gpg [options] [files]\n"
103               "Check signatures against known trusted keys\n");
104         break;
105
106       default:  p = NULL;
107     }
108     return p;
109 }
110
111
112
113 int
114 main( int argc, char **argv )
115 {
116     ARGPARSE_ARGS pargs;
117     int rc=0;
118     strlist_t sl;
119     strlist_t nrings=NULL;
120     unsigned configlineno;
121
122     set_strusage (my_strusage);
123     log_set_prefix ("gpgv", 1);
124
125     /* Make sure that our subsystems are ready.  */
126     init_common_subsystems ();
127
128     gnupg_init_signals (0, NULL);
129     i18n_init();
130
131     opt.command_fd = -1; /* no command fd */
132     opt.pgp2_workarounds = 1;
133     opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
134     opt.trust_model = TM_ALWAYS;
135     opt.batch = 1;
136
137     opt.homedir = default_homedir ();
138
139     tty_no_terminal(1);
140     tty_batchmode(1);
141     disable_dotlock();
142
143     pargs.argc = &argc;
144     pargs.argv = &argv;
145     pargs.flags=  1;  /* do not remove the args */
146     while( optfile_parse( NULL, NULL, &configlineno, &pargs, opts) ) {
147         switch( pargs.r_opt ) {
148           case oQuiet: opt.quiet = 1; break;
149           case oVerbose: 
150             opt.verbose++; 
151             opt.list_sigs=1;
152             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
153             break;
154           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
155           case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
156           case oLoggerFD: 
157             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
158             break;
159           case oHomedir: opt.homedir = pargs.r.ret_str; break;
160           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
161           default : pargs.err = 2; break;
162         }
163     }
164
165     if( log_get_errorcount(0) )
166         g10_exit(2);
167
168      if( opt.verbose > 1 )
169         set_packet_list_mode(1);
170
171     if( !nrings )  /* no keyring given: use default one */
172         keydb_add_resource ("trustedkeys" EXTSEP_S "gpg", 0, 0);
173     for(sl = nrings; sl; sl = sl->next )
174         keydb_add_resource (sl->d, 0, 0 );
175     
176     FREE_STRLIST (nrings);
177     
178     if( (rc = verify_signatures( argc, argv ) ))
179         log_error("verify signatures failed: %s\n", g10_errstr(rc) );
180
181     /* cleanup */
182     g10_exit(0);
183     return 8; /*NEVER REACHED*/
184 }
185
186
187 void
188 g10_exit( int rc )
189 {
190     rc = rc? rc : log_get_errorcount(0)? 2 :
191                         g10_errors_seen? 1 : 0;
192     exit(rc );
193 }
194
195
196 /* Stub:
197  * We have to override the trustcheck from pkclist.c becuase 
198  * this utility assumes that all keys in the keyring are trustworthy
199  */
200 int
201 check_signatures_trust( PKT_signature *sig )
202 {
203   (void)sig;
204   return 0;
205 }
206
207 void
208 read_trust_options(byte *trust_model, ulong *created, ulong *nextcheck,
209                    byte *marginals, byte *completes, byte *cert_depth) 
210 {
211   (void)trust_model;
212   (void)created;
213   (void)nextcheck;
214   (void)marginals;
215   (void)completes;
216   (void)cert_depth;
217 }
218
219 /* Stub: 
220  * We don't have the trustdb , so we have to provide some stub functions
221  * instead
222  */
223
224 int
225 cache_disabled_value(PKT_public_key *pk)
226 {
227   (void)pk;
228   return 0;
229 }
230
231 void
232 check_trustdb_stale(void) 
233 {
234 }
235
236 int
237 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
238 {
239   (void)pk;
240   (void)uid;
241   return '?';
242 }
243
244 unsigned int
245 get_validity (PKT_public_key *pk, PKT_user_id *uid)
246 {
247   (void)pk;
248   (void)uid;
249   return 0;
250 }
251
252 const char *
253 trust_value_to_string (unsigned int value)
254 {
255   (void)value;
256   return "err";
257 }
258
259 const char *
260 uid_trust_string_fixed (PKT_public_key *key, PKT_user_id *uid)
261 {
262   (void)key;
263   (void)uid;
264   return "err";
265 }
266
267 int
268 get_ownertrust_info (PKT_public_key *pk)
269 {
270   (void)pk;
271   return '?';
272 }
273
274 unsigned int
275 get_ownertrust (PKT_public_key *pk)
276 {
277   (void)pk;
278   return TRUST_UNKNOWN;
279 }
280
281
282 /* Stubs:
283  * Because we only work with trusted keys, it does not make sense to
284  * get them from a keyserver
285  */
286
287 struct keyserver_spec *
288 keyserver_match (struct keyserver_spec *spec)
289 {
290   (void)spec;
291   return NULL; 
292 }
293
294 int
295 keyserver_import_keyid (u32 *keyid, void *dummy)
296 {
297   (void)keyid;
298   (void)dummy;
299   return -1;
300 }
301
302 int
303 keyserver_import_cert (const char *name)
304 {
305   (void)name;
306   return -1; 
307 }
308
309 int
310 keyserver_import_pka (const char *name,unsigned char *fpr)
311 {
312   (void)name;
313   (void)fpr;
314   return -1;
315 }
316
317 int
318 keyserver_import_name (const char *name,struct keyserver_spec *spec)
319 {
320   (void)name;
321   (void)spec;
322   return -1;
323 }
324
325 int
326 keyserver_import_ldap (const char *name)
327 {
328   (void)name;
329   return -1;
330 }
331
332 /* Stub:
333  * No encryption here but mainproc links to these functions.
334  */
335 int
336 get_session_key (PKT_pubkey_enc *k, DEK *dek)
337 {
338   (void)k;
339   (void)dek;
340   return G10ERR_GENERAL;
341 }
342
343 /* Stub: */
344 int
345 get_override_session_key (DEK *dek, const char *string)
346 {
347   (void)dek;
348   (void)string;
349   return G10ERR_GENERAL;
350 }
351
352 /* Stub: */
353 int
354 decrypt_data (void *procctx, PKT_encrypted *ed, DEK *dek)
355 {
356   (void)procctx;
357   (void)ed;
358   (void)dek;
359   return G10ERR_GENERAL;
360 }
361
362
363 /* Stub:
364  * No interactive commands, so we don't need the helptexts
365  */
366 void
367 display_online_help (const char *keyword)
368 {
369   (void)keyword;
370 }
371
372 /* Stub:
373  * We don't use secret keys, but getkey.c links to this
374  */
375 int
376 check_secret_key (PKT_secret_key *sk, int n)
377 {
378   (void)sk;
379   (void)n;
380   return G10ERR_GENERAL;
381 }
382
383 /* Stub:
384  * No secret key, so no passphrase needed 
385  */
386 DEK *
387 passphrase_to_dek (u32 *keyid, int pubkey_algo,
388                    int cipher_algo, STRING2KEY *s2k, int mode,
389                    const char *tmp, int *canceled)
390 {
391   (void)keyid;
392   (void)pubkey_algo;
393   (void)cipher_algo;
394   (void)s2k;
395   (void)mode;
396   (void)tmp;
397
398   if (canceled)
399     *canceled = 0;
400   return NULL;
401 }
402
403 struct keyserver_spec *
404 parse_preferred_keyserver(PKT_signature *sig) 
405 {
406   (void)sig;
407   return NULL;
408 }
409
410 struct keyserver_spec *
411 parse_keyserver_uri (const char *uri, int require_scheme,
412                      const char *configname, unsigned int configlineno)
413 {
414   (void)uri;
415   (void)require_scheme;
416   (void)configname;
417   (void)configlineno;
418   return NULL;
419 }
420
421 void 
422 free_keyserver_spec (struct keyserver_spec *keyserver)
423 {
424   (void)keyserver;
425 }
426
427 /* Stubs to avoid linking to photoid.c */
428 void 
429 show_photos (const struct user_attribute *attrs, int count, PKT_public_key *pk)
430 {
431   (void)attrs;
432   (void)count;
433   (void)pk;
434 }
435
436 int 
437 parse_image_header (const struct user_attribute *attr, byte *type, u32 *len)
438 {
439   (void)attr;
440   (void)type;
441   (void)len;
442   return 0;
443 }
444
445 char *
446 image_type_to_string (byte type, int string)
447 {
448   (void)type;
449   (void)string;
450   return NULL;
451 }
452
453 #ifdef ENABLE_CARD_SUPPORT
454 int 
455 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
456 {
457   (void)name;
458   (void)info;
459   return 0;
460 }
461 #endif /* ENABLE_CARD_SUPPORT */
462
463 /* We do not do any locking, so use these stubs here */
464 void 
465 disable_dotlock (void)
466 {
467 }
468
469 DOTLOCK 
470 create_dotlock (const char *file_to_lock)
471 {
472   (void)file_to_lock;
473   return NULL;
474 }
475
476 void 
477 destroy_dotlock (DOTLOCK h)
478 {
479   (void)h;
480 }
481
482 int
483 make_dotlock (DOTLOCK h, long timeout)
484 {
485   (void)h;
486   (void)timeout;
487   return 0;
488 }
489
490 int
491 release_dotlock (DOTLOCK h)
492 {
493   (void)h;
494   return 0;
495 }
496
497 void 
498 remove_lockfiles (void)
499 {
500 }
501