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