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