static PHB_ITEM hb_i18n_serialize( PHB_I18N_TRANS pI18N )
{
if( pI18N )
{
HB_SIZE nSize;
HB_U32 ulCRC;
char * pBuffer = hb_itemSerialize( pI18N->table, 0, &nSize );
char * pI18Nbuffer;
PHB_ITEM pKey, pValue;
ulCRC = hb_crc32( 0, pBuffer, nSize );
pI18Nbuffer = ( char * ) memset( hb_xgrab( nSize + HB_I18N_HEADER_SIZE + 1 ),
0, HB_I18N_HEADER_SIZE );
memcpy( pI18Nbuffer + HB_I18N_HEADER_SIZE, pBuffer, nSize );
hb_xfree( pBuffer );
memcpy( pI18Nbuffer, s_signature, HB_I18N_SIG_SIZE );
HB_PUT_LE_UINT32( &pI18Nbuffer[ HB_I18N_SIZE_OFFSET ], nSize );
HB_PUT_LE_UINT32( &pI18Nbuffer[ HB_I18N_CRC_OFFSET ], ulCRC );
pKey = hb_itemPutCConst( NULL, "DESCRIPTION" );
pValue = hb_hashGetItemPtr( pI18N->table, pKey, 0 );
if( pValue )
hb_strncpy( &pI18Nbuffer[ HB_I18N_TXT_OFFSET ],
hb_itemGetCPtr( pValue ), HB_I18N_TXT_SIZE );
return hb_itemPutCLPtr( pKey, pI18Nbuffer, nSize + HB_I18N_HEADER_SIZE );
}
return NULL;
}
static HB_BOOL s_netio_login_accept( PHB_CONSRV conn )
{
if( conn && conn->sd != HB_NO_SOCKET && ! conn->stop && ! conn->login )
{
HB_BYTE msgbuf[ NETIO_MSGLEN ];
if( s_srvRecvAll( conn, msgbuf, NETIO_MSGLEN ) == NETIO_MSGLEN &&
HB_GET_LE_INT32( msgbuf ) == NETIO_LOGIN )
{
long len = HB_GET_LE_INT16( &msgbuf[ 4 ] );
if( len < ( long ) sizeof( msgbuf ) &&
len == ( long ) strlen( NETIO_LOGINSTRID ) &&
s_srvRecvAll( conn, msgbuf, len ) == len )
{
if( memcmp( NETIO_LOGINSTRID, msgbuf, len ) == 0 )
{
HB_PUT_LE_UINT32( &msgbuf[ 0 ], NETIO_LOGIN );
HB_PUT_LE_UINT32( &msgbuf[ 4 ], NETIO_CONNECTED );
memset( msgbuf + 8, '\0', NETIO_MSGLEN - 8 );
if( s_srvSendAll( conn, msgbuf, NETIO_MSGLEN ) == NETIO_MSGLEN )
conn->login = HB_TRUE;
}
}
}
if( ! conn->login )
s_consrv_disconnect( conn );
return conn->login;
}
return HB_FALSE;
}
void * hb_xrealloc( void * pMem, HB_SIZE nSize ) /* reallocates memory */
{
#ifdef HB_FM_STATISTICS
PHB_MEMINFO pMemBlock;
HB_SIZE nMemSize;
void * pResult;
if( nSize == 0 )
{
if( pMem )
hb_xfree( pMem );
return NULL;
}
else if( ! pMem )
return hb_xgrab( nSize );
pMemBlock = ( PHB_MEMINFO ) ( ( HB_BYTE * ) pMem - HB_MEMINFO_SIZE );
nMemSize = pMemBlock->nSize;
if( pMemBlock->Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XREALLOCINV, "hb_xrealloc called with an invalid pointer", NULL, NULL );
if( HB_GET_LE_UINT32( ( ( HB_BYTE * ) pMem ) + nMemSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, "Memory buffer overflow", NULL, NULL );
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pMem ) + nMemSize, 0 );
pResult = realloc( pMemBlock, nSize + HB_MEMINFO_SIZE + sizeof( HB_U32 ) );
if( pResult )
{
if( s_pMemBlocks == pMemBlock )
s_pMemBlocks = ( PHB_MEMINFO ) pResult;
else
( ( PHB_MEMINFO ) pResult )->pPrevBlock->pNextBlock = ( PHB_MEMINFO ) pResult;
if( ( ( PHB_MEMINFO ) pResult )->pNextBlock )
( ( PHB_MEMINFO ) pResult )->pNextBlock->pPrevBlock = ( PHB_MEMINFO ) pResult;
s_nMemoryConsumed += ( nSize - nMemSize );
if( s_nMemoryMaxConsumed < s_nMemoryConsumed )
s_nMemoryMaxConsumed = s_nMemoryConsumed;
( ( PHB_MEMINFO ) pResult )->nSize = nSize; /* size of the memory block */
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pResult ) + nSize + HB_MEMINFO_SIZE, HB_MEMINFO_SIGNATURE );
pResult = ( HB_BYTE * ) pResult + HB_MEMINFO_SIZE;
}
#else
void * pResult = realloc( pMem, nSize );
#endif
if( ! pResult && nSize )
hb_errInternal( HB_EI_XREALLOC, "hb_xrealloc can't reallocate memory", NULL, NULL );
return pResult;
}
void hb_xfree( void * pMem ) /* frees fixed memory */
{
if( pMem )
{
#ifdef HB_FM_STATISTICS
PHB_MEMINFO pMemBlock = ( PHB_MEMINFO ) ( ( HB_BYTE * ) pMem - HB_MEMINFO_SIZE );
if( pMemBlock->Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, "hb_xfree called with an invalid pointer", NULL, NULL );
if( HB_GET_LE_UINT32( ( ( HB_BYTE * ) pMem ) + pMemBlock->nSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, "Memory buffer overflow", NULL, NULL );
s_nMemoryConsumed -= pMemBlock->nSize;
s_nMemoryBlocks--;
if( s_pMemBlocks == pMemBlock )
s_pMemBlocks = pMemBlock->pNextBlock;
else
pMemBlock->pPrevBlock->pNextBlock = pMemBlock->pNextBlock;
if( pMemBlock->pNextBlock )
pMemBlock->pNextBlock->pPrevBlock = pMemBlock->pPrevBlock;
pMemBlock->Signature = 0;
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pMem ) + pMemBlock->nSize, 0 );
pMem = ( HB_BYTE * ) pMem - HB_MEMINFO_SIZE;
#endif
free( pMem );
}
else
hb_errInternal( HB_EI_XFREENULL, "hb_xfree called with a NULL pointer", NULL, NULL );
}
/**
* salsa20_8(B):
* Apply the salsa20/8 core to the provided block.
*/
static void
salsa20_8(uint8_t B[64])
{
uint32_t B32[16];
uint32_t x[16];
size_t i;
/* Convert little-endian values in. */
for (i = 0; i < 16; i++)
B32[i] = HB_GET_LE_UINT32(&B[i * 4]);
/* Compute x = doubleround^4(B32). */
for (i = 0; i < 16; i++)
x[i] = B32[i];
for (i = 0; i < 8; i += 2) {
#define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))
/* Operate on columns. */
x[ 4] ^= R(x[ 0]+x[12], 7); x[ 8] ^= R(x[ 4]+x[ 0], 9);
x[12] ^= R(x[ 8]+x[ 4],13); x[ 0] ^= R(x[12]+x[ 8],18);
x[ 9] ^= R(x[ 5]+x[ 1], 7); x[13] ^= R(x[ 9]+x[ 5], 9);
x[ 1] ^= R(x[13]+x[ 9],13); x[ 5] ^= R(x[ 1]+x[13],18);
x[14] ^= R(x[10]+x[ 6], 7); x[ 2] ^= R(x[14]+x[10], 9);
x[ 6] ^= R(x[ 2]+x[14],13); x[10] ^= R(x[ 6]+x[ 2],18);
x[ 3] ^= R(x[15]+x[11], 7); x[ 7] ^= R(x[ 3]+x[15], 9);
x[11] ^= R(x[ 7]+x[ 3],13); x[15] ^= R(x[11]+x[ 7],18);
/* Operate on rows. */
x[ 1] ^= R(x[ 0]+x[ 3], 7); x[ 2] ^= R(x[ 1]+x[ 0], 9);
x[ 3] ^= R(x[ 2]+x[ 1],13); x[ 0] ^= R(x[ 3]+x[ 2],18);
x[ 6] ^= R(x[ 5]+x[ 4], 7); x[ 7] ^= R(x[ 6]+x[ 5], 9);
x[ 4] ^= R(x[ 7]+x[ 6],13); x[ 5] ^= R(x[ 4]+x[ 7],18);
x[11] ^= R(x[10]+x[ 9], 7); x[ 8] ^= R(x[11]+x[10], 9);
x[ 9] ^= R(x[ 8]+x[11],13); x[10] ^= R(x[ 9]+x[ 8],18);
x[12] ^= R(x[15]+x[14], 7); x[13] ^= R(x[12]+x[15], 9);
x[14] ^= R(x[13]+x[12],13); x[15] ^= R(x[14]+x[13],18);
#undef R
}
/* Compute B32 = B32 + x. */
for (i = 0; i < 16; i++)
B32[i] += x[i];
/* Convert little-endian values out. */
for (i = 0; i < 16; i++)
HB_PUT_LE_UINT32(&B[4 * i], B32[i]);
}
HB_BOOL hb_lppSend( PHB_LPP pSocket, const void * data, HB_SIZE len, HB_MAXINT timeout )
{
HB_MAXINT nTime = 0;
long lSend;
if( ! pSocket->pSendBuffer )
{
pSocket->pSendBuffer = ( char * ) hb_xgrab( len + 4 );
HB_PUT_LE_UINT32( pSocket->pSendBuffer, len );
hb_xmemcpy( pSocket->pSendBuffer + 4, data, len );
pSocket->nSendLen = len + 4;
pSocket->nSendPos = 0;
}
if( timeout > 0 )
nTime = ( HB_MAXINT ) hb_dateMilliSeconds() + timeout;
for( ;; )
{
if( pSocket->nSendLen - pSocket->nSendPos < ( HB_SIZE ) LONG_MAX )
lSend = ( long ) ( pSocket->nSendLen - pSocket->nSendPos );
else
lSend = LONG_MAX;
lSend = hb_socketSend( pSocket->sd, pSocket->pSendBuffer + pSocket->nSendPos, lSend, 0, timeout );
if( lSend == -1 )
{
pSocket->iError = hb_socketGetError();
return HB_FALSE;
}
pSocket->nSendPos += lSend;
if( pSocket->nSendPos == pSocket->nSendLen )
{
hb_xfree( pSocket->pSendBuffer );
pSocket->pSendBuffer = NULL;
pSocket->iError = 0;
return HB_TRUE;
}
if( timeout == 0 ||
( timeout > 0 && ( timeout = nTime - ( HB_MAXINT ) hb_dateMilliSeconds() ) <= 0 ) )
{
pSocket->iError = HB_SOCKET_ERR_TIMEOUT;
return HB_FALSE;
}
}
}
void * hb_xgrab( HB_SIZE nSize ) /* allocates fixed memory, exits on failure */
{
void * pMem;
if( nSize == 0 )
hb_errInternal( HB_EI_XGRABNULLSIZE, "hb_xgrab requested to allocate zero bytes", NULL, NULL );
#ifdef HB_FM_STATISTICS
pMem = malloc( nSize + HB_MEMINFO_SIZE + sizeof( HB_U32 ) );
if( pMem )
{
if( s_pMemBlocks )
s_pMemBlocks->pPrevBlock = ( PHB_MEMINFO ) pMem;
( ( PHB_MEMINFO ) pMem )->pNextBlock = s_pMemBlocks;
( ( PHB_MEMINFO ) pMem )->pPrevBlock = NULL;
s_pMemBlocks = ( PHB_MEMINFO ) pMem;
( ( PHB_MEMINFO ) pMem )->nSize = nSize;
( ( PHB_MEMINFO ) pMem )->Signature = HB_MEMINFO_SIGNATURE;
HB_PUT_LE_UINT32( ( ( HB_BYTE * ) pMem ) + HB_MEMINFO_SIZE + nSize, HB_MEMINFO_SIGNATURE );
s_nMemoryConsumed += nSize;
if( s_nMemoryMaxConsumed < s_nMemoryConsumed )
s_nMemoryMaxConsumed = s_nMemoryConsumed;
s_nMemoryBlocks++;
if( s_nMemoryMaxBlocks < s_nMemoryBlocks )
s_nMemoryMaxBlocks = s_nMemoryBlocks;
pMem = ( HB_BYTE * ) pMem + HB_MEMINFO_SIZE;
}
else
#else
pMem = malloc( nSize );
if( ! pMem )
#endif
hb_errInternal( HB_EI_XGRABALLOC, "hb_xgrab can't allocate memory", NULL, NULL );
return pMem;
}
void hb_compGenBufPortObj( HB_COMP_DECL, HB_BYTE ** pBufPtr, HB_SIZE * pnSize )
{
PHB_HFUNC pFunc;
PHB_HSYMBOL pSym;
HB_ULONG ulSymbols, ulFunctions;
HB_SIZE nLen;
HB_BYTE * ptr;
*pnSize = hb_compHrbSize( HB_COMP_PARAM, &ulSymbols, &ulFunctions );
/* additional 0 byte is for passing buffer directly as string item */
ptr = *pBufPtr = ( HB_BYTE * ) hb_xgrab( *pnSize + 1 );
/* signature */
*ptr++ = 0xC0;
*ptr++ = 'H';
*ptr++ = 'R';
*ptr++ = 'B';
HB_PUT_LE_UINT16( ptr, 2 ); /* version number */
ptr += 2;
HB_PUT_LE_UINT32( ptr, ulSymbols ); /* number of symbols */
ptr += 4;
/* generate the symbol table */
pSym = HB_COMP_PARAM->symbols.pFirst;
while( pSym )
{
nLen = strlen( pSym->szName ) + 1;
memcpy( ptr, pSym->szName, nLen );
ptr += nLen;
/* TOFIX: this conversion strips upper byte from symbol scope
* Now we added workaround for it by using some strict
* bit order and restoring some others at runtime when
* .hrb file is loaded but we should create new format
* for .hrb files in which this field will have at least
* 16bit [druzus]
*/
*ptr++ = ( HB_BYTE ) pSym->cScope;
/* symbol type */
if( pSym->cScope & HB_FS_LOCAL )
*ptr++ = SYM_FUNC; /* function defined in this module */
else if( pSym->cScope & HB_FS_DEFERRED )
*ptr++ = SYM_DEFERRED; /* lately bound function */
else if( pSym->iFunc )
*ptr++ = SYM_EXTERN; /* external function */
else
*ptr++ = SYM_NOLINK; /* other symbol */
pSym = pSym->pNext;
}
HB_PUT_LE_UINT32( ptr, ulFunctions ); /* number of functions */
ptr += 4;
/* generate functions data */
pFunc = HB_COMP_PARAM->functions.pFirst;
while( pFunc )
{
if( ( pFunc->funFlags & HB_FUNF_FILE_DECL ) == 0 )
{
nLen = strlen( pFunc->szName ) + 1;
memcpy( ptr, pFunc->szName, nLen );
ptr += nLen;
HB_PUT_LE_UINT32( ptr, pFunc->nPCodePos ); /* function size */
ptr += 4;
memcpy( ptr, pFunc->pCode, pFunc->nPCodePos ); /* function body */
ptr += pFunc->nPCodePos;
}
pFunc = pFunc->pNext;
}
}
