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