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