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