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