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