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