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