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