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