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