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