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