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