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