Preparing a new release
[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     oListKeys     = '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     aListOwnerTrust,
144     aImportOwnerTrust,
145     aDeArmor,
146     aEnArmor,
147     aGenRandom,
148     aRebuildKeydbCaches,
149     aCardStatus,
150     aCardEdit,
151     aChangePIN,
152
153     oTextmode,
154     oNoTextmode,
155     oExpert,
156     oNoExpert,
157     oDefSigExpire,
158     oAskSigExpire,
159     oNoAskSigExpire,
160     oDefCertExpire,
161     oAskCertExpire,
162     oNoAskCertExpire,
163     oDefCertLevel,
164     oMinCertLevel,
165     oAskCertLevel,
166     oNoAskCertLevel,
167     oFingerprint,
168     oWithFingerprint,
169     oAnswerYes,
170     oAnswerNo,
171     oKeyring,
172     oPrimaryKeyring,
173     oSecretKeyring,
174     oShowKeyring,
175     oDefaultKey,
176     oDefRecipient,
177     oDefRecipientSelf,
178     oNoDefRecipient,
179     oOptions,
180     oDebug,
181     oDebugLevel,
182     oDebugAll,
183     oDebugCCIDDriver,
184     oStatusFD,
185     oStatusFile,
186     oAttributeFD,
187     oAttributeFile,
188     oEmitVersion,
189     oNoEmitVersion,
190     oCompletesNeeded,
191     oMarginalsNeeded,
192     oMaxCertDepth,
193     oLoadExtension,
194     oGnuPG,
195     oRFC1991,
196     oRFC2440,
197     oOpenPGP,
198     oPGP2,
199     oPGP6,
200     oPGP7,
201     oPGP8,
202     oRFC2440Text,
203     oNoRFC2440Text,
204     oCipherAlgo,
205     oDigestAlgo,
206     oCertDigestAlgo,
207     oCompressAlgo,
208     oCompressLevel,
209     oBZ2CompressLevel,
210     oBZ2DecompressLowmem,
211     oPasswd,
212     oPasswdFD,
213     oPasswdFile,
214     oCommandFD,
215     oCommandFile,
216     oQuickRandom,
217     oNoVerbose,
218     oTrustDBName,
219     oNoSecmemWarn,
220     oRequireSecmem,
221     oNoRequireSecmem,
222     oNoPermissionWarn,
223     oNoMDCWarn,
224     oNoArmor,
225     oNoDefKeyring,
226     oNoGreeting,
227     oNoTTY,
228     oNoOptions,
229     oNoBatch,
230     oHomedir,
231     oWithColons,
232     oWithKeyData,
233     oSkipVerify,
234     oCompressKeys,
235     oCompressSigs,
236     oAlwaysTrust,
237     oTrustModel,
238     oForceOwnertrust,
239     oSetFilename,
240     oForYourEyesOnly,
241     oNoForYourEyesOnly,
242     oSetPolicyURL,
243     oSigPolicyURL,
244     oCertPolicyURL,
245     oShowPolicyURL,
246     oNoShowPolicyURL,
247     oSigKeyserverURL,
248     oUseEmbeddedFilename,
249     oNoUseEmbeddedFilename,
250     oComment,
251     oDefaultComment,
252     oNoComments,
253     oThrowKeyids,
254     oNoThrowKeyids,
255     oShowPhotos,
256     oNoShowPhotos,
257     oPhotoViewer,
258     oForceV3Sigs,
259     oNoForceV3Sigs,
260     oForceV4Certs,
261     oNoForceV4Certs,
262     oForceMDC,
263     oNoForceMDC,
264     oDisableMDC,
265     oNoDisableMDC,
266     oS2KMode,
267     oS2KDigest,
268     oS2KCipher,
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     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
528     { oCipherAlgo, "cipher-algo", 2, "@"},
529     { oDigestAlgo, "digest-algo", 2, "@"},
530     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
531     { oCompressAlgo,"compress-algo", 2, "@"},
532     { oCompressAlgo, "compression-algo", 2, "@"}, /* Alias */
533     { oThrowKeyids, "throw-keyid", 0, "@"},
534     { oThrowKeyids, "throw-keyids", 0, "@"},
535     { oNoThrowKeyids, "no-throw-keyid", 0, "@" },
536     { oNoThrowKeyids, "no-throw-keyids", 0, "@" },
537     { oShowPhotos,   "show-photos", 0, "@" },
538     { oNoShowPhotos, "no-show-photos", 0, "@" },
539     { oPhotoViewer,  "photo-viewer", 2, "@" },
540     { oSetNotation,  "set-notation", 2, "@" },
541     { oSetNotation,  "notation-data", 2, "@" }, /* Alias */
542     { oSigNotation,  "sig-notation", 2, "@" },
543     { oCertNotation, "cert-notation", 2, "@" },
544
545     { 302, NULL, 0, N_(
546   "@\n(See the man page for a complete listing of all commands and options)\n"
547                       )},
548
549     { 303, NULL, 0, N_("@\nExamples:\n\n"
550     " -se -r Bob [file]          sign and encrypt for user Bob\n"
551     " --clearsign [file]         make a clear text signature\n"
552     " --detach-sign [file]       make a detached signature\n"
553     " --list-keys [names]        show keys\n"
554     " --fingerprint [names]      show fingerprints\n"  ) },
555
556   /* hidden options */
557     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
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
1714 int
1715 main (int argc, char **argv )
1716 {
1717     ARGPARSE_ARGS pargs;
1718     IOBUF a;
1719     int rc=0;
1720     int orig_argc;
1721     char **orig_argv;
1722     const char *fname;
1723     char *username;
1724     int may_coredump;
1725     strlist_t sl, remusr= NULL, locusr=NULL;
1726     strlist_t nrings=NULL, sec_nrings=NULL;
1727     armor_filter_context_t afx;
1728     int detached_sig = 0;
1729     FILE *configfp = NULL;
1730     char *configname = NULL;
1731     char *save_configname = NULL;
1732     unsigned configlineno;
1733     int parse_debug = 0;
1734     int default_config = 1;
1735     int default_keyring = 1;
1736     int greeting = 0;
1737     int nogreeting = 0;
1738     char *logfile = NULL;
1739     int use_random_seed = 1;
1740     enum cmd_and_opt_values cmd = 0;
1741     const char *debug_level = NULL;
1742     const char *trustdb_name = NULL;
1743     char *def_cipher_string = NULL;
1744     char *def_digest_string = NULL;
1745     char *compress_algo_string = NULL;
1746     char *cert_digest_string = NULL;
1747     char *s2k_cipher_string = NULL;
1748     char *s2k_digest_string = NULL;
1749     char *pers_cipher_list = NULL;
1750     char *pers_digest_list = NULL;
1751     char *pers_compress_list = NULL;
1752     int eyes_only=0;
1753     int multifile=0;
1754     int pwfd = -1;
1755     int with_fpr = 0; /* make an option out of --fingerprint */
1756     int any_explicit_recipient = 0;
1757     int require_secmem=0,got_secmem=0;
1758
1759 #ifdef __riscos__
1760     opt.lock_once = 1;
1761 #endif /* __riscos__ */
1762
1763
1764     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1765        when adding any stuff between here and the call to
1766        secmem_init() somewhere after the option parsing. */
1767     reopen_std ();
1768     trap_unaligned ();
1769     gnupg_rl_initialize ();
1770     set_strusage (my_strusage);
1771     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1772     /* We don't need any locking in libgcrypt unless we use any kind of
1773        threading. */
1774     gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
1775     log_set_prefix ("gpg", 1);
1776
1777     /* Check that the libraries are suitable.  Do it right here because the
1778        option parsing may need services of the library.  */
1779     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1780       {
1781         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
1782                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1783       }
1784
1785     /* Put random number into secure memory */
1786     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1787
1788     may_coredump = disable_core_dumps();
1789
1790     gnupg_init_signals (0, emergency_cleanup);
1791
1792     create_dotlock(NULL); /* Register locking cleanup. */
1793
1794     i18n_init();
1795
1796     opt.command_fd = -1; /* no command fd */
1797     opt.compress_level = -1; /* defaults to standard compress level */
1798     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1799     /* note: if you change these lines, look at oOpenPGP */
1800     opt.def_cipher_algo = 0;
1801     opt.def_digest_algo = 0;
1802     opt.cert_digest_algo = 0;
1803     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1804     opt.s2k_mode = 3; /* iterated+salted */
1805 #ifdef USE_CAST5
1806     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1807 #else
1808     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1809 #endif
1810     opt.completes_needed = 1;
1811     opt.marginals_needed = 3;
1812     opt.max_cert_depth = 5;
1813     opt.pgp2_workarounds = 1;
1814     opt.force_v3_sigs = 1;
1815     opt.escape_from = 1;
1816     opt.import_options=IMPORT_SK2PK;
1817     opt.export_options=EXPORT_ATTRIBUTES;
1818     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1819     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1820     opt.keyserver_options.options=
1821       KEYSERVER_HONOR_KEYSERVER_URL|KEYSERVER_HONOR_PKA_RECORD;
1822     opt.verify_options=
1823       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1824     opt.trust_model=TM_AUTO;
1825     opt.mangle_dos_filenames=0;
1826     opt.min_cert_level=2;
1827     set_screen_dimensions();
1828     opt.keyid_format=KF_SHORT;
1829     opt.rfc2440_text=1;
1830     opt.def_sig_expire="0";
1831     opt.def_cert_expire="0";
1832     opt.flags.require_cross_cert = 1;
1833     set_homedir ( default_homedir () );
1834
1835     /* Check whether we have a config file on the command line.  */
1836     orig_argc = argc;
1837     orig_argv = argv;
1838     pargs.argc = &argc;
1839     pargs.argv = &argv;
1840     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1841     while( arg_parse( &pargs, opts) ) {
1842         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1843             parse_debug++;
1844         else if( pargs.r_opt == oOptions ) {
1845             /* yes there is one, so we do not try the default one, but
1846              * read the option file when it is encountered at the commandline
1847              */
1848             default_config = 0;
1849         }
1850         else if( pargs.r_opt == oNoOptions )
1851             default_config = 0; /* --no-options */
1852         else if( pargs.r_opt == oHomedir )
1853             set_homedir ( pargs.r.ret_str );
1854         else if( pargs.r_opt == oNoPermissionWarn )
1855             opt.no_perm_warn=1;
1856         else if (pargs.r_opt == oStrict )
1857           {
1858             /* Not used */
1859           }
1860         else if (pargs.r_opt == oNoStrict )
1861           {
1862             /* Not used */
1863           }
1864     }
1865
1866 #ifdef HAVE_DOSISH_SYSTEM
1867     if ( strchr (opt.homedir,'\\') ) {
1868         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1869         const char *s = opt.homedir;
1870         for (d=buf,s=opt.homedir; *s; s++)
1871           {
1872             *d++ = *s == '\\'? '/': *s;
1873 #ifdef HAVE_W32_SYSTEM
1874             if (s[1] && IsDBCSLeadByte (*s))
1875               *d++ = *++s;
1876 #endif
1877           }
1878         *d = 0;
1879         set_homedir (buf);
1880     }
1881 #endif
1882
1883     /* Initialize the secure memory. */
1884     gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
1885     got_secmem = 1; /* FIXME: gcry_control should return an indicator. */
1886 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
1887     /* There should be no way to get to this spot while still carrying
1888        setuid privs.  Just in case, bomb out if we are. */
1889     if(getuid()!=geteuid())
1890       BUG();
1891 #endif
1892     maybe_setuid = 0;
1893
1894     /* Okay, we are now working under our real uid */
1895
1896     /* malloc hooks go here ... */
1897     assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1898     assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
1899
1900
1901     set_native_charset (NULL); /* Try to auto set the character set */
1902
1903     /* Try for a version specific config file first */
1904     if( default_config )
1905       {
1906         char *name=xstrdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1907         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1908
1909         do
1910           {
1911             if(configname)
1912               {
1913                 char *tok;
1914
1915                 xfree(configname);
1916                 configname=NULL;
1917
1918                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1919                   *tok='\0';
1920                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1921                   *tok='\0';
1922                 else
1923                   break;
1924               }
1925
1926             configname = make_filename(opt.homedir,name,NULL);
1927           }
1928         while(access(configname,R_OK));
1929
1930         xfree(name);
1931
1932         if(!configname)
1933           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1934         if (!access (configname, R_OK))
1935           { /* Print a warning when both config files are present. */
1936             char *p = make_filename(opt.homedir, "options", NULL );
1937             if (!access (p, R_OK))
1938               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1939             xfree (p);
1940           }
1941         else
1942           { /* Keep on using the old default one. */
1943             xfree (configname);
1944             configname = make_filename(opt.homedir, "options", NULL );
1945           }
1946       }
1947     argc = orig_argc;
1948     argv = orig_argv;
1949     pargs.argc = &argc;
1950     pargs.argv = &argv;
1951     pargs.flags=  1;  /* do not remove the args */
1952
1953     /* By this point we have a homedir, and cannot change it. */
1954     check_permissions(opt.homedir,0);
1955
1956   next_pass:
1957     if( configname ) {
1958       if(check_permissions(configname,1))
1959         {
1960           /* If any options file is unsafe, then disable any external
1961              programs for keyserver calls or photo IDs.  Since the
1962              external program to call is set in the options file, a
1963              unsafe options file can lead to an arbitrary program
1964              being run. */
1965
1966           opt.exec_disable=1;
1967         }
1968
1969         configlineno = 0;
1970         configfp = fopen( configname, "r" );
1971         if (configfp && is_secured_file (fileno (configfp)))
1972           {
1973             fclose (configfp);
1974             configfp = NULL;
1975             errno = EPERM;
1976           }
1977         if( !configfp ) {
1978             if( default_config ) {
1979                 if( parse_debug )
1980                     log_info(_("NOTE: no default option file `%s'\n"),
1981                                                             configname );
1982             }
1983             else {
1984                 log_error(_("option file `%s': %s\n"),
1985                                     configname, strerror(errno) );
1986                 g10_exit(2);
1987             }
1988             xfree(configname); configname = NULL;
1989         }
1990         if( parse_debug && configname )
1991             log_info(_("reading options from `%s'\n"), configname );
1992         default_config = 0;
1993     }
1994
1995     while( optfile_parse( configfp, configname, &configlineno,
1996                                                 &pargs, opts) )
1997       {
1998         switch( pargs.r_opt )
1999           {
2000           case aCheckKeys: 
2001           case aListConfig:
2002           case aGPGConfList:
2003           case aListPackets:
2004           case aImport: 
2005           case aFastImport: 
2006           case aSendKeys: 
2007           case aRecvKeys: 
2008           case aSearchKeys:
2009           case aRefreshKeys:
2010           case aFetchKeys:
2011           case aExport: 
2012 #ifdef ENABLE_CARD_SUPPORT
2013           case aCardStatus:
2014           case aCardEdit: 
2015           case aChangePIN:
2016 #endif /* ENABLE_CARD_SUPPORT*/
2017             set_cmd (&cmd, pargs.r_opt);
2018             break;
2019
2020           case aListKeys: set_cmd( &cmd, aListKeys); break;
2021           case aListSigs: set_cmd( &cmd, aListSigs); break;
2022           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
2023           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
2024           case aDeleteSecretKeys:
2025             set_cmd( &cmd, aDeleteSecretKeys);
2026             greeting=1;
2027             break;
2028           case aDeleteSecretAndPublicKeys:
2029             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
2030             greeting=1; 
2031             break;
2032           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
2033
2034           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2035           case aSym: set_cmd( &cmd, aSym); break;
2036
2037           case aDecryptFiles: multifile=1; /* fall through */
2038           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2039
2040           case aEncrFiles: multifile=1; /* fall through */
2041           case aEncr: set_cmd( &cmd, aEncr); break;
2042
2043           case aVerifyFiles: multifile=1; /* fall through */
2044           case aVerify: set_cmd( &cmd, aVerify); break;
2045
2046           case aSign: set_cmd( &cmd, aSign );  break;
2047           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
2048           case aSignKey: set_cmd( &cmd, aSignKey); break;
2049           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
2050           case aStore: set_cmd( &cmd, aStore); break;
2051           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
2052           case aClearsign: set_cmd( &cmd, aClearsign); break;
2053           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
2054           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
2055           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
2056           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
2057           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
2058           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
2059           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
2060           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
2061           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
2062           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
2063           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
2064           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
2065           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
2066           case aListOwnerTrust:
2067             deprecated_warning(configname,configlineno,
2068                                "--list-ownertrust","--export-ownertrust","");
2069           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
2070           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
2071           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
2072
2073           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2074           case oOutput: opt.outfile = pargs.r.ret_str; break;
2075           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2076           case oQuiet: opt.quiet = 1; break;
2077           case oNoTTY: tty_no_terminal(1); break;
2078           case oDryRun: opt.dry_run = 1; break;
2079           case oInteractive: opt.interactive = 1; break;
2080           case oVerbose:
2081             opt.verbose++;
2082             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2083             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2084             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2085             break;
2086
2087           case oBatch: opt.batch = 1; nogreeting = 1; break;
2088           case oUseAgent:
2089 #ifndef __riscos__
2090             opt.use_agent = 1;
2091 #else /* __riscos__ */
2092             opt.use_agent = 0;
2093             riscos_not_implemented("use-agent");
2094 #endif /* __riscos__ */
2095             break;
2096           case oNoUseAgent: opt.use_agent = 0; break;
2097           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
2098           case oAnswerYes: opt.answer_yes = 1; break;
2099           case oAnswerNo: opt.answer_no = 1; break;
2100           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2101           case oPrimaryKeyring:
2102             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2103             sl->flags=2;
2104             break;
2105           case oShowKeyring:
2106             deprecated_warning(configname,configlineno,"--show-keyring",
2107                                "--list-options ","show-keyring");
2108             opt.list_options|=LIST_SHOW_KEYRING;
2109             break;
2110
2111           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2112           case oDebugAll: opt.debug = ~0; break;
2113           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2114
2115           case oStatusFD:
2116             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
2117             break;
2118           case oStatusFile:
2119             set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
2120             break;
2121           case oAttributeFD:
2122             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
2123             break;
2124           case oAttributeFile:
2125             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
2126             break;
2127           case oLoggerFD:
2128             log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
2129             break;
2130           case oLoggerFile:
2131             logfile = pargs.r.ret_str;
2132             break;
2133
2134           case oWithFingerprint:
2135             opt.with_fingerprint = 1;
2136             with_fpr=1; /*fall thru*/
2137           case oFingerprint: opt.fingerprint++; break;
2138           case oSecretKeyring:
2139             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2140             break;
2141           case oOptions:
2142             /* config files may not be nested (silently ignore them) */
2143             if( !configfp ) {
2144                 xfree(configname);
2145                 configname = xstrdup(pargs.r.ret_str);
2146                 goto next_pass;
2147             }
2148             break;
2149           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2150           case oNoDefKeyring: default_keyring = 0; break;
2151           case oNoGreeting: nogreeting = 1; break;
2152           case oNoVerbose: 
2153             opt.verbose = 0;
2154             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2155             opt.list_sigs=0;
2156             break;
2157           case oQuickRandom: 
2158             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2159             break;
2160           case oEmitVersion: opt.no_version=0; break;
2161           case oNoEmitVersion: opt.no_version=1; break;
2162           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2163           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2164           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2165           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2166           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2167           case oDefRecipient:
2168             if( *pargs.r.ret_str )
2169               opt.def_recipient = make_username(pargs.r.ret_str);
2170             break;
2171           case oDefRecipientSelf:
2172             xfree(opt.def_recipient); opt.def_recipient = NULL;
2173             opt.def_recipient_self = 1;
2174             break;
2175           case oNoDefRecipient:
2176             xfree(opt.def_recipient); opt.def_recipient = NULL;
2177             opt.def_recipient_self = 0;
2178             break;
2179           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2180           case oHomedir: break;
2181           case oNoBatch: opt.batch = 0; break;
2182           case oWithKeyData: opt.with_key_data=1; /* fall thru */
2183           case oWithColons: opt.with_colons=':'; break;
2184
2185           case oSkipVerify: opt.skip_verify=1; break;
2186           case oCompressKeys: opt.compress_keys = 1; break;
2187           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2188             /* There are many programs (like mutt) that call gpg with
2189                --always-trust so keep this option around for a long
2190                time. */
2191           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2192           case oTrustModel:
2193             parse_trust_model(pargs.r.ret_str);
2194             break;
2195           case oForceOwnertrust:
2196             log_info(_("NOTE: %s is not for normal use!\n"),
2197                      "--force-ownertrust");
2198             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2199             if(opt.force_ownertrust==-1)
2200               {
2201                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2202                 opt.force_ownertrust=0;
2203               }
2204             break;
2205           case oLoadExtension:
2206 #ifndef __riscos__
2207 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
2208             if(check_permissions(pargs.r.ret_str,2))
2209               log_info(_("cipher extension `%s' not loaded due to"
2210                          " unsafe permissions\n"),pargs.r.ret_str);
2211             else
2212               register_cipher_extension(orig_argc? *orig_argv:NULL,
2213                                         pargs.r.ret_str);
2214 #endif
2215 #else /* __riscos__ */
2216             riscos_not_implemented("load-extension");
2217 #endif /* __riscos__ */
2218             break;
2219           case oRFC1991:
2220             opt.compliance = CO_RFC1991;
2221             opt.force_v4_certs = 0;
2222             opt.escape_from = 1;
2223             break;
2224           case oOpenPGP:
2225           case oRFC2440:
2226             /* TODO: When 2440bis becomes a RFC, set new values for
2227                oOpenPGP. */
2228             opt.rfc2440_text=1;
2229             opt.compliance = CO_RFC2440;
2230             opt.allow_non_selfsigned_uid = 1;
2231             opt.allow_freeform_uid = 1;
2232             opt.pgp2_workarounds = 0;
2233             opt.escape_from = 0;
2234             opt.force_v3_sigs = 0;
2235             opt.compress_keys = 0;          /* not mandated, but we do it */
2236             opt.compress_sigs = 0;          /* ditto. */
2237             opt.not_dash_escaped = 0;
2238             opt.def_cipher_algo = 0;
2239             opt.def_digest_algo = 0;
2240             opt.cert_digest_algo = 0;
2241             opt.compress_algo = -1;
2242             opt.s2k_mode = 3; /* iterated+salted */
2243             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2244             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2245             break;
2246           case oPGP2:  opt.compliance = CO_PGP2;  break;
2247           case oPGP6:  opt.compliance = CO_PGP6;  break;
2248           case oPGP7:  opt.compliance = CO_PGP7;  break;
2249           case oPGP8:  opt.compliance = CO_PGP8;  break;
2250           case oGnuPG: opt.compliance = CO_GNUPG; break;
2251           case oCompressSigs: opt.compress_sigs = 1; break;
2252           case oRFC2440Text: opt.rfc2440_text=1; break;
2253           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2254           case oSetFilename:
2255             if(utf8_strings)
2256               opt.set_filename = pargs.r.ret_str;
2257             else
2258               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2259             break;
2260           case oForYourEyesOnly: eyes_only = 1; break;
2261           case oNoForYourEyesOnly: eyes_only = 0; break;
2262           case oSetPolicyURL:
2263             add_policy_url(pargs.r.ret_str,0);
2264             add_policy_url(pargs.r.ret_str,1);
2265             break;
2266           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2267           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2268           case oShowPolicyURL:
2269             deprecated_warning(configname,configlineno,"--show-policy-url",
2270                                "--list-options ","show-policy-urls");
2271             deprecated_warning(configname,configlineno,"--show-policy-url",
2272                                "--verify-options ","show-policy-urls");
2273             opt.list_options|=LIST_SHOW_POLICY_URLS;
2274             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2275             break;
2276           case oNoShowPolicyURL:
2277             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2278                                "--list-options ","no-show-policy-urls");
2279             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2280                                "--verify-options ","no-show-policy-urls");
2281             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2282             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2283             break;
2284           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2285           case oUseEmbeddedFilename:
2286             opt.flags.use_embedded_filename=1;
2287             break;
2288           case oNoUseEmbeddedFilename:
2289             opt.flags.use_embedded_filename=0;
2290             break;
2291           case oComment:
2292             if(pargs.r.ret_str[0])
2293               append_to_strlist(&opt.comments,pargs.r.ret_str);
2294             break;
2295           case oDefaultComment:
2296             deprecated_warning(configname,configlineno,
2297                                "--default-comment","--no-comments","");
2298             /* fall through */
2299           case oNoComments:
2300             free_strlist(opt.comments);
2301             opt.comments=NULL;
2302             break;
2303           case oThrowKeyids: opt.throw_keyid = 1; break;
2304           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2305           case oShowPhotos:
2306             deprecated_warning(configname,configlineno,"--show-photos",
2307                                "--list-options ","show-photos");
2308             deprecated_warning(configname,configlineno,"--show-photos",
2309                                "--verify-options ","show-photos");
2310             opt.list_options|=LIST_SHOW_PHOTOS;
2311             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2312             break;
2313           case oNoShowPhotos:
2314             deprecated_warning(configname,configlineno,"--no-show-photos",
2315                                "--list-options ","no-show-photos");
2316             deprecated_warning(configname,configlineno,"--no-show-photos",
2317                                "--verify-options ","no-show-photos");
2318             opt.list_options&=~LIST_SHOW_PHOTOS;
2319             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2320             break;
2321           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2322           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2323           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2324           case oForceV4Certs: opt.force_v4_certs = 1; break;
2325           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2326           case oForceMDC: opt.force_mdc = 1; break;
2327           case oNoForceMDC: opt.force_mdc = 0; break;
2328           case oDisableMDC: opt.disable_mdc = 1; break;
2329           case oNoDisableMDC: opt.disable_mdc = 0; break;
2330           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2331           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2332           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2333           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2334           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2335           case oEncryptTo: /* store the recipient in the second list */
2336             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2337             sl->flags = 1;
2338             break;
2339           case oHiddenEncryptTo: /* store the recipient in the second list */
2340             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2341             sl->flags = 1|2;
2342             break;
2343           case oRecipient: /* store the recipient */
2344             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2345             any_explicit_recipient = 1;
2346             break;
2347           case oHiddenRecipient: /* store the recipient with a flag */
2348             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2349             sl->flags = 2;
2350             any_explicit_recipient = 1;
2351             break;
2352           case oTextmodeShort: opt.textmode = 2; break;
2353           case oTextmode: opt.textmode=1;  break;
2354           case oNoTextmode: opt.textmode=0;  break;
2355           case oExpert: opt.expert = 1; break;
2356           case oNoExpert: opt.expert = 0; break;
2357           case oDefSigExpire:
2358             if(*pargs.r.ret_str!='\0')
2359               {
2360                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2361                   log_error(_("`%s' is not a valid signature expiration\n"),
2362                             pargs.r.ret_str);
2363                 else
2364                   opt.def_sig_expire=pargs.r.ret_str;
2365               }
2366             break;
2367           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2368           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2369           case oDefCertExpire:
2370             if(*pargs.r.ret_str!='\0')
2371               {
2372                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2373                   log_error(_("`%s' is not a valid signature expiration\n"),
2374                             pargs.r.ret_str);
2375                 else
2376                   opt.def_cert_expire=pargs.r.ret_str;
2377               }
2378             break;
2379           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2380           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2381           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2382           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2383           case oAskCertLevel: opt.ask_cert_level = 1; break;
2384           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2385           case oLocalUser: /* store the local users */
2386             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2387             break;
2388           case oCompress:
2389             /* this is the -z command line option */
2390             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2391             break;
2392           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2393           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2394           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2395           case oPasswd:
2396             set_passphrase_from_string(pargs.r.ret_str);
2397             break;
2398           case oPasswdFD:
2399             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2400             opt.use_agent = 0;
2401             break;
2402           case oPasswdFile:
2403             pwfd = open_info_file (pargs.r.ret_str, 0);
2404             break;
2405           case oCommandFD:
2406             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2407             break;
2408           case oCommandFile:
2409             opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2410             break;
2411           case oCipherAlgo: 
2412             def_cipher_string = xstrdup(pargs.r.ret_str);
2413             break;
2414           case oDigestAlgo:
2415             def_digest_string = xstrdup(pargs.r.ret_str);
2416             break;
2417           case oCompressAlgo:
2418             /* If it is all digits, stick a Z in front of it for
2419                later.  This is for backwards compatibility with
2420                versions that took the compress algorithm number. */
2421             {
2422               char *pt=pargs.r.ret_str;
2423               while(*pt)
2424                 {
2425                   if (!isascii (*pt) || !isdigit (*pt))
2426                     break;
2427
2428                   pt++;
2429                 }
2430
2431               if(*pt=='\0')
2432                 {
2433                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2434                   strcpy(compress_algo_string,"Z");
2435                   strcat(compress_algo_string,pargs.r.ret_str);
2436                 }
2437               else
2438                 compress_algo_string = xstrdup(pargs.r.ret_str);
2439             }
2440             break;
2441           case oCertDigestAlgo: 
2442             cert_digest_string = xstrdup(pargs.r.ret_str);
2443             break;
2444
2445           case oNoSecmemWarn: 
2446             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
2447             break;
2448
2449           case oRequireSecmem: require_secmem=1; break;
2450           case oNoRequireSecmem: require_secmem=0; break;
2451           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2452           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2453           case oDisplayCharset:
2454             if( set_native_charset( pargs.r.ret_str ) )
2455                 log_error(_("`%s' is not a valid character set\n"),
2456                           pargs.r.ret_str);
2457             break;
2458           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2459           case oEscapeFrom: opt.escape_from = 1; break;
2460           case oNoEscapeFrom: opt.escape_from = 0; break;
2461           case oLockOnce: opt.lock_once = 1; break;
2462           case oLockNever:
2463             disable_dotlock ();
2464             break;
2465           case oLockMultiple:
2466 #ifndef __riscos__
2467             opt.lock_once = 0;
2468 #else /* __riscos__ */
2469             riscos_not_implemented("lock-multiple");
2470 #endif /* __riscos__ */
2471             break;
2472           case oKeyServer:
2473             {
2474               struct keyserver_spec *keyserver;
2475               keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2476                                             configname,configlineno);
2477               if(!keyserver)
2478                 log_error(_("could not parse keyserver URL\n"));
2479               else
2480                 {
2481                   keyserver->next=opt.keyserver;
2482                   opt.keyserver=keyserver;
2483                 }
2484             }
2485             break;
2486           case oKeyServerOptions:
2487             if(!parse_keyserver_options(pargs.r.ret_str))
2488               {
2489                 if(configname)
2490                   log_error(_("%s:%d: invalid keyserver options\n"),
2491                             configname,configlineno);
2492                 else
2493                   log_error(_("invalid keyserver options\n"));
2494               }
2495             break;
2496           case oImportOptions:
2497             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2498               {
2499                 if(configname)
2500                   log_error(_("%s:%d: invalid import options\n"),
2501                             configname,configlineno);
2502                 else
2503                   log_error(_("invalid import options\n"));
2504               }
2505             break;
2506           case oExportOptions:
2507             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2508               {
2509                 if(configname)
2510                   log_error(_("%s:%d: invalid export options\n"),
2511                             configname,configlineno);
2512                 else
2513                   log_error(_("invalid export options\n"));
2514               }
2515             break;
2516           case oListOptions:
2517             if(!parse_list_options(pargs.r.ret_str))
2518               {
2519                 if(configname)
2520                   log_error(_("%s:%d: invalid list options\n"),
2521                             configname,configlineno);
2522                 else
2523                   log_error(_("invalid list options\n"));
2524               }
2525             break;
2526           case oVerifyOptions:
2527             {
2528               struct parse_options vopts[]=
2529                 {
2530                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2531                    N_("display photo IDs during signature verification")},
2532                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2533                    N_("show policy URLs during signature verification")},
2534                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2535                    N_("show all notations during signature verification")},
2536                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2537                    N_("show IETF standard notations during signature verification")},
2538                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2539                    NULL},
2540                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2541                    N_("show user-supplied notations during signature verification")},
2542                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2543                    N_("show preferred keyserver URLs during signature verification")},
2544                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2545                    N_("show user ID validity during signature verification")},
2546                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2547                    N_("show revoked and expired user IDs in signature verification")},
2548                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2549                    N_("validate signatures with PKA data")},
2550                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2551                    N_("elevate the trust of signatures with valid PKA data")},
2552                   {NULL,0,NULL,NULL}
2553                 };
2554
2555               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2556                 {
2557                   if(configname)
2558                     log_error(_("%s:%d: invalid verify options\n"),
2559                               configname,configlineno);
2560                   else
2561                     log_error(_("invalid verify options\n"));
2562                 }
2563             }
2564             break;
2565           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2566           case oExecPath:
2567             if(set_exec_path(pargs.r.ret_str))
2568               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2569             else
2570               opt.exec_path_set=1;
2571             break;
2572           case oSetNotation:
2573             add_notation_data( pargs.r.ret_str, 0 );
2574             add_notation_data( pargs.r.ret_str, 1 );
2575             break;
2576           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2577           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2578           case oShowNotation:
2579             deprecated_warning(configname,configlineno,"--show-notation",
2580                                "--list-options ","show-notations");
2581             deprecated_warning(configname,configlineno,"--show-notation",
2582                                "--verify-options ","show-notations");
2583             opt.list_options|=LIST_SHOW_NOTATIONS;
2584             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2585             break;
2586           case oNoShowNotation:
2587             deprecated_warning(configname,configlineno,"--no-show-notation",
2588                                "--list-options ","no-show-notations");
2589             deprecated_warning(configname,configlineno,"--no-show-notation",
2590                                "--verify-options ","no-show-notations");
2591             opt.list_options&=~LIST_SHOW_NOTATIONS;
2592             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2593             break;
2594           case oUtf8Strings: utf8_strings = 1; break;
2595           case oNoUtf8Strings: utf8_strings = 0; break;
2596           case oDisableCipherAlgo:
2597             {
2598               int algo = string_to_cipher_algo (pargs.r.ret_str);
2599               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2600             }
2601             break;
2602           case oDisablePubkeyAlgo:
2603             {
2604               int algo = gcry_pk_map_name (pargs.r.ret_str);
2605               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2606             }
2607             break;
2608           case oNoSigCache: opt.no_sig_cache = 1; break;
2609           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2610           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2611           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2612           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2613           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2614           case oNoLiteral: opt.no_literal = 1; break;
2615           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2616           case oHonorHttpProxy:
2617                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2618                 deprecated_warning(configname,configlineno,
2619                                    "--honor-http-proxy",
2620                                    "--keyserver-options ","http-proxy");
2621                 break;
2622           case oFastListMode: opt.fast_list_mode = 1; break;
2623           case oFixedListMode: opt.fixed_list_mode = 1; break;
2624           case oListOnly: opt.list_only=1; break;
2625           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2626           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2627           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2628           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2629           case oNoRandomSeedFile: use_random_seed = 0; break;
2630           case oAutoKeyRetrieve:
2631           case oNoAutoKeyRetrieve:
2632                 if(pargs.r_opt==oAutoKeyRetrieve)
2633                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2634                 else
2635                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2636
2637                 deprecated_warning(configname,configlineno,
2638                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2639                                "--no-auto-key-retrieve","--keyserver-options ",
2640                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2641                                "no-auto-key-retrieve");
2642                 break;
2643           case oShowSessionKey: opt.show_session_key = 1; break;
2644           case oOverrideSessionKey:
2645                 opt.override_session_key = pargs.r.ret_str;
2646                 break;
2647           case oMergeOnly:
2648                 deprecated_warning(configname,configlineno,"--merge-only",
2649                                    "--import-options ","merge-only");
2650                 opt.import_options|=IMPORT_MERGE_ONLY;
2651             break;
2652           case oAllowSecretKeyImport: /* obsolete */ break;
2653           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2654           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2655           case oEnableSpecialFilenames:
2656             iobuf_enable_special_filenames (1);
2657             break;
2658           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2659           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2660           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2661           case oPreservePermissions: opt.preserve_permissions=1; break;
2662           case oDefaultPreferenceList:
2663             opt.def_preference_list = pargs.r.ret_str;
2664             break;
2665           case oDefaultKeyserverURL:
2666             {
2667               struct keyserver_spec *keyserver;
2668               keyserver=parse_keyserver_uri(pargs.r.ret_str,1,
2669                                             configname,configlineno);
2670               if(!keyserver)
2671                 log_error(_("could not parse keyserver URL\n"));
2672               else
2673                 free_keyserver_spec(keyserver);
2674
2675               opt.def_keyserver_url = pargs.r.ret_str;
2676             }
2677             break;
2678           case oPersonalCipherPreferences:
2679             pers_cipher_list=pargs.r.ret_str;
2680             break;
2681           case oPersonalDigestPreferences:
2682             pers_digest_list=pargs.r.ret_str;
2683             break;
2684           case oPersonalCompressPreferences:
2685             pers_compress_list=pargs.r.ret_str;
2686             break;
2687           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
2688           case oDisplay: opt.display = pargs.r.ret_str; break;
2689           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2690           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2691           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2692           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2693           case oGroup: add_group(pargs.r.ret_str); break;
2694           case oUnGroup: rm_group(pargs.r.ret_str); break;
2695           case oNoGroups:
2696             while(opt.grouplist)
2697               {
2698                 struct groupitem *iter=opt.grouplist;
2699                 free_strlist(iter->values);
2700                 opt.grouplist=opt.grouplist->next;
2701                 xfree(iter);
2702               }
2703             break;
2704
2705           case oStrict: 
2706           case oNoStrict: 
2707             /* Not used */
2708             break;
2709
2710           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2711           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2712           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2713           case oMultifile: multifile=1; break;
2714           case oKeyidFormat:
2715             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2716               opt.keyid_format=KF_SHORT;
2717             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2718               opt.keyid_format=KF_LONG;
2719             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2720               opt.keyid_format=KF_0xSHORT;
2721             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2722               opt.keyid_format=KF_0xLONG;
2723             else
2724               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2725             break;
2726
2727           case oExitOnStatusWriteError:
2728             opt.exit_on_status_write_error = 1;
2729             break;
2730
2731           case oLimitCardInsertTries: 
2732             opt.limit_card_insert_tries = pargs.r.ret_int; 
2733             break;
2734
2735           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2736           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2737
2738           case oAutoKeyLocate:
2739             if(!parse_auto_key_locate(pargs.r.ret_str))
2740               {
2741                 if(configname)
2742                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2743                             configname,configlineno);
2744                 else
2745                   log_error(_("invalid auto-key-locate list\n"));
2746               }
2747             break;
2748           case oNoAutoKeyLocate:
2749             release_akl();
2750             break;
2751
2752           case oAllowMultisigVerification:
2753             opt.allow_multisig_verification = 1;
2754             break;
2755
2756           case oEnableDSA2: opt.flags.dsa2=1; break;
2757           case oDisableDSA2: opt.flags.dsa2=0; break;
2758
2759           case oNoop: break;
2760
2761           default : pargs.err = configfp? 1:2; break;
2762           }
2763       }
2764
2765
2766     if( configfp ) {
2767         fclose( configfp );
2768         configfp = NULL;
2769         /* Remember the first config file name. */
2770         if (!save_configname)
2771           save_configname = configname;
2772         else
2773           xfree(configname);
2774         configname = NULL;
2775         goto next_pass;
2776     }
2777     xfree( configname ); configname = NULL;
2778     if( log_get_errorcount(0) )
2779         g10_exit(2);
2780
2781     /* The command --gpgconf-list is pretty simple and may be called
2782        directly after the option parsing. */
2783     if (cmd == aGPGConfList)
2784       {
2785         gpgconf_list (save_configname);
2786         g10_exit (0);
2787       }
2788     xfree (save_configname);
2789
2790     if( nogreeting )
2791         greeting = 0;
2792
2793     if( greeting ) {
2794         fprintf(stderr, "%s %s; %s\n",
2795                         strusage(11), strusage(13), strusage(14) );
2796         fprintf(stderr, "%s\n", strusage(15) );
2797     }
2798 #ifdef IS_DEVELOPMENT_VERSION
2799     if( !opt.batch )
2800       {
2801         const char *s;
2802
2803         if((s=strusage(20)))
2804           log_info("%s\n",s);
2805         if((s=strusage(21)))
2806           log_info("%s\n",s);
2807         if((s=strusage(22)))
2808           log_info("%s\n",s);
2809       }
2810 #endif
2811
2812     log_info ("WARNING: This version of gpg is not ready for use, use gpg 1.4.x\n");
2813
2814     /* FIXME: We should use logging to a file only in server mode;
2815        however we have not yet implemetyed that.  Thus we try to get
2816        away with --batch as indication for logging to file
2817        required. */
2818     if (logfile && opt.batch)
2819       {
2820         log_set_file (logfile);
2821         log_set_prefix (NULL, 1|2|4);
2822       }
2823
2824     if (opt.verbose > 2)
2825         log_info ("using character set `%s'\n", get_native_charset ());
2826
2827     if( may_coredump && !opt.quiet )
2828         log_info(_("WARNING: program may create a core file!\n"));
2829
2830     if (eyes_only) {
2831       if (opt.set_filename)
2832           log_info(_("WARNING: %s overrides %s\n"),
2833                    "--for-your-eyes-only","--set-filename");
2834
2835       opt.set_filename="_CONSOLE";
2836     }
2837
2838     if (opt.no_literal) {
2839         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2840         if (opt.textmode)
2841             log_error(_("%s not allowed with %s!\n"),
2842                        "--textmode", "--no-literal" );
2843         if (opt.set_filename)
2844             log_error(_("%s makes no sense with %s!\n"),
2845                         eyes_only?"--for-your-eyes-only":"--set-filename",
2846                         "--no-literal" );
2847     }
2848
2849
2850     if (opt.set_filesize)
2851         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2852     if( opt.batch )
2853         tty_batchmode( 1 );
2854
2855     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
2856
2857     if(require_secmem && !got_secmem)
2858       {
2859         log_info(_("will not run with insecure memory due to %s\n"),
2860                  "--require-secmem");
2861         g10_exit(2);
2862       }
2863
2864     set_debug (debug_level);
2865
2866     /* Do these after the switch(), so they can override settings. */
2867     if(PGP2)
2868       {
2869         int unusable=0;
2870
2871         if(cmd==aSign && !detached_sig)
2872           {
2873             log_info(_("you can only make detached or clear signatures "
2874                        "while in --pgp2 mode\n"));
2875             unusable=1;
2876           }
2877         else if(cmd==aSignEncr || cmd==aSignSym)
2878           {
2879             log_info(_("you can't sign and encrypt at the "
2880                        "same time while in --pgp2 mode\n"));
2881             unusable=1;
2882           }
2883         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2884           {
2885             log_info(_("you must use files (and not a pipe) when "
2886                        "working with --pgp2 enabled.\n"));
2887             unusable=1;
2888           }
2889         else if(cmd==aEncr || cmd==aSym)
2890           {
2891             /* Everything else should work without IDEA (except using
2892                a secret key encrypted with IDEA and setting an IDEA
2893                preference, but those have their own error
2894                messages). */
2895
2896             if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
2897               {
2898                 log_info(_("encrypting a message in --pgp2 mode requires "
2899                            "the IDEA cipher\n"));
2900                 idea_cipher_warn(1);
2901                 unusable=1;
2902               }
2903             else if(cmd==aSym)
2904               {
2905                 /* This only sets IDEA for symmetric encryption
2906                    since it is set via select_algo_from_prefs for
2907                    pk encryption. */
2908                 xfree(def_cipher_string);
2909                 def_cipher_string = xstrdup("idea");
2910               }
2911
2912             /* PGP2 can't handle the output from the textmode
2913                filter, so we disable it for anything that could
2914                create a literal packet (only encryption and
2915                symmetric encryption, since we disable signing
2916                above). */
2917             if(!unusable)
2918               opt.textmode=0;
2919           }
2920
2921         if(unusable)
2922           compliance_failure();
2923         else
2924           {
2925             opt.force_v4_certs = 0;
2926             opt.escape_from = 1;
2927             opt.force_v3_sigs = 1;
2928             opt.pgp2_workarounds = 1;
2929             opt.ask_sig_expire = 0;
2930             opt.ask_cert_expire = 0;
2931             xfree(def_digest_string);
2932             def_digest_string = xstrdup("md5");
2933             xfree(s2k_digest_string);
2934             s2k_digest_string = xstrdup("md5");
2935             opt.compress_algo = COMPRESS_ALGO_ZIP;
2936           }
2937       }
2938     else if(PGP6)
2939       {
2940         opt.escape_from=1;
2941         opt.force_v3_sigs=1;
2942         opt.ask_sig_expire=0;
2943       }
2944     else if(PGP7)
2945       {
2946         opt.escape_from=1;
2947         opt.force_v3_sigs=1;
2948         opt.ask_sig_expire=0;
2949       }
2950     else if(PGP8)
2951       {
2952         opt.escape_from=1;
2953       }
2954
2955
2956     if( def_cipher_string ) {
2957         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
2958         if(opt.def_cipher_algo==0 &&
2959            (ascii_strcasecmp(def_cipher_string,"idea")==0
2960             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2961           idea_cipher_warn(1);
2962         xfree(def_cipher_string); def_cipher_string = NULL;
2963         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
2964             log_error(_("selected cipher algorithm is invalid\n"));
2965     }
2966     if( def_digest_string ) {
2967         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
2968         xfree(def_digest_string); def_digest_string = NULL;
2969         if ( openpgp_md_test_algo (opt.def_digest_algo) )
2970             log_error(_("selected digest algorithm is invalid\n"));
2971     }
2972     if( compress_algo_string ) {
2973         opt.compress_algo = string_to_compress_algo(compress_algo_string);
2974         xfree(compress_algo_string); compress_algo_string = NULL;
2975         if( check_compress_algo(opt.compress_algo) )
2976           log_error(_("selected compression algorithm is invalid\n"));
2977     }
2978     if( cert_digest_string ) {
2979         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
2980         xfree(cert_digest_string); cert_digest_string = NULL;
2981         if (openpgp_md_test_algo(opt.cert_digest_algo))
2982           log_error(_("selected certification digest algorithm is invalid\n"));
2983     }
2984     if( s2k_cipher_string ) {
2985         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
2986         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
2987         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
2988           log_error(_("selected cipher algorithm is invalid\n"));
2989     }
2990     if( s2k_digest_string ) {
2991         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
2992         xfree(s2k_digest_string); s2k_digest_string = NULL;
2993         if (openpgp_md_test_algo(opt.s2k_digest_algo))
2994           log_error(_("selected digest algorithm is invalid\n"));
2995     }
2996     if( opt.completes_needed < 1 )
2997       log_error(_("completes-needed must be greater than 0\n"));
2998     if( opt.marginals_needed < 2 )
2999       log_error(_("marginals-needed must be greater than 1\n"));
3000     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3001       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3002     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3003       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3004     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3005       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3006     switch( opt.s2k_mode ) {
3007       case 0:
3008         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3009         break;
3010       case 1: case 3: break;
3011       default:
3012         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3013     }
3014
3015     /* This isn't actually needed, but does serve to error out if the
3016        string is invalid. */
3017     if(opt.def_preference_list &&
3018         keygen_set_std_prefs(opt.def_preference_list,0))
3019       log_error(_("invalid default preferences\n"));
3020
3021     /* We provide defaults for the personal digest list.  This is
3022        SHA-1. */
3023     if(!pers_digest_list)
3024       pers_digest_list="h2";
3025
3026     if(pers_cipher_list &&
3027        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3028       log_error(_("invalid personal cipher preferences\n"));
3029
3030     if(pers_digest_list &&
3031        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3032       log_error(_("invalid personal digest preferences\n"));
3033
3034     if(pers_compress_list &&
3035        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3036       log_error(_("invalid personal compress preferences\n"));
3037
3038     /* We don't support all possible commands with multifile yet */
3039     if(multifile)
3040       {
3041         char *cmdname;
3042
3043         switch(cmd)
3044           {
3045           case aSign:
3046             cmdname="--sign";
3047             break;
3048           case aClearsign:
3049             cmdname="--clearsign";
3050             break;
3051           case aDetachedSign:
3052             cmdname="--detach-sign";
3053             break;
3054           case aSym:
3055             cmdname="--symmetric";
3056             break;
3057           case aEncrSym:
3058             cmdname="--symmetric --encrypt";
3059             break;
3060           case aStore:
3061             cmdname="--store";
3062             break;
3063           default:
3064             cmdname=NULL;
3065             break;
3066           }
3067
3068         if(cmdname)
3069           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3070       }
3071
3072     if( log_get_errorcount(0) )
3073         g10_exit(2);
3074
3075     if(opt.compress_level==0)
3076       opt.compress_algo=COMPRESS_ALGO_NONE;
3077
3078     /* Check our chosen algorithms against the list of legal
3079        algorithms. */
3080
3081     if(!GNUPG)
3082       {
3083         const char *badalg=NULL;
3084         preftype_t badtype=PREFTYPE_NONE;
3085
3086         if(opt.def_cipher_algo
3087            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3088           {
3089             badalg = gcry_cipher_algo_name (opt.def_cipher_algo);
3090             badtype = PREFTYPE_SYM;
3091           }
3092         else if(opt.def_digest_algo
3093                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3094           {
3095             badalg = gcry_md_algo_name (opt.def_digest_algo);
3096             badtype = PREFTYPE_HASH;
3097           }
3098         else if(opt.cert_digest_algo
3099                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3100           {
3101             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3102             badtype = PREFTYPE_HASH;
3103           }
3104         else if(opt.compress_algo!=-1
3105                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3106           {
3107             badalg = compress_algo_to_string(opt.compress_algo);
3108             badtype = PREFTYPE_ZIP;
3109           }
3110
3111         if(badalg)
3112           {
3113             switch(badtype)
3114               {
3115               case PREFTYPE_SYM:
3116                 log_info(_("you may not use cipher algorithm `%s'"
3117                            " while in %s mode\n"),
3118                          badalg,compliance_option_string());
3119                 break;
3120               case PREFTYPE_HASH:
3121                 log_info(_("you may not use digest algorithm `%s'"
3122                            " while in %s mode\n"),
3123                          badalg,compliance_option_string());
3124                 break;
3125               case PREFTYPE_ZIP:
3126                 log_info(_("you may not use compression algorithm `%s'"
3127                            " while in %s mode\n"),
3128                          badalg,compliance_option_string());
3129                 break;
3130               default:
3131                 BUG();
3132               }
3133
3134             compliance_failure();
3135           }
3136       }
3137
3138     /* Set the random seed file. */
3139     if( use_random_seed ) {
3140         char *p = make_filename(opt.homedir, "random_seed", NULL );
3141         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3142         if (!access (p, F_OK))
3143           register_secured_file (p);
3144         xfree(p);
3145     }
3146
3147     if( !cmd && opt.fingerprint && !with_fpr ) {
3148         set_cmd( &cmd, aListKeys);
3149     }
3150
3151     /* kludge to let -sat generate a clear text signature */
3152     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
3153       {
3154         log_info ("compatibility note:\n");
3155         log_info ("\"-sat\" won't generate clear signed messages in "
3156                   "future versions\n");
3157         log_info ("Use \"--clearsign\" instead of \"-sat\"\n");
3158         cmd = aClearsign;
3159       }
3160
3161     if( opt.verbose > 1 )
3162         set_packet_list_mode(1);
3163
3164     /* Add the keyrings, but not for some special commands.  Also
3165        avoid adding the secret keyring for a couple of commands to
3166        avoid unneeded access in case the secrings are stored on a
3167        floppy.
3168        
3169        We always need to add the keyrings if we are running under
3170        SELinux, this is so that the rings are added to the list of
3171        secured files. */
3172     if( ALWAYS_ADD_KEYRINGS 
3173         || (cmd != aDeArmor && cmd != aEnArmor) ) 
3174       {
3175         if (ALWAYS_ADD_KEYRINGS
3176             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3177                 && cmd != aVerify && cmd != aSym))
3178           {
3179             if (!sec_nrings || default_keyring) /* add default secret rings */
3180               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3181             for (sl = sec_nrings; sl; sl = sl->next)
3182               keydb_add_resource ( sl->d, 0, 1 );
3183           }
3184         if( !nrings || default_keyring )  /* add default ring */
3185             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3186         for(sl = nrings; sl; sl = sl->next )
3187             keydb_add_resource ( sl->d, sl->flags, 0 );
3188       }
3189     FREE_STRLIST(nrings);
3190     FREE_STRLIST(sec_nrings);
3191
3192
3193     if( pwfd != -1 )  /* read the passphrase now. */
3194         read_passphrase_from_fd( pwfd );
3195
3196     fname = argc? *argv : NULL;
3197
3198     if(fname && utf8_strings)
3199       opt.flags.utf8_filename=1;
3200
3201     switch( cmd ) {
3202       case aPrimegen:
3203       case aPrintMD:
3204       case aPrintMDs:
3205       case aGenRandom:
3206       case aDeArmor:
3207       case aEnArmor:
3208       case aFixTrustDB:
3209         break;
3210       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3211       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3212       default: rc = setup_trustdb(1, trustdb_name ); break;
3213     }
3214     if( rc )
3215         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3216
3217
3218     switch (cmd)
3219       {
3220       case aStore: 
3221       case aSym:  
3222       case aSign: 
3223       case aSignSym: 
3224       case aClearsign: 
3225         if (!opt.quiet && any_explicit_recipient)
3226           log_info (_("WARNING: recipients (-r) given "
3227                       "without using public key encryption\n"));
3228         break;
3229       default:
3230         break;
3231       }
3232
3233     switch( cmd )
3234       {
3235       case aStore: /* only store the file */
3236         if( argc > 1 )
3237             wrong_args(_("--store [filename]"));
3238         if( (rc = encode_store(fname)) )
3239             log_error ("storing `%s' failed: %s\n",
3240                        print_fname_stdin(fname),g10_errstr(rc) );
3241         break;
3242       case aSym: /* encrypt the given file only with the symmetric cipher */
3243         if( argc > 1 )
3244             wrong_args(_("--symmetric [filename]"));
3245         if( (rc = encode_symmetric(fname)) )
3246             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3247                         print_fname_stdin(fname),g10_errstr(rc) );
3248         break;
3249
3250       case aEncr: /* encrypt the given file */
3251         if(multifile)
3252           encode_crypt_files(argc, argv, remusr);
3253         else
3254           {
3255             if( argc > 1 )
3256               wrong_args(_("--encrypt [filename]"));
3257             if( (rc = encode_crypt(fname,remusr,0)) )
3258               log_error("%s: encryption failed: %s\n",
3259                         print_fname_stdin(fname), g10_errstr(rc) );
3260           }
3261         break;
3262
3263       case aEncrSym:
3264         /* This works with PGP 8 in the sense that it acts just like a
3265            symmetric message.  It doesn't work at all with 2 or 6.  It
3266            might work with 7, but alas, I don't have a copy to test
3267            with right now. */
3268         if( argc > 1 )
3269           wrong_args(_("--symmetric --encrypt [filename]"));
3270         else if(opt.s2k_mode==0)
3271           log_error(_("you cannot use --symmetric --encrypt"
3272                       " with --s2k-mode 0\n"));
3273         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3274           log_error(_("you cannot use --symmetric --encrypt"
3275                       " while in %s mode\n"),compliance_option_string());
3276         else
3277           {
3278             if( (rc = encode_crypt(fname,remusr,1)) )
3279               log_error("%s: encryption failed: %s\n",
3280                         print_fname_stdin(fname), g10_errstr(rc) );
3281           }
3282         break;
3283
3284       case aSign: /* sign the given file */
3285         sl = NULL;
3286         if( detached_sig ) { /* sign all files */
3287             for( ; argc; argc--, argv++ )
3288                 add_to_strlist( &sl, *argv );
3289         }
3290         else {
3291             if( argc > 1 )
3292                 wrong_args(_("--sign [filename]"));
3293             if( argc ) {
3294                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3295                 strcpy(sl->d, fname);
3296             }
3297         }
3298         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3299             log_error("signing failed: %s\n", g10_errstr(rc) );
3300         free_strlist(sl);
3301         break;
3302
3303       case aSignEncr: /* sign and encrypt the given file */
3304         if( argc > 1 )
3305             wrong_args(_("--sign --encrypt [filename]"));
3306         if( argc ) {
3307             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3308             strcpy(sl->d, fname);
3309         }
3310         else
3311             sl = NULL;
3312         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3313             log_error("%s: sign+encrypt failed: %s\n",
3314                       print_fname_stdin(fname), g10_errstr(rc) );
3315         free_strlist(sl);
3316         break;
3317
3318       case aSignEncrSym: /* sign and encrypt the given file */
3319         if( argc > 1 )
3320             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3321         else if(opt.s2k_mode==0)
3322           log_error(_("you cannot use --symmetric --sign --encrypt"
3323                       " with --s2k-mode 0\n"));
3324         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3325           log_error(_("you cannot use --symmetric --sign --encrypt"
3326                       " while in %s mode\n"),compliance_option_string());
3327         else
3328           {
3329             if( argc )
3330               {
3331                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3332                 strcpy(sl->d, fname);
3333               }
3334             else
3335               sl = NULL;
3336             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3337               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3338                         print_fname_stdin(fname), g10_errstr(rc) );
3339             free_strlist(sl);
3340           }
3341         break;
3342
3343       case aSignSym: /* sign and conventionally encrypt the given file */
3344         if (argc > 1)
3345             wrong_args(_("--sign --symmetric [filename]"));
3346         rc = sign_symencrypt_file (fname, locusr);
3347         if (rc)
3348             log_error("%s: sign+symmetric failed: %s\n",
3349                       print_fname_stdin(fname), g10_errstr(rc) );
3350         break;
3351
3352       case aClearsign: /* make a clearsig */
3353         if( argc > 1 )
3354             wrong_args(_("--clearsign [filename]"));
3355         if( (rc = clearsign_file(fname, locusr, NULL)) )
3356             log_error("%s: clearsign failed: %s\n",
3357                       print_fname_stdin(fname), g10_errstr(rc) );
3358         break;
3359
3360       case aVerify:
3361         if(multifile)
3362           {
3363             if( (rc = verify_files( argc, argv ) ))
3364               log_error("verify files failed: %s\n", g10_errstr(rc) );
3365           }
3366         else
3367           {
3368             if( (rc = verify_signatures( argc, argv ) ))
3369               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3370           }
3371         break;
3372
3373       case aDecrypt:
3374         if(multifile)
3375           decrypt_messages(argc, argv);
3376         else
3377           {
3378             if( argc > 1 )
3379               wrong_args(_("--decrypt [filename]"));
3380             if( (rc = decrypt_message( fname ) ))
3381               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3382           }
3383         break;
3384             
3385       case aSignKey:
3386         if( argc != 1 )
3387           wrong_args(_("--sign-key user-id"));
3388         /* fall through */
3389       case aLSignKey:
3390         if( argc != 1 )
3391           wrong_args(_("--lsign-key user-id"));
3392         /* fall through */
3393
3394         sl=NULL;
3395
3396         if(cmd==aSignKey)
3397           append_to_strlist(&sl,"sign");
3398         else if(cmd==aLSignKey)
3399           append_to_strlist(&sl,"lsign");
3400         else
3401           BUG();
3402
3403         append_to_strlist( &sl, "save" );
3404         username = make_username( fname );
3405         keyedit_menu(fname, locusr, sl, 0, 0 );
3406         xfree(username);
3407         free_strlist(sl);
3408         break;
3409
3410       case aEditKey: /* Edit a key signature */
3411         if( !argc )
3412             wrong_args(_("--edit-key user-id [commands]"));
3413         username = make_username( fname );
3414         if( argc > 1 ) {
3415             sl = NULL;
3416             for( argc--, argv++ ; argc; argc--, argv++ )
3417                 append_to_strlist( &sl, *argv );
3418             keyedit_menu( username, locusr, sl, 0, 1 );
3419             free_strlist(sl);
3420         }
3421         else
3422             keyedit_menu(username, locusr, NULL, 0, 1 );
3423         xfree(username);
3424         break;
3425
3426       case aDeleteKeys:
3427       case aDeleteSecretKeys:
3428       case aDeleteSecretAndPublicKeys:
3429         sl = NULL;
3430         /* I'm adding these in reverse order as add_to_strlist2
3431            reverses them again, and it's easier to understand in the
3432            proper order :) */
3433         for( ; argc; argc-- )
3434           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3435         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3436         free_strlist(sl);
3437         break;
3438
3439       case aCheckKeys:
3440         opt.check_sigs = 1;
3441       case aListSigs:
3442         opt.list_sigs = 1;
3443       case aListKeys:
3444         sl = NULL;
3445         for( ; argc; argc--, argv++ )
3446             add_to_strlist2( &sl, *argv, utf8_strings );
3447         public_key_list( sl );
3448         free_strlist(sl);
3449         break;
3450       case aListSecretKeys:
3451         sl = NULL;
3452         for( ; argc; argc--, argv++ )
3453             add_to_strlist2( &sl, *argv, utf8_strings );
3454         secret_key_list( sl );
3455         free_strlist(sl);
3456         break;
3457
3458       case aKeygen: /* generate a key */
3459         if( opt.batch ) {
3460             if( argc > 1 )
3461                 wrong_args("--gen-key [parameterfile]");
3462             generate_keypair( argc? *argv : NULL, NULL, NULL );
3463         }
3464         else {
3465             if( argc )
3466                 wrong_args("--gen-key");
3467             generate_keypair(NULL, NULL, NULL);
3468         }
3469         break;
3470
3471       case aFastImport:
3472         opt.import_options |= IMPORT_FAST;
3473       case aImport:
3474         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3475         break;
3476
3477         /* TODO: There are a number of command that use this same
3478            "make strlist, call function, report error, free strlist"
3479            pattern.  Join them together here and avoid all that
3480            duplicated code. */
3481
3482       case aExport:
3483       case aSendKeys:
3484       case aRecvKeys:
3485         sl = NULL;
3486         for( ; argc; argc--, argv++ )
3487             append_to_strlist2( &sl, *argv, utf8_strings );
3488         if( cmd == aSendKeys )
3489             rc=keyserver_export( sl );
3490         else if( cmd == aRecvKeys )
3491             rc=keyserver_import( sl );
3492         else
3493             rc=export_pubkeys( sl, opt.export_options );
3494         if(rc)
3495           {
3496             if(cmd==aSendKeys)
3497               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3498             else if(cmd==aRecvKeys)
3499               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3500             else
3501               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3502           }
3503         free_strlist(sl);
3504         break;
3505
3506      case aSearchKeys:
3507         sl = NULL;
3508         for( ; argc; argc--, argv++ )
3509           append_to_strlist2( &sl, *argv, utf8_strings );
3510         rc=keyserver_search( sl );
3511         if(rc)
3512           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3513         free_strlist(sl);
3514         break;
3515
3516       case aRefreshKeys:
3517         sl = NULL;
3518         for( ; argc; argc--, argv++ )