gpg: Add list-option "show-usage".
[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-usage",LIST_SHOW_USAGE,NULL,
1797        N_("show key usage information during key listings")},
1798       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1799        N_("show policy URLs during signature listings")},
1800       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1801        N_("show all notations during signature listings")},
1802       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1803        N_("show IETF standard notations during signature listings")},
1804       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1805        NULL},
1806       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1807        N_("show user-supplied notations during signature listings")},
1808       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1809        N_("show preferred keyserver URLs during signature listings")},
1810       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1811        N_("show user ID validity during key listings")},
1812       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1813        N_("show revoked and expired user IDs in key listings")},
1814       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1815        N_("show revoked and expired subkeys in key listings")},
1816       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1817        N_("show the keyring name in key listings")},
1818       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1819        N_("show expiration dates during signature listings")},
1820       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1821        NULL},
1822       {NULL,0,NULL,NULL}
1823     };
1824
1825   /* C99 allows for non-constant initializers, but we'd like to
1826      compile everywhere, so fill in the show-sig-subpackets argument
1827      here.  Note that if the parse_options array changes, we'll have
1828      to change the subscript here. */
1829   lopts[12].value=&subpackets;
1830
1831   if(parse_options(str,&opt.list_options,lopts,1))
1832     {
1833       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1834         {
1835           /* Unset so users can pass multiple lists in. */
1836           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1837           if(!parse_subpacket_list(subpackets))
1838             return 0;
1839         }
1840       else if(subpackets==NULL && opt.show_subpackets)
1841         {
1842           /* User did 'no-show-subpackets' */
1843           xfree(opt.show_subpackets);
1844           opt.show_subpackets=NULL;
1845         }
1846
1847       return 1;
1848     }
1849   else
1850     return 0;
1851 }
1852
1853
1854 /* Collapses argc/argv into a single string that must be freed */
1855 static char *
1856 collapse_args(int argc,char *argv[])
1857 {
1858   char *str=NULL;
1859   int i,first=1,len=0;
1860
1861   for(i=0;i<argc;i++)
1862     {
1863       len+=strlen(argv[i])+2;
1864       str=xrealloc(str,len);
1865       if(first)
1866         {
1867           str[0]='\0';
1868           first=0;
1869         }
1870       else
1871         strcat(str," ");
1872
1873       strcat(str,argv[i]);
1874     }
1875
1876   return str;
1877 }
1878
1879
1880 #ifndef NO_TRUST_MODELS
1881 static void
1882 parse_trust_model(const char *model)
1883 {
1884   if(ascii_strcasecmp(model,"pgp")==0)
1885     opt.trust_model=TM_PGP;
1886   else if(ascii_strcasecmp(model,"classic")==0)
1887     opt.trust_model=TM_CLASSIC;
1888   else if(ascii_strcasecmp(model,"always")==0)
1889     opt.trust_model=TM_ALWAYS;
1890   else if(ascii_strcasecmp(model,"direct")==0)
1891     opt.trust_model=TM_DIRECT;
1892   else if(ascii_strcasecmp(model,"auto")==0)
1893     opt.trust_model=TM_AUTO;
1894   else
1895     log_error("unknown trust model '%s'\n",model);
1896 }
1897 #endif /*NO_TRUST_MODELS*/
1898
1899
1900 /* This fucntion called to initialized a new control object.  It is
1901    assumed that this object has been zeroed out before calling this
1902    function. */
1903 static void
1904 gpg_init_default_ctrl (ctrl_t ctrl)
1905 {
1906   (void)ctrl;
1907 }
1908
1909
1910 /* This function is called to deinitialize a control object.  It is
1911    not deallocated. */
1912 static void
1913 gpg_deinit_default_ctrl (ctrl_t ctrl)
1914 {
1915   gpg_dirmngr_deinit_session_data (ctrl);
1916 }
1917
1918
1919 char *
1920 get_default_configname (void)
1921 {
1922   char *configname = NULL;
1923   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
1924   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
1925
1926   do
1927     {
1928       if (configname)
1929         {
1930           char *tok;
1931
1932           xfree (configname);
1933           configname = NULL;
1934
1935           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
1936             *tok='\0';
1937           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
1938             *tok='\0';
1939           else
1940             break;
1941         }
1942
1943       configname = make_filename (opt.homedir, name, NULL);
1944     }
1945   while (access (configname, R_OK));
1946
1947   xfree(name);
1948
1949   if (! configname)
1950     configname = make_filename (opt.homedir, GPG_NAME EXTSEP_S "conf", NULL);
1951   if (! access (configname, R_OK))
1952     {
1953       /* Print a warning when both config files are present.  */
1954       char *p = make_filename (opt.homedir, "options", NULL);
1955       if (! access (p, R_OK))
1956         log_info (_("NOTE: old default options file '%s' ignored\n"), p);
1957       xfree (p);
1958     }
1959   else
1960     {
1961       /* Use the old default only if it exists.  */
1962       char *p = make_filename (opt.homedir, "options", NULL);
1963       if (!access (p, R_OK))
1964         {
1965           xfree (configname);
1966           configname = p;
1967         }
1968       else
1969         xfree (p);
1970     }
1971
1972   return configname;
1973 }
1974
1975
1976 int
1977 main (int argc, char **argv)
1978 {
1979     ARGPARSE_ARGS pargs;
1980     IOBUF a;
1981     int rc=0;
1982     int orig_argc;
1983     char **orig_argv;
1984     const char *fname;
1985     char *username;
1986     int may_coredump;
1987     strlist_t sl, remusr= NULL, locusr=NULL;
1988     strlist_t nrings = NULL;
1989     armor_filter_context_t *afx = NULL;
1990     int detached_sig = 0;
1991     FILE *configfp = NULL;
1992     char *configname = NULL;
1993     char *save_configname = NULL;
1994     char *default_configname = NULL;
1995     unsigned configlineno;
1996     int parse_debug = 0;
1997     int default_config = 1;
1998     int default_keyring = 1;
1999     int greeting = 0;
2000     int nogreeting = 0;
2001     char *logfile = NULL;
2002     int use_random_seed = 1;
2003     enum cmd_and_opt_values cmd = 0;
2004     const char *debug_level = NULL;
2005 #ifndef NO_TRUST_MODELS
2006     const char *trustdb_name = NULL;
2007 #endif /*!NO_TRUST_MODELS*/
2008     char *def_cipher_string = NULL;
2009     char *def_digest_string = NULL;
2010     char *compress_algo_string = NULL;
2011     char *cert_digest_string = NULL;
2012     char *s2k_cipher_string = NULL;
2013     char *s2k_digest_string = NULL;
2014     char *pers_cipher_list = NULL;
2015     char *pers_digest_list = NULL;
2016     char *pers_compress_list = NULL;
2017     int eyes_only=0;
2018     int multifile=0;
2019     int pwfd = -1;
2020     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2021     int any_explicit_recipient = 0;
2022     int require_secmem=0,got_secmem=0;
2023     struct assuan_malloc_hooks malloc_hooks;
2024     ctrl_t ctrl;
2025
2026 #ifdef __riscos__
2027     opt.lock_once = 1;
2028 #endif /* __riscos__ */
2029
2030
2031     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2032        when adding any stuff between here and the call to
2033        secmem_init() somewhere after the option parsing. */
2034     gnupg_reopen_std (GPG_NAME);
2035     trap_unaligned ();
2036     gnupg_rl_initialize ();
2037     set_strusage (my_strusage);
2038     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2039     log_set_prefix (GPG_NAME, 1);
2040
2041     /* Make sure that our subsystems are ready.  */
2042     i18n_init();
2043     init_common_subsystems (&argc, &argv);
2044
2045     /* Check that the libraries are suitable.  Do it right here because the
2046        option parsing may need services of the library.  */
2047     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
2048       {
2049         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
2050                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
2051       }
2052
2053     /* Use our own logging handler for Libcgrypt.  */
2054     setup_libgcrypt_logging ();
2055
2056     /* Put random number into secure memory */
2057     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2058
2059     may_coredump = disable_core_dumps();
2060
2061     gnupg_init_signals (0, emergency_cleanup);
2062
2063     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2064
2065     opt.session_env = session_env_new ();
2066     if (!opt.session_env)
2067       log_fatal ("error allocating session environment block: %s\n",
2068                  strerror (errno));
2069
2070     opt.command_fd = -1; /* no command fd */
2071     opt.compress_level = -1; /* defaults to standard compress level */
2072     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2073     /* note: if you change these lines, look at oOpenPGP */
2074     opt.def_cipher_algo = 0;
2075     opt.def_digest_algo = 0;
2076     opt.cert_digest_algo = 0;
2077     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2078     opt.s2k_mode = 3; /* iterated+salted */
2079     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2080     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
2081     opt.completes_needed = 1;
2082     opt.marginals_needed = 3;
2083     opt.max_cert_depth = 5;
2084     opt.pgp2_workarounds = 1;
2085     opt.escape_from = 1;
2086     opt.flags.require_cross_cert = 1;
2087     opt.import_options = 0;
2088     opt.export_options = EXPORT_ATTRIBUTES;
2089     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
2090     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2091     opt.keyserver_options.options = (KEYSERVER_HONOR_KEYSERVER_URL
2092                                      | KEYSERVER_HONOR_PKA_RECORD );
2093     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2094                           | VERIFY_SHOW_POLICY_URLS
2095                           | VERIFY_SHOW_STD_NOTATIONS
2096                           | VERIFY_SHOW_KEYSERVER_URLS);
2097     opt.list_options   = LIST_SHOW_UID_VALIDITY;
2098 #ifdef NO_TRUST_MODELS
2099     opt.trust_model = TM_ALWAYS;
2100 #else
2101     opt.trust_model = TM_AUTO;
2102 #endif
2103     opt.mangle_dos_filenames = 0;
2104     opt.min_cert_level = 2;
2105     set_screen_dimensions ();
2106     opt.keyid_format = KF_SHORT;
2107     opt.def_sig_expire = "0";
2108     opt.def_cert_expire = "0";
2109     set_homedir (default_homedir ());
2110     opt.passphrase_repeat = 1;
2111     opt.emit_version = 1; /* Limit to the major number.  */
2112
2113     /* Check whether we have a config file on the command line.  */
2114     orig_argc = argc;
2115     orig_argv = argv;
2116     pargs.argc = &argc;
2117     pargs.argv = &argv;
2118     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2119     while( arg_parse( &pargs, opts) ) {
2120         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2121             parse_debug++;
2122         else if( pargs.r_opt == oOptions ) {
2123             /* yes there is one, so we do not try the default one, but
2124              * read the option file when it is encountered at the commandline
2125              */
2126             default_config = 0;
2127         }
2128         else if( pargs.r_opt == oNoOptions )
2129           {
2130             default_config = 0; /* --no-options */
2131             opt.no_homedir_creation = 1;
2132           }
2133         else if( pargs.r_opt == oHomedir )
2134             set_homedir ( pargs.r.ret_str );
2135         else if( pargs.r_opt == oNoPermissionWarn )
2136             opt.no_perm_warn=1;
2137         else if (pargs.r_opt == oStrict )
2138           {
2139             /* Not used */
2140           }
2141         else if (pargs.r_opt == oNoStrict )
2142           {
2143             /* Not used */
2144           }
2145     }
2146
2147 #ifdef HAVE_DOSISH_SYSTEM
2148     if ( strchr (opt.homedir,'\\') ) {
2149         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2150         const char *s = opt.homedir;
2151         for (d=buf,s=opt.homedir; *s; s++)
2152           {
2153             *d++ = *s == '\\'? '/': *s;
2154 #ifdef HAVE_W32_SYSTEM
2155             if (s[1] && IsDBCSLeadByte (*s))
2156               *d++ = *++s;
2157 #endif
2158           }
2159         *d = 0;
2160         set_homedir (buf);
2161     }
2162 #endif
2163
2164     /* Initialize the secure memory. */
2165     if (!gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0))
2166       got_secmem = 1;
2167 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2168     /* There should be no way to get to this spot while still carrying
2169        setuid privs.  Just in case, bomb out if we are. */
2170     if ( getuid () != geteuid () )
2171       BUG ();
2172 #endif
2173     maybe_setuid = 0;
2174
2175     /* Okay, we are now working under our real uid */
2176
2177     /* malloc hooks go here ... */
2178     malloc_hooks.malloc = gcry_malloc;
2179     malloc_hooks.realloc = gcry_realloc;
2180     malloc_hooks.free = gcry_free;
2181     assuan_set_malloc_hooks (&malloc_hooks);
2182     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2183     setup_libassuan_logging (&opt.debug);
2184
2185     /* Try for a version specific config file first */
2186     default_configname = get_default_configname ();
2187     if (default_config)
2188       configname = xstrdup (default_configname);
2189
2190     argc = orig_argc;
2191     argv = orig_argv;
2192     pargs.argc = &argc;
2193     pargs.argv = &argv;
2194     pargs.flags= ARGPARSE_FLAG_KEEP;
2195
2196     /* By this point we have a homedir, and cannot change it. */
2197     check_permissions(opt.homedir,0);
2198
2199   next_pass:
2200     if( configname ) {
2201       if(check_permissions(configname,1))
2202         {
2203           /* If any options file is unsafe, then disable any external
2204              programs for keyserver calls or photo IDs.  Since the
2205              external program to call is set in the options file, a
2206              unsafe options file can lead to an arbitrary program
2207              being run. */
2208
2209           opt.exec_disable=1;
2210         }
2211
2212         configlineno = 0;
2213         configfp = fopen( configname, "r" );
2214         if (configfp && is_secured_file (fileno (configfp)))
2215           {
2216             fclose (configfp);
2217             configfp = NULL;
2218             gpg_err_set_errno (EPERM);
2219           }
2220         if( !configfp ) {
2221             if( default_config ) {
2222                 if( parse_debug )
2223                     log_info(_("NOTE: no default option file '%s'\n"),
2224                                                             configname );
2225             }
2226             else {
2227                 log_error(_("option file '%s': %s\n"),
2228                                     configname, strerror(errno) );
2229                 g10_exit(2);
2230             }
2231             xfree(configname); configname = NULL;
2232         }
2233         if( parse_debug && configname )
2234             log_info(_("reading options from '%s'\n"), configname );
2235         default_config = 0;
2236     }
2237
2238     while( optfile_parse( configfp, configname, &configlineno,
2239                                                 &pargs, opts) )
2240       {
2241         switch( pargs.r_opt )
2242           {
2243           case aCheckKeys:
2244           case aListConfig:
2245           case aGPGConfList:
2246           case aGPGConfTest:
2247           case aListPackets:
2248           case aImport:
2249           case aFastImport:
2250           case aSendKeys:
2251           case aRecvKeys:
2252           case aSearchKeys:
2253           case aRefreshKeys:
2254           case aFetchKeys:
2255           case aExport:
2256 #ifdef ENABLE_CARD_SUPPORT
2257           case aCardStatus:
2258           case aCardEdit:
2259           case aChangePIN:
2260 #endif /* ENABLE_CARD_SUPPORT*/
2261           case aListKeys:
2262           case aLocateKeys:
2263           case aListSigs:
2264           case aExportSecret:
2265           case aExportSecretSub:
2266           case aSym:
2267           case aClearsign:
2268           case aGenRevoke:
2269           case aDesigRevoke:
2270           case aPrimegen:
2271           case aGenRandom:
2272           case aPrintMD:
2273           case aPrintMDs:
2274           case aListTrustDB:
2275           case aCheckTrustDB:
2276           case aUpdateTrustDB:
2277           case aFixTrustDB:
2278           case aListTrustPath:
2279           case aDeArmor:
2280           case aEnArmor:
2281           case aSign:
2282           case aQuickSignKey:
2283           case aQuickLSignKey:
2284           case aSignKey:
2285           case aLSignKey:
2286           case aStore:
2287           case aQuickKeygen:
2288           case aExportOwnerTrust:
2289           case aImportOwnerTrust:
2290           case aRebuildKeydbCaches:
2291             set_cmd (&cmd, pargs.r_opt);
2292             break;
2293
2294           case aKeygen:
2295           case aEditKey:
2296           case aDeleteSecretKeys:
2297           case aDeleteSecretAndPublicKeys:
2298           case aDeleteKeys:
2299           case aPasswd:
2300             set_cmd (&cmd, pargs.r_opt);
2301             greeting=1;
2302             break;
2303
2304           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2305
2306           case aDecryptFiles: multifile=1; /* fall through */
2307           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2308
2309           case aEncrFiles: multifile=1; /* fall through */
2310           case aEncr: set_cmd( &cmd, aEncr); break;
2311
2312           case aVerifyFiles: multifile=1; /* fall through */
2313           case aVerify: set_cmd( &cmd, aVerify); break;
2314
2315           case aServer:
2316             set_cmd (&cmd, pargs.r_opt);
2317             opt.batch = 1;
2318             break;
2319
2320           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2321           case oOutput: opt.outfile = pargs.r.ret_str; break;
2322           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2323           case oQuiet: opt.quiet = 1; break;
2324           case oNoTTY: tty_no_terminal(1); break;
2325           case oDryRun: opt.dry_run = 1; break;
2326           case oInteractive: opt.interactive = 1; break;
2327           case oVerbose:
2328             opt.verbose++;
2329             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2330             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2331             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2332             break;
2333
2334           case oBatch:
2335             opt.batch = 1;
2336             nogreeting = 1;
2337             break;
2338
2339           case oUseAgent: /* Dummy. */
2340             break;
2341           case oNoUseAgent:
2342             obsolete_option (configname, configlineno, "--no-use-agent");
2343             break;
2344           case oGpgAgentInfo:
2345             obsolete_option (configname, configlineno, "--gpg-agent-info");
2346             break;
2347
2348           case oAnswerYes: opt.answer_yes = 1; break;
2349           case oAnswerNo: opt.answer_no = 1; break;
2350           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2351           case oPrimaryKeyring:
2352             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2353             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2354             break;
2355           case oShowKeyring:
2356             deprecated_warning(configname,configlineno,"--show-keyring",
2357                                "--list-options ","show-keyring");
2358             opt.list_options|=LIST_SHOW_KEYRING;
2359             break;
2360
2361           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2362           case oDebugAll: opt.debug = ~0; break;
2363           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2364
2365           case oStatusFD:
2366             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2367             break;
2368           case oStatusFile:
2369             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2370             break;
2371           case oAttributeFD:
2372             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2373             break;
2374           case oAttributeFile:
2375             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2376             break;
2377           case oLoggerFD:
2378             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2379             break;
2380           case oLoggerFile:
2381             logfile = pargs.r.ret_str;
2382             break;
2383
2384           case oWithFingerprint:
2385             opt.with_fingerprint = 1;
2386             opt.fingerprint++;
2387             break;
2388           case oFingerprint:
2389             opt.fingerprint++;
2390             fpr_maybe_cmd = 1;
2391             break;
2392
2393           case oWithKeygrip:
2394             opt.with_keygrip = 1;
2395             break;
2396
2397           case oWithSecret:
2398             opt.with_secret = 1;
2399             break;
2400
2401           case oSecretKeyring:
2402             /* Ignore this old option.  */
2403             break;
2404
2405           case oOptions:
2406             /* config files may not be nested (silently ignore them) */
2407             if( !configfp ) {
2408                 xfree(configname);
2409                 configname = xstrdup(pargs.r.ret_str);
2410                 goto next_pass;
2411             }
2412             break;
2413           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2414           case oNoDefKeyring: default_keyring = 0; break;
2415           case oNoGreeting: nogreeting = 1; break;
2416           case oNoVerbose:
2417             opt.verbose = 0;
2418             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2419             opt.list_sigs=0;
2420             break;
2421           case oQuickRandom:
2422             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2423             break;
2424           case oEmitVersion: opt.emit_version++; break;
2425           case oNoEmitVersion: opt.emit_version=0; break;
2426           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2427           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2428           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2429
2430 #ifndef NO_TRUST_MODELS
2431           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2432
2433 #endif /*!NO_TRUST_MODELS*/
2434           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2435           case oDefRecipient:
2436             if( *pargs.r.ret_str )
2437               opt.def_recipient = make_username(pargs.r.ret_str);
2438             break;
2439           case oDefRecipientSelf:
2440             xfree(opt.def_recipient); opt.def_recipient = NULL;
2441             opt.def_recipient_self = 1;
2442             break;
2443           case oNoDefRecipient:
2444             xfree(opt.def_recipient); opt.def_recipient = NULL;
2445             opt.def_recipient_self = 0;
2446             break;
2447           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2448           case oHomedir: break;
2449           case oNoBatch: opt.batch = 0; break;
2450
2451           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2452           case oWithColons: opt.with_colons=':'; break;
2453
2454           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2455           case oWithSigList: opt.list_sigs = 1; break;
2456
2457           case oSkipVerify: opt.skip_verify=1; break;
2458
2459           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2460           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2461
2462           case oCompressKeys: opt.compress_keys = 1; break;
2463           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2464
2465 #ifndef NO_TRUST_MODELS
2466             /* There are many programs (like mutt) that call gpg with
2467                --always-trust so keep this option around for a long
2468                time. */
2469           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2470           case oTrustModel:
2471             parse_trust_model(pargs.r.ret_str);
2472             break;
2473 #endif /*!NO_TRUST_MODELS*/
2474
2475           case oForceOwnertrust:
2476             log_info(_("NOTE: %s is not for normal use!\n"),
2477                      "--force-ownertrust");
2478             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2479             if(opt.force_ownertrust==-1)
2480               {
2481                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2482                 opt.force_ownertrust=0;
2483               }
2484             break;
2485           case oLoadExtension:
2486             /* Dummy so that gpg 1.4 conf files can work. Should
2487                eventually be removed.  */
2488             break;
2489           case oRFC1991:
2490             opt.compliance = CO_RFC1991;
2491             opt.force_v4_certs = 0;
2492             opt.escape_from = 1;
2493             break;
2494           case oOpenPGP:
2495           case oRFC4880:
2496             /* This is effectively the same as RFC2440, but with
2497                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2498                --require-cross-certification". */
2499             opt.compliance = CO_RFC4880;
2500             opt.flags.dsa2 = 1;
2501             opt.flags.require_cross_cert = 1;
2502             opt.rfc2440_text = 0;
2503             opt.allow_non_selfsigned_uid = 1;
2504             opt.allow_freeform_uid = 1;
2505             opt.pgp2_workarounds = 0;
2506             opt.escape_from = 1;
2507             opt.force_v3_sigs = 0;
2508             opt.compress_keys = 0;          /* not mandated, but we do it */
2509             opt.compress_sigs = 0;          /* ditto. */
2510             opt.not_dash_escaped = 0;
2511             opt.def_cipher_algo = 0;
2512             opt.def_digest_algo = 0;
2513             opt.cert_digest_algo = 0;
2514             opt.compress_algo = -1;
2515             opt.s2k_mode = 3; /* iterated+salted */
2516             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2517             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2518             break;
2519           case oRFC2440:
2520             opt.compliance = CO_RFC2440;
2521             opt.flags.dsa2 = 0;
2522             opt.rfc2440_text = 1;
2523             opt.allow_non_selfsigned_uid = 1;
2524             opt.allow_freeform_uid = 1;
2525             opt.pgp2_workarounds = 0;
2526             opt.escape_from = 0;
2527             opt.force_v3_sigs = 0;
2528             opt.compress_keys = 0;          /* not mandated, but we do it */
2529             opt.compress_sigs = 0;          /* ditto. */
2530             opt.not_dash_escaped = 0;
2531             opt.def_cipher_algo = 0;
2532             opt.def_digest_algo = 0;
2533             opt.cert_digest_algo = 0;
2534             opt.compress_algo = -1;
2535             opt.s2k_mode = 3; /* iterated+salted */
2536             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2537             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2538             break;
2539           case oPGP2:  opt.compliance = CO_PGP2;  break;
2540           case oPGP6:  opt.compliance = CO_PGP6;  break;
2541           case oPGP7:  opt.compliance = CO_PGP7;  break;
2542           case oPGP8:  opt.compliance = CO_PGP8;  break;
2543           case oGnuPG: opt.compliance = CO_GNUPG; break;
2544           case oCompressSigs: opt.compress_sigs = 1; break;
2545           case oRFC2440Text: opt.rfc2440_text=1; break;
2546           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2547           case oSetFilename:
2548             if(utf8_strings)
2549               opt.set_filename = pargs.r.ret_str;
2550             else
2551               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2552             break;
2553           case oForYourEyesOnly: eyes_only = 1; break;
2554           case oNoForYourEyesOnly: eyes_only = 0; break;
2555           case oSetPolicyURL:
2556             add_policy_url(pargs.r.ret_str,0);
2557             add_policy_url(pargs.r.ret_str,1);
2558             break;
2559           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2560           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2561           case oShowPolicyURL:
2562             deprecated_warning(configname,configlineno,"--show-policy-url",
2563                                "--list-options ","show-policy-urls");
2564             deprecated_warning(configname,configlineno,"--show-policy-url",
2565                                "--verify-options ","show-policy-urls");
2566             opt.list_options|=LIST_SHOW_POLICY_URLS;
2567             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2568             break;
2569           case oNoShowPolicyURL:
2570             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2571                                "--list-options ","no-show-policy-urls");
2572             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2573                                "--verify-options ","no-show-policy-urls");
2574             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2575             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2576             break;
2577           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2578           case oUseEmbeddedFilename:
2579             opt.flags.use_embedded_filename=1;
2580             break;
2581           case oNoUseEmbeddedFilename:
2582             opt.flags.use_embedded_filename=0;
2583             break;
2584           case oComment:
2585             if(pargs.r.ret_str[0])
2586               append_to_strlist(&opt.comments,pargs.r.ret_str);
2587             break;
2588           case oDefaultComment:
2589             deprecated_warning(configname,configlineno,
2590                                "--default-comment","--no-comments","");
2591             /* fall through */
2592           case oNoComments:
2593             free_strlist(opt.comments);
2594             opt.comments=NULL;
2595             break;
2596           case oThrowKeyids: opt.throw_keyid = 1; break;
2597           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2598           case oShowPhotos:
2599             deprecated_warning(configname,configlineno,"--show-photos",
2600                                "--list-options ","show-photos");
2601             deprecated_warning(configname,configlineno,"--show-photos",
2602                                "--verify-options ","show-photos");
2603             opt.list_options|=LIST_SHOW_PHOTOS;
2604             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2605             break;
2606           case oNoShowPhotos:
2607             deprecated_warning(configname,configlineno,"--no-show-photos",
2608                                "--list-options ","no-show-photos");
2609             deprecated_warning(configname,configlineno,"--no-show-photos",
2610                                "--verify-options ","no-show-photos");
2611             opt.list_options&=~LIST_SHOW_PHOTOS;
2612             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2613             break;
2614           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2615           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2616           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2617           case oForceV4Certs: opt.force_v4_certs = 1; break;
2618           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2619           case oForceMDC: opt.force_mdc = 1; break;
2620           case oNoForceMDC: opt.force_mdc = 0; break;
2621           case oDisableMDC: opt.disable_mdc = 1; break;
2622           case oNoDisableMDC: opt.disable_mdc = 0; break;
2623           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2624           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2625           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2626           case oS2KCount:
2627             if (pargs.r.ret_int)
2628               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2629             else
2630               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2631             break;
2632           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2633           case oEncryptTo: /* store the recipient in the second list */
2634             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2635             sl->flags = 1;
2636             break;
2637           case oHiddenEncryptTo: /* store the recipient in the second list */
2638             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2639             sl->flags = 1|2;
2640             break;
2641           case oRecipient: /* store the recipient */
2642             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2643             any_explicit_recipient = 1;
2644             break;
2645           case oHiddenRecipient: /* store the recipient with a flag */
2646             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2647             sl->flags = 2;
2648             any_explicit_recipient = 1;
2649             break;
2650
2651           case oTrySecretKey:
2652             add_to_strlist2 (&opt.secret_keys_to_try,
2653                              pargs.r.ret_str, utf8_strings);
2654             break;
2655
2656           case oTextmodeShort: opt.textmode = 2; break;
2657           case oTextmode: opt.textmode=1;  break;
2658           case oNoTextmode: opt.textmode=0;  break;
2659           case oExpert: opt.expert = 1; break;
2660           case oNoExpert: opt.expert = 0; break;
2661           case oDefSigExpire:
2662             if(*pargs.r.ret_str!='\0')
2663               {
2664                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2665                   log_error(_("'%s' is not a valid signature expiration\n"),
2666                             pargs.r.ret_str);
2667                 else
2668                   opt.def_sig_expire=pargs.r.ret_str;
2669               }
2670             break;
2671           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2672           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2673           case oDefCertExpire:
2674             if(*pargs.r.ret_str!='\0')
2675               {
2676                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2677                   log_error(_("'%s' is not a valid signature expiration\n"),
2678                             pargs.r.ret_str);
2679                 else
2680                   opt.def_cert_expire=pargs.r.ret_str;
2681               }
2682             break;
2683           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2684           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2685           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2686           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2687           case oAskCertLevel: opt.ask_cert_level = 1; break;
2688           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2689           case oLocalUser: /* store the local users */
2690             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2691             break;
2692           case oCompress:
2693             /* this is the -z command line option */
2694             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2695             break;
2696           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2697           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2698           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2699           case oPassphrase:
2700             set_passphrase_from_string(pargs.r.ret_str);
2701             break;
2702           case oPassphraseFD:
2703             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2704             break;
2705           case oPassphraseFile:
2706             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
2707             break;
2708           case oPassphraseRepeat:
2709             opt.passphrase_repeat = pargs.r.ret_int;
2710             break;
2711
2712           case oPinentryMode:
2713             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
2714             if (opt.pinentry_mode == -1)
2715               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
2716             break;
2717
2718           case oCommandFD:
2719             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2720             break;
2721           case oCommandFile:
2722             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
2723             break;
2724           case oCipherAlgo:
2725             def_cipher_string = xstrdup(pargs.r.ret_str);
2726             break;
2727           case oDigestAlgo:
2728             def_digest_string = xstrdup(pargs.r.ret_str);
2729             break;
2730           case oCompressAlgo:
2731             /* If it is all digits, stick a Z in front of it for
2732                later.  This is for backwards compatibility with
2733                versions that took the compress algorithm number. */
2734             {
2735               char *pt=pargs.r.ret_str;
2736               while(*pt)
2737                 {
2738                   if (!isascii (*pt) || !isdigit (*pt))
2739                     break;
2740
2741                   pt++;
2742                 }
2743
2744               if(*pt=='\0')
2745                 {
2746                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2747                   strcpy(compress_algo_string,"Z");
2748                   strcat(compress_algo_string,pargs.r.ret_str);
2749                 }
2750               else
2751                 compress_algo_string = xstrdup(pargs.r.ret_str);
2752             }
2753             break;
2754           case oCertDigestAlgo:
2755             cert_digest_string = xstrdup(pargs.r.ret_str);
2756             break;
2757
2758           case oNoSecmemWarn:
2759             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
2760             break;
2761
2762           case oRequireSecmem: require_secmem=1; break;
2763           case oNoRequireSecmem: require_secmem=0; break;
2764           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2765           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2766           case oDisplayCharset:
2767             if( set_native_charset( pargs.r.ret_str ) )
2768                 log_error(_("'%s' is not a valid character set\n"),
2769                           pargs.r.ret_str);
2770             break;
2771           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2772           case oEscapeFrom: opt.escape_from = 1; break;
2773           case oNoEscapeFrom: opt.escape_from = 0; break;
2774           case oLockOnce: opt.lock_once = 1; break;
2775           case oLockNever:
2776             dotlock_disable ();
2777             break;
2778           case oLockMultiple:
2779 #ifndef __riscos__
2780             opt.lock_once = 0;
2781 #else /* __riscos__ */
2782             riscos_not_implemented("lock-multiple");
2783 #endif /* __riscos__ */
2784             break;
2785           case oKeyServer:
2786             {
2787               keyserver_spec_t keyserver;
2788               keyserver = parse_keyserver_uri (pargs.r.ret_str,0,
2789                                                configname,configlineno);
2790               if (!keyserver)
2791                 log_error (_("could not parse keyserver URL\n"));
2792               else
2793                 {
2794                   keyserver->next = opt.keyserver;
2795                   opt.keyserver = keyserver;
2796                 }
2797             }
2798             break;
2799           case oKeyServerOptions:
2800             if(!parse_keyserver_options(pargs.r.ret_str))
2801               {
2802                 if(configname)
2803                   log_error(_("%s:%d: invalid keyserver options\n"),
2804                             configname,configlineno);
2805                 else
2806                   log_error(_("invalid keyserver options\n"));
2807               }
2808             break;
2809           case oImportOptions:
2810             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2811               {
2812                 if(configname)
2813                   log_error(_("%s:%d: invalid import options\n"),
2814                             configname,configlineno);
2815                 else
2816                   log_error(_("invalid import options\n"));
2817               }
2818             break;
2819           case oExportOptions:
2820             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2821               {
2822                 if(configname)
2823                   log_error(_("%s:%d: invalid export options\n"),
2824                             configname,configlineno);
2825                 else
2826                   log_error(_("invalid export options\n"));
2827               }
2828             break;
2829           case oListOptions:
2830             if(!parse_list_options(pargs.r.ret_str))
2831               {
2832                 if(configname)
2833                   log_error(_("%s:%d: invalid list options\n"),
2834                             configname,configlineno);
2835                 else
2836                   log_error(_("invalid list options\n"));
2837               }
2838             break;
2839           case oVerifyOptions:
2840             {
2841               struct parse_options vopts[]=
2842                 {
2843                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2844                    N_("display photo IDs during signature verification")},
2845                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2846                    N_("show policy URLs during signature verification")},
2847                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2848                    N_("show all notations during signature verification")},
2849                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2850                    N_("show IETF standard notations during signature verification")},
2851                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2852                    NULL},
2853                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2854                    N_("show user-supplied notations during signature verification")},
2855                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2856                    N_("show preferred keyserver URLs during signature verification")},
2857                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2858                    N_("show user ID validity during signature verification")},
2859                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2860                    N_("show revoked and expired user IDs in signature verification")},
2861                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
2862                    N_("show only the primary user ID in signature verification")},
2863                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2864                    N_("validate signatures with PKA data")},
2865                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2866                    N_("elevate the trust of signatures with valid PKA data")},
2867                   {NULL,0,NULL,NULL}
2868                 };
2869
2870               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2871                 {
2872                   if(configname)
2873                     log_error(_("%s:%d: invalid verify options\n"),
2874                               configname,configlineno);
2875                   else
2876                     log_error(_("invalid verify options\n"));
2877                 }
2878             }
2879             break;
2880           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2881           case oExecPath:
2882             if(set_exec_path(pargs.r.ret_str))
2883               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2884             else
2885               opt.exec_path_set=1;
2886             break;
2887           case oSetNotation:
2888             add_notation_data( pargs.r.ret_str, 0 );
2889             add_notation_data( pargs.r.ret_str, 1 );
2890             break;
2891           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2892           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2893           case oShowNotation:
2894             deprecated_warning(configname,configlineno,"--show-notation",
2895                                "--list-options ","show-notations");
2896             deprecated_warning(configname,configlineno,"--show-notation",
2897                                "--verify-options ","show-notations");
2898             opt.list_options|=LIST_SHOW_NOTATIONS;
2899             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2900             break;
2901           case oNoShowNotation:
2902             deprecated_warning(configname,configlineno,"--no-show-notation",
2903                                "--list-options ","no-show-notations");
2904             deprecated_warning(configname,configlineno,"--no-show-notation",
2905                                "--verify-options ","no-show-notations");
2906             opt.list_options&=~LIST_SHOW_NOTATIONS;
2907             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2908             break;
2909           case oUtf8Strings: utf8_strings = 1; break;
2910           case oNoUtf8Strings: utf8_strings = 0; break;
2911           case oDisableCipherAlgo:
2912             {
2913               int algo = string_to_cipher_algo (pargs.r.ret_str);
2914               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2915             }
2916             break;
2917           case oDisablePubkeyAlgo:
2918             {
2919               int algo = gcry_pk_map_name (pargs.r.ret_str);
2920               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2921             }
2922             break;
2923           case oNoSigCache: opt.no_sig_cache = 1; break;
2924           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2925           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2926           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2927           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2928           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2929           case oNoLiteral: opt.no_literal = 1; break;
2930           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2931           case oHonorHttpProxy:
2932                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2933                 deprecated_warning(configname,configlineno,
2934                                    "--honor-http-proxy",
2935                                    "--keyserver-options ","http-proxy");
2936                 break;
2937           case oFastListMode: opt.fast_list_mode = 1; break;
2938           case oFixedListMode: /* Dummy */ break;
2939           case oLegacyListMode: opt.legacy_list_mode = 1; break;
2940           case oListOnly: opt.list_only=1; break;
2941           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2942           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2943           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2944           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2945           case oNoRandomSeedFile: use_random_seed = 0; break;
2946           case oAutoKeyRetrieve:
2947           case oNoAutoKeyRetrieve:
2948                 if(pargs.r_opt==oAutoKeyRetrieve)
2949                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2950                 else
2951                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2952
2953                 deprecated_warning(configname,configlineno,
2954                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2955                                "--no-auto-key-retrieve","--keyserver-options ",
2956                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2957                                "no-auto-key-retrieve");
2958                 break;
2959           case oShowSessionKey: opt.show_session_key = 1; break;
2960           case oOverrideSessionKey:
2961                 opt.override_session_key = pargs.r.ret_str;
2962                 break;
2963           case oMergeOnly:
2964                 deprecated_warning(configname,configlineno,"--merge-only",
2965                                    "--import-options ","merge-only");
2966                 opt.import_options|=IMPORT_MERGE_ONLY;
2967             break;
2968           case oAllowSecretKeyImport: /* obsolete */ break;
2969           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2970           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2971           case oEnableSpecialFilenames:
2972             iobuf_enable_special_filenames (1);
2973             break;
2974           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2975           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2976           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2977           case oPreservePermissions: opt.preserve_permissions=1; break;
2978           case oDefaultPreferenceList:
2979             opt.def_preference_list = pargs.r.ret_str;
2980             break;
2981           case oDefaultKeyserverURL:
2982             {
2983               keyserver_spec_t keyserver;
2984               keyserver = parse_keyserver_uri (pargs.r.ret_str,1,
2985                                                configname,configlineno);
2986               if (!keyserver)
2987                 log_error (_("could not parse keyserver URL\n"));
2988               else
2989                 free_keyserver_spec (keyserver);
2990
2991               opt.def_keyserver_url = pargs.r.ret_str;
2992             }
2993             break;
2994           case oPersonalCipherPreferences:
2995             pers_cipher_list=pargs.r.ret_str;
2996             break;
2997           case oPersonalDigestPreferences:
2998             pers_digest_list=pargs.r.ret_str;
2999             break;
3000           case oPersonalCompressPreferences:
3001             pers_compress_list=pargs.r.ret_str;
3002             break;
3003           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3004           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3005
3006           case oDisplay:
3007             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3008             break;
3009           case oTTYname:
3010             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3011             break;
3012           case oTTYtype:
3013             set_opt_session_env ("TERM", pargs.r.ret_str);
3014             break;
3015           case oXauthority:
3016             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3017             break;
3018
3019           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3020           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3021
3022           case oGroup: add_group(pargs.r.ret_str); break;
3023           case oUnGroup: rm_group(pargs.r.ret_str); break;
3024           case oNoGroups:
3025             while(opt.grouplist)
3026               {
3027                 struct groupitem *iter=opt.grouplist;
3028                 free_strlist(iter->values);
3029                 opt.grouplist=opt.grouplist->next;
3030                 xfree(iter);
3031               }
3032             break;
3033
3034           case oStrict:
3035           case oNoStrict:
3036             /* Not used */
3037             break;
3038
3039           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3040           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3041           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3042           case oMultifile: multifile=1; break;
3043           case oKeyidFormat:
3044             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3045               opt.keyid_format=KF_SHORT;
3046             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3047               opt.keyid_format=KF_LONG;
3048             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3049               opt.keyid_format=KF_0xSHORT;
3050             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3051               opt.keyid_format=KF_0xLONG;
3052             else
3053               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3054             break;
3055
3056           case oExitOnStatusWriteError:
3057             opt.exit_on_status_write_error = 1;
3058             break;
3059
3060           case oLimitCardInsertTries:
3061             opt.limit_card_insert_tries = pargs.r.ret_int;
3062             break;
3063
3064           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3065           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3066
3067           case oAutoKeyLocate:
3068             if(!parse_auto_key_locate(pargs.r.ret_str))
3069               {
3070                 if(configname)
3071                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3072                             configname,configlineno);
3073                 else
3074                   log_error(_("invalid auto-key-locate list\n"));
3075               }
3076             break;
3077           case oNoAutoKeyLocate:
3078             release_akl();
3079             break;
3080
3081           case oEnableDSA2: opt.flags.dsa2=1; break;
3082           case oDisableDSA2: opt.flags.dsa2=0; break;
3083
3084           case oAllowMultisigVerification:
3085           case oAllowMultipleMessages:
3086             opt.flags.allow_multiple_messages=1;
3087             break;
3088
3089           case oNoAllowMultipleMessages:
3090             opt.flags.allow_multiple_messages=0;
3091             break;
3092
3093           case oAllowWeakDigestAlgos:
3094             opt.flags.allow_weak_digest_algos = 1;
3095             break;
3096
3097           case oFakedSystemTime:
3098             {
3099               time_t faked_time = isotime2epoch (pargs.r.ret_str);
3100               if (faked_time == (time_t)(-1))
3101                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3102               gnupg_set_time (faked_time, 0);
3103             }
3104             break;
3105
3106           case oNoop: break;
3107
3108           default:
3109             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3110             break;
3111           }
3112       }
3113
3114     if (configfp)
3115       {
3116         fclose( configfp );
3117         configfp = NULL;
3118         /* Remember the first config file name. */
3119         if (!save_configname)
3120           save_configname = configname;
3121         else
3122           xfree(configname);
3123         configname = NULL;
3124         goto next_pass;
3125       }
3126     xfree(configname); configname = NULL;
3127     if (log_get_errorcount (0))
3128       g10_exit(2);
3129
3130     /* The command --gpgconf-list is pretty simple and may be called
3131        directly after the option parsing. */
3132     if (cmd == aGPGConfList)
3133       {
3134         gpgconf_list (save_configname ? save_configname : default_configname);
3135         g10_exit (0);
3136       }
3137     xfree (save_configname);
3138     xfree (default_configname);
3139
3140     if( nogreeting )
3141         greeting = 0;
3142
3143     if( greeting )
3144       {
3145         es_fprintf (es_stderr, "%s %s; %s\n",
3146                     strusage(11), strusage(13), strusage(14) );
3147         es_fprintf (es_stderr, "%s\n", strusage(15) );
3148       }
3149 #ifdef IS_DEVELOPMENT_VERSION
3150     if (!opt.batch)
3151       {
3152         const char *s;
3153
3154         if((s=strusage(25)))
3155           log_info("%s\n",s);
3156         if((s=strusage(26)))
3157           log_info("%s\n",s);
3158         if((s=strusage(27)))
3159           log_info("%s\n",s);
3160       }
3161 #endif
3162
3163     /* FIXME: We should use logging to a file only in server mode;
3164        however we have not yet implemetyed that.  Thus we try to get
3165        away with --batch as indication for logging to file
3166        required. */
3167     if (logfile && opt.batch)
3168       {
3169         log_set_file (logfile);
3170         log_set_prefix (NULL, 1|2|4);
3171       }
3172
3173     /* Older Libgcrypts fail with an assertion during DSA key
3174        generation.  Better disable DSA2 entirely. */
3175     if (opt.flags.dsa2 && !gcry_check_version ("1.4.0") )
3176       {
3177         log_info ("WARNING: "
3178                   "DSA2 is only available with Libgcrypt 1.4 and later\n");
3179         opt.flags.dsa2 = 0;
3180       }
3181
3182     if (opt.verbose > 2)
3183         log_info ("using character set '%s'\n", get_native_charset ());
3184
3185     if( may_coredump && !opt.quiet )
3186         log_info(_("WARNING: program may create a core file!\n"));
3187
3188     if (eyes_only) {
3189       if (opt.set_filename)
3190           log_info(_("WARNING: %s overrides %s\n"),
3191                    "--for-your-eyes-only","--set-filename");
3192
3193       opt.set_filename="_CONSOLE";
3194     }
3195
3196     if (opt.no_literal) {
3197         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
3198         if (opt.textmode)
3199             log_error(_("%s not allowed with %s!\n"),
3200                        "--textmode", "--no-literal" );
3201         if (opt.set_filename)
3202             log_error(_("%s makes no sense with %s!\n"),
3203                         eyes_only?"--for-your-eyes-only":"--set-filename",
3204                         "--no-literal" );
3205     }
3206
3207
3208     if (opt.set_filesize)
3209         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
3210     if( opt.batch )
3211         tty_batchmode( 1 );
3212
3213     if (gnupg_faked_time_p ())
3214       {
3215         gnupg_isotime_t tbuf;
3216
3217         log_info (_("WARNING: running with faked system time: "));
3218         gnupg_get_isotime (tbuf);
3219         dump_isotime (tbuf);
3220         log_printf ("\n");
3221       }
3222
3223     /* Print a warning if an argument looks like an option.  */
3224     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3225       {
3226         int i;
3227
3228         for (i=0; i < argc; i++)
3229           if (argv[i][0] == '-' && argv[i][1] == '-')
3230             log_info (_("NOTE: '%s' is not considered an option\n"), argv[i]);
3231       }
3232
3233
3234     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3235
3236     if(require_secmem && !got_secmem)
3237       {
3238         log_info(_("will not run with insecure memory due to %s\n"),
3239                  "--require-secmem");
3240         g10_exit(2);
3241       }
3242
3243     set_debug (debug_level);
3244     if (DBG_CLOCK)
3245       log_clock ("start");
3246
3247     /* Do these after the switch(), so they can override settings. */
3248     if(PGP2)
3249       {
3250         int unusable=0;
3251
3252         if(cmd==aSign && !detached_sig)
3253           {
3254             log_info(_("you can only make detached or clear signatures "
3255                        "while in --pgp2 mode\n"));
3256             unusable=1;
3257           }
3258         else if(cmd==aSignEncr || cmd==aSignSym)
3259           {
3260             log_info(_("you can't sign and encrypt at the "
3261                        "same time while in --pgp2 mode\n"));
3262             unusable=1;
3263           }
3264         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
3265           {
3266             log_info(_("you must use files (and not a pipe) when "
3267                        "working with --pgp2 enabled.\n"));
3268             unusable=1;
3269           }
3270         else if(cmd==aEncr || cmd==aSym)
3271           {
3272             /* Everything else should work without IDEA (except using
3273                a secret key encrypted with IDEA and setting an IDEA
3274                preference, but those have their own error
3275                messages). */
3276
3277             if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
3278               {
3279                 log_info(_("encrypting a message in --pgp2 mode requires "
3280                            "the IDEA cipher\n"));
3281                 unusable=1;
3282               }
3283             else if(cmd==aSym)
3284               {
3285                 /* This only sets IDEA for symmetric encryption
3286                    since it is set via select_algo_from_prefs for
3287                    pk encryption. */
3288                 xfree(def_cipher_string);
3289                 def_cipher_string = xstrdup("idea");
3290               }
3291
3292             /* PGP2 can't handle the output from the textmode
3293                filter, so we disable it for anything that could
3294                create a literal packet (only encryption and
3295                symmetric encryption, since we disable signing
3296                above). */
3297             if(!unusable)
3298               opt.textmode=0;
3299           }
3300
3301         if(unusable)
3302           compliance_failure();
3303         else
3304           {
3305             opt.force_v4_certs = 0;
3306             opt.escape_from = 1;
3307             opt.force_v3_sigs = 1;
3308             opt.pgp2_workarounds = 1;
3309             opt.ask_sig_expire = 0;
3310             opt.ask_cert_expire = 0;
3311             opt.flags.allow_weak_digest_algos = 1;
3312             xfree(def_digest_string);
3313             def_digest_string = xstrdup("md5");
3314             xfree(s2k_digest_string);
3315             s2k_digest_string = xstrdup("md5");
3316             opt.compress_algo = COMPRESS_ALGO_ZIP;
3317           }
3318       }
3319     else if(PGP6)
3320       {
3321         opt.disable_mdc=1;
3322         opt.escape_from=1;
3323         opt.force_v3_sigs=1;
3324         opt.ask_sig_expire=0;
3325       }
3326     else if(PGP7)
3327       {
3328         opt.escape_from=1;
3329         opt.force_v3_sigs=1;
3330         opt.ask_sig_expire=0;
3331       }
3332     else if(PGP8)
3333       {
3334         opt.escape_from=1;
3335       }
3336
3337
3338     if( def_cipher_string ) {
3339         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3340         xfree(def_cipher_string); def_cipher_string = NULL;
3341         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3342             log_error(_("selected cipher algorithm is invalid\n"));
3343     }
3344     if( def_digest_string ) {
3345         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3346         xfree(def_digest_string); def_digest_string = NULL;
3347         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3348             log_error(_("selected digest algorithm is invalid\n"));
3349     }
3350     if( compress_algo_string ) {
3351         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3352         xfree(compress_algo_string); compress_algo_string = NULL;
3353         if( check_compress_algo(opt.compress_algo) )
3354           log_error(_("selected compression algorithm is invalid\n"));
3355     }
3356     if( cert_digest_string ) {
3357         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3358         xfree(cert_digest_string); cert_digest_string = NULL;
3359         if (openpgp_md_test_algo(opt.cert_digest_algo))
3360           log_error(_("selected certification digest algorithm is invalid\n"));
3361     }
3362     if( s2k_cipher_string ) {
3363         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3364         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3365         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3366           log_error(_("selected cipher algorithm is invalid\n"));
3367     }
3368     if( s2k_digest_string ) {
3369         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3370         xfree(s2k_digest_string); s2k_digest_string = NULL;
3371         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3372           log_error(_("selected digest algorithm is invalid\n"));
3373     }
3374     if( opt.completes_needed < 1 )
3375       log_error(_("completes-needed must be greater than 0\n"));
3376     if( opt.marginals_needed < 2 )
3377       log_error(_("marginals-needed must be greater than 1\n"));
3378     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3379       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3380     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3381       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3382     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3383       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3384     switch( opt.s2k_mode ) {
3385       case 0:
3386         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3387         break;
3388       case 1: case 3: break;
3389       default:
3390         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3391     }
3392
3393     /* This isn't actually needed, but does serve to error out if the
3394        string is invalid. */
3395     if(opt.def_preference_list &&
3396         keygen_set_std_prefs(opt.def_preference_list,0))
3397       log_error(_("invalid default preferences\n"));
3398
3399     if(pers_cipher_list &&
3400        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3401       log_error(_("invalid personal cipher preferences\n"));
3402
3403     if(pers_digest_list &&
3404        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3405       log_error(_("invalid personal digest preferences\n"));
3406
3407     if(pers_compress_list &&
3408        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3409       log_error(_("invalid personal compress preferences\n"));
3410
3411     /* We don't support all possible commands with multifile yet */
3412     if(multifile)
3413       {
3414         char *cmdname;
3415
3416         switch(cmd)
3417           {
3418           case aSign:
3419             cmdname="--sign";
3420             break;
3421           case aClearsign:
3422             cmdname="--clearsign";
3423             break;
3424           case aDetachedSign:
3425             cmdname="--detach-sign";
3426             break;
3427           case aSym:
3428             cmdname="--symmetric";
3429             break;
3430           case aEncrSym:
3431             cmdname="--symmetric --encrypt";
3432             break;
3433           case aStore:
3434             cmdname="--store";
3435             break;
3436           default:
3437             cmdname=NULL;
3438             break;
3439           }
3440
3441         if(cmdname)
3442           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3443       }
3444
3445     if( log_get_errorcount(0) )
3446         g10_exit(2);
3447
3448     if(opt.compress_level==0)
3449       opt.compress_algo=COMPRESS_ALGO_NONE;
3450
3451     /* Check our chosen algorithms against the list of legal
3452        algorithms. */
3453
3454     if(!GNUPG)
3455       {
3456         const char *badalg=NULL;
3457         preftype_t badtype=PREFTYPE_NONE;
3458
3459         if(opt.def_cipher_algo
3460            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3461           {
3462             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3463             badtype = PREFTYPE_SYM;
3464           }
3465         else if(opt.def_digest_algo
3466                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3467           {
3468             badalg = gcry_md_algo_name (opt.def_digest_algo);
3469             badtype = PREFTYPE_HASH;
3470           }
3471         else if(opt.cert_digest_algo
3472                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3473           {
3474             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3475             badtype = PREFTYPE_HASH;
3476           }
3477         else if(opt.compress_algo!=-1
3478                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3479           {
3480             badalg = compress_algo_to_string(opt.compress_algo);
3481             badtype = PREFTYPE_ZIP;
3482           }
3483
3484         if(badalg)
3485           {
3486             switch(badtype)
3487               {
3488               case PREFTYPE_SYM:
3489                 log_info(_("you may not use cipher algorithm '%s'"
3490                            " while in %s mode\n"),
3491                          badalg,compliance_option_string());
3492                 break;
3493               case PREFTYPE_HASH:
3494                 log_info(_("you may not use digest algorithm '%s'"
3495                            " while in %s mode\n"),
3496                          badalg,compliance_option_string());
3497                 break;
3498               case PREFTYPE_ZIP:
3499                 log_info(_("you may not use compression algorithm '%s'"
3500                            " while in %s mode\n"),
3501                          badalg,compliance_option_string());
3502                 break;
3503               default:
3504                 BUG();
3505               }
3506
3507             compliance_failure();
3508           }
3509       }
3510
3511     /* Set the random seed file. */
3512     if( use_random_seed ) {
3513         char *p = make_filename(opt.homedir, "random_seed", NULL );
3514         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3515         if (!access (p, F_OK))
3516           register_secured_file (p);
3517         xfree(p);
3518     }
3519
3520     /* If there is no command but the --fingerprint is given, default
3521        to the --list-keys command.  */
3522     if (!cmd && fpr_maybe_cmd)
3523       {
3524         set_cmd (&cmd, aListKeys);
3525       }
3526
3527
3528     if( opt.verbose > 1 )
3529         set_packet_list_mode(1);
3530
3531     /* Add the keyrings, but not for some special commands.
3532        We always need to add the keyrings if we are running under
3533        SELinux, this is so that the rings are added to the list of
3534        secured files. */
3535     if( ALWAYS_ADD_KEYRINGS
3536         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) )
3537       {
3538         if (!nrings || default_keyring)  /* Add default ring. */
3539             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3540                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3541         for (sl = nrings; sl; sl = sl->next )
3542           keydb_add_resource (sl->d, sl->flags);
3543       }
3544     FREE_STRLIST(nrings);
3545
3546     if (cmd == aGPGConfTest)
3547       g10_exit(0);
3548
3549
3550     if( pwfd != -1 )  /* Read the passphrase now. */
3551         read_passphrase_from_fd( pwfd );
3552
3553     fname = argc? *argv : NULL;
3554
3555     if(fname && utf8_strings)
3556       opt.flags.utf8_filename=1;
3557
3558     ctrl = xcalloc (1, sizeof *ctrl);
3559     gpg_init_default_ctrl (ctrl);
3560
3561 #ifndef NO_TRUST_MODELS
3562     switch (cmd)
3563       {
3564       case aPrimegen:
3565       case aPrintMD:
3566       case aPrintMDs:
3567       case aGenRandom:
3568       case aDeArmor:
3569       case aEnArmor:
3570         break;
3571       case aFixTrustDB:
3572       case aExportOwnerTrust:
3573         rc = setup_trustdb (0, trustdb_name);
3574         break;
3575       case aListTrustDB:
3576         rc = setup_trustdb (argc? 1:0, trustdb_name);
3577         break;
3578       default:
3579         /* If we are using TM_ALWAYS, we do not need to create the
3580            trustdb.  */
3581         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3582         break;
3583       }
3584     if (rc)
3585       log_error (_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3586 #endif /*!NO_TRUST_MODELS*/
3587
3588     switch (cmd)
3589       {
3590       case aStore:
3591       case aSym:
3592       case aSign:
3593       case aSignSym:
3594       case aClearsign:
3595         if (!opt.quiet && any_explicit_recipient)
3596           log_info (_("WARNING: recipients (-r) given "
3597                       "without using public key encryption\n"));
3598         break;
3599       default:
3600         break;
3601       }
3602
3603
3604     /* Check for certain command whether we need to migrate a
3605        secring.gpg to the gpg-agent. */
3606     switch (cmd)
3607       {
3608       case aListSecretKeys:
3609       case aSign:
3610       case aSignEncr:
3611       case aSignEncrSym:
3612       case aSignSym:
3613       case aClearsign:
3614       case aDecrypt:
3615       case aSignKey:
3616       case aLSignKey:
3617       case aEditKey:
3618       case aPasswd:
3619       case aDeleteSecretKeys:
3620       case aDeleteSecretAndPublicKeys:
3621       case aQuickKeygen:
3622       case aKeygen:
3623       case aImport:
3624       case aExportSecret:
3625       case aExportSecretSub:
3626       case aGenRevoke:
3627       case aDesigRevoke:
3628       case aCardEdit:
3629       case aChangePIN:
3630         migrate_secring (ctrl);
3631         break;
3632       case aListKeys:
3633         if (opt.with_secret)
3634           migrate_secring (ctrl);
3635         break;
3636       default:
3637         break;
3638       }
3639
3640     /* The command dispatcher.  */
3641     switch( cmd )
3642       {
3643       case aServer:
3644         gpg_server (ctrl);
3645         break;
3646
3647       case aStore: /* only store the file */
3648         if( argc > 1 )
3649             wrong_args(_("--store [filename]"));
3650         if( (rc = encrypt_store(fname)) )
3651             log_error ("storing '%s' failed: %s\n",
3652                        print_fname_stdin(fname),g10_errstr(rc) );
3653         break;
3654       case aSym: /* encrypt the given file only with the symmetric cipher */
3655         if( argc > 1 )
3656             wrong_args(_("--symmetric [filename]"));
3657         if( (rc = encrypt_symmetric(fname)) )
3658             log_error (_("symmetric encryption of '%s' failed: %s\n"),
3659                         print_fname_stdin(fname),g10_errstr(rc) );
3660         break;
3661
3662       case aEncr: /* encrypt the given file */
3663         if(multifile)
3664           encrypt_crypt_files (ctrl, argc, argv, remusr);
3665         else
3666           {
3667             if( argc > 1 )
3668               wrong_args(_("--encrypt [filename]"));
3669             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
3670               log_error("%s: encryption failed: %s\n",
3671                         print_fname_stdin(fname), g10_errstr(rc) );
3672           }
3673         break;
3674
3675       case aEncrSym:
3676         /* This works with PGP 8 in the sense that it acts just like a
3677            symmetric message.  It doesn't work at all with 2 or 6.  It
3678            might work with 7, but alas, I don't have a copy to test
3679            with right now. */
3680         if( argc > 1 )
3681           wrong_args(_("--symmetric --encrypt [filename]"));
3682         else if(opt.s2k_mode==0)
3683           log_error(_("you cannot use --symmetric --encrypt"
3684                       " with --s2k-mode 0\n"));
3685         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3686           log_error(_("you cannot use --symmetric --encrypt"
3687                       " while in %s mode\n"),compliance_option_string());
3688         else
3689           {
3690             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
3691               log_error("%s: encryption failed: %s\n",
3692                         print_fname_stdin(fname), g10_errstr(rc) );
3693           }
3694         break;
3695
3696       case aSign: /* sign the given file */
3697         sl = NULL;
3698         if( detached_sig ) { /* sign all files */
3699             for( ; argc; argc--, argv++ )
3700                 add_to_strlist( &sl, *argv );
3701         }
3702         else {
3703             if( argc > 1 )
3704                 wrong_args(_("--sign [filename]"));
3705             if( argc ) {
3706                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3707                 strcpy(sl->d, fname);
3708             }
3709         }
3710         if( (rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)) )
3711             log_error("signing failed: %s\n", g10_errstr(rc) );
3712         free_strlist(sl);
3713         break;
3714
3715       case aSignEncr: /* sign and encrypt the given file */
3716         if( argc > 1 )
3717             wrong_args(_("--sign --encrypt [filename]"));
3718         if( argc ) {
3719             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3720             strcpy(sl->d, fname);
3721         }
3722         else
3723             sl = NULL;
3724         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
3725             log_error("%s: sign+encrypt failed: %s\n",
3726                       print_fname_stdin(fname), g10_errstr(rc) );
3727         free_strlist(sl);
3728         break;
3729
3730       case aSignEncrSym: /* sign and encrypt the given file */
3731         if( argc > 1 )
3732             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3733         else if(opt.s2k_mode==0)
3734           log_error(_("you cannot use --symmetric --sign --encrypt"
3735                       " with --s2k-mode 0\n"));
3736         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3737           log_error(_("you cannot use --symmetric --sign --encrypt"
3738                       " while in %s mode\n"),compliance_option_string());
3739         else
3740           {
3741             if( argc )
3742               {
3743                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3744                 strcpy(sl->d, fname);
3745               }
3746             else
3747               sl = NULL;
3748             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
3749                                  2, remusr, NULL)))
3750               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3751                         print_fname_stdin(fname), g10_errstr(rc) );
3752             free_strlist(sl);
3753           }
3754         break;
3755
3756       case aSignSym: /* sign and conventionally encrypt the given file */
3757         if (argc > 1)
3758             wrong_args(_("--sign --symmetric [filename]"));
3759         rc = sign_symencrypt_file (fname, locusr);
3760         if (rc)
3761             log_error("%s: sign+symmetric failed: %s\n",
3762                       print_fname_stdin(fname), g10_errstr(rc) );
3763         break;
3764
3765       case aClearsign: /* make a clearsig */
3766         if( argc > 1 )
3767             wrong_args(_("--clearsign [filename]"));
3768         if( (rc = clearsign_file(fname, locusr, NULL)) )
3769             log_error("%s: clearsign failed: %s\n",
3770                       print_fname_stdin(fname), g10_errstr(rc) );
3771         break;
3772
3773       case aVerify:
3774         if (multifile)
3775           {
3776             if ((rc = verify_files (ctrl, argc, argv)))
3777               log_error("verify files failed: %s\n", g10_errstr(rc) );
3778           }
3779         else
3780           {
3781             if ((rc = verify_signatures (ctrl, argc, argv)))
3782               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3783           }
3784         break;
3785
3786       case aDecrypt:
3787         if (multifile)
3788           decrypt_messages (ctrl, argc, argv);
3789         else
3790           {
3791             if( argc > 1 )
3792               wrong_args(_("--decrypt [filename]"));
3793             if( (rc = decrypt_message (ctrl, fname) ))
3794               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3795           }
3796         break;
3797
3798       case aQuickSignKey:
3799       case aQuickLSignKey:
3800         {
3801           const char *fpr;
3802
3803           if (argc < 1)
3804             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
3805           fpr = *argv++; argc--;
3806           sl = NULL;
3807           for( ; argc; argc--, argv++)
3808             append_to_strlist2 (&sl, *argv, utf8_strings);
3809           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
3810           free_strlist (sl);
3811         }
3812         break;
3813
3814       case aSignKey:
3815         if( argc != 1 )
3816           wrong_args(_("--sign-key user-id"));
3817         /* fall through */
3818       case aLSignKey:
3819         if( argc != 1 )
3820           wrong_args(_("--lsign-key user-id"));
3821         /* fall through */
3822
3823         sl=NULL;
3824
3825         if(cmd==aSignKey)
3826           append_to_strlist(&sl,"sign");
3827         else if(cmd==aLSignKey)
3828           append_to_strlist(&sl,"lsign");
3829         else
3830           BUG();
3831
3832         append_to_strlist( &sl, "save" );
3833         username = make_username( fname );
3834         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
3835         xfree(username);
3836         free_strlist(sl);
3837         break;
3838
3839       case aEditKey: /* Edit a key signature */
3840         if( !argc )
3841             wrong_args(_("--edit-key user-id [commands]"));
3842         username = make_username( fname );
3843         if( argc > 1 ) {
3844             sl = NULL;
3845             for( argc--, argv++ ; argc; argc--, argv++ )
3846                 append_to_strlist( &sl, *argv );
3847             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
3848             free_strlist(sl);
3849         }
3850         else
3851             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
3852         xfree(username);
3853         break;
3854
3855       case aPasswd:
3856         if (argc != 1)
3857           wrong_args (_("--passwd <user-id>"));
3858         else
3859           {
3860             username = make_username (fname);
3861             keyedit_passwd (ctrl, username);
3862             xfree (username);
3863           }
3864         break;
3865
3866       case aDeleteKeys:
3867       case aDeleteSecretKeys:
3868       case aDeleteSecretAndPublicKeys:
3869         sl = NULL;
3870         /* I'm adding these in reverse order as add_to_strlist2
3871            reverses them again, and it's easier to understand in the
3872            proper order :) */
3873         for( ; argc; argc-- )
3874           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3875         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3876         free_strlist(sl);
3877         break;
3878
3879       case aCheckKeys:
3880         opt.check_sigs = 1;
3881       case aListSigs:
3882         opt.list_sigs = 1;
3883       case aListKeys:
3884         sl = NULL;
3885         for( ; argc; argc--, argv++ )
3886             add_to_strlist2( &sl, *argv, utf8_strings );
3887         public_key_list (ctrl, sl, 0);
3888         free_strlist(sl);
3889         break;
3890       case aListSecretKeys:
3891         sl = NULL;
3892         for( ; argc; argc--, argv++ )
3893             add_to_strlist2( &sl, *argv, utf8_strings );
3894         secret_key_list (ctrl, sl);
3895         free_strlist(sl);
3896         break;
3897       case aLocateKeys:
3898         sl = NULL;
3899         for (; argc; argc--, argv++)
3900           add_to_strlist2( &sl, *argv, utf8_strings );
3901         public_key_list (ctrl, sl, 1);
3902         free_strlist (sl);
3903         break;
3904
3905       case aQuickKeygen:
3906         if (argc != 1 )
3907           wrong_args("--gen-key user-id");
3908         username = make_username (fname);
3909         quick_generate_keypair (username);
3910         xfree (username);
3911         break;
3912
3913       case aKeygen: /* generate a key */
3914         if( opt.batch ) {
3915             if( argc > 1 )
3916                 wrong_args("--gen-key [parameterfile]");
3917             generate_keypair (ctrl, argc? *argv : NULL, NULL, 0);
3918         }
3919         else {
3920             if( argc )
3921                 wrong_args("--gen-key");
3922             generate_keypair (ctrl, NULL, NULL, 0);
3923         }
3924         break;
3925
3926       case aFastImport:
3927         opt.import_options |= IMPORT_FAST;
3928       case aImport:
3929         import_keys (ctrl, argc? argv:NULL, argc, NULL, opt.import_options);
3930         break;
3931
3932         /* TODO: There are a number of command that use this same
3933            "make strlist, call function, report error, free strlist"
3934            pattern.  Join them together here and avoid all that
3935            duplicated code. */
3936
3937       case aExport:
3938       case aSendKeys:
3939       case aRecvKeys:
3940         sl = NULL;
3941         for( ; argc; argc--, argv++ )
3942             append_to_strlist2( &sl, *argv, utf8_strings );
3943         if( cmd == aSendKeys )
3944             rc = keyserver_export (ctrl, sl );
3945         else if( cmd == aRecvKeys )
3946             rc = keyserver_import (ctrl, sl );
3947         else
3948             rc = export_pubkeys (ctrl, sl, opt.export_options);
3949         if(rc)
3950           {
3951             if(cmd==aSendKeys)
3952               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3953             else if(cmd==aRecvKeys)
3954               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3955             else
3956               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3957           }
3958         free_strlist(sl);
3959         break;
3960
3961      case aSearchKeys:
3962         sl = NULL;
3963         for (; argc; argc--, argv++)
3964           append_to_strlist2 (&sl, *argv, utf8_strings);
3965         rc = keyserver_search (ctrl, sl);
3966         if (rc)
3967           log_error (_("keyserver search failed: %s\n"), gpg_strerror (rc));
3968         free_strlist (sl);
3969         break;
3970
3971       case aRefreshKeys:
3972         sl = NULL;
3973         for( ; argc; argc--, argv++ )
3974             append_to_strlist2( &sl, *argv, utf8_strings );
3975         rc = keyserver_refresh (ctrl, sl);
3976         if(rc)
3977           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3978         free_strlist(sl);
3979         break;
3980
3981       case aFetchKeys:
3982         sl = NULL;
3983         for( ; argc; argc--, argv++ )
3984             append_to_strlist2( &sl, *argv, utf8_strings );
3985         rc = keyserver_fetch (ctrl, sl);
3986         if(rc)
3987           log_error("key fetch failed: %s\n",g10_errstr(rc));
3988         free_strlist(sl);
3989         break;
3990
3991       case aExportSecret:
3992         sl = NULL;
3993         for( ; argc; argc--, argv++ )
3994             add_to_strlist2( &sl, *argv, utf8_strings );
3995         export_seckeys (ctrl, sl);
3996         free_strlist(sl);
3997         break;
3998
3999       case aExportSecretSub:
4000         sl = NULL;
4001         for( ; argc; argc--, argv++ )
4002             add_to_strlist2( &sl, *argv, utf8_strings );
4003         export_secsubkeys (ctrl, sl);
4004         free_strlist(sl);
4005         break;
4006
4007       case aGenRevoke:
4008         if( argc != 1 )
4009             wrong_args("--gen-revoke user-id");
4010         username =  make_username(*argv);
4011         gen_revoke( username );
4012         xfree( username );
4013         break;
4014
4015       case aDesigRevoke:
4016         if( argc != 1 )
4017             wrong_args("--desig-revoke user-id");
4018         username =  make_username(*argv);
4019         gen_desig_revoke( username, locusr );
4020         xfree( username );
4021         break;
4022
4023       case aDeArmor:
4024         if( argc > 1 )
4025             wrong_args("--dearmor [file]");
4026         rc = dearmor_file( argc? *argv: NULL );
4027         if( rc )
4028             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
4029         break;
4030
4031       case aEnArmor:
4032         if( argc > 1 )
4033             wrong_args("--enarmor [file]");
4034         rc = enarmor_file( argc? *argv: NULL );
4035         if( rc )
4036             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
4037         break;
4038
4039
4040       case aPrimegen:
4041 #if 0 /*FIXME*/
4042         {   int mode = argc < 2 ? 0 : atoi(*argv);
4043
4044             if( mode == 1 && argc == 2 ) {
4045                 mpi_print (es_stdout,
4046                            generate_public_prime( atoi(argv[1]) ), 1);
4047             }
4048             else if( mode == 2 && argc == 3 ) {
4049                 mpi_print (es_stdout, generate_elg_prime(
4050                                              0, atoi(argv[1]),
4051                                              atoi(argv[2]), NULL,NULL ), 1);
4052             }
4053             else if( mode == 3 && argc == 3 ) {
4054                 MPI *factors;
4055                 mpi_print (es_stdout, generate_elg_prime(
4056                                              1, atoi(argv[1]),
4057                                              atoi(argv[2]), NULL,&factors ), 1);
4058                 putchar('\n');
4059                 mpi_print (es_stdout, factors[0], 1 ); /* print q */
4060             }
4061             else if( mode == 4 && argc == 3 ) {
4062                 MPI g = mpi_alloc(1);
4063                 mpi_print (es_stdout, generate_elg_prime(
4064                                                  0, atoi(argv[1]),
4065                                                  atoi(argv[2]), g, NULL ), 1);
4066                 putchar('\n');
4067                 mpi_print (es_stdout, g, 1 );
4068                 mpi_free (g);
4069             }
4070             else
4071                 wrong_args("--gen-prime mode bits [qbits] ");
4072             putchar('\n');
4073         }
4074 #endif
4075         wrong_args("--gen-prime not yet supported ");
4076         break;
4077
4078       case aGenRandom:
4079         {
4080             int level = argc ? atoi(*argv):0;
4081             int count = argc > 1 ? atoi(argv[1]): 0;
4082             int endless = !count;
4083
4084             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
4085                 wrong_args("--gen-random 0|1|2 [count]");
4086
4087             while( endless || count ) {
4088                 byte *p;
4089                 /* Wee need a multiple of 3, so that in case of
4090                    armored output we get a correct string.  No
4091                    linefolding is done, as it is best to levae this to
4092                    other tools */
4093                 size_t n = !endless && count < 99? count : 99;
4094
4095                 p = gcry_random_bytes (n, level);
4096 #ifdef HAVE_DOSISH_SYSTEM
4097                 setmode ( fileno(stdout), O_BINARY );
4098 #endif
4099                 if (opt.armor) {
4100                     char *tmp = make_radix64_string (p, n);
4101                     fputs (tmp, stdout);
4102                     xfree (tmp);
4103                     if (n%3 == 1)
4104                       putchar ('=');
4105                     if (n%3)
4106                       putchar ('=');
4107                 } else {
4108                     fwrite( p, n, 1, stdout );
4109                 }
4110                 xfree(p);
4111                 if( !endless )
4112                     count -= n;
4113             }
4114             if (opt.armor)
4115                 putchar ('\n');
4116         }
4117         break;
4118
4119       case aPrintMD:
4120         if( argc < 1)
4121             wrong_args("--print-md algo [files]");
4122         {
4123             int all_algos = (**argv=='*' && !(*argv)[1]);
4124             int algo = all_algos? 0 : gcry_md_map_name (*argv);
4125
4126             if( !algo && !all_algos )
4127                 log_error(_("invalid hash algorithm '%s'\n"), *argv );
4128             else {
4129                 argc--; argv++;
4130                 if( !argc )
4131                     print_mds(NULL, algo);
4132                 else {
4133                     for(; argc; argc--, argv++ )
4134                         print_mds(*argv, algo);
4135                 }
4136             }
4137         }
4138         break;
4139
4140       case aPrintMDs: /* old option */
4141         if( !argc )
4142             print_mds(NULL,0);
4143         else {
4144             for(; argc; argc--, argv++ )
4145                 print_mds(*argv,0);
4146         }
4147         break;
4148
4149 #ifndef NO_TRUST_MODELS
4150       case aListTrustDB:
4151         if( !argc )
4152             list_trustdb(NULL);
4153         else {
4154             for( ; argc; argc--, argv++ )
4155                 list_trustdb( *argv );
4156         }
4157         break;
4158
4159       case aUpdateTrustDB:
4160         if( argc )