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