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