Cleanup initialization of libgcrypt.
[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     /* Use our own logging handler for Libcgrypt.  */
2205     setup_libgcrypt_logging ();
2206
2207     /* Put random number into secure memory */
2208     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2209
2210     may_coredump = disable_core_dumps();
2211
2212     gnupg_init_signals (0, emergency_cleanup);
2213
2214     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2215
2216     opt.autostart = 1;
2217     opt.session_env = session_env_new ();
2218     if (!opt.session_env)
2219       log_fatal ("error allocating session environment block: %s\n",
2220                  strerror (errno));
2221
2222     opt.command_fd = -1; /* no command fd */
2223     opt.compress_level = -1; /* defaults to standard compress level */
2224     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2225     /* note: if you change these lines, look at oOpenPGP */
2226     opt.def_cipher_algo = 0;
2227     opt.def_digest_algo = 0;
2228     opt.cert_digest_algo = 0;
2229     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2230     opt.s2k_mode = 3; /* iterated+salted */
2231     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2232     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2233     opt.completes_needed = 1;
2234     opt.marginals_needed = 3;
2235     opt.max_cert_depth = 5;
2236     opt.escape_from = 1;
2237     opt.flags.require_cross_cert = 1;
2238     opt.import_options = 0;
2239     opt.export_options = EXPORT_ATTRIBUTES;
2240     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
2241     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2242     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2243     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2244                           | VERIFY_SHOW_POLICY_URLS
2245                           | VERIFY_SHOW_STD_NOTATIONS
2246                           | VERIFY_SHOW_KEYSERVER_URLS);
2247     opt.list_options   = (LIST_SHOW_UID_VALIDITY
2248                           | LIST_SHOW_USAGE);
2249 #ifdef NO_TRUST_MODELS
2250     opt.trust_model = TM_ALWAYS;
2251 #else
2252     opt.trust_model = TM_AUTO;
2253 #endif
2254     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2255     opt.tofu_db_format = TOFU_DB_AUTO;
2256     opt.mangle_dos_filenames = 0;
2257     opt.min_cert_level = 2;
2258     set_screen_dimensions ();
2259     opt.keyid_format = KF_NONE;
2260     opt.def_sig_expire = "0";
2261     opt.def_cert_expire = "0";
2262     gnupg_set_homedir (NULL);
2263     opt.passphrase_repeat = 1;
2264     opt.emit_version = 0;
2265     opt.weak_digests = NULL;
2266     additional_weak_digest("MD5");
2267
2268     /* Check whether we have a config file on the command line.  */
2269     orig_argc = argc;
2270     orig_argv = argv;
2271     pargs.argc = &argc;
2272     pargs.argv = &argv;
2273     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2274     while( arg_parse( &pargs, opts) ) {
2275         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2276             parse_debug++;
2277         else if (pargs.r_opt == oDebugIOLBF)
2278             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2279         else if( pargs.r_opt == oOptions ) {
2280             /* yes there is one, so we do not try the default one, but
2281              * read the option file when it is encountered at the commandline
2282              */
2283             default_config = 0;
2284         }
2285         else if( pargs.r_opt == oNoOptions )
2286           {
2287             default_config = 0; /* --no-options */
2288             opt.no_homedir_creation = 1;
2289           }
2290         else if( pargs.r_opt == oHomedir )
2291             gnupg_set_homedir (pargs.r.ret_str);
2292         else if( pargs.r_opt == oNoPermissionWarn )
2293             opt.no_perm_warn=1;
2294         else if (pargs.r_opt == oStrict )
2295           {
2296             /* Not used */
2297           }
2298         else if (pargs.r_opt == oNoStrict )
2299           {
2300             /* Not used */
2301           }
2302     }
2303
2304 #ifdef HAVE_DOSISH_SYSTEM
2305     if ( strchr (gnupg_homedir (), '\\') ) {
2306       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
2307       const char *s;
2308       for (d=buf, s = gnupg_homedir (); *s; s++)
2309           {
2310             *d++ = *s == '\\'? '/': *s;
2311 #ifdef HAVE_W32_SYSTEM
2312             if (s[1] && IsDBCSLeadByte (*s))
2313               *d++ = *++s;
2314 #endif
2315           }
2316         *d = 0;
2317         gnupg_set_homedir (buf);
2318     }
2319 #endif
2320
2321     /* Initialize the secure memory. */
2322     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2323       got_secmem = 1;
2324 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2325     /* There should be no way to get to this spot while still carrying
2326        setuid privs.  Just in case, bomb out if we are. */
2327     if ( getuid () != geteuid () )
2328       BUG ();
2329 #endif
2330     maybe_setuid = 0;
2331
2332     /* Okay, we are now working under our real uid */
2333
2334     /* malloc hooks go here ... */
2335     malloc_hooks.malloc = gcry_malloc;
2336     malloc_hooks.realloc = gcry_realloc;
2337     malloc_hooks.free = gcry_free;
2338     assuan_set_malloc_hooks (&malloc_hooks);
2339     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2340     setup_libassuan_logging (&opt.debug);
2341
2342     /* Try for a version specific config file first */
2343     default_configname = get_default_configname ();
2344     if (default_config)
2345       configname = xstrdup (default_configname);
2346
2347     argc = orig_argc;
2348     argv = orig_argv;
2349     pargs.argc = &argc;
2350     pargs.argv = &argv;
2351     pargs.flags= ARGPARSE_FLAG_KEEP;
2352
2353     /* By this point we have a homedir, and cannot change it. */
2354     check_permissions (gnupg_homedir (), 0);
2355
2356   next_pass:
2357     if( configname ) {
2358       if(check_permissions(configname,1))
2359         {
2360           /* If any options file is unsafe, then disable any external
2361              programs for keyserver calls or photo IDs.  Since the
2362              external program to call is set in the options file, a
2363              unsafe options file can lead to an arbitrary program
2364              being run. */
2365
2366           opt.exec_disable=1;
2367         }
2368
2369         configlineno = 0;
2370         configfp = fopen( configname, "r" );
2371         if (configfp && is_secured_file (fileno (configfp)))
2372           {
2373             fclose (configfp);
2374             configfp = NULL;
2375             gpg_err_set_errno (EPERM);
2376           }
2377         if( !configfp ) {
2378             if( default_config ) {
2379                 if( parse_debug )
2380                     log_info(_("Note: no default option file '%s'\n"),
2381                                                             configname );
2382             }
2383             else {
2384                 log_error(_("option file '%s': %s\n"),
2385                                     configname, strerror(errno) );
2386                 g10_exit(2);
2387             }
2388             xfree(configname); configname = NULL;
2389         }
2390         if( parse_debug && configname )
2391             log_info(_("reading options from '%s'\n"), configname );
2392         default_config = 0;
2393     }
2394
2395     while( optfile_parse( configfp, configname, &configlineno,
2396                                                 &pargs, opts) )
2397       {
2398         switch( pargs.r_opt )
2399           {
2400           case aCheckKeys:
2401           case aListConfig:
2402           case aListGcryptConfig:
2403           case aGPGConfList:
2404           case aGPGConfTest:
2405           case aListPackets:
2406           case aImport:
2407           case aFastImport:
2408           case aSendKeys:
2409           case aRecvKeys:
2410           case aSearchKeys:
2411           case aRefreshKeys:
2412           case aFetchKeys:
2413           case aExport:
2414 #ifdef ENABLE_CARD_SUPPORT
2415           case aCardStatus:
2416           case aCardEdit:
2417           case aChangePIN:
2418 #endif /* ENABLE_CARD_SUPPORT*/
2419           case aListKeys:
2420           case aLocateKeys:
2421           case aListSigs:
2422           case aExportSecret:
2423           case aExportSecretSub:
2424           case aExportSshKey:
2425           case aSym:
2426           case aClearsign:
2427           case aGenRevoke:
2428           case aDesigRevoke:
2429           case aPrimegen:
2430           case aGenRandom:
2431           case aPrintMD:
2432           case aPrintMDs:
2433           case aListTrustDB:
2434           case aCheckTrustDB:
2435           case aUpdateTrustDB:
2436           case aFixTrustDB:
2437           case aListTrustPath:
2438           case aDeArmor:
2439           case aEnArmor:
2440           case aSign:
2441           case aQuickSignKey:
2442           case aQuickLSignKey:
2443           case aSignKey:
2444           case aLSignKey:
2445           case aStore:
2446           case aQuickKeygen:
2447           case aQuickAddUid:
2448           case aQuickAddKey:
2449           case aQuickRevUid:
2450           case aExportOwnerTrust:
2451           case aImportOwnerTrust:
2452           case aRebuildKeydbCaches:
2453             set_cmd (&cmd, pargs.r_opt);
2454             break;
2455
2456           case aKeygen:
2457           case aFullKeygen:
2458           case aEditKey:
2459           case aDeleteSecretKeys:
2460           case aDeleteSecretAndPublicKeys:
2461           case aDeleteKeys:
2462           case aPasswd:
2463             set_cmd (&cmd, pargs.r_opt);
2464             greeting=1;
2465             break;
2466
2467           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2468
2469           case aDecryptFiles: multifile=1; /* fall through */
2470           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2471
2472           case aEncrFiles: multifile=1; /* fall through */
2473           case aEncr: set_cmd( &cmd, aEncr); break;
2474
2475           case aVerifyFiles: multifile=1; /* fall through */
2476           case aVerify: set_cmd( &cmd, aVerify); break;
2477
2478           case aServer:
2479             set_cmd (&cmd, pargs.r_opt);
2480             opt.batch = 1;
2481             break;
2482
2483           case aTOFUPolicy:
2484             set_cmd (&cmd, pargs.r_opt);
2485             break;
2486
2487           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2488           case oOutput: opt.outfile = pargs.r.ret_str; break;
2489           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2490           case oQuiet: opt.quiet = 1; break;
2491           case oNoTTY: tty_no_terminal(1); break;
2492           case oDryRun: opt.dry_run = 1; break;
2493           case oInteractive: opt.interactive = 1; break;
2494           case oVerbose:
2495             opt.verbose++;
2496             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2497             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2498             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2499             break;
2500
2501           case oBatch:
2502             opt.batch = 1;
2503             nogreeting = 1;
2504             break;
2505
2506           case oUseAgent: /* Dummy. */
2507             break;
2508
2509           case oNoUseAgent:
2510             obsolete_option (configname, configlineno, "no-use-agent");
2511             break;
2512           case oGpgAgentInfo:
2513             obsolete_option (configname, configlineno, "gpg-agent-info");
2514             break;
2515           case oReaderPort:
2516             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2517             break;
2518           case octapiDriver:
2519             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2520             break;
2521           case opcscDriver:
2522             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2523             break;
2524           case oDisableCCID:
2525             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2526             break;
2527           case oHonorHttpProxy:
2528             obsolete_option (configname, configlineno, "honor-http-proxy");
2529             break;
2530
2531           case oAnswerYes: opt.answer_yes = 1; break;
2532           case oAnswerNo: opt.answer_no = 1; break;
2533           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2534           case oPrimaryKeyring:
2535             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2536             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2537             break;
2538           case oShowKeyring:
2539             deprecated_warning(configname,configlineno,"--show-keyring",
2540                                "--list-options ","show-keyring");
2541             opt.list_options|=LIST_SHOW_KEYRING;
2542             break;
2543
2544           case oDebug:
2545             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2546               {
2547                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2548                 pargs.err = ARGPARSE_PRINT_ERROR;
2549               }
2550             break;
2551
2552           case oDebugAll: opt.debug = ~0; break;
2553           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2554
2555           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2556
2557           case oStatusFD:
2558             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2559             break;
2560           case oStatusFile:
2561             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2562             break;
2563           case oAttributeFD:
2564             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2565             break;
2566           case oAttributeFile:
2567             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2568             break;
2569           case oLoggerFD:
2570             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2571             break;
2572           case oLoggerFile:
2573             logfile = pargs.r.ret_str;
2574             break;
2575
2576           case oWithFingerprint:
2577             opt.with_fingerprint = 1;
2578             opt.fingerprint++;
2579             break;
2580           case oWithSubkeyFingerprint:
2581             opt.with_subkey_fingerprint = 1;
2582             break;
2583           case oWithICAOSpelling:
2584             opt.with_icao_spelling = 1;
2585             break;
2586           case oFingerprint:
2587             opt.fingerprint++;
2588             fpr_maybe_cmd = 1;
2589             break;
2590
2591           case oWithKeygrip:
2592             opt.with_keygrip = 1;
2593             break;
2594
2595           case oWithSecret:
2596             opt.with_secret = 1;
2597             break;
2598
2599           case oWithWKDHash:
2600             opt.with_wkd_hash = 1;
2601             break;
2602
2603           case oSecretKeyring:
2604             /* Ignore this old option.  */
2605             break;
2606
2607           case oOptions:
2608             /* config files may not be nested (silently ignore them) */
2609             if( !configfp ) {
2610                 xfree(configname);
2611                 configname = xstrdup(pargs.r.ret_str);
2612                 goto next_pass;
2613             }
2614             break;
2615           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2616
2617           case oNoDefKeyring:
2618             if (default_keyring > 0)
2619               default_keyring = 0;
2620             break;
2621           case oNoKeyring:
2622             default_keyring = -1;
2623             break;
2624
2625           case oNoGreeting: nogreeting = 1; break;
2626           case oNoVerbose:
2627             opt.verbose = 0;
2628             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2629             opt.list_sigs=0;
2630             break;
2631           case oQuickRandom:
2632             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2633             break;
2634           case oEmitVersion: opt.emit_version++; break;
2635           case oNoEmitVersion: opt.emit_version=0; break;
2636           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2637           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2638           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2639
2640 #ifndef NO_TRUST_MODELS
2641           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2642
2643 #endif /*!NO_TRUST_MODELS*/
2644           case oDefaultKey:
2645             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2646             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2647             if (configfp)
2648               sl->flags |= PK_LIST_CONFIG;
2649             break;
2650           case oDefRecipient:
2651             if( *pargs.r.ret_str )
2652               {
2653                 xfree (opt.def_recipient);
2654                 opt.def_recipient = make_username(pargs.r.ret_str);
2655               }
2656             break;
2657           case oDefRecipientSelf:
2658             xfree(opt.def_recipient); opt.def_recipient = NULL;
2659             opt.def_recipient_self = 1;
2660             break;
2661           case oNoDefRecipient:
2662             xfree(opt.def_recipient); opt.def_recipient = NULL;
2663             opt.def_recipient_self = 0;
2664             break;
2665           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2666           case oHomedir: break;
2667           case oNoBatch: opt.batch = 0; break;
2668
2669           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2670           case oWithColons: opt.with_colons=':'; break;
2671
2672           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2673           case oWithSigList: opt.list_sigs = 1; break;
2674
2675           case oSkipVerify: opt.skip_verify=1; break;
2676
2677           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2678           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2679
2680           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2681
2682 #ifndef NO_TRUST_MODELS
2683             /* There are many programs (like mutt) that call gpg with
2684                --always-trust so keep this option around for a long
2685                time. */
2686           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2687           case oTrustModel:
2688             parse_trust_model(pargs.r.ret_str);
2689             break;
2690 #endif /*!NO_TRUST_MODELS*/
2691           case oTOFUDefaultPolicy:
2692             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2693             break;
2694           case oTOFUDBFormat:
2695             opt.tofu_db_format = parse_tofu_db_format (pargs.r.ret_str);
2696             break;
2697
2698           case oForceOwnertrust:
2699             log_info(_("Note: %s is not for normal use!\n"),
2700                      "--force-ownertrust");
2701             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2702             if(opt.force_ownertrust==-1)
2703               {
2704                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2705                 opt.force_ownertrust=0;
2706               }
2707             break;
2708           case oLoadExtension:
2709             /* Dummy so that gpg 1.4 conf files can work. Should
2710                eventually be removed.  */
2711             break;
2712           case oRFC4880bis:
2713             opt.flags.rfc4880bis = 1;
2714             /* fall thru.  */
2715           case oOpenPGP:
2716           case oRFC4880:
2717             /* This is effectively the same as RFC2440, but with
2718                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2719                --require-cross-certification". */
2720             opt.compliance = CO_RFC4880;
2721             opt.flags.dsa2 = 1;
2722             opt.flags.require_cross_cert = 1;
2723             opt.rfc2440_text = 0;
2724             opt.allow_non_selfsigned_uid = 1;
2725             opt.allow_freeform_uid = 1;
2726             opt.escape_from = 1;
2727             opt.not_dash_escaped = 0;
2728             opt.def_cipher_algo = 0;
2729             opt.def_digest_algo = 0;
2730             opt.cert_digest_algo = 0;
2731             opt.compress_algo = -1;
2732             opt.s2k_mode = 3; /* iterated+salted */
2733             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2734             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2735             break;
2736           case oRFC2440:
2737             opt.compliance = CO_RFC2440;
2738             opt.flags.dsa2 = 0;
2739             opt.rfc2440_text = 1;
2740             opt.allow_non_selfsigned_uid = 1;
2741             opt.allow_freeform_uid = 1;
2742             opt.escape_from = 0;
2743             opt.not_dash_escaped = 0;
2744             opt.def_cipher_algo = 0;
2745             opt.def_digest_algo = 0;
2746             opt.cert_digest_algo = 0;
2747             opt.compress_algo = -1;
2748             opt.s2k_mode = 3; /* iterated+salted */
2749             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2750             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2751             break;
2752           case oPGP6:  opt.compliance = CO_PGP6;  break;
2753           case oPGP7:  opt.compliance = CO_PGP7;  break;
2754           case oPGP8:  opt.compliance = CO_PGP8;  break;
2755           case oGnuPG: opt.compliance = CO_GNUPG; break;
2756           case oRFC2440Text: opt.rfc2440_text=1; break;
2757           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2758           case oSetFilename:
2759             if(utf8_strings)
2760               opt.set_filename = pargs.r.ret_str;
2761             else
2762               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2763             break;
2764           case oForYourEyesOnly: eyes_only = 1; break;
2765           case oNoForYourEyesOnly: eyes_only = 0; break;
2766           case oSetPolicyURL:
2767             add_policy_url(pargs.r.ret_str,0);
2768             add_policy_url(pargs.r.ret_str,1);
2769             break;
2770           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2771           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2772           case oShowPolicyURL:
2773             deprecated_warning(configname,configlineno,"--show-policy-url",
2774                                "--list-options ","show-policy-urls");
2775             deprecated_warning(configname,configlineno,"--show-policy-url",
2776                                "--verify-options ","show-policy-urls");
2777             opt.list_options|=LIST_SHOW_POLICY_URLS;
2778             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2779             break;
2780           case oNoShowPolicyURL:
2781             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2782                                "--list-options ","no-show-policy-urls");
2783             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2784                                "--verify-options ","no-show-policy-urls");
2785             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2786             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2787             break;
2788           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2789           case oUseEmbeddedFilename:
2790             opt.flags.use_embedded_filename=1;
2791             break;
2792           case oNoUseEmbeddedFilename:
2793             opt.flags.use_embedded_filename=0;
2794             break;
2795           case oComment:
2796             if(pargs.r.ret_str[0])
2797               append_to_strlist(&opt.comments,pargs.r.ret_str);
2798             break;
2799           case oDefaultComment:
2800             deprecated_warning(configname,configlineno,
2801                                "--default-comment","--no-comments","");
2802             /* fall through */
2803           case oNoComments:
2804             free_strlist(opt.comments);
2805             opt.comments=NULL;
2806             break;
2807           case oThrowKeyids: opt.throw_keyids = 1; break;
2808           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2809           case oShowPhotos:
2810             deprecated_warning(configname,configlineno,"--show-photos",
2811                                "--list-options ","show-photos");
2812             deprecated_warning(configname,configlineno,"--show-photos",
2813                                "--verify-options ","show-photos");
2814             opt.list_options|=LIST_SHOW_PHOTOS;
2815             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2816             break;
2817           case oNoShowPhotos:
2818             deprecated_warning(configname,configlineno,"--no-show-photos",
2819                                "--list-options ","no-show-photos");
2820             deprecated_warning(configname,configlineno,"--no-show-photos",
2821                                "--verify-options ","no-show-photos");
2822             opt.list_options&=~LIST_SHOW_PHOTOS;
2823             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2824             break;
2825           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2826
2827           case oForceMDC: opt.force_mdc = 1; break;
2828           case oNoForceMDC: opt.force_mdc = 0; break;
2829           case oDisableMDC: opt.disable_mdc = 1; break;
2830           case oNoDisableMDC: opt.disable_mdc = 0; break;
2831
2832           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
2833
2834           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2835           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2836           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2837           case oS2KCount:
2838             if (pargs.r.ret_int)
2839               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2840             else
2841               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2842             break;
2843
2844           case oRecipient:
2845           case oHiddenRecipient:
2846           case oRecipientFile:
2847           case oHiddenRecipientFile:
2848             /* Store the recipient.  Note that we also store the
2849              * option as private data in the flags.  This is achieved
2850              * by shifting the option value to the left so to keep
2851              * enough space for the flags.  */
2852             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2853             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2854             if (configfp)
2855               sl->flags |= PK_LIST_CONFIG;
2856             if (pargs.r_opt == oHiddenRecipient
2857                 || pargs.r_opt == oHiddenRecipientFile)
2858               sl->flags |= PK_LIST_HIDDEN;
2859             if (pargs.r_opt == oRecipientFile
2860                 || pargs.r_opt == oHiddenRecipientFile)
2861               sl->flags |= PK_LIST_FROM_FILE;
2862             any_explicit_recipient = 1;
2863             break;
2864
2865           case oEncryptTo:
2866           case oHiddenEncryptTo:
2867             /* Store an additional recipient.  */
2868             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2869             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
2870             if (configfp)
2871               sl->flags |= PK_LIST_CONFIG;
2872             if (pargs.r_opt == oHiddenEncryptTo)
2873               sl->flags |= PK_LIST_HIDDEN;
2874             break;
2875
2876           case oNoEncryptTo:
2877             opt.no_encrypt_to = 1;
2878             break;
2879           case oEncryptToDefaultKey:
2880             opt.encrypt_to_default_key = configfp ? 2 : 1;
2881             break;
2882
2883           case oTrySecretKey:
2884             add_to_strlist2 (&opt.secret_keys_to_try,
2885                              pargs.r.ret_str, utf8_strings);
2886             break;
2887
2888           case oMimemode: opt.mimemode = opt.textmode = 1; break;
2889           case oTextmodeShort: opt.textmode = 2; break;
2890           case oTextmode: opt.textmode=1;  break;
2891           case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
2892
2893           case oExpert: opt.expert = 1; break;
2894           case oNoExpert: opt.expert = 0; break;
2895           case oDefSigExpire:
2896             if(*pargs.r.ret_str!='\0')
2897               {
2898                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2899                   log_error(_("'%s' is not a valid signature expiration\n"),
2900                             pargs.r.ret_str);
2901                 else
2902                   opt.def_sig_expire=pargs.r.ret_str;
2903               }
2904             break;
2905           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2906           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2907           case oDefCertExpire:
2908             if(*pargs.r.ret_str!='\0')
2909               {
2910                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2911                   log_error(_("'%s' is not a valid signature expiration\n"),
2912                             pargs.r.ret_str);
2913                 else
2914                   opt.def_cert_expire=pargs.r.ret_str;
2915               }
2916             break;
2917           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2918           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2919           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2920           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2921           case oAskCertLevel: opt.ask_cert_level = 1; break;
2922           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2923           case oLocalUser: /* store the local users */
2924             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2925             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2926             if (configfp)
2927               sl->flags |= PK_LIST_CONFIG;
2928             break;
2929           case oCompress:
2930             /* this is the -z command line option */
2931             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2932             break;
2933           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2934           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2935           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2936           case oPassphrase:
2937             set_passphrase_from_string(pargs.r.ret_str);
2938             break;
2939           case oPassphraseFD:
2940             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2941             break;
2942           case oPassphraseFile:
2943             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
2944             break;
2945           case oPassphraseRepeat:
2946             opt.passphrase_repeat = pargs.r.ret_int;
2947             break;
2948
2949           case oPinentryMode:
2950             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
2951             if (opt.pinentry_mode == -1)
2952               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
2953             break;
2954
2955           case oCommandFD:
2956             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2957             break;
2958           case oCommandFile:
2959             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
2960             break;
2961           case oCipherAlgo:
2962             def_cipher_string = xstrdup(pargs.r.ret_str);
2963             break;
2964           case oDigestAlgo:
2965             def_digest_string = xstrdup(pargs.r.ret_str);
2966             break;
2967           case oCompressAlgo:
2968             /* If it is all digits, stick a Z in front of it for
2969                later.  This is for backwards compatibility with
2970                versions that took the compress algorithm number. */
2971             {
2972               char *pt=pargs.r.ret_str;
2973               while(*pt)
2974                 {
2975                   if (!isascii (*pt) || !isdigit (*pt))
2976                     break;
2977
2978                   pt++;
2979                 }
2980
2981               if(*pt=='\0')
2982                 {
2983                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2984                   strcpy(compress_algo_string,"Z");
2985                   strcat(compress_algo_string,pargs.r.ret_str);
2986                 }
2987               else
2988                 compress_algo_string = xstrdup(pargs.r.ret_str);
2989             }
2990             break;
2991           case oCertDigestAlgo:
2992             cert_digest_string = xstrdup(pargs.r.ret_str);
2993             break;
2994
2995           case oNoSecmemWarn:
2996             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
2997             break;
2998
2999           case oRequireSecmem: require_secmem=1; break;
3000           case oNoRequireSecmem: require_secmem=0; break;
3001           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3002           case oNoMDCWarn: opt.no_mdc_warn=1; break;
3003           case oDisplayCharset:
3004             if( set_native_charset( pargs.r.ret_str ) )
3005                 log_error(_("'%s' is not a valid character set\n"),
3006                           pargs.r.ret_str);
3007             break;
3008           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3009           case oEscapeFrom: opt.escape_from = 1; break;
3010           case oNoEscapeFrom: opt.escape_from = 0; break;
3011           case oLockOnce: opt.lock_once = 1; break;
3012           case oLockNever:
3013             dotlock_disable ();
3014             break;
3015           case oLockMultiple:
3016 #ifndef __riscos__
3017             opt.lock_once = 0;
3018 #else /* __riscos__ */
3019             riscos_not_implemented("lock-multiple");
3020 #endif /* __riscos__ */
3021             break;
3022           case oKeyServer:
3023             {
3024               keyserver_spec_t keyserver;
3025               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3026               if (!keyserver)
3027                 log_error (_("could not parse keyserver URL\n"));
3028               else
3029                 {
3030                   /* We only support a single keyserver.  Later ones
3031                      override earlier ones.  (Since we parse the
3032                      config file first and then the command line
3033                      arguments, the command line takes
3034                      precedence.)  */
3035                   if (opt.keyserver)
3036                     free_keyserver_spec (opt.keyserver);
3037                   opt.keyserver = keyserver;
3038                 }
3039             }
3040             break;
3041           case oKeyServerOptions:
3042             if(!parse_keyserver_options(pargs.r.ret_str))
3043               {
3044                 if(configname)
3045                   log_error(_("%s:%d: invalid keyserver options\n"),
3046                             configname,configlineno);
3047                 else
3048                   log_error(_("invalid keyserver options\n"));
3049               }
3050             break;
3051           case oImportOptions:
3052             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3053               {
3054                 if(configname)
3055                   log_error(_("%s:%d: invalid import options\n"),
3056                             configname,configlineno);
3057                 else
3058                   log_error(_("invalid import options\n"));
3059               }
3060             break;
3061           case oImportFilter:
3062             rc = parse_and_set_import_filter (pargs.r.ret_str);
3063             if (rc)
3064               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3065             break;
3066           case oExportOptions:
3067             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3068               {
3069                 if(configname)
3070                   log_error(_("%s:%d: invalid export options\n"),
3071                             configname,configlineno);
3072                 else
3073                   log_error(_("invalid export options\n"));
3074               }
3075             break;
3076           case oExportFilter:
3077             rc = parse_and_set_export_filter (pargs.r.ret_str);
3078             if (rc)
3079               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3080             break;
3081           case oListOptions:
3082             if(!parse_list_options(pargs.r.ret_str))
3083               {
3084                 if(configname)
3085                   log_error(_("%s:%d: invalid list options\n"),
3086                             configname,configlineno);
3087                 else
3088                   log_error(_("invalid list options\n"));
3089               }
3090             break;
3091           case oVerifyOptions:
3092             {
3093               struct parse_options vopts[]=
3094                 {
3095                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3096                    N_("display photo IDs during signature verification")},
3097                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3098                    N_("show policy URLs during signature verification")},
3099                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3100                    N_("show all notations during signature verification")},
3101                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3102                    N_("show IETF standard notations during signature verification")},
3103                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3104                    NULL},
3105                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3106                    N_("show user-supplied notations during signature verification")},
3107                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3108                    N_("show preferred keyserver URLs during signature verification")},
3109                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3110                    N_("show user ID validity during signature verification")},
3111                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3112                    N_("show revoked and expired user IDs in signature verification")},
3113                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3114                    N_("show only the primary user ID in signature verification")},
3115                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3116                    N_("validate signatures with PKA data")},
3117                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3118                    N_("elevate the trust of signatures with valid PKA data")},
3119                   {NULL,0,NULL,NULL}
3120                 };
3121
3122               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3123                 {
3124                   if(configname)
3125                     log_error(_("%s:%d: invalid verify options\n"),
3126                               configname,configlineno);
3127                   else
3128                     log_error(_("invalid verify options\n"));
3129                 }
3130             }
3131             break;
3132           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3133           case oExecPath:
3134             if(set_exec_path(pargs.r.ret_str))
3135               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3136             else
3137               opt.exec_path_set=1;
3138             break;
3139           case oSetNotation:
3140             add_notation_data( pargs.r.ret_str, 0 );
3141             add_notation_data( pargs.r.ret_str, 1 );
3142             break;
3143           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3144           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3145           case oShowNotation:
3146             deprecated_warning(configname,configlineno,"--show-notation",
3147                                "--list-options ","show-notations");
3148             deprecated_warning(configname,configlineno,"--show-notation",
3149                                "--verify-options ","show-notations");
3150             opt.list_options|=LIST_SHOW_NOTATIONS;
3151             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3152             break;
3153           case oNoShowNotation:
3154             deprecated_warning(configname,configlineno,"--no-show-notation",
3155                                "--list-options ","no-show-notations");
3156             deprecated_warning(configname,configlineno,"--no-show-notation",
3157                                "--verify-options ","no-show-notations");
3158             opt.list_options&=~LIST_SHOW_NOTATIONS;
3159             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3160             break;
3161           case oUtf8Strings: utf8_strings = 1; break;
3162           case oNoUtf8Strings: utf8_strings = 0; break;
3163           case oDisableCipherAlgo:
3164             {
3165               int algo = string_to_cipher_algo (pargs.r.ret_str);
3166               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3167             }
3168             break;
3169           case oDisablePubkeyAlgo:
3170             {
3171               int algo = gcry_pk_map_name (pargs.r.ret_str);
3172               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3173             }
3174             break;
3175           case oNoSigCache: opt.no_sig_cache = 1; break;
3176           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3177           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3178           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3179           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3180           case oNoLiteral: opt.no_literal = 1; break;
3181           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3182           case oFastListMode: opt.fast_list_mode = 1; break;
3183           case oFixedListMode: /* Dummy */ break;
3184           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3185           case oPrintPKARecords: print_pka_records = 1; break;
3186           case oPrintDANERecords: print_dane_records = 1; break;
3187           case oListOnly: opt.list_only=1; break;
3188           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3189           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3190           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3191           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3192           case oNoRandomSeedFile: use_random_seed = 0; break;
3193           case oAutoKeyRetrieve:
3194           case oNoAutoKeyRetrieve:
3195                 if(pargs.r_opt==oAutoKeyRetrieve)
3196                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
3197                 else
3198                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
3199                 break;
3200           case oShowSessionKey: opt.show_session_key = 1; break;
3201           case oOverrideSessionKey:
3202                 opt.override_session_key = pargs.r.ret_str;
3203                 break;
3204           case oMergeOnly:
3205                 deprecated_warning(configname,configlineno,"--merge-only",
3206                                    "--import-options ","merge-only");
3207                 opt.import_options|=IMPORT_MERGE_ONLY;
3208             break;
3209           case oAllowSecretKeyImport: /* obsolete */ break;
3210           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3211           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3212           case oEnableSpecialFilenames:
3213             iobuf_enable_special_filenames (1);
3214             break;
3215           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3216           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3217           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3218           case oPreservePermissions: opt.preserve_permissions=1; break;
3219           case oDefaultPreferenceList:
3220             opt.def_preference_list = pargs.r.ret_str;
3221             break;
3222           case oDefaultKeyserverURL:
3223             {
3224               keyserver_spec_t keyserver;
3225               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3226               if (!keyserver)
3227                 log_error (_("could not parse keyserver URL\n"));
3228               else
3229                 free_keyserver_spec (keyserver);
3230
3231               opt.def_keyserver_url = pargs.r.ret_str;
3232             }
3233             break;
3234           case oPersonalCipherPreferences:
3235             pers_cipher_list=pargs.r.ret_str;
3236             break;
3237           case oPersonalDigestPreferences:
3238             pers_digest_list=pargs.r.ret_str;
3239             break;
3240           case oPersonalCompressPreferences:
3241             pers_compress_list=pargs.r.ret_str;
3242             break;
3243           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3244           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3245           case oWeakDigest:
3246             additional_weak_digest(pargs.r.ret_str);
3247             break;
3248           case oUnwrap:
3249             opt.unwrap_encryption = 1;
3250             break;
3251           case oOnlySignTextIDs:
3252             opt.only_sign_text_ids = 1;
3253             break;
3254
3255           case oDisplay:
3256             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3257             break;
3258           case oTTYname:
3259             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3260             break;
3261           case oTTYtype:
3262             set_opt_session_env ("TERM", pargs.r.ret_str);
3263             break;
3264           case oXauthority:
3265             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3266             break;
3267
3268           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3269           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3270
3271           case oGroup: add_group(pargs.r.ret_str); break;
3272           case oUnGroup: rm_group(pargs.r.ret_str); break;
3273           case oNoGroups:
3274             while(opt.grouplist)
3275               {
3276                 struct groupitem *iter=opt.grouplist;
3277                 free_strlist(iter->values);
3278                 opt.grouplist=opt.grouplist->next;
3279                 xfree(iter);
3280               }
3281             break;
3282
3283           case oStrict:
3284           case oNoStrict:
3285             /* Not used */
3286             break;
3287
3288           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3289           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3290           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3291           case oMultifile: multifile=1; break;
3292           case oKeyidFormat:
3293             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3294               opt.keyid_format=KF_SHORT;
3295             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3296               opt.keyid_format=KF_LONG;
3297             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3298               opt.keyid_format=KF_0xSHORT;
3299             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3300               opt.keyid_format=KF_0xLONG;
3301             else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
3302               opt.keyid_format = KF_NONE;
3303             else
3304               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3305             break;
3306
3307           case oExitOnStatusWriteError:
3308             opt.exit_on_status_write_error = 1;
3309             break;
3310
3311           case oLimitCardInsertTries:
3312             opt.limit_card_insert_tries = pargs.r.ret_int;
3313             break;
3314
3315           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3316           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3317
3318           case oAutoKeyLocate:
3319             if(!parse_auto_key_locate(pargs.r.ret_str))
3320               {
3321                 if(configname)
3322                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3323                             configname,configlineno);
3324                 else
3325                   log_error(_("invalid auto-key-locate list\n"));
3326               }
3327             break;
3328           case oNoAutoKeyLocate:
3329             release_akl();
3330             break;
3331
3332           case oEnableLargeRSA:
3333 #if SECMEM_BUFFER_SIZE >= 65536
3334             opt.flags.large_rsa=1;
3335 #else
3336             if (configname)
3337               log_info("%s:%d: WARNING: gpg not built with large secure "
3338                          "memory buffer.  Ignoring enable-large-rsa\n",
3339                         configname,configlineno);
3340             else
3341               log_info("WARNING: gpg not built with large secure "
3342                          "memory buffer.  Ignoring --enable-large-rsa\n");
3343 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3344             break;
3345           case oDisableLargeRSA: opt.flags.large_rsa=0;
3346             break;
3347
3348           case oEnableDSA2: opt.flags.dsa2=1; break;
3349           case oDisableDSA2: opt.flags.dsa2=0; break;
3350
3351           case oAllowMultisigVerification:
3352           case oAllowMultipleMessages:
3353             opt.flags.allow_multiple_messages=1;
3354             break;
3355
3356           case oNoAllowMultipleMessages:
3357             opt.flags.allow_multiple_messages=0;
3358             break;
3359
3360           case oAllowWeakDigestAlgos:
3361             opt.flags.allow_weak_digest_algos = 1;
3362             break;
3363
3364           case oFakedSystemTime:
3365             {
3366               time_t faked_time = isotime2epoch (pargs.r.ret_str);
3367               if (faked_time == (time_t)(-1))
3368                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3369               gnupg_set_time (faked_time, 0);
3370             }
3371             break;
3372
3373           case oNoAutostart: opt.autostart = 0; break;
3374
3375           case oNoop: break;
3376
3377           default:
3378             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3379             break;
3380           }
3381       }
3382
3383     if (configfp)
3384       {
3385         fclose( configfp );
3386         configfp = NULL;
3387         /* Remember the first config file name. */
3388         if (!save_configname)
3389           save_configname = configname;
3390         else
3391           xfree(configname);
3392         configname = NULL;
3393         goto next_pass;
3394       }
3395     xfree(configname); configname = NULL;
3396     if (log_get_errorcount (0))
3397       g10_exit(2);
3398
3399     /* The command --gpgconf-list is pretty simple and may be called
3400        directly after the option parsing. */
3401     if (cmd == aGPGConfList)
3402       {
3403         gpgconf_list (save_configname ? save_configname : default_configname);
3404         g10_exit (0);
3405       }
3406     xfree (save_configname);
3407     xfree (default_configname);
3408
3409     if (print_dane_records)
3410       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3411                  "--print-dane-records",
3412                  "--export-options export-dane");
3413     if (print_pka_records)
3414       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3415                  "--print-pks-records",
3416                  "--export-options export-pka");
3417     if (log_get_errorcount (0))
3418       g10_exit(2);
3419
3420
3421     if( nogreeting )
3422         greeting = 0;
3423
3424     if( greeting )
3425       {
3426         es_fprintf (es_stderr, "%s %s; %s\n",
3427                     strusage(11), strusage(13), strusage(14) );
3428         es_fprintf (es_stderr, "%s\n", strusage(15) );
3429       }
3430 #ifdef IS_DEVELOPMENT_VERSION
3431     if (!opt.batch)
3432       {
3433         const char *s;
3434
3435         if((s=strusage(25)))
3436           log_info("%s\n",s);
3437         if((s=strusage(26)))
3438           log_info("%s\n",s);
3439         if((s=strusage(27)))
3440           log_info("%s\n",s);
3441       }
3442 #endif
3443
3444     /* FIXME: We should use logging to a file only in server mode;
3445        however we have not yet implemetyed that.  Thus we try to get
3446        away with --batch as indication for logging to file
3447        required. */
3448     if (logfile && opt.batch)
3449       {
3450         log_set_file (logfile);
3451         log_set_prefix (NULL, 1|2|4);
3452       }
3453
3454     if (opt.verbose > 2)
3455         log_info ("using character set '%s'\n", get_native_charset ());
3456
3457     if( may_coredump && !opt.quiet )
3458         log_info(_("WARNING: program may create a core file!\n"));
3459
3460     if (opt.flags.rfc4880bis)
3461         log_info ("WARNING: using experimental features from RFC4880bis!\n");
3462     else
3463       {
3464         opt.mimemode = 0; /* This will use text mode instead.  */
3465       }
3466
3467     if (eyes_only) {
3468       if (opt.set_filename)
3469           log_info(_("WARNING: %s overrides %s\n"),
3470                    "--for-your-eyes-only","--set-filename");
3471
3472       opt.set_filename="_CONSOLE";
3473     }
3474
3475     if (opt.no_literal) {
3476         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3477         if (opt.textmode)
3478             log_error(_("%s not allowed with %s!\n"),
3479                        "--textmode", "--no-literal" );
3480         if (opt.set_filename)
3481             log_error(_("%s makes no sense with %s!\n"),
3482                         eyes_only?"--for-your-eyes-only":"--set-filename",
3483                         "--no-literal" );
3484     }
3485
3486
3487     if (opt.set_filesize)
3488         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3489     if( opt.batch )
3490         tty_batchmode( 1 );
3491
3492     if (gnupg_faked_time_p ())
3493       {
3494         gnupg_isotime_t tbuf;
3495
3496         log_info (_("WARNING: running with faked system time: "));
3497         gnupg_get_isotime (tbuf);
3498         dump_isotime (tbuf);
3499         log_printf ("\n");
3500       }
3501
3502     /* Print a warning if an argument looks like an option.  */
3503     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3504       {
3505         int i;
3506
3507         for (i=0; i < argc; i++)
3508           if (argv[i][0] == '-' && argv[i][1] == '-')
3509             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3510       }
3511
3512
3513     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3514
3515     if(require_secmem && !got_secmem)
3516       {
3517         log_info(_("will not run with insecure memory due to %s\n"),
3518                  "--require-secmem");
3519         g10_exit(2);
3520       }
3521
3522     set_debug (debug_level);
3523     if (DBG_CLOCK)
3524       log_clock ("start");
3525
3526     /* Do these after the switch(), so they can override settings. */
3527     if(PGP6)
3528       {
3529         /* That does not anymore work because we have no more support
3530            for v3 signatures.  */
3531         opt.disable_mdc=1;
3532         opt.escape_from=1;
3533         opt.ask_sig_expire=0;
3534       }
3535     else if(PGP7)
3536       {
3537         /* That does not anymore work because we have no more support
3538            for v3 signatures.  */
3539         opt.escape_from=1;
3540         opt.ask_sig_expire=0;
3541       }
3542     else if(PGP8)
3543       {
3544         opt.escape_from=1;
3545       }
3546
3547
3548     if( def_cipher_string ) {
3549         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3550         xfree(def_cipher_string); def_cipher_string = NULL;
3551         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3552             log_error(_("selected cipher algorithm is invalid\n"));
3553     }
3554     if( def_digest_string ) {
3555         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3556         xfree(def_digest_string); def_digest_string = NULL;
3557         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3558             log_error(_("selected digest algorithm is invalid\n"));
3559     }
3560     if( compress_algo_string ) {
3561         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3562         xfree(compress_algo_string); compress_algo_string = NULL;
3563         if( check_compress_algo(opt.compress_algo) )
3564           log_error(_("selected compression algorithm is invalid\n"));
3565     }
3566     if( cert_digest_string ) {
3567         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3568         xfree(cert_digest_string); cert_digest_string = NULL;
3569         if (openpgp_md_test_algo(opt.cert_digest_algo))
3570           log_error(_("selected certification digest algorithm is invalid\n"));
3571     }
3572     if( s2k_cipher_string ) {
3573         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3574         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3575         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3576           log_error(_("selected cipher algorithm is invalid\n"));
3577     }
3578     if( s2k_digest_string ) {
3579         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3580         xfree(s2k_digest_string); s2k_digest_string = NULL;
3581         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3582           log_error(_("selected digest algorithm is invalid\n"));
3583     }
3584     if( opt.completes_needed < 1 )
3585       log_error(_("completes-needed must be greater than 0\n"));
3586     if( opt.marginals_needed < 2 )
3587       log_error(_("marginals-needed must be greater than 1\n"));
3588     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3589       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3590     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3591       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3592     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3593       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3594     switch( opt.s2k_mode ) {
3595       case 0:
3596         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3597         break;
3598       case 1: case 3: break;
3599       default:
3600         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3601     }
3602
3603     /* This isn't actually needed, but does serve to error out if the
3604        string is invalid. */
3605     if(opt.def_preference_list &&
3606         keygen_set_std_prefs(opt.def_preference_list,0))
3607       log_error(_("invalid default preferences\n"));
3608
3609     if(pers_cipher_list &&
3610        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3611       log_error(_("invalid personal cipher preferences\n"));
3612
3613     if(pers_digest_list &&
3614        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3615       log_error(_("invalid personal digest preferences\n"));
3616
3617     if(pers_compress_list &&
3618        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3619       log_error(_("invalid personal compress preferences\n"));
3620
3621     /* We don't support all possible commands with multifile yet */
3622     if(multifile)
3623       {
3624         char *cmdname;
3625
3626         switch(cmd)
3627           {
3628           case aSign:
3629             cmdname="--sign";
3630             break;
3631           case aSignEncr:
3632             cmdname="--sign --encrypt";
3633             break;
3634           case aClearsign:
3635             cmdname="--clearsign";
3636             break;
3637           case aDetachedSign:
3638             cmdname="--detach-sign";
3639             break;
3640           case aSym:
3641             cmdname="--symmetric";
3642             break;
3643           case aEncrSym:
3644             cmdname="--symmetric --encrypt";
3645             break;
3646           case aStore:
3647             cmdname="--store";
3648             break;
3649           default:
3650             cmdname=NULL;
3651             break;
3652           }
3653
3654         if(cmdname)
3655           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3656       }
3657
3658     if( log_get_errorcount(0) )
3659         g10_exit(2);
3660
3661     if(opt.compress_level==0)
3662       opt.compress_algo=COMPRESS_ALGO_NONE;
3663
3664     /* Check our chosen algorithms against the list of legal
3665        algorithms. */
3666
3667     if(!GNUPG)
3668       {
3669         const char *badalg=NULL;
3670         preftype_t badtype=PREFTYPE_NONE;
3671
3672         if(opt.def_cipher_algo
3673            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3674           {
3675             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3676             badtype = PREFTYPE_SYM;
3677           }
3678         else if(opt.def_digest_algo
3679                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3680           {
3681             badalg = gcry_md_algo_name (opt.def_digest_algo);
3682             badtype = PREFTYPE_HASH;
3683           }
3684         else if(opt.cert_digest_algo
3685                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3686           {
3687             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3688             badtype = PREFTYPE_HASH;
3689           }
3690         else if(opt.compress_algo!=-1
3691                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3692           {
3693             badalg = compress_algo_to_string(opt.compress_algo);
3694             badtype = PREFTYPE_ZIP;
3695           }
3696
3697         if(badalg)
3698           {
3699             switch(badtype)
3700               {
3701               case PREFTYPE_SYM:
3702                 log_info(_("you may not use cipher algorithm '%s'"
3703                            " while in %s mode\n"),
3704                          badalg,compliance_option_string());
3705                 break;
3706               case PREFTYPE_HASH:
3707                 log_info(_("you may not use digest algorithm '%s'"
3708                            " while in %s mode\n"),
3709                          badalg,compliance_option_string());
3710                 break;
3711               case PREFTYPE_ZIP:
3712                 log_info(_("you may not use compression algorithm '%s'"
3713                            " while in %s mode\n"),
3714                          badalg,compliance_option_string());
3715                 break;
3716               default:
3717                 BUG();
3718               }
3719
3720             compliance_failure();
3721           }
3722       }
3723
3724     /* Set the random seed file. */
3725     if( use_random_seed ) {
3726       char *p = make_filename (gnupg_homedir (), "random_seed", NULL );
3727         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3728         if (!access (p, F_OK))
3729           register_secured_file (p);
3730         xfree(p);
3731     }
3732
3733     /* If there is no command but the --fingerprint is given, default
3734        to the --list-keys command.  */
3735     if (!cmd && fpr_maybe_cmd)
3736       {
3737         set_cmd (&cmd, aListKeys);
3738       }
3739
3740
3741     if( opt.verbose > 1 )
3742         set_packet_list_mode(1);
3743
3744     /* Add the keyrings, but not for some special commands.  We always
3745      * need to add the keyrings if we are running under SELinux, this
3746      * is so that the rings are added to the list of secured files.
3747      * We do not add any keyring if --no-keyring has been used.  */
3748     if (default_keyring >= 0
3749         && (ALWAYS_ADD_KEYRINGS
3750             || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest)))
3751       {
3752         if (!nrings || default_keyring > 0)  /* Add default ring. */
3753             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3754                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3755         for (sl = nrings; sl; sl = sl->next )
3756           keydb_add_resource (sl->d, sl->flags);
3757       }
3758     FREE_STRLIST(nrings);
3759
3760     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
3761       /* In loopback mode, never ask for the password multiple
3762          times.  */
3763       {
3764         opt.passphrase_repeat = 0;
3765       }
3766
3767     if (cmd == aGPGConfTest)
3768       g10_exit(0);
3769
3770
3771     if( pwfd != -1 )  /* Read the passphrase now. */
3772         read_passphrase_from_fd( pwfd );
3773
3774     fname = argc? *argv : NULL;
3775
3776     if(fname && utf8_strings)
3777       opt.flags.utf8_filename=1;
3778
3779     ctrl = xcalloc (1, sizeof *ctrl);
3780     gpg_init_default_ctrl (ctrl);
3781
3782 #ifndef NO_TRUST_MODELS
3783     switch (cmd)
3784       {
3785       case aPrimegen:
3786       case aPrintMD:
3787       case aPrintMDs:
3788       case aGenRandom:
3789       case aDeArmor:
3790       case aEnArmor:
3791         break;
3792       case aFixTrustDB:
3793       case aExportOwnerTrust:
3794         rc = setup_trustdb (0, trustdb_name);
3795         break;
3796       case aListTrustDB:
3797         rc = setup_trustdb (argc? 1:0, trustdb_name);
3798         break;
3799       default:
3800         /* If we are using TM_ALWAYS, we do not need to create the
3801            trustdb.  */
3802         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3803         break;
3804       }
3805     if (rc)
3806       log_error (_("failed to initialize the TrustDB: %s\n"),
3807                  gpg_strerror (rc));
3808 #endif /*!NO_TRUST_MODELS*/
3809
3810     switch (cmd)
3811       {
3812       case aStore:
3813       case aSym:
3814       case aSign:
3815       case aSignSym:
3816       case aClearsign:
3817         if (!opt.quiet && any_explicit_recipient)
3818           log_info (_("WARNING: recipients (-r) given "
3819                       "without using public key encryption\n"));
3820         break;
3821       default:
3822         break;
3823       }
3824
3825
3826     /* Check for certain command whether we need to migrate a
3827        secring.gpg to the gpg-agent. */
3828     switch (cmd)
3829       {
3830       case aListSecretKeys:
3831       case aSign:
3832       case aSignEncr:
3833       case aSignEncrSym:
3834       case aSignSym:
3835       case aClearsign:
3836       case aDecrypt:
3837       case aSignKey:
3838       case aLSignKey:
3839       case aEditKey:
3840       case aPasswd:
3841       case aDeleteSecretKeys:
3842       case aDeleteSecretAndPublicKeys:
3843       case aQuickKeygen:
3844       case aQuickAddUid:
3845       case aQuickAddKey:
3846       case aQuickRevUid:
3847       case aFullKeygen:
3848       case aKeygen:
3849       case aImport:
3850       case aExportSecret:
3851       case aExportSecretSub:
3852       case aGenRevoke:
3853       case aDesigRevoke:
3854       case aCardEdit:
3855       case aChangePIN:
3856         migrate_secring (ctrl);
3857         break;
3858       case aListKeys:
3859         if (opt.with_secret)
3860           migrate_secring (ctrl);
3861         break;
3862       default:
3863         break;
3864       }
3865
3866     /* The command dispatcher.  */
3867     switch( cmd )
3868       {
3869       case aServer:
3870         gpg_server (ctrl);
3871         break;
3872
3873       case aStore: /* only store the file */
3874         if( argc > 1 )
3875             wrong_args(_("--store [filename]"));
3876         if( (rc = encrypt_store(fname)) )
3877           {
3878             write_status_failure ("store", rc);
3879             log_error ("storing '%s' failed: %s\n",
3880                        print_fname_stdin(fname),gpg_strerror (rc) );
3881           }
3882         break;
3883       case aSym: /* encrypt the given file only with the symmetric cipher */
3884         if( argc > 1 )
3885             wrong_args(_("--symmetric [filename]"));
3886         if( (rc = encrypt_symmetric(fname)) )
3887           {
3888             write_status_failure ("symencrypt", rc);
3889             log_error (_("symmetric encryption of '%s' failed: %s\n"),
3890                         print_fname_stdin(fname),gpg_strerror (rc) );
3891           }
3892         break;
3893
3894       case aEncr: /* encrypt the given file */
3895         if(multifile)
3896           encrypt_crypt_files (ctrl, argc, argv, remusr);
3897         else
3898           {
3899             if( argc > 1 )
3900               wrong_args(_("--encrypt [filename]"));
3901             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
3902               {
3903                 write_status_failure ("encrypt", rc);
3904                 log_error("%s: encryption failed: %s\n",
3905                           print_fname_stdin(fname), gpg_strerror (rc) );
3906               }
3907           }
3908         break;
3909
3910       case aEncrSym:
3911         /* This works with PGP 8 in the sense that it acts just like a
3912            symmetric message.  It doesn't work at all with 2 or 6.  It
3913            might work with 7, but alas, I don't have a copy to test
3914            with right now. */
3915         if( argc > 1 )
3916           wrong_args(_("--symmetric --encrypt [filename]"));
3917         else if(opt.s2k_mode==0)
3918           log_error(_("you cannot use --symmetric --encrypt"
3919                       " with --s2k-mode 0\n"));
3920         else if(PGP6 || PGP7)
3921           log_error(_("you cannot use --symmetric --encrypt"
3922                       " while in %s mode\n"),compliance_option_string());
3923         else
3924           {
3925             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
3926               {
3927                 write_status_failure ("encrypt", rc);
3928                 log_error ("%s: encryption failed: %s\n",
3929                            print_fname_stdin(fname), gpg_strerror (rc) );
3930               }
3931           }
3932         break;
3933
3934       case aSign: /* sign the given file */
3935         sl = NULL;
3936         if( detached_sig ) { /* sign all files */
3937             for( ; argc; argc--, argv++ )
3938                 add_to_strlist( &sl, *argv );
3939         }
3940         else {
3941             if( argc > 1 )
3942                 wrong_args(_("--sign [filename]"));
3943             if( argc ) {
3944                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3945                 strcpy(sl->d, fname);
3946             }
3947         }
3948         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
3949           {
3950             write_status_failure ("sign", rc);
3951             log_error ("signing failed: %s\n", gpg_strerror (rc) );
3952           }
3953         free_strlist(sl);
3954         break;
3955
3956       case aSignEncr: /* sign and encrypt the given file */
3957         if( argc > 1 )
3958             wrong_args(_("--sign --encrypt [filename]"));
3959         if( argc ) {
3960             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3961             strcpy(sl->d, fname);
3962         }
3963         else
3964             sl = NULL;
3965         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
3966           {
3967             write_status_failure ("sign-encrypt", rc);
3968             log_error("%s: sign+encrypt failed: %s\n",
3969                       print_fname_stdin(fname), gpg_strerror (rc) );
3970           }
3971         free_strlist(sl);
3972         break;
3973
3974       case aSignEncrSym: /* sign and encrypt the given file */
3975         if( argc > 1 )
3976             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3977         else if(opt.s2k_mode==0)
3978           log_error(_("you cannot use --symmetric --sign --encrypt"
3979                       " with --s2k-mode 0\n"));
3980         else if(PGP6 || PGP7)
3981           log_error(_("you cannot use --symmetric --sign --encrypt"
3982                       " while in %s mode\n"),compliance_option_string());
3983         else
3984           {
3985             if( argc )
3986               {
3987                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3988                 strcpy(sl->d, fname);
3989               }
3990             else
3991               sl = NULL;
3992             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
3993                                  2, remusr, NULL)))
3994               {
3995                 write_status_failure ("sign-encrypt", rc);
3996                 log_error("%s: symmetric+sign+encrypt failed: %s\n",
3997                           print_fname_stdin(fname), gpg_strerror (rc) );
3998               }
3999             free_strlist(sl);
4000           }
4001         break;
4002
4003       case aSignSym: /* sign and conventionally encrypt the given file */
4004         if (argc > 1)
4005             wrong_args(_("--sign --symmetric [filename]"));
4006         rc = sign_symencrypt_file (ctrl, fname, locusr);
4007         if (rc)
4008           {
4009             write_status_failure ("sign-symencrypt", rc);
4010             log_error("%s: sign+symmetric failed: %s\n",
4011                       print_fname_stdin(fname), gpg_strerror (rc) );
4012           }
4013         break;
4014
4015       case aClearsign: /* make a clearsig */
4016         if( argc > 1 )
4017             wrong_args(_("--clearsign [filename]"));
4018         if( (rc = clearsign_file (ctrl, fname, locusr, NULL)) )
4019           {
4020             write_status_failure ("sign", rc);
4021             log_error("%s: clearsign failed: %s\n",
4022                       print_fname_stdin(fname), gpg_strerror (rc) );
4023           }
4024         break;
4025
4026       case aVerify:
4027         if (multifile)
4028           {
4029             if ((rc = verify_files (ctrl, argc, argv)))
4030               log_error("verify files failed: %s\n", gpg_strerror (rc) );
4031           }
4032         else
4033           {
4034             if ((rc = verify_signatures (ctrl, argc, argv)))
4035               log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
4036           }
4037         if (rc)
4038           write_status_failure ("verify", rc);
4039         break;
4040
4041       case aDecrypt:
4042         if (multifile)
4043           decrypt_messages (ctrl, argc, argv);
4044         else
4045           {
4046             if( argc > 1 )
4047               wrong_args(_("--decrypt [filename]"));
4048             if( (rc = decrypt_message (ctrl, fname) ))
4049               {
4050                 write_status_failure ("decrypt", rc);
4051                 log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
4052               }
4053           }
4054         break;
4055
4056       case aQuickSignKey:
4057       case aQuickLSignKey:
4058         {
4059           const char *fpr;
4060
4061           if (argc < 1)
4062             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
4063           fpr = *argv++; argc--;
4064           sl = NULL;
4065           for( ; argc; argc--, argv++)
4066             append_to_strlist2 (&sl, *argv, utf8_strings);
4067           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
4068           free_strlist (sl);
4069         }
4070         break;
4071
4072       case aSignKey:
4073         if( argc != 1 )
4074           wrong_args(_("--sign-key user-id"));
4075         /* fall through */
4076       case aLSignKey:
4077         if( argc != 1 )
4078           wrong_args(_("--lsign-key user-id"));
4079         /* fall through */
4080
4081         sl=NULL;
4082
4083         if(cmd==aSignKey)
4084           append_to_strlist(&sl,"sign");
4085         else if(cmd==aLSignKey)
4086           append_to_strlist(&sl,"lsign");
4087         else
4088           BUG();
4089
4090         append_to_strlist( &sl, "save" );
4091         username = make_username( fname );
4092         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
4093         xfree(username);
4094         free_strlist(sl);
4095         break;
4096
4097       case aEditKey: /* Edit a key signature */
4098         if( !argc )
4099             wrong_args(_("--edit-key user-id [commands]"));
4100         username = make_username( fname );
4101         if( argc > 1 ) {
4102             sl = NULL;
4103             for( argc--, argv++ ; argc; argc--, argv++ )
4104                 append_to_strlist( &sl, *argv );
4105             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
4106             free_strlist(sl);
4107         }
4108         else
4109             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
4110         xfree(username);
4111         break;
4112
4113       case aPasswd:
4114         if (argc != 1)
4115           wrong_args (_("--passwd <user-id>"));
4116         else
4117           {
4118             username = make_username (fname);
4119             keyedit_passwd (ctrl, username);
4120             xfree (username);
4121           }
4122         break;
4123
4124       case aDeleteKeys:
4125       case aDeleteSecretKeys:
4126       case aDeleteSecretAndPublicKeys:
4127         sl = NULL;
4128         /* I'm adding these in reverse order as add_to_strlist2
4129            reverses them again, and it's easier to understand in the
4130            proper order :) */
4131         for( ; argc; argc-- )
4132           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
4133         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
4134         free_strlist(sl);
4135         break;
4136
4137       case aCheckKeys:
4138         opt.check_sigs = 1;
4139       case aListSigs:
4140         opt.list_sigs = 1;
4141       case aListKeys:
4142         sl = NULL;
4143         for( ; argc; argc--, argv++ )
4144             add_to_strlist2( &sl, *argv, utf8_strings );
4145         public_key_list (ctrl, sl, 0);
4146         free_strlist(sl);
4147         break;
4148       case aListSecretKeys:
4149         sl = NULL;
4150         for( ; argc; argc--, argv++ )
4151             add_to_strlist2( &sl, *argv, utf8_strings );
4152         secret_key_list (ctrl, sl);
4153         free_strlist(sl);
4154         break;
4155       case aLocateKeys:
4156         sl = NULL;
4157         for (; argc; argc--, argv++)
4158           add_to_strlist2( &sl, *argv, utf8_strings );
4159         public_key_list (ctrl, sl, 1);
4160         free_strlist (sl);
4161         break;
4162
4163       case aQuickKeygen:
4164         {
4165           const char *x_algo, *x_usage, *x_expire;
4166
4167           if (argc < 1 || argc > 4)
4168             wrong_args("--quick-gen-key USER-ID [ALGO [USAGE [EXPIRE]]]");
4169           username = make_username (fname);
4170           argv++, argc--;
4171           x_algo = "";
4172           x_usage = "";
4173           x_expire = "";
4174           if (argc)
4175             {
4176               x_algo = *argv++; argc--;
4177               if (argc)
4178                 {
4179                   x_usage = *argv++; argc--;
4180                   if (argc)
4181                     {
4182                       x_expire = *argv++; argc--;
4183                     }
4184                 }
4185             }
4186           quick_generate_keypair (ctrl, username, x_algo, x_usage, x_expire);
4187           xfree (username);
4188         }
4189         break;
4190
4191       case aKeygen: /* generate a key */
4192 &nb