b1c7971e2a122c92a2e9cf94223ea9ce967bc634
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998,1999,2000,2001,2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <assert.h>
29 #ifdef HAVE_DOSISH_SYSTEM
30   #include <fcntl.h> /* for setmode() */
31 #endif
32 #ifdef HAVE_STAT
33 #include <sys/stat.h> /* for stat() */
34 #endif
35
36 #define INCLUDED_BY_MAIN_MODULE 1
37 #include "packet.h"
38 #include "iobuf.h"
39 #include "memory.h"
40 #include "util.h"
41 #include "main.h"
42 #include "options.h"
43 #include "keydb.h"
44 #include "trustdb.h"
45 #include "mpi.h"
46 #include "cipher.h"
47 #include "filter.h"
48 #include "ttyio.h"
49 #include "i18n.h"
50 #include "status.h"
51 #include "g10defs.h"
52 #include "keyserver-internal.h"
53 #include "exec.h"
54
55 enum cmd_and_opt_values { aNull = 0,
56     oArmor        = 'a',
57     aDetachedSign = 'b',
58     aSym          = 'c',
59     aDecrypt      = 'd',
60     aEncr         = 'e',
61     aEncrFiles,
62     oInteractive  = 'i',
63     oKOption      = 'k',
64     oDryRun       = 'n',
65     oOutput       = 'o',
66     oQuiet        = 'q',
67     oRecipient    = 'r',
68     oHiddenRecipient = 'R',
69     aSign         = 's',
70     oTextmodeShort= 't',
71     oUser         = 'u',
72     oVerbose      = 'v',
73     oCompress     = 'z',
74     oNotation     = 'N',
75     oBatch        = 500,
76     oSigNotation,
77     oCertNotation,
78     oShowNotation,
79     oNoShowNotation,
80     aDecryptFiles,                          
81     aClearsign,
82     aStore,
83     aKeygen,
84     aSignEncr,
85     aSignSym,
86     aSignKey,
87     aLSignKey,
88     aNRSignKey,
89     aNRLSignKey,
90     aListPackets,
91     aEditKey,
92     aDeleteKeys,
93     aDeleteSecretKeys,
94     aDeleteSecretAndPublicKeys,
95     aKMode,
96     aKModeC,
97     aImport,
98     aFastImport,
99     aVerify,
100     aVerifyFiles,
101     aListKeys,
102     aListSigs,
103     aListSecretKeys,
104     aSendKeys,
105     aRecvKeys,
106     aSearchKeys,
107     aExport,
108     aExportAll,
109     aExportSecret,
110     aExportSecretSub,
111     aCheckKeys,
112     aGenRevoke,
113     aDesigRevoke,
114     aPrimegen,
115     aPrintMD,
116     aPrintMDs,
117     aCheckTrustDB,
118     aUpdateTrustDB,
119     aFixTrustDB,
120     aListTrustDB,
121     aListTrustPath,
122     aExportOwnerTrust,
123     aImportOwnerTrust,
124     aDeArmor,
125     aEnArmor,
126     aGenRandom,
127     aPipeMode,
128     aRebuildKeydbCaches,
129     aRefreshKeys,
130
131     oTextmode,
132     oExpert,
133     oNoExpert,
134     oAskSigExpire,
135     oNoAskSigExpire,
136     oAskCertExpire,
137     oNoAskCertExpire,
138     oFingerprint,
139     oWithFingerprint,
140     oAnswerYes,
141     oAnswerNo,
142     oDefCertCheckLevel,
143     oKeyring,
144     oPrimaryKeyring,
145     oSecretKeyring,
146     oShowKeyring,
147     oDefaultKey,
148     oDefRecipient,
149     oDefRecipientSelf,
150     oNoDefRecipient,
151     oOptions,
152     oDebug,
153     oDebugAll,
154     oStatusFD,
155 #ifdef __riscos__
156     oStatusFile,
157 #endif /* __riscos__ */
158     oAttributeFD,
159 #ifdef __riscos__
160     oAttributeFile,
161 #endif /* __riscos__ */
162     oSKComments,
163     oNoSKComments,
164     oNoVersion,
165     oEmitVersion,
166     oCompletesNeeded,
167     oMarginalsNeeded,
168     oMaxCertDepth,
169     oLoadExtension,
170     oRFC1991,
171     oOpenPGP,
172     oPGP2,
173     oNoPGP2,
174     oPGP6,
175     oNoPGP6,
176     oPGP7,
177     oNoPGP7,
178     oPGP8,
179     oNoPGP8,
180     oCipherAlgo,
181     oDigestAlgo,
182     oCertDigestAlgo,
183     oCompressAlgo,
184     oPasswdFD,
185 #ifdef __riscos__
186     oPasswdFile,
187 #endif /* __riscos__ */
188     oCommandFD,
189 #ifdef __riscos__
190     oCommandFile,
191 #endif /* __riscos__ */
192     oQuickRandom,
193     oNoVerbose,
194     oTrustDBName,
195     oNoSecmemWarn,
196     oNoPermissionWarn,
197     oNoMDCWarn,
198     oNoArmor,
199     oNoDefKeyring,
200     oNoGreeting,
201     oNoTTY,
202     oNoOptions,
203     oNoBatch,
204     oHomedir,
205     oWithColons,
206     oWithKeyData,
207     oSkipVerify,
208     oCompressKeys,
209     oCompressSigs,
210     oAlwaysTrust,
211     oTrustModel,
212     oForceOwnertrust,
213     oEmuChecksumBug,
214     oRunAsShmCP,
215     oSetFilename,
216     oForYourEyesOnly,
217     oNoForYourEyesOnly,
218     oSetPolicyURL,
219     oSigPolicyURL,
220     oCertPolicyURL,
221     oShowPolicyURL,
222     oNoShowPolicyURL,
223     oUseEmbeddedFilename,
224     oComment,
225     oDefaultComment,
226     oThrowKeyid,
227     oNoThrowKeyid,
228     oShowPhotos,
229     oNoShowPhotos,
230     oPhotoViewer,
231     oForceV3Sigs,
232     oNoForceV3Sigs,
233     oForceV4Certs,
234     oNoForceV4Certs,
235     oForceMDC,
236     oNoForceMDC,
237     oDisableMDC,
238     oNoDisableMDC,
239     oS2KMode,
240     oS2KDigest,
241     oS2KCipher,
242     oSimpleSKChecksum,                          
243     oCharset,
244     oNotDashEscaped,
245     oEscapeFrom,
246     oNoEscapeFrom,
247     oLockOnce,
248     oLockMultiple,
249     oLockNever,
250     oKeyServer,
251     oKeyServerOptions,
252     oImportOptions,
253     oExportOptions,
254     oTempDir,
255     oExecPath,
256     oEncryptTo,
257     oHiddenEncryptTo,
258     oNoEncryptTo,
259     oLoggerFD,
260 #ifdef __riscos__
261     oLoggerFile,
262 #endif /* __riscos__ */
263     oUtf8Strings,
264     oNoUtf8Strings,
265     oDisableCipherAlgo,
266     oDisablePubkeyAlgo,
267     oAllowNonSelfsignedUID,
268     oNoAllowNonSelfsignedUID,
269     oAllowFreeformUID,
270     oNoAllowFreeformUID,
271     oAllowSecretKeyImport,                      
272     oEnableSpecialFilenames,
273     oNoLiteral,
274     oSetFilesize,
275     oHonorHttpProxy,
276     oFastListMode,
277     oListOnly,
278     oIgnoreTimeConflict,
279     oIgnoreValidFrom,
280     oIgnoreCrcError,
281     oIgnoreMDCError,
282     oShowSessionKey,
283     oOverrideSessionKey,
284     oNoRandomSeedFile,
285     oAutoKeyRetrieve,
286     oNoAutoKeyRetrieve,
287     oUseAgent,
288     oNoUseAgent,
289     oGpgAgentInfo,
290     oMergeOnly,
291     oTryAllSecrets,
292     oTrustedKey,
293     oNoExpensiveTrustChecks,
294     oFixedListMode,
295     oNoSigCache,
296     oNoSigCreateCheck,
297     oAutoCheckTrustDB,
298     oNoAutoCheckTrustDB,
299     oPreservePermissions,
300     oDefaultPreferenceList,
301     oPersonalCipherPreferences,
302     oPersonalDigestPreferences,
303     oPersonalCompressPreferences,
304     oEmuMDEncodeBug,
305     oDisplay,
306     oTTYname,
307     oTTYtype,
308     oLCctype,
309     oLCmessages,
310     oGroup,
311     oStrict,
312     oNoStrict,
313     oMangleDosFilenames,
314     oNoMangleDosFilenames,
315 aTest };
316
317
318 static ARGPARSE_OPTS opts[] = {
319
320     { 300, NULL, 0, N_("@Commands:\n ") },
321
322     { aSign, "sign",      256, N_("|[file]|make a signature")},
323     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
324     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
325     { aEncr, "encrypt",   256, N_("encrypt data")},
326     { aEncrFiles, "encrypt-files", 256, N_("|[files]|encrypt files")},
327     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
328     { aStore, "store",     256, N_("store only")},
329     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
330     { aDecryptFiles, "decrypt-files", 256, N_("|[files]|decrypt files")},
331     { aVerify, "verify"   , 256, N_("verify a signature")},
332     { aVerifyFiles, "verify-files" , 256, "@" },
333     { aListKeys, "list-keys", 256, N_("list keys")},
334     { aListKeys, "list-public-keys", 256, "@" },
335     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
336     { aCheckKeys, "check-sigs",256, N_("check key signatures")},
337     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
338     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
339     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
340     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
341     { aDeleteSecretKeys, "delete-secret-keys",256,
342                                     N_("remove keys from the secret keyring")},
343     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
344     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
345     { aNRSignKey, "nrsign-key"  ,256, N_("sign a key non-revocably")},
346     { aNRLSignKey, "nrlsign-key"  ,256, N_("sign a key locally and non-revocably")},
347     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
348     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
349     { aDesigRevoke, "desig-revoke",256, "@" },
350     { aExport, "export"           , 256, N_("export keys") },
351     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
352     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
353     { aSearchKeys, "search-keys" , 256,
354                                     N_("search for keys on a key server") },
355     { aRefreshKeys, "refresh-keys", 256,
356                                     N_("update all keys from a keyserver")},
357     { aExportAll, "export-all"    , 256, "@" },
358     { aExportSecret, "export-secret-keys" , 256, "@" },
359     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
360     { aImport, "import",      256     , N_("import/merge keys")},
361     { aFastImport, "fast-import",  256 , "@"},
362     { aListPackets, "list-packets",256,N_("list only the sequence of packets")},
363     { aExportOwnerTrust,
364               "export-ownertrust", 256, N_("export the ownertrust values")},
365     { aImportOwnerTrust,
366               "import-ownertrust", 256 , N_("import ownertrust values")},
367     { aUpdateTrustDB,
368               "update-trustdb",0 , N_("update the trust database")},
369     { aCheckTrustDB,
370               "check-trustdb",0 , N_("unattended trust database update")},
371     { aFixTrustDB, "fix-trustdb",0 , N_("fix a corrupted trust database")},
372     { aDeArmor, "dearmor", 256, N_("De-Armor a file or stdin") },
373     { aDeArmor, "dearmour", 256, "@" },
374     { aEnArmor, "enarmor", 256, N_("En-Armor a file or stdin") },
375     { aEnArmor, "enarmour", 256, "@" },
376     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
377     { aPrimegen, "gen-prime" , 256, "@" },
378     { aGenRandom, "gen-random" , 256, "@" },
379
380     { 301, NULL, 0, N_("@\nOptions:\n ") },
381
382     { oArmor, "armor",     0, N_("create ascii armored output")},
383     { oArmor, "armour",     0, "@" },
384     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
385     { oHiddenRecipient, "hidden-recipient", 2, "@" },
386     { oRecipient, "remote-user", 2, "@"},  /* old option name */
387     { oDefRecipient, "default-recipient" ,2,
388                                   N_("|NAME|use NAME as default recipient")},
389     { oDefRecipientSelf, "default-recipient-self" ,0,
390                                 N_("use the default key as default recipient")},
391     { oNoDefRecipient, "no-default-recipient", 0, "@" },
392     { oTempDir, "temp-directory", 2, "@" },
393     { oExecPath, "exec-path", 2, "@" },
394     { oEncryptTo, "encrypt-to", 2, "@" },
395     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
396     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
397     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
398     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
399     { oTextmodeShort, NULL,   0, "@"},
400     { oTextmode, "textmode",  0, N_("use canonical text mode")},
401     { oExpert, "expert",   0, "@"},
402     { oNoExpert, "no-expert",   0, "@"},
403     { oAskSigExpire, "ask-sig-expire",   0, "@"},
404     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
405     { oAskCertExpire, "ask-cert-expire",   0, "@"},
406     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
407     { oOutput, "output",    2, N_("use as output file")},
408     { oVerbose, "verbose",   0, N_("verbose") },
409     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
410     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
411     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
412     { oNoForceV3Sigs, "no-force-v3-sigs", 0, N_("do not force v3 signatures") },
413     { oForceV4Certs, "force-v4-certs", 0, N_("force v4 key signatures") },
414     { oNoForceV4Certs, "no-force-v4-certs", 0, N_("do not force v4 key signatures") },
415     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
416     { oNoForceMDC, "no-force-mdc", 0, "@" },
417     { oDisableMDC, "disable-mdc", 0, N_("never use a MDC for encryption") },
418     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
419     { oDryRun, "dry-run",   0, N_("do not make any changes") },
420     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
421     { oUseAgent, "use-agent",0, N_("use the gpg-agent")},
422     { oNoUseAgent, "no-use-agent",0, "@"},
423     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
424     { oBatch, "batch",     0, N_("batch mode: never ask")},
425     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
426     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
427     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
428     { oPrimaryKeyring, "primary-keyring",2, "@" },
429     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
430     { oShowKeyring, "show-keyring", 0, N_("show which keyring a listed key is on")},
431     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
432     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
433     { oKeyServerOptions, "keyserver-options",2,"@"},
434     { oImportOptions, "import-options",2,"@"},
435     { oExportOptions, "export-options",2,"@"},
436     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
437     { oOptions, "options"   , 2, N_("read options from file")},
438
439     { oDebug, "debug"     ,4|16, "@"},
440     { oDebugAll, "debug-all" ,0, "@"},
441     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
442 #ifdef __riscos__
443     { oStatusFile, "status-file" ,2, N_("|[file]|write status info to file") },
444 #endif /* __riscos__ */
445     { oAttributeFD, "attribute-fd" ,1, "@" },
446 #ifdef __riscos__
447     { oAttributeFile, "attribute-file" ,2, "@" },
448 #endif /* __riscos__ */
449     { oNoSKComments, "no-comment", 0,   "@"},
450     { oNoSKComments, "no-sk-comments", 0,   "@"},
451     { oSKComments, "sk-comments", 0,   "@"},
452     { oCompletesNeeded, "completes-needed", 1, "@"},
453     { oMarginalsNeeded, "marginals-needed", 1, "@"},
454     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
455     { oTrustedKey, "trusted-key", 2, N_("|KEYID|ultimately trust this key")},
456     { oLoadExtension, "load-extension" ,2, N_("|FILE|load extension module FILE")},
457     { oRFC1991, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
458     { oOpenPGP, "openpgp", 0, N_("set all packet, cipher and digest options to OpenPGP behavior")},
459     { oPGP2, "pgp2", 0, N_("set all packet, cipher and digest options to PGP 2.x behavior")},
460     { oNoPGP2, "no-pgp2", 0, "@"},
461     { oPGP6, "pgp6", 0, "@"},
462     { oNoPGP6, "no-pgp6", 0, "@"},
463     { oPGP7, "pgp7", 0, "@"},
464     { oNoPGP7, "no-pgp7", 0, "@"},
465     { oPGP8, "pgp8", 0, "@"},
466     { oNoPGP8, "no-pgp8", 0, "@"},
467     { oS2KMode, "s2k-mode",  1, N_("|N|use passphrase mode N")},
468     { oS2KDigest, "s2k-digest-algo",2,
469                 N_("|NAME|use message digest algorithm NAME for passphrases")},
470     { oS2KCipher, "s2k-cipher-algo",2,
471                 N_("|NAME|use cipher algorithm NAME for passphrases")},
472     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
473     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
474     { oDigestAlgo, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
475     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
476     { oCompressAlgo,"compress-algo",2,N_("|NAME|use compression algorithm NAME")},
477     { oThrowKeyid, "throw-keyid", 0, N_("throw keyid field of encrypted packets")},
478     { oNoThrowKeyid, "no-throw-keyid", 0, "@" },
479     { oShowPhotos,   "show-photos", 0, N_("Show Photo IDs")},
480     { oNoShowPhotos, "no-show-photos", 0, N_("Don't show Photo IDs")},
481     { oPhotoViewer,  "photo-viewer", 2, N_("Set command line to view Photo IDs")},
482     { oNotation,   "notation-data", 2, "@" },
483     { oSigNotation,   "sig-notation", 2, "@" },
484     { oCertNotation,  "cert-notation", 2, "@" },
485
486     { 302, NULL, 0, N_(
487   "@\n(See the man page for a complete listing of all commands and options)\n"
488                       )},
489
490     { 303, NULL, 0, N_("@\nExamples:\n\n"
491     " -se -r Bob [file]          sign and encrypt for user Bob\n"
492     " --clearsign [file]         make a clear text signature\n"
493     " --detach-sign [file]       make a detached signature\n"
494     " --list-keys [names]        show keys\n"
495     " --fingerprint [names]      show fingerprints\n"  ) },
496
497   /* hidden options */
498     { aExportOwnerTrust, "list-ownertrust",0 , "@"},  /* alias */
499     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
500     { aListTrustDB, "list-trustdb",0 , "@"},
501     /* Not yet used */
502     /* { aListTrustPath, "list-trust-path",0, "@"}, */
503     { aPipeMode,  "pipemode", 0, "@" },
504     { oKOption, NULL,    0, "@"},
505     { oPasswdFD, "passphrase-fd",1, "@" },
506 #ifdef __riscos__
507     { oPasswdFile, "passphrase-file",2, "@" },
508 #endif /* __riscos__ */
509     { oCommandFD, "command-fd",1, "@" },
510 #ifdef __riscos__
511     { oCommandFile, "command-file",2, "@" },
512 #endif /* __riscos__ */
513     { oQuickRandom, "quick-random", 0, "@"},
514     { oNoVerbose, "no-verbose", 0, "@"},
515     { oTrustDBName, "trustdb-name", 2, "@" },
516     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
517     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
518     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
519     { oNoArmor, "no-armor",   0, "@"},
520     { oNoArmor, "no-armour",   0, "@"},
521     { oNoDefKeyring, "no-default-keyring", 0, "@" },
522     { oNoGreeting, "no-greeting", 0, "@" },
523     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
524     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
525     { oNoBatch, "no-batch", 0, "@" },
526     { oWithColons, "with-colons", 0, "@"},
527     { oWithKeyData,"with-key-data", 0, "@"},
528     { aListKeys, "list-key", 0, "@" }, /* alias */
529     { aListSigs, "list-sig", 0, "@" }, /* alias */
530     { aCheckKeys, "check-sig",0, "@" }, /* alias */
531     { oSkipVerify, "skip-verify",0, "@" },
532     { oCompressKeys, "compress-keys",0, "@"},
533     { oCompressSigs, "compress-sigs",0, "@"},
534     { oDefCertCheckLevel, "default-cert-check-level", 1, "@"},
535     { oAlwaysTrust, "always-trust", 0, "@"},
536     { oTrustModel, "trust-model", 2, "@"},
537     { oForceOwnertrust, "force-ownertrust", 1, "@"},
538     { oEmuChecksumBug, "emulate-checksum-bug", 0, "@"},
539     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
540     { oSetFilename, "set-filename", 2, "@" },
541     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
542     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
543     { oSetPolicyURL, "set-policy-url", 2, "@" },
544     { oSigPolicyURL, "sig-policy-url", 2, "@" },
545     { oCertPolicyURL, "cert-policy-url", 2, "@" },
546     { oShowPolicyURL, "show-policy-url", 0, "@" },
547     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
548     { oShowNotation, "show-notation", 0, "@" },
549     { oNoShowNotation, "no-show-notation", 0, "@" },
550     { oComment, "comment", 2, "@" },
551     { oDefaultComment, "default-comment", 0, "@" },
552     { oNoVersion, "no-version", 0, "@"},
553     { oEmitVersion, "emit-version", 0, "@"},
554     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
555     { oEscapeFrom, "escape-from-lines", 0, "@" },
556     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
557     { oLockOnce, "lock-once", 0, "@" },
558     { oLockMultiple, "lock-multiple", 0, "@" },
559     { oLockNever, "lock-never", 0, "@" },
560     { oLoggerFD, "logger-fd",1, "@" },
561 #ifdef __riscos__
562     { oLoggerFile, "logger-file",2, "@" },
563 #endif /* __riscos__ */
564     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
565     { oUtf8Strings, "utf8-strings", 0, "@" },
566     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
567     { oWithFingerprint, "with-fingerprint", 0, "@" },
568     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
569     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
570     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
571     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
572     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
573     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
574     { oNoLiteral, "no-literal", 0, "@" },
575     { oSetFilesize, "set-filesize", 20, "@" },
576     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
577     { oFastListMode,"fast-list-mode", 0, "@" },
578     { oFixedListMode,"fixed-list-mode", 0, "@" },
579     { oListOnly, "list-only", 0, "@"},
580     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
581     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
582     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
583     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
584     { oShowSessionKey, "show-session-key", 0, "@" },
585     { oOverrideSessionKey, "override-session-key", 2, "@" },
586     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
587     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
588     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
589     { oNoSigCache,         "no-sig-cache", 0, "@" },
590     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
591     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
592     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
593     { oMergeOnly,         "merge-only", 0, "@" },
594     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
595     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
596     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
597     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
598     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
599     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
600     { oPreservePermissions, "preserve-permissions", 0, "@"},
601     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
602     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
603     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
604     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
605     { oEmuMDEncodeBug,  "emulate-md-encode-bug", 0, "@"},
606     { oDisplay,    "display",     2, "@" },
607     { oTTYname,    "ttyname",     2, "@" },
608     { oTTYtype,    "ttytype",     2, "@" },
609     { oLCctype,    "lc-ctype",    2, "@" },
610     { oLCmessages, "lc-messages", 2, "@" },
611     { oGroup,      "group",       2, "@" },
612     { oStrict,     "strict",      0, "@" },
613     { oNoStrict,   "no-strict",   0, "@" },
614     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
615     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
616 {0} };
617
618
619
620 int g10_errors_seen = 0;
621
622 static int utf8_strings = 0;
623 static int maybe_setuid = 1;
624
625 static char *build_list( const char *text, char letter,
626                          const char *(*mapf)(int), int (*chkf)(int) );
627 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
628                         enum cmd_and_opt_values new_cmd );
629 static void print_mds( const char *fname, int algo );
630 static void add_notation_data( const char *string, int which );
631 static void add_policy_url( const char *string, int which );
632
633 #ifdef __riscos__
634 RISCOS_GLOBAL_STATICS("GnuPG Heap")
635 #endif /* __riscos__ */
636
637 const char *
638 strusage( int level )
639 {
640   static char *digests, *pubkeys, *ciphers, *zips;
641     const char *p;
642     switch( level ) {
643       case 11: p = "gpg (GnuPG)";
644         break;
645       case 13: p = VERSION; break;
646       case 17: p = PRINTABLE_OS_NAME; break;
647       case 19: p =
648             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
649         break;
650       case 1:
651       case 40:  p =
652             _("Usage: gpg [options] [files] (-h for help)");
653         break;
654       case 41:  p =
655             _("Syntax: gpg [options] [files]\n"
656               "sign, check, encrypt or decrypt\n"
657               "default operation depends on the input data\n");
658         break;
659
660       case 31: p = "\nHome: "; break;
661 #ifndef __riscos__
662       case 32: p = opt.homedir; break;
663 #else /* __riscos__ */
664       case 32: p = make_filename(opt.homedir, NULL); break;
665 #endif /* __riscos__ */
666       case 33: p = _("\nSupported algorithms:\n"); break;
667       case 34:
668         if( !pubkeys )
669             pubkeys = build_list("Pubkey: ", 0, pubkey_algo_to_string,
670                                                         check_pubkey_algo );
671         p = pubkeys;
672         break;
673       case 35:
674         if( !ciphers )
675             ciphers = build_list("Cipher: ", 'S', cipher_algo_to_string,
676                                                         check_cipher_algo );
677         p = ciphers;
678         break;
679       case 36:
680         if( !digests )
681             digests = build_list("Hash: ", 'H', digest_algo_to_string,
682                                                         check_digest_algo );
683         p = digests;
684         break;
685       case 37:
686         if( !zips )
687             zips = build_list("Compress: ",'Z',compress_algo_to_string,
688                                                         check_compress_algo);
689         p = zips;
690         break;
691
692       default:  p = default_strusage(level);
693     }
694     return p;
695 }
696
697
698 static char *
699 build_list( const char *text, char letter,
700             const char * (*mapf)(int), int (*chkf)(int) )
701 {
702     int i;
703     const char *s;
704     size_t n=strlen(text)+2;
705     char *list, *p, *line=NULL;
706
707     if( maybe_setuid )
708         secmem_init( 0 );    /* drop setuid */
709
710     for(i=0; i <= 110; i++ )
711         if( !chkf(i) && (s=mapf(i)) )
712             n += strlen(s) + 7 + 2;
713     list = m_alloc( 21 + n ); *list = 0;
714     for(p=NULL, i=0; i <= 110; i++ ) {
715         if( !chkf(i) && (s=mapf(i)) ) {
716             if( !p ) {
717                 p = stpcpy( list, text );
718                 line=p;
719             }
720             else
721                 p = stpcpy( p, ", ");
722
723             if(strlen(line)>60) {
724               int spaces=strlen(text);
725
726               list=m_realloc(list,n+spaces+1);
727               /* realloc could move the block, so find the end again */
728               p=list;
729               while(*p)
730                 p++;
731
732               p=stpcpy(p, "\n");
733               line=p;
734               for(;spaces;spaces--)
735                 p=stpcpy(p, " ");
736             }
737
738             p = stpcpy(p, s );
739             if(opt.verbose && letter)
740               {
741                 char num[8];
742                 sprintf(num," (%c%d)",letter,i);
743                 p = stpcpy(p,num);
744               }
745         }
746     }
747     if( p )
748         p = stpcpy(p, "\n" );
749     return list;
750 }
751
752
753 static void
754 i18n_init(void)
755 {
756   #ifdef USE_SIMPLE_GETTEXT
757     set_gettext_file( PACKAGE );
758   #else
759   #ifdef ENABLE_NLS
760     setlocale( LC_ALL, "" );
761     bindtextdomain( PACKAGE, G10_LOCALEDIR );
762     textdomain( PACKAGE );
763   #endif
764   #endif
765 }
766
767 static void
768 wrong_args( const char *text)
769 {
770     fputs(_("usage: gpg [options] "),stderr);
771     fputs(text,stderr);
772     putc('\n',stderr);
773     g10_exit(2);
774 }
775
776
777 static char *
778 make_username( const char *string )
779 {
780     char *p;
781     if( utf8_strings )
782         p = m_strdup(string);
783     else
784         p = native_to_utf8( string );
785     return p;
786 }
787
788
789 static void
790 set_debug(void)
791 {
792     if( opt.debug & DBG_MEMORY_VALUE )
793         memory_debug_mode = 1;
794     if( opt.debug & DBG_MEMSTAT_VALUE )
795         memory_stat_debug_mode = 1;
796     if( opt.debug & DBG_MPI_VALUE )
797         mpi_debug_mode = 1;
798     if( opt.debug & DBG_CIPHER_VALUE )
799         g10c_debug_mode = 1;
800     if( opt.debug & DBG_IOBUF_VALUE )
801         iobuf_debug_mode = 1;
802
803 }
804
805
806 /* We need the home directory also in some other directories, so make
807    sure that both variables are always in sync. */
808 static void
809 set_homedir (char *dir)
810 {
811   if (!dir)
812     dir = "";
813   g10_opt_homedir = opt.homedir = dir;
814 }
815
816
817 static void
818 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
819 {
820     enum cmd_and_opt_values cmd = *ret_cmd;
821
822     if( !cmd || cmd == new_cmd )
823         cmd = new_cmd;
824     else if( cmd == aSign && new_cmd == aEncr )
825         cmd = aSignEncr;
826     else if( cmd == aEncr && new_cmd == aSign )
827         cmd = aSignEncr;
828     else if( cmd == aSign && new_cmd == aSym )
829         cmd = aSignSym;
830     else if( cmd == aSym && new_cmd == aSign )
831         cmd = aSignSym;
832     else if( cmd == aKMode && new_cmd == aSym )
833         cmd = aKModeC;
834     else if(    ( cmd == aSign     && new_cmd == aClearsign )
835              || ( cmd == aClearsign && new_cmd == aSign )  )
836         cmd = aClearsign;
837     else {
838         log_error(_("conflicting commands\n"));
839         g10_exit(2);
840     }
841
842     *ret_cmd = cmd;
843 }
844
845
846 static void add_group(char *string)
847 {
848   char *name,*value;
849   struct groupitem *item;
850   STRLIST values=NULL;
851
852   /* Break off the group name */
853   name=strsep(&string,"=");
854   if(string==NULL)
855     {
856       log_error(_("no = sign found in group definition \"%s\"\n"),name);
857       return;
858     }
859
860   trim_trailing_ws(name,strlen(name));
861
862   /* Break apart the values */
863   while ((value= strsep(&string," \t")))
864     {
865       if (*value)
866         add_to_strlist2 (&values,value,utf8_strings);
867     }
868
869   item=m_alloc(sizeof(struct groupitem));
870   item->name=name;
871   item->values=values;
872   item->next=opt.grouplist;
873
874   opt.grouplist=item;
875 }
876
877 /* We need to check three things.
878
879    0) The homedir.  It must be x00, a directory, and owned by the
880    user.
881
882    1) The options file.  Okay unless it or its containing directory is
883    group or other writable or not owned by us.  disable exec in this
884    case.
885
886    2) Extensions.  Same as #2.
887
888    Returns true if the item is unsafe. */
889 static int
890 check_permissions(const char *path,int item)
891 {
892 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
893   static int homedir_cache=-1;
894   char *tmppath,*dir;
895   struct stat statbuf,dirbuf;
896   int homedir=0,ret=0,checkonly=0;
897   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
898
899   if(opt.no_perm_warn)
900     return 0;
901
902   assert(item==0 || item==1 || item==2);
903
904   /* extensions may attach a path */
905   if(item==2 && path[0]!=DIRSEP_C)
906     {
907       if(strchr(path,DIRSEP_C))
908         tmppath=make_filename(path,NULL);
909       else
910         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
911     }
912   else
913     tmppath=m_strdup(path);
914
915   /* If the item is located in the homedir, but isn't the homedir,
916      don't continue if we already checked the homedir itself.  This is
917      to avoid user confusion with an extra options file warning which
918      could be rectified if the homedir itself had proper
919      permissions. */
920   if(item!=0 && homedir_cache>-1
921      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
922     {
923       ret=homedir_cache;
924       goto end;
925     }
926
927   /* It's okay if the file or directory doesn't exist */
928   if(stat(tmppath,&statbuf)!=0)
929     {
930       ret=0;
931       goto end;
932     }
933
934   /* Now check the enclosing directory.  Theoretically, we could walk
935      this test up to the root directory /, but for the sake of sanity,
936      I'm stopping at one level down. */
937   dir=make_dirname(tmppath);
938
939   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
940     {
941       /* Weird error */
942       ret=1;
943       goto end;
944     }
945
946   m_free(dir);
947
948   /* Assume failure */
949   ret=1;
950
951   if(item==0)
952     {
953       /* The homedir must be x00, a directory, and owned by the user. */
954
955       if(S_ISDIR(statbuf.st_mode))
956         {
957           if(statbuf.st_uid==getuid())
958             {
959               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
960                 ret=0;
961               else
962                 perm=1;
963             }
964           else
965             own=1;
966
967           homedir_cache=ret;
968         }
969     }
970   else if(item==1 || item==2)
971     {
972       /* The options or extension file.  Okay unless it or its
973          containing directory is group or other writable or not owned
974          by us or root. */
975
976       if(S_ISREG(statbuf.st_mode))
977         {
978           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
979             {
980               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
981                 {
982                   /* it's not writable, so make sure the enclosing
983                      directory is also not writable */
984                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
985                     {
986                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
987                         ret=0;
988                       else
989                         enc_dir_perm=1;
990                     }
991                   else
992                     enc_dir_own=1;
993                 }
994               else
995                 {
996                   /* it's writable, so the enclosing directory had
997                      better not let people get to it. */
998                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
999                     {
1000                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1001                         ret=0;
1002                       else
1003                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1004                     }
1005                   else
1006                     enc_dir_own=1;
1007                 }
1008             }
1009           else
1010             own=1;
1011         }
1012     }
1013   else
1014     BUG();
1015
1016   if(!checkonly)
1017     {
1018       if(own)
1019         {
1020           if(item==0)
1021             log_info(_("WARNING: unsafe ownership on "
1022                        "homedir \"%s\"\n"),tmppath);
1023           else if(item==1)
1024             log_info(_("WARNING: unsafe ownership on "
1025                        "configuration file \"%s\"\n"),tmppath);
1026           else
1027             log_info(_("WARNING: unsafe ownership on "
1028                        "extension \"%s\"\n"),tmppath);
1029         }
1030       if(perm)
1031         {
1032           if(item==0)
1033             log_info(_("WARNING: unsafe permissions on "
1034                        "homedir \"%s\"\n"),tmppath);
1035           else if(item==1)
1036             log_info(_("WARNING: unsafe permissions on "
1037                        "configuration file \"%s\"\n"),tmppath);
1038           else
1039             log_info(_("WARNING: unsafe permissions on "
1040                        "extension \"%s\"\n"),tmppath);
1041         }
1042       if(enc_dir_own)
1043         {
1044           if(item==0)
1045             log_info(_("WARNING: unsafe enclosing directory ownership on "
1046                        "homedir \"%s\"\n"),tmppath);
1047           else if(item==1)
1048             log_info(_("WARNING: unsafe enclosing directory ownership on "
1049                        "configuration file \"%s\"\n"),tmppath);
1050           else
1051             log_info(_("WARNING: unsafe enclosing directory ownership on "
1052                        "extension \"%s\"\n"),tmppath);
1053         }
1054       if(enc_dir_perm)
1055         {
1056           if(item==0)
1057             log_info(_("WARNING: unsafe enclosing directory permissions on "
1058                        "homedir \"%s\"\n"),tmppath);
1059           else if(item==1)
1060             log_info(_("WARNING: unsafe enclosing directory permissions on "
1061                        "configuration file \"%s\"\n"),tmppath);
1062           else
1063             log_info(_("WARNING: unsafe enclosing directory permissions on "
1064                        "extension \"%s\"\n"),tmppath);
1065         }
1066     }
1067
1068  end:
1069   m_free(tmppath);
1070
1071   if(homedir)
1072     homedir_cache=ret;
1073
1074   return ret;
1075
1076 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1077
1078   return 0;
1079 }
1080
1081 int
1082 main( int argc, char **argv )
1083 {
1084     ARGPARSE_ARGS pargs;
1085     IOBUF a;
1086     int rc=0;
1087     int orig_argc;
1088     char **orig_argv;
1089     const char *fname;
1090     char *username;
1091     int may_coredump;
1092     STRLIST sl, remusr= NULL, locusr=NULL;
1093     STRLIST nrings=NULL, sec_nrings=NULL;
1094     armor_filter_context_t afx;
1095     int detached_sig = 0;
1096     FILE *configfp = NULL;
1097     char *configname = NULL;
1098     unsigned configlineno;
1099     int parse_debug = 0;
1100     int default_config = 1;
1101     int default_keyring = 1;
1102     int greeting = 0;
1103     int nogreeting = 0;
1104     int use_random_seed = 1;
1105     enum cmd_and_opt_values cmd = 0;
1106     const char *trustdb_name = NULL;
1107     char *def_cipher_string = NULL;
1108     char *def_digest_string = NULL;
1109     char *def_compress_string = NULL;
1110     char *cert_digest_string = NULL;
1111     char *s2k_cipher_string = NULL;
1112     char *s2k_digest_string = NULL;
1113     char *pers_cipher_list = NULL;
1114     char *pers_digest_list = NULL;
1115     char *pers_compress_list = NULL;
1116     int eyes_only=0;
1117     int pwfd = -1;
1118     int with_fpr = 0; /* make an option out of --fingerprint */
1119     int any_explicit_recipient = 0;
1120   #ifdef USE_SHM_COPROCESSING
1121     ulong requested_shm_size=0;
1122   #endif
1123
1124   #ifdef __riscos__
1125     riscos_global_defaults();
1126     opt.lock_once = 1;
1127   #endif /* __riscos__ */
1128
1129     trap_unaligned();
1130     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
1131     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1132      * when adding any stuff between here and the call to
1133      * secmem_init()  somewhere after the option parsing
1134      */
1135     log_set_name("gpg");
1136     secure_random_alloc(); /* put random number into secure memory */
1137     may_coredump = disable_core_dumps();
1138     init_signals();
1139     create_dotlock(NULL); /* register locking cleanup */
1140     i18n_init();
1141     opt.command_fd = -1; /* no command fd */
1142     opt.compress = -1; /* defaults to standard compress level */
1143     /* note: if you change these lines, look at oOpenPGP */
1144     opt.def_cipher_algo = 0;
1145     opt.def_digest_algo = 0;
1146     opt.cert_digest_algo = 0;
1147     opt.def_compress_algo = -1;
1148     opt.s2k_mode = 3; /* iterated+salted */
1149     opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1150     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1151     opt.completes_needed = 1;
1152     opt.marginals_needed = 3;
1153     opt.max_cert_depth = 5;
1154     opt.pgp2_workarounds = 1;
1155     opt.force_v3_sigs = 1;
1156     opt.escape_from = 1;
1157     opt.import_options=IMPORT_SK2PK;
1158     opt.export_options=
1159       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1160     opt.keyserver_options.import_options=IMPORT_REPAIR_HKP_SUBKEY_BUG;
1161     opt.keyserver_options.export_options=
1162       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1163     opt.keyserver_options.include_subkeys=1;
1164     opt.keyserver_options.include_revoked=1;
1165     opt.trust_model=TM_OPENPGP;
1166     opt.mangle_dos_filenames = 1;
1167
1168 #if defined (__MINGW32__)
1169     set_homedir ( read_w32_registry_string( NULL,
1170                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1171 #else
1172     set_homedir ( getenv("GNUPGHOME") );
1173 #endif
1174     if( !*opt.homedir )
1175         set_homedir ( GNUPG_HOMEDIR );
1176
1177     /* check whether we have a config file on the commandline */
1178     orig_argc = argc;
1179     orig_argv = argv;
1180     pargs.argc = &argc;
1181     pargs.argv = &argv;
1182     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1183     while( arg_parse( &pargs, opts) ) {
1184         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1185             parse_debug++;
1186         else if( pargs.r_opt == oOptions ) {
1187             /* yes there is one, so we do not try the default one, but
1188              * read the option file when it is encountered at the commandline
1189              */
1190             default_config = 0;
1191         }
1192         else if( pargs.r_opt == oNoOptions )
1193             default_config = 0; /* --no-options */
1194         else if( pargs.r_opt == oHomedir )
1195             set_homedir ( pargs.r.ret_str );
1196         else if( pargs.r_opt == oNoPermissionWarn )
1197             opt.no_perm_warn=1;
1198         else if (pargs.r_opt == oStrict )
1199           {
1200             opt.strict=1;
1201             log_set_strict(1);
1202           }
1203         else if (pargs.r_opt == oNoStrict )
1204           {
1205             opt.strict=0;
1206             log_set_strict(0);
1207           }
1208       #ifdef USE_SHM_COPROCESSING
1209         else if( pargs.r_opt == oRunAsShmCP ) {
1210             /* does not make sense in a options file, we do it here,
1211              * so that we are the able to drop setuid as soon as possible */
1212             opt.shm_coprocess = 1;
1213             requested_shm_size = pargs.r.ret_ulong;
1214         }
1215         else if ( pargs.r_opt == oStatusFD ) {
1216             /* this is needed to ensure that the status-fd filedescriptor is
1217              * initialized when init_shm_coprocessing() is called */
1218             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1219         }
1220       #endif
1221     }
1222
1223 #ifdef HAVE_DOSISH_SYSTEM
1224     if ( strchr (opt.homedir,'\\') ) {
1225         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
1226         const char *s = opt.homedir;
1227         for (d=buf,s=opt.homedir; *s; s++)
1228             *d++ = *s == '\\'? '/': *s;
1229         *d = 0;
1230         set_homedir (buf);
1231     }
1232 #endif
1233 #ifdef USE_SHM_COPROCESSING
1234     if( opt.shm_coprocess ) {
1235         init_shm_coprocessing(requested_shm_size, 1 );
1236     }
1237 #endif
1238     /* initialize the secure memory. */
1239     secmem_init( 16384 );
1240     maybe_setuid = 0;
1241     /* Okay, we are now working under our real uid */
1242
1243     set_native_charset (NULL); /* Try to auto set the character set */
1244
1245     if( default_config )
1246       {
1247         configname = make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1248         if (!access (configname, R_OK))
1249           { /* Print a warning when both config files are present. */
1250             char *p = make_filename(opt.homedir, "options", NULL );
1251             if (!access (p, R_OK))
1252               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1253             m_free (p);
1254           }
1255         else
1256           { /* Keep on using the old default one. */
1257             m_free (configname);
1258             configname = make_filename(opt.homedir, "options", NULL );
1259           }
1260       }
1261     argc = orig_argc;
1262     argv = orig_argv;
1263     pargs.argc = &argc;
1264     pargs.argv = &argv;
1265     pargs.flags=  1;  /* do not remove the args */
1266
1267     /* By this point we have a homedir, and cannot change it. */
1268     check_permissions(opt.homedir,0);
1269
1270   next_pass:
1271     if( configname ) {
1272       if(check_permissions(configname,1))
1273         {
1274           /* If any options file is unsafe, then disable any external
1275              programs for keyserver calls or photo IDs.  Since the
1276              external program to call is set in the options file, a
1277              unsafe options file can lead to an arbitrary program
1278              being run. */
1279
1280           opt.exec_disable=1;
1281         }
1282
1283         configlineno = 0;
1284         configfp = fopen( configname, "r" );
1285         if( !configfp ) {
1286             if( default_config ) {
1287                 if( parse_debug )
1288                     log_info(_("NOTE: no default option file `%s'\n"),
1289                                                             configname );
1290             }
1291             else {
1292                 log_error(_("option file `%s': %s\n"),
1293                                     configname, strerror(errno) );
1294                 g10_exit(2);
1295             }
1296             m_free(configname); configname = NULL;
1297         }
1298         if( parse_debug && configname )
1299             log_info(_("reading options from `%s'\n"), configname );
1300         default_config = 0;
1301     }
1302
1303     while( optfile_parse( configfp, configname, &configlineno,
1304                                                 &pargs, opts) ) {
1305         switch( pargs.r_opt ) {
1306           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1307           case aListPackets: set_cmd( &cmd, aListPackets); break;
1308           case aImport: set_cmd( &cmd, aImport); break;
1309           case aFastImport: set_cmd( &cmd, aFastImport); break;
1310           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1311           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1312           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1313           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1314           case aExport: set_cmd( &cmd, aExport); break;
1315           case aExportAll: set_cmd( &cmd, aExportAll); break;
1316           case aListKeys: set_cmd( &cmd, aListKeys); break;
1317           case aListSigs: set_cmd( &cmd, aListSigs); break;
1318           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1319           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1320           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1321                                                         greeting=1; break;
1322           case aDeleteSecretAndPublicKeys:
1323             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1324             greeting=1; 
1325             break;
1326           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1327
1328           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1329           case aSym: set_cmd( &cmd, aSym); break;
1330
1331           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1332           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1333
1334           case aEncr: set_cmd( &cmd, aEncr); break;
1335           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1336           case aSign: set_cmd( &cmd, aSign );  break;
1337           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1338           case aSignKey: set_cmd( &cmd, aSignKey); break;
1339           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1340           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1341           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1342           case aStore: set_cmd( &cmd, aStore); break;
1343           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1344           case aClearsign: set_cmd( &cmd, aClearsign); break;
1345           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1346           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1347           case aVerify: set_cmd( &cmd, aVerify); break;
1348           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1349           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1350           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1351           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1352           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1353           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1354           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1355           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1356           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1357           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1358           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1359           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1360           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1361           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1362           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1363           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1364
1365           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1366           case oOutput: opt.outfile = pargs.r.ret_str; break;
1367           case oQuiet: opt.quiet = 1; break;
1368           case oNoTTY: tty_no_terminal(1); break;
1369           case oDryRun: opt.dry_run = 1; break;
1370           case oInteractive: opt.interactive = 1; break;
1371           case oVerbose: g10_opt_verbose++;
1372                     opt.verbose++; opt.list_sigs=1; break;
1373           case oKOption: set_cmd( &cmd, aKMode ); break;
1374
1375           case oBatch: opt.batch = 1; nogreeting = 1; break;
1376           case oUseAgent:
1377 #ifndef __riscos__
1378             opt.use_agent = 1;
1379 #else /* __riscos__ */
1380             opt.use_agent = 0;
1381             riscos_not_implemented("use-agent");
1382 #endif /* __riscos__ */
1383             break;
1384           case oNoUseAgent: opt.use_agent = 0; break;
1385           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1386           case oAnswerYes: opt.answer_yes = 1; break;
1387           case oAnswerNo: opt.answer_no = 1; break;
1388           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1389           case oPrimaryKeyring:
1390             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1391             sl->flags=2;
1392             break;
1393           case oShowKeyring: opt.show_keyring = 1; break;
1394           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1395           case oDebugAll: opt.debug = ~0; break;
1396           case oStatusFD:
1397             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1398             break;
1399 #ifdef __riscos__
1400           case oStatusFile:
1401             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1402             break;
1403 #endif /* __riscos__ */
1404           case oAttributeFD:
1405             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1406             break;
1407 #ifdef __riscos__
1408           case oAttributeFile:
1409             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1410             break;
1411 #endif /* __riscos__ */
1412           case oLoggerFD:
1413             log_set_logfile( NULL,
1414                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1415             break;
1416 #ifdef __riscos__
1417           case oLoggerFile:
1418             log_set_logfile( NULL,
1419                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1420             break;
1421 #endif /* __riscos__ */
1422           case oWithFingerprint:
1423             opt.with_fingerprint = 1;
1424             with_fpr=1; /*fall thru*/
1425           case oFingerprint: opt.fingerprint++; break;
1426           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1427           case oOptions:
1428             /* config files may not be nested (silently ignore them) */
1429             if( !configfp ) {
1430                 m_free(configname);
1431                 configname = m_strdup(pargs.r.ret_str);
1432                 goto next_pass;
1433             }
1434             break;
1435           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1436           case oNoDefKeyring: default_keyring = 0; break;
1437           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1438           case oNoGreeting: nogreeting = 1; break;
1439           case oNoVerbose: g10_opt_verbose = 0;
1440                            opt.verbose = 0; opt.list_sigs=0; break;
1441           case oQuickRandom: quick_random_gen(1); break;
1442           case oSKComments: opt.sk_comments=1; break;
1443           case oNoSKComments: opt.sk_comments=0; break;
1444           case oNoVersion: opt.no_version=1; break;
1445           case oEmitVersion: opt.no_version=0; break;
1446           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1447           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1448           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1449           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1450           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1451           case oDefRecipient:
1452                     if( *pargs.r.ret_str )
1453                         opt.def_recipient = make_username(pargs.r.ret_str);
1454                     break;
1455           case oDefRecipientSelf:
1456                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1457                     opt.def_recipient_self = 1;
1458                     break;
1459           case oNoDefRecipient:
1460                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1461                     opt.def_recipient_self = 0;
1462                     break;
1463           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1464           case oHomedir: break;
1465           case oNoBatch: opt.batch = 0; break;
1466           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1467           case oWithColons: opt.with_colons=':'; break;
1468
1469           case oSkipVerify: opt.skip_verify=1; break;
1470           case oCompressKeys: opt.compress_keys = 1; break;
1471           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1472             /* There are many programs (like mutt) that call gpg with
1473                --always-trust so keep this option around for a long
1474                time. */
1475           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1476           case oTrustModel:
1477             if(ascii_strcasecmp(pargs.r.ret_str,"openpgp")==0)
1478               opt.trust_model=TM_OPENPGP;
1479             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1480               opt.trust_model=TM_CLASSIC;
1481             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1482               opt.trust_model=TM_ALWAYS;
1483             else
1484               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1485             break;
1486           case oForceOwnertrust:
1487             log_info(_("NOTE: %s is not for normal use!\n"),
1488                      "--force-ownertrust");
1489             if(pargs.r.ret_int>=TRUST_UNDEFINED
1490                && pargs.r.ret_int<=TRUST_ULTIMATE)
1491               opt.force_ownertrust=pargs.r.ret_int;
1492             else
1493               log_error("invalid ownertrust %d\n",pargs.r.ret_int);
1494             break;
1495           case oLoadExtension:
1496 #ifndef __riscos__
1497 #if defined(USE_DYNAMIC_LINKING) || defined(__MINGW32__)
1498             if(check_permissions(pargs.r.ret_str,2))
1499               log_info(_("cipher extension \"%s\" not loaded due to "
1500                          "unsafe permissions\n"),pargs.r.ret_str);
1501             else
1502               register_cipher_extension(orig_argc? *orig_argv:NULL,
1503                                         pargs.r.ret_str);
1504 #endif
1505 #else /* __riscos__ */
1506             riscos_not_implemented("load-extension");
1507 #endif /* __riscos__ */
1508             break;
1509           case oRFC1991:
1510             opt.rfc1991 = 1;
1511             opt.rfc2440 = 0;
1512             opt.force_v4_certs = 0;
1513             opt.disable_mdc = 1;
1514             opt.escape_from = 1;
1515             break;
1516           case oOpenPGP:
1517             /* TODO: When 2440bis becomes a RFC, these may need
1518                changing. */
1519             opt.rfc1991 = 0;
1520             opt.rfc2440 = 1;
1521             opt.disable_mdc = 1;
1522             opt.allow_non_selfsigned_uid = 1;
1523             opt.allow_freeform_uid = 1;
1524             opt.pgp2_workarounds = 0;
1525             opt.escape_from = 0;
1526             opt.force_v3_sigs = 0;
1527             opt.compress_keys = 0;          /* not mandated  but we do it */
1528             opt.compress_sigs = 0;          /* ditto. */
1529             opt.not_dash_escaped = 0;
1530             opt.def_cipher_algo = 0;
1531             opt.def_digest_algo = 0;
1532             opt.cert_digest_algo = 0;
1533             opt.def_compress_algo = -1;
1534             opt.s2k_mode = 3; /* iterated+salted */
1535             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1536             opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1537             break;
1538           case oPGP2: opt.pgp2 = 1; break;
1539           case oNoPGP2: opt.pgp2 = 0; break;
1540           case oPGP6: opt.pgp6 = 1; break;
1541           case oNoPGP6: opt.pgp6 = 0; break;
1542           case oPGP7: opt.pgp7 = 1; break;
1543           case oNoPGP7: opt.pgp7 = 0; break;
1544           case oPGP8: opt.pgp8 = 1; break;
1545           case oNoPGP8: opt.pgp8 = 0; break;
1546           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1547           case oCompressSigs: opt.compress_sigs = 1; break;
1548           case oRunAsShmCP:
1549 #ifndef __riscos__
1550 # ifndef USE_SHM_COPROCESSING
1551             /* not possible in the option file,
1552              * but we print the warning here anyway */
1553             log_error("shared memory coprocessing is not available\n");
1554 # endif
1555 #else /* __riscos__ */
1556             riscos_not_implemented("run-as-shm-coprocess");
1557 #endif /* __riscos__ */
1558             break;
1559           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1560           case oForYourEyesOnly: eyes_only = 1; break;
1561           case oNoForYourEyesOnly: eyes_only = 0; break;
1562           case oSetPolicyURL:
1563             add_policy_url(pargs.r.ret_str,0);
1564             add_policy_url(pargs.r.ret_str,1);
1565             break;
1566           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1567           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1568           case oShowPolicyURL: opt.show_policy_url=1; break;
1569           case oNoShowPolicyURL: opt.show_policy_url=0; break;
1570           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1571           case oComment: opt.comment_string = pargs.r.ret_str; break;
1572           case oDefaultComment: opt.comment_string = NULL; break;
1573           case oThrowKeyid: opt.throw_keyid = 1; break;
1574           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1575           case oShowPhotos: opt.show_photos = 1; break;
1576           case oNoShowPhotos: opt.show_photos = 0; break;
1577           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1578           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1579           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1580           case oForceV4Certs: opt.force_v4_certs = 1; break;
1581           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1582           case oForceMDC: opt.force_mdc = 1; break;
1583           case oNoForceMDC: opt.force_mdc = 0; break;
1584           case oDisableMDC: opt.disable_mdc = 1; break;
1585           case oNoDisableMDC: opt.disable_mdc = 0; break;
1586           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1587           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1588           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1589           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1590           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1591           case oEncryptTo: /* store the recipient in the second list */
1592             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1593             sl->flags = 1;
1594             break;
1595           case oHiddenEncryptTo: /* store the recipient in the second list */
1596             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1597             sl->flags = 1|2;
1598             break;
1599           case oRecipient: /* store the recipient */
1600             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1601             any_explicit_recipient = 1;
1602             break;
1603           case oHiddenRecipient: /* store the recipient with a flag */
1604             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1605             sl->flags = 2;
1606             any_explicit_recipient = 1;
1607             break;
1608           case oTextmodeShort: opt.textmode = 2; break;
1609           case oTextmode: opt.textmode=1;  break;
1610           case oExpert: opt.expert = 1; break;
1611           case oNoExpert: opt.expert = 0; break;
1612           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1613           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1614           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1615           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1616           case oUser: /* store the local users */
1617             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1618             break;
1619           case oCompress: opt.compress = pargs.r.ret_int; break;
1620           case oPasswdFD:
1621             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1622             break;
1623 #ifdef __riscos__
1624           case oPasswdFile:
1625             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1626             break;
1627 #endif /* __riscos__ */
1628           case oCommandFD:
1629             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1630             break;
1631 #ifdef __riscos__
1632           case oCommandFile:
1633             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1634             break;
1635 #endif /* __riscos__ */
1636           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1637           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1638           case oCompressAlgo:
1639             /* If it is all digits, stick a Z in front of it for
1640                later.  This is for backwards compatibility with
1641                versions that took the compress algorithm number. */
1642             {
1643               char *pt=pargs.r.ret_str;
1644               while(*pt)
1645                 {
1646                   if(!isdigit(*pt))
1647                     break;
1648
1649                   pt++;
1650                 }
1651
1652               if(*pt=='\0')
1653                 {
1654                   def_compress_string=m_alloc(strlen(pargs.r.ret_str)+2);
1655                   strcpy(def_compress_string,"Z");
1656                   strcat(def_compress_string,pargs.r.ret_str);
1657                 }
1658               else
1659                 def_compress_string = m_strdup(pargs.r.ret_str);
1660             }
1661             break;
1662           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1663           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1664           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1665           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1666           case oCharset:
1667             if( set_native_charset( pargs.r.ret_str ) )
1668                 log_error(_("%s is not a valid character set\n"),
1669                                                     pargs.r.ret_str);
1670             break;
1671           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1672           case oEscapeFrom: opt.escape_from = 1; break;
1673           case oNoEscapeFrom: opt.escape_from = 0; break;
1674           case oLockOnce: opt.lock_once = 1; break;
1675           case oLockNever: disable_dotlock(); break;
1676           case oLockMultiple:
1677 #ifndef __riscos__
1678             opt.lock_once = 0;
1679 #else /* __riscos__ */
1680             riscos_not_implemented("lock-multiple");
1681 #endif /* __riscos__ */
1682             break;
1683           case oKeyServer:
1684             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1685             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1686               log_error(_("could not parse keyserver URI\n"));
1687             break;
1688           case oKeyServerOptions:
1689             parse_keyserver_options(pargs.r.ret_str);
1690             break;
1691           case oImportOptions:
1692             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1693               {
1694                 if(configname)
1695                   log_error(_("%s:%d: invalid import options\n"),
1696                             configname,configlineno);
1697                 else
1698                   log_error(_("invalid import options\n"));
1699               }
1700             break;
1701           case oExportOptions:
1702             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1703               {
1704                 if(configname)
1705                   log_error(_("%s:%d: invalid export options\n"),
1706                             configname,configlineno);
1707                 else
1708                   log_error(_("invalid export options\n"));
1709               }
1710             break;
1711           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1712           case oExecPath:
1713             if(set_exec_path(pargs.r.ret_str,0))
1714               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1715             else
1716               opt.exec_path_set=1;
1717             break;
1718           case oNotation:
1719             add_notation_data( pargs.r.ret_str, 0 );
1720             add_notation_data( pargs.r.ret_str, 1 );
1721             break;
1722           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1723           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1724           case oShowNotation: opt.show_notation=1; break;
1725           case oNoShowNotation: opt.show_notation=0; break;
1726           case oUtf8Strings: utf8_strings = 1; break;
1727           case oNoUtf8Strings: utf8_strings = 0; break;
1728           case oDisableCipherAlgo:
1729                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1730                 break;
1731           case oDisablePubkeyAlgo:
1732                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1733                 break;
1734           case oNoSigCache: opt.no_sig_cache = 1; break;
1735           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1736           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1737           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1738           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1739           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1740           case oNoLiteral: opt.no_literal = 1; break;
1741           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1742           case oHonorHttpProxy:
1743                 opt.keyserver_options.honor_http_proxy = 1;
1744                 deprecated_warning(configname,configlineno,
1745                                    "--honor-http-proxy",
1746                                    "--keyserver-options ",
1747                                    "honor-http-proxy");
1748                 break;
1749           case oFastListMode: opt.fast_list_mode = 1; break;
1750           case oFixedListMode: opt.fixed_list_mode = 1; break;
1751           case oListOnly: opt.list_only=1; break;
1752           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1753           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1754           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1755           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1756           case oNoRandomSeedFile: use_random_seed = 0; break;
1757           case oAutoKeyRetrieve:
1758           case oNoAutoKeyRetrieve:
1759                 opt.keyserver_options.auto_key_retrieve=
1760                                              (pargs.r_opt==oAutoKeyRetrieve);
1761                 deprecated_warning(configname,configlineno,
1762                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1763                                "--no-auto-key-retrieve","--keyserver-options ",
1764                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1765                                "no-auto-key-retrieve");
1766                 break;
1767           case oShowSessionKey: opt.show_session_key = 1; break;
1768           case oOverrideSessionKey:
1769                 opt.override_session_key = pargs.r.ret_str;
1770                 break;
1771           case oMergeOnly: opt.merge_only = 1; break;
1772           case oAllowSecretKeyImport: /* obsolete */ break;
1773           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1774           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1775           case oEnableSpecialFilenames:
1776             iobuf_enable_special_filenames (1);
1777             break;
1778           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1779           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1780           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1781           case oPreservePermissions: opt.preserve_permissions=1; break;
1782           case oDefaultPreferenceList:
1783             opt.def_preference_list = pargs.r.ret_str;
1784             break;
1785           case oPersonalCipherPreferences:
1786             pers_cipher_list=pargs.r.ret_str;
1787             break;
1788           case oPersonalDigestPreferences:
1789             pers_digest_list=pargs.r.ret_str;
1790             break;
1791           case oPersonalCompressPreferences:
1792             pers_compress_list=pargs.r.ret_str;
1793             break;
1794           case oDisplay: opt.display = pargs.r.ret_str; break;
1795           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1796           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1797           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1798           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1799           case oGroup: add_group(pargs.r.ret_str); break;
1800           case oStrict: opt.strict=1; log_set_strict(1); break;
1801           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1802
1803           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1804           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1805
1806           default : pargs.err = configfp? 1:2; break;
1807         }
1808     }
1809
1810     if( configfp ) {
1811         fclose( configfp );
1812         configfp = NULL;
1813         m_free(configname); configname = NULL;
1814         goto next_pass;
1815     }
1816     m_free( configname ); configname = NULL;
1817     if( log_get_errorcount(0) )
1818         g10_exit(2);
1819     if( nogreeting )
1820         greeting = 0;
1821
1822     if( greeting ) {
1823         fprintf(stderr, "%s %s; %s\n",
1824                         strusage(11), strusage(13), strusage(14) );
1825         fprintf(stderr, "%s\n", strusage(15) );
1826     }
1827   #ifdef IS_DEVELOPMENT_VERSION
1828     if( !opt.batch ) {
1829         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1830         log_info("It is only intended for test purposes and should NOT be\n");
1831         log_info("used in a production environment or with production keys!\n");
1832     }
1833   #endif
1834
1835     if (opt.verbose > 2)
1836         log_info ("using character set `%s'\n", get_native_charset ());
1837
1838     if( may_coredump && !opt.quiet )
1839         log_info(_("WARNING: program may create a core file!\n"));
1840
1841     if (eyes_only) {
1842       if (opt.set_filename)
1843           log_info(_("WARNING: %s overrides %s\n"),
1844                    "--for-your-eyes-only","--set-filename");
1845
1846       opt.set_filename="_CONSOLE";
1847     }
1848
1849     if (opt.no_literal) {
1850         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1851         if (opt.textmode)
1852             log_error(_("%s not allowed with %s!\n"),
1853                        "--textmode", "--no-literal" );
1854         if (opt.set_filename)
1855             log_error(_("%s makes no sense with %s!\n"),
1856                         eyes_only?"--for-your-eyes-only":"--set-filename",
1857                         "--no-literal" );
1858     }
1859
1860     if (opt.set_filesize)
1861         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1862     if( opt.batch )
1863         tty_batchmode( 1 );
1864
1865     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1866
1867     set_debug();
1868
1869     /* Do these after the switch(), so they can override settings. */
1870     if(opt.pgp2 && (opt.pgp6 || opt.pgp7 || opt.pgp8))
1871       log_error(_("%s not allowed with %s!\n"),
1872                 "--pgp2",opt.pgp6?"--pgp6":opt.pgp7?"--pgp7":"--pgp8");
1873     else
1874       {
1875         if(opt.pgp2)
1876           {
1877             int unusable=0;
1878
1879             if(cmd==aSign && !detached_sig)
1880               {
1881                 log_info(_("you can only make detached or clear signatures "
1882                            "while in --pgp2 mode\n"));
1883                 unusable=1;
1884               }
1885             else if(cmd==aSignEncr || cmd==aSignSym)
1886               {
1887                 log_info(_("you can't sign and encrypt at the "
1888                            "same time while in --pgp2 mode\n"));
1889                 unusable=1;
1890               }
1891             else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1892               {
1893                 log_info(_("you must use files (and not a pipe) when "
1894                            "working with --pgp2 enabled.\n"));
1895                 unusable=1;
1896               }
1897             else if(cmd==aEncr || cmd==aSym)
1898               {
1899                 /* Everything else should work without IDEA (except using
1900                    a secret key encrypted with IDEA and setting an IDEA
1901                    preference, but those have their own error
1902                    messages). */
1903
1904                 if(check_cipher_algo(CIPHER_ALGO_IDEA))
1905                   {
1906                     log_info(_("encrypting a message in --pgp2 mode requires "
1907                                "the IDEA cipher\n"));
1908                     idea_cipher_warn(1);
1909                     unusable=1;
1910                   }
1911                 else if(cmd==aSym)
1912                   {
1913                     /* This only sets IDEA for symmetric encryption
1914                        since it is set via select_algo_from_prefs for
1915                        pk encryption. */
1916                     m_free(def_cipher_string);
1917                     def_cipher_string = m_strdup("idea");
1918                   }
1919
1920                 /* PGP2 can't handle the output from the textmode
1921                    filter, so we disable it for anything that could
1922                    create a literal packet (only encryption and
1923                    symmetric encryption, since we disable signing
1924                    above). */
1925                 if(!unusable)
1926                   opt.textmode=0;
1927               }
1928
1929             if(unusable)
1930               {
1931                 log_info(_("this message may not be usable by %s\n"),
1932                          "PGP 2.x");
1933                 opt.pgp2=0;
1934               }
1935             else
1936               {
1937                 opt.rfc1991 = 1;
1938                 opt.rfc2440 = 0;
1939                 opt.force_mdc = 0;
1940                 opt.disable_mdc = 1;
1941                 opt.force_v4_certs = 0;
1942                 opt.sk_comments = 0;
1943                 opt.escape_from = 1;
1944                 opt.force_v3_sigs = 1;
1945                 opt.pgp2_workarounds = 1;
1946                 opt.ask_sig_expire = 0;
1947                 opt.ask_cert_expire = 0;
1948                 m_free(def_digest_string);
1949                 def_digest_string = m_strdup("md5");
1950                 opt.def_compress_algo = 1;
1951               }
1952           }
1953         else if(opt.pgp6)
1954           {
1955             opt.sk_comments=0;
1956             opt.escape_from=1;
1957             opt.force_v3_sigs=1;
1958             opt.ask_sig_expire=0;
1959             opt.def_compress_algo=1;
1960             opt.force_mdc=0;
1961             opt.disable_mdc=1;
1962           }
1963         else if(opt.pgp7)
1964           {
1965             opt.sk_comments=0;
1966             opt.escape_from=1;
1967             opt.force_v3_sigs=1;
1968             opt.ask_sig_expire=0;
1969             opt.def_compress_algo=1;
1970           }
1971         else if(opt.pgp8)
1972           {
1973             opt.escape_from=1;
1974             opt.def_compress_algo=1;
1975           }
1976       }
1977
1978     /* must do this after dropping setuid, because string_to...
1979      * may try to load an module */
1980     if( def_cipher_string ) {
1981         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
1982         if(opt.def_cipher_algo==0 &&
1983            ascii_strcasecmp(def_cipher_string,"idea")==0)
1984           idea_cipher_warn(1);
1985         m_free(def_cipher_string); def_cipher_string = NULL;
1986         if( check_cipher_algo(opt.def_cipher_algo) )
1987             log_error(_("selected cipher algorithm is invalid\n"));
1988     }
1989     if( def_digest_string ) {
1990         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
1991         m_free(def_digest_string); def_digest_string = NULL;
1992         if( check_digest_algo(opt.def_digest_algo) )
1993             log_error(_("selected digest algorithm is invalid\n"));
1994     }
1995     if( def_compress_string ) {
1996         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
1997         m_free(def_compress_string); def_compress_string = NULL;
1998         if( check_compress_algo(opt.def_compress_algo) )
1999             log_error(_("selected compression algorithm is invalid\n"));
2000     }
2001     if( cert_digest_string ) {
2002         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2003         m_free(cert_digest_string); cert_digest_string = NULL;
2004         if( check_digest_algo(opt.cert_digest_algo) )
2005             log_error(_("selected certification digest algorithm is invalid\n"));
2006     }
2007     if( s2k_cipher_string ) {
2008         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2009         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2010         if( check_cipher_algo(opt.s2k_cipher_algo) )
2011             log_error(_("selected cipher algorithm is invalid\n"));
2012     }
2013     if( s2k_digest_string ) {
2014         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2015         m_free(s2k_digest_string); s2k_digest_string = NULL;
2016         if( check_digest_algo(opt.s2k_digest_algo) )
2017             log_error(_("selected digest algorithm is invalid\n"));
2018     }
2019     if( opt.completes_needed < 1 )
2020         log_error(_("completes-needed must be greater than 0\n"));
2021     if( opt.marginals_needed < 2 )
2022         log_error(_("marginals-needed must be greater than 1\n"));
2023     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2024         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2025     switch( opt.s2k_mode ) {
2026       case 0:
2027         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2028         break;
2029       case 1: case 3: break;
2030       default:
2031         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2032     }
2033
2034     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2035       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2036
2037     /* This isn't actually needed, but does serve to error out if the
2038        string is invalid. */
2039     if(opt.def_preference_list &&
2040         keygen_set_std_prefs(opt.def_preference_list,0))
2041       log_error(_("invalid default preferences\n"));
2042
2043     /* We provide defaults for the personal digest list */
2044     if(!pers_digest_list)
2045       pers_digest_list="h2";
2046
2047     if(pers_cipher_list &&
2048        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2049       log_error(_("invalid personal cipher preferences\n"));
2050
2051     if(pers_digest_list &&
2052        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2053       log_error(_("invalid personal digest preferences\n"));
2054
2055     if(pers_compress_list &&
2056        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2057       log_error(_("invalid personal compress preferences\n"));
2058
2059     if( log_get_errorcount(0) )
2060         g10_exit(2);
2061
2062     /* set the random seed file */
2063     if( use_random_seed ) {
2064         char *p = make_filename(opt.homedir, "random_seed", NULL );
2065         set_random_seed_file(p);
2066         m_free(p);
2067     }
2068
2069     if( !cmd && opt.fingerprint && !with_fpr ) {
2070         set_cmd( &cmd, aListKeys);
2071     }
2072
2073     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2074         if( cmd == aKModeC ) {
2075             opt.fingerprint = 1;
2076             cmd = aKMode;
2077         }
2078         opt.list_sigs = 0;
2079         if( opt.verbose > 2 )
2080             opt.check_sigs++;
2081         if( opt.verbose > 1 )
2082             opt.list_sigs++;
2083
2084         opt.verbose = opt.verbose > 1;
2085         g10_opt_verbose = opt.verbose;
2086     }
2087
2088     /* Compression algorithm 0 means no compression at all */
2089     if( opt.def_compress_algo == 0)
2090         opt.compress = 0;
2091
2092     /* kludge to let -sat generate a clear text signature */
2093     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2094         cmd = aClearsign;
2095
2096     if( opt.verbose > 1 )
2097         set_packet_list_mode(1);
2098
2099     /* Add the keyrings, but not for some special commands and not in
2100        case of "-kvv userid keyring".  Also avoid adding the secret
2101        keyring for a couple of commands to avoid unneeded access in
2102        case the secrings are stored on a floppy */
2103     if( cmd != aDeArmor && cmd != aEnArmor
2104         && !(cmd == aKMode && argc == 2 ) ) 
2105       {
2106         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2107             && cmd != aVerify && cmd != aVerifyFiles
2108             && cmd != aSym)
2109           {
2110             if (!sec_nrings || default_keyring) /* add default secret rings */
2111               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2112             for (sl = sec_nrings; sl; sl = sl->next)
2113               keydb_add_resource ( sl->d, 0, 1 );
2114           }
2115         if( !nrings || default_keyring )  /* add default ring */
2116             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2117         for(sl = nrings; sl; sl = sl->next )
2118             keydb_add_resource ( sl->d, sl->flags, 0 );
2119       }
2120     FREE_STRLIST(nrings);
2121     FREE_STRLIST(sec_nrings);
2122
2123
2124     if( pwfd != -1 )  /* read the passphrase now. */
2125         read_passphrase_from_fd( pwfd );
2126
2127     fname = argc? *argv : NULL;
2128
2129     switch( cmd ) {
2130       case aPrimegen:
2131       case aPrintMD:
2132       case aPrintMDs:
2133       case aGenRandom:
2134       case aDeArmor:
2135       case aEnArmor:
2136       case aFixTrustDB:
2137         break;
2138       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2139       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2140       default: rc = setup_trustdb(1, trustdb_name ); break;
2141     }
2142     if( rc )
2143         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2144
2145
2146     switch (cmd) {
2147       case aStore: 
2148       case aSym:  
2149       case aSign: 
2150       case aSignSym: 
2151       case aClearsign: 
2152         if (!opt.quiet && any_explicit_recipient)
2153           log_info (_("WARNING: recipients (-r) given "
2154                       "without using public key encryption\n"));
2155         break;
2156       default:
2157         break;
2158     }
2159
2160     switch( cmd ) {
2161       case aStore: /* only store the file */
2162         if( argc > 1 )
2163             wrong_args(_("--store [filename]"));
2164         if( (rc = encode_store(fname)) )
2165             log_error_f( print_fname_stdin(fname),
2166                         "store failed: %s\n", g10_errstr(rc) );
2167         break;
2168       case aSym: /* encrypt the given file only with the symmetric cipher */
2169         if( argc > 1 )
2170             wrong_args(_("--symmetric [filename]"));
2171         if( (rc = encode_symmetric(fname)) )
2172             log_error_f(print_fname_stdin(fname),
2173                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2174         break;
2175
2176       case aEncr: /* encrypt the given file */
2177         if( argc > 1 )
2178             wrong_args(_("--encrypt [filename]"));
2179         if( (rc = encode_crypt(fname,remusr)) )
2180             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2181         break;
2182
2183       case aEncrFiles: /* encrypt the given files */
2184         encode_crypt_files(argc, argv, remusr);
2185         break;
2186           
2187       case aSign: /* sign the given file */
2188         sl = NULL;
2189         if( detached_sig ) { /* sign all files */
2190             for( ; argc; argc--, argv++ )
2191                 add_to_strlist( &sl, *argv );
2192         }
2193         else {
2194             if( argc > 1 )
2195                 wrong_args(_("--sign [filename]"));
2196             if( argc ) {
2197                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2198                 strcpy(sl->d, fname);
2199             }
2200         }
2201         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2202             log_error("signing failed: %s\n", g10_errstr(rc) );
2203         free_strlist(sl);
2204         break;
2205
2206       case aSignEncr: /* sign and encrypt the given file */
2207         if( argc > 1 )
2208             wrong_args(_("--sign --encrypt [filename]"));
2209         if( argc ) {
2210             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2211             strcpy(sl->d, fname);
2212         }
2213         else
2214             sl = NULL;
2215         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2216             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2217         free_strlist(sl);
2218         break;
2219
2220       case aSignSym: /* sign and conventionally encrypt the given file */
2221         if (argc > 1)
2222             wrong_args(_("--sign --symmetric [filename]"));
2223         rc = sign_symencrypt_file (fname, locusr);
2224         if (rc)
2225             log_error("%s: sign+symmetric failed: %s\n",
2226                       print_fname_stdin(fname), g10_errstr(rc) );
2227         break;
2228
2229       case aClearsign: /* make a clearsig */
2230         if( argc > 1 )
2231             wrong_args(_("--clearsign [filename]"));
2232         if( (rc = clearsign_file(fname, locusr, NULL)) )
2233             log_error("%s: clearsign failed: %s\n",
2234                       print_fname_stdin(fname), g10_errstr(rc) );
2235         break;
2236
2237       case aVerify:
2238         if( (rc = verify_signatures( argc, argv ) ))
2239             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2240         break;
2241
2242       case aVerifyFiles:
2243         if( (rc = verify_files( argc, argv ) ))
2244             log_error("verify files failed: %s\n", g10_errstr(rc) );
2245         break;
2246
2247       case aDecrypt:
2248         if( argc > 1 )
2249             wrong_args(_("--decrypt [filename]"));
2250         if( (rc = decrypt_message( fname ) ))
2251             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2252         break;
2253
2254       case aDecryptFiles:
2255         decrypt_messages(argc, argv);
2256         break;
2257             
2258       case aSignKey: /* sign the key given as argument */
2259         if( argc != 1 )
2260             wrong_args(_("--sign-key user-id"));
2261         username = make_username( fname );
2262         keyedit_menu(fname, locusr, NULL, 1 );
2263         m_free(username);
2264         break;
2265
2266       case aLSignKey:
2267         if( argc != 1 )
2268             wrong_args(_("--lsign-key user-id"));
2269         username = make_username( fname );
2270         keyedit_menu(fname, locusr, NULL, 2 );
2271         m_free(username);
2272         break;
2273
2274       case aNRSignKey:
2275         if( argc != 1 )
2276             wrong_args(_("--nrsign-key user-id"));
2277         username = make_username( fname );
2278         keyedit_menu(fname, locusr, NULL, 3 );
2279         m_free(username);
2280         break;
2281
2282       case aNRLSignKey:
2283         if( argc != 1 )
2284             wrong_args(_("--nrlsign-key user-id"));
2285         username = make_username( fname );
2286         keyedit_menu(fname, locusr, NULL, 4 );
2287         m_free(username);
2288         break;
2289
2290       case aEditKey: /* Edit a key signature */
2291         if( !argc )
2292             wrong_args(_("--edit-key user-id [commands]"));
2293         username = make_username( fname );
2294         if( argc > 1 ) {
2295             sl = NULL;
2296             for( argc--, argv++ ; argc; argc--, argv++ )
2297                 append_to_strlist( &sl, *argv );
2298             keyedit_menu( username, locusr, sl, 0 );
2299             free_strlist(sl);
2300         }
2301         else
2302             keyedit_menu(username, locusr, NULL, 0 );
2303         m_free(username);
2304         break;
2305
2306       case aDeleteKeys:
2307       case aDeleteSecretKeys:
2308       case aDeleteSecretAndPublicKeys:
2309         sl = NULL;
2310         /* I'm adding these in reverse order as add_to_strlist2
2311            reverses them again, and it's easier to understand in the
2312            proper order :) */
2313         for( ; argc; argc-- )
2314           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2315         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2316         free_strlist(sl);
2317         break;
2318
2319       case aCheckKeys:
2320         opt.check_sigs = 1;
2321       case aListSigs:
2322         opt.list_sigs = 1;
2323       case aListKeys:
2324         sl = NULL;
2325         for( ; argc; argc--, argv++ )
2326             add_to_strlist2( &sl, *argv, utf8_strings );
2327         public_key_list( sl );
2328         free_strlist(sl);
2329         break;
2330       case aListSecretKeys:
2331         sl = NULL;
2332         for( ; argc; argc--, argv++ )
2333             add_to_strlist2( &sl, *argv, utf8_strings );
2334         secret_key_list( sl );
2335         free_strlist(sl);
2336         break;
2337
2338       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2339         if( argc < 2 ) { /* -kv [userid] */
2340             sl = NULL;
2341             if (argc && **argv)
2342                 add_to_strlist2( &sl, *argv, utf8_strings );
2343             public_key_list( sl );
2344             free_strlist(sl);
2345         }
2346         else if( argc == 2 ) { /* -kv userid keyring */
2347             if( access( argv[1], R_OK ) ) {
2348                 log_error(_("can't open %s: %s\n"),
2349                                print_fname_stdin(argv[1]), strerror(errno));
2350             }
2351             else {
2352                 /* add keyring (default keyrings are not registered in this
2353                  * special case */
2354                 keydb_add_resource( argv[1], 0, 0 );
2355                 sl = NULL;
2356                 if (**argv)
2357                     add_to_strlist2( &sl, *argv, utf8_strings );
2358                 public_key_list( sl );
2359                 free_strlist(sl);
2360             }
2361         }
2362         else
2363             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2364         break;
2365
2366       case aKeygen: /* generate a key */
2367         if( opt.batch ) {
2368             if( argc > 1 )
2369                 wrong_args("--gen-key [parameterfile]");
2370             generate_keypair( argc? *argv : NULL );
2371         }
2372         else {
2373             if( argc )
2374                 wrong_args("--gen-key");
2375             generate_keypair(NULL);
2376         }
2377         break;
2378
2379       case aFastImport:
2380         opt.import_options |= IMPORT_FAST_IMPORT;
2381       case aImport:
2382         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2383         break;
2384
2385       case aExport:
2386       case aExportAll:
2387       case aSendKeys:
2388       case aRecvKeys:
2389         sl = NULL;
2390         for( ; argc; argc--, argv++ )
2391             add_to_strlist2( &sl, *argv, utf8_strings );
2392         if( cmd == aSendKeys )
2393             keyserver_export( sl );
2394         else if( cmd == aRecvKeys )
2395             keyserver_import( sl );
2396         else
2397             export_pubkeys( sl, opt.export_options );
2398         free_strlist(sl);
2399         break;
2400
2401      case aSearchKeys:
2402         sl = NULL;
2403         for( ; argc; argc--, argv++ )
2404           append_to_strlist2( &sl, *argv, utf8_strings );
2405
2406         keyserver_search( sl );
2407         free_strlist(sl);
2408         break;
2409
2410       case aRefreshKeys:
2411         sl = NULL;
2412         for( ; argc; argc--, argv++ )
2413             add_to_strlist2( &sl, *argv, utf8_strings );
2414         keyserver_refresh(sl);
2415         free_strlist(sl);
2416         break;
2417
2418       case aExportSecret:
2419         sl = NULL;
2420         for( ; argc; argc--, argv++ )
2421             add_to_strlist2( &sl, *argv, utf8_strings );
2422         export_seckeys( sl );
2423         free_strlist(sl);
2424         break;
2425
2426       case aExportSecretSub:
2427         sl = NULL;
2428         for( ; argc; argc--, argv++ )
2429             add_to_strlist2( &sl, *argv, utf8_strings );
2430         export_secsubkeys( sl );
2431         free_strlist(sl);
2432         break;
2433
2434       case aGenRevoke:
2435         if( argc != 1 )
2436             wrong_args("--gen-revoke user-id");
2437         username =  make_username(*argv);
2438         gen_revoke( username );
2439         m_free( username );
2440         break;
2441
2442       case aDesigRevoke:
2443         if( argc != 1 )
2444             wrong_args("--desig-revoke user-id");
2445         username =  make_username(*argv);
2446         gen_desig_revoke( username );
2447         m_free( username );
2448         break;
2449
2450       case aDeArmor:
2451         if( argc > 1 )
2452             wrong_args("--dearmor [file]");
2453         rc = dearmor_file( argc? *argv: NULL );
2454         if( rc )
2455             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2456         break;
2457
2458       case aEnArmor:
2459         if( argc > 1 )
2460             wrong_args("--enarmor [file]");
2461         rc = enarmor_file( argc? *argv: NULL );
2462         if( rc )
2463             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2464         break;
2465
2466
2467       case aPrimegen:
2468         {   int mode = argc < 2 ? 0 : atoi(*argv);
2469
2470             if( mode == 1 && argc == 2 ) {
2471                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2472             }
2473             else if( mode == 2 && argc == 3 ) {
2474                 mpi_print( stdout, generate_elg_prime(
2475                                              0, atoi(argv[1]),
2476                                              atoi(argv[2]), NULL,NULL ), 1);
2477             }
2478             else if( mode == 3 && argc == 3 ) {
2479                 MPI *factors;
2480                 mpi_print( stdout, generate_elg_prime(
2481                                              1, atoi(argv[1]),
2482                                              atoi(argv[2]), NULL,&factors ), 1);
2483                 putchar('\n');
2484                 mpi_print( stdout, factors[0], 1 ); /* print q */
2485             }
2486             else if( mode == 4 && argc == 3 ) {
2487                 MPI g = mpi_alloc(1);
2488                 mpi_print( stdout, generate_elg_prime(
2489                                                  0, atoi(argv[1]),
2490                                                  atoi(argv[2]), g, NULL ), 1);
2491                 putchar('\n');
2492                 mpi_print( stdout, g, 1 );
2493                 mpi_free(g);
2494             }
2495             else
2496                 wrong_args("--gen-prime mode bits [qbits] ");
2497             putchar('\n');
2498         }
2499         break;
2500
2501       case aGenRandom:
2502         {
2503             int level = argc ? atoi(*argv):0;
2504             int count = argc > 1 ? atoi(argv[1]): 0;
2505             int endless = !count;
2506
2507             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2508                 wrong_args("--gen-random 0|1|2 [count]");
2509
2510             while( endless || count ) {
2511                 byte *p;
2512                 /* Wee need a multiple of 3, so that in case of
2513                    armored output we get a correct string.  No
2514                    linefolding is done, as it is best to levae this to
2515                    other tools */
2516                 size_t n = !endless && count < 99? count : 99;
2517
2518                 p = get_random_bits( n*8, level, 0);
2519               #ifdef HAVE_DOSISH_SYSTEM
2520                 setmode ( fileno(stdout), O_BINARY );
2521               #endif
2522                 if (opt.armor) {
2523                     char *tmp = make_radix64_string (p, n);
2524                     fputs (tmp, stdout);
2525                     m_free (tmp);
2526                     if (n%3 == 1)
2527                       putchar ('=');
2528                     if (n%3)
2529                       putchar ('=');
2530                 } else {
2531                     fwrite( p, n, 1, stdout );
2532                 }
2533                 m_free(p);
2534                 if( !endless )
2535                     count -= n;
2536             }
2537             if (opt.armor)
2538                 putchar ('\n');
2539         }
2540         break;
2541
2542       case aPrintMD:
2543         if( argc < 1)
2544             wrong_args("--print-md algo [files]");
2545         {
2546             int all_algos = (**argv=='*' && !(*argv)[1]);
2547             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2548
2549             if( !algo && !all_algos )
2550                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2551             else {
2552                 argc--; argv++;
2553                 if( !argc )
2554                     print_mds(NULL, algo);
2555                 else {
2556                     for(; argc; argc--, argv++ )
2557                         print_mds(*argv, algo);
2558                 }
2559             }
2560         }
2561         break;
2562
2563       case aPrintMDs: /* old option */
2564         if( !argc )
2565             print_mds(NULL,0);
2566         else {
2567             for(; argc; argc--, argv++ )
2568                 print_mds(*argv,0);
2569         }
2570         break;
2571
2572       case aListTrustDB:
2573         if( !argc )
2574             list_trustdb(NULL);
2575         else {
2576             for( ; argc; argc--, argv++ )
2577                 list_trustdb( *argv );
2578         }
2579         break;
2580
2581       case aUpdateTrustDB:
2582         if( argc )
2583             wrong_args("--update-trustdb");
2584         update_trustdb();
2585         break;
2586
2587       case aCheckTrustDB:
2588         /* Old versions allowed for arguments - ignore them */
2589         check_trustdb();
2590         break;
2591
2592       case aFixTrustDB:
2593         log_error("this command is not yet implemented.\n");
2594         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2595         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2596         break;
2597
2598       case aListTrustPath:
2599         if( !argc )
2600             wrong_args("--list-trust-path <user-ids>");
2601         for( ; argc; argc--, argv++ ) {
2602             username = make_username( *argv );
2603             list_trust_path( username );
2604             m_free(username);
2605         }
2606         break;
2607
2608       case aExportOwnerTrust:
2609         if( argc )
2610             wrong_args("--export-ownertrust");
2611         export_ownertrust();
2612         break;
2613
2614       case aImportOwnerTrust:
2615         if( argc > 1 )
2616             wrong_args("--import-ownertrust [file]");
2617         import_ownertrust( argc? *argv:NULL );
2618         break;
2619       
2620       case aPipeMode:
2621         if ( argc )
2622             wrong_args ("--pipemode");
2623         run_in_pipemode ();
2624         break;
2625
2626       case aRebuildKeydbCaches:
2627         if (argc)
2628             wrong_args ("--rebuild-keydb-caches");
2629         keydb_rebuild_caches ();
2630         break;
2631
2632       case aListPackets:
2633         opt.list_packets=2;
2634       default:
2635         if( argc > 1 )
2636             wrong_args(_("[filename]"));
2637         /* Issue some output for the unix newbie */
2638         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2639                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2640             log_info(_("Go ahead and type your message ...\n"));
2641
2642         if( !(a = iobuf_open(fname)) )
2643             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2644         else {
2645
2646             if( !opt.no_armor ) {
2647                 if( use_armor_filter( a ) ) {
2648                     memset( &afx, 0, sizeof afx);
2649                     iobuf_push_filter( a, armor_filter, &afx );
2650                 }
2651             }
2652             if( cmd == aListPackets ) {
2653                 set_packet_list_mode(1);
2654                 opt.list_packets=1;
2655             }
2656             rc = proc_packets(NULL, a );
2657             if( rc )
2658                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2659             iobuf_close(a);
2660         }
2661         break;
2662     }
2663
2664     /* cleanup */
2665     FREE_STRLIST(remusr);
2666     FREE_STRLIST(locusr);
2667     g10_exit(0);
2668     return 8; /*NEVER REACHED*/
2669 }
2670
2671
2672 void
2673 g10_exit( int rc )
2674 {
2675     update_random_seed_file();
2676     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2677         m_print_stats("on exit");
2678         random_dump_stats();
2679     }
2680     if( opt.debug )
2681         secmem_dump_stats();
2682     secmem_term();
2683     rc = rc? rc : log_get_errorcount(0)? 2 :
2684                         g10_errors_seen? 1 : 0;
2685     exit(rc );
2686 }
2687
2688
2689 /* Pretty-print hex hashes.  This assumes at least an 80-character
2690    display, but there are a few other similar assumptions in the
2691    display code. */
2692 static void
2693 print_hex( MD_HANDLE md, int algo, const char *fname )
2694 {
2695   int i,n,count,indent=0;
2696   const byte *p;
2697
2698   if(fname)
2699     indent=printf("%s: ",fname);
2700
2701   if(indent>40)
2702     {
2703       printf("\n");
2704       indent=0;
2705     }
2706
2707   if(algo==DIGEST_ALGO_RMD160)
2708     indent+=printf("RMD160 = ");
2709   else if(algo==DIGEST_ALGO_TIGER)
2710     indent+=printf(" TIGER = ");
2711   else if(algo>0)
2712     indent+=printf("%6s = ",digest_algo_to_string(algo));
2713   else
2714     algo=abs(algo);
2715
2716   count=indent;
2717
2718   p = md_read( md, algo );
2719   n = md_digest_length(algo);
2720
2721   count+=printf("%02X",*p++);
2722
2723   for(i=1;i<n;i++,p++)
2724     {
2725       if(n==16)
2726         {
2727           if(count+2>79)
2728             {
2729               printf("\n%*s",indent," ");
2730               count=indent;
2731             }
2732           else
2733             count+=printf(" ");
2734
2735           if(!(i%8))
2736             count+=printf(" ");
2737         }
2738       else if (n==20)
2739         {
2740           if(!(i%2))
2741             {
2742               if(count+4>79)
2743                 {
2744                   printf("\n%*s",indent," ");
2745                   count=indent;
2746                 }
2747               else
2748                 count+=printf(" ");
2749             }
2750
2751           if(!(i%10))
2752             count+=printf(" ");
2753         }
2754       else
2755         {
2756           if(!(i%4))
2757             {
2758               if(count+8>79)
2759                 {
2760                   printf("\n%*s",indent," ");
2761                   count=indent;
2762                 }
2763               else
2764                 count+=printf(" ");
2765             }
2766         }
2767
2768       count+=printf("%02X",*p);
2769     }
2770
2771   printf("\n");
2772 }
2773
2774 static void
2775 print_hashline( MD_HANDLE md, int algo, const char *fname )
2776 {
2777     int i, n;
2778     const byte *p;
2779     
2780     if ( fname ) {
2781         for (p = fname; *p; p++ ) {
2782             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2783                 printf("%%%02X", *p );
2784             else 
2785                 putchar( *p );
2786         }
2787     }
2788     putchar(':');
2789     printf("%d:", algo );
2790     p = md_read( md, algo );
2791     n = md_digest_length(algo);
2792     for(i=0; i < n ; i++, p++ ) 
2793         printf("%02X", *p );
2794     putchar(':');
2795     putchar('\n');
2796 }
2797
2798 static void
2799 print_mds( const char *fname, int algo )
2800 {
2801     FILE *fp;
2802     char buf[1024];
2803     size_t n;
2804     MD_HANDLE md;
2805
2806     if( !fname ) {
2807         fp = stdin;
2808       #ifdef HAVE_DOSISH_SYSTEM
2809         setmode ( fileno(fp) , O_BINARY );
2810       #endif
2811     }
2812     else {
2813         fp = fopen( fname, "rb" );
2814     }
2815     if( !fp ) {
2816         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
2817         return;
2818     }
2819
2820     md = md_open( 0, 0 );
2821     if( algo )
2822         md_enable( md, algo );
2823     else {
2824         md_enable( md, DIGEST_ALGO_MD5 );
2825         md_enable( md, DIGEST_ALGO_SHA1 );
2826         md_enable( md, DIGEST_ALGO_RMD160 );
2827         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2828             md_enable( md, DIGEST_ALGO_TIGER );
2829         md_enable( md, DIGEST_ALGO_SHA256 );
2830         if( !check_digest_algo(DIGEST_ALGO_SHA384) )
2831           md_enable( md, DIGEST_ALGO_SHA384 );
2832         if( !check_digest_algo(DIGEST_ALGO_SHA512) )
2833           md_enable( md, DIGEST_ALGO_SHA512 );
2834     }
2835
2836     while( (n=fread( buf, 1, DIM(buf), fp )) )
2837         md_write( md, buf, n );
2838     if( ferror(fp) )
2839         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
2840     else {
2841         md_final(md);
2842         if ( opt.with_colons ) {
2843             if ( algo ) 
2844                 print_hashline( md, algo, fname );
2845             else {
2846                 print_hashline( md, DIGEST_ALGO_MD5, fname );
2847                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
2848                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
2849                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) 
2850                     print_hashline( md, DIGEST_ALGO_TIGER, fname );
2851                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
2852                 if( !check_digest_algo(DIGEST_ALGO_SHA384) ) 
2853                   print_hashline( md, DIGEST_ALGO_SHA384, fname );
2854                 if( !check_digest_algo(DIGEST_ALGO_SHA512) ) 
2855                   print_hashline( md, DIGEST_ALGO_SHA512, fname );
2856             }
2857         }
2858         else {
2859             if( algo )
2860                print_hex(md,-algo,fname);
2861             else {
2862                 print_hex( md, DIGEST_ALGO_MD5, fname );
2863                 print_hex( md, DIGEST_ALGO_SHA1, fname );
2864                 print_hex( md, DIGEST_ALGO_RMD160, fname );
2865                 if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2866                   print_hex( md, DIGEST_ALGO_TIGER, fname );
2867                 print_hex( md, DIGEST_ALGO_SHA256, fname );
2868                 if( !check_digest_algo(DIGEST_ALGO_SHA384) )
2869                   print_hex( md, DIGEST_ALGO_SHA384, fname );
2870                 if( !check_digest_algo(DIGEST_ALGO_SHA512) )
2871                   print_hex( md, DIGEST_ALGO_SHA512, fname );
2872             }
2873         }
2874     }
2875     md_close(md);
2876
2877     if( fp != stdin )
2878         fclose(fp);
2879 }
2880
2881
2882 /****************
2883  * Check the supplied name,value string and add it to the notation
2884  * data to be used for signatures.  which==0 for sig notations, and 1
2885  * for cert notations.
2886 */
2887 static void
2888 add_notation_data( const char *string, int which )
2889 {
2890     const char *s;
2891     STRLIST sl,*notation_data;
2892     int critical=0;
2893     int highbit=0;
2894     int saw_at=0;
2895
2896     if(which)
2897       notation_data=&opt.cert_notation_data;
2898     else
2899       notation_data=&opt.sig_notation_data;
2900
2901     if( *string == '!' ) {
2902         critical = 1;
2903         string++;
2904     }
2905
2906     /* If and when the IETF assigns some official name tags, we'll
2907        have to add them here. */
2908
2909     for( s=string ; *s != '='; s++ )
2910       {
2911         if( *s=='@')
2912           saw_at=1;
2913
2914         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
2915           {
2916             log_error(_("a notation name must have only printable characters "
2917                         "or spaces, and end with an '='\n") );
2918             return;
2919           }
2920       }
2921
2922     if(!saw_at && !opt.expert)
2923       {
2924         log_error(
2925                 _("a user notation name must contain the '@' character\n"));
2926         return;
2927       }
2928
2929     /* we only support printable text - therefore we enforce the use
2930      * of only printable characters (an empty value is valid) */
2931     for( s++; *s ; s++ ) {
2932         if( iscntrl(*s) ) {
2933             log_error(_("a notation value must not use "
2934                         "any control characters\n") );
2935             return;
2936         }
2937         else if( *s & 0x80 )
2938             highbit = 1;
2939     }
2940
2941     if( highbit )   /* must use UTF8 encoding */
2942         sl = add_to_strlist2( notation_data, string, utf8_strings );
2943     else
2944         sl = add_to_strlist( notation_data, string );
2945
2946     if( critical )
2947         sl->flags |= 1;
2948 }
2949
2950
2951 static void
2952 add_policy_url( const char *string, int which )
2953 {
2954   int i,critical=0;
2955   STRLIST sl;
2956
2957   if(*string=='!')
2958     {
2959       string++;
2960       critical=1;
2961     }
2962
2963   for(i=0;i<strlen(string);i++)
2964     if(string[i]&0x80 || iscntrl(string[i]))
2965       break;
2966
2967   if(i==0 || i<strlen(string))
2968     {
2969       if(which)
2970         log_error(_("the given certification policy URL is invalid\n"));
2971       else
2972         log_error(_("the given signature policy URL is invalid\n"));
2973     }
2974
2975   if(which)
2976     sl=add_to_strlist( &opt.cert_policy_url, string );
2977   else
2978     sl=add_to_strlist( &opt.sig_policy_url, string );
2979
2980   if(critical)
2981     sl->flags |= 1;    
2982 }