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