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