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