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