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