* misc.c (compress_algo_to_string, string_to_compress_algo,
[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     /* Try for a version specific config file first */
1303     if( default_config )
1304       {
1305         char *name=m_strdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1306         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1307
1308         do
1309           {
1310             if(configname)
1311               {
1312                 char *tok;
1313
1314                 m_free(configname);
1315                 configname=NULL;
1316
1317                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1318                   *tok='\0';
1319                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1320                   *tok='\0';
1321                 else
1322                   break;
1323               }
1324
1325             configname = make_filename(opt.homedir,name,NULL);
1326           }
1327         while(access(configname,R_OK));
1328
1329         m_free(name);
1330
1331         if(!configname)
1332           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1333         if (!access (configname, R_OK))
1334           { /* Print a warning when both config files are present. */
1335             char *p = make_filename(opt.homedir, "options", NULL );
1336             if (!access (p, R_OK))
1337               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1338             m_free (p);
1339           }
1340         else
1341           { /* Keep on using the old default one. */
1342             m_free (configname);
1343             configname = make_filename(opt.homedir, "options", NULL );
1344           }
1345       }
1346     argc = orig_argc;
1347     argv = orig_argv;
1348     pargs.argc = &argc;
1349     pargs.argv = &argv;
1350     pargs.flags=  1;  /* do not remove the args */
1351
1352     /* By this point we have a homedir, and cannot change it. */
1353     check_permissions(opt.homedir,0);
1354
1355   next_pass:
1356     if( configname ) {
1357       if(check_permissions(configname,1))
1358         {
1359           /* If any options file is unsafe, then disable any external
1360              programs for keyserver calls or photo IDs.  Since the
1361              external program to call is set in the options file, a
1362              unsafe options file can lead to an arbitrary program
1363              being run. */
1364
1365           opt.exec_disable=1;
1366         }
1367
1368         configlineno = 0;
1369         configfp = fopen( configname, "r" );
1370         if( !configfp ) {
1371             if( default_config ) {
1372                 if( parse_debug )
1373                     log_info(_("NOTE: no default option file `%s'\n"),
1374                                                             configname );
1375             }
1376             else {
1377                 log_error(_("option file `%s': %s\n"),
1378                                     configname, strerror(errno) );
1379                 g10_exit(2);
1380             }
1381             m_free(configname); configname = NULL;
1382         }
1383         if( parse_debug && configname )
1384             log_info(_("reading options from `%s'\n"), configname );
1385         default_config = 0;
1386     }
1387
1388     while( optfile_parse( configfp, configname, &configlineno,
1389                                                 &pargs, opts) )
1390       {
1391         switch( pargs.r_opt )
1392           {
1393           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1394           case aListPackets: set_cmd( &cmd, aListPackets); break;
1395           case aImport: set_cmd( &cmd, aImport); break;
1396           case aFastImport: set_cmd( &cmd, aFastImport); break;
1397           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1398           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1399           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1400           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1401           case aExport: set_cmd( &cmd, aExport); break;
1402           case aExportAll: set_cmd( &cmd, aExportAll); break;
1403           case aListKeys: set_cmd( &cmd, aListKeys); break;
1404           case aListSigs: set_cmd( &cmd, aListSigs); break;
1405           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1406           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1407           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1408                                                         greeting=1; break;
1409           case aDeleteSecretAndPublicKeys:
1410             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1411             greeting=1; 
1412             break;
1413           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1414
1415           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1416           case aSym: set_cmd( &cmd, aSym); break;
1417
1418           case aDecryptFiles: multifile=1; /* fall through */
1419           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1420
1421           case aEncrFiles: multifile=1; /* fall through */
1422           case aEncr: set_cmd( &cmd, aEncr); break;
1423
1424           case aVerifyFiles: multifile=1; /* fall through */
1425           case aVerify: set_cmd( &cmd, aVerify); break;
1426
1427           case aSign: set_cmd( &cmd, aSign );  break;
1428           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1429           case aSignKey: set_cmd( &cmd, aSignKey); break;
1430           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1431           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1432           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1433           case aStore: set_cmd( &cmd, aStore); break;
1434           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1435           case aClearsign: set_cmd( &cmd, aClearsign); break;
1436           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1437           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1438           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1439           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1440           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1441           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1442           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1443           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1444           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1445           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1446           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1447           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1448           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1449           case aListOwnerTrust:
1450             deprecated_warning(configname,configlineno,
1451                                "--list-ownertrust","--export-ownertrust","");
1452           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1453           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1454           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1455           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1456
1457 #ifdef ENABLE_CARD_SUPPORT
1458           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
1459           case aCardEdit: set_cmd (&cmd, aCardEdit); break;
1460           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
1461           case oReaderPort:
1462             card_set_reader_port (pargs.r.ret_str);
1463             break;
1464           case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
1465           case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
1466           case oDisableCCID: opt.disable_ccid = 1; break;
1467 #endif /* ENABLE_CARD_SUPPORT*/
1468
1469           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1470           case oOutput: opt.outfile = pargs.r.ret_str; break;
1471           case oQuiet: opt.quiet = 1; break;
1472           case oNoTTY: tty_no_terminal(1); break;
1473           case oDryRun: opt.dry_run = 1; break;
1474           case oInteractive: opt.interactive = 1; break;
1475           case oVerbose:
1476             g10_opt_verbose++;
1477             opt.verbose++;
1478             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
1479             break;
1480           case oKOption: set_cmd( &cmd, aKMode ); break;
1481
1482           case oBatch: opt.batch = 1; nogreeting = 1; break;
1483           case oUseAgent:
1484 #ifndef __riscos__
1485             opt.use_agent = 1;
1486 #else /* __riscos__ */
1487             opt.use_agent = 0;
1488             riscos_not_implemented("use-agent");
1489 #endif /* __riscos__ */
1490             break;
1491           case oNoUseAgent: opt.use_agent = 0; break;
1492           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1493           case oAnswerYes: opt.answer_yes = 1; break;
1494           case oAnswerNo: opt.answer_no = 1; break;
1495           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1496           case oPrimaryKeyring:
1497             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1498             sl->flags=2;
1499             break;
1500           case oShowKeyring:
1501             deprecated_warning(configname,configlineno,"--show-keyring",
1502                                "--list-options ","show-keyring");
1503             opt.list_options|=LIST_SHOW_KEYRING;
1504             break;
1505           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1506           case oDebugAll: opt.debug = ~0; break;
1507           case oStatusFD:
1508             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1509             break;
1510 #ifdef __riscos__
1511           case oStatusFile:
1512             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1513             break;
1514 #endif /* __riscos__ */
1515           case oAttributeFD:
1516             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1517             break;
1518 #ifdef __riscos__
1519           case oAttributeFile:
1520             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1521             break;
1522 #endif /* __riscos__ */
1523           case oLoggerFD:
1524             log_set_logfile( NULL,
1525                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1526             break;
1527 #ifdef __riscos__
1528           case oLoggerFile:
1529             log_set_logfile( NULL,
1530                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1531             break;
1532 #endif /* __riscos__ */
1533           case oWithFingerprint:
1534             opt.with_fingerprint = 1;
1535             with_fpr=1; /*fall thru*/
1536           case oFingerprint: opt.fingerprint++; break;
1537           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1538           case oOptions:
1539             /* config files may not be nested (silently ignore them) */
1540             if( !configfp ) {
1541                 m_free(configname);
1542                 configname = m_strdup(pargs.r.ret_str);
1543                 goto next_pass;
1544             }
1545             break;
1546           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1547           case oNoDefKeyring: default_keyring = 0; break;
1548           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1549           case oNoGreeting: nogreeting = 1; break;
1550           case oNoVerbose: g10_opt_verbose = 0;
1551                            opt.verbose = 0; opt.list_sigs=0; break;
1552           case oQuickRandom: quick_random_gen(1); break;
1553           case oSKComments: opt.sk_comments=1; break;
1554           case oNoSKComments: opt.sk_comments=0; break;
1555           case oEmitVersion: opt.no_version=0; break;
1556           case oNoEmitVersion: opt.no_version=1; break;
1557           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1558           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1559           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1560           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1561           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1562           case oDefRecipient:
1563                     if( *pargs.r.ret_str )
1564                         opt.def_recipient = make_username(pargs.r.ret_str);
1565                     break;
1566           case oDefRecipientSelf:
1567                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1568                     opt.def_recipient_self = 1;
1569                     break;
1570           case oNoDefRecipient:
1571                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1572                     opt.def_recipient_self = 0;
1573                     break;
1574           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1575           case oHomedir: break;
1576           case oNoBatch: opt.batch = 0; break;
1577           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1578           case oWithColons: opt.with_colons=':'; break;
1579
1580           case oSkipVerify: opt.skip_verify=1; break;
1581           case oCompressKeys: opt.compress_keys = 1; break;
1582           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1583             /* There are many programs (like mutt) that call gpg with
1584                --always-trust so keep this option around for a long
1585                time. */
1586           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1587           case oTrustModel:
1588             if(ascii_strcasecmp(pargs.r.ret_str,"pgp")==0)
1589               opt.trust_model=TM_PGP;
1590             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1591               opt.trust_model=TM_CLASSIC;
1592             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1593               opt.trust_model=TM_ALWAYS;
1594             else if(ascii_strcasecmp(pargs.r.ret_str,"auto")==0)
1595               opt.trust_model=TM_AUTO;
1596             else
1597               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1598             break;
1599           case oForceOwnertrust:
1600             log_info(_("NOTE: %s is not for normal use!\n"),
1601                      "--force-ownertrust");
1602             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
1603             if(opt.force_ownertrust==-1)
1604               {
1605                 log_error("invalid ownertrust \"%s\"\n",pargs.r.ret_str);
1606                 opt.force_ownertrust=0;
1607               }
1608             break;
1609           case oLoadExtension:
1610 #ifndef __riscos__
1611 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
1612             if(check_permissions(pargs.r.ret_str,2))
1613               log_info(_("cipher extension \"%s\" not loaded due to "
1614                          "unsafe permissions\n"),pargs.r.ret_str);
1615             else
1616               register_cipher_extension(orig_argc? *orig_argv:NULL,
1617                                         pargs.r.ret_str);
1618 #endif
1619 #else /* __riscos__ */
1620             riscos_not_implemented("load-extension");
1621 #endif /* __riscos__ */
1622             break;
1623           case oRFC1991:
1624             opt.compliance = CO_RFC1991;
1625             opt.force_v4_certs = 0;
1626             opt.escape_from = 1;
1627             break;
1628           case oRFC2440:
1629           case oOpenPGP:
1630             /* TODO: When 2440bis becomes a RFC, these may need
1631                changing. */
1632             opt.compliance = CO_RFC2440;
1633             opt.allow_non_selfsigned_uid = 1;
1634             opt.allow_freeform_uid = 1;
1635             opt.pgp2_workarounds = 0;
1636             opt.escape_from = 0;
1637             opt.force_v3_sigs = 0;
1638             opt.compress_keys = 0;          /* not mandated  but we do it */
1639             opt.compress_sigs = 0;          /* ditto. */
1640             opt.not_dash_escaped = 0;
1641             opt.def_cipher_algo = 0;
1642             opt.def_digest_algo = 0;
1643             opt.cert_digest_algo = 0;
1644             opt.def_compress_algo = -1;
1645             opt.s2k_mode = 3; /* iterated+salted */
1646             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1647             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1648             break;
1649           case oPGP2:  opt.compliance = CO_PGP2;  break;
1650           case oPGP6:  opt.compliance = CO_PGP6;  break;
1651           case oPGP7:  opt.compliance = CO_PGP7;  break;
1652           case oPGP8:  opt.compliance = CO_PGP8;  break;
1653           case oGnuPG: opt.compliance = CO_GNUPG; break;
1654           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1655           case oCompressSigs: opt.compress_sigs = 1; break;
1656           case oRunAsShmCP:
1657 #ifndef __riscos__
1658 # ifndef USE_SHM_COPROCESSING
1659             /* not possible in the option file,
1660              * but we print the warning here anyway */
1661             log_error("shared memory coprocessing is not available\n");
1662 # endif
1663 #else /* __riscos__ */
1664             riscos_not_implemented("run-as-shm-coprocess");
1665 #endif /* __riscos__ */
1666             break;
1667           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1668           case oForYourEyesOnly: eyes_only = 1; break;
1669           case oNoForYourEyesOnly: eyes_only = 0; break;
1670           case oSetPolicyURL:
1671             add_policy_url(pargs.r.ret_str,0);
1672             add_policy_url(pargs.r.ret_str,1);
1673             break;
1674           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1675           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1676           case oShowPolicyURL:
1677             deprecated_warning(configname,configlineno,"--show-policy-url",
1678                                "--list-options ","show-policy-url");
1679             deprecated_warning(configname,configlineno,"--show-policy-url",
1680                                "--verify-options ","show-policy-url");
1681             opt.list_options|=LIST_SHOW_POLICY;
1682             opt.verify_options|=VERIFY_SHOW_POLICY;
1683             break;
1684           case oNoShowPolicyURL:
1685             deprecated_warning(configname,configlineno,"--no-show-policy-url",
1686                                "--list-options ","no-show-policy-url");
1687             deprecated_warning(configname,configlineno,"--no-show-policy-url",
1688                                "--verify-options ","no-show-policy-url");
1689             opt.list_options&=~LIST_SHOW_POLICY;
1690             opt.verify_options&=~VERIFY_SHOW_POLICY;
1691             break;
1692           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
1693           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1694           case oComment:
1695             if(pargs.r.ret_str[0])
1696               add_to_strlist(&opt.comments,pargs.r.ret_str);
1697             break;
1698           case oDefaultComment:
1699             deprecated_warning(configname,configlineno,
1700                                "--default-comment","--no-comments","");
1701             /* fall through */
1702           case oNoComments:
1703             free_strlist(opt.comments);
1704             opt.comments=NULL;
1705             break;
1706           case oThrowKeyid: opt.throw_keyid = 1; break;
1707           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1708           case oShowPhotos:
1709             deprecated_warning(configname,configlineno,"--show-photos",
1710                                "--list-options ","show-photos");
1711             deprecated_warning(configname,configlineno,"--show-photos",
1712                                "--verify-options ","show-photos");
1713             opt.list_options|=LIST_SHOW_PHOTOS;
1714             opt.verify_options|=VERIFY_SHOW_PHOTOS;
1715             break;
1716           case oNoShowPhotos:
1717             deprecated_warning(configname,configlineno,"--no-show-photos",
1718                                "--list-options ","no-show-photos");
1719             deprecated_warning(configname,configlineno,"--no-show-photos",
1720                                "--verify-options ","no-show-photos");
1721             opt.list_options&=~LIST_SHOW_PHOTOS;
1722             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
1723             break;
1724           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1725           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1726           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1727           case oForceV4Certs: opt.force_v4_certs = 1; break;
1728           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1729           case oForceMDC: opt.force_mdc = 1; break;
1730           case oNoForceMDC: opt.force_mdc = 0; break;
1731           case oDisableMDC: opt.disable_mdc = 1; break;
1732           case oNoDisableMDC: opt.disable_mdc = 0; break;
1733           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1734           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1735           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1736           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1737           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1738           case oEncryptTo: /* store the recipient in the second list */
1739             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1740             sl->flags = 1;
1741             break;
1742           case oHiddenEncryptTo: /* store the recipient in the second list */
1743             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1744             sl->flags = 1|2;
1745             break;
1746           case oRecipient: /* store the recipient */
1747             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1748             any_explicit_recipient = 1;
1749             break;
1750           case oHiddenRecipient: /* store the recipient with a flag */
1751             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1752             sl->flags = 2;
1753             any_explicit_recipient = 1;
1754             break;
1755           case oTextmodeShort: opt.textmode = 2; break;
1756           case oTextmode: opt.textmode=1;  break;
1757           case oNoTextmode: opt.textmode=0;  break;
1758           case oExpert: opt.expert = 1; break;
1759           case oNoExpert: opt.expert = 0; break;
1760           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1761           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1762           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1763           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1764           case oUser: /* store the local users */
1765             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1766             break;
1767           case oCompress: opt.compress = pargs.r.ret_int; break;
1768           case oPasswdFD:
1769             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1770             opt.use_agent = 0;
1771             break;
1772 #ifdef __riscos__
1773           case oPasswdFile:
1774             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1775             break;
1776 #endif /* __riscos__ */
1777           case oCommandFD:
1778             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1779             break;
1780 #ifdef __riscos__
1781           case oCommandFile:
1782             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1783             break;
1784 #endif /* __riscos__ */
1785           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1786           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1787           case oCompressAlgo:
1788             /* If it is all digits, stick a Z in front of it for
1789                later.  This is for backwards compatibility with
1790                versions that took the compress algorithm number. */
1791             {
1792               char *pt=pargs.r.ret_str;
1793               while(*pt)
1794                 {
1795                   if(!isdigit(*pt))
1796                     break;
1797
1798                   pt++;
1799                 }
1800
1801               if(*pt=='\0')
1802                 {
1803                   def_compress_string=m_alloc(strlen(pargs.r.ret_str)+2);
1804                   strcpy(def_compress_string,"Z");
1805                   strcat(def_compress_string,pargs.r.ret_str);
1806                 }
1807               else
1808                 def_compress_string = m_strdup(pargs.r.ret_str);
1809             }
1810             break;
1811           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1812           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1813           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1814           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1815           case oCharset:
1816             if( set_native_charset( pargs.r.ret_str ) )
1817                 log_error(_("%s is not a valid character set\n"),
1818                                                     pargs.r.ret_str);
1819             break;
1820           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1821           case oEscapeFrom: opt.escape_from = 1; break;
1822           case oNoEscapeFrom: opt.escape_from = 0; break;
1823           case oLockOnce: opt.lock_once = 1; break;
1824           case oLockNever: disable_dotlock(); break;
1825           case oLockMultiple:
1826 #ifndef __riscos__
1827             opt.lock_once = 0;
1828 #else /* __riscos__ */
1829             riscos_not_implemented("lock-multiple");
1830 #endif /* __riscos__ */
1831             break;
1832           case oKeyServer:
1833             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1834             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1835               log_error(_("could not parse keyserver URI\n"));
1836             break;
1837           case oKeyServerOptions:
1838             parse_keyserver_options(pargs.r.ret_str);
1839             break;
1840           case oImportOptions:
1841             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1842               {
1843                 if(configname)
1844                   log_error(_("%s:%d: invalid import options\n"),
1845                             configname,configlineno);
1846                 else
1847                   log_error(_("invalid import options\n"));
1848               }
1849             break;
1850           case oExportOptions:
1851             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1852               {
1853                 if(configname)
1854                   log_error(_("%s:%d: invalid export options\n"),
1855                             configname,configlineno);
1856                 else
1857                   log_error(_("invalid export options\n"));
1858               }
1859             break;
1860           case oListOptions:
1861             {
1862               struct parse_options lopts[]=
1863                 {
1864                   {"show-photos",LIST_SHOW_PHOTOS},
1865                   {"show-policy-url",LIST_SHOW_POLICY},
1866                   {"show-notation",LIST_SHOW_NOTATION},
1867                   {"show-keyserver-url",LIST_SHOW_KEYSERVER},
1868                   {"show-validity",LIST_SHOW_VALIDITY},
1869                   {"show-long-keyid",LIST_SHOW_LONG_KEYID},
1870                   {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS},
1871                   {"show-keyring",LIST_SHOW_KEYRING},
1872                   {"show-sig-expire",LIST_SHOW_SIG_EXPIRE},
1873                   {NULL,0}
1874                 };
1875
1876               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts))
1877                 {
1878                   if(configname)
1879                     log_error(_("%s:%d: invalid list options\n"),
1880                               configname,configlineno);
1881                   else
1882                     log_error(_("invalid list options\n"));
1883                 }
1884             }
1885             break;
1886           case oVerifyOptions:
1887             {
1888               struct parse_options vopts[]=
1889                 {
1890                   {"show-photos",VERIFY_SHOW_PHOTOS},
1891                   {"show-policy-url",VERIFY_SHOW_POLICY},
1892                   {"show-notation",VERIFY_SHOW_NOTATION},
1893                   {"show-keyserver-url",VERIFY_SHOW_KEYSERVER},
1894                   {"show-validity",VERIFY_SHOW_VALIDITY},
1895                   {"show-long-keyid",VERIFY_SHOW_LONG_KEYID},
1896                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS},
1897                   {NULL,0}
1898                 };
1899
1900               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts))
1901                 {
1902                   if(configname)
1903                     log_error(_("%s:%d: invalid verify options\n"),
1904                               configname,configlineno);
1905                   else
1906                     log_error(_("invalid verify options\n"));
1907                 }
1908             }
1909             break;
1910           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1911           case oExecPath:
1912             if(set_exec_path(pargs.r.ret_str,0))
1913               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1914             else
1915               opt.exec_path_set=1;
1916             break;
1917           case oSetNotation:
1918             add_notation_data( pargs.r.ret_str, 0 );
1919             add_notation_data( pargs.r.ret_str, 1 );
1920             break;
1921           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1922           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1923           case oShowNotation:
1924             deprecated_warning(configname,configlineno,"--show-notation",
1925                                "--list-options ","show-notation");
1926             deprecated_warning(configname,configlineno,"--show-notation",
1927                                "--verify-options ","show-notation");
1928             opt.list_options|=LIST_SHOW_NOTATION;
1929             opt.verify_options|=VERIFY_SHOW_NOTATION;
1930             break;
1931           case oNoShowNotation:
1932             deprecated_warning(configname,configlineno,"--no-show-notation",
1933                                "--list-options ","no-show-notation");
1934             deprecated_warning(configname,configlineno,"--no-show-notation",
1935                                "--verify-options ","no-show-notation");
1936             opt.list_options&=~LIST_SHOW_NOTATION;
1937             opt.verify_options&=~VERIFY_SHOW_NOTATION;
1938             break;
1939           case oUtf8Strings: utf8_strings = 1; break;
1940           case oNoUtf8Strings: utf8_strings = 0; break;
1941           case oDisableCipherAlgo:
1942                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1943                 break;
1944           case oDisablePubkeyAlgo:
1945                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1946                 break;
1947           case oNoSigCache: opt.no_sig_cache = 1; break;
1948           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1949           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1950           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1951           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1952           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1953           case oNoLiteral: opt.no_literal = 1; break;
1954           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1955           case oHonorHttpProxy:
1956                 opt.keyserver_options.honor_http_proxy = 1;
1957                 deprecated_warning(configname,configlineno,
1958                                    "--honor-http-proxy",
1959                                    "--keyserver-options ",
1960                                    "honor-http-proxy");
1961                 break;
1962           case oFastListMode: opt.fast_list_mode = 1; break;
1963           case oFixedListMode: opt.fixed_list_mode = 1; break;
1964           case oListOnly: opt.list_only=1; break;
1965           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1966           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1967           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1968           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1969           case oNoRandomSeedFile: use_random_seed = 0; break;
1970           case oAutoKeyRetrieve:
1971           case oNoAutoKeyRetrieve:
1972                 opt.keyserver_options.auto_key_retrieve=
1973                                              (pargs.r_opt==oAutoKeyRetrieve);
1974                 deprecated_warning(configname,configlineno,
1975                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1976                                "--no-auto-key-retrieve","--keyserver-options ",
1977                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1978                                "no-auto-key-retrieve");
1979                 break;
1980           case oShowSessionKey: opt.show_session_key = 1; break;
1981           case oOverrideSessionKey:
1982                 opt.override_session_key = pargs.r.ret_str;
1983                 break;
1984           case oMergeOnly: opt.merge_only = 1; break;
1985           case oAllowSecretKeyImport: /* obsolete */ break;
1986           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1987           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1988           case oEnableSpecialFilenames:
1989             iobuf_enable_special_filenames (1);
1990             break;
1991           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1992           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1993           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1994           case oPreservePermissions: opt.preserve_permissions=1; break;
1995           case oDefaultPreferenceList:
1996             opt.def_preference_list = pargs.r.ret_str;
1997             break;
1998           case oPersonalCipherPreferences:
1999             pers_cipher_list=pargs.r.ret_str;
2000             break;
2001           case oPersonalDigestPreferences:
2002             pers_digest_list=pargs.r.ret_str;
2003             break;
2004           case oPersonalCompressPreferences:
2005             pers_compress_list=pargs.r.ret_str;
2006             break;
2007           case oDisplay: opt.display = pargs.r.ret_str; break;
2008           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2009           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2010           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2011           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2012           case oGroup: add_group(pargs.r.ret_str); break;
2013           case oNoGroups:
2014             while(opt.grouplist)
2015               {
2016                 struct groupitem *iter=opt.grouplist;
2017                 free_strlist(iter->values);
2018                 opt.grouplist=opt.grouplist->next;
2019                 m_free(iter);
2020               }
2021             break;
2022           case oStrict: opt.strict=1; log_set_strict(1); break;
2023           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2024           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2025           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2026           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2027           case oMultifile: multifile=1; break;
2028
2029           default : pargs.err = configfp? 1:2; break;
2030           }
2031       }
2032
2033     if( configfp ) {
2034         fclose( configfp );
2035         configfp = NULL;
2036         m_free(configname); configname = NULL;
2037         goto next_pass;
2038     }
2039     m_free( configname ); configname = NULL;
2040     if( log_get_errorcount(0) )
2041         g10_exit(2);
2042     if( nogreeting )
2043         greeting = 0;
2044
2045     if( greeting ) {
2046         fprintf(stderr, "%s %s; %s\n",
2047                         strusage(11), strusage(13), strusage(14) );
2048         fprintf(stderr, "%s\n", strusage(15) );
2049     }
2050 #ifdef IS_DEVELOPMENT_VERSION
2051     if( !opt.batch ) {
2052         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
2053         log_info("It is only intended for test purposes and should NOT be\n");
2054         log_info("used in a production environment or with production keys!\n");
2055     }
2056 #endif
2057
2058     if (opt.verbose > 2)
2059         log_info ("using character set `%s'\n", get_native_charset ());
2060
2061     if( may_coredump && !opt.quiet )
2062         log_info(_("WARNING: program may create a core file!\n"));
2063
2064     if (eyes_only) {
2065       if (opt.set_filename)
2066           log_info(_("WARNING: %s overrides %s\n"),
2067                    "--for-your-eyes-only","--set-filename");
2068
2069       opt.set_filename="_CONSOLE";
2070     }
2071
2072     if (opt.no_literal) {
2073         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2074         if (opt.textmode)
2075             log_error(_("%s not allowed with %s!\n"),
2076                        "--textmode", "--no-literal" );
2077         if (opt.set_filename)
2078             log_error(_("%s makes no sense with %s!\n"),
2079                         eyes_only?"--for-your-eyes-only":"--set-filename",
2080                         "--no-literal" );
2081     }
2082
2083     if (opt.set_filesize)
2084         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2085     if( opt.batch )
2086         tty_batchmode( 1 );
2087
2088     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2089
2090     set_debug();
2091
2092     /* Do these after the switch(), so they can override settings. */
2093     if(PGP2)
2094       {
2095         int unusable=0;
2096
2097         if(cmd==aSign && !detached_sig)
2098           {
2099             log_info(_("you can only make detached or clear signatures "
2100                        "while in --pgp2 mode\n"));
2101             unusable=1;
2102           }
2103         else if(cmd==aSignEncr || cmd==aSignSym)
2104           {
2105             log_info(_("you can't sign and encrypt at the "
2106                        "same time while in --pgp2 mode\n"));
2107             unusable=1;
2108           }
2109         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2110           {
2111             log_info(_("you must use files (and not a pipe) when "
2112                        "working with --pgp2 enabled.\n"));
2113             unusable=1;
2114           }
2115         else if(cmd==aEncr || cmd==aSym)
2116           {
2117             /* Everything else should work without IDEA (except using
2118                a secret key encrypted with IDEA and setting an IDEA
2119                preference, but those have their own error
2120                messages). */
2121
2122             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2123               {
2124                 log_info(_("encrypting a message in --pgp2 mode requires "
2125                            "the IDEA cipher\n"));
2126                 idea_cipher_warn(1);
2127                 unusable=1;
2128               }
2129             else if(cmd==aSym)
2130               {
2131                 /* This only sets IDEA for symmetric encryption
2132                    since it is set via select_algo_from_prefs for
2133                    pk encryption. */
2134                 m_free(def_cipher_string);
2135                 def_cipher_string = m_strdup("idea");
2136               }
2137
2138             /* PGP2 can't handle the output from the textmode
2139                filter, so we disable it for anything that could
2140                create a literal packet (only encryption and
2141                symmetric encryption, since we disable signing
2142                above). */
2143             if(!unusable)
2144               opt.textmode=0;
2145           }
2146
2147         if(unusable)
2148           compliance_failure();
2149         else
2150           {
2151             opt.force_v4_certs = 0;
2152             opt.sk_comments = 0;
2153             opt.escape_from = 1;
2154             opt.force_v3_sigs = 1;
2155             opt.pgp2_workarounds = 1;
2156             opt.ask_sig_expire = 0;
2157             opt.ask_cert_expire = 0;
2158             m_free(def_digest_string);
2159             def_digest_string = m_strdup("md5");
2160             opt.def_compress_algo = 1;
2161           }
2162       }
2163     else if(PGP6)
2164       {
2165         opt.sk_comments=0;
2166         opt.escape_from=1;
2167         opt.force_v3_sigs=1;
2168         opt.ask_sig_expire=0;
2169       }
2170     else if(PGP7)
2171       {
2172         opt.sk_comments=0;
2173         opt.escape_from=1;
2174         opt.force_v3_sigs=1;
2175         opt.ask_sig_expire=0;
2176       }
2177     else if(PGP8)
2178       {
2179         opt.escape_from=1;
2180       }
2181
2182     /* must do this after dropping setuid, because string_to...
2183      * may try to load an module */
2184     if( def_cipher_string ) {
2185         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2186         if(opt.def_cipher_algo==0 &&
2187            (ascii_strcasecmp(def_cipher_string,"idea")==0
2188             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2189           idea_cipher_warn(1);
2190         m_free(def_cipher_string); def_cipher_string = NULL;
2191         if( check_cipher_algo(opt.def_cipher_algo) )
2192             log_error(_("selected cipher algorithm is invalid\n"));
2193     }
2194     if( def_digest_string ) {
2195         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2196         m_free(def_digest_string); def_digest_string = NULL;
2197         if( check_digest_algo(opt.def_digest_algo) )
2198             log_error(_("selected digest algorithm is invalid\n"));
2199     }
2200     if( def_compress_string ) {
2201         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
2202         m_free(def_compress_string); def_compress_string = NULL;
2203         if( check_compress_algo(opt.def_compress_algo) )
2204             log_error(_("selected compression algorithm is invalid\n"));
2205     }
2206     if( cert_digest_string ) {
2207         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2208         m_free(cert_digest_string); cert_digest_string = NULL;
2209         if( check_digest_algo(opt.cert_digest_algo) )
2210             log_error(_("selected certification digest algorithm is invalid\n"));
2211     }
2212     if( s2k_cipher_string ) {
2213         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2214         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2215         if( check_cipher_algo(opt.s2k_cipher_algo) )
2216             log_error(_("selected cipher algorithm is invalid\n"));
2217     }
2218     if( s2k_digest_string ) {
2219         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2220         m_free(s2k_digest_string); s2k_digest_string = NULL;
2221         if( check_digest_algo(opt.s2k_digest_algo) )
2222             log_error(_("selected digest algorithm is invalid\n"));
2223     }
2224     if( opt.completes_needed < 1 )
2225         log_error(_("completes-needed must be greater than 0\n"));
2226     if( opt.marginals_needed < 2 )
2227         log_error(_("marginals-needed must be greater than 1\n"));
2228     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2229         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2230     switch( opt.s2k_mode ) {
2231       case 0:
2232         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2233         break;
2234       case 1: case 3: break;
2235       default:
2236         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2237     }
2238
2239     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2240       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2241
2242     /* This isn't actually needed, but does serve to error out if the
2243        string is invalid. */
2244     if(opt.def_preference_list &&
2245         keygen_set_std_prefs(opt.def_preference_list,0))
2246       log_error(_("invalid default preferences\n"));
2247
2248     /* We provide defaults for the personal digest list */
2249     if(!pers_digest_list)
2250       pers_digest_list="h2";
2251
2252     if(pers_cipher_list &&
2253        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2254       log_error(_("invalid personal cipher preferences\n"));
2255
2256     if(pers_digest_list &&
2257        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2258       log_error(_("invalid personal digest preferences\n"));
2259
2260     if(pers_compress_list &&
2261        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2262       log_error(_("invalid personal compress preferences\n"));
2263
2264     /* We don't support all possible commands with multifile yet */
2265     if(multifile)
2266       {
2267         char *cmdname;
2268
2269         switch(cmd)
2270           {
2271           case aSign:
2272             cmdname="--sign";
2273             break;
2274           case aClearsign:
2275             cmdname="--clearsign";
2276             break;
2277           case aDetachedSign:
2278             cmdname="--detach-sign";
2279             break;
2280           case aSym:
2281             cmdname="--symmetric";
2282             break;
2283           case aEncrSym:
2284             cmdname="--symmetric --encrypt";
2285             break;
2286           case aStore:
2287             cmdname="--store";
2288             break;
2289           default:
2290             cmdname=NULL;
2291             break;
2292           }
2293
2294         if(cmdname)
2295           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2296       }
2297
2298     if( log_get_errorcount(0) )
2299         g10_exit(2);
2300
2301     /* Check our chosen algorithms against the list of legal
2302        algorithms. */
2303
2304     if(!GNUPG)
2305       {
2306         const char *badalg=NULL;
2307         preftype_t badtype=PREFTYPE_NONE;
2308
2309         if(opt.def_cipher_algo
2310            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2311           {
2312             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2313             badtype=PREFTYPE_SYM;
2314           }
2315         else if(opt.def_digest_algo
2316                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2317           {
2318             badalg=digest_algo_to_string(opt.def_digest_algo);
2319             badtype=PREFTYPE_HASH;
2320           }
2321         else if(opt.cert_digest_algo
2322                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2323           {
2324             badalg=digest_algo_to_string(opt.cert_digest_algo);
2325             badtype=PREFTYPE_HASH;
2326           }
2327         else if(opt.def_compress_algo!=-1
2328                 && !algo_available(PREFTYPE_ZIP,opt.def_compress_algo,NULL))
2329           {
2330             badalg=compress_algo_to_string(opt.def_compress_algo);
2331             badtype=PREFTYPE_ZIP;
2332           }
2333
2334         if(badalg)
2335           {
2336             switch(badtype)
2337               {
2338               case PREFTYPE_SYM:
2339                 log_info(_("you may not use cipher algorithm \"%s\" "
2340                            "while in %s mode\n"),
2341                          badalg,compliance_option_string());
2342                 break;
2343               case PREFTYPE_HASH:
2344                 log_info(_("you may not use digest algorithm \"%s\" "
2345                            "while in %s mode\n"),
2346                          badalg,compliance_option_string());
2347                 break;
2348               case PREFTYPE_ZIP:
2349                 log_info(_("you may not use compression algorithm \"%s\" "
2350                            "while in %s mode\n"),
2351                          badalg,compliance_option_string());
2352                 break;
2353               default:
2354                 BUG();
2355               }
2356
2357             compliance_failure();
2358           }
2359       }
2360
2361     /* set the random seed file */
2362     if( use_random_seed ) {
2363         char *p = make_filename(opt.homedir, "random_seed", NULL );
2364         set_random_seed_file(p);
2365         m_free(p);
2366     }
2367
2368     if( !cmd && opt.fingerprint && !with_fpr ) {
2369         set_cmd( &cmd, aListKeys);
2370     }
2371
2372     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2373         if( cmd == aKModeC ) {
2374             opt.fingerprint = 1;
2375             cmd = aKMode;
2376         }
2377         opt.list_sigs = 0;
2378         if( opt.verbose > 2 )
2379             opt.check_sigs++;
2380         if( opt.verbose > 1 )
2381             opt.list_sigs++;
2382
2383         opt.verbose = opt.verbose > 1;
2384         g10_opt_verbose = opt.verbose;
2385     }
2386
2387     /* Compression algorithm 0 means no compression at all */
2388     if( opt.def_compress_algo == 0)
2389         opt.compress = 0;
2390
2391     /* kludge to let -sat generate a clear text signature */
2392     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2393         cmd = aClearsign;
2394
2395     if( opt.verbose > 1 )
2396         set_packet_list_mode(1);
2397
2398     /* Add the keyrings, but not for some special commands and not in
2399        case of "-kvv userid keyring".  Also avoid adding the secret
2400        keyring for a couple of commands to avoid unneeded access in
2401        case the secrings are stored on a floppy */
2402     if( cmd != aDeArmor && cmd != aEnArmor
2403         && !(cmd == aKMode && argc == 2 ) ) 
2404       {
2405         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2406             && cmd != aVerify && cmd != aSym)
2407           {
2408             if (!sec_nrings || default_keyring) /* add default secret rings */
2409               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2410             for (sl = sec_nrings; sl; sl = sl->next)
2411               keydb_add_resource ( sl->d, 0, 1 );
2412           }
2413         if( !nrings || default_keyring )  /* add default ring */
2414             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2415         for(sl = nrings; sl; sl = sl->next )
2416             keydb_add_resource ( sl->d, sl->flags, 0 );
2417       }
2418     FREE_STRLIST(nrings);
2419     FREE_STRLIST(sec_nrings);
2420
2421
2422     if( pwfd != -1 )  /* read the passphrase now. */
2423         read_passphrase_from_fd( pwfd );
2424
2425     fname = argc? *argv : NULL;
2426
2427     switch( cmd ) {
2428       case aPrimegen:
2429       case aPrintMD:
2430       case aPrintMDs:
2431       case aGenRandom:
2432       case aDeArmor:
2433       case aEnArmor:
2434       case aFixTrustDB:
2435         break;
2436       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2437       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2438       default: rc = setup_trustdb(1, trustdb_name ); break;
2439     }
2440     if( rc )
2441         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2442
2443
2444     switch (cmd) {
2445       case aStore: 
2446       case aSym:  
2447       case aSign: 
2448       case aSignSym: 
2449       case aClearsign: 
2450         if (!opt.quiet && any_explicit_recipient)
2451           log_info (_("WARNING: recipients (-r) given "
2452                       "without using public key encryption\n"));
2453         break;
2454       default:
2455         break;
2456     }
2457
2458     switch( cmd ) {
2459       case aStore: /* only store the file */
2460         if( argc > 1 )
2461             wrong_args(_("--store [filename]"));
2462         if( (rc = encode_store(fname)) )
2463             log_error_f( print_fname_stdin(fname),
2464                         "store failed: %s\n", g10_errstr(rc) );
2465         break;
2466       case aSym: /* encrypt the given file only with the symmetric cipher */
2467         if( argc > 1 )
2468             wrong_args(_("--symmetric [filename]"));
2469         if( (rc = encode_symmetric(fname)) )
2470             log_error_f(print_fname_stdin(fname),
2471                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2472         break;
2473
2474       case aEncr: /* encrypt the given file */
2475         if(multifile)
2476           encode_crypt_files(argc, argv, remusr);
2477         else
2478           {
2479             if( argc > 1 )
2480               wrong_args(_("--encrypt [filename]"));
2481             if( (rc = encode_crypt(fname,remusr,0)) )
2482               log_error("%s: encryption failed: %s\n",
2483                         print_fname_stdin(fname), g10_errstr(rc) );
2484           }
2485         break;
2486
2487       case aEncrSym:
2488         /* This works with PGP 8 in the sense that it acts just like a
2489            symmetric message.  It doesn't work at all with 2 or 6.  It
2490            might work with 7, but alas, I don't have a copy to test
2491            with right now. */
2492         if( argc > 1 )
2493           wrong_args(_("--symmetric --encrypt [filename]"));
2494         else if(opt.s2k_mode==0)
2495           log_error(_("you cannot use --symmetric --encrypt"
2496                       " with --s2k-mode 0\n"));
2497         else if(PGP2 || PGP6 || PGP7 || RFC1991)
2498           log_error(_("you cannot use --symmetric --encrypt"
2499                       " while in %s mode\n"),compliance_option_string());
2500         else
2501           {
2502             if( (rc = encode_crypt(fname,remusr,1)) )
2503               log_error("%s: encryption failed: %s\n",
2504                         print_fname_stdin(fname), g10_errstr(rc) );
2505           }
2506         break;
2507
2508       case aSign: /* sign the given file */
2509         sl = NULL;
2510         if( detached_sig ) { /* sign all files */
2511             for( ; argc; argc--, argv++ )
2512                 add_to_strlist( &sl, *argv );
2513         }
2514         else {
2515             if( argc > 1 )
2516                 wrong_args(_("--sign [filename]"));
2517             if( argc ) {
2518                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2519                 strcpy(sl->d, fname);
2520             }
2521         }
2522         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2523             log_error("signing failed: %s\n", g10_errstr(rc) );
2524         free_strlist(sl);
2525         break;
2526
2527       case aSignEncr: /* sign and encrypt the given file */
2528         if( argc > 1 )
2529             wrong_args(_("--sign --encrypt [filename]"));
2530         if( argc ) {
2531             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2532             strcpy(sl->d, fname);
2533         }
2534         else
2535             sl = NULL;
2536         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2537             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2538         free_strlist(sl);
2539         break;
2540
2541       case aSignSym: /* sign and conventionally encrypt the given file */
2542         if (argc > 1)
2543             wrong_args(_("--sign --symmetric [filename]"));
2544         rc = sign_symencrypt_file (fname, locusr);
2545         if (rc)
2546             log_error("%s: sign+symmetric failed: %s\n",
2547                       print_fname_stdin(fname), g10_errstr(rc) );
2548         break;
2549
2550       case aClearsign: /* make a clearsig */
2551         if( argc > 1 )
2552             wrong_args(_("--clearsign [filename]"));
2553         if( (rc = clearsign_file(fname, locusr, NULL)) )
2554             log_error("%s: clearsign failed: %s\n",
2555                       print_fname_stdin(fname), g10_errstr(rc) );
2556         break;
2557
2558       case aVerify:
2559         if(multifile)
2560           {
2561             if( (rc = verify_files( argc, argv ) ))
2562               log_error("verify files failed: %s\n", g10_errstr(rc) );
2563           }
2564         else
2565           {
2566             if( (rc = verify_signatures( argc, argv ) ))
2567               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2568           }
2569         break;
2570
2571       case aDecrypt:
2572         if(multifile)
2573           decrypt_messages(argc, argv);
2574         else
2575           {
2576             if( argc > 1 )
2577               wrong_args(_("--decrypt [filename]"));
2578             if( (rc = decrypt_message( fname ) ))
2579               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2580           }
2581         break;
2582             
2583       case aSignKey: /* sign the key given as argument */
2584         if( argc != 1 )
2585             wrong_args(_("--sign-key user-id"));
2586         username = make_username( fname );
2587         keyedit_menu(fname, locusr, NULL, 1 );
2588         m_free(username);
2589         break;
2590
2591       case aLSignKey:
2592         if( argc != 1 )
2593             wrong_args(_("--lsign-key user-id"));
2594         username = make_username( fname );
2595         keyedit_menu(fname, locusr, NULL, 2 );
2596         m_free(username);
2597         break;
2598
2599       case aNRSignKey:
2600         if( argc != 1 )
2601             wrong_args(_("--nrsign-key user-id"));
2602         username = make_username( fname );
2603         keyedit_menu(fname, locusr, NULL, 3 );
2604         m_free(username);
2605         break;
2606
2607       case aNRLSignKey:
2608         if( argc != 1 )
2609             wrong_args(_("--nrlsign-key user-id"));
2610         username = make_username( fname );
2611         keyedit_menu(fname, locusr, NULL, 4 );
2612         m_free(username);
2613         break;
2614
2615       case aEditKey: /* Edit a key signature */
2616         if( !argc )
2617             wrong_args(_("--edit-key user-id [commands]"));
2618         username = make_username( fname );
2619         if( argc > 1 ) {
2620             sl = NULL;
2621             for( argc--, argv++ ; argc; argc--, argv++ )
2622                 append_to_strlist( &sl, *argv );
2623             keyedit_menu( username, locusr, sl, 0 );
2624             free_strlist(sl);
2625         }
2626         else
2627             keyedit_menu(username, locusr, NULL, 0 );
2628         m_free(username);
2629         break;
2630
2631       case aDeleteKeys:
2632       case aDeleteSecretKeys:
2633       case aDeleteSecretAndPublicKeys:
2634         sl = NULL;
2635         /* I'm adding these in reverse order as add_to_strlist2
2636            reverses them again, and it's easier to understand in the
2637            proper order :) */
2638         for( ; argc; argc-- )
2639           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2640         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2641         free_strlist(sl);
2642         break;
2643
2644       case aCheckKeys:
2645         opt.check_sigs = 1;
2646       case aListSigs:
2647         opt.list_sigs = 1;
2648       case aListKeys:
2649         sl = NULL;
2650         for( ; argc; argc--, argv++ )
2651             add_to_strlist2( &sl, *argv, utf8_strings );
2652         public_key_list( sl );
2653         free_strlist(sl);
2654         break;
2655       case aListSecretKeys:
2656         sl = NULL;
2657         for( ; argc; argc--, argv++ )
2658             add_to_strlist2( &sl, *argv, utf8_strings );
2659         secret_key_list( sl );
2660         free_strlist(sl);
2661         break;
2662
2663       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2664         if( argc < 2 ) { /* -kv [userid] */
2665             sl = NULL;
2666             if (argc && **argv)
2667                 add_to_strlist2( &sl, *argv, utf8_strings );
2668             public_key_list( sl );
2669             free_strlist(sl);
2670         }
2671         else if( argc == 2 ) { /* -kv userid keyring */
2672             if( access( argv[1], R_OK ) ) {
2673                 log_error(_("can't open %s: %s\n"),
2674                                print_fname_stdin(argv[1]), strerror(errno));
2675             }
2676             else {
2677                 /* add keyring (default keyrings are not registered in this
2678                  * special case */
2679                 keydb_add_resource( argv[1], 0, 0 );
2680                 sl = NULL;
2681                 if (**argv)
2682                     add_to_strlist2( &sl, *argv, utf8_strings );
2683                 public_key_list( sl );
2684                 free_strlist(sl);
2685             }
2686         }
2687         else
2688             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2689         break;
2690
2691       case aKeygen: /* generate a key */
2692         if( opt.batch ) {
2693             if( argc > 1 )
2694                 wrong_args("--gen-key [parameterfile]");
2695             generate_keypair( argc? *argv : NULL, NULL );
2696         }
2697         else {
2698             if( argc )
2699                 wrong_args("--gen-key");
2700             generate_keypair(NULL, NULL);
2701         }
2702         break;
2703
2704       case aFastImport:
2705         opt.import_options |= IMPORT_FAST_IMPORT;
2706       case aImport:
2707         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2708         break;
2709
2710       case aExport:
2711       case aExportAll:
2712       case aSendKeys:
2713       case aRecvKeys:
2714         sl = NULL;
2715         for( ; argc; argc--, argv++ )
2716             add_to_strlist2( &sl, *argv, utf8_strings );
2717         if( cmd == aSendKeys )
2718             rc=keyserver_export( sl );
2719         else if( cmd == aRecvKeys )
2720             rc=keyserver_import( sl );
2721         else
2722             rc=export_pubkeys( sl, opt.export_options );
2723         if(rc)
2724           {
2725             if(cmd==aSendKeys)
2726               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
2727             else if(cmd==aRecvKeys)
2728               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
2729             else
2730               log_error(_("key export failed: %s\n"),g10_errstr(rc));
2731           }
2732         free_strlist(sl);
2733         break;
2734
2735      case aSearchKeys:
2736         sl = NULL;
2737         for( ; argc; argc--, argv++ )
2738           append_to_strlist2( &sl, *argv, utf8_strings );
2739
2740         rc=keyserver_search( sl );
2741         if(rc)
2742           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
2743         free_strlist(sl);
2744         break;
2745
2746       case aRefreshKeys:
2747         sl = NULL;
2748         for( ; argc; argc--, argv++ )
2749             add_to_strlist2( &sl, *argv, utf8_strings );
2750         rc=keyserver_refresh(sl);
2751         if(rc)
2752           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
2753         free_strlist(sl);
2754         break;
2755
2756       case aExportSecret:
2757         sl = NULL;
2758         for( ; argc; argc--, argv++ )
2759             add_to_strlist2( &sl, *argv, utf8_strings );
2760         export_seckeys( sl );
2761         free_strlist(sl);
2762         break;
2763
2764       case aExportSecretSub:
2765         sl = NULL;
2766         for( ; argc; argc--, argv++ )
2767             add_to_strlist2( &sl, *argv, utf8_strings );
2768         export_secsubkeys( sl );
2769         free_strlist(sl);
2770         break;
2771
2772       case aGenRevoke:
2773         if( argc != 1 )
2774             wrong_args("--gen-revoke user-id");
2775         username =  make_username(*argv);
2776         gen_revoke( username );
2777         m_free( username );
2778         break;
2779
2780       case aDesigRevoke:
2781         if( argc != 1 )
2782             wrong_args("--desig-revoke user-id");
2783         username =  make_username(*argv);
2784         gen_desig_revoke( username );
2785         m_free( username );
2786         break;
2787
2788       case aDeArmor:
2789         if( argc > 1 )
2790             wrong_args("--dearmor [file]");
2791         rc = dearmor_file( argc? *argv: NULL );
2792         if( rc )
2793             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2794         break;
2795
2796       case aEnArmor:
2797         if( argc > 1 )
2798             wrong_args("--enarmor [file]");
2799         rc = enarmor_file( argc? *argv: NULL );
2800         if( rc )
2801             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2802         break;
2803
2804
2805       case aPrimegen:
2806         {   int mode = argc < 2 ? 0 : atoi(*argv);
2807
2808             if( mode == 1 && argc == 2 ) {
2809                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2810             }
2811             else if( mode == 2 && argc == 3 ) {
2812                 mpi_print( stdout, generate_elg_prime(
2813                                              0, atoi(argv[1]),
2814                                              atoi(argv[2]), NULL,NULL ), 1);
2815             }
2816             else if( mode == 3 && argc == 3 ) {
2817                 MPI *factors;
2818                 mpi_print( stdout, generate_elg_prime(
2819                                              1, atoi(argv[1]),
2820                                              atoi(argv[2]), NULL,&factors ), 1);
2821                 putchar('\n');
2822                 mpi_print( stdout, factors[0], 1 ); /* print q */
2823             }
2824             else if( mode == 4 && argc == 3 ) {
2825                 MPI g = mpi_alloc(1);
2826                 mpi_print( stdout, generate_elg_prime(
2827                                                  0, atoi(argv[1]),
2828                                                  atoi(argv[2]), g, NULL ), 1);
2829                 putchar('\n');
2830                 mpi_print( stdout, g, 1 );
2831                 mpi_free(g);
2832             }
2833             else
2834                 wrong_args("--gen-prime mode bits [qbits] ");
2835             putchar('\n');
2836         }
2837         break;
2838
2839       case aGenRandom:
2840         {
2841             int level = argc ? atoi(*argv):0;
2842             int count = argc > 1 ? atoi(argv[1]): 0;
2843             int endless = !count;
2844
2845             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2846                 wrong_args("--gen-random 0|1|2 [count]");
2847
2848             while( endless || count ) {
2849                 byte *p;
2850                 /* Wee need a multiple of 3, so that in case of
2851                    armored output we get a correct string.  No
2852                    linefolding is done, as it is best to levae this to
2853                    other tools */
2854                 size_t n = !endless && count < 99? count : 99;
2855
2856                 p = get_random_bits( n*8, level, 0);
2857 #ifdef HAVE_DOSISH_SYSTEM
2858                 setmode ( fileno(stdout), O_BINARY );
2859 #endif
2860                 if (opt.armor) {
2861                     char *tmp = make_radix64_string (p, n);
2862                     fputs (tmp, stdout);
2863                     m_free (tmp);
2864                     if (n%3 == 1)
2865                       putchar ('=');
2866                     if (n%3)
2867                       putchar ('=');
2868                 } else {
2869                     fwrite( p, n, 1, stdout );
2870                 }
2871                 m_free(p);
2872                 if( !endless )
2873                     count -= n;
2874             }
2875             if (opt.armor)
2876                 putchar ('\n');
2877         }
2878         break;
2879
2880       case aPrintMD:
2881         if( argc < 1)
2882             wrong_args("--print-md algo [files]");
2883         {
2884             int all_algos = (**argv=='*' && !(*argv)[1]);
2885             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2886
2887             if( !algo && !all_algos )
2888                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2889             else {
2890                 argc--; argv++;
2891                 if( !argc )
2892                     print_mds(NULL, algo);
2893                 else {
2894                     for(; argc; argc--, argv++ )
2895                         print_mds(*argv, algo);
2896                 }
2897             }
2898         }
2899         break;
2900
2901       case aPrintMDs: /* old option */
2902         if( !argc )
2903             print_mds(NULL,0);
2904         else {
2905             for(; argc; argc--, argv++ )
2906                 print_mds(*argv,0);
2907         }
2908         break;
2909
2910       case aListTrustDB:
2911         if( !argc )
2912             list_trustdb(NULL);
2913         else {
2914             for( ; argc; argc--, argv++ )
2915                 list_trustdb( *argv );
2916         }
2917         break;
2918
2919       case aUpdateTrustDB:
2920         if( argc )
2921             wrong_args("--update-trustdb");
2922         update_trustdb();
2923         break;
2924
2925       case aCheckTrustDB:
2926         /* Old versions allowed for arguments - ignore them */
2927         check_trustdb();
2928         break;
2929
2930       case aFixTrustDB:
2931         log_error("this command is not yet implemented.\n");
2932         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2933         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2934         break;
2935
2936       case aListTrustPath:
2937         if( !argc )
2938             wrong_args("--list-trust-path <user-ids>");
2939         for( ; argc; argc--, argv++ ) {
2940             username = make_username( *argv );
2941             list_trust_path( username );
2942             m_free(username);
2943         }
2944         break;
2945
2946       case aExportOwnerTrust:
2947         if( argc )
2948             wrong_args("--export-ownertrust");
2949         export_ownertrust();
2950         break;
2951
2952       case aImportOwnerTrust:
2953         if( argc > 1 )
2954             wrong_args("--import-ownertrust [file]");
2955         import_ownertrust( argc? *argv:NULL );
2956         break;
2957       
2958       case aPipeMode:
2959         if ( argc )
2960             wrong_args ("--pipemode");
2961         run_in_pipemode ();
2962         break;
2963
2964       case aRebuildKeydbCaches:
2965         if (argc)
2966             wrong_args ("--rebuild-keydb-caches");
2967         keydb_rebuild_caches ();
2968         break;
2969
2970 #ifdef ENABLE_CARD_SUPPORT
2971       case aCardStatus:
2972         if (argc)
2973             wrong_args ("--card-status");
2974         card_status (stdout, NULL, 0);
2975         break;
2976
2977       case aCardEdit:
2978         if (argc) {
2979             sl = NULL;
2980             for (argc--, argv++ ; argc; argc--, argv++)
2981                 append_to_strlist (&sl, *argv);
2982             card_edit (sl);
2983             free_strlist (sl);
2984         }
2985         else
2986             card_edit (NULL);
2987         break;
2988
2989       case aChangePIN:
2990         if (!argc)
2991             change_pin (0);
2992         else if (argc == 1)
2993             change_pin ( atoi (*argv));
2994         else
2995         wrong_args ("--change-pin [no]");
2996         break;
2997 #endif /* ENABLE_CARD_SUPPORT*/
2998
2999
3000       case aListPackets:
3001         opt.list_packets=2;
3002       default:
3003         if( argc > 1 )
3004             wrong_args(_("[filename]"));
3005         /* Issue some output for the unix newbie */
3006         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3007                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3008             log_info(_("Go ahead and type your message ...\n"));
3009
3010         if( !(a = iobuf_open(fname)) )
3011             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3012         else {
3013
3014             if( !opt.no_armor ) {
3015                 if( use_armor_filter( a ) ) {
3016                     memset( &afx, 0, sizeof afx);
3017                     iobuf_push_filter( a, armor_filter, &afx );
3018                 }
3019             }
3020             if( cmd == aListPackets ) {
3021                 set_packet_list_mode(1);
3022                 opt.list_packets=1;
3023             }
3024             rc = proc_packets(NULL, a );
3025             if( rc )
3026                 log_error("processing message failed: %s\n", g10_errstr(rc) );
3027             iobuf_close(a);
3028         }
3029         break;
3030     }
3031
3032     /* cleanup */
3033     FREE_STRLIST(remusr);
3034     FREE_STRLIST(locusr);
3035     g10_exit(0);
3036     return 8; /*NEVER REACHED*/
3037 }
3038
3039
3040 void
3041 g10_exit( int rc )
3042 {
3043 #ifdef ENABLE_CARD_SUPPORT
3044     card_close ();
3045 #endif
3046     update_random_seed_file();
3047     if( opt.debug & DBG_MEMSTAT_VALUE ) {
3048         m_print_stats("on exit");
3049         random_dump_stats();
3050     }
3051     if( opt.debug )
3052         secmem_dump_stats();
3053     secmem_term();
3054     rc = rc? rc : log_get_errorcount(0)? 2 :
3055                         g10_errors_seen? 1 : 0;
3056     exit(rc );
3057 }
3058
3059
3060 /* Pretty-print hex hashes.  This assumes at least an 80-character
3061    display, but there are a few other similar assumptions in the
3062    display code. */
3063 static void
3064 print_hex( MD_HANDLE md, int algo, const char *fname )
3065 {
3066   int i,n,count,indent=0;
3067   const byte *p;
3068
3069   if(fname)
3070     indent=printf("%s: ",fname);
3071
3072   if(indent>40)
3073     {
3074       printf("\n");
3075       indent=0;
3076     }
3077
3078   if(algo==DIGEST_ALGO_RMD160)
3079     indent+=printf("RMD160 = ");
3080   else if(algo>0)
3081     indent+=printf("%6s = ",digest_algo_to_string(algo));
3082   else
3083     algo=abs(algo);
3084
3085   count=indent;
3086
3087   p = md_read( md, algo );
3088   n = md_digest_length(algo);
3089
3090   count+=printf("%02X",*p++);
3091
3092   for(i=1;i<n;i++,p++)
3093     {
3094       if(n==16)
3095         {
3096           if(count+2>79)
3097             {
3098               printf("\n%*s",indent," ");
3099               count=indent;
3100             }
3101           else
3102             count+=printf(" ");
3103
3104           if(!(i%8))
3105             count+=printf(" ");
3106         }
3107       else if (n==20)
3108         {
3109           if(!(i%2))
3110             {
3111               if(count+4>79)
3112                 {
3113                   printf("\n%*s",indent," ");
3114                   count=indent;
3115                 }
3116               else
3117                 count+=printf(" ");
3118             }
3119
3120           if(!(i%10))
3121             count+=printf(" ");
3122         }
3123       else
3124         {
3125           if(!(i%4))
3126             {
3127               if(count+8>79)
3128                 {
3129                   printf("\n%*s",indent," ");
3130                   count=indent;
3131                 }
3132               else
3133                 count+=printf(" ");
3134             }
3135         }
3136
3137       count+=printf("%02X",*p);
3138     }
3139
3140   printf("\n");
3141 }
3142
3143 static void
3144 print_hashline( MD_HANDLE md, int algo, const char *fname )
3145 {
3146     int i, n;
3147     const byte *p;
3148     
3149     if ( fname ) {
3150         for (p = fname; *p; p++ ) {
3151             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3152                 printf("%%%02X", *p );
3153             else 
3154                 putchar( *p );
3155         }
3156     }
3157     putchar(':');
3158     printf("%d:", algo );
3159     p = md_read( md, algo );
3160     n = md_digest_length(algo);
3161     for(i=0; i < n ; i++, p++ ) 
3162         printf("%02X", *p );
3163     putchar(':');
3164     putchar('\n');
3165 }
3166
3167 static void
3168 print_mds( const char *fname, int algo )
3169 {
3170     FILE *fp;
3171     char buf[1024];
3172     size_t n;
3173     MD_HANDLE md;
3174
3175     if( !fname ) {
3176         fp = stdin;
3177 #ifdef HAVE_DOSISH_SYSTEM
3178         setmode ( fileno(fp) , O_BINARY );
3179 #endif
3180     }
3181     else {
3182         fp = fopen( fname, "rb" );
3183     }
3184     if( !fp ) {
3185         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3186         return;
3187     }
3188
3189     md = md_open( 0, 0 );
3190     if( algo )
3191         md_enable( md, algo );
3192     else {
3193         md_enable( md, DIGEST_ALGO_MD5 );
3194         md_enable( md, DIGEST_ALGO_SHA1 );
3195         md_enable( md, DIGEST_ALGO_RMD160 );
3196 #ifdef USE_SHA256
3197         md_enable( md, DIGEST_ALGO_SHA256 );
3198 #endif
3199 #ifdef USE_SHA512
3200         md_enable( md, DIGEST_ALGO_SHA384 );
3201         md_enable( md, DIGEST_ALGO_SHA512 );
3202 #endif
3203     }
3204
3205     while( (n=fread( buf, 1, DIM(buf), fp )) )
3206         md_write( md, buf, n );
3207     if( ferror(fp) )
3208         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3209     else {
3210         md_final(md);
3211         if ( opt.with_colons ) {
3212             if ( algo ) 
3213                 print_hashline( md, algo, fname );
3214             else {
3215                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3216                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3217                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3218 #ifdef USE_SHA256
3219                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3220 #endif
3221 #ifdef USE_SHA512
3222                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3223                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3224 #endif
3225             }
3226         }
3227         else {
3228             if( algo )
3229                print_hex(md,-algo,fname);
3230             else {
3231                 print_hex( md, DIGEST_ALGO_MD5, fname );
3232                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3233                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3234 #ifdef USE_SHA256
3235                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3236 #endif
3237 #ifdef USE_SHA512
3238                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3239                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3240 #endif
3241             }
3242         }
3243     }
3244     md_close(md);
3245
3246     if( fp != stdin )
3247         fclose(fp);
3248 }
3249
3250
3251 /****************
3252  * Check the supplied name,value string and add it to the notation
3253  * data to be used for signatures.  which==0 for sig notations, and 1
3254  * for cert notations.
3255 */
3256 static void
3257 add_notation_data( const char *string, int which )
3258 {
3259     const char *s;
3260     STRLIST sl,*notation_data;
3261     int critical=0;
3262     int highbit=0;
3263     int saw_at=0;
3264
3265     if(which)
3266       notation_data=&opt.cert_notation_data;
3267     else
3268       notation_data=&opt.sig_notation_data;
3269
3270     if( *string == '!' ) {
3271         critical = 1;
3272         string++;
3273     }
3274
3275     /* If and when the IETF assigns some official name tags, we'll
3276        have to add them here. */
3277
3278     for( s=string ; *s != '='; s++ )
3279       {
3280         if( *s=='@')
3281           saw_at=1;
3282
3283         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3284           {
3285             log_error(_("a notation name must have only printable characters "
3286                         "or spaces, and end with an '='\n") );
3287             return;
3288           }
3289       }
3290
3291     if(!saw_at && !opt.expert)
3292       {
3293         log_error(
3294                 _("a user notation name must contain the '@' character\n"));
3295         return;
3296       }
3297
3298     /* we only support printable text - therefore we enforce the use
3299      * of only printable characters (an empty value is valid) */
3300     for( s++; *s ; s++ ) {
3301         if ((*s & 0x80))
3302           highbit = 1;
3303         else if (iscntrl(*s)) {
3304             log_error(_("a notation value must not use "
3305                         "any control characters\n") );
3306             return;
3307         }
3308     }
3309
3310     if( highbit )   /* must use UTF8 encoding */
3311         sl = add_to_strlist2( notation_data, string, utf8_strings );
3312     else
3313         sl = add_to_strlist( notation_data, string );
3314
3315     if( critical )
3316         sl->flags |= 1;
3317 }
3318
3319 static void
3320 add_policy_url( const char *string, int which )
3321 {
3322   int i,critical=0;
3323   STRLIST sl;
3324
3325   if(*string=='!')
3326     {
3327       string++;
3328       critical=1;
3329     }
3330
3331   for(i=0;i<strlen(string);i++)
3332     if(string[i]&0x80 || iscntrl(string[i]))
3333       break;
3334
3335   if(i==0 || i<strlen(string))
3336     {
3337       if(which)
3338         log_error(_("the given certification policy URL is invalid\n"));
3339       else
3340         log_error(_("the given signature policy URL is invalid\n"));
3341     }
3342
3343   if(which)
3344     sl=add_to_strlist( &opt.cert_policy_url, string );
3345   else
3346     sl=add_to_strlist( &opt.sig_policy_url, string );
3347
3348   if(critical)
3349     sl->flags |= 1;    
3350 }
3351
3352 static void
3353 add_keyserver_url( const char *string, int which )
3354 {
3355   int i,critical=0;
3356   STRLIST sl;
3357
3358   if(*string=='!')
3359     {
3360       string++;
3361       critical=1;
3362     }
3363
3364   for(i=0;i<strlen(string);i++)
3365     if(string[i]&0x80 || iscntrl(string[i]))
3366       break;
3367
3368   if(i==0 || i<strlen(string))
3369     {
3370       if(which)
3371         BUG();
3372       else
3373         log_error(_("the given signature preferred"
3374                     " keyserver URL is invalid\n"));
3375     }
3376
3377   if(which)
3378     BUG();
3379   else
3380     sl=add_to_strlist( &opt.sig_keyserver_url, string );
3381
3382   if(critical)
3383     sl->flags |= 1;    
3384 }