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