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