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