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