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