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