tests: Add a first v5 sample key
[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   opt.flags.rfc4880bis = 0;  /* Clear becuase it is initially set.  */
2152
2153   switch (option)
2154     {
2155     case oRFC4880bis:
2156       opt.flags.rfc4880bis = 1;
2157       /* fall through.  */
2158     case oOpenPGP:
2159     case oRFC4880:
2160       /* This is effectively the same as RFC2440, but with
2161          "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2162          --require-cross-certification". */
2163       opt.compliance = CO_RFC4880;
2164       opt.flags.dsa2 = 1;
2165       opt.flags.require_cross_cert = 1;
2166       opt.rfc2440_text = 0;
2167       opt.allow_non_selfsigned_uid = 1;
2168       opt.allow_freeform_uid = 1;
2169       opt.escape_from = 1;
2170       opt.not_dash_escaped = 0;
2171       opt.def_cipher_algo = 0;
2172       opt.def_aead_algo = 0;
2173       opt.def_digest_algo = 0;
2174       opt.cert_digest_algo = 0;
2175       opt.compress_algo = -1;
2176       opt.s2k_mode = 3; /* iterated+salted */
2177       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2178       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2179       break;
2180     case oRFC2440:
2181       opt.compliance = CO_RFC2440;
2182       opt.flags.dsa2 = 0;
2183       opt.rfc2440_text = 1;
2184       opt.allow_non_selfsigned_uid = 1;
2185       opt.allow_freeform_uid = 1;
2186       opt.escape_from = 0;
2187       opt.not_dash_escaped = 0;
2188       opt.def_cipher_algo = 0;
2189       opt.def_aead_algo = 0;
2190       opt.def_digest_algo = 0;
2191       opt.cert_digest_algo = 0;
2192       opt.compress_algo = -1;
2193       opt.s2k_mode = 3; /* iterated+salted */
2194       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2195       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2196       break;
2197     case oPGP7:  opt.compliance = CO_PGP7;  break;
2198     case oPGP8:  opt.compliance = CO_PGP8;  break;
2199     case oGnuPG:
2200       opt.compliance = CO_GNUPG;
2201       opt.flags.rfc4880bis = 1;
2202       break;
2203
2204     case oDE_VS:
2205       set_compliance_option (oOpenPGP);
2206       opt.compliance = CO_DE_VS;
2207       opt.def_aead_algo = 0;
2208       /* Fixme: Change other options.  */
2209       break;
2210
2211     default:
2212       BUG ();
2213     }
2214 }
2215
2216
2217
2218
2219
2220
2221 /* This function called to initialized a new control object.  It is
2222    assumed that this object has been zeroed out before calling this
2223    function. */
2224 static void
2225 gpg_init_default_ctrl (ctrl_t ctrl)
2226 {
2227   ctrl->magic = SERVER_CONTROL_MAGIC;
2228 }
2229
2230
2231 /* This function is called to deinitialize a control object.  It is
2232    not deallocated. */
2233 static void
2234 gpg_deinit_default_ctrl (ctrl_t ctrl)
2235 {
2236 #ifdef USE_TOFU
2237   tofu_closedbs (ctrl);
2238 #endif
2239   gpg_dirmngr_deinit_session_data (ctrl);
2240
2241   keydb_release (ctrl->cached_getkey_kdb);
2242 }
2243
2244
2245 char *
2246 get_default_configname (void)
2247 {
2248   char *configname = NULL;
2249   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
2250   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
2251
2252   do
2253     {
2254       if (configname)
2255         {
2256           char *tok;
2257
2258           xfree (configname);
2259           configname = NULL;
2260
2261           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
2262             *tok='\0';
2263           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
2264             *tok='\0';
2265           else
2266             break;
2267         }
2268
2269       configname = make_filename (gnupg_homedir (), name, NULL);
2270     }
2271   while (access (configname, R_OK));
2272
2273   xfree(name);
2274
2275   if (! configname)
2276     configname = make_filename (gnupg_homedir (),
2277                                 GPG_NAME EXTSEP_S "conf", NULL);
2278   if (! access (configname, R_OK))
2279     {
2280       /* Print a warning when both config files are present.  */
2281       char *p = make_filename (gnupg_homedir (), "options", NULL);
2282       if (! access (p, R_OK))
2283         log_info (_("Note: old default options file '%s' ignored\n"), p);
2284       xfree (p);
2285     }
2286   else
2287     {
2288       /* Use the old default only if it exists.  */
2289       char *p = make_filename (gnupg_homedir (), "options", NULL);
2290       if (!access (p, R_OK))
2291         {
2292           xfree (configname);
2293           configname = p;
2294         }
2295       else
2296         xfree (p);
2297     }
2298
2299   return configname;
2300 }
2301
2302 int
2303 main (int argc, char **argv)
2304 {
2305     ARGPARSE_ARGS pargs;
2306     IOBUF a;
2307     int rc=0;
2308     int orig_argc;
2309     char **orig_argv;
2310     const char *fname;
2311     char *username;
2312     int may_coredump;
2313     strlist_t sl;
2314     strlist_t remusr = NULL;
2315     strlist_t locusr = NULL;
2316     strlist_t nrings = NULL;
2317     armor_filter_context_t *afx = NULL;
2318     int detached_sig = 0;
2319     FILE *configfp = NULL;
2320     char *configname = NULL;
2321     char *save_configname = NULL;
2322     char *default_configname = NULL;
2323     unsigned configlineno;
2324     int parse_debug = 0;
2325     int default_config = 1;
2326     int default_keyring = 1;
2327     int greeting = 0;
2328     int nogreeting = 0;
2329     char *logfile = NULL;
2330     int use_random_seed = 1;
2331     enum cmd_and_opt_values cmd = 0;
2332     const char *debug_level = NULL;
2333 #ifndef NO_TRUST_MODELS
2334     const char *trustdb_name = NULL;
2335 #endif /*!NO_TRUST_MODELS*/
2336     char *def_cipher_string = NULL;
2337     char *def_aead_string = NULL;
2338     char *def_digest_string = NULL;
2339     char *compress_algo_string = NULL;
2340     char *cert_digest_string = NULL;
2341     char *s2k_cipher_string = NULL;
2342     char *s2k_digest_string = NULL;
2343     char *pers_cipher_list = NULL;
2344     char *pers_aead_list = NULL;
2345     char *pers_digest_list = NULL;
2346     char *pers_compress_list = NULL;
2347     int eyes_only=0;
2348     int multifile=0;
2349     int pwfd = -1;
2350     int ovrseskeyfd = -1;
2351     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2352     int any_explicit_recipient = 0;
2353     int default_akl = 1;
2354     int require_secmem = 0;
2355     int got_secmem = 0;
2356     struct assuan_malloc_hooks malloc_hooks;
2357     ctrl_t ctrl;
2358
2359     static int print_dane_records;
2360     static int print_pka_records;
2361     static int allow_large_chunks;
2362
2363
2364 #ifdef __riscos__
2365     opt.lock_once = 1;
2366 #endif /* __riscos__ */
2367
2368     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2369        when adding any stuff between here and the call to
2370        secmem_init() somewhere after the option parsing. */
2371     early_system_init ();
2372     gnupg_reopen_std (GPG_NAME);
2373     trap_unaligned ();
2374     gnupg_rl_initialize ();
2375     set_strusage (my_strusage);
2376     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2377     log_set_prefix (GPG_NAME, GPGRT_LOG_WITH_PREFIX);
2378
2379     /* Make sure that our subsystems are ready.  */
2380     i18n_init();
2381     init_common_subsystems (&argc, &argv);
2382
2383     /* Use our own logging handler for Libcgrypt.  */
2384     setup_libgcrypt_logging ();
2385
2386     /* Put random number into secure memory */
2387     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2388
2389     may_coredump = disable_core_dumps();
2390
2391     gnupg_init_signals (0, emergency_cleanup);
2392
2393     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2394
2395     /* Tell the compliance module who we are.  */
2396     gnupg_initialize_compliance (GNUPG_MODULE_NAME_GPG);
2397
2398     opt.autostart = 1;
2399     opt.session_env = session_env_new ();
2400     if (!opt.session_env)
2401       log_fatal ("error allocating session environment block: %s\n",
2402                  strerror (errno));
2403
2404     opt.command_fd = -1; /* no command fd */
2405     opt.compress_level = -1; /* defaults to standard compress level */
2406     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2407     /* note: if you change these lines, look at oOpenPGP */
2408     opt.def_cipher_algo = 0;
2409     opt.def_aead_algo = 0;
2410     opt.def_digest_algo = 0;
2411     opt.cert_digest_algo = 0;
2412     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2413     opt.s2k_mode = 3; /* iterated+salted */
2414     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2415     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2416     opt.completes_needed = 1;
2417     opt.marginals_needed = 3;
2418     opt.max_cert_depth = 5;
2419     opt.escape_from = 1;
2420     opt.flags.require_cross_cert = 1;
2421     opt.import_options = IMPORT_REPAIR_KEYS;
2422     opt.export_options = EXPORT_ATTRIBUTES;
2423     opt.keyserver_options.import_options = (IMPORT_REPAIR_KEYS
2424                                             | IMPORT_REPAIR_PKS_SUBKEY_BUG);
2425     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2426     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2427     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2428                           | VERIFY_SHOW_POLICY_URLS
2429                           | VERIFY_SHOW_STD_NOTATIONS
2430                           | VERIFY_SHOW_KEYSERVER_URLS);
2431     opt.list_options   = (LIST_SHOW_UID_VALIDITY
2432                           | LIST_SHOW_USAGE);
2433 #ifdef NO_TRUST_MODELS
2434     opt.trust_model = TM_ALWAYS;
2435 #else
2436     opt.trust_model = TM_AUTO;
2437 #endif
2438     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2439     opt.mangle_dos_filenames = 0;
2440     opt.min_cert_level = 2;
2441     set_screen_dimensions ();
2442     opt.keyid_format = KF_NONE;
2443     opt.def_sig_expire = "0";
2444     opt.def_cert_expire = "0";
2445     gnupg_set_homedir (NULL);
2446     opt.passphrase_repeat = 1;
2447     opt.emit_version = 0;
2448     opt.weak_digests = NULL;
2449     opt.compliance = CO_GNUPG;
2450     opt.flags.rfc4880bis = 1;
2451
2452     /* Check whether we have a config file on the command line.  */
2453     orig_argc = argc;
2454     orig_argv = argv;
2455     pargs.argc = &argc;
2456     pargs.argv = &argv;
2457     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2458     while( arg_parse( &pargs, opts) ) {
2459         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2460             parse_debug++;
2461         else if (pargs.r_opt == oDebugIOLBF)
2462             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2463         else if( pargs.r_opt == oOptions ) {
2464             /* yes there is one, so we do not try the default one, but
2465              * read the option file when it is encountered at the commandline
2466              */
2467             default_config = 0;
2468         }
2469         else if( pargs.r_opt == oNoOptions )
2470           {
2471             default_config = 0; /* --no-options */
2472             opt.no_homedir_creation = 1;
2473           }
2474         else if( pargs.r_opt == oHomedir )
2475             gnupg_set_homedir (pargs.r.ret_str);
2476         else if( pargs.r_opt == oNoPermissionWarn )
2477             opt.no_perm_warn=1;
2478         else if (pargs.r_opt == oStrict )
2479           {
2480             /* Not used */
2481           }
2482         else if (pargs.r_opt == oNoStrict )
2483           {
2484             /* Not used */
2485           }
2486     }
2487
2488 #ifdef HAVE_DOSISH_SYSTEM
2489     if ( strchr (gnupg_homedir (), '\\') ) {
2490       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
2491       const char *s;
2492       for (d=buf, s = gnupg_homedir (); *s; s++)
2493           {
2494             *d++ = *s == '\\'? '/': *s;
2495 #ifdef HAVE_W32_SYSTEM
2496             if (s[1] && IsDBCSLeadByte (*s))
2497               *d++ = *++s;
2498 #endif
2499           }
2500         *d = 0;
2501         gnupg_set_homedir (buf);
2502     }
2503 #endif
2504
2505     /* Initialize the secure memory. */
2506     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2507       got_secmem = 1;
2508 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2509     /* There should be no way to get to this spot while still carrying
2510        setuid privs.  Just in case, bomb out if we are. */
2511     if ( getuid () != geteuid () )
2512       BUG ();
2513 #endif
2514     maybe_setuid = 0;
2515
2516     /* Okay, we are now working under our real uid */
2517
2518     /* malloc hooks go here ... */
2519     malloc_hooks.malloc = gcry_malloc;
2520     malloc_hooks.realloc = gcry_realloc;
2521     malloc_hooks.free = gcry_free;
2522     assuan_set_malloc_hooks (&malloc_hooks);
2523     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2524     setup_libassuan_logging (&opt.debug, NULL);
2525
2526     /* Set default options which require that malloc stuff is ready.  */
2527     additional_weak_digest ("MD5");
2528     parse_auto_key_locate ("local,wkd");
2529
2530     /* Try for a version specific config file first */
2531     default_configname = get_default_configname ();
2532     if (default_config)
2533       configname = xstrdup (default_configname);
2534
2535     argc = orig_argc;
2536     argv = orig_argv;
2537     pargs.argc = &argc;
2538     pargs.argv = &argv;
2539     pargs.flags= ARGPARSE_FLAG_KEEP;
2540
2541     /* By this point we have a homedir, and cannot change it. */
2542     check_permissions (gnupg_homedir (), 0);
2543
2544   next_pass:
2545     if( configname ) {
2546       if(check_permissions(configname,1))
2547         {
2548           /* If any options file is unsafe, then disable any external
2549              programs for keyserver calls or photo IDs.  Since the
2550              external program to call is set in the options file, a
2551              unsafe options file can lead to an arbitrary program
2552              being run. */
2553
2554           opt.exec_disable=1;
2555         }
2556
2557         configlineno = 0;
2558         configfp = fopen( configname, "r" );
2559         if (configfp && is_secured_file (fileno (configfp)))
2560           {
2561             fclose (configfp);
2562             configfp = NULL;
2563             gpg_err_set_errno (EPERM);
2564           }
2565         if( !configfp ) {
2566             if( default_config ) {
2567                 if( parse_debug )
2568                     log_info(_("Note: no default option file '%s'\n"),
2569                                                             configname );
2570             }
2571             else {
2572                 log_error(_("option file '%s': %s\n"),
2573                                     configname, strerror(errno) );
2574                 g10_exit(2);
2575             }
2576             xfree(configname); configname = NULL;
2577         }
2578         if( parse_debug && configname )
2579             log_info(_("reading options from '%s'\n"), configname );
2580         default_config = 0;
2581     }
2582
2583     while( optfile_parse( configfp, configname, &configlineno,
2584                                                 &pargs, opts) )
2585       {
2586         switch( pargs.r_opt )
2587           {
2588           case aListConfig:
2589           case aListGcryptConfig:
2590           case aGPGConfList:
2591           case aGPGConfTest:
2592             set_cmd (&cmd, pargs.r_opt);
2593             /* Do not register a keyring for these commands.  */
2594             default_keyring = -1;
2595             break;
2596
2597           case aCheckKeys:
2598           case aListPackets:
2599           case aImport:
2600           case aFastImport:
2601           case aSendKeys:
2602           case aRecvKeys:
2603           case aSearchKeys:
2604           case aRefreshKeys:
2605           case aFetchKeys:
2606           case aExport:
2607 #ifdef ENABLE_CARD_SUPPORT
2608           case aCardStatus:
2609           case aCardEdit:
2610           case aChangePIN:
2611 #endif /* ENABLE_CARD_SUPPORT*/
2612           case aListKeys:
2613           case aLocateKeys:
2614           case aListSigs:
2615           case aExportSecret:
2616           case aExportSecretSub:
2617           case aExportSshKey:
2618           case aSym:
2619           case aClearsign:
2620           case aGenRevoke:
2621           case aDesigRevoke:
2622           case aPrimegen:
2623           case aGenRandom:
2624           case aPrintMD:
2625           case aPrintMDs:
2626           case aListTrustDB:
2627           case aCheckTrustDB:
2628           case aUpdateTrustDB:
2629           case aFixTrustDB:
2630           case aListTrustPath:
2631           case aDeArmor:
2632           case aEnArmor:
2633           case aSign:
2634           case aQuickSignKey:
2635           case aQuickLSignKey:
2636           case aSignKey:
2637           case aLSignKey:
2638           case aStore:
2639           case aQuickKeygen:
2640           case aQuickAddUid:
2641           case aQuickAddKey:
2642           case aQuickRevUid:
2643           case aQuickSetExpire:
2644           case aQuickSetPrimaryUid:
2645           case aExportOwnerTrust:
2646           case aImportOwnerTrust:
2647           case aRebuildKeydbCaches:
2648             set_cmd (&cmd, pargs.r_opt);
2649             break;
2650
2651           case aKeygen:
2652           case aFullKeygen:
2653           case aEditKey:
2654           case aDeleteSecretKeys:
2655           case aDeleteSecretAndPublicKeys:
2656           case aDeleteKeys:
2657           case aPasswd:
2658             set_cmd (&cmd, pargs.r_opt);
2659             greeting=1;
2660             break;
2661
2662           case aShowKeys:
2663             set_cmd (&cmd, pargs.r_opt);
2664             opt.import_options |= IMPORT_SHOW;
2665             opt.import_options |= IMPORT_DRY_RUN;
2666             opt.import_options &= ~IMPORT_REPAIR_KEYS;
2667             opt.list_options |= LIST_SHOW_UNUSABLE_UIDS;
2668             opt.list_options |= LIST_SHOW_UNUSABLE_SUBKEYS;
2669             opt.list_options |= LIST_SHOW_NOTATIONS;
2670             opt.list_options |= LIST_SHOW_POLICY_URLS;
2671             break;
2672
2673           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2674
2675           case aDecryptFiles: multifile=1; /* fall through */
2676           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2677
2678           case aEncrFiles: multifile=1; /* fall through */
2679           case aEncr: set_cmd( &cmd, aEncr); break;
2680
2681           case aVerifyFiles: multifile=1; /* fall through */
2682           case aVerify: set_cmd( &cmd, aVerify); break;
2683
2684           case aServer:
2685             set_cmd (&cmd, pargs.r_opt);
2686             opt.batch = 1;
2687             break;
2688
2689           case aTOFUPolicy:
2690             set_cmd (&cmd, pargs.r_opt);
2691             break;
2692
2693           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2694           case oOutput: opt.outfile = pargs.r.ret_str; break;
2695
2696           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2697
2698           case oInputSizeHint:
2699             opt.input_size_hint = string_to_u64 (pargs.r.ret_str);
2700             break;
2701
2702           case oChunkSize:
2703             opt.chunk_size = pargs.r.ret_int;
2704             break;
2705
2706           case oQuiet: opt.quiet = 1; break;
2707           case oNoTTY: tty_no_terminal(1); break;
2708           case oDryRun: opt.dry_run = 1; break;
2709           case oInteractive: opt.interactive = 1; break;
2710           case oVerbose:
2711             opt.verbose++;
2712             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2713             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2714             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2715             break;
2716
2717           case oBatch:
2718             opt.batch = 1;
2719             nogreeting = 1;
2720             break;
2721
2722           case oUseAgent: /* Dummy. */
2723             break;
2724
2725           case oNoUseAgent:
2726             obsolete_option (configname, configlineno, "no-use-agent");
2727             break;
2728           case oGpgAgentInfo:
2729             obsolete_option (configname, configlineno, "gpg-agent-info");
2730             break;
2731           case oReaderPort:
2732             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2733             break;
2734           case octapiDriver:
2735             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2736             break;
2737           case opcscDriver:
2738             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2739             break;
2740           case oDisableCCID:
2741             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2742             break;
2743           case oHonorHttpProxy:
2744             obsolete_option (configname, configlineno, "honor-http-proxy");
2745             break;
2746
2747           case oAnswerYes: opt.answer_yes = 1; break;
2748           case oAnswerNo: opt.answer_no = 1; break;
2749           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2750           case oPrimaryKeyring:
2751             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2752             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2753             break;
2754           case oShowKeyring:
2755             deprecated_warning(configname,configlineno,"--show-keyring",
2756                                "--list-options ","show-keyring");
2757             opt.list_options|=LIST_SHOW_KEYRING;
2758             break;
2759
2760           case oDebug:
2761             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2762               {
2763                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2764                 pargs.err = ARGPARSE_PRINT_ERROR;
2765               }
2766             break;
2767
2768           case oDebugAll: opt.debug = ~0; break;
2769           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2770
2771           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2772
2773           case oDebugSetIobufSize:
2774             opt_set_iobuf_size = pargs.r.ret_ulong;
2775             opt_set_iobuf_size_used = 1;
2776             break;
2777
2778           case oDebugAllowLargeChunks:
2779             allow_large_chunks = 1;
2780             break;
2781
2782           case oStatusFD:
2783             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2784             break;
2785           case oStatusFile:
2786             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2787             break;
2788           case oAttributeFD:
2789             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2790             break;
2791           case oAttributeFile:
2792             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2793             break;
2794           case oLoggerFD:
2795             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2796             break;
2797           case oLoggerFile:
2798             logfile = pargs.r.ret_str;
2799             break;
2800
2801           case oWithFingerprint:
2802             opt.with_fingerprint = 1;
2803             opt.fingerprint++;
2804             break;
2805           case oWithSubkeyFingerprint:
2806             opt.with_subkey_fingerprint = 1;
2807             break;
2808           case oWithICAOSpelling:
2809             opt.with_icao_spelling = 1;
2810             break;
2811           case oFingerprint:
2812             opt.fingerprint++;
2813             fpr_maybe_cmd = 1;
2814             break;
2815
2816           case oWithKeygrip:
2817             opt.with_keygrip = 1;
2818             break;
2819
2820           case oWithKeyScreening:
2821             opt.with_key_screening = 1;
2822             break;
2823
2824           case oWithSecret:
2825             opt.with_secret = 1;
2826             break;
2827
2828           case oWithWKDHash:
2829             opt.with_wkd_hash = 1;
2830             break;
2831
2832           case oWithKeyOrigin:
2833             opt.with_key_origin = 1;
2834             break;
2835
2836           case oSecretKeyring:
2837             /* Ignore this old option.  */
2838             break;
2839
2840           case oOptions:
2841             /* config files may not be nested (silently ignore them) */
2842             if( !configfp ) {
2843                 xfree(configname);
2844                 configname = xstrdup(pargs.r.ret_str);
2845                 goto next_pass;
2846             }
2847             break;
2848           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2849
2850           case oNoDefKeyring:
2851             if (default_keyring > 0)
2852               default_keyring = 0;
2853             break;
2854           case oNoKeyring:
2855             default_keyring = -1;
2856             break;
2857
2858           case oNoGreeting: nogreeting = 1; break;
2859           case oNoVerbose:
2860             opt.verbose = 0;
2861             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2862             opt.list_sigs=0;
2863             break;
2864           case oQuickRandom:
2865             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2866             break;
2867           case oEmitVersion: opt.emit_version++; break;
2868           case oNoEmitVersion: opt.emit_version=0; break;
2869           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2870           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2871           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2872
2873 #ifndef NO_TRUST_MODELS
2874           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2875
2876 #endif /*!NO_TRUST_MODELS*/
2877           case oDefaultKey:
2878             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2879             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2880             if (configfp)
2881               sl->flags |= PK_LIST_CONFIG;
2882             break;
2883           case oDefRecipient:
2884             if( *pargs.r.ret_str )
2885               {
2886                 xfree (opt.def_recipient);
2887                 opt.def_recipient = make_username(pargs.r.ret_str);
2888               }
2889             break;
2890           case oDefRecipientSelf:
2891             xfree(opt.def_recipient); opt.def_recipient = NULL;
2892             opt.def_recipient_self = 1;
2893             break;
2894           case oNoDefRecipient:
2895             xfree(opt.def_recipient); opt.def_recipient = NULL;
2896             opt.def_recipient_self = 0;
2897             break;
2898           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2899           case oHomedir: break;
2900           case oNoBatch: opt.batch = 0; break;
2901
2902           case oWithTofuInfo: opt.with_tofu_info = 1; break;
2903
2904           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2905           case oWithColons: opt.with_colons=':'; break;
2906
2907           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2908           case oWithSigList: opt.list_sigs = 1; break;
2909
2910           case oSkipVerify: opt.skip_verify=1; break;
2911
2912           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2913           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2914
2915           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2916
2917 #ifndef NO_TRUST_MODELS
2918             /* There are many programs (like mutt) that call gpg with
2919                --always-trust so keep this option around for a long
2920                time. */
2921           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2922           case oTrustModel:
2923             parse_trust_model(pargs.r.ret_str);
2924             break;
2925 #endif /*!NO_TRUST_MODELS*/
2926           case oTOFUDefaultPolicy:
2927             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2928             break;
2929           case oTOFUDBFormat:
2930             obsolete_option (configname, configlineno, "tofu-db-format");
2931             break;
2932
2933           case oForceOwnertrust:
2934             log_info(_("Note: %s is not for normal use!\n"),
2935                      "--force-ownertrust");
2936             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2937             if(opt.force_ownertrust==-1)
2938               {
2939                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2940                 opt.force_ownertrust=0;
2941               }
2942             break;
2943           case oLoadExtension:
2944             /* Dummy so that gpg 1.4 conf files can work. Should
2945                eventually be removed.  */
2946             break;
2947
2948           case oCompliance:
2949             {
2950               int compliance = gnupg_parse_compliance_option
2951                 (pargs.r.ret_str,
2952                  compliance_options, DIM (compliance_options),
2953                  opt.quiet);
2954               if (compliance < 0)
2955                 g10_exit (1);
2956               set_compliance_option (compliance);
2957             }
2958             break;
2959           case oOpenPGP:
2960           case oRFC2440:
2961           case oRFC4880:
2962           case oRFC4880bis:
2963           case oPGP7:
2964           case oPGP8:
2965           case oGnuPG:
2966             set_compliance_option (pargs.r_opt);
2967             break;
2968
2969           case oRFC2440Text: opt.rfc2440_text=1; break;
2970           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2971
2972           case oSetFilename:
2973             if(utf8_strings)
2974               opt.set_filename = pargs.r.ret_str;
2975             else
2976               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2977             break;
2978           case oForYourEyesOnly: eyes_only = 1; break;
2979           case oNoForYourEyesOnly: eyes_only = 0; break;
2980           case oSetPolicyURL:
2981             add_policy_url(pargs.r.ret_str,0);
2982             add_policy_url(pargs.r.ret_str,1);
2983             break;
2984           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2985           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2986           case oShowPolicyURL:
2987             deprecated_warning(configname,configlineno,"--show-policy-url",
2988                                "--list-options ","show-policy-urls");
2989             deprecated_warning(configname,configlineno,"--show-policy-url",
2990                                "--verify-options ","show-policy-urls");
2991             opt.list_options|=LIST_SHOW_POLICY_URLS;
2992             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2993             break;
2994           case oNoShowPolicyURL:
2995             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2996                                "--list-options ","no-show-policy-urls");
2997             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2998                                "--verify-options ","no-show-policy-urls");
2999             opt.list_options&=~LIST_SHOW_POLICY_URLS;
3000             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
3001             break;
3002           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
3003           case oUseEmbeddedFilename:
3004             opt.flags.use_embedded_filename=1;
3005             break;
3006           case oNoUseEmbeddedFilename:
3007             opt.flags.use_embedded_filename=0;
3008             break;
3009           case oComment:
3010             if(pargs.r.ret_str[0])
3011               append_to_strlist(&opt.comments,pargs.r.ret_str);
3012             break;
3013           case oDefaultComment:
3014             deprecated_warning(configname,configlineno,
3015                                "--default-comment","--no-comments","");
3016             /* fall through */
3017           case oNoComments:
3018             free_strlist(opt.comments);
3019             opt.comments=NULL;
3020             break;
3021           case oThrowKeyids: opt.throw_keyids = 1; break;
3022           case oNoThrowKeyids: opt.throw_keyids = 0; break;
3023           case oShowPhotos:
3024             deprecated_warning(configname,configlineno,"--show-photos",
3025                                "--list-options ","show-photos");
3026             deprecated_warning(configname,configlineno,"--show-photos",
3027                                "--verify-options ","show-photos");
3028             opt.list_options|=LIST_SHOW_PHOTOS;
3029             opt.verify_options|=VERIFY_SHOW_PHOTOS;
3030             break;
3031           case oNoShowPhotos:
3032             deprecated_warning(configname,configlineno,"--no-show-photos",
3033                                "--list-options ","no-show-photos");
3034             deprecated_warning(configname,configlineno,"--no-show-photos",
3035                                "--verify-options ","no-show-photos");
3036             opt.list_options&=~LIST_SHOW_PHOTOS;
3037             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
3038             break;
3039           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
3040
3041           case oForceAEAD: opt.force_aead = 1; break;
3042
3043           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
3044
3045           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
3046           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
3047           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
3048           case oS2KCount:
3049             if (pargs.r.ret_int)
3050               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
3051             else
3052               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
3053             break;
3054
3055           case oRecipient:
3056           case oHiddenRecipient:
3057           case oRecipientFile:
3058           case oHiddenRecipientFile:
3059             /* Store the recipient.  Note that we also store the
3060              * option as private data in the flags.  This is achieved
3061              * by shifting the option value to the left so to keep
3062              * enough space for the flags.  */
3063             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3064             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3065             if (configfp)
3066               sl->flags |= PK_LIST_CONFIG;
3067             if (pargs.r_opt == oHiddenRecipient
3068                 || pargs.r_opt == oHiddenRecipientFile)
3069               sl->flags |= PK_LIST_HIDDEN;
3070             if (pargs.r_opt == oRecipientFile
3071                 || pargs.r_opt == oHiddenRecipientFile)
3072               sl->flags |= PK_LIST_FROM_FILE;
3073             any_explicit_recipient = 1;
3074             break;
3075
3076           case oEncryptTo:
3077           case oHiddenEncryptTo:
3078             /* Store an additional recipient.  */
3079             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3080             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
3081             if (configfp)
3082               sl->flags |= PK_LIST_CONFIG;
3083             if (pargs.r_opt == oHiddenEncryptTo)
3084               sl->flags |= PK_LIST_HIDDEN;
3085             break;
3086
3087           case oNoEncryptTo:
3088             opt.no_encrypt_to = 1;
3089             break;
3090           case oEncryptToDefaultKey:
3091             opt.encrypt_to_default_key = configfp ? 2 : 1;
3092             break;
3093
3094           case oTrySecretKey:
3095             add_to_strlist2 (&opt.secret_keys_to_try,
3096                              pargs.r.ret_str, utf8_strings);
3097             break;
3098
3099           case oMimemode: opt.mimemode = opt.textmode = 1; break;
3100           case oTextmodeShort: opt.textmode = 2; break;
3101           case oTextmode: opt.textmode=1;  break;
3102           case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
3103
3104           case oExpert: opt.expert = 1; break;
3105           case oNoExpert: opt.expert = 0; break;
3106           case oDefSigExpire:
3107             if(*pargs.r.ret_str!='\0')
3108               {
3109                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3110                   log_error(_("'%s' is not a valid signature expiration\n"),
3111                             pargs.r.ret_str);
3112                 else
3113                   opt.def_sig_expire=pargs.r.ret_str;
3114               }
3115             break;
3116           case oAskSigExpire: opt.ask_sig_expire = 1; break;
3117           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
3118           case oDefCertExpire:
3119             if(*pargs.r.ret_str!='\0')
3120               {
3121                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3122                   log_error(_("'%s' is not a valid signature expiration\n"),
3123                             pargs.r.ret_str);
3124                 else
3125                   opt.def_cert_expire=pargs.r.ret_str;
3126               }
3127             break;
3128           case oAskCertExpire: opt.ask_cert_expire = 1; break;
3129           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
3130           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
3131           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
3132           case oAskCertLevel: opt.ask_cert_level = 1; break;
3133           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
3134           case oLocalUser: /* store the local users */
3135             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
3136             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3137             if (configfp)
3138               sl->flags |= PK_LIST_CONFIG;
3139             break;
3140           case oSender:
3141             {
3142               char *mbox = mailbox_from_userid (pargs.r.ret_str, 0);
3143               if (!mbox)
3144                 log_error (_("\"%s\" is not a proper mail address\n"),
3145                            pargs.r.ret_str);
3146               else
3147                 {
3148                   add_to_strlist (&opt.sender_list, mbox);
3149                   xfree (mbox);
3150                 }
3151             }
3152             break;
3153           case oCompress:
3154             /* this is the -z command line option */
3155             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
3156             break;
3157           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
3158           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
3159           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3160           case oPassphrase:
3161             set_passphrase_from_string(pargs.r.ret_str);
3162             break;
3163           case oPassphraseFD:
3164             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3165             break;
3166           case oPassphraseFile:
3167             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3168             break;
3169           case oPassphraseRepeat:
3170             opt.passphrase_repeat = pargs.r.ret_int;
3171             break;
3172
3173           case oPinentryMode:
3174             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3175             if (opt.pinentry_mode == -1)
3176               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3177             break;
3178
3179           case oRequestOrigin:
3180             opt.request_origin = parse_request_origin (pargs.r.ret_str);
3181             if (opt.request_origin == -1)
3182               log_error (_("invalid request origin '%s'\n"), pargs.r.ret_str);
3183             break;
3184
3185           case oCommandFD:
3186             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3187             if (! gnupg_fd_valid (opt.command_fd))
3188               log_error ("command-fd is invalid: %s\n", strerror (errno));
3189             break;
3190           case oCommandFile:
3191             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3192             break;
3193           case oCipherAlgo:
3194             def_cipher_string = xstrdup(pargs.r.ret_str);
3195             break;
3196           case oAEADAlgo:
3197             def_aead_string = xstrdup (pargs.r.ret_str);
3198             break;
3199           case oDigestAlgo:
3200             def_digest_string = xstrdup(pargs.r.ret_str);
3201             break;
3202           case oCompressAlgo:
3203             /* If it is all digits, stick a Z in front of it for
3204                later.  This is for backwards compatibility with
3205                versions that took the compress algorithm number. */
3206             {
3207               char *pt=pargs.r.ret_str;
3208               while(*pt)
3209                 {
3210                   if (!isascii (*pt) || !isdigit (*pt))
3211                     break;
3212
3213                   pt++;
3214                 }
3215
3216               if(*pt=='\0')
3217                 {
3218                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3219                   strcpy(compress_algo_string,"Z");
3220                   strcat(compress_algo_string,pargs.r.ret_str);
3221                 }
3222               else
3223                 compress_algo_string = xstrdup(pargs.r.ret_str);
3224             }
3225             break;
3226           case oCertDigestAlgo:
3227             cert_digest_string = xstrdup(pargs.r.ret_str);
3228             break;
3229
3230           case oNoSecmemWarn:
3231             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3232             break;
3233
3234           case oRequireSecmem: require_secmem=1; break;
3235           case oNoRequireSecmem: require_secmem=0; break;
3236           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3237           case oDisplayCharset:
3238             if( set_native_charset( pargs.r.ret_str ) )
3239                 log_error(_("'%s' is not a valid character set\n"),
3240                           pargs.r.ret_str);
3241             break;
3242           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3243           case oEscapeFrom: opt.escape_from = 1; break;
3244           case oNoEscapeFrom: opt.escape_from = 0; break;
3245           case oLockOnce: opt.lock_once = 1; break;
3246           case oLockNever:
3247             dotlock_disable ();
3248             break;
3249           case oLockMultiple:
3250 #ifndef __riscos__
3251             opt.lock_once = 0;
3252 #else /* __riscos__ */
3253             riscos_not_implemented("lock-multiple");
3254 #endif /* __riscos__ */
3255             break;
3256           case oKeyServer:
3257             {
3258               keyserver_spec_t keyserver;
3259               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3260               if (!keyserver)
3261                 log_error (_("could not parse keyserver URL\n"));
3262               else
3263                 {
3264                   /* We only support a single keyserver.  Later ones
3265                      override earlier ones.  (Since we parse the
3266                      config file first and then the command line
3267                      arguments, the command line takes
3268                      precedence.)  */
3269                   if (opt.keyserver)
3270                     free_keyserver_spec (opt.keyserver);
3271                   opt.keyserver = keyserver;
3272                 }
3273             }
3274             break;
3275           case oKeyServerOptions:
3276             if(!parse_keyserver_options(pargs.r.ret_str))
3277               {
3278                 if(configname)
3279                   log_error(_("%s:%d: invalid keyserver options\n"),
3280                             configname,configlineno);
3281                 else
3282                   log_error(_("invalid keyserver options\n"));
3283               }
3284             break;
3285           case oImportOptions:
3286             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3287               {
3288                 if(configname)
3289                   log_error(_("%s:%d: invalid import options\n"),
3290                             configname,configlineno);
3291                 else
3292                   log_error(_("invalid import options\n"));
3293               }
3294             break;
3295           case oImportFilter:
3296             rc = parse_and_set_import_filter (pargs.r.ret_str);
3297             if (rc)
3298               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3299             break;
3300           case oExportOptions:
3301             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3302               {
3303                 if(configname)
3304                   log_error(_("%s:%d: invalid export options\n"),
3305                             configname,configlineno);
3306                 else
3307                   log_error(_("invalid export options\n"));
3308               }
3309             break;
3310           case oExportFilter:
3311             rc = parse_and_set_export_filter (pargs.r.ret_str);
3312             if (rc)
3313               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3314             break;
3315           case oListOptions:
3316             if(!parse_list_options(pargs.r.ret_str))
3317               {
3318                 if(configname)
3319                   log_error(_("%s:%d: invalid list options\n"),
3320                             configname,configlineno);
3321                 else
3322                   log_error(_("invalid list options\n"));
3323               }
3324             break;
3325           case oVerifyOptions:
3326             {
3327               struct parse_options vopts[]=
3328                 {
3329                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3330                    N_("display photo IDs during signature verification")},
3331                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3332                    N_("show policy URLs during signature verification")},
3333                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3334                    N_("show all notations during signature verification")},
3335                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3336                    N_("show IETF standard notations during signature verification")},
3337                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3338                    NULL},
3339                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3340                    N_("show user-supplied notations during signature verification")},
3341                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3342                    N_("show preferred keyserver URLs during signature verification")},
3343                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3344                    N_("show user ID validity during signature verification")},
3345                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3346                    N_("show revoked and expired user IDs in signature verification")},
3347                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3348                    N_("show only the primary user ID in signature verification")},
3349                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3350                    N_("validate signatures with PKA data")},
3351                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3352                    N_("elevate the trust of signatures with valid PKA data")},
3353                   {NULL,0,NULL,NULL}
3354                 };
3355
3356               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3357                 {
3358                   if(configname)
3359                     log_error(_("%s:%d: invalid verify options\n"),
3360                               configname,configlineno);
3361                   else
3362                     log_error(_("invalid verify options\n"));
3363                 }
3364             }
3365             break;
3366           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3367           case oExecPath:
3368             if(set_exec_path(pargs.r.ret_str))
3369               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3370             else
3371               opt.exec_path_set=1;
3372             break;
3373           case oSetNotation:
3374             add_notation_data( pargs.r.ret_str, 0 );
3375             add_notation_data( pargs.r.ret_str, 1 );
3376             break;
3377           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3378           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3379           case oKnownNotation: register_known_notation (pargs.r.ret_str); break;
3380           case oShowNotation:
3381             deprecated_warning(configname,configlineno,"--show-notation",
3382                                "--list-options ","show-notations");
3383             deprecated_warning(configname,configlineno,"--show-notation",
3384                                "--verify-options ","show-notations");
3385             opt.list_options|=LIST_SHOW_NOTATIONS;
3386             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3387             break;
3388           case oNoShowNotation:
3389             deprecated_warning(configname,configlineno,"--no-show-notation",
3390                                "--list-options ","no-show-notations");
3391             deprecated_warning(configname,configlineno,"--no-show-notation",
3392                                "--verify-options ","no-show-notations");
3393             opt.list_options&=~LIST_SHOW_NOTATIONS;
3394             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3395             break;
3396           case oUtf8Strings: utf8_strings = 1; break;
3397           case oNoUtf8Strings: utf8_strings = 0; break;
3398           case oDisableCipherAlgo:
3399             {
3400               int algo = string_to_cipher_algo (pargs.r.ret_str);
3401               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3402             }
3403             break;
3404           case oDisablePubkeyAlgo:
3405             {
3406               int algo = gcry_pk_map_name (pargs.r.ret_str);
3407               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3408             }
3409             break;
3410           case oNoSigCache: opt.no_sig_cache = 1; break;
3411           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3412           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3413           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3414           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3415           case oNoLiteral: opt.no_literal = 1; break;
3416           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3417           case oFastListMode: opt.fast_list_mode = 1; break;
3418           case oFixedListMode: /* Dummy */ break;
3419           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3420           case oPrintPKARecords: print_pka_records = 1; break;
3421           case oPrintDANERecords: print_dane_records = 1; break;
3422           case oListOnly: opt.list_only=1; break;
3423           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3424           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3425           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3426           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3427           case oNoRandomSeedFile: use_random_seed = 0; break;
3428
3429           case oAutoKeyRetrieve:
3430             opt.keyserver_options.options |= KEYSERVER_AUTO_KEY_RETRIEVE;
3431             break;
3432           case oNoAutoKeyRetrieve:
3433             opt.keyserver_options.options &= ~KEYSERVER_AUTO_KEY_RETRIEVE;
3434             break;
3435
3436           case oShowSessionKey: opt.show_session_key = 1; break;
3437           case oOverrideSessionKey:
3438                 opt.override_session_key = pargs.r.ret_str;
3439                 break;
3440           case oOverrideSessionKeyFD:
3441                 ovrseskeyfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3442                 break;
3443           case oMergeOnly:
3444                 deprecated_warning(configname,configlineno,"--merge-only",
3445                                    "--import-options ","merge-only");
3446                 opt.import_options|=IMPORT_MERGE_ONLY;
3447             break;
3448           case oAllowSecretKeyImport: /* obsolete */ break;
3449           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3450           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3451
3452           case oEnableSpecialFilenames:
3453             enable_special_filenames ();
3454             break;
3455
3456           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3457           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3458           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3459           case oPreservePermissions: opt.preserve_permissions=1; break;
3460           case oDefaultPreferenceList:
3461             opt.def_preference_list = pargs.r.ret_str;
3462             break;
3463           case oDefaultKeyserverURL:
3464             {
3465               keyserver_spec_t keyserver;
3466               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3467               if (!keyserver)
3468                 log_error (_("could not parse keyserver URL\n"));
3469               else
3470                 free_keyserver_spec (keyserver);
3471
3472               opt.def_keyserver_url = pargs.r.ret_str;
3473             }
3474             break;
3475           case oPersonalCipherPreferences:
3476             pers_cipher_list=pargs.r.ret_str;
3477             break;
3478           case oPersonalAEADPreferences:
3479             pers_aead_list = pargs.r.ret_str;
3480             break;
3481           case oPersonalDigestPreferences:
3482             pers_digest_list=pargs.r.ret_str;
3483             break;
3484           case oPersonalCompressPreferences:
3485             pers_compress_list=pargs.r.ret_str;
3486             break;
3487           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3488           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3489           case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
3490           case oWeakDigest:
3491             additional_weak_digest(pargs.r.ret_str);
3492             break;
3493           case oUnwrap:
3494             opt.unwrap_encryption = 1;
3495             break;
3496           case oOnlySignTextIDs:
3497             opt.only_sign_text_ids = 1;
3498             break;
3499
3500           case oDisplay:
3501             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3502             break;
3503           case oTTYname:
3504             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3505             break;
3506           case oTTYtype:
3507             set_opt_session_env ("TERM", pargs.r.ret_str);
3508             break;
3509           case oXauthority:
3510             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3511             break;
3512
3513           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3514           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3515
3516           case oGroup: add_group(pargs.r.ret_str); break;
3517           case oUnGroup: rm_group(pargs.r.ret_str); break;
3518           case oNoGroups:
3519             while(opt.grouplist)
3520               {
3521                 struct groupitem *iter=opt.grouplist;
3522                 free_strlist(iter->values);
3523                 opt.grouplist=opt.grouplist->next;
3524                 xfree(iter);
3525               }
3526             break;
3527
3528           case oStrict:
3529           case oNoStrict:
3530             /* Not used */
3531             break;
3532
3533           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3534           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3535           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3536           case oMultifile: multifile=1; break;
3537           case oKeyidFormat:
3538             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3539               opt.keyid_format=KF_SHORT;
3540             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3541               opt.keyid_format=KF_LONG;
3542             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3543               opt.keyid_format=KF_0xSHORT;
3544             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3545               opt.keyid_format=KF_0xLONG;
3546             else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
3547               opt.keyid_format = KF_NONE;
3548             else
3549               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3550             break;
3551
3552           case oExitOnStatusWriteError:
3553             opt.exit_on_status_write_error = 1;
3554             break;
3555
3556           case oLimitCardInsertTries:
3557             opt.limit_card_insert_tries = pargs.r.ret_int;
3558             break;
3559
3560           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3561           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3562
3563           case oAutoKeyLocate:
3564             if (default_akl)
3565               {
3566                 /* This is the first time --auto-key-locate is seen.
3567                  * We need to reset the default akl.  */
3568                 default_akl = 0;
3569                 release_akl();
3570               }
3571             if(!parse_auto_key_locate(pargs.r.ret_str))
3572               {
3573                 if(configname)
3574                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3575                             configname,configlineno);
3576                 else
3577                   log_error(_("invalid auto-key-locate list\n"));
3578               }
3579             break;
3580           case oNoAutoKeyLocate:
3581             release_akl();
3582             break;
3583
3584           case oKeyOrigin:
3585             if(!parse_key_origin (pargs.r.ret_str))
3586               log_error (_("invalid argument for option \"%.50s\"\n"),
3587                          "--key-origin");
3588             break;
3589
3590           case oEnableLargeRSA:
3591 #if SECMEM_BUFFER_SIZE >= 65536
3592             opt.flags.large_rsa=1;
3593 #else
3594             if (configname)
3595               log_info("%s:%d: WARNING: gpg not built with large secure "
3596                          "memory buffer.  Ignoring enable-large-rsa\n",
3597                         configname,configlineno);
3598             else
3599               log_info("WARNING: gpg not built with large secure "
3600                          "memory buffer.  Ignoring --enable-large-rsa\n");
3601 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3602             break;
3603           case oDisableLargeRSA: opt.flags.large_rsa=0;
3604             break;
3605
3606           case oEnableDSA2: opt.flags.dsa2=1; break;
3607           case oDisableDSA2: opt.flags.dsa2=0; break;
3608
3609           case oAllowWeakDigestAlgos:
3610             opt.flags.allow_weak_digest_algos = 1;
3611             break;
3612
3613           case oFakedSystemTime:
3614             {
3615               size_t len = strlen (pargs.r.ret_str);
3616               int freeze = 0;
3617               time_t faked_time;
3618
3619               if (len > 0 && pargs.r.ret_str[len-1] == '!')
3620                 {
3621                   freeze = 1;
3622                   pargs.r.ret_str[len-1] = '\0';
3623                 }
3624
3625               faked_time = isotime2epoch (pargs.r.ret_str);
3626               if (faked_time == (time_t)(-1))
3627                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3628               gnupg_set_time (faked_time, freeze);
3629             }
3630             break;
3631
3632           case oNoAutostart: opt.autostart = 0; break;
3633           case oNoSymkeyCache: opt.no_symkey_cache = 1; break;
3634
3635           case oDefaultNewKeyAlgo:
3636             opt.def_new_key_algo = pargs.r.ret_str;
3637             break;
3638
3639           case oNoop: break;
3640
3641           default:
3642             if (configfp)
3643               pargs.err = ARGPARSE_PRINT_WARNING;
3644             else
3645               {
3646                 pargs.err = ARGPARSE_PRINT_ERROR;
3647                 /* The argparse function calls a plain exit and thus
3648                  * we need to print a status here.  */
3649                 write_status_failure ("option-parser",
3650                                       gpg_error(GPG_ERR_GENERAL));
3651               }
3652             break;
3653           }
3654       }
3655
3656     if (configfp)
3657       {
3658         fclose( configfp );
3659         configfp = NULL;
3660         /* Remember the first config file name. */
3661         if (!save_configname)
3662           save_configname = configname;
3663         else
3664           xfree(configname);
3665         configname = NULL;
3666         goto next_pass;
3667       }
3668     xfree(configname); configname = NULL;
3669     if (log_get_errorcount (0))
3670       {
3671         write_status_failure ("option-parser", gpg_error(GPG_ERR_GENERAL));
3672         g10_exit(2);
3673       }
3674
3675     /* The command --gpgconf-list is pretty simple and may be called
3676        directly after the option parsing. */
3677     if (cmd == aGPGConfList)
3678       {
3679         gpgconf_list (save_configname ? save_configname : default_configname);
3680         g10_exit (0);
3681       }
3682     xfree (save_configname);
3683     xfree (default_configname);
3684
3685     if (print_dane_records)
3686       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3687                  "--print-dane-records",
3688                  "--export-options export-dane");
3689     if (print_pka_records)
3690       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3691                  "--print-pks-records",
3692                  "--export-options export-pka");
3693     if (log_get_errorcount (0))
3694       {
3695         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
3696         g10_exit(2);
3697       }
3698
3699
3700     if( nogreeting )
3701         greeting = 0;
3702
3703     if( greeting )
3704       {
3705         es_fprintf (es_stderr, "%s %s; %s\n",
3706                     strusage(11), strusage(13), strusage(14) );
3707         es_fprintf (es_stderr, "%s\n", strusage(15) );
3708       }
3709 #ifdef IS_DEVELOPMENT_VERSION
3710     if (!opt.batch)
3711       {
3712         const char *s;
3713
3714         if((s=strusage(25)))
3715           log_info("%s\n",s);
3716         if((s=strusage(26)))
3717           log_info("%s\n",s);
3718         if((s=strusage(27)))
3719           log_info("%s\n",s);
3720       }
3721 #endif
3722
3723     /* FIXME: We should use logging to a file only in server mode;
3724        however we have not yet implemetyed that.  Thus we try to get
3725        away with --batch as indication for logging to file
3726        required. */
3727     if (logfile && opt.batch)
3728       {
3729         log_set_file (logfile);
3730         log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
3731       }
3732
3733     if (opt.verbose > 2)
3734         log_info ("using character set '%s'\n", get_native_charset ());
3735
3736     if( may_coredump && !opt.quiet )
3737         log_info(_("WARNING: program may create a core file!\n"));
3738
3739     if (opt.flags.rfc4880bis)
3740         log_info ("Note: RFC4880bis features are enabled.\n");
3741     else
3742       {
3743         opt.mimemode = 0; /* This will use text mode instead.  */
3744       }
3745
3746     if (eyes_only) {
3747       if (opt.set_filename)
3748           log_info(_("WARNING: %s overrides %s\n"),
3749                    "--for-your-eyes-only","--set-filename");
3750
3751       opt.set_filename="_CONSOLE";
3752     }
3753
3754     if (opt.no_literal) {
3755         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3756         if (opt.textmode)
3757             log_error(_("%s not allowed with %s!\n"),
3758                        "--textmode", "--no-literal" );
3759         if (opt.set_filename)
3760             log_error(_("%s makes no sense with %s!\n"),
3761                         eyes_only?"--for-your-eyes-only":"--set-filename",
3762                         "--no-literal" );
3763     }
3764
3765
3766     if (opt.set_filesize)
3767         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3768     if( opt.batch )
3769         tty_batchmode( 1 );
3770
3771     if (gnupg_faked_time_p ())
3772       {
3773         gnupg_isotime_t tbuf;
3774
3775         log_info (_("WARNING: running with faked system time: "));
3776         gnupg_get_isotime (tbuf);
3777         dump_isotime (tbuf);
3778         log_printf ("\n");
3779       }
3780
3781     /* Print a warning if an argument looks like an option.  */
3782     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3783       {
3784         int i;
3785
3786         for (i=0; i < argc; i++)
3787           if (argv[i][0] == '-' && argv[i][1] == '-')
3788             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3789       }
3790
3791
3792     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3793
3794     if(require_secmem && !got_secmem)
3795       {
3796         log_info(_("will not run with insecure memory due to %s\n"),
3797                  "--require-secmem");
3798         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
3799         g10_exit(2);
3800       }
3801
3802     set_debug (debug_level);
3803     if (DBG_CLOCK)
3804       log_clock ("start");
3805
3806     /* Do these after the switch(), so they can override settings. */
3807     if (PGP7)
3808       {
3809         /* That does not anymore work because we have no more support
3810            for v3 signatures.  */
3811         opt.escape_from=1;
3812         opt.ask_sig_expire=0;
3813       }
3814     else if(PGP8)
3815       {
3816         opt.escape_from=1;
3817       }
3818
3819
3820     if( def_cipher_string ) {
3821         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3822         xfree(def_cipher_string); def_cipher_string = NULL;
3823         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3824             log_error(_("selected cipher algorithm is invalid\n"));
3825     }
3826     if (def_aead_string)
3827       {
3828         opt.def_aead_algo = string_to_aead_algo (def_aead_string);
3829         xfree (def_aead_string); def_aead_string = NULL;
3830         if (openpgp_aead_test_algo (opt.def_aead_algo))
3831           log_error(_("selected AEAD algorithm is invalid\n"));
3832       }
3833     if( def_digest_string ) {
3834         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3835         xfree(def_digest_string); def_digest_string = NULL;
3836         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3837             log_error(_("selected digest algorithm is invalid\n"));
3838     }
3839     if( compress_algo_string ) {
3840         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3841         xfree(compress_algo_string); compress_algo_string = NULL;
3842         if( check_compress_algo(opt.compress_algo) )
3843           log_error(_("selected compression algorithm is invalid\n"));
3844     }
3845     if( cert_digest_string ) {
3846         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3847         xfree(cert_digest_string); cert_digest_string = NULL;
3848         if (openpgp_md_test_algo(opt.cert_digest_algo))
3849           log_error(_("selected certification digest algorithm is invalid\n"));
3850     }
3851     if( s2k_cipher_string ) {
3852         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3853         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3854         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3855           log_error(_("selected cipher algorithm is invalid\n"));
3856     }
3857     if( s2k_digest_string ) {
3858         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3859         xfree(s2k_digest_string); s2k_digest_string = NULL;
3860         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3861           log_error(_("selected digest algorithm is invalid\n"));
3862     }
3863     if( opt.completes_needed < 1 )
3864       log_error(_("completes-needed must be greater than 0\n"));
3865     if( opt.marginals_needed < 2 )
3866       log_error(_("marginals-needed must be greater than 1\n"));
3867     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3868       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3869     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3870       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3871     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3872       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3873     switch( opt.s2k_mode ) {
3874       case 0:
3875         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3876         break;
3877       case 1: case 3: break;
3878       default:
3879         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3880     }
3881
3882     /* This isn't actually needed, but does serve to error out if the
3883        string is invalid. */
3884     if(opt.def_preference_list &&
3885         keygen_set_std_prefs(opt.def_preference_list,0))
3886       log_error(_("invalid default preferences\n"));
3887
3888     if(pers_cipher_list &&
3889        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3890       log_error(_("invalid personal cipher preferences\n"));
3891
3892     if (pers_aead_list && keygen_set_std_prefs (pers_aead_list, PREFTYPE_AEAD))
3893       log_error(_("invalid personal AEAD preferences\n"));
3894
3895     if(pers_digest_list &&
3896        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3897       log_error(_("invalid personal digest preferences\n"));
3898
3899     if(pers_compress_list &&
3900        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3901       log_error(_("invalid personal compress preferences\n"));
3902
3903     /* Check chunk size.  Please fix also the man page if you change
3904      * the default.  The limits are given by the specs.  */
3905     if (!opt.chunk_size)
3906       opt.chunk_size = 27; /* Default to the suggested max of 128 MiB.  */
3907     else if (opt.chunk_size < 6)
3908       {
3909         opt.chunk_size = 6;
3910         log_info (_("chunk size invalid - using %d\n"), opt.chunk_size);
3911       }
3912     else if (opt.chunk_size > (allow_large_chunks? 62 : 27))
3913       {
3914         opt.chunk_size = (allow_large_chunks? 62 : 27);
3915         log_info (_("chunk size invalid - using %d\n"), opt.chunk_size);
3916       }
3917
3918     /* We don't support all possible commands with multifile yet */
3919     if(multifile)
3920       {
3921         char *cmdname;
3922
3923         switch(cmd)
3924           {
3925           case aSign:
3926             cmdname="--sign";
3927             break;
3928           case aSignEncr:
3929             cmdname="--sign --encrypt";
3930             break;
3931           case aClearsign:
3932             cmdname="--clear-sign";
3933             break;
3934           case aDetachedSign:
3935             cmdname="--detach-sign";
3936             break;
3937           case aSym:
3938             cmdname="--symmetric";
3939             break;
3940           case aEncrSym:
3941             cmdname="--symmetric --encrypt";
3942             break;
3943           case aStore:
3944             cmdname="--store";
3945             break;
3946           default:
3947             cmdname=NULL;
3948             break;
3949           }
3950
3951         if(cmdname)
3952           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3953       }
3954
3955     if( log_get_errorcount(0) )
3956       {
3957         write_status_failure ("option-postprocessing",
3958                               gpg_error(GPG_ERR_GENERAL));
3959         g10_exit (2);
3960       }
3961
3962     if(opt.compress_level==0)
3963       opt.compress_algo=COMPRESS_ALGO_NONE;
3964
3965     /* Check our chosen algorithms against the list of legal
3966        algorithms. */
3967
3968     if(!GNUPG && !opt.flags.rfc4880bis)
3969       {
3970         const char *badalg=NULL;
3971         preftype_t badtype=PREFTYPE_NONE;
3972
3973         if(opt.def_cipher_algo
3974            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3975           {
3976             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3977             badtype = PREFTYPE_SYM;
3978           }
3979         else if(opt.def_aead_algo
3980            && !algo_available(PREFTYPE_AEAD, opt.def_aead_algo, NULL))
3981           {
3982             badalg = openpgp_aead_algo_name (opt.def_aead_algo);
3983             badtype = PREFTYPE_AEAD;
3984           }
3985         else if(opt.def_digest_algo
3986                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3987           {
3988             badalg = gcry_md_algo_name (opt.def_digest_algo);
3989             badtype = PREFTYPE_HASH;
3990           }
3991         else if(opt.cert_digest_algo
3992                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3993           {
3994             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3995             badtype = PREFTYPE_HASH;
3996           }
3997         else if(opt.compress_algo!=-1
3998                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3999           {
4000             badalg = compress_algo_to_string(opt.compress_algo);
4001             badtype = PREFTYPE_ZIP;
4002           }
4003
4004         if(badalg)
4005           {
4006             switch(badtype)
4007               {
4008               case PREFTYPE_SYM:
4009                 log_info (_("cipher algorithm '%s'"
4010                             " may not be used in %s mode\n"),
4011                          badalg,
4012                           gnupg_compliance_option_string (opt.compliance));
4013                 break;
4014               case PREFTYPE_AEAD:
4015                 log_info (_("AEAD algorithm '%s'"
4016                             " may not be used in %s mode\n"),
4017                           badalg,
4018                           gnupg_compliance_option_string (opt.compliance));
4019                 break;
4020               case PREFTYPE_HASH:
4021                 log_info (_("digest algorithm '%s'"
4022                             " may not be used in %s mode\n"),
4023                           badalg,
4024                           gnupg_compliance_option_string (opt.compliance));
4025                 break;
4026               case PREFTYPE_ZIP:
4027                 log_info (_("compression algorithm '%s'"
4028                             " may not be used in %s mode\n"),
4029                           badalg,
4030                           gnupg_compliance_option_string (opt.compliance));
4031                 break;
4032               default:
4033                 BUG();
4034               }
4035
4036             compliance_failure();
4037           }
4038       }
4039
4040     /* Check our chosen algorithms against the list of allowed
4041      * algorithms in the current compliance mode, and fail hard if it
4042      * is not.  This is us being nice to the user informing her early
4043      * that the chosen algorithms are not available.  We also check
4044      * and enforce this right before the actual operation.  */
4045     /* FIXME: We also need to check the AEAD algo. */
4046     if (opt.def_cipher_algo
4047         && ! gnupg_cipher_is_allowed (opt.compliance,
4048                                       cmd == aEncr
4049                                       || cmd == aSignEncr
4050                                       || cmd == aEncrSym
4051                                       || cmd == aSym
4052                                       || cmd == aSignSym
4053                                       || cmd == aSignEncrSym,
4054                                       opt.def_cipher_algo,
4055                                       GCRY_CIPHER_MODE_NONE))
4056       log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
4057                  openpgp_cipher_algo_name (opt.def_cipher_algo),
4058                  gnupg_compliance_option_string (opt.compliance));
4059
4060     if (opt.def_digest_algo
4061         && ! gnupg_digest_is_allowed (opt.compliance,
4062                                       cmd == aSign
4063                                       || cmd == aSignEncr
4064                                       || cmd == aSignEncrSym
4065                                       || cmd == aSignSym
4066                                       || cmd == aClearsign,
4067                                       opt.def_digest_algo))
4068       log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
4069                  gcry_md_algo_name (opt.def_digest_algo),
4070                  gnupg_compliance_option_string (opt.compliance));
4071
4072     /* Fail hard.  */
4073     if (log_get_errorcount (0))
4074       {
4075         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
4076         g10_exit (2);
4077       }
4078
4079     /* Set the random seed file. */
4080     if( use_random_seed ) {
4081       char *p = make_filename (gnupg_homedir (), "random_seed", NULL );
4082         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
4083         if (!access (p, F_OK))
4084           register_secured_file (p);
4085         xfree(p);
4086     }
4087
4088     /* If there is no command but the --fingerprint is given, default
4089        to the --list-keys command.  */
4090     if (!cmd && fpr_maybe_cmd)
4091       {
4092         set_cmd (&cmd, aListKeys);
4093       }
4094
4095
4096     if( opt.verbose > 1 )
4097         set_packet_list_mode(1);
4098
4099     /* Add the keyrings, but not for some special commands.  We always
4100      * need to add the keyrings if we are running under SELinux, this
4101      * is so that the rings are added to the list of secured files.
4102      * We do not add any keyring if --no-keyring has been used.  */
4103     if (default_keyring >= 0
4104         && (ALWAYS_ADD_KEYRINGS
4105             || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest)))
4106       {
4107         if (!nrings || default_keyring > 0)  /* Add default ring. */
4108             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
4109                                 KEYDB_RESOURCE_FLAG_DEFAULT);
4110         for (sl = nrings; sl; sl = sl->next )
4111           keydb_add_resource (sl->d, sl->flags);
4112       }
4113     FREE_STRLIST(nrings);
4114
4115     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
4116       /* In loopback mode, never ask for the password multiple
4117          times.  */
4118       {
4119         opt.passphrase_repeat = 0;
4120       }
4121
4122     if (cmd == aGPGConfTest)
4123       g10_exit(0);
4124
4125
4126     if (pwfd != -1)  /* Read the passphrase now. */
4127       read_passphrase_from_fd (pwfd);
4128
4129     if (ovrseskeyfd != -1 )  /* Read the sessionkey now. */
4130       read_sessionkey_from_fd (ovrseskeyfd);
4131
4132     fname = argc? *argv : NULL;
4133
4134     if(fname && utf8_strings)
4135       opt.flags.utf8_filename=1;
4136
4137     ctrl = xcalloc (1, sizeof *ctrl);
4138     gpg_init_default_ctrl (ctrl);
4139
4140 #ifndef NO_TRUST_MODELS
4141     switch (cmd)
4142       {
4143       case aPrimegen:
4144       case aPrintMD:
4145       case aPrintMDs:
4146       case aGenRandom:
4147       case aDeArmor:
4148       case aEnArmor:
4149       case aListConfig:
4150       case aListGcryptConfig:
4151         break;
4152       case aFixTrustDB:
4153       case aExportOwnerTrust:
4154         rc = setup_trustdb (0, trustdb_name);
4155         break;
4156       case aListTrustDB:
4157         rc = setup_trustdb (argc? 1:0, trustdb_name);
4158         break;
4159       case aKeygen:
4160       case aFullKeygen:
4161       case aQuickKeygen:
4162         rc = setup_trustdb (1, trustdb_name);
4163         break;
4164       default:
4165         /* If we are using TM_ALWAYS, we do not need to create the
4166            trustdb.  */
4167         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
4168         break;
4169       }
4170     if (rc)
4171       log_error (_("failed to initialize the TrustDB: %s\n"),
4172                  gpg_strerror (rc));
4173 #endif /*!NO_TRUST_MODELS*/
4174
4175     switch (cmd)
4176       {
4177       case aStore:
4178       case aSym:
4179       case aSign:
4180       case aSignSym:
4181       case aClearsign:
4182         if (!opt.quiet && any_explicit_recipient)
4183           log_info (_("WARNING: recipients (-r) given "
4184                       "without using public key encryption\n"));
4185         break;
4186       default:
4187         break;
4188       }
4189
4190
4191     /* Check for certain command whether we need to migrate a
4192        secring.gpg to the gpg-agent. */
4193     switch (cmd)
4194       {
4195       case aListSecretKeys:
4196       case aSign:
4197       case aSignEncr:
4198       case aSignEncrSym:
4199       case aSignSym:
4200       case aClearsign:
4201       case aDecrypt:
4202       case aSignKey:
4203       case aLSignKey:
4204       case aEditKey:
4205       case aPasswd:
4206       case aDeleteSecretKeys:
4207       case aDeleteSecretAndPublicKeys:
4208       case aQuickKeygen:
4209       case aQuickAddUid:
4210       case aQuickAddKey:
4211       case aQuickRevUid:
4212       case aQuickSetPrimaryUid:
4213       case aFullKeygen:
4214       case aKeygen:
4215       case aImport:
4216       case aExportSecret:
4217       case aExportSecretSub:
4218       case aGenRevoke:
4219       case aDesigRevoke:
4220       case aCardEdit:
4221       case aChangePIN:
4222         migrate_secring (ctrl);
4223         break;
4224       case aListKeys:
4225         if (opt.with_secret)
4226           migrate_secring (ctrl);
4227         break;
4228       default:
4229         break;
4230       }
4231
4232     /* The command dispatcher.  */
4233     switch( cmd )
4234       {
4235       case aServer:
4236         gpg_server (ctrl);
4237         break;
4238
4239       case aStore: /* only store the file */
4240         if( argc > 1 )
4241             wrong_args("--store [filename]");
4242         if( (rc = encrypt_store(fname)) )
4243           {
4244             write_status_failure ("store", rc);
4245             log_error ("storing '%s' failed: %s\n",
4246                        print_fname_stdin(fname),gpg_strerror (rc) );
4247           }
4248         break;
4249       case aSym: /* encrypt the given file only with the symmetric cipher */
4250         if( argc > 1 )
4251             wrong_args("--symmetric [filename]");
4252         if( (rc = encrypt_symmetric(fname)) )
4253           {
4254             write_status_failure ("symencrypt", rc);
4255             log_error (_("symmetric encryption of '%s' failed: %s\n"),
4256                         print_fname_stdin(fname),gpg_strerror (rc) );
4257           }
4258         break;
4259
4260       case aEncr: /* encrypt the given file */
4261         if(multifile)
4262           encrypt_crypt_files (ctrl, argc, argv, remusr);
4263         else
4264           {
4265             if( argc > 1 )
4266               wrong_args("--encrypt [filename]");
4267             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
4268               {
4269                 write_status_failure ("encrypt", rc);
4270                 log_error("%s: encryption failed: %s\n",
4271                           print_fname_stdin(fname), gpg_strerror (rc) );
4272               }
4273           }
4274         break;
4275
4276       case aEncrSym:
4277         /* This works with PGP 8 in the sense that it acts just like a
4278            symmetric message.  It doesn't work at all with 2 or 6.  It
4279            might work with 7, but alas, I don't have a copy to test
4280            with right now. */
4281         if( argc > 1 )
4282           wrong_args("--symmetric --encrypt [filename]");
4283         else if(opt.s2k_mode==0)
4284           log_error(_("you cannot use --symmetric --encrypt"
4285                       " with --s2k-mode 0\n"));
4286         else if (PGP7)
4287           log_error(_("you cannot use --symmetric --encrypt"
4288                       " in %s mode\n"),
4289                     gnupg_compliance_option_string (opt.compliance));
4290         else
4291           {
4292             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
4293               {
4294                 write_status_failure ("encrypt", rc);
4295                 log_error ("%s: encryption failed: %s\n",
4296                            print_fname_stdin(fname), gpg_strerror (rc) );
4297               }
4298           }
4299         break;
4300
4301       case aSign: /* sign the given file */
4302         sl = NULL;
4303         if( detached_sig ) { /* sign all files */
4304             for( ; argc; argc--, argv++ )
4305                 add_to_strlist( &sl, *argv );
4306         }
4307         else {
4308             if( argc > 1 )
4309                 wrong_args("--sign [filename]");
4310             if( argc ) {
4311                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4312                 strcpy(sl->d, fname);
4313             }
4314         }
4315         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
4316           {
4317             write_status_failure ("sign", rc);
4318             log_error ("signing failed: %s\n", gpg_strerror (rc) );
4319           }
4320         free_strlist(sl);
4321         break;
4322
4323       case aSignEncr: /* sign and encrypt the given file */
4324         if( argc > 1 )
4325             wrong_args("--sign --encrypt [filename]");
4326         if( argc ) {
4327             sl = xmalloc_clear( sizeof *sl + strlen(fname));
4328             strcpy(sl->d, fname);
4329         }
4330         else
4331             sl = NULL;
4332         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
4333           {
4334             write_status_failure ("sign-encrypt", rc);
4335             log_error("%s: sign+encrypt failed: %s\n",
4336                       print_fname_stdin(fname), gpg_strerror (rc) );
4337           }
4338         free_strlist(sl);
4339         break;
4340
4341       case aSignEncrSym: /* sign and encrypt the given file */
4342         if( argc > 1 )
4343             wrong_args("--symmetric --sign --encrypt [filename]");
4344         else if(opt.s2k_mode==0)
4345           log_error(_("you cannot use --symmetric --sign --encrypt"
4346                       " with --s2k-mode 0\n"));
4347         else if (PGP7)
4348           log_error(_("you cannot use --symmetric --sign --encrypt"
4349                       " in %s mode\n"),
4350                     gnupg_compliance_option_string (opt.compliance));
4351         else
4352           {
4353             if( argc )
4354               {
4355                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4356                 strcpy(sl->d, fname);
4357               }
4358             else
4359               sl = NULL;
4360             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
4361                                  2, remusr, NULL)))
4362               {
4363                 write_status_failure ("sign-encrypt", rc);
4364                 log_error("%s: symmetric+sign+encrypt failed: %s\n",
4365                           print_fname_stdin(fname), gpg_strerror (rc) );
4366               }
4367             free_strlist(sl);
4368           }
4369         break;
4370
4371       case aSignSym: /* sign and conventionally encrypt the given file */
4372         if (argc > 1)
4373             wrong_args("--sign --symmetric [filename]");
4374         rc = sign_symencrypt_file (ctrl, fname, locusr);
4375         if (rc)
4376           {
4377             write_status_failure ("sign-symencrypt", rc);
4378             log_error("%s: sign+symmetric failed: %s\n",
4379                       print_fname_stdin(fname), gpg_strerror (rc) );
4380           }
4381         break;
4382
4383       case aClearsign: /* make a clearsig */
4384         if( argc > 1 )
4385             wrong_args("--clear-sign [filename]");
4386         if( (rc = clearsign_file (ctrl, fname, locusr, NULL)) )
4387           {
4388             write_status_failure ("sign", rc);
4389             log_error("%s: clear-sign failed: %s\n",
4390                       print_fname_stdin(fname), gpg_strerror (rc) );
4391           }
4392         break;
4393
4394       case aVerify:
4395         if (multifile)
4396           {
4397             if ((rc = verify_files (ctrl, argc, argv)))
4398               log_error("verify files failed: %s\n", gpg_strerror (rc) );
4399           }
4400         else
4401           {
4402             if ((rc = verify_signatures (ctrl, argc, argv)))
4403               log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
4404           }
4405         if (rc)
4406           write_status_failure ("verify", rc);
4407         break;
4408
4409       case aDecrypt:
4410         if (multifile)
4411           decrypt_messages (ctrl, argc, argv);
4412         else
4413           {
4414             if( argc > 1 )
4415               wrong_args("--decrypt [filename]");
4416             if( (rc = decrypt_message (ctrl, fname) ))
4417               {
4418                 write_status_failure ("decrypt", rc);
4419                 log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
4420               }
4421           }
4422         break;
4423
4424       case aQuickSignKey:
4425       case aQuickLSignKey:
4426         {
4427           const char *fpr;
4428
4429           if (argc < 1)
4430             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
4431           fpr = *argv++; argc--;
4432           sl = NULL;
4433           for( ; argc; argc--, argv++)
4434             append_to_strlist2 (&sl, *argv, utf8_strings);
4435           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
4436           free_strlist (sl);
4437         }
4438         break;
4439
4440       case aSignKey:
4441         if( argc != 1 )
4442           wrong_args("--sign-key user-id");
4443         /* fall through */
4444       case aLSignKey:
4445         if( argc != 1 )
4446           wrong_args("--lsign-key user-id");
4447         /* fall through */
4448
4449         sl=NULL;
4450
4451         if(cmd==aSignKey)
4452           append_to_strlist(&sl,"sign");
4453         else if(cmd==aLSignKey)
4454           append_to_strlist(&sl,"lsign");
4455         else
4456           BUG();
4457
4458         append_to_strlist( &sl, "save" );
4459         username = make_username( fname );
4460         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
4461         xfree(username);
4462         free_strlist(sl);
4463         break;
4464
4465       case aEditKey: /* Edit a key signature */
4466         if( !argc )
4467             wrong_args("--edit-key user-id [commands]");
4468         username = make_username( fname );
4469         if( argc > 1 ) {
4470             sl = NULL;
4471             for( argc--, argv++ ; argc; argc--, argv++ )
4472                 append_to_strlist( &sl, *argv );
4473             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
4474             free_strlist(sl);
4475         }
4476         else
4477             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
4478         xfree(username);
4479         break;
4480
4481       case aPasswd:
4482         if (argc != 1)
4483           wrong_args("--change-passphrase <user-id>");
4484         else
4485           {
4486             username = make_username (fname);
4487             keyedit_passwd (ctrl, username);
4488             xfree (username);
4489           }
4490         break;
4491
4492       case aDeleteKeys:
4493       case aDeleteSecretKeys:
4494       case aDeleteSecretAndPublicKeys:
4495         sl = NULL;
4496         /* I'm adding these in reverse order as add_to_strlist2
4497            reverses them again, and it's easier to understand in the
4498            proper order :) */
4499         for( ; argc; argc-- )
4500           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
4501         delete_keys (ctrl, sl,
4502                      cmd==aDeleteSecretKeys, cmd==aDeleteSecretAndPublicKeys);
4503         free_strlist(sl);
4504         break;
4505
4506       case aCheckKeys:
4507         opt.check_sigs = 1; /* fall through */
4508       case aListSigs:
4509         opt.list_sigs = 1; /* fall through */
4510       case aListKeys:
4511         sl = NULL;
4512         for( ; argc; argc--, argv++ )
4513             add_to_strlist2( &sl, *argv, utf8_strings );
4514         public_key_list (ctrl, sl, 0);
4515         free_strlist(sl);
4516         break;
4517       case aListSecretKeys:
4518         sl = NULL;
4519         for( ; argc; argc--, argv++ )
4520             add_to_strlist2( &sl, *argv, utf8_strings );
4521         secret_key_list (ctrl, sl);
4522         free_strlist(sl);
4523         break;
4524       case aLocateKeys:
4525         sl = NULL;
4526         for (; argc; argc--, argv++)
4527           add_to_strlist2( &sl, *argv, utf8_strings );
4528         public_key_list (ctrl, sl, 1);
4529         free_strlist (sl);
4530         break;
4531
4532       case aQuickKeygen:
4533         {
4534           const char *x_algo, *x_usage, *x_expire;
4535
4536           if (argc < 1 || argc > 4)
4537             wrong_args("--quick-generate-key USER-ID [ALGO [USAGE [EXPIRE]]]");
4538           username = make_username (fname);
4539           argv++, argc--;
4540           x_algo = "";
4541           x_usage = "";
4542           x_expire = "";
4543           if (argc)
4544             {
4545               x_algo = *argv++; argc--;
4546               if (argc)
4547                 {
4548                   x_usage = *argv++; argc--;
4549                   if (argc)
4550                     {
4551                       x_expire = *argv++; argc--;
4552                     }
4553                 }
4554             }
4555           quick_generate_keypair (ctrl, username, x_algo, x_usage, x_expire);
4556           xfree (username);
4557         }
4558         break;
4559
4560       case aKeygen: /* generate a key */
4561         if( opt.batch ) {
4562             if( argc > 1 )
4563                 wrong_args("--generate-key [parameterfile]");
4564             generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4565         }
4566         else {
4567             if (opt.command_fd != -1 && argc)
4568               {
4569                 if( argc > 1 )
4570                   wrong_args("--generate-key [parameterfile]");
4571
4572                 opt.batch = 1;
4573                 generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4574               }
4575             else if (argc)
4576               wrong_args ("--generate-key");
4577             else
4578               generate_keypair (ctrl, 0, NULL, NULL, 0);
4579         }
4580         break;
4581
4582       case aFullKeygen: /* Generate a key with all options. */
4583         if (opt.batch)
4584           {
4585             if (argc > 1)
4586               wrong_args ("--full-generate-key [parameterfile]");
4587             generate_keypair (ctrl, 1, argc? *argv : NULL, NULL, 0);
4588           }
4589         else
4590           {
4591             if (argc)
4592               wrong_args("--full-generate-key");
4593             generate_keypair (ctrl, 1, NULL, NULL, 0);
4594         }
4595         break;
4596
4597       case aQuickAddUid:
4598         {
4599           const char *uid, *newuid;
4600
4601           if (argc != 2)
4602             wrong_args ("--quick-add-uid USER-ID NEW-USER-ID");
4603           uid = *argv++; argc--;
4604           newuid = *argv++; argc--;
4605           keyedit_quick_adduid (ctrl, uid, newuid);
4606         }
4607         break;
4608
4609       case aQuickAddKey:
4610         {
4611           const char *x_fpr, *x_algo, *x_usage, *x_expire;
4612
4613           if (argc < 1 || argc > 4)
4614             wrong_args ("--quick-add-key FINGERPRINT [ALGO [USAGE [EXPIRE]]]");
4615           x_fpr = *argv++; argc--;
4616           x_algo = "";
4617           x_usage = "";
4618           x_expire = "";
4619           if (argc)
4620             {
4621               x_algo = *argv++; argc--;
4622               if (argc)
4623                 {
4624                   x_usage = *argv++; argc--;
4625                   if (argc)
4626                    {
4627                      x_expire = *argv++; argc--;
4628                    }
4629                 }
4630             }
4631           keyedit_quick_addkey (ctrl, x_fpr, x_algo, x_usage, x_expire);
4632         }
4633         break;
4634
4635       case aQuickRevUid:
4636         {
4637           const char *uid, *uidtorev;
4638
4639           if (argc != 2)
4640             wrong_args ("--quick-revoke-uid USER-ID USER-ID-TO-REVOKE");
4641           uid = *argv++; argc--;
4642           uidtorev = *argv++; argc--;
4643           keyedit_quick_revuid (ctrl, uid, uidtorev);
4644         }
4645         break;
4646
4647       case aQuickSetExpire:
4648         {
4649           const char *x_fpr, *x_expire;
4650
4651           if (argc < 2)
4652             wrong_args ("--quick-set-exipre FINGERPRINT EXPIRE [SUBKEY-FPRS]");
4653           x_fpr = *argv++; argc--;
4654           x_expire = *argv++; argc--;
4655           keyedit_quick_set_expire (ctrl, x_fpr, x_expire, argv);
4656         }
4657         break;
4658
4659       case aQuickSetPrimaryUid:
4660         {
4661           const char *uid, *primaryuid;
4662
4663           if (argc != 2)
4664             wrong_args ("--quick-set-primary-uid USER-ID PRIMARY-USER-ID");
4665           uid = *argv++; argc--;
4666           primaryuid = *argv++; argc--;
4667           keyedit_quick_set_primary (ctrl, uid, primaryuid);
4668         }
4669         break;
4670
4671       case aFastImport:
4672         opt.import_options |= IMPORT_FAST; /* fall through */
4673       case aImport:
4674       case aShowKeys:
4675         import_keys (ctrl, argc? argv:NULL, argc, NULL,
4676                      opt.import_options, opt.key_origin, opt.key_origin_url);
4677         break;
4678
4679         /* TODO: There are a number of command that use this same
4680            "make strlist, call function, report error, free strlist"
4681            pattern.  Join them together here and avoid all that
4682            duplicated code. */
4683
4684       case aExport:
4685       case aSendKeys:
4686       case aRecvKeys:
4687         sl = NULL;
4688         for( ; argc; argc--, argv++ )
4689             append_to_strlist2( &sl, *argv, utf8_strings );
4690         if( cmd == aSendKeys )
4691             rc = keyserver_export (ctrl, sl );
4692         else if( cmd == aRecvKeys )
4693             rc = keyserver_import (ctrl, sl );
4694         else
4695           {
4696             export_stats_t stats = export_new_stats ();
4697             rc = export_pubkeys (ctrl, sl, opt.export_options, stats);
4698             export_print_stats (stats);
4699             export_release_stats (stats);
4700           }
4701         if(rc)
4702           {
4703             if(cmd==aSendKeys)
4704               {
4705                 write_status_failure ("send-keys", rc);
4706                 log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
4707               }
4708             else if(cmd==aRecvKeys)
4709               {
4710                 write_status_failure ("recv-keys", rc);
4711                 log_error (_("keyserver receive failed: %s\n"),
4712                            gpg_strerror (rc));
4713               }
4714             else
4715               {
4716                 write_status_failure ("export", rc);
4717                 log_error (_("key export failed: %s\n"), gpg_strerror (rc));
4718               }
4719           }
4720         free_strlist(sl);
4721         break;
4722
4723       case aExportSshKey:
4724         if (argc != 1)
4725           wrong_args ("--export-ssh-key <user-id>");
4726         rc = export_ssh_key (ctrl, argv[0]);
4727         if (rc)
4728           {
4729             write_status_failure ("export-ssh-key", rc);
4730             log_error (_("export as ssh key failed: %s\n"), gpg_strerror (rc));
4731           }
4732         break;
4733
4734      case aSearchKeys:
4735         sl = NULL;
4736         for (; argc; argc--, argv++)
4737           append_to_strlist2 (&sl, *argv, utf8_strings);
4738         rc = keyserver_search (ctrl, sl);
4739         if (rc)
4740           {
4741             write_status_failure ("search-keys", rc);
4742             log_error (_("keyserver search failed: %s\n"), gpg_strerror (rc));
4743           }
4744         free_strlist (sl);
4745         break;
4746
4747       case aRefreshKeys:
4748         sl = NULL;
4749         for( ; argc; argc--, argv++ )
4750             append_to_strlist2( &sl, *argv, utf8_strings );
4751         rc = keyserver_refresh (ctrl, sl);
4752         if(rc)
4753           {
4754             write_status_failure ("refresh-keys", rc);
4755             log_error (_("keyserver refresh failed: %s\n"),gpg_strerror (rc));
4756           }
4757         free_strlist(sl);
4758         break;
4759
4760       case aFetchKeys:
4761         sl = NULL;
4762         for( ; argc; argc--, argv++ )
4763             append_to_strlist2( &sl, *argv, utf8_strings );
4764         rc = keyserver_fetch (ctrl, sl, opt.key_origin);
4765         if(rc)
4766           {
4767             write_status_failure ("fetch-keys", rc);
4768             log_error ("key fetch failed: %s\n",gpg_strerror (rc));
4769           }
4770         free_strlist(sl);
4771         break;
4772
4773       case aExportSecret:
4774         sl = NULL;
4775         for( ; argc; argc--, argv++ )
4776             add_to_strlist2( &sl, *argv, utf8_strings );
4777         {
4778           export_stats_t stats = export_new_stats ();
4779           export_seckeys (ctrl, sl, opt.export_options, stats);
4780           export_print_stats (stats);
4781           export_release_stats (stats);
4782         }
4783         free_strlist(sl);
4784         break;
4785
4786       case aExportSecretSub:
4787         sl = NULL;
4788         for( ; argc; argc--, argv++ )
4789             add_to_strlist2( &sl, *argv, utf8_strings );
4790         {
4791           export_stats_t stats = export_new_stats ();
4792           export_secsubkeys (ctrl, sl, opt.export_options, stats);
4793           export_print_stats (stats);
4794           export_release_stats (stats);
4795         }
4796         free_strlist(sl);
4797         break;
4798
4799       case aGenRevoke:
4800         if( argc != 1 )
4801             wrong_args("--generate-revocation user-id");
4802         username =  make_username(*argv);
4803         gen_revoke (ctrl, username );
4804         xfree( username );
4805         break;
4806
4807       case aDesigRevoke:
4808         if (argc != 1)
4809             wrong_args ("--generate-designated-revocation user-id");
4810         username = make_username (*argv);
4811         gen_desig_revoke (ctrl, username, locusr);
4812         xfree (username);
4813         break;
4814
4815       case aDeArmor:
4816         if( argc > 1 )
4817             wrong_args("--dearmor [file]");
4818         rc = dearmor_file( argc? *argv: NULL );
4819         if( rc )
4820           {
4821             write_status_failure ("dearmor", rc);
4822             log_error (_("dearmoring failed: %s\n"), gpg_strerror (rc));
4823           }
4824         break;
4825
4826       case aEnArmor:
4827         if( argc > 1 )
4828             wrong_args("--enarmor [file]");
4829         rc = enarmor_file( argc? *argv: NULL );
4830         if( rc )
4831           {
4832             write_status_failure ("enarmor", rc);
4833             log_error (_("enarmoring failed: %s\n"), gpg_strerror (rc));
4834           }
4835         break;
4836
4837
4838       case aPrimegen:
4839 #if 0 /*FIXME*/
4840         {   int mode = argc < 2 ? 0 : atoi(*argv);
4841
4842             if( mode == 1 && argc == 2 ) {
4843                 mpi_print (es_stdout,
4844                            generate_public_prime( atoi(argv[1]) ), 1);
4845             }
4846             else if( mode == 2 && argc == 3 ) {
4847                 mpi_print (es_stdout, generate_elg_prime(
4848                                              0, atoi(argv[1]),
4849                                              atoi(argv[2]), NULL,NULL ), 1);
4850             }
4851             else if( mode == 3 && argc == 3 ) {
4852                 MPI *factors;
4853                 mpi_print (es_stdout, generate_elg_prime(
4854                                              1, atoi(argv[1]),
4855                                              atoi(argv[2]), NULL,&factors ), 1);
4856                 es_putc ('\n', es_stdout);
4857                 mpi_print (es_stdout, factors[0], 1 ); /* print q */
4858             }
4859             else if( mode == 4 && argc == 3 ) {
4860                 MPI g = mpi_alloc(1);
4861                 mpi_print (es_stdout, generate_elg_prime(
4862                                                  0, atoi(argv[1]),
4863                                                  atoi(argv[2]), g, NULL ), 1);
4864                 es_putc ('\n', es_stdout);