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