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