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