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