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