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