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