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