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