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