Add new option --with-keygrip
[gnupg.git] / g10 / gpg.c
1 /* gpg.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 #include <assert.h>
29 #ifdef HAVE_STAT
30 #include <sys/stat.h> /* for stat() */
31 #endif
32 #include <fcntl.h>
33 #ifdef HAVE_W32_SYSTEM
34 #include <windows.h>
35 #endif
36
37 #define INCLUDED_BY_MAIN_MODULE 1
38 #include "gpg.h"
39 #include <assuan.h>
40 #include "../common/iobuf.h"
41 #include "util.h"
42 #include "packet.h"
43 #include "main.h"
44 #include "options.h"
45 #include "keydb.h"
46 #include "trustdb.h"
47 #include "cipher.h"
48 #include "filter.h"
49 #include "ttyio.h"
50 #include "i18n.h"
51 #include "sysutils.h"
52 #include "status.h"
53 #include "keyserver-internal.h"
54 #include "exec.h"
55 #include "gc-opt-flags.h"
56 #include "asshelp.h"
57
58 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
59 #define MY_O_BINARY  O_BINARY
60 #ifndef S_IRGRP
61 # define S_IRGRP 0
62 # define S_IWGRP 0
63 #endif
64 #else
65 #define MY_O_BINARY  0
66 #endif
67
68
69 enum cmd_and_opt_values
70   {
71     aNull = 0,
72     oArmor        = 'a',
73     aDetachedSign = 'b',
74     aSym          = 'c',
75     aDecrypt      = 'd',
76     aEncr         = 'e',
77     oInteractive  = 'i',
78     aListKeys     = 'k',
79     oDryRun       = 'n',
80     oOutput       = 'o',
81     oQuiet        = 'q',
82     oRecipient    = 'r',
83     oHiddenRecipient = 'R',
84     aSign         = 's',
85     oTextmodeShort= 't',
86     oLocalUser    = 'u',
87     oVerbose      = 'v',
88     oCompress     = 'z',
89     oSetNotation  = 'N',
90     aListSecretKeys = 'K',
91     oBatch        = 500,
92     oMaxOutput,
93     oSigNotation,
94     oCertNotation,
95     oShowNotation,
96     oNoShowNotation,
97     aEncrFiles,
98     aEncrSym,
99     aDecryptFiles,
100     aClearsign,
101     aStore,
102     aKeygen,
103     aSignEncr,
104     aSignEncrSym,
105     aSignSym,
106     aSignKey,
107     aLSignKey,
108     aListConfig,
109     aGPGConfList,
110     aGPGConfTest,
111     aListPackets,
112     aEditKey,
113     aDeleteKeys,
114     aDeleteSecretKeys,
115     aDeleteSecretAndPublicKeys,
116     aImport,
117     aFastImport,
118     aVerify,
119     aVerifyFiles,
120     aListSigs,
121     aSendKeys,
122     aRecvKeys,
123     aLocateKeys,
124     aSearchKeys,
125     aRefreshKeys,
126     aFetchKeys,
127     aExport,
128     aExportSecret,
129     aExportSecretSub,
130     aCheckKeys,
131     aGenRevoke,
132     aDesigRevoke,
133     aPrimegen,
134     aPrintMD,
135     aPrintMDs,
136     aCheckTrustDB,
137     aUpdateTrustDB,
138     aFixTrustDB,
139     aListTrustDB,
140     aListTrustPath,
141     aExportOwnerTrust,
142     aImportOwnerTrust,
143     aDeArmor,
144     aEnArmor,
145     aGenRandom,
146     aRebuildKeydbCaches,
147     aCardStatus,
148     aCardEdit,
149     aChangePIN,
150     aPasswd,
151     aServer,
152
153     oTextmode,
154     oNoTextmode,
155     oExpert,
156     oNoExpert,
157     oDefSigExpire,
158     oAskSigExpire,
159     oNoAskSigExpire,
160     oDefCertExpire,
161     oAskCertExpire,
162     oNoAskCertExpire,
163     oDefCertLevel,
164     oMinCertLevel,
165     oAskCertLevel,
166     oNoAskCertLevel,
167     oFingerprint,
168     oWithFingerprint,
169     oWithKeygrip,
170     oAnswerYes,
171     oAnswerNo,
172     oKeyring,
173     oPrimaryKeyring,
174     oSecretKeyring,
175     oShowKeyring,
176     oDefaultKey,
177     oDefRecipient,
178     oDefRecipientSelf,
179     oNoDefRecipient,
180     oOptions,
181     oDebug,
182     oDebugLevel,
183     oDebugAll,
184     oDebugCCIDDriver,
185     oStatusFD,
186     oStatusFile,
187     oAttributeFD,
188     oAttributeFile,
189     oEmitVersion,
190     oNoEmitVersion,
191     oCompletesNeeded,
192     oMarginalsNeeded,
193     oMaxCertDepth,
194     oLoadExtension,
195     oGnuPG,
196     oRFC1991,
197     oRFC2440,
198     oRFC4880,
199     oOpenPGP,
200     oPGP2,
201     oPGP6,
202     oPGP7,
203     oPGP8,
204     oRFC2440Text,
205     oNoRFC2440Text,
206     oCipherAlgo,
207     oDigestAlgo,
208     oCertDigestAlgo,
209     oCompressAlgo,
210     oCompressLevel,
211     oBZ2CompressLevel,
212     oBZ2DecompressLowmem,
213     oPassphrase,
214     oPassphraseFD,
215     oPassphraseFile,
216     oPassphraseRepeat,
217     oCommandFD,
218     oCommandFile,
219     oQuickRandom,
220     oNoVerbose,
221     oTrustDBName,
222     oNoSecmemWarn,
223     oRequireSecmem,
224     oNoRequireSecmem,
225     oNoPermissionWarn,
226     oNoMDCWarn,
227     oNoArmor,
228     oNoDefKeyring,
229     oNoGreeting,
230     oNoTTY,
231     oNoOptions,
232     oNoBatch,
233     oHomedir,
234     oWithColons,
235     oWithKeyData,
236     oWithSigList,
237     oWithSigCheck,
238     oSkipVerify,
239     oSkipHiddenRecipients,
240     oNoSkipHiddenRecipients,
241     oCompressKeys,
242     oCompressSigs,
243     oAlwaysTrust,
244     oTrustModel,
245     oForceOwnertrust,
246     oSetFilename,
247     oForYourEyesOnly,
248     oNoForYourEyesOnly,
249     oSetPolicyURL,
250     oSigPolicyURL,
251     oCertPolicyURL,
252     oShowPolicyURL,
253     oNoShowPolicyURL,
254     oSigKeyserverURL,
255     oUseEmbeddedFilename,
256     oNoUseEmbeddedFilename,
257     oComment,
258     oDefaultComment,
259     oNoComments,
260     oThrowKeyids,
261     oNoThrowKeyids,
262     oShowPhotos,
263     oNoShowPhotos,
264     oPhotoViewer,
265     oForceV3Sigs,
266     oNoForceV3Sigs,
267     oForceV4Certs,
268     oNoForceV4Certs,
269     oForceMDC,
270     oNoForceMDC,
271     oDisableMDC,
272     oNoDisableMDC,
273     oS2KMode,
274     oS2KDigest,
275     oS2KCipher,
276     oS2KCount,
277     oDisplayCharset,
278     oNotDashEscaped,
279     oEscapeFrom,
280     oNoEscapeFrom,
281     oLockOnce,
282     oLockMultiple,
283     oLockNever,
284     oKeyServer,
285     oKeyServerOptions,
286     oImportOptions,
287     oExportOptions,
288     oListOptions,
289     oVerifyOptions,
290     oTempDir,
291     oExecPath,
292     oEncryptTo,
293     oHiddenEncryptTo,
294     oNoEncryptTo,
295     oLoggerFD,
296     oLoggerFile,
297     oUtf8Strings,
298     oNoUtf8Strings,
299     oDisableCipherAlgo,
300     oDisablePubkeyAlgo,
301     oAllowNonSelfsignedUID,
302     oNoAllowNonSelfsignedUID,
303     oAllowFreeformUID,
304     oNoAllowFreeformUID,
305     oAllowSecretKeyImport,                      
306     oEnableSpecialFilenames,
307     oNoLiteral,
308     oSetFilesize,
309     oHonorHttpProxy,
310     oFastListMode,
311     oListOnly,
312     oIgnoreTimeConflict,
313     oIgnoreValidFrom,
314     oIgnoreCrcError,
315     oIgnoreMDCError,
316     oShowSessionKey,
317     oOverrideSessionKey,
318     oNoRandomSeedFile,
319     oAutoKeyRetrieve,
320     oNoAutoKeyRetrieve,
321     oUseAgent,
322     oNoUseAgent,
323     oGpgAgentInfo,
324     oMergeOnly,
325     oTryAllSecrets,
326     oTrustedKey,
327     oNoExpensiveTrustChecks,
328     oFixedListMode,
329     oNoSigCache,
330     oNoSigCreateCheck,
331     oAutoCheckTrustDB,
332     oNoAutoCheckTrustDB,
333     oPreservePermissions,
334     oDefaultPreferenceList,
335     oDefaultKeyserverURL,
336     oPersonalCipherPreferences,
337     oPersonalDigestPreferences,
338     oPersonalCompressPreferences,
339     oAgentProgram,
340     oDisplay,
341     oTTYname,
342     oTTYtype,
343     oLCctype,
344     oLCmessages,
345     oXauthority,
346     oGroup,
347     oUnGroup,
348     oNoGroups,
349     oStrict,
350     oNoStrict,
351     oMangleDosFilenames,
352     oNoMangleDosFilenames,
353     oEnableProgressFilter,
354     oMultifile,
355     oKeyidFormat,
356     oExitOnStatusWriteError,
357     oLimitCardInsertTries,
358     oRequireCrossCert,
359     oNoRequireCrossCert,
360     oAutoKeyLocate,
361     oNoAutoKeyLocate,
362     oAllowMultisigVerification,
363     oEnableDSA2,
364     oDisableDSA2,
365     oAllowMultipleMessages,
366     oNoAllowMultipleMessages,
367     oFakedSystemTime,
368
369     oNoop
370   };
371
372
373 static ARGPARSE_OPTS opts[] = {
374
375   ARGPARSE_group (300, N_("@Commands:\n ")),
376
377   ARGPARSE_c (aSign, "sign", N_("make a signature")),
378   ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature")),
379   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
380   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
381   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
382   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
383   ARGPARSE_c (aStore, "store",     "@"),
384   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
385   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
386   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
387   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
388   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
389   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
390   ARGPARSE_c (aListSigs, "list-sigs", N_("list keys and signatures")),
391   ARGPARSE_c (aCheckKeys, "check-sigs",N_("list and check key signatures")),
392   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
393   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
394   ARGPARSE_c (aKeygen,     "gen-key",  N_("generate a new key pair")),
395   ARGPARSE_c (aGenRevoke, "gen-revoke",N_("generate a revocation certificate")),
396   ARGPARSE_c (aDeleteKeys,"delete-keys", 
397               N_("remove keys from the public keyring")),
398   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
399               N_("remove keys from the secret keyring")),
400   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
401   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
402   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
403   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
404   ARGPARSE_c (aPasswd,   "passwd",     N_("change a passphrase")),
405   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
406   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
407   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a key server") ),
408   ARGPARSE_c (aRecvKeys, "recv-keys"     , N_("import keys from a key server") ),
409   ARGPARSE_c (aSearchKeys, "search-keys" , 
410               N_("search for keys on a key server") ),
411   ARGPARSE_c (aRefreshKeys, "refresh-keys", 
412               N_("update all keys from a keyserver")),
413   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
414   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
415   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
416   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
417   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
418   ARGPARSE_c (aFastImport, "fast-import", "@"),
419 #ifdef ENABLE_CARD_SUPPORT
420   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
421   ARGPARSE_c (aCardEdit,   "card-edit",  N_("change data on a card")),
422   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
423 #endif
424   ARGPARSE_c (aListConfig, "list-config", "@"),
425   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
426   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
427   ARGPARSE_c (aListPackets, "list-packets","@"),
428   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
429   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
430   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
431               N_("update the trust database")),
432   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
433   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
434   ARGPARSE_c (aDeArmor, "dearmor", "@"),
435   ARGPARSE_c (aDeArmor, "dearmour", "@"),
436   ARGPARSE_c (aEnArmor, "enarmor", "@"),
437   ARGPARSE_c (aEnArmor, "enarmour", "@"),
438   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
439   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
440   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
441   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
442
443   ARGPARSE_group (301, N_("@\nOptions:\n ")),
444
445   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
446   ARGPARSE_s_n (oArmor, "armour", "@"),
447
448   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
449   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
450   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
451   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
452   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
453   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
454
455   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
456   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
457   ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
458   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
459   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
460   ARGPARSE_s_s (oLocalUser, "local-user",
461                 N_("|USER-ID|use USER-ID to sign or decrypt")),
462
463   ARGPARSE_s_i (oCompress, NULL,
464                 N_("|N|set compress level to N (0 disables)")),
465   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
466   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
467   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
468
469   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
470   ARGPARSE_s_n (oTextmode,      "textmode", N_("use canonical text mode")),
471   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
472
473   ARGPARSE_s_n (oExpert,      "expert", "@"),
474   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
475
476   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
477   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
478   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
479   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
480   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
481   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
482   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
483   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
484   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
485   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
486
487   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
488   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
489
490   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
491   ARGPARSE_s_n (oQuiet,   "quiet",   "@"),
492   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
493
494   ARGPARSE_s_n (oForceV3Sigs,      "force-v3-sigs", "@"),
495   ARGPARSE_s_n (oNoForceV3Sigs, "no-force-v3-sigs", "@"),
496   ARGPARSE_s_n (oForceV4Certs,     "force-v4-certs", "@"),
497   ARGPARSE_s_n (oNoForceV4Certs, "no-force-v4-certs", "@"),
498   ARGPARSE_s_n (oForceMDC, "force-mdc", "@"),
499   ARGPARSE_s_n (oNoForceMDC, "no-force-mdc", "@"),
500   ARGPARSE_s_n (oDisableMDC, "disable-mdc", "@"),
501   ARGPARSE_s_n (oNoDisableMDC, "no-disable-mdc", "@"),
502
503   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
504   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
505
506   ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
507   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
508   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
509
510   ARGPARSE_s_n (oBatch, "batch", "@"),
511   ARGPARSE_s_n (oAnswerYes, "yes", "@"),
512   ARGPARSE_s_n (oAnswerNo, "no", "@"),
513   ARGPARSE_s_s (oKeyring, "keyring", "@"),
514   ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
515   ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
516   ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
517   ARGPARSE_s_s (oDefaultKey, "default-key", "@"),
518
519   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
520   ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
521   ARGPARSE_s_s (oImportOptions, "import-options", "@"),
522   ARGPARSE_s_s (oExportOptions, "export-options", "@"),
523   ARGPARSE_s_s (oListOptions,   "list-options", "@"),
524   ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
525
526   ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
527   ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
528   ARGPARSE_s_s (oOptions, "options", "@"),
529
530   ARGPARSE_p_u (oDebug, "debug", "@"),
531   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
532   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
533   ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
534   ARGPARSE_s_s (oStatusFile, "status-file", "@"),
535   ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
536   ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
537
538   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
539   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
540
541   ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
542   ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
543   ARGPARSE_s_i (oMaxCertDepth,  "max-cert-depth", "@" ),
544   ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
545
546   ARGPARSE_s_s (oLoadExtension, "load-extension", "@"),  /* Dummy.  */
547
548   ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
549   ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
550   ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
551   ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
552   ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
553   ARGPARSE_s_n (oRFC1991, "rfc1991", "@"),
554   ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
555   ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
556   ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
557   ARGPARSE_s_n (oPGP2, "pgp2", "@"),
558   ARGPARSE_s_n (oPGP6, "pgp6", "@"),
559   ARGPARSE_s_n (oPGP7, "pgp7", "@"),
560   ARGPARSE_s_n (oPGP8, "pgp8", "@"),
561
562   ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
563   ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
564   ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
565   ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
566   ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
567   ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
568   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
569   ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
570   ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
571   ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
572   ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
573   ARGPARSE_s_n (oThrowKeyids, "throw-keyid", "@"),
574   ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
575   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyid", "@"),
576   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
577   ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
578   ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
579   ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
580   ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
581   ARGPARSE_s_s (oSetNotation,  "notation-data", "@"), /* Alias */
582   ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
583   ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
584
585   ARGPARSE_group (302, N_(
586   "@\n(See the man page for a complete listing of all commands and options)\n"
587                       )),
588
589   ARGPARSE_group (303, N_("@\nExamples:\n\n"
590     " -se -r Bob [file]          sign and encrypt for user Bob\n"
591     " --clearsign [file]         make a clear text signature\n"
592     " --detach-sign [file]       make a detached signature\n"
593     " --list-keys [names]        show keys\n"
594     " --fingerprint [names]      show fingerprints\n")),
595
596   /* More hidden commands and options. */
597   ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
598   ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
599   /* Not yet used: 
600      ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
601   ARGPARSE_c (aDeleteSecretAndPublicKeys,
602               "delete-secret-and-public-keys", "@"),
603   ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
604
605   ARGPARSE_s_s (oPassphrase,      "passphrase", "@"),
606   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
607   ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
608   ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
609   ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
610   ARGPARSE_s_s (oCommandFile, "command-file", "@"),
611   ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
612   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
613   ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
614   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
615   ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
616   ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
617   ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
618   ARGPARSE_s_n (oNoMDCWarn, "no-mdc-warning", "@"),
619   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
620   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
621   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
622   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
623   ARGPARSE_s_n (oNoOptions, "no-options", "@"), 
624   ARGPARSE_s_s (oHomedir, "homedir", "@"), 
625   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
626   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
627   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
628   ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
629   ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
630   ARGPARSE_s_n (aListKeys, "list-key", "@"),   /* alias */
631   ARGPARSE_s_n (aListSigs, "list-sig", "@"),   /* alias */
632   ARGPARSE_s_n (aCheckKeys, "check-sig", "@"), /* alias */
633   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
634   ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
635   ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
636   ARGPARSE_s_n (oCompressKeys, "compress-keys", "@"),
637   ARGPARSE_s_n (oCompressSigs, "compress-sigs", "@"),
638   ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
639   ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
640   ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
641   ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
642   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
643   ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
644   ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
645   ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
646   ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
647   ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
648   ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
649   ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
650   ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
651   ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
652   ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
653   ARGPARSE_s_s (oComment, "comment", "@"),
654   ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
655   ARGPARSE_s_n (oNoComments, "no-comments", "@"),
656   ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
657   ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
658   ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
659   ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
660   ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
661   ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
662   ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
663   ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
664   ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
665   ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
666   ARGPARSE_s_s (oLoggerFile, "log-file", "@"),
667   ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
668   ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
669   ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
670   ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
671   ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
672   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
673   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
674   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
675   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
676   ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
677   ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
678   ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
679   ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
680   ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
681   ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
682   ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
683   ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
684   ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
685   ARGPARSE_s_n (oListOnly, "list-only", "@"),
686   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
687   ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
688   ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
689   ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
690   ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
691   ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
692   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
693   ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
694   ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
695   ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
696   ARGPARSE_s_n (oNoSigCreateCheck,   "no-sig-create-check", "@"),
697   ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
698   ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
699   ARGPARSE_s_n (oMergeOnly,       "merge-only", "@" ),
700   ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
701   ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
702   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
703   ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
704   ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
705   ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
706   ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
707   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
708   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
709   ARGPARSE_s_s (oPersonalCompressPreferences,
710                                          "personal-compress-preferences", "@"),
711   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
712
713   /* Aliases.  I constantly mistype these, and assume other people do
714      as well. */
715   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
716   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
717   ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
718   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
719   ARGPARSE_s_s (oDisplay,    "display",    "@"),
720   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
721   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
722   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
723   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
724   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
725   ARGPARSE_s_s (oGroup,      "group",      "@"),
726   ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
727   ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
728   ARGPARSE_s_n (oStrict,     "strict",     "@"),
729   ARGPARSE_s_n (oNoStrict,   "no-strict",  "@"),
730   ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
731   ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
732   ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
733   ARGPARSE_s_n (oMultifile, "multifile", "@"),
734   ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
735   ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
736   ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
737   
738   ARGPARSE_s_n (oAllowMultisigVerification, 
739                 "allow-multisig-verification", "@"),
740   ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
741   ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
742   ARGPARSE_s_n (oAllowMultipleMessages,      "allow-multiple-messages", "@"),
743   ARGPARSE_s_n (oNoAllowMultipleMessages, "no-allow-multiple-messages", "@"),
744
745   /* These two are aliases to help users of the PGP command line
746      product use gpg with minimal pain.  Many commands are common
747      already as they seem to have borrowed commands from us.  Now I'm
748      returning the favor. */
749   ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
750   ARGPARSE_s_s (oRecipient, "user", "@"),
751
752   ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
753   ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
754   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
755   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
756
757   /* New options.  Fixme: Should go more to the top.  */
758   ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate", "@"),
759   ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
760
761   ARGPARSE_end ()
762 };
763
764
765 #ifdef ENABLE_SELINUX_HACKS
766 #define ALWAYS_ADD_KEYRINGS 1
767 #else
768 #define ALWAYS_ADD_KEYRINGS 0
769 #endif
770
771
772 int g10_errors_seen = 0;
773
774 static int utf8_strings = 0;
775 static int maybe_setuid = 1;
776
777 static char *build_list( const char *text, char letter,
778                          const char *(*mapf)(int), int (*chkf)(int) );
779 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
780                         enum cmd_and_opt_values new_cmd );
781 static void print_mds( const char *fname, int algo );
782 static void add_notation_data( const char *string, int which );
783 static void add_policy_url( const char *string, int which );
784 static void add_keyserver_url( const char *string, int which );
785 static void emergency_cleanup (void);
786
787
788 static char *
789 make_libversion (const char *libname, const char *(*getfnc)(const char*))
790 {
791   const char *s;
792   char *result;
793   
794   if (maybe_setuid)
795     {
796       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
797       maybe_setuid = 0;
798     }
799   s = getfnc (NULL);
800   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
801   strcpy (stpcpy (stpcpy (result, libname), " "), s);
802   return result;
803 }
804
805
806 static const char *
807 my_strusage( int level )
808 {
809   static char *digests, *pubkeys, *ciphers, *zips, *ver_gcry;
810   const char *p;
811
812     switch( level ) {
813       case 11: p = "gpg (GnuPG)";
814         break;
815       case 13: p = VERSION; break;
816       case 17: p = PRINTABLE_OS_NAME; break;
817       case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
818
819     case 20:
820       if (!ver_gcry)
821         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
822       p = ver_gcry;
823       break;
824
825 #ifdef IS_DEVELOPMENT_VERSION
826       case 25:
827         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
828         break;
829       case 26:
830         p="It is only intended for test purposes and should NOT be";
831         break;
832       case 27:
833         p="used in a production environment or with production keys!";
834         break;
835 #endif
836
837       case 1:
838       case 40:  p =
839             _("Usage: gpg [options] [files] (-h for help)");
840         break;
841       case 41:  p =
842             _("Syntax: gpg [options] [files]\n"
843               "sign, check, encrypt or decrypt\n"
844               "default operation depends on the input data\n");
845         break;
846
847       case 31: p = "\nHome: "; break;
848 #ifndef __riscos__
849       case 32: p = opt.homedir; break;
850 #else /* __riscos__ */
851       case 32: p = make_filename(opt.homedir, NULL); break;
852 #endif /* __riscos__ */
853       case 33: p = _("\nSupported algorithms:\n"); break;
854       case 34:
855         if (!pubkeys)
856             pubkeys = build_list (_("Pubkey: "), 0,
857                                   gcry_pk_algo_name,
858                                   openpgp_pk_test_algo );
859         p = pubkeys;
860         break;
861       case 35:
862         if( !ciphers )
863             ciphers = build_list(_("Cipher: "), 'S', 
864                                  openpgp_cipher_algo_name,
865                                  openpgp_cipher_test_algo );
866         p = ciphers;
867         break;
868       case 36:
869         if( !digests )
870             digests = build_list(_("Hash: "), 'H', 
871                                  gcry_md_algo_name,
872                                  openpgp_md_test_algo );
873         p = digests;
874         break;
875       case 37:
876         if( !zips )
877             zips = build_list(_("Compression: "),'Z',
878                               compress_algo_to_string,
879                               check_compress_algo);
880         p = zips;
881         break;
882
883       default:  p = NULL;
884     }
885     return p;
886 }
887
888
889 static char *
890 build_list( const char *text, char letter,
891             const char * (*mapf)(int), int (*chkf)(int) )
892 {
893     int i;
894     const char *s;
895     size_t n=strlen(text)+2;
896     char *list, *p, *line=NULL;
897
898     if (maybe_setuid)
899       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
900
901     for(i=0; i <= 110; i++ )
902         if( !chkf(i) && (s=mapf(i)) )
903             n += strlen(s) + 7 + 2;
904     list = xmalloc( 21 + n ); *list = 0;
905     for(p=NULL, i=0; i <= 110; i++ ) {
906         if( !chkf(i) && (s=mapf(i)) ) {
907             if( !p ) {
908                 p = stpcpy( list, text );
909                 line=p;
910             }
911             else
912                 p = stpcpy( p, ", ");
913
914             if(strlen(line)>60) {
915               int spaces=strlen(text);
916
917               list=xrealloc(list,n+spaces+1);
918               /* realloc could move the block, so find the end again */
919               p=list;
920               while(*p)
921                 p++;
922
923               p=stpcpy(p, "\n");
924               line=p;
925               for(;spaces;spaces--)
926                 p=stpcpy(p, " ");
927             }
928
929             p = stpcpy(p, s );
930             if(opt.verbose && letter)
931               {
932                 char num[8];
933                 sprintf(num," (%c%d)",letter,i);
934                 p = stpcpy(p,num);
935               }
936         }
937     }
938     if( p )
939         p = stpcpy(p, "\n" );
940     return list;
941 }
942
943
944 static void
945 wrong_args( const char *text)
946 {
947     fputs(_("usage: gpg [options] "),stderr);
948     fputs(text,stderr);
949     putc('\n',stderr);
950     g10_exit(2);
951 }
952
953
954 static char *
955 make_username( const char *string )
956 {
957     char *p;
958     if( utf8_strings )
959         p = xstrdup(string);
960     else
961         p = native_to_utf8( string );
962     return p;
963 }
964
965
966 static void
967 set_opt_session_env (const char *name, const char *value)
968 {
969   gpg_error_t err;
970   
971   err = session_env_setenv (opt.session_env, name, value);
972   if (err)
973     log_fatal ("error setting session environment: %s\n",
974                gpg_strerror (err));
975 }
976
977 /* Setup the debugging.  With a LEVEL of NULL only the active debug
978    flags are propagated to the subsystems.  With LEVEL set, a specific
979    set of debug flags is set; thus overriding all flags already
980    set. */
981 static void
982 set_debug (const char *level)
983 {
984   int numok = (level && digitp (level));
985   int numlvl = numok? atoi (level) : 0;
986
987   if (!level)
988     ;
989   else if (!strcmp (level, "none") || (numok && numlvl < 1))
990     opt.debug = 0;
991   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
992     opt.debug = DBG_MEMSTAT_VALUE;
993   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
994     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
995   else if (!strcmp (level, "expert")  || (numok && numlvl <= 8))
996     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
997                  |DBG_CACHE_VALUE|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
998   else if (!strcmp (level, "guru") || numok)
999     {
1000       opt.debug = ~0;
1001       /* Unless the "guru" string has been used we don't want to allow
1002          hashing debugging.  The rationale is that people tend to
1003          select the highest debug value and would then clutter their
1004          disk with debug files which may reveal confidential data.  */ 
1005       if (numok)
1006         opt.debug &= ~(DBG_HASHING_VALUE);
1007     }
1008   else
1009     {
1010       log_error (_("invalid debug-level `%s' given\n"), level);
1011       g10_exit (2);
1012     }
1013
1014   if (opt.debug & DBG_MEMORY_VALUE )
1015     memory_debug_mode = 1;
1016   if (opt.debug & DBG_MEMSTAT_VALUE )
1017     memory_stat_debug_mode = 1;
1018   if (opt.debug & DBG_MPI_VALUE)
1019     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
1020   if (opt.debug & DBG_CIPHER_VALUE )
1021     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
1022   if (opt.debug & DBG_IOBUF_VALUE )
1023     iobuf_debug_mode = 1;
1024   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1025
1026   if (opt.debug)
1027     log_info ("enabled debug flags:%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
1028               (opt.debug & DBG_PACKET_VALUE )? " packet":"",    
1029               (opt.debug & DBG_MPI_VALUE    )? " mpi":"",    
1030               (opt.debug & DBG_CIPHER_VALUE )? " cipher":"",    
1031               (opt.debug & DBG_FILTER_VALUE )? " filter":"", 
1032               (opt.debug & DBG_IOBUF_VALUE  )? " iobuf":"", 
1033               (opt.debug & DBG_MEMORY_VALUE )? " memory":"", 
1034               (opt.debug & DBG_CACHE_VALUE  )? " cache":"", 
1035               (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"", 
1036               (opt.debug & DBG_TRUST_VALUE  )? " trust":"", 
1037               (opt.debug & DBG_HASHING_VALUE)? " hashing":"", 
1038               (opt.debug & DBG_EXTPROG_VALUE)? " extprog":"", 
1039               (opt.debug & DBG_CARD_IO_VALUE)? " cardio":"",
1040               (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"");
1041 }
1042
1043
1044
1045 /* We need the home directory also in some other directories, so make
1046    sure that both variables are always in sync. */
1047 static void
1048 set_homedir (const char *dir)
1049 {
1050   if (!dir)
1051     dir = "";
1052   opt.homedir = dir;
1053 }
1054
1055
1056 /* We set the screen dimensions for UI purposes.  Do not allow screens
1057    smaller than 80x24 for the sake of simplicity. */
1058 static void
1059 set_screen_dimensions(void)
1060 {
1061 #ifndef HAVE_W32_SYSTEM
1062   char *str;
1063
1064   str=getenv("COLUMNS");
1065   if(str)
1066     opt.screen_columns=atoi(str);
1067
1068   str=getenv("LINES");
1069   if(str)
1070     opt.screen_lines=atoi(str);
1071 #endif
1072
1073   if(opt.screen_columns<80 || opt.screen_columns>255)
1074     opt.screen_columns=80;
1075
1076   if(opt.screen_lines<24 || opt.screen_lines>255)
1077     opt.screen_lines=24;
1078 }
1079
1080
1081 /* Helper to open a file FNAME either for reading or writing to be
1082    used with --status-file etc functions.  Not generally useful but it
1083    avoids the riscos specific functions and well some Windows people
1084    might like it too.  Prints an error message and returns -1 on
1085    error.  On success the file descriptor is returned.  */
1086 static int
1087 open_info_file (const char *fname, int for_write, int binary)
1088 {
1089 #ifdef __riscos__
1090   return riscos_fdopenfile (fname, for_write);
1091 #elif defined (ENABLE_SELINUX_HACKS)
1092   /* We can't allow these even when testing for a secured filename
1093      because files to be secured might not yet been secured.  This is
1094      similar to the option file but in that case it is unlikely that
1095      sensitive information may be retrieved by means of error
1096      messages.  */
1097   (void)fname;
1098   (void)for_write;
1099   (void)binary;
1100   return -1;
1101 #else 
1102   int fd;
1103
1104   if (binary)
1105     binary = MY_O_BINARY;
1106
1107 /*   if (is_secured_filename (fname)) */
1108 /*     { */
1109 /*       fd = -1; */
1110 /*       gpg_err_set_errno (EPERM); */
1111 /*     } */
1112 /*   else */
1113 /*     { */
1114       do
1115         {
1116           if (for_write)
1117             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY | binary,
1118                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1119           else
1120             fd = open (fname, O_RDONLY | binary);
1121         }
1122       while (fd == -1 && errno == EINTR);
1123 /*     } */
1124   if ( fd == -1)
1125     log_error ( for_write? _("can't create `%s': %s\n")
1126                          : _("can't open `%s': %s\n"), fname, strerror(errno));
1127   
1128   return fd;
1129 #endif
1130 }
1131
1132 static void
1133 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1134 {
1135     enum cmd_and_opt_values cmd = *ret_cmd;
1136
1137     if( !cmd || cmd == new_cmd )
1138         cmd = new_cmd;
1139     else if( cmd == aSign && new_cmd == aEncr )
1140         cmd = aSignEncr;
1141     else if( cmd == aEncr && new_cmd == aSign )
1142         cmd = aSignEncr;
1143     else if( cmd == aSign && new_cmd == aSym )
1144         cmd = aSignSym;
1145     else if( cmd == aSym && new_cmd == aSign )
1146         cmd = aSignSym;
1147     else if( cmd == aSym && new_cmd == aEncr )
1148         cmd = aEncrSym;
1149     else if( cmd == aEncr && new_cmd == aSym )
1150         cmd = aEncrSym;
1151     else if (cmd == aSignEncr && new_cmd == aSym)
1152         cmd = aSignEncrSym;
1153     else if (cmd == aSignSym && new_cmd == aEncr)
1154         cmd = aSignEncrSym;
1155     else if (cmd == aEncrSym && new_cmd == aSign)
1156         cmd = aSignEncrSym;
1157     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1158              || ( cmd == aClearsign && new_cmd == aSign )  )
1159         cmd = aClearsign;
1160     else {
1161         log_error(_("conflicting commands\n"));
1162         g10_exit(2);
1163     }
1164
1165     *ret_cmd = cmd;
1166 }
1167
1168
1169 static void
1170 add_group(char *string)
1171 {
1172   char *name,*value;
1173   struct groupitem *item;
1174
1175   /* Break off the group name */
1176   name=strsep(&string,"=");
1177   if(string==NULL)
1178     {
1179       log_error(_("no = sign found in group definition `%s'\n"),name);
1180       return;
1181     }
1182
1183   trim_trailing_ws(name,strlen(name));
1184
1185   /* Does this group already exist? */
1186   for(item=opt.grouplist;item;item=item->next)
1187     if(strcasecmp(item->name,name)==0)
1188       break;
1189
1190   if(!item)
1191     {
1192       item=xmalloc(sizeof(struct groupitem));
1193       item->name=name;
1194       item->next=opt.grouplist;
1195       item->values=NULL;
1196       opt.grouplist=item;
1197     }
1198
1199   /* Break apart the values */
1200   while ((value= strsep(&string," \t")))
1201     {
1202       if (*value)
1203         add_to_strlist2(&item->values,value,utf8_strings);
1204     }
1205 }
1206
1207
1208 static void
1209 rm_group(char *name)
1210 {
1211   struct groupitem *item,*last=NULL;
1212
1213   trim_trailing_ws(name,strlen(name));
1214
1215   for(item=opt.grouplist;item;last=item,item=item->next)
1216     {
1217       if(strcasecmp(item->name,name)==0)
1218         {
1219           if(last)
1220             last->next=item->next;
1221           else
1222             opt.grouplist=item->next;
1223
1224           free_strlist(item->values);
1225           xfree(item);
1226           break;
1227         }
1228     }
1229 }
1230
1231
1232 /* We need to check three things.
1233
1234    0) The homedir.  It must be x00, a directory, and owned by the
1235    user.
1236
1237    1) The options/gpg.conf file.  Okay unless it or its containing
1238    directory is group or other writable or not owned by us.  Disable
1239    exec in this case.
1240
1241    2) Extensions.  Same as #1.
1242
1243    Returns true if the item is unsafe. */
1244 static int
1245 check_permissions (const char *path, int item)
1246 {
1247 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1248   static int homedir_cache=-1;
1249   char *tmppath,*dir;
1250   struct stat statbuf,dirbuf;
1251   int homedir=0,ret=0,checkonly=0;
1252   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1253
1254   if(opt.no_perm_warn)
1255     return 0;
1256
1257   assert(item==0 || item==1 || item==2);
1258
1259   /* extensions may attach a path */
1260   if(item==2 && path[0]!=DIRSEP_C)
1261     {
1262       if(strchr(path,DIRSEP_C))
1263         tmppath=make_filename(path,NULL);
1264       else
1265         tmppath=make_filename(gnupg_libdir (),path,NULL);
1266     }
1267   else
1268     tmppath=xstrdup(path);
1269
1270   /* If the item is located in the homedir, but isn't the homedir,
1271      don't continue if we already checked the homedir itself.  This is
1272      to avoid user confusion with an extra options file warning which
1273      could be rectified if the homedir itself had proper
1274      permissions. */
1275   if(item!=0 && homedir_cache>-1
1276      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1277     {
1278       ret=homedir_cache;
1279       goto end;
1280     }
1281
1282   /* It's okay if the file or directory doesn't exist */
1283   if(stat(tmppath,&statbuf)!=0)
1284     {
1285       ret=0;
1286       goto end;
1287     }
1288
1289   /* Now check the enclosing directory.  Theoretically, we could walk
1290      this test up to the root directory /, but for the sake of sanity,
1291      I'm stopping at one level down. */
1292   dir=make_dirname(tmppath);
1293
1294   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1295     {
1296       /* Weird error */
1297       ret=1;
1298       goto end;
1299     }
1300
1301   xfree(dir);
1302
1303   /* Assume failure */
1304   ret=1;
1305
1306   if(item==0)
1307     {
1308       /* The homedir must be x00, a directory, and owned by the user. */
1309
1310       if(S_ISDIR(statbuf.st_mode))
1311         {
1312           if(statbuf.st_uid==getuid())
1313             {
1314               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1315                 ret=0;
1316               else
1317                 perm=1;
1318             }
1319           else
1320             own=1;
1321
1322           homedir_cache=ret;
1323         }
1324     }
1325   else if(item==1 || item==2)
1326     {
1327       /* The options or extension file.  Okay unless it or its
1328          containing directory is group or other writable or not owned
1329          by us or root. */
1330
1331       if(S_ISREG(statbuf.st_mode))
1332         {
1333           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1334             {
1335               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1336                 {
1337                   /* it's not writable, so make sure the enclosing
1338                      directory is also not writable */
1339                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1340                     {
1341                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1342                         ret=0;
1343                       else
1344                         enc_dir_perm=1;
1345                     }
1346                   else
1347                     enc_dir_own=1;
1348                 }
1349               else
1350                 {
1351                   /* it's writable, so the enclosing directory had
1352                      better not let people get to it. */
1353                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1354                     {
1355                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1356                         ret=0;
1357                       else
1358                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1359                     }
1360                   else
1361                     enc_dir_own=1;
1362                 }
1363             }
1364           else
1365             own=1;
1366         }
1367     }
1368   else
1369     BUG();
1370
1371   if(!checkonly)
1372     {
1373       if(own)
1374         {
1375           if(item==0)
1376             log_info(_("WARNING: unsafe ownership on"
1377                        " homedir `%s'\n"),tmppath);
1378           else if(item==1)
1379             log_info(_("WARNING: unsafe ownership on"
1380                        " configuration file `%s'\n"),tmppath);
1381           else
1382             log_info(_("WARNING: unsafe ownership on"
1383                        " extension `%s'\n"),tmppath);
1384         }
1385       if(perm)
1386         {
1387           if(item==0)
1388             log_info(_("WARNING: unsafe permissions on"
1389                        " homedir `%s'\n"),tmppath);
1390           else if(item==1)
1391             log_info(_("WARNING: unsafe permissions on"
1392                        " configuration file `%s'\n"),tmppath);
1393           else
1394             log_info(_("WARNING: unsafe permissions on"
1395                        " extension `%s'\n"),tmppath);
1396         }
1397       if(enc_dir_own)
1398         {
1399           if(item==0)
1400             log_info(_("WARNING: unsafe enclosing directory ownership on"
1401                        " homedir `%s'\n"),tmppath);
1402           else if(item==1)
1403             log_info(_("WARNING: unsafe enclosing directory ownership on"
1404                        " configuration file `%s'\n"),tmppath);
1405           else
1406             log_info(_("WARNING: unsafe enclosing directory ownership on"
1407                        " extension `%s'\n"),tmppath);
1408         }
1409       if(enc_dir_perm)
1410         {
1411           if(item==0)
1412             log_info(_("WARNING: unsafe enclosing directory permissions on"
1413                        " homedir `%s'\n"),tmppath);
1414           else if(item==1)
1415             log_info(_("WARNING: unsafe enclosing directory permissions on"
1416                        " configuration file `%s'\n"),tmppath);
1417           else
1418             log_info(_("WARNING: unsafe enclosing directory permissions on"
1419                        " extension `%s'\n"),tmppath);
1420         }
1421     }
1422
1423  end:
1424   xfree(tmppath);
1425
1426   if(homedir)
1427     homedir_cache=ret;
1428
1429   return ret;
1430
1431 #else /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1432   (void)path;
1433   (void)item;
1434   return 0;
1435 #endif /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1436 }
1437
1438
1439 /* Print the OpenPGP defined algo numbers.  */
1440 static void
1441 print_algo_numbers(int (*checker)(int))
1442 {
1443   int i,first=1;
1444
1445   for(i=0;i<=110;i++)
1446     {
1447       if(!checker(i))
1448         {
1449           if(first)
1450             first=0;
1451           else
1452             es_printf (";");
1453           es_printf ("%d",i);
1454         }
1455     }
1456 }
1457
1458
1459 static void
1460 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1461 {
1462   int i,first=1;
1463
1464   for(i=0;i<=110;i++)
1465     {
1466       if(!checker(i))
1467         {
1468           if(first)
1469             first=0;
1470           else
1471             es_printf (";");
1472           es_printf ("%s",mapper(i));
1473         }
1474     }
1475 }
1476
1477 /* In the future, we can do all sorts of interesting configuration
1478    output here.  For now, just give "group" as the Enigmail folks need
1479    it, and pubkey, cipher, hash, and compress as they may be useful
1480    for frontends. */
1481 static void
1482 list_config(char *items)
1483 {
1484   int show_all=(items==NULL);
1485   char *name=NULL;
1486
1487   if(!opt.with_colons)
1488     return;
1489
1490   while(show_all || (name=strsep(&items," ")))
1491     {
1492       int any=0;
1493
1494       if(show_all || ascii_strcasecmp(name,"group")==0)
1495         {
1496           struct groupitem *iter;
1497
1498           for(iter=opt.grouplist;iter;iter=iter->next)
1499             {
1500               strlist_t sl;
1501
1502               es_fprintf (es_stdout, "cfg:group:");
1503               es_write_sanitized (es_stdout, iter->name, strlen(iter->name),
1504                                   ":", NULL);
1505               es_putc (':', es_stdout);
1506
1507               for(sl=iter->values;sl;sl=sl->next)
1508                 {
1509                   print_sanitized_string2 (stdout, sl->d, ':',';');
1510                   if(sl->next)
1511                     es_printf(";");
1512                 }
1513
1514               es_printf("\n");
1515             }
1516
1517           any=1;
1518         }
1519
1520       if(show_all || ascii_strcasecmp(name,"version")==0)
1521         {
1522           es_printf("cfg:version:");
1523           es_write_sanitized (es_stdout, VERSION, strlen(VERSION), ":", NULL);
1524           es_printf ("\n");
1525           any=1;
1526         }
1527
1528       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1529         {
1530           es_printf ("cfg:pubkey:");
1531           print_algo_numbers (openpgp_pk_test_algo);
1532           es_printf ("\n");
1533           any=1;
1534         }
1535
1536       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1537         {
1538           es_printf ("cfg:cipher:");
1539           print_algo_numbers(openpgp_cipher_test_algo);
1540           es_printf ("\n");
1541           any=1;
1542         }
1543
1544       if (show_all || !ascii_strcasecmp (name,"ciphername"))
1545         {
1546           es_printf ("cfg:ciphername:");
1547           print_algo_names (openpgp_cipher_test_algo,openpgp_cipher_algo_name);
1548           es_printf ("\n");
1549           any = 1;
1550         }
1551
1552       if(show_all
1553          || ascii_strcasecmp(name,"digest")==0
1554          || ascii_strcasecmp(name,"hash")==0)
1555         {
1556           es_printf ("cfg:digest:");
1557           print_algo_numbers(openpgp_md_test_algo);
1558           es_printf ("\n");
1559           any=1;
1560         }
1561
1562       if (show_all
1563           || !ascii_strcasecmp(name,"digestname")
1564           || !ascii_strcasecmp(name,"hashname"))
1565         {
1566           es_printf ("cfg:digestname:");
1567           print_algo_names (openpgp_md_test_algo, gcry_md_algo_name);
1568           es_printf ("\n");
1569           any=1;
1570         }
1571       
1572       if(show_all || ascii_strcasecmp(name,"compress")==0)
1573         {
1574           es_printf ("cfg:compress:");
1575           print_algo_numbers(check_compress_algo);
1576           es_printf ("\n");
1577           any=1;
1578         }
1579
1580       if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1581         {
1582 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB) \
1583     && GNUPG_MAJOR_VERSION == 1
1584
1585           char *p, *p2, *list = ccid_get_reader_list ();
1586
1587           for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1588             {
1589               *p2 = 0;
1590               es_printf ("cfg:ccid-reader-id:%s\n", p);
1591             }
1592           free (list);
1593 #endif
1594           any=1;
1595         }
1596
1597       if(show_all)
1598         break;
1599
1600       if(!any)
1601         log_error(_("unknown configuration item `%s'\n"),name);
1602     }
1603 }
1604
1605
1606 /* List options and default values in the GPG Conf format.  This is a
1607    new tool distributed with gnupg 1.9.x but we also want some limited
1608    support in older gpg versions.  The output is the name of the
1609    configuration file and a list of options available for editing by
1610    gpgconf.  */
1611 static void
1612 gpgconf_list (const char *configfile)
1613 {
1614   char *configfile_esc = percent_escape (configfile, NULL);
1615
1616   es_printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1617              GC_OPT_FLAG_DEFAULT,
1618              configfile_esc ? configfile_esc : "/dev/null");
1619   es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1620   es_printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1621   es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1622   es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1623   es_printf ("default-key:%lu:\n", GC_OPT_FLAG_NONE);
1624   es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_NONE);
1625   es_printf ("auto-key-locate:%lu:\n", GC_OPT_FLAG_NONE);
1626   es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1627   es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1628   es_printf ("group:%lu:\n", GC_OPT_FLAG_NONE);
1629
1630   /* The next one is an info only item and should match the macros at
1631      the top of keygen.c  */
1632   es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1633              "RSA-2048");
1634
1635   xfree (configfile_esc);
1636 }
1637
1638
1639 static int
1640 parse_subpacket_list(char *list)
1641 {
1642   char *tok;
1643   byte subpackets[128],i;
1644   int count=0;
1645
1646   if(!list)
1647     {
1648       /* No arguments means all subpackets */
1649       memset(subpackets+1,1,sizeof(subpackets)-1);
1650       count=127;
1651     }
1652   else
1653     {
1654       memset(subpackets,0,sizeof(subpackets));
1655
1656       /* Merge with earlier copy */
1657       if(opt.show_subpackets)
1658         {
1659           byte *in;
1660
1661           for(in=opt.show_subpackets;*in;in++)
1662             {
1663               if(*in>127 || *in<1)
1664                 BUG();
1665
1666               if(!subpackets[*in])
1667                 count++;
1668               subpackets[*in]=1;
1669             }
1670         }
1671
1672       while((tok=strsep(&list," ,")))
1673         {
1674           if(!*tok)
1675             continue;
1676
1677           i=atoi(tok);
1678           if(i>127 || i<1)
1679             return 0;
1680
1681           if(!subpackets[i])
1682             count++;
1683           subpackets[i]=1;
1684         }
1685     }
1686
1687   xfree(opt.show_subpackets);
1688   opt.show_subpackets=xmalloc(count+1);
1689   opt.show_subpackets[count--]=0;
1690
1691   for(i=1;i<128 && count>=0;i++)
1692     if(subpackets[i])
1693       opt.show_subpackets[count--]=i;
1694
1695   return 1;
1696 }
1697
1698
1699 static int
1700 parse_list_options(char *str)
1701 {
1702   char *subpackets=""; /* something that isn't NULL */
1703   struct parse_options lopts[]=
1704     {
1705       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1706        N_("display photo IDs during key listings")},
1707       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1708        N_("show policy URLs during signature listings")},
1709       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1710        N_("show all notations during signature listings")},
1711       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1712        N_("show IETF standard notations during signature listings")},
1713       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1714        NULL},
1715       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1716        N_("show user-supplied notations during signature listings")},
1717       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1718        N_("show preferred keyserver URLs during signature listings")},
1719       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1720        N_("show user ID validity during key listings")},
1721       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1722        N_("show revoked and expired user IDs in key listings")},
1723       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1724        N_("show revoked and expired subkeys in key listings")},
1725       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1726        N_("show the keyring name in key listings")},
1727       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1728        N_("show expiration dates during signature listings")},
1729       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1730        NULL},
1731       {NULL,0,NULL,NULL}
1732     };
1733
1734   /* C99 allows for non-constant initializers, but we'd like to
1735      compile everywhere, so fill in the show-sig-subpackets argument
1736      here.  Note that if the parse_options array changes, we'll have
1737      to change the subscript here. */
1738   lopts[12].value=&subpackets;
1739
1740   if(parse_options(str,&opt.list_options,lopts,1))
1741     {
1742       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1743         {
1744           /* Unset so users can pass multiple lists in. */
1745           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1746           if(!parse_subpacket_list(subpackets))
1747             return 0;
1748         }
1749       else if(subpackets==NULL && opt.show_subpackets)
1750         {
1751           /* User did 'no-show-subpackets' */
1752           xfree(opt.show_subpackets);
1753           opt.show_subpackets=NULL;
1754         }
1755
1756       return 1;
1757     }
1758   else
1759     return 0;
1760 }
1761
1762
1763 /* Collapses argc/argv into a single string that must be freed */
1764 static char *
1765 collapse_args(int argc,char *argv[])
1766 {
1767   char *str=NULL;
1768   int i,first=1,len=0;
1769
1770   for(i=0;i<argc;i++)
1771     {
1772       len+=strlen(argv[i])+2;
1773       str=xrealloc(str,len);
1774       if(first)
1775         {
1776           str[0]='\0';
1777           first=0;
1778         }
1779       else
1780         strcat(str," ");
1781
1782       strcat(str,argv[i]);
1783     }
1784
1785   return str;
1786 }
1787
1788 static void
1789 parse_trust_model(const char *model)
1790 {
1791   if(ascii_strcasecmp(model,"pgp")==0)
1792     opt.trust_model=TM_PGP;
1793   else if(ascii_strcasecmp(model,"classic")==0)
1794     opt.trust_model=TM_CLASSIC;
1795   else if(ascii_strcasecmp(model,"always")==0)
1796     opt.trust_model=TM_ALWAYS;
1797   else if(ascii_strcasecmp(model,"direct")==0)
1798     opt.trust_model=TM_DIRECT;
1799   else if(ascii_strcasecmp(model,"auto")==0)
1800     opt.trust_model=TM_AUTO;
1801   else
1802     log_error("unknown trust model `%s'\n",model);
1803 }
1804
1805
1806 /* This fucntion called to initialized a new control object.  It is
1807    assumed that this object has been zeroed out before calling this
1808    function. */
1809 static void
1810 gpg_init_default_ctrl (ctrl_t ctrl)
1811 {
1812   (void)ctrl;
1813 }
1814
1815
1816 /* This function is called to deinitialize a control object.  It is
1817    not deallocated. */
1818 static void
1819 gpg_deinit_default_ctrl (ctrl_t ctrl)
1820 {
1821   (void)ctrl;
1822 }
1823
1824
1825 char *
1826 get_default_configname (void)
1827 {
1828   char *configname = NULL;
1829   char *name = xstrdup ("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1830   char *ver = &name[strlen ("gpg" EXTSEP_S "conf-")];
1831
1832   do
1833     {
1834       if (configname)
1835         {
1836           char *tok;
1837           
1838           xfree (configname);
1839           configname = NULL;
1840
1841           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
1842             *tok='\0';
1843           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
1844             *tok='\0';
1845           else
1846             break;
1847         }
1848       
1849       configname = make_filename (opt.homedir, name, NULL);
1850     }
1851   while (access (configname, R_OK));
1852
1853   xfree(name);
1854   
1855   if (! configname)
1856     configname = make_filename (opt.homedir, "gpg" EXTSEP_S "conf", NULL);
1857   if (! access (configname, R_OK))
1858     {
1859       /* Print a warning when both config files are present.  */
1860       char *p = make_filename (opt.homedir, "options", NULL);
1861       if (! access (p, R_OK))
1862         log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1863       xfree (p);
1864     }
1865   else
1866     {
1867       /* Use the old default only if it exists.  */
1868       char *p = make_filename (opt.homedir, "options", NULL);
1869       if (!access (p, R_OK))
1870         {
1871           xfree (configname);
1872           configname = p;
1873         }
1874       else
1875         xfree (p);
1876     }
1877
1878   return configname;
1879 }
1880
1881
1882 int
1883 main (int argc, char **argv)
1884 {
1885     ARGPARSE_ARGS pargs;
1886     IOBUF a;
1887     int rc=0;
1888     int orig_argc;
1889     char **orig_argv;
1890     const char *fname;
1891     char *username;
1892     int may_coredump;
1893     strlist_t sl, remusr= NULL, locusr=NULL;
1894     strlist_t nrings = NULL;
1895     armor_filter_context_t *afx = NULL;
1896     int detached_sig = 0;
1897     FILE *configfp = NULL;
1898     char *configname = NULL;
1899     char *save_configname = NULL;
1900     char *default_configname = NULL;
1901     unsigned configlineno;
1902     int parse_debug = 0;
1903     int default_config = 1;
1904     int default_keyring = 1;
1905     int greeting = 0;
1906     int nogreeting = 0;
1907     char *logfile = NULL;
1908     int use_random_seed = 1;
1909     enum cmd_and_opt_values cmd = 0;
1910     const char *debug_level = NULL;
1911     const char *trustdb_name = NULL;
1912     char *def_cipher_string = NULL;
1913     char *def_digest_string = NULL;
1914     char *compress_algo_string = NULL;
1915     char *cert_digest_string = NULL;
1916     char *s2k_cipher_string = NULL;
1917     char *s2k_digest_string = NULL;
1918     char *pers_cipher_list = NULL;
1919     char *pers_digest_list = NULL;
1920     char *pers_compress_list = NULL;
1921     int eyes_only=0;
1922     int multifile=0;
1923     int pwfd = -1;
1924     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
1925     int any_explicit_recipient = 0;
1926     int require_secmem=0,got_secmem=0;
1927     struct assuan_malloc_hooks malloc_hooks;
1928     ctrl_t ctrl;
1929
1930 #ifdef __riscos__
1931     opt.lock_once = 1;
1932 #endif /* __riscos__ */
1933
1934
1935     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1936        when adding any stuff between here and the call to
1937        secmem_init() somewhere after the option parsing. */
1938     gnupg_reopen_std ("gpg");
1939     trap_unaligned ();
1940     gnupg_rl_initialize ();
1941     set_strusage (my_strusage);
1942     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1943     log_set_prefix ("gpg", 1);
1944
1945     /* Make sure that our subsystems are ready.  */
1946     i18n_init();
1947     init_common_subsystems (&argc, &argv);
1948
1949     /* Check that the libraries are suitable.  Do it right here because the
1950        option parsing may need services of the library.  */
1951     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1952       {
1953         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
1954                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1955       }
1956
1957     /* Put random number into secure memory */
1958     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1959
1960     may_coredump = disable_core_dumps();
1961
1962     gnupg_init_signals (0, emergency_cleanup);
1963
1964     create_dotlock(NULL); /* Register locking cleanup. */
1965
1966     opt.session_env = session_env_new ();
1967     if (!opt.session_env)
1968       log_fatal ("error allocating session environment block: %s\n",
1969                  strerror (errno));
1970
1971     opt.command_fd = -1; /* no command fd */
1972     opt.compress_level = -1; /* defaults to standard compress level */
1973     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1974     /* note: if you change these lines, look at oOpenPGP */
1975     opt.def_cipher_algo = 0;
1976     opt.def_digest_algo = 0;
1977     opt.cert_digest_algo = 0;
1978     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1979     opt.s2k_mode = 3; /* iterated+salted */
1980     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
1981     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1982     opt.completes_needed = 1;
1983     opt.marginals_needed = 3;
1984     opt.max_cert_depth = 5;
1985     opt.pgp2_workarounds = 1;
1986     opt.escape_from = 1;
1987     opt.flags.require_cross_cert = 1;
1988     opt.import_options = 0;
1989     opt.export_options = EXPORT_ATTRIBUTES;
1990     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
1991     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
1992     opt.keyserver_options.options = (KEYSERVER_HONOR_KEYSERVER_URL
1993                                      | KEYSERVER_HONOR_PKA_RECORD );
1994     opt.verify_options = (VERIFY_SHOW_POLICY_URLS
1995                           | VERIFY_SHOW_STD_NOTATIONS
1996                           | VERIFY_SHOW_KEYSERVER_URLS);
1997     opt.trust_model = TM_AUTO;
1998     opt.mangle_dos_filenames = 0;
1999     opt.min_cert_level = 2;
2000     set_screen_dimensions ();
2001     opt.keyid_format = KF_SHORT;
2002     opt.def_sig_expire = "0";
2003     opt.def_cert_expire = "0";
2004     set_homedir (default_homedir ());
2005     opt.passphrase_repeat = 1;
2006
2007     /* Check whether we have a config file on the command line.  */
2008     orig_argc = argc;
2009     orig_argv = argv;
2010     pargs.argc = &argc;
2011     pargs.argv = &argv;
2012     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
2013     while( arg_parse( &pargs, opts) ) {
2014         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2015             parse_debug++;
2016         else if( pargs.r_opt == oOptions ) {
2017             /* yes there is one, so we do not try the default one, but
2018              * read the option file when it is encountered at the commandline
2019              */
2020             default_config = 0;
2021         }
2022         else if( pargs.r_opt == oNoOptions )
2023           {
2024             default_config = 0; /* --no-options */
2025             opt.no_homedir_creation = 1;
2026           }
2027         else if( pargs.r_opt == oHomedir )
2028             set_homedir ( pargs.r.ret_str );
2029         else if( pargs.r_opt == oNoPermissionWarn )
2030             opt.no_perm_warn=1;
2031         else if (pargs.r_opt == oStrict )
2032           {
2033             /* Not used */
2034           }
2035         else if (pargs.r_opt == oNoStrict )
2036           {
2037             /* Not used */
2038           }
2039     }
2040
2041 #ifdef HAVE_DOSISH_SYSTEM
2042     if ( strchr (opt.homedir,'\\') ) {
2043         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2044         const char *s = opt.homedir;
2045         for (d=buf,s=opt.homedir; *s; s++)
2046           {
2047             *d++ = *s == '\\'? '/': *s;
2048 #ifdef HAVE_W32_SYSTEM
2049             if (s[1] && IsDBCSLeadByte (*s))
2050               *d++ = *++s;
2051 #endif
2052           }
2053         *d = 0;
2054         set_homedir (buf);
2055     }
2056 #endif
2057
2058     /* Initialize the secure memory. */
2059     if (!gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0))
2060       got_secmem = 1; 
2061 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2062     /* There should be no way to get to this spot while still carrying
2063        setuid privs.  Just in case, bomb out if we are. */
2064     if ( getuid () != geteuid () )
2065       BUG ();
2066 #endif
2067     maybe_setuid = 0;
2068
2069     /* Okay, we are now working under our real uid */
2070
2071     /* malloc hooks go here ... */
2072     malloc_hooks.malloc = gcry_malloc;
2073     malloc_hooks.realloc = gcry_realloc;
2074     malloc_hooks.free = gcry_free;
2075     assuan_set_malloc_hooks (&malloc_hooks);
2076     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2077     setup_libassuan_logging (&opt.debug);
2078  
2079     /* Try for a version specific config file first */
2080     default_configname = get_default_configname ();
2081     if (default_config)
2082       configname = xstrdup (default_configname);
2083
2084     argc = orig_argc;
2085     argv = orig_argv;
2086     pargs.argc = &argc;
2087     pargs.argv = &argv;
2088     pargs.flags=  1;  /* do not remove the args */
2089
2090     /* By this point we have a homedir, and cannot change it. */
2091     check_permissions(opt.homedir,0);
2092
2093   next_pass:
2094     if( configname ) {
2095       if(check_permissions(configname,1))
2096         {
2097           /* If any options file is unsafe, then disable any external
2098              programs for keyserver calls or photo IDs.  Since the
2099              external program to call is set in the options file, a
2100              unsafe options file can lead to an arbitrary program
2101              being run. */
2102
2103           opt.exec_disable=1;
2104         }
2105
2106         configlineno = 0;
2107         configfp = fopen( configname, "r" );
2108         if (configfp && is_secured_file (fileno (configfp)))
2109           {
2110             fclose (configfp);
2111             configfp = NULL;
2112             gpg_err_set_errno (EPERM);
2113           }
2114         if( !configfp ) {
2115             if( default_config ) {
2116                 if( parse_debug )
2117                     log_info(_("NOTE: no default option file `%s'\n"),
2118                                                             configname );
2119             }
2120             else {
2121                 log_error(_("option file `%s': %s\n"),
2122                                     configname, strerror(errno) );
2123                 g10_exit(2);
2124             }
2125             xfree(configname); configname = NULL;
2126         }
2127         if( parse_debug && configname )
2128             log_info(_("reading options from `%s'\n"), configname );
2129         default_config = 0;
2130     }
2131
2132     while( optfile_parse( configfp, configname, &configlineno,
2133                                                 &pargs, opts) )
2134       {
2135         switch( pargs.r_opt )
2136           {
2137           case aCheckKeys: 
2138           case aListConfig:
2139           case aGPGConfList:
2140           case aGPGConfTest:
2141           case aListPackets:
2142           case aImport: 
2143           case aFastImport: 
2144           case aSendKeys: 
2145           case aRecvKeys: 
2146           case aSearchKeys:
2147           case aRefreshKeys:
2148           case aFetchKeys:
2149           case aExport: 
2150 #ifdef ENABLE_CARD_SUPPORT
2151           case aCardStatus:
2152           case aCardEdit: 
2153           case aChangePIN:
2154 #endif /* ENABLE_CARD_SUPPORT*/
2155           case aListKeys: 
2156           case aLocateKeys:
2157           case aListSigs: 
2158           case aExportSecret: 
2159           case aExportSecretSub: 
2160           case aSym:
2161           case aClearsign: 
2162           case aGenRevoke: 
2163           case aDesigRevoke: 
2164           case aPrimegen: 
2165           case aGenRandom:
2166           case aPrintMD:
2167           case aPrintMDs: 
2168           case aListTrustDB: 
2169           case aCheckTrustDB:
2170           case aUpdateTrustDB: 
2171           case aFixTrustDB: 
2172           case aListTrustPath: 
2173           case aDeArmor: 
2174           case aEnArmor: 
2175           case aSign: 
2176           case aSignKey: 
2177           case aLSignKey:
2178           case aStore: 
2179           case aExportOwnerTrust: 
2180           case aImportOwnerTrust: 
2181           case aRebuildKeydbCaches:
2182             set_cmd (&cmd, pargs.r_opt);
2183             break;
2184
2185           case aKeygen: 
2186           case aEditKey:
2187           case aDeleteSecretKeys:
2188           case aDeleteSecretAndPublicKeys:
2189           case aDeleteKeys:
2190           case aPasswd:
2191             set_cmd (&cmd, pargs.r_opt);
2192             greeting=1;
2193             break;
2194
2195           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2196
2197           case aDecryptFiles: multifile=1; /* fall through */
2198           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2199
2200           case aEncrFiles: multifile=1; /* fall through */
2201           case aEncr: set_cmd( &cmd, aEncr); break;
2202
2203           case aVerifyFiles: multifile=1; /* fall through */
2204           case aVerify: set_cmd( &cmd, aVerify); break;
2205
2206           case aServer:
2207             set_cmd (&cmd, pargs.r_opt);
2208             opt.batch = 1;
2209             break;
2210
2211           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2212           case oOutput: opt.outfile = pargs.r.ret_str; break;
2213           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2214           case oQuiet: opt.quiet = 1; break;
2215           case oNoTTY: tty_no_terminal(1); break;
2216           case oDryRun: opt.dry_run = 1; break;
2217           case oInteractive: opt.interactive = 1; break;
2218           case oVerbose:
2219             opt.verbose++;
2220             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2221             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2222             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2223             break;
2224
2225           case oBatch:
2226             opt.batch = 1;
2227             nogreeting = 1;
2228             break;
2229
2230           case oUseAgent: /* Dummy. */
2231             break;
2232           case oNoUseAgent:
2233             obsolete_option (configname, configlineno, "--no-use-agent");
2234             break;
2235           case oGpgAgentInfo: 
2236             obsolete_option (configname, configlineno, "--gpg-agent-info");
2237             break;
2238
2239           case oAnswerYes: opt.answer_yes = 1; break;
2240           case oAnswerNo: opt.answer_no = 1; break;
2241           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2242           case oPrimaryKeyring:
2243             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2244             sl->flags=2;
2245             break;
2246           case oShowKeyring:
2247             deprecated_warning(configname,configlineno,"--show-keyring",
2248                                "--list-options ","show-keyring");
2249             opt.list_options|=LIST_SHOW_KEYRING;
2250             break;
2251
2252           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2253           case oDebugAll: opt.debug = ~0; break;
2254           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2255
2256           case oStatusFD:
2257             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2258             break;
2259           case oStatusFile:
2260             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2261             break;
2262           case oAttributeFD:
2263             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2264             break;
2265           case oAttributeFile:
2266             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2267             break;
2268           case oLoggerFD:
2269             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2270             break;
2271           case oLoggerFile:
2272             logfile = pargs.r.ret_str;
2273             break;
2274
2275           case oWithFingerprint:
2276             opt.with_fingerprint = 1;
2277             opt.fingerprint++;
2278             break;
2279           case oFingerprint:
2280             opt.fingerprint++;
2281             fpr_maybe_cmd = 1;
2282             break;
2283
2284           case oWithKeygrip:
2285             opt.with_keygrip = 1;
2286             break;
2287
2288           case oSecretKeyring:
2289             /* Ignore this old option.  */
2290             break;
2291
2292           case oOptions:
2293             /* config files may not be nested (silently ignore them) */
2294             if( !configfp ) {
2295                 xfree(configname);
2296                 configname = xstrdup(pargs.r.ret_str);
2297                 goto next_pass;
2298             }
2299             break;
2300           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2301           case oNoDefKeyring: default_keyring = 0; break;
2302           case oNoGreeting: nogreeting = 1; break;
2303           case oNoVerbose: 
2304             opt.verbose = 0;
2305             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2306             opt.list_sigs=0;
2307             break;
2308           case oQuickRandom: 
2309             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2310             break;
2311           case oEmitVersion: opt.no_version=0; break;
2312           case oNoEmitVersion: opt.no_version=1; break;
2313           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2314           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2315           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2316           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2317           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2318           case oDefRecipient:
2319             if( *pargs.r.ret_str )
2320               opt.def_recipient = make_username(pargs.r.ret_str);
2321             break;
2322           case oDefRecipientSelf:
2323             xfree(opt.def_recipient); opt.def_recipient = NULL;
2324             opt.def_recipient_self = 1;
2325             break;
2326           case oNoDefRecipient:
2327             xfree(opt.def_recipient); opt.def_recipient = NULL;
2328             opt.def_recipient_self = 0;
2329             break;
2330           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2331           case oHomedir: break;
2332           case oNoBatch: opt.batch = 0; break;
2333
2334           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2335           case oWithColons: opt.with_colons=':'; break;
2336
2337           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2338           case oWithSigList: opt.list_sigs = 1; break;  
2339
2340           case oSkipVerify: opt.skip_verify=1; break;
2341
2342           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2343           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2344
2345           case oCompressKeys: opt.compress_keys = 1; break;
2346           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2347             /* There are many programs (like mutt) that call gpg with
2348                --always-trust so keep this option around for a long
2349                time. */
2350           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2351           case oTrustModel:
2352             parse_trust_model(pargs.r.ret_str);
2353             break;
2354           case oForceOwnertrust:
2355             log_info(_("NOTE: %s is not for normal use!\n"),
2356                      "--force-ownertrust");
2357             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2358             if(opt.force_ownertrust==-1)
2359               {
2360                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2361                 opt.force_ownertrust=0;
2362               }
2363             break;
2364           case oLoadExtension:
2365             /* Dummy so that gpg 1.4 conf files can work. Should
2366                eventually be removed.  */
2367             break;
2368           case oRFC1991:
2369             opt.compliance = CO_RFC1991;
2370             opt.force_v4_certs = 0;
2371             opt.escape_from = 1;
2372             break;
2373           case oOpenPGP:
2374           case oRFC4880:
2375             /* This is effectively the same as RFC2440, but with
2376                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2377                --require-cross-certification". */
2378             opt.compliance = CO_RFC4880;
2379             opt.flags.dsa2 = 1;
2380             opt.flags.require_cross_cert = 1;
2381             opt.rfc2440_text = 0;
2382             opt.allow_non_selfsigned_uid = 1;
2383             opt.allow_freeform_uid = 1;
2384             opt.pgp2_workarounds = 0;
2385             opt.escape_from = 1;
2386             opt.force_v3_sigs = 0;
2387             opt.compress_keys = 0;          /* not mandated, but we do it */
2388             opt.compress_sigs = 0;          /* ditto. */
2389             opt.not_dash_escaped = 0;
2390             opt.def_cipher_algo = 0;
2391             opt.def_digest_algo = 0;
2392             opt.cert_digest_algo = 0;
2393             opt.compress_algo = -1;
2394             opt.s2k_mode = 3; /* iterated+salted */
2395             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2396             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2397             break;
2398           case oRFC2440:
2399             opt.compliance = CO_RFC2440;
2400             opt.flags.dsa2 = 0;
2401             opt.rfc2440_text = 1;
2402             opt.allow_non_selfsigned_uid = 1;
2403             opt.allow_freeform_uid = 1;
2404             opt.pgp2_workarounds = 0;
2405             opt.escape_from = 0;
2406             opt.force_v3_sigs = 0;
2407             opt.compress_keys = 0;          /* not mandated, but we do it */
2408             opt.compress_sigs = 0;          /* ditto. */
2409             opt.not_dash_escaped = 0;
2410             opt.def_cipher_algo = 0;
2411             opt.def_digest_algo = 0;
2412             opt.cert_digest_algo = 0;
2413             opt.compress_algo = -1;
2414             opt.s2k_mode = 3; /* iterated+salted */
2415             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2416             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2417             break;
2418           case oPGP2:  opt.compliance = CO_PGP2;  break;
2419           case oPGP6:  opt.compliance = CO_PGP6;  break;
2420           case oPGP7:  opt.compliance = CO_PGP7;  break;
2421           case oPGP8:  opt.compliance = CO_PGP8;  break;
2422           case oGnuPG: opt.compliance = CO_GNUPG; break;
2423           case oCompressSigs: opt.compress_sigs = 1; break;
2424           case oRFC2440Text: opt.rfc2440_text=1; break;
2425           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2426           case oSetFilename:
2427             if(utf8_strings)
2428               opt.set_filename = pargs.r.ret_str;
2429             else
2430               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2431             break;
2432           case oForYourEyesOnly: eyes_only = 1; break;
2433           case oNoForYourEyesOnly: eyes_only = 0; break;
2434           case oSetPolicyURL:
2435             add_policy_url(pargs.r.ret_str,0);
2436             add_policy_url(pargs.r.ret_str,1);
2437             break;
2438           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2439           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2440           case oShowPolicyURL:
2441             deprecated_warning(configname,configlineno,"--show-policy-url",
2442                                "--list-options ","show-policy-urls");
2443             deprecated_warning(configname,configlineno,"--show-policy-url",
2444                                "--verify-options ","show-policy-urls");
2445             opt.list_options|=LIST_SHOW_POLICY_URLS;
2446             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2447             break;
2448           case oNoShowPolicyURL:
2449             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2450                                "--list-options ","no-show-policy-urls");
2451             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2452                                "--verify-options ","no-show-policy-urls");
2453             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2454             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2455             break;
2456           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2457           case oUseEmbeddedFilename:
2458             opt.flags.use_embedded_filename=1;
2459             break;
2460           case oNoUseEmbeddedFilename:
2461             opt.flags.use_embedded_filename=0;
2462             break;
2463           case oComment:
2464             if(pargs.r.ret_str[0])
2465               append_to_strlist(&opt.comments,pargs.r.ret_str);
2466             break;
2467           case oDefaultComment:
2468             deprecated_warning(configname,configlineno,
2469                                "--default-comment","--no-comments","");
2470             /* fall through */
2471           case oNoComments:
2472             free_strlist(opt.comments);
2473             opt.comments=NULL;
2474             break;
2475           case oThrowKeyids: opt.throw_keyid = 1; break;
2476           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2477           case oShowPhotos:
2478             deprecated_warning(configname,configlineno,"--show-photos",
2479                                "--list-options ","show-photos");
2480             deprecated_warning(configname,configlineno,"--show-photos",
2481                                "--verify-options ","show-photos");
2482             opt.list_options|=LIST_SHOW_PHOTOS;
2483             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2484             break;
2485           case oNoShowPhotos:
2486             deprecated_warning(configname,configlineno,"--no-show-photos",
2487                                "--list-options ","no-show-photos");
2488             deprecated_warning(configname,configlineno,"--no-show-photos",
2489                                "--verify-options ","no-show-photos");
2490             opt.list_options&=~LIST_SHOW_PHOTOS;
2491             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2492             break;
2493           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2494           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2495           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2496           case oForceV4Certs: opt.force_v4_certs = 1; break;
2497           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2498           case oForceMDC: opt.force_mdc = 1; break;
2499           case oNoForceMDC: opt.force_mdc = 0; break;
2500           case oDisableMDC: opt.disable_mdc = 1; break;
2501           case oNoDisableMDC: opt.disable_mdc = 0; break;
2502           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2503           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2504           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2505           case oS2KCount:
2506             if (pargs.r.ret_int)
2507               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2508             else
2509               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2510             break;
2511           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2512           case oEncryptTo: /* store the recipient in the second list */
2513             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2514             sl->flags = 1;
2515             break;
2516           case oHiddenEncryptTo: /* store the recipient in the second list */
2517             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2518             sl->flags = 1|2;
2519             break;
2520           case oRecipient: /* store the recipient */
2521             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2522             any_explicit_recipient = 1;
2523             break;
2524           case oHiddenRecipient: /* store the recipient with a flag */
2525             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2526             sl->flags = 2;
2527             any_explicit_recipient = 1;
2528             break;
2529           case oTextmodeShort: opt.textmode = 2; break;
2530           case oTextmode: opt.textmode=1;  break;
2531           case oNoTextmode: opt.textmode=0;  break;
2532           case oExpert: opt.expert = 1; break;
2533           case oNoExpert: opt.expert = 0; break;
2534           case oDefSigExpire:
2535             if(*pargs.r.ret_str!='\0')
2536               {
2537                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2538                   log_error(_("`%s' is not a valid signature expiration\n"),
2539                             pargs.r.ret_str);
2540                 else
2541                   opt.def_sig_expire=pargs.r.ret_str;
2542               }
2543             break;
2544           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2545           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2546           case oDefCertExpire:
2547             if(*pargs.r.ret_str!='\0')
2548               {
2549                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2550                   log_error(_("`%s' is not a valid signature expiration\n"),
2551                             pargs.r.ret_str);
2552                 else
2553                   opt.def_cert_expire=pargs.r.ret_str;
2554               }
2555             break;
2556           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2557           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2558           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2559           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2560           case oAskCertLevel: opt.ask_cert_level = 1; break;
2561           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2562           case oLocalUser: /* store the local users */
2563             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2564             break;
2565           case oCompress:
2566             /* this is the -z command line option */
2567             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2568             break;
2569           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2570           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2571           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2572           case oPassphrase:
2573             set_passphrase_from_string(pargs.r.ret_str);
2574             break;
2575           case oPassphraseFD:
2576             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2577             break;
2578           case oPassphraseFile:
2579             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
2580             break;
2581           case oPassphraseRepeat: opt.passphrase_repeat=pargs.r.ret_int; break;
2582           case oCommandFD:
2583             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2584             break;
2585           case oCommandFile:
2586             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
2587             break;
2588           case oCipherAlgo: 
2589             def_cipher_string = xstrdup(pargs.r.ret_str);
2590             break;
2591           case oDigestAlgo:
2592             def_digest_string = xstrdup(pargs.r.ret_str);
2593             break;
2594           case oCompressAlgo:
2595             /* If it is all digits, stick a Z in front of it for
2596                later.  This is for backwards compatibility with
2597                versions that took the compress algorithm number. */
2598             {
2599               char *pt=pargs.r.ret_str;
2600               while(*pt)
2601                 {
2602                   if (!isascii (*pt) || !isdigit (*pt))
2603                     break;
2604
2605                   pt++;
2606                 }
2607
2608               if(*pt=='\0')
2609                 {
2610                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2611                   strcpy(compress_algo_string,"Z");
2612                   strcat(compress_algo_string,pargs.r.ret_str);
2613                 }
2614               else
2615                 compress_algo_string = xstrdup(pargs.r.ret_str);
2616             }
2617             break;
2618           case oCertDigestAlgo: 
2619             cert_digest_string = xstrdup(pargs.r.ret_str);
2620             break;
2621
2622           case oNoSecmemWarn: 
2623             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
2624             break;
2625
2626           case oRequireSecmem: require_secmem=1; break;
2627           case oNoRequireSecmem: require_secmem=0; break;
2628           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2629           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2630           case oDisplayCharset:
2631             if( set_native_charset( pargs.r.ret_str ) )
2632                 log_error(_("`%s' is not a valid character set\n"),
2633                           pargs.r.ret_str);
2634             break;
2635           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2636           case oEscapeFrom: opt.escape_from = 1; break;
2637           case oNoEscapeFrom: opt.escape_from = 0; break;
2638           case oLockOnce: opt.lock_once = 1; break;
2639           case oLockNever:
2640             disable_dotlock ();
2641             break;
2642           case oLockMultiple:
2643 #ifndef __riscos__
2644             opt.lock_once = 0;
2645 #else /* __riscos__ */
2646             riscos_not_implemented("lock-multiple");
2647 #endif /* __riscos__ */
2648             break;
2649           case oKeyServer:
2650             {
2651               struct keyserver_spec *keyserver;
2652               keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2653                                             configname,configlineno);
2654               if(!keyserver)
2655                 log_error(_("could not parse keyserver URL\n"));
2656               else
2657                 {
2658                   keyserver->next=opt.keyserver;
2659                   opt.keyserver=keyserver;
2660                 }
2661             }
2662             break;
2663           case oKeyServerOptions:
2664             if(!parse_keyserver_options(pargs.r.ret_str))
2665               {
2666                 if(configname)
2667                   log_error(_("%s:%d: invalid keyserver options\n"),
2668                             configname,configlineno);
2669                 else
2670                   log_error(_("invalid keyserver options\n"));
2671               }
2672             break;
2673           case oImportOptions:
2674             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2675               {
2676                 if(configname)
2677                   log_error(_("%s:%d: invalid import options\n"),
2678                             configname,configlineno);
2679                 else
2680                   log_error(_("invalid import options\n"));
2681               }
2682             break;
2683           case oExportOptions:
2684             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2685               {
2686                 if(configname)
2687                   log_error(_("%s:%d: invalid export options\n"),
2688                             configname,configlineno);
2689                 else
2690                   log_error(_("invalid export options\n"));
2691               }
2692             break;
2693           case oListOptions:
2694             if(!parse_list_options(pargs.r.ret_str))
2695               {
2696                 if(configname)
2697                   log_error(_("%s:%d: invalid list options\n"),
2698                             configname,configlineno);
2699                 else
2700                   log_error(_("invalid list options\n"));
2701               }
2702             break;
2703           case oVerifyOptions:
2704             {
2705               struct parse_options vopts[]=
2706                 {
2707                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2708                    N_("display photo IDs during signature verification")},
2709                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2710                    N_("show policy URLs during signature verification")},
2711                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2712                    N_("show all notations during signature verification")},
2713                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2714                    N_("show IETF standard notations during signature verification")},
2715                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2716                    NULL},
2717                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2718                    N_("show user-supplied notations during signature verification")},
2719                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2720                    N_("show preferred keyserver URLs during signature verification")},
2721                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2722                    N_("show user ID validity during signature verification")},
2723                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2724                    N_("show revoked and expired user IDs in signature verification")},
2725                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
2726                    N_("show only the primary user ID in signature verification")},
2727                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2728                    N_("validate signatures with PKA data")},
2729                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2730                    N_("elevate the trust of signatures with valid PKA data")},
2731                   {NULL,0,NULL,NULL}
2732                 };
2733
2734               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2735                 {
2736                   if(configname)
2737                     log_error(_("%s:%d: invalid verify options\n"),
2738                               configname,configlineno);
2739                   else
2740                     log_error(_("invalid verify options\n"));
2741                 }
2742             }
2743             break;
2744           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2745           case oExecPath:
2746             if(set_exec_path(pargs.r.ret_str))
2747               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2748             else
2749               opt.exec_path_set=1;
2750             break;
2751           case oSetNotation:
2752             add_notation_data( pargs.r.ret_str, 0 );
2753             add_notation_data( pargs.r.ret_str, 1 );
2754             break;
2755           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2756           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2757           case oShowNotation:
2758             deprecated_warning(configname,configlineno,"--show-notation",
2759                                "--list-options ","show-notations");
2760             deprecated_warning(configname,configlineno,"--show-notation",
2761                                "--verify-options ","show-notations");
2762             opt.list_options|=LIST_SHOW_NOTATIONS;
2763             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2764             break;
2765           case oNoShowNotation:
2766             deprecated_warning(configname,configlineno,"--no-show-notation",
2767                                "--list-options ","no-show-notations");
2768             deprecated_warning(configname,configlineno,"--no-show-notation",
2769                                "--verify-options ","no-show-notations");
2770             opt.list_options&=~LIST_SHOW_NOTATIONS;
2771             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2772             break;
2773           case oUtf8Strings: utf8_strings = 1; break;
2774           case oNoUtf8Strings: utf8_strings = 0; break;
2775           case oDisableCipherAlgo:
2776             {
2777               int algo = string_to_cipher_algo (pargs.r.ret_str);
2778               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2779             }
2780             break;
2781           case oDisablePubkeyAlgo:
2782             {
2783               int algo = gcry_pk_map_name (pargs.r.ret_str);
2784               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2785             }
2786             break;
2787           case oNoSigCache: opt.no_sig_cache = 1; break;
2788           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2789           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2790           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2791           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2792           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2793           case oNoLiteral: opt.no_literal = 1; break;
2794           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2795           case oHonorHttpProxy:
2796                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2797                 deprecated_warning(configname,configlineno,
2798                                    "--honor-http-proxy",
2799                                    "--keyserver-options ","http-proxy");
2800                 break;
2801           case oFastListMode: opt.fast_list_mode = 1; break;
2802           case oFixedListMode: /* Dummy */ break;
2803           case oListOnly: opt.list_only=1; break;
2804           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2805           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2806           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2807           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2808           case oNoRandomSeedFile: use_random_seed = 0; break;
2809           case oAutoKeyRetrieve:
2810           case oNoAutoKeyRetrieve:
2811                 if(pargs.r_opt==oAutoKeyRetrieve)
2812                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2813                 else
2814                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2815
2816                 deprecated_warning(configname,configlineno,
2817                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2818                                "--no-auto-key-retrieve","--keyserver-options ",
2819                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2820                                "no-auto-key-retrieve");
2821                 break;
2822           case oShowSessionKey: opt.show_session_key = 1; break;
2823           case oOverrideSessionKey:
2824                 opt.override_session_key = pargs.r.ret_str;
2825                 break;
2826           case oMergeOnly:
2827                 deprecated_warning(configname,configlineno,"--merge-only",
2828                                    "--import-options ","merge-only");
2829                 opt.import_options|=IMPORT_MERGE_ONLY;
2830             break;
2831           case oAllowSecretKeyImport: /* obsolete */ break;
2832           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2833           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2834           case oEnableSpecialFilenames:
2835             iobuf_enable_special_filenames (1);
2836             break;
2837           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2838           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2839           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2840           case oPreservePermissions: opt.preserve_permissions=1; break;
2841           case oDefaultPreferenceList:
2842             opt.def_preference_list = pargs.r.ret_str;
2843             break;
2844           case oDefaultKeyserverURL:
2845             {
2846               struct keyserver_spec *keyserver;
2847               keyserver=parse_keyserver_uri(pargs.r.ret_str,1,
2848                                             configname,configlineno);
2849               if(!keyserver)
2850                 log_error(_("could not parse keyserver URL\n"));
2851               else
2852                 free_keyserver_spec(keyserver);
2853
2854               opt.def_keyserver_url = pargs.r.ret_str;
2855             }
2856             break;
2857           case oPersonalCipherPreferences:
2858             pers_cipher_list=pargs.r.ret_str;
2859             break;
2860           case oPersonalDigestPreferences:
2861             pers_digest_list=pargs.r.ret_str;
2862             break;
2863           case oPersonalCompressPreferences:
2864             pers_compress_list=pargs.r.ret_str;
2865             break;
2866           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
2867
2868           case oDisplay:
2869             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
2870             break;
2871           case oTTYname:
2872             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
2873             break;
2874           case oTTYtype:
2875             set_opt_session_env ("TERM", pargs.r.ret_str);
2876             break;
2877           case oXauthority:
2878             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
2879             break;
2880
2881           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2882           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2883
2884           case oGroup: add_group(pargs.r.ret_str); break;
2885           case oUnGroup: rm_group(pargs.r.ret_str); break;
2886           case oNoGroups:
2887             while(opt.grouplist)
2888               {
2889                 struct groupitem *iter=opt.grouplist;
2890                 free_strlist(iter->values);
2891                 opt.grouplist=opt.grouplist->next;
2892                 xfree(iter);
2893               }
2894             break;
2895
2896           case oStrict: 
2897           case oNoStrict: 
2898             /* Not used */
2899             break;
2900
2901           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2902           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2903           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2904           case oMultifile: multifile=1; break;
2905           case oKeyidFormat:
2906             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2907               opt.keyid_format=KF_SHORT;
2908             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2909               opt.keyid_format=KF_LONG;
2910             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2911               opt.keyid_format=KF_0xSHORT;
2912             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2913               opt.keyid_format=KF_0xLONG;
2914             else
2915               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2916             break;
2917
2918           case oExitOnStatusWriteError:
2919             opt.exit_on_status_write_error = 1;
2920             break;
2921
2922           case oLimitCardInsertTries: 
2923             opt.limit_card_insert_tries = pargs.r.ret_int; 
2924             break;
2925
2926           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2927           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2928
2929           case oAutoKeyLocate:
2930             if(!parse_auto_key_locate(pargs.r.ret_str))
2931               {
2932                 if(configname)
2933                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2934                             configname,configlineno);
2935                 else
2936                   log_error(_("invalid auto-key-locate list\n"));
2937               }
2938             break;
2939           case oNoAutoKeyLocate:
2940             release_akl();
2941             break;
2942
2943           case oEnableDSA2: opt.flags.dsa2=1; break;
2944           case oDisableDSA2: opt.flags.dsa2=0; break;
2945
2946           case oAllowMultisigVerification:
2947           case oAllowMultipleMessages:
2948             opt.flags.allow_multiple_messages=1;
2949             break;
2950
2951           case oNoAllowMultipleMessages:
2952             opt.flags.allow_multiple_messages=0;
2953             break;
2954
2955           case oFakedSystemTime:
2956             {
2957               time_t faked_time = isotime2epoch (pargs.r.ret_str); 
2958               if (faked_time == (time_t)(-1))
2959                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
2960               gnupg_set_time (faked_time, 0);
2961             }
2962             break;
2963
2964           case oNoop: break;
2965
2966           default: 
2967             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
2968             break;
2969           }
2970       }
2971
2972     if (configfp)
2973       {
2974         fclose( configfp );
2975         configfp = NULL;
2976         /* Remember the first config file name. */
2977         if (!save_configname)
2978           save_configname = configname;
2979         else
2980           xfree(configname);
2981         configname = NULL;
2982         goto next_pass;
2983       }
2984     xfree(configname); configname = NULL;
2985     if (log_get_errorcount (0))
2986       g10_exit(2);
2987
2988     /* The command --gpgconf-list is pretty simple and may be called
2989        directly after the option parsing. */
2990     if (cmd == aGPGConfList)
2991       {
2992         gpgconf_list (save_configname ? save_configname : default_configname);
2993         g10_exit (0);
2994       }
2995     xfree (save_configname);
2996     xfree (default_configname);
2997
2998     if( nogreeting )
2999         greeting = 0;
3000
3001     if( greeting )
3002       {
3003         es_fprintf (es_stderr, "%s %s; %s\n",
3004                     strusage(11), strusage(13), strusage(14) );
3005         es_fprintf (es_stderr, "%s\n", strusage(15) );
3006       }
3007 #ifdef IS_DEVELOPMENT_VERSION
3008     if (!opt.batch)
3009       {
3010         const char *s;
3011
3012         if((s=strusage(25)))
3013           log_info("%s\n",s);
3014         if((s=strusage(26)))
3015           log_info("%s\n",s);
3016         if((s=strusage(27)))
3017           log_info("%s\n",s);
3018       }
3019 #endif
3020
3021     /* FIXME: We should use logging to a file only in server mode;
3022        however we have not yet implemetyed that.  Thus we try to get
3023        away with --batch as indication for logging to file
3024        required. */
3025     if (logfile && opt.batch)
3026       {
3027         log_set_file (logfile);
3028         log_set_prefix (NULL, 1|2|4);
3029       }
3030
3031     /* Older Libgcrypts fail with an assertion during DSA key
3032        generation.  Better disable DSA2 entirely. */
3033     if (opt.flags.dsa2 && !gcry_check_version ("1.4.0") )
3034       {
3035         log_info ("WARNING: "
3036                   "DSA2 is only available with Libgcrypt 1.4 and later\n");
3037         opt.flags.dsa2 = 0;
3038       }
3039
3040     if (opt.verbose > 2)
3041         log_info ("using character set `%s'\n", get_native_charset ());
3042
3043     if( may_coredump && !opt.quiet )
3044         log_info(_("WARNING: program may create a core file!\n"));
3045
3046     if (eyes_only) {
3047       if (opt.set_filename)
3048           log_info(_("WARNING: %s overrides %s\n"),
3049                    "--for-your-eyes-only","--set-filename");
3050
3051       opt.set_filename="_CONSOLE";
3052     }
3053
3054     if (opt.no_literal) {
3055         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
3056         if (opt.textmode)
3057             log_error(_("%s not allowed with %s!\n"),
3058                        "--textmode", "--no-literal" );
3059         if (opt.set_filename)
3060             log_error(_("%s makes no sense with %s!\n"),
3061                         eyes_only?"--for-your-eyes-only":"--set-filename",
3062                         "--no-literal" );
3063     }
3064
3065
3066     if (opt.set_filesize)
3067         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
3068     if( opt.batch )
3069         tty_batchmode( 1 );
3070
3071     if (gnupg_faked_time_p ())
3072       {
3073         gnupg_isotime_t tbuf;
3074         
3075         log_info (_("WARNING: running with faked system time: "));
3076         gnupg_get_isotime (tbuf);
3077         dump_isotime (tbuf);
3078         log_printf ("\n");
3079       }
3080     
3081
3082     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3083
3084     if(require_secmem && !got_secmem)
3085       {
3086         log_info(_("will not run with insecure memory due to %s\n"),
3087                  "--require-secmem");
3088         g10_exit(2);
3089       }
3090
3091     set_debug (debug_level);
3092
3093     /* Do these after the switch(), so they can override settings. */
3094     if(PGP2)
3095       {
3096         int unusable=0;
3097
3098         if(cmd==aSign && !detached_sig)
3099           {
3100             log_info(_("you can only make detached or clear signatures "
3101                        "while in --pgp2 mode\n"));
3102             unusable=1;
3103           }
3104         else if(cmd==aSignEncr || cmd==aSignSym)
3105           {
3106             log_info(_("you can't sign and encrypt at the "
3107                        "same time while in --pgp2 mode\n"));
3108             unusable=1;
3109           }
3110         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
3111           {
3112             log_info(_("you must use files (and not a pipe) when "
3113                        "working with --pgp2 enabled.\n"));
3114             unusable=1;
3115           }
3116         else if(cmd==aEncr || cmd==aSym)
3117           {
3118             /* Everything else should work without IDEA (except using
3119                a secret key encrypted with IDEA and setting an IDEA
3120                preference, but those have their own error
3121                messages). */
3122
3123             if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
3124               {
3125                 log_info(_("encrypting a message in --pgp2 mode requires "
3126                            "the IDEA cipher\n"));
3127                 idea_cipher_warn(1);
3128                 unusable=1;
3129               }
3130             else if(cmd==aSym)
3131               {
3132                 /* This only sets IDEA for symmetric encryption
3133                    since it is set via select_algo_from_prefs for
3134                    pk encryption. */
3135                 xfree(def_cipher_string);
3136                 def_cipher_string = xstrdup("idea");
3137               }
3138
3139             /* PGP2 can't handle the output from the textmode
3140                filter, so we disable it for anything that could
3141                create a literal packet (only encryption and
3142                symmetric encryption, since we disable signing
3143                above). */
3144             if(!unusable)
3145               opt.textmode=0;
3146           }
3147
3148         if(unusable)
3149           compliance_failure();
3150         else
3151           {
3152             opt.force_v4_certs = 0;
3153             opt.escape_from = 1;
3154             opt.force_v3_sigs = 1;
3155             opt.pgp2_workarounds = 1;
3156             opt.ask_sig_expire = 0;
3157             opt.ask_cert_expire = 0;
3158             xfree(def_digest_string);
3159             def_digest_string = xstrdup("md5");
3160             xfree(s2k_digest_string);
3161             s2k_digest_string = xstrdup("md5");
3162             opt.compress_algo = COMPRESS_ALGO_ZIP;
3163           }
3164       }
3165     else if(PGP6)
3166       {
3167         opt.disable_mdc=1;
3168         opt.escape_from=1;
3169         opt.force_v3_sigs=1;
3170         opt.ask_sig_expire=0;
3171       }
3172     else if(PGP7)
3173       {
3174         opt.escape_from=1;
3175         opt.force_v3_sigs=1;
3176         opt.ask_sig_expire=0;
3177       }
3178     else if(PGP8)
3179       {
3180         opt.escape_from=1;
3181       }
3182
3183
3184     if( def_cipher_string ) {
3185         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3186         if(opt.def_cipher_algo==0 &&
3187            (ascii_strcasecmp(def_cipher_string,"idea")==0
3188             || ascii_strcasecmp(def_cipher_string,"s1")==0))
3189           idea_cipher_warn(1);
3190         xfree(def_cipher_string); def_cipher_string = NULL;
3191         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3192             log_error(_("selected cipher algorithm is invalid\n"));
3193     }
3194     if( def_digest_string ) {
3195         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3196         xfree(def_digest_string); def_digest_string = NULL;
3197         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3198             log_error(_("selected digest algorithm is invalid\n"));
3199     }
3200     if( compress_algo_string ) {
3201         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3202         xfree(compress_algo_string); compress_algo_string = NULL;
3203         if( check_compress_algo(opt.compress_algo) )
3204           log_error(_("selected compression algorithm is invalid\n"));
3205     }
3206     if( cert_digest_string ) {
3207         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3208         xfree(cert_digest_string); cert_digest_string = NULL;
3209         if (openpgp_md_test_algo(opt.cert_digest_algo))
3210           log_error(_("selected certification digest algorithm is invalid\n"));
3211     }
3212     if( s2k_cipher_string ) {
3213         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3214         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3215         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3216           log_error(_("selected cipher algorithm is invalid\n"));
3217     }
3218     if( s2k_digest_string ) {
3219         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3220         xfree(s2k_digest_string); s2k_digest_string = NULL;
3221         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3222           log_error(_("selected digest algorithm is invalid\n"));
3223     }
3224     if( opt.completes_needed < 1 )
3225       log_error(_("completes-needed must be greater than 0\n"));
3226     if( opt.marginals_needed < 2 )
3227       log_error(_("marginals-needed must be greater than 1\n"));
3228     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3229       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3230     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3231       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3232     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3233       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3234     switch( opt.s2k_mode ) {
3235       case 0:
3236         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3237         break;
3238       case 1: case 3: break;
3239       default:
3240         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3241     }
3242
3243     /* This isn't actually needed, but does serve to error out if the
3244        string is invalid. */
3245     if(opt.def_preference_list &&
3246         keygen_set_std_prefs(opt.def_preference_list,0))
3247       log_error(_("invalid default preferences\n"));
3248
3249     if(pers_cipher_list &&
3250        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3251       log_error(_("invalid personal cipher preferences\n"));
3252
3253     if(pers_digest_list &&
3254        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3255       log_error(_("invalid personal digest preferences\n"));
3256
3257     if(pers_compress_list &&
3258        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3259       log_error(_("invalid personal compress preferences\n"));
3260
3261     /* We don't support all possible commands with multifile yet */
3262     if(multifile)
3263       {
3264         char *cmdname;
3265
3266         switch(cmd)
3267           {
3268           case aSign:
3269             cmdname="--sign";
3270             break;
3271           case aClearsign:
3272             cmdname="--clearsign";
3273             break;
3274           case aDetachedSign:
3275             cmdname="--detach-sign";
3276             break;
3277           case aSym:
3278             cmdname="--symmetric";
3279             break;
3280           case aEncrSym:
3281             cmdname="--symmetric --encrypt";
3282             break;
3283           case aStore:
3284             cmdname="--store";
3285             break;
3286           default:
3287             cmdname=NULL;
3288             break;
3289           }
3290
3291         if(cmdname)
3292           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3293       }
3294
3295     if( log_get_errorcount(0) )
3296         g10_exit(2);
3297
3298     if(opt.compress_level==0)
3299       opt.compress_algo=COMPRESS_ALGO_NONE;
3300
3301     /* Check our chosen algorithms against the list of legal
3302        algorithms. */
3303
3304     if(!GNUPG)
3305       {
3306         const char *badalg=NULL;
3307         preftype_t badtype=PREFTYPE_NONE;
3308
3309         if(opt.def_cipher_algo
3310            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3311           {
3312             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3313             badtype = PREFTYPE_SYM;
3314           }
3315         else if(opt.def_digest_algo
3316                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3317           {
3318             badalg = gcry_md_algo_name (opt.def_digest_algo);
3319             badtype = PREFTYPE_HASH;
3320           }
3321         else if(opt.cert_digest_algo
3322                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3323           {
3324             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3325             badtype = PREFTYPE_HASH;
3326           }
3327         else if(opt.compress_algo!=-1
3328                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3329           {
3330             badalg = compress_algo_to_string(opt.compress_algo);
3331             badtype = PREFTYPE_ZIP;
3332           }
3333
3334         if(badalg)
3335           {
3336             switch(badtype)
3337               {
3338               case PREFTYPE_SYM:
3339                 log_info(_("you may not use cipher algorithm `%s'"
3340                            " while in %s mode\n"),
3341                          badalg,compliance_option_string());
3342                 break;
3343               case PREFTYPE_HASH:
3344                 log_info(_("you may not use digest algorithm `%s'"
3345                            " while in %s mode\n"),
3346                          badalg,compliance_option_string());
3347                 break;
3348               case PREFTYPE_ZIP:
3349                 log_info(_("you may not use compression algorithm `%s'"
3350                            " while in %s mode\n"),
3351                          badalg,compliance_option_string());
3352                 break;
3353               default:
3354                 BUG();
3355               }
3356
3357             compliance_failure();
3358           }
3359       }
3360
3361     /* Set the random seed file. */
3362     if( use_random_seed ) {
3363         char *p = make_filename(opt.homedir, "random_seed", NULL );
3364         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3365         if (!access (p, F_OK))
3366           register_secured_file (p);
3367         xfree(p);
3368     }
3369
3370     /* If there is no command but the --fingerprint is given, default
3371        to the --list-keys command.  */
3372     if (!cmd && fpr_maybe_cmd)
3373       {
3374         set_cmd (&cmd, aListKeys);
3375       }
3376
3377
3378     if( opt.verbose > 1 )
3379         set_packet_list_mode(1);
3380
3381     /* Add the keyrings, but not for some special commands.  Also
3382        avoid adding the secret keyring for a couple of commands to
3383        avoid unneeded access in case the secrings are stored on a
3384        floppy.
3385        
3386        We always need to add the keyrings if we are running under
3387        SELinux, this is so that the rings are added to the list of
3388        secured files. */
3389     if( ALWAYS_ADD_KEYRINGS 
3390         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) ) 
3391       {
3392         if (!nrings || default_keyring)  /* Add default ring. */
3393             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4);
3394         for (sl = nrings; sl; sl = sl->next )
3395           keydb_add_resource (sl->d, sl->flags);
3396       }
3397     FREE_STRLIST(nrings);
3398
3399     if (cmd == aGPGConfTest)
3400       g10_exit(0);
3401
3402
3403     if( pwfd != -1 )  /* Read the passphrase now. */
3404         read_passphrase_from_fd( pwfd );
3405
3406     fname = argc? *argv : NULL;
3407
3408     if(fname && utf8_strings)
3409       opt.flags.utf8_filename=1;
3410
3411     ctrl = xcalloc (1, sizeof *ctrl);
3412     gpg_init_default_ctrl (ctrl);
3413
3414     switch( cmd ) {
3415       case aPrimegen:
3416       case aPrintMD:
3417       case aPrintMDs:
3418       case aGenRandom:
3419       case aDeArmor:
3420       case aEnArmor:
3421         break;
3422       case aFixTrustDB:
3423       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3424       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3425       default: rc = setup_trustdb(1, trustdb_name ); break;
3426     }
3427     if( rc )
3428         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3429
3430
3431     switch (cmd)
3432       {
3433       case aStore: 
3434       case aSym:  
3435       case aSign: 
3436       case aSignSym: 
3437       case aClearsign: 
3438         if (!opt.quiet && any_explicit_recipient)
3439           log_info (_("WARNING: recipients (-r) given "
3440                       "without using public key encryption\n"));
3441         break;
3442       default:
3443         break;
3444       }
3445
3446     switch( cmd )
3447       {
3448       case aServer:
3449         gpg_server (ctrl);
3450         break;
3451
3452       case aStore: /* only store the file */
3453         if( argc > 1 )
3454             wrong_args(_("--store [filename]"));
3455         if( (rc = encrypt_store(fname)) )
3456             log_error ("storing `%s' failed: %s\n",
3457                        print_fname_stdin(fname),g10_errstr(rc) );
3458         break;
3459       case aSym: /* encrypt the given file only with the symmetric cipher */
3460         if( argc > 1 )
3461             wrong_args(_("--symmetric [filename]"));
3462         if( (rc = encrypt_symmetric(fname)) )
3463             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3464                         print_fname_stdin(fname),g10_errstr(rc) );
3465         break;
3466
3467       case aEncr: /* encrypt the given file */
3468         if(multifile)
3469           encrypt_crypt_files (ctrl, argc, argv, remusr);
3470         else
3471           {
3472             if( argc > 1 )
3473               wrong_args(_("--encrypt [filename]"));
3474             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
3475               log_error("%s: encryption failed: %s\n",
3476                         print_fname_stdin(fname), g10_errstr(rc) );
3477           }
3478         break;
3479
3480       case aEncrSym:
3481         /* This works with PGP 8 in the sense that it acts just like a
3482            symmetric message.  It doesn't work at all with 2 or 6.  It
3483            might work with 7, but alas, I don't have a copy to test
3484            with right now. */
3485         if( argc > 1 )
3486           wrong_args(_("--symmetric --encrypt [filename]"));
3487         else if(opt.s2k_mode==0)
3488           log_error(_("you cannot use --symmetric --encrypt"
3489                       " with --s2k-mode 0\n"));
3490         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3491           log_error(_("you cannot use --symmetric --encrypt"
3492                       " while in %s mode\n"),compliance_option_string());
3493         else
3494           {
3495             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
3496               log_error("%s: encryption failed: %s\n",
3497                         print_fname_stdin(fname), g10_errstr(rc) );
3498           }
3499         break;
3500
3501       case aSign: /* sign the given file */
3502         sl = NULL;
3503         if( detached_sig ) { /* sign all files */
3504             for( ; argc; argc--, argv++ )
3505                 add_to_strlist( &sl, *argv );
3506         }
3507         else {
3508             if( argc > 1 )
3509                 wrong_args(_("--sign [filename]"));
3510             if( argc ) {
3511                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3512                 strcpy(sl->d, fname);
3513             }
3514         }
3515         if( (rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)) )
3516             log_error("signing failed: %s\n", g10_errstr(rc) );
3517         free_strlist(sl);
3518         break;
3519
3520       case aSignEncr: /* sign and encrypt the given file */
3521         if( argc > 1 )
3522             wrong_args(_("--sign --encrypt [filename]"));
3523         if( argc ) {
3524             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3525             strcpy(sl->d, fname);
3526         }
3527         else
3528             sl = NULL;
3529         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
3530             log_error("%s: sign+encrypt failed: %s\n",
3531                       print_fname_stdin(fname), g10_errstr(rc) );
3532         free_strlist(sl);
3533         break;
3534
3535       case aSignEncrSym: /* sign and encrypt the given file */
3536         if( argc > 1 )
3537             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3538         else if(opt.s2k_mode==0)
3539           log_error(_("you cannot use --symmetric --sign --encrypt"
3540                       " with --s2k-mode 0\n"));
3541         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3542           log_error(_("you cannot use --symmetric --sign --encrypt"
3543                       " while in %s mode\n"),compliance_option_string());
3544         else
3545           {
3546             if( argc )
3547               {
3548                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3549                 strcpy(sl->d, fname);
3550               }
3551             else
3552               sl = NULL;
3553             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
3554                                  2, remusr, NULL)))
3555               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3556                         print_fname_stdin(fname), g10_errstr(rc) );
3557             free_strlist(sl);
3558           }
3559         break;
3560
3561       case aSignSym: /* sign and conventionally encrypt the given file */
3562         if (argc > 1)
3563             wrong_args(_("--sign --symmetric [filename]"));
3564         rc = sign_symencrypt_file (fname, locusr);
3565         if (rc)
3566             log_error("%s: sign+symmetric failed: %s\n",
3567                       print_fname_stdin(fname), g10_errstr(rc) );
3568         break;
3569
3570       case aClearsign: /* make a clearsig */
3571         if( argc > 1 )
3572             wrong_args(_("--clearsign [filename]"));
3573         if( (rc = clearsign_file(fname, locusr, NULL)) )
3574             log_error("%s: clearsign failed: %s\n",
3575                       print_fname_stdin(fname), g10_errstr(rc) );
3576         break;
3577
3578       case aVerify:
3579         if (multifile)
3580           {
3581             if ((rc = verify_files (ctrl, argc, argv)))
3582               log_error("verify files failed: %s\n", g10_errstr(rc) );
3583           }
3584         else
3585           {
3586             if ((rc = verify_signatures (ctrl, argc, argv)))
3587               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3588           }
3589         break;
3590
3591       case aDecrypt:
3592         if (multifile)
3593           decrypt_messages (ctrl, argc, argv);
3594         else
3595           {
3596             if( argc > 1 )
3597               wrong_args(_("--decrypt [filename]"));
3598             if( (rc = decrypt_message (ctrl, fname) ))
3599               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3600           }
3601         break;
3602             
3603       case aSignKey:
3604         if( argc != 1 )
3605           wrong_args(_("--sign-key user-id"));
3606         /* fall through */
3607       case aLSignKey:
3608         if( argc != 1 )
3609           wrong_args(_("--lsign-key user-id"));
3610         /* fall through */
3611
3612         sl=NULL;
3613
3614         if(cmd==aSignKey)
3615           append_to_strlist(&sl,"sign");
3616         else if(cmd==aLSignKey)
3617           append_to_strlist(&sl,"lsign");
3618         else
3619           BUG();
3620
3621         append_to_strlist( &sl, "save" );
3622         username = make_username( fname );
3623         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
3624         xfree(username);
3625         free_strlist(sl);
3626         break;
3627
3628       case aEditKey: /* Edit a key signature */
3629         if( !argc )
3630             wrong_args(_("--edit-key user-id [commands]"));
3631         username = make_username( fname );
3632         if( argc > 1 ) {
3633             sl = NULL;
3634             for( argc--, argv++ ; argc; argc--, argv++ )
3635                 append_to_strlist( &sl, *argv );
3636             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
3637             free_strlist(sl);
3638         }
3639         else
3640             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
3641         xfree(username);
3642         break;
3643
3644       case aPasswd:
3645         if (argc != 1)
3646           wrong_args (_("--passwd <user-id>"));
3647         else
3648           {
3649             username = make_username (fname);
3650             keyedit_passwd (username);
3651             xfree (username);
3652           }
3653         break;
3654
3655       case aDeleteKeys:
3656       case aDeleteSecretKeys:
3657       case aDeleteSecretAndPublicKeys:
3658         sl = NULL;
3659         /* I'm adding these in reverse order as add_to_strlist2
3660            reverses them again, and it's easier to understand in the
3661            proper order :) */
3662         for( ; argc; argc-- )
3663           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3664         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3665         free_strlist(sl);
3666         break;
3667
3668       case aCheckKeys:
3669         opt.check_sigs = 1;
3670       case aListSigs:
3671         opt.list_sigs = 1;
3672       case aListKeys:
3673         sl = NULL;
3674         for( ; argc; argc--, argv++ )
3675             add_to_strlist2( &sl, *argv, utf8_strings );
3676         public_key_list (ctrl, sl, 0);
3677         free_strlist(sl);
3678         break;
3679       case aListSecretKeys:
3680         sl = NULL;
3681         for( ; argc; argc--, argv++ )
3682             add_to_strlist2( &sl, *argv, utf8_strings );
3683         secret_key_list (ctrl, sl);
3684         free_strlist(sl);
3685         break;
3686       case aLocateKeys:
3687         sl = NULL;
3688         for (; argc; argc--, argv++)
3689           add_to_strlist2( &sl, *argv, utf8_strings );
3690         public_key_list (ctrl, sl, 1);
3691         free_strlist (sl);
3692         break;
3693
3694       case aKeygen: /* generate a key */
3695         if( opt.batch ) {
3696             if( argc > 1 )
3697                 wrong_args("--gen-key [parameterfile]");
3698             generate_keypair( argc? *argv : NULL, NULL, NULL );
3699         }
3700         else {
3701             if( argc )
3702                 wrong_args("--gen-key");
3703             generate_keypair(NULL, NULL, NULL);
3704         }
3705         break;
3706
3707       case aFastImport:
3708         opt.import_options |= IMPORT_FAST;
3709       case aImport:
3710         import_keys (ctrl, argc? argv:NULL, argc, NULL, opt.import_options);
3711         break;
3712
3713         /* TODO: There are a number of command that use this same
3714            "make strlist, call function, report error, free strlist"
3715            pattern.  Join them together here and avoid all that
3716            duplicated code. */
3717
3718       case aExport:
3719       case aSendKeys:
3720       case aRecvKeys:
3721         sl = NULL;
3722         for( ; argc; argc--, argv++ )
3723             append_to_strlist2( &sl, *argv, utf8_strings );
3724         if( cmd == aSendKeys )
3725             rc = keyserver_export (ctrl, sl );
3726         else if( cmd == aRecvKeys )
3727             rc = keyserver_import (ctrl, sl );
3728         else
3729             rc = export_pubkeys (ctrl, sl, opt.export_options);
3730         if(rc)
3731           {
3732             if(cmd==aSendKeys)
3733               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3734             else if(cmd==aRecvKeys)
3735               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3736             else
3737               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3738           }
3739         free_strlist(sl);
3740         break;
3741
3742      case aSearchKeys:
3743         sl = NULL;
3744         for( ; argc; argc--, argv++ )
3745           append_to_strlist2( &sl, *argv, utf8_strings );
3746         rc = keyserver_search (ctrl, sl);
3747         if(rc)
3748           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3749         free_strlist(sl);
3750         break;
3751
3752       case aRefreshKeys:
3753         sl = NULL;
3754         for( ; argc; argc--, argv++ )
3755             append_to_strlist2( &sl, *argv, utf8_strings );
3756         rc = keyserver_refresh (ctrl, sl);
3757         if(rc)
3758           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3759         free_strlist(sl);
3760         break;
3761
3762       case aFetchKeys:
3763         sl = NULL;
3764         for( ; argc; argc--, argv++ )
3765             append_to_strlist2( &sl, *argv, utf8_strings );
3766         rc = keyserver_fetch (ctrl, sl);
3767         if(rc)
3768           log_error("key fetch failed: %s\n",g10_errstr(rc));
3769         free_strlist(sl);
3770         break;
3771
3772       case aExportSecret:
3773         sl = NULL;
3774         for( ; argc; argc--, argv++ )
3775             add_to_strlist2( &sl, *argv, utf8_strings );
3776         export_seckeys (ctrl, sl);
3777         free_strlist(sl);
3778         break;
3779
3780       case aExportSecretSub:
3781         sl = NULL;
3782         for( ; argc; argc--, argv++ )
3783             add_to_strlist2( &sl, *argv, utf8_strings );
3784         export_secsubkeys (ctrl, sl);
3785         free_strlist(sl);
3786         break;
3787
3788       case aGenRevoke:
3789         if( argc != 1 )
3790             wrong_args("--gen-revoke user-id");
3791         username =  make_username(*argv);
3792         gen_revoke( username );
3793         xfree( username );
3794         break;
3795
3796       case aDesigRevoke:
3797         if( argc != 1 )
3798             wrong_args("--desig-revoke user-id");
3799         username =  make_username(*argv);
3800         gen_desig_revoke( username, locusr );
3801         xfree( username );
3802         break;
3803
3804       case aDeArmor:
3805         if( argc > 1 )
3806             wrong_args("--dearmor [file]");
3807         rc = dearmor_file( argc? *argv: NULL );
3808         if( rc )
3809             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3810         break;
3811
3812       case aEnArmor:
3813         if( argc > 1 )
3814             wrong_args("--enarmor [file]");
3815         rc = enarmor_file( argc? *argv: NULL );
3816         if( rc )
3817             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3818         break;
3819
3820
3821       case aPrimegen:
3822 #if 0 /*FIXME*/
3823         {   int mode = argc < 2 ? 0 : atoi(*argv);
3824
3825             if( mode == 1 && argc == 2 ) {
3826                 mpi_print (es_stdout,
3827                            generate_public_prime( atoi(argv[1]) ), 1);
3828             }
3829             else if( mode == 2 && argc == 3 ) {
3830                 mpi_print (es_stdout, generate_elg_prime(
3831                                              0, atoi(argv[1]),
3832                                              atoi(argv[2]), NULL,NULL ), 1);
3833             }
3834             else if( mode == 3 && argc == 3 ) {
3835                 MPI *factors;
3836                 mpi_print (es_stdout, generate_elg_prime(
3837                                              1, atoi(argv[1]),
3838                                              atoi(argv[2]), NULL,&factors ), 1);
3839                 putchar('\n');
3840                 mpi_print (es_stdout, factors[0], 1 ); /* print q */
3841             }
3842             else if( mode == 4 && argc == 3 ) {
3843                 MPI g = mpi_alloc(1);
3844                 mpi_print (es_stdout, generate_elg_prime(
3845                                                  0, atoi(argv[1]),
3846                                                  atoi(argv[2]), g, NULL ), 1);
3847                 putchar('\n');
3848                 mpi_print (es_stdout, g, 1 );
3849                 mpi_free (g);
3850             }
3851             else
3852                 wrong_args("--gen-prime mode bits [qbits] ");
3853             putchar('\n');
3854         }
3855 #endif
3856         wrong_args("--gen-prime not yet supported ");
3857         break;
3858
3859       case aGenRandom:
3860         {
3861             int level = argc ? atoi(*argv):0;
3862             int count = argc > 1 ? atoi(argv[1]): 0;
3863             int endless = !count;
3864
3865             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3866                 wrong_args("--gen-random 0|1|2 [count]");
3867
3868             while( endless || count ) {
3869                 byte *p;
3870                 /* Wee need a multiple of 3, so that in case of
3871                    armored output we get a correct string.  No
3872                    linefolding is done, as it is best to levae this to
3873                    other tools */
3874                 size_t n = !endless && count < 99? count : 99;
3875
3876                 p = gcry_random_bytes (n, level);
3877 #ifdef HAVE_DOSISH_SYSTEM
3878                 setmode ( fileno(stdout), O_BINARY );
3879 #endif
3880                 if (opt.armor) {
3881                     char *tmp = make_radix64_string (p, n);
3882                     fputs (tmp, stdout);
3883                     xfree (tmp);
3884                     if (n%3 == 1)
3885                       putchar ('=');
3886                     if (n%3)
3887                       putchar ('=');
3888                 } else {
3889                     fwrite( p, n, 1, stdout );
3890                 }
3891                 xfree(p);
3892                 if( !endless )
3893                     count -= n;
3894             }
3895             if (opt.armor)
3896                 putchar ('\n');
3897         }
3898         break;
3899
3900       case aPrintMD:
3901         if( argc < 1)
3902             wrong_args("--print-md algo [files]");
3903         {
3904             int all_algos = (**argv=='*' && !(*argv)[1]);
3905             int algo = all_algos? 0 : gcry_md_map_name (*argv);
3906
3907             if( !algo && !all_algos )
3908                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3909             else {
3910                 argc--; argv++;
3911                 if( !argc )
3912                     print_mds(NULL, algo);
3913                 else {
3914                     for(; argc; argc--, argv++ )
3915                         print_mds(*argv, algo);
3916                 }
3917             }
3918         }
3919         break;
3920
3921       case aPrintMDs: /* old option */
3922         if( !argc )
3923             print_mds(NULL,0);
3924         else {
3925             for(; argc; argc--, argv++ )
3926                 print_mds(*argv,0);
3927         }
3928         break;
3929
3930       case aListTrustDB:
3931         if( !argc )
3932             list_trustdb(NULL);
3933         else {
3934             for( ; argc; argc--, argv++ )
3935                 list_trustdb( *argv );
3936         }
3937         break;
3938
3939       case aUpdateTrustDB:
3940         if( argc )
3941             wrong_args("--update-trustdb");
3942         update_trustdb();
3943         break;
3944
3945       case aCheckTrustDB:
3946         /* Old versions allowed for arguments - ignore them */
3947         check_trustdb();
3948         break;
3949
3950       case aFixTrustDB:
3951         how_to_fix_the_trustdb ();
3952         break;
3953
3954       case aListTrustPath:
3955         if( !argc )
3956             wrong_args("--list-trust-path <user-ids>");
3957         for( ; argc; argc--, argv++ ) {
3958             username = make_username( *argv );
3959             list_trust_path( username );
3960             xfree(username);
3961         }
3962         break;
3963
3964       case aExportOwnerTrust:
3965         if( argc )
3966             wrong_args("--export-ownertrust");
3967         export_ownertrust();
3968         break;
3969
3970       case aImportOwnerTrust:
3971         if( argc > 1 )
3972             wrong_args("--import-ownertrust [file]");
3973         import_ownertrust( argc? *argv:NULL );
3974         break;
3975       
3976       case aRebuildKeydbCaches:
3977         if (argc)
3978             wrong_args ("--rebuild-keydb-caches");
3979         keydb_rebuild_caches (1);
3980         break;
3981
3982 #ifdef ENABLE_CARD_SUPPORT
3983       case aCardStatus:
3984         if (argc)
3985             wrong_args ("--card-status");
3986         card_status (es_stdout, NULL, 0);
3987         break;
3988
3989       case aCardEdit:
3990         if (argc) {
3991             sl = NULL;
3992             for (argc--, argv++ ; argc; argc--, argv++)
3993                 append_to_strlist (&sl, *argv);
3994             card_edit (ctrl, sl);
3995             free_strlist (sl);
3996         }
3997         else
3998           card_edit (ctrl, NULL);
3999         break;
4000
4001       case aChangePIN:
4002         if (!argc)
4003             change_pin (0,1);
4004         else if (argc == 1)
4005             change_pin (atoi (*argv),1);
4006         else
4007         wrong_args ("--change-pin [no]");
4008         break;
4009 #endif /* ENABLE_CARD_SUPPORT*/
4010
4011       case aListConfig:
4012         {
4013           char *str=collapse_args(argc,argv);
4014           list_config(str);
4015           xfree(str);
4016         }
4017         break;
4018
4019       case aListPackets:
4020         opt.list_packets=2;
4021       default:
4022         if( argc > 1 )
4023             wrong_args(_("[filename]"));
4024         /* Issue some output for the unix newbie */
4025         if (!fname && !opt.outfile
4026             && gnupg_isatty (fileno (stdin))
4027             && gnupg_isatty (fileno (stdout))
4028             && gnupg_isatty (fileno (stderr)))
4029             log_info(_("Go ahead and type your message ...\n"));
4030
4031         a = iobuf_open(fname);
4032         if (a && is_secured_file (iobuf_get_fd (a)))
4033           {
4034             iobuf_close (a);
4035             a = NULL;
4036             gpg_err_set_errno (EPERM);
4037           }
4038         if( !a )
4039             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
4040         else {
4041
4042             if( !opt.no_armor ) {
4043                 if( use_armor_filter( a ) ) {
4044                     afx = new_armor_context ();
4045                     push_armor_filter (afx, a);
4046                 }
4047             }
4048             if( cmd == aListPackets ) {
4049                 set_packet_list_mode(1);
4050                 opt.list_packets=1;
4051             }
4052             rc = proc_packets (ctrl, NULL, a );
4053             if( rc )
4054                 log_error("processing message failed: %s\n", g10_errstr(rc) );
4055             iobuf_close(a);
4056         }
4057         break;
4058       }
4059
4060     /* cleanup */
4061     gpg_deinit_default_ctrl (ctrl);
4062     xfree (ctrl);
4063     release_armor_context (afx);
4064     FREE_STRLIST(remusr);
4065     FREE_STRLIST(locusr);
4066     g10_exit(0);
4067     return 8; /*NEVER REACHED*/
4068 }
4069
4070
4071 /* Note: This function is used by signal handlers!. */
4072 static void
4073 emergency_cleanup (void)
4074 {
4075   gcry_control (GCRYCTL_TERM_SECMEM );
4076 }
4077
4078
4079 void
4080 g10_exit( int rc )
4081 {
4082   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
4083   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
4084     {
4085       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
4086       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
4087     }
4088   if (opt.debug)
4089     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
4090
4091   emergency_cleanup ();
4092   
4093   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
4094   exit (rc);
4095 }
4096
4097
4098 /* Pretty-print hex hashes.  This assumes at least an 80-character
4099    display, but there are a few other similar assumptions in the
4100    display code. */
4101 static void
4102 print_hex (gcry_md_hd_t md, int algo, const char *fname)
4103 {
4104   int i,n,count,indent=0;
4105   const byte *p;
4106
4107   if (fname)
4108     indent = es_printf("%s: ",fname);
4109
4110   if (indent>40)
4111     {
4112       printf("\n");
4113       indent=0;
4114     }
4115
4116   if (algo==DIGEST_ALGO_RMD160)
4117     indent += es_printf("RMD160 = ");
4118   else if (algo>0)
4119     indent += es_printf("%6s = ", gcry_md_algo_name (algo));
4120   else
4121     algo = abs(algo);
4122
4123   count = indent;
4124
4125   p = gcry_md_read (md, algo);
4126   n = gcry_md_get_algo_dlen (algo);
4127
4128   count += es_printf ("%02X",*p++);
4129
4130   for(i=1;i<n;i++,p++)
4131     {
4132       if(n==16)
4133         {
4134           if(count+2>79)
4135             {
4136               es_printf ("\n%*s",indent," ");
4137               count = indent;
4138             }
4139           else
4140             count += es_printf(" ");
4141
4142           if (!(i%8))
4143             count += es_printf(" ");
4144         }
4145       else if (n==20)
4146         {
4147           if(!(i%2))
4148             {
4149               if(count+4>79)
4150                 {