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