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