gpg: Simplify command --gen-key and add --full-gen-key.
[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     aFullKeygen,
111     aKeygen,
112     aSignEncr,
113     aSignEncrSym,
114     aSignSym,
115     aSignKey,
116     aLSignKey,
117     aQuickSignKey,
118     aQuickLSignKey,
119     aListConfig,
120     aGPGConfList,
121     aGPGConfTest,
122     aListPackets,
123     aEditKey,
124     aDeleteKeys,
125     aDeleteSecretKeys,
126     aDeleteSecretAndPublicKeys,
127     aImport,
128     aFastImport,
129     aVerify,
130     aVerifyFiles,
131     aListSigs,
132     aSendKeys,
133     aRecvKeys,
134     aLocateKeys,
135     aSearchKeys,
136     aRefreshKeys,
137     aFetchKeys,
138     aExport,
139     aExportSecret,
140     aExportSecretSub,
141     aCheckKeys,
142     aGenRevoke,
143     aDesigRevoke,
144     aPrimegen,
145     aPrintMD,
146     aPrintMDs,
147     aCheckTrustDB,
148     aUpdateTrustDB,
149     aFixTrustDB,
150     aListTrustDB,
151     aListTrustPath,
152     aExportOwnerTrust,
153     aImportOwnerTrust,
154     aDeArmor,
155     aEnArmor,
156     aGenRandom,
157     aRebuildKeydbCaches,
158     aCardStatus,
159     aCardEdit,
160     aChangePIN,
161     aPasswd,
162     aServer,
163
164     oTextmode,
165     oNoTextmode,
166     oExpert,
167     oNoExpert,
168     oDefSigExpire,
169     oAskSigExpire,
170     oNoAskSigExpire,
171     oDefCertExpire,
172     oAskCertExpire,
173     oNoAskCertExpire,
174     oDefCertLevel,
175     oMinCertLevel,
176     oAskCertLevel,
177     oNoAskCertLevel,
178     oFingerprint,
179     oWithFingerprint,
180     oWithKeygrip,
181     oWithSecret,
182     oAnswerYes,
183     oAnswerNo,
184     oKeyring,
185     oPrimaryKeyring,
186     oSecretKeyring,
187     oShowKeyring,
188     oDefaultKey,
189     oDefRecipient,
190     oDefRecipientSelf,
191     oNoDefRecipient,
192     oTrySecretKey,
193     oOptions,
194     oDebug,
195     oDebugLevel,
196     oDebugAll,
197     oDebugCCIDDriver,
198     oStatusFD,
199     oStatusFile,
200     oAttributeFD,
201     oAttributeFile,
202     oEmitVersion,
203     oNoEmitVersion,
204     oCompletesNeeded,
205     oMarginalsNeeded,
206     oMaxCertDepth,
207     oLoadExtension,
208     oGnuPG,
209     oRFC2440,
210     oRFC4880,
211     oOpenPGP,
212     oPGP6,
213     oPGP7,
214     oPGP8,
215     oRFC2440Text,
216     oNoRFC2440Text,
217     oCipherAlgo,
218     oDigestAlgo,
219     oCertDigestAlgo,
220     oCompressAlgo,
221     oCompressLevel,
222     oBZ2CompressLevel,
223     oBZ2DecompressLowmem,
224     oPassphrase,
225     oPassphraseFD,
226     oPassphraseFile,
227     oPassphraseRepeat,
228     oPinentryMode,
229     oCommandFD,
230     oCommandFile,
231     oQuickRandom,
232     oNoVerbose,
233     oTrustDBName,
234     oNoSecmemWarn,
235     oRequireSecmem,
236     oNoRequireSecmem,
237     oNoPermissionWarn,
238     oNoMDCWarn,
239     oNoArmor,
240     oNoDefKeyring,
241     oNoGreeting,
242     oNoTTY,
243     oNoOptions,
244     oNoBatch,
245     oHomedir,
246     oWithColons,
247     oWithKeyData,
248     oWithSigList,
249     oWithSigCheck,
250     oSkipVerify,
251     oSkipHiddenRecipients,
252     oNoSkipHiddenRecipients,
253     oAlwaysTrust,
254     oTrustModel,
255     oForceOwnertrust,
256     oSetFilename,
257     oForYourEyesOnly,
258     oNoForYourEyesOnly,
259     oSetPolicyURL,
260     oSigPolicyURL,
261     oCertPolicyURL,
262     oShowPolicyURL,
263     oNoShowPolicyURL,
264     oSigKeyserverURL,
265     oUseEmbeddedFilename,
266     oNoUseEmbeddedFilename,
267     oComment,
268     oDefaultComment,
269     oNoComments,
270     oThrowKeyids,
271     oNoThrowKeyids,
272     oShowPhotos,
273     oNoShowPhotos,
274     oPhotoViewer,
275     oForceV3Sigs,
276     oNoForceV3Sigs,
277     oForceV4Certs,
278     oNoForceV4Certs,
279     oForceMDC,
280     oNoForceMDC,
281     oDisableMDC,
282     oNoDisableMDC,
283     oS2KMode,
284     oS2KDigest,
285     oS2KCipher,
286     oS2KCount,
287     oDisplayCharset,
288     oNotDashEscaped,
289     oEscapeFrom,
290     oNoEscapeFrom,
291     oLockOnce,
292     oLockMultiple,
293     oLockNever,
294     oKeyServer,
295     oKeyServerOptions,
296     oImportOptions,
297     oExportOptions,
298     oListOptions,
299     oVerifyOptions,
300     oTempDir,
301     oExecPath,
302     oEncryptTo,
303     oHiddenEncryptTo,
304     oNoEncryptTo,
305     oLoggerFD,
306     oLoggerFile,
307     oUtf8Strings,
308     oNoUtf8Strings,
309     oDisableCipherAlgo,
310     oDisablePubkeyAlgo,
311     oAllowNonSelfsignedUID,
312     oNoAllowNonSelfsignedUID,
313     oAllowFreeformUID,
314     oNoAllowFreeformUID,
315     oAllowSecretKeyImport,
316     oEnableSpecialFilenames,
317     oNoLiteral,
318     oSetFilesize,
319     oHonorHttpProxy,
320     oFastListMode,
321     oListOnly,
322     oIgnoreTimeConflict,
323     oIgnoreValidFrom,
324     oIgnoreCrcError,
325     oIgnoreMDCError,
326     oShowSessionKey,
327     oOverrideSessionKey,
328     oNoRandomSeedFile,
329     oAutoKeyRetrieve,
330     oNoAutoKeyRetrieve,
331     oUseAgent,
332     oNoUseAgent,
333     oGpgAgentInfo,
334     oMergeOnly,
335     oTryAllSecrets,
336     oTrustedKey,
337     oNoExpensiveTrustChecks,
338     oFixedListMode,
339     oLegacyListMode,
340     oNoSigCache,
341     oNoSigCreateCheck,
342     oAutoCheckTrustDB,
343     oNoAutoCheckTrustDB,
344     oPreservePermissions,
345     oDefaultPreferenceList,
346     oDefaultKeyserverURL,
347     oPersonalCipherPreferences,
348     oPersonalDigestPreferences,
349     oPersonalCompressPreferences,
350     oAgentProgram,
351     oDirmngrProgram,
352     oDisplay,
353     oTTYname,
354     oTTYtype,
355     oLCctype,
356     oLCmessages,
357     oXauthority,
358     oGroup,
359     oUnGroup,
360     oNoGroups,
361     oStrict,
362     oNoStrict,
363     oMangleDosFilenames,
364     oNoMangleDosFilenames,
365     oEnableProgressFilter,
366     oMultifile,
367     oKeyidFormat,
368     oExitOnStatusWriteError,
369     oLimitCardInsertTries,
370     oReaderPort,
371     octapiDriver,
372     opcscDriver,
373     oDisableCCID,
374     oRequireCrossCert,
375     oNoRequireCrossCert,
376     oAutoKeyLocate,
377     oNoAutoKeyLocate,
378     oAllowMultisigVerification,
379     oEnableDSA2,
380     oDisableDSA2,
381     oAllowMultipleMessages,
382     oNoAllowMultipleMessages,
383     oAllowWeakDigestAlgos,
384     oFakedSystemTime,
385
386     oNoop
387   };
388
389
390 static ARGPARSE_OPTS opts[] = {
391
392   ARGPARSE_group (300, N_("@Commands:\n ")),
393
394   ARGPARSE_c (aSign, "sign", N_("make a signature")),
395   ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature")),
396   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
397   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
398   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
399   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
400   ARGPARSE_c (aStore, "store",     "@"),
401   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
402   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
403   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
404   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
405   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
406   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
407   ARGPARSE_c (aListSigs, "list-sigs", N_("list keys and signatures")),
408   ARGPARSE_c (aCheckKeys, "check-sigs",N_("list and check key signatures")),
409   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
410   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
411   ARGPARSE_c (aKeygen,      "gen-key",
412               N_("generate a new key pair")),
413   ARGPARSE_c (aQuickKeygen, "quick-gen-key" ,
414               N_("quickly generate a new key pair")),
415   ARGPARSE_c (aFullKeygen,  "full-gen-key" ,
416               N_("full featured key pair generation")),
417   ARGPARSE_c (aGenRevoke, "gen-revoke",N_("generate a revocation certificate")),
418   ARGPARSE_c (aDeleteKeys,"delete-keys",
419               N_("remove keys from the public keyring")),
420   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
421               N_("remove keys from the secret keyring")),
422   ARGPARSE_c (aQuickSignKey,  "quick-sign-key" ,
423               N_("quickly sign a key")),
424   ARGPARSE_c (aQuickLSignKey, "quick-lsign-key",
425               N_("quickly sign a key locally")),
426   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
427   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
428   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
429   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
430   ARGPARSE_c (aPasswd,   "passwd",     N_("change a passphrase")),
431   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
432   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
433   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a key server") ),
434   ARGPARSE_c (aRecvKeys, "recv-keys"     , N_("import keys from a key server") ),
435   ARGPARSE_c (aSearchKeys, "search-keys" ,
436               N_("search for keys on a key server") ),
437   ARGPARSE_c (aRefreshKeys, "refresh-keys",
438               N_("update all keys from a keyserver")),
439   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
440   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
441   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
442   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
443   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
444   ARGPARSE_c (aFastImport, "fast-import", "@"),
445 #ifdef ENABLE_CARD_SUPPORT
446   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
447   ARGPARSE_c (aCardEdit,   "card-edit",  N_("change data on a card")),
448   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
449 #endif
450   ARGPARSE_c (aListConfig, "list-config", "@"),
451   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
452   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
453   ARGPARSE_c (aListPackets, "list-packets","@"),
454
455 #ifndef NO_TRUST_MODELS
456   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
457   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
458   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
459               N_("update the trust database")),
460   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
461   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
462 #endif
463
464   ARGPARSE_c (aDeArmor, "dearmor", "@"),
465   ARGPARSE_c (aDeArmor, "dearmour", "@"),
466   ARGPARSE_c (aEnArmor, "enarmor", "@"),
467   ARGPARSE_c (aEnArmor, "enarmour", "@"),
468   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
469   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
470   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
471   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
472
473   ARGPARSE_group (301, N_("@\nOptions:\n ")),
474
475   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
476   ARGPARSE_s_n (oArmor, "armour", "@"),
477
478   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
479   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
480   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
481   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
482   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
483   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
484
485   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
486   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
487   ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
488   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
489   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
490   ARGPARSE_s_s (oLocalUser, "local-user",
491                 N_("|USER-ID|use USER-ID to sign or decrypt")),
492
493   ARGPARSE_s_s (oTrySecretKey, "try-secret-key", "@"),
494
495   ARGPARSE_s_i (oCompress, NULL,
496                 N_("|N|set compress level to N (0 disables)")),
497   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
498   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
499   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
500
501   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
502   ARGPARSE_s_n (oTextmode,      "textmode", N_("use canonical text mode")),
503   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
504
505   ARGPARSE_s_n (oExpert,      "expert", "@"),
506   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
507
508   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
509   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
510   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
511   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
512   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
513   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
514   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
515   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
516   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
517   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
518
519   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
520   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
521
522   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
523   ARGPARSE_s_n (oQuiet,   "quiet",   "@"),
524   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
525
526   ARGPARSE_s_n (oForceV3Sigs,      "force-v3-sigs", "@"),
527   ARGPARSE_s_n (oNoForceV3Sigs, "no-force-v3-sigs", "@"),
528   ARGPARSE_s_n (oForceV4Certs,     "force-v4-certs", "@"),
529   ARGPARSE_s_n (oNoForceV4Certs, "no-force-v4-certs", "@"),
530   ARGPARSE_s_n (oForceMDC, "force-mdc", "@"),
531   ARGPARSE_s_n (oNoForceMDC, "no-force-mdc", "@"),
532   ARGPARSE_s_n (oDisableMDC, "disable-mdc", "@"),
533   ARGPARSE_s_n (oNoDisableMDC, "no-disable-mdc", "@"),
534
535   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
536   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
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_n (oUseAgent,      "use-agent", "@"),
797   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
798   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
799   ARGPARSE_s_s (oReaderPort, "reader-port", "@"),
800   ARGPARSE_s_s (octapiDriver, "ctapi-driver", "@"),
801   ARGPARSE_s_s (opcscDriver, "pcsc-driver", "@"),
802   ARGPARSE_s_n (oDisableCCID, "disable-ccid", "@"),
803
804   /* Dummy options.  */
805   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
806   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
807   ARGPARSE_s_n (oNoop, "compress-keys", "@"),
808   ARGPARSE_s_n (oNoop, "compress-sigs", "@"),
809
810   ARGPARSE_end ()
811 };
812
813
814 #ifdef ENABLE_SELINUX_HACKS
815 #define ALWAYS_ADD_KEYRINGS 1
816 #else
817 #define ALWAYS_ADD_KEYRINGS 0
818 #endif
819
820
821 int g10_errors_seen = 0;
822
823 static int utf8_strings = 0;
824 static int maybe_setuid = 1;
825
826 static char *build_list( const char *text, char letter,
827                          const char *(*mapf)(int), int (*chkf)(int) );
828 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
829                         enum cmd_and_opt_values new_cmd );
830 static void print_mds( const char *fname, int algo );
831 static void add_notation_data( const char *string, int which );
832 static void add_policy_url( const char *string, int which );
833 static void add_keyserver_url( const char *string, int which );
834 static void emergency_cleanup (void);
835
836
837 static char *
838 make_libversion (const char *libname, const char *(*getfnc)(const char*))
839 {
840   const char *s;
841   char *result;
842
843   if (maybe_setuid)
844     {
845       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
846       maybe_setuid = 0;
847     }
848   s = getfnc (NULL);
849   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
850   strcpy (stpcpy (stpcpy (result, libname), " "), s);
851   return result;
852 }
853
854
855 static int
856 build_list_pk_test_algo (int algo)
857 {
858   /* Show only one "RSA" string.  If RSA_E or RSA_S is available RSA
859      is also available.  */
860   if (algo == PUBKEY_ALGO_RSA_E
861       || algo == PUBKEY_ALGO_RSA_S)
862     return GPG_ERR_DIGEST_ALGO;
863
864   return openpgp_pk_test_algo (algo);
865 }
866
867 static const char *
868 build_list_pk_algo_name (int algo)
869 {
870   return openpgp_pk_algo_name (algo);
871 }
872
873 static int
874 build_list_cipher_test_algo (int algo)
875 {
876   return openpgp_cipher_test_algo (algo);
877 }
878
879 static const char *
880 build_list_cipher_algo_name (int algo)
881 {
882   return openpgp_cipher_algo_name (algo);
883 }
884
885 static int
886 build_list_md_test_algo (int algo)
887 {
888   /* By default we do not accept MD5 based signatures.  To avoid
889      confusion we do not announce support for it either.  */
890   if (algo == DIGEST_ALGO_MD5)
891     return GPG_ERR_DIGEST_ALGO;
892
893   return openpgp_md_test_algo (algo);
894 }
895
896 static const char *
897 build_list_md_algo_name (int algo)
898 {
899   return openpgp_md_algo_name (algo);
900 }
901
902
903 static const char *
904 my_strusage( int level )
905 {
906   static char *digests, *pubkeys, *ciphers, *zips, *ver_gcry;
907   const char *p;
908
909     switch( level ) {
910       case 11: p = "@GPG@ (@GNUPG@)";
911         break;
912       case 13: p = VERSION; break;
913       case 17: p = PRINTABLE_OS_NAME; break;
914       case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
915
916     case 20:
917       if (!ver_gcry)
918         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
919       p = ver_gcry;
920       break;
921
922 #ifdef IS_DEVELOPMENT_VERSION
923       case 25:
924         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
925         break;
926       case 26:
927         p="It is only intended for test purposes and should NOT be";
928         break;
929       case 27:
930         p="used in a production environment or with production keys!";
931         break;
932 #endif
933
934       case 1:
935       case 40:  p =
936             _("Usage: @GPG@ [options] [files] (-h for help)");
937         break;
938       case 41:  p =
939             _("Syntax: @GPG@ [options] [files]\n"
940               "Sign, check, encrypt or decrypt\n"
941               "Default operation depends on the input data\n");
942         break;
943
944       case 31: p = "\nHome: "; break;
945 #ifndef __riscos__
946       case 32: p = opt.homedir; break;
947 #else /* __riscos__ */
948       case 32: p = make_filename(opt.homedir, NULL); break;
949 #endif /* __riscos__ */
950       case 33: p = _("\nSupported algorithms:\n"); break;
951       case 34:
952         if (!pubkeys)
953             pubkeys = build_list (_("Pubkey: "), 1,
954                                   build_list_pk_algo_name,
955                                   build_list_pk_test_algo );
956         p = pubkeys;
957         break;
958       case 35:
959         if( !ciphers )
960             ciphers = build_list(_("Cipher: "), 'S',
961                                  build_list_cipher_algo_name,
962                                  build_list_cipher_test_algo );
963         p = ciphers;
964         break;
965       case 36:
966         if( !digests )
967             digests = build_list(_("Hash: "), 'H',
968                                  build_list_md_algo_name,
969                                  build_list_md_test_algo );
970         p = digests;
971         break;
972       case 37:
973         if( !zips )
974             zips = build_list(_("Compression: "),'Z',
975                               compress_algo_to_string,
976                               check_compress_algo);
977         p = zips;
978         break;
979
980       default:  p = NULL;
981     }
982     return p;
983 }
984
985
986 static char *
987 build_list (const char *text, char letter,
988             const char * (*mapf)(int), int (*chkf)(int))
989 {
990   membuf_t mb;
991   int indent;
992   int i, j, len;
993   const char *s;
994   char *string;
995
996   if (maybe_setuid)
997     gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
998
999   indent = utf8_charcount (text);
1000   len = 0;
1001   init_membuf (&mb, 512);
1002
1003   for (i=0; i <= 110; i++ )
1004     {
1005       if (!chkf (i) && (s = mapf (i)))
1006         {
1007           if (mb.len - len > 60)
1008             {
1009               put_membuf_str (&mb, ",\n");
1010               len = mb.len;
1011               for (j=0; j < indent; j++)
1012                 put_membuf_str (&mb, " ");
1013             }
1014           else if (mb.len)
1015             put_membuf_str (&mb, ", ");
1016           else
1017             put_membuf_str (&mb, text);
1018
1019           put_membuf_str (&mb, s);
1020           if (opt.verbose && letter)
1021             {
1022               char num[20];
1023               if (letter == 1)
1024                 snprintf (num, sizeof num, " (%d)", i);
1025               else
1026                 snprintf (num, sizeof num, " (%c%d)", letter, i);
1027               put_membuf_str (&mb, num);
1028             }
1029         }
1030     }
1031   if (mb.len)
1032     put_membuf_str (&mb, "\n");
1033   put_membuf (&mb, "", 1);
1034
1035   string = get_membuf (&mb, NULL);
1036   return xrealloc (string, strlen (string)+1);
1037 }
1038
1039
1040 static void
1041 wrong_args( const char *text)
1042 {
1043   fprintf (stderr, _("usage: %s [options] %s\n"), GPG_NAME, text);
1044   g10_exit(2);
1045 }
1046
1047
1048 static char *
1049 make_username( const char *string )
1050 {
1051     char *p;
1052     if( utf8_strings )
1053         p = xstrdup(string);
1054     else
1055         p = native_to_utf8( string );
1056     return p;
1057 }
1058
1059
1060 static void
1061 set_opt_session_env (const char *name, const char *value)
1062 {
1063   gpg_error_t err;
1064
1065   err = session_env_setenv (opt.session_env, name, value);
1066   if (err)
1067     log_fatal ("error setting session environment: %s\n",
1068                gpg_strerror (err));
1069 }
1070
1071 /* Setup the debugging.  With a LEVEL of NULL only the active debug
1072    flags are propagated to the subsystems.  With LEVEL set, a specific
1073    set of debug flags is set; thus overriding all flags already
1074    set. */
1075 static void
1076 set_debug (const char *level)
1077 {
1078   int numok = (level && digitp (level));
1079   int numlvl = numok? atoi (level) : 0;
1080
1081   if (!level)
1082     ;
1083   else if (!strcmp (level, "none") || (numok && numlvl < 1))
1084     opt.debug = 0;
1085   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
1086     opt.debug = DBG_MEMSTAT_VALUE;
1087   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
1088     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
1089   else if (!strcmp (level, "expert")  || (numok && numlvl <= 8))
1090     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
1091                  |DBG_CACHE_VALUE|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
1092   else if (!strcmp (level, "guru") || numok)
1093     {
1094       opt.debug = ~0;
1095       /* Unless the "guru" string has been used we don't want to allow
1096          hashing debugging.  The rationale is that people tend to
1097          select the highest debug value and would then clutter their
1098          disk with debug files which may reveal confidential data.  */
1099       if (numok)
1100         opt.debug &= ~(DBG_HASHING_VALUE);
1101     }
1102   else
1103     {
1104       log_error (_("invalid debug-level '%s' given\n"), level);
1105       g10_exit (2);
1106     }
1107
1108   if (opt.debug & DBG_MEMORY_VALUE )
1109     memory_debug_mode = 1;
1110   if (opt.debug & DBG_MEMSTAT_VALUE )
1111     memory_stat_debug_mode = 1;
1112   if (opt.debug & DBG_MPI_VALUE)
1113     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
1114   if (opt.debug & DBG_CIPHER_VALUE )
1115     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
1116   if (opt.debug & DBG_IOBUF_VALUE )
1117     iobuf_debug_mode = 1;
1118   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1119
1120   if (opt.debug)
1121     log_info ("enabled debug flags:%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
1122               (opt.debug & DBG_PACKET_VALUE )? " packet":"",
1123               (opt.debug & DBG_MPI_VALUE    )? " mpi":"",
1124               (opt.debug & DBG_CIPHER_VALUE )? " cipher":"",
1125               (opt.debug & DBG_FILTER_VALUE )? " filter":"",
1126               (opt.debug & DBG_IOBUF_VALUE  )? " iobuf":"",
1127               (opt.debug & DBG_MEMORY_VALUE )? " memory":"",
1128               (opt.debug & DBG_CACHE_VALUE  )? " cache":"",
1129               (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"",
1130               (opt.debug & DBG_TRUST_VALUE  )? " trust":"",
1131               (opt.debug & DBG_HASHING_VALUE)? " hashing":"",
1132               (opt.debug & DBG_EXTPROG_VALUE)? " extprog":"",
1133               (opt.debug & DBG_CARD_IO_VALUE)? " cardio":"",
1134               (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"",
1135               (opt.debug & DBG_CLOCK_VALUE  )? " clock":"");
1136 }
1137
1138
1139
1140 /* We need the home directory also in some other directories, so make
1141    sure that both variables are always in sync. */
1142 static void
1143 set_homedir (const char *dir)
1144 {
1145   if (!dir)
1146     dir = "";
1147   opt.homedir = dir;
1148 }
1149
1150
1151 /* We set the screen dimensions for UI purposes.  Do not allow screens
1152    smaller than 80x24 for the sake of simplicity. */
1153 static void
1154 set_screen_dimensions(void)
1155 {
1156 #ifndef HAVE_W32_SYSTEM
1157   char *str;
1158
1159   str=getenv("COLUMNS");
1160   if(str)
1161     opt.screen_columns=atoi(str);
1162
1163   str=getenv("LINES");
1164   if(str)
1165     opt.screen_lines=atoi(str);
1166 #endif
1167
1168   if(opt.screen_columns<80 || opt.screen_columns>255)
1169     opt.screen_columns=80;
1170
1171   if(opt.screen_lines<24 || opt.screen_lines>255)
1172     opt.screen_lines=24;
1173 }
1174
1175
1176 /* Helper to open a file FNAME either for reading or writing to be
1177    used with --status-file etc functions.  Not generally useful but it
1178    avoids the riscos specific functions and well some Windows people
1179    might like it too.  Prints an error message and returns -1 on
1180    error.  On success the file descriptor is returned.  */
1181 static int
1182 open_info_file (const char *fname, int for_write, int binary)
1183 {
1184 #ifdef __riscos__
1185   return riscos_fdopenfile (fname, for_write);
1186 #elif defined (ENABLE_SELINUX_HACKS)
1187   /* We can't allow these even when testing for a secured filename
1188      because files to be secured might not yet been secured.  This is
1189      similar to the option file but in that case it is unlikely that
1190      sensitive information may be retrieved by means of error
1191      messages.  */
1192   (void)fname;
1193   (void)for_write;
1194   (void)binary;
1195   return -1;
1196 #else
1197   int fd;
1198
1199   if (binary)
1200     binary = MY_O_BINARY;
1201
1202 /*   if (is_secured_filename (fname)) */
1203 /*     { */
1204 /*       fd = -1; */
1205 /*       gpg_err_set_errno (EPERM); */
1206 /*     } */
1207 /*   else */
1208 /*     { */
1209       do
1210         {
1211           if (for_write)
1212             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY | binary,
1213                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1214           else
1215             fd = open (fname, O_RDONLY | binary);
1216         }
1217       while (fd == -1 && errno == EINTR);
1218 /*     } */
1219   if ( fd == -1)
1220     log_error ( for_write? _("can't create '%s': %s\n")
1221                          : _("can't open '%s': %s\n"), fname, strerror(errno));
1222
1223   return fd;
1224 #endif
1225 }
1226
1227 static void
1228 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1229 {
1230     enum cmd_and_opt_values cmd = *ret_cmd;
1231
1232     if( !cmd || cmd == new_cmd )
1233         cmd = new_cmd;
1234     else if( cmd == aSign && new_cmd == aEncr )
1235         cmd = aSignEncr;
1236     else if( cmd == aEncr && new_cmd == aSign )
1237         cmd = aSignEncr;
1238     else if( cmd == aSign && new_cmd == aSym )
1239         cmd = aSignSym;
1240     else if( cmd == aSym && new_cmd == aSign )
1241         cmd = aSignSym;
1242     else if( cmd == aSym && new_cmd == aEncr )
1243         cmd = aEncrSym;
1244     else if( cmd == aEncr && new_cmd == aSym )
1245         cmd = aEncrSym;
1246     else if (cmd == aSignEncr && new_cmd == aSym)
1247         cmd = aSignEncrSym;
1248     else if (cmd == aSignSym && new_cmd == aEncr)
1249         cmd = aSignEncrSym;
1250     else if (cmd == aEncrSym && new_cmd == aSign)
1251         cmd = aSignEncrSym;
1252     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1253              || ( cmd == aClearsign && new_cmd == aSign )  )
1254         cmd = aClearsign;
1255     else {
1256         log_error(_("conflicting commands\n"));
1257         g10_exit(2);
1258     }
1259
1260     *ret_cmd = cmd;
1261 }
1262
1263
1264 static void
1265 add_group(char *string)
1266 {
1267   char *name,*value;
1268   struct groupitem *item;
1269
1270   /* Break off the group name */
1271   name=strsep(&string,"=");
1272   if(string==NULL)
1273     {
1274       log_error(_("no = sign found in group definition '%s'\n"),name);
1275       return;
1276     }
1277
1278   trim_trailing_ws(name,strlen(name));
1279
1280   /* Does this group already exist? */
1281   for(item=opt.grouplist;item;item=item->next)
1282     if(strcasecmp(item->name,name)==0)
1283       break;
1284
1285   if(!item)
1286     {
1287       item=xmalloc(sizeof(struct groupitem));
1288       item->name=name;
1289       item->next=opt.grouplist;
1290       item->values=NULL;
1291       opt.grouplist=item;
1292     }
1293
1294   /* Break apart the values */
1295   while ((value= strsep(&string," \t")))
1296     {
1297       if (*value)
1298         add_to_strlist2(&item->values,value,utf8_strings);
1299     }
1300 }
1301
1302
1303 static void
1304 rm_group(char *name)
1305 {
1306   struct groupitem *item,*last=NULL;
1307
1308   trim_trailing_ws(name,strlen(name));
1309
1310   for(item=opt.grouplist;item;last=item,item=item->next)
1311     {
1312       if(strcasecmp(item->name,name)==0)
1313         {
1314           if(last)
1315             last->next=item->next;
1316           else
1317             opt.grouplist=item->next;
1318
1319           free_strlist(item->values);
1320           xfree(item);
1321           break;
1322         }
1323     }
1324 }
1325
1326
1327 /* We need to check three things.
1328
1329    0) The homedir.  It must be x00, a directory, and owned by the
1330    user.
1331
1332    1) The options/gpg.conf file.  Okay unless it or its containing
1333    directory is group or other writable or not owned by us.  Disable
1334    exec in this case.
1335
1336    2) Extensions.  Same as #1.
1337
1338    Returns true if the item is unsafe. */
1339 static int
1340 check_permissions (const char *path, int item)
1341 {
1342 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1343   static int homedir_cache=-1;
1344   char *tmppath,*dir;
1345   struct stat statbuf,dirbuf;
1346   int homedir=0,ret=0,checkonly=0;
1347   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1348
1349   if(opt.no_perm_warn)
1350     return 0;
1351
1352   assert(item==0 || item==1 || item==2);
1353
1354   /* extensions may attach a path */
1355   if(item==2 && path[0]!=DIRSEP_C)
1356     {
1357       if(strchr(path,DIRSEP_C))
1358         tmppath=make_filename(path,NULL);
1359       else
1360         tmppath=make_filename(gnupg_libdir (),path,NULL);
1361     }
1362   else
1363     tmppath=xstrdup(path);
1364
1365   /* If the item is located in the homedir, but isn't the homedir,
1366      don't continue if we already checked the homedir itself.  This is
1367      to avoid user confusion with an extra options file warning which
1368      could be rectified if the homedir itself had proper
1369      permissions. */
1370   if(item!=0 && homedir_cache>-1
1371      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1372     {
1373       ret=homedir_cache;
1374       goto end;
1375     }
1376
1377   /* It's okay if the file or directory doesn't exist */
1378   if(stat(tmppath,&statbuf)!=0)
1379     {
1380       ret=0;
1381       goto end;
1382     }
1383
1384   /* Now check the enclosing directory.  Theoretically, we could walk
1385      this test up to the root directory /, but for the sake of sanity,
1386      I'm stopping at one level down. */
1387   dir=make_dirname(tmppath);
1388
1389   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1390     {
1391       /* Weird error */
1392       ret=1;
1393       goto end;
1394     }
1395
1396   xfree(dir);
1397
1398   /* Assume failure */
1399   ret=1;
1400
1401   if(item==0)
1402     {
1403       /* The homedir must be x00, a directory, and owned by the user. */
1404
1405       if(S_ISDIR(statbuf.st_mode))
1406         {
1407           if(statbuf.st_uid==getuid())
1408             {
1409               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1410                 ret=0;
1411               else
1412                 perm=1;
1413             }
1414           else
1415             own=1;
1416
1417           homedir_cache=ret;
1418         }
1419     }
1420   else if(item==1 || item==2)
1421     {
1422       /* The options or extension file.  Okay unless it or its
1423          containing directory is group or other writable or not owned
1424          by us or root. */
1425
1426       if(S_ISREG(statbuf.st_mode))
1427         {
1428           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1429             {
1430               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1431                 {
1432                   /* it's not writable, so make sure the enclosing
1433                      directory is also not writable */
1434                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1435                     {
1436                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1437                         ret=0;
1438                       else
1439                         enc_dir_perm=1;
1440                     }
1441                   else
1442                     enc_dir_own=1;
1443                 }
1444               else
1445                 {
1446                   /* it's writable, so the enclosing directory had
1447                      better not let people get to it. */
1448                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1449                     {
1450                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1451                         ret=0;
1452                       else
1453                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1454                     }
1455                   else
1456                     enc_dir_own=1;
1457                 }
1458             }
1459           else
1460             own=1;
1461         }
1462     }
1463   else
1464     BUG();
1465
1466   if(!checkonly)
1467     {
1468       if(own)
1469         {
1470           if(item==0)
1471             log_info(_("WARNING: unsafe ownership on"
1472                        " homedir '%s'\n"),tmppath);
1473           else if(item==1)
1474             log_info(_("WARNING: unsafe ownership on"
1475                        " configuration file '%s'\n"),tmppath);
1476           else
1477             log_info(_("WARNING: unsafe ownership on"
1478                        " extension '%s'\n"),tmppath);
1479         }
1480       if(perm)
1481         {
1482           if(item==0)
1483             log_info(_("WARNING: unsafe permissions on"
1484                        " homedir '%s'\n"),tmppath);
1485           else if(item==1)
1486             log_info(_("WARNING: unsafe permissions on"
1487                        " configuration file '%s'\n"),tmppath);
1488           else
1489             log_info(_("WARNING: unsafe permissions on"
1490                        " extension '%s'\n"),tmppath);
1491         }
1492       if(enc_dir_own)
1493         {
1494           if(item==0)
1495             log_info(_("WARNING: unsafe enclosing directory ownership on"
1496                        " homedir '%s'\n"),tmppath);
1497           else if(item==1)
1498             log_info(_("WARNING: unsafe enclosing directory ownership on"
1499                        " configuration file '%s'\n"),tmppath);
1500           else
1501             log_info(_("WARNING: unsafe enclosing directory ownership on"
1502                        " extension '%s'\n"),tmppath);
1503         }
1504       if(enc_dir_perm)
1505         {
1506           if(item==0)
1507             log_info(_("WARNING: unsafe enclosing directory permissions on"
1508                        " homedir '%s'\n"),tmppath);
1509           else if(item==1)
1510             log_info(_("WARNING: unsafe enclosing directory permissions on"
1511                        " configuration file '%s'\n"),tmppath);
1512           else
1513             log_info(_("WARNING: unsafe enclosing directory permissions on"
1514                        " extension '%s'\n"),tmppath);
1515         }
1516     }
1517
1518  end:
1519   xfree(tmppath);
1520
1521   if(homedir)
1522     homedir_cache=ret;
1523
1524   return ret;
1525
1526 #else /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1527   (void)path;
1528   (void)item;
1529   return 0;
1530 #endif /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1531 }
1532
1533
1534 /* Print the OpenPGP defined algo numbers.  */
1535 static void
1536 print_algo_numbers(int (*checker)(int))
1537 {
1538   int i,first=1;
1539
1540   for(i=0;i<=110;i++)
1541     {
1542       if(!checker(i))
1543         {
1544           if(first)
1545             first=0;
1546           else
1547             es_printf (";");
1548           es_printf ("%d",i);
1549         }
1550     }
1551 }
1552
1553
1554 static void
1555 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1556 {
1557   int i,first=1;
1558
1559   for(i=0;i<=110;i++)
1560     {
1561       if(!checker(i))
1562         {
1563           if(first)
1564             first=0;
1565           else
1566             es_printf (";");
1567           es_printf ("%s",mapper(i));
1568         }
1569     }
1570 }
1571
1572 /* In the future, we can do all sorts of interesting configuration
1573    output here.  For now, just give "group" as the Enigmail folks need
1574    it, and pubkey, cipher, hash, and compress as they may be useful
1575    for frontends. */
1576 static void
1577 list_config(char *items)
1578 {
1579   int show_all=(items==NULL);
1580   char *name=NULL;
1581
1582   if(!opt.with_colons)
1583     return;
1584
1585   while(show_all || (name=strsep(&items," ")))
1586     {
1587       int any=0;
1588
1589       if(show_all || ascii_strcasecmp(name,"group")==0)
1590         {
1591           struct groupitem *iter;
1592
1593           for(iter=opt.grouplist;iter;iter=iter->next)
1594             {
1595               strlist_t sl;
1596
1597               es_fprintf (es_stdout, "cfg:group:");
1598               es_write_sanitized (es_stdout, iter->name, strlen(iter->name),
1599                                   ":", NULL);
1600               es_putc (':', es_stdout);
1601
1602               for(sl=iter->values;sl;sl=sl->next)
1603                 {
1604                   print_sanitized_string2 (stdout, sl->d, ':',';');
1605                   if(sl->next)
1606                     es_printf(";");
1607                 }
1608
1609               es_printf("\n");
1610             }
1611
1612           any=1;
1613         }
1614
1615       if(show_all || ascii_strcasecmp(name,"version")==0)
1616         {
1617           es_printf("cfg:version:");
1618           es_write_sanitized (es_stdout, VERSION, strlen(VERSION), ":", NULL);
1619           es_printf ("\n");
1620           any=1;
1621         }
1622
1623       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1624         {
1625           es_printf ("cfg:pubkey:");
1626           print_algo_numbers (build_list_pk_test_algo);
1627           es_printf ("\n");
1628           any=1;
1629         }
1630
1631       if(show_all || ascii_strcasecmp(name,"pubkeyname")==0)
1632         {
1633           es_printf ("cfg:pubkeyname:");
1634           print_algo_names (build_list_pk_test_algo,
1635                             build_list_pk_algo_name);
1636           es_printf ("\n");
1637           any=1;
1638         }
1639
1640       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1641         {
1642           es_printf ("cfg:cipher:");
1643           print_algo_numbers (build_list_cipher_test_algo);
1644           es_printf ("\n");
1645           any=1;
1646         }
1647
1648       if (show_all || !ascii_strcasecmp (name,"ciphername"))
1649         {
1650           es_printf ("cfg:ciphername:");
1651           print_algo_names (build_list_cipher_test_algo,
1652                             build_list_cipher_algo_name);
1653           es_printf ("\n");
1654           any = 1;
1655         }
1656
1657       if(show_all
1658          || ascii_strcasecmp(name,"digest")==0
1659          || ascii_strcasecmp(name,"hash")==0)
1660         {
1661           es_printf ("cfg:digest:");
1662           print_algo_numbers (build_list_md_test_algo);
1663           es_printf ("\n");
1664           any=1;
1665         }
1666
1667       if (show_all
1668           || !ascii_strcasecmp(name,"digestname")
1669           || !ascii_strcasecmp(name,"hashname"))
1670         {
1671           es_printf ("cfg:digestname:");
1672           print_algo_names (build_list_md_test_algo,
1673                             build_list_md_algo_name);
1674           es_printf ("\n");
1675           any=1;
1676         }
1677
1678       if(show_all || ascii_strcasecmp(name,"compress")==0)
1679         {
1680           es_printf ("cfg:compress:");
1681           print_algo_numbers(check_compress_algo);
1682           es_printf ("\n");
1683           any=1;
1684         }
1685
1686       if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1687         {
1688 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB) \
1689     && GNUPG_MAJOR_VERSION == 1
1690
1691           char *p, *p2, *list = ccid_get_reader_list ();
1692
1693           for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1694             {
1695               *p2 = 0;
1696               es_printf ("cfg:ccid-reader-id:%s\n", p);
1697             }
1698           free (list);
1699 #endif
1700           any=1;
1701         }
1702
1703       if(show_all)
1704         break;
1705
1706       if(!any)
1707         log_error(_("unknown configuration item '%s'\n"),name);
1708     }
1709 }
1710
1711
1712 /* List options and default values in the GPG Conf format.  This is a
1713    new tool distributed with gnupg 1.9.x but we also want some limited
1714    support in older gpg versions.  The output is the name of the
1715    configuration file and a list of options available for editing by
1716    gpgconf.  */
1717 static void
1718 gpgconf_list (const char *configfile)
1719 {
1720   char *configfile_esc = percent_escape (configfile, NULL);
1721
1722   es_printf ("%s-%s.conf:%lu:\"%s\n",
1723              GPGCONF_NAME, GPG_NAME,
1724              GC_OPT_FLAG_DEFAULT,
1725              configfile_esc ? configfile_esc : "/dev/null");
1726   es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1727   es_printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1728   es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1729   es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1730   es_printf ("default-key:%lu:\n", GC_OPT_FLAG_NONE);
1731   es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_NONE);
1732   es_printf ("try-secret-key:%lu:\n", GC_OPT_FLAG_NONE);
1733   es_printf ("auto-key-locate:%lu:\n", GC_OPT_FLAG_NONE);
1734   es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1735   es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1736   es_printf ("group:%lu:\n", GC_OPT_FLAG_NONE);
1737
1738   /* The next one is an info only item and should match the macros at
1739      the top of keygen.c  */
1740   es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1741              "RSA-2048");
1742
1743   xfree (configfile_esc);
1744 }
1745
1746
1747 static int
1748 parse_subpacket_list(char *list)
1749 {
1750   char *tok;
1751   byte subpackets[128],i;
1752   int count=0;
1753
1754   if(!list)
1755     {
1756       /* No arguments means all subpackets */
1757       memset(subpackets+1,1,sizeof(subpackets)-1);
1758       count=127;
1759     }
1760   else
1761     {
1762       memset(subpackets,0,sizeof(subpackets));
1763
1764       /* Merge with earlier copy */
1765       if(opt.show_subpackets)
1766         {
1767           byte *in;
1768
1769           for(in=opt.show_subpackets;*in;in++)
1770             {
1771               if(*in>127 || *in<1)
1772                 BUG();
1773
1774               if(!subpackets[*in])
1775                 count++;
1776               subpackets[*in]=1;
1777             }
1778         }
1779
1780       while((tok=strsep(&list," ,")))
1781         {
1782           if(!*tok)
1783             continue;
1784
1785           i=atoi(tok);
1786           if(i>127 || i<1)
1787             return 0;
1788
1789           if(!subpackets[i])
1790             count++;
1791           subpackets[i]=1;
1792         }
1793     }
1794
1795   xfree(opt.show_subpackets);
1796   opt.show_subpackets=xmalloc(count+1);
1797   opt.show_subpackets[count--]=0;
1798
1799   for(i=1;i<128 && count>=0;i++)
1800     if(subpackets[i])
1801       opt.show_subpackets[count--]=i;
1802
1803   return 1;
1804 }
1805
1806
1807 static int
1808 parse_list_options(char *str)
1809 {
1810   char *subpackets=""; /* something that isn't NULL */
1811   struct parse_options lopts[]=
1812     {
1813       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1814        N_("display photo IDs during key listings")},
1815       {"show-usage",LIST_SHOW_USAGE,NULL,
1816        N_("show key usage information during key listings")},
1817       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1818        N_("show policy URLs during signature listings")},
1819       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1820        N_("show all notations during signature listings")},
1821       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1822        N_("show IETF standard notations during signature listings")},
1823       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1824        NULL},
1825       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1826        N_("show user-supplied notations during signature listings")},
1827       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1828        N_("show preferred keyserver URLs during signature listings")},
1829       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1830        N_("show user ID validity during key listings")},
1831       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1832        N_("show revoked and expired user IDs in key listings")},
1833       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1834        N_("show revoked and expired subkeys in key listings")},
1835       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1836        N_("show the keyring name in key listings")},
1837       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1838        N_("show expiration dates during signature listings")},
1839       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1840        NULL},
1841       {NULL,0,NULL,NULL}
1842     };
1843
1844   /* C99 allows for non-constant initializers, but we'd like to
1845      compile everywhere, so fill in the show-sig-subpackets argument
1846      here.  Note that if the parse_options array changes, we'll have
1847      to change the subscript here. */
1848   lopts[12].value=&subpackets;
1849
1850   if(parse_options(str,&opt.list_options,lopts,1))
1851     {
1852       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1853         {
1854           /* Unset so users can pass multiple lists in. */
1855           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1856           if(!parse_subpacket_list(subpackets))
1857             return 0;
1858         }
1859       else if(subpackets==NULL && opt.show_subpackets)
1860         {
1861           /* User did 'no-show-subpackets' */
1862           xfree(opt.show_subpackets);
1863           opt.show_subpackets=NULL;
1864         }
1865
1866       return 1;
1867     }
1868   else
1869     return 0;
1870 }
1871
1872
1873 /* Collapses argc/argv into a single string that must be freed */
1874 static char *
1875 collapse_args(int argc,char *argv[])
1876 {
1877   char *str=NULL;
1878   int i,first=1,len=0;
1879
1880   for(i=0;i<argc;i++)
1881     {
1882       len+=strlen(argv[i])+2;
1883       str=xrealloc(str,len);
1884       if(first)
1885         {
1886           str[0]='\0';
1887           first=0;
1888         }
1889       else
1890         strcat(str," ");
1891
1892       strcat(str,argv[i]);
1893     }
1894
1895   return str;
1896 }
1897
1898
1899 #ifndef NO_TRUST_MODELS
1900 static void
1901 parse_trust_model(const char *model)
1902 {
1903   if(ascii_strcasecmp(model,"pgp")==0)
1904     opt.trust_model=TM_PGP;
1905   else if(ascii_strcasecmp(model,"classic")==0)
1906     opt.trust_model=TM_CLASSIC;
1907   else if(ascii_strcasecmp(model,"always")==0)
1908     opt.trust_model=TM_ALWAYS;
1909   else if(ascii_strcasecmp(model,"direct")==0)
1910     opt.trust_model=TM_DIRECT;
1911   else if(ascii_strcasecmp(model,"auto")==0)
1912     opt.trust_model=TM_AUTO;
1913   else
1914     log_error("unknown trust model '%s'\n",model);
1915 }
1916 #endif /*NO_TRUST_MODELS*/
1917
1918
1919 /* This fucntion called to initialized a new control object.  It is
1920    assumed that this object has been zeroed out before calling this
1921    function. */
1922 static void
1923 gpg_init_default_ctrl (ctrl_t ctrl)
1924 {
1925   (void)ctrl;
1926 }
1927
1928
1929 /* This function is called to deinitialize a control object.  It is
1930    not deallocated. */
1931 static void
1932 gpg_deinit_default_ctrl (ctrl_t ctrl)
1933 {
1934   gpg_dirmngr_deinit_session_data (ctrl);
1935 }
1936
1937
1938 char *
1939 get_default_configname (void)
1940 {
1941   char *configname = NULL;
1942   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
1943   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
1944
1945   do
1946     {
1947       if (configname)
1948         {
1949           char *tok;
1950
1951           xfree (configname);
1952           configname = NULL;
1953
1954           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
1955             *tok='\0';
1956           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
1957             *tok='\0';
1958           else
1959             break;
1960         }
1961
1962       configname = make_filename (opt.homedir, name, NULL);
1963     }
1964   while (access (configname, R_OK));
1965
1966   xfree(name);
1967
1968   if (! configname)
1969     configname = make_filename (opt.homedir, GPG_NAME EXTSEP_S "conf", NULL);
1970   if (! access (configname, R_OK))
1971     {
1972       /* Print a warning when both config files are present.  */
1973       char *p = make_filename (opt.homedir, "options", NULL);
1974       if (! access (p, R_OK))
1975         log_info (_("NOTE: old default options file '%s' ignored\n"), p);
1976       xfree (p);
1977     }
1978   else
1979     {
1980       /* Use the old default only if it exists.  */
1981       char *p = make_filename (opt.homedir, "options", NULL);
1982       if (!access (p, R_OK))
1983         {
1984           xfree (configname);
1985           configname = p;
1986         }
1987       else
1988         xfree (p);
1989     }
1990
1991   return configname;
1992 }
1993
1994
1995 int
1996 main (int argc, char **argv)
1997 {
1998     ARGPARSE_ARGS pargs;
1999     IOBUF a;
2000     int rc=0;
2001     int orig_argc;
2002     char **orig_argv;
2003     const char *fname;
2004     char *username;
2005     int may_coredump;
2006     strlist_t sl, remusr= NULL, locusr=NULL;
2007     strlist_t nrings = NULL;
2008     armor_filter_context_t *afx = NULL;
2009     int detached_sig = 0;
2010     FILE *configfp = NULL;
2011     char *configname = NULL;
2012     char *save_configname = NULL;
2013     char *default_configname = NULL;
2014     unsigned configlineno;
2015     int parse_debug = 0;
2016     int default_config = 1;
2017     int default_keyring = 1;
2018     int greeting = 0;
2019     int nogreeting = 0;
2020     char *logfile = NULL;
2021     int use_random_seed = 1;
2022     enum cmd_and_opt_values cmd = 0;
2023     const char *debug_level = NULL;
2024 #ifndef NO_TRUST_MODELS
2025     const char *trustdb_name = NULL;
2026 #endif /*!NO_TRUST_MODELS*/
2027     char *def_cipher_string = NULL;
2028     char *def_digest_string = NULL;
2029     char *compress_algo_string = NULL;
2030     char *cert_digest_string = NULL;
2031     char *s2k_cipher_string = NULL;
2032     char *s2k_digest_string = NULL;
2033     char *pers_cipher_list = NULL;
2034     char *pers_digest_list = NULL;
2035     char *pers_compress_list = NULL;
2036     int eyes_only=0;
2037     int multifile=0;
2038     int pwfd = -1;
2039     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2040     int any_explicit_recipient = 0;
2041     int require_secmem=0,got_secmem=0;
2042     struct assuan_malloc_hooks malloc_hooks;
2043     ctrl_t ctrl;
2044
2045 #ifdef __riscos__
2046     opt.lock_once = 1;
2047 #endif /* __riscos__ */
2048
2049
2050     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2051        when adding any stuff between here and the call to
2052        secmem_init() somewhere after the option parsing. */
2053     gnupg_reopen_std (GPG_NAME);
2054     trap_unaligned ();
2055     gnupg_rl_initialize ();
2056     set_strusage (my_strusage);
2057     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2058     log_set_prefix (GPG_NAME, 1);
2059
2060     /* Make sure that our subsystems are ready.  */
2061     i18n_init();
2062     init_common_subsystems (&argc, &argv);
2063
2064     /* Check that the libraries are suitable.  Do it right here because the
2065        option parsing may need services of the library.  */
2066     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
2067       {
2068         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
2069                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
2070       }
2071
2072     /* Use our own logging handler for Libcgrypt.  */
2073     setup_libgcrypt_logging ();
2074
2075     /* Put random number into secure memory */
2076     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2077
2078     may_coredump = disable_core_dumps();
2079
2080     gnupg_init_signals (0, emergency_cleanup);
2081
2082     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2083
2084     opt.session_env = session_env_new ();
2085     if (!opt.session_env)
2086       log_fatal ("error allocating session environment block: %s\n",
2087                  strerror (errno));
2088
2089     opt.command_fd = -1; /* no command fd */
2090     opt.compress_level = -1; /* defaults to standard compress level */
2091     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2092     /* note: if you change these lines, look at oOpenPGP */
2093     opt.def_cipher_algo = 0;
2094     opt.def_digest_algo = 0;
2095     opt.cert_digest_algo = 0;
2096     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2097     opt.s2k_mode = 3; /* iterated+salted */
2098     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2099     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2100     opt.completes_needed = 1;
2101     opt.marginals_needed = 3;
2102     opt.max_cert_depth = 5;
2103     opt.pgp2_workarounds = 1;
2104     opt.escape_from = 1;
2105     opt.flags.require_cross_cert = 1;
2106     opt.import_options = 0;
2107     opt.export_options = EXPORT_ATTRIBUTES;
2108     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
2109     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2110     opt.keyserver_options.options = (KEYSERVER_HONOR_KEYSERVER_URL
2111                                      | KEYSERVER_HONOR_PKA_RECORD );
2112     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2113                           | VERIFY_SHOW_POLICY_URLS
2114                           | VERIFY_SHOW_STD_NOTATIONS
2115                           | VERIFY_SHOW_KEYSERVER_URLS);
2116     opt.list_options   = LIST_SHOW_UID_VALIDITY;
2117 #ifdef NO_TRUST_MODELS
2118     opt.trust_model = TM_ALWAYS;
2119 #else
2120     opt.trust_model = TM_AUTO;
2121 #endif
2122     opt.mangle_dos_filenames = 0;
2123     opt.min_cert_level = 2;
2124     set_screen_dimensions ();
2125     opt.keyid_format = KF_SHORT;
2126     opt.def_sig_expire = "0";
2127     opt.def_cert_expire = "0";
2128     set_homedir (default_homedir ());
2129     opt.passphrase_repeat = 1;
2130     opt.emit_version = 1; /* Limit to the major number.  */
2131
2132     /* Check whether we have a config file on the command line.  */
2133     orig_argc = argc;
2134     orig_argv = argv;
2135     pargs.argc = &argc;
2136     pargs.argv = &argv;
2137     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2138     while( arg_parse( &pargs, opts) ) {
2139         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2140             parse_debug++;
2141         else if( pargs.r_opt == oOptions ) {
2142             /* yes there is one, so we do not try the default one, but
2143              * read the option file when it is encountered at the commandline
2144              */
2145             default_config = 0;
2146         }
2147         else if( pargs.r_opt == oNoOptions )
2148           {
2149             default_config = 0; /* --no-options */
2150             opt.no_homedir_creation = 1;
2151           }
2152         else if( pargs.r_opt == oHomedir )
2153             set_homedir ( pargs.r.ret_str );
2154         else if( pargs.r_opt == oNoPermissionWarn )
2155             opt.no_perm_warn=1;
2156         else if (pargs.r_opt == oStrict )
2157           {
2158             /* Not used */
2159           }
2160         else if (pargs.r_opt == oNoStrict )
2161           {
2162             /* Not used */
2163           }
2164     }
2165
2166 #ifdef HAVE_DOSISH_SYSTEM
2167     if ( strchr (opt.homedir,'\\') ) {
2168         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2169         const char *s = opt.homedir;
2170         for (d=buf,s=opt.homedir; *s; s++)
2171           {
2172             *d++ = *s == '\\'? '/': *s;
2173 #ifdef HAVE_W32_SYSTEM
2174             if (s[1] && IsDBCSLeadByte (*s))
2175               *d++ = *++s;
2176 #endif
2177           }
2178         *d = 0;
2179         set_homedir (buf);
2180     }
2181 #endif
2182
2183     /* Initialize the secure memory. */
2184     if (!gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0))
2185       got_secmem = 1;
2186 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2187     /* There should be no way to get to this spot while still carrying
2188        setuid privs.  Just in case, bomb out if we are. */
2189     if ( getuid () != geteuid () )
2190       BUG ();
2191 #endif
2192     maybe_setuid = 0;
2193
2194     /* Okay, we are now working under our real uid */
2195
2196     /* malloc hooks go here ... */
2197     malloc_hooks.malloc = gcry_malloc;
2198     malloc_hooks.realloc = gcry_realloc;
2199     malloc_hooks.free = gcry_free;
2200     assuan_set_malloc_hooks (&malloc_hooks);
2201     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2202     setup_libassuan_logging (&opt.debug);
2203
2204     /* Try for a version specific config file first */
2205     default_configname = get_default_configname ();
2206     if (default_config)
2207       configname = xstrdup (default_configname);
2208
2209     argc = orig_argc;
2210     argv = orig_argv;
2211     pargs.argc = &argc;
2212     pargs.argv = &argv;
2213     pargs.flags= ARGPARSE_FLAG_KEEP;
2214
2215     /* By this point we have a homedir, and cannot change it. */
2216     check_permissions(opt.homedir,0);
2217
2218   next_pass:
2219     if( configname ) {
2220       if(check_permissions(configname,1))
2221         {
2222           /* If any options file is unsafe, then disable any external
2223              programs for keyserver calls or photo IDs.  Since the
2224              external program to call is set in the options file, a
2225              unsafe options file can lead to an arbitrary program
2226              being run. */
2227
2228           opt.exec_disable=1;
2229         }
2230
2231         configlineno = 0;
2232         configfp = fopen( configname, "r" );
2233         if (configfp && is_secured_file (fileno (configfp)))
2234           {
2235             fclose (configfp);
2236             configfp = NULL;
2237             gpg_err_set_errno (EPERM);
2238           }
2239         if( !configfp ) {
2240             if( default_config ) {
2241                 if( parse_debug )
2242                     log_info(_("NOTE: no default option file '%s'\n"),
2243                                                             configname );
2244             }
2245             else {
2246                 log_error(_("option file '%s': %s\n"),
2247                                     configname, strerror(errno) );
2248                 g10_exit(2);
2249             }
2250             xfree(configname); configname = NULL;
2251         }
2252         if( parse_debug && configname )
2253             log_info(_("reading options from '%s'\n"), configname );
2254         default_config = 0;
2255     }
2256
2257     while( optfile_parse( configfp, configname, &configlineno,
2258                                                 &pargs, opts) )
2259       {
2260         switch( pargs.r_opt )
2261           {
2262           case aCheckKeys:
2263           case aListConfig:
2264           case aGPGConfList:
2265           case aGPGConfTest:
2266           case aListPackets:
2267           case aImport:
2268           case aFastImport:
2269           case aSendKeys:
2270           case aRecvKeys:
2271           case aSearchKeys:
2272           case aRefreshKeys:
2273           case aFetchKeys:
2274           case aExport:
2275 #ifdef ENABLE_CARD_SUPPORT
2276           case aCardStatus:
2277           case aCardEdit:
2278           case aChangePIN:
2279 #endif /* ENABLE_CARD_SUPPORT*/
2280           case aListKeys:
2281           case aLocateKeys:
2282           case aListSigs:
2283           case aExportSecret:
2284           case aExportSecretSub:
2285           case aSym:
2286           case aClearsign:
2287           case aGenRevoke:
2288           case aDesigRevoke:
2289           case aPrimegen:
2290           case aGenRandom:
2291           case aPrintMD:
2292           case aPrintMDs:
2293           case aListTrustDB:
2294           case aCheckTrustDB:
2295           case aUpdateTrustDB:
2296           case aFixTrustDB:
2297           case aListTrustPath:
2298           case aDeArmor:
2299           case aEnArmor:
2300           case aSign:
2301           case aQuickSignKey:
2302           case aQuickLSignKey:
2303           case aSignKey:
2304           case aLSignKey:
2305           case aStore:
2306           case aQuickKeygen:
2307           case aExportOwnerTrust:
2308           case aImportOwnerTrust:
2309           case aRebuildKeydbCaches:
2310             set_cmd (&cmd, pargs.r_opt);
2311             break;
2312
2313           case aKeygen:
2314           case aFullKeygen:
2315           case aEditKey:
2316           case aDeleteSecretKeys:
2317           case aDeleteSecretAndPublicKeys:
2318           case aDeleteKeys:
2319           case aPasswd:
2320             set_cmd (&cmd, pargs.r_opt);
2321             greeting=1;
2322             break;
2323
2324           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2325
2326           case aDecryptFiles: multifile=1; /* fall through */
2327           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2328
2329           case aEncrFiles: multifile=1; /* fall through */
2330           case aEncr: set_cmd( &cmd, aEncr); break;
2331
2332           case aVerifyFiles: multifile=1; /* fall through */
2333           case aVerify: set_cmd( &cmd, aVerify); break;
2334
2335           case aServer:
2336             set_cmd (&cmd, pargs.r_opt);
2337             opt.batch = 1;
2338             break;
2339
2340           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2341           case oOutput: opt.outfile = pargs.r.ret_str; break;
2342           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2343           case oQuiet: opt.quiet = 1; break;
2344           case oNoTTY: tty_no_terminal(1); break;
2345           case oDryRun: opt.dry_run = 1; break;
2346           case oInteractive: opt.interactive = 1; break;
2347           case oVerbose:
2348             opt.verbose++;
2349             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2350             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2351             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2352             break;
2353
2354           case oBatch:
2355             opt.batch = 1;
2356             nogreeting = 1;
2357             break;
2358
2359           case oUseAgent: /* Dummy. */
2360             break;
2361
2362           case oNoUseAgent:
2363             obsolete_option (configname, configlineno, "no-use-agent");
2364             break;
2365           case oGpgAgentInfo:
2366             obsolete_option (configname, configlineno, "gpg-agent-info");
2367             break;
2368           case oReaderPort:
2369             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2370             break;
2371           case octapiDriver:
2372             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2373             break;
2374           case opcscDriver:
2375             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2376             break;
2377           case oDisableCCID:
2378             obsolete_scdaemon_option (configname, configlineno, "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 aFullKeygen:
3573       case aKeygen:
3574       case aImport:
3575       case aExportSecret:
3576       case aExportSecretSub:
3577       case aGenRevoke:
3578       case aDesigRevoke:
3579       case aCardEdit:
3580       case aChangePIN:
3581         migrate_secring (ctrl);
3582         break;
3583       case aListKeys:
3584         if (opt.with_secret)
3585           migrate_secring (ctrl);
3586         break;
3587       default:
3588         break;
3589       }
3590
3591     /* The command dispatcher.  */
3592     switch( cmd )
3593       {
3594       case aServer:
3595         gpg_server (ctrl);
3596         break;
3597
3598       case aStore: /* only store the file */
3599         if( argc > 1 )
3600             wrong_args(_("--store [filename]"));
3601         if( (rc = encrypt_store(fname)) )
3602             log_error ("storing '%s' failed: %s\n",
3603                        print_fname_stdin(fname),g10_errstr(rc) );
3604         break;
3605       case aSym: /* encrypt the given file only with the symmetric cipher */
3606         if( argc > 1 )
3607             wrong_args(_("--symmetric [filename]"));
3608         if( (rc = encrypt_symmetric(fname)) )
3609             log_error (_("symmetric encryption of '%s' failed: %s\n"),
3610                         print_fname_stdin(fname),g10_errstr(rc) );
3611         break;
3612
3613       case aEncr: /* encrypt the given file */
3614         if(multifile)
3615           encrypt_crypt_files (ctrl, argc, argv, remusr);
3616         else
3617           {
3618             if( argc > 1 )
3619               wrong_args(_("--encrypt [filename]"));
3620             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
3621               log_error("%s: encryption failed: %s\n",
3622                         print_fname_stdin(fname), g10_errstr(rc) );
3623           }
3624         break;
3625
3626       case aEncrSym:
3627         /* This works with PGP 8 in the sense that it acts just like a
3628            symmetric message.  It doesn't work at all with 2 or 6.  It
3629            might work with 7, but alas, I don't have a copy to test
3630            with right now. */
3631         if( argc > 1 )
3632           wrong_args(_("--symmetric --encrypt [filename]"));
3633         else if(opt.s2k_mode==0)
3634           log_error(_("you cannot use --symmetric --encrypt"
3635                       " with --s2k-mode 0\n"));
3636         else if(PGP6 || PGP7)
3637           log_error(_("you cannot use --symmetric --encrypt"
3638                       " while in %s mode\n"),compliance_option_string());
3639         else
3640           {
3641             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
3642               log_error("%s: encryption failed: %s\n",
3643                         print_fname_stdin(fname), g10_errstr(rc) );
3644           }
3645         break;
3646
3647       case aSign: /* sign the given file */
3648         sl = NULL;
3649         if( detached_sig ) { /* sign all files */
3650             for( ; argc; argc--, argv++ )
3651                 add_to_strlist( &sl, *argv );
3652         }
3653         else {
3654             if( argc > 1 )
3655                 wrong_args(_("--sign [filename]"));
3656             if( argc ) {
3657                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3658                 strcpy(sl->d, fname);
3659             }
3660         }
3661         if( (rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)) )
3662             log_error("signing failed: %s\n", g10_errstr(rc) );
3663         free_strlist(sl);
3664         break;
3665
3666       case aSignEncr: /* sign and encrypt the given file */
3667         if( argc > 1 )
3668             wrong_args(_("--sign --encrypt [filename]"));
3669         if( argc ) {
3670             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3671             strcpy(sl->d, fname);
3672         }
3673         else
3674             sl = NULL;
3675         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
3676             log_error("%s: sign+encrypt failed: %s\n",
3677                       print_fname_stdin(fname), g10_errstr(rc) );
3678         free_strlist(sl);
3679         break;
3680
3681       case aSignEncrSym: /* sign and encrypt the given file */
3682         if( argc > 1 )
3683             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3684         else if(opt.s2k_mode==0)
3685           log_error(_("you cannot use --symmetric --sign --encrypt"
3686                       " with --s2k-mode 0\n"));
3687         else if(PGP6 || PGP7)
3688           log_error(_("you cannot use --symmetric --sign --encrypt"
3689                       " while in %s mode\n"),compliance_option_string());
3690         else
3691           {
3692             if( argc )
3693               {
3694                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3695                 strcpy(sl->d, fname);
3696               }
3697             else
3698               sl = NULL;
3699             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
3700                                  2, remusr, NULL)))
3701               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3702                         print_fname_stdin(fname), g10_errstr(rc) );
3703             free_strlist(sl);
3704           }
3705         break;
3706
3707       case aSignSym: /* sign and conventionally encrypt the given file */
3708         if (argc > 1)
3709             wrong_args(_("--sign --symmetric [filename]"));
3710         rc = sign_symencrypt_file (fname, locusr);
3711         if (rc)
3712             log_error("%s: sign+symmetric failed: %s\n",
3713                       print_fname_stdin(fname), g10_errstr(rc) );
3714         break;
3715
3716       case aClearsign: /* make a clearsig */
3717         if( argc > 1 )
3718             wrong_args(_("--clearsign [filename]"));
3719         if( (rc = clearsign_file(fname, locusr, NULL)) )
3720             log_error("%s: clearsign failed: %s\n",
3721                       print_fname_stdin(fname), g10_errstr(rc) );
3722         break;
3723
3724       case aVerify:
3725         if (multifile)
3726           {
3727             if ((rc = verify_files (ctrl, argc, argv)))
3728               log_error("verify files failed: %s\n", g10_errstr(rc) );
3729           }
3730         else
3731           {
3732             if ((rc = verify_signatures (ctrl, argc, argv)))
3733               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3734           }
3735         break;
3736
3737       case aDecrypt:
3738         if (multifile)
3739           decrypt_messages (ctrl, argc, argv);
3740         else
3741           {
3742             if( argc > 1 )
3743               wrong_args(_("--decrypt [filename]"));
3744             if( (rc = decrypt_message (ctrl, fname) ))
3745               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3746           }
3747         break;
3748
3749       case aQuickSignKey:
3750       case aQuickLSignKey:
3751         {
3752           const char *fpr;
3753
3754           if (argc < 1)
3755             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
3756           fpr = *argv++; argc--;
3757           sl = NULL;
3758           for( ; argc; argc--, argv++)
3759             append_to_strlist2 (&sl, *argv, utf8_strings);
3760           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
3761           free_strlist (sl);
3762         }
3763         break;
3764
3765       case aSignKey:
3766         if( argc != 1 )
3767           wrong_args(_("--sign-key user-id"));
3768         /* fall through */
3769       case aLSignKey:
3770         if( argc != 1 )
3771           wrong_args(_("--lsign-key user-id"));
3772         /* fall through */
3773
3774         sl=NULL;
3775
3776         if(cmd==aSignKey)
3777           append_to_strlist(&sl,"sign");
3778         else if(cmd==aLSignKey)
3779           append_to_strlist(&sl,"lsign");
3780         else
3781           BUG();
3782
3783         append_to_strlist( &sl, "save" );
3784         username = make_username( fname );
3785         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
3786         xfree(username);
3787         free_strlist(sl);
3788         break;
3789
3790       case aEditKey: /* Edit a key signature */
3791         if( !argc )
3792             wrong_args(_("--edit-key user-id [commands]"));
3793         username = make_username( fname );
3794         if( argc > 1 ) {
3795             sl = NULL;
3796             for( argc--, argv++ ; argc; argc--, argv++ )
3797                 append_to_strlist( &sl, *argv );
3798             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
3799             free_strlist(sl);
3800         }
3801         else
3802             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
3803         xfree(username);
3804         break;
3805
3806       case aPasswd:
3807         if (argc != 1)
3808           wrong_args (_("--passwd <user-id>"));
3809         else
3810           {
3811             username = make_username (fname);
3812             keyedit_passwd (ctrl, username);
3813             xfree (username);
3814           }
3815         break;
3816
3817       case aDeleteKeys:
3818       case aDeleteSecretKeys:
3819       case aDeleteSecretAndPublicKeys:
3820         sl = NULL;
3821         /* I'm adding these in reverse order as add_to_strlist2
3822            reverses them again, and it's easier to understand in the
3823            proper order :) */
3824         for( ; argc; argc-- )
3825           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3826         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3827         free_strlist(sl);
3828         break;
3829
3830       case aCheckKeys:
3831         opt.check_sigs = 1;
3832       case aListSigs:
3833         opt.list_sigs = 1;
3834       case aListKeys:
3835         sl = NULL;
3836         for( ; argc; argc--, argv++ )
3837             add_to_strlist2( &sl, *argv, utf8_strings );
3838         public_key_list (ctrl, sl, 0);
3839         free_strlist(sl);
3840         break;
3841       case aListSecretKeys:
3842         sl = NULL;
3843         for( ; argc; argc--, argv++ )
3844             add_to_strlist2( &sl, *argv, utf8_strings );
3845         secret_key_list (ctrl, sl);
3846         free_strlist(sl);
3847         break;
3848       case aLocateKeys:
3849         sl = NULL;
3850         for (; argc; argc--, argv++)
3851           add_to_strlist2( &sl, *argv, utf8_strings );
3852         public_key_list (ctrl, sl, 1);
3853         free_strlist (sl);
3854         break;
3855
3856       case aQuickKeygen:
3857         if (argc != 1 )
3858           wrong_args("--gen-key user-id");
3859         username = make_username (fname);
3860         quick_generate_keypair (username);
3861         xfree (username);
3862         break;
3863
3864       case aKeygen: /* generate a key */
3865         if( opt.batch ) {
3866             if( argc > 1 )
3867                 wrong_args("--gen-key [parameterfile]");
3868             generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
3869         }
3870         else {
3871             if( argc )
3872                 wrong_args("--gen-key");
3873             generate_keypair (ctrl, 0, NULL, NULL, 0);
3874         }
3875         break;
3876
3877       case aFullKeygen: /* Generate a key with all options. */
3878         if (opt.batch)
3879           {
3880             if (argc > 1)
3881               wrong_args ("--full-gen-key [parameterfile]");
3882             generate_keypair (ctrl, 1, argc? *argv : NULL, NULL, 0);
3883           }
3884         else
3885           {
3886             if (argc)
3887               wrong_args("--full-gen-key");
3888             generate_keypair (ctrl, 1, NULL, NULL, 0);
3889         }
3890         break;
3891
3892       case aFastImport:
3893         opt.import_options |= IMPORT_FAST;
3894       case aImport:
3895         import_keys (ctrl, argc? argv:NULL, argc, NULL, opt.import_options);
3896         break;
3897
3898         /* TODO: There are a number of command that use this same
3899            "make strlist, call function, report error, free strlist"
3900            pattern.  Join them together here and avoid all that
3901            duplicated code. */
3902
3903       case aExport:
3904       case aSendKeys:
3905       case aRecvKeys:
3906         sl = NULL;
3907         for( ; argc; argc--, argv++ )
3908             append_to_strlist2( &sl, *argv, utf8_strings );
3909         if( cmd == aSendKeys )
3910             rc = keyserver_export (ctrl, sl );
3911         else if( cmd == aRecvKeys )
3912             rc = keyserver_import (ctrl, sl );
3913         else
3914             rc = export_pubkeys (ctrl, sl, opt.export_options);
3915         if(rc)
3916           {
3917             if(cmd==aSendKeys)
3918               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3919             else if(cmd==aRecvKeys)
3920               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3921             else
3922               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3923           }
3924         free_strlist(sl);
3925         break;
3926
3927      case aSearchKeys:
3928         sl = NULL;
3929         for (; argc; argc--, argv++)
3930           append_to_strlist2 (&sl, *argv, utf8_strings);
3931         rc = keyserver_search (ctrl, sl);
3932         if (rc)
3933           log_error (_("keyserver search failed: %s\n"), gpg_strerror (rc));
3934         free_strlist (sl);
3935         break;
3936
3937       case aRefreshKeys:
3938         sl = NULL;
3939         for( ; argc; argc--, argv++ )
3940             append_to_strlist2( &sl, *argv, utf8_strings );
3941         rc = keyserver_refresh (ctrl, sl);
3942         if(rc)
3943           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3944         free_strlist(sl);
3945         break;
3946
3947       case aFetchKeys:
3948         sl = NULL;
3949         for( ; argc; argc--, argv++ )
3950             append_to_strlist2( &sl, *argv, utf8_strings );
3951         rc = keyserver_fetch (ctrl, sl);
3952         if(rc)
3953           log_error("key fetch failed: %s\n",g10_errstr(rc));
3954         free_strlist(sl);
3955         break;
3956
3957       case aExportSecret:
3958         sl = NULL;
3959         for( ; argc; argc--, argv++ )
3960             add_to_strlist2( &sl, *argv, utf8_strings );
3961         export_seckeys (ctrl, sl);
3962         free_strlist(sl);
3963         break;
3964
3965       case aExportSecretSub:
3966         sl = NULL;
3967         for( ; argc; argc--, argv++ )
3968             add_to_strlist2( &sl, *argv, utf8_strings );
3969         export_secsubkeys (ctrl, sl);
3970         free_strlist(sl);
3971         break;
3972
3973       case aGenRevoke:
3974         if( argc != 1 )
3975             wrong_args("--gen-revoke user-id");
3976         username =  make_username(*argv);
3977         gen_revoke( username );
3978         xfree( username );
3979         break;
3980
3981       case aDesigRevoke:
3982         if( argc != 1 )
3983             wrong_args("--desig-revoke user-id");
3984         username =  make_username(*argv);
3985         gen_desig_revoke( username, locusr );
3986         xfree( username );
3987         break;
3988
3989       case aDeArmor:
3990         if( argc > 1 )
3991             wrong_args("--dearmor [file]");
3992         rc = dearmor_file( argc? *argv: NULL );
3993         if( rc )
3994             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3995         break;
3996
3997       case aEnArmor:
3998         if( argc > 1 )
3999             wrong_args("--enarmor [file]");
4000         rc = enarmor_file( argc? *argv: NULL );
4001         if( rc )
4002             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
4003         break;
4004
4005
4006       case aPrimegen:
4007 #if 0 /*FIXME*/
4008         {   int mode = argc < 2 ? 0 : atoi(*argv);
4009
4010             if( mode == 1 && argc == 2 ) {
4011                 mpi_print (es_stdout,
4012                            generate_public_prime( atoi(argv[1]) ), 1);
4013             }
4014             else if( mode == 2 && argc == 3 ) {
4015                 mpi_print (es_stdout, generate_elg_prime(
4016                                              0, atoi(argv[1]),
4017                                              atoi(argv[2]), NULL,NULL ), 1);
4018             }
4019             else if( mode == 3 && argc == 3 ) {
4020                 MPI *factors;
4021                 mpi_print (es_stdout, generate_elg_prime(
4022                                              1, atoi(argv[1]),
4023                                              atoi(argv[2]), NULL,&factors ), 1);
4024                 putchar('\n');
4025                 mpi_print (es_stdout, factors[0], 1 ); /* print q */
4026             }
4027             else if( mode == 4 && argc == 3 ) {
4028                 MPI g = mpi_alloc(1);
4029                 mpi_print (es_stdout, generate_elg_prime(
4030                                                  0, atoi(argv[1]),
4031                                                  atoi(argv[2]), g, NULL ), 1);
4032                 putchar('\n');
4033                 mpi_print (es_stdout, g, 1 );
4034                 mpi_free (g);
4035             }
4036             else
4037                 wrong_args("--gen-prime mode bits [qbits] ");
4038             putchar('\n');
4039         }
4040 #endif
4041         wrong_args("--gen-prime not yet supported ");
4042         break;
4043
4044       case aGenRandom:
4045         {
4046             int level = argc ? atoi(*argv):0;
4047             int count = argc > 1 ? atoi(argv[1]): 0;
4048             int endless = !count;
4049
4050             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
4051                 wrong_args("--gen-random 0|1|2 [count]");
4052
4053             while( endless || count ) {
4054                 byte *p;
4055                 /* Wee need a multiple of 3, so that in case of
4056                    armored output we get a correct string.  No
4057                    linefolding is done, as it is best to levae this to
4058                    other tools */
4059                 size_t n = !endless && count < 99? count : 99;
4060
4061                 p = gcry_random_bytes (n, level);
4062 #ifdef HAVE_DOSISH_SYSTEM
4063                 setmode ( fileno(stdout), O_BINARY );
4064 #endif
4065                 if (opt.armor) {
4066                     char *tmp = make_radix64_string (p, n);
4067                     fputs (tmp, stdout);
4068                     xfree (tmp);
4069                     if (n%3 == 1)
4070                       putchar ('=');
4071                     if (n%3)
4072                       putchar ('=');
4073                 } else {
4074                     fwrite( p, n, 1, stdout );
4075                 }
4076                 xfree(p);
4077                 if( !endless )
4078                     count -= n;
4079             }
4080             if (opt.armor)
4081                 putchar ('\n');
4082         }
4083         break;
4084
4085       case aPrintMD:
4086         if( argc < 1)
4087             wrong_args("--print-md algo [files]");
4088         {
4089             int all_algos = (**argv=='*' && !(*argv)[1]);
4090             int algo = all_algos? 0 : gcry_md_map_name (*argv);
4091
4092             if( !algo && !all_algos )
4093                 log_error(_("invalid hash algorithm '%s'\n"), *argv );
4094             else {
4095                 argc--; argv++;
4096                 if( !argc )
4097                     print_mds(NULL, algo);
4098                 else {
4099                     for(; argc; argc--, argv++ )
4100                         print_mds(*argv, algo);
4101                 }
4102             }
4103         }
4104         break;
4105
4106       case aPrintMDs: /* old option */
4107         if( !argc )
4108             print_mds(NULL,0);
4109         else {
4110             for(; argc; argc--, argv++ )
4111                 print_mds(*argv,0);
4112         }
4113         break;
4114
4115 #ifndef NO_TRUST_MODELS
4116       case aListTrustDB:
4117         if( !argc )
4118             list_trustdb(NULL);
4119         else {
4120             for( ; argc; argc--, argv++ )
4121                 list_trustdb( *argv );
4122         }
4123         break;
4124
4125       case aUpdateTrustDB:
4126         if( argc )
4127             wrong_args("--update-trustdb");
4128         update_trustdb();
4129         break;
4130
4131       case aCheckTrustDB:
4132         /* Old versions allowed for arguments - ignore them */
4133         check_trustdb();
4134         break;
4135
4136       case aFixTrustDB:
4137         how_to_fix_the_trustdb ();
4138         break;
4139
4140       case aListTrustPath:
4141         if( !argc )
4142             wrong_args("--list-trust-path <user-ids>");
4143         for( ; argc; argc--, argv++ ) {
4144             username = make_username( *argv );
4145             list_trust_path( username );
4146             xfree(username);
4147         }
4148         break;
4149
4150       case aExportOwnerTrust:
4151         if( argc )
4152             wrong_args("--export-ownertrust");
4153         export_ownertrust();
4154         break;
4155
4156       case aImportOwnerTrust:
4157         if( argc > 1 )
4158             wrong_args("--import-ownertrust [file]");
4159         import_ownertrust( argc? *argv:NULL );
4160         break;
4161 #endif /*!NO_TRUST_MODELS*/
4162
4163       case aRebuildKeydbCaches:
4164         if (argc)
4165             wrong_args ("--rebuild-keydb-caches");
4166         keydb_rebuild_caches (1);
4167         break;
4168
4169 #ifdef ENABLE_CARD_SUPPORT
4170       case aCardStatus:
4171         if (argc)
4172             wrong_args ("--card-status");