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