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