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