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