gpg: Avoid publishing the GnuPG version by default
[gnupg.git] / g10 / gpg.c
1 /* gpg.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998-2015 Free Software Foundation, Inc.
3  * Copyright (C) 1997-2015 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #ifdef HAVE_STRINGS_H
27 #include <strings.h>
28 #endif
29 #include <ctype.h>
30 #include <unistd.h>
31 #include <assert.h>
32 #ifdef HAVE_DOSISH_SYSTEM
33 #include <fcntl.h> /* for setmode() */
34 #endif
35 #ifdef HAVE_STAT
36 #include <sys/stat.h> /* for stat() */
37 #endif
38 #include <fcntl.h>
39 #ifdef HAVE_W32_SYSTEM
40 #include <windows.h>
41 #endif
42 #ifdef __VMS
43 # include "vms.h"
44 #endif
45
46 #define INCLUDED_BY_MAIN_MODULE 1
47 #include "packet.h"
48 #include "iobuf.h"
49 #include "memory.h"
50 #include "util.h"
51 #include "main.h"
52 #include "options.h"
53 #include "keydb.h"
54 #include "trustdb.h"
55 #include "mpi.h"
56 #include "cipher.h"
57 #include "filter.h"
58 #include "ttyio.h"
59 #include "i18n.h"
60 #include "status.h"
61 #include "keyserver-internal.h"
62 #include "exec.h"
63 #include "cardglue.h"
64 #ifdef ENABLE_CARD_SUPPORT
65 #include "ccid-driver.h"
66 #endif
67
68 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
69 #define MY_O_BINARY  O_BINARY
70 #ifndef S_IRGRP
71 # define S_IRGRP 0
72 # define S_IWGRP 0
73 #endif
74 #else
75 #define MY_O_BINARY  0
76 #endif
77
78
79 enum cmd_and_opt_values
80   {
81     aNull = 0,
82     oArmor        = 'a',
83     aDetachedSign = 'b',
84     aSym          = 'c',
85     aDecrypt      = 'd',
86     aEncr         = 'e',
87     oInteractive  = 'i',
88     oKOption      = 'k',
89     oDryRun       = 'n',
90     oOutput       = 'o',
91     oQuiet        = 'q',
92     oRecipient    = 'r',
93     oHiddenRecipient = 'R',
94     aSign         = 's',
95     oTextmodeShort= 't',
96     oLocalUser    = 'u',
97     oVerbose      = 'v',
98     oCompress     = 'z',
99     oSetNotation  = 'N',
100     aListSecretKeys = 'K',
101     oBatch        = 500,
102     oMaxOutput,
103     oSigNotation,
104     oCertNotation,
105     oShowNotation,
106     oNoShowNotation,
107     aEncrFiles,
108     aEncrSym,
109     aDecryptFiles,
110     aClearsign,
111     aStore,
112     aKeygen,
113     aSignEncr,
114     aSignEncrSym,
115     aSignSym,
116     aSignKey,
117     aLSignKey,
118     aListConfig,
119     aGPGConfList,
120     aGPGConfTest,
121     aListPackets,
122     aEditKey,
123     aDeleteKeys,
124     aDeleteSecretKeys,
125     aDeleteSecretAndPublicKeys,
126     aKMode,
127     aKModeC,
128     aImport,
129     aFastImport,
130     aVerify,
131     aVerifyFiles,
132     aListKeys,
133     aListSigs,
134     aSendKeys,
135     aRecvKeys,
136     aSearchKeys,
137     aRefreshKeys,
138     aFetchKeys,
139     aExport,
140     aExportSecret,
141     aExportSecretSub,
142     aCheckKeys,
143     aGenRevoke,
144     aDesigRevoke,
145     aPrimegen,
146     aPrintMD,
147     aPrintMDs,
148     aCheckTrustDB,
149     aUpdateTrustDB,
150     aFixTrustDB,
151     aListTrustDB,
152     aListTrustPath,
153     aExportOwnerTrust,
154     aListOwnerTrust,
155     aImportOwnerTrust,
156     aDeArmor,
157     aEnArmor,
158     aGenRandom,
159     aPipeMode,
160     aRebuildKeydbCaches,
161     aCardStatus,
162     aCardEdit,
163     aChangePIN,
164
165     oTextmode,
166     oNoTextmode,
167     oExpert,
168     oNoExpert,
169     oDefSigExpire,
170     oAskSigExpire,
171     oNoAskSigExpire,
172     oDefCertExpire,
173     oAskCertExpire,
174     oNoAskCertExpire,
175     oDefCertLevel,
176     oMinCertLevel,
177     oAskCertLevel,
178     oNoAskCertLevel,
179     oFingerprint,
180     oWithFingerprint,
181     oAnswerYes,
182     oAnswerNo,
183     oKeyring,
184     oPrimaryKeyring,
185     oSecretKeyring,
186     oShowKeyring,
187     oDefaultKey,
188     oDefRecipient,
189     oDefRecipientSelf,
190     oNoDefRecipient,
191     oOptions,
192     oDebug,
193     oDebugAll,
194     oDebugLevel,
195     oDebugCCIDDriver,
196     oStatusFD,
197     oStatusFile,
198     oAttributeFD,
199     oAttributeFile,
200     oEmitVersion,
201     oNoEmitVersion,
202     oCompletesNeeded,
203     oMarginalsNeeded,
204     oMaxCertDepth,
205     oLoadExtension,
206     oGnuPG,
207     oRFC1991,
208     oRFC2440,
209     oRFC4880,
210     oOpenPGP,
211     oPGP2,
212     oPGP6,
213     oPGP7,
214     oPGP8,
215     oRFC2440Text,
216     oNoRFC2440Text,
217     oCipherAlgo,
218     oDigestAlgo,
219     oCertDigestAlgo,
220     oCompressAlgo,
221     oCompressLevel,
222     oBZ2CompressLevel,
223     oBZ2DecompressLowmem,
224     oPasswd,
225     oPasswdFD,
226     oPasswdFile,
227     oPasswdRepeat,
228     oCommandFD,
229     oCommandFile,
230     oQuickRandom,
231     oNoVerbose,
232     oTrustDBName,
233     oNoSecmemWarn,
234     oRequireSecmem,
235     oNoRequireSecmem,
236     oNoPermissionWarn,
237     oNoMDCWarn,
238     oNoArmor,
239     oNoDefKeyring,
240     oNoGreeting,
241     oNoTTY,
242     oNoOptions,
243     oNoBatch,
244     oHomedir,
245     oWithColons,
246     oWithKeyData,
247     oSkipVerify,
248     oCompressKeys,
249     oCompressSigs,
250     oAlwaysTrust,
251     oTrustModel,
252     oForceOwnertrust,
253     oRunAsShmCP,
254     oSetFilename,
255     oForYourEyesOnly,
256     oNoForYourEyesOnly,
257     oSetPolicyURL,
258     oSigPolicyURL,
259     oCertPolicyURL,
260     oShowPolicyURL,
261     oNoShowPolicyURL,
262     oSigKeyserverURL,
263     oUseEmbeddedFilename,
264     oNoUseEmbeddedFilename,
265     oComment,
266     oDefaultComment,
267     oNoComments,
268     oThrowKeyids,
269     oNoThrowKeyids,
270     oShowPhotos,
271     oNoShowPhotos,
272     oPhotoViewer,
273     oForceV3Sigs,
274     oNoForceV3Sigs,
275     oForceV4Certs,
276     oNoForceV4Certs,
277     oForceMDC,
278     oNoForceMDC,
279     oDisableMDC,
280     oNoDisableMDC,
281     oS2KMode,
282     oS2KDigest,
283     oS2KCipher,
284     oS2KCount,
285     oSimpleSKChecksum,
286     oDisplayCharset,
287     oNotDashEscaped,
288     oEscapeFrom,
289     oNoEscapeFrom,
290     oLockOnce,
291     oLockMultiple,
292     oLockNever,
293     oKeyServer,
294     oKeyServerOptions,
295     oImportOptions,
296     oExportOptions,
297     oListOptions,
298     oVerifyOptions,
299     oTempDir,
300     oExecPath,
301     oEncryptTo,
302     oHiddenEncryptTo,
303     oNoEncryptTo,
304     oLoggerFD,
305     oLoggerFile,
306     oUtf8Strings,
307     oNoUtf8Strings,
308     oDisableCipherAlgo,
309     oDisablePubkeyAlgo,
310     oAllowNonSelfsignedUID,
311     oNoAllowNonSelfsignedUID,
312     oAllowFreeformUID,
313     oNoAllowFreeformUID,
314     oAllowSecretKeyImport,
315     oEnableSpecialFilenames,
316     oNoLiteral,
317     oSetFilesize,
318     oHonorHttpProxy,
319     oFastListMode,
320     oListOnly,
321     oIgnoreTimeConflict,
322     oIgnoreValidFrom,
323     oIgnoreCrcError,
324     oIgnoreMDCError,
325     oShowSessionKey,
326     oOverrideSessionKey,
327     oNoRandomSeedFile,
328     oAutoKeyRetrieve,
329     oNoAutoKeyRetrieve,
330     oUseAgent,
331     oNoUseAgent,
332     oGpgAgentInfo,
333     oMergeOnly,
334     oTryAllSecrets,
335     oTrustedKey,
336     oNoExpensiveTrustChecks,
337     oFixedListMode,
338     oNoSigCache,
339     oAutoCheckTrustDB,
340     oNoAutoCheckTrustDB,
341     oPreservePermissions,
342     oDefaultPreferenceList,
343     oDefaultKeyserverURL,
344     oPersonalCipherPreferences,
345     oPersonalDigestPreferences,
346     oPersonalCompressPreferences,
347     oDisplay,
348     oTTYname,
349     oTTYtype,
350     oLCctype,
351     oLCmessages,
352     oGroup,
353     oUnGroup,
354     oNoGroups,
355     oStrict,
356     oNoStrict,
357     oMangleDosFilenames,
358     oNoMangleDosFilenames,
359     oEnableProgressFilter,
360     oMultifile,
361     oKeyidFormat,
362     oExitOnStatusWriteError,
363     oLimitCardInsertTries,
364     oReaderPort,
365     octapiDriver,
366     opcscDriver,
367     oDisableCCID,
368     oRequireCrossCert,
369     oNoRequireCrossCert,
370     oAutoKeyLocate,
371     oNoAutoKeyLocate,
372     oAllowMultisigVerification,
373     oEnableLargeRSA,
374     oDisableLargeRSA,
375     oEnableDSA2,
376     oDisableDSA2,
377     oAllowMultipleMessages,
378     oNoAllowMultipleMessages,
379     oAllowWeakDigestAlgos,
380     oWeakDigest,
381
382     oNoop
383   };
384
385
386 static ARGPARSE_OPTS opts[] = {
387
388     { 300, NULL, 0, N_("@Commands:\n ") },
389
390     { aSign, "sign",      256, N_("|[file]|make a signature")},
391     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature")},
392     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
393     { aEncr, "encrypt",   256, N_("encrypt data")},
394     { aEncrFiles, "encrypt-files", 256, "@"},
395     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
396     { aStore, "store",     256, "@"},
397     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
398     { aDecryptFiles, "decrypt-files", 256, "@"},
399     { aVerify, "verify"   , 256, N_("verify a signature")},
400     { aVerifyFiles, "verify-files" , 256, "@" },
401     { aListKeys, "list-keys", 256, N_("list keys")},
402     { aListKeys, "list-public-keys", 256, "@" },
403     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
404     { aCheckKeys, "check-sigs",256, N_("list and check key signatures")},
405     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
406     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
407     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
408     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
409     { aDeleteSecretKeys, "delete-secret-keys",256,
410                                     N_("remove keys from the secret keyring")},
411     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
412     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
413     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
414     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
415     { aDesigRevoke, "desig-revoke",256, "@" },
416     { aExport, "export"           , 256, N_("export keys") },
417     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
418     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
419     { aSearchKeys, "search-keys" , 256,
420                                     N_("search for keys on a key server") },
421     { aRefreshKeys, "refresh-keys", 256,
422                                     N_("update all keys from a keyserver")},
423     { aFetchKeys, "fetch-keys" , 256, "@" },
424     { aExportSecret, "export-secret-keys" , 256, "@" },
425     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
426     { aImport, "import",      256     , N_("import/merge keys")},
427     { aFastImport, "fast-import",  256 , "@"},
428 #ifdef ENABLE_CARD_SUPPORT
429     { aCardStatus,  "card-status", 256, N_("print the card status")},
430     { aCardEdit,   "card-edit",  256, N_("change data on a card")},
431     { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
432 #endif
433     { aListConfig, "list-config", 256, "@"},
434     { aGPGConfList, "gpgconf-list", 256, "@" },
435     { aGPGConfTest, "gpgconf-test", 256, "@" },
436     { aListPackets, "list-packets",256, "@"},
437     { aExportOwnerTrust, "export-ownertrust", 256, "@"},
438     { aImportOwnerTrust, "import-ownertrust", 256, "@"},
439     { aUpdateTrustDB,
440               "update-trustdb",0 , N_("update the trust database")},
441     { aCheckTrustDB, "check-trustdb", 0, "@"},
442     { aFixTrustDB, "fix-trustdb", 0, "@"},
443     { aDeArmor, "dearmor", 256, "@"},
444     { aDeArmor, "dearmour", 256, "@"},
445     { aEnArmor, "enarmor", 256, "@"},
446     { aEnArmor, "enarmour", 256, "@"},
447     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
448     { aPrimegen, "gen-prime" , 256, "@" },
449     { aGenRandom, "gen-random" , 256, "@" },
450
451     { 301, NULL, 0, N_("@\nOptions:\n ") },
452
453     { oArmor, "armor",     0, N_("create ascii armored output")},
454     { oArmor, "armour",     0, "@" },
455     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
456     { oHiddenRecipient, "hidden-recipient", 2, "@" },
457     { oRecipient, "remote-user", 2, "@"},  /* old option name */
458     { oDefRecipient, "default-recipient", 2, "@"},
459     { oDefRecipientSelf, "default-recipient-self", 0, "@"},
460     { oNoDefRecipient, "no-default-recipient", 0, "@" },
461     { oTempDir, "temp-directory", 2, "@" },
462     { oExecPath, "exec-path", 2, "@" },
463     { oEncryptTo, "encrypt-to", 2, "@" },
464     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
465     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
466     { oLocalUser, "local-user",2, N_("use this user-id to sign or decrypt")},
467     { oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
468     { oCompressLevel, "compress-level", 1, "@" },
469     { oBZ2CompressLevel, "bzip2-compress-level", 1, "@" },
470     { oBZ2DecompressLowmem, "bzip2-decompress-lowmem", 0, "@" },
471     { oTextmodeShort, NULL,   0, "@"},
472     { oTextmode, "textmode",  0, N_("use canonical text mode")},
473     { oNoTextmode, "no-textmode",  0, "@"},
474     { oExpert, "expert",   0, "@"},
475     { oNoExpert, "no-expert",   0, "@"},
476     { oDefSigExpire, "default-sig-expire", 2, "@"},
477     { oAskSigExpire, "ask-sig-expire",   0, "@"},
478     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
479     { oDefCertExpire, "default-cert-expire", 2, "@"},
480     { oAskCertExpire, "ask-cert-expire",   0, "@"},
481     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
482     { oDefCertLevel, "default-cert-level", 1, "@"},
483     { oMinCertLevel, "min-cert-level", 1, "@"},
484     { oAskCertLevel, "ask-cert-level",   0, "@"},
485     { oNoAskCertLevel, "no-ask-cert-level",   0, "@"},
486     { oOutput, "output",    2, N_("use as output file")},
487     { oMaxOutput, "max-output", 16|4, "@" },
488     { oVerbose, "verbose",   0, N_("verbose") },
489     { oQuiet,   "quiet",   0, "@"},
490     { oNoTTY, "no-tty", 0, "@"},
491     { oForceV3Sigs, "force-v3-sigs", 0, "@"},
492     { oNoForceV3Sigs, "no-force-v3-sigs", 0, "@"},
493     { oForceV4Certs, "force-v4-certs", 0, "@"},
494     { oNoForceV4Certs, "no-force-v4-certs", 0, "@"},
495     { oForceMDC, "force-mdc", 0, "@"},
496     { oNoForceMDC, "no-force-mdc", 0, "@" },
497     { oDisableMDC, "disable-mdc", 0, "@"},
498     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
499     { oDryRun, "dry-run",   0, N_("do not make any changes") },
500     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
501     { oUseAgent, "use-agent",0, "@"},
502     { oNoUseAgent, "no-use-agent",0, "@"},
503     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
504     { oBatch, "batch", 0, "@"},
505     { oAnswerYes, "yes", 0, "@"},
506     { oAnswerNo, "no", 0, "@"},
507     { oKeyring, "keyring", 2, "@"},
508     { oPrimaryKeyring, "primary-keyring",2, "@" },
509     { oSecretKeyring, "secret-keyring", 2, "@"},
510     { oShowKeyring, "show-keyring", 0, "@"},
511     { oDefaultKey, "default-key", 2, "@"},
512     { oKeyServer, "keyserver", 2, "@"},
513     { oKeyServerOptions, "keyserver-options",2,"@"},
514     { oImportOptions, "import-options",2,"@"},
515     { oExportOptions, "export-options",2,"@"},
516     { oListOptions, "list-options",2,"@"},
517     { oVerifyOptions, "verify-options",2,"@"},
518     { oDisplayCharset, "display-charset", 2, "@"},
519     { oDisplayCharset, "charset", 2, "@"},
520     { oOptions, "options", 2, "@"},
521     { oDebug, "debug"     ,4|16, "@"},
522     { oDebugAll, "debug-all" ,0, "@"},
523     { oDebugLevel, "debug-level" ,2, "@"},
524     { oStatusFD, "status-fd" ,1, "@"},
525     { oStatusFile, "status-file" ,2, "@"},
526     { oAttributeFD, "attribute-fd" ,1, "@" },
527     { oAttributeFile, "attribute-file" ,2, "@" },
528     { oNoop, "sk-comments", 0,   "@"},
529     { oNoop, "no-sk-comments", 0,   "@"},
530     { oCompletesNeeded, "completes-needed", 1, "@"},
531     { oMarginalsNeeded, "marginals-needed", 1, "@"},
532     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
533     { oTrustedKey, "trusted-key", 2, "@"},
534     { oLoadExtension, "load-extension", 2, "@"},
535     { oGnuPG, "gnupg",   0, "@"},
536     { oGnuPG, "no-pgp2", 0, "@"},
537     { oGnuPG, "no-pgp6", 0, "@"},
538     { oGnuPG, "no-pgp7", 0, "@"},
539     { oGnuPG, "no-pgp8", 0, "@"},
540     { oRFC1991, "rfc1991",   0, "@"},
541     { oRFC2440, "rfc2440", 0, "@" },
542     { oRFC4880, "rfc4880", 0, "@" },
543     { oOpenPGP, "openpgp", 0, N_("use strict OpenPGP behavior")},
544     { oPGP2, "pgp2", 0, N_("generate PGP 2.x compatible messages")},
545     { oPGP6, "pgp6", 0, "@"},
546     { oPGP7, "pgp7", 0, "@"},
547     { oPGP8, "pgp8", 0, "@"},
548     { oRFC2440Text, "rfc2440-text", 0, "@"},
549     { oNoRFC2440Text, "no-rfc2440-text", 0, "@"},
550     { oS2KMode, "s2k-mode", 1, "@"},
551     { oS2KDigest, "s2k-digest-algo", 2, "@"},
552     { oS2KCipher, "s2k-cipher-algo", 2, "@"},
553     { oS2KCount, "s2k-count", 1, "@"},
554     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
555     { oCipherAlgo, "cipher-algo", 2, "@"},
556     { oDigestAlgo, "digest-algo", 2, "@"},
557     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
558     { oCompressAlgo,"compress-algo", 2, "@"},
559     { oCompressAlgo, "compression-algo", 2, "@"}, /* Alias */
560     { oThrowKeyids, "throw-keyid", 0, "@"},
561     { oThrowKeyids, "throw-keyids", 0, "@"},
562     { oNoThrowKeyids, "no-throw-keyid", 0, "@" },
563     { oNoThrowKeyids, "no-throw-keyids", 0, "@" },
564     { oShowPhotos,   "show-photos", 0, "@" },
565     { oNoShowPhotos, "no-show-photos", 0, "@" },
566     { oPhotoViewer,  "photo-viewer", 2, "@" },
567     { oSetNotation,  "set-notation", 2, "@" },
568     { oSetNotation,  "notation-data", 2, "@" }, /* Alias */
569     { oSigNotation,  "sig-notation", 2, "@" },
570     { oCertNotation, "cert-notation", 2, "@" },
571
572     { 302, NULL, 0, N_(
573   "@\n(See the man page for a complete listing of all commands and options)\n"
574                       )},
575
576     { 303, NULL, 0, N_("@\nExamples:\n\n"
577     " -se -r Bob [file]          sign and encrypt for user Bob\n"
578     " --clearsign [file]         make a clear text signature\n"
579     " --detach-sign [file]       make a detached signature\n"
580     " --list-keys [names]        show keys\n"
581     " --fingerprint [names]      show fingerprints\n"  ) },
582
583   /* hidden options */
584     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
585     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
586     { aListTrustDB, "list-trustdb",0 , "@"},
587     /* Not yet used */
588     /* { aListTrustPath, "list-trust-path",0, "@"}, */
589     { aPipeMode,  "pipemode", 0, "@" },
590     { oKOption, NULL,    0, "@"},
591     { oPasswd, "passphrase",2, "@" },
592     { oPasswdFD, "passphrase-fd",1, "@" },
593     { oPasswdFile, "passphrase-file",2, "@" },
594     { oPasswdRepeat, "passphrase-repeat", 1, "@"},
595     { oCommandFD, "command-fd",1, "@" },
596     { oCommandFile, "command-file",2, "@" },
597     { oQuickRandom, "quick-random", 0, "@"},
598     { oNoVerbose, "no-verbose", 0, "@"},
599     { oTrustDBName, "trustdb-name", 2, "@" },
600     { oNoSecmemWarn, "no-secmem-warning", 0, "@" },
601     { oRequireSecmem,"require-secmem", 0, "@" },
602     { oNoRequireSecmem,"no-require-secmem", 0, "@" },
603     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
604     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
605     { oNoArmor, "no-armor",   0, "@"},
606     { oNoArmor, "no-armour",   0, "@"},
607     { oNoDefKeyring, "no-default-keyring", 0, "@" },
608     { oNoGreeting, "no-greeting", 0, "@" },
609     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
610     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
611     { oNoBatch, "no-batch", 0, "@" },
612     { oWithColons, "with-colons", 0, "@"},
613     { oWithKeyData,"with-key-data", 0, "@"},
614     { aListKeys, "list-key", 0, "@" }, /* alias */
615     { aListSigs, "list-sig", 0, "@" }, /* alias */
616     { aCheckKeys, "check-sig",0, "@" }, /* alias */
617     { oSkipVerify, "skip-verify",0, "@" },
618     { oCompressKeys, "compress-keys",0, "@"},
619     { oCompressSigs, "compress-sigs",0, "@"},
620     { oDefCertLevel, "default-cert-check-level", 1, "@"}, /* Old option */
621     { oAlwaysTrust, "always-trust", 0, "@"},
622     { oTrustModel, "trust-model", 2, "@"},
623     { oForceOwnertrust, "force-ownertrust", 2, "@"},
624     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
625     { oSetFilename, "set-filename", 2, "@" },
626     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
627     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
628     { oSetPolicyURL, "set-policy-url", 2, "@" },
629     { oSigPolicyURL, "sig-policy-url", 2, "@" },
630     { oCertPolicyURL, "cert-policy-url", 2, "@" },
631     { oShowPolicyURL, "show-policy-url", 0, "@" },
632     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
633     { oSigKeyserverURL, "sig-keyserver-url", 2, "@" },
634     { oShowNotation, "show-notation", 0, "@" },
635     { oNoShowNotation, "no-show-notation", 0, "@" },
636     { oComment, "comment", 2, "@" },
637     { oDefaultComment, "default-comment", 0, "@" },
638     { oNoComments, "no-comments", 0, "@" },
639     { oEmitVersion, "emit-version", 0, "@"},
640     { oNoEmitVersion, "no-emit-version", 0, "@"},
641     { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
642     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
643     { oEscapeFrom, "escape-from-lines", 0, "@" },
644     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
645     { oLockOnce, "lock-once", 0, "@" },
646     { oLockMultiple, "lock-multiple", 0, "@" },
647     { oLockNever, "lock-never", 0, "@" },
648     { oLoggerFD, "logger-fd",1, "@" },
649     { oLoggerFile, "logger-file",2, "@" },
650     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
651     { oNoUseEmbeddedFilename, "no-use-embedded-filename", 0, "@" },
652     { oUtf8Strings, "utf8-strings", 0, "@" },
653     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
654     { oWithFingerprint, "with-fingerprint", 0, "@" },
655     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
656     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
657     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
658     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
659     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
660     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
661     { oNoLiteral, "no-literal", 0, "@" },
662     { oSetFilesize, "set-filesize", 20, "@" },
663     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
664     { oFastListMode,"fast-list-mode", 0, "@" },
665     { oFixedListMode,"fixed-list-mode", 0, "@" },
666     { oListOnly, "list-only", 0, "@"},
667     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
668     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
669     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
670     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
671     { oShowSessionKey, "show-session-key", 0, "@" },
672     { oOverrideSessionKey, "override-session-key", 2, "@" },
673     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
674     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
675     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
676     { oNoSigCache,         "no-sig-cache", 0, "@" },
677     { oNoop,               "no-sig-create-check", 0, "@" },
678     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
679     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
680     { oMergeOnly,         "merge-only", 0, "@" },
681     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
682     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
683     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
684     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
685     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
686     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
687     { oPreservePermissions, "preserve-permissions", 0, "@"},
688     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
689     { oDefaultKeyserverURL,  "default-keyserver-url", 2, "@"},
690     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
691     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
692     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
693     { oWeakDigest,  "weak-digest", 2, "@"},
694     /* Aliases.  I constantly mistype these, and assume other people
695        do as well. */
696     { oPersonalCipherPreferences, "personal-cipher-prefs", 2, "@"},
697     { oPersonalDigestPreferences, "personal-digest-prefs", 2, "@"},
698     { oPersonalCompressPreferences, "personal-compress-prefs", 2, "@"},
699     { oDisplay,    "display",     2, "@" },
700     { oTTYname,    "ttyname",     2, "@" },
701     { oTTYtype,    "ttytype",     2, "@" },
702     { oLCctype,    "lc-ctype",    2, "@" },
703     { oLCmessages, "lc-messages", 2, "@" },
704     { oGroup,      "group",       2, "@" },
705     { oUnGroup,    "ungroup",     2, "@" },
706     { oNoGroups,   "no-groups",    0, "@" },
707     { oStrict,     "strict",      0, "@" },
708     { oNoStrict,   "no-strict",   0, "@" },
709     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
710     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
711     { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
712     { oMultifile, "multifile", 0, "@" },
713     { oKeyidFormat, "keyid-format", 2, "@" },
714     { oExitOnStatusWriteError, "exit-on-status-write-error", 0, "@" },
715     { oLimitCardInsertTries, "limit-card-insert-tries", 1, "@"},
716
717     { oReaderPort, "reader-port",    2, "@"},
718     { octapiDriver, "ctapi-driver",  2, "@"},
719     { opcscDriver, "pcsc-driver",    2, "@"},
720     { oDisableCCID, "disable-ccid", 0, "@"},
721 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
722     { oDebugCCIDDriver, "debug-ccid-driver", 0, "@"},
723 #endif
724     { oAllowMultisigVerification, "allow-multisig-verification", 0, "@"},
725     { oEnableLargeRSA, "enable-large-rsa", 0, "@"},
726     { oDisableLargeRSA, "disable-large-rsa", 0, "@"},
727     { oEnableDSA2, "enable-dsa2", 0, "@"},
728     { oDisableDSA2, "disable-dsa2", 0, "@"},
729     { oAllowMultipleMessages, "allow-multiple-messages", 0, "@"},
730     { oNoAllowMultipleMessages, "no-allow-multiple-messages", 0, "@"},
731     { oAllowWeakDigestAlgos, "allow-weak-digest-algos", 0, "@"},
732
733     /* These two are aliases to help users of the PGP command line
734        product use gpg with minimal pain.  Many commands are common
735        already as they seem to have borrowed commands from us.  Now
736        I'm returning the favor. */
737     { oLocalUser, "sign-with", 2, "@" },
738     { oRecipient, "user", 2, "@" },
739     { oRequireCrossCert, "require-backsigs", 0, "@"},
740     { oRequireCrossCert, "require-cross-certification", 0, "@"},
741     { oNoRequireCrossCert, "no-require-backsigs", 0, "@"},
742     { oNoRequireCrossCert, "no-require-cross-certification", 0, "@"},
743     { oAutoKeyLocate, "auto-key-locate", 2, "@"},
744     { oNoAutoKeyLocate, "no-auto-key-locate", 0, "@"},
745     {0,NULL,0,NULL}
746 };
747
748
749 #ifdef ENABLE_SELINUX_HACKS
750 #define ALWAYS_ADD_KEYRINGS 1
751 #else
752 #define ALWAYS_ADD_KEYRINGS 0
753 #endif
754
755
756 int g10_errors_seen = 0;
757
758 static int utf8_strings = 0;
759 static int maybe_setuid = 1;
760
761 static char *build_list( const char *text, char letter,
762                          const char *(*mapf)(int), int (*chkf)(int) );
763 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
764                         enum cmd_and_opt_values new_cmd );
765 static void print_mds( const char *fname, int algo );
766 static void add_notation_data( const char *string, int which );
767 static void add_policy_url( const char *string, int which );
768 static void add_keyserver_url( const char *string, int which );
769
770 const char *
771 strusage( int level )
772 {
773   static char *digests, *pubkeys, *ciphers, *zips;
774     const char *p;
775     switch( level ) {
776       case 11: p = "gpg (GnuPG)";
777         break;
778       case 13: p = VERSION; break;
779       case 17: p = PRINTABLE_OS_NAME; break;
780       case 19: p =
781             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
782         break;
783
784 #ifdef IS_DEVELOPMENT_VERSION
785       case 20:
786         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
787         break;
788       case 21:
789         p="It is only intended for test purposes and should NOT be";
790         break;
791       case 22:
792         p="used in a production environment or with production keys!";
793         break;
794 #endif
795
796       case 1:
797       case 40:  p =
798             _("Usage: gpg [options] [files] (-h for help)");
799         break;
800       case 41:  p =
801             _("Syntax: gpg [options] [files]\n"
802               "Sign, check, encrypt or decrypt\n"
803               "Default operation depends on the input data\n");
804         break;
805
806       case 31: p = "\nHome: "; break;
807 #ifndef __riscos__
808       case 32: p = opt.homedir; break;
809 #else /* __riscos__ */
810       case 32: p = make_filename(opt.homedir, NULL); break;
811 #endif /* __riscos__ */
812       case 33: p = _("\nSupported algorithms:\n"); break;
813       case 34:
814         if( !pubkeys )
815             pubkeys = build_list(_("Pubkey: "), 0, pubkey_algo_to_string,
816                                                         check_pubkey_algo );
817         p = pubkeys;
818         break;
819       case 35:
820         if( !ciphers )
821             ciphers = build_list(_("Cipher: "), 'S', cipher_algo_to_string,
822                                                         check_cipher_algo );
823         p = ciphers;
824         break;
825       case 36:
826         if( !digests )
827             digests = build_list(_("Hash: "), 'H', digest_algo_to_string,
828                                                         check_digest_algo );
829         p = digests;
830         break;
831       case 37:
832         if( !zips )
833             zips = build_list(_("Compression: "),'Z',compress_algo_to_string,
834                                                         check_compress_algo);
835         p = zips;
836         break;
837
838       default:  p = default_strusage(level);
839     }
840     return p;
841 }
842
843
844 static char *
845 build_list (const char *text, char letter,
846             const char * (*mapf)(int), int (*chkf)(int))
847 {
848   membuf_t mb;
849   int indent;
850   int i, j, len;
851   const char *s;
852   char *string;
853
854   if (maybe_setuid)
855     secmem_init (0);    /* Drop setuid */
856
857   indent = strlen (text);
858   len = 0;
859   init_membuf (&mb, 512);
860
861   for (i=0; i <= 110; i++ )
862     {
863       if (!chkf (i) && (s = mapf (i)))
864         {
865           if (mb.len - len > 60)
866             {
867               put_membuf_str (&mb, ",\n");
868               len = mb.len;
869               for (j=0; j < indent; j++)
870                 put_membuf_str (&mb, " ");
871             }
872           else if (mb.len)
873             put_membuf_str (&mb, ", ");
874           else
875             put_membuf_str (&mb, text);
876
877           put_membuf_str (&mb, s);
878           if (opt.verbose && letter)
879             {
880               char num[20];
881               snprintf (num, sizeof num, " (%c%d)", letter, i);
882               put_membuf_str (&mb, num);
883             }
884         }
885     }
886   if (mb.len)
887     put_membuf_str (&mb, "\n");
888   put_membuf (&mb, "", 1);
889
890   string = get_membuf (&mb, NULL);
891   return xrealloc (string, strlen (string)+1);
892 }
893
894
895 static void
896 i18n_init(void)
897 {
898 #ifdef USE_SIMPLE_GETTEXT
899     set_gettext_file (PACKAGE, "Software\\GNU\\GnuPG");
900 #else
901 #ifdef ENABLE_NLS
902     setlocale( LC_ALL, "" );
903     bindtextdomain (PACKAGE, LOCALEDIR);
904     textdomain( PACKAGE );
905 #endif
906 #endif
907 }
908
909 static void
910 wrong_args( const char *text)
911 {
912     fputs(_("usage: gpg [options] "),stderr);
913     fputs(text,stderr);
914     putc('\n',stderr);
915     g10_exit(2);
916 }
917
918
919 static char *
920 make_username( const char *string )
921 {
922     char *p;
923     if( utf8_strings )
924         p = xstrdup(string);
925     else
926         p = native_to_utf8( string );
927     return p;
928 }
929
930
931 static void
932 set_debug(void)
933 {
934     if( opt.debug & DBG_MEMORY_VALUE )
935         memory_debug_mode = 1;
936     if( opt.debug & DBG_MEMSTAT_VALUE )
937         memory_stat_debug_mode = 1;
938     if( opt.debug & DBG_MPI_VALUE )
939         mpi_debug_mode = 1;
940     if( opt.debug & DBG_CIPHER_VALUE )
941         g10c_debug_mode = 1;
942     if( opt.debug & DBG_IOBUF_VALUE )
943         iobuf_debug_mode = 1;
944
945 }
946
947
948 /* We need the home directory also in some other directories, so make
949    sure that both variables are always in sync. */
950 static void
951 set_homedir (char *dir)
952 {
953   if (!dir)
954     dir = "";
955   g10_opt_homedir = opt.homedir = dir;
956 }
957
958
959 /* We set the screen dimensions for UI purposes.  Do not allow screens
960    smaller than 80x24 for the sake of simplicity. */
961 static void
962 set_screen_dimensions(void)
963 {
964 #ifndef _WIN32
965   char *str;
966
967   str=getenv("COLUMNS");
968   if(str)
969     opt.screen_columns=atoi(str);
970
971   str=getenv("LINES");
972   if(str)
973     opt.screen_lines=atoi(str);
974 #endif
975
976   if(opt.screen_columns<80 || opt.screen_columns>255)
977     opt.screen_columns=80;
978
979   if(opt.screen_lines<24 || opt.screen_lines>255)
980     opt.screen_lines=24;
981 }
982
983
984 /* Helper to open a file FNAME either for reading or writing to be
985    used with --status-file etc functions.  Not generally useful but it
986    avoids the riscos specific functions and well some Windows people
987    might like it too.  Prints an error message and returns -1 on
988    error. On success the file descriptor is returned.  */
989 static int
990 open_info_file (const char *fname, int for_write)
991 {
992 #ifdef __riscos__
993   return riscos_fdopenfile (fname, for_write);
994 #elif defined (ENABLE_SELINUX_HACKS)
995   /* We can't allow these even when testing for a secured filename
996      because files to be secured might not yet been secured.  This is
997      similar to the option file but in that case it is unlikely that
998      sensitive information may be retrieved by means of error
999      messages.  */
1000   return -1;
1001 #else
1002   int fd;
1003
1004 /*   if (is_secured_filename (fname)) */
1005 /*     { */
1006 /*       fd = -1; */
1007 /*       errno = EPERM; */
1008 /*     } */
1009 /*   else */
1010 /*     { */
1011       do
1012         {
1013           if (for_write)
1014             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY,
1015                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1016           else
1017             fd = open (fname, O_RDONLY | MY_O_BINARY);
1018         }
1019       while (fd == -1 && errno == EINTR);
1020 /*     } */
1021   if ( fd == -1)
1022     log_error ( for_write? _("can't create `%s': %s\n")
1023                          : _("can't open `%s': %s\n"), fname, strerror(errno));
1024
1025   return fd;
1026 #endif
1027 }
1028
1029 static void
1030 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1031 {
1032     enum cmd_and_opt_values cmd = *ret_cmd;
1033
1034     if( !cmd || cmd == new_cmd )
1035         cmd = new_cmd;
1036     else if( cmd == aSign && new_cmd == aEncr )
1037         cmd = aSignEncr;
1038     else if( cmd == aEncr && new_cmd == aSign )
1039         cmd = aSignEncr;
1040     else if( cmd == aSign && new_cmd == aSym )
1041         cmd = aSignSym;
1042     else if( cmd == aSym && new_cmd == aSign )
1043         cmd = aSignSym;
1044     else if( cmd == aSym && new_cmd == aEncr )
1045         cmd = aEncrSym;
1046     else if( cmd == aEncr && new_cmd == aSym )
1047         cmd = aEncrSym;
1048     else if( cmd == aKMode && new_cmd == aSym )
1049         cmd = aKModeC;
1050     else if (cmd == aSignEncr && new_cmd == aSym)
1051         cmd = aSignEncrSym;
1052     else if (cmd == aSignSym && new_cmd == aEncr)
1053         cmd = aSignEncrSym;
1054     else if (cmd == aEncrSym && new_cmd == aSign)
1055         cmd = aSignEncrSym;
1056     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1057              || ( cmd == aClearsign && new_cmd == aSign )  )
1058         cmd = aClearsign;
1059     else {
1060         log_error(_("conflicting commands\n"));
1061         g10_exit(2);
1062     }
1063
1064     *ret_cmd = cmd;
1065 }
1066
1067
1068 static void
1069 add_group(char *string)
1070 {
1071   char *name,*value;
1072   struct groupitem *item;
1073
1074   /* Break off the group name */
1075   name=strsep(&string,"=");
1076   if(string==NULL)
1077     {
1078       log_error(_("no = sign found in group definition `%s'\n"),name);
1079       return;
1080     }
1081
1082   trim_trailing_ws(name,strlen(name));
1083
1084   /* Does this group already exist? */
1085   for(item=opt.grouplist;item;item=item->next)
1086     if(strcasecmp(item->name,name)==0)
1087       break;
1088
1089   if(!item)
1090     {
1091       item=xmalloc(sizeof(struct groupitem));
1092       item->name=name;
1093       item->next=opt.grouplist;
1094       item->values=NULL;
1095       opt.grouplist=item;
1096     }
1097
1098   /* Break apart the values */
1099   while ((value= strsep(&string," \t")))
1100     {
1101       if (*value)
1102         add_to_strlist2(&item->values,value,utf8_strings);
1103     }
1104 }
1105
1106
1107 static void
1108 rm_group(char *name)
1109 {
1110   struct groupitem *item,*last=NULL;
1111
1112   trim_trailing_ws(name,strlen(name));
1113
1114   for(item=opt.grouplist;item;last=item,item=item->next)
1115     {
1116       if(strcasecmp(item->name,name)==0)
1117         {
1118           if(last)
1119             last->next=item->next;
1120           else
1121             opt.grouplist=item->next;
1122
1123           free_strlist(item->values);
1124           xfree(item);
1125           break;
1126         }
1127     }
1128 }
1129
1130
1131 /* We need to check three things.
1132
1133    0) The homedir.  It must be x00, a directory, and owned by the
1134    user.
1135
1136    1) The options/gpg.conf file.  Okay unless it or its containing
1137    directory is group or other writable or not owned by us.  Disable
1138    exec in this case.
1139
1140    Returns true if the item is unsafe. */
1141 static int
1142 check_permissions(const char *path,int item)
1143 {
1144 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1145   static int homedir_cache=-1;
1146   char *tmppath,*dir;
1147   struct stat statbuf,dirbuf;
1148   int homedir=0,ret=0,checkonly=0;
1149   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1150
1151   if(opt.no_perm_warn)
1152     return 0;
1153
1154   assert(item==0 || item==1 || item==2);
1155
1156   tmppath=xstrdup(path);
1157
1158   /* If the item is located in the homedir, but isn't the homedir,
1159      don't continue if we already checked the homedir itself.  This is
1160      to avoid user confusion with an extra options file warning which
1161      could be rectified if the homedir itself had proper
1162      permissions. */
1163   if(item!=0 && homedir_cache>-1
1164      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1165     {
1166       ret=homedir_cache;
1167       goto end;
1168     }
1169
1170   /* It's okay if the file or directory doesn't exist */
1171   if(stat(tmppath,&statbuf)!=0)
1172     {
1173       ret=0;
1174       goto end;
1175     }
1176
1177   /* Now check the enclosing directory.  Theoretically, we could walk
1178      this test up to the root directory /, but for the sake of sanity,
1179      I'm stopping at one level down. */
1180   dir=make_dirname(tmppath);
1181
1182   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1183     {
1184       /* Weird error */
1185       ret=1;
1186       goto end;
1187     }
1188
1189   xfree(dir);
1190
1191   /* Assume failure */
1192   ret=1;
1193
1194   if(item==0)
1195     {
1196       /* The homedir must be x00, a directory, and owned by the user. */
1197
1198       if(S_ISDIR(statbuf.st_mode))
1199         {
1200           if(statbuf.st_uid==getuid())
1201             {
1202               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1203                 ret=0;
1204               else
1205                 perm=1;
1206             }
1207           else
1208             own=1;
1209
1210           homedir_cache=ret;
1211         }
1212     }
1213   else if(item==1)
1214     {
1215       /* The options file.  Okay unless it or its
1216          containing directory is group or other writable or not owned
1217          by us or root. */
1218
1219       if(S_ISREG(statbuf.st_mode))
1220         {
1221           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1222             {
1223               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1224                 {
1225                   /* it's not writable, so make sure the enclosing
1226                      directory is also not writable */
1227                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1228                     {
1229                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1230                         ret=0;
1231                       else
1232                         enc_dir_perm=1;
1233                     }
1234                   else
1235                     enc_dir_own=1;
1236                 }
1237               else
1238                 {
1239                   /* it's writable, so the enclosing directory had
1240                      better not let people get to it. */
1241                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1242                     {
1243                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1244                         ret=0;
1245                       else
1246                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1247                     }
1248                   else
1249                     enc_dir_own=1;
1250                 }
1251             }
1252           else
1253             own=1;
1254         }
1255     }
1256   else
1257     BUG();
1258
1259   if(!checkonly)
1260     {
1261       if(own)
1262         {
1263           if(item==0)
1264             log_info(_("WARNING: unsafe ownership on"
1265                        " homedir `%s'\n"),tmppath);
1266           else
1267             log_info(_("WARNING: unsafe ownership on"
1268                        " configuration file `%s'\n"),tmppath);
1269         }
1270       if(perm)
1271         {
1272           if(item==0)
1273             log_info(_("WARNING: unsafe permissions on"
1274                        " homedir `%s'\n"),tmppath);
1275           else
1276             log_info(_("WARNING: unsafe permissions on"
1277                        " configuration file `%s'\n"),tmppath);
1278         }
1279       if(enc_dir_own)
1280         {
1281           if(item==0)
1282             log_info(_("WARNING: unsafe enclosing directory ownership on"
1283                        " homedir `%s'\n"),tmppath);
1284           else
1285             log_info(_("WARNING: unsafe enclosing directory ownership on"
1286                        " configuration file `%s'\n"),tmppath);
1287         }
1288       if(enc_dir_perm)
1289         {
1290           if(item==0)
1291             log_info(_("WARNING: unsafe enclosing directory permissions on"
1292                        " homedir `%s'\n"),tmppath);
1293           else
1294             log_info(_("WARNING: unsafe enclosing directory permissions on"
1295                        " configuration file `%s'\n"),tmppath);
1296         }
1297     }
1298
1299  end:
1300   xfree(tmppath);
1301
1302   if(homedir)
1303     homedir_cache=ret;
1304
1305   return ret;
1306
1307 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1308
1309   return 0;
1310 }
1311
1312 static void
1313 print_algo_numbers(int (*checker)(int))
1314 {
1315   int i,first=1;
1316
1317   for(i=0;i<=110;i++)
1318     {
1319       if(!checker(i))
1320         {
1321           if(first)
1322             first=0;
1323           else
1324             printf(";");
1325           printf("%d",i);
1326         }
1327     }
1328 }
1329
1330 static void
1331 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1332 {
1333   int i,first=1;
1334
1335   for(i=0;i<=110;i++)
1336     {
1337       if(!checker(i))
1338         {
1339           if(first)
1340             first=0;
1341           else
1342             printf(";");
1343           printf("%s",mapper(i));
1344         }
1345     }
1346 }
1347
1348 /* In the future, we can do all sorts of interesting configuration
1349    output here.  For now, just give "group" as the Enigmail folks need
1350    it, and pubkey, cipher, hash, and compress as they may be useful
1351    for frontends. */
1352 static void
1353 list_config(char *items)
1354 {
1355   int show_all=(items==NULL);
1356   char *name=NULL;
1357
1358   if(!opt.with_colons)
1359     return;
1360
1361   while(show_all || (name=strsep(&items," ")))
1362     {
1363       int any=0;
1364
1365       if(show_all || ascii_strcasecmp(name,"group")==0)
1366         {
1367           struct groupitem *iter;
1368
1369           for(iter=opt.grouplist;iter;iter=iter->next)
1370             {
1371               STRLIST sl;
1372
1373               printf("cfg:group:");
1374               print_string(stdout,iter->name,strlen(iter->name),':');
1375               printf(":");
1376
1377               for(sl=iter->values;sl;sl=sl->next)
1378                 {
1379                   print_string2(stdout,sl->d,strlen(sl->d),':',';');
1380                   if(sl->next)
1381                     printf(";");
1382                 }
1383
1384               printf("\n");
1385             }
1386
1387           any=1;
1388         }
1389
1390       if(show_all || ascii_strcasecmp(name,"version")==0)
1391         {
1392           printf("cfg:version:");
1393           print_string(stdout,VERSION,strlen(VERSION),':');
1394           printf("\n");
1395           any=1;
1396         }
1397
1398       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1399         {
1400           printf("cfg:pubkey:");
1401           print_algo_numbers(check_pubkey_algo);
1402           printf("\n");
1403           any=1;
1404         }
1405
1406       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1407         {
1408           printf("cfg:cipher:");
1409           print_algo_numbers(check_cipher_algo);
1410           printf("\n");
1411           any=1;
1412         }
1413
1414       if(show_all || ascii_strcasecmp(name,"ciphername")==0)
1415         {
1416           printf("cfg:ciphername:");
1417           print_algo_names(check_cipher_algo,cipher_algo_to_string);
1418           printf("\n");
1419           any=1;
1420         }
1421
1422       if(show_all
1423          || ascii_strcasecmp(name,"digest")==0
1424          || ascii_strcasecmp(name,"hash")==0)
1425         {
1426           printf("cfg:digest:");
1427           print_algo_numbers(check_digest_algo);
1428           printf("\n");
1429           any=1;
1430         }
1431
1432       if(show_all
1433          || ascii_strcasecmp(name,"digestname")==0
1434          || ascii_strcasecmp(name,"hashname")==0)
1435         {
1436           printf("cfg:digestname:");
1437           print_algo_names(check_digest_algo,digest_algo_to_string);
1438           printf("\n");
1439           any=1;
1440         }
1441
1442       if(show_all || ascii_strcasecmp(name,"compress")==0)
1443         {
1444           printf("cfg:compress:");
1445           print_algo_numbers(check_compress_algo);
1446           printf("\n");
1447           any=1;
1448         }
1449
1450       if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1451         {
1452 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
1453           char *p, *p2, *list = ccid_get_reader_list ();
1454
1455           for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1456             {
1457               *p2 = 0;
1458               printf("cfg:ccid-reader-id:%s\n", p);
1459             }
1460           free (list);
1461 #endif
1462           any=1;
1463         }
1464
1465       if(show_all)
1466         break;
1467
1468       if(!any)
1469         log_error(_("unknown configuration item `%s'\n"),name);
1470     }
1471 }
1472
1473
1474 /* List options and default values in the GPG Conf format.  This is a
1475    new tool distributed with gnupg 1.9.x but we also want some limited
1476    support in older gpg versions.  The output is the name of the
1477    configuration file and a list of options available for editing by
1478    gpgconf.  */
1479 static void
1480 gpgconf_list (const char *configfile)
1481 {
1482   /* The following definitions are taken from gnupg/tools/gpgconf-comp.c.  */
1483 #define GC_OPT_FLAG_NONE        0UL
1484 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1485
1486   printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1487           GC_OPT_FLAG_DEFAULT,configfile?configfile:"/dev/null");
1488   printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1489   printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1490   printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1491   printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1492 }
1493
1494
1495 static int
1496 parse_subpacket_list(char *list)
1497 {
1498   char *tok;
1499   byte subpackets[128],i;
1500   int count=0;
1501
1502   if(!list)
1503     {
1504       /* No arguments means all subpackets */
1505       memset(subpackets+1,1,sizeof(subpackets)-1);
1506       count=127;
1507     }
1508   else
1509     {
1510       memset(subpackets,0,sizeof(subpackets));
1511
1512       /* Merge with earlier copy */
1513       if(opt.show_subpackets)
1514         {
1515           byte *in;
1516
1517           for(in=opt.show_subpackets;*in;in++)
1518             {
1519               if(*in>127 || *in<1)
1520                 BUG();
1521
1522               if(!subpackets[*in])
1523                 count++;
1524               subpackets[*in]=1;
1525             }
1526         }
1527
1528       while((tok=strsep(&list," ,")))
1529         {
1530           if(!*tok)
1531             continue;
1532
1533           i=atoi(tok);
1534           if(i>127 || i<1)
1535             return 0;
1536
1537           if(!subpackets[i])
1538             count++;
1539           subpackets[i]=1;
1540         }
1541     }
1542
1543   xfree(opt.show_subpackets);
1544   opt.show_subpackets=xmalloc(count+1);
1545   opt.show_subpackets[count--]=0;
1546
1547   for(i=1;i<128 && count>=0;i++)
1548     if(subpackets[i])
1549       opt.show_subpackets[count--]=i;
1550
1551   return 1;
1552 }
1553
1554
1555 static int
1556 parse_list_options(char *str)
1557 {
1558   char *subpackets=""; /* something that isn't NULL */
1559   struct parse_options lopts[]=
1560     {
1561       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1562        N_("display photo IDs during key listings")},
1563       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1564        N_("show policy URLs during signature listings")},
1565       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1566        N_("show all notations during signature listings")},
1567       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1568        N_("show IETF standard notations during signature listings")},
1569       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1570        NULL},
1571       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1572        N_("show user-supplied notations during signature listings")},
1573       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1574        N_("show preferred keyserver URLs during signature listings")},
1575       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1576        N_("show user ID validity during key listings")},
1577       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1578        N_("show revoked and expired user IDs in key listings")},
1579       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1580        N_("show revoked and expired subkeys in key listings")},
1581       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1582        N_("show the keyring name in key listings")},
1583       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1584        N_("show expiration dates during signature listings")},
1585       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1586        NULL},
1587       {NULL,0,NULL,NULL}
1588     };
1589
1590   /* C99 allows for non-constant initializers, but we'd like to
1591      compile everywhere, so fill in the show-sig-subpackets argument
1592      here.  Note that if the parse_options array changes, we'll have
1593      to change the subscript here. */
1594   lopts[12].value=&subpackets;
1595
1596   if(parse_options(str,&opt.list_options,lopts,1))
1597     {
1598       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1599         {
1600           /* Unset so users can pass multiple lists in. */
1601           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1602           if(!parse_subpacket_list(subpackets))
1603             return 0;
1604         }
1605       else if(subpackets==NULL && opt.show_subpackets)
1606         {
1607           /* User did 'no-show-subpackets' */
1608           xfree(opt.show_subpackets);
1609           opt.show_subpackets=NULL;
1610         }
1611
1612       return 1;
1613     }
1614   else
1615     return 0;
1616 }
1617
1618
1619 /* Collapses argc/argv into a single string that must be freed */
1620 static char *
1621 collapse_args(int argc,char *argv[])
1622 {
1623   char *str=NULL;
1624   int i,first=1,len=0;
1625
1626   for(i=0;i<argc;i++)
1627     {
1628       len+=strlen(argv[i])+2;
1629       str=xrealloc(str,len);
1630       if(first)
1631         {
1632           str[0]='\0';
1633           first=0;
1634         }
1635       else
1636         strcat(str," ");
1637
1638       strcat(str,argv[i]);
1639     }
1640
1641   return str;
1642 }
1643
1644 static void
1645 parse_trust_model(const char *model)
1646 {
1647   if(ascii_strcasecmp(model,"pgp")==0)
1648     opt.trust_model=TM_PGP;
1649   else if(ascii_strcasecmp(model,"classic")==0)
1650     opt.trust_model=TM_CLASSIC;
1651   else if(ascii_strcasecmp(model,"always")==0)
1652     opt.trust_model=TM_ALWAYS;
1653   else if(ascii_strcasecmp(model,"direct")==0)
1654     opt.trust_model=TM_DIRECT;
1655   else if(ascii_strcasecmp(model,"auto")==0)
1656     opt.trust_model=TM_AUTO;
1657   else
1658     log_error("unknown trust model `%s'\n",model);
1659 }
1660
1661 /* Must be called before we open any files. */
1662 static void
1663 reopen_std(void)
1664 {
1665 #if defined(HAVE_STAT) && !defined(HAVE_W32_SYSTEM)
1666   struct stat statbuf;
1667   int did_stdin=0,did_stdout=0,did_stderr=0;
1668   FILE *complain;
1669
1670   if(fstat(STDIN_FILENO,&statbuf)==-1 && errno==EBADF)
1671     {
1672       if(open("/dev/null",O_RDONLY)==STDIN_FILENO)
1673         did_stdin=1;
1674       else
1675         did_stdin=2;
1676     }
1677
1678   if(fstat(STDOUT_FILENO,&statbuf)==-1 && errno==EBADF)
1679     {
1680       if(open("/dev/null",O_WRONLY)==STDOUT_FILENO)
1681         did_stdout=1;
1682       else
1683         did_stdout=2;
1684     }
1685
1686   if(fstat(STDERR_FILENO,&statbuf)==-1 && errno==EBADF)
1687     {
1688       if(open("/dev/null",O_WRONLY)==STDERR_FILENO)
1689         did_stderr=1;
1690       else
1691         did_stderr=2;
1692     }
1693
1694   /* It's hard to log this sort of thing since the filehandle we would
1695      complain to may be closed... */
1696   if(did_stderr==0)
1697     complain=stderr;
1698   else if(did_stdout==0)
1699     complain=stdout;
1700   else
1701     complain=NULL;
1702
1703   if(complain)
1704     {
1705       if(did_stdin==1)
1706         fprintf(complain,"gpg: WARNING: standard input reopened\n");
1707       if(did_stdout==1)
1708         fprintf(complain,"gpg: WARNING: standard output reopened\n");
1709       if(did_stderr==1)
1710         fprintf(complain,"gpg: WARNING: standard error reopened\n");
1711
1712       if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1713         fprintf(complain,"gpg: fatal: unable to reopen standard input,"
1714                 " output, or error\n");
1715     }
1716
1717   if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1718     exit(3);
1719 #endif /* HAVE_STAT && !HAVE_W32_SYSTEM */
1720 }
1721
1722 /* Pack an s2k iteration count into the form specified in 2440.  If
1723    we're in between valid values, round up. */
1724 static unsigned char
1725 encode_s2k_iterations(int iterations)
1726 {
1727   unsigned char c=0,result;
1728   unsigned int count;
1729
1730   if(iterations<=1024)
1731     return 0;
1732
1733   if(iterations>=65011712)
1734     return 255;
1735
1736   /* Need count to be in the range 16-31 */
1737   for(count=iterations>>6;count>=32;count>>=1)
1738     c++;
1739
1740   result=(c<<4)|(count-16);
1741
1742   if(S2K_DECODE_COUNT(result)<iterations)
1743     result++;
1744
1745   return result;
1746 }
1747
1748
1749 char *
1750 get_default_configname (void)
1751 {
1752   char *configname = NULL;
1753   char *name = xstrdup ("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1754   char *ver = &name[strlen ("gpg" EXTSEP_S "conf-")];
1755
1756   do
1757     {
1758       if (configname)
1759         {
1760           char *tok;
1761
1762           xfree (configname);
1763           configname = NULL;
1764
1765           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
1766             *tok='\0';
1767           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
1768             *tok='\0';
1769           else
1770             break;
1771         }
1772
1773       configname = make_filename (opt.homedir, name, NULL);
1774     }
1775   while (access (configname, R_OK));
1776
1777   xfree(name);
1778
1779   if (! configname)
1780     configname = make_filename (opt.homedir, "gpg" EXTSEP_S "conf", NULL);
1781   if (! access (configname, R_OK))
1782     {
1783       /* Print a warning when both config files are present.  */
1784       char *p = make_filename (opt.homedir, "options", NULL);
1785       if (! access (p, R_OK))
1786         log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1787       xfree (p);
1788     }
1789   else
1790     {
1791       /* Use the old default only if it exists.  */
1792       char *p = make_filename (opt.homedir, "options", NULL);
1793       if (!access (p, R_OK))
1794         {
1795           xfree (configname);
1796           configname = p;
1797         }
1798       else
1799         xfree (p);
1800     }
1801
1802   return configname;
1803 }
1804
1805
1806
1807 int
1808 main (int argc, char **argv )
1809 {
1810     ARGPARSE_ARGS pargs;
1811     IOBUF a;
1812     int rc=0;
1813     int orig_argc;
1814     char **orig_argv;
1815     const char *fname;
1816     char *username;
1817     int may_coredump;
1818     STRLIST sl, remusr= NULL, locusr=NULL;
1819     STRLIST nrings=NULL, sec_nrings=NULL;
1820     armor_filter_context_t afx;
1821     int detached_sig = 0;
1822     FILE *configfp = NULL;
1823     char *configname = NULL;
1824     char *save_configname = NULL;
1825     char *default_configname = NULL;
1826     unsigned configlineno;
1827     int parse_debug = 0;
1828     int default_config = 1;
1829     int default_keyring = 1;
1830     int greeting = 0;
1831     int nogreeting = 0;
1832     int use_random_seed = 1;
1833     enum cmd_and_opt_values cmd = 0;
1834     const char *trustdb_name = NULL;
1835     char *def_cipher_string = NULL;
1836     char *def_digest_string = NULL;
1837     char *compress_algo_string = NULL;
1838     char *cert_digest_string = NULL;
1839     char *s2k_cipher_string = NULL;
1840     char *s2k_digest_string = NULL;
1841     char *pers_cipher_list = NULL;
1842     char *pers_digest_list = NULL;
1843     char *pers_compress_list = NULL;
1844     int eyes_only=0;
1845     int multifile=0;
1846     int pwfd = -1;
1847     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
1848     int any_explicit_recipient = 0;
1849     int require_secmem=0,got_secmem=0;
1850 #ifdef USE_SHM_COPROCESSING
1851     ulong requested_shm_size=0;
1852 #endif
1853
1854 #ifdef __riscos__
1855     opt.lock_once = 1;
1856 #endif /* __riscos__ */
1857
1858 #ifdef __VMS
1859     /* On VMS, set the default value of the "--[no-]batch" flag
1860      * according to the actual process mode.  The user can override
1861      * this with an explicit command-line "--[no-]batch" option.  This
1862      * avoids that the process stops while trying to initialize the
1863      * tty in batch mode.  */
1864     opt.batch = batch_mode_vms();
1865 #endif
1866
1867     reopen_std();
1868     trap_unaligned();
1869     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
1870     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1871      * when adding any stuff between here and the call to
1872      * secmem_init()  somewhere after the option parsing
1873      */
1874     log_set_name("gpg");
1875     secure_randoxmalloc(); /* put random number into secure memory */
1876     may_coredump = disable_core_dumps();
1877     init_signals();
1878     dotlock_create (NULL, 0); /* Register locking cleanup.  */
1879     i18n_init();
1880     opt.command_fd = -1; /* no command fd */
1881     opt.compress_level = -1; /* defaults to standard compress level */
1882     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1883     /* note: if you change these lines, look at oOpenPGP */
1884     opt.def_cipher_algo = 0;
1885     opt.def_digest_algo = 0;
1886     opt.cert_digest_algo = 0;
1887     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1888     opt.s2k_mode = 3; /* iterated+salted */
1889     opt.s2k_count = 96; /* 65536 iterations */
1890     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
1891     opt.completes_needed = 1;
1892     opt.marginals_needed = 3;
1893     opt.max_cert_depth = 5;
1894     opt.pgp2_workarounds = 1;
1895     opt.escape_from = 1;
1896     opt.flags.require_cross_cert = 1;
1897     opt.import_options=IMPORT_SK2PK;
1898     opt.export_options=EXPORT_ATTRIBUTES;
1899     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1900     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1901     opt.keyserver_options.options=
1902       KEYSERVER_HONOR_KEYSERVER_URL|KEYSERVER_HONOR_PKA_RECORD;
1903     opt.verify_options=
1904       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1905     opt.trust_model=TM_AUTO;
1906     opt.mangle_dos_filenames=0;
1907     opt.min_cert_level=2;
1908     set_screen_dimensions();
1909     opt.keyid_format=KF_SHORT;
1910     opt.def_sig_expire="0";
1911     opt.def_cert_expire="0";
1912     set_homedir ( default_homedir () );
1913     opt.passwd_repeat=1;
1914     opt.emit_version = 0;
1915
1916 #ifdef ENABLE_CARD_SUPPORT
1917 #if defined(_WIN32) || defined(__CYGWIN__)
1918     opt.pcsc_driver = "winscard.dll";
1919 #elif defined(__APPLE__)
1920     opt.pcsc_driver = "/System/Library/Frameworks/PCSC.framework/PCSC";
1921 #elif defined(__GLIBC__)
1922     opt.pcsc_driver = "libpcsclite.so.1";
1923 #else
1924     opt.pcsc_driver = "libpcsclite.so";
1925 #endif
1926     opt.disable_keypad = 1;  /* No keypad support; use gpg2 instead.  */
1927 #endif /*ENABLE_CARD_SUPPORT*/
1928     opt.weak_digests = NULL;
1929     additional_weak_digest("MD5");
1930
1931     /* check whether we have a config file on the commandline */
1932     orig_argc = argc;
1933     orig_argv = argv;
1934     pargs.argc = &argc;
1935     pargs.argv = &argv;
1936     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1937     while( arg_parse( &pargs, opts) ) {
1938         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1939             parse_debug++;
1940         else if( pargs.r_opt == oOptions ) {
1941             /* yes there is one, so we do not try the default one, but
1942              * read the option file when it is encountered at the commandline
1943              */
1944             default_config = 0;
1945         }
1946         else if( pargs.r_opt == oNoOptions )
1947           {
1948             default_config = 0; /* --no-options */
1949             opt.no_homedir_creation = 1;
1950           }
1951         else if( pargs.r_opt == oHomedir )
1952             set_homedir ( pargs.r.ret_str );
1953         else if( pargs.r_opt == oNoPermissionWarn )
1954             opt.no_perm_warn=1;
1955         else if (pargs.r_opt == oStrict )
1956           {
1957             opt.strict=1;
1958             log_set_strict(1);
1959           }
1960         else if (pargs.r_opt == oNoStrict )
1961           {
1962             opt.strict=0;
1963             log_set_strict(0);
1964           }
1965 #ifdef USE_SHM_COPROCESSING
1966         else if( pargs.r_opt == oRunAsShmCP ) {
1967             /* does not make sense in a options file, we do it here,
1968              * so that we are the able to drop setuid as soon as possible */
1969             opt.shm_coprocess = 1;
1970             requested_shm_size = pargs.r.ret_ulong;
1971         }
1972         else if ( pargs.r_opt == oStatusFD ) {
1973             /* this is needed to ensure that the status-fd filedescriptor is
1974              * initialized when init_shm_coprocessing() is called */
1975             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1976         }
1977 #endif
1978     }
1979
1980 #ifdef HAVE_DOSISH_SYSTEM
1981     if ( strchr (opt.homedir,'\\') ) {
1982         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1983         const char *s = opt.homedir;
1984         for (d=buf,s=opt.homedir; *s; s++)
1985           {
1986             *d++ = *s == '\\'? '/': *s;
1987 #ifdef HAVE_W32_SYSTEM
1988             if (s[1] && IsDBCSLeadByte (*s))
1989               *d++ = *++s;
1990 #endif
1991           }
1992         *d = 0;
1993         set_homedir (buf);
1994     }
1995 #endif
1996 #ifdef USE_SHM_COPROCESSING
1997     if( opt.shm_coprocess ) {
1998         init_shm_coprocessing(requested_shm_size, 1 );
1999     }
2000 #endif
2001     /* initialize the secure memory. */
2002     got_secmem=secmem_init( SECMEM_BUFFER_SIZE );
2003     maybe_setuid = 0;
2004     /* Okay, we are now working under our real uid */
2005
2006 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2007     /* There should be no way to get to this spot while still carrying
2008        setuid privs.  Just in case, bomb out if we are. */
2009     if ( getuid () != geteuid () )
2010       BUG();
2011 #endif
2012
2013     set_native_charset (NULL); /* Try to auto set the character set */
2014
2015     /* Try for a version specific config file first */
2016     default_configname = get_default_configname ();
2017     if (default_config)
2018       configname = xstrdup (default_configname);
2019
2020     argc = orig_argc;
2021     argv = orig_argv;
2022     pargs.argc = &argc;
2023     pargs.argv = &argv;
2024     pargs.flags=  1;  /* do not remove the args */
2025
2026     /* By this point we have a homedir, and cannot change it. */
2027     check_permissions(opt.homedir,0);
2028
2029   next_pass:
2030     if( configname ) {
2031       if(check_permissions(configname,1))
2032         {
2033           /* If any options file is unsafe, then disable any external
2034              programs for keyserver calls or photo IDs.  Since the
2035              external program to call is set in the options file, a
2036              unsafe options file can lead to an arbitrary program
2037              being run. */
2038
2039           opt.exec_disable=1;
2040         }
2041
2042         configlineno = 0;
2043         configfp = fopen( configname, "r" );
2044         if (configfp && is_secured_file (fileno (configfp)))
2045           {
2046             fclose (configfp);
2047             configfp = NULL;
2048             errno = EPERM;
2049           }
2050         if( !configfp ) {
2051             if( default_config ) {
2052                 if( parse_debug )
2053                     log_info(_("NOTE: no default option file `%s'\n"),
2054                                                             configname );
2055             }
2056             else {
2057                 log_error(_("option file `%s': %s\n"),
2058                                     configname, strerror(errno) );
2059                 g10_exit(2);
2060             }
2061             xfree(configname); configname = NULL;
2062         }
2063         if( parse_debug && configname )
2064             log_info(_("reading options from `%s'\n"), configname );
2065         default_config = 0;
2066     }
2067
2068     while( optfile_parse( configfp, configname, &configlineno,
2069                                                 &pargs, opts) )
2070       {
2071         switch( pargs.r_opt )
2072           {
2073           case aCheckKeys:
2074           case aListConfig:
2075           case aGPGConfList:
2076           case aGPGConfTest:
2077           case aListPackets:
2078           case aImport:
2079           case aFastImport:
2080           case aSendKeys:
2081           case aRecvKeys:
2082           case aSearchKeys:
2083           case aRefreshKeys:
2084           case aFetchKeys:
2085           case aExport:
2086             set_cmd (&cmd, pargs.r_opt);
2087             break;
2088           case aListKeys: set_cmd( &cmd, aListKeys); break;
2089           case aListSigs: set_cmd( &cmd, aListSigs); break;
2090           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
2091           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
2092           case aDeleteSecretKeys:
2093             set_cmd( &cmd, aDeleteSecretKeys);
2094             greeting=1;
2095             break;
2096           case aDeleteSecretAndPublicKeys:
2097             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
2098             greeting=1;
2099             break;
2100           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
2101
2102           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2103           case aSym: set_cmd( &cmd, aSym); break;
2104
2105           case aDecryptFiles: multifile=1; /* fall through */
2106           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2107
2108           case aEncrFiles: multifile=1; /* fall through */
2109           case aEncr: set_cmd( &cmd, aEncr); break;
2110
2111           case aVerifyFiles: multifile=1; /* fall through */
2112           case aVerify: set_cmd( &cmd, aVerify); break;
2113
2114           case aSign: set_cmd( &cmd, aSign );  break;
2115           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
2116           case aSignKey: set_cmd( &cmd, aSignKey); break;
2117           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
2118           case aStore: set_cmd( &cmd, aStore); break;
2119           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
2120           case aClearsign: set_cmd( &cmd, aClearsign); break;
2121           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
2122           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
2123           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
2124           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
2125           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
2126           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
2127           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
2128           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
2129           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
2130           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
2131           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
2132           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
2133           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
2134           case aListOwnerTrust:
2135             deprecated_warning(configname,configlineno,
2136                                "--list-ownertrust","--export-ownertrust","");
2137           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
2138           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
2139           case aPipeMode:
2140             deprecated_command ("--pipemode");
2141             set_cmd( &cmd, aPipeMode);
2142             break;
2143
2144           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
2145
2146 #ifdef ENABLE_CARD_SUPPORT
2147           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
2148           case aCardEdit: set_cmd (&cmd, aCardEdit); break;
2149           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
2150           case oReaderPort:
2151             card_set_reader_port (pargs.r.ret_str);
2152             break;
2153           case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
2154           case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
2155           case oDisableCCID: opt.disable_ccid = 1; break;
2156 #endif /* ENABLE_CARD_SUPPORT*/
2157
2158           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2159           case oOutput: opt.outfile = pargs.r.ret_str; break;
2160           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2161           case oQuiet: opt.quiet = 1; break;
2162           case oNoTTY: tty_no_terminal(1); break;
2163           case oDryRun: opt.dry_run = 1; break;
2164           case oInteractive: opt.interactive = 1; break;
2165           case oVerbose:
2166             g10_opt_verbose++;
2167             opt.verbose++;
2168             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2169             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2170             break;
2171           case oKOption: set_cmd( &cmd, aKMode ); break;
2172
2173           case oBatch: opt.batch = 1; nogreeting = 1; break;
2174           case oUseAgent:
2175 #ifndef __riscos__
2176             opt.use_agent = 1;
2177 #else /* __riscos__ */
2178             opt.use_agent = 0;
2179             riscos_not_implemented("use-agent");
2180 #endif /* __riscos__ */
2181             break;
2182           case oNoUseAgent: opt.use_agent = 0; break;
2183           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
2184           case oAnswerYes: opt.answer_yes = 1; break;
2185           case oAnswerNo: opt.answer_no = 1; break;
2186           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2187           case oPrimaryKeyring:
2188             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2189             sl->flags=2;
2190             break;
2191           case oShowKeyring:
2192             deprecated_warning(configname,configlineno,"--show-keyring",
2193                                "--list-options ","show-keyring");
2194             opt.list_options|=LIST_SHOW_KEYRING;
2195             break;
2196           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2197           case oDebugAll: opt.debug = ~0; break;
2198           case oDebugLevel: break; /* Not supported.  */
2199           case oDebugCCIDDriver:
2200 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
2201             ccid_set_debug_level (ccid_set_debug_level (1)+1);
2202 #endif
2203             break;
2204           case oStatusFD:
2205             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
2206             break;
2207           case oStatusFile:
2208             set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
2209             break;
2210           case oAttributeFD:
2211             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
2212             break;
2213           case oAttributeFile:
2214             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
2215             break;
2216           case oLoggerFD:
2217             log_set_logfile( NULL,
2218                              iobuf_translate_file_handle (pargs.r.ret_int, 1));
2219             break;
2220           case oLoggerFile:
2221             /* Our log code does not support the socket feature.  Thus
2222                we ignore such log files to avoid problems with
2223                gpg.conf files which are also used by gpg2.  */
2224             if (strncmp (pargs.r.ret_str, "socket://", 9))
2225               log_set_logfile( NULL, open_info_file (pargs.r.ret_str, 1) );
2226             break;
2227
2228           case oWithFingerprint:
2229             opt.with_fingerprint = 1;
2230             opt.fingerprint++;
2231             break;
2232           case oFingerprint:
2233             opt.fingerprint++;
2234             fpr_maybe_cmd = 1;
2235             break;
2236
2237           case oSecretKeyring:
2238             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2239             break;
2240           case oOptions:
2241             /* config files may not be nested (silently ignore them) */
2242             if( !configfp ) {
2243                 xfree(configname);
2244                 configname = xstrdup(pargs.r.ret_str);
2245                 goto next_pass;
2246             }
2247             break;
2248           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2249           case oNoDefKeyring: default_keyring = 0; break;
2250           case oNoGreeting: nogreeting = 1; break;
2251           case oNoVerbose: g10_opt_verbose = 0;
2252                            opt.verbose = 0; opt.list_sigs=0; break;
2253           case oQuickRandom: quick_random_gen(1); break;
2254           case oEmitVersion: opt.emit_version++; break;
2255           case oNoEmitVersion: opt.emit_version=0; break;
2256           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2257           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2258           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2259           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2260           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2261           case oDefRecipient:
2262                     if( *pargs.r.ret_str )
2263                         opt.def_recipient = make_username(pargs.r.ret_str);
2264                     break;
2265           case oDefRecipientSelf:
2266                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2267                     opt.def_recipient_self = 1;
2268                     break;
2269           case oNoDefRecipient:
2270                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2271                     opt.def_recipient_self = 0;
2272                     break;
2273           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2274           case oHomedir: break;
2275           case oNoBatch: opt.batch = 0; break;
2276           case oWithKeyData: opt.with_key_data=1; /* fall thru */
2277           case oWithColons: opt.with_colons=':'; break;
2278
2279           case oSkipVerify: opt.skip_verify=1; break;
2280           case oCompressKeys: opt.compress_keys = 1; break;
2281           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2282             /* There are many programs (like mutt) that call gpg with
2283                --always-trust so keep this option around for a long
2284                time. */
2285           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2286           case oTrustModel:
2287             parse_trust_model(pargs.r.ret_str);
2288             break;
2289           case oForceOwnertrust:
2290             log_info(_("NOTE: %s is not for normal use!\n"),
2291                      "--force-ownertrust");
2292             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2293             if(opt.force_ownertrust==-1)
2294               {
2295                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2296                 opt.force_ownertrust=0;
2297               }
2298             break;
2299           case oLoadExtension:
2300             break;  /* This is a dummy option since 1.4.13.  */
2301           case oRFC1991:
2302             opt.compliance = CO_RFC1991;
2303             opt.force_v4_certs = 0;
2304             opt.escape_from = 1;
2305             break;
2306           case oOpenPGP:
2307           case oRFC4880:
2308             /* This is effectively the same as RFC2440, but with
2309                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2310                --require-cross-certification". */
2311             opt.compliance = CO_RFC4880;
2312             opt.flags.dsa2 = 1;
2313             opt.flags.require_cross_cert = 1;
2314             opt.rfc2440_text = 0;
2315             opt.allow_non_selfsigned_uid = 1;
2316             opt.allow_freeform_uid = 1;
2317             opt.pgp2_workarounds = 0;
2318             opt.escape_from = 1;
2319             opt.force_v3_sigs = 0;
2320             opt.compress_keys = 0;          /* not mandated, but we do it */
2321             opt.compress_sigs = 0;          /* ditto. */
2322             opt.not_dash_escaped = 0;
2323             opt.def_cipher_algo = 0;
2324             opt.def_digest_algo = 0;
2325             opt.cert_digest_algo = 0;
2326             opt.compress_algo = -1;
2327             opt.s2k_mode = 3; /* iterated+salted */
2328             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2329             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2330             break;
2331           case oRFC2440:
2332             opt.compliance = CO_RFC2440;
2333             opt.flags.dsa2 = 0;
2334             opt.rfc2440_text = 1;
2335             opt.allow_non_selfsigned_uid = 1;
2336             opt.allow_freeform_uid = 1;
2337             opt.pgp2_workarounds = 0;
2338             opt.escape_from = 0;
2339             opt.force_v3_sigs = 0;
2340             opt.compress_keys = 0;          /* not mandated, but we do it */
2341             opt.compress_sigs = 0;          /* ditto. */
2342             opt.not_dash_escaped = 0;
2343             opt.def_cipher_algo = 0;
2344             opt.def_digest_algo = 0;
2345             opt.cert_digest_algo = 0;
2346             opt.compress_algo = -1;
2347             opt.s2k_mode = 3; /* iterated+salted */
2348             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2349             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2350             break;
2351           case oPGP2:  opt.compliance = CO_PGP2;  break;
2352           case oPGP6:  opt.compliance = CO_PGP6;  break;
2353           case oPGP7:  opt.compliance = CO_PGP7;  break;
2354           case oPGP8:  opt.compliance = CO_PGP8;  break;
2355           case oGnuPG: opt.compliance = CO_GNUPG; break;
2356           case oCompressSigs: opt.compress_sigs = 1; break;
2357           case oRFC2440Text: opt.rfc2440_text=1; break;
2358           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2359           case oRunAsShmCP:
2360 #ifndef __riscos__
2361 # ifndef USE_SHM_COPROCESSING
2362             /* not possible in the option file,
2363              * but we print the warning here anyway */
2364             log_error("shared memory coprocessing is not available\n");
2365 # endif
2366 #else /* __riscos__ */
2367             riscos_not_implemented("run-as-shm-coprocess");
2368 #endif /* __riscos__ */
2369             break;
2370           case oSetFilename:
2371             if(utf8_strings)
2372               opt.set_filename = pargs.r.ret_str;
2373             else
2374               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2375             break;
2376           case oForYourEyesOnly: eyes_only = 1; break;
2377           case oNoForYourEyesOnly: eyes_only = 0; break;
2378           case oSetPolicyURL:
2379             add_policy_url(pargs.r.ret_str,0);
2380             add_policy_url(pargs.r.ret_str,1);
2381             break;
2382           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2383           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2384           case oShowPolicyURL:
2385             deprecated_warning(configname,configlineno,"--show-policy-url",
2386                                "--list-options ","show-policy-urls");
2387             deprecated_warning(configname,configlineno,"--show-policy-url",
2388                                "--verify-options ","show-policy-urls");
2389             opt.list_options|=LIST_SHOW_POLICY_URLS;
2390             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2391             break;
2392           case oNoShowPolicyURL:
2393             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2394                                "--list-options ","no-show-policy-urls");
2395             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2396                                "--verify-options ","no-show-policy-urls");
2397             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2398             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2399             break;
2400           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2401           case oUseEmbeddedFilename:
2402             opt.flags.use_embedded_filename=1;
2403             break;
2404           case oNoUseEmbeddedFilename:
2405             opt.flags.use_embedded_filename=0;
2406             break;
2407           case oComment:
2408             if(pargs.r.ret_str[0])
2409               append_to_strlist(&opt.comments,pargs.r.ret_str);
2410             break;
2411           case oDefaultComment:
2412             deprecated_warning(configname,configlineno,
2413                                "--default-comment","--no-comments","");
2414             /* fall through */
2415           case oNoComments:
2416             free_strlist(opt.comments);
2417             opt.comments=NULL;
2418             break;
2419           case oThrowKeyids: opt.throw_keyid = 1; break;
2420           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2421           case oShowPhotos:
2422             deprecated_warning(configname,configlineno,"--show-photos",
2423                                "--list-options ","show-photos");
2424             deprecated_warning(configname,configlineno,"--show-photos",
2425                                "--verify-options ","show-photos");
2426             opt.list_options|=LIST_SHOW_PHOTOS;
2427             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2428             break;
2429           case oNoShowPhotos:
2430             deprecated_warning(configname,configlineno,"--no-show-photos",
2431                                "--list-options ","no-show-photos");
2432             deprecated_warning(configname,configlineno,"--no-show-photos",
2433                                "--verify-options ","no-show-photos");
2434             opt.list_options&=~LIST_SHOW_PHOTOS;
2435             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2436             break;
2437           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2438           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2439           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2440           case oForceV4Certs: opt.force_v4_certs = 1; break;
2441           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2442           case oForceMDC: opt.force_mdc = 1; break;
2443           case oNoForceMDC: opt.force_mdc = 0; break;
2444           case oDisableMDC: opt.disable_mdc = 1; break;
2445           case oNoDisableMDC: opt.disable_mdc = 0; break;
2446           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2447           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2448           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2449           case oS2KCount:
2450             opt.s2k_count=encode_s2k_iterations(pargs.r.ret_int);
2451             break;
2452           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2453           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2454           case oEncryptTo: /* store the recipient in the second list */
2455             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2456             sl->flags = 1;
2457             break;
2458           case oHiddenEncryptTo: /* store the recipient in the second list */
2459             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2460             sl->flags = 1|2;
2461             break;
2462           case oRecipient: /* store the recipient */
2463             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2464             any_explicit_recipient = 1;
2465             break;
2466           case oHiddenRecipient: /* store the recipient with a flag */
2467             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2468             sl->flags = 2;
2469             any_explicit_recipient = 1;
2470             break;
2471           case oTextmodeShort: opt.textmode = 2; break;
2472           case oTextmode: opt.textmode=1;  break;
2473           case oNoTextmode: opt.textmode=0;  break;
2474           case oExpert: opt.expert = 1; break;
2475           case oNoExpert: opt.expert = 0; break;
2476           case oDefSigExpire:
2477             if(*pargs.r.ret_str!='\0')
2478               {
2479                 if(parse_expire_string(0,pargs.r.ret_str)==(u32)-1)
2480                   log_error(_("`%s' is not a valid signature expiration\n"),
2481                             pargs.r.ret_str);
2482                 else
2483                   opt.def_sig_expire=pargs.r.ret_str;
2484               }
2485             break;
2486           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2487           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2488           case oDefCertExpire:
2489             if(*pargs.r.ret_str!='\0')
2490               {
2491                 if(parse_expire_string(0,pargs.r.ret_str)==(u32)-1)
2492                   log_error(_("`%s' is not a valid signature expiration\n"),
2493                             pargs.r.ret_str);
2494                 else
2495                   opt.def_cert_expire=pargs.r.ret_str;
2496               }
2497             break;
2498           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2499           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2500           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2501           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2502           case oAskCertLevel: opt.ask_cert_level = 1; break;
2503           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2504           case oLocalUser: /* store the local users */
2505             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2506             break;
2507           case oCompress:
2508             /* this is the -z command line option */
2509             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2510             break;
2511           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2512           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2513           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2514           case oPasswd:
2515             set_passphrase_from_string(pargs.r.ret_str);
2516             break;
2517           case oPasswdFD:
2518             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2519             opt.use_agent = 0;
2520             break;
2521           case oPasswdFile:
2522             pwfd = open_info_file (pargs.r.ret_str, 0);
2523             break;
2524           case oPasswdRepeat: opt.passwd_repeat=pargs.r.ret_int; break;
2525           case oCommandFD:
2526             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2527             break;
2528           case oCommandFile:
2529             opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2530             break;
2531           case oCipherAlgo:
2532             def_cipher_string = xstrdup(pargs.r.ret_str);
2533             break;
2534           case oDigestAlgo:
2535             def_digest_string = xstrdup(pargs.r.ret_str);
2536             break;
2537           case oCompressAlgo:
2538             /* If it is all digits, stick a Z in front of it for
2539                later.  This is for backwards compatibility with
2540                versions that took the compress algorithm number. */
2541             {
2542               char *pt=pargs.r.ret_str;
2543               while(*pt)
2544                 {
2545                   if (!isascii (*pt) || !isdigit (*pt))
2546                     break;
2547
2548                   pt++;
2549                 }
2550
2551               if(*pt=='\0')
2552                 {
2553                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2554                   strcpy(compress_algo_string,"Z");
2555                   strcat(compress_algo_string,pargs.r.ret_str);
2556                 }
2557               else
2558                 compress_algo_string = xstrdup(pargs.r.ret_str);
2559             }
2560             break;
2561           case oCertDigestAlgo: cert_digest_string = xstrdup(pargs.r.ret_str); break;
2562           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
2563           case oRequireSecmem: require_secmem=1; break;
2564           case oNoRequireSecmem: require_secmem=0; break;
2565           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2566           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2567           case oDisplayCharset:
2568             if( set_native_charset( pargs.r.ret_str ) )
2569                 log_error(_("`%s' is not a valid character set\n"),
2570                           pargs.r.ret_str);
2571             break;
2572           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2573           case oEscapeFrom: opt.escape_from = 1; break;
2574           case oNoEscapeFrom: opt.escape_from = 0; break;
2575           case oLockOnce: opt.lock_once = 1; break;
2576           case oLockNever:
2577             dotlock_disable ();
2578             random_disable_locking ();
2579             break;
2580           case oLockMultiple:
2581 #ifndef __riscos__
2582             opt.lock_once = 0;
2583 #else /* __riscos__ */
2584             riscos_not_implemented("lock-multiple");
2585 #endif /* __riscos__ */
2586             break;
2587           case oKeyServer:
2588             {
2589               struct keyserver_spec *keyserver;
2590               keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2591                                             configname,configlineno);
2592               if(!keyserver)
2593                 log_error(_("could not parse keyserver URL\n"));
2594               else
2595                 {
2596                   keyserver->next=opt.keyserver;
2597                   opt.keyserver=keyserver;
2598                 }
2599             }
2600             break;
2601           case oKeyServerOptions:
2602             if(!parse_keyserver_options(pargs.r.ret_str))
2603               {
2604                 if(configname)
2605                   log_error(_("%s:%d: invalid keyserver options\n"),
2606                             configname,configlineno);
2607                 else
2608                   log_error(_("invalid keyserver options\n"));
2609               }
2610             break;
2611           case oImportOptions:
2612             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2613               {
2614                 if(configname)
2615                   log_error(_("%s:%d: invalid import options\n"),
2616                             configname,configlineno);
2617                 else
2618                   log_error(_("invalid import options\n"));
2619               }
2620             break;
2621           case oExportOptions:
2622             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2623               {
2624                 if(configname)
2625                   log_error(_("%s:%d: invalid export options\n"),
2626                             configname,configlineno);
2627                 else
2628                   log_error(_("invalid export options\n"));
2629               }
2630             break;
2631           case oListOptions:
2632             if(!parse_list_options(pargs.r.ret_str))
2633               {
2634                 if(configname)
2635                   log_error(_("%s:%d: invalid list options\n"),
2636                             configname,configlineno);
2637                 else
2638                   log_error(_("invalid list options\n"));
2639               }
2640             break;
2641           case oVerifyOptions:
2642             {
2643               struct parse_options vopts[]=
2644                 {
2645                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2646                    N_("display photo IDs during signature verification")},
2647                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2648                    N_("show policy URLs during signature verification")},
2649                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2650                    N_("show all notations during signature verification")},
2651                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2652                    N_("show IETF standard notations during signature verification")},
2653                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2654                    NULL},
2655                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2656                    N_("show user-supplied notations during signature verification")},
2657                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2658                    N_("show preferred keyserver URLs during signature verification")},
2659                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2660                    N_("show user ID validity during signature verification")},
2661                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2662                    N_("show revoked and expired user IDs in signature verification")},
2663                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
2664                    N_("show only the primary user ID in signature verification")},
2665                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2666                    N_("validate signatures with PKA data")},
2667                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2668                    N_("elevate the trust of signatures with valid PKA data")},
2669                   {NULL,0,NULL,NULL}
2670                 };
2671
2672               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2673                 {
2674                   if(configname)
2675                     log_error(_("%s:%d: invalid verify options\n"),
2676                               configname,configlineno);
2677                   else
2678                     log_error(_("invalid verify options\n"));
2679                 }
2680             }
2681             break;
2682           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2683           case oExecPath:
2684             if(set_exec_path(pargs.r.ret_str))
2685               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2686             else
2687               opt.exec_path_set=1;
2688             break;
2689           case oSetNotation:
2690             add_notation_data( pargs.r.ret_str, 0 );
2691             add_notation_data( pargs.r.ret_str, 1 );
2692             break;
2693           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2694           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2695           case oShowNotation:
2696             deprecated_warning(configname,configlineno,"--show-notation",
2697                                "--list-options ","show-notations");
2698             deprecated_warning(configname,configlineno,"--show-notation",
2699                                "--verify-options ","show-notations");
2700             opt.list_options|=LIST_SHOW_NOTATIONS;
2701             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2702             break;
2703           case oNoShowNotation:
2704             deprecated_warning(configname,configlineno,"--no-show-notation",
2705                                "--list-options ","no-show-notations");
2706             deprecated_warning(configname,configlineno,"--no-show-notation",
2707                                "--verify-options ","no-show-notations");
2708             opt.list_options&=~LIST_SHOW_NOTATIONS;
2709             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2710             break;
2711           case oUtf8Strings: utf8_strings = 1; break;
2712           case oNoUtf8Strings: utf8_strings = 0; break;
2713           case oDisableCipherAlgo:
2714                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
2715                 break;
2716           case oDisablePubkeyAlgo:
2717                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
2718                 break;
2719           case oNoSigCache: opt.no_sig_cache = 1; break;
2720           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2721           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2722           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2723           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2724           case oNoLiteral: opt.no_literal = 1; break;
2725           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2726           case oHonorHttpProxy:
2727                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2728                 deprecated_warning(configname,configlineno,
2729                                    "--honor-http-proxy",
2730                                    "--keyserver-options ","http-proxy");
2731                 break;
2732           case oFastListMode: opt.fast_list_mode = 1; break;
2733           case oFixedListMode: opt.fixed_list_mode = 1; break;
2734           case oListOnly: opt.list_only=1; break;
2735           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2736           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2737           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2738           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2739           case oNoRandomSeedFile: use_random_seed = 0; break;
2740           case oAutoKeyRetrieve:
2741           case oNoAutoKeyRetrieve:
2742                 if(pargs.r_opt==oAutoKeyRetrieve)
2743                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2744                 else
2745                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2746
2747                 deprecated_warning(configname,configlineno,
2748                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2749                                "--no-auto-key-retrieve","--keyserver-options ",
2750                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2751                                "no-auto-key-retrieve");
2752                 break;
2753           case oShowSessionKey: opt.show_session_key = 1; break;
2754           case oOverrideSessionKey:
2755                 opt.override_session_key = pargs.r.ret_str;
2756                 break;
2757           case oMergeOnly:
2758                 deprecated_warning(configname,configlineno,"--merge-only",
2759                                    "--import-options ","merge-only");
2760                 opt.import_options|=IMPORT_MERGE_ONLY;
2761             break;
2762           case oAllowSecretKeyImport: /* obsolete */ break;
2763           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2764           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2765           case oEnableSpecialFilenames:
2766             iobuf_enable_special_filenames (1);
2767             break;
2768           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2769           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2770           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2771           case oPreservePermissions: opt.preserve_permissions=1; break;
2772           case oDefaultPreferenceList:
2773             opt.def_preference_list = pargs.r.ret_str;
2774             break;
2775           case oDefaultKeyserverURL:
2776             {
2777               struct keyserver_spec *keyserver;
2778               keyserver=parse_keyserver_uri(pargs.r.ret_str,1,
2779                                             configname,configlineno);
2780               if(!keyserver)
2781                 log_error(_("could not parse keyserver URL\n"));
2782               else
2783                 free_keyserver_spec(keyserver);
2784
2785               opt.def_keyserver_url = pargs.r.ret_str;
2786             }
2787             break;
2788           case oPersonalCipherPreferences:
2789             pers_cipher_list=pargs.r.ret_str;
2790             break;
2791           case oPersonalDigestPreferences:
2792             pers_digest_list=pargs.r.ret_str;
2793             break;
2794           case oPersonalCompressPreferences:
2795             pers_compress_list=pargs.r.ret_str;
2796             break;
2797           case oDisplay: opt.display = pargs.r.ret_str; break;
2798           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2799           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2800           case oWeakDigest:
2801             additional_weak_digest(pargs.r.ret_str);
2802             break;
2803           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2804           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2805           case oGroup: add_group(pargs.r.ret_str); break;
2806           case oUnGroup: rm_group(pargs.r.ret_str); break;
2807           case oNoGroups:
2808             while(opt.grouplist)
2809               {
2810                 struct groupitem *iter=opt.grouplist;
2811                 free_strlist(iter->values);
2812                 opt.grouplist=opt.grouplist->next;
2813                 xfree(iter);
2814               }
2815             break;
2816           case oStrict: opt.strict=1; log_set_strict(1); break;
2817           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2818           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2819           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2820           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2821           case oMultifile: multifile=1; break;
2822           case oKeyidFormat:
2823             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2824               opt.keyid_format=KF_SHORT;
2825             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2826               opt.keyid_format=KF_LONG;
2827             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2828               opt.keyid_format=KF_0xSHORT;
2829             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2830               opt.keyid_format=KF_0xLONG;
2831             else
2832               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2833             break;
2834
2835           case oExitOnStatusWriteError:
2836             opt.exit_on_status_write_error = 1;
2837             break;
2838
2839           case oLimitCardInsertTries:
2840             opt.limit_card_insert_tries = pargs.r.ret_int;
2841             break;
2842
2843           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2844           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2845
2846           case oAutoKeyLocate:
2847             if(!parse_auto_key_locate(pargs.r.ret_str))
2848               {
2849                 if(configname)
2850                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2851                             configname,configlineno);
2852                 else
2853                   log_error(_("invalid auto-key-locate list\n"));
2854               }
2855             break;
2856           case oNoAutoKeyLocate:
2857             release_akl();
2858             break;
2859
2860           case oEnableLargeRSA:
2861 #if SECMEM_BUFFER_SIZE >= 65536
2862             opt.flags.large_rsa=1;
2863 #else
2864             if (configname)
2865               log_info("%s:%d: WARNING: gpg not built with large secure "
2866                          "memory buffer.  Ignoring enable-large-rsa\n",
2867                         configname,configlineno);
2868             else
2869               log_info("WARNING: gpg not built with large secure "
2870                          "memory buffer.  Ignoring --enable-large-rsa\n");
2871 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
2872             break;
2873           case oDisableLargeRSA: opt.flags.large_rsa=0;
2874             break;
2875
2876           case oEnableDSA2: opt.flags.dsa2=1; break;
2877           case oDisableDSA2: opt.flags.dsa2=0; break;
2878
2879           case oAllowMultisigVerification:
2880           case oAllowMultipleMessages:
2881             opt.flags.allow_multiple_messages=1;
2882             break;
2883
2884           case oNoAllowMultipleMessages:
2885             opt.flags.allow_multiple_messages=0;
2886             break;
2887
2888           case oAllowWeakDigestAlgos:
2889             opt.flags.allow_weak_digest_algos = 1;
2890             break;
2891
2892           case oNoop: break;
2893
2894           default : pargs.err = configfp? 1:2; break;
2895           }
2896       }
2897
2898
2899     if( configfp ) {
2900         fclose( configfp );
2901         configfp = NULL;
2902         /* Remember the first config file name. */
2903         if (!save_configname)
2904           save_configname = configname;
2905         else
2906           xfree(configname);
2907         configname = NULL;
2908         goto next_pass;
2909     }
2910     xfree( configname ); configname = NULL;
2911     if( log_get_errorcount(0) )
2912         g10_exit(2);
2913
2914     /* The command --gpgconf-list is pretty simple and may be called
2915        directly after the option parsing. */
2916     if (cmd == aGPGConfList)
2917       {
2918         gpgconf_list (save_configname ? save_configname : default_configname);
2919         g10_exit (0);
2920       }
2921     xfree (save_configname);
2922     xfree (default_configname);
2923
2924     if( nogreeting )
2925         greeting = 0;
2926
2927     if( greeting ) {
2928         fprintf(stderr, "%s %s; %s\n",
2929                         strusage(11), strusage(13), strusage(14) );
2930         fprintf(stderr, "%s\n", strusage(15) );
2931     }
2932 #ifdef IS_DEVELOPMENT_VERSION
2933     if( !opt.batch )
2934       {
2935         const char *s;
2936
2937         if((s=strusage(20)))
2938           log_info("%s\n",s);
2939         if((s=strusage(21)))
2940           log_info("%s\n",s);
2941         if((s=strusage(22)))
2942           log_info("%s\n",s);
2943       }
2944 #endif
2945
2946     if (opt.verbose > 2)
2947         log_info ("using character set `%s'\n", get_native_charset ());
2948
2949     if( may_coredump && !opt.quiet )
2950         log_info(_("WARNING: program may create a core file!\n"));
2951
2952     if (eyes_only) {
2953       if (opt.set_filename)
2954           log_info(_("WARNING: %s overrides %s\n"),
2955                    "--for-your-eyes-only","--set-filename");
2956
2957       opt.set_filename="_CONSOLE";
2958     }
2959
2960     if (opt.no_literal) {
2961         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2962         if (opt.textmode)
2963             log_error(_("%s not allowed with %s!\n"),
2964                        "--textmode", "--no-literal" );
2965         if (opt.set_filename)
2966             log_error(_("%s makes no sense with %s!\n"),
2967                         eyes_only?"--for-your-eyes-only":"--set-filename",
2968                         "--no-literal" );
2969     }
2970
2971 #ifndef ENABLE_AGENT_SUPPORT
2972     if (opt.use_agent) {
2973       log_info(_("NOTE: %s is not available in this version\n"),
2974                "--use-agent");
2975       opt.use_agent = 0;
2976     }
2977 #endif /*!ENABLE_AGENT_SUPPORT*/
2978
2979     if (opt.set_filesize)
2980         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2981     if( opt.batch )
2982         tty_batchmode( 1 );
2983
2984     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2985
2986     if(require_secmem && !got_secmem)
2987       {
2988         log_info(_("will not run with insecure memory due to %s\n"),
2989                  "--require-secmem");
2990         g10_exit(2);
2991       }
2992
2993     set_debug();
2994
2995     /* Do these after the switch(), so they can override settings. */
2996     if(PGP2)
2997       {
2998         int unusable=0;
2999
3000         if(cmd==aSign && !detached_sig)
3001           {
3002             log_info(_("you can only make detached or clear signatures "
3003                        "while in --pgp2 mode\n"));
3004             unusable=1;
3005           }
3006         else if(cmd==aSignEncr || cmd==aSignSym)
3007           {
3008             log_info(_("you can't sign and encrypt at the "
3009                        "same time while in --pgp2 mode\n"));
3010             unusable=1;
3011           }
3012         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
3013           {
3014             log_info(_("you must use files (and not a pipe) when "
3015                        "working with --pgp2 enabled.\n"));
3016             unusable=1;
3017           }
3018         else if(cmd==aEncr || cmd==aSym)
3019           {
3020             /* Everything else should work without IDEA (except using
3021                a secret key encrypted with IDEA and setting an IDEA
3022                preference, but those have their own error
3023                messages). */
3024
3025             if(check_cipher_algo(CIPHER_ALGO_IDEA))
3026               {
3027                 log_info(_("encrypting a message in --pgp2 mode requires "
3028                            "the IDEA cipher\n"));
3029                 unusable=1;
3030               }
3031             else if(cmd==aSym)
3032               {
3033                 /* This only sets IDEA for symmetric encryption
3034                    since it is set via select_algo_from_prefs for
3035                    pk encryption. */
3036                 xfree(def_cipher_string);
3037                 def_cipher_string = xstrdup("idea");
3038               }
3039
3040             /* PGP2 can't handle the output from the textmode
3041                filter, so we disable it for anything that could
3042                create a literal packet (only encryption and
3043                symmetric encryption, since we disable signing
3044                above). */
3045             if(!unusable)
3046               opt.textmode=0;
3047           }
3048
3049         if(unusable)
3050           compliance_failure();
3051         else
3052           {
3053             opt.force_v4_certs = 0;
3054             opt.escape_from = 1;
3055             opt.force_v3_sigs = 1;
3056             opt.pgp2_workarounds = 1;
3057             opt.ask_sig_expire = 0;
3058             opt.ask_cert_expire = 0;
3059             opt.flags.allow_weak_digest_algos = 1;
3060             xfree(def_digest_string);
3061             def_digest_string = xstrdup("md5");
3062             xfree(s2k_digest_string);
3063             s2k_digest_string = xstrdup("md5");
3064             opt.compress_algo = COMPRESS_ALGO_ZIP;
3065           }
3066       }
3067     else if(PGP6)
3068       {
3069         opt.disable_mdc=1;
3070         opt.escape_from=1;
3071         opt.force_v3_sigs=1;
3072         opt.ask_sig_expire=0;
3073       }
3074     else if(PGP7)
3075       {
3076         opt.escape_from=1;
3077         opt.force_v3_sigs=1;
3078         opt.ask_sig_expire=0;
3079       }
3080     else if(PGP8)
3081       {
3082         opt.escape_from=1;
3083       }
3084
3085     /* must do this after dropping setuid, because string_to...
3086      * may try to load an module */
3087     if( def_cipher_string ) {
3088         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
3089         xfree(def_cipher_string); def_cipher_string = NULL;
3090         if( check_cipher_algo(opt.def_cipher_algo) )
3091             log_error(_("selected cipher algorithm is invalid\n"));
3092     }
3093     if( def_digest_string ) {
3094         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
3095         xfree(def_digest_string); def_digest_string = NULL;
3096         if( check_digest_algo(opt.def_digest_algo) )
3097             log_error(_("selected digest algorithm is invalid\n"));
3098     }
3099     if( compress_algo_string ) {
3100         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3101         xfree(compress_algo_string); compress_algo_string = NULL;
3102         if( check_compress_algo(opt.compress_algo) )
3103             log_error(_("selected compression algorithm is invalid\n"));
3104     }
3105     if( cert_digest_string ) {
3106         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
3107         xfree(cert_digest_string); cert_digest_string = NULL;
3108         if( check_digest_algo(opt.cert_digest_algo) )
3109             log_error(_("selected certification digest algorithm is invalid\n"));
3110     }
3111     if( s2k_cipher_string ) {
3112         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
3113         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3114         if( check_cipher_algo(opt.s2k_cipher_algo) )
3115             log_error(_("selected cipher algorithm is invalid\n"));
3116     }
3117     if( s2k_digest_string ) {
3118         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
3119         xfree(s2k_digest_string); s2k_digest_string = NULL;
3120         if( check_digest_algo(opt.s2k_digest_algo) )
3121             log_error(_("selected digest algorithm is invalid\n"));
3122     }
3123     if( opt.completes_needed < 1 )
3124       log_error(_("completes-needed must be greater than 0\n"));
3125     if( opt.marginals_needed < 2 )
3126       log_error(_("marginals-needed must be greater than 1\n"));
3127     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3128       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3129     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3130       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3131     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3132       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3133     switch( opt.s2k_mode ) {
3134       case 0:
3135         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3136         break;
3137       case 1: case 3: break;
3138       default:
3139         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3140     }
3141
3142     /* This isn't actually needed, but does serve to error out if the
3143        string is invalid. */
3144     if(opt.def_preference_list &&
3145         keygen_set_std_prefs(opt.def_preference_list,0))
3146       log_error(_("invalid default preferences\n"));
3147
3148     if(pers_cipher_list &&
3149        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3150       log_error(_("invalid personal cipher preferences\n"));
3151
3152     if(pers_digest_list &&
3153        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3154       log_error(_("invalid personal digest preferences\n"));
3155
3156     if(pers_compress_list &&
3157        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3158       log_error(_("invalid personal compress preferences\n"));
3159
3160     /* We don't support all possible commands with multifile yet */
3161     if(multifile)
3162       {
3163         char *cmdname;
3164
3165         switch(cmd)
3166           {
3167           case aSign:
3168             cmdname="--sign";
3169             break;
3170           case aClearsign:
3171             cmdname="--clearsign";
3172             break;
3173           case aDetachedSign:
3174             cmdname="--detach-sign";
3175             break;
3176           case aSym:
3177             cmdname="--symmetric";
3178             break;
3179           case aEncrSym:
3180             cmdname="--symmetric --encrypt";
3181             break;
3182           case aStore:
3183             cmdname="--store";
3184             break;
3185           default:
3186             cmdname=NULL;
3187             break;
3188           }
3189
3190         if(cmdname)
3191           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3192       }
3193
3194     if( log_get_errorcount(0) )
3195         g10_exit(2);
3196
3197     if(opt.compress_level==0)
3198       opt.compress_algo=COMPRESS_ALGO_NONE;
3199
3200     /* Check our chosen algorithms against the list of legal
3201        algorithms. */
3202
3203     if(!GNUPG)
3204       {
3205         const char *badalg=NULL;
3206         preftype_t badtype=PREFTYPE_NONE;
3207
3208         if(opt.def_cipher_algo
3209            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3210           {
3211             badalg=cipher_algo_to_string(opt.def_cipher_algo);
3212             badtype=PREFTYPE_SYM;
3213           }
3214         else if(opt.def_digest_algo
3215                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3216           {
3217             badalg=digest_algo_to_string(opt.def_digest_algo);
3218             badtype=PREFTYPE_HASH;
3219           }
3220         else if(opt.cert_digest_algo
3221                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3222           {
3223             badalg=digest_algo_to_string(opt.cert_digest_algo);
3224             badtype=PREFTYPE_HASH;
3225           }
3226         else if(opt.compress_algo!=-1
3227                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3228           {
3229             badalg=compress_algo_to_string(opt.compress_algo);
3230             badtype=PREFTYPE_ZIP;
3231           }
3232
3233         if(badalg)
3234           {
3235             switch(badtype)
3236               {
3237               case PREFTYPE_SYM:
3238                 log_info(_("you may not use cipher algorithm `%s'"
3239                            " while in %s mode\n"),
3240                          badalg,compliance_option_string());
3241                 break;
3242               case PREFTYPE_HASH:
3243                 log_info(_("you may not use digest algorithm `%s'"
3244                            " while in %s mode\n"),
3245                          badalg,compliance_option_string());
3246                 break;
3247               case PREFTYPE_ZIP:
3248                 log_info(_("you may not use compression algorithm `%s'"
3249                            " while in %s mode\n"),
3250                          badalg,compliance_option_string());
3251                 break;
3252               default:
3253                 BUG();
3254               }
3255
3256             compliance_failure();
3257           }
3258       }
3259
3260     /* set the random seed file */
3261     if( use_random_seed ) {
3262         char *p = make_filename(opt.homedir, "random_seed", NULL );
3263         set_random_seed_file(p);
3264         if (!access (p, F_OK))
3265           register_secured_file (p);
3266         xfree(p);
3267     }
3268
3269     /* If there is no command but the --fingerprint is given, default
3270        to the --list-keys command.  */
3271     if (!cmd && fpr_maybe_cmd)
3272       {
3273         set_cmd (&cmd, aListKeys);
3274       }
3275
3276     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
3277         if( cmd == aKModeC ) {
3278             opt.fingerprint = 1;
3279             cmd = aKMode;
3280         }
3281         opt.list_sigs = 0;
3282         if( opt.verbose > 2 )
3283             opt.check_sigs++;
3284         if( opt.verbose > 1 )
3285             opt.list_sigs++;
3286
3287         opt.verbose = opt.verbose > 1;
3288         g10_opt_verbose = opt.verbose;
3289     }
3290
3291     /* kludge to let -sat generate a clear text signature */
3292     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
3293         cmd = aClearsign;
3294
3295     if( opt.verbose > 1 )
3296         set_packet_list_mode(1);
3297
3298     if (cmd == aGPGConfTest)
3299       g10_exit(0);
3300
3301     /* Add the keyrings, but not for some special commands and not in
3302        case of "-kvv userid keyring".  Also avoid adding the secret
3303        keyring for a couple of commands to avoid unneeded access in
3304        case the secrings are stored on a floppy.
3305
3306        We always need to add the keyrings if we are running under
3307        SELinux, this is so that the rings are added to the list of
3308        secured files. */
3309     if( ALWAYS_ADD_KEYRINGS
3310         || (cmd != aDeArmor && cmd != aEnArmor
3311             && !(cmd == aKMode && argc == 2 )) )
3312       {
3313         if (ALWAYS_ADD_KEYRINGS
3314             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3315                 && cmd != aVerify && cmd != aSym))
3316           {
3317             if (!sec_nrings || default_keyring) /* add default secret rings */
3318               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3319             for (sl = sec_nrings; sl; sl = sl->next)
3320               keydb_add_resource ( sl->d, 0, 1 );
3321           }
3322         if( !nrings || default_keyring )  /* add default ring */
3323             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3324         for(sl = nrings; sl; sl = sl->next )
3325             keydb_add_resource ( sl->d, sl->flags, 0 );
3326       }
3327     FREE_STRLIST(nrings);
3328     FREE_STRLIST(sec_nrings);
3329
3330
3331     if( pwfd != -1 )  /* read the passphrase now. */
3332         read_passphrase_from_fd( pwfd );
3333
3334     fname = argc? *argv : NULL;
3335
3336     if(fname && utf8_strings)
3337       opt.flags.utf8_filename=1;
3338
3339     switch( cmd ) {
3340       case aPrimegen:
3341       case aPrintMD:
3342       case aPrintMDs:
3343       case aGenRandom:
3344       case aDeArmor:
3345       case aEnArmor:
3346         break;
3347       case aFixTrustDB:
3348       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3349       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3350       default:
3351           /* No need to create the trust model if we are using the
3352          * always trust model.  */
3353         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3354         break;
3355       }
3356     if( rc )
3357         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3358
3359
3360     switch (cmd)
3361       {
3362       case aStore:
3363       case aSym:
3364       case aSign:
3365       case aSignSym:
3366       case aClearsign:
3367         if (!opt.quiet && any_explicit_recipient)
3368           log_info (_("WARNING: recipients (-r) given "
3369                       "without using public key encryption\n"));
3370         break;
3371       default:
3372         break;
3373       }
3374
3375     switch( cmd )
3376       {
3377       case aStore: /* only store the file */
3378         if( argc > 1 )
3379             wrong_args(_("--store [filename]"));
3380         if( (rc = encode_store(fname)) )
3381             log_error ("storing `%s' failed: %s\n",
3382                        print_fname_stdin(fname),g10_errstr(rc) );
3383         break;
3384       case aSym: /* encrypt the given file only with the symmetric cipher */
3385         if( argc > 1 )
3386             wrong_args(_("--symmetric [filename]"));
3387         if( (rc = encode_symmetric(fname)) )
3388             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3389                         print_fname_stdin(fname),g10_errstr(rc) );
3390         break;
3391
3392       case aEncr: /* encrypt the given file */
3393         if(multifile)
3394           encode_crypt_files(argc, argv, remusr);
3395         else
3396           {
3397             if( argc > 1 )
3398               wrong_args(_("--encrypt [filename]"));
3399             if( (rc = encode_crypt(fname,remusr,0)) )
3400               log_error("%s: encryption failed: %s\n",
3401                         print_fname_stdin(fname), g10_errstr(rc) );
3402           }
3403         break;
3404
3405       case aEncrSym:
3406         /* This works with PGP 8 in the sense that it acts just like a
3407            symmetric message.  It doesn't work at all with 2 or 6.  It
3408            might work with 7, but alas, I don't have a copy to test
3409            with right now. */
3410         if( argc > 1 )
3411           wrong_args(_("--symmetric --encrypt [filename]"));
3412         else if(opt.s2k_mode==0)
3413           log_error(_("you cannot use --symmetric --encrypt"
3414                       " with --s2k-mode 0\n"));
3415         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3416           log_error(_("you cannot use --symmetric --encrypt"
3417                       " while in %s mode\n"),compliance_option_string());
3418         else
3419           {
3420             if( (rc = encode_crypt(fname,remusr,1)) )
3421               log_error("%s: encryption failed: %s\n",
3422                         print_fname_stdin(fname), g10_errstr(rc) );
3423           }
3424         break;
3425
3426       case aSign: /* sign the given file */
3427         sl = NULL;
3428         if( detached_sig ) { /* sign all files */
3429             for( ; argc; argc--, argv++ )
3430                 add_to_strlist( &sl, *argv );
3431         }
3432         else {
3433             if( argc > 1 )
3434                 wrong_args(_("--sign [filename]"));
3435             if( argc ) {
3436                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3437                 strcpy(sl->d, fname);
3438             }
3439         }
3440         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3441             log_error("signing failed: %s\n", g10_errstr(rc) );
3442         free_strlist(sl);
3443         break;
3444
3445       case aSignEncr: /* sign and encrypt the given file */
3446         if( argc > 1 )
3447             wrong_args(_("--sign --encrypt [filename]"));
3448         if( argc ) {
3449             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3450             strcpy(sl->d, fname);
3451         }
3452         else
3453             sl = NULL;
3454         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3455             log_error("%s: sign+encrypt failed: %s\n",
3456                       print_fname_stdin(fname), g10_errstr(rc) );
3457         free_strlist(sl);
3458         break;
3459
3460       case aSignEncrSym: /* sign and encrypt the given file */
3461         if( argc > 1 )
3462             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3463         else if(opt.s2k_mode==0)
3464           log_error(_("you cannot use --symmetric --sign --encrypt"
3465                       " with --s2k-mode 0\n"));
3466         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3467           log_error(_("you cannot use --symmetric --sign --encrypt"
3468                       " while in %s mode\n"),compliance_option_string());
3469         else
3470           {
3471             if( argc )
3472               {
3473                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3474                 strcpy(sl->d, fname);
3475               }
3476             else
3477               sl = NULL;
3478             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3479               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3480                         print_fname_stdin(fname), g10_errstr(rc) );
3481             free_strlist(sl);
3482           }
3483         break;
3484
3485       case aSignSym: /* sign and conventionally encrypt the given file */
3486         if (argc > 1)
3487             wrong_args(_("--sign --symmetric [filename]"));
3488         rc = sign_symencrypt_file (fname, locusr);
3489         if (rc)
3490             log_error("%s: sign+symmetric failed: %s\n",
3491                       print_fname_stdin(fname), g10_errstr(rc) );
3492         break;
3493
3494       case aClearsign: /* make a clearsig */
3495         if( argc > 1 )
3496             wrong_args(_("--clearsign [filename]"));
3497         if( (rc = clearsign_file(fname, locusr, NULL)) )
3498             log_error("%s: clearsign failed: %s\n",
3499                       print_fname_stdin(fname), g10_errstr(rc) );
3500         break;
3501
3502       case aVerify:
3503         if(multifile)
3504           {
3505             if( (rc = verify_files( argc, argv ) ))
3506               log_error("verify files failed: %s\n", g10_errstr(rc) );
3507           }
3508         else
3509           {
3510             if( (rc = verify_signatures( argc, argv ) ))
3511               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3512           }
3513         break;
3514
3515       case aDecrypt:
3516         if(multifile)
3517           decrypt_messages(argc, argv);
3518         else
3519           {
3520             if( argc > 1 )
3521               wrong_args(_("--decrypt [filename]"));
3522             if( (rc = decrypt_message( fname ) ))
3523               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3524           }
3525         break;
3526
3527       case aSignKey: