ready for a new release
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GNUPG utility (main for gpg)
2  *      Copyright (C) 1998 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 2 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, 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 <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 /* #define MAINTAINER_OPTIONS */
29
30 #include "packet.h"
31 #include "iobuf.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "main.h"
35 #include "options.h"
36 #include "keydb.h"
37 #include "mpi.h"
38 #include "cipher.h"
39 #include "filter.h"
40 #include "trustdb.h"
41 #include "ttyio.h"
42 #include "i18n.h"
43 #include "status.h"
44
45 #ifndef IS_G10MAINT
46   #define IS_G10 1
47 #endif
48
49
50 static ARGPARSE_OPTS opts[] = {
51
52     { 300, NULL, 0, N_("@Commands:\n ") },
53
54   #ifdef IS_G10
55     { 's', "sign",      256, N_("|[file]|make a signature")},
56     { 539, "clearsign", 256, N_("|[file]|make a clear text signature") },
57     { 'b', "detach-sign", 256, N_("make a detached signature")},
58     { 'e', "encrypt",   256, N_("encrypt data")},
59     { 'c', "symmetric", 256, N_("encryption only with symmetric cipher")},
60     { 507, "store",     256, N_("store only")},
61     { 'd', "decrypt",   256, N_("decrypt data (default)")},
62     { 550, "verify"   , 256, N_("verify a signature")},
63   #endif
64     { 551, "list-keys", 256, N_("list keys")},
65     { 552, "list-sigs", 256, N_("list keys and signatures")},
66     { 508, "check-sigs",256, N_("check key signatures")},
67     { 515, "fingerprint", 256, N_("list keys and fingerprints")},
68     { 558, "list-secret-keys", 256, N_("list secret keys")},
69   #ifdef IS_G10
70     { 503, "gen-key",   256, N_("generate a new key pair")},
71     { 505, "delete-key",256, N_("remove key from the public keyring")},
72     { 524, "edit-key"  ,256, N_("sign or edit a key")},
73     { 542, "gen-revoke",256, N_("generate a revocation certificate")},
74   #endif
75     { 537, "export"          , 256, N_("export keys") },
76     { 563, "export-secret-keys" , 256, "@" },
77     { 565, "do-not-export-rsa", 0, "@" },
78     { 530, "import",      256     , N_("import/merge keys")},
79     { 521, "list-packets",256,N_("list only the sequence of packets")},
80   #ifdef IS_G10MAINT
81     { 564, "export-ownertrust", 256, N_("export the ownertrust values")},
82     { 525, "import-ownertrust", 256 , N_("import ownertrust values")},
83     { 567, "check-trustdb",0 , N_("|[NAMES]|check the trust database")},
84     { 546, "dearmor", 256, N_("De-Armor a file or stdin") },
85     { 547, "enarmor", 256, N_("En-Armor a file or stdin") },
86     { 555, "print-md" , 256, N_("|algo [files]|print message digests")},
87     { 516, "print-mds" , 256, N_("print all message digests")},
88     #ifdef MAINTAINER_OPTIONS
89     { 513, "gen-prime" , 256, "@" },
90     { 548, "gen-random" , 256, "@" },
91     #endif
92   #endif
93
94     { 301, NULL, 0, N_("@\nOptions:\n ") },
95
96     { 'a', "armor",     0, N_("create ascii armored output")},
97   #ifdef IS_G10
98     { 'u', "local-user",2, N_("use this user-id to sign or decrypt")},
99     { 'r', "remote-user", 2, N_("use this user-id for encryption")},
100     { 'z', NULL,        1, N_("|N|set compress level N (0 disables)") },
101     { 't', "textmode",  0, N_("use canonical text mode")},
102   #endif
103     { 'o', "output",    2, N_("use as output file")},
104     { 'v', "verbose",   0, N_("verbose") },
105     { 'n', "dry-run",   0, N_("do not make any changes") },
106     { 500, "batch",     0, N_("batch mode: never ask")},
107     { 501, "yes",       0, N_("assume yes on most questions")},
108     { 502, "no",        0, N_("assume no on most questions")},
109     { 509, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
110     { 517, "secret-keyring" ,2, N_("add this secret keyring to the list")},
111     { 541, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
112     { 518, "options"   , 2, N_("read options from file")},
113
114     { 510, "debug"     ,4|16, N_("set debugging flags")},
115     { 511, "debug-all" ,0, N_("enable full debugging")},
116     { 512, "status-fd" ,1, N_("|FD|write status info to this FD") },
117     { 534, "no-comment", 0,   N_("do not write comment packets")},
118     { 535, "completes-needed", 1, N_("(default is 1)")},
119     { 536, "marginals-needed", 1, N_("(default is 3)")},
120     { 560, "load-extension" ,2, N_("|file|load extension module")},
121     { 561, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
122   #ifdef IS_G10
123     { 527, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
124     { 529, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
125     { 556, "compress-algo", 1 , N_("|N|use compress algorithm N")},
126   #else /* some dummies */
127     { 527, "cipher-algo", 2 , "@"},
128     { 529, "digest-algo", 2 , "@"},
129     { 556, "compress-algo", 1 , "@"},
130   #endif
131
132   #ifdef IS_G10
133     { 302, NULL, 0, N_("@\nExamples:\n\n"
134     " -se -r Bob [file]          sign and encrypt for user Bob\n"
135     " -sat [file]                make a clear text signature\n"
136     " -sb  [file]                make a detached signature\n"
137     " -k   [userid]              show keys\n"
138     " -kc  [userid]              show fingerprint\n"  ) },
139   #endif
140
141   /* hidden options */
142   #ifdef IS_G10MAINT
143     { 514, "test"      , 0, "@" },
144     { 564, "list-ownertrust",0 , "@"},
145     { 567, "check-trustdb",0 , "@"},
146     { 531, "list-trustdb",0 , "@"},
147     { 533, "list-trust-path",0, "@"},
148   #endif
149   #ifdef IS_G10
150     { 'k', NULL,        0, "@"},
151     { 504, "delete-secret-key",0, "@" },
152     { 524, "edit-sig"  ,0, "@"}, /* alias for edit-key */
153     { 523, "passphrase-fd",1, "@" },
154     { 506, "sign-key"  ,256, "@" }, /* alias for edit-key */
155   #endif
156     { 532, "quick-random", 0, "@"},
157     { 526, "no-verbose", 0, "@"},
158     { 538, "trustdb-name", 2, "@" },
159     { 540, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
160     { 519, "no-armor",   0, "@"},
161     { 520, "no-default-keyring", 0, "@" },
162     { 522, "no-greeting", 0, "@" },
163     { 543, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
164     { 544, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
165     { 545, "no-batch", 0, "@" },
166     { 549, "with-colons", 0, "@"},
167     { 551, "list-key", 0, "@" }, /* alias */
168     { 552, "list-sig", 0, "@" }, /* alias */
169     { 508, "check-sig",0, "@" }, /* alias */
170     { 553, "skip-verify",0, "@" },
171     { 557, "compress-keys",0, "@"},
172     { 566, "compress-sigs",0, "@"},
173     { 559, "always-trust", 0, "@"},
174     { 562, "emulate-checksum-bug", 0, "@"},
175     { 554, "run-as-shm-coprocess", 4, "@" },
176      /* 568 unused */
177 {0} };
178
179
180 enum cmd_values { aNull = 0,
181     aSym, aStore, aEncr, aKeygen, aSign, aSignEncr,
182     aSignKey, aClearsign, aListPackets, aEditKey, aDeleteKey, aDeleteSecretKey,
183     aKMode, aKModeC,  aImport, aVerify, aDecrypt, aListKeys,
184     aListSigs, aListSecretKeys, aExport, aExportSecret,
185     aCheckKeys, aGenRevoke, aPrimegen, aPrintMD, aPrintMDs,
186     aCheckTrustDB, aListTrustDB, aListTrustPath,
187     aExportOwnerTrust, aImportOwnerTrust,
188     aDeArmor, aEnArmor, aGenRandom,
189 aTest };
190
191 static int maybe_setuid = 1;
192
193 static char *build_list( const char *text,
194                          const char *(*mapf)(int), int (*chkf)(int) );
195 static void set_cmd( enum cmd_values *ret_cmd,
196                         enum cmd_values new_cmd );
197 #ifdef IS_G10MAINT
198 static void print_hex( byte *p, size_t n );
199 static void print_mds( const char *fname, int algo );
200 #endif
201
202 const char *
203 strusage( int level )
204 {
205   static char *digests, *pubkeys, *ciphers;
206     const char *p;
207     switch( level ) {
208       case 11: p =
209           #ifdef IS_G10MAINT
210             "gpgm (GNUPG)";
211           #else
212             "gpg (GNUPG)";
213           #endif
214         break;
215       case 13: p = VERSION; break;
216       case 17: p = PRINTABLE_OS_NAME; break;
217       case 19: p =
218             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
219         break;
220       case 1:
221       case 40:  p =
222           #ifdef IS_G10MAINT
223             _("Usage: gpgm [options] [files] (-h for help)");
224           #else
225             _("Usage: gpg [options] [files] (-h for help)");
226           #endif
227         break;
228       case 41:  p =
229           #ifdef IS_G10MAINT
230             _("Syntax: gpgm [options] [files]\n"
231               "GNUPG maintenance utility\n");
232           #else
233             _("Syntax: gpg [options] [files]\n"
234               "sign, check, encrypt or decrypt\n"
235               "default operation depends on the input data\n");
236           #endif
237         break;
238
239       case 31: p = "\n"; break;
240       case 32:
241         if( !ciphers )
242             ciphers = build_list("Supported ciphers: ", cipher_algo_to_string,
243                                                         check_cipher_algo );
244         p = ciphers;
245         break;
246       case 33:
247         if( !pubkeys )
248             pubkeys = build_list("Supported pubkeys: ", pubkey_algo_to_string,
249                                                         check_pubkey_algo );
250         p = pubkeys;
251         break;
252       case 34:
253         if( !digests )
254             digests = build_list("Supported digests: ", digest_algo_to_string,
255                                                         check_digest_algo );
256         p = digests;
257         break;
258
259       default:  p = default_strusage(level);
260     }
261     return p;
262 }
263
264
265 static char *
266 build_list( const char *text, const char * (*mapf)(int), int (*chkf)(int) )
267 {
268     int i;
269     const char *s;
270     size_t n=strlen(text)+2;
271     char *list, *p;
272
273     if( maybe_setuid )
274         secmem_init( 0 );    /* drop setuid */
275
276     for(i=1; i < 110; i++ )
277         if( !chkf(i) && (s=mapf(i)) )
278             n += strlen(s) + 2;
279     list = m_alloc( 21 + n ); *list = 0;
280     for(p=NULL, i=1; i < 110; i++ ) {
281         if( !chkf(i) && (s=mapf(i)) ) {
282             if( !p )
283                 p = stpcpy( list, text );
284             else
285                 p = stpcpy( p, ", ");
286             p = stpcpy(p, s );
287         }
288     }
289     if( p )
290         p = stpcpy(p, "\n" );
291     return list;
292 }
293
294
295 static void
296 i18n_init(void)
297 {
298   #ifdef ENABLE_NLS
299     #ifdef HAVE_LC_MESSAGES
300        setlocale( LC_MESSAGES, "" );
301     #else
302        setlocale( LC_ALL, "" );
303     #endif
304     bindtextdomain( PACKAGE, G10_LOCALEDIR );
305     textdomain( PACKAGE );
306   #endif
307 }
308
309 static void
310 wrong_args( const char *text)
311 {
312   #ifdef IS_G10MAINT
313     fputs(_("usage: gpgm [options] "),stderr);
314   #else
315     fputs(_("usage: gpg [options] "),stderr);
316   #endif
317     fputs(text,stderr);
318     putc('\n',stderr);
319     g10_exit(2);
320 }
321
322 static void
323 set_debug(void)
324 {
325     if( opt.debug & DBG_MEMORY_VALUE )
326         memory_debug_mode = 1;
327     if( opt.debug & DBG_MEMSTAT_VALUE )
328         memory_stat_debug_mode = 1;
329     if( opt.debug & DBG_MPI_VALUE )
330         mpi_debug_mode = 1;
331     if( opt.debug & DBG_CIPHER_VALUE )
332         g10c_debug_mode = 1;
333     if( opt.debug & DBG_IOBUF_VALUE )
334         iobuf_debug_mode = 1;
335
336 }
337
338
339 static void
340 set_cmd( enum cmd_values *ret_cmd, enum cmd_values new_cmd )
341 {
342     enum cmd_values cmd = *ret_cmd;
343
344     if( !cmd || cmd == new_cmd )
345         cmd = new_cmd;
346     else if( cmd == aSign && new_cmd == aEncr )
347         cmd = aSignEncr;
348     else if( cmd == aEncr && new_cmd == aSign )
349         cmd = aSignEncr;
350     else if( cmd == aKMode && new_cmd == aSym )
351         cmd = aKModeC;
352     else if(    ( cmd == aSign     && new_cmd == aClearsign )
353              || ( cmd == aClearsign && new_cmd == aSign )  )
354         cmd = aClearsign;
355     else {
356         log_error(_("conflicting commands\n"));
357         g10_exit(2);
358     }
359
360     *ret_cmd = cmd;
361 }
362
363
364
365 int
366 main( int argc, char **argv )
367 {
368     ARGPARSE_ARGS pargs;
369     IOBUF a;
370     int rc=0;
371     int orig_argc;
372     char **orig_argv;
373     const char *fname;
374     STRLIST sl, remusr= NULL, locusr=NULL;
375     STRLIST nrings=NULL, sec_nrings=NULL;
376     armor_filter_context_t afx;
377     int detached_sig = 0;
378     FILE *configfp = NULL;
379     char *configname = NULL;
380     unsigned configlineno;
381     int parse_debug = 0;
382     int default_config =1;
383     int errors=0;
384     int default_keyring = 1;
385     int greeting = 1;
386     enum cmd_values cmd = 0;
387     const char *trustdb_name = NULL;
388     char *def_cipher_string = NULL;
389     char *def_digest_string = NULL;
390   #ifdef USE_SHM_COPROCESSING
391     ulong requested_shm_size=0;
392   #endif
393
394     trap_unaligned();
395   #ifdef IS_G10MAINT
396     secmem_init( 0 );      /* disable use of secmem */
397     maybe_setuid = 0;
398     log_set_name("gpgm");
399   #else
400     /* Please note that we may running SUID(ROOT), so be very CAREFUL
401      * when adding any stuff between here and the call to
402      * secmem_init()  somewhere after the option parsing
403      */
404     log_set_name("gpg");
405     secure_random_alloc(); /* put random number into secure memory */
406     disable_core_dumps();
407     init_signals();
408   #endif
409     i18n_init();
410     opt.compress = -1; /* defaults to standard compress level */
411     /* fixme: set the next two to zero and decide where used */
412     opt.def_cipher_algo = 0;
413     opt.def_digest_algo = 0;
414     opt.def_compress_algo = 2;
415     opt.completes_needed = 1;
416     opt.marginals_needed = 3;
417     opt.homedir = getenv("GNUPGHOME");
418     if( !opt.homedir || !*opt.homedir ) {
419       #ifdef __MINGW32__
420         opt.homedir = "c:/gnupg";
421       #else
422         opt.homedir = "~/.gnupg";
423       #endif
424     }
425
426     /* check whether we have a config file on the commandline */
427     orig_argc = argc;
428     orig_argv = argv;
429     pargs.argc = &argc;
430     pargs.argv = &argv;
431     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
432     while( arg_parse( &pargs, opts) ) {
433         if( pargs.r_opt == 510 || pargs.r_opt == 511 )
434             parse_debug++;
435         else if( pargs.r_opt == 518 ) {
436             /* yes there is one, so we do not try the default one, but
437              * read the option file when it is encountered at the commandline
438              */
439             default_config = 0;
440         }
441         else if( pargs.r_opt == 543 )
442             default_config = 0; /* --no-options */
443         else if( pargs.r_opt == 544 )
444             opt.homedir = pargs.r.ret_str;
445     }
446
447     if( default_config )
448         configname = make_filename(opt.homedir, "options", NULL );
449
450     argc = orig_argc;
451     argv = orig_argv;
452     pargs.argc = &argc;
453     pargs.argv = &argv;
454     pargs.flags=  1;  /* do not remove the args */
455   next_pass:
456     if( configname ) {
457         configlineno = 0;
458         configfp = fopen( configname, "r" );
459         if( !configfp ) {
460             if( default_config ) {
461                 if( parse_debug )
462                     log_info(_("note: no default option file '%s'\n"),
463                                                             configname );
464             }
465             else {
466                 log_error(_("option file '%s': %s\n"),
467                                     configname, strerror(errno) );
468                 g10_exit(1);
469             }
470             m_free(configname); configname = NULL;
471         }
472         if( parse_debug && configname )
473             log_info(_("reading options from '%s'\n"), configname );
474         default_config = 0;
475     }
476
477     while( optfile_parse( configfp, configname, &configlineno,
478                                                 &pargs, opts) ) {
479         switch( pargs.r_opt ) {
480
481           case 'a': opt.armor = 1; opt.no_armor=0; break;
482         #ifdef IS_G10
483           case 'b': detached_sig = 1; set_cmd( &cmd, aSign ); break;
484           case 'c': set_cmd( &cmd, aSym); break;
485           case 'd': set_cmd( &cmd, aDecrypt); break;
486           case 'e': set_cmd( &cmd, aEncr); break;
487           case 'r': /* store the remote users */
488             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
489             strcpy(sl->d, pargs.r.ret_str);
490             sl->next = remusr;
491             remusr = sl;
492             break;
493           case 's': set_cmd( &cmd, aSign );  break;
494           case 't': opt.textmode=1;  break;
495           case 'u': /* store the local users */
496             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
497             strcpy(sl->d, pargs.r.ret_str);
498             sl->next = locusr;
499             locusr = sl;
500             break;
501           case 'z': opt.compress = pargs.r.ret_int; break;
502           case 503: set_cmd( &cmd, aKeygen); break;
503           case 504: set_cmd( &cmd, aDeleteSecretKey); break;
504           case 505: set_cmd( &cmd, aDeleteKey); break;
505           case 506: set_cmd( &cmd, aSignKey); break;
506           case 507: set_cmd( &cmd, aStore); break;
507           case 523: set_passphrase_fd( pargs.r.ret_int ); break;
508           case 524: set_cmd( &cmd, aEditKey); break;
509           case 527: def_cipher_string = m_strdup(pargs.r.ret_str); break;
510           case 529: def_digest_string = m_strdup(pargs.r.ret_str); break;
511           case 539: set_cmd( &cmd, aClearsign); break;
512           case 540: secmem_set_flags( secmem_get_flags() | 1 ); break;
513           case 542: set_cmd( &cmd, aGenRevoke); break;
514           case 550: set_cmd( &cmd, aVerify); break;
515         #else
516           case 527:
517           case 529:
518             break;
519         #endif /* !IS_G10 */
520
521         #ifdef IS_G10MAINT
522           #ifdef MAINTAINER_OPTIONS
523             case 513: set_cmd( &cmd, aPrimegen); break;
524             case 514: set_cmd( &cmd, aTest); break;
525             case 548: set_cmd( &cmd, aGenRandom); break;
526           #endif
527           case 516: set_cmd( &cmd, aPrintMDs); break;
528           case 531: set_cmd( &cmd, aListTrustDB); break;
529           case 567: set_cmd( &cmd, aCheckTrustDB); break;
530           case 533: set_cmd( &cmd, aListTrustPath); break;
531           case 540: break; /* dummy */
532           case 546: set_cmd( &cmd, aDeArmor); break;
533           case 547: set_cmd( &cmd, aEnArmor); break;
534           case 555: set_cmd( &cmd, aPrintMD); break;
535           case 564: set_cmd( &cmd, aExportOwnerTrust); break;
536           case 525: set_cmd( &cmd, aImportOwnerTrust); break;
537         #endif /* IS_G10MAINT */
538
539           case 'o': opt.outfile = pargs.r.ret_str; break;
540           case 'v': g10_opt_verbose++;
541                     opt.verbose++; opt.list_sigs=1; break;
542           case 'k': set_cmd( &cmd, aKMode ); break;
543
544           case 500: opt.batch = 1; greeting = 0; break;
545           case 501: opt.answer_yes = 1; break;
546           case 502: opt.answer_no = 1; break;
547           case 508: set_cmd( &cmd, aCheckKeys); break;
548           case 509: append_to_strlist( &nrings, pargs.r.ret_str); break;
549           case 510: opt.debug |= pargs.r.ret_ulong; break;
550           case 511: opt.debug = ~0; break;
551           case 512: set_status_fd( pargs.r.ret_int ); break;
552           case 515: opt.fingerprint++; break;
553           case 517: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
554           case 518:
555             /* config files may not be nested (silently ignore them) */
556             if( !configfp ) {
557                 m_free(configname);
558                 configname = m_strdup(pargs.r.ret_str);
559                 goto next_pass;
560             }
561             break;
562           case 519: opt.no_armor=1; opt.armor=0; break;
563           case 520: default_keyring = 0; break;
564           case 521: set_cmd( &cmd, aListPackets); break;
565           case 522: greeting = 0; break;
566           case 526: g10_opt_verbose = 0;
567                     opt.verbose = 0; opt.list_sigs=0; break;
568           case 530: set_cmd( &cmd, aImport); break;
569           case 532: quick_random_gen(1); break;
570           case 534: opt.no_comment=1; break;
571           case 535: opt.completes_needed = pargs.r.ret_int; break;
572           case 536: opt.marginals_needed = pargs.r.ret_int; break;
573           case 537: set_cmd( &cmd, aExport); break;
574           case 538: trustdb_name = pargs.r.ret_str; break;
575           case 541: opt.def_secret_key = pargs.r.ret_str; break;
576           case 543: break; /* no-options */
577           case 544: opt.homedir = pargs.r.ret_str; break;
578           case 545: opt.batch = 0; break;
579           case 549: opt.with_colons=':'; break;
580           case 551: set_cmd( &cmd, aListKeys); break;
581           case 552: set_cmd( &cmd, aListSigs); break;
582           case 553: opt.skip_verify=1; break;
583           case 556: opt.def_compress_algo = pargs.r.ret_int; break;
584           case 557: opt.compress_keys = 1; break;
585           case 558: set_cmd( &cmd, aListSecretKeys); break;
586           case 559: opt.always_trust = 1; break;
587           case 560: register_cipher_extension(pargs.r.ret_str); break;
588           case 561: opt.rfc1991 = 1; opt.no_comment = 1; break;
589           case 562: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
590           case 563: set_cmd( &cmd, aExportSecret); break;
591           case 565: opt.do_not_export_rsa = 1; break;
592           case 566: opt.compress_sigs = 1; break;
593           case 554:
594           #ifdef USE_SHM_COPROCESSING
595             opt.shm_coprocess = 1;
596             requested_shm_size = pargs.r.ret_ulong;
597           #else
598             log_error("shared memory coprocessing is not available\n");
599           #endif
600             break;
601           default : errors++; pargs.err = configfp? 1:2; break;
602         }
603     }
604     if( configfp ) {
605         fclose( configfp );
606         configfp = NULL;
607         m_free(configname); configname = NULL;
608         goto next_pass;
609     }
610     m_free( configname ); configname = NULL;
611     if( log_get_errorcount(0) )
612         g10_exit(2);
613
614     if( greeting ) {
615         tty_printf("%s %s; %s\n", strusage(11), strusage(13), strusage(14) );
616         tty_printf("%s\n", strusage(15) );
617     }
618
619   #ifdef USE_SHM_COPROCESSING
620     if( opt.shm_coprocess ) {
621       #ifdef IS_G10
622         init_shm_coprocessing(requested_shm_size, 1 );
623       #else
624         init_shm_coprocessing(requested_shm_size, 0 );
625       #endif
626     }
627   #endif
628   #ifdef IS_G10
629     /* initialize the secure memory. */
630     secmem_init( 16384 );
631     maybe_setuid = 0;
632     /* Okay, we are now working under our real uid */
633   #endif
634
635
636     set_debug();
637
638     /* must do this after dropping setuid, because string_to...
639      * may try to load an module */
640     if( def_cipher_string ) {
641         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
642         m_free(def_cipher_string); def_cipher_string = NULL;
643         if( check_cipher_algo(opt.def_cipher_algo) )
644             log_error(_("selected cipher algorithm is invalid\n"));
645     }
646     if( def_digest_string ) {
647         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
648         m_free(def_digest_string); def_digest_string = NULL;
649         if( check_digest_algo(opt.def_digest_algo) )
650             log_error(_("selected digest algorithm is invalid\n"));
651     }
652     if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
653         log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
654     if( opt.completes_needed < 1 )
655         log_error(_("completes-needed must be greater than 0\n"));
656     if( opt.marginals_needed < 2 )
657         log_error(_("marginals-needed must be greater than 1\n"));
658
659     if( log_get_errorcount(0) )
660         g10_exit(2);
661
662     if( !cmd && opt.fingerprint )
663         set_cmd( &cmd, aListKeys);
664
665     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
666         if( cmd == aKModeC ) {
667             opt.fingerprint = 1;
668             cmd = aKMode;
669         }
670         opt.list_sigs = 0;
671         if( opt.verbose > 2 )
672             opt.check_sigs++;
673         if( opt.verbose > 1 )
674             opt.list_sigs++;
675
676         opt.verbose = opt.verbose > 1;
677         g10_opt_verbose = opt.verbose;
678     }
679
680
681     /* kludge to let -sat generate a clear text signature */
682     if( opt.textmode && !detached_sig && opt.armor && cmd == aSign )
683         cmd = aClearsign;
684
685     if( opt.verbose > 1 )
686         set_packet_list_mode(1);
687
688     /* add the keyrings, but not for some special commands and
689      * not in case of "-kvv userid keyring" */
690     if( cmd != aDeArmor && cmd != aEnArmor
691         && !(cmd == aKMode && argc == 2 ) ) {
692
693         if( !sec_nrings || default_keyring )  /* add default secret rings */
694             add_secret_keyring("secring.gpg");
695         for(sl = sec_nrings; sl; sl = sl->next )
696             add_secret_keyring( sl->d );
697         if( !nrings || default_keyring )  /* add default ring */
698             add_keyring("pubring.gpg");
699         for(sl = nrings; sl; sl = sl->next )
700             add_keyring( sl->d );
701     }
702     FREE_STRLIST(nrings);
703     FREE_STRLIST(sec_nrings);
704
705     if( argc )
706         fname = *argv;
707     else {
708         fname = NULL;
709         if( get_passphrase_fd() == 0 ) {
710             /* reading data and passphrase from stdin:
711              * we assume the first line is the passphrase, so
712              * we should read it now.
713              *
714              * We should do it here, but for now it is not needed.
715              * Anyway, this password scheme is not quite good
716              */
717         }
718     }
719
720     switch( cmd ) {
721       case aPrimegen:
722       case aPrintMD:
723       case aPrintMDs:
724       case aGenRandom:
725       case aDeArmor:
726       case aEnArmor:
727         break;
728       case aKMode:
729       case aListKeys:
730       case aListSecretKeys:
731       case aCheckKeys:
732         if( opt.with_colons ) /* need this to list the trust */
733             rc = init_trustdb(1, trustdb_name );
734         break;
735       case aExportOwnerTrust: rc = init_trustdb( 0, trustdb_name ); break;
736       case aListTrustDB: rc = init_trustdb( argc? 1:0, trustdb_name ); break;
737       default: rc = init_trustdb(1, trustdb_name ); break;
738     }
739     if( rc )
740         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
741
742
743     switch( cmd ) {
744       case aStore: /* only store the file */
745         if( argc > 1 )
746             wrong_args(_("--store [filename]"));
747         if( (rc = encode_store(fname)) )
748             log_error_f( print_fname_stdin(fname),
749                         "store failed: %s\n", g10_errstr(rc) );
750         break;
751     #ifdef IS_G10
752       case aSym: /* encrypt the given file only with the symmetric cipher */
753         if( argc > 1 )
754             wrong_args(_("--symmetric [filename]"));
755         if( (rc = encode_symmetric(fname)) )
756             log_error_f(print_fname_stdin(fname),
757                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
758         break;
759
760       case aEncr: /* encrypt the given file */
761         if( argc > 1 )
762             wrong_args(_("--encrypt [filename]"));
763         if( (rc = encode_crypt(fname,remusr)) )
764             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
765         break;
766
767       case aSign: /* sign the given file */
768         sl = NULL;
769         if( detached_sig ) { /* sign all files */
770             for( ; argc; argc--, argv++ )
771                 add_to_strlist( &sl, *argv );
772         }
773         else {
774             if( argc > 1 )
775                 wrong_args(_("--sign [filename]"));
776             if( argc ) {
777                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
778                 strcpy(sl->d, fname);
779             }
780         }
781         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
782             log_error("signing failed: %s\n", g10_errstr(rc) );
783         free_strlist(sl);
784         break;
785
786       case aSignEncr: /* sign and encrypt the given file */
787         if( argc > 1 )
788             wrong_args(_("--sign --encrypt [filename]"));
789         if( argc ) {
790             sl = m_alloc_clear( sizeof *sl + strlen(fname));
791             strcpy(sl->d, fname);
792         }
793         else
794             sl = NULL;
795         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
796             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
797         free_strlist(sl);
798         break;
799
800       case aClearsign: /* make a clearsig */
801         if( argc > 1 )
802             wrong_args(_("--clearsign [filename]"));
803         if( (rc = clearsign_file(fname, locusr, NULL)) )
804             log_error("%s: clearsign failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
805         break;
806
807       case aVerify:
808         if( (rc = verify_signatures( argc, argv ) ))
809             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
810         break;
811
812       case aDecrypt:
813         if( argc > 1 )
814             wrong_args(_("--decrypt [filename]"));
815         if( (rc = decrypt_message( fname ) ))
816             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
817         break;
818
819
820       case aSignKey: /* sign the key given as argument */
821       case aEditKey: /* Edit a key signature */
822         if( argc != 1 )
823             wrong_args(_("--edit-key username"));
824         keyedit_menu(fname, locusr );
825         break;
826
827       case aDeleteSecretKey:
828         if( argc != 1 )
829             wrong_args(_("--delete-secret-key username"));
830       case aDeleteKey:
831         if( argc != 1 )
832             wrong_args(_("--delete-key username"));
833         /* note: fname is the user id! */
834         if( (rc = delete_key(fname, cmd==aDeleteSecretKey)) )
835             log_error("%s: delete key failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
836         break;
837
838       #endif /* IS_G10 */
839
840       case aCheckKeys:
841         opt.check_sigs = 1;
842       case aListSigs:
843         opt.list_sigs = 1;
844       case aListKeys:
845         public_key_list( argc, argv );
846         break;
847       case aListSecretKeys:
848         secret_key_list( argc, argv );
849         break;
850
851       case aKMode: /* list keyring */
852         if( argc < 2 )  /* -kv [userid] */
853             public_key_list( (argc && **argv)? 1:0, argv );
854         else if( argc == 2 ) { /* -kv userid keyring */
855             if( access( argv[1], R_OK ) ) {
856                 log_error(_("can't open %s: %s\n"),
857                                print_fname_stdin(argv[1]), strerror(errno));
858             }
859             else {
860                 /* add keyring (default keyrings are not registered in this
861                  * special case */
862                 add_keyring( argv[1] );
863                 public_key_list( **argv?1:0, argv );
864             }
865         }
866         else
867             wrong_args(_("-k[v][v][v][c] [userid] [keyring]") );
868         break;
869
870     #ifdef IS_G10
871       case aKeygen: /* generate a key (interactive) */
872         if( argc )
873             wrong_args("--gen-key");
874         generate_keypair();
875         break;
876     #endif
877
878       case aImport:
879         if( !argc  ) {
880             rc = import_keys( NULL );
881             if( rc )
882                 log_error("import failed: %s\n", g10_errstr(rc) );
883         }
884         for( ; argc; argc--, argv++ ) {
885             rc = import_keys( *argv );
886             if( rc )
887                 log_error("import from '%s' failed: %s\n",
888                                                 *argv, g10_errstr(rc) );
889         }
890         break;
891
892       case aExport:
893         sl = NULL;
894         for( ; argc; argc--, argv++ )
895             add_to_strlist( &sl, *argv );
896         export_pubkeys( sl );
897         free_strlist(sl);
898         break;
899
900       case aExportSecret:
901         sl = NULL;
902         for( ; argc; argc--, argv++ )
903             add_to_strlist( &sl, *argv );
904         export_seckeys( sl );
905         free_strlist(sl);
906         break;
907
908     #ifdef IS_G10
909       case aGenRevoke:
910         if( argc != 1 )
911             wrong_args("--gen-revoke user-id");
912         gen_revoke( *argv );
913         break;
914     #endif
915
916     #ifdef IS_G10MAINT
917       case aDeArmor:
918         if( argc > 1 )
919             wrong_args("--dearmor [file]");
920         rc = dearmor_file( argc? *argv: NULL );
921         if( rc )
922             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
923         break;
924
925       case aEnArmor:
926         if( argc > 1 )
927             wrong_args("--enarmor [file]");
928         rc = enarmor_file( argc? *argv: NULL );
929         if( rc )
930             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
931         break;
932
933
934      #ifdef MAINTAINER_OPTIONS
935       case aPrimegen:
936         if( argc == 1 ) {
937             mpi_print( stdout, generate_public_prime( atoi(argv[0]) ), 1);
938             putchar('\n');
939         }
940         else if( argc == 2 ) {
941             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
942                                                    atoi(argv[1]), NULL,NULL ), 1);
943             putchar('\n');
944         }
945         else if( argc == 3 ) {
946             MPI g = mpi_alloc(1);
947             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
948                                                    atoi(argv[1]), g, NULL ), 1);
949             printf("\nGenerator: ");
950             mpi_print( stdout, g, 1 );
951             putchar('\n');
952             mpi_free(g);
953         }
954         else if( argc == 4 ) {
955             mpi_print( stdout, generate_elg_prime( 1, atoi(argv[0]),
956                                                    atoi(argv[1]), NULL,NULL ), 1);
957             putchar('\n');
958         }
959         else
960             usage(1);
961         break;
962       #endif /* MAINTAINER OPTIONS */
963
964       #ifdef MAINTAINER_OPTIONS
965       case aGenRandom:
966         if( argc < 1 || argc > 2 )
967             wrong_args("--gen-random level [hex]");
968         {
969             int level = atoi(*argv);
970             for(;;) {
971                 byte *p = get_random_bits( 8, level, 0);
972                 if( argc == 1 ) {
973                     printf("%02x", *p );
974                     fflush(stdout);
975                 }
976                 else
977                     putchar(c&0xff);
978                 m_free(p);
979             }
980         }
981         break;
982       #endif /* MAINTAINER OPTIONS */
983
984       case aPrintMD:
985         if( argc < 1)
986             wrong_args("--print-md algo [file]");
987         else {
988             int algo = string_to_digest_algo(*argv);
989
990             if( !algo )
991                 log_error(_("invalid hash algorithm '%s'\n"), *argv );
992             else {
993                 argc--; argv++;
994                 if( !argc )
995                     print_mds(NULL, algo);
996                 else {
997                     for(; argc; argc--, argv++ )
998                         print_mds(*argv, algo);
999                 }
1000             }
1001         }
1002         break;
1003
1004       case aPrintMDs:
1005         if( !argc )
1006             print_mds(NULL,0);
1007         else {
1008             for(; argc; argc--, argv++ )
1009                 print_mds(*argv,0);
1010         }
1011         break;
1012
1013      #ifdef MAINTAINER_OPTIONS
1014       case aTest: do_test( argc? atoi(*argv): 1 ); break;
1015       #endif /* MAINTAINER OPTIONS */
1016
1017       case aListTrustDB:
1018         if( !argc )
1019             list_trustdb(NULL);
1020         else {
1021             for( ; argc; argc--, argv++ )
1022                 list_trustdb( *argv );
1023         }
1024         break;
1025
1026       case aCheckTrustDB:
1027         if( !argc )
1028             check_trustdb(NULL);
1029         else {
1030             for( ; argc; argc--, argv++ )
1031                 check_trustdb( *argv );
1032         }
1033         break;
1034
1035       case aListTrustPath:
1036         if( argc != 2 )
1037             wrong_args("--list-trust-path [-- -]<maxdepth> <username>");
1038         list_trust_path( atoi(*argv), argv[1] );
1039         break;
1040
1041       case aExportOwnerTrust:
1042         if( argc )
1043             wrong_args("--export-ownertrust");
1044         export_ownertrust();
1045         break;
1046
1047       case aImportOwnerTrust:
1048         if( argc > 1 )
1049             wrong_args("--import-ownertrust [file]");
1050         import_ownertrust( argc? *argv:NULL );
1051         break;
1052
1053      #endif /* IS_G10MAINT */
1054
1055
1056       case aListPackets:
1057         opt.list_packets=1;
1058       default:
1059         /* fixme: g10maint should do regular maintenace tasks here */
1060         if( argc > 1 )
1061             wrong_args(_("[filename]"));
1062         if( !(a = iobuf_open(fname)) )
1063             log_error(_("can't open '%s'\n"), print_fname_stdin(fname));
1064         else {
1065             if( !opt.no_armor ) {
1066                 if( use_armor_filter( a ) ) {
1067                     memset( &afx, 0, sizeof afx);
1068                     iobuf_push_filter( a, armor_filter, &afx );
1069                 }
1070             }
1071             if( cmd == aListPackets ) {
1072                 set_packet_list_mode(1);
1073                 opt.list_packets=1;
1074             }
1075             proc_packets( a );
1076             iobuf_close(a);
1077         }
1078         break;
1079     }
1080
1081     /* cleanup */
1082     FREE_STRLIST(remusr);
1083     FREE_STRLIST(locusr);
1084     g10_exit(0);
1085     return 8; /*NEVER REACHED*/
1086 }
1087
1088
1089 void
1090 g10_exit( int rc )
1091 {
1092     if( opt.debug )
1093         secmem_dump_stats();
1094     secmem_term();
1095     rc = rc? rc : log_get_errorcount(0)? 2:0;
1096     /*write_status( STATUS_LEAVE );*/
1097     exit(rc );
1098 }
1099
1100
1101 void
1102 do_not_use_RSA()
1103 {
1104     static int did_rsa_note = 0;
1105
1106     if( !did_rsa_note ) {
1107         did_rsa_note = 1;
1108         log_info(_("RSA keys are deprecated; please consider "
1109                    "creating a new key and use this key in the future\n"));
1110     }
1111 }
1112
1113
1114 #ifdef IS_G10MAINT
1115 static void
1116 print_hex( byte *p, size_t n )
1117 {
1118     int i;
1119
1120     if( n == 20 ) {
1121         for(i=0; i < n ; i++, i++, p += 2 ) {
1122             if( i )
1123                 putchar(' ');
1124             if( i == 10 )
1125                 putchar(' ');
1126             printf("%02X%02X", *p, p[1] );
1127         }
1128     }
1129     else if( n == 24 ) {
1130         for(i=0; i < n ; i += 4, p += 4 ) {
1131             if( i )
1132                 putchar(' ');
1133             if( i == 12 )
1134                 putchar(' ');
1135             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
1136         }
1137     }
1138     else {
1139         for(i=0; i < n ; i++, p++ ) {
1140             if( i )
1141                 putchar(' ');
1142             if( i && !(i%8) )
1143                 putchar(' ');
1144             printf("%02X", *p );
1145         }
1146     }
1147 }
1148
1149 static void
1150 print_mds( const char *fname, int algo )
1151 {
1152     FILE *fp;
1153     char buf[1024];
1154     size_t n;
1155     MD_HANDLE md;
1156     char *pname;
1157
1158     if( !fname ) {
1159         fp = stdin;
1160         pname = m_strdup("[stdin]: ");
1161     }
1162     else {
1163         pname = m_alloc(strlen(fname)+3);
1164         strcpy(stpcpy(pname,fname),": ");
1165         fp = fopen( fname, "rb" );
1166     }
1167     if( !fp ) {
1168         log_error("%s%s\n", pname, strerror(errno) );
1169         m_free(pname);
1170         return;
1171     }
1172
1173     md = md_open( 0, 0 );
1174     if( algo )
1175         md_enable( md, algo );
1176     else {
1177         md_enable( md, DIGEST_ALGO_MD5 );
1178         md_enable( md, DIGEST_ALGO_SHA1 );
1179         md_enable( md, DIGEST_ALGO_RMD160 );
1180         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
1181             md_enable( md, DIGEST_ALGO_TIGER );
1182     }
1183
1184     while( (n=fread( buf, 1, DIM(buf), fp )) )
1185         md_write( md, buf, n );
1186     if( ferror(fp) )
1187         log_error("%s%s\n", pname, strerror(errno) );
1188     else {
1189         md_final(md);
1190         if( algo ) {
1191             if( fname )
1192                 fputs( pname, stdout );
1193             print_hex(md_read(md, algo), md_digest_length(algo) );
1194         }
1195         else {
1196             printf(  "%s   MD5 = ", fname?pname:"" );
1197                             print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
1198             printf("\n%s  SHA1 = ", fname?pname:""  );
1199                             print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
1200             printf("\n%sRMD160 = ", fname?pname:""  );
1201                             print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
1202             if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
1203                 printf("\n%s TIGER = ", fname?pname:""  );
1204                             print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
1205             }
1206         }
1207         putchar('\n');
1208     }
1209     md_close(md);
1210
1211     if( fp != stdin )
1212         fclose(fp);
1213 }
1214
1215
1216
1217 #ifdef MAINTAINER_OPTIONS
1218 static void
1219 do_test(int times)
1220 {
1221     m_check(NULL);
1222 }
1223 #endif /* MAINTAINER OPTIONS */
1224 #endif /* IS_G10MAINT */
1225