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