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