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