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