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