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