c9fa7ae5bd560fcac5294b6250ffa2427cae5c7f
[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     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2371                           | VERIFY_SHOW_POLICY_URLS
2372                           | VERIFY_SHOW_STD_NOTATIONS
2373                           | VERIFY_SHOW_KEYSERVER_URLS);
2374     opt.list_options   = (LIST_SHOW_UID_VALIDITY
2375                           | LIST_SHOW_USAGE);
2376 #ifdef NO_TRUST_MODELS
2377     opt.trust_model = TM_ALWAYS;
2378 #else
2379     opt.trust_model = TM_AUTO;
2380 #endif
2381     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2382     opt.mangle_dos_filenames = 0;
2383     opt.min_cert_level = 2;
2384     set_screen_dimensions ();
2385     opt.keyid_format = KF_NONE;
2386     opt.def_sig_expire = "0";
2387     opt.def_cert_expire = "0";
2388     gnupg_set_homedir (NULL);
2389     opt.passphrase_repeat = 1;
2390     opt.emit_version = 0;
2391     opt.weak_digests = NULL;
2392
2393     /* Check whether we have a config file on the command line.  */
2394     orig_argc = argc;
2395     orig_argv = argv;
2396     pargs.argc = &argc;
2397     pargs.argv = &argv;
2398     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2399     while( arg_parse( &pargs, opts) ) {
2400         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2401             parse_debug++;
2402         else if (pargs.r_opt == oDebugIOLBF)
2403             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2404         else if( pargs.r_opt == oOptions ) {
2405             /* yes there is one, so we do not try the default one, but
2406              * read the option file when it is encountered at the commandline
2407              */
2408             default_config = 0;
2409         }
2410         else if( pargs.r_opt == oNoOptions )
2411           {
2412             default_config = 0; /* --no-options */
2413             opt.no_homedir_creation = 1;
2414           }
2415         else if( pargs.r_opt == oHomedir )
2416             gnupg_set_homedir (pargs.r.ret_str);
2417         else if( pargs.r_opt == oNoPermissionWarn )
2418             opt.no_perm_warn=1;
2419         else if (pargs.r_opt == oStrict )
2420           {
2421             /* Not used */
2422           }
2423         else if (pargs.r_opt == oNoStrict )
2424           {
2425             /* Not used */
2426           }
2427     }
2428
2429 #ifdef HAVE_DOSISH_SYSTEM
2430     if ( strchr (gnupg_homedir (), '\\') ) {
2431       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
2432       const char *s;
2433       for (d=buf, s = gnupg_homedir (); *s; s++)
2434           {
2435             *d++ = *s == '\\'? '/': *s;
2436 #ifdef HAVE_W32_SYSTEM
2437             if (s[1] && IsDBCSLeadByte (*s))
2438               *d++ = *++s;
2439 #endif
2440           }
2441         *d = 0;
2442         gnupg_set_homedir (buf);
2443     }
2444 #endif
2445
2446     /* Initialize the secure memory. */
2447     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2448       got_secmem = 1;
2449 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2450     /* There should be no way to get to this spot while still carrying
2451        setuid privs.  Just in case, bomb out if we are. */
2452     if ( getuid () != geteuid () )
2453       BUG ();
2454 #endif
2455     maybe_setuid = 0;
2456
2457     /* Okay, we are now working under our real uid */
2458
2459     /* malloc hooks go here ... */
2460     malloc_hooks.malloc = gcry_malloc;
2461     malloc_hooks.realloc = gcry_realloc;
2462     malloc_hooks.free = gcry_free;
2463     assuan_set_malloc_hooks (&malloc_hooks);
2464     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2465     setup_libassuan_logging (&opt.debug, NULL);
2466
2467     /* Set default options which require that malloc stuff is ready.  */
2468     additional_weak_digest ("MD5");
2469     parse_auto_key_locate ("local,wkd");
2470
2471     /* Try for a version specific config file first */
2472     default_configname = get_default_configname ();
2473     if (default_config)
2474       configname = xstrdup (default_configname);
2475
2476     argc = orig_argc;
2477     argv = orig_argv;
2478     pargs.argc = &argc;
2479     pargs.argv = &argv;
2480     pargs.flags= ARGPARSE_FLAG_KEEP;
2481
2482     /* By this point we have a homedir, and cannot change it. */
2483     check_permissions (gnupg_homedir (), 0);
2484
2485   next_pass:
2486     if( configname ) {
2487       if(check_permissions(configname,1))
2488         {
2489           /* If any options file is unsafe, then disable any external
2490              programs for keyserver calls or photo IDs.  Since the
2491              external program to call is set in the options file, a
2492              unsafe options file can lead to an arbitrary program
2493              being run. */
2494
2495           opt.exec_disable=1;
2496         }
2497
2498         configlineno = 0;
2499         configfp = fopen( configname, "r" );
2500         if (configfp && is_secured_file (fileno (configfp)))
2501           {
2502             fclose (configfp);
2503             configfp = NULL;
2504             gpg_err_set_errno (EPERM);
2505           }
2506         if( !configfp ) {
2507             if( default_config ) {
2508                 if( parse_debug )
2509                     log_info(_("Note: no default option file '%s'\n"),
2510                                                             configname );
2511             }
2512             else {
2513                 log_error(_("option file '%s': %s\n"),
2514                                     configname, strerror(errno) );
2515                 g10_exit(2);
2516             }
2517             xfree(configname); configname = NULL;
2518         }
2519         if( parse_debug && configname )
2520             log_info(_("reading options from '%s'\n"), configname );
2521         default_config = 0;
2522     }
2523
2524     while( optfile_parse( configfp, configname, &configlineno,
2525                                                 &pargs, opts) )
2526       {
2527         switch( pargs.r_opt )
2528           {
2529           case aListConfig:
2530           case aListGcryptConfig:
2531           case aGPGConfList:
2532           case aGPGConfTest:
2533             set_cmd (&cmd, pargs.r_opt);
2534             /* Do not register a keyring for these commands.  */
2535             default_keyring = -1;
2536             break;
2537
2538           case aCheckKeys:
2539           case aListPackets:
2540           case aImport:
2541           case aFastImport:
2542           case aSendKeys:
2543           case aRecvKeys:
2544           case aSearchKeys:
2545           case aRefreshKeys:
2546           case aFetchKeys:
2547           case aExport:
2548 #ifdef ENABLE_CARD_SUPPORT
2549           case aCardStatus:
2550           case aCardEdit:
2551           case aChangePIN:
2552 #endif /* ENABLE_CARD_SUPPORT*/
2553           case aListKeys:
2554           case aLocateKeys:
2555           case aListSigs:
2556           case aExportSecret:
2557           case aExportSecretSub:
2558           case aExportSshKey:
2559           case aSym:
2560           case aClearsign:
2561           case aGenRevoke:
2562           case aDesigRevoke:
2563           case aPrimegen:
2564           case aGenRandom:
2565           case aPrintMD:
2566           case aPrintMDs:
2567           case aListTrustDB:
2568           case aCheckTrustDB:
2569           case aUpdateTrustDB:
2570           case aFixTrustDB:
2571           case aListTrustPath:
2572           case aDeArmor:
2573           case aEnArmor:
2574           case aSign:
2575           case aQuickSignKey:
2576           case aQuickLSignKey:
2577           case aSignKey:
2578           case aLSignKey:
2579           case aStore:
2580           case aQuickKeygen:
2581           case aQuickAddUid:
2582           case aQuickAddKey:
2583           case aQuickRevUid:
2584           case aQuickSetExpire:
2585           case aQuickSetPrimaryUid:
2586           case aExportOwnerTrust:
2587           case aImportOwnerTrust:
2588           case aRebuildKeydbCaches:
2589             set_cmd (&cmd, pargs.r_opt);
2590             break;
2591
2592           case aKeygen:
2593           case aFullKeygen:
2594           case aEditKey:
2595           case aDeleteSecretKeys:
2596           case aDeleteSecretAndPublicKeys:
2597           case aDeleteKeys:
2598           case aPasswd:
2599             set_cmd (&cmd, pargs.r_opt);
2600             greeting=1;
2601             break;
2602
2603           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2604
2605           case aDecryptFiles: multifile=1; /* fall through */
2606           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2607
2608           case aEncrFiles: multifile=1; /* fall through */
2609           case aEncr: set_cmd( &cmd, aEncr); break;
2610
2611           case aVerifyFiles: multifile=1; /* fall through */
2612           case aVerify: set_cmd( &cmd, aVerify); break;
2613
2614           case aServer:
2615             set_cmd (&cmd, pargs.r_opt);
2616             opt.batch = 1;
2617             break;
2618
2619           case aTOFUPolicy:
2620             set_cmd (&cmd, pargs.r_opt);
2621             break;
2622
2623           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2624           case oOutput: opt.outfile = pargs.r.ret_str; break;
2625
2626           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2627
2628           case oInputSizeHint:
2629             opt.input_size_hint = string_to_u64 (pargs.r.ret_str);
2630             break;
2631
2632           case oQuiet: opt.quiet = 1; break;
2633           case oNoTTY: tty_no_terminal(1); break;
2634           case oDryRun: opt.dry_run = 1; break;
2635           case oInteractive: opt.interactive = 1; break;
2636           case oVerbose:
2637             opt.verbose++;
2638             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2639             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2640             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2641             break;
2642
2643           case oBatch:
2644             opt.batch = 1;
2645             nogreeting = 1;
2646             break;
2647
2648           case oUseAgent: /* Dummy. */
2649             break;
2650
2651           case oNoUseAgent:
2652             obsolete_option (configname, configlineno, "no-use-agent");
2653             break;
2654           case oGpgAgentInfo:
2655             obsolete_option (configname, configlineno, "gpg-agent-info");
2656             break;
2657           case oReaderPort:
2658             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2659             break;
2660           case octapiDriver:
2661             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2662             break;
2663           case opcscDriver:
2664             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2665             break;
2666           case oDisableCCID:
2667             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2668             break;
2669           case oHonorHttpProxy:
2670             obsolete_option (configname, configlineno, "honor-http-proxy");
2671             break;
2672
2673           case oAnswerYes: opt.answer_yes = 1; break;
2674           case oAnswerNo: opt.answer_no = 1; break;
2675           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2676           case oPrimaryKeyring:
2677             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2678             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2679             break;
2680           case oShowKeyring:
2681             deprecated_warning(configname,configlineno,"--show-keyring",
2682                                "--list-options ","show-keyring");
2683             opt.list_options|=LIST_SHOW_KEYRING;
2684             break;
2685
2686           case oDebug:
2687             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2688               {
2689                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2690                 pargs.err = ARGPARSE_PRINT_ERROR;
2691               }
2692             break;
2693
2694           case oDebugAll: opt.debug = ~0; break;
2695           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2696
2697           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2698
2699           case oStatusFD:
2700             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2701             break;
2702           case oStatusFile:
2703             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2704             break;
2705           case oAttributeFD:
2706             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2707             break;
2708           case oAttributeFile:
2709             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2710             break;
2711           case oLoggerFD:
2712             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2713             break;
2714           case oLoggerFile:
2715             logfile = pargs.r.ret_str;
2716             break;
2717
2718           case oWithFingerprint:
2719             opt.with_fingerprint = 1;
2720             opt.fingerprint++;
2721             break;
2722           case oWithSubkeyFingerprint:
2723             opt.with_subkey_fingerprint = 1;
2724             break;
2725           case oWithICAOSpelling:
2726             opt.with_icao_spelling = 1;
2727             break;
2728           case oFingerprint:
2729             opt.fingerprint++;
2730             fpr_maybe_cmd = 1;
2731             break;
2732
2733           case oWithKeygrip:
2734             opt.with_keygrip = 1;
2735             break;
2736
2737           case oWithSecret:
2738             opt.with_secret = 1;
2739             break;
2740
2741           case oWithWKDHash:
2742             opt.with_wkd_hash = 1;
2743             break;
2744
2745           case oWithKeyOrigin:
2746             opt.with_key_origin = 1;
2747             break;
2748
2749           case oSecretKeyring:
2750             /* Ignore this old option.  */
2751             break;
2752
2753           case oOptions:
2754             /* config files may not be nested (silently ignore them) */
2755             if( !configfp ) {
2756                 xfree(configname);
2757                 configname = xstrdup(pargs.r.ret_str);
2758                 goto next_pass;
2759             }
2760             break;
2761           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2762
2763           case oNoDefKeyring:
2764             if (default_keyring > 0)
2765               default_keyring = 0;
2766             break;
2767           case oNoKeyring:
2768             default_keyring = -1;
2769             break;
2770
2771           case oNoGreeting: nogreeting = 1; break;
2772           case oNoVerbose:
2773             opt.verbose = 0;
2774             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2775             opt.list_sigs=0;
2776             break;
2777           case oQuickRandom:
2778             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2779             break;
2780           case oEmitVersion: opt.emit_version++; break;
2781           case oNoEmitVersion: opt.emit_version=0; break;
2782           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2783           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2784           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2785
2786 #ifndef NO_TRUST_MODELS
2787           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2788
2789 #endif /*!NO_TRUST_MODELS*/
2790           case oDefaultKey:
2791             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2792             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2793             if (configfp)
2794               sl->flags |= PK_LIST_CONFIG;
2795             break;
2796           case oDefRecipient:
2797             if( *pargs.r.ret_str )
2798               {
2799                 xfree (opt.def_recipient);
2800                 opt.def_recipient = make_username(pargs.r.ret_str);
2801               }
2802             break;
2803           case oDefRecipientSelf:
2804             xfree(opt.def_recipient); opt.def_recipient = NULL;
2805             opt.def_recipient_self = 1;
2806             break;
2807           case oNoDefRecipient:
2808             xfree(opt.def_recipient); opt.def_recipient = NULL;
2809             opt.def_recipient_self = 0;
2810             break;
2811           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2812           case oHomedir: break;
2813           case oNoBatch: opt.batch = 0; break;
2814
2815           case oWithTofuInfo: opt.with_tofu_info = 1; break;
2816
2817           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2818           case oWithColons: opt.with_colons=':'; break;
2819
2820           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2821           case oWithSigList: opt.list_sigs = 1; break;
2822
2823           case oSkipVerify: opt.skip_verify=1; break;
2824
2825           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2826           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2827
2828           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2829
2830 #ifndef NO_TRUST_MODELS
2831             /* There are many programs (like mutt) that call gpg with
2832                --always-trust so keep this option around for a long
2833                time. */
2834           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2835           case oTrustModel:
2836             parse_trust_model(pargs.r.ret_str);
2837             break;
2838 #endif /*!NO_TRUST_MODELS*/
2839           case oTOFUDefaultPolicy:
2840             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2841             break;
2842           case oTOFUDBFormat:
2843             obsolete_option (configname, configlineno, "tofu-db-format");
2844             break;
2845
2846           case oForceOwnertrust:
2847             log_info(_("Note: %s is not for normal use!\n"),
2848                      "--force-ownertrust");
2849             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2850             if(opt.force_ownertrust==-1)
2851               {
2852                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2853                 opt.force_ownertrust=0;
2854               }
2855             break;
2856           case oLoadExtension:
2857             /* Dummy so that gpg 1.4 conf files can work. Should
2858                eventually be removed.  */
2859             break;
2860
2861           case oCompliance:
2862             {
2863               int compliance = gnupg_parse_compliance_option
2864                 (pargs.r.ret_str,
2865                  compliance_options, DIM (compliance_options),
2866                  opt.quiet);
2867               if (compliance < 0)
2868                 g10_exit (1);
2869               set_compliance_option (compliance);
2870             }
2871             break;
2872           case oOpenPGP:
2873           case oRFC2440:
2874           case oRFC4880:
2875           case oRFC4880bis:
2876           case oPGP6:
2877           case oPGP7:
2878           case oPGP8:
2879           case oGnuPG:
2880             set_compliance_option (pargs.r_opt);
2881             break;
2882
2883           case oRFC2440Text: opt.rfc2440_text=1; break;
2884           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2885
2886           case oSetFilename:
2887             if(utf8_strings)
2888               opt.set_filename = pargs.r.ret_str;
2889             else
2890               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2891             break;
2892           case oForYourEyesOnly: eyes_only = 1; break;
2893           case oNoForYourEyesOnly: eyes_only = 0; break;
2894           case oSetPolicyURL:
2895             add_policy_url(pargs.r.ret_str,0);
2896             add_policy_url(pargs.r.ret_str,1);
2897             break;
2898           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2899           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2900           case oShowPolicyURL:
2901             deprecated_warning(configname,configlineno,"--show-policy-url",
2902                                "--list-options ","show-policy-urls");
2903             deprecated_warning(configname,configlineno,"--show-policy-url",
2904                                "--verify-options ","show-policy-urls");
2905             opt.list_options|=LIST_SHOW_POLICY_URLS;
2906             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2907             break;
2908           case oNoShowPolicyURL:
2909             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2910                                "--list-options ","no-show-policy-urls");
2911             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2912                                "--verify-options ","no-show-policy-urls");
2913             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2914             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2915             break;
2916           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2917           case oUseEmbeddedFilename:
2918             opt.flags.use_embedded_filename=1;
2919             break;
2920           case oNoUseEmbeddedFilename:
2921             opt.flags.use_embedded_filename=0;
2922             break;
2923           case oComment:
2924             if(pargs.r.ret_str[0])
2925               append_to_strlist(&opt.comments,pargs.r.ret_str);
2926             break;
2927           case oDefaultComment:
2928             deprecated_warning(configname,configlineno,
2929                                "--default-comment","--no-comments","");
2930             /* fall through */
2931           case oNoComments:
2932             free_strlist(opt.comments);
2933             opt.comments=NULL;
2934             break;
2935           case oThrowKeyids: opt.throw_keyids = 1; break;
2936           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2937           case oShowPhotos:
2938             deprecated_warning(configname,configlineno,"--show-photos",
2939                                "--list-options ","show-photos");
2940             deprecated_warning(configname,configlineno,"--show-photos",
2941                                "--verify-options ","show-photos");
2942             opt.list_options|=LIST_SHOW_PHOTOS;
2943             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2944             break;
2945           case oNoShowPhotos:
2946             deprecated_warning(configname,configlineno,"--no-show-photos",
2947                                "--list-options ","no-show-photos");
2948             deprecated_warning(configname,configlineno,"--no-show-photos",
2949                                "--verify-options ","no-show-photos");
2950             opt.list_options&=~LIST_SHOW_PHOTOS;
2951             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2952             break;
2953           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2954
2955           case oForceMDC: opt.force_mdc = 1; break;
2956           case oNoForceMDC: opt.force_mdc = 0; break;
2957           case oDisableMDC: opt.disable_mdc = 1; break;
2958           case oNoDisableMDC: opt.disable_mdc = 0; break;
2959
2960           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
2961
2962           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2963           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2964           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2965           case oS2KCount:
2966             if (pargs.r.ret_int)
2967               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2968             else
2969               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2970             break;
2971
2972           case oRecipient:
2973           case oHiddenRecipient:
2974           case oRecipientFile:
2975           case oHiddenRecipientFile:
2976             /* Store the recipient.  Note that we also store the
2977              * option as private data in the flags.  This is achieved
2978              * by shifting the option value to the left so to keep
2979              * enough space for the flags.  */
2980             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2981             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2982             if (configfp)
2983               sl->flags |= PK_LIST_CONFIG;
2984             if (pargs.r_opt == oHiddenRecipient
2985                 || pargs.r_opt == oHiddenRecipientFile)
2986               sl->flags |= PK_LIST_HIDDEN;
2987             if (pargs.r_opt == oRecipientFile
2988                 || pargs.r_opt == oHiddenRecipientFile)
2989               sl->flags |= PK_LIST_FROM_FILE;
2990             any_explicit_recipient = 1;
2991             break;
2992
2993           case oEncryptTo:
2994           case oHiddenEncryptTo:
2995             /* Store an additional recipient.  */
2996             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2997             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
2998             if (configfp)
2999               sl->flags |= PK_LIST_CONFIG;
3000             if (pargs.r_opt == oHiddenEncryptTo)
3001               sl->flags |= PK_LIST_HIDDEN;
3002             break;
3003
3004           case oNoEncryptTo:
3005             opt.no_encrypt_to = 1;
3006             break;
3007           case oEncryptToDefaultKey:
3008             opt.encrypt_to_default_key = configfp ? 2 : 1;
3009             break;
3010
3011           case oTrySecretKey:
3012             add_to_strlist2 (&opt.secret_keys_to_try,
3013                              pargs.r.ret_str, utf8_strings);
3014             break;
3015
3016           case oMimemode: opt.mimemode = opt.textmode = 1; break;
3017           case oTextmodeShort: opt.textmode = 2; break;
3018           case oTextmode: opt.textmode=1;  break;
3019           case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
3020
3021           case oExpert: opt.expert = 1; break;
3022           case oNoExpert: opt.expert = 0; break;
3023           case oDefSigExpire:
3024             if(*pargs.r.ret_str!='\0')
3025               {
3026                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3027                   log_error(_("'%s' is not a valid signature expiration\n"),
3028                             pargs.r.ret_str);
3029                 else
3030                   opt.def_sig_expire=pargs.r.ret_str;
3031               }
3032             break;
3033           case oAskSigExpire: opt.ask_sig_expire = 1; break;
3034           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
3035           case oDefCertExpire:
3036             if(*pargs.r.ret_str!='\0')
3037               {
3038                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3039                   log_error(_("'%s' is not a valid signature expiration\n"),
3040                             pargs.r.ret_str);
3041                 else
3042                   opt.def_cert_expire=pargs.r.ret_str;
3043               }
3044             break;
3045           case oAskCertExpire: opt.ask_cert_expire = 1; break;
3046           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
3047           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
3048           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
3049           case oAskCertLevel: opt.ask_cert_level = 1; break;
3050           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
3051           case oLocalUser: /* store the local users */
3052             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
3053             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3054             if (configfp)
3055               sl->flags |= PK_LIST_CONFIG;
3056             break;
3057           case oSender:
3058             {
3059               char *mbox = mailbox_from_userid (pargs.r.ret_str);
3060               if (!mbox)
3061                 log_error (_("\"%s\" is not a proper mail address\n"),
3062                            pargs.r.ret_str);
3063               else
3064                 {
3065                   add_to_strlist (&opt.sender_list, mbox);
3066                   xfree (mbox);
3067                 }
3068             }
3069             break;
3070           case oCompress:
3071             /* this is the -z command line option */
3072             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
3073             break;
3074           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
3075           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
3076           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3077           case oPassphrase:
3078             set_passphrase_from_string(pargs.r.ret_str);
3079             break;
3080           case oPassphraseFD:
3081             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3082             break;
3083           case oPassphraseFile:
3084             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3085             break;
3086           case oPassphraseRepeat:
3087             opt.passphrase_repeat = pargs.r.ret_int;
3088             break;
3089
3090           case oPinentryMode:
3091             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3092             if (opt.pinentry_mode == -1)
3093               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3094             break;
3095
3096           case oCommandFD:
3097             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3098             if (! gnupg_fd_valid (opt.command_fd))
3099               log_fatal ("command-fd is invalid: %s\n", strerror (errno));
3100             break;
3101           case oCommandFile:
3102             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3103             break;
3104           case oCipherAlgo:
3105             def_cipher_string = xstrdup(pargs.r.ret_str);
3106             break;
3107           case oDigestAlgo:
3108             def_digest_string = xstrdup(pargs.r.ret_str);
3109             break;
3110           case oCompressAlgo:
3111             /* If it is all digits, stick a Z in front of it for
3112                later.  This is for backwards compatibility with
3113                versions that took the compress algorithm number. */
3114             {
3115               char *pt=pargs.r.ret_str;
3116               while(*pt)
3117                 {
3118                   if (!isascii (*pt) || !isdigit (*pt))
3119                     break;
3120
3121                   pt++;
3122                 }
3123
3124               if(*pt=='\0')
3125                 {
3126                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3127                   strcpy(compress_algo_string,"Z");
3128                   strcat(compress_algo_string,pargs.r.ret_str);
3129                 }
3130               else
3131                 compress_algo_string = xstrdup(pargs.r.ret_str);
3132             }
3133             break;
3134           case oCertDigestAlgo:
3135             cert_digest_string = xstrdup(pargs.r.ret_str);
3136             break;
3137
3138           case oNoSecmemWarn:
3139             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3140             break;
3141
3142           case oRequireSecmem: require_secmem=1; break;
3143           case oNoRequireSecmem: require_secmem=0; break;
3144           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3145           case oNoMDCWarn: opt.no_mdc_warn=1; break;
3146           case oDisplayCharset:
3147             if( set_native_charset( pargs.r.ret_str ) )
3148                 log_error(_("'%s' is not a valid character set\n"),
3149                           pargs.r.ret_str);
3150             break;
3151           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3152           case oEscapeFrom: opt.escape_from = 1; break;
3153           case oNoEscapeFrom: opt.escape_from = 0; break;
3154           case oLockOnce: opt.lock_once = 1; break;
3155           case oLockNever:
3156             dotlock_disable ();
3157             break;
3158           case oLockMultiple:
3159 #ifndef __riscos__
3160             opt.lock_once = 0;
3161 #else /* __riscos__ */
3162             riscos_not_implemented("lock-multiple");
3163 #endif /* __riscos__ */
3164             break;
3165           case oKeyServer:
3166             {
3167               keyserver_spec_t keyserver;
3168               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3169               if (!keyserver)
3170                 log_error (_("could not parse keyserver URL\n"));
3171               else
3172                 {
3173                   /* We only support a single keyserver.  Later ones
3174                      override earlier ones.  (Since we parse the
3175                      config file first and then the command line
3176                      arguments, the command line takes
3177                      precedence.)  */
3178                   if (opt.keyserver)
3179                     free_keyserver_spec (opt.keyserver);
3180                   opt.keyserver = keyserver;
3181                 }
3182             }
3183             break;
3184           case oKeyServerOptions:
3185             if(!parse_keyserver_options(pargs.r.ret_str))
3186               {
3187                 if(configname)
3188                   log_error(_("%s:%d: invalid keyserver options\n"),
3189                             configname,configlineno);
3190                 else
3191                   log_error(_("invalid keyserver options\n"));
3192               }
3193             break;
3194           case oImportOptions:
3195             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3196               {
3197                 if(configname)
3198                   log_error(_("%s:%d: invalid import options\n"),
3199                             configname,configlineno);
3200                 else
3201                   log_error(_("invalid import options\n"));
3202               }
3203             break;
3204           case oImportFilter:
3205             rc = parse_and_set_import_filter (pargs.r.ret_str);
3206             if (rc)
3207               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3208             break;
3209           case oExportOptions:
3210             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3211               {
3212                 if(configname)
3213                   log_error(_("%s:%d: invalid export options\n"),
3214                             configname,configlineno);
3215                 else
3216                   log_error(_("invalid export options\n"));
3217               }
3218             break;
3219           case oExportFilter:
3220             rc = parse_and_set_export_filter (pargs.r.ret_str);
3221             if (rc)
3222               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3223             break;
3224           case oListOptions:
3225             if(!parse_list_options(pargs.r.ret_str))
3226               {
3227                 if(configname)
3228                   log_error(_("%s:%d: invalid list options\n"),
3229                             configname,configlineno);
3230                 else
3231                   log_error(_("invalid list options\n"));
3232               }
3233             break;
3234           case oVerifyOptions:
3235             {
3236               struct parse_options vopts[]=
3237                 {
3238                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3239                    N_("display photo IDs during signature verification")},
3240                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3241                    N_("show policy URLs during signature verification")},
3242                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3243                    N_("show all notations during signature verification")},
3244                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3245                    N_("show IETF standard notations during signature verification")},
3246                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3247                    NULL},
3248                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3249                    N_("show user-supplied notations during signature verification")},
3250                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3251                    N_("show preferred keyserver URLs during signature verification")},
3252                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3253                    N_("show user ID validity during signature verification")},
3254                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3255                    N_("show revoked and expired user IDs in signature verification")},
3256                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3257                    N_("show only the primary user ID in signature verification")},
3258                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3259                    N_("validate signatures with PKA data")},
3260                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3261                    N_("elevate the trust of signatures with valid PKA data")},
3262                   {NULL,0,NULL,NULL}
3263                 };
3264
3265               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3266                 {
3267                   if(configname)
3268                     log_error(_("%s:%d: invalid verify options\n"),
3269                               configname,configlineno);
3270                   else
3271                     log_error(_("invalid verify options\n"));
3272                 }
3273             }
3274             break;
3275           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3276           case oExecPath:
3277             if(set_exec_path(pargs.r.ret_str))
3278               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3279             else
3280               opt.exec_path_set=1;
3281             break;
3282           case oSetNotation:
3283             add_notation_data( pargs.r.ret_str, 0 );
3284             add_notation_data( pargs.r.ret_str, 1 );
3285             break;
3286           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3287           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3288           case oShowNotation:
3289             deprecated_warning(configname,configlineno,"--show-notation",
3290                                "--list-options ","show-notations");
3291             deprecated_warning(configname,configlineno,"--show-notation",
3292                                "--verify-options ","show-notations");
3293             opt.list_options|=LIST_SHOW_NOTATIONS;
3294             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3295             break;
3296           case oNoShowNotation:
3297             deprecated_warning(configname,configlineno,"--no-show-notation",
3298                                "--list-options ","no-show-notations");
3299             deprecated_warning(configname,configlineno,"--no-show-notation",
3300                                "--verify-options ","no-show-notations");
3301             opt.list_options&=~LIST_SHOW_NOTATIONS;
3302             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3303             break;
3304           case oUtf8Strings: utf8_strings = 1; break;
3305           case oNoUtf8Strings: utf8_strings = 0; break;
3306           case oDisableCipherAlgo:
3307             {
3308               int algo = string_to_cipher_algo (pargs.r.ret_str);
3309               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3310             }
3311             break;
3312           case oDisablePubkeyAlgo:
3313             {
3314               int algo = gcry_pk_map_name (pargs.r.ret_str);
3315               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3316             }
3317             break;
3318           case oNoSigCache: opt.no_sig_cache = 1; break;
3319           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3320           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3321           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3322           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3323           case oNoLiteral: opt.no_literal = 1; break;
3324           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3325           case oFastListMode: opt.fast_list_mode = 1; break;
3326           case oFixedListMode: /* Dummy */ break;
3327           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3328           case oPrintPKARecords: print_pka_records = 1; break;
3329           case oPrintDANERecords: print_dane_records = 1; break;
3330           case oListOnly: opt.list_only=1; break;
3331           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3332           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3333           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3334           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3335           case oNoRandomSeedFile: use_random_seed = 0; break;
3336           case oAutoKeyRetrieve:
3337           case oNoAutoKeyRetrieve:
3338                 if(pargs.r_opt==oAutoKeyRetrieve)
3339                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
3340                 else
3341                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
3342                 break;
3343           case oShowSessionKey: opt.show_session_key = 1; break;
3344           case oOverrideSessionKey:
3345                 opt.override_session_key = pargs.r.ret_str;
3346                 break;
3347           case oOverrideSessionKeyFD:
3348                 ovrseskeyfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3349                 break;
3350           case oMergeOnly:
3351                 deprecated_warning(configname,configlineno,"--merge-only",
3352                                    "--import-options ","merge-only");
3353                 opt.import_options|=IMPORT_MERGE_ONLY;
3354             break;
3355           case oAllowSecretKeyImport: /* obsolete */ break;
3356           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3357           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3358
3359           case oEnableSpecialFilenames:
3360             enable_special_filenames ();
3361             break;
3362
3363           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3364           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3365           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3366           case oPreservePermissions: opt.preserve_permissions=1; break;
3367           case oDefaultPreferenceList:
3368             opt.def_preference_list = pargs.r.ret_str;
3369             break;
3370           case oDefaultKeyserverURL:
3371             {
3372               keyserver_spec_t keyserver;
3373               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3374               if (!keyserver)
3375                 log_error (_("could not parse keyserver URL\n"));
3376               else
3377                 free_keyserver_spec (keyserver);
3378
3379               opt.def_keyserver_url = pargs.r.ret_str;
3380             }
3381             break;
3382           case oPersonalCipherPreferences:
3383             pers_cipher_list=pargs.r.ret_str;
3384             break;
3385           case oPersonalDigestPreferences:
3386             pers_digest_list=pargs.r.ret_str;
3387             break;
3388           case oPersonalCompressPreferences:
3389             pers_compress_list=pargs.r.ret_str;
3390             break;
3391           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3392           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3393           case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
3394           case oWeakDigest:
3395             additional_weak_digest(pargs.r.ret_str);
3396             break;
3397           case oUnwrap:
3398             opt.unwrap_encryption = 1;
3399             break;
3400           case oOnlySignTextIDs:
3401             opt.only_sign_text_ids = 1;
3402             break;
3403
3404           case oDisplay:
3405             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3406             break;
3407           case oTTYname:
3408             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3409             break;
3410           case oTTYtype:
3411             set_opt_session_env ("TERM", pargs.r.ret_str);
3412             break;
3413           case oXauthority:
3414             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3415             break;
3416
3417           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3418           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3419
3420           case oGroup: add_group(pargs.r.ret_str); break;
3421           case oUnGroup: rm_group(pargs.r.ret_str); break;
3422           case oNoGroups:
3423             while(opt.grouplist)
3424               {
3425                 struct groupitem *iter=opt.grouplist;
3426                 free_strlist(iter->values);
3427                 opt.grouplist=opt.grouplist->next;
3428                 xfree(iter);
3429               }
3430             break;
3431
3432           case oStrict:
3433           case oNoStrict:
3434             /* Not used */
3435             break;
3436
3437           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3438           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3439           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3440           case oMultifile: multifile=1; break;
3441           case oKeyidFormat:
3442             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3443               opt.keyid_format=KF_SHORT;
3444             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3445               opt.keyid_format=KF_LONG;
3446             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3447               opt.keyid_format=KF_0xSHORT;
3448             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3449               opt.keyid_format=KF_0xLONG;
3450             else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
3451               opt.keyid_format = KF_NONE;
3452             else
3453               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3454             break;
3455
3456           case oExitOnStatusWriteError:
3457             opt.exit_on_status_write_error = 1;
3458             break;
3459
3460           case oLimitCardInsertTries:
3461             opt.limit_card_insert_tries = pargs.r.ret_int;
3462             break;
3463
3464           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3465           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3466
3467           case oAutoKeyLocate:
3468             if (default_akl)
3469               {
3470                 /* This is the first time --aito-key-locate is seen.
3471                  * We need to reset the default akl.  */
3472                 default_akl = 0;
3473                 release_akl();
3474               }
3475             if(!parse_auto_key_locate(pargs.r.ret_str))
3476               {
3477                 if(configname)
3478                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3479                             configname,configlineno);
3480                 else
3481                   log_error(_("invalid auto-key-locate list\n"));
3482               }
3483             break;
3484           case oNoAutoKeyLocate:
3485             release_akl();
3486             break;
3487
3488           case oKeyOrigin:
3489             if(!parse_key_origin (pargs.r.ret_str))
3490               log_error (_("invalid argument for option \"%.50s\"\n"),
3491                          "--key-origin");
3492             break;
3493
3494           case oEnableLargeRSA:
3495 #if SECMEM_BUFFER_SIZE >= 65536
3496             opt.flags.large_rsa=1;
3497 #else
3498             if (configname)
3499               log_info("%s:%d: WARNING: gpg not built with large secure "
3500                          "memory buffer.  Ignoring enable-large-rsa\n",
3501                         configname,configlineno);
3502             else
3503               log_info("WARNING: gpg not built with large secure "
3504                          "memory buffer.  Ignoring --enable-large-rsa\n");
3505 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3506             break;
3507           case oDisableLargeRSA: opt.flags.large_rsa=0;
3508             break;
3509
3510           case oEnableDSA2: opt.flags.dsa2=1; break;
3511           case oDisableDSA2: opt.flags.dsa2=0; break;
3512
3513           case oAllowMultisigVerification:
3514           case oAllowMultipleMessages:
3515             opt.flags.allow_multiple_messages=1;
3516             break;
3517
3518           case oNoAllowMultipleMessages:
3519             opt.flags.allow_multiple_messages=0;
3520             break;
3521
3522           case oAllowWeakDigestAlgos:
3523             opt.flags.allow_weak_digest_algos = 1;
3524             break;
3525
3526           case oFakedSystemTime:
3527             {
3528               size_t len = strlen (pargs.r.ret_str);
3529               int freeze = 0;
3530               time_t faked_time;
3531
3532               if (len > 0 && pargs.r.ret_str[len-1] == '!')
3533                 {
3534                   freeze = 1;
3535                   pargs.r.ret_str[len-1] = '\0';
3536                 }
3537
3538               faked_time = isotime2epoch (pargs.r.ret_str);
3539               if (faked_time == (time_t)(-1))
3540                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3541               gnupg_set_time (faked_time, freeze);
3542             }
3543             break;
3544
3545           case oNoAutostart: opt.autostart = 0; break;
3546
3547           case oDefaultNewKeyAlgo:
3548             opt.def_new_key_algo = pargs.r.ret_str;
3549             break;
3550
3551           case oNoop: break;
3552
3553           default:
3554             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3555             break;
3556           }
3557       }
3558
3559     if (configfp)
3560       {
3561         fclose( configfp );
3562         configfp = NULL;
3563         /* Remember the first config file name. */
3564         if (!save_configname)
3565           save_configname = configname;
3566         else
3567           xfree(configname);
3568         configname = NULL;
3569         goto next_pass;
3570       }
3571     xfree(configname); configname = NULL;
3572     if (log_get_errorcount (0))
3573       g10_exit(2);
3574
3575     /* The command --gpgconf-list is pretty simple and may be called
3576        directly after the option parsing. */
3577     if (cmd == aGPGConfList)
3578       {
3579         gpgconf_list (save_configname ? save_configname : default_configname);
3580         g10_exit (0);
3581       }
3582     xfree (save_configname);
3583     xfree (default_configname);
3584
3585     if (print_dane_records)
3586       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3587                  "--print-dane-records",
3588                  "--export-options export-dane");
3589     if (print_pka_records)
3590       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3591                  "--print-pks-records",
3592                  "--export-options export-pka");
3593     if (log_get_errorcount (0))
3594       g10_exit(2);
3595
3596
3597     if( nogreeting )
3598         greeting = 0;
3599
3600     if( greeting )
3601       {
3602         es_fprintf (es_stderr, "%s %s; %s\n",
3603                     strusage(11), strusage(13), strusage(14) );
3604         es_fprintf (es_stderr, "%s\n", strusage(15) );
3605       }
3606 #ifdef IS_DEVELOPMENT_VERSION
3607     if (!opt.batch)
3608       {
3609         const char *s;
3610
3611         if((s=strusage(25)))
3612           log_info("%s\n",s);
3613         if((s=strusage(26)))
3614           log_info("%s\n",s);
3615         if((s=strusage(27)))
3616           log_info("%s\n",s);
3617       }
3618 #endif
3619
3620     /* FIXME: We should use logging to a file only in server mode;
3621        however we have not yet implemetyed that.  Thus we try to get
3622        away with --batch as indication for logging to file
3623        required. */
3624     if (logfile && opt.batch)
3625       {
3626         log_set_file (logfile);
3627         log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
3628       }
3629
3630     if (opt.verbose > 2)
3631         log_info ("using character set '%s'\n", get_native_charset ());
3632
3633     if( may_coredump && !opt.quiet )
3634         log_info(_("WARNING: program may create a core file!\n"));
3635
3636     if (opt.flags.rfc4880bis)
3637         log_info ("WARNING: using experimental features from RFC4880bis!\n");
3638     else
3639       {
3640         opt.mimemode = 0; /* This will use text mode instead.  */
3641       }
3642
3643     if (eyes_only) {
3644       if (opt.set_filename)
3645           log_info(_("WARNING: %s overrides %s\n"),
3646                    "--for-your-eyes-only","--set-filename");
3647
3648       opt.set_filename="_CONSOLE";
3649     }
3650
3651     if (opt.no_literal) {
3652         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3653         if (opt.textmode)
3654             log_error(_("%s not allowed with %s!\n"),
3655                        "--textmode", "--no-literal" );
3656         if (opt.set_filename)
3657             log_error(_("%s makes no sense with %s!\n"),
3658                         eyes_only?"--for-your-eyes-only":"--set-filename",
3659                         "--no-literal" );
3660     }
3661
3662
3663     if (opt.set_filesize)
3664         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3665     if( opt.batch )
3666         tty_batchmode( 1 );
3667
3668     if (gnupg_faked_time_p ())
3669       {
3670         gnupg_isotime_t tbuf;
3671
3672         log_info (_("WARNING: running with faked system time: "));
3673         gnupg_get_isotime (tbuf);
3674         dump_isotime (tbuf);
3675         log_printf ("\n");
3676       }
3677
3678     /* Print a warning if an argument looks like an option.  */
3679     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3680       {
3681         int i;
3682
3683         for (i=0; i < argc; i++)
3684           if (argv[i][0] == '-' && argv[i][1] == '-')
3685             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3686       }
3687
3688
3689     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3690
3691     if(require_secmem && !got_secmem)
3692       {
3693         log_info(_("will not run with insecure memory due to %s\n"),
3694                  "--require-secmem");
3695         g10_exit(2);
3696       }
3697
3698     set_debug (debug_level);
3699     if (DBG_CLOCK)
3700       log_clock ("start");
3701
3702     /* Do these after the switch(), so they can override settings. */
3703     if(PGP6)
3704       {
3705         /* That does not anymore work because we have no more support
3706            for v3 signatures.  */
3707         opt.disable_mdc=1;
3708         opt.escape_from=1;
3709         opt.ask_sig_expire=0;
3710       }
3711     else if(PGP7)
3712       {
3713         /* That does not anymore work because we have no more support
3714            for v3 signatures.  */
3715         opt.escape_from=1;
3716         opt.ask_sig_expire=0;
3717       }
3718     else if(PGP8)
3719       {
3720         opt.escape_from=1;
3721       }
3722
3723
3724     if( def_cipher_string ) {
3725         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3726         xfree(def_cipher_string); def_cipher_string = NULL;
3727         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3728             log_error(_("selected cipher algorithm is invalid\n"));
3729     }
3730     if( def_digest_string ) {
3731         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3732         xfree(def_digest_string); def_digest_string = NULL;
3733         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3734             log_error(_("selected digest algorithm is invalid\n"));
3735     }
3736     if( compress_algo_string ) {
3737         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3738         xfree(compress_algo_string); compress_algo_string = NULL;
3739         if( check_compress_algo(opt.compress_algo) )
3740           log_error(_("selected compression algorithm is invalid\n"));
3741     }
3742     if( cert_digest_string ) {
3743         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3744         xfree(cert_digest_string); cert_digest_string = NULL;
3745         if (openpgp_md_test_algo(opt.cert_digest_algo))
3746           log_error(_("selected certification digest algorithm is invalid\n"));
3747     }
3748     if( s2k_cipher_string ) {
3749         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3750         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3751         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3752           log_error(_("selected cipher algorithm is invalid\n"));
3753     }
3754     if( s2k_digest_string ) {
3755         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3756         xfree(s2k_digest_string); s2k_digest_string = NULL;
3757         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3758           log_error(_("selected digest algorithm is invalid\n"));
3759     }
3760     if( opt.completes_needed < 1 )
3761       log_error(_("completes-needed must be greater than 0\n"));
3762     if( opt.marginals_needed < 2 )
3763       log_error(_("marginals-needed must be greater than 1\n"));
3764     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3765       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3766     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3767       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3768     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3769       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3770     switch( opt.s2k_mode ) {
3771       case 0:
3772         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3773         break;
3774       case 1: case 3: break;
3775       default:
3776         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3777     }
3778
3779     /* This isn't actually needed, but does serve to error out if the
3780        string is invalid. */
3781     if(opt.def_preference_list &&
3782         keygen_set_std_prefs(opt.def_preference_list,0))
3783       log_error(_("invalid default preferences\n"));
3784
3785     if(pers_cipher_list &&
3786        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3787       log_error(_("invalid personal cipher preferences\n"));
3788
3789     if(pers_digest_list &&
3790        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3791       log_error(_("invalid personal digest preferences\n"));
3792
3793     if(pers_compress_list &&
3794        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3795       log_error(_("invalid personal compress preferences\n"));
3796
3797     /* We don't support all possible commands with multifile yet */
3798     if(multifile)
3799       {
3800         char *cmdname;
3801
3802         switch(cmd)
3803           {
3804           case aSign:
3805             cmdname="--sign";
3806             break;
3807           case aSignEncr:
3808             cmdname="--sign --encrypt";
3809             break;
3810           case aClearsign:
3811             cmdname="--clear-sign";
3812             break;
3813           case aDetachedSign:
3814             cmdname="--detach-sign";
3815             break;
3816           case aSym:
3817             cmdname="--symmetric";
3818             break;
3819           case aEncrSym:
3820             cmdname="--symmetric --encrypt";
3821             break;
3822           case aStore:
3823             cmdname="--store";
3824             break;
3825           default:
3826             cmdname=NULL;
3827             break;
3828           }
3829
3830         if(cmdname)
3831           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3832       }
3833
3834     if( log_get_errorcount(0) )
3835         g10_exit(2);
3836
3837     if(opt.compress_level==0)
3838       opt.compress_algo=COMPRESS_ALGO_NONE;
3839
3840     /* Check our chosen algorithms against the list of legal
3841        algorithms. */
3842
3843     if(!GNUPG)
3844       {
3845         const char *badalg=NULL;
3846         preftype_t badtype=PREFTYPE_NONE;
3847
3848         if(opt.def_cipher_algo
3849            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3850           {
3851             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3852             badtype = PREFTYPE_SYM;
3853           }
3854         else if(opt.def_digest_algo
3855                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3856           {
3857             badalg = gcry_md_algo_name (opt.def_digest_algo);
3858             badtype = PREFTYPE_HASH;
3859           }
3860         else if(opt.cert_digest_algo
3861                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3862           {
3863             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3864             badtype = PREFTYPE_HASH;
3865           }
3866         else if(opt.compress_algo!=-1
3867                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3868           {
3869             badalg = compress_algo_to_string(opt.compress_algo);
3870             badtype = PREFTYPE_ZIP;
3871           }
3872
3873         if(badalg)
3874           {
3875             switch(badtype)
3876               {
3877               case PREFTYPE_SYM:
3878                 log_info (_("cipher algorithm '%s'"
3879                             " may not be used in %s mode\n"),
3880                          badalg,
3881                           gnupg_compliance_option_string (opt.compliance));
3882                 break;
3883               case PREFTYPE_HASH:
3884                 log_info (_("digest algorithm '%s'"
3885                             " may not be used in %s mode\n"),
3886                           badalg,
3887                           gnupg_compliance_option_string (opt.compliance));
3888                 break;
3889               case PREFTYPE_ZIP:
3890                 log_info (_("compression algorithm '%s'"
3891                             " may not be used in %s mode\n"),
3892                           badalg,
3893                           gnupg_compliance_option_string (opt.compliance));
3894                 break;
3895               default:
3896                 BUG();
3897               }
3898
3899             compliance_failure();
3900           }
3901       }
3902
3903     /* Check our chosen algorithms against the list of allowed
3904      * algorithms in the current compliance mode, and fail hard if it
3905      * is not.  This is us being nice to the user informing her early
3906      * that the chosen algorithms are not available.  We also check
3907      * and enforce this right before the actual operation.  */
3908     if (opt.def_cipher_algo
3909         && ! gnupg_cipher_is_allowed (opt.compliance,
3910                                       cmd == aEncr
3911                                       || cmd == aSignEncr
3912                                       || cmd == aEncrSym
3913                                       || cmd == aSym
3914                                       || cmd == aSignSym
3915                                       || cmd == aSignEncrSym,
3916                                       opt.def_cipher_algo,
3917                                       GCRY_CIPHER_MODE_NONE))
3918       log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
3919                  openpgp_cipher_algo_name (opt.def_cipher_algo),
3920                  gnupg_compliance_option_string (opt.compliance));
3921
3922     if (opt.def_digest_algo
3923         && ! gnupg_digest_is_allowed (opt.compliance,
3924                                       cmd == aSign
3925                                       || cmd == aSignEncr
3926                                       || cmd == aSignEncrSym
3927                                       || cmd == aSignSym
3928                                       || cmd == aClearsign,
3929                                       opt.def_digest_algo))
3930       log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
3931                  gcry_md_algo_name (opt.def_digest_algo),
3932                  gnupg_compliance_option_string (opt.compliance));
3933
3934     /* Fail hard.  */
3935     if (log_get_errorcount (0))
3936         g10_exit (2);
3937
3938     /* Set the random seed file. */
3939     if( use_random_seed ) {
3940       char *p = make_filename (gnupg_homedir (), "random_seed", NULL );
3941         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3942         if (!access (p, F_OK))
3943           register_secured_file (p);
3944         xfree(p);
3945     }
3946
3947     /* If there is no command but the --fingerprint is given, default
3948        to the --list-keys command.  */
3949     if (!cmd && fpr_maybe_cmd)
3950       {
3951         set_cmd (&cmd, aListKeys);
3952       }
3953
3954
3955     if( opt.verbose > 1 )
3956         set_packet_list_mode(1);
3957
3958     /* Add the keyrings, but not for some special commands.  We always
3959      * need to add the keyrings if we are running under SELinux, this
3960      * is so that the rings are added to the list of secured files.
3961      * We do not add any keyring if --no-keyring has been used.  */
3962     if (default_keyring >= 0
3963         && (ALWAYS_ADD_KEYRINGS
3964             || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest)))
3965       {
3966         if (!nrings || default_keyring > 0)  /* Add default ring. */
3967             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3968                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3969         for (sl = nrings; sl; sl = sl->next )
3970           keydb_add_resource (sl->d, sl->flags);
3971       }
3972     FREE_STRLIST(nrings);
3973
3974     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
3975       /* In loopback mode, never ask for the password multiple
3976          times.  */
3977       {
3978         opt.passphrase_repeat = 0;
3979       }
3980
3981     if (cmd == aGPGConfTest)
3982       g10_exit(0);
3983
3984
3985     if (pwfd != -1)  /* Read the passphrase now. */
3986       read_passphrase_from_fd (pwfd);
3987
3988     if (ovrseskeyfd != -1 )  /* Read the sessionkey now. */
3989       read_sessionkey_from_fd (ovrseskeyfd);
3990
3991     fname = argc? *argv : NULL;
3992
3993     if(fname && utf8_strings)
3994       opt.flags.utf8_filename=1;
3995
3996     ctrl = xcalloc (1, sizeof *ctrl);
3997     gpg_init_default_ctrl (ctrl);
3998
3999 #ifndef NO_TRUST_MODELS
4000     switch (cmd)
4001       {
4002       case aPrimegen:
4003       case aPrintMD:
4004       case aPrintMDs:
4005       case aGenRandom:
4006       case aDeArmor:
4007       case aEnArmor:
4008       case aListConfig:
4009       case aListGcryptConfig:
4010         break;
4011       case aFixTrustDB:
4012       case aExportOwnerTrust:
4013         rc = setup_trustdb (0, trustdb_name);
4014         break;
4015       case aListTrustDB:
4016         rc = setup_trustdb (argc? 1:0, trustdb_name);
4017         break;
4018       case aKeygen:
4019       case aFullKeygen:
4020       case aQuickKeygen:
4021         rc = setup_trustdb (1, trustdb_name);
4022         break;
4023       default:
4024         /* If we are using TM_ALWAYS, we do not need to create the
4025            trustdb.  */
4026         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
4027         break;
4028       }
4029     if (rc)
4030       log_error (_("failed to initialize the TrustDB: %s\n"),
4031                  gpg_strerror (rc));
4032 #endif /*!NO_TRUST_MODELS*/
4033
4034     switch (cmd)
4035       {
4036       case aStore:
4037       case aSym:
4038       case aSign:
4039       case aSignSym:
4040       case aClearsign:
4041         if (!opt.quiet && any_explicit_recipient)
4042           log_info (_("WARNING: recipients (-r) given "
4043                       "without using public key encryption\n"));
4044         break;
4045       default:
4046         break;
4047       }
4048
4049
4050     /* Check for certain command whether we need to migrate a
4051        secring.gpg to the gpg-agent. */
4052     switch (cmd)
4053       {
4054       case aListSecretKeys:
4055       case aSign:
4056       case aSignEncr:
4057       case aSignEncrSym:
4058       case aSignSym:
4059       case aClearsign:
4060       case aDecrypt:
4061       case aSignKey:
4062       case aLSignKey:
4063       case aEditKey:
4064       case aPasswd:
4065       case aDeleteSecretKeys:
4066       case aDeleteSecretAndPublicKeys:
4067       case aQuickKeygen:
4068       case aQuickAddUid:
4069       case aQuickAddKey:
4070       case aQuickRevUid:
4071       case aQuickSetPrimaryUid:
4072       case aFullKeygen:
4073       case aKeygen:
4074       case aImport:
4075       case aExportSecret:
4076       case aExportSecretSub:
4077       case aGenRevoke:
4078       case aDesigRevoke:
4079       case aCardEdit:
4080       case aChangePIN:
4081         migrate_secring (ctrl);
4082         break;
4083       case aListKeys:
4084         if (opt.with_secret)
4085           migrate_secring (ctrl);
4086         break;
4087       default:
4088         break;
4089       }
4090
4091     /* The command dispatcher.  */
4092     switch( cmd )
4093       {
4094       case aServer:
4095         gpg_server (ctrl);
4096         break;
4097
4098       case aStore: /* only store the file */
4099         if( argc > 1 )
4100             wrong_args("--store [filename]");
4101         if( (rc = encrypt_store(fname)) )
4102           {
4103             write_status_failure ("store", rc);
4104             log_error ("storing '%s' failed: %s\n",
4105                        print_fname_stdin(fname),gpg_strerror (rc) );
4106           }
4107         break;
4108       case aSym: /* encrypt the given file only with the symmetric cipher */
4109         if( argc > 1 )
4110             wrong_args("--symmetric [filename]");
4111         if( (rc = encrypt_symmetric(fname)) )
4112           {
4113             write_status_failure ("symencrypt", rc);
4114             log_error (_("symmetric encryption of '%s' failed: %s\n"),
4115                         print_fname_stdin(fname),gpg_strerror (rc) );
4116           }
4117         break;
4118
4119       case aEncr: /* encrypt the given file */
4120         if(multifile)
4121           encrypt_crypt_files (ctrl, argc, argv, remusr);
4122         else
4123           {
4124             if( argc > 1 )
4125               wrong_args("--encrypt [filename]");
4126             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
4127               {
4128                 write_status_failure ("encrypt", rc);
4129                 log_error("%s: encryption failed: %s\n",
4130                           print_fname_stdin(fname), gpg_strerror (rc) );
4131               }
4132           }
4133         break;
4134
4135       case aEncrSym:
4136         /* This works with PGP 8 in the sense that it acts just like a
4137            symmetric message.  It doesn't work at all with 2 or 6.  It
4138            might work with 7, but alas, I don't have a copy to test
4139            with right now. */
4140         if( argc > 1 )
4141           wrong_args("--symmetric --encrypt [filename]");
4142         else if(opt.s2k_mode==0)
4143           log_error(_("you cannot use --symmetric --encrypt"
4144                       " with --s2k-mode 0\n"));
4145         else if(PGP6 || PGP7)
4146           log_error(_("you cannot use --symmetric --encrypt"
4147                       " in %s mode\n"),
4148                     gnupg_compliance_option_string (opt.compliance));
4149         else
4150           {
4151             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
4152               {
4153                 write_status_failure ("encrypt", rc);
4154                 log_error ("%s: encryption failed: %s\n",
4155                            print_fname_stdin(fname), gpg_strerror (rc) );
4156               }
4157           }
4158         break;
4159
4160       case aSign: /* sign the given file */
4161         sl = NULL;
4162         if( detached_sig ) { /* sign all files */
4163             for( ; argc; argc--, argv++ )
4164                 add_to_strlist( &sl, *argv );
4165         }
4166         else {
4167             if( argc > 1 )
4168                 wrong_args("--sign [filename]");
4169             if( argc ) {
4170                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4171                 strcpy(sl->d, fname);
4172             }
4173         }
4174         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
4175           {
4176             write_status_failure ("sign", rc);
4177             log_error ("signing failed: %s\n", gpg_strerror (rc) );
4178           }
4179         free_strlist(sl);
4180         break;
4181
4182       case aSignEncr: /* sign and encrypt the given file */
4183         if( argc > 1 )
4184             wrong_args("--sign --encrypt [filename]");
4185         if( argc ) {
4186             sl = xmalloc_clear( sizeof *sl + strlen(fname));
4187             strcpy(sl->d, fname);
4188         }
4189         else
4190             sl = NULL;
4191         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
4192           {
4193             write_status_failure ("sign-encrypt", rc);
4194             log_error("%s: sign+encrypt failed: %s\n",
4195                       print_fname_stdin(fname), gpg_strerror (rc) );
4196           }
4197         free_strlist(sl);
4198         break;
4199
4200       case aSignEncrSym: /* sign and encrypt the given file */
4201         if( argc > 1 )
4202             wrong_args("--symmetric --sign --encrypt [filename]");
4203         else if(opt.s2k_mode==0)
4204           log_error(_("you cannot use --symmetric --sign --encrypt"
4205                       " with --s2k-mode 0\n"));
4206         else if(PGP6 || PGP7)
4207           log_error(_("you cannot use --symmetric --sign --encrypt"
4208                       " in %s mode\n"),
4209                     gnupg_compliance_option_string (opt.compliance));
4210         else
4211           {
4212             if( argc )
4213