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