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