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