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