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