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