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