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