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