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