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