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