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