08c91106c47f35e3b5ce1e5710b9d4d03de38c8a
[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.disable_mdc=1;
3116         opt.escape_from=1;
3117         opt.force_v3_sigs=1;
3118         opt.ask_sig_expire=0;
3119       }
3120     else if(PGP7)
3121       {
3122         opt.escape_from=1;
3123         opt.force_v3_sigs=1;
3124         opt.ask_sig_expire=0;
3125       }
3126     else if(PGP8)
3127       {
3128         opt.escape_from=1;
3129       }
3130
3131
3132     if( def_cipher_string ) {
3133         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3134         if(opt.def_cipher_algo==0 &&
3135            (ascii_strcasecmp(def_cipher_string,"idea")==0
3136             || ascii_strcasecmp(def_cipher_string,"s1")==0))
3137           idea_cipher_warn(1);
3138         xfree(def_cipher_string); def_cipher_string = NULL;
3139         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3140             log_error(_("selected cipher algorithm is invalid\n"));
3141     }
3142     if( def_digest_string ) {
3143         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3144         xfree(def_digest_string); def_digest_string = NULL;
3145         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3146             log_error(_("selected digest algorithm is invalid\n"));
3147     }
3148     if( compress_algo_string ) {
3149         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3150         xfree(compress_algo_string); compress_algo_string = NULL;
3151         if( check_compress_algo(opt.compress_algo) )
3152           log_error(_("selected compression algorithm is invalid\n"));
3153     }
3154     if( cert_digest_string ) {
3155         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3156         xfree(cert_digest_string); cert_digest_string = NULL;
3157         if (openpgp_md_test_algo(opt.cert_digest_algo))
3158           log_error(_("selected certification digest algorithm is invalid\n"));
3159     }
3160     if( s2k_cipher_string ) {
3161         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3162         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3163         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3164           log_error(_("selected cipher algorithm is invalid\n"));
3165     }
3166     if( s2k_digest_string ) {
3167         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3168         xfree(s2k_digest_string); s2k_digest_string = NULL;
3169         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3170           log_error(_("selected digest algorithm is invalid\n"));
3171     }
3172     if( opt.completes_needed < 1 )
3173       log_error(_("completes-needed must be greater than 0\n"));
3174     if( opt.marginals_needed < 2 )
3175       log_error(_("marginals-needed must be greater than 1\n"));
3176     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3177       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3178     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3179       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3180     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3181       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3182     switch( opt.s2k_mode ) {
3183       case 0:
3184         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3185         break;
3186       case 1: case 3: break;
3187       default:
3188         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3189     }
3190
3191     /* This isn't actually needed, but does serve to error out if the
3192        string is invalid. */
3193     if(opt.def_preference_list &&
3194         keygen_set_std_prefs(opt.def_preference_list,0))
3195       log_error(_("invalid default preferences\n"));
3196
3197     if(pers_cipher_list &&
3198        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3199       log_error(_("invalid personal cipher preferences\n"));
3200
3201     if(pers_digest_list &&
3202        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3203       log_error(_("invalid personal digest preferences\n"));
3204
3205     if(pers_compress_list &&
3206        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3207       log_error(_("invalid personal compress preferences\n"));
3208
3209     /* We don't support all possible commands with multifile yet */
3210     if(multifile)
3211       {
3212         char *cmdname;
3213
3214         switch(cmd)
3215           {
3216           case aSign:
3217             cmdname="--sign";
3218             break;
3219           case aClearsign:
3220             cmdname="--clearsign";
3221             break;
3222           case aDetachedSign:
3223             cmdname="--detach-sign";
3224             break;
3225           case aSym:
3226             cmdname="--symmetric";
3227             break;
3228           case aEncrSym:
3229             cmdname="--symmetric --encrypt";
3230             break;
3231           case aStore:
3232             cmdname="--store";
3233             break;
3234           default:
3235             cmdname=NULL;
3236             break;
3237           }
3238
3239         if(cmdname)
3240           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3241       }
3242
3243     if( log_get_errorcount(0) )
3244         g10_exit(2);
3245
3246     if(opt.compress_level==0)
3247       opt.compress_algo=COMPRESS_ALGO_NONE;
3248
3249     /* Check our chosen algorithms against the list of legal
3250        algorithms. */
3251
3252     if(!GNUPG)
3253       {
3254         const char *badalg=NULL;
3255         preftype_t badtype=PREFTYPE_NONE;
3256
3257         if(opt.def_cipher_algo
3258            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3259           {
3260             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3261             badtype = PREFTYPE_SYM;
3262           }
3263         else if(opt.def_digest_algo
3264                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3265           {
3266             badalg = gcry_md_algo_name (opt.def_digest_algo);
3267             badtype = PREFTYPE_HASH;
3268           }
3269         else if(opt.cert_digest_algo
3270                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3271           {
3272             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3273             badtype = PREFTYPE_HASH;
3274           }
3275         else if(opt.compress_algo!=-1
3276                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3277           {
3278             badalg = compress_algo_to_string(opt.compress_algo);
3279             badtype = PREFTYPE_ZIP;
3280           }
3281
3282         if(badalg)
3283           {
3284             switch(badtype)
3285               {
3286               case PREFTYPE_SYM:
3287                 log_info(_("you may not use cipher algorithm `%s'"
3288                            " while in %s mode\n"),
3289                          badalg,compliance_option_string());
3290                 break;
3291               case PREFTYPE_HASH:
3292                 log_info(_("you may not use digest algorithm `%s'"
3293                            " while in %s mode\n"),
3294                          badalg,compliance_option_string());
3295                 break;
3296               case PREFTYPE_ZIP:
3297                 log_info(_("you may not use compression algorithm `%s'"
3298                            " while in %s mode\n"),
3299                          badalg,compliance_option_string());
3300                 break;
3301               default:
3302                 BUG();
3303               }
3304
3305             compliance_failure();
3306           }
3307       }
3308
3309     /* Set the random seed file. */
3310     if( use_random_seed ) {
3311         char *p = make_filename(opt.homedir, "random_seed", NULL );
3312         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3313         if (!access (p, F_OK))
3314           register_secured_file (p);
3315         xfree(p);
3316     }
3317
3318     /* If there is no command but the --fingerprint is given, default
3319        to the --list-keys command.  */
3320     if (!cmd && fpr_maybe_cmd)
3321       {
3322         set_cmd (&cmd, aListKeys);
3323       }
3324
3325
3326     if( opt.verbose > 1 )
3327         set_packet_list_mode(1);
3328
3329     /* Add the keyrings, but not for some special commands.  Also
3330        avoid adding the secret keyring for a couple of commands to
3331        avoid unneeded access in case the secrings are stored on a
3332        floppy.
3333        
3334        We always need to add the keyrings if we are running under
3335        SELinux, this is so that the rings are added to the list of
3336        secured files. */
3337     if( ALWAYS_ADD_KEYRINGS 
3338         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) ) 
3339       {
3340         if (ALWAYS_ADD_KEYRINGS
3341             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3342                 && cmd != aVerify && cmd != aSym && cmd != aLocateKeys))
3343           {
3344             if (!sec_nrings || default_keyring) /* add default secret rings */
3345               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3346             for (sl = sec_nrings; sl; sl = sl->next)
3347               keydb_add_resource ( sl->d, 0, 1 );
3348           }
3349         if( !nrings || default_keyring )  /* add default ring */
3350             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3351         for(sl = nrings; sl; sl = sl->next )
3352             keydb_add_resource ( sl->d, sl->flags, 0 );
3353       }
3354     FREE_STRLIST(nrings);
3355     FREE_STRLIST(sec_nrings);
3356
3357     if (cmd == aGPGConfTest)
3358       g10_exit(0);
3359
3360
3361     if( pwfd != -1 )  /* Read the passphrase now. */
3362         read_passphrase_from_fd( pwfd );
3363
3364     fname = argc? *argv : NULL;
3365
3366     if(fname && utf8_strings)
3367       opt.flags.utf8_filename=1;
3368
3369     switch( cmd ) {
3370       case aPrimegen:
3371       case aPrintMD:
3372       case aPrintMDs:
3373       case aGenRandom:
3374       case aDeArmor:
3375       case aEnArmor:
3376         break;
3377       case aFixTrustDB:
3378       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3379       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3380       default: rc = setup_trustdb(1, trustdb_name ); break;
3381     }
3382     if( rc )
3383         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3384
3385
3386     switch (cmd)
3387       {
3388       case aStore: 
3389       case aSym:  
3390       case aSign: 
3391       case aSignSym: 
3392       case aClearsign: 
3393         if (!opt.quiet && any_explicit_recipient)
3394           log_info (_("WARNING: recipients (-r) given "
3395                       "without using public key encryption\n"));
3396         break;
3397       default:
3398         break;
3399       }
3400
3401     switch( cmd )
3402       {
3403       case aServer:
3404         {
3405           ctrl_t ctrl = xtrycalloc (1, sizeof *ctrl);
3406           gpg_init_default_ctrl (ctrl);
3407           gpg_server (ctrl);
3408           gpg_deinit_default_ctrl (ctrl);
3409           xfree (ctrl);
3410         }
3411         break;
3412
3413       case aStore: /* only store the file */
3414         if( argc > 1 )
3415             wrong_args(_("--store [filename]"));
3416         if( (rc = encode_store(fname)) )
3417             log_error ("storing `%s' failed: %s\n",
3418                        print_fname_stdin(fname),g10_errstr(rc) );
3419         break;
3420       case aSym: /* encrypt the given file only with the symmetric cipher */
3421         if( argc > 1 )
3422             wrong_args(_("--symmetric [filename]"));
3423         if( (rc = encode_symmetric(fname)) )
3424             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3425                         print_fname_stdin(fname),g10_errstr(rc) );
3426         break;
3427
3428       case aEncr: /* encrypt the given file */
3429         if(multifile)
3430           encode_crypt_files(argc, argv, remusr);
3431         else
3432           {
3433             if( argc > 1 )
3434               wrong_args(_("--encrypt [filename]"));
3435             if( (rc = encode_crypt(fname,remusr,0)) )
3436               log_error("%s: encryption failed: %s\n",
3437                         print_fname_stdin(fname), g10_errstr(rc) );
3438           }
3439         break;
3440
3441       case aEncrSym:
3442         /* This works with PGP 8 in the sense that it acts just like a
3443            symmetric message.  It doesn't work at all with 2 or 6.  It
3444            might work with 7, but alas, I don't have a copy to test
3445            with right now. */
3446         if( argc > 1 )
3447           wrong_args(_("--symmetric --encrypt [filename]"));
3448         else if(opt.s2k_mode==0)
3449           log_error(_("you cannot use --symmetric --encrypt"
3450                       " with --s2k-mode 0\n"));
3451         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3452           log_error(_("you cannot use --symmetric --encrypt"
3453                       " while in %s mode\n"),compliance_option_string());
3454         else
3455           {
3456             if( (rc = encode_crypt(fname,remusr,1)) )
3457               log_error("%s: encryption failed: %s\n",
3458                         print_fname_stdin(fname), g10_errstr(rc) );
3459           }
3460         break;
3461
3462       case aSign: /* sign the given file */
3463         sl = NULL;
3464         if( detached_sig ) { /* sign all files */
3465             for( ; argc; argc--, argv++ )
3466                 add_to_strlist( &sl, *argv );
3467         }
3468         else {
3469             if( argc > 1 )
3470                 wrong_args(_("--sign [filename]"));
3471             if( argc ) {
3472                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3473                 strcpy(sl->d, fname);
3474             }
3475         }
3476         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3477             log_error("signing failed: %s\n", g10_errstr(rc) );
3478         free_strlist(sl);
3479         break;
3480
3481       case aSignEncr: /* sign and encrypt the given file */
3482         if( argc > 1 )
3483             wrong_args(_("--sign --encrypt [filename]"));
3484         if( argc ) {
3485             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3486             strcpy(sl->d, fname);
3487         }
3488         else
3489             sl = NULL;
3490         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3491             log_error("%s: sign+encrypt failed: %s\n",
3492                       print_fname_stdin(fname), g10_errstr(rc) );
3493         free_strlist(sl);
3494         break;
3495
3496       case aSignEncrSym: /* sign and encrypt the given file */
3497         if( argc > 1 )
3498             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3499         else if(opt.s2k_mode==0)
3500           log_error(_("you cannot use --symmetric --sign --encrypt"
3501                       " with --s2k-mode 0\n"));
3502         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3503           log_error(_("you cannot use --symmetric --sign --encrypt"
3504                       " while in %s mode\n"),compliance_option_string());
3505         else
3506           {
3507             if( argc )
3508               {
3509                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3510                 strcpy(sl->d, fname);
3511               }
3512             else
3513               sl = NULL;
3514             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3515               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3516                         print_fname_stdin(fname), g10_errstr(rc) );
3517             free_strlist(sl);
3518           }
3519         break;
3520
3521       case aSignSym: /* sign and conventionally encrypt the given file */
3522         if (argc > 1)
3523             wrong_args(_("--sign --symmetric [filename]"));
3524         rc = sign_symencrypt_file (fname, locusr);
3525         if (rc)
3526             log_error("%s: sign+symmetric failed: %s\n",
3527                       print_fname_stdin(fname), g10_errstr(rc) );
3528         break;
3529
3530       case aClearsign: /* make a clearsig */
3531         if( argc > 1 )
3532             wrong_args(_("--clearsign [filename]"));
3533         if( (rc = clearsign_file(fname, locusr, NULL)) )
3534             log_error("%s: clearsign failed: %s\n",
3535                       print_fname_stdin(fname), g10_errstr(rc) );
3536         break;
3537
3538       case aVerify:
3539         if(multifile)
3540           {
3541             if( (rc = verify_files( argc, argv ) ))
3542               log_error("verify files failed: %s\n", g10_errstr(rc) );
3543           }
3544         else
3545           {
3546             if( (rc = verify_signatures( argc, argv ) ))
3547               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3548           }
3549         break;
3550
3551       case aDecrypt:
3552         if(multifile)
3553           decrypt_messages(argc, argv);
3554         else
3555           {
3556             if( argc > 1 )
3557               wrong_args(_("--decrypt [filename]"));
3558             if( (rc = decrypt_message( fname ) ))
3559               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3560           }
3561         break;
3562             
3563       case aSignKey:
3564         if( argc != 1 )
3565           wrong_args(_("--sign-key user-id"));
3566         /* fall through */
3567       case aLSignKey:
3568         if( argc != 1 )
3569           wrong_args(_("--lsign-key user-id"));
3570         /* fall through */
3571
3572         sl=NULL;
3573
3574         if(cmd==aSignKey)
3575           append_to_strlist(&sl,"sign");
3576         else if(cmd==aLSignKey)
3577           append_to_strlist(&sl,"lsign");
3578         else
3579           BUG();
3580
3581         append_to_strlist( &sl, "save" );
3582         username = make_username( fname );
3583         keyedit_menu (username, locusr, sl, 0, 0 );
3584         xfree(username);
3585         free_strlist(sl);
3586         break;
3587
3588       case aEditKey: /* Edit a key signature */
3589         if( !argc )
3590             wrong_args(_("--edit-key user-id [commands]"));
3591         username = make_username( fname );
3592         if( argc > 1 ) {
3593             sl = NULL;
3594             for( argc--, argv++ ; argc; argc--, argv++ )
3595                 append_to_strlist( &sl, *argv );
3596             keyedit_menu( username, locusr, sl, 0, 1 );
3597             free_strlist(sl);
3598         }
3599         else
3600             keyedit_menu(username, locusr, NULL, 0, 1 );
3601         xfree(username);
3602         break;
3603
3604       case aDeleteKeys:
3605       case aDeleteSecretKeys:
3606       case aDeleteSecretAndPublicKeys:
3607         sl = NULL;
3608         /* I'm adding these in reverse order as add_to_strlist2
3609            reverses them again, and it's easier to understand in the
3610            proper order :) */
3611         for( ; argc; argc-- )
3612           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3613         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3614         free_strlist(sl);
3615         break;
3616
3617       case aCheckKeys:
3618         opt.check_sigs = 1;
3619       case aListSigs:
3620         opt.list_sigs = 1;
3621       case aListKeys:
3622         sl = NULL;
3623         for( ; argc; argc--, argv++ )
3624             add_to_strlist2( &sl, *argv, utf8_strings );
3625         public_key_list( sl, 0 );
3626         free_strlist(sl);
3627         break;
3628       case aListSecretKeys:
3629         sl = NULL;
3630         for( ; argc; argc--, argv++ )
3631             add_to_strlist2( &sl, *argv, utf8_strings );
3632         secret_key_list( sl );
3633         free_strlist(sl);
3634         break;
3635       case aLocateKeys:
3636         sl = NULL;
3637         for (; argc; argc--, argv++)
3638           add_to_strlist2( &sl, *argv, utf8_strings );
3639         public_key_list (sl, 1);
3640         free_strlist (sl);
3641         break;
3642
3643       case aKeygen: /* generate a key */
3644         if( opt.batch ) {
3645             if( argc > 1 )
3646                 wrong_args("--gen-key [parameterfile]");
3647             generate_keypair( argc? *argv : NULL, NULL, NULL );
3648         }
3649         else {
3650             if( argc )
3651                 wrong_args("--gen-key");
3652             generate_keypair(NULL, NULL, NULL);
3653         }
3654         break;
3655
3656       case aFastImport:
3657         opt.import_options |= IMPORT_FAST;
3658       case aImport:
3659         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3660         break;
3661
3662         /* TODO: There are a number of command that use this same
3663            "make strlist, call function, report error, free strlist"
3664            pattern.  Join them together here and avoid all that
3665            duplicated code. */
3666
3667       case aExport:
3668       case aSendKeys:
3669       case aRecvKeys:
3670         sl = NULL;
3671         for( ; argc; argc--, argv++ )
3672             append_to_strlist2( &sl, *argv, utf8_strings );
3673         if( cmd == aSendKeys )
3674             rc=keyserver_export( sl );
3675         else if( cmd == aRecvKeys )
3676             rc=keyserver_import( sl );
3677         else
3678             rc=export_pubkeys( sl, opt.export_options );
3679         if(rc)
3680           {
3681             if(cmd==aSendKeys)
3682               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3683             else if(cmd==aRecvKeys)
3684               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3685             else
3686               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3687           }
3688         free_strlist(sl);
3689         break;
3690
3691      case aSearchKeys:
3692         sl = NULL;
3693         for( ; argc; argc--, argv++ )
3694           append_to_strlist2( &sl, *argv, utf8_strings );
3695         rc=keyserver_search( sl );
3696         if(rc)
3697           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3698         free_strlist(sl);
3699         break;
3700
3701       case aRefreshKeys:
3702         sl = NULL;
3703         for( ; argc; argc--, argv++ )
3704             append_to_strlist2( &sl, *argv, utf8_strings );
3705         rc=keyserver_refresh(sl);
3706         if(rc)
3707           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3708         free_strlist(sl);
3709         break;
3710
3711       case aFetchKeys:
3712         sl = NULL;
3713         for( ; argc; argc--, argv++ )
3714             append_to_strlist2( &sl, *argv, utf8_strings );
3715         rc=keyserver_fetch(sl);
3716         if(rc)
3717           log_error("key fetch failed: %s\n",g10_errstr(rc));
3718         free_strlist(sl);
3719         break;
3720
3721       case aExportSecret:
3722         sl = NULL;
3723         for( ; argc; argc--, argv++ )
3724             add_to_strlist2( &sl, *argv, utf8_strings );
3725         export_seckeys( sl );
3726         free_strlist(sl);
3727         break;
3728
3729       case aExportSecretSub:
3730         sl = NULL;
3731         for( ; argc; argc--, argv++ )
3732             add_to_strlist2( &sl, *argv, utf8_strings );
3733         export_secsubkeys( sl );
3734         free_strlist(sl);
3735         break;
3736
3737       case aGenRevoke:
3738         if( argc != 1 )
3739             wrong_args("--gen-revoke user-id");
3740         username =  make_username(*argv);
3741         gen_revoke( username );
3742         xfree( username );
3743         break;
3744
3745       case aDesigRevoke:
3746         if( argc != 1 )
3747             wrong_args("--desig-revoke user-id");
3748         username =  make_username(*argv);
3749         gen_desig_revoke( username, locusr );
3750         xfree( username );
3751         break;
3752
3753       case aDeArmor:
3754         if( argc > 1 )
3755             wrong_args("--dearmor [file]");
3756         rc = dearmor_file( argc? *argv: NULL );
3757         if( rc )
3758             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3759         break;
3760
3761       case aEnArmor:
3762         if( argc > 1 )
3763             wrong_args("--enarmor [file]");
3764         rc = enarmor_file( argc? *argv: NULL );
3765         if( rc )
3766             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3767         break;
3768
3769
3770       case aPrimegen:
3771 #if 0 /*FIXME*/
3772         {   int mode = argc < 2 ? 0 : atoi(*argv);
3773
3774             if( mode == 1 && argc == 2 ) {
3775                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3776             }
3777             else if( mode == 2 && argc == 3 ) {
3778                 mpi_print( stdout, generate_elg_prime(
3779                                              0, atoi(argv[1]),
3780                                              atoi(argv[2]), NULL,NULL ), 1);
3781             }
3782             else if( mode == 3 && argc == 3 ) {
3783                 MPI *factors;
3784                 mpi_print( stdout, generate_elg_prime(
3785                                              1, atoi(argv[1]),
3786                                              atoi(argv[2]), NULL,&factors ), 1);
3787                 putchar('\n');
3788                 mpi_print( stdout, factors[0], 1 ); /* print q */
3789             }
3790             else if( mode == 4 && argc == 3 ) {
3791                 MPI g = mpi_alloc(1);
3792                 mpi_print( stdout, generate_elg_prime(
3793                                                  0, atoi(argv[1]),
3794                                                  atoi(argv[2]), g, NULL ), 1);
3795                 putchar('\n');
3796                 mpi_print( stdout, g, 1 );
3797                 mpi_free(g);
3798             }
3799             else
3800                 wrong_args("--gen-prime mode bits [qbits] ");
3801             putchar('\n');
3802         }
3803 #endif
3804         wrong_args("--gen-prime not yet supported ");
3805         break;
3806
3807       case aGenRandom:
3808         {
3809             int level = argc ? atoi(*argv):0;
3810             int count = argc > 1 ? atoi(argv[1]): 0;
3811             int endless = !count;
3812
3813             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3814                 wrong_args("--gen-random 0|1|2 [count]");
3815
3816             while( endless || count ) {
3817                 byte *p;
3818                 /* Wee need a multiple of 3, so that in case of
3819                    armored output we get a correct string.  No
3820                    linefolding is done, as it is best to levae this to
3821                    other tools */
3822                 size_t n = !endless && count < 99? count : 99;
3823
3824                 p = gcry_random_bytes (n, level);
3825 #ifdef HAVE_DOSISH_SYSTEM
3826                 setmode ( fileno(stdout), O_BINARY );
3827 #endif
3828                 if (opt.armor) {
3829                     char *tmp = make_radix64_string (p, n);
3830                     fputs (tmp, stdout);
3831                     xfree (tmp);
3832                     if (n%3 == 1)
3833                       putchar ('=');
3834                     if (n%3)
3835                       putchar ('=');
3836                 } else {
3837                     fwrite( p, n, 1, stdout );
3838                 }
3839                 xfree(p);
3840                 if( !endless )
3841                     count -= n;
3842             }
3843             if (opt.armor)
3844                 putchar ('\n');
3845         }
3846         break;
3847
3848       case aPrintMD:
3849         if( argc < 1)
3850             wrong_args("--print-md algo [files]");
3851         {
3852             int all_algos = (**argv=='*' && !(*argv)[1]);
3853             int algo = all_algos? 0 : gcry_md_map_name (*argv);
3854
3855             if( !algo && !all_algos )
3856                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3857             else {
3858                 argc--; argv++;
3859                 if( !argc )
3860                     print_mds(NULL, algo);
3861                 else {
3862                     for(; argc; argc--, argv++ )
3863                         print_mds(*argv, algo);
3864                 }
3865             }
3866         }
3867         break;
3868
3869       case aPrintMDs: /* old option */
3870         if( !argc )
3871             print_mds(NULL,0);
3872         else {
3873             for(; argc; argc--, argv++ )
3874                 print_mds(*argv,0);
3875         }
3876         break;
3877
3878       case aListTrustDB:
3879         if( !argc )
3880             list_trustdb(NULL);
3881         else {
3882             for( ; argc; argc--, argv++ )
3883                 list_trustdb( *argv );
3884         }
3885         break;
3886
3887       case aUpdateTrustDB:
3888         if( argc )
3889             wrong_args("--update-trustdb");
3890         update_trustdb();
3891         break;
3892
3893       case aCheckTrustDB:
3894         /* Old versions allowed for arguments - ignore them */
3895         check_trustdb();
3896         break;
3897
3898       case aFixTrustDB:
3899         how_to_fix_the_trustdb ();
3900         break;
3901
3902       case aListTrustPath:
3903         if( !argc )
3904             wrong_args("--list-trust-path <user-ids>");
3905         for( ; argc; argc--, argv++ ) {
3906             username = make_username( *argv );
3907             list_trust_path( username );
3908             xfree(username);
3909         }
3910         break;
3911
3912       case aExportOwnerTrust:
3913         if( argc )
3914             wrong_args("--export-ownertrust");
3915         export_ownertrust();
3916         break;
3917
3918       case aImportOwnerTrust:
3919         if( argc > 1 )
3920             wrong_args("--import-ownertrust [file]");
3921         import_ownertrust( argc? *argv:NULL );
3922         break;
3923       
3924       case aRebuildKeydbCaches:
3925         if (argc)
3926             wrong_args ("--rebuild-keydb-caches");
3927         keydb_rebuild_caches (1);
3928         break;
3929
3930 #ifdef ENABLE_CARD_SUPPORT
3931       case aCardStatus:
3932         if (argc)
3933             wrong_args ("--card-status");
3934         card_status (stdout, NULL, 0);
3935         break;
3936
3937       case aCardEdit:
3938         if (argc) {
3939             sl = NULL;
3940             for (argc--, argv++ ; argc; argc--, argv++)
3941                 append_to_strlist (&sl, *argv);
3942             card_edit (sl);
3943             free_strlist (sl);
3944         }
3945         else
3946             card_edit (NULL);
3947         break;
3948
3949       case aChangePIN:
3950         if (!argc)
3951             change_pin (0,1);
3952         else if (argc == 1)
3953             change_pin (atoi (*argv),1);
3954         else
3955         wrong_args ("--change-pin [no]");
3956         break;
3957 #endif /* ENABLE_CARD_SUPPORT*/
3958
3959       case aListConfig:
3960         {
3961           char *str=collapse_args(argc,argv);
3962           list_config(str);
3963           xfree(str);
3964         }
3965         break;
3966
3967       case aListPackets:
3968         opt.list_packets=2;
3969       default:
3970         if( argc > 1 )
3971             wrong_args(_("[filename]"));
3972         /* Issue some output for the unix newbie */
3973         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3974                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3975             log_info(_("Go ahead and type your message ...\n"));
3976
3977         a = iobuf_open(fname);
3978         if (a && is_secured_file (iobuf_get_fd (a)))
3979           {
3980             iobuf_close (a);
3981             a = NULL;
3982             errno = EPERM;
3983           }
3984         if( !a )
3985             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3986         else {
3987
3988             if( !opt.no_armor ) {
3989                 if( use_armor_filter( a ) ) {
3990                     afx = new_armor_context ();
3991                     push_armor_filter (afx, a);
3992                 }
3993             }
3994             if( cmd == aListPackets ) {
3995                 set_packet_list_mode(1);
3996                 opt.list_packets=1;
3997             }
3998             rc = proc_packets(NULL, a );
3999             if( rc )
4000                 log_error("processing message failed: %s\n", g10_errstr(rc) );
4001             iobuf_close(a);
4002         }
4003         break;
4004       }
4005
4006     /* cleanup */
4007     release_armor_context (afx);
4008     FREE_STRLIST(remusr);
4009     FREE_STRLIST(locusr);
4010     g10_exit(0);
4011     return 8; /*NEVER REACHED*/
4012 }
4013
4014
4015 /* Note: This function is used by signal handlers!. */
4016 static void
4017 emergency_cleanup (void)
4018 {
4019   gcry_control (GCRYCTL_TERM_SECMEM );
4020 }
4021
4022
4023 void
4024 g10_exit( int rc )
4025 {
4026   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
4027   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
4028     {
4029       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
4030       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
4031     }
4032   if (opt.debug)
4033     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
4034
4035   emergency_cleanup ();
4036   
4037   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
4038   exit (rc);
4039 }
4040
4041
4042 /* Pretty-print hex hashes.  This assumes at least an 80-character
4043    display, but there are a few other similar assumptions in the
4044    display code. */
4045 static void
4046 print_hex( gcry_md_hd_t md, int algo, const char *fname )
4047 {
4048   int i,n,count,indent=0;
4049   const byte *p;
4050
4051   if(fname)
4052     indent=printf("%s: ",fname);
4053
4054   if(indent>40)
4055     {
4056       printf("\n");
4057       indent=0;
4058     }
4059
4060   if(algo==DIGEST_ALGO_RMD160)
4061     indent+=printf("RMD160 = ");
4062   else if(algo>0)
4063     indent+=printf("%6s = ", gcry_md_algo_name (algo));
4064   else
4065     algo=abs(algo);
4066
4067   count=indent;
4068
4069   p = gcry_md_read (md, algo);
4070   n = gcry_md_get_algo_dlen (algo);
4071
4072   count += printf ("%02X",*p++);
4073
4074   for(i=1;i<n;i++,p++)
4075     {
4076       if(n==16)
4077         {
4078           if(count+2>79)
4079             {
4080               printf("\n%*s",indent," ");
4081               count=indent;
4082             }
4083           else
4084             count+=printf(" ");
4085
4086           if(!(i%8))
4087             count+=printf(" ");
4088         }
4089       else if (n==20)
4090         {
4091           if(!(i%2))
4092             {
4093               if(count+4>79)
4094                 {
4095                   printf("\n%*s",indent," ");
4096                   count=indent;
4097                 }
4098               else
4099                 count+=printf(" ");
4100             }
4101
4102           if(!(i%10))
4103             count+=printf(" ");
4104         }
4105       else
4106         {
4107           if(!(i%4))
4108             {
4109               if(count+8>79)
4110                 {
4111                   printf("\n%*s",indent," ");
4112                   count=indent;
4113                 }
4114               else
4115                 count+=printf(" ");
4116             }
4117         }
4118
4119       count+=printf("%02X",*p);
4120     }
4121
4122   printf("\n");
4123 }
4124
4125 static void
4126 print_hashline( gcry_md_hd_t md, int algo, const char *fname )
4127 {
4128     int i, n;
4129     const byte *p;
4130     
4131     if ( fname ) {
4132         for (p = fname; *p; p++ ) {
4133             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
4134                 printf("%%%02X", *p );
4135             else 
4136                 putchar( *p );
4137         }
4138     }
4139     putchar(':');
4140     printf("%d:", algo );
4141     p = gcry_md_read (md, algo);
4142     n = gcry_md_get_algo_dlen (algo);
4143     for(i=0; i < n ; i++, p++ ) 
4144         printf("%02X", *p );
4145     putchar(':');
4146     putchar('\n');
4147 }
4148
4149 static void
4150 print_mds( const char *fname, int algo )
4151 {
4152     FILE *fp;
4153     char buf[1024];
4154     size_t n;
4155     gcry_md_hd_t md;
4156
4157     if( !fname ) {
4158         fp = stdin;
4159 #ifdef HAVE_DOSISH_SYSTEM
4160         setmode ( fileno(fp) , O_BINARY );
4161 #endif
4162     }
4163     else {
4164         fp = fopen( fname, "rb" );
4165         if (fp && is_secured_file (fileno (fp)))
4166           {
4167             fclose (fp);
4168             fp = NULL;
4169             errno = EPERM;
4170           }
4171     }
4172     if( !fp ) {
4173         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
4174         return;
4175     }
4176
4177     gcry_md_open (&md, 0, 0);
4178     if( algo )
4179         gcry_md_enable (md, algo);
4180     else {
4181         gcry_md_enable (md, GCRY_MD_MD5);
4182         gcry_md_enable (md, GCRY_MD_SHA1);
4183         gcry_md_enable (md, GCRY_MD_RMD160);
4184         if (!openpgp_md_test_algo (GCRY_MD_SHA224))
4185           gcry_md_enable (md, GCRY_MD_SHA224);
4186         if (!openpgp_md_test_algo (GCRY_MD_SHA256))
4187           gcry_md_enable (md, GCRY_MD_SHA256);
4188         if (!openpgp_md_test_algo (GCRY_MD_SHA384))
4189           gcry_md_enable (md, GCRY_MD_SHA384);
4190         if (!openpgp_md_test_algo (GCRY_MD_SHA512))
4191           gcry_md_enable (md, GCRY_MD_SHA512);
4192  &n