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