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