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