See ChangeLog: Tue Jul 13 17:39:25 CEST 1999 Werner Koch
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  *      Copyright (C) 1998, 1999 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28
29
30 #include "packet.h"
31 #include "iobuf.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "main.h"
35 #include "options.h"
36 #include "keydb.h"
37 #include "trustdb.h"
38 #include "mpi.h"
39 #include "cipher.h"
40 #include "filter.h"
41 #include "ttyio.h"
42 #include "i18n.h"
43 #include "status.h"
44 #include "g10defs.h"
45 #include "hkp.h"
46
47
48 enum cmd_and_opt_values { aNull = 0,
49     oArmor        = 'a',
50     aDetachedSign = 'b',
51     aSym          = 'c',
52     aDecrypt      = 'd',
53     aEncr         = 'e',
54     oInteractive  = 'i',
55     oKOption      = 'k',
56     oDryRun       = 'n',
57     oOutput       = 'o',
58     oQuiet        = 'q',
59     oRecipient    = 'r',
60     aSign         = 's',
61     oTextmodeShort= 't',
62     oUser         = 'u',
63     oVerbose      = 'v',
64     oCompress     = 'z',
65     oNotation     = 'N',
66     oBatch        = 500,
67     aClearsign,
68     aStore,
69     aKeygen,
70     aSignEncr,
71     aSignKey,
72     aLSignKey,
73     aListPackets,
74     aEditKey,
75     aDeleteKey,
76     aDeleteSecretKey,
77     aKMode,
78     aKModeC,
79     aImport,
80     aFastImport,
81     aVerify,
82     aListKeys,
83     aListSigs,
84     aListSecretKeys,
85     aSendKeys,
86     aRecvKeys,
87     aExport,
88     aExportAll,
89     aExportSecret,
90     aCheckKeys,
91     aGenRevoke,
92     aPrimegen,
93     aPrintMD,
94     aPrintMDs,
95     aCheckTrustDB,
96     aUpdateTrustDB,
97     aFixTrustDB,
98     aListTrustDB,
99     aListTrustPath,
100     aExportOwnerTrust,
101     aImportOwnerTrust,
102     aDeArmor,
103     aEnArmor,
104     aGenRandom,
105
106     oTextmode,
107     oFingerprint,
108     oWithFingerprint,
109     oAnswerYes,
110     oAnswerNo,
111     oKeyring,
112     oSecretKeyring,
113     oDefaultKey,
114     oDefRecipient,
115     oDefRecipientSelf,
116     oNoDefRecipient,
117     oOptions,
118     oDebug,
119     oDebugAll,
120     oStatusFD,
121     oNoComment,
122     oNoVersion,
123     oEmitVersion,
124     oCompletesNeeded,
125     oMarginalsNeeded,
126     oMaxCertDepth,
127     oLoadExtension,
128     oRFC1991,
129     oOpenPGP,
130     oCipherAlgo,
131     oDigestAlgo,
132     oCompressAlgo,
133     oPasswdFD,
134     oQuickRandom,
135     oNoVerbose,
136     oTrustDBName,
137     oNoSecmemWarn,
138     oNoArmor,
139     oNoDefKeyring,
140     oNoGreeting,
141     oNoTTY,
142     oNoOptions,
143     oNoBatch,
144     oHomedir,
145     oWithColons,
146     oWithKeyData,
147     oSkipVerify,
148     oCompressKeys,
149     oCompressSigs,
150     oAlwaysTrust,
151     oEmuChecksumBug,
152     oRunAsShmCP,
153     oSetFilename,
154     oSetPolicyURL,
155     oUseEmbeddedFilename,
156     oComment,
157     oDefaultComment,
158     oThrowKeyid,
159     oForceV3Sigs,
160     oForceMDC,
161     oS2KMode,
162     oS2KDigest,
163     oS2KCipher,
164     oCharset,
165     oNotDashEscaped,
166     oEscapeFrom,
167     oLockOnce,
168     oLockMultiple,
169     oKeyServer,
170     oEncryptTo,
171     oNoEncryptTo,
172     oLoggerFD,
173     oUtf8Strings,
174     oNoUtf8Strings,
175 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_("|[NAMES]|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     enum cmd_and_opt_values cmd = 0;
530     const char *trustdb_name = NULL;
531     char *def_cipher_string = NULL;
532     char *def_digest_string = NULL;
533     char *s2k_cipher_string = NULL;
534     char *s2k_digest_string = NULL;
535     int pwfd = -1;
536     int with_fpr = 0; /* make an option out of --fingerprint */
537   #ifdef USE_SHM_COPROCESSING
538     ulong requested_shm_size=0;
539   #endif
540
541     trap_unaligned();
542     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
543     /* Please note that we may running SUID(ROOT), so be very CAREFUL
544      * when adding any stuff between here and the call to
545      * secmem_init()  somewhere after the option parsing
546      */
547     log_set_name("gpg");
548     secure_random_alloc(); /* put random number into secure memory */
549     disable_core_dumps();
550     init_signals();
551     create_dotlock(NULL); /* register locking cleanup */
552     i18n_init();
553     opt.compress = -1; /* defaults to standard compress level */
554     /* note: if you change these lines, look at oOpenPGP */
555     opt.def_cipher_algo = 0;
556     opt.def_digest_algo = 0;
557     opt.def_compress_algo = 2;
558     opt.s2k_mode = 3; /* iterated+salted */
559     opt.s2k_digest_algo = DIGEST_ALGO_RMD160;
560     opt.s2k_cipher_algo = CIPHER_ALGO_BLOWFISH;
561     opt.completes_needed = 1;
562     opt.marginals_needed = 3;
563     opt.max_cert_depth = 5;
564     opt.homedir = getenv("GNUPGHOME");
565     if( !opt.homedir || !*opt.homedir ) {
566       #ifdef HAVE_DRIVE_LETTERS
567         opt.homedir = "c:/gnupg";
568       #else
569         opt.homedir = "~/.gnupg";
570       #endif
571     }
572
573     /* check whether we have a config file on the commandline */
574     orig_argc = argc;
575     orig_argv = argv;
576     pargs.argc = &argc;
577     pargs.argv = &argv;
578     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
579     while( arg_parse( &pargs, opts) ) {
580         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
581             parse_debug++;
582         else if( pargs.r_opt == oOptions ) {
583             /* yes there is one, so we do not try the default one, but
584              * read the option file when it is encountered at the commandline
585              */
586             default_config = 0;
587         }
588         else if( pargs.r_opt == oNoOptions )
589             default_config = 0; /* --no-options */
590         else if( pargs.r_opt == oHomedir )
591             opt.homedir = pargs.r.ret_str;
592       #ifdef USE_SHM_COPROCESSING
593         else if( pargs.r_opt == oRunAsShmCP ) {
594             /* does not make sense in a options file, we do it here,
595              * so that we are the able to drop setuid as soon as possible */
596             opt.shm_coprocess = 1;
597             requested_shm_size = pargs.r.ret_ulong;
598         }
599         else if ( pargs.r_opt == oStatusFD ) {
600             /* this is needed to ensure that the status-fd filedescriptor is
601              * initialized when init_shm_coprocessing() is called */
602             set_status_fd( pargs.r.ret_int );
603         }
604       #endif
605     }
606
607
608   #ifdef USE_SHM_COPROCESSING
609     if( opt.shm_coprocess ) {
610         init_shm_coprocessing(requested_shm_size, 1 );
611     }
612   #endif
613     /* initialize the secure memory. */
614     secmem_init( 16384 );
615     maybe_setuid = 0;
616     /* Okay, we are now working under our real uid */
617
618     if( default_config )
619         configname = make_filename(opt.homedir, "options", NULL );
620
621     argc = orig_argc;
622     argv = orig_argv;
623     pargs.argc = &argc;
624     pargs.argv = &argv;
625     pargs.flags=  1;  /* do not remove the args */
626   next_pass:
627     if( configname ) {
628         configlineno = 0;
629         configfp = fopen( configname, "r" );
630         if( !configfp ) {
631             if( default_config ) {
632                 if( parse_debug )
633                     log_info(_("NOTE: no default option file `%s'\n"),
634                                                             configname );
635             }
636             else {
637                 log_error(_("option file `%s': %s\n"),
638                                     configname, strerror(errno) );
639                 g10_exit(2);
640             }
641             m_free(configname); configname = NULL;
642         }
643         if( parse_debug && configname )
644             log_info(_("reading options from `%s'\n"), configname );
645         default_config = 0;
646     }
647
648     while( optfile_parse( configfp, configname, &configlineno,
649                                                 &pargs, opts) ) {
650         switch( pargs.r_opt ) {
651           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
652           case aListPackets: set_cmd( &cmd, aListPackets); break;
653           case aImport: set_cmd( &cmd, aImport); break;
654           case aFastImport: set_cmd( &cmd, aFastImport); break;
655           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
656           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
657           case aExport: set_cmd( &cmd, aExport); break;
658           case aExportAll: set_cmd( &cmd, aExportAll); break;
659           case aListKeys: set_cmd( &cmd, aListKeys); break;
660           case aListSigs: set_cmd( &cmd, aListSigs); break;
661           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
662           case aDeleteSecretKey: set_cmd( &cmd, aDeleteSecretKey);
663                                                         greeting=1; break;
664           case aDeleteKey: set_cmd( &cmd, aDeleteKey); greeting=1; break;
665
666           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
667           case aSym: set_cmd( &cmd, aSym); break;
668           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
669           case aEncr: set_cmd( &cmd, aEncr); break;
670           case aSign: set_cmd( &cmd, aSign );  break;
671           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
672           case aSignKey: set_cmd( &cmd, aSignKey); break;
673           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
674           case aStore: set_cmd( &cmd, aStore); break;
675           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
676           case aClearsign: set_cmd( &cmd, aClearsign); break;
677           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
678           case aVerify: set_cmd( &cmd, aVerify); break;
679           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
680           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
681           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
682           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
683           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
684           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
685           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
686           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
687           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
688           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
689           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
690           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
691           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
692
693           case oArmor: opt.armor = 1; opt.no_armor=0; break;
694           case oOutput: opt.outfile = pargs.r.ret_str; break;
695           case oQuiet: opt.quiet = 1; break;
696           case oNoTTY: opt.quiet = 1; tty_no_terminal(1); break;
697           case oDryRun: opt.dry_run = 1; break;
698           case oInteractive: opt.interactive = 1; break;
699           case oVerbose: g10_opt_verbose++;
700                     opt.verbose++; opt.list_sigs=1; break;
701           case oKOption: set_cmd( &cmd, aKMode ); break;
702
703           case oBatch: opt.batch = 1; greeting = 0; break;
704           case oAnswerYes: opt.answer_yes = 1; break;
705           case oAnswerNo: opt.answer_no = 1; break;
706           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
707           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
708           case oDebugAll: opt.debug = ~0; break;
709           case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
710           case oLoggerFD: log_set_logfile( NULL, pargs.r.ret_int ); break;
711           case oWithFingerprint:
712                 with_fpr=1; /*fall thru*/
713           case oFingerprint: opt.fingerprint++; break;
714           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
715           case oOptions:
716             /* config files may not be nested (silently ignore them) */
717             if( !configfp ) {
718                 m_free(configname);
719                 configname = m_strdup(pargs.r.ret_str);
720                 goto next_pass;
721             }
722             break;
723           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
724           case oNoDefKeyring: default_keyring = 0; break;
725           case oNoGreeting: greeting = 0; break;
726           case oNoVerbose: g10_opt_verbose = 0;
727                            opt.verbose = 0; opt.list_sigs=0; break;
728           case oQuickRandom: quick_random_gen(1); break;
729           case oNoComment: opt.no_comment=1; break;
730           case oNoVersion: opt.no_version=1; break;
731           case oEmitVersion: opt.no_version=0; break;
732           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
733           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
734           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
735           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
736           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
737           case oDefRecipient:
738                     if( *pargs.r.ret_str )
739                         opt.def_recipient = make_username(pargs.r.ret_str);
740                     break;
741           case oDefRecipientSelf:
742                     m_free(opt.def_recipient); opt.def_recipient = NULL;
743                     opt.def_recipient_self = 1;
744                     break;
745           case oNoDefRecipient:
746                     m_free(opt.def_recipient); opt.def_recipient = NULL;
747                     opt.def_recipient_self = 0;
748                     break;
749           case oNoOptions: break; /* no-options */
750           case oHomedir: opt.homedir = pargs.r.ret_str; break;
751           case oNoBatch: opt.batch = 0; break;
752           case oWithKeyData: opt.with_key_data=1; /* fall thru */
753           case oWithColons: opt.with_colons=':'; break;
754
755           case oSkipVerify: opt.skip_verify=1; break;
756           case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
757           case oCompressKeys: opt.compress_keys = 1; break;
758           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
759           case oAlwaysTrust: opt.always_trust = 1; break;
760           case oLoadExtension:
761             register_cipher_extension(orig_argc? *orig_argv:NULL,
762                                       pargs.r.ret_str);
763             break;
764           case oRFC1991:
765             opt.rfc1991 = 1;
766             opt.no_comment = 1;
767             opt.escape_from = 1;
768             break;
769           case oOpenPGP:
770             opt.rfc1991 = 0;
771             opt.escape_from = 0;
772             opt.force_v3_sigs = 0;
773             opt.compress_keys = 0;          /* not mandated  but we do it */
774             opt.compress_sigs = 0;          /* ditto. */
775             opt.not_dash_escaped = 0;
776             opt.def_cipher_algo = 0;
777             opt.def_digest_algo = 0;
778             opt.def_compress_algo = 2;
779             opt.s2k_mode = 3; /* iterated+salted */
780             opt.s2k_digest_algo = DIGEST_ALGO_RMD160;
781             opt.s2k_cipher_algo = CIPHER_ALGO_BLOWFISH;
782             break;
783           case oEmuChecksumBug: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
784           case oCompressSigs: opt.compress_sigs = 1; break;
785           case oRunAsShmCP:
786           #ifndef USE_SHM_COPROCESSING
787             /* not possible in the option file,
788              * but we print the warning here anyway */
789             log_error("shared memory coprocessing is not available\n");
790           #endif
791             break;
792           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
793           case oSetPolicyURL: opt.set_policy_url = pargs.r.ret_str; break;
794           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
795           case oComment: opt.comment_string = pargs.r.ret_str; break;
796           case oDefaultComment: opt.comment_string = NULL; break;
797           case oThrowKeyid: opt.throw_keyid = 1; break;
798           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
799           case oForceMDC: opt.force_mdc = 1; break;
800           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
801           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
802           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
803
804           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
805           case oEncryptTo: /* store the recipient in the second list */
806             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
807             sl->flags = 1;
808             break;
809           case oRecipient: /* store the recipient */
810             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
811             break;
812           case oTextmodeShort: opt.textmode = 2; break;
813           case oTextmode: opt.textmode=1;  break;
814           case oUser: /* store the local users */
815             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
816             break;
817           case oCompress: opt.compress = pargs.r.ret_int; break;
818           case oPasswdFD: pwfd = pargs.r.ret_int; break;
819           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
820           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
821           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
822           case oCharset:
823             if( set_native_charset( pargs.r.ret_str ) )
824                 log_error(_("%s is not a valid character set\n"),
825                                                     pargs.r.ret_str);
826             break;
827           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
828           case oEscapeFrom: opt.escape_from = 1; break;
829           case oLockOnce: opt.lock_once = 1; break;
830           case oLockMultiple: opt.lock_once = 0; break;
831           case oKeyServer: opt.keyserver_name = pargs.r.ret_str; break;
832           case oNotation: add_notation_data( pargs.r.ret_str ); break;
833           case oUtf8Strings: utf8_strings = 1; break;
834           case oNoUtf8Strings: utf8_strings = 0; break;
835
836           default : pargs.err = configfp? 1:2; break;
837         }
838     }
839     if( configfp ) {
840         fclose( configfp );
841         configfp = NULL;
842         m_free(configname); configname = NULL;
843         goto next_pass;
844     }
845     m_free( configname ); configname = NULL;
846     if( log_get_errorcount(0) )
847         g10_exit(2);
848
849     if( greeting ) {
850         fprintf(stderr, "%s %s; %s\n",
851                         strusage(11), strusage(13), strusage(14) );
852         fprintf(stderr, "%s\n", strusage(15) );
853     }
854   #ifdef IS_DEVELOPMENT_VERSION
855     if( !opt.batch )
856         log_info("NOTE: this is a development version!\n");
857   #endif
858     if( opt.batch )
859         tty_batchmode( 1 );
860
861     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
862
863     set_debug();
864     g10_opt_homedir = opt.homedir;
865
866     /* must do this after dropping setuid, because string_to...
867      * may try to load an module */
868     if( def_cipher_string ) {
869         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
870         m_free(def_cipher_string); def_cipher_string = NULL;
871         if( check_cipher_algo(opt.def_cipher_algo) )
872             log_error(_("selected cipher algorithm is invalid\n"));
873     }
874     if( def_digest_string ) {
875         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
876         m_free(def_digest_string); def_digest_string = NULL;
877         if( check_digest_algo(opt.def_digest_algo) )
878             log_error(_("selected digest algorithm is invalid\n"));
879     }
880     if( s2k_cipher_string ) {
881         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
882         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
883         if( check_cipher_algo(opt.s2k_cipher_algo) )
884             log_error(_("selected cipher algorithm is invalid\n"));
885     }
886     if( s2k_digest_string ) {
887         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
888         m_free(s2k_digest_string); s2k_digest_string = NULL;
889         if( check_digest_algo(opt.s2k_digest_algo) )
890             log_error(_("selected digest algorithm is invalid\n"));
891     }
892     if( opt.set_policy_url ) {
893         if( check_policy_url( opt.set_policy_url ) )
894             log_error(_("the given policy URL is invalid\n"));
895     }
896     if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
897         log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
898     if( opt.completes_needed < 1 )
899         log_error(_("completes-needed must be greater than 0\n"));
900     if( opt.marginals_needed < 2 )
901         log_error(_("marginals-needed must be greater than 1\n"));
902     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
903         log_error(_("max-cert-depth must be in range 1 to 255\n"));
904     switch( opt.s2k_mode ) {
905       case 0:
906         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
907         break;
908       case 1: case 3: break;
909       default:
910         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
911     }
912
913
914     if( log_get_errorcount(0) )
915         g10_exit(2);
916
917     if( !cmd && opt.fingerprint && !with_fpr )
918         set_cmd( &cmd, aListKeys);
919
920     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
921         if( cmd == aKModeC ) {
922             opt.fingerprint = 1;
923             cmd = aKMode;
924         }
925         opt.list_sigs = 0;
926         if( opt.verbose > 2 )
927             opt.check_sigs++;
928         if( opt.verbose > 1 )
929             opt.list_sigs++;
930
931         opt.verbose = opt.verbose > 1;
932         g10_opt_verbose = opt.verbose;
933     }
934
935
936     /* kludge to let -sat generate a clear text signature */
937     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
938         cmd = aClearsign;
939
940     if( opt.verbose > 1 )
941         set_packet_list_mode(1);
942
943     /* add the keyrings, but not for some special commands and
944      * not in case of "-kvv userid keyring" */
945     if( cmd != aDeArmor && cmd != aEnArmor
946         && !(cmd == aKMode && argc == 2 ) ) {
947
948         if( !sec_nrings && default_keyring )  /* add default secret rings */
949             add_keyblock_resource("secring.gpg", 0, 1);
950         for(sl = sec_nrings; sl; sl = sl->next )
951             add_keyblock_resource( sl->d, 0, 1 );
952         if( !nrings && default_keyring )  /* add default ring */
953             add_keyblock_resource("pubring.gpg", 0, 0);
954         for(sl = nrings; sl; sl = sl->next )
955             add_keyblock_resource( sl->d, 0, 0 );
956     }
957     FREE_STRLIST(nrings);
958     FREE_STRLIST(sec_nrings);
959
960
961     if( pwfd != -1 )  /* read the passphrase now. */
962         read_passphrase_from_fd( pwfd );
963
964     fname = argc? *argv : NULL;
965
966     switch( cmd ) {
967       case aPrimegen:
968       case aPrintMD:
969       case aPrintMDs:
970       case aGenRandom:
971       case aDeArmor:
972       case aEnArmor:
973       case aFixTrustDB:
974         break;
975       case aKMode:
976       case aListKeys:
977       case aListSecretKeys:
978       case aCheckKeys:
979         if( opt.with_colons ) /* need this to list the trust */
980             rc = setup_trustdb(1, trustdb_name );
981         break;
982       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
983       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
984       default: rc = setup_trustdb(1, trustdb_name ); break;
985     }
986     if( rc )
987         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
988
989
990     switch( cmd ) {
991       case aStore: /* only store the file */
992         if( argc > 1 )
993             wrong_args(_("--store [filename]"));
994         if( (rc = encode_store(fname)) )
995             log_error_f( print_fname_stdin(fname),
996                         "store failed: %s\n", g10_errstr(rc) );
997         break;
998       case aSym: /* encrypt the given file only with the symmetric cipher */
999         if( argc > 1 )
1000             wrong_args(_("--symmetric [filename]"));
1001         if( (rc = encode_symmetric(fname)) )
1002             log_error_f(print_fname_stdin(fname),
1003                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
1004         break;
1005
1006       case aEncr: /* encrypt the given file */
1007         if( argc > 1 )
1008             wrong_args(_("--encrypt [filename]"));
1009         if( (rc = encode_crypt(fname,remusr)) )
1010             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1011         break;
1012
1013       case aSign: /* sign the given file */
1014         sl = NULL;
1015         if( detached_sig ) { /* sign all files */
1016             for( ; argc; argc--, argv++ )
1017                 add_to_strlist( &sl, *argv );
1018         }
1019         else {
1020             if( argc > 1 )
1021                 wrong_args(_("--sign [filename]"));
1022             if( argc ) {
1023                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
1024                 strcpy(sl->d, fname);
1025             }
1026         }
1027         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1028             log_error("signing failed: %s\n", g10_errstr(rc) );
1029         free_strlist(sl);
1030         break;
1031
1032       case aSignEncr: /* sign and encrypt the given file */
1033         if( argc > 1 )
1034             wrong_args(_("--sign --encrypt [filename]"));
1035         if( argc ) {
1036             sl = m_alloc_clear( sizeof *sl + strlen(fname));
1037             strcpy(sl->d, fname);
1038         }
1039         else
1040             sl = NULL;
1041         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1042             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1043         free_strlist(sl);
1044         break;
1045
1046       case aClearsign: /* make a clearsig */
1047         if( argc > 1 )
1048             wrong_args(_("--clearsign [filename]"));
1049         if( (rc = clearsign_file(fname, locusr, NULL)) )
1050             log_error("%s: clearsign failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1051         break;
1052
1053       case aVerify:
1054         if( (rc = verify_signatures( argc, argv ) ))
1055             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
1056         break;
1057
1058       case aDecrypt:
1059         if( argc > 1 )
1060             wrong_args(_("--decrypt [filename]"));
1061         if( (rc = decrypt_message( fname ) ))
1062             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
1063         break;
1064
1065
1066       case aSignKey: /* sign the key given as argument */
1067         if( argc != 1 )
1068             wrong_args(_("--sign-key user-id"));
1069         username = make_username( fname );
1070         keyedit_menu(fname, locusr, NULL, 1 );
1071         m_free(username);
1072         break;
1073
1074       case aLSignKey:
1075         if( argc != 1 )
1076             wrong_args(_("--lsign-key user-id"));
1077         username = make_username( fname );
1078         keyedit_menu(fname, locusr, NULL, 2 );
1079         m_free(username);
1080         break;
1081
1082       case aEditKey: /* Edit a key signature */
1083         if( !argc )
1084             wrong_args(_("--edit-key user-id [commands]"));
1085         username = make_username( fname );
1086         if( argc > 1 ) {
1087             sl = NULL;
1088             for( argc--, argv++ ; argc; argc--, argv++ )
1089                 append_to_strlist( &sl, *argv );
1090             keyedit_menu( username, locusr, sl, 0 );
1091             free_strlist(sl);
1092         }
1093         else
1094             keyedit_menu(username, locusr, NULL, 0 );
1095         m_free(username);
1096         break;
1097
1098       case aDeleteSecretKey:
1099         if( argc != 1 )
1100             wrong_args(_("--delete-secret-key user-id"));
1101       case aDeleteKey:
1102         if( argc != 1 )
1103             wrong_args(_("--delete-key user-id"));
1104         username = make_username( fname );
1105         if( (rc = delete_key(username, cmd==aDeleteSecretKey)) )
1106             log_error("%s: delete key failed: %s\n", username, g10_errstr(rc) );
1107         m_free(username);
1108         break;
1109
1110
1111       case aCheckKeys:
1112         opt.check_sigs = 1;
1113       case aListSigs:
1114         opt.list_sigs = 1;
1115       case aListKeys:
1116         public_key_list( argc, argv );
1117         break;
1118       case aListSecretKeys:
1119         secret_key_list( argc, argv );
1120         break;
1121
1122       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1123         if( argc < 2 )  /* -kv [userid] */
1124             public_key_list( (argc && **argv)? 1:0, argv );
1125         else if( argc == 2 ) { /* -kv userid keyring */
1126             if( access( argv[1], R_OK ) ) {
1127                 log_error(_("can't open %s: %s\n"),
1128                                print_fname_stdin(argv[1]), strerror(errno));
1129             }
1130             else {
1131                 /* add keyring (default keyrings are not registered in this
1132                  * special case */
1133                 add_keyblock_resource( argv[1], 0, 0 );
1134                 public_key_list( **argv?1:0, argv );
1135             }
1136         }
1137         else
1138             wrong_args(_("-k[v][v][v][c] [userid] [keyring]") );
1139         break;
1140
1141       case aKeygen: /* generate a key (interactive) */
1142         if( argc )
1143             wrong_args("--gen-key");
1144         generate_keypair();
1145         break;
1146
1147       case aFastImport:
1148       case aImport:
1149         if( !argc  ) {
1150             rc = import_keys( NULL, (cmd == aFastImport) );
1151             if( rc )
1152                 log_error("import failed: %s\n", g10_errstr(rc) );
1153         }
1154         for( ; argc; argc--, argv++ ) {
1155             rc = import_keys( *argv, (cmd == aFastImport) );
1156             if( rc )
1157                 log_error("import from `%s' failed: %s\n",
1158                                                 *argv, g10_errstr(rc) );
1159         }
1160         break;
1161
1162       case aExport:
1163       case aExportAll:
1164       case aSendKeys:
1165       case aRecvKeys:
1166         sl = NULL;
1167         for( ; argc; argc--, argv++ )
1168             add_to_strlist2( &sl, *argv, utf8_strings );
1169         if( cmd == aSendKeys )
1170             hkp_export( sl );
1171         else if( cmd == aRecvKeys )
1172             hkp_import( sl );
1173         else
1174             export_pubkeys( sl, (cmd == aExport) );
1175         free_strlist(sl);
1176         break;
1177
1178       case aExportSecret:
1179         sl = NULL;
1180         for( ; argc; argc--, argv++ )
1181             add_to_strlist2( &sl, *argv, utf8_strings );
1182         export_seckeys( sl );
1183         free_strlist(sl);
1184         break;
1185
1186       case aGenRevoke:
1187         if( argc != 1 )
1188             wrong_args("--gen-revoke user-id");
1189         username =  make_username(*argv);
1190         gen_revoke( username );
1191         m_free( username );
1192         break;
1193
1194       case aDeArmor:
1195         if( argc > 1 )
1196             wrong_args("--dearmor [file]");
1197         rc = dearmor_file( argc? *argv: NULL );
1198         if( rc )
1199             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
1200         break;
1201
1202       case aEnArmor:
1203         if( argc > 1 )
1204             wrong_args("--enarmor [file]");
1205         rc = enarmor_file( argc? *argv: NULL );
1206         if( rc )
1207             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
1208         break;
1209
1210
1211       case aPrimegen:
1212         {   int mode = argc < 2 ? 0 : atoi(*argv);
1213
1214             if( mode == 1 && argc == 2 ) {
1215                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
1216             }
1217             else if( mode == 2 && argc == 3 ) {
1218                 mpi_print( stdout, generate_elg_prime(
1219                                              0, atoi(argv[1]),
1220                                              atoi(argv[2]), NULL,NULL ), 1);
1221             }
1222             else if( mode == 3 && argc == 3 ) {
1223                 MPI *factors;
1224                 mpi_print( stdout, generate_elg_prime(
1225                                              1, atoi(argv[1]),
1226                                              atoi(argv[2]), NULL,&factors ), 1);
1227                 putchar('\n');
1228                 mpi_print( stdout, factors[0], 1 ); /* print q */
1229             }
1230             else if( mode == 4 && argc == 3 ) {
1231                 MPI g = mpi_alloc(1);
1232                 mpi_print( stdout, generate_elg_prime(
1233                                                  0, atoi(argv[1]),
1234                                                  atoi(argv[2]), g, NULL ), 1);
1235                 putchar('\n');
1236                 mpi_print( stdout, g, 1 );
1237                 mpi_free(g);
1238             }
1239             else
1240                 wrong_args("--gen-prime mode bits [qbits] ");
1241             putchar('\n');
1242         }
1243         break;
1244
1245       case aGenRandom:
1246         {
1247             int level = argc ? atoi(*argv):0;
1248             int count = argc > 1 ? atoi(argv[1]): 0;
1249             int endless = !count;
1250
1251             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
1252                 wrong_args("--gen-random 0|1|2 [count]");
1253
1254             while( endless || count ) {
1255                 byte *p;
1256                 size_t n = !endless && count < 100? count : 100;
1257
1258                 p = get_random_bits( n*8, level, 0);
1259                 fwrite( p, n, 1, stdout );
1260                 m_free(p);
1261                 if( !endless )
1262                     count -= n;
1263             }
1264         }
1265         break;
1266
1267       case aPrintMD:
1268         if( argc < 1)
1269             wrong_args("--print-md algo [files]");
1270         {
1271             int all_algos = (**argv=='*' && !(*argv)[1]);
1272             int algo = all_algos? 0 : string_to_digest_algo(*argv);
1273
1274             if( !algo && !all_algos )
1275                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
1276             else {
1277                 argc--; argv++;
1278                 if( !argc )
1279                     print_mds(NULL, algo);
1280                 else {
1281                     for(; argc; argc--, argv++ )
1282                         print_mds(*argv, algo);
1283                 }
1284             }
1285         }
1286         break;
1287
1288       case aPrintMDs: /* old option */
1289         if( !argc )
1290             print_mds(NULL,0);
1291         else {
1292             for(; argc; argc--, argv++ )
1293                 print_mds(*argv,0);
1294         }
1295         break;
1296
1297       case aListTrustDB:
1298         if( !argc )
1299             list_trustdb(NULL);
1300         else {
1301             for( ; argc; argc--, argv++ )
1302                 list_trustdb( *argv );
1303         }
1304         break;
1305
1306       case aUpdateTrustDB:
1307         if( argc )
1308             wrong_args("--update-trustdb");
1309         update_trustdb();
1310         break;
1311
1312       case aCheckTrustDB:
1313         if( !argc )
1314             check_trustdb(NULL);
1315         else {
1316             for( ; argc; argc--, argv++ ) {
1317                 username = make_username( *argv );
1318                 check_trustdb( username );
1319                 m_free(username);
1320             }
1321         }
1322         break;
1323
1324       case aFixTrustDB:
1325         log_error("this command ist not yet implemented.\"\n");
1326         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
1327         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
1328         break;
1329
1330       case aListTrustPath:
1331         if( !argc )
1332             wrong_args("--list-trust-path <user-ids>");
1333         for( ; argc; argc--, argv++ ) {
1334             username = make_username( *argv );
1335             list_trust_path( username );
1336             m_free(username);
1337         }
1338         break;
1339
1340       case aExportOwnerTrust:
1341         if( argc )
1342             wrong_args("--export-ownertrust");
1343         export_ownertrust();
1344         break;
1345
1346       case aImportOwnerTrust:
1347         if( argc > 1 )
1348             wrong_args("--import-ownertrust [file]");
1349         import_ownertrust( argc? *argv:NULL );
1350         break;
1351
1352       case aListPackets:
1353         opt.list_packets=1;
1354       default:
1355         if( argc > 1 )
1356             wrong_args(_("[filename]"));
1357         /* Issue some output for the unix newbie */
1358         if( !fname && !opt.outfile && isatty( fileno(stdin) )
1359                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
1360             log_info(_("Go ahead and type your message ...\n"));
1361
1362         if( !(a = iobuf_open(fname)) )
1363             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
1364         else {
1365
1366             if( !opt.no_armor ) {
1367                 if( use_armor_filter( a ) ) {
1368                     memset( &afx, 0, sizeof afx);
1369                     iobuf_push_filter( a, armor_filter, &afx );
1370                 }
1371             }
1372             if( cmd == aListPackets ) {
1373                 set_packet_list_mode(1);
1374                 opt.list_packets=1;
1375             }
1376             rc = proc_packets(NULL, a );
1377             if( rc )
1378                 log_error("processing message failed: %s\n", g10_errstr(rc) );
1379             iobuf_close(a);
1380         }
1381         break;
1382     }
1383
1384     /* cleanup */
1385     FREE_STRLIST(remusr);
1386     FREE_STRLIST(locusr);
1387     g10_exit(0);
1388     return 8; /*NEVER REACHED*/
1389 }
1390
1391
1392 void
1393 g10_exit( int rc )
1394 {
1395     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1396         m_print_stats("on exit");
1397         random_dump_stats();
1398     }
1399     if( opt.debug )
1400         secmem_dump_stats();
1401     secmem_term();
1402     rc = rc? rc : log_get_errorcount(0)? 2 :
1403                         g10_errors_seen? 1 : 0;
1404     /*write_status( STATUS_LEAVE );*/
1405     exit(rc );
1406 }
1407
1408
1409
1410
1411 static void
1412 print_hex( byte *p, size_t n )
1413 {
1414     int i;
1415
1416     if( n == 20 ) {
1417         for(i=0; i < n ; i++, i++, p += 2 ) {
1418             if( i )
1419                 putchar(' ');
1420             if( i == 10 )
1421                 putchar(' ');
1422             printf("%02X%02X", *p, p[1] );
1423         }
1424     }
1425     else if( n == 24 ) {
1426         for(i=0; i < n ; i += 4, p += 4 ) {
1427             if( i )
1428                 putchar(' ');
1429             if( i == 12 )
1430                 putchar(' ');
1431             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
1432         }
1433     }
1434     else {
1435         for(i=0; i < n ; i++, p++ ) {
1436             if( i )
1437                 putchar(' ');
1438             if( i && !(i%8) )
1439                 putchar(' ');
1440             printf("%02X", *p );
1441         }
1442     }
1443 }
1444
1445 static void
1446 print_mds( const char *fname, int algo )
1447 {
1448     FILE *fp;
1449     char buf[1024];
1450     size_t n;
1451     MD_HANDLE md;
1452     char *pname;
1453
1454     if( !fname ) {
1455         fp = stdin;
1456         pname = m_strdup("[stdin]: ");
1457     }
1458     else {
1459         pname = m_alloc(strlen(fname)+3);
1460         strcpy(stpcpy(pname,fname),": ");
1461         fp = fopen( fname, "rb" );
1462     }
1463     if( !fp ) {
1464         log_error("%s%s\n", pname, strerror(errno) );
1465         m_free(pname);
1466         return;
1467     }
1468
1469     md = md_open( 0, 0 );
1470     if( algo )
1471         md_enable( md, algo );
1472     else {
1473         md_enable( md, DIGEST_ALGO_MD5 );
1474         md_enable( md, DIGEST_ALGO_SHA1 );
1475         md_enable( md, DIGEST_ALGO_RMD160 );
1476         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
1477             md_enable( md, DIGEST_ALGO_TIGER );
1478     }
1479
1480     while( (n=fread( buf, 1, DIM(buf), fp )) )
1481         md_write( md, buf, n );
1482     if( ferror(fp) )
1483         log_error("%s%s\n", pname, strerror(errno) );
1484     else {
1485         md_final(md);
1486         if( algo ) {
1487             if( fname )
1488                 fputs( pname, stdout );
1489             print_hex(md_read(md, algo), md_digest_length(algo) );
1490         }
1491         else {
1492             printf(  "%s   MD5 = ", fname?pname:"" );
1493                             print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
1494             printf("\n%s  SHA1 = ", fname?pname:""  );
1495                             print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
1496             printf("\n%sRMD160 = ", fname?pname:""  );
1497                             print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
1498             if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
1499                 printf("\n%s TIGER = ", fname?pname:""  );
1500                             print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
1501             }
1502         }
1503         putchar('\n');
1504     }
1505     md_close(md);
1506
1507     if( fp != stdin )
1508         fclose(fp);
1509 }
1510
1511
1512 /****************
1513  * Check the supplied name,value string and add it to the notation
1514  * data to be used for signatures.
1515  */
1516 static void
1517 add_notation_data( const char *string )
1518 {
1519     const char *s;
1520     const char *s2;
1521     STRLIST sl;
1522     int critical=0;
1523     int highbit=0;
1524
1525     if( *string == '!' ) {
1526         critical = 1;
1527         string++;
1528     }
1529     s = string;
1530
1531     if( !*s || (*s & 0x80) || (!isalpha(*s) && *s != '_') ) {
1532         log_error(_("the first character of a notation name "
1533                     "must be a letter or an underscore\n") );
1534         return;
1535     }
1536     for(s++; *s != '='; s++ ) {
1537         if( !*s || (*s & 0x80) || (!isalnum(*s) && *s != '_' && *s != '.' ) ) {
1538             log_error(_("a notation name must have only letters, "
1539                         "digits, dots or underscores and end with an '='\n") );
1540             return;
1541         }
1542     }
1543     if( s[-1] == '.' || ((s2=strstr(string, "..")) && s2 < s ) ) {
1544         log_error(_("dots in a notation name must be surrounded "
1545                     "by other characters\n") );
1546         return;
1547     }
1548     /* we do only support printabe text - therefore we enforce the use
1549      * of only printable characters (an empty value is valid) */
1550     for( s++; *s ; s++ ) {
1551         if( iscntrl(*s) ) {
1552             log_error(_("a notation value must not use "
1553                         "any control characters\n") );
1554             return;
1555         }
1556         else if( *s & 0x80 )
1557             highbit = 1;
1558     }
1559
1560     if( highbit )   /* must use UTF8 encoding */
1561         sl = add_to_strlist2( &opt.notation_data, string, utf8_strings );
1562     else
1563         sl = add_to_strlist( &opt.notation_data, string );
1564
1565     if( critical )
1566         sl->flags |= 1;
1567 }
1568
1569
1570 static int
1571 check_policy_url( const char *s )
1572 {
1573     if( *s == '!' )
1574         s++;
1575     if( !*s )
1576         return -1;
1577     for(; *s ; s++ ) {
1578         if( (*s & 0x80) || iscntrl(*s) )
1579             return -1;
1580     }
1581     return 0;
1582 }
1583