* tdbio.c (tdbio_read_record, tdbio_write_record): Compact 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   /* Break apart the values */
862   while((value=strsep(&string," ")) && *value!='\0')
863     add_to_strlist2(&values,value,utf8_strings);
864
865   item=m_alloc(sizeof(struct groupitem));
866   item->name=name;
867   item->values=values;
868   item->next=opt.grouplist;
869
870   opt.grouplist=item;
871 }
872
873 /* We need to check three things.
874
875    0) The homedir.  It must be x00, a directory, and owned by the
876    user.
877
878    1) The options file.  Okay unless it or its containing directory is
879    group or other writable or not owned by us.  disable exec in this
880    case.
881
882    2) Extensions.  Same as #2.
883
884    Returns true if the item is unsafe. */
885 static int
886 check_permissions(const char *path,int item)
887 {
888 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
889   static int homedir_cache=-1;
890   char *tmppath,*dir;
891   struct stat statbuf,dirbuf;
892   int homedir=0,ret=0,checkonly=0;
893   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
894
895   if(opt.no_perm_warn)
896     return 0;
897
898   assert(item==0 || item==1 || item==2);
899
900   /* extensions may attach a path */
901   if(item==2 && path[0]!=DIRSEP_C)
902     {
903       if(strchr(path,DIRSEP_C))
904         tmppath=make_filename(path,NULL);
905       else
906         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
907     }
908   else
909     tmppath=m_strdup(path);
910
911   /* If the item is located in the homedir, but isn't the homedir,
912      don't continue if we already checked the homedir itself.  This is
913      to avoid user confusion with an extra options file warning which
914      could be rectified if the homedir itself had proper
915      permissions. */
916   if(item!=0 && homedir_cache>-1
917      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
918     {
919       ret=homedir_cache;
920       goto end;
921     }
922
923   /* It's okay if the file or directory doesn't exist */
924   if(stat(tmppath,&statbuf)!=0)
925     {
926       ret=0;
927       goto end;
928     }
929
930   /* Now check the enclosing directory.  Theoretically, we could walk
931      this test up to the root directory /, but for the sake of sanity,
932      I'm stopping at one level down. */
933   dir=make_dirname(tmppath);
934
935   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
936     {
937       /* Weird error */
938       ret=1;
939       goto end;
940     }
941
942   m_free(dir);
943
944   /* Assume failure */
945   ret=1;
946
947   if(item==0)
948     {
949       /* The homedir must be x00, a directory, and owned by the user. */
950
951       if(S_ISDIR(statbuf.st_mode))
952         {
953           if(statbuf.st_uid==getuid())
954             {
955               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
956                 ret=0;
957               else
958                 perm=1;
959             }
960           else
961             own=1;
962
963           homedir_cache=ret;
964         }
965     }
966   else if(item==1 || item==2)
967     {
968       /* The options or extension file.  Okay unless it or its
969          containing directory is group or other writable or not owned
970          by us or root. */
971
972       if(S_ISREG(statbuf.st_mode))
973         {
974           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
975             {
976               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
977                 {
978                   /* it's not writable, so make sure the enclosing
979                      directory is also not writable */
980                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
981                     {
982                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
983                         ret=0;
984                       else
985                         enc_dir_perm=1;
986                     }
987                   else
988                     enc_dir_own=1;
989                 }
990               else
991                 {
992                   /* it's writable, so the enclosing directory had
993                      better not let people get to it. */
994                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
995                     {
996                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
997                         ret=0;
998                       else
999                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1000                     }
1001                   else
1002                     enc_dir_own=1;
1003                 }
1004             }
1005           else
1006             own=1;
1007         }
1008     }
1009   else
1010     BUG();
1011
1012   if(!checkonly)
1013     {
1014       if(own)
1015         {
1016           if(item==0)
1017             log_info(_("WARNING: unsafe ownership on "
1018                        "homedir \"%s\"\n"),tmppath);
1019           else if(item==1)
1020             log_info(_("WARNING: unsafe ownership on "
1021                        "configuration file \"%s\"\n"),tmppath);
1022           else
1023             log_info(_("WARNING: unsafe ownership on "
1024                        "extension \"%s\"\n"),tmppath);
1025         }
1026       if(perm)
1027         {
1028           if(item==0)
1029             log_info(_("WARNING: unsafe permissions on "
1030                        "homedir \"%s\"\n"),tmppath);
1031           else if(item==1)
1032             log_info(_("WARNING: unsafe permissions on "
1033                        "configuration file \"%s\"\n"),tmppath);
1034           else
1035             log_info(_("WARNING: unsafe permissions on "
1036                        "extension \"%s\"\n"),tmppath);
1037         }
1038       if(enc_dir_own)
1039         {
1040           if(item==0)
1041             log_info(_("WARNING: unsafe enclosing directory ownership on "
1042                        "homedir \"%s\"\n"),tmppath);
1043           else if(item==1)
1044             log_info(_("WARNING: unsafe enclosing directory ownership on "
1045                        "configuration file \"%s\"\n"),tmppath);
1046           else
1047             log_info(_("WARNING: unsafe enclosing directory ownership on "
1048                        "extension \"%s\"\n"),tmppath);
1049         }
1050       if(enc_dir_perm)
1051         {
1052           if(item==0)
1053             log_info(_("WARNING: unsafe enclosing directory permissions on "
1054                        "homedir \"%s\"\n"),tmppath);
1055           else if(item==1)
1056             log_info(_("WARNING: unsafe enclosing directory permissions on "
1057                        "configuration file \"%s\"\n"),tmppath);
1058           else
1059             log_info(_("WARNING: unsafe enclosing directory permissions on "
1060                        "extension \"%s\"\n"),tmppath);
1061         }
1062     }
1063
1064  end:
1065   m_free(tmppath);
1066
1067   if(homedir)
1068     homedir_cache=ret;
1069
1070   return ret;
1071
1072 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1073
1074   return 0;
1075 }
1076
1077 int
1078 main( int argc, char **argv )
1079 {
1080     ARGPARSE_ARGS pargs;
1081     IOBUF a;
1082     int rc=0;
1083     int orig_argc;
1084     char **orig_argv;
1085     const char *fname;
1086     char *username;
1087     int may_coredump;
1088     STRLIST sl, remusr= NULL, locusr=NULL;
1089     STRLIST nrings=NULL, sec_nrings=NULL;
1090     armor_filter_context_t afx;
1091     int detached_sig = 0;
1092     FILE *configfp = NULL;
1093     char *configname = NULL;
1094     unsigned configlineno;
1095     int parse_debug = 0;
1096     int default_config = 1;
1097     int default_keyring = 1;
1098     int greeting = 0;
1099     int nogreeting = 0;
1100     int use_random_seed = 1;
1101     enum cmd_and_opt_values cmd = 0;
1102     const char *trustdb_name = NULL;
1103     char *def_cipher_string = NULL;
1104     char *def_digest_string = NULL;
1105     char *def_compress_string = NULL;
1106     char *cert_digest_string = NULL;
1107     char *s2k_cipher_string = NULL;
1108     char *s2k_digest_string = NULL;
1109     char *pers_cipher_list = NULL;
1110     char *pers_digest_list = NULL;
1111     char *pers_compress_list = NULL;
1112     int eyes_only=0;
1113     int pwfd = -1;
1114     int with_fpr = 0; /* make an option out of --fingerprint */
1115     int any_explicit_recipient = 0;
1116   #ifdef USE_SHM_COPROCESSING
1117     ulong requested_shm_size=0;
1118   #endif
1119
1120   #ifdef __riscos__
1121     riscos_global_defaults();
1122     opt.lock_once = 1;
1123   #endif /* __riscos__ */
1124
1125     trap_unaligned();
1126     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
1127     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1128      * when adding any stuff between here and the call to
1129      * secmem_init()  somewhere after the option parsing
1130      */
1131     log_set_name("gpg");
1132     secure_random_alloc(); /* put random number into secure memory */
1133     may_coredump = disable_core_dumps();
1134     init_signals();
1135     create_dotlock(NULL); /* register locking cleanup */
1136     i18n_init();
1137     opt.command_fd = -1; /* no command fd */
1138     opt.compress = -1; /* defaults to standard compress level */
1139     /* note: if you change these lines, look at oOpenPGP */
1140     opt.def_cipher_algo = 0;
1141     opt.def_digest_algo = 0;
1142     opt.cert_digest_algo = 0;
1143     opt.def_compress_algo = -1;
1144     opt.s2k_mode = 3; /* iterated+salted */
1145     opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1146     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1147     opt.completes_needed = 1;
1148     opt.marginals_needed = 3;
1149     opt.max_cert_depth = 5;
1150     opt.pgp2_workarounds = 1;
1151     opt.force_v3_sigs = 1;
1152     opt.escape_from = 1;
1153     opt.import_options=IMPORT_SK2PK;
1154     opt.export_options=
1155       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1156     opt.keyserver_options.import_options=IMPORT_REPAIR_HKP_SUBKEY_BUG;
1157     opt.keyserver_options.export_options=
1158       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1159     opt.keyserver_options.include_subkeys=1;
1160     opt.keyserver_options.include_revoked=1;
1161     opt.trust_model=TM_OPENPGP;
1162     opt.mangle_dos_filenames = 1;
1163
1164 #if defined (__MINGW32__)
1165     set_homedir ( read_w32_registry_string( NULL,
1166                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1167 #else
1168     set_homedir ( getenv("GNUPGHOME") );
1169 #endif
1170     if( !*opt.homedir )
1171         set_homedir ( GNUPG_HOMEDIR );
1172
1173     /* check whether we have a config file on the commandline */
1174     orig_argc = argc;
1175     orig_argv = argv;
1176     pargs.argc = &argc;
1177     pargs.argv = &argv;
1178     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1179     while( arg_parse( &pargs, opts) ) {
1180         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1181             parse_debug++;
1182         else if( pargs.r_opt == oOptions ) {
1183             /* yes there is one, so we do not try the default one, but
1184              * read the option file when it is encountered at the commandline
1185              */
1186             default_config = 0;
1187         }
1188         else if( pargs.r_opt == oNoOptions )
1189             default_config = 0; /* --no-options */
1190         else if( pargs.r_opt == oHomedir )
1191             set_homedir ( pargs.r.ret_str );
1192         else if( pargs.r_opt == oNoPermissionWarn )
1193             opt.no_perm_warn=1;
1194         else if (pargs.r_opt == oStrict )
1195           {
1196             opt.strict=1;
1197             log_set_strict(1);
1198           }
1199         else if (pargs.r_opt == oNoStrict )
1200           {
1201             opt.strict=0;
1202             log_set_strict(0);
1203           }
1204       #ifdef USE_SHM_COPROCESSING
1205         else if( pargs.r_opt == oRunAsShmCP ) {
1206             /* does not make sense in a options file, we do it here,
1207              * so that we are the able to drop setuid as soon as possible */
1208             opt.shm_coprocess = 1;
1209             requested_shm_size = pargs.r.ret_ulong;
1210         }
1211         else if ( pargs.r_opt == oStatusFD ) {
1212             /* this is needed to ensure that the status-fd filedescriptor is
1213              * initialized when init_shm_coprocessing() is called */
1214             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1215         }
1216       #endif
1217     }
1218
1219 #ifdef HAVE_DOSISH_SYSTEM
1220     if ( strchr (opt.homedir,'\\') ) {
1221         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
1222         const char *s = opt.homedir;
1223         for (d=buf,s=opt.homedir; *s; s++)
1224             *d++ = *s == '\\'? '/': *s;
1225         *d = 0;
1226         set_homedir (buf);
1227     }
1228 #endif
1229 #ifdef USE_SHM_COPROCESSING
1230     if( opt.shm_coprocess ) {
1231         init_shm_coprocessing(requested_shm_size, 1 );
1232     }
1233 #endif
1234     /* initialize the secure memory. */
1235     secmem_init( 16384 );
1236     maybe_setuid = 0;
1237     /* Okay, we are now working under our real uid */
1238
1239     set_native_charset (NULL); /* Try to auto set the character set */
1240
1241     if( default_config )
1242       {
1243         configname = make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1244         if (!access (configname, R_OK))
1245           { /* Print a warning when both config files are present. */
1246             char *p = make_filename(opt.homedir, "options", NULL );
1247             if (!access (p, R_OK))
1248               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1249             m_free (p);
1250           }
1251         else
1252           { /* Keep on using the old default one. */
1253             m_free (configname);
1254             configname = make_filename(opt.homedir, "options", NULL );
1255           }
1256       }
1257     argc = orig_argc;
1258     argv = orig_argv;
1259     pargs.argc = &argc;
1260     pargs.argv = &argv;
1261     pargs.flags=  1;  /* do not remove the args */
1262
1263     /* By this point we have a homedir, and cannot change it. */
1264     check_permissions(opt.homedir,0);
1265
1266   next_pass:
1267     if( configname ) {
1268       if(check_permissions(configname,1))
1269         {
1270           /* If any options file is unsafe, then disable any external
1271              programs for keyserver calls or photo IDs.  Since the
1272              external program to call is set in the options file, a
1273              unsafe options file can lead to an arbitrary program
1274              being run. */
1275
1276           opt.exec_disable=1;
1277         }
1278
1279         configlineno = 0;
1280         configfp = fopen( configname, "r" );
1281         if( !configfp ) {
1282             if( default_config ) {
1283                 if( parse_debug )
1284                     log_info(_("NOTE: no default option file `%s'\n"),
1285                                                             configname );
1286             }
1287             else {
1288                 log_error(_("option file `%s': %s\n"),
1289                                     configname, strerror(errno) );
1290                 g10_exit(2);
1291             }
1292             m_free(configname); configname = NULL;
1293         }
1294         if( parse_debug && configname )
1295             log_info(_("reading options from `%s'\n"), configname );
1296         default_config = 0;
1297     }
1298
1299     while( optfile_parse( configfp, configname, &configlineno,
1300                                                 &pargs, opts) ) {
1301         switch( pargs.r_opt ) {
1302           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1303           case aListPackets: set_cmd( &cmd, aListPackets); break;
1304           case aImport: set_cmd( &cmd, aImport); break;
1305           case aFastImport: set_cmd( &cmd, aFastImport); break;
1306           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1307           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1308           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1309           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1310           case aExport: set_cmd( &cmd, aExport); break;
1311           case aExportAll: set_cmd( &cmd, aExportAll); break;
1312           case aListKeys: set_cmd( &cmd, aListKeys); break;
1313           case aListSigs: set_cmd( &cmd, aListSigs); break;
1314           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1315           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1316           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1317                                                         greeting=1; break;
1318           case aDeleteSecretAndPublicKeys:
1319             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1320             greeting=1; 
1321             break;
1322           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1323
1324           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1325           case aSym: set_cmd( &cmd, aSym); break;
1326
1327           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1328           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1329
1330           case aEncr: set_cmd( &cmd, aEncr); break;
1331           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1332           case aSign: set_cmd( &cmd, aSign );  break;
1333           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1334           case aSignKey: set_cmd( &cmd, aSignKey); break;
1335           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1336           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1337           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1338           case aStore: set_cmd( &cmd, aStore); break;
1339           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1340           case aClearsign: set_cmd( &cmd, aClearsign); break;
1341           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1342           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1343           case aVerify: set_cmd( &cmd, aVerify); break;
1344           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1345           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1346           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1347           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1348           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1349           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1350           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1351           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1352           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1353           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1354           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1355           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1356           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1357           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1358           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1359           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1360
1361           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1362           case oOutput: opt.outfile = pargs.r.ret_str; break;
1363           case oQuiet: opt.quiet = 1; break;
1364           case oNoTTY: tty_no_terminal(1); break;
1365           case oDryRun: opt.dry_run = 1; break;
1366           case oInteractive: opt.interactive = 1; break;
1367           case oVerbose: g10_opt_verbose++;
1368                     opt.verbose++; opt.list_sigs=1; break;
1369           case oKOption: set_cmd( &cmd, aKMode ); break;
1370
1371           case oBatch: opt.batch = 1; nogreeting = 1; break;
1372           case oUseAgent:
1373 #ifndef __riscos__
1374             opt.use_agent = 1;
1375 #else /* __riscos__ */
1376             opt.use_agent = 0;
1377             riscos_not_implemented("use-agent");
1378 #endif /* __riscos__ */
1379             break;
1380           case oNoUseAgent: opt.use_agent = 0; break;
1381           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1382           case oAnswerYes: opt.answer_yes = 1; break;
1383           case oAnswerNo: opt.answer_no = 1; break;
1384           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1385           case oPrimaryKeyring:
1386             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1387             sl->flags=2;
1388             break;
1389           case oShowKeyring: opt.show_keyring = 1; break;
1390           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1391           case oDebugAll: opt.debug = ~0; break;
1392           case oStatusFD:
1393             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1394             break;
1395 #ifdef __riscos__
1396           case oStatusFile:
1397             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1398             break;
1399 #endif /* __riscos__ */
1400           case oAttributeFD:
1401             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1402             break;
1403 #ifdef __riscos__
1404           case oAttributeFile:
1405             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1406             break;
1407 #endif /* __riscos__ */
1408           case oLoggerFD:
1409             log_set_logfile( NULL,
1410                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1411             break;
1412 #ifdef __riscos__
1413           case oLoggerFile:
1414             log_set_logfile( NULL,
1415                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1416             break;
1417 #endif /* __riscos__ */
1418           case oWithFingerprint:
1419             opt.with_fingerprint = 1;
1420             with_fpr=1; /*fall thru*/
1421           case oFingerprint: opt.fingerprint++; break;
1422           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1423           case oOptions:
1424             /* config files may not be nested (silently ignore them) */
1425             if( !configfp ) {
1426                 m_free(configname);
1427                 configname = m_strdup(pargs.r.ret_str);
1428                 goto next_pass;
1429             }
1430             break;
1431           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1432           case oNoDefKeyring: default_keyring = 0; break;
1433           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1434           case oNoGreeting: nogreeting = 1; break;
1435           case oNoVerbose: g10_opt_verbose = 0;
1436                            opt.verbose = 0; opt.list_sigs=0; break;
1437           case oQuickRandom: quick_random_gen(1); break;
1438           case oSKComments: opt.sk_comments=1; break;
1439           case oNoSKComments: opt.sk_comments=0; break;
1440           case oNoVersion: opt.no_version=1; break;
1441           case oEmitVersion: opt.no_version=0; break;
1442           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1443           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1444           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1445           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1446           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1447           case oDefRecipient:
1448                     if( *pargs.r.ret_str )
1449                         opt.def_recipient = make_username(pargs.r.ret_str);
1450                     break;
1451           case oDefRecipientSelf:
1452                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1453                     opt.def_recipient_self = 1;
1454                     break;
1455           case oNoDefRecipient:
1456                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1457                     opt.def_recipient_self = 0;
1458                     break;
1459           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1460           case oHomedir: break;
1461           case oNoBatch: opt.batch = 0; break;
1462           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1463           case oWithColons: opt.with_colons=':'; break;
1464
1465           case oSkipVerify: opt.skip_verify=1; break;
1466           case oCompressKeys: opt.compress_keys = 1; break;
1467           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1468             /* There are many programs (like mutt) that call gpg with
1469                --always-trust so keep this option around for a long
1470                time. */
1471           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1472           case oTrustModel:
1473             if(ascii_strcasecmp(pargs.r.ret_str,"openpgp")==0)
1474               opt.trust_model=TM_OPENPGP;
1475             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1476               opt.trust_model=TM_CLASSIC;
1477             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1478               opt.trust_model=TM_ALWAYS;
1479             else
1480               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1481             break;
1482           case oForceOwnertrust:
1483             log_info(_("NOTE: %s is not for normal use!\n"),
1484                      "--force-ownertrust");
1485             if(pargs.r.ret_int>=TRUST_UNDEFINED
1486                && pargs.r.ret_int<=TRUST_ULTIMATE)
1487               opt.force_ownertrust=pargs.r.ret_int;
1488             else
1489               log_error("invalid ownertrust %d\n",pargs.r.ret_int);
1490             break;
1491           case oLoadExtension:
1492 #ifndef __riscos__
1493 #if defined(USE_DYNAMIC_LINKING) || defined(__MINGW32__)
1494             if(check_permissions(pargs.r.ret_str,2))
1495               log_info(_("cipher extension \"%s\" not loaded due to "
1496                          "unsafe permissions\n"),pargs.r.ret_str);
1497             else
1498               register_cipher_extension(orig_argc? *orig_argv:NULL,
1499                                         pargs.r.ret_str);
1500 #endif
1501 #else /* __riscos__ */
1502             riscos_not_implemented("load-extension");
1503 #endif /* __riscos__ */
1504             break;
1505           case oRFC1991:
1506             opt.rfc1991 = 1;
1507             opt.rfc2440 = 0;
1508             opt.force_v4_certs = 0;
1509             opt.disable_mdc = 1;
1510             opt.escape_from = 1;
1511             break;
1512           case oOpenPGP:
1513             /* TODO: When 2440bis becomes a RFC, these may need
1514                changing. */
1515             opt.rfc1991 = 0;
1516             opt.rfc2440 = 1;
1517             opt.disable_mdc = 1;
1518             opt.allow_non_selfsigned_uid = 1;
1519             opt.allow_freeform_uid = 1;
1520             opt.pgp2_workarounds = 0;
1521             opt.escape_from = 0;
1522             opt.force_v3_sigs = 0;
1523             opt.compress_keys = 0;          /* not mandated  but we do it */
1524             opt.compress_sigs = 0;          /* ditto. */
1525             opt.not_dash_escaped = 0;
1526             opt.def_cipher_algo = 0;
1527             opt.def_digest_algo = 0;
1528             opt.cert_digest_algo = 0;
1529             opt.def_compress_algo = -1;
1530             opt.s2k_mode = 3; /* iterated+salted */
1531             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1532             opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1533             break;
1534           case oPGP2: opt.pgp2 = 1; break;
1535           case oNoPGP2: opt.pgp2 = 0; break;
1536           case oPGP6: opt.pgp6 = 1; break;
1537           case oNoPGP6: opt.pgp6 = 0; break;
1538           case oPGP7: opt.pgp7 = 1; break;
1539           case oNoPGP7: opt.pgp7 = 0; break;
1540           case oPGP8: opt.pgp8 = 1; break;
1541           case oNoPGP8: opt.pgp8 = 0; break;
1542           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1543           case oCompressSigs: opt.compress_sigs = 1; break;
1544           case oRunAsShmCP:
1545 #ifndef __riscos__
1546 # ifndef USE_SHM_COPROCESSING
1547             /* not possible in the option file,
1548              * but we print the warning here anyway */
1549             log_error("shared memory coprocessing is not available\n");
1550 # endif
1551 #else /* __riscos__ */
1552             riscos_not_implemented("run-as-shm-coprocess");
1553 #endif /* __riscos__ */
1554             break;
1555           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1556           case oForYourEyesOnly: eyes_only = 1; break;
1557           case oNoForYourEyesOnly: eyes_only = 0; break;
1558           case oSetPolicyURL:
1559             add_policy_url(pargs.r.ret_str,0);
1560             add_policy_url(pargs.r.ret_str,1);
1561             break;
1562           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1563           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1564           case oShowPolicyURL: opt.show_policy_url=1; break;
1565           case oNoShowPolicyURL: opt.show_policy_url=0; break;
1566           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1567           case oComment: opt.comment_string = pargs.r.ret_str; break;
1568           case oDefaultComment: opt.comment_string = NULL; break;
1569           case oThrowKeyid: opt.throw_keyid = 1; break;
1570           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1571           case oShowPhotos: opt.show_photos = 1; break;
1572           case oNoShowPhotos: opt.show_photos = 0; break;
1573           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1574           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1575           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1576           case oForceV4Certs: opt.force_v4_certs = 1; break;
1577           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1578           case oForceMDC: opt.force_mdc = 1; break;
1579           case oNoForceMDC: opt.force_mdc = 0; break;
1580           case oDisableMDC: opt.disable_mdc = 1; break;
1581           case oNoDisableMDC: opt.disable_mdc = 0; break;
1582           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1583           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1584           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1585           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1586           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1587           case oEncryptTo: /* store the recipient in the second list */
1588             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1589             sl->flags = 1;
1590             break;
1591           case oHiddenEncryptTo: /* store the recipient in the second list */
1592             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1593             sl->flags = 1|2;
1594             break;
1595           case oRecipient: /* store the recipient */
1596             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1597             any_explicit_recipient = 1;
1598             break;
1599           case oHiddenRecipient: /* store the recipient with a flag */
1600             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1601             sl->flags = 2;
1602             any_explicit_recipient = 1;
1603             break;
1604           case oTextmodeShort: opt.textmode = 2; break;
1605           case oTextmode: opt.textmode=1;  break;
1606           case oExpert: opt.expert = 1; break;
1607           case oNoExpert: opt.expert = 0; break;
1608           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1609           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1610           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1611           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1612           case oUser: /* store the local users */
1613             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1614             break;
1615           case oCompress: opt.compress = pargs.r.ret_int; break;
1616           case oPasswdFD:
1617             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1618             break;
1619 #ifdef __riscos__
1620           case oPasswdFile:
1621             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1622             break;
1623 #endif /* __riscos__ */
1624           case oCommandFD:
1625             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1626             break;
1627 #ifdef __riscos__
1628           case oCommandFile:
1629             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1630             break;
1631 #endif /* __riscos__ */
1632           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1633           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1634           case oCompressAlgo:
1635             /* If it is all digits, stick a Z in front of it for
1636                later.  This is for backwards compatibility with
1637                versions that took the compress algorithm number. */
1638             {
1639               char *pt=pargs.r.ret_str;
1640               while(*pt)
1641                 {
1642                   if(!isdigit(*pt))
1643                     break;
1644
1645                   pt++;
1646                 }
1647
1648               if(*pt=='\0')
1649                 {
1650                   def_compress_string=m_alloc(strlen(pargs.r.ret_str)+2);
1651                   strcpy(def_compress_string,"Z");
1652                   strcat(def_compress_string,pargs.r.ret_str);
1653                 }
1654               else
1655                 def_compress_string = m_strdup(pargs.r.ret_str);
1656             }
1657             break;
1658           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1659           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1660           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1661           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1662           case oCharset:
1663             if( set_native_charset( pargs.r.ret_str ) )
1664                 log_error(_("%s is not a valid character set\n"),
1665                                                     pargs.r.ret_str);
1666             break;
1667           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1668           case oEscapeFrom: opt.escape_from = 1; break;
1669           case oNoEscapeFrom: opt.escape_from = 0; break;
1670           case oLockOnce: opt.lock_once = 1; break;
1671           case oLockNever: disable_dotlock(); break;
1672           case oLockMultiple:
1673 #ifndef __riscos__
1674             opt.lock_once = 0;
1675 #else /* __riscos__ */
1676             riscos_not_implemented("lock-multiple");
1677 #endif /* __riscos__ */
1678             break;
1679           case oKeyServer:
1680             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1681             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1682               log_error(_("could not parse keyserver URI\n"));
1683             break;
1684           case oKeyServerOptions:
1685             parse_keyserver_options(pargs.r.ret_str);
1686             break;
1687           case oImportOptions:
1688             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1689               {
1690                 if(configname)
1691                   log_error(_("%s:%d: invalid import options\n"),
1692                             configname,configlineno);
1693                 else
1694                   log_error(_("invalid import options\n"));
1695               }
1696             break;
1697           case oExportOptions:
1698             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1699               {
1700                 if(configname)
1701                   log_error(_("%s:%d: invalid export options\n"),
1702                             configname,configlineno);
1703                 else
1704                   log_error(_("invalid export options\n"));
1705               }
1706             break;
1707           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1708           case oExecPath:
1709             if(set_exec_path(pargs.r.ret_str,0))
1710               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1711             else
1712               opt.exec_path_set=1;
1713             break;
1714           case oNotation:
1715             add_notation_data( pargs.r.ret_str, 0 );
1716             add_notation_data( pargs.r.ret_str, 1 );
1717             break;
1718           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1719           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1720           case oShowNotation: opt.show_notation=1; break;
1721           case oNoShowNotation: opt.show_notation=0; break;
1722           case oUtf8Strings: utf8_strings = 1; break;
1723           case oNoUtf8Strings: utf8_strings = 0; break;
1724           case oDisableCipherAlgo:
1725                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1726                 break;
1727           case oDisablePubkeyAlgo:
1728                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1729                 break;
1730           case oNoSigCache: opt.no_sig_cache = 1; break;
1731           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1732           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1733           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1734           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1735           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1736           case oNoLiteral: opt.no_literal = 1; break;
1737           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1738           case oHonorHttpProxy:
1739                 opt.keyserver_options.honor_http_proxy = 1;
1740                 deprecated_warning(configname,configlineno,
1741                                    "--honor-http-proxy",
1742                                    "--keyserver-options ",
1743                                    "honor-http-proxy");
1744                 break;
1745           case oFastListMode: opt.fast_list_mode = 1; break;
1746           case oFixedListMode: opt.fixed_list_mode = 1; break;
1747           case oListOnly: opt.list_only=1; break;
1748           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1749           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1750           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1751           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1752           case oNoRandomSeedFile: use_random_seed = 0; break;
1753           case oAutoKeyRetrieve:
1754           case oNoAutoKeyRetrieve:
1755                 opt.keyserver_options.auto_key_retrieve=
1756                                              (pargs.r_opt==oAutoKeyRetrieve);
1757                 deprecated_warning(configname,configlineno,
1758                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1759                                "--no-auto-key-retrieve","--keyserver-options ",
1760                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1761                                "no-auto-key-retrieve");
1762                 break;
1763           case oShowSessionKey: opt.show_session_key = 1; break;
1764           case oOverrideSessionKey:
1765                 opt.override_session_key = pargs.r.ret_str;
1766                 break;
1767           case oMergeOnly: opt.merge_only = 1; break;
1768           case oAllowSecretKeyImport: /* obsolete */ break;
1769           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1770           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1771           case oEnableSpecialFilenames:
1772             iobuf_enable_special_filenames (1);
1773             break;
1774           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1775           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1776           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1777           case oPreservePermissions: opt.preserve_permissions=1; break;
1778           case oDefaultPreferenceList:
1779             opt.def_preference_list = pargs.r.ret_str;
1780             break;
1781           case oPersonalCipherPreferences:
1782             pers_cipher_list=pargs.r.ret_str;
1783             break;
1784           case oPersonalDigestPreferences:
1785             pers_digest_list=pargs.r.ret_str;
1786             break;
1787           case oPersonalCompressPreferences:
1788             pers_compress_list=pargs.r.ret_str;
1789             break;
1790           case oDisplay: opt.display = pargs.r.ret_str; break;
1791           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1792           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1793           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1794           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1795           case oGroup: add_group(pargs.r.ret_str); break;
1796           case oStrict: opt.strict=1; log_set_strict(1); break;
1797           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1798
1799           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1800           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1801
1802           default : pargs.err = configfp? 1:2; break;
1803         }
1804     }
1805
1806     if( configfp ) {
1807         fclose( configfp );
1808         configfp = NULL;
1809         m_free(configname); configname = NULL;
1810         goto next_pass;
1811     }
1812     m_free( configname ); configname = NULL;
1813     if( log_get_errorcount(0) )
1814         g10_exit(2);
1815     if( nogreeting )
1816         greeting = 0;
1817
1818     if( greeting ) {
1819         fprintf(stderr, "%s %s; %s\n",
1820                         strusage(11), strusage(13), strusage(14) );
1821         fprintf(stderr, "%s\n", strusage(15) );
1822     }
1823   #ifdef IS_DEVELOPMENT_VERSION
1824     if( !opt.batch ) {
1825         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1826         log_info("It is only intended for test purposes and should NOT be\n");
1827         log_info("used in a production environment or with production keys!\n");
1828     }
1829   #endif
1830
1831     if (opt.verbose > 2)
1832         log_info ("using character set `%s'\n", get_native_charset ());
1833
1834     if( may_coredump && !opt.quiet )
1835         log_info(_("WARNING: program may create a core file!\n"));
1836
1837     if (eyes_only) {
1838       if (opt.set_filename)
1839           log_info(_("WARNING: %s overrides %s\n"),
1840                    "--for-your-eyes-only","--set-filename");
1841
1842       opt.set_filename="_CONSOLE";
1843     }
1844
1845     if (opt.no_literal) {
1846         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1847         if (opt.textmode)
1848             log_error(_("%s not allowed with %s!\n"),
1849                        "--textmode", "--no-literal" );
1850         if (opt.set_filename)
1851             log_error(_("%s makes no sense with %s!\n"),
1852                         eyes_only?"--for-your-eyes-only":"--set-filename",
1853                         "--no-literal" );
1854     }
1855
1856     if (opt.set_filesize)
1857         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1858     if( opt.batch )
1859         tty_batchmode( 1 );
1860
1861     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1862
1863     set_debug();
1864
1865     /* Do these after the switch(), so they can override settings. */
1866     if(opt.pgp2 && (opt.pgp6 || opt.pgp7 || opt.pgp8))
1867       log_error(_("%s not allowed with %s!\n"),
1868                 "--pgp2",opt.pgp6?"--pgp6":opt.pgp7?"--pgp7":"--pgp8");
1869     else
1870       {
1871         if(opt.pgp2)
1872           {
1873             int unusable=0;
1874
1875             if(cmd==aSign && !detached_sig)
1876               {
1877                 log_info(_("you can only make detached or clear signatures "
1878                            "while in --pgp2 mode\n"));
1879                 unusable=1;
1880               }
1881             else if(cmd==aSignEncr || cmd==aSignSym)
1882               {
1883                 log_info(_("you can't sign and encrypt at the "
1884                            "same time while in --pgp2 mode\n"));
1885                 unusable=1;
1886               }
1887             else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1888               {
1889                 log_info(_("you must use files (and not a pipe) when "
1890                            "working with --pgp2 enabled.\n"));
1891                 unusable=1;
1892               }
1893             else if(cmd==aEncr || cmd==aSym)
1894               {
1895                 /* Everything else should work without IDEA (except using
1896                    a secret key encrypted with IDEA and setting an IDEA
1897                    preference, but those have their own error
1898                    messages). */
1899
1900                 if(check_cipher_algo(CIPHER_ALGO_IDEA))
1901                   {
1902                     log_info(_("encrypting a message in --pgp2 mode requires "
1903                                "the IDEA cipher\n"));
1904                     idea_cipher_warn(1);
1905                     unusable=1;
1906                   }
1907                 else if(cmd==aSym)
1908                   {
1909                     /* This only sets IDEA for symmetric encryption
1910                        since it is set via select_algo_from_prefs for
1911                        pk encryption. */
1912                     m_free(def_cipher_string);
1913                     def_cipher_string = m_strdup("idea");
1914                   }
1915
1916                 /* PGP2 can't handle the output from the textmode
1917                    filter, so we disable it for anything that could
1918                    create a literal packet (only encryption and
1919                    symmetric encryption, since we disable signing
1920                    above). */
1921                 if(!unusable)
1922                   opt.textmode=0;
1923               }
1924
1925             if(unusable)
1926               {
1927                 log_info(_("this message may not be usable by %s\n"),
1928                          "PGP 2.x");
1929                 opt.pgp2=0;
1930               }
1931             else
1932               {
1933                 opt.rfc1991 = 1;
1934                 opt.rfc2440 = 0;
1935                 opt.force_mdc = 0;
1936                 opt.disable_mdc = 1;
1937                 opt.force_v4_certs = 0;
1938                 opt.sk_comments = 0;
1939                 opt.escape_from = 1;
1940                 opt.force_v3_sigs = 1;
1941                 opt.pgp2_workarounds = 1;
1942                 opt.ask_sig_expire = 0;
1943                 opt.ask_cert_expire = 0;
1944                 m_free(def_digest_string);
1945                 def_digest_string = m_strdup("md5");
1946                 opt.def_compress_algo = 1;
1947               }
1948           }
1949         else if(opt.pgp6)
1950           {
1951             opt.sk_comments=0;
1952             opt.escape_from=1;
1953             opt.force_v3_sigs=1;
1954             opt.ask_sig_expire=0;
1955             opt.def_compress_algo=1;
1956             opt.force_mdc=0;
1957             opt.disable_mdc=1;
1958           }
1959         else if(opt.pgp7)
1960           {
1961             opt.sk_comments=0;
1962             opt.escape_from=1;
1963             opt.force_v3_sigs=1;
1964             opt.ask_sig_expire=0;
1965             opt.def_compress_algo=1;
1966           }
1967         else if(opt.pgp8)
1968           {
1969             opt.escape_from=1;
1970             opt.def_compress_algo=1;
1971           }
1972       }
1973
1974     /* must do this after dropping setuid, because string_to...
1975      * may try to load an module */
1976     if( def_cipher_string ) {
1977         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
1978         if(opt.def_cipher_algo==0 &&
1979            ascii_strcasecmp(def_cipher_string,"idea")==0)
1980           idea_cipher_warn(1);
1981         m_free(def_cipher_string); def_cipher_string = NULL;
1982         if( check_cipher_algo(opt.def_cipher_algo) )
1983             log_error(_("selected cipher algorithm is invalid\n"));
1984     }
1985     if( def_digest_string ) {
1986         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
1987         m_free(def_digest_string); def_digest_string = NULL;
1988         if( check_digest_algo(opt.def_digest_algo) )
1989             log_error(_("selected digest algorithm is invalid\n"));
1990     }
1991     if( def_compress_string ) {
1992         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
1993         m_free(def_compress_string); def_compress_string = NULL;
1994         if( check_compress_algo(opt.def_compress_algo) )
1995             log_error(_("selected compression algorithm is invalid\n"));
1996     }
1997     if( cert_digest_string ) {
1998         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
1999         m_free(cert_digest_string); cert_digest_string = NULL;
2000         if( check_digest_algo(opt.cert_digest_algo) )
2001             log_error(_("selected certification digest algorithm is invalid\n"));
2002     }
2003     if( s2k_cipher_string ) {
2004         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2005         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2006         if( check_cipher_algo(opt.s2k_cipher_algo) )
2007             log_error(_("selected cipher algorithm is invalid\n"));
2008     }
2009     if( s2k_digest_string ) {
2010         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2011         m_free(s2k_digest_string); s2k_digest_string = NULL;
2012         if( check_digest_algo(opt.s2k_digest_algo) )
2013             log_error(_("selected digest algorithm is invalid\n"));
2014     }
2015     if( opt.completes_needed < 1 )
2016         log_error(_("completes-needed must be greater than 0\n"));
2017     if( opt.marginals_needed < 2 )
2018         log_error(_("marginals-needed must be greater than 1\n"));
2019     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2020         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2021     switch( opt.s2k_mode ) {
2022       case 0:
2023         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2024         break;
2025       case 1: case 3: break;
2026       default:
2027         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2028     }
2029
2030     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2031       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2032
2033     /* This isn't actually needed, but does serve to error out if the
2034        string is invalid. */
2035     if(opt.def_preference_list &&
2036         keygen_set_std_prefs(opt.def_preference_list,0))
2037       log_error(_("invalid default preferences\n"));
2038
2039     /* We provide defaults for the personal digest list */
2040     if(!pers_digest_list)
2041       pers_digest_list="h2";
2042
2043     if(pers_cipher_list &&
2044        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2045       log_error(_("invalid personal cipher preferences\n"));
2046
2047     if(pers_digest_list &&
2048        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2049       log_error(_("invalid personal digest preferences\n"));
2050
2051     if(pers_compress_list &&
2052        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2053       log_error(_("invalid personal compress preferences\n"));
2054
2055     if( log_get_errorcount(0) )
2056         g10_exit(2);
2057
2058     /* set the random seed file */
2059     if( use_random_seed ) {
2060         char *p = make_filename(opt.homedir, "random_seed", NULL );
2061         set_random_seed_file(p);
2062         m_free(p);
2063     }
2064
2065     if( !cmd && opt.fingerprint && !with_fpr ) {
2066         set_cmd( &cmd, aListKeys);
2067     }
2068
2069     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2070         if( cmd == aKModeC ) {
2071             opt.fingerprint = 1;
2072             cmd = aKMode;
2073         }
2074         opt.list_sigs = 0;
2075         if( opt.verbose > 2 )
2076             opt.check_sigs++;
2077         if( opt.verbose > 1 )
2078             opt.list_sigs++;
2079
2080         opt.verbose = opt.verbose > 1;
2081         g10_opt_verbose = opt.verbose;
2082     }
2083
2084     /* Compression algorithm 0 means no compression at all */
2085     if( opt.def_compress_algo == 0)
2086         opt.compress = 0;
2087
2088     /* kludge to let -sat generate a clear text signature */
2089     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2090         cmd = aClearsign;
2091
2092     if( opt.verbose > 1 )
2093         set_packet_list_mode(1);
2094
2095     /* Add the keyrings, but not for some special commands and not in
2096        case of "-kvv userid keyring".  Also avoid adding the secret
2097        keyring for a couple of commands to avoid unneeded access in
2098        case the secrings are stored on a floppy */
2099     if( cmd != aDeArmor && cmd != aEnArmor
2100         && !(cmd == aKMode && argc == 2 ) ) 
2101       {
2102         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2103             && cmd != aVerify && cmd != aVerifyFiles
2104             && cmd != aSym)
2105           {
2106             if (!sec_nrings || default_keyring) /* add default secret rings */
2107               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2108             for (sl = sec_nrings; sl; sl = sl->next)
2109               keydb_add_resource ( sl->d, 0, 1 );
2110           }
2111         if( !nrings || default_keyring )  /* add default ring */
2112             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2113         for(sl = nrings; sl; sl = sl->next )
2114             keydb_add_resource ( sl->d, sl->flags, 0 );
2115       }
2116     FREE_STRLIST(nrings);
2117     FREE_STRLIST(sec_nrings);
2118
2119
2120     if( pwfd != -1 )  /* read the passphrase now. */
2121         read_passphrase_from_fd( pwfd );
2122
2123     fname = argc? *argv : NULL;
2124
2125     switch( cmd ) {
2126       case aPrimegen:
2127       case aPrintMD:
2128       case aPrintMDs:
2129       case aGenRandom:
2130       case aDeArmor:
2131       case aEnArmor:
2132       case aFixTrustDB:
2133         break;
2134       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2135       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2136       default: rc = setup_trustdb(1, trustdb_name ); break;
2137     }
2138     if( rc )
2139         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2140
2141
2142     switch (cmd) {
2143       case aStore: 
2144       case aSym:  
2145       case aSign: 
2146       case aSignSym: 
2147       case aClearsign: 
2148         if (!opt.quiet && any_explicit_recipient)
2149           log_info (_("WARNING: recipients (-r) given "
2150                       "without using public key encryption\n"));
2151         break;
2152       default:
2153         break;
2154     }
2155
2156     switch( cmd ) {
2157       case aStore: /* only store the file */
2158         if( argc > 1 )
2159             wrong_args(_("--store [filename]"));
2160         if( (rc = encode_store(fname)) )
2161             log_error_f( print_fname_stdin(fname),
2162                         "store failed: %s\n", g10_errstr(rc) );
2163         break;
2164       case aSym: /* encrypt the given file only with the symmetric cipher */
2165         if( argc > 1 )
2166             wrong_args(_("--symmetric [filename]"));
2167         if( (rc = encode_symmetric(fname)) )
2168             log_error_f(print_fname_stdin(fname),
2169                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2170         break;
2171
2172       case aEncr: /* encrypt the given file */
2173         if( argc > 1 )
2174             wrong_args(_("--encrypt [filename]"));
2175         if( (rc = encode_crypt(fname,remusr)) )
2176             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2177         break;
2178
2179       case aEncrFiles: /* encrypt the given files */
2180         encode_crypt_files(argc, argv, remusr);
2181         break;
2182           
2183       case aSign: /* sign the given file */
2184         sl = NULL;
2185         if( detached_sig ) { /* sign all files */
2186             for( ; argc; argc--, argv++ )
2187                 add_to_strlist( &sl, *argv );
2188         }
2189         else {
2190             if( argc > 1 )
2191                 wrong_args(_("--sign [filename]"));
2192             if( argc ) {
2193                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2194                 strcpy(sl->d, fname);
2195             }
2196         }
2197         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2198             log_error("signing failed: %s\n", g10_errstr(rc) );
2199         free_strlist(sl);
2200         break;
2201
2202       case aSignEncr: /* sign and encrypt the given file */
2203         if( argc > 1 )
2204             wrong_args(_("--sign --encrypt [filename]"));
2205         if( argc ) {
2206             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2207             strcpy(sl->d, fname);
2208         }
2209         else
2210             sl = NULL;
2211         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2212             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2213         free_strlist(sl);
2214         break;
2215
2216       case aSignSym: /* sign and conventionally encrypt the given file */
2217         if (argc > 1)
2218             wrong_args(_("--sign --symmetric [filename]"));
2219         rc = sign_symencrypt_file (fname, locusr);
2220         if (rc)
2221             log_error("%s: sign+symmetric failed: %s\n",
2222                       print_fname_stdin(fname), g10_errstr(rc) );
2223         break;
2224
2225       case aClearsign: /* make a clearsig */
2226         if( argc > 1 )
2227             wrong_args(_("--clearsign [filename]"));
2228         if( (rc = clearsign_file(fname, locusr, NULL)) )
2229             log_error("%s: clearsign failed: %s\n",
2230                       print_fname_stdin(fname), g10_errstr(rc) );
2231         break;
2232
2233       case aVerify:
2234         if( (rc = verify_signatures( argc, argv ) ))
2235             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2236         break;
2237
2238       case aVerifyFiles:
2239         if( (rc = verify_files( argc, argv ) ))
2240             log_error("verify files failed: %s\n", g10_errstr(rc) );
2241         break;
2242
2243       case aDecrypt:
2244         if( argc > 1 )
2245             wrong_args(_("--decrypt [filename]"));
2246         if( (rc = decrypt_message( fname ) ))
2247             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2248         break;
2249
2250       case aDecryptFiles:
2251         decrypt_messages(argc, argv);
2252         break;
2253             
2254       case aSignKey: /* sign the key given as argument */
2255         if( argc != 1 )
2256             wrong_args(_("--sign-key user-id"));
2257         username = make_username( fname );
2258         keyedit_menu(fname, locusr, NULL, 1 );
2259         m_free(username);
2260         break;
2261
2262       case aLSignKey:
2263         if( argc != 1 )
2264             wrong_args(_("--lsign-key user-id"));
2265         username = make_username( fname );
2266         keyedit_menu(fname, locusr, NULL, 2 );
2267         m_free(username);
2268         break;
2269
2270       case aNRSignKey:
2271         if( argc != 1 )
2272             wrong_args(_("--nrsign-key user-id"));
2273         username = make_username( fname );
2274         keyedit_menu(fname, locusr, NULL, 3 );
2275         m_free(username);
2276         break;
2277
2278       case aNRLSignKey:
2279         if( argc != 1 )
2280             wrong_args(_("--nrlsign-key user-id"));
2281         username = make_username( fname );
2282         keyedit_menu(fname, locusr, NULL, 4 );
2283         m_free(username);
2284         break;
2285
2286       case aEditKey: /* Edit a key signature */
2287         if( !argc )
2288             wrong_args(_("--edit-key user-id [commands]"));
2289         username = make_username( fname );
2290         if( argc > 1 ) {
2291             sl = NULL;
2292             for( argc--, argv++ ; argc; argc--, argv++ )
2293                 append_to_strlist( &sl, *argv );
2294             keyedit_menu( username, locusr, sl, 0 );
2295             free_strlist(sl);
2296         }
2297         else
2298             keyedit_menu(username, locusr, NULL, 0 );
2299         m_free(username);
2300         break;
2301
2302       case aDeleteKeys:
2303       case aDeleteSecretKeys:
2304       case aDeleteSecretAndPublicKeys:
2305         sl = NULL;
2306         /* I'm adding these in reverse order as add_to_strlist2
2307            reverses them again, and it's easier to understand in the
2308            proper order :) */
2309         for( ; argc; argc-- )
2310           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2311         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2312         free_strlist(sl);
2313         break;
2314
2315       case aCheckKeys:
2316         opt.check_sigs = 1;
2317       case aListSigs:
2318         opt.list_sigs = 1;
2319       case aListKeys:
2320         sl = NULL;
2321         for( ; argc; argc--, argv++ )
2322             add_to_strlist2( &sl, *argv, utf8_strings );
2323         public_key_list( sl );
2324         free_strlist(sl);
2325         break;
2326       case aListSecretKeys:
2327         sl = NULL;
2328         for( ; argc; argc--, argv++ )
2329             add_to_strlist2( &sl, *argv, utf8_strings );
2330         secret_key_list( sl );
2331         free_strlist(sl);
2332         break;
2333
2334       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2335         if( argc < 2 ) { /* -kv [userid] */
2336             sl = NULL;
2337             if (argc && **argv)
2338                 add_to_strlist2( &sl, *argv, utf8_strings );
2339             public_key_list( sl );
2340             free_strlist(sl);
2341         }
2342         else if( argc == 2 ) { /* -kv userid keyring */
2343             if( access( argv[1], R_OK ) ) {
2344                 log_error(_("can't open %s: %s\n"),
2345                                print_fname_stdin(argv[1]), strerror(errno));
2346             }
2347             else {
2348                 /* add keyring (default keyrings are not registered in this
2349                  * special case */
2350                 keydb_add_resource( argv[1], 0, 0 );
2351                 sl = NULL;
2352                 if (**argv)
2353                     add_to_strlist2( &sl, *argv, utf8_strings );
2354                 public_key_list( sl );
2355                 free_strlist(sl);
2356             }
2357         }
2358         else
2359             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2360         break;
2361
2362       case aKeygen: /* generate a key */
2363         if( opt.batch ) {
2364             if( argc > 1 )
2365                 wrong_args("--gen-key [parameterfile]");
2366             generate_keypair( argc? *argv : NULL );
2367         }
2368         else {
2369             if( argc )
2370                 wrong_args("--gen-key");
2371             generate_keypair(NULL);
2372         }
2373         break;
2374
2375       case aFastImport:
2376         opt.import_options |= IMPORT_FAST_IMPORT;
2377       case aImport:
2378         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2379         break;
2380
2381       case aExport:
2382       case aExportAll:
2383       case aSendKeys:
2384       case aRecvKeys:
2385         sl = NULL;
2386         for( ; argc; argc--, argv++ )
2387             add_to_strlist2( &sl, *argv, utf8_strings );
2388         if( cmd == aSendKeys )
2389             keyserver_export( sl );
2390         else if( cmd == aRecvKeys )
2391             keyserver_import( sl );
2392         else
2393             export_pubkeys( sl, opt.export_options );
2394         free_strlist(sl);
2395         break;
2396
2397      case aSearchKeys:
2398         sl = NULL;
2399         for( ; argc; argc--, argv++ )
2400           append_to_strlist2( &sl, *argv, utf8_strings );
2401
2402         keyserver_search( sl );
2403         free_strlist(sl);
2404         break;
2405
2406       case aRefreshKeys:
2407         sl = NULL;
2408         for( ; argc; argc--, argv++ )
2409             add_to_strlist2( &sl, *argv, utf8_strings );
2410         keyserver_refresh(sl);
2411         free_strlist(sl);
2412         break;
2413
2414       case aExportSecret:
2415         sl = NULL;
2416         for( ; argc; argc--, argv++ )
2417             add_to_strlist2( &sl, *argv, utf8_strings );
2418         export_seckeys( sl );
2419         free_strlist(sl);
2420         break;
2421
2422       case aExportSecretSub:
2423         sl = NULL;
2424         for( ; argc; argc--, argv++ )
2425             add_to_strlist2( &sl, *argv, utf8_strings );
2426         export_secsubkeys( sl );
2427         free_strlist(sl);
2428         break;
2429
2430       case aGenRevoke:
2431         if( argc != 1 )
2432             wrong_args("--gen-revoke user-id");
2433         username =  make_username(*argv);
2434         gen_revoke( username );
2435         m_free( username );
2436         break;
2437
2438       case aDesigRevoke:
2439         if( argc != 1 )
2440             wrong_args("--desig-revoke user-id");
2441         username =  make_username(*argv);
2442         gen_desig_revoke( username );
2443         m_free( username );
2444         break;
2445
2446       case aDeArmor:
2447         if( argc > 1 )
2448             wrong_args("--dearmor [file]");
2449         rc = dearmor_file( argc? *argv: NULL );
2450         if( rc )
2451             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2452         break;
2453
2454       case aEnArmor:
2455         if( argc > 1 )
2456             wrong_args("--enarmor [file]");
2457         rc = enarmor_file( argc? *argv: NULL );
2458         if( rc )
2459             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2460         break;
2461
2462
2463       case aPrimegen:
2464         {   int mode = argc < 2 ? 0 : atoi(*argv);
2465
2466             if( mode == 1 && argc == 2 ) {
2467                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2468             }
2469             else if( mode == 2 && argc == 3 ) {
2470                 mpi_print( stdout, generate_elg_prime(
2471                                              0, atoi(argv[1]),
2472                                              atoi(argv[2]), NULL,NULL ), 1);
2473             }
2474             else if( mode == 3 && argc == 3 ) {
2475                 MPI *factors;
2476                 mpi_print( stdout, generate_elg_prime(
2477                                              1, atoi(argv[1]),
2478                                              atoi(argv[2]), NULL,&factors ), 1);
2479                 putchar('\n');
2480                 mpi_print( stdout, factors[0], 1 ); /* print q */
2481             }
2482             else if( mode == 4 && argc == 3 ) {
2483                 MPI g = mpi_alloc(1);
2484                 mpi_print( stdout, generate_elg_prime(
2485                                                  0, atoi(argv[1]),
2486                                                  atoi(argv[2]), g, NULL ), 1);
2487                 putchar('\n');
2488                 mpi_print( stdout, g, 1 );
2489                 mpi_free(g);
2490             }
2491             else
2492                 wrong_args("--gen-prime mode bits [qbits] ");
2493             putchar('\n');
2494         }
2495         break;
2496
2497       case aGenRandom:
2498         {
2499             int level = argc ? atoi(*argv):0;
2500             int count = argc > 1 ? atoi(argv[1]): 0;
2501             int endless = !count;
2502
2503             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2504                 wrong_args("--gen-random 0|1|2 [count]");
2505
2506             while( endless || count ) {
2507                 byte *p;
2508                 /* Wee need a multiple of 3, so that in case of
2509                    armored output we get a correct string.  No
2510                    linefolding is done, as it is best to levae this to
2511                    other tools */
2512                 size_t n = !endless && count < 99? count : 99;
2513
2514                 p = get_random_bits( n*8, level, 0);
2515               #ifdef HAVE_DOSISH_SYSTEM
2516                 setmode ( fileno(stdout), O_BINARY );
2517               #endif
2518                 if (opt.armor) {
2519                     char *tmp = make_radix64_string (p, n);
2520                     fputs (tmp, stdout);
2521                     m_free (tmp);
2522                     if (n%3 == 1)
2523                       putchar ('=');
2524                     if (n%3)
2525                       putchar ('=');
2526                 } else {
2527                     fwrite( p, n, 1, stdout );
2528                 }
2529                 m_free(p);
2530                 if( !endless )
2531                     count -= n;
2532             }
2533             if (opt.armor)
2534                 putchar ('\n');
2535         }
2536         break;
2537
2538       case aPrintMD:
2539         if( argc < 1)
2540             wrong_args("--print-md algo [files]");
2541         {
2542             int all_algos = (**argv=='*' && !(*argv)[1]);
2543             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2544
2545             if( !algo && !all_algos )
2546                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2547             else {
2548                 argc--; argv++;
2549                 if( !argc )
2550                     print_mds(NULL, algo);
2551                 else {
2552                     for(; argc; argc--, argv++ )
2553                         print_mds(*argv, algo);
2554                 }
2555             }
2556         }
2557         break;
2558
2559       case aPrintMDs: /* old option */
2560         if( !argc )
2561             print_mds(NULL,0);
2562         else {
2563             for(; argc; argc--, argv++ )
2564                 print_mds(*argv,0);
2565         }
2566         break;
2567
2568       case aListTrustDB:
2569         if( !argc )
2570             list_trustdb(NULL);
2571         else {
2572             for( ; argc; argc--, argv++ )
2573                 list_trustdb( *argv );
2574         }
2575         break;
2576
2577       case aUpdateTrustDB:
2578         if( argc )
2579             wrong_args("--update-trustdb");
2580         update_trustdb();
2581         break;
2582
2583       case aCheckTrustDB:
2584         /* Old versions allowed for arguments - ignore them */
2585         check_trustdb();
2586         break;
2587
2588       case aFixTrustDB:
2589         log_error("this command is not yet implemented.\n");
2590         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2591         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2592         break;
2593
2594       case aListTrustPath:
2595         if( !argc )
2596             wrong_args("--list-trust-path <user-ids>");
2597         for( ; argc; argc--, argv++ ) {
2598             username = make_username( *argv );
2599             list_trust_path( username );
2600             m_free(username);
2601         }
2602         break;
2603
2604       case aExportOwnerTrust:
2605         if( argc )
2606             wrong_args("--export-ownertrust");
2607         export_ownertrust();
2608         break;
2609
2610       case aImportOwnerTrust:
2611         if( argc > 1 )
2612             wrong_args("--import-ownertrust [file]");
2613         import_ownertrust( argc? *argv:NULL );
2614         break;
2615       
2616       case aPipeMode:
2617         if ( argc )
2618             wrong_args ("--pipemode");
2619         run_in_pipemode ();
2620         break;
2621
2622       case aRebuildKeydbCaches:
2623         if (argc)
2624             wrong_args ("--rebuild-keydb-caches");
2625         keydb_rebuild_caches ();
2626         break;
2627
2628       case aListPackets:
2629         opt.list_packets=2;
2630       default:
2631         if( argc > 1 )
2632             wrong_args(_("[filename]"));
2633         /* Issue some output for the unix newbie */
2634         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2635                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2636             log_info(_("Go ahead and type your message ...\n"));
2637
2638         if( !(a = iobuf_open(fname)) )
2639             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2640         else {
2641
2642             if( !opt.no_armor ) {
2643                 if( use_armor_filter( a ) ) {
2644                     memset( &afx, 0, sizeof afx);
2645                     iobuf_push_filter( a, armor_filter, &afx );
2646                 }
2647             }
2648             if( cmd == aListPackets ) {
2649                 set_packet_list_mode(1);
2650                 opt.list_packets=1;
2651             }
2652             rc = proc_packets(NULL, a );
2653             if( rc )
2654                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2655             iobuf_close(a);
2656         }
2657         break;
2658     }
2659
2660     /* cleanup */
2661     FREE_STRLIST(remusr);
2662     FREE_STRLIST(locusr);
2663     g10_exit(0);
2664     return 8; /*NEVER REACHED*/
2665 }
2666
2667
2668 void
2669 g10_exit( int rc )
2670 {
2671     update_random_seed_file();
2672     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2673         m_print_stats("on exit");
2674         random_dump_stats();
2675     }
2676     if( opt.debug )
2677         secmem_dump_stats();
2678     secmem_term();
2679     rc = rc? rc : log_get_errorcount(0)? 2 :
2680                         g10_errors_seen? 1 : 0;
2681     exit(rc );
2682 }
2683
2684
2685
2686
2687 static void
2688 print_hex( byte *p, size_t n )
2689 {
2690     int i;
2691
2692     if( n == 20 ) {
2693         for(i=0; i < n ; i++, i++, p += 2 ) {
2694             if( i )
2695                 putchar(' ');
2696             if( i == 10 )
2697                 putchar(' ');
2698             printf("%02X%02X", *p, p[1] );
2699         }
2700     }
2701     else if( n == 24 ) {
2702         for(i=0; i < n ; i += 4, p += 4 ) {
2703             if( i )
2704                 putchar(' ');
2705             if( i == 12 )
2706                 putchar(' ');
2707             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
2708         }
2709     }
2710     else {
2711         for(i=0; i < n ; i++, p++ ) {
2712             if( i )
2713                 putchar(' ');
2714             if( i && !(i%8) )
2715                 putchar(' ');
2716             printf("%02X", *p );
2717         }
2718     }
2719 }
2720
2721 static void
2722 print_hashline( MD_HANDLE md, int algo, const char *fname )
2723 {
2724     int i, n;
2725     const byte *p;
2726     
2727     if ( fname ) {
2728         for (p = fname; *p; p++ ) {
2729             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2730                 printf("%%%02X", *p );
2731             else 
2732                 putchar( *p );
2733         }
2734     }
2735     putchar(':');
2736     printf("%d:", algo );
2737     p = md_read( md, algo );
2738     n = md_digest_length(algo);
2739     for(i=0; i < n ; i++, p++ ) 
2740         printf("%02X", *p );
2741     putchar(':');
2742     putchar('\n');
2743 }
2744
2745 static void
2746 print_mds( const char *fname, int algo )
2747 {
2748     FILE *fp;
2749     char buf[1024];
2750     size_t n;
2751     MD_HANDLE md;
2752     char *pname;
2753
2754     if( !fname ) {
2755         fp = stdin;
2756       #ifdef HAVE_DOSISH_SYSTEM
2757         setmode ( fileno(fp) , O_BINARY );
2758       #endif
2759         pname = m_strdup("[stdin]: ");
2760     }
2761     else {
2762         pname = m_alloc(strlen(fname)+3);
2763         strcpy(stpcpy(pname,fname),": ");
2764         fp = fopen( fname, "rb" );
2765     }
2766     if( !fp ) {
2767         log_error("%s%s\n", pname, strerror(errno) );
2768         m_free(pname);
2769         return;
2770     }
2771
2772     md = md_open( 0, 0 );
2773     if( algo )
2774         md_enable( md, algo );
2775     else {
2776         md_enable( md, DIGEST_ALGO_MD5 );
2777         md_enable( md, DIGEST_ALGO_SHA1 );
2778         md_enable( md, DIGEST_ALGO_RMD160 );
2779         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2780             md_enable( md, DIGEST_ALGO_TIGER );
2781     }
2782
2783     while( (n=fread( buf, 1, DIM(buf), fp )) )
2784         md_write( md, buf, n );
2785     if( ferror(fp) )
2786         log_error("%s%s\n", pname, strerror(errno) );
2787     else {
2788         md_final(md);
2789         if ( opt.with_colons ) {
2790             if ( algo ) 
2791                 print_hashline( md, algo, fname );
2792             else {
2793                 print_hashline( md, DIGEST_ALGO_MD5, fname );
2794                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
2795                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
2796                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) 
2797                     print_hashline( md, DIGEST_ALGO_TIGER, fname );
2798             }
2799         }
2800         else {
2801             if( algo ) {
2802                 if( fname )
2803                     fputs( pname, stdout );
2804                 print_hex(md_read(md, algo), md_digest_length(algo) );
2805             }
2806             else {
2807                 printf(  "%s   MD5 = ", fname?pname:"" );
2808                 print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
2809                 printf("\n%s  SHA1 = ", fname?pname:""  );
2810                 print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
2811                 printf("\n%sRMD160 = ", fname?pname:""  );
2812                 print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
2813                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
2814                     printf("\n%s TIGER = ", fname?pname:""  );
2815                     print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
2816                 }
2817             }
2818             putchar('\n');
2819         }
2820     }
2821     md_close(md);
2822
2823     if( fp != stdin )
2824         fclose(fp);
2825 }
2826
2827
2828 /****************
2829  * Check the supplied name,value string and add it to the notation
2830  * data to be used for signatures.  which==0 for sig notations, and 1
2831  * for cert notations.
2832 */
2833 static void
2834 add_notation_data( const char *string, int which )
2835 {
2836     const char *s;
2837     STRLIST sl,*notation_data;
2838     int critical=0;
2839     int highbit=0;
2840     int saw_at=0;
2841
2842     if(which)
2843       notation_data=&opt.cert_notation_data;
2844     else
2845       notation_data=&opt.sig_notation_data;
2846
2847     if( *string == '!' ) {
2848         critical = 1;
2849         string++;
2850     }
2851
2852     /* If and when the IETF assigns some official name tags, we'll
2853        have to add them here. */
2854
2855     for( s=string ; *s != '='; s++ )
2856       {
2857         if( *s=='@')
2858           saw_at=1;
2859
2860         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
2861           {
2862             log_error(_("a notation name must have only printable characters "
2863                         "or spaces, and end with an '='\n") );
2864             return;
2865           }
2866       }
2867
2868     if(!saw_at && !opt.expert)
2869       {
2870         log_error(
2871                 _("a user notation name must contain the '@' character\n"));
2872         return;
2873       }
2874
2875     /* we only support printable text - therefore we enforce the use
2876      * of only printable characters (an empty value is valid) */
2877     for( s++; *s ; s++ ) {
2878         if( iscntrl(*s) ) {
2879             log_error(_("a notation value must not use "
2880                         "any control characters\n") );
2881             return;
2882         }
2883         else if( *s & 0x80 )
2884             highbit = 1;
2885     }
2886
2887     if( highbit )   /* must use UTF8 encoding */
2888         sl = add_to_strlist2( notation_data, string, utf8_strings );
2889     else
2890         sl = add_to_strlist( notation_data, string );
2891
2892     if( critical )
2893         sl->flags |= 1;
2894 }
2895
2896
2897 static void
2898 add_policy_url( const char *string, int which )
2899 {
2900   int i,critical=0;
2901   STRLIST sl;
2902
2903   if(*string=='!')
2904     {
2905       string++;
2906       critical=1;
2907     }
2908
2909   for(i=0;i<strlen(string);i++)
2910     if(string[i]&0x80 || iscntrl(string[i]))
2911       break;
2912
2913   if(i==0 || i<strlen(string))
2914     {
2915       if(which)
2916         log_error(_("the given certification policy URL is invalid\n"));
2917       else
2918         log_error(_("the given signature policy URL is invalid\n"));
2919     }
2920
2921   if(which)
2922     sl=add_to_strlist( &opt.cert_policy_url, string );
2923   else
2924     sl=add_to_strlist( &opt.sig_policy_url, string );
2925
2926   if(critical)
2927     sl->flags |= 1;    
2928 }