* g10.c (add_group): Use '=' to separate group name from group members.
[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 = sign found in group definition \"%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     opt.keyserver_options.include_revoked=1;
1096 #if defined (__MINGW32__) || defined (__CYGWIN32__)
1097     opt.homedir = read_w32_registry_string( NULL, "Software\\GNU\\GnuPG", "HomeDir" );
1098 #else
1099     opt.homedir = getenv("GNUPGHOME");
1100 #endif
1101     if( !opt.homedir || !*opt.homedir ) {
1102         opt.homedir = GNUPG_HOMEDIR;
1103     }
1104
1105     /* check whether we have a config file on the commandline */
1106     orig_argc = argc;
1107     orig_argv = argv;
1108     pargs.argc = &argc;
1109     pargs.argv = &argv;
1110     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1111     while( arg_parse( &pargs, opts) ) {
1112         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1113             parse_debug++;
1114         else if( pargs.r_opt == oOptions ) {
1115             /* yes there is one, so we do not try the default one, but
1116              * read the option file when it is encountered at the commandline
1117              */
1118             default_config = 0;
1119         }
1120         else if( pargs.r_opt == oNoOptions )
1121             default_config = 0; /* --no-options */
1122         else if( pargs.r_opt == oHomedir )
1123             opt.homedir = pargs.r.ret_str;
1124         else if( pargs.r_opt == oNoPermissionWarn )
1125             opt.no_perm_warn=1;
1126       #ifdef USE_SHM_COPROCESSING
1127         else if( pargs.r_opt == oRunAsShmCP ) {
1128             /* does not make sense in a options file, we do it here,
1129              * so that we are the able to drop setuid as soon as possible */
1130             opt.shm_coprocess = 1;
1131             requested_shm_size = pargs.r.ret_ulong;
1132         }
1133         else if ( pargs.r_opt == oStatusFD ) {
1134             /* this is needed to ensure that the status-fd filedescriptor is
1135              * initialized when init_shm_coprocessing() is called */
1136             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1137         }
1138       #endif
1139     }
1140
1141 #ifdef HAVE_DOSISH_SYSTEM
1142     if ( strchr (opt.homedir,'\\') ) {
1143         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
1144         const char *s = opt.homedir;
1145         for (d=buf,s=opt.homedir; *s; s++)
1146             *d++ = *s == '\\'? '/': *s;
1147         *d = 0;
1148         opt.homedir = buf;
1149     }
1150 #endif
1151 #ifdef USE_SHM_COPROCESSING
1152     if( opt.shm_coprocess ) {
1153         init_shm_coprocessing(requested_shm_size, 1 );
1154     }
1155 #endif
1156     /* initialize the secure memory. */
1157     secmem_init( 16384 );
1158     maybe_setuid = 0;
1159     /* Okay, we are now working under our real uid */
1160
1161     set_native_charset (NULL); /* Try to auto set the character set */
1162
1163     if( default_config )
1164       {
1165         configname = make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1166         if (!access (configname, R_OK))
1167           { /* Print a warning when both config files are present. */
1168             char *p = make_filename(opt.homedir, "options", NULL );
1169             if (!access (p, R_OK))
1170               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1171             m_free (p);
1172           }
1173         else
1174           { /* Keep on using the old default one. */
1175             m_free (configname);
1176             configname = make_filename(opt.homedir, "options", NULL );
1177           }
1178       }
1179     argc = orig_argc;
1180     argv = orig_argv;
1181     pargs.argc = &argc;
1182     pargs.argv = &argv;
1183     pargs.flags=  1;  /* do not remove the args */
1184
1185     /* By this point we have a homedir, and cannot change it. */
1186     check_permissions(opt.homedir,0);
1187
1188   next_pass:
1189     if( configname ) {
1190       if(check_permissions(configname,1))
1191         {
1192           /* If any options file is unsafe, then disable any external
1193              programs for keyserver calls or photo IDs.  Since the
1194              external program to call is set in the options file, a
1195              unsafe options file can lead to an arbitrary program
1196              being run. */
1197
1198           opt.exec_disable=1;
1199         }
1200
1201         configlineno = 0;
1202         configfp = fopen( configname, "r" );
1203         if( !configfp ) {
1204             if( default_config ) {
1205                 if( parse_debug )
1206                     log_info(_("NOTE: no default option file `%s'\n"),
1207                                                             configname );
1208             }
1209             else {
1210                 log_error(_("option file `%s': %s\n"),
1211                                     configname, strerror(errno) );
1212                 g10_exit(2);
1213             }
1214             m_free(configname); configname = NULL;
1215         }
1216         if( parse_debug && configname )
1217             log_info(_("reading options from `%s'\n"), configname );
1218         default_config = 0;
1219     }
1220
1221     while( optfile_parse( configfp, configname, &configlineno,
1222                                                 &pargs, opts) ) {
1223         switch( pargs.r_opt ) {
1224           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1225           case aListPackets: set_cmd( &cmd, aListPackets); break;
1226           case aImport: set_cmd( &cmd, aImport); break;
1227           case aFastImport: set_cmd( &cmd, aFastImport); break;
1228           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1229           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1230           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1231           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1232           case aExport: set_cmd( &cmd, aExport); break;
1233           case aExportAll: set_cmd( &cmd, aExportAll); break;
1234           case aListKeys: set_cmd( &cmd, aListKeys); break;
1235           case aListSigs: set_cmd( &cmd, aListSigs); break;
1236           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1237           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1238           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1239                                                         greeting=1; break;
1240           case aDeleteSecretAndPublicKeys:
1241             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1242             greeting=1; 
1243             break;
1244           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1245
1246           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1247           case aSym: set_cmd( &cmd, aSym); break;
1248
1249           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1250           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1251
1252           case aEncr: set_cmd( &cmd, aEncr); break;
1253           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1254           case aSign: set_cmd( &cmd, aSign );  break;
1255           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1256           case aSignKey: set_cmd( &cmd, aSignKey); break;
1257           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1258           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1259           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1260           case aStore: set_cmd( &cmd, aStore); break;
1261           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1262           case aClearsign: set_cmd( &cmd, aClearsign); break;
1263           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1264           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1265           case aVerify: set_cmd( &cmd, aVerify); break;
1266           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1267           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1268           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1269           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1270           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1271           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1272           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1273           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1274           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1275           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1276           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1277           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1278           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1279           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1280           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1281           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1282
1283           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1284           case oOutput: opt.outfile = pargs.r.ret_str; break;
1285           case oQuiet: opt.quiet = 1; break;
1286           case oNoTTY: tty_no_terminal(1); break;
1287           case oDryRun: opt.dry_run = 1; break;
1288           case oInteractive: opt.interactive = 1; break;
1289           case oVerbose: g10_opt_verbose++;
1290                     opt.verbose++; opt.list_sigs=1; break;
1291           case oKOption: set_cmd( &cmd, aKMode ); break;
1292
1293           case oBatch: opt.batch = 1; nogreeting = 1; break;
1294           case oUseAgent:
1295 #ifndef __riscos__
1296             opt.use_agent = 1;
1297 #else /* __riscos__ */
1298             opt.use_agent = 0;
1299             not_implemented("use-agent");
1300 #endif /* __riscos__ */
1301             break;
1302           case oNoUseAgent: opt.use_agent = 0; break;
1303           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1304           case oAnswerYes: opt.answer_yes = 1; break;
1305           case oAnswerNo: opt.answer_no = 1; break;
1306           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1307           case oShowKeyring: opt.show_keyring = 1; break;
1308           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1309           case oDebugAll: opt.debug = ~0; break;
1310           case oStatusFD:
1311             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1312             break;
1313 #ifdef __riscos__
1314           case oStatusFile:
1315             set_status_fd( iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1316             break;
1317 #endif /* __riscos__ */
1318           case oAttributeFD:
1319             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1320             break;
1321 #ifdef __riscos__
1322           case oAttributeFile:
1323             set_attrib_fd(iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1324             break;
1325 #endif /* __riscos__ */
1326           case oLoggerFD:
1327             log_set_logfile( NULL,
1328                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1329             break;
1330 #ifdef __riscos__
1331           case oLoggerFile:
1332             log_set_logfile( NULL,
1333                              iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1334             break;
1335 #endif /* __riscos__ */
1336           case oWithFingerprint:
1337             opt.with_fingerprint = 1;
1338             with_fpr=1; /*fall thru*/
1339           case oFingerprint: opt.fingerprint++; break;
1340           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1341           case oOptions:
1342             /* config files may not be nested (silently ignore them) */
1343             if( !configfp ) {
1344                 m_free(configname);
1345                 configname = m_strdup(pargs.r.ret_str);
1346                 goto next_pass;
1347             }
1348             break;
1349           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1350           case oNoDefKeyring: default_keyring = 0; break;
1351           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1352           case oNoGreeting: nogreeting = 1; break;
1353           case oNoVerbose: g10_opt_verbose = 0;
1354                            opt.verbose = 0; opt.list_sigs=0; break;
1355           case oQuickRandom: quick_random_gen(1); break;
1356           case oSKComments: opt.sk_comments=1; break;
1357           case oNoSKComments: opt.sk_comments=0; break;
1358           case oNoVersion: opt.no_version=1; break;
1359           case oEmitVersion: opt.no_version=0; break;
1360           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1361           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1362           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1363           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1364           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1365           case oDefRecipient:
1366                     if( *pargs.r.ret_str )
1367                         opt.def_recipient = make_username(pargs.r.ret_str);
1368                     break;
1369           case oDefRecipientSelf:
1370                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1371                     opt.def_recipient_self = 1;
1372                     break;
1373           case oNoDefRecipient:
1374                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1375                     opt.def_recipient_self = 0;
1376                     break;
1377           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1378           case oHomedir: break;
1379           case oNoBatch: opt.batch = 0; break;
1380           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1381           case oWithColons: opt.with_colons=':'; break;
1382
1383           case oSkipVerify: opt.skip_verify=1; break;
1384           case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
1385           case oCompressKeys: opt.compress_keys = 1; break;
1386           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1387           case oAlwaysTrust: opt.always_trust = 1; break;
1388           case oLoadExtension:
1389 #ifndef __riscos__
1390 #ifdef USE_DYNAMIC_LINKING
1391             if(check_permissions(pargs.r.ret_str,2))
1392               log_info(_("cipher extension \"%s\" not loaded due to "
1393                          "unsafe permissions\n"),pargs.r.ret_str);
1394             else
1395               register_cipher_extension(orig_argc? *orig_argv:NULL,
1396                                         pargs.r.ret_str);
1397 #endif
1398 #else /* __riscos__ */
1399             not_implemented("load-extension");
1400 #endif /* __riscos__ */
1401             break;
1402           case oRFC1991:
1403             opt.rfc1991 = 1;
1404             opt.rfc2440 = 0;
1405             opt.force_v4_certs = 0;
1406             opt.disable_mdc = 1;
1407             opt.escape_from = 1;
1408             break;
1409           case oOpenPGP:
1410             /* TODO: When 2440bis becomes a RFC, these may need
1411                changing. */
1412             opt.rfc1991 = 0;
1413             opt.rfc2440 = 1;
1414             opt.disable_mdc = 1;
1415             opt.allow_non_selfsigned_uid = 1;
1416             opt.allow_freeform_uid = 1;
1417             opt.pgp2_workarounds = 0;
1418             opt.escape_from = 0;
1419             opt.force_v3_sigs = 0;
1420             opt.compress_keys = 0;          /* not mandated  but we do it */
1421             opt.compress_sigs = 0;          /* ditto. */
1422             opt.not_dash_escaped = 0;
1423             opt.def_cipher_algo = 0;
1424             opt.def_digest_algo = 0;
1425             opt.cert_digest_algo = 0;
1426             opt.def_compress_algo = 1;
1427             opt.s2k_mode = 3; /* iterated+salted */
1428             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1429             opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1430             break;
1431           case oPGP2: opt.pgp2 = 1; break;
1432           case oNoPGP2: opt.pgp2 = 0; break;
1433           case oPGP6: opt.pgp6 = 1; break;
1434           case oNoPGP6: opt.pgp6 = 0; break;
1435           case oPGP7: opt.pgp7 = 1; break;
1436           case oNoPGP7: opt.pgp7 = 0; break;
1437           case oEmuChecksumBug: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
1438           case oEmu3DESS2KBug:  opt.emulate_bugs |= EMUBUG_3DESS2K; break;
1439           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1440           case oCompressSigs: opt.compress_sigs = 1; break;
1441           case oRunAsShmCP:
1442 #ifndef __riscos__
1443           #ifndef USE_SHM_COPROCESSING
1444             /* not possible in the option file,
1445              * but we print the warning here anyway */
1446             log_error("shared memory coprocessing is not available\n");
1447           #endif
1448 #else /* __riscos__ */
1449             not_implemented("run-as-shm-coprocess");
1450 #endif /* __riscos__ */
1451             break;
1452           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1453           case oForYourEyesOnly: eyes_only = 1; break;
1454           case oNoForYourEyesOnly: eyes_only = 0; break;
1455           case oSetPolicyURL:
1456             add_policy_url(pargs.r.ret_str,0);
1457             add_policy_url(pargs.r.ret_str,1);
1458             break;
1459           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1460           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1461           case oShowPolicyURL: opt.show_policy_url=1; break;
1462           case oNoShowPolicyURL: opt.show_policy_url=0; break;
1463           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1464           case oComment: opt.comment_string = pargs.r.ret_str; break;
1465           case oDefaultComment: opt.comment_string = NULL; break;
1466           case oThrowKeyid: opt.throw_keyid = 1; break;
1467           case oShowPhotos: opt.show_photos = 1; break;
1468           case oNoShowPhotos: opt.show_photos = 0; break;
1469           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1470           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1471           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1472           case oForceV4Certs: opt.force_v4_certs = 1; break;
1473           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1474           case oForceMDC: opt.force_mdc = 1; break;
1475           case oNoForceMDC: opt.force_mdc = 0; break;
1476           case oDisableMDC: opt.disable_mdc = 1; break;
1477           case oNoDisableMDC: opt.disable_mdc = 0; break;
1478           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1479           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1480           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1481           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1482           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1483           case oEncryptTo: /* store the recipient in the second list */
1484             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1485             sl->flags = 1;
1486             break;
1487           case oRecipient: /* store the recipient */
1488             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1489             any_explicit_recipient = 1;
1490             break;
1491           case oTextmodeShort: opt.textmode = 2; break;
1492           case oTextmode: opt.textmode=1;  break;
1493           case oExpert: opt.expert = 1; break;
1494           case oNoExpert: opt.expert = 0; break;
1495           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1496           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1497           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1498           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1499           case oUser: /* store the local users */
1500             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1501             break;
1502           case oCompress: opt.compress = pargs.r.ret_int; break;
1503           case oPasswdFD:
1504             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1505             break;
1506 #ifdef __riscos__
1507           case oPasswdFile:
1508             pwfd = iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 0), 0);
1509             break;
1510 #endif /* __riscos__ */
1511           case oCommandFD:
1512             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1513             break;
1514 #ifdef __riscos__
1515           case oCommandFile:
1516             opt.command_fd = iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 0), 0);
1517             break;
1518 #endif /* __riscos__ */
1519           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1520           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1521           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1522           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1523           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1524           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1525           case oCharset:
1526             if( set_native_charset( pargs.r.ret_str ) )
1527                 log_error(_("%s is not a valid character set\n"),
1528                                                     pargs.r.ret_str);
1529             break;
1530           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1531           case oEscapeFrom: opt.escape_from = 1; break;
1532           case oNoEscapeFrom: opt.escape_from = 0; break;
1533           case oLockOnce: opt.lock_once = 1; break;
1534           case oLockNever: disable_dotlock(); break;
1535           case oLockMultiple:
1536 #ifndef __riscos__
1537             opt.lock_once = 0;
1538 #else /* __riscos__ */
1539             not_implemented("lock-multiple");
1540 #endif /* __riscos__ */
1541             break;
1542           case oKeyServer:
1543             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1544             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1545               log_error(_("could not parse keyserver URI\n"));
1546             break;
1547           case oKeyServerOptions:
1548             parse_keyserver_options(pargs.r.ret_str);
1549             break;
1550           case oImportOptions:
1551             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1552               {
1553                 if(configname)
1554                   log_error(_("%s:%d: invalid import options\n"),
1555                             configname,configlineno);
1556                 else
1557                   log_error(_("invalid import options\n"));
1558               }
1559             break;
1560           case oExportOptions:
1561             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1562               {
1563                 if(configname)
1564                   log_error(_("%s:%d: invalid export options\n"),
1565                             configname,configlineno);
1566                 else
1567                   log_error(_("invalid export options\n"));
1568               }
1569             break;
1570           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1571           case oExecPath:
1572             if(set_exec_path(pargs.r.ret_str,0))
1573               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1574             else
1575               opt.exec_path_set=1;
1576             break;
1577           case oNotation:
1578             add_notation_data( pargs.r.ret_str, 0 );
1579             add_notation_data( pargs.r.ret_str, 1 );
1580             break;
1581           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1582           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1583           case oShowNotation: opt.show_notation=1; break;
1584           case oNoShowNotation: opt.show_notation=0; break;
1585           case oUtf8Strings: utf8_strings = 1; break;
1586           case oNoUtf8Strings: utf8_strings = 0; break;
1587           case oDisableCipherAlgo:
1588                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1589                 break;
1590           case oDisablePubkeyAlgo:
1591                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1592                 break;
1593           case oNoSigCache: opt.no_sig_cache = 1; break;
1594           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1595           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1596           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1597           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1598           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1599           case oNoLiteral: opt.no_literal = 1; break;
1600           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1601           case oHonorHttpProxy:
1602                 opt.keyserver_options.honor_http_proxy = 1;
1603                 deprecated_warning(configname,configlineno,
1604                                    "--honor-http-proxy",
1605                                    "--keyserver-options ",
1606                                    "honor-http-proxy");
1607                 break;
1608           case oFastListMode: opt.fast_list_mode = 1; break;
1609           case oFixedListMode: opt.fixed_list_mode = 1; break;
1610           case oListOnly: opt.list_only=1; break;
1611           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1612           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1613           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1614           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1615           case oNoRandomSeedFile: use_random_seed = 0; break;
1616           case oAutoKeyRetrieve:
1617           case oNoAutoKeyRetrieve:
1618                 opt.keyserver_options.auto_key_retrieve=
1619                                              (pargs.r_opt==oAutoKeyRetrieve);
1620                 deprecated_warning(configname,configlineno,
1621                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1622                                "--no-auto-key-retrieve","--keyserver-options ",
1623                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1624                                "no-auto-key-retrieve");
1625                 break;
1626           case oShowSessionKey: opt.show_session_key = 1; break;
1627           case oOverrideSessionKey:
1628                 opt.override_session_key = pargs.r.ret_str;
1629                 break;
1630           case oMergeOnly: opt.merge_only = 1; break;
1631           case oAllowSecretKeyImport: /* obsolete */ break;
1632           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1633           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1634           case oEnableSpecialFilenames:
1635             iobuf_enable_special_filenames (1);
1636             break;
1637           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1638           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1639           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1640           case oPreservePermissions: opt.preserve_permissions=1; break;
1641           case oDefaultPreferenceList:
1642             opt.def_preference_list = pargs.r.ret_str;
1643             break;
1644           case oPersonalCipherPreferences:
1645             pers_cipher_list=pargs.r.ret_str;
1646             break;
1647           case oPersonalDigestPreferences:
1648             pers_digest_list=pargs.r.ret_str;
1649             break;
1650           case oPersonalCompressPreferences:
1651             pers_compress_list=pargs.r.ret_str;
1652             break;
1653           case oDisplay: opt.display = pargs.r.ret_str; break;
1654           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1655           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1656           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1657           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1658           case oGroup: add_group(pargs.r.ret_str); break;
1659           default : pargs.err = configfp? 1:2; break;
1660         }
1661     }
1662
1663     if( configfp ) {
1664         fclose( configfp );
1665         configfp = NULL;
1666         m_free(configname); configname = NULL;
1667         goto next_pass;
1668     }
1669     m_free( configname ); configname = NULL;
1670     if( log_get_errorcount(0) )
1671         g10_exit(2);
1672     if( nogreeting )
1673         greeting = 0;
1674
1675     if( greeting ) {
1676         fprintf(stderr, "%s %s; %s\n",
1677                         strusage(11), strusage(13), strusage(14) );
1678         fprintf(stderr, "%s\n", strusage(15) );
1679     }
1680   #ifdef IS_DEVELOPMENT_VERSION
1681     if( !opt.batch ) {
1682         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1683         log_info("It is only intended for test purposes and should NOT be\n");
1684         log_info("used in a production environment or with production keys!\n");
1685     }
1686   #endif
1687
1688     if (opt.verbose > 2)
1689         log_info ("using character set `%s'\n", get_native_charset ());
1690
1691     if( may_coredump && !opt.quiet )
1692         log_info(_("WARNING: program may create a core file!\n"));
1693
1694     if (eyes_only) {
1695       if (opt.set_filename)
1696           log_info(_("WARNING: %s overrides %s\n"),
1697                    "--for-your-eyes-only","--set-filename");
1698
1699       opt.set_filename="_CONSOLE";
1700     }
1701
1702     if (opt.no_literal) {
1703         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1704         if (opt.textmode)
1705             log_error(_("%s not allowed with %s!\n"),
1706                        "--textmode", "--no-literal" );
1707         if (opt.set_filename)
1708             log_error(_("%s makes no sense with %s!\n"),
1709                         eyes_only?"--for-your-eyes-only":"--set-filename",
1710                         "--no-literal" );
1711     }
1712
1713     if (opt.set_filesize)
1714         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1715     if( opt.batch )
1716         tty_batchmode( 1 );
1717
1718     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1719
1720     set_debug();
1721     g10_opt_homedir = opt.homedir;
1722
1723     /* Do these after the switch(), so they can override settings. */
1724     if(opt.pgp2 && (opt.pgp6 || opt.pgp7))
1725       log_error(_("%s not allowed with %s!\n"),
1726                 "--pgp2",opt.pgp6?"--pgp6":"--pgp7");
1727     else
1728       {
1729         if(opt.pgp2)
1730           {
1731             int unusable=0;
1732
1733             if(cmd==aSign && !detached_sig)
1734               {
1735                 log_info(_("you can only make detached or clear signatures "
1736                            "while in --pgp2 mode\n"));
1737                 unusable=1;
1738               }
1739             else if(cmd==aSignEncr || cmd==aSignSym)
1740               {
1741                 log_info(_("you can't sign and encrypt at the "
1742                            "same time while in --pgp2 mode\n"));
1743                 unusable=1;
1744               }
1745             else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1746               {
1747                 log_info(_("you must use files (and not a pipe) when "
1748                            "working with --pgp2 enabled.\n"));
1749                 unusable=1;
1750               }
1751             else if(cmd==aEncr || cmd==aSym)
1752               {
1753                 /* Everything else should work without IDEA (except using
1754                    a secret key encrypted with IDEA and setting an IDEA
1755                    preference, but those have their own error
1756                    messages). */
1757
1758                 if(check_cipher_algo(CIPHER_ALGO_IDEA))
1759                   {
1760                     log_info(_("encrypting a message in --pgp2 mode requires "
1761                                "the IDEA cipher\n"));
1762                     idea_cipher_warn(1);
1763                     unusable=1;
1764                   }
1765                 else if(cmd==aSym)
1766                   {
1767                     m_free(def_cipher_string);
1768                     def_cipher_string = m_strdup("idea");
1769                   }
1770               }
1771
1772             if(unusable)
1773               {
1774                 log_info(_("this message may not be usable by %s\n"),
1775                          "PGP 2.x");
1776                 opt.pgp2=0;
1777               }
1778             else
1779               {
1780                 opt.rfc1991 = 1;
1781                 opt.rfc2440 = 0;
1782                 opt.force_mdc = 0;
1783                 opt.disable_mdc = 1;
1784                 opt.force_v4_certs = 0;
1785                 opt.sk_comments = 0;
1786                 opt.escape_from = 1;
1787                 opt.force_v3_sigs = 1;
1788                 opt.pgp2_workarounds = 1;
1789                 opt.ask_sig_expire = 0;
1790                 opt.ask_cert_expire = 0;
1791                 m_free(def_digest_string);
1792                 def_digest_string = m_strdup("md5");
1793                 opt.def_compress_algo = 1;
1794               }
1795           }
1796
1797         if(opt.pgp6 || opt.pgp7)
1798           {
1799             opt.sk_comments=0;
1800             opt.escape_from=1;
1801             opt.force_v3_sigs=1;
1802             opt.ask_sig_expire=0;
1803             opt.def_compress_algo=1;
1804
1805             if(opt.pgp6) /* pgp7 has MDC */
1806               {
1807                 opt.force_mdc=0;
1808                 opt.disable_mdc=1;
1809               }
1810           }
1811       }
1812
1813     /* must do this after dropping setuid, because string_to...
1814      * may try to load an module */
1815     if( def_cipher_string ) {
1816         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
1817         if(opt.def_cipher_algo==0 &&
1818            ascii_strcasecmp(def_cipher_string,"idea")==0)
1819           idea_cipher_warn(1);
1820         m_free(def_cipher_string); def_cipher_string = NULL;
1821         if( check_cipher_algo(opt.def_cipher_algo) )
1822             log_error(_("selected cipher algorithm is invalid\n"));
1823     }
1824     if( def_digest_string ) {
1825         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
1826         m_free(def_digest_string); def_digest_string = NULL;
1827         if( check_digest_algo(opt.def_digest_algo) )
1828             log_error(_("selected digest algorithm is invalid\n"));
1829     }
1830     if( cert_digest_string ) {
1831         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
1832         m_free(cert_digest_string); cert_digest_string = NULL;
1833         if( check_digest_algo(opt.cert_digest_algo) )
1834             log_error(_("selected certification digest algorithm is invalid\n"));
1835     }
1836     if( s2k_cipher_string ) {
1837         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
1838         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
1839         if( check_cipher_algo(opt.s2k_cipher_algo) )
1840             log_error(_("selected cipher algorithm is invalid\n"));
1841     }
1842     if( s2k_digest_string ) {
1843         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
1844         m_free(s2k_digest_string); s2k_digest_string = NULL;
1845         if( check_digest_algo(opt.s2k_digest_algo) )
1846             log_error(_("selected digest algorithm is invalid\n"));
1847     }
1848     if( opt.def_compress_algo < -1 || opt.def_compress_algo > 2 )
1849         log_error(_("compress algorithm must be in range %d..%d\n"), 0, 2);
1850     if( opt.completes_needed < 1 )
1851         log_error(_("completes-needed must be greater than 0\n"));
1852     if( opt.marginals_needed < 2 )
1853         log_error(_("marginals-needed must be greater than 1\n"));
1854     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
1855         log_error(_("max-cert-depth must be in range 1 to 255\n"));
1856     switch( opt.s2k_mode ) {
1857       case 0:
1858         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
1859         break;
1860       case 1: case 3: break;
1861       default:
1862         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
1863     }
1864
1865     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
1866       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
1867
1868     /* This isn't actually needed, but does serve to error out if the
1869        string is invalid. */
1870     if(opt.def_preference_list &&
1871         keygen_set_std_prefs(opt.def_preference_list,0))
1872       log_error(_("invalid default preferences\n"));
1873
1874     /* We provide defaults for the personal digest list */
1875     if(!pers_digest_list)
1876       pers_digest_list="h2";
1877
1878     if(pers_cipher_list &&
1879        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
1880       log_error(_("invalid personal cipher preferences\n"));
1881
1882     if(pers_digest_list &&
1883        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
1884       log_error(_("invalid personal digest preferences\n"));
1885
1886     if(pers_compress_list &&
1887        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
1888       log_error(_("invalid personal compress preferences\n"));
1889
1890     if( log_get_errorcount(0) )
1891         g10_exit(2);
1892
1893     /* set the random seed file */
1894     if( use_random_seed ) {
1895         char *p = make_filename(opt.homedir, "random_seed", NULL );
1896         set_random_seed_file(p);
1897         m_free(p);
1898     }
1899
1900     if( !cmd && opt.fingerprint && !with_fpr ) {
1901         set_cmd( &cmd, aListKeys);
1902     }
1903
1904     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
1905         if( cmd == aKModeC ) {
1906             opt.fingerprint = 1;
1907             cmd = aKMode;
1908         }
1909         opt.list_sigs = 0;
1910         if( opt.verbose > 2 )
1911             opt.check_sigs++;
1912         if( opt.verbose > 1 )
1913             opt.list_sigs++;
1914
1915         opt.verbose = opt.verbose > 1;
1916         g10_opt_verbose = opt.verbose;
1917     }
1918
1919     /* Compression algorithm 0 means no compression at all */
1920     if( opt.def_compress_algo == 0)
1921         opt.compress = 0;
1922
1923     /* kludge to let -sat generate a clear text signature */
1924     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
1925         cmd = aClearsign;
1926
1927     if( opt.verbose > 1 )
1928         set_packet_list_mode(1);
1929
1930     /* Add the keyrings, but not for some special commands and not in
1931        case of "-kvv userid keyring".  Also avoid adding the secret
1932        keyring for a couple of commands to avoid unneeded access in
1933        case the secrings are stored on a floppy */
1934     if( cmd != aDeArmor && cmd != aEnArmor
1935         && !(cmd == aKMode && argc == 2 ) ) 
1936       {
1937         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
1938             && cmd != aVerify && cmd != aVerifyFiles
1939             && cmd != aSym)
1940           {
1941             if (!sec_nrings || default_keyring) /* add default secret rings */
1942               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
1943             for (sl = sec_nrings; sl; sl = sl->next)
1944               keydb_add_resource ( sl->d, 0, 1 );
1945           }
1946         if( !nrings || default_keyring )  /* add default ring */
1947             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
1948         for(sl = nrings; sl; sl = sl->next )
1949             keydb_add_resource ( sl->d, 0, 0 );
1950       }
1951     FREE_STRLIST(nrings);
1952     FREE_STRLIST(sec_nrings);
1953
1954
1955     if( pwfd != -1 )  /* read the passphrase now. */
1956         read_passphrase_from_fd( pwfd );
1957
1958     fname = argc? *argv : NULL;
1959
1960     switch( cmd ) {
1961       case aPrimegen:
1962       case aPrintMD:
1963       case aPrintMDs:
1964       case aGenRandom:
1965       case aDeArmor:
1966       case aEnArmor:
1967       case aFixTrustDB:
1968         break;
1969       case aKMode:
1970       case aListKeys:
1971       case aListSecretKeys:
1972       case aCheckKeys:
1973         if( opt.with_colons ) /* need this to list the trust */
1974             rc = setup_trustdb(1, trustdb_name );
1975         break;
1976       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
1977       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
1978       default: rc = setup_trustdb(1, trustdb_name ); break;
1979     }
1980     if( rc )
1981         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
1982
1983
1984     switch (cmd) {
1985       case aStore: 
1986       case aSym:  
1987       case aSign: 
1988       case aSignSym: 
1989       case aClearsign: 
1990         if (!opt.quiet && any_explicit_recipient)
1991           log_info (_("WARNING: recipients (-r) given "
1992                       "without using public key encryption\n"));
1993         break;
1994       default:
1995         break;
1996     }
1997
1998     switch( cmd ) {
1999       case aStore: /* only store the file */
2000         if( argc > 1 )
2001             wrong_args(_("--store [filename]"));
2002         if( (rc = encode_store(fname)) )
2003             log_error_f( print_fname_stdin(fname),
2004                         "store failed: %s\n", g10_errstr(rc) );
2005         break;
2006       case aSym: /* encrypt the given file only with the symmetric cipher */
2007         if( argc > 1 )
2008             wrong_args(_("--symmetric [filename]"));
2009         if( (rc = encode_symmetric(fname)) )
2010             log_error_f(print_fname_stdin(fname),
2011                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2012         break;
2013
2014       case aEncr: /* encrypt the given file */
2015         if( argc > 1 )
2016             wrong_args(_("--encrypt [filename]"));
2017         if( (rc = encode_crypt(fname,remusr)) )
2018             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2019         break;
2020
2021       case aEncrFiles: /* encrypt the given files */
2022         encode_crypt_files(argc, argv, remusr);
2023         break;
2024           
2025       case aSign: /* sign the given file */
2026         sl = NULL;
2027         if( detached_sig ) { /* sign all files */
2028             for( ; argc; argc--, argv++ )
2029                 add_to_strlist( &sl, *argv );
2030         }
2031         else {
2032             if( argc > 1 )
2033                 wrong_args(_("--sign [filename]"));
2034             if( argc ) {
2035                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2036                 strcpy(sl->d, fname);
2037             }
2038         }
2039         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2040             log_error("signing failed: %s\n", g10_errstr(rc) );
2041         free_strlist(sl);
2042         break;
2043
2044       case aSignEncr: /* sign and encrypt the given file */
2045         if( argc > 1 )
2046             wrong_args(_("--sign --encrypt [filename]"));
2047         if( argc ) {
2048             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2049             strcpy(sl->d, fname);
2050         }
2051         else
2052             sl = NULL;
2053         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2054             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2055         free_strlist(sl);
2056         break;
2057
2058       case aSignSym: /* sign and conventionally encrypt the given file */
2059         if (argc > 1)
2060             wrong_args(_("--sign --symmetric [filename]"));
2061         rc = sign_symencrypt_file (fname, locusr);
2062         if (rc)
2063             log_error("%s: sign+symmetric failed: %s\n",
2064                       print_fname_stdin(fname), g10_errstr(rc) );
2065         break;
2066
2067       case aClearsign: /* make a clearsig */
2068         if( argc > 1 )
2069             wrong_args(_("--clearsign [filename]"));
2070         if( (rc = clearsign_file(fname, locusr, NULL)) )
2071             log_error("%s: clearsign failed: %s\n",
2072                       print_fname_stdin(fname), g10_errstr(rc) );
2073         break;
2074
2075       case aVerify:
2076         if( (rc = verify_signatures( argc, argv ) ))
2077             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2078         break;
2079
2080       case aVerifyFiles:
2081         if( (rc = verify_files( argc, argv ) ))
2082             log_error("verify files failed: %s\n", g10_errstr(rc) );
2083         break;
2084
2085       case aDecrypt:
2086         if( argc > 1 )
2087             wrong_args(_("--decrypt [filename]"));
2088         if( (rc = decrypt_message( fname ) ))
2089             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2090         break;
2091
2092       case aDecryptFiles:
2093         decrypt_messages(argc, argv);
2094         break;
2095             
2096       case aSignKey: /* sign the key given as argument */
2097         if( argc != 1 )
2098             wrong_args(_("--sign-key user-id"));
2099         username = make_username( fname );
2100         keyedit_menu(fname, locusr, NULL, 1 );
2101         m_free(username);
2102         break;
2103
2104       case aLSignKey:
2105         if( argc != 1 )
2106             wrong_args(_("--lsign-key user-id"));
2107         username = make_username( fname );
2108         keyedit_menu(fname, locusr, NULL, 2 );
2109         m_free(username);
2110         break;
2111
2112       case aNRSignKey:
2113         if( argc != 1 )
2114             wrong_args(_("--nrsign-key user-id"));
2115         username = make_username( fname );
2116         keyedit_menu(fname, locusr, NULL, 3 );
2117         m_free(username);
2118         break;
2119
2120       case aNRLSignKey:
2121         if( argc != 1 )
2122             wrong_args(_("--nrlsign-key user-id"));
2123         username = make_username( fname );
2124         keyedit_menu(fname, locusr, NULL, 4 );
2125         m_free(username);
2126         break;
2127
2128       case aEditKey: /* Edit a key signature */
2129         if( !argc )
2130             wrong_args(_("--edit-key user-id [commands]"));
2131         username = make_username( fname );
2132         if( argc > 1 ) {
2133             sl = NULL;
2134             for( argc--, argv++ ; argc; argc--, argv++ )
2135                 append_to_strlist( &sl, *argv );
2136             keyedit_menu( username, locusr, sl, 0 );
2137             free_strlist(sl);
2138         }
2139         else
2140             keyedit_menu(username, locusr, NULL, 0 );
2141         m_free(username);
2142         break;
2143
2144       case aDeleteKeys:
2145       case aDeleteSecretKeys:
2146       case aDeleteSecretAndPublicKeys:
2147         sl = NULL;
2148         /* I'm adding these in reverse order as add_to_strlist2
2149            reverses them again, and it's easier to understand in the
2150            proper order :) */
2151         for( ; argc; argc-- )
2152           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2153         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2154         free_strlist(sl);
2155         break;
2156
2157       case aCheckKeys:
2158         opt.check_sigs = 1;
2159       case aListSigs:
2160         opt.list_sigs = 1;
2161       case aListKeys:
2162         sl = NULL;
2163         for( ; argc; argc--, argv++ )
2164             add_to_strlist2( &sl, *argv, utf8_strings );
2165         public_key_list( sl );
2166         free_strlist(sl);
2167         break;
2168       case aListSecretKeys:
2169         sl = NULL;
2170         for( ; argc; argc--, argv++ )
2171             add_to_strlist2( &sl, *argv, utf8_strings );
2172         secret_key_list( sl );
2173         free_strlist(sl);
2174         break;
2175
2176       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2177         if( argc < 2 ) { /* -kv [userid] */
2178             sl = NULL;
2179             if (argc && **argv)
2180                 add_to_strlist2( &sl, *argv, utf8_strings );
2181             public_key_list( sl );
2182             free_strlist(sl);
2183         }
2184         else if( argc == 2 ) { /* -kv userid keyring */
2185             if( access( argv[1], R_OK ) ) {
2186                 log_error(_("can't open %s: %s\n"),
2187                                print_fname_stdin(argv[1]), strerror(errno));
2188             }
2189             else {
2190                 /* add keyring (default keyrings are not registered in this
2191                  * special case */
2192                 keydb_add_resource( argv[1], 0, 0 );
2193                 sl = NULL;
2194                 if (**argv)
2195                     add_to_strlist2( &sl, *argv, utf8_strings );
2196                 public_key_list( sl );
2197                 free_strlist(sl);
2198             }
2199         }
2200         else
2201             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2202         break;
2203
2204       case aKeygen: /* generate a key */
2205         if( opt.batch ) {
2206             if( argc > 1 )
2207                 wrong_args("--gen-key [parameterfile]");
2208             generate_keypair( argc? *argv : NULL );
2209         }
2210         else {
2211             if( argc )
2212                 wrong_args("--gen-key");
2213             generate_keypair(NULL);
2214         }
2215         break;
2216
2217       case aFastImport:
2218       case aImport:
2219         import_keys( argc? argv:NULL, argc, (cmd == aFastImport),
2220                      NULL, opt.import_options );
2221         break;
2222
2223       case aExport:
2224       case aExportAll:
2225       case aSendKeys:
2226       case aRecvKeys:
2227         sl = NULL;
2228         for( ; argc; argc--, argv++ )
2229             add_to_strlist2( &sl, *argv, utf8_strings );
2230         if( cmd == aSendKeys )
2231             keyserver_export( sl );
2232         else if( cmd == aRecvKeys )
2233             keyserver_import( sl );
2234         else
2235             export_pubkeys( sl, opt.export_options );
2236         free_strlist(sl);
2237         break;
2238
2239      case aSearchKeys:
2240         sl = NULL;
2241         for( ; argc; argc--, argv++ )
2242           append_to_strlist2( &sl, *argv, utf8_strings );
2243
2244         keyserver_search( sl );
2245         free_strlist(sl);
2246         break;
2247
2248       case aRefreshKeys:
2249         sl = NULL;
2250         for( ; argc; argc--, argv++ )
2251             add_to_strlist2( &sl, *argv, utf8_strings );
2252         keyserver_refresh(sl);
2253         free_strlist(sl);
2254         break;
2255
2256       case aExportSecret:
2257         sl = NULL;
2258         for( ; argc; argc--, argv++ )
2259             add_to_strlist2( &sl, *argv, utf8_strings );
2260         export_seckeys( sl );
2261         free_strlist(sl);
2262         break;
2263
2264       case aExportSecretSub:
2265         sl = NULL;
2266         for( ; argc; argc--, argv++ )
2267             add_to_strlist2( &sl, *argv, utf8_strings );
2268         export_secsubkeys( sl );
2269         free_strlist(sl);
2270         break;
2271
2272       case aGenRevoke:
2273         if( argc != 1 )
2274             wrong_args("--gen-revoke user-id");
2275         username =  make_username(*argv);
2276         gen_revoke( username );
2277         m_free( username );
2278         break;
2279
2280       case aDesigRevoke:
2281         if( argc != 1 )
2282             wrong_args("--desig-revoke user-id");
2283         username =  make_username(*argv);
2284         gen_desig_revoke( username );
2285         m_free( username );
2286         break;
2287
2288       case aDeArmor:
2289         if( argc > 1 )
2290             wrong_args("--dearmor [file]");
2291         rc = dearmor_file( argc? *argv: NULL );
2292         if( rc )
2293             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2294         break;
2295
2296       case aEnArmor:
2297         if( argc > 1 )
2298             wrong_args("--enarmor [file]");
2299         rc = enarmor_file( argc? *argv: NULL );
2300         if( rc )
2301             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2302         break;
2303
2304
2305       case aPrimegen:
2306         {   int mode = argc < 2 ? 0 : atoi(*argv);
2307
2308             if( mode == 1 && argc == 2 ) {
2309                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2310             }
2311             else if( mode == 2 && argc == 3 ) {
2312                 mpi_print( stdout, generate_elg_prime(
2313                                              0, atoi(argv[1]),
2314                                              atoi(argv[2]), NULL,NULL ), 1);
2315             }
2316             else if( mode == 3 && argc == 3 ) {
2317                 MPI *factors;
2318                 mpi_print( stdout, generate_elg_prime(
2319                                              1, atoi(argv[1]),
2320                                              atoi(argv[2]), NULL,&factors ), 1);
2321                 putchar('\n');
2322                 mpi_print( stdout, factors[0], 1 ); /* print q */
2323             }
2324             else if( mode == 4 && argc == 3 ) {
2325                 MPI g = mpi_alloc(1);
2326                 mpi_print( stdout, generate_elg_prime(
2327                                                  0, atoi(argv[1]),
2328                                                  atoi(argv[2]), g, NULL ), 1);
2329                 putchar('\n');
2330                 mpi_print( stdout, g, 1 );
2331                 mpi_free(g);
2332             }
2333             else
2334                 wrong_args("--gen-prime mode bits [qbits] ");
2335             putchar('\n');
2336         }
2337         break;
2338
2339       case aGenRandom:
2340         {
2341             int level = argc ? atoi(*argv):0;
2342             int count = argc > 1 ? atoi(argv[1]): 0;
2343             int endless = !count;
2344
2345             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2346                 wrong_args("--gen-random 0|1|2 [count]");
2347
2348             while( endless || count ) {
2349                 byte *p;
2350                 /* Wee need a multiple of 3, so that in case of
2351                    armored output we get a correct string.  No
2352                    linefolding is done, as it is best to levae this to
2353                    other tools */
2354                 size_t n = !endless && count < 99? count : 99;
2355
2356                 p = get_random_bits( n*8, level, 0);
2357               #ifdef HAVE_DOSISH_SYSTEM
2358                 setmode ( fileno(stdout), O_BINARY );
2359               #endif
2360                 if (opt.armor) {
2361                     char *tmp = make_radix64_string (p, n);
2362                     fputs (tmp, stdout);
2363                     m_free (tmp);
2364                     if (n%3 == 1)
2365                       putchar ('=');
2366                     if (n%3)
2367                       putchar ('=');
2368                 } else {
2369                     fwrite( p, n, 1, stdout );
2370                 }
2371                 m_free(p);
2372                 if( !endless )
2373                     count -= n;
2374             }
2375             if (opt.armor)
2376                 putchar ('\n');
2377         }
2378         break;
2379
2380       case aPrintMD:
2381         if( argc < 1)
2382             wrong_args("--print-md algo [files]");
2383         {
2384             int all_algos = (**argv=='*' && !(*argv)[1]);
2385             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2386
2387             if( !algo && !all_algos )
2388                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2389             else {
2390                 argc--; argv++;
2391                 if( !argc )
2392                     print_mds(NULL, algo);
2393                 else {
2394                     for(; argc; argc--, argv++ )
2395                         print_mds(*argv, algo);
2396                 }
2397             }
2398         }
2399         break;
2400
2401       case aPrintMDs: /* old option */
2402         if( !argc )
2403             print_mds(NULL,0);
2404         else {
2405             for(; argc; argc--, argv++ )
2406                 print_mds(*argv,0);
2407         }
2408         break;
2409
2410       case aListTrustDB:
2411         if( !argc )
2412             list_trustdb(NULL);
2413         else {
2414             for( ; argc; argc--, argv++ )
2415                 list_trustdb( *argv );
2416         }
2417         break;
2418
2419       case aUpdateTrustDB:
2420         if( argc )
2421             wrong_args("--update-trustdb");
2422         update_trustdb();
2423         break;
2424
2425       case aCheckTrustDB:
2426         /* Old versions allowed for arguments - ignore them */
2427         check_trustdb();
2428         break;
2429
2430       case aFixTrustDB:
2431         log_error("this command is not yet implemented.\n");
2432         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2433         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2434         break;
2435
2436       case aListTrustPath:
2437         if( !argc )
2438             wrong_args("--list-trust-path <user-ids>");
2439         for( ; argc; argc--, argv++ ) {
2440             username = make_username( *argv );
2441             list_trust_path( username );
2442             m_free(username);
2443         }
2444         break;
2445
2446       case aExportOwnerTrust:
2447         if( argc )
2448             wrong_args("--export-ownertrust");
2449         export_ownertrust();
2450         break;
2451
2452       case aImportOwnerTrust:
2453         if( argc > 1 )
2454             wrong_args("--import-ownertrust [file]");
2455         import_ownertrust( argc? *argv:NULL );
2456         break;
2457       
2458       case aPipeMode:
2459         if ( argc )
2460             wrong_args ("--pipemode");
2461         run_in_pipemode ();
2462         break;
2463
2464       case aRebuildKeydbCaches:
2465         if (argc)
2466             wrong_args ("--rebuild-keydb-caches");
2467         keydb_rebuild_caches ();
2468         break;
2469
2470       case aListPackets:
2471         opt.list_packets=2;
2472       default:
2473         if( argc > 1 )
2474             wrong_args(_("[filename]"));
2475         /* Issue some output for the unix newbie */
2476         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2477                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2478             log_info(_("Go ahead and type your message ...\n"));
2479
2480         if( !(a = iobuf_open(fname)) )
2481             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2482         else {
2483
2484             if( !opt.no_armor ) {
2485                 if( use_armor_filter( a ) ) {
2486                     memset( &afx, 0, sizeof afx);
2487                     iobuf_push_filter( a, armor_filter, &afx );
2488                 }
2489             }
2490             if( cmd == aListPackets ) {
2491                 set_packet_list_mode(1);
2492                 opt.list_packets=1;
2493             }
2494             rc = proc_packets(NULL, a );
2495             if( rc )
2496                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2497             iobuf_close(a);
2498         }
2499         break;
2500     }
2501
2502     /* cleanup */
2503     FREE_STRLIST(remusr);
2504     FREE_STRLIST(locusr);
2505     g10_exit(0);
2506     return 8; /*NEVER REACHED*/
2507 }
2508
2509
2510 void
2511 g10_exit( int rc )
2512 {
2513     update_random_seed_file();
2514     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2515         m_print_stats("on exit");
2516         random_dump_stats();
2517     }
2518     if( opt.debug )
2519         secmem_dump_stats();
2520     secmem_term();
2521     rc = rc? rc : log_get_errorcount(0)? 2 :
2522                         g10_errors_seen? 1 : 0;
2523     exit(rc );
2524 }
2525
2526
2527
2528
2529 static void
2530 print_hex( byte *p, size_t n )
2531 {
2532     int i;
2533
2534     if( n == 20 ) {
2535         for(i=0; i < n ; i++, i++, p += 2 ) {
2536             if( i )
2537                 putchar(' ');
2538             if( i == 10 )
2539                 putchar(' ');
2540             printf("%02X%02X", *p, p[1] );
2541         }
2542     }
2543     else if( n == 24 ) {
2544         for(i=0; i < n ; i += 4, p += 4 ) {
2545             if( i )
2546                 putchar(' ');
2547             if( i == 12 )
2548                 putchar(' ');
2549             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
2550         }
2551     }
2552     else {
2553         for(i=0; i < n ; i++, p++ ) {
2554             if( i )
2555                 putchar(' ');
2556             if( i && !(i%8) )
2557                 putchar(' ');
2558             printf("%02X", *p );
2559         }
2560     }
2561 }
2562
2563 static void
2564 print_hashline( MD_HANDLE md, int algo, const char *fname )
2565 {
2566     int i, n;
2567     const byte *p;
2568     
2569     if ( fname ) {
2570         for (p = fname; *p; p++ ) {
2571             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2572                 printf("%%%02X", *p );
2573             else 
2574                 putchar( *p );
2575         }
2576     }
2577     putchar(':');
2578     printf("%d:", algo );
2579     p = md_read( md, algo );
2580     n = md_digest_length(algo);
2581     for(i=0; i < n ; i++, p++ ) 
2582         printf("%02X", *p );
2583     putchar(':');
2584     putchar('\n');
2585 }
2586
2587 static void
2588 print_mds( const char *fname, int algo )
2589 {
2590     FILE *fp;
2591     char buf[1024];
2592     size_t n;
2593     MD_HANDLE md;
2594     char *pname;
2595
2596     if( !fname ) {
2597         fp = stdin;
2598       #ifdef HAVE_DOSISH_SYSTEM
2599         setmode ( fileno(fp) , O_BINARY );
2600       #endif
2601         pname = m_strdup("[stdin]: ");
2602     }
2603     else {
2604         pname = m_alloc(strlen(fname)+3);
2605         strcpy(stpcpy(pname,fname),": ");
2606         fp = fopen( fname, "rb" );
2607     }
2608     if( !fp ) {
2609         log_error("%s%s\n", pname, strerror(errno) );
2610         m_free(pname);
2611         return;
2612     }
2613
2614     md = md_open( 0, 0 );
2615     if( algo )
2616         md_enable( md, algo );
2617     else {
2618         md_enable( md, DIGEST_ALGO_MD5 );
2619         md_enable( md, DIGEST_ALGO_SHA1 );
2620         md_enable( md, DIGEST_ALGO_RMD160 );
2621         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2622             md_enable( md, DIGEST_ALGO_TIGER );
2623     }
2624
2625     while( (n=fread( buf, 1, DIM(buf), fp )) )
2626         md_write( md, buf, n );
2627     if( ferror(fp) )
2628         log_error("%s%s\n", pname, strerror(errno) );
2629     else {
2630         md_final(md);
2631         if ( opt.with_colons ) {
2632             if ( algo ) 
2633                 print_hashline( md, algo, fname );
2634             else {
2635                 print_hashline( md, DIGEST_ALGO_MD5, fname );
2636                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
2637                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
2638                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) 
2639                     print_hashline( md, DIGEST_ALGO_TIGER, fname );
2640             }
2641         }
2642         else {
2643             if( algo ) {
2644                 if( fname )
2645                     fputs( pname, stdout );
2646                 print_hex(md_read(md, algo), md_digest_length(algo) );
2647             }
2648             else {
2649                 printf(  "%s   MD5 = ", fname?pname:"" );
2650                 print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
2651                 printf("\n%s  SHA1 = ", fname?pname:""  );
2652                 print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
2653                 printf("\n%sRMD160 = ", fname?pname:""  );
2654                 print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
2655                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
2656                     printf("\n%s TIGER = ", fname?pname:""  );
2657                     print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
2658                 }
2659             }
2660             putchar('\n');
2661         }
2662     }
2663     md_close(md);
2664
2665     if( fp != stdin )
2666         fclose(fp);
2667 }
2668
2669
2670 /****************
2671  * Check the supplied name,value string and add it to the notation
2672  * data to be used for signatures.  which==0 for sig notations, and 1
2673  * for cert notations.
2674 */
2675 static void
2676 add_notation_data( const char *string, int which )
2677 {
2678     const char *s;
2679     STRLIST sl,*notation_data;
2680     int critical=0;
2681     int highbit=0;
2682
2683     if(which)
2684       notation_data=&opt.cert_notation_data;
2685     else
2686       notation_data=&opt.sig_notation_data;
2687
2688     if( *string == '!' ) {
2689         critical = 1;
2690         string++;
2691     }
2692
2693     for( s=string ; *s != '='; s++ ) {
2694         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) ) {
2695             log_error(_("a notation name must have only printable characters "
2696                         "or spaces, and end with an '='\n") );
2697             return;
2698         }
2699     }
2700     /* we only support printable text - therefore we enforce the use
2701      * of only printable characters (an empty value is valid) */
2702     for( s++; *s ; s++ ) {
2703         if( iscntrl(*s) ) {
2704             log_error(_("a notation value must not use "
2705                         "any control characters\n") );
2706             return;
2707         }
2708         else if( *s & 0x80 )
2709             highbit = 1;
2710     }
2711
2712     if( highbit )   /* must use UTF8 encoding */
2713         sl = add_to_strlist2( notation_data, string, utf8_strings );
2714     else
2715         sl = add_to_strlist( notation_data, string );
2716
2717     if( critical )
2718         sl->flags |= 1;
2719 }
2720
2721
2722 static void
2723 add_policy_url( const char *string, int which )
2724 {
2725   int i,critical=0;
2726   STRLIST sl;
2727
2728   if(*string=='!')
2729     {
2730       string++;
2731       critical=1;
2732     }
2733
2734   for(i=0;i<strlen(string);i++)
2735     if(string[i]&0x80 || iscntrl(string[i]))
2736       break;
2737
2738   if(i==0 || i<strlen(string))
2739     {
2740       if(which)
2741         log_error(_("the given certification policy URL is invalid\n"));
2742       else
2743         log_error(_("the given signature policy URL is invalid\n"));
2744     }
2745
2746   if(which)
2747     sl=add_to_strlist( &opt.cert_policy_url, string );
2748   else
2749     sl=add_to_strlist( &opt.sig_policy_url, string );
2750
2751   if(critical)
2752     sl->flags |= 1;    
2753 }