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