gpg: New command --export-ssh-key
[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 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 #ifdef NO_TRUST_MODELS
2231     opt.trust_model = TM_ALWAYS;
2232 #else
2233     opt.trust_model = TM_AUTO;
2234 #endif
2235     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2236     opt.tofu_db_format = TOFU_DB_AUTO;
2237     opt.mangle_dos_filenames = 0;
2238     opt.min_cert_level = 2;
2239     set_screen_dimensions ();
2240     opt.keyid_format = KF_SHORT;
2241     opt.def_sig_expire = "0";
2242     opt.def_cert_expire = "0";
2243     set_homedir (default_homedir ());
2244     opt.passphrase_repeat = 1;
2245     opt.emit_version = 1; /* Limit to the major number.  */
2246     opt.weak_digests = NULL;
2247     additional_weak_digest("MD5");
2248
2249     /* Check whether we have a config file on the command line.  */
2250     orig_argc = argc;
2251     orig_argv = argv;
2252     pargs.argc = &argc;
2253     pargs.argv = &argv;
2254     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2255     while( arg_parse( &pargs, opts) ) {
2256         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2257             parse_debug++;
2258         else if (pargs.r_opt == oDebugIOLBF)
2259             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2260         else if( pargs.r_opt == oOptions ) {
2261             /* yes there is one, so we do not try the default one, but
2262              * read the option file when it is encountered at the commandline
2263              */
2264             default_config = 0;
2265         }
2266         else if( pargs.r_opt == oNoOptions )
2267           {
2268             default_config = 0; /* --no-options */
2269             opt.no_homedir_creation = 1;
2270           }
2271         else if( pargs.r_opt == oHomedir )
2272             set_homedir ( pargs.r.ret_str );
2273         else if( pargs.r_opt == oNoPermissionWarn )
2274             opt.no_perm_warn=1;
2275         else if (pargs.r_opt == oStrict )
2276           {
2277             /* Not used */
2278           }
2279         else if (pargs.r_opt == oNoStrict )
2280           {
2281             /* Not used */
2282           }
2283     }
2284
2285 #ifdef HAVE_DOSISH_SYSTEM
2286     if ( strchr (opt.homedir,'\\') ) {
2287         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2288         const char *s = opt.homedir;
2289         for (d=buf,s=opt.homedir; *s; s++)
2290           {
2291             *d++ = *s == '\\'? '/': *s;
2292 #ifdef HAVE_W32_SYSTEM
2293             if (s[1] && IsDBCSLeadByte (*s))
2294               *d++ = *++s;
2295 #endif
2296           }
2297         *d = 0;
2298         set_homedir (buf);
2299     }
2300 #endif
2301
2302     /* Initialize the secure memory. */
2303     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2304       got_secmem = 1;
2305 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2306     /* There should be no way to get to this spot while still carrying
2307        setuid privs.  Just in case, bomb out if we are. */
2308     if ( getuid () != geteuid () )
2309       BUG ();
2310 #endif
2311     maybe_setuid = 0;
2312
2313     /* Okay, we are now working under our real uid */
2314
2315     /* malloc hooks go here ... */
2316     malloc_hooks.malloc = gcry_malloc;
2317     malloc_hooks.realloc = gcry_realloc;
2318     malloc_hooks.free = gcry_free;
2319     assuan_set_malloc_hooks (&malloc_hooks);
2320     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2321     setup_libassuan_logging (&opt.debug);
2322
2323     /* Try for a version specific config file first */
2324     default_configname = get_default_configname ();
2325     if (default_config)
2326       configname = xstrdup (default_configname);
2327
2328     argc = orig_argc;
2329     argv = orig_argv;
2330     pargs.argc = &argc;
2331     pargs.argv = &argv;
2332     pargs.flags= ARGPARSE_FLAG_KEEP;
2333
2334     /* By this point we have a homedir, and cannot change it. */
2335     check_permissions(opt.homedir,0);
2336
2337   next_pass:
2338     if( configname ) {
2339       if(check_permissions(configname,1))
2340         {
2341           /* If any options file is unsafe, then disable any external
2342              programs for keyserver calls or photo IDs.  Since the
2343              external program to call is set in the options file, a
2344              unsafe options file can lead to an arbitrary program
2345              being run. */
2346
2347           opt.exec_disable=1;
2348         }
2349
2350         configlineno = 0;
2351         configfp = fopen( configname, "r" );
2352         if (configfp && is_secured_file (fileno (configfp)))
2353           {
2354             fclose (configfp);
2355             configfp = NULL;
2356             gpg_err_set_errno (EPERM);
2357           }
2358         if( !configfp ) {
2359             if( default_config ) {
2360                 if( parse_debug )
2361                     log_info(_("Note: no default option file '%s'\n"),
2362                                                             configname );
2363             }
2364             else {
2365                 log_error(_("option file '%s': %s\n"),
2366                                     configname, strerror(errno) );
2367                 g10_exit(2);
2368             }
2369             xfree(configname); configname = NULL;
2370         }
2371         if( parse_debug && configname )
2372             log_info(_("reading options from '%s'\n"), configname );
2373         default_config = 0;
2374     }
2375
2376     while( optfile_parse( configfp, configname, &configlineno,
2377                                                 &pargs, opts) )
2378       {
2379         switch( pargs.r_opt )
2380           {
2381           case aCheckKeys:
2382           case aListConfig:
2383           case aListGcryptConfig:
2384           case aGPGConfList:
2385           case aGPGConfTest:
2386           case aListPackets:
2387           case aImport:
2388           case aFastImport:
2389           case aSendKeys:
2390           case aRecvKeys:
2391           case aSearchKeys:
2392           case aRefreshKeys:
2393           case aFetchKeys:
2394           case aExport:
2395 #ifdef ENABLE_CARD_SUPPORT
2396           case aCardStatus:
2397           case aCardEdit:
2398           case aChangePIN:
2399 #endif /* ENABLE_CARD_SUPPORT*/
2400           case aListKeys:
2401           case aLocateKeys:
2402           case aListSigs:
2403           case aExportSecret:
2404           case aExportSecretSub:
2405           case aExportSshKey:
2406           case aSym:
2407           case aClearsign:
2408           case aGenRevoke:
2409           case aDesigRevoke:
2410           case aPrimegen:
2411           case aGenRandom:
2412           case aPrintMD:
2413           case aPrintMDs:
2414           case aListTrustDB:
2415           case aCheckTrustDB:
2416           case aUpdateTrustDB:
2417           case aFixTrustDB:
2418           case aListTrustPath:
2419           case aDeArmor:
2420           case aEnArmor:
2421           case aSign:
2422           case aQuickSignKey:
2423           case aQuickLSignKey:
2424           case aSignKey:
2425           case aLSignKey:
2426           case aStore:
2427           case aQuickKeygen:
2428           case aQuickAddUid:
2429           case aExportOwnerTrust:
2430           case aImportOwnerTrust:
2431           case aRebuildKeydbCaches:
2432             set_cmd (&cmd, pargs.r_opt);
2433             break;
2434
2435           case aKeygen:
2436           case aFullKeygen:
2437           case aEditKey:
2438           case aDeleteSecretKeys:
2439           case aDeleteSecretAndPublicKeys:
2440           case aDeleteKeys:
2441           case aPasswd:
2442             set_cmd (&cmd, pargs.r_opt);
2443             greeting=1;
2444             break;
2445
2446           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2447
2448           case aDecryptFiles: multifile=1; /* fall through */
2449           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2450
2451           case aEncrFiles: multifile=1; /* fall through */
2452           case aEncr: set_cmd( &cmd, aEncr); break;
2453
2454           case aVerifyFiles: multifile=1; /* fall through */
2455           case aVerify: set_cmd( &cmd, aVerify); break;
2456
2457           case aServer:
2458             set_cmd (&cmd, pargs.r_opt);
2459             opt.batch = 1;
2460             break;
2461
2462           case aTOFUPolicy:
2463             set_cmd (&cmd, pargs.r_opt);
2464             break;
2465
2466           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2467           case oOutput: opt.outfile = pargs.r.ret_str; break;
2468           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2469           case oQuiet: opt.quiet = 1; break;
2470           case oNoTTY: tty_no_terminal(1); break;
2471           case oDryRun: opt.dry_run = 1; break;
2472           case oInteractive: opt.interactive = 1; break;
2473           case oVerbose:
2474             opt.verbose++;
2475             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2476             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2477             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2478             break;
2479
2480           case oBatch:
2481             opt.batch = 1;
2482             nogreeting = 1;
2483             break;
2484
2485           case oUseAgent: /* Dummy. */
2486             break;
2487
2488           case oNoUseAgent:
2489             obsolete_option (configname, configlineno, "no-use-agent");
2490             break;
2491           case oGpgAgentInfo:
2492             obsolete_option (configname, configlineno, "gpg-agent-info");
2493             break;
2494           case oReaderPort:
2495             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2496             break;
2497           case octapiDriver:
2498             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2499             break;
2500           case opcscDriver:
2501             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2502             break;
2503           case oDisableCCID:
2504             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2505             break;
2506           case oHonorHttpProxy:
2507             obsolete_option (configname, configlineno, "honor-http-proxy");
2508             break;
2509
2510           case oAnswerYes: opt.answer_yes = 1; break;
2511           case oAnswerNo: opt.answer_no = 1; break;
2512           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2513           case oPrimaryKeyring:
2514             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2515             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2516             break;
2517           case oShowKeyring:
2518             deprecated_warning(configname,configlineno,"--show-keyring",
2519                                "--list-options ","show-keyring");
2520             opt.list_options|=LIST_SHOW_KEYRING;
2521             break;
2522
2523           case oDebug:
2524             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2525               {
2526                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2527                 pargs.err = ARGPARSE_PRINT_ERROR;
2528               }
2529             break;
2530
2531           case oDebugAll: opt.debug = ~0; break;
2532           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2533
2534           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2535
2536           case oStatusFD:
2537             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2538             break;
2539           case oStatusFile:
2540             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2541             break;
2542           case oAttributeFD:
2543             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2544             break;
2545           case oAttributeFile:
2546             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2547             break;
2548           case oLoggerFD:
2549             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2550             break;
2551           case oLoggerFile:
2552             logfile = pargs.r.ret_str;
2553             break;
2554
2555           case oWithFingerprint:
2556             opt.with_fingerprint = 1;
2557             opt.fingerprint++;
2558             break;
2559           case oWithICAOSpelling:
2560             opt.with_icao_spelling = 1;
2561             break;
2562           case oFingerprint:
2563             opt.fingerprint++;
2564             fpr_maybe_cmd = 1;
2565             break;
2566
2567           case oWithKeygrip:
2568             opt.with_keygrip = 1;
2569             break;
2570
2571           case oWithSecret:
2572             opt.with_secret = 1;
2573             break;
2574
2575           case oSecretKeyring:
2576             /* Ignore this old option.  */
2577             break;
2578
2579           case oOptions:
2580             /* config files may not be nested (silently ignore them) */
2581             if( !configfp ) {
2582                 xfree(configname);
2583                 configname = xstrdup(pargs.r.ret_str);
2584                 goto next_pass;
2585             }
2586             break;
2587           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2588           case oNoDefKeyring: default_keyring = 0; break;
2589           case oNoGreeting: nogreeting = 1; break;
2590           case oNoVerbose:
2591             opt.verbose = 0;
2592             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2593             opt.list_sigs=0;
2594             break;
2595           case oQuickRandom:
2596             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2597             break;
2598           case oEmitVersion: opt.emit_version++; break;
2599           case oNoEmitVersion: opt.emit_version=0; break;
2600           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2601           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2602           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2603
2604 #ifndef NO_TRUST_MODELS
2605           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2606
2607 #endif /*!NO_TRUST_MODELS*/
2608           case oDefaultKey:
2609             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2610             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2611             if (configfp)
2612               sl->flags |= PK_LIST_CONFIG;
2613             break;
2614           case oDefRecipient:
2615             if( *pargs.r.ret_str )
2616               {
2617                 xfree (opt.def_recipient);
2618                 opt.def_recipient = make_username(pargs.r.ret_str);
2619               }
2620             break;
2621           case oDefRecipientSelf:
2622             xfree(opt.def_recipient); opt.def_recipient = NULL;
2623             opt.def_recipient_self = 1;
2624             break;
2625           case oNoDefRecipient:
2626             xfree(opt.def_recipient); opt.def_recipient = NULL;
2627             opt.def_recipient_self = 0;
2628             break;
2629           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2630           case oHomedir: break;
2631           case oNoBatch: opt.batch = 0; break;
2632
2633           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2634           case oWithColons: opt.with_colons=':'; break;
2635
2636           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2637           case oWithSigList: opt.list_sigs = 1; break;
2638
2639           case oSkipVerify: opt.skip_verify=1; break;
2640
2641           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2642           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2643
2644           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2645
2646 #ifndef NO_TRUST_MODELS
2647             /* There are many programs (like mutt) that call gpg with
2648                --always-trust so keep this option around for a long
2649                time. */
2650           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2651           case oTrustModel:
2652             parse_trust_model(pargs.r.ret_str);
2653             break;
2654 #endif /*!NO_TRUST_MODELS*/
2655           case oTOFUDefaultPolicy:
2656             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2657             break;
2658           case oTOFUDBFormat:
2659             opt.tofu_db_format = parse_tofu_db_format (pargs.r.ret_str);
2660             break;
2661
2662           case oForceOwnertrust:
2663             log_info(_("Note: %s is not for normal use!\n"),
2664                      "--force-ownertrust");
2665             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2666             if(opt.force_ownertrust==-1)
2667               {
2668                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2669                 opt.force_ownertrust=0;
2670               }
2671             break;
2672           case oLoadExtension:
2673             /* Dummy so that gpg 1.4 conf files can work. Should
2674                eventually be removed.  */
2675             break;
2676           case oOpenPGP:
2677           case oRFC4880:
2678             /* This is effectively the same as RFC2440, but with
2679                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2680                --require-cross-certification". */
2681             opt.compliance = CO_RFC4880;
2682             opt.flags.dsa2 = 1;
2683             opt.flags.require_cross_cert = 1;
2684             opt.rfc2440_text = 0;
2685             opt.allow_non_selfsigned_uid = 1;
2686             opt.allow_freeform_uid = 1;
2687             opt.escape_from = 1;
2688             opt.not_dash_escaped = 0;
2689             opt.def_cipher_algo = 0;
2690             opt.def_digest_algo = 0;
2691             opt.cert_digest_algo = 0;
2692             opt.compress_algo = -1;
2693             opt.s2k_mode = 3; /* iterated+salted */
2694             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2695             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2696             break;
2697           case oRFC2440:
2698             opt.compliance = CO_RFC2440;
2699             opt.flags.dsa2 = 0;
2700             opt.rfc2440_text = 1;
2701             opt.allow_non_selfsigned_uid = 1;
2702             opt.allow_freeform_uid = 1;
2703             opt.escape_from = 0;
2704             opt.not_dash_escaped = 0;
2705             opt.def_cipher_algo = 0;
2706             opt.def_digest_algo = 0;
2707             opt.cert_digest_algo = 0;
2708             opt.compress_algo = -1;
2709             opt.s2k_mode = 3; /* iterated+salted */
2710             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2711             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2712             break;
2713           case oPGP6:  opt.compliance = CO_PGP6;  break;
2714           case oPGP7:  opt.compliance = CO_PGP7;  break;
2715           case oPGP8:  opt.compliance = CO_PGP8;  break;
2716           case oGnuPG: opt.compliance = CO_GNUPG; break;
2717           case oRFC2440Text: opt.rfc2440_text=1; break;
2718           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2719           case oSetFilename:
2720             if(utf8_strings)
2721               opt.set_filename = pargs.r.ret_str;
2722             else
2723               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2724             break;
2725           case oForYourEyesOnly: eyes_only = 1; break;
2726           case oNoForYourEyesOnly: eyes_only = 0; break;
2727           case oSetPolicyURL:
2728             add_policy_url(pargs.r.ret_str,0);
2729             add_policy_url(pargs.r.ret_str,1);
2730             break;
2731           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2732           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2733           case oShowPolicyURL:
2734             deprecated_warning(configname,configlineno,"--show-policy-url",
2735                                "--list-options ","show-policy-urls");
2736             deprecated_warning(configname,configlineno,"--show-policy-url",
2737                                "--verify-options ","show-policy-urls");
2738             opt.list_options|=LIST_SHOW_POLICY_URLS;
2739             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2740             break;
2741           case oNoShowPolicyURL:
2742             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2743                                "--list-options ","no-show-policy-urls");
2744             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2745                                "--verify-options ","no-show-policy-urls");
2746             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2747             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2748             break;
2749           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2750           case oUseEmbeddedFilename:
2751             opt.flags.use_embedded_filename=1;
2752             break;
2753           case oNoUseEmbeddedFilename:
2754             opt.flags.use_embedded_filename=0;
2755             break;
2756           case oComment:
2757             if(pargs.r.ret_str[0])
2758               append_to_strlist(&opt.comments,pargs.r.ret_str);
2759             break;
2760           case oDefaultComment:
2761             deprecated_warning(configname,configlineno,
2762                                "--default-comment","--no-comments","");
2763             /* fall through */
2764           case oNoComments:
2765             free_strlist(opt.comments);
2766             opt.comments=NULL;
2767             break;
2768           case oThrowKeyids: opt.throw_keyids = 1; break;
2769           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2770           case oShowPhotos:
2771             deprecated_warning(configname,configlineno,"--show-photos",
2772                                "--list-options ","show-photos");
2773             deprecated_warning(configname,configlineno,"--show-photos",
2774                                "--verify-options ","show-photos");
2775             opt.list_options|=LIST_SHOW_PHOTOS;
2776             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2777             break;
2778           case oNoShowPhotos:
2779             deprecated_warning(configname,configlineno,"--no-show-photos",
2780                                "--list-options ","no-show-photos");
2781             deprecated_warning(configname,configlineno,"--no-show-photos",
2782                                "--verify-options ","no-show-photos");
2783             opt.list_options&=~LIST_SHOW_PHOTOS;
2784             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2785             break;
2786           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2787
2788           case oForceMDC: opt.force_mdc = 1; break;
2789           case oNoForceMDC: opt.force_mdc = 0; break;
2790           case oDisableMDC: opt.disable_mdc = 1; break;
2791           case oNoDisableMDC: opt.disable_mdc = 0; break;
2792           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2793           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2794           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2795           case oS2KCount:
2796             if (pargs.r.ret_int)
2797               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2798             else
2799               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2800             break;
2801           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2802           case oEncryptTo: /* store the recipient in the second list */
2803             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2804             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
2805             if (configfp)
2806               sl->flags |= PK_LIST_CONFIG;
2807             break;
2808           case oHiddenEncryptTo: /* store the recipient in the second list */
2809             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2810             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT)
2811                          | PK_LIST_ENCRYPT_TO|PK_LIST_HIDDEN);
2812             if (configfp)
2813               sl->flags |= PK_LIST_CONFIG;
2814             break;
2815           case oEncryptToDefaultKey:
2816             opt.encrypt_to_default_key = configfp ? 2 : 1;
2817             break;
2818           case oRecipient: /* store the recipient */
2819             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2820             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2821             if (configfp)
2822               sl->flags |= PK_LIST_CONFIG;
2823             any_explicit_recipient = 1;
2824             break;
2825           case oHiddenRecipient: /* store the recipient with a flag */
2826             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2827             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_HIDDEN);
2828             if (configfp)
2829               sl->flags |= PK_LIST_CONFIG;
2830             any_explicit_recipient = 1;
2831             break;
2832
2833           case oTrySecretKey:
2834             add_to_strlist2 (&opt.secret_keys_to_try,
2835                              pargs.r.ret_str, utf8_strings);
2836             break;
2837
2838           case oTextmodeShort: opt.textmode = 2; break;
2839           case oTextmode: opt.textmode=1;  break;
2840           case oNoTextmode: opt.textmode=0;  break;
2841           case oExpert: opt.expert = 1; break;
2842           case oNoExpert: opt.expert = 0; break;
2843           case oDefSigExpire:
2844             if(*pargs.r.ret_str!='\0')
2845               {
2846                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2847                   log_error(_("'%s' is not a valid signature expiration\n"),
2848                             pargs.r.ret_str);
2849                 else
2850                   opt.def_sig_expire=pargs.r.ret_str;
2851               }
2852             break;
2853           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2854           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2855           case oDefCertExpire:
2856             if(*pargs.r.ret_str!='\0')
2857               {
2858                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2859                   log_error(_("'%s' is not a valid signature expiration\n"),
2860                             pargs.r.ret_str);
2861                 else
2862                   opt.def_cert_expire=pargs.r.ret_str;
2863               }
2864             break;
2865           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2866           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2867           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2868           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2869           case oAskCertLevel: opt.ask_cert_level = 1; break;
2870           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2871           case oLocalUser: /* store the local users */
2872             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2873             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2874             if (configfp)
2875               sl->flags |= PK_LIST_CONFIG;
2876             break;
2877           case oCompress:
2878             /* this is the -z command line option */
2879             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2880             break;
2881           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2882           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2883           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2884           case oPassphrase:
2885             set_passphrase_from_string(pargs.r.ret_str);
2886             break;
2887           case oPassphraseFD:
2888             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2889             break;
2890           case oPassphraseFile:
2891             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
2892             break;
2893           case oPassphraseRepeat:
2894             opt.passphrase_repeat = pargs.r.ret_int;
2895             break;
2896
2897           case oPinentryMode:
2898             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
2899             if (opt.pinentry_mode == -1)
2900               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
2901             break;
2902
2903           case oCommandFD:
2904             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2905             break;
2906           case oCommandFile:
2907             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
2908             break;
2909           case oCipherAlgo:
2910             def_cipher_string = xstrdup(pargs.r.ret_str);
2911             break;
2912           case oDigestAlgo:
2913             def_digest_string = xstrdup(pargs.r.ret_str);
2914             break;
2915           case oCompressAlgo:
2916             /* If it is all digits, stick a Z in front of it for
2917                later.  This is for backwards compatibility with
2918                versions that took the compress algorithm number. */
2919             {
2920               char *pt=pargs.r.ret_str;
2921               while(*pt)
2922                 {
2923                   if (!isascii (*pt) || !isdigit (*pt))
2924                     break;
2925
2926                   pt++;
2927                 }
2928
2929               if(*pt=='\0')
2930                 {
2931                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2932                   strcpy(compress_algo_string,"Z");
2933                   strcat(compress_algo_string,pargs.r.ret_str);
2934                 }
2935               else
2936                 compress_algo_string = xstrdup(pargs.r.ret_str);
2937             }
2938             break;
2939           case oCertDigestAlgo:
2940             cert_digest_string = xstrdup(pargs.r.ret_str);
2941             break;
2942
2943           case oNoSecmemWarn:
2944             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
2945             break;
2946
2947           case oRequireSecmem: require_secmem=1; break;
2948           case oNoRequireSecmem: require_secmem=0; break;
2949           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2950           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2951           case oDisplayCharset:
2952             if( set_native_charset( pargs.r.ret_str ) )
2953                 log_error(_("'%s' is not a valid character set\n"),
2954                           pargs.r.ret_str);
2955             break;
2956           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2957           case oEscapeFrom: opt.escape_from = 1; break;
2958           case oNoEscapeFrom: opt.escape_from = 0; break;
2959           case oLockOnce: opt.lock_once = 1; break;
2960           case oLockNever:
2961             dotlock_disable ();
2962             break;
2963           case oLockMultiple:
2964 #ifndef __riscos__
2965             opt.lock_once = 0;
2966 #else /* __riscos__ */
2967             riscos_not_implemented("lock-multiple");
2968 #endif /* __riscos__ */
2969             break;
2970           case oKeyServer:
2971             {
2972               keyserver_spec_t keyserver;
2973               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
2974               if (!keyserver)
2975                 log_error (_("could not parse keyserver URL\n"));
2976               else
2977                 {
2978                   /* We only support a single keyserver.  Later ones
2979                      override earlier ones.  (Since we parse the
2980                      config file first and then the command line
2981                      arguments, the command line takes
2982                      precedence.)  */
2983                   if (opt.keyserver)
2984                     free_keyserver_spec (opt.keyserver);
2985                   opt.keyserver = keyserver;
2986                 }
2987             }
2988             break;
2989           case oKeyServerOptions:
2990             if(!parse_keyserver_options(pargs.r.ret_str))
2991               {
2992                 if(configname)
2993                   log_error(_("%s:%d: invalid keyserver options\n"),
2994                             configname,configlineno);
2995                 else
2996                   log_error(_("invalid keyserver options\n"));
2997               }
2998             break;
2999           case oImportOptions:
3000             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3001               {
3002                 if(configname)
3003                   log_error(_("%s:%d: invalid import options\n"),
3004                             configname,configlineno);
3005                 else
3006                   log_error(_("invalid import options\n"));
3007               }
3008             break;
3009           case oExportOptions:
3010             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3011               {
3012                 if(configname)
3013                   log_error(_("%s:%d: invalid export options\n"),
3014                             configname,configlineno);
3015                 else
3016                   log_error(_("invalid export options\n"));
3017               }
3018             break;
3019           case oListOptions:
3020             if(!parse_list_options(pargs.r.ret_str))
3021               {
3022                 if(configname)
3023                   log_error(_("%s:%d: invalid list options\n"),
3024                             configname,configlineno);
3025                 else
3026                   log_error(_("invalid list options\n"));
3027               }
3028             break;
3029           case oVerifyOptions:
3030             {
3031               struct parse_options vopts[]=
3032                 {
3033                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3034                    N_("display photo IDs during signature verification")},
3035                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3036                    N_("show policy URLs during signature verification")},
3037                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3038                    N_("show all notations during signature verification")},
3039                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3040                    N_("show IETF standard notations during signature verification")},
3041                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3042                    NULL},
3043                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3044                    N_("show user-supplied notations during signature verification")},
3045                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3046                    N_("show preferred keyserver URLs during signature verification")},
3047                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3048                    N_("show user ID validity during signature verification")},
3049                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3050                    N_("show revoked and expired user IDs in signature verification")},
3051                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3052                    N_("show only the primary user ID in signature verification")},
3053                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3054                    N_("validate signatures with PKA data")},
3055                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3056                    N_("elevate the trust of signatures with valid PKA data")},
3057                   {NULL,0,NULL,NULL}
3058                 };
3059
3060               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3061                 {
3062                   if(configname)
3063                     log_error(_("%s:%d: invalid verify options\n"),
3064                               configname,configlineno);
3065                   else
3066                     log_error(_("invalid verify options\n"));
3067                 }
3068             }
3069             break;
3070           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3071           case oExecPath:
3072             if(set_exec_path(pargs.r.ret_str))
3073               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3074             else
3075               opt.exec_path_set=1;
3076             break;
3077           case oSetNotation:
3078             add_notation_data( pargs.r.ret_str, 0 );
3079             add_notation_data( pargs.r.ret_str, 1 );
3080             break;
3081           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3082           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3083           case oShowNotation:
3084             deprecated_warning(configname,configlineno,"--show-notation",
3085                                "--list-options ","show-notations");
3086             deprecated_warning(configname,configlineno,"--show-notation",
3087                                "--verify-options ","show-notations");
3088             opt.list_options|=LIST_SHOW_NOTATIONS;
3089             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3090             break;
3091           case oNoShowNotation:
3092             deprecated_warning(configname,configlineno,"--no-show-notation",
3093                                "--list-options ","no-show-notations");
3094             deprecated_warning(configname,configlineno,"--no-show-notation",
3095                                "--verify-options ","no-show-notations");
3096             opt.list_options&=~LIST_SHOW_NOTATIONS;
3097             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3098             break;
3099           case oUtf8Strings: utf8_strings = 1; break;
3100           case oNoUtf8Strings: utf8_strings = 0; break;
3101           case oDisableCipherAlgo:
3102             {
3103               int algo = string_to_cipher_algo (pargs.r.ret_str);
3104               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3105             }
3106             break;
3107           case oDisablePubkeyAlgo:
3108             {
3109               int algo = gcry_pk_map_name (pargs.r.ret_str);
3110               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3111             }
3112             break;
3113           case oNoSigCache: opt.no_sig_cache = 1; break;
3114           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3115           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3116           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3117           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3118           case oNoLiteral: opt.no_literal = 1; break;
3119           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3120           case oFastListMode: opt.fast_list_mode = 1; break;
3121           case oFixedListMode: /* Dummy */ break;
3122           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3123           case oPrintPKARecords: opt.print_pka_records = 1; break;
3124           case oPrintDANERecords: opt.print_dane_records = 1; break;
3125           case oListOnly: opt.list_only=1; break;
3126           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3127           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3128           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3129           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3130           case oNoRandomSeedFile: use_random_seed = 0; break;
3131           case oAutoKeyRetrieve:
3132           case oNoAutoKeyRetrieve:
3133                 if(pargs.r_opt==oAutoKeyRetrieve)
3134                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
3135                 else
3136                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
3137
3138                 deprecated_warning(configname,configlineno,
3139                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
3140                                "--no-auto-key-retrieve","--keyserver-options ",
3141                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
3142                                "no-auto-key-retrieve");
3143                 break;
3144           case oShowSessionKey: opt.show_session_key = 1; break;
3145           case oOverrideSessionKey:
3146                 opt.override_session_key = pargs.r.ret_str;
3147                 break;
3148           case oMergeOnly:
3149                 deprecated_warning(configname,configlineno,"--merge-only",
3150                                    "--import-options ","merge-only");
3151                 opt.import_options|=IMPORT_MERGE_ONLY;
3152             break;
3153           case oAllowSecretKeyImport: /* obsolete */ break;
3154           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3155           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3156           case oEnableSpecialFilenames:
3157             iobuf_enable_special_filenames (1);
3158             break;
3159           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3160           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3161           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3162           case oPreservePermissions: opt.preserve_permissions=1; break;
3163           case oDefaultPreferenceList:
3164             opt.def_preference_list = pargs.r.ret_str;
3165             break;
3166           case oDefaultKeyserverURL:
3167             {
3168               keyserver_spec_t keyserver;
3169               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3170               if (!keyserver)
3171                 log_error (_("could not parse keyserver URL\n"));
3172               else
3173                 free_keyserver_spec (keyserver);
3174
3175               opt.def_keyserver_url = pargs.r.ret_str;
3176             }
3177             break;
3178           case oPersonalCipherPreferences:
3179             pers_cipher_list=pargs.r.ret_str;
3180             break;
3181           case oPersonalDigestPreferences:
3182             pers_digest_list=pargs.r.ret_str;
3183             break;
3184           case oPersonalCompressPreferences:
3185             pers_compress_list=pargs.r.ret_str;
3186             break;
3187           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3188           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3189           case oWeakDigest:
3190             additional_weak_digest(pargs.r.ret_str);
3191             break;
3192           case oUnwrap:
3193             opt.unwrap_encryption = 1;
3194             break;
3195           case oOnlySignTextIDs:
3196             opt.only_sign_text_ids = 1;
3197             break;
3198
3199           case oDisplay:
3200             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3201             break;
3202           case oTTYname:
3203             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3204             break;
3205           case oTTYtype:
3206             set_opt_session_env ("TERM", pargs.r.ret_str);
3207             break;
3208           case oXauthority:
3209             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3210             break;
3211
3212           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3213           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3214
3215           case oGroup: add_group(pargs.r.ret_str); break;
3216           case oUnGroup: rm_group(pargs.r.ret_str); break;
3217           case oNoGroups:
3218             while(opt.grouplist)
3219               {
3220                 struct groupitem *iter=opt.grouplist;
3221                 free_strlist(iter->values);
3222                 opt.grouplist=opt.grouplist->next;
3223                 xfree(iter);
3224               }
3225             break;
3226
3227           case oStrict:
3228           case oNoStrict:
3229             /* Not used */
3230             break;
3231
3232           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3233           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3234           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3235           case oMultifile: multifile=1; break;
3236           case oKeyidFormat:
3237             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3238               opt.keyid_format=KF_SHORT;
3239             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3240               opt.keyid_format=KF_LONG;
3241             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3242               opt.keyid_format=KF_0xSHORT;
3243             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3244               opt.keyid_format=KF_0xLONG;
3245             else
3246               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3247             break;
3248
3249           case oExitOnStatusWriteError:
3250             opt.exit_on_status_write_error = 1;
3251             break;
3252
3253           case oLimitCardInsertTries:
3254             opt.limit_card_insert_tries = pargs.r.ret_int;
3255             break;
3256
3257           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3258           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3259
3260           case oAutoKeyLocate:
3261             if(!parse_auto_key_locate(pargs.r.ret_str))
3262               {
3263                 if(configname)
3264                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3265                             configname,configlineno);
3266                 else
3267                   log_error(_("invalid auto-key-locate list\n"));
3268               }
3269             break;
3270           case oNoAutoKeyLocate:
3271             release_akl();
3272             break;
3273
3274           case oEnableLargeRSA:
3275 #if SECMEM_BUFFER_SIZE >= 65536
3276             opt.flags.large_rsa=1;
3277 #else
3278             if (configname)
3279               log_info("%s:%d: WARNING: gpg not built with large secure "
3280                          "memory buffer.  Ignoring enable-large-rsa\n",
3281                         configname,configlineno);
3282             else
3283               log_info("WARNING: gpg not built with large secure "
3284                          "memory buffer.  Ignoring --enable-large-rsa\n");
3285 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3286             break;
3287           case oDisableLargeRSA: opt.flags.large_rsa=0;
3288             break;
3289
3290           case oEnableDSA2: opt.flags.dsa2=1; break;
3291           case oDisableDSA2: opt.flags.dsa2=0; break;
3292
3293           case oAllowMultisigVerification:
3294           case oAllowMultipleMessages:
3295             opt.flags.allow_multiple_messages=1;
3296             break;
3297
3298           case oNoAllowMultipleMessages:
3299             opt.flags.allow_multiple_messages=0;
3300             break;
3301
3302           case oAllowWeakDigestAlgos:
3303             opt.flags.allow_weak_digest_algos = 1;
3304             break;
3305
3306           case oFakedSystemTime:
3307             {
3308               time_t faked_time = isotime2epoch (pargs.r.ret_str);
3309               if (faked_time == (time_t)(-1))
3310                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3311               gnupg_set_time (faked_time, 0);
3312             }
3313             break;
3314
3315           case oNoAutostart: opt.autostart = 0; break;
3316
3317           case oNoop: break;
3318
3319           default:
3320             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3321             break;
3322           }
3323       }
3324
3325     if (configfp)
3326       {
3327         fclose( configfp );
3328         configfp = NULL;
3329         /* Remember the first config file name. */
3330         if (!save_configname)
3331           save_configname = configname;
3332         else
3333           xfree(configname);
3334         configname = NULL;
3335         goto next_pass;
3336       }
3337     xfree(configname); configname = NULL;
3338     if (log_get_errorcount (0))
3339       g10_exit(2);
3340
3341     /* The command --gpgconf-list is pretty simple and may be called
3342        directly after the option parsing. */
3343     if (cmd == aGPGConfList)
3344       {
3345         gpgconf_list (save_configname ? save_configname : default_configname);
3346         g10_exit (0);
3347       }
3348     xfree (save_configname);
3349     xfree (default_configname);
3350
3351     if( nogreeting )
3352         greeting = 0;
3353
3354     if( greeting )
3355       {
3356         es_fprintf (es_stderr, "%s %s; %s\n",
3357                     strusage(11), strusage(13), strusage(14) );
3358         es_fprintf (es_stderr, "%s\n", strusage(15) );
3359       }
3360 #ifdef IS_DEVELOPMENT_VERSION
3361     if (!opt.batch)
3362       {
3363         const char *s;
3364
3365         if((s=strusage(25)))
3366           log_info("%s\n",s);
3367         if((s=strusage(26)))
3368           log_info("%s\n",s);
3369         if((s=strusage(27)))
3370           log_info("%s\n",s);
3371       }
3372 #endif
3373
3374     /* FIXME: We should use logging to a file only in server mode;
3375        however we have not yet implemetyed that.  Thus we try to get
3376        away with --batch as indication for logging to file
3377        required. */
3378     if (logfile && opt.batch)
3379       {
3380         log_set_file (logfile);
3381         log_set_prefix (NULL, 1|2|4);
3382       }
3383
3384     if (opt.verbose > 2)
3385         log_info ("using character set '%s'\n", get_native_charset ());
3386
3387     if( may_coredump && !opt.quiet )
3388         log_info(_("WARNING: program may create a core file!\n"));
3389
3390     if (eyes_only) {
3391       if (opt.set_filename)
3392           log_info(_("WARNING: %s overrides %s\n"),
3393                    "--for-your-eyes-only","--set-filename");
3394
3395       opt.set_filename="_CONSOLE";
3396     }
3397
3398     if (opt.no_literal) {
3399         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3400         if (opt.textmode)
3401             log_error(_("%s not allowed with %s!\n"),
3402                        "--textmode", "--no-literal" );
3403         if (opt.set_filename)
3404             log_error(_("%s makes no sense with %s!\n"),
3405                         eyes_only?"--for-your-eyes-only":"--set-filename",
3406                         "--no-literal" );
3407     }
3408
3409
3410     if (opt.set_filesize)
3411         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3412     if( opt.batch )
3413         tty_batchmode( 1 );
3414
3415     if (gnupg_faked_time_p ())
3416       {
3417         gnupg_isotime_t tbuf;
3418
3419         log_info (_("WARNING: running with faked system time: "));
3420         gnupg_get_isotime (tbuf);
3421         dump_isotime (tbuf);
3422         log_printf ("\n");
3423       }
3424
3425     /* Print a warning if an argument looks like an option.  */
3426     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3427       {
3428         int i;
3429
3430         for (i=0; i < argc; i++)
3431           if (argv[i][0] == '-' && argv[i][1] == '-')
3432             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3433       }
3434
3435
3436     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3437
3438     if(require_secmem && !got_secmem)
3439       {
3440         log_info(_("will not run with insecure memory due to %s\n"),
3441                  "--require-secmem");
3442         g10_exit(2);
3443       }
3444
3445     set_debug (debug_level);
3446     if (DBG_CLOCK)
3447       log_clock ("start");
3448
3449     /* Do these after the switch(), so they can override settings. */
3450     if(PGP6)
3451       {
3452         /* That does not anymore work because we have no more support
3453            for v3 signatures.  */
3454         opt.disable_mdc=1;
3455         opt.escape_from=1;
3456         opt.ask_sig_expire=0;
3457       }
3458     else if(PGP7)
3459       {
3460         /* That does not anymore work because we have no more support
3461            for v3 signatures.  */
3462         opt.escape_from=1;
3463         opt.ask_sig_expire=0;
3464       }
3465     else if(PGP8)
3466       {
3467         opt.escape_from=1;
3468       }
3469
3470
3471     if( def_cipher_string ) {
3472         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3473         xfree(def_cipher_string); def_cipher_string = NULL;
3474         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3475             log_error(_("selected cipher algorithm is invalid\n"));
3476     }
3477     if( def_digest_string ) {
3478         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3479         xfree(def_digest_string); def_digest_string = NULL;
3480         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3481             log_error(_("selected digest algorithm is invalid\n"));
3482     }
3483     if( compress_algo_string ) {
3484         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3485         xfree(compress_algo_string); compress_algo_string = NULL;
3486         if( check_compress_algo(opt.compress_algo) )
3487           log_error(_("selected compression algorithm is invalid\n"));
3488     }
3489     if( cert_digest_string ) {
3490         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3491         xfree(cert_digest_string); cert_digest_string = NULL;
3492         if (openpgp_md_test_algo(opt.cert_digest_algo))
3493           log_error(_("selected certification digest algorithm is invalid\n"));
3494     }
3495     if( s2k_cipher_string ) {
3496         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3497         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3498         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3499           log_error(_("selected cipher algorithm is invalid\n"));
3500     }
3501     if( s2k_digest_string ) {
3502         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3503         xfree(s2k_digest_string); s2k_digest_string = NULL;
3504         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3505           log_error(_("selected digest algorithm is invalid\n"));
3506     }
3507     if( opt.completes_needed < 1 )
3508       log_error(_("completes-needed must be greater than 0\n"));
3509     if( opt.marginals_needed < 2 )
3510       log_error(_("marginals-needed must be greater than 1\n"));
3511     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3512       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3513     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3514       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3515     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3516       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3517     switch( opt.s2k_mode ) {
3518       case 0:
3519         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3520         break;
3521       case 1: case 3: break;
3522       default:
3523         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3524     }
3525
3526     /* This isn't actually needed, but does serve to error out if the
3527        string is invalid. */
3528     if(opt.def_preference_list &&
3529         keygen_set_std_prefs(opt.def_preference_list,0))
3530       log_error(_("invalid default preferences\n"));
3531
3532     if(pers_cipher_list &&
3533        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3534       log_error(_("invalid personal cipher preferences\n"));
3535
3536     if(pers_digest_list &&
3537        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3538       log_error(_("invalid personal digest preferences\n"));
3539
3540     if(pers_compress_list &&
3541        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3542       log_error(_("invalid personal compress preferences\n"));
3543
3544     /* We don't support all possible commands with multifile yet */
3545     if(multifile)
3546       {
3547         char *cmdname;
3548
3549         switch(cmd)
3550           {
3551           case aSign:
3552             cmdname="--sign";
3553             break;
3554           case aSignEncr:
3555             cmdname="--sign --encrypt";
3556             break;
3557           case aClearsign:
3558             cmdname="--clearsign";
3559             break;
3560           case aDetachedSign:
3561             cmdname="--detach-sign";
3562             break;
3563           case aSym:
3564             cmdname="--symmetric";
3565             break;
3566           case aEncrSym:
3567             cmdname="--symmetric --encrypt";
3568             break;
3569           case aStore:
3570             cmdname="--store";
3571             break;
3572           default:
3573             cmdname=NULL;
3574             break;
3575           }
3576
3577         if(cmdname)
3578           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3579       }
3580
3581     if( log_get_errorcount(0) )
3582         g10_exit(2);
3583
3584     if(opt.compress_level==0)
3585       opt.compress_algo=COMPRESS_ALGO_NONE;
3586
3587     /* Check our chosen algorithms against the list of legal
3588        algorithms. */
3589
3590     if(!GNUPG)
3591       {
3592         const char *badalg=NULL;
3593         preftype_t badtype=PREFTYPE_NONE;
3594
3595         if(opt.def_cipher_algo
3596            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3597           {
3598             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3599             badtype = PREFTYPE_SYM;
3600           }
3601         else if(opt.def_digest_algo
3602                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3603           {
3604             badalg = gcry_md_algo_name (opt.def_digest_algo);
3605             badtype = PREFTYPE_HASH;
3606           }
3607         else if(opt.cert_digest_algo
3608                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3609           {
3610             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3611             badtype = PREFTYPE_HASH;
3612           }
3613         else if(opt.compress_algo!=-1
3614                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3615           {
3616             badalg = compress_algo_to_string(opt.compress_algo);
3617             badtype = PREFTYPE_ZIP;
3618           }
3619
3620         if(badalg)
3621           {
3622             switch(badtype)
3623               {
3624               case PREFTYPE_SYM:
3625                 log_info(_("you may not use cipher algorithm '%s'"
3626                            " while in %s mode\n"),
3627                          badalg,compliance_option_string());
3628                 break;
3629               case PREFTYPE_HASH:
3630                 log_info(_("you may not use digest algorithm '%s'"
3631                            " while in %s mode\n"),
3632                          badalg,compliance_option_string());
3633                 break;
3634               case PREFTYPE_ZIP:
3635                 log_info(_("you may not use compression algorithm '%s'"
3636                            " while in %s mode\n"),
3637                          badalg,compliance_option_string());
3638                 break;
3639               default:
3640                 BUG();
3641               }
3642
3643             compliance_failure();
3644           }
3645       }
3646
3647     /* Set the random seed file. */
3648     if( use_random_seed ) {
3649         char *p = make_filename(opt.homedir, "random_seed", NULL );
3650         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3651         if (!access (p, F_OK))
3652           register_secured_file (p);
3653         xfree(p);
3654     }
3655
3656     /* If there is no command but the --fingerprint is given, default
3657        to the --list-keys command.  */
3658     if (!cmd && fpr_maybe_cmd)
3659       {
3660         set_cmd (&cmd, aListKeys);
3661       }
3662
3663
3664     if( opt.verbose > 1 )
3665         set_packet_list_mode(1);
3666
3667     /* Add the keyrings, but not for some special commands.
3668        We always need to add the keyrings if we are running under
3669        SELinux, this is so that the rings are added to the list of
3670        secured files. */
3671     if( ALWAYS_ADD_KEYRINGS
3672         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) )
3673       {
3674         if (!nrings || default_keyring)  /* Add default ring. */
3675             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3676                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3677         for (sl = nrings; sl; sl = sl->next )
3678           keydb_add_resource (sl->d, sl->flags);
3679       }
3680     FREE_STRLIST(nrings);
3681
3682     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
3683       /* In loopback mode, never ask for the password multiple
3684          times.  */
3685       {
3686         opt.passphrase_repeat = 0;
3687       }
3688
3689     if (cmd == aGPGConfTest)
3690       g10_exit(0);
3691
3692
3693     if( pwfd != -1 )  /* Read the passphrase now. */
3694         read_passphrase_from_fd( pwfd );
3695
3696     fname = argc? *argv : NULL;
3697
3698     if(fname && utf8_strings)
3699       opt.flags.utf8_filename=1;
3700
3701     ctrl = xcalloc (1, sizeof *ctrl);
3702     gpg_init_default_ctrl (ctrl);
3703
3704 #ifndef NO_TRUST_MODELS
3705     switch (cmd)
3706       {
3707       case aPrimegen:
3708       case aPrintMD:
3709       case aPrintMDs:
3710       case aGenRandom:
3711       case aDeArmor:
3712       case aEnArmor:
3713         break;
3714       case aFixTrustDB:
3715       case aExportOwnerTrust:
3716         rc = setup_trustdb (0, trustdb_name);
3717         break;
3718       case aListTrustDB:
3719         rc = setup_trustdb (argc? 1:0, trustdb_name);
3720         break;
3721       default:
3722         /* If we are using TM_ALWAYS, we do not need to create the
3723            trustdb.  */
3724         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3725         break;
3726       }
3727     if (rc)
3728       log_error (_("failed to initialize the TrustDB: %s\n"),
3729                  gpg_strerror (rc));
3730 #endif /*!NO_TRUST_MODELS*/
3731
3732     switch (cmd)
3733       {
3734       case aStore:
3735       case aSym:
3736       case aSign:
3737       case aSignSym:
3738       case aClearsign:
3739         if (!opt.quiet && any_explicit_recipient)
3740           log_info (_("WARNING: recipients (-r) given "
3741                       "without using public key encryption\n"));
3742         break;
3743       default:
3744         break;
3745       }
3746
3747
3748     /* Check for certain command whether we need to migrate a
3749        secring.gpg to the gpg-agent. */
3750     switch (cmd)
3751       {
3752       case aListSecretKeys:
3753       case aSign:
3754       case aSignEncr:
3755       case aSignEncrSym:
3756       case aSignSym:
3757       case aClearsign:
3758       case aDecrypt:
3759       case aSignKey:
3760       case aLSignKey:
3761       case aEditKey:
3762       case aPasswd:
3763       case aDeleteSecretKeys:
3764       case aDeleteSecretAndPublicKeys:
3765       case aQuickKeygen:
3766       case aQuickAddUid:
3767       case aFullKeygen:
3768       case aKeygen:
3769       case aImport:
3770       case aExportSecret:
3771       case aExportSecretSub:
3772       case aGenRevoke:
3773       case aDesigRevoke:
3774       case aCardEdit:
3775       case aChangePIN:
3776         migrate_secring (ctrl);
3777         break;
3778       case aListKeys:
3779         if (opt.with_secret)
3780           migrate_secring (ctrl);
3781         break;
3782       default:
3783         break;
3784       }
3785
3786     /* The command dispatcher.  */
3787     switch( cmd )
3788       {
3789       case aServer:
3790         gpg_server (ctrl);
3791         break;
3792
3793       case aStore: /* only store the file */
3794         if( argc > 1 )
3795             wrong_args(_("--store [filename]"));
3796         if( (rc = encrypt_store(fname)) )
3797           {
3798             write_status_failure ("store", rc);
3799             log_error ("storing '%s' failed: %s\n",
3800                        print_fname_stdin(fname),gpg_strerror (rc) );
3801           }
3802         break;
3803       case aSym: /* encrypt the given file only with the symmetric cipher */
3804         if( argc > 1 )
3805             wrong_args(_("--symmetric [filename]"));
3806         if( (rc = encrypt_symmetric(fname)) )
3807           {
3808             write_status_failure ("symencrypt", rc);
3809             log_error (_("symmetric encryption of '%s' failed: %s\n"),
3810                         print_fname_stdin(fname),gpg_strerror (rc) );
3811           }
3812         break;
3813
3814       case aEncr: /* encrypt the given file */
3815         if(multifile)
3816           encrypt_crypt_files (ctrl, argc, argv, remusr);
3817         else
3818           {
3819             if( argc > 1 )
3820               wrong_args(_("--encrypt [filename]"));
3821             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
3822               {
3823                 write_status_failure ("encrypt", rc);
3824                 log_error("%s: encryption failed: %s\n",
3825                           print_fname_stdin(fname), gpg_strerror (rc) );
3826               }
3827           }
3828         break;
3829
3830       case aEncrSym:
3831         /* This works with PGP 8 in the sense that it acts just like a
3832            symmetric message.  It doesn't work at all with 2 or 6.  It
3833            might work with 7, but alas, I don't have a copy to test
3834            with right now. */
3835         if( argc > 1 )
3836           wrong_args(_("--symmetric --encrypt [filename]"));
3837         else if(opt.s2k_mode==0)
3838           log_error(_("you cannot use --symmetric --encrypt"
3839                       " with --s2k-mode 0\n"));
3840         else if(PGP6 || PGP7)
3841           log_error(_("you cannot use --symmetric --encrypt"
3842                       " while in %s mode\n"),compliance_option_string());
3843         else
3844           {
3845             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
3846               {
3847                 write_status_failure ("encrypt", rc);
3848                 log_error ("%s: encryption failed: %s\n",
3849                            print_fname_stdin(fname), gpg_strerror (rc) );
3850               }
3851           }
3852         break;
3853
3854       case aSign: /* sign the given file */
3855         sl = NULL;
3856         if( detached_sig ) { /* sign all files */
3857             for( ; argc; argc--, argv++ )
3858                 add_to_strlist( &sl, *argv );
3859         }
3860         else {
3861             if( argc > 1 )
3862                 wrong_args(_("--sign [filename]"));
3863             if( argc ) {
3864                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3865                 strcpy(sl->d, fname);
3866             }
3867         }
3868         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
3869           {
3870             write_status_failure ("sign", rc);
3871             log_error ("signing failed: %s\n", gpg_strerror (rc) );
3872           }
3873         free_strlist(sl);
3874         break;
3875
3876       case aSignEncr: /* sign and encrypt the given file */
3877         if( argc > 1 )
3878             wrong_args(_("--sign --encrypt [filename]"));
3879         if( argc ) {
3880             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3881             strcpy(sl->d, fname);
3882         }
3883         else
3884             sl = NULL;
3885         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
3886           {
3887             write_status_failure ("sign-encrypt", rc);
3888             log_error("%s: sign+encrypt failed: %s\n",
3889                       print_fname_stdin(fname), gpg_strerror (rc) );
3890           }
3891         free_strlist(sl);
3892         break;
3893
3894       case aSignEncrSym: /* sign and encrypt the given file */
3895         if( argc > 1 )
3896             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3897         else if(opt.s2k_mode==0)
3898           log_error(_("you cannot use --symmetric --sign --encrypt"
3899                       " with --s2k-mode 0\n"));
3900         else if(PGP6 || PGP7)
3901           log_error(_("you cannot use --symmetric --sign --encrypt"
3902                       " while in %s mode\n"),compliance_option_string());
3903         else
3904           {
3905             if( argc )
3906               {
3907                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3908                 strcpy(sl->d, fname);
3909               }
3910             else
3911               sl = NULL;
3912             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
3913                                  2, remusr, NULL)))
3914               {
3915                 write_status_failure ("sign-encrypt", rc);
3916                 log_error("%s: symmetric+sign+encrypt failed: %s\n",
3917                           print_fname_stdin(fname), gpg_strerror (rc) );
3918               }
3919             free_strlist(sl);
3920           }
3921         break;
3922
3923       case aSignSym: /* sign and conventionally encrypt the given file */
3924         if (argc > 1)
3925             wrong_args(_("--sign --symmetric [filename]"));
3926         rc = sign_symencrypt_file (ctrl, fname, locusr);
3927         if (rc)
3928           {
3929             write_status_failure ("sign-symencrypt", rc);
3930             log_error("%s: sign+symmetric failed: %s\n",
3931                       print_fname_stdin(fname), gpg_strerror (rc) );
3932           }
3933         break;
3934
3935       case aClearsign: /* make a clearsig */
3936         if( argc > 1 )
3937             wrong_args(_("--clearsign [filename]"));
3938         if( (rc = clearsign_file (ctrl, fname, locusr, NULL)) )
3939           {
3940             write_status_failure ("sign", rc);
3941             log_error("%s: clearsign failed: %s\n",
3942                       print_fname_stdin(fname), gpg_strerror (rc) );
3943           }
3944         break;
3945
3946       case aVerify:
3947         if (multifile)
3948           {
3949             if ((rc = verify_files (ctrl, argc, argv)))
3950               log_error("verify files failed: %s\n", gpg_strerror (rc) );
3951           }
3952         else
3953           {
3954             if ((rc = verify_signatures (ctrl, argc, argv)))
3955               log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
3956           }
3957         if (rc)
3958           write_status_failure ("verify", rc);
3959         break;
3960
3961       case aDecrypt:
3962         if (multifile)
3963           decrypt_messages (ctrl, argc, argv);
3964         else
3965           {
3966             if( argc > 1 )
3967               wrong_args(_("--decrypt [filename]"));
3968             if( (rc = decrypt_message (ctrl, fname) ))
3969               {
3970                 write_status_failure ("decrypt", rc);
3971                 log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
3972               }
3973           }
3974         break;
3975
3976       case aQuickSignKey:
3977       case aQuickLSignKey:
3978         {
3979           const char *fpr;
3980
3981           if (argc < 1)
3982             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
3983           fpr = *argv++; argc--;
3984           sl = NULL;
3985           for( ; argc; argc--, argv++)
3986             append_to_strlist2 (&sl, *argv, utf8_strings);
3987           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
3988           free_strlist (sl);
3989         }
3990         break;
3991
3992       case aSignKey:
3993         if( argc != 1 )
3994           wrong_args(_("--sign-key user-id"));
3995         /* fall through */
3996       case aLSignKey:
3997         if( argc != 1 )
3998           wrong_args(_("--lsign-key user-id"));
3999         /* fall through */
4000
4001         sl=NULL;
4002
4003         if(cmd==aSignKey)
4004           append_to_strlist(&sl,"sign");
4005         else if(cmd==aLSignKey)
4006           append_to_strlist(&sl,"lsign");
4007         else
4008           BUG();
4009
4010         append_to_strlist( &sl, "save" );
4011         username = make_username( fname );
4012         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
4013         xfree(username);
4014         free_strlist(sl);
4015         break;
4016
4017       case aEditKey: /* Edit a key signature */
4018         if( !argc )
4019             wrong_args(_("--edit-key user-id [commands]"));
4020         username = make_username( fname );
4021         if( argc > 1 ) {
4022             sl = NULL;
4023             for( argc--, argv++ ; argc; argc--, argv++ )
4024                 append_to_strlist( &sl, *argv );
4025             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
4026             free_strlist(sl);
4027         }
4028         else
4029             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
4030         xfree(username);
4031         break;
4032
4033       case aPasswd:
4034         if (argc != 1)
4035           wrong_args (_("--passwd <user-id>"));
4036         else
4037           {
4038             username = make_username (fname);
4039             keyedit_passwd (ctrl, username);
4040             xfree (username);
4041           }
4042         break;
4043
4044       case aDeleteKeys:
4045       case aDeleteSecretKeys:
4046       case aDeleteSecretAndPublicKeys:
4047         sl = NULL;
4048         /* I'm adding these in reverse order as add_to_strlist2
4049            reverses them again, and it's easier to understand in the
4050            proper order :) */
4051         for( ; argc; argc-- )
4052           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
4053         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
4054         free_strlist(sl);
4055         break;
4056
4057       case aCheckKeys:
4058         opt.check_sigs = 1;
4059       case aListSigs:
4060         opt.list_sigs = 1;
4061       case aListKeys:
4062         sl = NULL;
4063         for( ; argc; argc--, argv++ )
4064             add_to_strlist2( &sl, *argv, utf8_strings );
4065         public_key_list (ctrl, sl, 0);
4066         free_strlist(sl);
4067         break;
4068       case aListSecretKeys:
4069         sl = NULL;
4070         for( ; argc; argc--, argv++ )
4071             add_to_strlist2( &sl, *argv, utf8_strings );
4072         secret_key_list (ctrl, sl);
4073         free_strlist(sl);
4074         break;
4075       case aLocateKeys:
4076         sl = NULL;
4077         for (; argc; argc--, argv++)
4078           add_to_strlist2( &sl, *argv, utf8_strings );
4079         public_key_list (ctrl, sl, 1);
4080         free_strlist (sl);
4081         break;
4082
4083       case aQuickKeygen:
4084         if (argc != 1 )
4085           wrong_args("--gen-key user-id");
4086         username = make_username (fname);
4087         quick_generate_keypair (ctrl, username);
4088         xfree (username);
4089         break;
4090
4091       case aKeygen: /* generate a key */
4092         if( opt.batch ) {
4093             if( argc > 1 )
4094                 wrong_args("--gen-key [parameterfile]");
4095             generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4096         }
4097         else {
4098             if (opt.command_fd != -1 && argc)
4099               {
4100                 if( argc > 1 )
4101                   wrong_args("--gen-key [parameterfile]");
4102
4103                 opt.batch = 1;
4104                 generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4105               }
4106             else if (argc)
4107               wrong_args ("--gen-key");
4108             else
4109               generate_keypair (ctrl, 0, NULL, NULL, 0);
4110         }
4111         break;
4112
4113       case aFullKeygen: /* Generate a key with all options. */
4114         if (opt.batch)
4115           {
4116             if (argc > 1)
4117               wrong_args ("--full-gen-key [parameterfile]");
4118             generate_keypair (ctrl, 1, argc? *argv : NULL, NULL, 0);
4119           }
4120         else
4121           {
4122             if (argc)
4123               wrong_args("--full-gen-key");
4124             generate_keypair (ctrl, 1, NULL, NULL, 0);
4125         }
4126         break;
4127
4128       case aQuickAddUid:
4129         {
4130           const char *uid, *newuid;
4131
4132           if (argc != 2)
4133             wrong_args ("--quick-adduid USER-ID NEW-USER-ID");
4134           uid = *argv++; argc--;
4135           newuid = *argv++; argc--;
4136           keyedit_quick_adduid (ctrl, uid, newuid);
4137         }
4138         break;
4139
4140       case aFastImport:
4141         opt.import_options |= IMPORT_FAST;
4142       case aImport:
4143         import_keys (ctrl, argc? argv:NULL, argc, NULL, opt.import_options);
4144         break;
4145
4146         /* TODO: There are a number of command that use this same
4147            "make strlist, call function, report error, free strlist"
4148            pattern.  Join them together here and avoid all that
4149            duplicated code. */
4150
4151       case aExport:
4152       case aSendKeys:
4153       case aRecvKeys:
4154         sl = NULL;
4155         for( ; argc; argc--, argv++ )
4156             append_to_strlist2( &sl, *argv, utf8_strings );
4157         if( cmd == aSendKeys )
4158             rc = keyserver_export (ctrl, sl );
4159         else if( cmd == aRecvKeys )
4160             rc = keyserver_import (ctrl, sl );
4161         else
4162           {
4163             export_stats_t stats = export_new_stats ();
4164             rc = export_pubkeys (ctrl, sl, opt.export_options, stats);
4165             export_print_stats (stats);
4166             export_release_stats (stats);
4167           }
4168         if(rc)
4169           {
4170             if(cmd==aSendKeys)
4171               {
4172                 write_status_failure ("send-keys", rc);
4173                 log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
4174               }
4175             else if(cmd==aRecvKeys)
4176               {
4177                 write_status_failure ("recv-keys", rc);
4178                 log_error (_("keyserver receive failed: %s\n"),
4179                            gpg_strerror (rc));
4180               }
4181             else
4182               {
4183                 write_status_failure ("export", rc);
4184                 log_error (_("key export failed: %s\n"), gpg_strerror (rc));
4185               }
4186           }