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