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