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