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