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