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