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