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