indent: Fix indentation of read_block in g10/import.c
[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     aShowKeys,
153     aExport,
154     aExportSecret,
155     aExportSecretSub,
156     aExportSshKey,
157     aCheckKeys,
158     aGenRevoke,
159     aDesigRevoke,
160     aPrimegen,
161     aPrintMD,
162     aPrintMDs,
163     aCheckTrustDB,
164     aUpdateTrustDB,
165     aFixTrustDB,
166     aListTrustDB,
167     aListTrustPath,
168     aExportOwnerTrust,
169     aImportOwnerTrust,
170     aDeArmor,
171     aEnArmor,
172     aGenRandom,
173     aRebuildKeydbCaches,
174     aCardStatus,
175     aCardEdit,
176     aChangePIN,
177     aPasswd,
178     aServer,
179     aTOFUPolicy,
180
181     oMimemode,
182     oTextmode,
183     oNoTextmode,
184     oExpert,
185     oNoExpert,
186     oDefSigExpire,
187     oAskSigExpire,
188     oNoAskSigExpire,
189     oDefCertExpire,
190     oAskCertExpire,
191     oNoAskCertExpire,
192     oDefCertLevel,
193     oMinCertLevel,
194     oAskCertLevel,
195     oNoAskCertLevel,
196     oFingerprint,
197     oWithFingerprint,
198     oWithSubkeyFingerprint,
199     oWithICAOSpelling,
200     oWithKeygrip,
201     oWithSecret,
202     oWithWKDHash,
203     oWithColons,
204     oWithKeyData,
205     oWithKeyOrigin,
206     oWithTofuInfo,
207     oWithSigList,
208     oWithSigCheck,
209     oAnswerYes,
210     oAnswerNo,
211     oKeyring,
212     oPrimaryKeyring,
213     oSecretKeyring,
214     oShowKeyring,
215     oDefaultKey,
216     oDefRecipient,
217     oDefRecipientSelf,
218     oNoDefRecipient,
219     oTrySecretKey,
220     oOptions,
221     oDebug,
222     oDebugLevel,
223     oDebugAll,
224     oDebugIOLBF,
225     oStatusFD,
226     oStatusFile,
227     oAttributeFD,
228     oAttributeFile,
229     oEmitVersion,
230     oNoEmitVersion,
231     oCompletesNeeded,
232     oMarginalsNeeded,
233     oMaxCertDepth,
234     oLoadExtension,
235     oCompliance,
236     oGnuPG,
237     oRFC2440,
238     oRFC4880,
239     oRFC4880bis,
240     oOpenPGP,
241     oPGP6,
242     oPGP7,
243     oPGP8,
244     oDE_VS,
245     oRFC2440Text,
246     oNoRFC2440Text,
247     oCipherAlgo,
248     oDigestAlgo,
249     oCertDigestAlgo,
250     oCompressAlgo,
251     oCompressLevel,
252     oBZ2CompressLevel,
253     oBZ2DecompressLowmem,
254     oPassphrase,
255     oPassphraseFD,
256     oPassphraseFile,
257     oPassphraseRepeat,
258     oPinentryMode,
259     oCommandFD,
260     oCommandFile,
261     oQuickRandom,
262     oNoVerbose,
263     oTrustDBName,
264     oNoSecmemWarn,
265     oRequireSecmem,
266     oNoRequireSecmem,
267     oNoPermissionWarn,
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     oS2KMode,
302     oS2KDigest,
303     oS2KCipher,
304     oS2KCount,
305     oDisplayCharset,
306     oNotDashEscaped,
307     oEscapeFrom,
308     oNoEscapeFrom,
309     oLockOnce,
310     oLockMultiple,
311     oLockNever,
312     oKeyServer,
313     oKeyServerOptions,
314     oImportOptions,
315     oImportFilter,
316     oExportOptions,
317     oExportFilter,
318     oListOptions,
319     oVerifyOptions,
320     oTempDir,
321     oExecPath,
322     oEncryptTo,
323     oHiddenEncryptTo,
324     oNoEncryptTo,
325     oEncryptToDefaultKey,
326     oLoggerFD,
327     oLoggerFile,
328     oUtf8Strings,
329     oNoUtf8Strings,
330     oDisableCipherAlgo,
331     oDisablePubkeyAlgo,
332     oAllowNonSelfsignedUID,
333     oNoAllowNonSelfsignedUID,
334     oAllowFreeformUID,
335     oNoAllowFreeformUID,
336     oAllowSecretKeyImport,
337     oEnableSpecialFilenames,
338     oNoLiteral,
339     oSetFilesize,
340     oHonorHttpProxy,
341     oFastListMode,
342     oListOnly,
343     oIgnoreTimeConflict,
344     oIgnoreValidFrom,
345     oIgnoreCrcError,
346     oIgnoreMDCError,
347     oShowSessionKey,
348     oOverrideSessionKey,
349     oOverrideSessionKeyFD,
350     oNoRandomSeedFile,
351     oAutoKeyRetrieve,
352     oNoAutoKeyRetrieve,
353     oUseAgent,
354     oNoUseAgent,
355     oGpgAgentInfo,
356     oMergeOnly,
357     oTryAllSecrets,
358     oTrustedKey,
359     oNoExpensiveTrustChecks,
360     oFixedListMode,
361     oLegacyListMode,
362     oNoSigCache,
363     oAutoCheckTrustDB,
364     oNoAutoCheckTrustDB,
365     oPreservePermissions,
366     oDefaultPreferenceList,
367     oDefaultKeyserverURL,
368     oPersonalCipherPreferences,
369     oPersonalDigestPreferences,
370     oPersonalCompressPreferences,
371     oAgentProgram,
372     oDirmngrProgram,
373     oDisableDirmngr,
374     oDisplay,
375     oTTYname,
376     oTTYtype,
377     oLCctype,
378     oLCmessages,
379     oXauthority,
380     oGroup,
381     oUnGroup,
382     oNoGroups,
383     oStrict,
384     oNoStrict,
385     oMangleDosFilenames,
386     oNoMangleDosFilenames,
387     oEnableProgressFilter,
388     oMultifile,
389     oKeyidFormat,
390     oExitOnStatusWriteError,
391     oLimitCardInsertTries,
392     oReaderPort,
393     octapiDriver,
394     opcscDriver,
395     oDisableCCID,
396     oRequireCrossCert,
397     oNoRequireCrossCert,
398     oAutoKeyLocate,
399     oNoAutoKeyLocate,
400     oAllowMultisigVerification,
401     oEnableLargeRSA,
402     oDisableLargeRSA,
403     oEnableDSA2,
404     oDisableDSA2,
405     oAllowMultipleMessages,
406     oNoAllowMultipleMessages,
407     oAllowWeakDigestAlgos,
408     oFakedSystemTime,
409     oNoAutostart,
410     oPrintPKARecords,
411     oPrintDANERecords,
412     oTOFUDefaultPolicy,
413     oTOFUDBFormat,
414     oDefaultNewKeyAlgo,
415     oWeakDigest,
416     oUnwrap,
417     oOnlySignTextIDs,
418     oDisableSignerUID,
419     oSender,
420     oKeyOrigin,
421     oRequestOrigin,
422     oNoSymkeyCache,
423
424     oNoop
425   };
426
427
428 static ARGPARSE_OPTS opts[] = {
429
430   ARGPARSE_group (300, N_("@Commands:\n ")),
431
432   ARGPARSE_c (aSign, "sign", N_("make a signature")),
433   ARGPARSE_c (aClearsign, "clear-sign", N_("make a clear text signature")),
434   ARGPARSE_c (aClearsign, "clearsign", "@"),
435   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
436   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
437   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
438   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
439   ARGPARSE_c (aStore, "store",     "@"),
440   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
441   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
442   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
443   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
444   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
445   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
446   ARGPARSE_c (aListSigs, "list-signatures", N_("list keys and signatures")),
447   ARGPARSE_c (aListSigs, "list-sigs", "@"),
448   ARGPARSE_c (aCheckKeys, "check-signatures",
449               N_("list and check key signatures")),
450   ARGPARSE_c (aCheckKeys, "check-sigs", "@"),
451   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
452   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
453   ARGPARSE_c (aKeygen,      "generate-key",
454               N_("generate a new key pair")),
455   ARGPARSE_c (aKeygen,      "gen-key", "@"),
456   ARGPARSE_c (aQuickKeygen, "quick-generate-key" ,
457               N_("quickly generate a new key pair")),
458   ARGPARSE_c (aQuickKeygen, "quick-gen-key", "@"),
459   ARGPARSE_c (aQuickAddUid,  "quick-add-uid",
460               N_("quickly add a new user-id")),
461   ARGPARSE_c (aQuickAddUid,  "quick-adduid", "@"),
462   ARGPARSE_c (aQuickAddKey,  "quick-add-key", "@"),
463   ARGPARSE_c (aQuickAddKey,  "quick-addkey", "@"),
464   ARGPARSE_c (aQuickRevUid,  "quick-revoke-uid",
465               N_("quickly revoke a user-id")),
466   ARGPARSE_c (aQuickRevUid,  "quick-revuid", "@"),
467   ARGPARSE_c (aQuickSetExpire,  "quick-set-expire",
468               N_("quickly set a new expiration date")),
469   ARGPARSE_c (aQuickSetPrimaryUid,  "quick-set-primary-uid", "@"),
470   ARGPARSE_c (aFullKeygen,  "full-generate-key" ,
471               N_("full featured key pair generation")),
472   ARGPARSE_c (aFullKeygen,  "full-gen-key", "@"),
473   ARGPARSE_c (aGenRevoke, "generate-revocation",
474               N_("generate a revocation certificate")),
475   ARGPARSE_c (aGenRevoke, "gen-revoke", "@"),
476   ARGPARSE_c (aDeleteKeys,"delete-keys",
477               N_("remove keys from the public keyring")),
478   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
479               N_("remove keys from the secret keyring")),
480   ARGPARSE_c (aQuickSignKey,  "quick-sign-key" ,
481               N_("quickly sign a key")),
482   ARGPARSE_c (aQuickLSignKey, "quick-lsign-key",
483               N_("quickly sign a key locally")),
484   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
485   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
486   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
487   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
488   ARGPARSE_c (aPasswd,   "change-passphrase", N_("change a passphrase")),
489   ARGPARSE_c (aPasswd,   "passwd", "@"),
490   ARGPARSE_c (aDesigRevoke, "generate-designated-revocation", "@"),
491   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
492   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
493   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a keyserver") ),
494   ARGPARSE_c (aRecvKeys, "receive-keys" , N_("import keys from a keyserver") ),
495   ARGPARSE_c (aRecvKeys, "recv-keys"     , "@"),
496   ARGPARSE_c (aSearchKeys, "search-keys" ,
497               N_("search for keys on a keyserver") ),
498   ARGPARSE_c (aRefreshKeys, "refresh-keys",
499               N_("update all keys from a keyserver")),
500   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
501   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
502   ARGPARSE_c (aShowKeys, "show-keys" , "@" ),
503   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
504   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
505   ARGPARSE_c (aExportSshKey, "export-ssh-key", "@" ),
506   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
507   ARGPARSE_c (aFastImport, "fast-import", "@"),
508 #ifdef ENABLE_CARD_SUPPORT
509   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
510   ARGPARSE_c (aCardEdit,   "edit-card",  N_("change data on a card")),
511   ARGPARSE_c (aCardEdit,   "card-edit", "@"),
512   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
513 #endif
514   ARGPARSE_c (aListConfig, "list-config", "@"),
515   ARGPARSE_c (aListGcryptConfig, "list-gcrypt-config", "@"),
516   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
517   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
518   ARGPARSE_c (aListPackets, "list-packets","@"),
519
520 #ifndef NO_TRUST_MODELS
521   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
522   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
523   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
524               N_("update the trust database")),
525   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
526   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
527 #endif
528
529   ARGPARSE_c (aDeArmor, "dearmor", "@"),
530   ARGPARSE_c (aDeArmor, "dearmour", "@"),
531   ARGPARSE_c (aEnArmor, "enarmor", "@"),
532   ARGPARSE_c (aEnArmor, "enarmour", "@"),
533   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
534   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
535   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
536   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
537   ARGPARSE_c (aTOFUPolicy, "tofu-policy",
538               N_("|VALUE|set the TOFU policy for a key")),
539
540   ARGPARSE_group (301, N_("@\nOptions:\n ")),
541
542   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
543   ARGPARSE_s_n (oArmor, "armour", "@"),
544
545   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
546   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
547   ARGPARSE_s_s (oRecipientFile, "recipient-file", "@"),
548   ARGPARSE_s_s (oHiddenRecipientFile, "hidden-recipient-file", "@"),
549   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
550   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
551   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
552   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
553
554   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
555   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
556   ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
557   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
558   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
559   ARGPARSE_s_n (oEncryptToDefaultKey, "encrypt-to-default-key", "@"),
560   ARGPARSE_s_s (oLocalUser, "local-user",
561                 N_("|USER-ID|use USER-ID to sign or decrypt")),
562   ARGPARSE_s_s (oSender, "sender", "@"),
563
564   ARGPARSE_s_s (oTrySecretKey, "try-secret-key", "@"),
565
566   ARGPARSE_s_i (oCompress, NULL,
567                 N_("|N|set compress level to N (0 disables)")),
568   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
569   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
570   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
571
572   ARGPARSE_s_n (oMimemode, "mimemode", "@"),
573   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
574   ARGPARSE_s_n (oTextmode,   "textmode", N_("use canonical text mode")),
575   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
576
577   ARGPARSE_s_n (oExpert,      "expert", "@"),
578   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
579
580   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
581   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
582   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
583   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
584   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
585   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
586   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
587   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
588   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
589   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
590
591   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
592   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
593   ARGPARSE_s_s (oInputSizeHint, "input-size-hint", "@"),
594
595   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
596   ARGPARSE_s_n (oQuiet,   "quiet",   "@"),
597   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
598
599   ARGPARSE_s_n (oDisableSignerUID, "disable-signer-uid", "@"),
600
601   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
602   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
603
604   ARGPARSE_s_n (oBatch, "batch", "@"),
605   ARGPARSE_s_n (oAnswerYes, "yes", "@"),
606   ARGPARSE_s_n (oAnswerNo, "no", "@"),
607   ARGPARSE_s_s (oKeyring, "keyring", "@"),
608   ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
609   ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
610   ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
611   ARGPARSE_s_s (oDefaultKey, "default-key", "@"),
612
613   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
614   ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
615   ARGPARSE_s_s (oKeyOrigin, "key-origin", "@"),
616   ARGPARSE_s_s (oImportOptions, "import-options", "@"),
617   ARGPARSE_s_s (oImportFilter,  "import-filter", "@"),
618   ARGPARSE_s_s (oExportOptions, "export-options", "@"),
619   ARGPARSE_s_s (oExportFilter,  "export-filter", "@"),
620   ARGPARSE_s_s (oListOptions,   "list-options", "@"),
621   ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
622
623   ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
624   ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
625   ARGPARSE_s_s (oOptions, "options", "@"),
626
627   ARGPARSE_s_s (oDebug, "debug", "@"),
628   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
629   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
630   ARGPARSE_s_n (oDebugIOLBF, "debug-iolbf", "@"),
631   ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
632   ARGPARSE_s_s (oStatusFile, "status-file", "@"),
633   ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
634   ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
635
636   ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
637   ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
638   ARGPARSE_s_i (oMaxCertDepth,  "max-cert-depth", "@" ),
639   ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
640
641   ARGPARSE_s_s (oLoadExtension, "load-extension", "@"),  /* Dummy.  */
642
643   ARGPARSE_s_s (oCompliance, "compliance",   "@"),
644   ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
645   ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
646   ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
647   ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
648   ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
649   ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
650   ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
651   ARGPARSE_s_n (oRFC4880bis, "rfc4880bis", "@"),
652   ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
653   ARGPARSE_s_n (oPGP6, "pgp6", "@"),
654   ARGPARSE_s_n (oPGP7, "pgp7", "@"),
655   ARGPARSE_s_n (oPGP8, "pgp8", "@"),
656
657   ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
658   ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
659   ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
660   ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
661   ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
662   ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
663   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
664   ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
665   ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
666   ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
667   ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
668   ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
669   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
670   ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
671   ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
672   ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
673   ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
674   ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
675   ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
676
677   ARGPARSE_group (302, N_(
678   "@\n(See the man page for a complete listing of all commands and options)\n"
679                       )),
680
681   ARGPARSE_group (303, N_("@\nExamples:\n\n"
682     " -se -r Bob [file]          sign and encrypt for user Bob\n"
683     " --clear-sign [file]        make a clear text signature\n"
684     " --detach-sign [file]       make a detached signature\n"
685     " --list-keys [names]        show keys\n"
686     " --fingerprint [names]      show fingerprints\n")),
687
688   /* More hidden commands and options. */
689   ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
690 #ifndef NO_TRUST_MODELS
691   ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
692 #endif
693
694   /* Not yet used:
695      ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
696   ARGPARSE_c (aDeleteSecretAndPublicKeys,
697               "delete-secret-and-public-keys", "@"),
698   ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
699
700   ARGPARSE_s_s (oPassphrase,      "passphrase", "@"),
701   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
702   ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
703   ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
704   ARGPARSE_s_s (oPinentryMode,    "pinentry-mode", "@"),
705   ARGPARSE_s_s (oRequestOrigin,   "request-origin", "@"),
706   ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
707   ARGPARSE_s_s (oCommandFile, "command-file", "@"),
708   ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
709   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
710
711 #ifndef NO_TRUST_MODELS
712   ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
713   ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
714   ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
715   ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
716 #endif
717
718   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
719   ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
720   ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
721   ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
722   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
723   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
724   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
725   ARGPARSE_s_n (oNoKeyring, "no-keyring", "@"),
726   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
727   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
728   ARGPARSE_s_s (oHomedir, "homedir", "@"),
729   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
730   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
731   ARGPARSE_s_n (oWithTofuInfo,"with-tofu-info", "@"),
732   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
733   ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
734   ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
735   ARGPARSE_c (aListKeys, "list-key", "@"),   /* alias */
736   ARGPARSE_c (aListSigs, "list-sig", "@"),   /* alias */
737   ARGPARSE_c (aCheckKeys, "check-sig", "@"), /* alias */
738   ARGPARSE_c (aShowKeys,  "show-key", "@"), /* alias */
739   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
740   ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
741   ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
742   ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
743 #ifndef NO_TRUST_MODELS
744   ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
745 #endif
746   ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
747   ARGPARSE_s_s (oTOFUDefaultPolicy, "tofu-default-policy", "@"),
748   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
749   ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
750   ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
751   ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
752   ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
753   ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
754   ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
755   ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
756   ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
757   ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
758   ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
759   ARGPARSE_s_s (oComment, "comment", "@"),
760   ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
761   ARGPARSE_s_n (oNoComments, "no-comments", "@"),
762   ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
763   ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
764   ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
765   ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
766   ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
767   ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
768   ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
769   ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
770   ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
771   ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
772   ARGPARSE_s_s (oLoggerFile, "log-file", "@"),
773   ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
774   ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
775   ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
776   ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
777   ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
778   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
779   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprint", "@"),
780   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprints", "@"),
781   ARGPARSE_s_n (oWithICAOSpelling, "with-icao-spelling", "@"),
782   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
783   ARGPARSE_s_n (oWithSecret,      "with-secret", "@"),
784   ARGPARSE_s_n (oWithWKDHash,     "with-wkd-hash", "@"),
785   ARGPARSE_s_n (oWithKeyOrigin,   "with-key-origin", "@"),
786   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
787   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
788   ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
789   ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
790   ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
791   ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
792   ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
793   ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
794   ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
795   ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
796   ARGPARSE_s_n (oLegacyListMode, "legacy-list-mode", "@"),
797   ARGPARSE_s_n (oListOnly, "list-only", "@"),
798   ARGPARSE_s_n (oPrintPKARecords, "print-pka-records", "@"),
799   ARGPARSE_s_n (oPrintDANERecords, "print-dane-records", "@"),
800   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
801   ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
802   ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
803   ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
804   ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
805   ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
806   ARGPARSE_s_i (oOverrideSessionKeyFD, "override-session-key-fd", "@"),
807   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
808   ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
809   ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
810   ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
811   ARGPARSE_s_n (oMergeOnly,       "merge-only", "@" ),
812   ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
813   ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
814   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
815   ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
816   ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
817   ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
818   ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
819   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
820   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
821   ARGPARSE_s_s (oPersonalCompressPreferences,
822                                          "personal-compress-preferences", "@"),
823   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
824   ARGPARSE_s_s (oWeakDigest, "weak-digest","@"),
825   ARGPARSE_s_n (oUnwrap, "unwrap", "@"),
826   ARGPARSE_s_n (oOnlySignTextIDs, "only-sign-text-ids", "@"),
827
828   /* Aliases.  I constantly mistype these, and assume other people do
829      as well. */
830   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
831   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
832   ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
833
834   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
835   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
836   ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr", "@"),
837   ARGPARSE_s_s (oDisplay,    "display",    "@"),
838   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
839   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
840   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
841   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
842   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
843   ARGPARSE_s_s (oGroup,      "group",      "@"),
844   ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
845   ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
846   ARGPARSE_s_n (oStrict,     "strict",     "@"),
847   ARGPARSE_s_n (oNoStrict,   "no-strict",  "@"),
848   ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
849   ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
850   ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
851   ARGPARSE_s_n (oMultifile, "multifile", "@"),
852   ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
853   ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
854   ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
855
856   ARGPARSE_s_n (oAllowMultisigVerification,
857                 "allow-multisig-verification", "@"),
858   ARGPARSE_s_n (oEnableLargeRSA, "enable-large-rsa", "@"),
859   ARGPARSE_s_n (oDisableLargeRSA, "disable-large-rsa", "@"),
860   ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
861   ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
862   ARGPARSE_s_n (oAllowMultipleMessages,      "allow-multiple-messages", "@"),
863   ARGPARSE_s_n (oNoAllowMultipleMessages, "no-allow-multiple-messages", "@"),
864   ARGPARSE_s_n (oAllowWeakDigestAlgos, "allow-weak-digest-algos", "@"),
865
866   ARGPARSE_s_s (oDefaultNewKeyAlgo, "default-new-key-algo", "@"),
867
868   /* These two are aliases to help users of the PGP command line
869      product use gpg with minimal pain.  Many commands are common
870      already as they seem to have borrowed commands from us.  Now I'm
871      returning the favor. */
872   ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
873   ARGPARSE_s_s (oRecipient, "user", "@"),
874
875   ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
876   ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
877   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
878   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
879
880   /* New options.  Fixme: Should go more to the top.  */
881   ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate", "@"),
882   ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
883   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
884   ARGPARSE_s_n (oNoSymkeyCache, "no-symkey-cache", "@"),
885
886   /* Dummy options with warnings.  */
887   ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
888   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
889   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
890   ARGPARSE_s_s (oReaderPort, "reader-port", "@"),
891   ARGPARSE_s_s (octapiDriver, "ctapi-driver", "@"),
892   ARGPARSE_s_s (opcscDriver, "pcsc-driver", "@"),
893   ARGPARSE_s_n (oDisableCCID, "disable-ccid", "@"),
894   ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
895   ARGPARSE_s_s (oTOFUDBFormat, "tofu-db-format", "@"),
896
897   /* Dummy options.  */
898   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
899   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
900   ARGPARSE_s_n (oNoop, "compress-keys", "@"),
901   ARGPARSE_s_n (oNoop, "compress-sigs", "@"),
902   ARGPARSE_s_n (oNoop, "force-v3-sigs", "@"),
903   ARGPARSE_s_n (oNoop, "no-force-v3-sigs", "@"),
904   ARGPARSE_s_n (oNoop, "force-v4-certs", "@"),
905   ARGPARSE_s_n (oNoop, "no-force-v4-certs", "@"),
906   ARGPARSE_s_n (oNoop, "no-mdc-warning", "@"),
907   ARGPARSE_s_n (oNoop, "force-mdc", "@"),
908   ARGPARSE_s_n (oNoop, "no-force-mdc", "@"),
909   ARGPARSE_s_n (oNoop, "disable-mdc", "@"),
910   ARGPARSE_s_n (oNoop, "no-disable-mdc", "@"),
911
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       /* Fixme: Change other options.  */
2161       break;
2162
2163     default:
2164       BUG ();
2165     }
2166 }
2167
2168
2169
2170
2171
2172
2173 /* This function called to initialized a new control object.  It is
2174    assumed that this object has been zeroed out before calling this
2175    function. */
2176 static void
2177 gpg_init_default_ctrl (ctrl_t ctrl)
2178 {
2179   ctrl->magic = SERVER_CONTROL_MAGIC;
2180 }
2181
2182
2183 /* This function is called to deinitialize a control object.  It is
2184    not deallocated. */
2185 static void
2186 gpg_deinit_default_ctrl (ctrl_t ctrl)
2187 {
2188 #ifdef USE_TOFU
2189   tofu_closedbs (ctrl);
2190 #endif
2191   gpg_dirmngr_deinit_session_data (ctrl);
2192
2193   keydb_release (ctrl->cached_getkey_kdb);
2194 }
2195
2196
2197 char *
2198 get_default_configname (void)
2199 {
2200   char *configname = NULL;
2201   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
2202   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
2203
2204   do
2205     {
2206       if (configname)
2207         {
2208           char *tok;
2209
2210           xfree (configname);
2211           configname = NULL;
2212
2213           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
2214             *tok='\0';
2215           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
2216             *tok='\0';
2217           else
2218             break;
2219         }
2220
2221       configname = make_filename (gnupg_homedir (), name, NULL);
2222     }
2223   while (access (configname, R_OK));
2224
2225   xfree(name);
2226
2227   if (! configname)
2228     configname = make_filename (gnupg_homedir (),
2229                                 GPG_NAME EXTSEP_S "conf", NULL);
2230   if (! access (configname, R_OK))
2231     {
2232       /* Print a warning when both config files are present.  */
2233       char *p = make_filename (gnupg_homedir (), "options", NULL);
2234       if (! access (p, R_OK))
2235         log_info (_("Note: old default options file '%s' ignored\n"), p);
2236       xfree (p);
2237     }
2238   else
2239     {
2240       /* Use the old default only if it exists.  */
2241       char *p = make_filename (gnupg_homedir (), "options", NULL);
2242       if (!access (p, R_OK))
2243         {
2244           xfree (configname);
2245           configname = p;
2246         }
2247       else
2248         xfree (p);
2249     }
2250
2251   return configname;
2252 }
2253
2254 int
2255 main (int argc, char **argv)
2256 {
2257     ARGPARSE_ARGS pargs;
2258     IOBUF a;
2259     int rc=0;
2260     int orig_argc;
2261     char **orig_argv;
2262     const char *fname;
2263     char *username;
2264     int may_coredump;
2265     strlist_t sl;
2266     strlist_t remusr = NULL;
2267     strlist_t locusr = NULL;
2268     strlist_t nrings = NULL;
2269     armor_filter_context_t *afx = NULL;
2270     int detached_sig = 0;
2271     FILE *configfp = NULL;
2272     char *configname = NULL;
2273     char *save_configname = NULL;
2274     char *default_configname = NULL;
2275     unsigned configlineno;
2276     int parse_debug = 0;
2277     int default_config = 1;
2278     int default_keyring = 1;
2279     int greeting = 0;
2280     int nogreeting = 0;
2281     char *logfile = NULL;
2282     int use_random_seed = 1;
2283     enum cmd_and_opt_values cmd = 0;
2284     const char *debug_level = NULL;
2285 #ifndef NO_TRUST_MODELS
2286     const char *trustdb_name = NULL;
2287 #endif /*!NO_TRUST_MODELS*/
2288     char *def_cipher_string = NULL;
2289     char *def_digest_string = NULL;
2290     char *compress_algo_string = NULL;
2291     char *cert_digest_string = NULL;
2292     char *s2k_cipher_string = NULL;
2293     char *s2k_digest_string = NULL;
2294     char *pers_cipher_list = NULL;
2295     char *pers_digest_list = NULL;
2296     char *pers_compress_list = NULL;
2297     int eyes_only=0;
2298     int multifile=0;
2299     int pwfd = -1;
2300     int ovrseskeyfd = -1;
2301     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2302     int any_explicit_recipient = 0;
2303     int default_akl = 1;
2304     int require_secmem = 0;
2305     int got_secmem = 0;
2306     struct assuan_malloc_hooks malloc_hooks;
2307     ctrl_t ctrl;
2308
2309     static int print_dane_records;
2310     static int print_pka_records;
2311
2312
2313 #ifdef __riscos__
2314     opt.lock_once = 1;
2315 #endif /* __riscos__ */
2316
2317     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2318        when adding any stuff between here and the call to
2319        secmem_init() somewhere after the option parsing. */
2320     early_system_init ();
2321     gnupg_reopen_std (GPG_NAME);
2322     trap_unaligned ();
2323     gnupg_rl_initialize ();
2324     set_strusage (my_strusage);
2325     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2326     log_set_prefix (GPG_NAME, GPGRT_LOG_WITH_PREFIX);
2327
2328     /* Make sure that our subsystems are ready.  */
2329     i18n_init();
2330     init_common_subsystems (&argc, &argv);
2331
2332     /* Use our own logging handler for Libcgrypt.  */
2333     setup_libgcrypt_logging ();
2334
2335     /* Put random number into secure memory */
2336     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2337
2338     may_coredump = disable_core_dumps();
2339
2340     gnupg_init_signals (0, emergency_cleanup);
2341
2342     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2343
2344     /* Tell the compliance module who we are.  */
2345     gnupg_initialize_compliance (GNUPG_MODULE_NAME_GPG);
2346
2347     opt.autostart = 1;
2348     opt.session_env = session_env_new ();
2349     if (!opt.session_env)
2350       log_fatal ("error allocating session environment block: %s\n",
2351                  strerror (errno));
2352
2353     opt.command_fd = -1; /* no command fd */
2354     opt.compress_level = -1; /* defaults to standard compress level */
2355     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2356     /* note: if you change these lines, look at oOpenPGP */
2357     opt.def_cipher_algo = 0;
2358     opt.def_digest_algo = 0;
2359     opt.cert_digest_algo = 0;
2360     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2361     opt.s2k_mode = 3; /* iterated+salted */
2362     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2363     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2364     opt.completes_needed = 1;
2365     opt.marginals_needed = 3;
2366     opt.max_cert_depth = 5;
2367     opt.escape_from = 1;
2368     opt.flags.require_cross_cert = 1;
2369     opt.import_options = IMPORT_REPAIR_KEYS;
2370     opt.export_options = EXPORT_ATTRIBUTES;
2371     opt.keyserver_options.import_options = (IMPORT_REPAIR_KEYS
2372                                             | IMPORT_REPAIR_PKS_SUBKEY_BUG);
2373     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2374     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2375     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2376                           | VERIFY_SHOW_POLICY_URLS
2377                           | VERIFY_SHOW_STD_NOTATIONS
2378                           | VERIFY_SHOW_KEYSERVER_URLS);
2379     opt.list_options   = (LIST_SHOW_UID_VALIDITY
2380                           | LIST_SHOW_USAGE);
2381 #ifdef NO_TRUST_MODELS
2382     opt.trust_model = TM_ALWAYS;
2383 #else
2384     opt.trust_model = TM_AUTO;
2385 #endif
2386     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2387     opt.mangle_dos_filenames = 0;
2388     opt.min_cert_level = 2;
2389     set_screen_dimensions ();
2390     opt.keyid_format = KF_NONE;
2391     opt.def_sig_expire = "0";
2392     opt.def_cert_expire = "0";
2393     gnupg_set_homedir (NULL);
2394     opt.passphrase_repeat = 1;
2395     opt.emit_version = 0;
2396     opt.weak_digests = NULL;
2397
2398     /* Check whether we have a config file on the command line.  */
2399     orig_argc = argc;
2400     orig_argv = argv;
2401     pargs.argc = &argc;
2402     pargs.argv = &argv;
2403     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2404     while( arg_parse( &pargs, opts) ) {
2405         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2406             parse_debug++;
2407         else if (pargs.r_opt == oDebugIOLBF)
2408             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2409         else if( pargs.r_opt == oOptions ) {
2410             /* yes there is one, so we do not try the default one, but
2411              * read the option file when it is encountered at the commandline
2412              */
2413             default_config = 0;
2414         }
2415         else if( pargs.r_opt == oNoOptions )
2416           {
2417             default_config = 0; /* --no-options */
2418             opt.no_homedir_creation = 1;
2419           }
2420         else if( pargs.r_opt == oHomedir )
2421             gnupg_set_homedir (pargs.r.ret_str);
2422         else if( pargs.r_opt == oNoPermissionWarn )
2423             opt.no_perm_warn=1;
2424         else if (pargs.r_opt == oStrict )
2425           {
2426             /* Not used */
2427           }
2428         else if (pargs.r_opt == oNoStrict )
2429           {
2430             /* Not used */
2431           }
2432     }
2433
2434 #ifdef HAVE_DOSISH_SYSTEM
2435     if ( strchr (gnupg_homedir (), '\\') ) {
2436       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
2437       const char *s;
2438       for (d=buf, s = gnupg_homedir (); *s; s++)
2439           {
2440             *d++ = *s == '\\'? '/': *s;
2441 #ifdef HAVE_W32_SYSTEM
2442             if (s[1] && IsDBCSLeadByte (*s))
2443               *d++ = *++s;
2444 #endif
2445           }
2446         *d = 0;
2447         gnupg_set_homedir (buf);
2448     }
2449 #endif
2450
2451     /* Initialize the secure memory. */
2452     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2453       got_secmem = 1;
2454 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2455     /* There should be no way to get to this spot while still carrying
2456        setuid privs.  Just in case, bomb out if we are. */
2457     if ( getuid () != geteuid () )
2458       BUG ();
2459 #endif
2460     maybe_setuid = 0;
2461
2462     /* Okay, we are now working under our real uid */
2463
2464     /* malloc hooks go here ... */
2465     malloc_hooks.malloc = gcry_malloc;
2466     malloc_hooks.realloc = gcry_realloc;
2467     malloc_hooks.free = gcry_free;
2468     assuan_set_malloc_hooks (&malloc_hooks);
2469     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2470     setup_libassuan_logging (&opt.debug, NULL);
2471
2472     /* Set default options which require that malloc stuff is ready.  */
2473     additional_weak_digest ("MD5");
2474     parse_auto_key_locate ("local,wkd");
2475
2476     /* Try for a version specific config file first */
2477     default_configname = get_default_configname ();
2478     if (default_config)
2479       configname = xstrdup (default_configname);
2480
2481     argc = orig_argc;
2482     argv = orig_argv;
2483     pargs.argc = &argc;
2484     pargs.argv = &argv;
2485     pargs.flags= ARGPARSE_FLAG_KEEP;
2486
2487     /* By this point we have a homedir, and cannot change it. */
2488     check_permissions (gnupg_homedir (), 0);
2489
2490   next_pass:
2491     if( configname ) {
2492       if(check_permissions(configname,1))
2493         {
2494           /* If any options file is unsafe, then disable any external
2495              programs for keyserver calls or photo IDs.  Since the
2496              external program to call is set in the options file, a
2497              unsafe options file can lead to an arbitrary program
2498              being run. */
2499
2500           opt.exec_disable=1;
2501         }
2502
2503         configlineno = 0;
2504         configfp = fopen( configname, "r" );
2505         if (configfp && is_secured_file (fileno (configfp)))
2506           {
2507             fclose (configfp);
2508             configfp = NULL;
2509             gpg_err_set_errno (EPERM);
2510           }
2511         if( !configfp ) {
2512             if( default_config ) {
2513                 if( parse_debug )
2514                     log_info(_("Note: no default option file '%s'\n"),
2515                                                             configname );
2516             }
2517             else {
2518                 log_error(_("option file '%s': %s\n"),
2519                                     configname, strerror(errno) );
2520                 g10_exit(2);
2521             }
2522             xfree(configname); configname = NULL;
2523         }
2524         if( parse_debug && configname )
2525             log_info(_("reading options from '%s'\n"), configname );
2526         default_config = 0;
2527     }
2528
2529     while( optfile_parse( configfp, configname, &configlineno,
2530                                                 &pargs, opts) )
2531       {
2532         switch( pargs.r_opt )
2533           {
2534           case aListConfig:
2535           case aListGcryptConfig:
2536           case aGPGConfList:
2537           case aGPGConfTest:
2538             set_cmd (&cmd, pargs.r_opt);
2539             /* Do not register a keyring for these commands.  */
2540             default_keyring = -1;
2541             break;
2542
2543           case aCheckKeys:
2544           case aListPackets:
2545           case aImport:
2546           case aFastImport:
2547           case aSendKeys:
2548           case aRecvKeys:
2549           case aSearchKeys:
2550           case aRefreshKeys:
2551           case aFetchKeys:
2552           case aExport:
2553 #ifdef ENABLE_CARD_SUPPORT
2554           case aCardStatus:
2555           case aCardEdit:
2556           case aChangePIN:
2557 #endif /* ENABLE_CARD_SUPPORT*/
2558           case aListKeys:
2559           case aLocateKeys:
2560           case aListSigs:
2561           case aExportSecret:
2562           case aExportSecretSub:
2563           case aExportSshKey:
2564           case aSym:
2565           case aClearsign:
2566           case aGenRevoke:
2567           case aDesigRevoke:
2568           case aPrimegen:
2569           case aGenRandom:
2570           case aPrintMD:
2571           case aPrintMDs:
2572           case aListTrustDB:
2573           case aCheckTrustDB:
2574           case aUpdateTrustDB:
2575           case aFixTrustDB:
2576           case aListTrustPath:
2577           case aDeArmor:
2578           case aEnArmor:
2579           case aSign:
2580           case aQuickSignKey:
2581           case aQuickLSignKey:
2582           case aSignKey:
2583           case aLSignKey:
2584           case aStore:
2585           case aQuickKeygen:
2586           case aQuickAddUid:
2587           case aQuickAddKey:
2588           case aQuickRevUid:
2589           case aQuickSetExpire:
2590           case aQuickSetPrimaryUid:
2591           case aExportOwnerTrust:
2592           case aImportOwnerTrust:
2593           case aRebuildKeydbCaches:
2594             set_cmd (&cmd, pargs.r_opt);
2595             break;
2596
2597           case aKeygen:
2598           case aFullKeygen:
2599           case aEditKey:
2600           case aDeleteSecretKeys:
2601           case aDeleteSecretAndPublicKeys:
2602           case aDeleteKeys:
2603           case aPasswd:
2604             set_cmd (&cmd, pargs.r_opt);
2605             greeting=1;
2606             break;
2607
2608           case aShowKeys:
2609             set_cmd (&cmd, pargs.r_opt);
2610             opt.import_options |= IMPORT_SHOW;
2611             opt.import_options |= IMPORT_DRY_RUN;
2612             opt.import_options &= ~IMPORT_REPAIR_KEYS;
2613             opt.list_options |= LIST_SHOW_UNUSABLE_UIDS;
2614             opt.list_options |= LIST_SHOW_UNUSABLE_SUBKEYS;
2615             opt.list_options |= LIST_SHOW_NOTATIONS;
2616             opt.list_options |= LIST_SHOW_POLICY_URLS;
2617             break;
2618
2619           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2620
2621           case aDecryptFiles: multifile=1; /* fall through */
2622           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2623
2624           case aEncrFiles: multifile=1; /* fall through */
2625           case aEncr: set_cmd( &cmd, aEncr); break;
2626
2627           case aVerifyFiles: multifile=1; /* fall through */
2628           case aVerify: set_cmd( &cmd, aVerify); break;
2629
2630           case aServer:
2631             set_cmd (&cmd, pargs.r_opt);
2632             opt.batch = 1;
2633             break;
2634
2635           case aTOFUPolicy:
2636             set_cmd (&cmd, pargs.r_opt);
2637             break;
2638
2639           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2640           case oOutput: opt.outfile = pargs.r.ret_str; break;
2641
2642           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2643
2644           case oInputSizeHint:
2645             opt.input_size_hint = string_to_u64 (pargs.r.ret_str);
2646             break;
2647
2648           case oQuiet: opt.quiet = 1; break;
2649           case oNoTTY: tty_no_terminal(1); break;
2650           case oDryRun: opt.dry_run = 1; break;
2651           case oInteractive: opt.interactive = 1; break;
2652           case oVerbose:
2653             opt.verbose++;
2654             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2655             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2656             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2657             break;
2658
2659           case oBatch:
2660             opt.batch = 1;
2661             nogreeting = 1;
2662             break;
2663
2664           case oUseAgent: /* Dummy. */
2665             break;
2666
2667           case oNoUseAgent:
2668             obsolete_option (configname, configlineno, "no-use-agent");
2669             break;
2670           case oGpgAgentInfo:
2671             obsolete_option (configname, configlineno, "gpg-agent-info");
2672             break;
2673           case oReaderPort:
2674             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2675             break;
2676           case octapiDriver:
2677             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2678             break;
2679           case opcscDriver:
2680             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2681             break;
2682           case oDisableCCID:
2683             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2684             break;
2685           case oHonorHttpProxy:
2686             obsolete_option (configname, configlineno, "honor-http-proxy");
2687             break;
2688
2689           case oAnswerYes: opt.answer_yes = 1; break;
2690           case oAnswerNo: opt.answer_no = 1; break;
2691           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2692           case oPrimaryKeyring:
2693             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2694             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2695             break;
2696           case oShowKeyring:
2697             deprecated_warning(configname,configlineno,"--show-keyring",
2698                                "--list-options ","show-keyring");
2699             opt.list_options|=LIST_SHOW_KEYRING;
2700             break;
2701
2702           case oDebug:
2703             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2704               {
2705                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2706                 pargs.err = ARGPARSE_PRINT_ERROR;
2707               }
2708             break;
2709
2710           case oDebugAll: opt.debug = ~0; break;
2711           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2712
2713           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2714
2715           case oStatusFD:
2716             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2717             break;
2718           case oStatusFile:
2719             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2720             break;
2721           case oAttributeFD:
2722             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2723             break;
2724           case oAttributeFile:
2725             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2726             break;
2727           case oLoggerFD:
2728             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2729             break;
2730           case oLoggerFile:
2731             logfile = pargs.r.ret_str;
2732             break;
2733
2734           case oWithFingerprint:
2735             opt.with_fingerprint = 1;
2736             opt.fingerprint++;
2737             break;
2738           case oWithSubkeyFingerprint:
2739             opt.with_subkey_fingerprint = 1;
2740             break;
2741           case oWithICAOSpelling:
2742             opt.with_icao_spelling = 1;
2743             break;
2744           case oFingerprint:
2745             opt.fingerprint++;
2746             fpr_maybe_cmd = 1;
2747             break;
2748
2749           case oWithKeygrip:
2750             opt.with_keygrip = 1;
2751             break;
2752
2753           case oWithSecret:
2754             opt.with_secret = 1;
2755             break;
2756
2757           case oWithWKDHash:
2758             opt.with_wkd_hash = 1;
2759             break;
2760
2761           case oWithKeyOrigin:
2762             opt.with_key_origin = 1;
2763             break;
2764
2765           case oSecretKeyring:
2766             /* Ignore this old option.  */
2767             break;
2768
2769           case oOptions:
2770             /* config files may not be nested (silently ignore them) */
2771             if( !configfp ) {
2772                 xfree(configname);
2773                 configname = xstrdup(pargs.r.ret_str);
2774                 goto next_pass;
2775             }
2776             break;
2777           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2778
2779           case oNoDefKeyring:
2780             if (default_keyring > 0)
2781               default_keyring = 0;
2782             break;
2783           case oNoKeyring:
2784             default_keyring = -1;
2785             break;
2786
2787           case oNoGreeting: nogreeting = 1; break;
2788           case oNoVerbose:
2789             opt.verbose = 0;
2790             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2791             opt.list_sigs=0;
2792             break;
2793           case oQuickRandom:
2794             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2795             break;
2796           case oEmitVersion: opt.emit_version++; break;
2797           case oNoEmitVersion: opt.emit_version=0; break;
2798           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2799           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2800           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2801
2802 #ifndef NO_TRUST_MODELS
2803           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2804
2805 #endif /*!NO_TRUST_MODELS*/
2806           case oDefaultKey:
2807             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2808             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2809             if (configfp)
2810               sl->flags |= PK_LIST_CONFIG;
2811             break;
2812           case oDefRecipient:
2813             if( *pargs.r.ret_str )
2814               {
2815                 xfree (opt.def_recipient);
2816                 opt.def_recipient = make_username(pargs.r.ret_str);
2817               }
2818             break;
2819           case oDefRecipientSelf:
2820             xfree(opt.def_recipient); opt.def_recipient = NULL;
2821             opt.def_recipient_self = 1;
2822             break;
2823           case oNoDefRecipient:
2824             xfree(opt.def_recipient); opt.def_recipient = NULL;
2825             opt.def_recipient_self = 0;
2826             break;
2827           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2828           case oHomedir: break;
2829           case oNoBatch: opt.batch = 0; break;
2830
2831           case oWithTofuInfo: opt.with_tofu_info = 1; break;
2832
2833           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2834           case oWithColons: opt.with_colons=':'; break;
2835
2836           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2837           case oWithSigList: opt.list_sigs = 1; break;
2838
2839           case oSkipVerify: opt.skip_verify=1; break;
2840
2841           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2842           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2843
2844           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2845
2846 #ifndef NO_TRUST_MODELS
2847             /* There are many programs (like mutt) that call gpg with
2848                --always-trust so keep this option around for a long
2849                time. */
2850           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2851           case oTrustModel:
2852             parse_trust_model(pargs.r.ret_str);
2853             break;
2854 #endif /*!NO_TRUST_MODELS*/
2855           case oTOFUDefaultPolicy:
2856             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2857             break;
2858           case oTOFUDBFormat:
2859             obsolete_option (configname, configlineno, "tofu-db-format");
2860             break;
2861
2862           case oForceOwnertrust:
2863             log_info(_("Note: %s is not for normal use!\n"),
2864                      "--force-ownertrust");
2865             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2866             if(opt.force_ownertrust==-1)
2867               {
2868                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2869                 opt.force_ownertrust=0;
2870               }
2871             break;
2872           case oLoadExtension:
2873             /* Dummy so that gpg 1.4 conf files can work. Should
2874                eventually be removed.  */
2875             break;
2876
2877           case oCompliance:
2878             {
2879               int compliance = gnupg_parse_compliance_option
2880                 (pargs.r.ret_str,
2881                  compliance_options, DIM (compliance_options),
2882                  opt.quiet);
2883               if (compliance < 0)
2884                 g10_exit (1);
2885               set_compliance_option (compliance);
2886             }
2887             break;
2888           case oOpenPGP:
2889           case oRFC2440:
2890           case oRFC4880:
2891           case oRFC4880bis:
2892           case oPGP6:
2893           case oPGP7:
2894           case oPGP8:
2895           case oGnuPG:
2896             set_compliance_option (pargs.r_opt);
2897             break;
2898
2899           case oRFC2440Text: opt.rfc2440_text=1; break;
2900           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2901
2902           case oSetFilename:
2903             if(utf8_strings)
2904               opt.set_filename = pargs.r.ret_str;
2905             else
2906               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2907             break;
2908           case oForYourEyesOnly: eyes_only = 1; break;
2909           case oNoForYourEyesOnly: eyes_only = 0; break;
2910           case oSetPolicyURL:
2911             add_policy_url(pargs.r.ret_str,0);
2912             add_policy_url(pargs.r.ret_str,1);
2913             break;
2914           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2915           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2916           case oShowPolicyURL:
2917             deprecated_warning(configname,configlineno,"--show-policy-url",
2918                                "--list-options ","show-policy-urls");
2919             deprecated_warning(configname,configlineno,"--show-policy-url",
2920                                "--verify-options ","show-policy-urls");
2921             opt.list_options|=LIST_SHOW_POLICY_URLS;
2922             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2923             break;
2924           case oNoShowPolicyURL:
2925             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2926                                "--list-options ","no-show-policy-urls");
2927             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2928                                "--verify-options ","no-show-policy-urls");
2929             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2930             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2931             break;
2932           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2933           case oUseEmbeddedFilename:
2934             opt.flags.use_embedded_filename=1;
2935             break;
2936           case oNoUseEmbeddedFilename:
2937             opt.flags.use_embedded_filename=0;
2938             break;
2939           case oComment:
2940             if(pargs.r.ret_str[0])
2941               append_to_strlist(&opt.comments,pargs.r.ret_str);
2942             break;
2943           case oDefaultComment:
2944             deprecated_warning(configname,configlineno,
2945                                "--default-comment","--no-comments","");
2946             /* fall through */
2947           case oNoComments:
2948             free_strlist(opt.comments);
2949             opt.comments=NULL;
2950             break;
2951           case oThrowKeyids: opt.throw_keyids = 1; break;
2952           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2953           case oShowPhotos:
2954             deprecated_warning(configname,configlineno,"--show-photos",
2955                                "--list-options ","show-photos");
2956             deprecated_warning(configname,configlineno,"--show-photos",
2957                                "--verify-options ","show-photos");
2958             opt.list_options|=LIST_SHOW_PHOTOS;
2959             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2960             break;
2961           case oNoShowPhotos:
2962             deprecated_warning(configname,configlineno,"--no-show-photos",
2963                                "--list-options ","no-show-photos");
2964             deprecated_warning(configname,configlineno,"--no-show-photos",
2965                                "--verify-options ","no-show-photos");
2966             opt.list_options&=~LIST_SHOW_PHOTOS;
2967             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2968             break;
2969           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2970
2971           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
2972
2973           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2974           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2975           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2976           case oS2KCount:
2977             if (pargs.r.ret_int)
2978               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2979             else
2980               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2981             break;
2982
2983           case oRecipient:
2984           case oHiddenRecipient:
2985           case oRecipientFile:
2986           case oHiddenRecipientFile:
2987             /* Store the recipient.  Note that we also store the
2988              * option as private data in the flags.  This is achieved
2989              * by shifting the option value to the left so to keep
2990              * enough space for the flags.  */
2991             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2992             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2993             if (configfp)
2994               sl->flags |= PK_LIST_CONFIG;
2995             if (pargs.r_opt == oHiddenRecipient
2996                 || pargs.r_opt == oHiddenRecipientFile)
2997               sl->flags |= PK_LIST_HIDDEN;
2998             if (pargs.r_opt == oRecipientFile
2999                 || pargs.r_opt == oHiddenRecipientFile)
3000               sl->flags |= PK_LIST_FROM_FILE;
3001             any_explicit_recipient = 1;
3002             break;
3003
3004           case oEncryptTo:
3005           case oHiddenEncryptTo:
3006             /* Store an additional recipient.  */
3007             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3008             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
3009             if (configfp)
3010               sl->flags |= PK_LIST_CONFIG;
3011             if (pargs.r_opt == oHiddenEncryptTo)
3012               sl->flags |= PK_LIST_HIDDEN;
3013             break;
3014
3015           case oNoEncryptTo:
3016             opt.no_encrypt_to = 1;
3017             break;
3018           case oEncryptToDefaultKey:
3019             opt.encrypt_to_default_key = configfp ? 2 : 1;
3020             break;
3021
3022           case oTrySecretKey:
3023             add_to_strlist2 (&opt.secret_keys_to_try,
3024                              pargs.r.ret_str, utf8_strings);
3025             break;
3026
3027           case oMimemode: opt.mimemode = opt.textmode = 1; break;
3028           case oTextmodeShort: opt.textmode = 2; break;
3029           case oTextmode: opt.textmode=1;  break;
3030           case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
3031
3032           case oExpert: opt.expert = 1; break;
3033           case oNoExpert: opt.expert = 0; break;
3034           case oDefSigExpire:
3035             if(*pargs.r.ret_str!='\0')
3036               {
3037                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3038                   log_error(_("'%s' is not a valid signature expiration\n"),
3039                             pargs.r.ret_str);
3040                 else
3041                   opt.def_sig_expire=pargs.r.ret_str;
3042               }
3043             break;
3044           case oAskSigExpire: opt.ask_sig_expire = 1; break;
3045           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
3046           case oDefCertExpire:
3047             if(*pargs.r.ret_str!='\0')
3048               {
3049                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3050                   log_error(_("'%s' is not a valid signature expiration\n"),
3051                             pargs.r.ret_str);
3052                 else
3053                   opt.def_cert_expire=pargs.r.ret_str;
3054               }
3055             break;
3056           case oAskCertExpire: opt.ask_cert_expire = 1; break;
3057           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
3058           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
3059           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
3060           case oAskCertLevel: opt.ask_cert_level = 1; break;
3061           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
3062           case oLocalUser: /* store the local users */
3063             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
3064             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3065             if (configfp)
3066               sl->flags |= PK_LIST_CONFIG;
3067             break;
3068           case oSender:
3069             {
3070               char *mbox = mailbox_from_userid (pargs.r.ret_str);
3071               if (!mbox)
3072                 log_error (_("\"%s\" is not a proper mail address\n"),
3073                            pargs.r.ret_str);
3074               else
3075                 {
3076                   add_to_strlist (&opt.sender_list, mbox);
3077                   xfree (mbox);
3078                 }
3079             }
3080             break;
3081           case oCompress:
3082             /* this is the -z command line option */
3083             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
3084             break;
3085           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
3086           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
3087           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3088           case oPassphrase:
3089             set_passphrase_from_string(pargs.r.ret_str);
3090             break;
3091           case oPassphraseFD:
3092             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3093             break;
3094           case oPassphraseFile:
3095             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3096             break;
3097           case oPassphraseRepeat:
3098             opt.passphrase_repeat = pargs.r.ret_int;
3099             break;
3100
3101           case oPinentryMode:
3102             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3103             if (opt.pinentry_mode == -1)
3104               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3105             break;
3106
3107           case oRequestOrigin:
3108             opt.request_origin = parse_request_origin (pargs.r.ret_str);
3109             if (opt.request_origin == -1)
3110               log_error (_("invalid request origin '%s'\n"), pargs.r.ret_str);
3111             break;
3112
3113           case oCommandFD:
3114             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3115             if (! gnupg_fd_valid (opt.command_fd))
3116               log_error ("command-fd is invalid: %s\n", strerror (errno));
3117             break;
3118           case oCommandFile:
3119             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3120             break;
3121           case oCipherAlgo:
3122             def_cipher_string = xstrdup(pargs.r.ret_str);
3123             break;
3124           case oDigestAlgo:
3125             def_digest_string = xstrdup(pargs.r.ret_str);
3126             break;
3127           case oCompressAlgo:
3128             /* If it is all digits, stick a Z in front of it for
3129                later.  This is for backwards compatibility with
3130                versions that took the compress algorithm number. */
3131             {
3132               char *pt=pargs.r.ret_str;
3133               while(*pt)
3134                 {
3135                   if (!isascii (*pt) || !isdigit (*pt))
3136                     break;
3137
3138                   pt++;
3139                 }
3140
3141               if(*pt=='\0')
3142                 {
3143                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3144                   strcpy(compress_algo_string,"Z");
3145                   strcat(compress_algo_string,pargs.r.ret_str);
3146                 }
3147               else
3148                 compress_algo_string = xstrdup(pargs.r.ret_str);
3149             }
3150             break;
3151           case oCertDigestAlgo:
3152             cert_digest_string = xstrdup(pargs.r.ret_str);
3153             break;
3154
3155           case oNoSecmemWarn:
3156             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3157             break;
3158
3159           case oRequireSecmem: require_secmem=1; break;
3160           case oNoRequireSecmem: require_secmem=0; break;
3161           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3162           case oDisplayCharset:
3163             if( set_native_charset( pargs.r.ret_str ) )
3164                 log_error(_("'%s' is not a valid character set\n"),
3165                           pargs.r.ret_str);
3166             break;
3167           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3168           case oEscapeFrom: opt.escape_from = 1; break;
3169           case oNoEscapeFrom: opt.escape_from = 0; break;
3170           case oLockOnce: opt.lock_once = 1; break;
3171           case oLockNever:
3172             dotlock_disable ();
3173             break;
3174           case oLockMultiple:
3175 #ifndef __riscos__
3176             opt.lock_once = 0;
3177 #else /* __riscos__ */
3178             riscos_not_implemented("lock-multiple");
3179 #endif /* __riscos__ */
3180             break;
3181           case oKeyServer:
3182             {
3183               keyserver_spec_t keyserver;
3184               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3185               if (!keyserver)
3186                 log_error (_("could not parse keyserver URL\n"));
3187               else
3188                 {
3189                   /* We only support a single keyserver.  Later ones
3190                      override earlier ones.  (Since we parse the
3191                      config file first and then the command line
3192                      arguments, the command line takes
3193                      precedence.)  */
3194                   if (opt.keyserver)
3195                     free_keyserver_spec (opt.keyserver);
3196                   opt.keyserver = keyserver;
3197                 }
3198             }
3199             break;
3200           case oKeyServerOptions:
3201             if(!parse_keyserver_options(pargs.r.ret_str))
3202               {
3203                 if(configname)
3204                   log_error(_("%s:%d: invalid keyserver options\n"),
3205                             configname,configlineno);
3206                 else
3207                   log_error(_("invalid keyserver options\n"));
3208               }
3209             break;
3210           case oImportOptions:
3211             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3212               {
3213                 if(configname)
3214                   log_error(_("%s:%d: invalid import options\n"),
3215                             configname,configlineno);
3216                 else
3217                   log_error(_("invalid import options\n"));
3218               }
3219             break;
3220           case oImportFilter:
3221             rc = parse_and_set_import_filter (pargs.r.ret_str);
3222             if (rc)
3223               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3224             break;
3225           case oExportOptions:
3226             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3227               {
3228                 if(configname)
3229                   log_error(_("%s:%d: invalid export options\n"),
3230                             configname,configlineno);
3231                 else
3232                   log_error(_("invalid export options\n"));
3233               }
3234             break;
3235           case oExportFilter:
3236             rc = parse_and_set_export_filter (pargs.r.ret_str);
3237             if (rc)
3238               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3239             break;
3240           case oListOptions:
3241             if(!parse_list_options(pargs.r.ret_str))
3242               {
3243                 if(configname)
3244                   log_error(_("%s:%d: invalid list options\n"),
3245                             configname,configlineno);
3246                 else
3247                   log_error(_("invalid list options\n"));
3248               }
3249             break;
3250           case oVerifyOptions:
3251             {
3252               struct parse_options vopts[]=
3253                 {
3254                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3255                    N_("display photo IDs during signature verification")},
3256                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3257                    N_("show policy URLs during signature verification")},
3258                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3259                    N_("show all notations during signature verification")},
3260                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3261                    N_("show IETF standard notations during signature verification")},
3262                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3263                    NULL},
3264                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3265                    N_("show user-supplied notations during signature verification")},
3266                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3267                    N_("show preferred keyserver URLs during signature verification")},
3268                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3269                    N_("show user ID validity during signature verification")},
3270                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3271                    N_("show revoked and expired user IDs in signature verification")},
3272                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3273                    N_("show only the primary user ID in signature verification")},
3274                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3275                    N_("validate signatures with PKA data")},
3276                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3277                    N_("elevate the trust of signatures with valid PKA data")},
3278                   {NULL,0,NULL,NULL}
3279                 };
3280
3281               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3282                 {
3283                   if(configname)
3284                     log_error(_("%s:%d: invalid verify options\n"),
3285                               configname,configlineno);
3286                   else
3287                     log_error(_("invalid verify options\n"));
3288                 }
3289             }
3290             break;
3291           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3292           case oExecPath:
3293             if(set_exec_path(pargs.r.ret_str))
3294               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3295             else
3296               opt.exec_path_set=1;
3297             break;
3298           case oSetNotation:
3299             add_notation_data( pargs.r.ret_str, 0 );
3300             add_notation_data( pargs.r.ret_str, 1 );
3301             break;
3302           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3303           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3304           case oShowNotation:
3305             deprecated_warning(configname,configlineno,"--show-notation",
3306                                "--list-options ","show-notations");
3307             deprecated_warning(configname,configlineno,"--show-notation",
3308                                "--verify-options ","show-notations");
3309             opt.list_options|=LIST_SHOW_NOTATIONS;
3310             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3311             break;
3312           case oNoShowNotation:
3313             deprecated_warning(configname,configlineno,"--no-show-notation",
3314                                "--list-options ","no-show-notations");
3315             deprecated_warning(configname,configlineno,"--no-show-notation",
3316                                "--verify-options ","no-show-notations");
3317             opt.list_options&=~LIST_SHOW_NOTATIONS;
3318             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3319             break;
3320           case oUtf8Strings: utf8_strings = 1; break;
3321           case oNoUtf8Strings: utf8_strings = 0; break;
3322           case oDisableCipherAlgo:
3323             {
3324               int algo = string_to_cipher_algo (pargs.r.ret_str);
3325               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3326             }
3327             break;
3328           case oDisablePubkeyAlgo:
3329             {
3330               int algo = gcry_pk_map_name (pargs.r.ret_str);
3331               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3332             }
3333             break;
3334           case oNoSigCache: opt.no_sig_cache = 1; break;
3335           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3336           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3337           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3338           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3339           case oNoLiteral: opt.no_literal = 1; break;
3340           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3341           case oFastListMode: opt.fast_list_mode = 1; break;
3342           case oFixedListMode: /* Dummy */ break;
3343           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3344           case oPrintPKARecords: print_pka_records = 1; break;
3345           case oPrintDANERecords: print_dane_records = 1; break;
3346           case oListOnly: opt.list_only=1; break;
3347           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3348           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3349           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3350           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3351           case oNoRandomSeedFile: use_random_seed = 0; break;
3352
3353           case oAutoKeyRetrieve:
3354             opt.keyserver_options.options |= KEYSERVER_AUTO_KEY_RETRIEVE;
3355             break;
3356           case oNoAutoKeyRetrieve:
3357             opt.keyserver_options.options &= ~KEYSERVER_AUTO_KEY_RETRIEVE;
3358             break;
3359
3360           case oShowSessionKey: opt.show_session_key = 1; break;
3361           case oOverrideSessionKey:
3362                 opt.override_session_key = pargs.r.ret_str;
3363                 break;
3364           case oOverrideSessionKeyFD:
3365                 ovrseskeyfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3366                 break;
3367           case oMergeOnly:
3368                 deprecated_warning(configname,configlineno,"--merge-only",
3369                                    "--import-options ","merge-only");
3370                 opt.import_options|=IMPORT_MERGE_ONLY;
3371             break;
3372           case oAllowSecretKeyImport: /* obsolete */ break;
3373           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3374           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3375
3376           case oEnableSpecialFilenames:
3377             enable_special_filenames ();
3378             break;
3379
3380           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3381           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3382           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3383           case oPreservePermissions: opt.preserve_permissions=1; break;
3384           case oDefaultPreferenceList:
3385             opt.def_preference_list = pargs.r.ret_str;
3386             break;
3387           case oDefaultKeyserverURL:
3388             {
3389               keyserver_spec_t keyserver;
3390               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3391               if (!keyserver)
3392                 log_error (_("could not parse keyserver URL\n"));
3393               else
3394                 free_keyserver_spec (keyserver);
3395
3396               opt.def_keyserver_url = pargs.r.ret_str;
3397             }
3398             break;
3399           case oPersonalCipherPreferences:
3400             pers_cipher_list=pargs.r.ret_str;
3401             break;
3402           case oPersonalDigestPreferences:
3403             pers_digest_list=pargs.r.ret_str;
3404             break;
3405           case oPersonalCompressPreferences:
3406             pers_compress_list=pargs.r.ret_str;
3407             break;
3408           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3409           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3410           case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
3411           case oWeakDigest:
3412             additional_weak_digest(pargs.r.ret_str);
3413             break;
3414           case oUnwrap:
3415             opt.unwrap_encryption = 1;
3416             break;
3417           case oOnlySignTextIDs:
3418             opt.only_sign_text_ids = 1;
3419             break;
3420
3421           case oDisplay:
3422             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3423             break;
3424           case oTTYname:
3425             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3426             break;
3427           case oTTYtype:
3428             set_opt_session_env ("TERM", pargs.r.ret_str);
3429             break;
3430           case oXauthority:
3431             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3432             break;
3433
3434           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3435           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3436
3437           case oGroup: add_group(pargs.r.ret_str); break;
3438           case oUnGroup: rm_group(pargs.r.ret_str); break;
3439           case oNoGroups:
3440             while(opt.grouplist)
3441               {
3442                 struct groupitem *iter=opt.grouplist;
3443                 free_strlist(iter->values);
3444                 opt.grouplist=opt.grouplist->next;
3445                 xfree(iter);
3446               }
3447             break;
3448
3449           case oStrict:
3450           case oNoStrict:
3451             /* Not used */
3452             break;
3453
3454           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3455           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3456           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3457           case oMultifile: multifile=1; break;
3458           case oKeyidFormat:
3459             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3460               opt.keyid_format=KF_SHORT;
3461             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3462               opt.keyid_format=KF_LONG;
3463             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3464               opt.keyid_format=KF_0xSHORT;
3465             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3466               opt.keyid_format=KF_0xLONG;
3467             else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
3468               opt.keyid_format = KF_NONE;
3469             else
3470               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3471             break;
3472
3473           case oExitOnStatusWriteError:
3474             opt.exit_on_status_write_error = 1;
3475             break;
3476
3477           case oLimitCardInsertTries:
3478             opt.limit_card_insert_tries = pargs.r.ret_int;
3479             break;
3480
3481           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3482           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3483
3484           case oAutoKeyLocate:
3485             if (default_akl)
3486               {
3487                 /* This is the first time --aito-key-locate is seen.
3488                  * We need to reset the default akl.  */
3489                 default_akl = 0;
3490                 release_akl();
3491               }
3492             if(!parse_auto_key_locate(pargs.r.ret_str))
3493               {
3494                 if(configname)
3495                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3496                             configname,configlineno);
3497                 else
3498                   log_error(_("invalid auto-key-locate list\n"));
3499               }
3500             break;
3501           case oNoAutoKeyLocate:
3502             release_akl();
3503             break;
3504
3505           case oKeyOrigin:
3506             if(!parse_key_origin (pargs.r.ret_str))
3507               log_error (_("invalid argument for option \"%.50s\"\n"),
3508                          "--key-origin");
3509             break;
3510
3511           case oEnableLargeRSA:
3512 #if SECMEM_BUFFER_SIZE >= 65536
3513             opt.flags.large_rsa=1;
3514 #else
3515             if (configname)
3516               log_info("%s:%d: WARNING: gpg not built with large secure "
3517                          "memory buffer.  Ignoring enable-large-rsa\n",
3518                         configname,configlineno);
3519             else
3520               log_info("WARNING: gpg not built with large secure "
3521                          "memory buffer.  Ignoring --enable-large-rsa\n");
3522 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3523             break;
3524           case oDisableLargeRSA: opt.flags.large_rsa=0;
3525             break;
3526
3527           case oEnableDSA2: opt.flags.dsa2=1; break;
3528           case oDisableDSA2: opt.flags.dsa2=0; break;
3529
3530           case oAllowMultisigVerification:
3531           case oAllowMultipleMessages:
3532             opt.flags.allow_multiple_messages=1;
3533             break;
3534
3535           case oNoAllowMultipleMessages:
3536             opt.flags.allow_multiple_messages=0;
3537             break;
3538
3539           case oAllowWeakDigestAlgos:
3540             opt.flags.allow_weak_digest_algos = 1;
3541             break;
3542
3543           case oFakedSystemTime:
3544             {
3545               size_t len = strlen (pargs.r.ret_str);
3546               int freeze = 0;
3547               time_t faked_time;
3548
3549               if (len > 0 && pargs.r.ret_str[len-1] == '!')
3550                 {
3551                   freeze = 1;
3552                   pargs.r.ret_str[len-1] = '\0';
3553                 }
3554
3555               faked_time = isotime2epoch (pargs.r.ret_str);
3556               if (faked_time == (time_t)(-1))
3557                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3558               gnupg_set_time (faked_time, freeze);
3559             }
3560             break;
3561
3562           case oNoAutostart: opt.autostart = 0; break;
3563           case oNoSymkeyCache: opt.no_symkey_cache = 1; break;
3564
3565           case oDefaultNewKeyAlgo:
3566             opt.def_new_key_algo = pargs.r.ret_str;
3567             break;
3568
3569           case oNoop: break;
3570
3571           default:
3572             if (configfp)
3573               pargs.err = ARGPARSE_PRINT_WARNING;
3574             else
3575               {
3576                 pargs.err = ARGPARSE_PRINT_ERROR;
3577                 /* The argparse fucntion calls a plain exit and thus
3578                  * we need to print a status here.  */
3579                 write_status_failure ("option-parser",
3580                                       gpg_error(GPG_ERR_GENERAL));
3581               }
3582             break;
3583           }
3584       }
3585
3586     if (configfp)