Lzhl_tcp.h File Reference

Function Documentation

SOCKET lzhl_accept	(	SOCKET	s,
		struct sockaddr *	addr,
		int *	addrlen
	)

Definition at line 55 of file Lzhl_tcp.cpp.

00055                                                                     {
00056   SOCKET sock = accept( s, addr, addrlen );
00057 
00058   if ( sock >= 0 )
00059     globalMap.insert( GlobalMapType::value_type( sock, LZHL_SOCKET() ) );
00060 
00061   return sock;
00062 }

int lzhl_closesocket

(

SOCKET

sock

)

Definition at line 244 of file Lzhl_tcp.cpp.

00244                                     {
00245   GlobalMapType::iterator iter = globalMap.find( sock );
00246 
00247   if ( iter != globalMap.end() ) {
00248     LZHL_CHANDLE ch = (*iter).second.ch;
00249 
00250     if ( ch != LZHL_CHANDLE_NULL )
00251       LZHLDestroyCompressor( ch );
00252 
00253     LZHL_DHANDLE dh = (*iter).second.dh;
00254 
00255     if ( dh != LZHL_DHANDLE_NULL )
00256       LZHLDestroyDecompressor( dh );
00257 
00258     delete [] (*iter).second.dBuf;
00259   }
00260   return closesocket( sock );
00261 }

int lzhl_recv	(	SOCKET	s,
		char *	buf,
		int	len,
		int	flags
	)

Definition at line 155 of file Lzhl_tcp.cpp.

00156 {
00157   GlobalMapType::iterator iter = globalMap.find( sock );
00158   if ( iter != globalMap.end() ) {
00159     LZHL_SOCKET& ls = (*iter).second;
00160     LZHL_DHANDLE& dh = ls.dh;
00161 
00162     if ( dh == LZHL_DHANDLE_NULL )
00163       dh = LZHLCreateDecompressor();
00164 
00165     if ( ls.dBuf == 0 ) {
00166       unsigned int dataSz, compSz;
00167       BYTE tmp[ 10 ];
00168       int bytesRead = 0;
00169       int hdrSz;
00170 
00171       for (;;) {
00172         int bytes = recv( sock, (char*)( tmp + bytesRead ), 1, flags );
00173 
00174         if ( bytes <= 0 )
00175           return bytes;
00176 
00177         bytesRead += bytes;
00178         BYTE* p = tmp;
00179 
00180         int err = _getInt( p, bytesRead, &dataSz );
00181 
00182         if ( err == 1 )
00183           continue;  //forever
00184         else if ( err > 0 )
00185           return -1;
00186 
00187         err = _getInt( p, bytesRead - ( p - tmp ), &compSz );
00188 
00189         if ( err == 1 )
00190           continue;  //forever
00191         else if ( err > 0 )
00192           return -1;
00193 
00194         hdrSz = p - tmp;
00195         break; //forever
00196       }
00197 
00198       BYTE* compBuf = new BYTE[ compSz ];
00199       bytesRead -= hdrSz;
00200       memcpy( compBuf, tmp + hdrSz, bytesRead );
00201       for (;;) {
00202         int bytes = recv( sock, (char*)( compBuf + bytesRead ), compSz - bytesRead, flags );
00203         if ( bytes <= 0 ) {
00204           delete [] compBuf;
00205           return bytes;
00206         }
00207 
00208         bytesRead += bytes;
00209         if ( bytesRead == compSz )
00210           break;   //forever
00211       }
00212 
00213       ls.dSz = dataSz;
00214       ls.dDisp = 0;
00215       ls.dBuf = new BYTE[ dataSz ];
00216       
00217       int Ok = LZHLDecompress( dh, ls.dBuf, &dataSz, compBuf, &compSz );
00218       delete [] compBuf;
00219 
00220       if ( !Ok ) {
00221         delete [] ls.dBuf;
00222         ls.dBuf = 0;
00223         return -1;
00224       }
00225 
00226     }  // if ( ls.dBuf == 0 )
00227 
00228     assert( ls.dBuf );
00229     int sz = min( bufSz, ls.dSz - ls.dDisp );
00230     memcpy( buf, ls.dBuf + ls.dDisp, sz );
00231     ls.dDisp += sz;
00232 
00233     if ( ls.dDisp == ls.dSz ) {
00234       delete [] ls.dBuf;
00235       ls.dBuf = 0;
00236     }
00237     return sz;
00238 
00239   } else {
00240     return recv( sock, buf, bufSz, flags );
00241   }
00242 }

int lzhl_send	(	SOCKET	s,
		const char *	buf,
		int	len,
		int	flags
	)

Definition at line 101 of file Lzhl_tcp.cpp.

00101                                                                       {
00102   GlobalMapType::iterator iter = globalMap.find( sock );
00103   if ( iter != globalMap.end() ) {
00104     LZHL_CHANDLE& ch = (*iter).second.ch;
00105 
00106     if ( ch == LZHL_CHANDLE_NULL )
00107       ch = LZHLCreateCompressor();
00108 
00109     size_t maxSz = 10 + LZHLCompressorCalcMaxBuf( dataSz );
00110     BYTE* buf = new BYTE[ maxSz ];
00111     size_t compSz = LZHLCompress( ch, buf + 10, data, dataSz );
00112 
00113     int dSz;
00114 
00115     {
00116       BYTE tmp[ 5 ];
00117       BYTE* p = tmp;
00118       _putInt( p, compSz );
00119       int szSz = p - tmp;
00120       dSz = szSz;
00121       assert( dSz <= 10 );
00122       memcpy( buf + 10 - dSz, tmp, szSz );
00123       
00124       p = tmp;
00125       _putInt( p, dataSz );
00126       szSz = p - tmp;
00127       dSz += szSz;
00128       assert( dSz <= 10 );
00129       memcpy( buf + 10 - dSz, tmp, szSz );
00130     }
00131 
00132     {
00133       BYTE* p = buf + 10 - dSz;
00134       int sz = dSz + compSz;
00135 
00136       while( sz ) {
00137         int bytes = send( sock, (char*)( buf + 10 - dSz ), dSz + compSz, flags );
00138 
00139         if ( bytes < 0 )
00140           return bytes;
00141 
00142         assert( bytes <= sz );
00143         sz -= bytes;
00144         p  += bytes;
00145       }
00146     }
00147 
00148     delete [] buf;
00149     return dataSz;
00150   } else {
00151     return send( sock, data, dataSz, flags );
00152   }
00153 }

SOCKET lzhl_socket	(	int	af,
		int	type,
		int	protocol
	)

Definition at line 46 of file Lzhl_tcp.cpp.

00046                                                      {
00047   SOCKET sock = socket( af, type, protocol );
00048 
00049   if ( sock >= 0 )
00050     globalMap.insert( GlobalMapType::value_type( sock, LZHL_SOCKET() ) );
00051 
00052   return sock;
00053 }

Generated on Sun Oct 14 18:47:42 2001 for Standard J2K Library by

Functions
SOCKET	lzhl_socket (int af, int type, int protocol)
SOCKET	lzhl_accept (SOCKET s, struct sockaddr addr, int addrlen)
int	lzhl_send (SOCKET s, const char *buf, int len, int flags)
int	lzhl_recv (SOCKET s, char *buf, int len, int flags)
int	lzhl_closesocket (SOCKET sock)

C:/temp/src/j2k/LZH/Lzhl_tcp.h File Reference

Functions

Function Documentation