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