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