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