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