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