See ChangeLog: Mon Jul 12 14:55:34 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
446 static char *
447 make_username( const char *string )
448 {
449     char *p;
450     if( utf8_strings )
451         p = native_to_utf8( string );
452     else
453         p = m_strdup(string);
454     return p;
455 }
456
457
458 static void
459 set_debug(void)
460 {
461     if( opt.debug & DBG_MEMORY_VALUE )
462         memory_debug_mode = 1;
463     if( opt.debug & DBG_MEMSTAT_VALUE )
464         memory_stat_debug_mode = 1;
465     if( opt.debug & DBG_MPI_VALUE )
466         mpi_debug_mode = 1;
467     if( opt.debug & DBG_CIPHER_VALUE )
468         g10c_debug_mode = 1;
469     if( opt.debug & DBG_IOBUF_VALUE )
470         iobuf_debug_mode = 1;
471
472 }
473
474
475 static void
476 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
477 {
478     enum cmd_and_opt_values cmd = *ret_cmd;
479
480     if( !cmd || cmd == new_cmd )
481         cmd = new_cmd;
482     else if( cmd == aSign && new_cmd == aEncr )
483         cmd = aSignEncr;
484     else if( cmd == aEncr && new_cmd == aSign )
485         cmd = aSignEncr;
486     else if( cmd == aKMode && new_cmd == aSym )
487         cmd = aKModeC;
488     else if(    ( cmd == aSign     && new_cmd == aClearsign )
489              || ( cmd == aClearsign && new_cmd == aSign )  )
490         cmd = aClearsign;
491     else {
492         log_error(_("conflicting commands\n"));
493         g10_exit(2);
494     }
495
496     *ret_cmd = cmd;
497 }
498
499
500
501 int
502 main( int argc, char **argv )
503 {
504     ARGPARSE_ARGS pargs;
505     IOBUF a;
506     int rc=0;
507     int orig_argc;
508     char **orig_argv;
509     const char *fname;
510     char *username;
511     STRLIST sl, remusr= NULL, locusr=NULL;
512     STRLIST nrings=NULL, sec_nrings=NULL;
513     armor_filter_context_t afx;
514     int detached_sig = 0;
515     FILE *configfp = NULL;
516     char *configname = NULL;
517     unsigned configlineno;
518     int parse_debug = 0;
519     int default_config =1;
520     int default_keyring = 1;
521     int greeting = 1;
522     enum cmd_and_opt_values cmd = 0;
523     const char *trustdb_name = NULL;
524     char *def_cipher_string = NULL;
525     char *def_digest_string = NULL;
526     char *s2k_cipher_string = NULL;
527     char *s2k_digest_string = NULL;
528     int pwfd = -1;
529     int with_fpr = 0; /* make an option out of --fingerprint */
530   #ifdef USE_SHM_COPROCESSING
531     ulong requested_shm_size=0;
532   #endif
533
534     trap_unaligned();
535     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
536     /* Please note that we may running SUID(ROOT), so be very CAREFUL
537      * when adding any stuff between here and the call to
538      * secmem_init()  somewhere after the option parsing
539      */
540     log_set_name("gpg");
541     secure_random_alloc(); /* put random number into secure memory */
542     disable_core_dumps();
543     init_signals();
544     create_dotlock(NULL); /* register locking cleanup */
545     i18n_init();
546     opt.compress = -1; /* defaults to standard compress level */
547     /* note: if you change these lines, look at oOpenPGP */
548     opt.def_cipher_algo = 0;
549     opt.def_digest_algo = 0;
550     opt.def_compress_algo = 2;
551     opt.s2k_mode = 3; /* iterated+salted */
552     opt.s2k_digest_algo = DIGEST_ALGO_RMD160;
553     opt.s2k_cipher_algo = CIPHER_ALGO_BLOWFISH;
554     opt.completes_needed = 1;
555     opt.marginals_needed = 3;
556     opt.max_cert_depth = 5;
557     opt.homedir = getenv("GNUPGHOME");
558     if( !opt.homedir || !*opt.homedir ) {
559       #ifdef HAVE_DRIVE_LETTERS
560         opt.homedir = "c:/gnupg";
561       #else
562         opt.homedir = "~/.gnupg";
563       #endif
564     }
565
566     /* check whether we have a config file on the commandline */
567     orig_argc = argc;
568     orig_argv = argv;
569     pargs.argc = &argc;
570     pargs.argv = &argv;
571     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
572     while( arg_parse( &pargs, opts) ) {
573         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
574             parse_debug++;
575         else if( pargs.r_opt == oOptions ) {
576             /* yes there is one, so we do not try the default one, but
577              * read the option file when it is encountered at the commandline
578              */
579             default_config = 0;
580         }
581         else if( pargs.r_opt == oNoOptions )
582             default_config = 0; /* --no-options */
583         else if( pargs.r_opt == oHomedir )
584             opt.homedir = pargs.r.ret_str;
585       #ifdef USE_SHM_COPROCESSING
586         else if( pargs.r_opt == oRunAsShmCP ) {
587             /* does not make sense in a options file, we do it here,
588              * so that we are the able to drop setuid as soon as possible */
589             opt.shm_coprocess = 1;
590             requested_shm_size = pargs.r.ret_ulong;
591         }
592         else if ( pargs.r_opt == oStatusFD ) {
593             /* this is needed to ensure that the status-fd filedescriptor is
594              * initialized when init_shm_coprocessing() is called */
595             set_status_fd( pargs.r.ret_int );
596         }
597       #endif
598     }
599
600
601   #ifdef USE_SHM_COPROCESSING
602     if( opt.shm_coprocess ) {
603         init_shm_coprocessing(requested_shm_size, 1 );
604     }
605   #endif
606     /* initialize the secure memory. */
607     secmem_init( 16384 );
608     maybe_setuid = 0;
609     /* Okay, we are now working under our real uid */
610
611     if( default_config )
612         configname = make_filename(opt.homedir, "options", NULL );
613
614     argc = orig_argc;
615     argv = orig_argv;
616     pargs.argc = &argc;
617     pargs.argv = &argv;
618     pargs.flags=  1;  /* do not remove the args */
619   next_pass:
620     if( configname ) {
621         configlineno = 0;
622         configfp = fopen( configname, "r" );
623         if( !configfp ) {
624             if( default_config ) {
625                 if( parse_debug )
626                     log_info(_("NOTE: no default option file `%s'\n"),
627                                                             configname );
628             }
629             else {
630                 log_error(_("option file `%s': %s\n"),
631                                     configname, strerror(errno) );
632                 g10_exit(2);
633             }
634             m_free(configname); configname = NULL;
635         }
636         if( parse_debug && configname )
637             log_info(_("reading options from `%s'\n"), configname );
638         default_config = 0;
639     }
640
641     while( optfile_parse( configfp, configname, &configlineno,
642                                                 &pargs, opts) ) {
643         switch( pargs.r_opt ) {
644           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
645           case aListPackets: set_cmd( &cmd, aListPackets); break;
646           case aImport: set_cmd( &cmd, aImport); break;
647           case aFastImport: set_cmd( &cmd, aFastImport); break;
648           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
649           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
650           case aExport: set_cmd( &cmd, aExport); break;
651           case aExportAll: set_cmd( &cmd, aExportAll); break;
652           case aListKeys: set_cmd( &cmd, aListKeys); break;
653           case aListSigs: set_cmd( &cmd, aListSigs); break;
654           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
655           case aDeleteSecretKey: set_cmd( &cmd, aDeleteSecretKey); break;
656           case aDeleteKey: set_cmd( &cmd, aDeleteKey); break;
657
658           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
659           case aSym: set_cmd( &cmd, aSym); break;
660           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
661           case aEncr: set_cmd( &cmd, aEncr); break;
662           case aSign: set_cmd( &cmd, aSign );  break;
663           case aKeygen: set_cmd( &cmd, aKeygen); break;
664           case aSignKey: set_cmd( &cmd, aSignKey); break;
665           case aStore: set_cmd( &cmd, aStore); break;
666           case aEditKey: set_cmd( &cmd, aEditKey); break;
667           case aClearsign: set_cmd( &cmd, aClearsign); break;
668           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
669           case aVerify: set_cmd( &cmd, aVerify); break;
670         #ifdef MAINTAINER_OPTIONS
671           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
672           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
673         #endif
674           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
675           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
676           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
677           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
678           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
679           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
680           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
681           case aDeArmor: set_cmd( &cmd, aDeArmor); greeting = 0; break;
682           case aEnArmor: set_cmd( &cmd, aEnArmor); greeting = 0; break;
683           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
684           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
685
686           case oArmor: opt.armor = 1; opt.no_armor=0; break;
687           case oOutput: opt.outfile = pargs.r.ret_str; break;
688           case oQuiet: opt.quiet = 1; break;
689           case oNoTTY: opt.quiet = 1; tty_no_terminal(1); break;
690           case oDryRun: opt.dry_run = 1; break;
691           case oInteractive: opt.interactive = 1; break;
692           case oVerbose: g10_opt_verbose++;
693                     opt.verbose++; opt.list_sigs=1; break;
694           case oKOption: set_cmd( &cmd, aKMode ); break;
695
696           case oBatch: opt.batch = 1; greeting = 0; break;
697           case oAnswerYes: opt.answer_yes = 1; break;
698           case oAnswerNo: opt.answer_no = 1; break;
699           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
700           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
701           case oDebugAll: opt.debug = ~0; break;
702           case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
703           case oLoggerFD: log_set_logfile( NULL, pargs.r.ret_int ); break;
704           case oWithFingerprint:
705                 with_fpr=1; /*fall thru*/
706           case oFingerprint: opt.fingerprint++; break;
707           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
708           case oOptions:
709             /* config files may not be nested (silently ignore them) */
710             if( !configfp ) {
711                 m_free(configname);
712                 configname = m_strdup(pargs.r.ret_str);
713                 goto next_pass;
714             }
715             break;
716           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
717           case oNoDefKeyring: default_keyring = 0; break;
718           case oNoGreeting: greeting = 0; break;
719           case oNoVerbose: g10_opt_verbose = 0;
720                            opt.verbose = 0; opt.list_sigs=0; break;
721           case oQuickRandom: quick_random_gen(1); break;
722           case oNoComment: opt.no_comment=1; break;
723           case oNoVersion: opt.no_version=1; break;
724           case oEmitVersion: opt.no_version=0; break;
725           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
726           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
727           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
728           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
729           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
730           case oNoOptions: break; /* no-options */
731           case oHomedir: opt.homedir = pargs.r.ret_str; break;
732           case oNoBatch: opt.batch = 0; break;
733           case oWithKeyData: opt.with_key_data=1; /* fall thru */
734           case oWithColons: opt.with_colons=':'; break;
735
736           case oSkipVerify: opt.skip_verify=1; break;
737           case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
738           case oCompressKeys: opt.compress_keys = 1; break;
739           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
740           case oAlwaysTrust: opt.always_trust = 1; break;
741           case oLoadExtension:
742             register_cipher_extension(orig_argc? *orig_argv:NULL,
743                                       pargs.r.ret_str);
744             break;
745           case oRFC1991:
746             opt.rfc1991 = 1;
747             opt.no_comment = 1;
748             opt.escape_from = 1;
749             break;
750           case oOpenPGP:
751             opt.rfc1991 = 0;
752             opt.escape_from = 0;
753             opt.force_v3_sigs = 0;
754             opt.compress_keys = 0;          /* not mandated  but we do it */
755             opt.compress_sigs = 0;          /* ditto. */
756             opt.not_dash_escaped = 0;
757             opt.def_cipher_algo = 0;
758             opt.def_digest_algo = 0;
759             opt.def_compress_algo = 2;
760             opt.s2k_mode = 3; /* iterated+salted */
761             opt.s2k_digest_algo = DIGEST_ALGO_RMD160;
762             opt.s2k_cipher_algo = CIPHER_ALGO_BLOWFISH;
763             break;
764           case oEmuChecksumBug: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
765           case oCompressSigs: opt.compress_sigs = 1; break;
766           case oRunAsShmCP:
767           #ifndef USE_SHM_COPROCESSING
768             /* not possible in the option file,
769              * but we print the warning here anyway */
770             log_error("shared memory coprocessing is not available\n");
771           #endif
772             break;
773           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
774           case oSetPolicyURL: opt.set_policy_url = pargs.r.ret_str; break;
775           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
776           case oComment: opt.comment_string = pargs.r.ret_str; break;
777           case oDefaultComment: opt.comment_string = NULL; break;
778           case oThrowKeyid: opt.throw_keyid = 1; break;
779           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
780           case oForceMDC: opt.force_mdc = 1; break;
781           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
782           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
783           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
784
785           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
786           case oEncryptTo: /* store the recipient in the second list */
787             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
788             sl->flags = 1;
789             break;
790           case oRecipient: /* store the recipient */
791             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
792             break;
793           case oTextmodeShort: opt.textmode = 2; break;
794           case oTextmode: opt.textmode=1;  break;
795           case oUser: /* store the local users */
796             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
797             break;
798           case oCompress: opt.compress = pargs.r.ret_int; break;
799           case oPasswdFD: pwfd = pargs.r.ret_int; break;
800           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
801           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
802           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
803           case oCharset:
804             if( set_native_charset( pargs.r.ret_str ) )
805                 log_error(_("%s is not a valid character set\n"),
806                                                     pargs.r.ret_str);
807             break;
808           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
809           case oEscapeFrom: opt.escape_from = 1; break;
810           case oLockOnce: opt.lock_once = 1; break;
811           case oLockMultiple: opt.lock_once = 0; break;
812           case oKeyServer: opt.keyserver_name = pargs.r.ret_str; break;
813           case oNotation: add_notation_data( pargs.r.ret_str ); break;
814           case oUtf8Strings: utf8_strings = 1; break;
815           case oNoUtf8Strings: utf8_strings = 0; break;
816
817           default : pargs.err = configfp? 1:2; break;
818         }
819     }
820     if( configfp ) {
821         fclose( configfp );
822         configfp = NULL;
823         m_free(configname); configname = NULL;
824         goto next_pass;
825     }
826     m_free( configname ); configname = NULL;
827     if( log_get_errorcount(0) )
828         g10_exit(2);
829
830     if( greeting ) {
831         fprintf(stderr, "%s %s; %s\n",
832                         strusage(11), strusage(13), strusage(14) );
833         fprintf(stderr, "%s\n", strusage(15) );
834       #ifdef IS_DEVELOPMENT_VERSION
835         log_info("NOTE: this is a development version!\n");
836       #endif
837     }
838     if( opt.batch )
839         tty_batchmode( 1 );
840
841     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
842
843     set_debug();
844     g10_opt_homedir = opt.homedir;
845
846     /* must do this after dropping setuid, because string_to...
847      * may try to load an module */
848     if( def_cipher_string ) {
849         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
850         m_free(def_cipher_string); def_cipher_string = NULL;
851         if( check_cipher_algo(opt.def_cipher_algo) )
852             log_error(_("selected cipher algorithm is invalid\n"));
853     }
854     if( def_digest_string ) {
855         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
856         m_free(def_digest_string); def_digest_string = NULL;
857         if( check_digest_algo(opt.def_digest_algo) )
858             log_error(_("selected digest algorithm is invalid\n"));
859     }
860     if( s2k_cipher_string ) {
861         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
862         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
863         if( check_cipher_algo(opt.s2k_cipher_algo) )
864             log_error(_("selected cipher algorithm is invalid\n"));
865     }
866     if( s2k_digest_string ) {
867         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
868         m_free(s2k_digest_string); s2k_digest_string = NULL;
869         if( check_digest_algo(opt.s2k_digest_algo) )
870             log_error(_("selected digest algorithm is invalid\n"));
871     }
872     if( opt.set_policy_url ) {
873         if( check_policy_url( opt.set_policy_url ) )
874             log_error(_("the given policy URL is invalid\n"));
875     }
876     if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
877         log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
878     if( opt.completes_needed < 1 )
879         log_error(_("completes-needed must be greater than 0\n"));
880     if( opt.marginals_needed < 2 )
881         log_error(_("marginals-needed must be greater than 1\n"));
882     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
883         log_error(_("max-cert-depth must be in range 1 to 255\n"));
884     switch( opt.s2k_mode ) {
885       case 0:
886         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
887         break;
888       case 1: case 3: break;
889       default:
890         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
891     }
892
893
894     if( log_get_errorcount(0) )
895         g10_exit(2);
896
897     if( !cmd && opt.fingerprint && !with_fpr )
898         set_cmd( &cmd, aListKeys);
899
900     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
901         if( cmd == aKModeC ) {
902             opt.fingerprint = 1;
903             cmd = aKMode;
904         }
905         opt.list_sigs = 0;
906         if( opt.verbose > 2 )
907             opt.check_sigs++;
908         if( opt.verbose > 1 )
909             opt.list_sigs++;
910
911         opt.verbose = opt.verbose > 1;
912         g10_opt_verbose = opt.verbose;
913     }
914
915
916     /* kludge to let -sat generate a clear text signature */
917     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
918         cmd = aClearsign;
919
920     if( opt.verbose > 1 )
921         set_packet_list_mode(1);
922
923     /* add the keyrings, but not for some special commands and
924      * not in case of "-kvv userid keyring" */
925     if( cmd != aDeArmor && cmd != aEnArmor
926         && !(cmd == aKMode && argc == 2 ) ) {
927
928         if( !sec_nrings && default_keyring )  /* add default secret rings */
929             add_keyblock_resource("secring.gpg", 0, 1);
930         for(sl = sec_nrings; sl; sl = sl->next )
931             add_keyblock_resource( sl->d, 0, 1 );
932         if( !nrings && default_keyring )  /* add default ring */
933             add_keyblock_resource("pubring.gpg", 0, 0);
934         for(sl = nrings; sl; sl = sl->next )
935             add_keyblock_resource( sl->d, 0, 0 );
936     }
937     FREE_STRLIST(nrings);
938     FREE_STRLIST(sec_nrings);
939
940
941     if( pwfd != -1 )  /* read the passphrase now. */
942         read_passphrase_from_fd( pwfd );
943
944     fname = argc? *argv : NULL;
945
946     switch( cmd ) {
947       case aPrimegen:
948       case aPrintMD:
949       case aPrintMDs:
950       case aGenRandom:
951       case aDeArmor:
952       case aEnArmor:
953       case aFixTrustDB:
954         break;
955       case aKMode:
956       case aListKeys:
957       case aListSecretKeys:
958       case aCheckKeys:
959         if( opt.with_colons ) /* need this to list the trust */
960             rc = setup_trustdb(1, trustdb_name );
961         break;
962       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
963       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
964       default: rc = setup_trustdb(1, trustdb_name ); break;
965     }
966     if( rc )
967         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
968
969
970     switch( cmd ) {
971       case aStore: /* only store the file */
972         if( argc > 1 )
973             wrong_args(_("--store [filename]"));
974         if( (rc = encode_store(fname)) )
975             log_error_f( print_fname_stdin(fname),
976                         "store failed: %s\n", g10_errstr(rc) );
977         break;
978       case aSym: /* encrypt the given file only with the symmetric cipher */
979         if( argc > 1 )
980             wrong_args(_("--symmetric [filename]"));
981         if( (rc = encode_symmetric(fname)) )
982             log_error_f(print_fname_stdin(fname),
983                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
984         break;
985
986       case aEncr: /* encrypt the given file */
987         if( argc > 1 )
988             wrong_args(_("--encrypt [filename]"));
989         if( (rc = encode_crypt(fname,remusr)) )
990             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
991         break;
992
993       case aSign: /* sign the given file */
994         sl = NULL;
995         if( detached_sig ) { /* sign all files */
996             for( ; argc; argc--, argv++ )
997                 add_to_strlist( &sl, *argv );
998         }
999         else {
1000             if( argc > 1 )
1001                 wrong_args(_("--sign [filename]"));
1002             if( argc ) {
1003                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
1004                 strcpy(sl->d, fname);
1005             }
1006         }
1007         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1008             log_error("signing failed: %s\n", g10_errstr(rc) );
1009         free_strlist(sl);
1010         break;
1011
1012       case aSignEncr: /* sign and encrypt the given file */
1013         if( argc > 1 )
1014             wrong_args(_("--sign --encrypt [filename]"));
1015         if( argc ) {
1016             sl = m_alloc_clear( sizeof *sl + strlen(fname));
1017             strcpy(sl->d, fname);
1018         }
1019         else
1020             sl = NULL;
1021         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1022             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1023         free_strlist(sl);
1024         break;
1025
1026       case aClearsign: /* make a clearsig */
1027         if( argc > 1 )
1028             wrong_args(_("--clearsign [filename]"));
1029         if( (rc = clearsign_file(fname, locusr, NULL)) )
1030             log_error("%s: clearsign failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1031         break;
1032
1033       case aVerify:
1034         if( (rc = verify_signatures( argc, argv ) ))
1035             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
1036         break;
1037
1038       case aDecrypt:
1039         if( argc > 1 )
1040             wrong_args(_("--decrypt [filename]"));
1041         if( (rc = decrypt_message( fname ) ))
1042             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
1043         break;
1044
1045
1046       case aSignKey: /* sign the key given as argument */
1047       case aEditKey: /* Edit a key signature */
1048         if( !argc )
1049             wrong_args(_("--edit-key username [commands]"));
1050         if( argc > 1 ) {
1051             sl = NULL;
1052             for( argc--, argv++ ; argc; argc--, argv++ )
1053                 append_to_strlist2( &sl, *argv, utf8_strings );
1054             keyedit_menu( fname, locusr, sl );
1055             free_strlist(sl);
1056         }
1057         else
1058             keyedit_menu(fname, locusr, NULL );
1059         break;
1060
1061       case aDeleteSecretKey:
1062         if( argc != 1 )
1063             wrong_args(_("--delete-secret-key username"));
1064       case aDeleteKey:
1065         if( argc != 1 )
1066             wrong_args(_("--delete-key username"));
1067         username = make_username( fname );
1068         if( (rc = delete_key(username, cmd==aDeleteSecretKey)) )
1069             log_error("%s: delete key failed: %s\n", username, g10_errstr(rc) );
1070         m_free(username);
1071         break;
1072
1073
1074       case aCheckKeys:
1075         opt.check_sigs = 1;
1076       case aListSigs:
1077         opt.list_sigs = 1;
1078       case aListKeys:
1079         public_key_list( argc, argv );
1080         break;
1081       case aListSecretKeys:
1082         secret_key_list( argc, argv );
1083         break;
1084
1085       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1086         if( argc < 2 )  /* -kv [userid] */
1087             public_key_list( (argc && **argv)? 1:0, argv );
1088         else if( argc == 2 ) { /* -kv userid keyring */
1089             if( access( argv[1], R_OK ) ) {
1090                 log_error(_("can't open %s: %s\n"),
1091                                print_fname_stdin(argv[1]), strerror(errno));
1092             }
1093             else {
1094                 /* add keyring (default keyrings are not registered in this
1095                  * special case */
1096                 add_keyblock_resource( argv[1], 0, 0 );
1097                 public_key_list( **argv?1:0, argv );
1098             }
1099         }
1100         else
1101             wrong_args(_("-k[v][v][v][c] [userid] [keyring]") );
1102         break;
1103
1104       case aKeygen: /* generate a key (interactive) */
1105         if( argc )
1106             wrong_args("--gen-key");
1107         generate_keypair();
1108         break;
1109
1110       case aFastImport:
1111       case aImport:
1112         if( !argc  ) {
1113             rc = import_keys( NULL, (cmd == aFastImport) );
1114             if( rc )
1115                 log_error("import failed: %s\n", g10_errstr(rc) );
1116         }
1117         for( ; argc; argc--, argv++ ) {
1118             rc = import_keys( *argv, (cmd == aFastImport) );
1119             if( rc )
1120                 log_error("import from `%s' failed: %s\n",
1121                                                 *argv, g10_errstr(rc) );
1122         }
1123         break;
1124
1125       case aExport:
1126       case aExportAll:
1127       case aSendKeys:
1128       case aRecvKeys:
1129         sl = NULL;
1130         for( ; argc; argc--, argv++ )
1131             add_to_strlist2( &sl, *argv, utf8_strings );
1132         if( cmd == aSendKeys )
1133             hkp_export( sl );
1134         else if( cmd == aRecvKeys )
1135             hkp_import( sl );
1136         else
1137             export_pubkeys( sl, (cmd == aExport) );
1138         free_strlist(sl);
1139         break;
1140
1141       case aExportSecret:
1142         sl = NULL;
1143         for( ; argc; argc--, argv++ )
1144             add_to_strlist2( &sl, *argv, utf8_strings );
1145         export_seckeys( sl );
1146         free_strlist(sl);
1147         break;
1148
1149       case aGenRevoke:
1150         if( argc != 1 )
1151             wrong_args("--gen-revoke user-id");
1152         username =  make_username(*argv);
1153         gen_revoke( username );
1154         m_free( username );
1155         break;
1156
1157       case aDeArmor:
1158         if( argc > 1 )
1159             wrong_args("--dearmor [file]");
1160         rc = dearmor_file( argc? *argv: NULL );
1161         if( rc )
1162             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
1163         break;
1164
1165       case aEnArmor:
1166         if( argc > 1 )
1167             wrong_args("--enarmor [file]");
1168         rc = enarmor_file( argc? *argv: NULL );
1169         if( rc )
1170             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
1171         break;
1172
1173
1174      #ifdef MAINTAINER_OPTIONS
1175       case aPrimegen:
1176         if( argc == 1 ) {
1177             mpi_print( stdout, generate_public_prime( atoi(argv[0]) ), 1);
1178             putchar('\n');
1179         }
1180         else if( argc == 2 ) {
1181             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
1182                                                    atoi(argv[1]), NULL,NULL ), 1);
1183             putchar('\n');
1184         }
1185         else if( argc == 3 ) {
1186             MPI g = mpi_alloc(1);
1187             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
1188                                                    atoi(argv[1]), g, NULL ), 1);
1189             printf("\nGenerator: ");
1190             mpi_print( stdout, g, 1 );
1191             putchar('\n');
1192             mpi_free(g);
1193         }
1194         else if( argc == 4 ) {
1195             mpi_print( stdout, generate_elg_prime( 1, atoi(argv[0]),
1196                                                    atoi(argv[1]), NULL,NULL ), 1);
1197             putchar('\n');
1198         }
1199         else
1200             usage(1);
1201         break;
1202       #endif /* MAINTAINER OPTIONS */
1203
1204       #ifdef MAINTAINER_OPTIONS
1205       case aGenRandom:
1206         if( argc < 1 || argc > 2 )
1207             wrong_args("--gen-random level [hex]");
1208         {
1209             int c;
1210             int level = atoi(*argv);
1211             for(;;) {
1212                 byte *p;
1213                 if( argc == 2 ) {
1214                     p = get_random_bits( 8, level, 0);
1215                     printf("%02x", *p );
1216                     fflush(stdout);
1217                 }
1218                 else {
1219                     p = get_random_bits( 800, level, 0);
1220                     for(c=0; c < 100; c++ )
1221                         putchar( p[c] );
1222                 }
1223                 m_free(p);
1224             }
1225         }
1226         break;
1227       #endif /* MAINTAINER OPTIONS */
1228
1229       case aPrintMD:
1230         if( argc < 1)
1231             wrong_args("--print-md algo [file]");
1232         else {
1233             int algo = string_to_digest_algo(*argv);
1234
1235             if( !algo )
1236                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
1237             else {
1238                 argc--; argv++;
1239                 if( !argc )
1240                     print_mds(NULL, algo);
1241                 else {
1242                     for(; argc; argc--, argv++ )
1243                         print_mds(*argv, algo);
1244                 }
1245             }
1246         }
1247         break;
1248
1249       case aPrintMDs:
1250         if( !argc )
1251             print_mds(NULL,0);
1252         else {
1253             for(; argc; argc--, argv++ )
1254                 print_mds(*argv,0);
1255         }
1256         break;
1257
1258       case aListTrustDB:
1259         if( !argc )
1260             list_trustdb(NULL);
1261         else {
1262             for( ; argc; argc--, argv++ )
1263                 list_trustdb( *argv );
1264         }
1265         break;
1266
1267       case aUpdateTrustDB:
1268         if( argc )
1269             wrong_args("--update-trustdb");
1270         update_trustdb();
1271         break;
1272
1273       case aCheckTrustDB:
1274         if( !argc )
1275             check_trustdb(NULL);
1276         else {
1277             for( ; argc; argc--, argv++ ) {
1278                 username = make_username( *argv );
1279                 check_trustdb( username );
1280                 m_free(username);
1281             }
1282         }
1283         break;
1284
1285       case aFixTrustDB:
1286         log_error("this command ist not yet implemented.\"\n");
1287         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
1288         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
1289         break;
1290
1291       case aListTrustPath:
1292         if( !argc )
1293             wrong_args("--list-trust-path <usernames>");
1294         for( ; argc; argc--, argv++ ) {
1295             username = make_username( *argv );
1296             list_trust_path( username );
1297             m_free(username);
1298         }
1299         break;
1300
1301       case aExportOwnerTrust:
1302         if( argc )
1303             wrong_args("--export-ownertrust");
1304         export_ownertrust();
1305         break;
1306
1307       case aImportOwnerTrust:
1308         if( argc > 1 )
1309             wrong_args("--import-ownertrust [file]");
1310         import_ownertrust( argc? *argv:NULL );
1311         break;
1312
1313       case aListPackets:
1314         opt.list_packets=1;
1315       default:
1316         if( argc > 1 )
1317             wrong_args(_("[filename]"));
1318         /* Issue some output for the unix newbie */
1319         if( !fname && !opt.outfile && isatty( fileno(stdin) )
1320                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
1321             log_info(_("Go ahead and type your message ...\n"));
1322
1323         if( !(a = iobuf_open(fname)) )
1324             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
1325         else {
1326
1327             if( !opt.no_armor ) {
1328                 if( use_armor_filter( a ) ) {
1329                     memset( &afx, 0, sizeof afx);
1330                     iobuf_push_filter( a, armor_filter, &afx );
1331                 }
1332             }
1333             if( cmd == aListPackets ) {
1334                 set_packet_list_mode(1);
1335                 opt.list_packets=1;
1336             }
1337             rc = proc_packets(NULL, a );
1338             if( rc )
1339                 log_error("processing message failed: %s\n", g10_errstr(rc) );
1340             iobuf_close(a);
1341         }
1342         break;
1343     }
1344
1345     /* cleanup */
1346     FREE_STRLIST(remusr);
1347     FREE_STRLIST(locusr);
1348     g10_exit(0);
1349     return 8; /*NEVER REACHED*/
1350 }
1351
1352
1353 void
1354 g10_exit( int rc )
1355 {
1356     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1357         m_print_stats("on exit");
1358         random_dump_stats();
1359     }
1360     if( opt.debug )
1361         secmem_dump_stats();
1362     secmem_term();
1363     rc = rc? rc : log_get_errorcount(0)? 2 :
1364                         g10_errors_seen? 1 : 0;
1365     /*write_status( STATUS_LEAVE );*/
1366     exit(rc );
1367 }
1368
1369
1370
1371
1372 static void
1373 print_hex( byte *p, size_t n )
1374 {
1375     int i;
1376
1377     if( n == 20 ) {
1378         for(i=0; i < n ; i++, i++, p += 2 ) {
1379             if( i )
1380                 putchar(' ');
1381             if( i == 10 )
1382                 putchar(' ');
1383             printf("%02X%02X", *p, p[1] );
1384         }
1385     }
1386     else if( n == 24 ) {
1387         for(i=0; i < n ; i += 4, p += 4 ) {
1388             if( i )
1389                 putchar(' ');
1390             if( i == 12 )
1391                 putchar(' ');
1392             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
1393         }
1394     }
1395     else {
1396         for(i=0; i < n ; i++, p++ ) {
1397             if( i )
1398                 putchar(' ');
1399             if( i && !(i%8) )
1400                 putchar(' ');
1401             printf("%02X", *p );
1402         }
1403     }
1404 }
1405
1406 static void
1407 print_mds( const char *fname, int algo )
1408 {
1409     FILE *fp;
1410     char buf[1024];
1411     size_t n;
1412     MD_HANDLE md;
1413     char *pname;
1414
1415     if( !fname ) {
1416         fp = stdin;
1417         pname = m_strdup("[stdin]: ");
1418     }
1419     else {
1420         pname = m_alloc(strlen(fname)+3);
1421         strcpy(stpcpy(pname,fname),": ");
1422         fp = fopen( fname, "rb" );
1423     }
1424     if( !fp ) {
1425         log_error("%s%s\n", pname, strerror(errno) );
1426         m_free(pname);
1427         return;
1428     }
1429
1430     md = md_open( 0, 0 );
1431     if( algo )
1432         md_enable( md, algo );
1433     else {
1434         md_enable( md, DIGEST_ALGO_MD5 );
1435         md_enable( md, DIGEST_ALGO_SHA1 );
1436         md_enable( md, DIGEST_ALGO_RMD160 );
1437         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
1438             md_enable( md, DIGEST_ALGO_TIGER );
1439     }
1440
1441     while( (n=fread( buf, 1, DIM(buf), fp )) )
1442         md_write( md, buf, n );
1443     if( ferror(fp) )
1444         log_error("%s%s\n", pname, strerror(errno) );
1445     else {
1446         md_final(md);
1447         if( algo ) {
1448             if( fname )
1449                 fputs( pname, stdout );
1450             print_hex(md_read(md, algo), md_digest_length(algo) );
1451         }
1452         else {
1453             printf(  "%s   MD5 = ", fname?pname:"" );
1454                             print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
1455             printf("\n%s  SHA1 = ", fname?pname:""  );
1456                             print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
1457             printf("\n%sRMD160 = ", fname?pname:""  );
1458                             print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
1459             if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
1460                 printf("\n%s TIGER = ", fname?pname:""  );
1461                             print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
1462             }
1463         }
1464         putchar('\n');
1465     }
1466     md_close(md);
1467
1468     if( fp != stdin )
1469         fclose(fp);
1470 }
1471
1472
1473 /****************
1474  * Check the supplied name,value string and add it to the notation
1475  * data to be used for signatures.
1476  */
1477 static void
1478 add_notation_data( const char *string )
1479 {
1480     const char *s;
1481     const char *s2;
1482     STRLIST sl;
1483     int critical=0;
1484     int highbit=0;
1485
1486     if( *string == '!' ) {
1487         critical = 1;
1488         string++;
1489     }
1490     s = string;
1491
1492     if( !*s || (*s & 0x80) || (!isalpha(*s) && *s != '_') ) {
1493         log_error(_("the first character of a notation name "
1494                     "must be a letter or an underscore\n") );
1495         return;
1496     }
1497     for(s++; *s != '='; s++ ) {
1498         if( !*s || (*s & 0x80) || (!isalnum(*s) && *s != '_' && *s != '.' ) ) {
1499             log_error(_("a notation name must have only letters, "
1500                         "digits, dots or underscores and end with an '='\n") );
1501             return;
1502         }
1503     }
1504     if( s[-1] == '.' || ((s2=strstr(string, "..")) && s2 < s ) ) {
1505         log_error(_("dots in a notation name must be surrounded "
1506                     "by other characters\n") );
1507         return;
1508     }
1509     /* we do only support printabe text - therefore we enforce the use
1510      * of only printable characters (an empty value is valid) */
1511     for( s++; *s ; s++ ) {
1512         if( iscntrl(*s) ) {
1513             log_error(_("a notation value must not use "
1514                         "any control characters\n") );
1515             return;
1516         }
1517         else if( *s & 0x80 )
1518             highbit = 1;
1519     }
1520
1521     if( highbit )   /* must use UTF8 encoding */
1522         sl = add_to_strlist2( &opt.notation_data, string, utf8_strings );
1523     else
1524         sl = add_to_strlist( &opt.notation_data, string );
1525
1526     if( critical )
1527         sl->flags |= 1;
1528 }
1529
1530
1531 static int
1532 check_policy_url( const char *s )
1533 {
1534     if( *s == '!' )
1535         s++;
1536     if( !*s )
1537         return -1;
1538     for(; *s ; s++ ) {
1539         if( (*s & 0x80) || iscntrl(*s) )
1540             return -1;
1541     }
1542     return 0;
1543 }
1544