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