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