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