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