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