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