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