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