static void Keccak( unsigned int rate, unsigned int capacity, const unsigned char * input, HB_SIZE inputByteLen, unsigned char delimitedSuffix, unsigned char * output, HB_SIZE outputByteLen )
{
HB_U8 state[ 200 ];
unsigned int rateInBytes = rate / 8;
unsigned int blockSize = 0;
unsigned int i;
if( ( ( rate + capacity ) != 1600 ) || ( ( rate % 8 ) != 0 ) )
return;
/* === Initialize the state === */
memset( state, 0, sizeof( state ) );
/* === Absorb all the input blocks === */
while( inputByteLen > 0 )
{
blockSize = HB_MIN( ( unsigned int ) inputByteLen, rateInBytes );
for( i = 0; i < blockSize; i++ )
state[ i ] ^= input[ i ];
input += blockSize;
inputByteLen -= blockSize;
if( blockSize == rateInBytes )
{
KeccakF1600_StatePermute( state );
blockSize = 0;
}
}
/* === Do the padding and switch to the squeezing phase === */
/* Absorb the last few bits and add the first bit of padding (which coincides with the delimiter in delimitedSuffix) */
state[ blockSize ] ^= delimitedSuffix;
/* If the first bit of padding is at position rate-1, we need a whole new block for the second bit of padding */
if( ( ( delimitedSuffix & 0x80 ) != 0 ) && ( blockSize == ( rateInBytes - 1 ) ) )
KeccakF1600_StatePermute( state );
/* Add the second bit of padding */
state[ rateInBytes - 1 ] ^= 0x80;
/* Switch to the squeezing phase */
KeccakF1600_StatePermute( state );
/* === Squeeze out all the output blocks === */
while( outputByteLen > 0 )
{
blockSize = HB_MIN( ( unsigned int ) outputByteLen, rateInBytes );
memcpy( output, state, blockSize );
output += blockSize;
outputByteLen -= blockSize;
if( outputByteLen > 0 )
KeccakF1600_StatePermute( state );
}
}
static long s_sockexRead( PHB_SOCKEX pSock, void * data, long len, HB_MAXINT timeout )
{
long lRead = HB_MIN( pSock->inbuffer, len );
if( lRead > 0 )
{
memcpy( data, pSock->buffer + pSock->posbuffer, lRead );
pSock->inbuffer -= lRead;
if( pSock->inbuffer )
pSock->posbuffer += lRead;
else
pSock->posbuffer = 0;
len -= lRead;
if( len == 0 || pSock->sd == HB_NO_SOCKET )
return lRead;
data = ( HB_BYTE * ) data + lRead;
timeout = 0;
}
else if( pSock->sd == HB_NO_SOCKET )
{
hb_socketSetError( HB_SOCKET_ERR_INVALIDHANDLE );
return -1;
}
len = pSock->cargo ? hb_znetRead( HB_ZNET_GET( pSock ), pSock->sd, data, len, timeout ) :
hb_socketRecv( pSock->sd, data, len, 0, timeout );
return lRead > 0 ? HB_MAX( len, 0 ) + lRead : len;
}
static long s_sockexRead( PHB_SOCKEX pSock, void * data, long len, HB_MAXINT timeout )
{
PHB_SOCKEX_BF pBF = HB_BFSOCK_GET( pSock );
long lRecv;
if( pSock->inbuffer > 0 && len > 0 )
{
lRecv = HB_MIN( pSock->inbuffer, len );
memcpy( data, pSock->buffer + pSock->posbuffer, lRecv );
if( ( pSock->inbuffer -= lRecv ) > 0 )
pSock->posbuffer += lRecv;
else
pSock->posbuffer = 0;
}
else
{
lRecv = hb_sockexRead( pBF->sock, data, len, timeout );
if( lRecv > 0 )
{
HB_BYTE * pData = ( HB_BYTE * ) data;
long l;
for( l = 0; l < lRecv; ++l )
{
if( ( pBF->decoded & ( HB_BF_CIPHERBLOCK - 1 ) ) == 0 )
{
s_bf_hash( &pBF->bf, pBF->decryptkey, pBF->decounter );
pBF->decoded = 0;
}
pData[ l ] ^= pBF->decryptkey[ pBF->decoded++ ];
}
}
}
return lRecv;
}
HB_ISIZ hb_strAtTBM( const char * needle, HB_ISIZ m, const char * haystack, HB_ISIZ n )
{
HB_ISIZ r = 0;
HB_ISIZ bcShift, j, shift, u, v, turboShift;
HB_ISIZ bmBc[ ASIZE ];
HB_ISIZ * bmGs;
bmGs = ( HB_ISIZ * ) hb_xgrab( m * sizeof( HB_ISIZ ) );
/* Preprocessing */
preBmGs( needle, m, bmGs );
preBmBc( needle, m, bmBc );
/* Searching */
j = u = 0;
shift = m;
while( j <= n - m )
{
HB_ISIZ i = m - 1;
while( i >= 0 && needle[ i ] == haystack[ i + j ] )
{
--i;
if( u != 0 && i == m - 1 - shift )
i -= u;
}
if( i < 0 )
{
r = j + 1;
break;
#if 0 /* To continue search */
shift = bmGs[ 0 ];
u = m - shift;
#endif
}
else
{
v = m - 1 - i;
turboShift = u - v;
bcShift = bmBc[ ( HB_UCHAR ) haystack[ i + j ] ] - m + 1 + i;
shift = HB_MAX( turboShift, bcShift );
shift = HB_MAX( shift, bmGs[ i ] );
if( shift == bmGs[ i ] )
u = HB_MIN( m - shift, v );
else
{
if( turboShift < bcShift )
shift = HB_MAX( shift, u + 1 );
u = 0;
}
}
j += shift;
}
hb_xfree( bmGs );
return r;
}
static int hb_win_ComSetTimeouts( HANDLE hCommPort, LPCOMMTIMEOUTS Timeouts, DWORD dwBaudRate, int iParity, int iByteSize, int iStopBits )
{
COMMTIMEOUTS NewTimeouts;
/* Maximum time, in milliseconds, allowed to elapse between the arrival of two characters on
the communications line. During a ReadFile operation, the time period begins when the first
character is received. If the interval between the arrival of any two characters exceeds this
amount, the ReadFile operation is completed and any buffered data is returned. A value of zero
indicates that interval time-outs are not used. */
/* A value of MAXDWORD, combined with zero values for both the ReadTotalTimeoutConstant and
ReadTotalTimeoutMultiplier members, specifies that the read operation is to return
immediately with the characters that have already been received, even if no characters
have been received. */
NewTimeouts.ReadIntervalTimeout = ( Timeouts->ReadIntervalTimeout == ( DWORD ) -1 ? MAXDWORD : Timeouts->ReadIntervalTimeout );
/* Multiplier, in milliseconds, used to calculate the total time-out period for read operations.
For each read operation, this value is multiplied by the requested number of bytes to be read. */
NewTimeouts.ReadTotalTimeoutMultiplier = ( Timeouts->ReadTotalTimeoutMultiplier == ( DWORD ) -1 ? 0 : Timeouts->ReadTotalTimeoutMultiplier );
/* Constant, in milliseconds, used to calculate the total time-out period for read operations.
For each read operation, this value is added to the product of the ReadTotalTimeoutMultiplier
member and the requested number of bytes. */
NewTimeouts.ReadTotalTimeoutConstant = ( Timeouts->ReadTotalTimeoutConstant == ( DWORD ) -1 ? 0 : Timeouts->ReadTotalTimeoutConstant );
/* A value of zero for both the ReadTotalTimeoutMultiplier and ReadTotalTimeoutConstant members
indicates that total time-outs are not used for read operations ...
and MAXDWORD, 0 and 0 are what we use by default */
/* Multiplier, in milliseconds, used to calculate the total time-out period for write operations.
For each write operation, this value is multiplied by the number of bytes to be written. */
if( Timeouts->WriteTotalTimeoutMultiplier == ( DWORD ) -1 )
{
/* float of 1.0 makes whole expression float */
NewTimeouts.WriteTotalTimeoutMultiplier = HB_MIN( 1, ( DWORD ) ( ( 1.0 / dwBaudRate ) *
( iByteSize + 1 + ( iParity == NOPARITY ? 0 : 1 ) + ( iStopBits == ONESTOPBIT ? 1 : iStopBits == ONE5STOPBITS ? 1.5 : 2 ) ) * 1000 ) );
}
/* Constant, in milliseconds, used to calculate the total time-out period for write operations.
For each write operation, this value is added to the product of the WriteTotalTimeoutMultiplier member and the number of bytes to be written. */
else
NewTimeouts.WriteTotalTimeoutMultiplier = Timeouts->WriteTotalTimeoutMultiplier;
/* 50 ms is a thumb-suck - seems long enough and not too long! */
NewTimeouts.WriteTotalTimeoutConstant = Timeouts->WriteTotalTimeoutConstant == ( DWORD ) -1 ? 50 : Timeouts->WriteTotalTimeoutConstant;
/* A value of zero for both the WriteTotalTimeoutMultiplier and WriteTotalTimeoutConstant members
indicates that total time-outs are not used for write operations ...
and if flow control is enabled the program will "hang" or if it is not enabled the data will
be lost (potentially), so we set a minimum of 1ms (baud rates higher than 4800) */
return SetCommTimeouts( hCommPort, &NewTimeouts );
}
static long s_sockexRead( PHB_SOCKEX pSock, void * data, long len, HB_MAXINT timeout )
{
PHB_SOCKEX_Z pZ = HB_ZSOCK_GET( pSock );
long lRecv = 0;
if( pSock->inbuffer > 0 && len > 0 )
{
lRecv = HB_MIN( pSock->inbuffer, len );
memcpy( data, pSock->buffer + pSock->posbuffer, lRecv );
if( ( pSock->inbuffer -= lRecv ) > 0 )
pSock->posbuffer += lRecv;
else
pSock->posbuffer = 0;
return lRecv;
}
else if( pZ->fDecompressIn )
{
int err = Z_OK;
pZ->z_read.next_out = ( Bytef * ) data;
pZ->z_read.avail_out = ( uInt ) len;
pZ->z_read.total_out = 0;
while( pZ->z_read.avail_out )
{
if( err == Z_BUF_ERROR && pZ->z_read.avail_in == 0 )
{
lRecv = hb_sockexRead( pZ->sock, pZ->rdbuf, HB_ZSOCK_RDBUFSIZE,
pZ->z_read.total_out == 0 ? timeout : 0 );
if( lRecv <= 0 )
break;
pZ->z_read.next_in = ( Bytef * ) pZ->rdbuf;
pZ->z_read.avail_in = ( uInt ) lRecv;
}
else if( err != Z_OK )
{
hb_socketSetError( HB_ZSOCK_ERROR_BASE - err );
lRecv = -1;
break;
}
err = inflate( &pZ->z_read, Z_SYNC_FLUSH );
}
if( pZ->z_read.total_out != 0 )
lRecv = ( long ) pZ->z_read.total_out;
return pZ->z_read.total_out != 0 ? ( long ) pZ->z_read.total_out : lRecv;
}
else
return hb_sockexRead( pZ->sock, data, len, timeout );
}
static long s_inetRecv( PHB_SOCKET_STRUCT socket, char * buffer, long size, HB_BOOL readahead )
{
long rec = 0;
if( readahead && socket->inbuffer == 0 && socket->readahead > size )
{
if( socket->buffer == NULL )
socket->buffer = ( char * ) hb_xgrab( socket->readahead );
socket->posbuffer = 0;
if( socket->recvFunc )
rec = socket->recvFunc( socket->stream, socket->sd,
socket->buffer, socket->readahead,
socket->iTimeout );
else
rec = hb_socketRecv( socket->sd, socket->buffer, socket->readahead,
0, socket->iTimeout );
socket->inbuffer = HB_MAX( 0, rec );
}
else
readahead = HB_FALSE;
if( socket->inbuffer > 0 )
{
rec = HB_MIN( size, socket->inbuffer );
memcpy( buffer, socket->buffer + socket->posbuffer, rec );
socket->posbuffer += rec;
socket->inbuffer -= rec;
if( size > rec && ! readahead )
{
if( socket->recvFunc )
rec = socket->recvFunc( socket->stream, socket->sd,
buffer + rec, size - rec,
socket->iTimeout );
else
size = hb_socketRecv( socket->sd, buffer + rec, size - rec, 0, 0 );
if( size > 0 )
rec += size;
}
}
else if( ! readahead )
{
if( socket->recvFunc )
rec = socket->recvFunc( socket->stream, socket->sd,
buffer, size, socket->iTimeout );
else
rec = hb_socketRecv( socket->sd, buffer, size, 0, socket->iTimeout );
}
return rec;
}
static HB_BOOL s_getKeyValue( LPCTSTR lpKey, LPTSTR lpBuffer, int iLen )
{
LPTSTR lpPtr;
int iSize, iPos, iCount;
if( lpKey == ( LPCTSTR ) -1 )
return GetModuleFileName( s_hInstDll, lpBuffer, iLen );
lpPtr = lpBuffer;
iSize = iLen - 1;
iPos = 0;
for( ;; )
{
TCHAR c = lpKey[ iPos++ ];
if( c == TEXT( '$' ) || c == TEXT( '@' ) || c == TEXT( '\0' ) )
{
if( --iPos )
{
iCount = HB_MIN( iPos, iSize );
memcpy( lpPtr, lpKey, iCount * sizeof( TCHAR ) );
lpKey += iPos;
lpPtr += iCount;
iSize -= iCount;
if( iSize == 0 )
break;
iPos = 0;
}
if( c == TEXT( '\0' ) )
break;
else
{
LPCTSTR lpVal = c == TEXT( '$' ) ? s_lpClsName : s_lpClsId;
iCount = ( int ) HB_STRNLEN( lpVal, iSize );
memcpy( lpPtr, lpVal, iCount * sizeof( TCHAR ) );
lpKey++;
lpPtr += iCount;
iSize -= iCount;
if( iSize == 0 )
break;
}
}
}
*lpPtr = TEXT( '\0' );
return iSize != 0;
}
static long s_sockexRead( PHB_SOCKEX pSock, void * data, long len, HB_MAXINT timeout )
{
long lRead = HB_MIN( pSock->inbuffer, len );
if( lRead > 0 )
{
memcpy( data, pSock->buffer + pSock->posbuffer, lRead );
pSock->inbuffer -= lRead;
if( pSock->inbuffer )
pSock->posbuffer += lRead;
else
pSock->posbuffer = 0;
return lRead;
}
else if( pSock->sd == HB_NO_SOCKET )
{
hb_socketSetError( HB_SOCKET_ERR_INVALIDHANDLE );
return -1;
}
return hb_ssl_socketRead( HB_SSLSOCK_GET( pSock ), pSock->sd, data, len, timeout );
}
HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
LPDBTRANSINFO lpdbTransInfo,
PHB_ITEM * pStruct, PHB_ITEM pFields )
{
HB_USHORT uiFields, uiSize, uiCount, uiPosSrc, uiPosDst, uiSizeSrc, uiSizeDst;
HB_ERRCODE errCode;
const char * szField;
HB_BOOL fAll;
errCode = SELF_FIELDCOUNT( lpaSource, &uiSizeSrc );
if( errCode != HB_SUCCESS )
return errCode;
if( lpaDest )
{
errCode = SELF_FIELDCOUNT( lpaDest, &uiSizeDst );
if( errCode != HB_SUCCESS )
return errCode;
uiSize = HB_MIN( uiSizeDst, uiSizeSrc );
}
else
{
uiSize = uiSizeDst = uiSizeSrc;
}
if( ! uiSize )
return HB_FAILURE;
if( hb_itemType( pFields ) & HB_IT_ARRAY )
{
uiFields = ( HB_USHORT ) hb_arrayLen( pFields );
if( uiFields )
uiSize = uiFields;
}
else
uiFields = 0;
fAll = ( uiSizeDst == uiSizeSrc );
lpdbTransInfo->lpaSource = lpaSource;
lpdbTransInfo->lpaDest = lpaDest;
lpdbTransInfo->lpTransItems = ( LPDBTRANSITEM )
hb_xgrab( uiSize * sizeof( DBTRANSITEM ) );
if( ! lpaDest )
{
*pStruct = hb_itemNew( NULL );
hb_arrayNew( *pStruct, 0 );
}
if( uiFields == 0 )
{
if( lpaDest )
{
PHB_ITEM pItem = hb_itemNew( NULL );
uiSize = 0;
for( uiCount = 1; uiCount <= uiSizeSrc; ++uiCount )
{
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_NAME, pItem ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
szField = hb_itemGetCPtr( pItem );
uiPosDst = hb_rddFieldExpIndex( lpaDest, szField );
if( uiPosDst != uiCount )
fAll = HB_FALSE;
if( uiPosDst )
{
HB_USHORT ui;
/* check for replicated field names in source area */
for( ui = 0; ui < uiSize; ++ui )
{
if( lpdbTransInfo->lpTransItems[ ui ].uiDest == uiPosDst )
break;
}
if( ui == uiSize )
{
lpdbTransInfo->lpTransItems[ uiSize ].uiSource = uiCount;
lpdbTransInfo->lpTransItems[ uiSize++ ].uiDest = uiPosDst;
}
}
}
hb_itemRelease( pItem );
}
else
{
hb_tblStructure( lpaSource, *pStruct, 0 );
uiSize = ( HB_USHORT ) hb_arrayLen( *pStruct );
for( uiCount = 0; uiCount < uiSize; ++uiCount )
{
lpdbTransInfo->lpTransItems[ uiCount ].uiSource =
lpdbTransInfo->lpTransItems[ uiCount ].uiDest = uiCount + 1;
}
}
}
else
{
uiSize = 0;
for( uiCount = 1; uiCount <= uiFields; ++uiCount )
{
szField = hb_dbTransFieldPos( pFields, uiCount );
if( szField )
{
uiPosSrc = hb_rddFieldExpIndex( lpaSource, szField );
if( ! uiPosSrc )
continue;
if( lpaDest )
uiPosDst = hb_rddFieldExpIndex( lpaDest, szField );
else
uiPosDst = uiSize + 1;
if( uiPosDst )
{
if( uiPosSrc != uiPosDst )
fAll = HB_FALSE;
lpdbTransInfo->lpTransItems[ uiSize ].uiSource = uiPosSrc;
lpdbTransInfo->lpTransItems[ uiSize++ ].uiDest = uiPosDst;
if( ! lpaDest )
{
hb_arraySize( *pStruct, uiSize );
hb_fldStructure( lpaSource, uiPosSrc, 0,
hb_arrayGetItemPtr( *pStruct, uiSize ) );
}
}
}
}
}
if( uiSize != uiSizeSrc )
fAll = HB_FALSE;
if( fAll && lpaDest )
{
PHB_ITEM pSrcItm = hb_itemNew( NULL ),
pDstItm = hb_itemNew( NULL );
/*
* if fAll is HB_TRUE here then it means that all fields are included
* and they are on the same positions in both tables, so now check
* if their types and sizes are also equal
*/
for( uiCount = 1; uiCount <= uiSize; ++uiCount )
{
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_TYPE, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_TYPE, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
if( hb_stricmp( hb_itemGetCPtr( pSrcItm ),
hb_itemGetCPtr( pDstItm ) ) != 0 )
{
fAll = HB_FALSE;
break;
}
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_LEN, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_LEN, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = HB_FALSE;
break;
}
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_DEC, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_DEC, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = HB_FALSE;
break;
}
#ifdef DBS_FLAG
if( SELF_FIELDINFO( lpaSource, uiCount, DBS_FLAG, pSrcItm ) != HB_SUCCESS ||
SELF_FIELDINFO( lpaDest, uiCount, DBS_FLAG, pDstItm ) != HB_SUCCESS )
{
uiSize = 0;
break;
}
if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
{
fAll = HB_FALSE;
break;
}
#endif
}
hb_itemRelease( pSrcItm );
hb_itemRelease( pDstItm );
}
lpdbTransInfo->uiFlags = fAll ? DBTF_MATCH : 0;
lpdbTransInfo->uiItemCount = uiSize;
return uiSize ? HB_SUCCESS : HB_FAILURE;
}
/* the contents of the inserted bytes are indeterminate, i.e. you'll have to
write to them before they mean anything */
static int _ins_buff( PFT_TEXT ft_text, HB_ISIZ iLen )
{
char * ReadBuff = ( char * ) hb_xgrab( BUFFSIZE );
char * WriteBuff = ( char * ) hb_xgrab( BUFFSIZE );
char * SaveBuff;
HB_FOFFSET fpRead, fpWrite;
HB_ISIZ WriteLen, ReadLen;
HB_ISIZ SaveLen;
HB_ISIZ iLenRemaining = iLen;
/* set target move distance, this allows iLen to be greater than BUFFSIZE */
iLen = HB_MIN( iLenRemaining, BUFFSIZE );
iLenRemaining -= iLen;
/* initialize file pointers */
fpRead = ft_text->offset[ ft_text->area ];
fpWrite = ft_text->offset[ ft_text->area ] + iLen;
/* do initial load of both buffers */
WriteLen = hb_fileResult( hb_fileReadAt( ft_text->handles[ ft_text->area ], WriteBuff, BUFFSIZE, fpRead ) );
fpRead += WriteLen;
ReadLen = hb_fileResult( hb_fileRead( ft_text->handles[ ft_text->area ], ReadBuff, BUFFSIZE, -1 ) );
fpRead += ReadLen;
ft_text->error[ ft_text->area ] = 0;
while( ! ft_text->error[ ft_text->area ] && iLen > 0 )
{
while( WriteLen > 0 )
{
/* position to beginning of write area */
if( hb_fileSeek( ft_text->handles[ ft_text->area ], fpWrite, FS_SET ) != fpWrite )
{
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
if( ( SaveLen = hb_fileResult( hb_fileWrite( ft_text->handles[ ft_text->area ], WriteBuff, WriteLen, -1 ) ) ) == 0 )
{
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
/* move write pointer */
fpWrite += SaveLen;
if( SaveLen != WriteLen )
{
/* error, fetch errcode and quit */
ft_text->error[ ft_text->area ] = hb_fsError();
break;
}
#if 0
WriteLen = SaveLen;
#endif
/* swap buffers */
SaveBuff = WriteBuff;
WriteBuff = ReadBuff;
ReadBuff = SaveBuff;
WriteLen = ReadLen;
/* return to read area and read another buffer */
ReadLen = hb_fileResult( hb_fileReadAt( ft_text->handles[ ft_text->area ], ReadBuff, BUFFSIZE, fpRead ) );
fpRead += ReadLen;
}
iLen = HB_MIN( iLenRemaining, BUFFSIZE );
iLenRemaining -= iLen;
}
/* store length in bytes, set legacy EOF marker */
ft_text->lastbyte[ ft_text->area ] = hb_fileSeek( ft_text->handles[ ft_text->area ], fpWrite, FS_SET );
hb_fileWrite( ft_text->handles[ ft_text->area ], WriteBuff, 0, -1 );
/* clear last_rec so next gobot will recount the records */
ft_text->last_rec[ ft_text->area ] = 0;
hb_fileSeek( ft_text->handles[ ft_text->area ], ft_text->offset[ ft_text->area ], FS_SET );
hb_xfree( ReadBuff );
hb_xfree( WriteBuff );
return ft_text->error[ ft_text->area ];
}
/* read data using stream structure
*/
long hb_znetRead( PHB_ZNETSTREAM pStream, HB_SOCKET sd, void * buffer, long len, HB_MAXINT timeout )
{
long rec = 0;
pStream->rd.next_out = ( Bytef * ) buffer;
pStream->rd.avail_out = ( uInt ) len;
pStream->err = Z_OK;
while( pStream->rd.avail_out )
{
if( pStream->rd.avail_in == 0 && pStream->err == Z_BUF_ERROR )
{
if( pStream->skip_in )
{
pStream->rd.next_in += pStream->skip_in;
pStream->skip_in = 0;
}
if( pStream->crypt_in && pStream->rd.next_in > pStream->inbuf )
memmove( pStream->inbuf, pStream->rd.next_in, pStream->crypt_in );
pStream->rd.next_in = pStream->inbuf;
if( ! pStream->crypt || pStream->crypt_in < 8 )
{
if( pStream->rd.avail_out != ( uInt ) len )
timeout = 0;
rec = hb_socketRecv( sd, pStream->inbuf + pStream->crypt_in, HB_ZNET_BUFSIZE - pStream->crypt_in, 0, timeout );
if( rec <= 0 )
break;
}
if( pStream->crypt )
{
pStream->crypt_in += rec;
if( pStream->crypt_size == 0 )
{
if( pStream->crypt_in >= 8 )
{
hb_znetDecrypt( pStream, pStream->rd.next_in );
pStream->crypt_size = HB_GET_BE_UINT16( pStream->rd.next_in );
pStream->rd.next_in += 2;
pStream->crypt_in -= 8;
rec = HB_MIN( pStream->crypt_size, 6 );
pStream->crypt_size -= ( uInt ) rec;
pStream->rd.avail_in += ( uInt ) rec;
pStream->skip_in = ( uInt ) ( 6 - rec );
rec = 0;
}
}
if( pStream->skip_in == 0 )
{
long l = ( pStream->crypt_size + 0x07 ) & ~0x07;
rec = pStream->crypt_in & ~0x07;
if( rec > l )
rec = l;
/* decrypt the buffer */
for( l = 0; l < rec; l += 8 )
hb_znetDecrypt( pStream, pStream->rd.next_in + pStream->rd.avail_in + l );
pStream->crypt_in -= rec;
if( ( uInt ) rec > pStream->crypt_size )
{
pStream->skip_in = rec - pStream->crypt_size;
rec = pStream->crypt_size;
}
pStream->crypt_size -= rec;
}
}
pStream->rd.avail_in += ( uInt ) rec;
if( pStream->rd.avail_in == 0 )
break;
rec = 0;
}
pStream->err = inflate( &pStream->rd, Z_SYNC_FLUSH );
/*
if( pStream->err == Z_STREAM_END && pStream->rd.avail_in == 0 )
pStream->err = Z_BUF_ERROR;
*/
if( pStream->err != Z_OK &&
! ( pStream->err == Z_BUF_ERROR && pStream->rd.avail_in == 0 ) )
break;
}
len -= pStream->rd.avail_out;
return len == 0 ? rec : len;
}
static int hb_zipDeleteFile( const char * szZipFile, const char * szFileMask )
{
char szTempFile[ HB_PATH_MAX ];
char szCurrFile[ HB_PATH_MAX ];
PHB_FNAME pFileName;
HB_FHANDLE hFile;
unzFile hUnzip;
zipFile hZip;
unz_global_info ugi;
unz_file_info ufi;
zip_fileinfo zfi;
char * pszGlobalComment = NULL;
char * pszFileComment = NULL;
void * pExtraField = NULL;
void * pLocalExtraField = NULL;
int iFilesLeft = 0;
int iFilesDel = 0;
int iExtraFieldLen;
int method;
int level;
int iResult;
char * pszFree;
/* open source file */
hUnzip = unzOpen( hb_fsNameConv( szZipFile, &pszFree ) );
if( pszFree )
hb_xfree( pszFree );
if( hUnzip == NULL )
return UNZ_ERRNO;
pFileName = hb_fsFNameSplit( szZipFile );
hFile = hb_fsCreateTemp( pFileName->szPath, NULL, FC_NORMAL, szTempFile );
hZip = NULL;
if( hFile != FS_ERROR )
{
hb_fsClose( hFile );
hZip = zipOpen( szTempFile, APPEND_STATUS_CREATE );
}
hb_xfree( pFileName );
if( hZip == NULL )
{
unzClose( hUnzip );
return UNZ_ERRNO;
}
iResult = unzGetGlobalInfo( hUnzip, &ugi );
if( iResult == UNZ_OK )
{
if( ugi.size_comment > 0 )
{
pszGlobalComment = ( char * ) hb_xgrab( ugi.size_comment + 1 );
if( ( uLong ) unzGetGlobalComment( hUnzip, pszGlobalComment,
ugi.size_comment ) != ugi.size_comment )
iResult = UNZ_ERRNO;
pszGlobalComment[ ugi.size_comment ] = '\0';
}
if( iResult == UNZ_OK )
iResult = unzGoToFirstFile( hUnzip );
}
while( iResult == UNZ_OK )
{
iResult = unzGetCurrentFileInfo( hUnzip, &ufi, szCurrFile, HB_PATH_MAX - 1, NULL, 0, NULL, 0 );
if( iResult != UNZ_OK )
break;
if( hb_strMatchFile( szCurrFile, szFileMask ) )
iFilesDel++;
else
{
if( ufi.size_file_extra )
pExtraField = ( char * ) hb_xgrab( ufi.size_file_extra );
if( ufi.size_file_comment )
pszFileComment = ( char * ) hb_xgrab( ufi.size_file_comment + 1 );
iResult = unzGetCurrentFileInfo( hUnzip, &ufi, NULL, 0,
pExtraField, ufi.size_file_extra,
pszFileComment, ufi.size_file_comment );
if( pszFileComment )
pszFileComment[ ufi.size_file_comment ] = '\0';
if( iResult != UNZ_OK )
break;
iResult = unzOpenCurrentFile2( hUnzip, &method, &level, 1 );
if( iResult != UNZ_OK )
break;
iExtraFieldLen = unzGetLocalExtrafield( hUnzip, NULL, 0 );
if( iExtraFieldLen < 0 )
{
iResult = UNZ_ERRNO;
break;
}
else if( iExtraFieldLen > 0 )
{
pLocalExtraField = hb_xgrab( iExtraFieldLen );
if( unzGetLocalExtrafield( hUnzip, pLocalExtraField, iExtraFieldLen ) != iExtraFieldLen )
{
iResult = UNZ_ERRNO;
break;
}
}
memset( &zfi, 0, sizeof( zfi ) );
memcpy( &zfi.tmz_date, &ufi.tmu_date, sizeof( tm_unz ) );
zfi.dosDate = ufi.dosDate;
zfi.internal_fa = ufi.internal_fa;
zfi.external_fa = ufi.external_fa;
iResult = zipOpenNewFileInZip2( hZip, szCurrFile, &zfi, pLocalExtraField, iExtraFieldLen, pExtraField, ufi.size_file_extra, pszFileComment, method, level, 1 );
if( iResult != UNZ_OK )
break;
if( ufi.compressed_size )
{
void * buffer = hb_xgrab( HB_Z_IOBUF_SIZE );
uLong ulLeft = ufi.compressed_size;
while( ulLeft > 0 )
{
int iRead = HB_MIN( ulLeft, HB_Z_IOBUF_SIZE );
iResult = unzReadCurrentFile( hUnzip, ( voidp ) buffer, iRead );
if( iResult < 0 )
break;
if( iResult != iRead )
{
iResult = UNZ_ERRNO;
break;
}
iResult = zipWriteInFileInZip( hZip, ( voidp ) buffer, iRead );
if( iResult != UNZ_OK )
break;
ulLeft -= iRead;
}
hb_xfree( buffer );
if( iResult != UNZ_OK )
break;
}
iResult = zipCloseFileInZipRaw( hZip, ufi.uncompressed_size, ufi.crc );
if( iResult != UNZ_OK )
break;
iResult = unzCloseCurrentFile( hUnzip );
if( iResult != UNZ_OK )
break;
if( pExtraField )
{
hb_xfree( pExtraField );
pExtraField = NULL;
}
if( pszFileComment )
{
hb_xfree( pszFileComment );
pszFileComment = NULL;
}
if( pLocalExtraField )
{
hb_xfree( pLocalExtraField );
pLocalExtraField = NULL;
}
iFilesLeft++;
}
iResult = unzGoToNextFile( hUnzip );
}
if( pExtraField )
hb_xfree( pExtraField );
if( pszFileComment )
hb_xfree( pszFileComment );
if( pLocalExtraField )
hb_xfree( pLocalExtraField );
if( iFilesDel == 0 )
iResult = UNZ_ERRNO;
else if( iResult == UNZ_END_OF_LIST_OF_FILE )
iResult = UNZ_OK;
if( iResult != UNZ_OK )
zipClose( hZip, NULL );
else
iResult = zipClose( hZip, pszGlobalComment );
unzClose( hUnzip );
if( pszGlobalComment )
hb_xfree( pszGlobalComment );
if( iResult != UNZ_OK )
hb_fsDelete( szTempFile );
else
{
hb_fsDelete( szZipFile );
if( iFilesLeft == 0 )
hb_fsDelete( szTempFile );
else if( ! hb_fsRename( szTempFile, szZipFile ) )
iResult = UNZ_ERRNO;
}
return iResult;
}
