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