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