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