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