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