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