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