gpg: Don't error out if a key occurs multiple times in the keyring.
[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
2105 static gpg_error_t
2106 check_user_ids (strlist_t *sp,
2107                 int warn_possibly_ambiguous,
2108                 int error_if_not_found)
2109 {
2110   strlist_t s = *sp;
2111   strlist_t s2 = NULL;
2112   strlist_t t;
2113
2114   gpg_error_t rc = 0;
2115   gpg_error_t err;
2116
2117   KEYDB_HANDLE hd = NULL;
2118
2119   char fingerprint_formatted[MAX_FORMATTED_FINGERPRINT_LEN + 1];
2120
2121   /* A quick check to avoid allocating a new strlist if we can skip
2122      all keys.  Handles also the case of !SP.  See below for details.  */
2123   for (t = s; t && (!(t->flags & PK_LIST_CONFIG)
2124                     && !(t->flags & PK_LIST_ENCRYPT_TO)); t = t->next)
2125     ;
2126   if (!t)
2127     return 0;
2128
2129   for (t = s; t; t = t->next)
2130     {
2131       const char *option;
2132
2133       KEYDB_SEARCH_DESC desc;
2134       KBNODE kb;
2135       PKT_public_key *pk;
2136       char fingerprint_bin[MAX_FINGERPRINT_LEN];
2137       size_t fingerprint_bin_len = sizeof (fingerprint_bin);
2138       /* We also potentially need a ! at the end.  */
2139       char fingerprint[2 * MAX_FINGERPRINT_LEN + 1 + 1];
2140       int added = 0;
2141       int dups = 0;
2142       int ambiguous = 0;
2143
2144       /* If the key has been given on the command line and it has not
2145          been given by one of the encrypt-to options, we skip the
2146          checks.  The reason is that the actual key selection code
2147          does its own checks and provides proper status message to the
2148          caller to detect the wrong keys.  */
2149       if (!(t->flags & PK_LIST_CONFIG) && !(t->flags & PK_LIST_ENCRYPT_TO))
2150         {
2151           add_to_strlist (&s2, t->d);
2152           s2->flags = t->flags;
2153           continue;
2154         }
2155
2156       switch (t->flags >> PK_LIST_SHIFT)
2157         {
2158         case oDefaultKey: option = "--default-key"; break;
2159         case oEncryptTo: option = "--encrypt-to"; break;
2160         case oHiddenEncryptTo: option = "--hidden-encrypt-to"; break;
2161         case oEncryptToDefaultKey: option = "--encrypt-to-default-key"; break;
2162         case oRecipient: option = "--recipient"; break;
2163         case oHiddenRecipient: option = "--hidden-recipient"; break;
2164         case oLocalUser: option = "--local-user"; break;
2165         default:
2166           log_bug ("Unsupport option: %d\n", (t->flags >> PK_LIST_SHIFT));
2167         }
2168
2169       if (DBG_LOOKUP)
2170         {
2171           log_debug ("\n");
2172           log_debug ("%s: Checking %s=%s\n", __func__, option, t->d);
2173         }
2174
2175       err = classify_user_id (t->d, &desc, 1);
2176       if (err)
2177         {
2178           if (! rc)
2179             rc = err;
2180
2181           log_error (_("key \"%s\" not found: %s\n"),
2182                        t->d, gpg_strerror (err));
2183           if (!opt.quiet)
2184             log_info (_("(check argument of option '%s')\n"), option);
2185           continue;
2186         }
2187
2188       if (warn_possibly_ambiguous
2189           && ! (desc.mode == KEYDB_SEARCH_MODE_LONG_KID
2190                 || desc.mode == KEYDB_SEARCH_MODE_FPR16
2191                 || desc.mode == KEYDB_SEARCH_MODE_FPR20
2192                 || desc.mode == KEYDB_SEARCH_MODE_FPR))
2193         log_info (_("Warning: value '%s' for option '%s'"
2194                     " should be a long key ID or a fingerprint\n"),
2195                   t->d, option);
2196
2197       if (! hd)
2198         {
2199           hd = keydb_new ();
2200           if (!hd)
2201             {
2202               rc = gpg_error_from_syserror ();
2203               break;
2204             }
2205         }
2206       else
2207         keydb_search_reset (hd);
2208
2209       err = keydb_search (hd, &desc, 1, NULL);
2210       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2211         {
2212           if (DBG_LOOKUP)
2213             log_debug ("%s: '%s' not found.\n", __func__, t->d);
2214
2215           if (error_if_not_found)
2216             {
2217               if (! rc)
2218                 rc = err;
2219
2220               log_error (_("key \"%s\" not found\n"), t->d);
2221               if (!opt.quiet)
2222                 log_info (_("(check argument of option '%s')\n"), option);
2223             }
2224           continue;
2225         }
2226       if (err)
2227         {
2228           if (! rc)
2229             rc = err;
2230
2231           log_error (_("key \"%s\" not found: %s\n"), t->d, gpg_strerror (err));
2232           break;
2233         }
2234
2235       err = keydb_get_keyblock (hd, &kb);
2236       if (err)
2237         {
2238           if (! rc)
2239             rc = err;
2240
2241           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2242           continue;
2243         }
2244
2245       pk = kb->pkt->pkt.public_key;
2246       if ((desc.mode == KEYDB_SEARCH_MODE_SHORT_KID
2247            || desc.mode == KEYDB_SEARCH_MODE_LONG_KID
2248            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2249            || desc.mode == KEYDB_SEARCH_MODE_FPR20)
2250           && strchr (t->d, '!'))
2251         /* Exact search.  In this case we want to set FINGERPRINT not
2252            to the primary key, but the key (primary or sub) that
2253            matched the search criteria.  Note: there will always be
2254            exactly one match.  */
2255         {
2256           kbnode_t n = kb;
2257           PKT_public_key *match = NULL;
2258           int i;
2259
2260           do
2261             {
2262               if ((n->flag & 1))
2263                 /* The matched node.  */
2264                 {
2265                   assert (! match);
2266                   match = n->pkt->pkt.public_key;
2267                 }
2268             }
2269           while ((n = find_next_kbnode (n, PKT_PUBLIC_SUBKEY)));
2270           assert (match);
2271
2272           fingerprint_from_pk (match, fingerprint_bin, &fingerprint_bin_len);
2273           assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2274           bin2hex (fingerprint_bin, MAX_FINGERPRINT_LEN, fingerprint);
2275
2276           i = strlen (fingerprint);
2277           fingerprint[i] = '!';
2278           fingerprint[i + 1] = '\0';
2279
2280           add_to_strlist (&s2, fingerprint);
2281           added = 1;
2282         }
2283
2284       /* We need the primary key's fingerprint to detect dups so
2285          always format it.  */
2286       fingerprint_from_pk (pk, fingerprint_bin, &fingerprint_bin_len);
2287       assert (fingerprint_bin_len == sizeof (fingerprint_bin));
2288       bin2hex (fingerprint_bin, MAX_FINGERPRINT_LEN, fingerprint);
2289
2290       if (! added)
2291         add_to_strlist (&s2, fingerprint);
2292       s2->flags = s->flags;
2293
2294       release_kbnode (kb);
2295
2296       /* Continue the search.  */
2297       if (DBG_LOOKUP)
2298         log_debug ("%s: Checking if %s='%s' is ambiguous or there are dups\n",
2299                    __func__, option, t->d);
2300       while (1)
2301         {
2302           char fingerprint_bin2[MAX_FINGERPRINT_LEN];
2303           size_t fingerprint_bin2_len = sizeof (fingerprint_bin2);
2304           char fingerprint2[2 * MAX_FINGERPRINT_LEN + 1];
2305
2306           err = keydb_search (hd, &desc, 1, NULL);
2307           if (gpg_err_code (err) == GPG_ERR_NOT_FOUND
2308               || gpg_err_code (err) == GPG_ERR_EOF)
2309             /* Not found => not ambiguous.   */
2310             break;
2311           else if (err)
2312             /* An error (other than "not found").  */
2313             {
2314               log_error (_("error searching the keyring: %s\n"),
2315                          gpg_strerror (err));
2316               if (! rc)
2317                 rc = err;
2318
2319               break;
2320             }
2321
2322           /* Another result!  */
2323
2324           err = keydb_get_keyblock (hd, &kb);
2325           if (err)
2326             {
2327               log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2328               if (! rc)
2329                 rc = err;
2330             }
2331           else
2332             {
2333               pk = kb->pkt->pkt.public_key;
2334               fingerprint_from_pk (pk, fingerprint_bin2, &fingerprint_bin2_len);
2335               assert (fingerprint_bin2_len == sizeof (fingerprint_bin2));
2336               bin2hex (fingerprint_bin2, MAX_FINGERPRINT_LEN, fingerprint2);
2337
2338               if (strcmp (fingerprint, fingerprint2) == 0)
2339                 dups ++;
2340               else
2341                 {
2342                   ambiguous ++;
2343
2344                   if (! rc)
2345                     rc = GPG_ERR_AMBIGUOUS_NAME;
2346
2347                   if (ambiguous == 1)
2348                     {
2349                       /* TRANSLATORS: The %s prints a key
2350                          specification which for example has been
2351                          given at the command line.  Lines with
2352                          fingerprints are printed after this
2353                          message.  */
2354                       log_error (_("key specification '%s' is ambiguous\n"),
2355                                  t->d);
2356                       if (!opt.quiet)
2357                         log_info (_("(check argument of option '%s')\n"),
2358                                   option);
2359
2360                       log_info (_("'%s' matches at least:\n"), t->d);
2361                       log_info ("  %s\n",
2362                                 format_hexfingerprint
2363                                  (fingerprint,
2364                                   fingerprint_formatted,
2365                                   sizeof fingerprint_formatted));
2366                     }
2367
2368                   log_info ("  %s\n",
2369                             format_hexfingerprint
2370                              (fingerprint2,
2371                               fingerprint_formatted,
2372                               sizeof fingerprint_formatted));
2373                 }
2374
2375               release_kbnode (kb);
2376             }
2377         }
2378
2379       if (dups)
2380         log_info (_("Warning: %s appears in the keyring %d times.\n"),
2381                   format_hexfingerprint (fingerprint,
2382                                          fingerprint_formatted,
2383                                          sizeof fingerprint_formatted),
2384                   1 + dups);
2385     }
2386
2387   strlist_rev (&s2);
2388
2389   keydb_release (hd);
2390
2391   free_strlist (s);
2392   *sp = s2;
2393   return rc;
2394 }
2395
2396
2397 int
2398 main (int argc, char **argv)
2399 {
2400     ARGPARSE_ARGS pargs;
2401     IOBUF a;
2402     int rc=0;
2403     int orig_argc;
2404     char **orig_argv;
2405     const char *fname;
2406     char *username;
2407     int may_coredump;
2408     strlist_t sl;
2409     strlist_t remusr = NULL;
2410     strlist_t locusr = NULL;
2411     strlist_t nrings = NULL;
2412     armor_filter_context_t *afx = NULL;
2413     int detached_sig = 0;
2414     FILE *configfp = NULL;
2415     char *configname = NULL;
2416     char *save_configname = NULL;
2417     char *default_configname = NULL;
2418     unsigned configlineno;
2419     int parse_debug = 0;
2420     int default_config = 1;
2421     int default_keyring = 1;
2422     int greeting = 0;
2423     int nogreeting = 0;
2424     char *logfile = NULL;
2425     int use_random_seed = 1;
2426     enum cmd_and_opt_values cmd = 0;
2427     const char *debug_level = NULL;
2428 #ifndef NO_TRUST_MODELS
2429     const char *trustdb_name = NULL;
2430 #endif /*!NO_TRUST_MODELS*/
2431     char *def_cipher_string = NULL;
2432     char *def_digest_string = NULL;
2433     char *compress_algo_string = NULL;
2434     char *cert_digest_string = NULL;
2435     char *s2k_cipher_string = NULL;
2436     char *s2k_digest_string = NULL;
2437     char *pers_cipher_list = NULL;
2438     char *pers_digest_list = NULL;
2439     char *pers_compress_list = NULL;
2440     int eyes_only=0;
2441     int multifile=0;
2442     int pwfd = -1;
2443     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2444     int any_explicit_recipient = 0;
2445     int require_secmem=0,got_secmem=0;
2446     struct assuan_malloc_hooks malloc_hooks;
2447     ctrl_t ctrl;
2448
2449 #ifdef __riscos__
2450     opt.lock_once = 1;
2451 #endif /* __riscos__ */
2452
2453
2454     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2455        when adding any stuff between here and the call to
2456        secmem_init() somewhere after the option parsing. */
2457     early_system_init ();
2458     gnupg_reopen_std (GPG_NAME);
2459     trap_unaligned ();
2460     gnupg_rl_initialize ();
2461     set_strusage (my_strusage);
2462     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2463     log_set_prefix (GPG_NAME, 1);
2464
2465     /* Make sure that our subsystems are ready.  */
2466     i18n_init();
2467     init_common_subsystems (&argc, &argv);
2468
2469     /* Check that the libraries are suitable.  Do it right here because the
2470        option parsing may need services of the library.  */
2471     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
2472       {
2473         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
2474                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
2475       }
2476
2477     /* Use our own logging handler for Libcgrypt.  */
2478     setup_libgcrypt_logging ();
2479
2480     /* Put random number into secure memory */
2481     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2482
2483     may_coredump = disable_core_dumps();
2484
2485     gnupg_init_signals (0, emergency_cleanup);
2486
2487     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2488
2489     opt.autostart = 1;
2490     opt.session_env = session_env_new ();
2491     if (!opt.session_env)
2492       log_fatal ("error allocating session environment block: %s\n",
2493                  strerror (errno));
2494
2495     opt.command_fd = -1; /* no command fd */
2496     opt.compress_level = -1; /* defaults to standard compress level */
2497     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2498     /* note: if you change these lines, look at oOpenPGP */
2499     opt.def_cipher_algo = 0;
2500     opt.def_digest_algo = 0;
2501     opt.cert_digest_algo = 0;
2502     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2503     opt.s2k_mode = 3; /* iterated+salted */
2504     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2505     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2506     opt.completes_needed = 1;
2507     opt.marginals_needed = 3;
2508     opt.max_cert_depth = 5;
2509     opt.escape_from = 1;
2510     opt.flags.require_cross_cert = 1;
2511     opt.import_options = 0;
2512     opt.export_options = EXPORT_ATTRIBUTES;
2513     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
2514     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2515     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2516     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2517                           | VERIFY_SHOW_POLICY_URLS
2518                           | VERIFY_SHOW_STD_NOTATIONS
2519                           | VERIFY_SHOW_KEYSERVER_URLS);
2520     opt.list_options   = LIST_SHOW_UID_VALIDITY;
2521 #ifdef NO_TRUST_MODELS
2522     opt.trust_model = TM_ALWAYS;
2523 #else
2524     opt.trust_model = TM_AUTO;
2525 #endif
2526     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2527     opt.tofu_db_format = TOFU_DB_AUTO;
2528     opt.mangle_dos_filenames = 0;
2529     opt.min_cert_level = 2;
2530     set_screen_dimensions ();
2531     opt.keyid_format = KF_SHORT;
2532     opt.def_sig_expire = "0";
2533     opt.def_cert_expire = "0";
2534     set_homedir (default_homedir ());
2535     opt.passphrase_repeat = 1;
2536     opt.emit_version = 1; /* Limit to the major number.  */
2537     opt.weak_digests = NULL;
2538     additional_weak_digest("MD5");
2539
2540     /* Check whether we have a config file on the command line.  */
2541     orig_argc = argc;
2542     orig_argv = argv;
2543     pargs.argc = &argc;
2544     pargs.argv = &argv;
2545     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2546     while( arg_parse( &pargs, opts) ) {
2547         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2548             parse_debug++;
2549         else if (pargs.r_opt == oDebugIOLBF)
2550             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2551         else if( pargs.r_opt == oOptions ) {
2552             /* yes there is one, so we do not try the default one, but
2553              * read the option file when it is encountered at the commandline
2554              */
2555             default_config = 0;
2556         }
2557         else if( pargs.r_opt == oNoOptions )
2558           {
2559             default_config = 0; /* --no-options */
2560             opt.no_homedir_creation = 1;
2561           }
2562         else if( pargs.r_opt == oHomedir )
2563             set_homedir ( pargs.r.ret_str );
2564         else if( pargs.r_opt == oNoPermissionWarn )
2565             opt.no_perm_warn=1;
2566         else if (pargs.r_opt == oStrict )
2567           {
2568             /* Not used */
2569           }
2570         else if (pargs.r_opt == oNoStrict )
2571           {
2572             /* Not used */
2573           }
2574     }
2575
2576 #ifdef HAVE_DOSISH_SYSTEM
2577     if ( strchr (opt.homedir,'\\') ) {
2578         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2579         const char *s = opt.homedir;
2580         for (d=buf,s=opt.homedir; *s; s++)
2581           {
2582             *d++ = *s == '\\'? '/': *s;
2583 #ifdef HAVE_W32_SYSTEM
2584             if (s[1] && IsDBCSLeadByte (*s))
2585               *d++ = *++s;
2586 #endif
2587           }
2588         *d = 0;
2589         set_homedir (buf);
2590     }
2591 #endif
2592
2593     /* Initialize the secure memory. */
2594     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2595       got_secmem = 1;
2596 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2597     /* There should be no way to get to this spot while still carrying
2598        setuid privs.  Just in case, bomb out if we are. */
2599     if ( getuid () != geteuid () )
2600       BUG ();
2601 #endif
2602     maybe_setuid = 0;
2603
2604     /* Okay, we are now working under our real uid */
2605
2606     /* malloc hooks go here ... */
2607     malloc_hooks.malloc = gcry_malloc;
2608     malloc_hooks.realloc = gcry_realloc;
2609     malloc_hooks.free = gcry_free;
2610     assuan_set_malloc_hooks (&malloc_hooks);
2611     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2612     setup_libassuan_logging (&opt.debug);
2613
2614     /* Try for a version specific config file first */
2615     default_configname = get_default_configname ();
2616     if (default_config)
2617       configname = xstrdup (default_configname);
2618
2619     argc = orig_argc;
2620     argv = orig_argv;
2621     pargs.argc = &argc;
2622     pargs.argv = &argv;
2623     pargs.flags= ARGPARSE_FLAG_KEEP;
2624
2625     /* By this point we have a homedir, and cannot change it. */
2626     check_permissions(opt.homedir,0);
2627
2628   next_pass:
2629     if( configname ) {
2630       if(check_permissions(configname,1))
2631         {
2632           /* If any options file is unsafe, then disable any external
2633              programs for keyserver calls or photo IDs.  Since the
2634              external program to call is set in the options file, a
2635              unsafe options file can lead to an arbitrary program
2636              being run. */
2637
2638           opt.exec_disable=1;
2639         }
2640
2641         configlineno = 0;
2642         configfp = fopen( configname, "r" );
2643         if (configfp && is_secured_file (fileno (configfp)))
2644           {
2645             fclose (configfp);
2646             configfp = NULL;
2647             gpg_err_set_errno (EPERM);
2648           }
2649         if( !configfp ) {
2650             if( default_config ) {
2651                 if( parse_debug )
2652                     log_info(_("Note: no default option file '%s'\n"),
2653                                                             configname );
2654             }
2655             else {
2656                 log_error(_("option file '%s': %s\n"),
2657                                     configname, strerror(errno) );
2658                 g10_exit(2);
2659             }
2660             xfree(configname); configname = NULL;
2661         }
2662         if( parse_debug && configname )
2663             log_info(_("reading options from '%s'\n"), configname );
2664         default_config = 0;
2665     }
2666
2667     while( optfile_parse( configfp, configname, &configlineno,
2668                                                 &pargs, opts) )
2669       {
2670         switch( pargs.r_opt )
2671           {
2672           case aCheckKeys:
2673           case aListConfig:
2674           case aListGcryptConfig:
2675           case aGPGConfList:
2676           case aGPGConfTest:
2677           case aListPackets:
2678           case aImport:
2679           case aFastImport:
2680           case aSendKeys:
2681           case aRecvKeys:
2682           case aSearchKeys:
2683           case aRefreshKeys:
2684           case aFetchKeys:
2685           case aExport:
2686 #ifdef ENABLE_CARD_SUPPORT
2687           case aCardStatus:
2688           case aCardEdit:
2689           case aChangePIN:
2690 #endif /* ENABLE_CARD_SUPPORT*/
2691           case aListKeys:
2692           case aLocateKeys:
2693           case aListSigs:
2694           case aExportSecret:
2695           case aExportSecretSub:
2696           case aSym:
2697           case aClearsign:
2698           case aGenRevoke:
2699           case aDesigRevoke:
2700           case aPrimegen:
2701           case aGenRandom:
2702           case aPrintMD:
2703           case aPrintMDs:
2704           case aListTrustDB:
2705           case aCheckTrustDB:
2706           case aUpdateTrustDB:
2707           case aFixTrustDB:
2708           case aListTrustPath:
2709           case aDeArmor:
2710           case aEnArmor:
2711           case aSign:
2712           case aQuickSignKey:
2713           case aQuickLSignKey:
2714           case aSignKey:
2715           case aLSignKey:
2716           case aStore:
2717           case aQuickKeygen:
2718           case aQuickAddUid:
2719           case aExportOwnerTrust:
2720           case aImportOwnerTrust:
2721           case aRebuildKeydbCaches:
2722             set_cmd (&cmd, pargs.r_opt);
2723             break;
2724
2725           case aKeygen:
2726           case aFullKeygen:
2727           case aEditKey:
2728           case aDeleteSecretKeys:
2729           case aDeleteSecretAndPublicKeys:
2730           case aDeleteKeys:
2731           case aPasswd:
2732             set_cmd (&cmd, pargs.r_opt);
2733             greeting=1;
2734             break;
2735
2736           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2737
2738           case aDecryptFiles: multifile=1; /* fall through */
2739           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2740
2741           case aEncrFiles: multifile=1; /* fall through */
2742           case aEncr: set_cmd( &cmd, aEncr); break;
2743
2744           case aVerifyFiles: multifile=1; /* fall through */
2745           case aVerify: set_cmd( &cmd, aVerify); break;
2746
2747           case aServer:
2748             set_cmd (&cmd, pargs.r_opt);
2749             opt.batch = 1;
2750             break;
2751
2752           case aTOFUPolicy:
2753             set_cmd (&cmd, pargs.r_opt);
2754             break;
2755
2756           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2757           case oOutput: opt.outfile = pargs.r.ret_str; break;
2758           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2759           case oQuiet: opt.quiet = 1; break;
2760           case oNoTTY: tty_no_terminal(1); break;
2761           case oDryRun: opt.dry_run = 1; break;
2762           case oInteractive: opt.interactive = 1; break;
2763           case oVerbose:
2764             opt.verbose++;
2765             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2766             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2767             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2768             break;
2769
2770           case oBatch:
2771             opt.batch = 1;
2772             nogreeting = 1;
2773             break;
2774
2775           case oUseAgent: /* Dummy. */
2776             break;
2777
2778           case oNoUseAgent:
2779             obsolete_option (configname, configlineno, "no-use-agent");
2780             break;
2781           case oGpgAgentInfo:
2782             obsolete_option (configname, configlineno, "gpg-agent-info");
2783             break;
2784           case oReaderPort:
2785             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2786             break;
2787           case octapiDriver:
2788             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2789             break;
2790           case opcscDriver:
2791             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2792             break;
2793           case oDisableCCID:
2794             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2795             break;
2796           case oHonorHttpProxy:
2797             obsolete_option (configname, configlineno, "honor-http-proxy");
2798             break;
2799
2800           case oAnswerYes: opt.answer_yes = 1; break;
2801           case oAnswerNo: opt.answer_no = 1; break;
2802           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2803           case oPrimaryKeyring:
2804             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2805             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2806             break;
2807           case oShowKeyring:
2808             deprecated_warning(configname,configlineno,"--show-keyring",
2809                                "--list-options ","show-keyring");
2810             opt.list_options|=LIST_SHOW_KEYRING;
2811             break;
2812
2813           case oDebug:
2814             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2815               {
2816                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2817                 pargs.err = ARGPARSE_PRINT_ERROR;
2818               }
2819             break;
2820
2821           case oDebugAll: opt.debug = ~0; break;
2822           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2823
2824           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2825
2826           case oStatusFD:
2827             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2828             break;
2829           case oStatusFile:
2830             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2831             break;
2832           case oAttributeFD:
2833             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2834             break;
2835           case oAttributeFile:
2836             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2837             break;
2838           case oLoggerFD:
2839             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2840             break;
2841           case oLoggerFile:
2842             logfile = pargs.r.ret_str;
2843             break;
2844
2845           case oWithFingerprint:
2846             opt.with_fingerprint = 1;
2847             opt.fingerprint++;
2848             break;
2849           case oWithICAOSpelling:
2850             opt.with_icao_spelling = 1;
2851             break;
2852           case oFingerprint:
2853             opt.fingerprint++;
2854             fpr_maybe_cmd = 1;
2855             break;
2856
2857           case oWithKeygrip:
2858             opt.with_keygrip = 1;
2859             break;
2860
2861           case oWithSecret:
2862             opt.with_secret = 1;
2863             break;
2864
2865           case oSecretKeyring:
2866             /* Ignore this old option.  */
2867             break;
2868
2869           case oOptions:
2870             /* config files may not be nested (silently ignore them) */
2871             if( !configfp ) {
2872                 xfree(configname);
2873                 configname = xstrdup(pargs.r.ret_str);
2874                 goto next_pass;
2875             }
2876             break;
2877           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2878           case oNoDefKeyring: default_keyring = 0; break;
2879           case oNoGreeting: nogreeting = 1; break;
2880           case oNoVerbose:
2881             opt.verbose = 0;
2882             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2883             opt.list_sigs=0;
2884             break;
2885           case oQuickRandom:
2886             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2887             break;
2888           case oEmitVersion: opt.emit_version++; break;
2889           case oNoEmitVersion: opt.emit_version=0; break;
2890           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2891           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2892           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2893
2894 #ifndef NO_TRUST_MODELS
2895           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2896
2897 #endif /*!NO_TRUST_MODELS*/
2898           case oDefaultKey:
2899             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2900             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2901             break;
2902           case oDefRecipient:
2903             if( *pargs.r.ret_str )
2904               {
2905                 xfree (opt.def_recipient);
2906                 opt.def_recipient = make_username(pargs.r.ret_str);
2907               }
2908             break;
2909           case oDefRecipientSelf:
2910             xfree(opt.def_recipient); opt.def_recipient = NULL;
2911             opt.def_recipient_self = 1;
2912             break;
2913           case oNoDefRecipient:
2914             xfree(opt.def_recipient); opt.def_recipient = NULL;
2915             opt.def_recipient_self = 0;
2916             break;
2917           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2918           case oHomedir: break;
2919           case oNoBatch: opt.batch = 0; break;
2920
2921           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2922           case oWithColons: opt.with_colons=':'; break;
2923
2924           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2925           case oWithSigList: opt.list_sigs = 1; break;
2926
2927           case oSkipVerify: opt.skip_verify=1; break;
2928
2929           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2930           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2931
2932           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2933
2934 #ifndef NO_TRUST_MODELS
2935             /* There are many programs (like mutt) that call gpg with
2936                --always-trust so keep this option around for a long
2937                time. */
2938           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2939           case oTrustModel:
2940             parse_trust_model(pargs.r.ret_str);
2941             break;
2942 #endif /*!NO_TRUST_MODELS*/
2943           case oTOFUDefaultPolicy:
2944             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2945             break;
2946           case oTOFUDBFormat:
2947             opt.tofu_db_format = parse_tofu_db_format (pargs.r.ret_str);
2948             break;
2949
2950           case oForceOwnertrust:
2951             log_info(_("Note: %s is not for normal use!\n"),
2952                      "--force-ownertrust");
2953             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2954             if(opt.force_ownertrust==-1)
2955               {
2956                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2957                 opt.force_ownertrust=0;
2958               }
2959             break;
2960           case oLoadExtension:
2961             /* Dummy so that gpg 1.4 conf files can work. Should
2962                eventually be removed.  */
2963             break;
2964           case oOpenPGP:
2965           case oRFC4880:
2966             /* This is effectively the same as RFC2440, but with
2967                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2968                --require-cross-certification". */
2969             opt.compliance = CO_RFC4880;
2970             opt.flags.dsa2 = 1;
2971             opt.flags.require_cross_cert = 1;
2972             opt.rfc2440_text = 0;
2973             opt.allow_non_selfsigned_uid = 1;
2974             opt.allow_freeform_uid = 1;
2975             opt.escape_from = 1;
2976             opt.not_dash_escaped = 0;
2977             opt.def_cipher_algo = 0;
2978             opt.def_digest_algo = 0;
2979             opt.cert_digest_algo = 0;
2980             opt.compress_algo = -1;
2981             opt.s2k_mode = 3; /* iterated+salted */
2982             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2983             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2984             break;
2985           case oRFC2440:
2986             opt.compliance = CO_RFC2440;
2987             opt.flags.dsa2 = 0;
2988             opt.rfc2440_text = 1;
2989             opt.allow_non_selfsigned_uid = 1;
2990             opt.allow_freeform_uid = 1;
2991             opt.escape_from = 0;
2992             opt.not_dash_escaped = 0;
2993             opt.def_cipher_algo = 0;
2994             opt.def_digest_algo = 0;
2995             opt.cert_digest_algo = 0;
2996             opt.compress_algo = -1;
2997             opt.s2k_mode = 3; /* iterated+salted */
2998             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2999             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
3000             break;
3001           case oPGP6:  opt.compliance = CO_PGP6;  break;
3002           case oPGP7:  opt.compliance = CO_PGP7;  break;
3003           case oPGP8:  opt.compliance = CO_PGP8;  break;
3004           case oGnuPG: opt.compliance = CO_GNUPG; break;
3005           case oRFC2440Text: opt.rfc2440_text=1; break;
3006           case oNoRFC2440Text: opt.rfc2440_text=0; break;
3007           case oSetFilename:
3008             if(utf8_strings)
3009               opt.set_filename = pargs.r.ret_str;
3010             else
3011               opt.set_filename = native_to_utf8(pargs.r.ret_str);
3012             break;
3013           case oForYourEyesOnly: eyes_only = 1; break;
3014           case oNoForYourEyesOnly: eyes_only = 0; break;
3015           case oSetPolicyURL:
3016             add_policy_url(pargs.r.ret_str,0);
3017             add_policy_url(pargs.r.ret_str,1);
3018             break;
3019           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
3020           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
3021           case oShowPolicyURL:
3022             deprecated_warning(configname,configlineno,"--show-policy-url",
3023                                "--list-options ","show-policy-urls");
3024             deprecated_warning(configname,configlineno,"--show-policy-url",
3025                                "--verify-options ","show-policy-urls");
3026             opt.list_options|=LIST_SHOW_POLICY_URLS;
3027             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
3028             break;
3029           case oNoShowPolicyURL:
3030             deprecated_warning(configname,configlineno,"--no-show-policy-url",
3031                                "--list-options ","no-show-policy-urls");
3032             deprecated_warning(configname,configlineno,"--no-show-policy-url",
3033                                "--verify-options ","no-show-policy-urls");
3034             opt.list_options&=~LIST_SHOW_POLICY_URLS;
3035             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
3036             break;
3037           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
3038           case oUseEmbeddedFilename:
3039             opt.flags.use_embedded_filename=1;
3040             break;
3041           case oNoUseEmbeddedFilename:
3042             opt.flags.use_embedded_filename=0;
3043             break;
3044           case oComment:
3045             if(pargs.r.ret_str[0])
3046               append_to_strlist(&opt.comments,pargs.r.ret_str);
3047             break;
3048           case oDefaultComment:
3049             deprecated_warning(configname,configlineno,
3050                                "--default-comment","--no-comments","");
3051             /* fall through */
3052           case oNoComments:
3053             free_strlist(opt.comments);
3054             opt.comments=NULL;
3055             break;
3056           case oThrowKeyids: opt.throw_keyids = 1; break;
3057           case oNoThrowKeyids: opt.throw_keyids = 0; break;
3058           case oShowPhotos:
3059             deprecated_warning(configname,configlineno,"--show-photos",
3060                                "--list-options ","show-photos");
3061             deprecated_warning(configname,configlineno,"--show-photos",
3062                                "--verify-options ","show-photos");
3063             opt.list_options|=LIST_SHOW_PHOTOS;
3064             opt.verify_options|=VERIFY_SHOW_PHOTOS;
3065             break;
3066           case oNoShowPhotos:
3067             deprecated_warning(configname,configlineno,"--no-show-photos",
3068                                "--list-options ","no-show-photos");
3069             deprecated_warning(configname,configlineno,"--no-show-photos",
3070                                "--verify-options ","no-show-photos");
3071             opt.list_options&=~LIST_SHOW_PHOTOS;
3072             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
3073             break;
3074           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
3075
3076           case oForceMDC: opt.force_mdc = 1; break;
3077           case oNoForceMDC: opt.force_mdc = 0; break;
3078           case oDisableMDC: opt.disable_mdc = 1; break;
3079           case oNoDisableMDC: opt.disable_mdc = 0; break;
3080           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
3081           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
3082           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
3083           case oS2KCount:
3084             if (pargs.r.ret_int)
3085               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
3086             else
3087               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
3088             break;
3089           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
3090           case oEncryptTo: /* store the recipient in the second list */
3091             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3092             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
3093             if (configfp)
3094               sl->flags |= PK_LIST_CONFIG;
3095             break;
3096           case oHiddenEncryptTo: /* store the recipient in the second list */
3097             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3098             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT)
3099                          | PK_LIST_ENCRYPT_TO|PK_LIST_HIDDEN);
3100             if (configfp)
3101               sl->flags |= PK_LIST_CONFIG;
3102             break;
3103           case oEncryptToDefaultKey:
3104             opt.encrypt_to_default_key = 1;
3105             break;
3106           case oRecipient: /* store the recipient */
3107             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3108             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3109             if (configfp)
3110               sl->flags |= PK_LIST_CONFIG;
3111             any_explicit_recipient = 1;
3112             break;
3113           case oHiddenRecipient: /* store the recipient with a flag */
3114             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3115             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_HIDDEN);
3116             if (configfp)
3117               sl->flags |= PK_LIST_CONFIG;
3118             any_explicit_recipient = 1;
3119             break;
3120
3121           case oTrySecretKey:
3122             add_to_strlist2 (&opt.secret_keys_to_try,
3123                              pargs.r.ret_str, utf8_strings);
3124             break;
3125
3126           case oTextmodeShort: opt.textmode = 2; break;
3127           case oTextmode: opt.textmode=1;  break;
3128           case oNoTextmode: opt.textmode=0;  break;
3129           case oExpert: opt.expert = 1; break;
3130           case oNoExpert: opt.expert = 0; break;
3131           case oDefSigExpire:
3132             if(*pargs.r.ret_str!='\0')
3133               {
3134                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3135                   log_error(_("'%s' is not a valid signature expiration\n"),
3136                             pargs.r.ret_str);
3137                 else
3138                   opt.def_sig_expire=pargs.r.ret_str;
3139               }
3140             break;
3141           case oAskSigExpire: opt.ask_sig_expire = 1; break;
3142           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
3143           case oDefCertExpire:
3144             if(*pargs.r.ret_str!='\0')
3145               {
3146                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3147                   log_error(_("'%s' is not a valid signature expiration\n"),
3148                             pargs.r.ret_str);
3149                 else
3150                   opt.def_cert_expire=pargs.r.ret_str;
3151               }
3152             break;
3153           case oAskCertExpire: opt.ask_cert_expire = 1; break;
3154           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
3155           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
3156           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
3157           case oAskCertLevel: opt.ask_cert_level = 1; break;
3158           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
3159           case oLocalUser: /* store the local users */
3160             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
3161             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3162             if (configfp)
3163               sl->flags |= PK_LIST_CONFIG;
3164             break;
3165           case oCompress:
3166             /* this is the -z command line option */
3167             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
3168             break;
3169           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
3170           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
3171           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3172           case oPassphrase:
3173             set_passphrase_from_string(pargs.r.ret_str);
3174             break;
3175           case oPassphraseFD:
3176             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3177             break;
3178           case oPassphraseFile:
3179             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3180             break;
3181           case oPassphraseRepeat:
3182             opt.passphrase_repeat = pargs.r.ret_int;
3183             break;
3184
3185           case oPinentryMode:
3186             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3187             if (opt.pinentry_mode == -1)
3188               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3189             break;
3190
3191           case oCommandFD:
3192             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3193             break;
3194           case oCommandFile:
3195             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3196             break;
3197           case oCipherAlgo:
3198             def_cipher_string = xstrdup(pargs.r.ret_str);
3199             break;
3200           case oDigestAlgo:
3201             def_digest_string = xstrdup(pargs.r.ret_str);
3202             break;
3203           case oCompressAlgo:
3204             /* If it is all digits, stick a Z in front of it for
3205                later.  This is for backwards compatibility with
3206                versions that took the compress algorithm number. */
3207             {
3208               char *pt=pargs.r.ret_str;
3209               while(*pt)
3210                 {
3211                   if (!isascii (*pt) || !isdigit (*pt))
3212                     break;
3213
3214                   pt++;
3215                 }
3216
3217               if(*pt=='\0')
3218                 {
3219                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3220                   strcpy(compress_algo_string,"Z");
3221                   strcat(compress_algo_string,pargs.r.ret_str);
3222                 }
3223               else
3224                 compress_algo_string = xstrdup(pargs.r.ret_str);
3225             }
3226             break;
3227           case oCertDigestAlgo:
3228             cert_digest_string = xstrdup(pargs.r.ret_str);
3229             break;
3230
3231           case oNoSecmemWarn:
3232             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3233             break;
3234
3235           case oRequireSecmem: require_secmem=1; break;
3236           case oNoRequireSecmem: require_secmem=0; break;
3237           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3238           case oNoMDCWarn: opt.no_mdc_warn=1; break;
3239           case oDisplayCharset:
3240             if( set_native_charset( pargs.r.ret_str ) )
3241                 log_error(_("'%s' is not a valid character set\n"),
3242                           pargs.r.ret_str);
3243             break;
3244           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3245           case oEscapeFrom: opt.escape_from = 1; break;
3246           case oNoEscapeFrom: opt.escape_from = 0; break;
3247           case oLockOnce: opt.lock_once = 1; break;
3248           case oLockNever:
3249             dotlock_disable ();
3250             break;
3251           case oLockMultiple:
3252 #ifndef __riscos__
3253             opt.lock_once = 0;
3254 #else /* __riscos__ */
3255             riscos_not_implemented("lock-multiple");
3256 #endif /* __riscos__ */
3257             break;
3258           case oKeyServer:
3259             {
3260               keyserver_spec_t keyserver;
3261               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3262               if (!keyserver)
3263                 log_error (_("could not parse keyserver URL\n"));
3264               else
3265                 {
3266                   /* We only support a single keyserver.  Later ones
3267                      override earlier ones.  (Since we parse the
3268                      config file first and then the command line
3269                      arguments, the command line takes
3270                      precedence.)  */
3271                   if (opt.keyserver)
3272                     free_keyserver_spec (opt.keyserver);
3273                   opt.keyserver = keyserver;
3274                 }
3275             }
3276             break;
3277           case oKeyServerOptions:
3278             if(!parse_keyserver_options(pargs.r.ret_str))
3279               {
3280                 if(configname)
3281                   log_error(_("%s:%d: invalid keyserver options\n"),
3282                             configname,configlineno);
3283                 else
3284                   log_error(_("invalid keyserver options\n"));
3285               }
3286             break;
3287           case oImportOptions:
3288             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3289               {
3290                 if(configname)
3291                   log_error(_("%s:%d: invalid import options\n"),
3292                             configname,configlineno);
3293                 else
3294                   log_error(_("invalid import options\n"));
3295               }
3296             break;
3297           case oExportOptions:
3298             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3299               {
3300                 if(configname)
3301                   log_error(_("%s:%d: invalid export options\n"),
3302                             configname,configlineno);
3303                 else
3304                   log_error(_("invalid export options\n"));
3305               }
3306             break;
3307           case oListOptions:
3308             if(!parse_list_options(pargs.r.ret_str))
3309               {
3310                 if(configname)
3311                   log_error(_("%s:%d: invalid list options\n"),
3312                             configname,configlineno);
3313                 else
3314                   log_error(_("invalid list options\n"));
3315               }
3316             break;
3317           case oVerifyOptions:
3318             {
3319               struct parse_options vopts[]=
3320                 {
3321                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3322                    N_("display photo IDs during signature verification")},
3323                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3324                    N_("show policy URLs during signature verification")},
3325                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3326                    N_("show all notations during signature verification")},
3327                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3328                    N_("show IETF standard notations during signature verification")},
3329                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3330                    NULL},
3331                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3332                    N_("show user-supplied notations during signature verification")},
3333                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3334                    N_("show preferred keyserver URLs during signature verification")},
3335                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3336                    N_("show user ID validity during signature verification")},
3337                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3338                    N_("show revoked and expired user IDs in signature verification")},
3339                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3340                    N_("show only the primary user ID in signature verification")},
3341                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3342                    N_("validate signatures with PKA data")},
3343                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3344                    N_("elevate the trust of signatures with valid PKA data")},
3345                   {NULL,0,NULL,NULL}
3346                 };
3347
3348               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3349                 {
3350                   if(configname)
3351                     log_error(_("%s:%d: invalid verify options\n"),
3352                               configname,configlineno);
3353                   else
3354                     log_error(_("invalid verify options\n"));
3355                 }
3356             }
3357             break;
3358           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3359           case oExecPath:
3360             if(set_exec_path(pargs.r.ret_str))
3361               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3362             else
3363               opt.exec_path_set=1;
3364             break;
3365           case oSetNotation:
3366             add_notation_data( pargs.r.ret_str, 0 );
3367             add_notation_data( pargs.r.ret_str, 1 );
3368             break;
3369           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3370           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3371           case oShowNotation:
3372             deprecated_warning(configname,configlineno,"--show-notation",
3373                                "--list-options ","show-notations");
3374             deprecated_warning(configname,configlineno,"--show-notation",
3375                                "--verify-options ","show-notations");
3376             opt.list_options|=LIST_SHOW_NOTATIONS;
3377             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3378             break;
3379           case oNoShowNotation:
3380             deprecated_warning(configname,configlineno,"--no-show-notation",
3381                                "--list-options ","no-show-notations");
3382             deprecated_warning(configname,configlineno,"--no-show-notation",
3383                                "--verify-options ","no-show-notations");
3384             opt.list_options&=~LIST_SHOW_NOTATIONS;
3385             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3386             break;
3387           case oUtf8Strings: utf8_strings = 1; break;
3388           case oNoUtf8Strings: utf8_strings = 0; break;
3389           case oDisableCipherAlgo:
3390             {
3391               int algo = string_to_cipher_algo (pargs.r.ret_str);
3392               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3393             }
3394             break;
3395           case oDisablePubkeyAlgo:
3396             {
3397               int algo = gcry_pk_map_name (pargs.r.ret_str);
3398               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3399             }
3400             break;
3401           case oNoSigCache: opt.no_sig_cache = 1; break;
3402           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3403           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3404           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3405           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3406           case oNoLiteral: opt.no_literal = 1; break;
3407           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3408           case oFastListMode: opt.fast_list_mode = 1; break;
3409           case oFixedListMode: /* Dummy */ break;
3410           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3411           case oPrintPKARecords: opt.print_pka_records = 1; break;
3412           case oPrintDANERecords: opt.print_dane_records = 1; break;
3413           case oListOnly: opt.list_only=1; break;
3414           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3415           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3416           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3417           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3418           case oNoRandomSeedFile: use_random_seed = 0; break;
3419           case oAutoKeyRetrieve:
3420           case oNoAutoKeyRetrieve:
3421                 if(pargs.r_opt==oAutoKeyRetrieve)
3422                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
3423                 else
3424                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
3425
3426                 deprecated_warning(configname,configlineno,
3427                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
3428                                "--no-auto-key-retrieve","--keyserver-options ",
3429                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
3430                                "no-auto-key-retrieve");
3431                 break;
3432           case oShowSessionKey: opt.show_session_key = 1; break;
3433           case oOverrideSessionKey:
3434                 opt.override_session_key = pargs.r.ret_str;
3435                 break;
3436           case oMergeOnly:
3437                 deprecated_warning(configname,configlineno,"--merge-only",
3438                                    "--import-options ","merge-only");
3439                 opt.import_options|=IMPORT_MERGE_ONLY;
3440             break;
3441           case oAllowSecretKeyImport: /* obsolete */ break;
3442           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3443           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3444           case oEnableSpecialFilenames:
3445             iobuf_enable_special_filenames (1);
3446             break;
3447           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3448           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3449           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3450           case oPreservePermissions: opt.preserve_permissions=1; break;
3451           case oDefaultPreferenceList:
3452             opt.def_preference_list = pargs.r.ret_str;
3453             break;
3454           case oDefaultKeyserverURL:
3455             {
3456               keyserver_spec_t keyserver;
3457               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3458               if (!keyserver)
3459                 log_error (_("could not parse keyserver URL\n"));
3460               else
3461                 free_keyserver_spec (keyserver);
3462
3463               opt.def_keyserver_url = pargs.r.ret_str;
3464             }
3465             break;
3466           case oPersonalCipherPreferences:
3467             pers_cipher_list=pargs.r.ret_str;
3468             break;
3469           case oPersonalDigestPreferences:
3470             pers_digest_list=pargs.r.ret_str;
3471             break;
3472           case oPersonalCompressPreferences:
3473             pers_compress_list=pargs.r.ret_str;
3474             break;
3475           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3476           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3477           case oWeakDigest:
3478             additional_weak_digest(pargs.r.ret_str);
3479             break;
3480           case oUnwrap:
3481             opt.unwrap_encryption = 1;
3482             break;
3483           case oOnlySignTextIDs:
3484             opt.only_sign_text_ids = 1;
3485             break;
3486
3487           case oDisplay:
3488             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3489             break;
3490           case oTTYname:
3491             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3492             break;
3493           case oTTYtype:
3494             set_opt_session_env ("TERM", pargs.r.ret_str);
3495             break;
3496           case oXauthority:
3497             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3498             break;
3499
3500           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3501           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3502
3503           case oGroup: add_group(pargs.r.ret_str); break;
3504           case oUnGroup: rm_group(pargs.r.ret_str); break;
3505           case oNoGroups:
3506             while(opt.grouplist)
3507               {
3508                 struct groupitem *iter=opt.grouplist;
3509                 free_strlist(iter->values);
3510                 opt.grouplist=opt.grouplist->next;
3511                 xfree(iter);
3512               }
3513             break;
3514
3515           case oStrict:
3516           case oNoStrict:
3517             /* Not used */
3518             break;
3519
3520           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3521           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3522           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3523           case oMultifile: multifile=1; break;
3524           case oKeyidFormat:
3525             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3526               opt.keyid_format=KF_SHORT;
3527             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3528               opt.keyid_format=KF_LONG;
3529             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3530               opt.keyid_format=KF_0xSHORT;
3531             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3532               opt.keyid_format=KF_0xLONG;
3533             else
3534               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3535             break;
3536
3537           case oExitOnStatusWriteError:
3538             opt.exit_on_status_write_error = 1;
3539             break;
3540
3541           case oLimitCardInsertTries:
3542             opt.limit_card_insert_tries = pargs.r.ret_int;
3543             break;
3544
3545           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3546           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3547
3548           case oAutoKeyLocate:
3549             if(!parse_auto_key_locate(pargs.r.ret_str))
3550               {
3551                 if(configname)
3552                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3553                             configname,configlineno);
3554                 else
3555                   log_error(_("invalid auto-key-locate list\n"));
3556               }
3557             break;
3558           case oNoAutoKeyLocate:
3559             release_akl();
3560             break;
3561
3562           case oEnableLargeRSA:
3563 #if SECMEM_BUFFER_SIZE >= 65536
3564             opt.flags.large_rsa=1;
3565 #else
3566             if (configname)
3567               log_info("%s:%d: WARNING: gpg not built with large secure "
3568                          "memory buffer.  Ignoring enable-large-rsa\n",
3569                         configname,configlineno);
3570             else
3571               log_info("WARNING: gpg not built with large secure "
3572                          "memory buffer.  Ignoring --enable-large-rsa\n");
3573 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3574             break;
3575           case oDisableLargeRSA: opt.flags.large_rsa=0;
3576             break;
3577
3578           case oEnableDSA2: opt.flags.dsa2=1; break;
3579           case oDisableDSA2: opt.flags.dsa2=0; break;
3580
3581           case oAllowMultisigVerification:
3582           case oAllowMultipleMessages:
3583             opt.flags.allow_multiple_messages=1;
3584             break;
3585
3586           case oNoAllowMultipleMessages:
3587             opt.flags.allow_multiple_messages=0;
3588             break;
3589
3590           case oAllowWeakDigestAlgos:
3591             opt.flags.allow_weak_digest_algos = 1;
3592             break;
3593
3594           case oFakedSystemTime:
3595             {
3596               time_t faked_time = isotime2epoch (pargs.r.ret_str);
3597               if (faked_time == (time_t)(-1))
3598                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3599               gnupg_set_time (faked_time, 0);
3600             }
3601             break;
3602
3603           case oNoAutostart: opt.autostart = 0; break;
3604
3605           case oNoop: break;
3606
3607           default:
3608             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3609             break;
3610           }
3611       }
3612
3613     if (configfp)
3614       {
3615         fclose( configfp );
3616         configfp = NULL;
3617         /* Remember the first config file name. */
3618         if (!save_configname)
3619           save_configname = configname;
3620         else
3621           xfree(configname);
3622         configname = NULL;
3623         goto next_pass;
3624       }
3625     xfree(configname); configname = NULL;
3626     if (log_get_errorcount (0))
3627       g10_exit(2);
3628
3629     /* The command --gpgconf-list is pretty simple and may be called
3630        directly after the option parsing. */
3631     if (cmd == aGPGConfList)
3632       {
3633         gpgconf_list (save_configname ? save_configname : default_configname);
3634         g10_exit (0);
3635       }
3636     xfree (save_configname);
3637     xfree (default_configname);
3638
3639     if( nogreeting )
3640         greeting = 0;
3641
3642     if( greeting )
3643       {
3644         es_fprintf (es_stderr, "%s %s; %s\n",
3645                     strusage(11), strusage(13), strusage(14) );
3646         es_fprintf (es_stderr, "%s\n", strusage(15) );
3647       }
3648 #ifdef IS_DEVELOPMENT_VERSION
3649     if (!opt.batch)
3650       {
3651         const char *s;
3652
3653         if((s=strusage(25)))
3654           log_info("%s\n",s);
3655         if((s=strusage(26)))
3656           log_info("%s\n",s);
3657         if((s=strusage(27)))
3658           log_info("%s\n",s);
3659       }
3660 #endif
3661
3662     /* FIXME: We should use logging to a file only in server mode;
3663        however we have not yet implemetyed that.  Thus we try to get
3664        away with --batch as indication for logging to file
3665        required. */
3666     if (logfile && opt.batch)
3667       {
3668         log_set_file (logfile);
3669         log_set_prefix (NULL, 1|2|4);
3670       }
3671
3672     if (opt.verbose > 2)
3673         log_info ("using character set '%s'\n", get_native_charset ());
3674
3675     if( may_coredump && !opt.quiet )
3676         log_info(_("WARNING: program may create a core file!\n"));
3677
3678     if (eyes_only) {
3679       if (opt.set_filename)
3680           log_info(_("WARNING: %s overrides %s\n"),
3681                    "--for-your-eyes-only","--set-filename");
3682
3683       opt.set_filename="_CONSOLE";
3684     }
3685
3686     if (opt.no_literal) {
3687         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3688         if (opt.textmode)
3689             log_error(_("%s not allowed with %s!\n"),
3690                        "--textmode", "--no-literal" );
3691         if (opt.set_filename)
3692             log_error(_("%s makes no sense with %s!\n"),
3693                         eyes_only?"--for-your-eyes-only":"--set-filename",
3694                         "--no-literal" );
3695     }
3696
3697
3698     if (opt.set_filesize)
3699         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3700     if( opt.batch )
3701         tty_batchmode( 1 );
3702
3703     if (gnupg_faked_time_p ())
3704       {
3705         gnupg_isotime_t tbuf;
3706
3707         log_info (_("WARNING: running with faked system time: "));
3708         gnupg_get_isotime (tbuf);
3709         dump_isotime (tbuf);
3710         log_printf ("\n");
3711       }
3712
3713     /* Print a warning if an argument looks like an option.  */
3714     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3715       {
3716         int i;
3717
3718         for (i=0; i < argc; i++)
3719           if (argv[i][0] == '-' && argv[i][1] == '-')
3720             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3721       }
3722
3723
3724     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3725
3726     if(require_secmem && !got_secmem)
3727       {
3728         log_info(_("will not run with insecure memory due to %s\n"),
3729                  "--require-secmem");
3730         g10_exit(2);
3731       }
3732
3733     set_debug (debug_level);
3734     if (DBG_CLOCK)
3735       log_clock ("start");
3736
3737     /* Do these after the switch(), so they can override settings. */
3738     if(PGP6)
3739       {
3740         /* That does not anymore work because we have no more support
3741            for v3 signatures.  */
3742         opt.disable_mdc=1;
3743         opt.escape_from=1;
3744         opt.ask_sig_expire=0;
3745       }
3746     else if(PGP7)
3747       {
3748         /* That does not anymore work because we have no more support
3749            for v3 signatures.  */
3750         opt.escape_from=1;
3751         opt.ask_sig_expire=0;
3752       }
3753     else if(PGP8)
3754       {
3755         opt.escape_from=1;
3756       }
3757
3758
3759     if( def_cipher_string ) {
3760         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3761         xfree(def_cipher_string); def_cipher_string = NULL;
3762         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3763             log_error(_("selected cipher algorithm is invalid\n"));
3764     }
3765     if( def_digest_string ) {
3766         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3767         xfree(def_digest_string); def_digest_string = NULL;
3768         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3769             log_error(_("selected digest algorithm is invalid\n"));
3770     }
3771     if( compress_algo_string ) {
3772         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3773         xfree(compress_algo_string); compress_algo_string = NULL;
3774         if( check_compress_algo(opt.compress_algo) )
3775           log_error(_("selected compression algorithm is invalid\n"));
3776     }
3777     if( cert_digest_string ) {
3778         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3779         xfree(cert_digest_string); cert_digest_string = NULL;
3780         if (openpgp_md_test_algo(opt.cert_digest_algo))
3781           log_error(_("selected certification digest algorithm is invalid\n"));
3782     }
3783     if( s2k_cipher_string ) {
3784         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3785         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3786         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3787           log_error(_("selected cipher algorithm is invalid\n"));
3788     }
3789     if( s2k_digest_string ) {
3790         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3791         xfree(s2k_digest_string); s2k_digest_string = NULL;
3792         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3793           log_error(_("selected digest algorithm is invalid\n"));
3794     }
3795     if( opt.completes_needed < 1 )
3796       log_error(_("completes-needed must be greater than 0\n"));
3797     if( opt.marginals_needed < 2 )
3798       log_error(_("marginals-needed must be greater than 1\n"));
3799     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3800       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3801     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3802       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3803     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3804       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3805     switch( opt.s2k_mode ) {
3806       case 0:
3807         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3808         break;
3809       case 1: case 3: break;
3810       default:
3811         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3812     }
3813
3814     /* This isn't actually needed, but does serve to error out if the
3815        string is invalid. */
3816     if(opt.def_preference_list &&
3817         keygen_set_std_prefs(opt.def_preference_list,0))
3818       log_error(_("invalid default preferences\n"));
3819
3820     if(pers_cipher_list &&
3821        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3822       log_error(_("invalid personal cipher preferences\n"));
3823
3824     if(pers_digest_list &&
3825        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3826       log_error(_("invalid personal digest preferences\n"));
3827
3828     if(pers_compress_list &&
3829        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3830       log_error(_("invalid personal compress preferences\n"));
3831
3832     /* We don't support all possible commands with multifile yet */
3833     if(multifile)
3834       {
3835         char *cmdname;
3836
3837         switch(cmd)
3838           {
3839           case aSign:
3840             cmdname="--sign";
3841             break;
3842           case aSignEncr:
3843             cmdname="--sign --encrypt";
3844             break;
3845           case aClearsign:
3846             cmdname="--clearsign";
3847             break;
3848           case aDetachedSign:
3849             cmdname="--detach-sign";
3850             break;
3851           case aSym:
3852             cmdname="--symmetric";
3853             break;
3854           case aEncrSym:
3855             cmdname="--symmetric --encrypt";
3856             break;
3857           case aStore:
3858             cmdname="--store";
3859             break;
3860           default:
3861             cmdname=NULL;
3862             break;
3863           }
3864
3865         if(cmdname)
3866           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3867       }
3868
3869     if( log_get_errorcount(0) )
3870         g10_exit(2);
3871
3872     if(opt.compress_level==0)
3873       opt.compress_algo=COMPRESS_ALGO_NONE;
3874
3875     /* Check our chosen algorithms against the list of legal
3876        algorithms. */
3877
3878     if(!GNUPG)
3879       {
3880         const char *badalg=NULL;
3881         preftype_t badtype=PREFTYPE_NONE;
3882
3883         if(opt.def_cipher_algo
3884            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3885           {
3886             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3887             badtype = PREFTYPE_SYM;
3888           }
3889         else if(opt.def_digest_algo
3890                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3891           {
3892             badalg = gcry_md_algo_name (opt.def_digest_algo);
3893             badtype = PREFTYPE_HASH;
3894           }
3895         else if(opt.cert_digest_algo
3896                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3897           {
3898             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3899             badtype = PREFTYPE_HASH;
3900           }
3901         else if(opt.compress_algo!=-1
3902                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3903           {
3904             badalg = compress_algo_to_string(opt.compress_algo);
3905             badtype = PREFTYPE_ZIP;
3906           }
3907
3908         if(badalg)
3909           {
3910             switch(badtype)
3911               {
3912               case PREFTYPE_SYM:
3913                 log_info(_("you may not use cipher algorithm '%s'"
3914                            " while in %s mode\n"),
3915                          badalg,compliance_option_string());
3916                 break;
3917               case PREFTYPE_HASH:
3918                 log_info(_("you may not use digest algorithm '%s'"
3919                            " while in %s mode\n"),
3920                          badalg,compliance_option_string());
3921                 break;
3922               case PREFTYPE_ZIP:
3923                 log_info(_("you may not use compression algorithm '%s'"
3924                            " while in %s mode\n"),
3925                          badalg,compliance_option_string());
3926                 break;
3927               default:
3928                 BUG();
3929               }
3930
3931             compliance_failure();
3932           }
3933       }
3934
3935     /* Set the random seed file. */
3936     if( use_random_seed ) {
3937         char *p = make_filename(opt.homedir, "random_seed", NULL );
3938         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3939         if (!access (p, F_OK))
3940           register_secured_file (p);
3941         xfree(p);
3942     }
3943
3944     /* If there is no command but the --fingerprint is given, default
3945        to the --list-keys command.  */
3946     if (!cmd && fpr_maybe_cmd)
3947       {
3948         set_cmd (&cmd, aListKeys);
3949       }
3950
3951
3952     if( opt.verbose > 1 )
3953         set_packet_list_mode(1);
3954
3955     /* Add the keyrings, but not for some special commands.
3956        We always need to add the keyrings if we are running under
3957        SELinux, this is so that the rings are added to the list of
3958        secured files. */
3959     if( ALWAYS_ADD_KEYRINGS
3960         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) )
3961       {
3962         if (!nrings || default_keyring)  /* Add default ring. */
3963             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3964                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3965         for (sl = nrings; sl; sl = sl->next )
3966           keydb_add_resource (sl->d, sl->flags);
3967       }
3968     FREE_STRLIST(nrings);
3969
3970     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
3971       /* In loopback mode, never ask for the password multiple
3972          times.  */
3973       {
3974         opt.passphrase_repeat = 0;
3975       }
3976
3977     if (cmd == aGPGConfTest)
3978       g10_exit(0);
3979
3980
3981     if( pwfd != -1 )  /* Read the passphrase now. */
3982         read_passphrase_from_fd( pwfd );
3983
3984     fname = argc? *argv : NULL;
3985
3986     if(fname && utf8_strings)
3987       opt.flags.utf8_filename=1;
3988
3989     ctrl = xcalloc (1, sizeof *ctrl);
3990     gpg_init_default_ctrl (ctrl);
3991
3992 #ifndef NO_TRUST_MODELS
3993     switch (cmd)
3994       {
3995       case aPrimegen:
3996       case aPrintMD:
3997       case aPrintMDs:
3998       case aGenRandom:
3999       case aDeArmor:
4000       case aEnArmor:
4001         break;
4002       case aFixTrustDB:
4003       case aExportOwnerTrust:
4004         rc = setup_trustdb (0, trustdb_name);
4005         break;
4006       case aListTrustDB:
4007         rc = setup_trustdb (argc? 1:0, trustdb_name);
4008         break;
4009       default:
4010         /* If we are using TM_ALWAYS, we do not need to create the
4011            trustdb.  */
4012         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
4013         break;
4014       }
4015     if (rc)
4016       log_error (_("failed to initialize the TrustDB: %s\n"),
4017                  gpg_strerror (rc));
4018 #endif /*!NO_TRUST_MODELS*/
4019
4020     switch (cmd)
4021       {
4022       case aStore:
4023       case aSym:
4024       case aSign:
4025       case aSignSym:
4026       case aClearsign:
4027         if (!opt.quiet && any_explicit_recipient)
4028           log_info (_("WARNING: recipients (-r) given "
4029                       "without using public key encryption\n"));
4030         break;
4031       default:
4032         break;
4033       }
4034
4035
4036     /* Check for certain command whether we need to migrate a
4037        secring.gpg to the gpg-agent. */
4038     switch (cmd)
4039       {
4040       case aListSecretKeys:
4041       case aSign:
4042       case aSignEncr:
4043       case aSignEncrSym:
4044       case aSignSym:
4045       case aClearsign:
4046       case aDecrypt:
4047       case aSignKey:
4048       case aLSignKey:
4049       case aEditKey:
4050       case aPasswd:
4051       case aDeleteSecretKeys:
4052       case aDeleteSecretAndPublicKeys:
4053       case aQuickKeygen:
4054       case aQuickAddUid:
4055       case aFullKeygen:
4056       case aKeygen:
4057       case aImport:
4058       case aExportSecret:
4059       case aExportSecretSub:
4060       case aGenRevoke:
4061       case aDesigRevoke:
4062       case aCardEdit:
4063       case aChangePIN:
4064         migrate_secring (ctrl);
4065         break;
4066       case aListKeys:
4067         if (opt.with_secret)
4068           migrate_secring (ctrl);
4069         break;
4070       default:
4071         break;
4072       }
4073
4074     {
4075       int have_def_secret_key = opt.def_secret_key != NULL;
4076
4077       rc = check_user_ids (&locusr, 1, 1);
4078       if (rc)
4079         g10_exit (1);
4080       rc = check_user_ids (&remusr, 0, 1);
4081       if (rc)
4082         g10_exit (1);
4083       rc = check_user_ids (&opt.def_secret_key, 1, 0);
4084       if (rc)
4085         g10_exit (1);
4086
4087       if (opt.encrypt_to_default_key)
4088         {
4089           const char *default_key = parse_def_secret_key (ctrl);
4090           if (default_key)
4091             {
4092               sl = add_to_strlist2 (&remusr, default_key, utf8_strings);
4093               sl->flags = ((oEncryptToDefaultKey << PK_LIST_SHIFT)
4094                            | PK_LIST_ENCRYPT_TO);
4095             }
4096           else if (have_def_secret_key)
4097             log_info (_("option '%s' given, but no valid default keys given\n"),
4098                       "--encrypt-to-default-key");
4099           else
4100             log_info (_("option '%s' given, but option '%s' not given\n"),
4101                       "--encrypt-to-default-key", "--default-key");
4102         }
4103     }
4104
4105     /* The command dispatcher.  */
4106     switch( cmd )
4107       {
4108       case aServer:
4109         gpg_server (ctrl);
4110         break;
4111
4112       case aStore: /* only store the file */
4113         if( argc > 1 )
4114             wrong_args(_("--store [filename]"));
4115         if( (rc = encrypt_store(fname)) )
4116           {
4117             write_status_failure ("store", rc);
4118             log_error ("storing '%s' failed: %s\n",
4119                        print_fname_stdin(fname),gpg_strerror (rc) );
4120           }
4121         break;
4122       case aSym: /* encrypt the given file only with the symmetric cipher */
4123         if( argc > 1 )
4124             wrong_args(_("--symmetric [filename]"));
4125         if( (rc = encrypt_symmetric(fname)) )
4126           {
4127             write_status_failure ("symencrypt", rc);
4128             log_error (_("symmetric encryption of '%s' failed: %s\n"),
4129                         print_fname_stdin(fname),gpg_strerror (rc) );
4130           }
4131         break;
4132
4133       case aEncr: /* encrypt the given file */
4134         if(multifile)
4135           encrypt_crypt_files (ctrl, argc, argv, remusr);
4136         else
4137           {
4138             if( argc > 1 )
4139               wrong_args(_("--encrypt [filename]"));
4140             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
4141               {
4142                 write_status_failure ("encrypt", rc);
4143                 log_error("%s: encryption failed: %s\n",
4144                           print_fname_stdin(fname), gpg_strerror (rc) );
4145               }
4146           }
4147         break;
4148
4149       case aEncrSym:
4150         /* This works with PGP 8 in the sense that it acts just like a
4151            symmetric message.  It doesn't work at all with 2 or 6.  It
4152            might work with 7, but alas, I don't have a copy to test
4153            with right now. */
4154         if( argc > 1 )
4155           wrong_args(_("--symmetric --encrypt [filename]"));
4156         else if(opt.s2k_mode==0)
4157           log_error(_("you cannot use --symmetric --encrypt"
4158                       " with --s2k-mode 0\n"));
4159         else if(PGP6 || PGP7)
4160           log_error(_("you cannot use --symmetric --encrypt"
4161                       " while in %s mode\n"),compliance_option_string());
4162         else
4163           {
4164             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
4165               {
4166                 write_status_failure ("encrypt", rc);
4167                 log_error ("%s: encryption failed: %s\n",
4168                            print_fname_stdin(fname), gpg_strerror (rc) );
4169               }
4170           }
4171         break;
4172
4173       case aSign: /* sign the given file */
4174         sl = NULL;
4175         if( detached_sig ) { /* sign all files */
4176             for( ; argc; argc--, argv++ )
4177                 add_to_strlist( &sl, *argv );
4178         }
4179         else {
4180             if( argc > 1 )
4181                 wrong_args(_("--sign [filename]"));
4182             if( argc ) {
4183                 sl = xmalloc_clear( sizeof *sl + strlen(fname));