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