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