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