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