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