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