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