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