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