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