sl@0: /*
sl@0: Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
sl@0: 
sl@0: Redistribution and use in source and binary forms, with or without 
sl@0: modification, are permitted provided that the following conditions are met:
sl@0: 
sl@0: * Redistributions of source code must retain the above copyright notice, this 
sl@0:   list of conditions and the following disclaimer.
sl@0: * Redistributions in binary form must reproduce the above copyright notice, 
sl@0:   this list of conditions and the following disclaimer in the documentation 
sl@0:   and/or other materials provided with the distribution.
sl@0: * Neither the name of Nokia Corporation nor the names of its contributors 
sl@0:   may be used to endorse or promote products derived from this software 
sl@0:   without specific prior written permission.
sl@0: 
sl@0: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
sl@0: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
sl@0: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
sl@0: DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
sl@0: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
sl@0: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
sl@0: SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
sl@0: CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
sl@0: OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
sl@0: OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
sl@0: 
sl@0: Description:
sl@0: */
sl@0: 
sl@0: #include <stdio.h>
sl@0: #include <stdlib.h>
sl@0: #include <string.h>
sl@0: #include <openssl/objects.h>
sl@0: #include <openssl/comp.h>
sl@0: #include <openssl/err.h>
sl@0: #if (defined(SYMBIAN) && (defined(__WINSCW__) || defined(__WINS__)))
sl@0: #include "libcrypto_wsd_macros.h"
sl@0: #include "libcrypto_wsd.h"
sl@0: #endif
sl@0: 
sl@0: 
sl@0: COMP_METHOD *COMP_zlib(void );
sl@0: #ifndef EMULATOR
sl@0: static COMP_METHOD zlib_method_nozlib={
sl@0: 	NID_undef,
sl@0: 	"(undef)",
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	};
sl@0: #else//EMULATOR
sl@0:   GET_STATIC_VAR_FROM_TLS(zlib_method_nozlib,c_zlib,COMP_METHOD)
sl@0:   #define zlib_method_nozlib (*GET_WSD_VAR_NAME(zlib_method_nozlib,c_zlib, s)())
sl@0:   const COMP_METHOD temp_s_zlib_method_nozlib={
sl@0: 	NID_undef,
sl@0: 	"(undef)",
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	};
sl@0: #endif//EMULATOR
sl@0: 
sl@0: #ifndef ZLIB
sl@0: #undef ZLIB_SHARED
sl@0: #else
sl@0: 
sl@0: #include <zlib.h>
sl@0: 
sl@0: static int zlib_stateful_init(COMP_CTX *ctx);
sl@0: static void zlib_stateful_finish(COMP_CTX *ctx);
sl@0: static int zlib_stateful_compress_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen);
sl@0: static int zlib_stateful_expand_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen);
sl@0: 
sl@0: #if 0
sl@0: static int zlib_compress_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen);
sl@0: static int zlib_expand_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen);
sl@0: 
sl@0: static int zz_uncompress(Bytef *dest, uLongf *destLen, const Bytef *source,
sl@0: 	uLong sourceLen);
sl@0: 
sl@0: static COMP_METHOD zlib_stateless_method={
sl@0: 	NID_zlib_compression,
sl@0: 	LN_zlib_compression,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	zlib_compress_block,
sl@0: 	zlib_expand_block,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	};
sl@0: #endif
sl@0: #ifndef EMULATOR
sl@0: static COMP_METHOD zlib_stateful_method={
sl@0: 	NID_zlib_compression,
sl@0: 	LN_zlib_compression,
sl@0: 	zlib_stateful_init,
sl@0: 	zlib_stateful_finish,
sl@0: 	zlib_stateful_compress_block,
sl@0: 	zlib_stateful_expand_block,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	};
sl@0: #else//EMULATOR
sl@0:   GET_STATIC_VAR_FROM_TLS(zlib_stateful_method,c_zlib,COMP_METHOD)
sl@0:   #define zlib_stateful_method (*GET_WSD_VAR_NAME(zlib_stateful_method,c_zlib, s)())
sl@0:   const COMP_METHOD temp_s_zlib_stateful_method={
sl@0: 	NID_zlib_compression,
sl@0: 	LN_zlib_compression,
sl@0: 	zlib_stateful_init,
sl@0: 	zlib_stateful_finish,
sl@0: 	zlib_stateful_compress_block,
sl@0: 	zlib_stateful_expand_block,
sl@0: 	NULL,
sl@0: 	NULL,
sl@0: 	};
sl@0: #endif//EMULATOR
sl@0: 
sl@0: /* 
sl@0:  * When OpenSSL is built on Windows, we do not want to require that
sl@0:  * the ZLIB.DLL be available in order for the OpenSSL DLLs to
sl@0:  * work.  Therefore, all ZLIB routines are loaded at run time
sl@0:  * and we do not link to a .LIB file.
sl@0:  */
sl@0: #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)
sl@0: # include <windows.h>
sl@0: 
sl@0: # define Z_CALLCONV _stdcall
sl@0: # ifndef ZLIB_SHARED
sl@0: #  define ZLIB_SHARED
sl@0: # endif
sl@0: #else
sl@0: # define Z_CALLCONV
sl@0: #endif /* !(OPENSSL_SYS_WINDOWS || OPENSSL_SYS_WIN32) */
sl@0: 
sl@0: #ifdef ZLIB_SHARED
sl@0: #include <openssl/dso.h>
sl@0: 
sl@0: /* Prototypes for built in stubs */
sl@0: #if 0
sl@0: static int stub_compress(Bytef *dest,uLongf *destLen,
sl@0: 	const Bytef *source, uLong sourceLen);
sl@0: #endif
sl@0: static int stub_inflateEnd(z_streamp strm);
sl@0: static int stub_inflate(z_streamp strm, int flush);
sl@0: static int stub_inflateInit_(z_streamp strm, const char * version,
sl@0: 	int stream_size);
sl@0: static int stub_deflateEnd(z_streamp strm);
sl@0: static int stub_deflate(z_streamp strm, int flush);
sl@0: static int stub_deflateInit_(z_streamp strm, int level,
sl@0: 	const char * version, int stream_size);
sl@0: 
sl@0: #ifndef EMULATOR
sl@0: /* Function pointers */
sl@0: typedef int (Z_CALLCONV *compress_ft)(Bytef *dest,uLongf *destLen,
sl@0: 	const Bytef *source, uLong sourceLen);
sl@0: typedef int (Z_CALLCONV *inflateEnd_ft)(z_streamp strm);
sl@0: typedef int (Z_CALLCONV *inflate_ft)(z_streamp strm, int flush);
sl@0: typedef int (Z_CALLCONV *inflateInit__ft)(z_streamp strm,
sl@0: 	const char * version, int stream_size);
sl@0: typedef int (Z_CALLCONV *deflateEnd_ft)(z_streamp strm);
sl@0: typedef int (Z_CALLCONV *deflate_ft)(z_streamp strm, int flush);
sl@0: typedef int (Z_CALLCONV *deflateInit__ft)(z_streamp strm, int level,
sl@0: 	const char * version, int stream_size);
sl@0: #endif	
sl@0: 	
sl@0: #ifndef EMULATOR	
sl@0: static compress_ft	p_compress=NULL;
sl@0: static inflateEnd_ft	p_inflateEnd=NULL;
sl@0: static inflate_ft	p_inflate=NULL;
sl@0: static inflateInit__ft	p_inflateInit_=NULL;
sl@0: 
sl@0: static deflateEnd_ft	p_deflateEnd=NULL;
sl@0: static deflate_ft	p_deflate=NULL;
sl@0: static deflateInit__ft	p_deflateInit_=NULL;
sl@0: static int zlib_loaded = 0;     /* only attempt to init func pts once */
sl@0: static DSO *zlib_dso = NULL;
sl@0: #else
sl@0: GET_STATIC_VAR_FROM_TLS(p_compress,c_zlib,compress_ft)
sl@0: #define p_compress (*GET_WSD_VAR_NAME(p_compress,c_zlib, s)())
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(p_inflateEnd,c_zlib,inflateEnd_ft)
sl@0: #define p_inflateEnd (*GET_WSD_VAR_NAME(p_inflateEnd,c_zlib, s)())
sl@0: 
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(p_inflate,c_zlib,inflate_ft)
sl@0: #define p_inflate (*GET_WSD_VAR_NAME(p_inflate,c_zlib, s)())
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(p_inflateInit_,c_zlib,inflateInit__ft)
sl@0: #define p_inflateInit_ (*GET_WSD_VAR_NAME(p_inflateInit_,c_zlib, s)())
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(p_deflateEnd,c_zlib,deflateEnd_ft)
sl@0: #define p_deflateEnd (*GET_WSD_VAR_NAME(p_deflateEnd,c_zlib, s)())
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(p_deflate,c_zlib,deflate_ft)
sl@0: #define p_deflate (*GET_WSD_VAR_NAME(p_deflate,c_zlib, s)())
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(p_deflateInit_,c_zlib,deflateInit__ft)
sl@0: #define p_deflateInit_ (*GET_WSD_VAR_NAME(p_deflateInit_,c_zlib, s)())
sl@0: 
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(zlib_loaded ,c_zlib,int)
sl@0: #define zlib_loaded  (*GET_WSD_VAR_NAME(zlib_loaded ,c_zlib, s)())
sl@0: 
sl@0: GET_STATIC_VAR_FROM_TLS(zlib_dso ,c_zlib,DSO *)
sl@0: #define zlib_dso  (*GET_WSD_VAR_NAME(zlib_dso ,c_zlib, s)())
sl@0: 
sl@0: #endif
sl@0: 
sl@0: #define compress                stub_compress
sl@0: #define inflateEnd              stub_inflateEnd
sl@0: #define inflate                 stub_inflate
sl@0: #define inflateInit_            stub_inflateInit_
sl@0: #define deflateEnd              stub_deflateEnd
sl@0: #define deflate                 stub_deflate
sl@0: #define deflateInit_            stub_deflateInit_
sl@0: #endif /* ZLIB_SHARED */
sl@0: 
sl@0: struct zlib_state
sl@0: 	{
sl@0: 	z_stream istream;
sl@0: 	z_stream ostream;
sl@0: 	};
sl@0: 
sl@0: #ifndef EMULATOR
sl@0: static int zlib_stateful_ex_idx = -1;
sl@0: #else
sl@0: GET_STATIC_VAR_FROM_TLS(zlib_stateful_ex_idx,c_zlib,int)
sl@0: #define zlib_stateful_ex_idx (*GET_WSD_VAR_NAME(zlib_stateful_ex_idx,c_zlib, s)())
sl@0: #endif
sl@0: 
sl@0: static void zlib_stateful_free_ex_data(void *obj, void *item,
sl@0: 	CRYPTO_EX_DATA *ad, int ind,long argl, void *argp)
sl@0: 	{
sl@0: 	struct zlib_state *state = (struct zlib_state *)item;
sl@0: 	inflateEnd(&state->istream);
sl@0: 	deflateEnd(&state->ostream);
sl@0: 	OPENSSL_free(state);
sl@0: 	}
sl@0: 
sl@0: static int zlib_stateful_init(COMP_CTX *ctx)
sl@0: 	{
sl@0: 	int err;
sl@0: 	struct zlib_state *state =
sl@0: 		(struct zlib_state *)OPENSSL_malloc(sizeof(struct zlib_state));
sl@0: 
sl@0: 	if (state == NULL)
sl@0: 		goto err;
sl@0: 
sl@0: 	state->istream.zalloc = Z_NULL;
sl@0: 	state->istream.zfree = Z_NULL;
sl@0: 	state->istream.opaque = Z_NULL;
sl@0: 	state->istream.next_in = Z_NULL;
sl@0: 	state->istream.next_out = Z_NULL;
sl@0: 	state->istream.avail_in = 0;
sl@0: 	state->istream.avail_out = 0;
sl@0: 	err = inflateInit_(&state->istream,
sl@0: 		ZLIB_VERSION, sizeof(z_stream));
sl@0: 	if (err != Z_OK)
sl@0: 		goto err;
sl@0: 
sl@0: 	state->ostream.zalloc = Z_NULL;
sl@0: 	state->ostream.zfree = Z_NULL;
sl@0: 	state->ostream.opaque = Z_NULL;
sl@0: 	state->ostream.next_in = Z_NULL;
sl@0: 	state->ostream.next_out = Z_NULL;
sl@0: 	state->ostream.avail_in = 0;
sl@0: 	state->ostream.avail_out = 0;
sl@0: 	err = deflateInit_(&state->ostream,Z_DEFAULT_COMPRESSION,
sl@0: 		ZLIB_VERSION, sizeof(z_stream));
sl@0: 	if (err != Z_OK)
sl@0: 		goto err;
sl@0: 
sl@0: 	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_COMP,ctx,&ctx->ex_data);
sl@0: 	if (zlib_stateful_ex_idx == -1)
sl@0: 		{
sl@0: 		CRYPTO_w_lock(CRYPTO_LOCK_COMP);
sl@0: 		if (zlib_stateful_ex_idx == -1)
sl@0: 			zlib_stateful_ex_idx =
sl@0: 				CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_COMP,
sl@0: 					0,NULL,NULL,NULL,zlib_stateful_free_ex_data);
sl@0: 		CRYPTO_w_unlock(CRYPTO_LOCK_COMP);
sl@0: 		if (zlib_stateful_ex_idx == -1)
sl@0: 			goto err;
sl@0: 		}
sl@0: 	CRYPTO_set_ex_data(&ctx->ex_data,zlib_stateful_ex_idx,state);
sl@0: 	return 1;
sl@0:  err:
sl@0: 	if (state) OPENSSL_free(state);
sl@0: 	return 0;
sl@0: 	}
sl@0: 
sl@0: static void zlib_stateful_finish(COMP_CTX *ctx)
sl@0: 	{
sl@0: 	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_COMP,ctx,&ctx->ex_data);
sl@0: 	}
sl@0: 
sl@0: static int zlib_stateful_compress_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen)
sl@0: 	{
sl@0: 	int err = Z_OK;
sl@0: 	struct zlib_state *state =
sl@0: 		(struct zlib_state *)CRYPTO_get_ex_data(&ctx->ex_data,
sl@0: 			zlib_stateful_ex_idx);
sl@0: 
sl@0: 	if (state == NULL)
sl@0: 		return -1;
sl@0: 
sl@0: 	state->ostream.next_in = in;
sl@0: 	state->ostream.avail_in = ilen;
sl@0: 	state->ostream.next_out = out;
sl@0: 	state->ostream.avail_out = olen;
sl@0: 	if (ilen > 0)
sl@0: 		err = deflate(&state->ostream, Z_SYNC_FLUSH);
sl@0: 	if (err != Z_OK)
sl@0: 		return -1;
sl@0: #ifdef DEBUG_ZLIB
sl@0: 	fprintf(stderr,"compress(%4d)->%4d %s\n",
sl@0: 		ilen,olen - state->ostream.avail_out,
sl@0: 		(ilen != olen - state->ostream.avail_out)?"zlib":"clear");
sl@0: #endif
sl@0: 	return olen - state->ostream.avail_out;
sl@0: 	}
sl@0: 
sl@0: static int zlib_stateful_expand_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen)
sl@0: 	{
sl@0: 	int err = Z_OK;
sl@0: 
sl@0: 	struct zlib_state *state =
sl@0: 		(struct zlib_state *)CRYPTO_get_ex_data(&ctx->ex_data,
sl@0: 			zlib_stateful_ex_idx);
sl@0: 
sl@0: 	if (state == NULL)
sl@0: 		return 0;
sl@0: 
sl@0: 	state->istream.next_in = in;
sl@0: 	state->istream.avail_in = ilen;
sl@0: 	state->istream.next_out = out;
sl@0: 	state->istream.avail_out = olen;
sl@0: 	if (ilen > 0)
sl@0: 		err = inflate(&state->istream, Z_SYNC_FLUSH);
sl@0: 	if (err != Z_OK)
sl@0: 		return -1;
sl@0: #ifdef DEBUG_ZLIB
sl@0: 	fprintf(stderr,"expand(%4d)->%4d %s\n",
sl@0: 		ilen,olen - state->istream.avail_out,
sl@0: 		(ilen != olen - state->istream.avail_out)?"zlib":"clear");
sl@0: #endif
sl@0: 	return olen - state->istream.avail_out;
sl@0: 	}
sl@0: 
sl@0: #if 0
sl@0: static int zlib_compress_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen)
sl@0: 	{
sl@0: 	unsigned long l;
sl@0: 	int i;
sl@0: 	int clear=1;
sl@0: 
sl@0: 	if (ilen > 128)
sl@0: 		{
sl@0: 		out[0]=1;
sl@0: 		l=olen-1;
sl@0: 		i=compress(&(out[1]),&l,in,(unsigned long)ilen);
sl@0: 		if (i != Z_OK)
sl@0: 			return(-1);
sl@0: 		if (ilen > l)
sl@0: 			{
sl@0: 			clear=0;
sl@0: 			l++;
sl@0: 			}
sl@0: 		}
sl@0: 	if (clear)
sl@0: 		{
sl@0: 		out[0]=0;
sl@0: 		memcpy(&(out[1]),in,ilen);
sl@0: 		l=ilen+1;
sl@0: 		}
sl@0: #ifdef DEBUG_ZLIB
sl@0: 	fprintf(stderr,"compress(%4d)->%4d %s\n",
sl@0: 		ilen,(int)l,(clear)?"clear":"zlib");
sl@0: #endif
sl@0: 	return((int)l);
sl@0: 	}
sl@0: 
sl@0: static int zlib_expand_block(COMP_CTX *ctx, unsigned char *out,
sl@0: 	unsigned int olen, unsigned char *in, unsigned int ilen)
sl@0: 	{
sl@0: 	unsigned long l;
sl@0: 	int i;
sl@0: 
sl@0: 	if (in[0])
sl@0: 		{
sl@0: 		l=olen;
sl@0: 		i=zz_uncompress(out,&l,&(in[1]),(unsigned long)ilen-1);
sl@0: 		if (i != Z_OK)
sl@0: 			return(-1);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		memcpy(out,&(in[1]),ilen-1);
sl@0: 		l=ilen-1;
sl@0: 		}
sl@0: #ifdef DEBUG_ZLIB
sl@0:         fprintf(stderr,"expand  (%4d)->%4d %s\n",
sl@0: 		ilen,(int)l,in[0]?"zlib":"clear");
sl@0: #endif
sl@0: 	return((int)l);
sl@0: 	}
sl@0: 
sl@0: static int zz_uncompress (Bytef *dest, uLongf *destLen, const Bytef *source,
sl@0: 	     uLong sourceLen)
sl@0: {
sl@0:     z_stream stream;
sl@0:     int err;
sl@0: 
sl@0:     stream.next_in = (Bytef*)source;
sl@0:     stream.avail_in = (uInt)sourceLen;
sl@0:     /* Check for source > 64K on 16-bit machine: */
sl@0:     if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
sl@0: 
sl@0:     stream.next_out = dest;
sl@0:     stream.avail_out = (uInt)*destLen;
sl@0:     if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
sl@0: 
sl@0:     stream.zalloc = (alloc_func)0;
sl@0:     stream.zfree = (free_func)0;
sl@0: 
sl@0:     err = inflateInit_(&stream,
sl@0: 	    ZLIB_VERSION, sizeof(z_stream));
sl@0:     if (err != Z_OK) return err;
sl@0: 
sl@0:     err = inflate(&stream, Z_FINISH);
sl@0:     if (err != Z_STREAM_END) {
sl@0:         inflateEnd(&stream);
sl@0:         return err;
sl@0:     }
sl@0:     *destLen = stream.total_out;
sl@0: 
sl@0:     err = inflateEnd(&stream);
sl@0:     return err;
sl@0: }
sl@0: #endif
sl@0: 
sl@0: #endif
sl@0: 
sl@0: EXPORT_C COMP_METHOD *COMP_zlib(void)
sl@0: 	{
sl@0: 	COMP_METHOD *meth = &zlib_method_nozlib;
sl@0: 
sl@0: #ifdef ZLIB_SHARED
sl@0: 	if (!zlib_loaded)
sl@0: 		{
sl@0: #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)
sl@0: 		zlib_dso = DSO_load(NULL, "ZLIB1", NULL, 0);
sl@0: 		if (!zlib_dso)
sl@0: 			{
sl@0: 			zlib_dso = DSO_load(NULL, "ZLIB", NULL, 0);
sl@0: 			if (zlib_dso)
sl@0: 				{
sl@0: 				/* Clear the errors from the first failed
sl@0: 				   DSO_load() */
sl@0: 				ERR_clear_error();
sl@0: 				}
sl@0: 			}
sl@0: #else
sl@0: 		zlib_dso = DSO_load(NULL, "z", NULL, 0);
sl@0: #endif
sl@0: #ifndef SYMBIAN
sl@0: 		if (zlib_dso != NULL)
sl@0: 			{
sl@0: 			p_compress
sl@0: 				= (compress_ft) DSO_bind_func(zlib_dso,
sl@0: 					"compress");
sl@0: 			p_inflateEnd
sl@0: 				= (inflateEnd_ft) DSO_bind_func(zlib_dso,
sl@0: 					"inflateEnd");
sl@0: 			p_inflate
sl@0: 				= (inflate_ft) DSO_bind_func(zlib_dso,
sl@0: 					"inflate");
sl@0: 			p_inflateInit_
sl@0: 				= (inflateInit__ft) DSO_bind_func(zlib_dso,
sl@0: 					"inflateInit_");
sl@0: 			p_deflateEnd
sl@0: 				= (deflateEnd_ft) DSO_bind_func(zlib_dso,
sl@0: 					"deflateEnd");
sl@0: 			p_deflate
sl@0: 				= (deflate_ft) DSO_bind_func(zlib_dso,
sl@0: 					"deflate");
sl@0: 			p_deflateInit_
sl@0: 				= (deflateInit__ft) DSO_bind_func(zlib_dso,
sl@0: 					"deflateInit_");
sl@0: 			zlib_loaded++;
sl@0: 			}
sl@0: #else
sl@0: #ifdef LIBDL_ONLY_ORDINALS
sl@0: #define zlib_compress "2"
sl@0: #define zlib_inflateEnd "34"
sl@0: #define zlib_inflate "33"
sl@0: #define zlib_inflateInit_ "36"
sl@0: #define zlib_deflateEnd "9"
sl@0: #define zlib_deflate "6"
sl@0: #define zlib_deflateInit_ "11"
sl@0: #else
sl@0: #define zlib_compress compress
sl@0: #define zlib_inflateEnd inflateEnd
sl@0: #define zlib_inflate inflate
sl@0: #define zlib_inflateInit_ inflateInit_
sl@0: #define zlib_deflateEnd deflateEnd
sl@0: #define zlib_deflate deflate
sl@0: #define zlib_deflateInit_ deflateInit_
sl@0: #endif
sl@0: 	    if (zlib_dso != NULL)
sl@0: 			{
sl@0: 			p_compress
sl@0: 				= (compress_ft) DSO_bind_func(zlib_dso,
sl@0: 					(const char*)zlib_compress);
sl@0: 			p_inflateEnd
sl@0: 				= (inflateEnd_ft) DSO_bind_func(zlib_dso,
sl@0: 					(const char*)zlib_inflateEnd);
sl@0: 			p_inflate
sl@0: 				= (inflate_ft) DSO_bind_func(zlib_dso,
sl@0: 					(const char*)zlib_inflate);
sl@0: 			p_inflateInit_
sl@0: 				= (inflateInit__ft) DSO_bind_func(zlib_dso,
sl@0: 					(const char*)zlib_inflateInit_);
sl@0: 			p_deflateEnd
sl@0: 				= (deflateEnd_ft) DSO_bind_func(zlib_dso,
sl@0: 					(const char*)zlib_deflateEnd);
sl@0: 			p_deflate
sl@0: 				= (deflate_ft) DSO_bind_func(zlib_dso,
sl@0: 					(const char*)zlib_deflate);
sl@0: 			p_deflateInit_
sl@0: 				= (deflateInit__ft) DSO_bind_func(zlib_dso,
sl@0: 					(const char*)zlib_deflateInit_);
sl@0: 			zlib_loaded++;
sl@0: 			}
sl@0: 
sl@0: #endif			
sl@0: 		}
sl@0: 
sl@0: #endif
sl@0: #if defined(ZLIB) || defined(ZLIB_SHARED)
sl@0: 			{
sl@0: 		/* init zlib_stateful_ex_idx here so that in a multi-process
sl@0: 		 * application it's enough to intialize openssl before forking
sl@0: 		 * (idx will be inherited in all the children) */
sl@0: 		if (zlib_stateful_ex_idx == -1)
sl@0: 			{
sl@0: 			CRYPTO_w_lock(CRYPTO_LOCK_COMP);
sl@0: 			if (zlib_stateful_ex_idx == -1)
sl@0: 				zlib_stateful_ex_idx =
sl@0: 					CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_COMP,
sl@0: 						0,NULL,NULL,NULL,zlib_stateful_free_ex_data);
sl@0: 			CRYPTO_w_unlock(CRYPTO_LOCK_COMP);
sl@0: 			if (zlib_stateful_ex_idx == -1)
sl@0: 				goto err;
sl@0: 			}
sl@0: 		
sl@0: 		meth = &zlib_stateful_method;
sl@0: 		}
sl@0: err:	
sl@0: #endif
sl@0: 
sl@0: 	return(meth);
sl@0: 	}
sl@0: 
sl@0: #ifdef ZLIB_SHARED
sl@0: #if 0
sl@0: /* Stubs for each function to be dynamicly loaded */
sl@0: static int 
sl@0: stub_compress(Bytef *dest,uLongf *destLen,const Bytef *source, uLong sourceLen)
sl@0: 	{
sl@0: 	if (p_compress)
sl@0: 		return(p_compress(dest,destLen,source,sourceLen));
sl@0: 	else
sl@0: 		return(Z_MEM_ERROR);
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: static int
sl@0: stub_inflateEnd(z_streamp strm)
sl@0: 	{
sl@0: 	if ( p_inflateEnd )
sl@0: 		return(p_inflateEnd(strm));
sl@0: 	else
sl@0: 		return(Z_MEM_ERROR);
sl@0: 	}
sl@0: 
sl@0: static int
sl@0: stub_inflate(z_streamp strm, int flush)
sl@0: 	{
sl@0: 	if ( p_inflate )
sl@0: 		return(p_inflate(strm,flush));
sl@0: 	else
sl@0: 		return(Z_MEM_ERROR);
sl@0: 	}
sl@0: 
sl@0: static int
sl@0: stub_inflateInit_(z_streamp strm, const char * version, int stream_size)
sl@0: 	{
sl@0: 	if ( p_inflateInit_ )
sl@0: 		return(p_inflateInit_(strm,version,stream_size));
sl@0: 	else
sl@0: 		return(Z_MEM_ERROR);
sl@0: 	}
sl@0: 
sl@0: static int
sl@0: stub_deflateEnd(z_streamp strm)
sl@0: 	{
sl@0: 	if ( p_deflateEnd )
sl@0: 		return(p_deflateEnd(strm));
sl@0: 	else
sl@0: 		return(Z_MEM_ERROR);
sl@0: 	}
sl@0: 
sl@0: static int
sl@0: stub_deflate(z_streamp strm, int flush)
sl@0: 	{
sl@0: 	if ( p_deflate )
sl@0: 		return(p_deflate(strm,flush));
sl@0: 	else
sl@0: 		return(Z_MEM_ERROR);
sl@0: 	}
sl@0: 
sl@0: static int
sl@0: stub_deflateInit_(z_streamp strm, int level,
sl@0: 	const char * version, int stream_size)
sl@0: 	{
sl@0: 	if ( p_deflateInit_ )
sl@0: 		return(p_deflateInit_(strm,level,version,stream_size));
sl@0: 	else
sl@0: 		return(Z_MEM_ERROR);
sl@0: 	}
sl@0: 
sl@0: #endif /* ZLIB_SHARED */