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