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