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