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