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