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