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