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