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