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