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