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