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