static HB_BOOL hb_GetJobs( HANDLE hPrinter, JOB_INFO_2 ** ppJobInfo, DWORD * pdwJobs )
{
HB_BOOL bResult = HB_FALSE;
DWORD dwNeeded = 0;
GetPrinter( hPrinter, 2, NULL, 0, &dwNeeded );
if( dwNeeded )
{
PRINTER_INFO_2 * pPrinterInfo = ( PRINTER_INFO_2 * ) hb_xgrabz( dwNeeded );
DWORD dwUsed = 0;
if( GetPrinter( hPrinter, 2, ( LPBYTE ) pPrinterInfo, dwNeeded, &dwUsed ) )
{
DWORD dwReturned = 0;
EnumJobs( hPrinter, 0, pPrinterInfo->cJobs, 2, NULL, 0, &dwNeeded, &dwReturned );
if( dwNeeded )
{
JOB_INFO_2 * pJobInfo = ( JOB_INFO_2 * ) hb_xgrabz( dwNeeded );
if( EnumJobs( hPrinter, 0, dwReturned, 2, ( LPBYTE ) pJobInfo, dwNeeded, &dwUsed, &dwReturned ) )
{
*pdwJobs = dwReturned;
*ppJobInfo = pJobInfo;
bResult = HB_TRUE;
}
else
hb_xfree( pJobInfo );
}
}
hb_xfree( pPrinterInfo );
}
return bResult;
}
PHB_COMP hb_comp_new( void )
{
PHB_COMP pComp = NULL;
PHB_PP_STATE pPP = hb_pp_new();
if( pPP )
{
pComp = ( PHB_COMP ) hb_xgrabz( sizeof( HB_COMP ) );
pComp->pLex = ( PHB_COMP_LEX ) hb_xgrabz( sizeof( HB_COMP_LEX ) );
/* initialize default settings */
pComp->mode = HB_MODE_COMPILER;
pComp->funcs = &s_comp_funcs;
pComp->pLex->pPP = pPP;
/* various compatibility flags (-k switch)
activate Harbour extensions by default. */
pComp->supported = HB_COMPFLAG_HARBOUR |
HB_COMPFLAG_XBASE |
HB_COMPFLAG_HB_INLINE |
HB_COMPFLAG_OPTJUMP |
HB_COMPFLAG_MACROTEXT |
HB_COMPFLAG_SHORTCUTS;
pComp->fSwitchCase = HB_FALSE;
pComp->fPPO = HB_FALSE; /* flag indicating, is ppo output needed */
pComp->fLineNumbers = HB_TRUE; /* holds if we need pcodes with line numbers */
pComp->fAnyWarning = HB_FALSE; /* holds if there was any warning during the compilation process */
pComp->fAutoMemvarAssume = HB_FALSE; /* holds if undeclared variables are automatically assumed MEMVAR (-a)*/
pComp->fForceMemvars = HB_FALSE; /* holds if memvars are assumed when accesing undeclared variable (-v)*/
pComp->fDebugInfo = HB_FALSE; /* holds if generate debugger required info */
pComp->fHideSource = ! pComp->fDebugInfo; /* do not store .prg file names in PCODE */
pComp->fNoStartUp = HB_FALSE; /* C code generation embed HB_FS_FIRST or not */
pComp->fCredits = HB_FALSE; /* print credits */
pComp->fBuildInfo = HB_FALSE; /* print build info */
pComp->fGauge = HB_TRUE; /* line counter gauge */
pComp->fLogo = HB_TRUE; /* print logo */
pComp->fSingleModule = HB_FALSE;
pComp->fError = HB_FALSE;
pComp->fINCLUDE = HB_TRUE;
pComp->iSyntaxCheckOnly = 0; /* syntax check only */
pComp->iStartProc = 0; /* no implicit starting procedure */
pComp->iWarnings = 0; /* enable parse warnings */
pComp->iErrorCount = 0; /* number of compile errors */
pComp->iGenCOutput = HB_COMPGENC_COMPACT; /* C code generation default mode */
pComp->iExitLevel = HB_EXITLEVEL_DEFAULT; /* holds if there was any warning during the compilation process */
pComp->iLanguage = HB_LANG_C; /* default Harbour generated output language */
pComp->iErrorFmt = HB_ERRORFMT_CLIPPER; /* default Harbour generated output language */
pComp->outMsgFunc = hb_compOutMsg;
}
return pComp;
}
PHB_SOCKEX hb_sockexNewZNet( HB_SOCKET sd, const void * keydata, int keylen,
int level, int strategy )
{
PHB_SOCKEX pSock = NULL;
if( sd != HB_NO_SOCKET )
{
PHB_ZNETSTREAM pStream = NULL;
if( level != HB_ZLIB_COMPRESSION_DISABLE )
{
pStream = hb_znetOpen( level, strategy );
if( pStream )
{
if( keydata && keylen > 0 )
hb_znetEncryptKey( pStream, keydata, keylen );
}
else
sd = HB_NO_SOCKET;
}
if( sd != HB_NO_SOCKET )
{
pSock = ( PHB_SOCKEX ) hb_xgrabz( sizeof( HB_SOCKEX ) );
pSock->sd = sd;
pSock->fRedirAll = HB_TRUE;
pSock->fShutDown = HB_TRUE;
pSock->pFilter = &s_sockFilter;
pSock->cargo = ( void * ) pStream;
}
}
return pSock;
}
/* create new stream structure
*/
PHB_ZNETSTREAM hb_znetOpen( int level, int strategy )
{
PHB_ZNETSTREAM pStream = ( PHB_ZNETSTREAM ) hb_xgrabz( sizeof( HB_ZNETSTREAM ) );
if( level != Z_DEFAULT_COMPRESSION &&
!( level >= Z_NO_COMPRESSION && level <= Z_BEST_COMPRESSION ) )
level = Z_DEFAULT_COMPRESSION;
if( strategy != Z_FILTERED &&
#if defined( Z_RLE )
strategy != Z_RLE &&
#endif
#if defined( Z_FIXED )
strategy != Z_FIXED &&
#endif
strategy != Z_HUFFMAN_ONLY )
strategy = Z_DEFAULT_STRATEGY;
if( deflateInit2( &pStream->wr, level,
Z_DEFLATED, -MAX_WBITS, HB_ZNET_MEM_LEVEL, strategy ) == Z_OK )
{
pStream->wr.next_out = pStream->outbuf = ( Bytef * ) hb_xgrab( HB_ZNET_BUFSIZE );
pStream->wr.avail_out = HB_ZNET_BUFSIZE;
pStream->rd.next_in = pStream->inbuf = ( Bytef * ) hb_xgrab( HB_ZNET_BUFSIZE );
if( inflateInit2( &pStream->rd, -MAX_WBITS ) == Z_OK )
return pStream;
}
hb_znetClose( pStream );
return NULL;
}
static PHB_IOUSR s_iousrAddNew( const char * pszPrefix )
{
PHB_IOUSR pIO = NULL;
int iCount;
HB_IOUSR_LOCK();
iCount = s_iCount;
while( --iCount >= 0 )
{
if( hb_stricmp( pszPrefix, s_ioUsrs[ iCount ]->prefix ) == 0 )
break;
}
if( iCount < 0 )
{
if( s_iCount == 0 )
hb_vmAtQuit( s_iousrFreeAll, NULL );
pIO = ( PHB_IOUSR ) hb_xgrabz( sizeof( HB_IOUSR ) );
pIO->prefix = hb_strdup( pszPrefix );
pIO->prefix_len = ( int ) strlen( pszPrefix );
s_ioUsrs[ s_iCount++ ] = pIO;
}
HB_IOUSR_UNLOCK();
return pIO;
}
static PHB_FILE hb_fileNew( HB_FHANDLE hFile, HB_BOOL fShared, HB_BOOL fReadonly,
HB_ULONG device, HB_ULONG inode, HB_BOOL fBind )
{
PHB_FILE pFile = hb_fileFind( device, inode );
if( ! pFile )
{
pFile = ( PHB_FILE ) hb_xgrabz( sizeof( HB_FILE ) );
pFile->pFuncs = s_fileMethods();
pFile->device = device;
pFile->inode = inode;
pFile->hFile = hFile;
pFile->hFileRO = FS_ERROR;
pFile->shared = fShared;
pFile->readonly = fReadonly;
if( fBind )
{
if( s_openFiles )
{
pFile->pNext = s_openFiles;
pFile->pPrev = s_openFiles->pPrev;
pFile->pPrev->pNext = pFile;
s_openFiles->pPrev = pFile;
}
else
s_openFiles = pFile->pNext = pFile->pPrev = pFile;
}
}
pFile->used++;
return pFile;
}
DOCINFO * hbwapi_par_DOCINFO( DOCINFO * p, int iParam, HB_BOOL bMandatory, void *** ph )
{
PHB_ITEM pStru = hb_param( iParam, HB_IT_ANY );
void ** h = ( void ** ) hb_xgrabz( 3 * sizeof( void * ) );
*ph = h;
memset( p, 0, sizeof( DOCINFO ) );
p->cbSize = sizeof( DOCINFO );
if( pStru && HB_IS_HASH( pStru ) )
{
p->lpszDocName = HB_ITEMGETSTR( hb_hashGetCItemPtr( pStru, "lpszDocName" ), &h[ 0 ], NULL );
p->lpszOutput = HB_ITEMGETSTR( hb_hashGetCItemPtr( pStru, "lpszOutput" ), &h[ 1 ], NULL );
p->lpszDatatype = HB_ITEMGETSTR( hb_hashGetCItemPtr( pStru, "lpszDatatype" ), &h[ 2 ], NULL );
p->fwType = ( DWORD ) hb_itemGetNL( hb_hashGetCItemPtr( pStru, "fwType" ) );
return p;
}
else if( bMandatory )
return p;
hb_xfree( h );
*ph = NULL;
return NULL;
}
static void hb_gt_cgi_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
{
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p,%p)", ( void * ) pGT, ( void * ) ( HB_PTRUINT ) hFilenoStdin, ( void * ) ( HB_PTRUINT ) hFilenoStdout, ( void * ) ( HB_PTRUINT ) hFilenoStderr ) );
HB_GTLOCAL( pGT ) = pGTCGI = ( PHB_GTCGI ) hb_xgrabz( sizeof( HB_GTCGI ) );
pGTCGI->pGT = pGT;
pGTCGI->hStdout = hFilenoStdout;
pGTCGI->szCrLf = hb_strdup( hb_conNewLine() );
pGTCGI->nCrLf = strlen( pGTCGI->szCrLf );
#ifdef HB_GT_CGI_WIN
{
DWORD dwMode;
pGTCGI->fIsConsole = GetConsoleMode( DosToWinHandle( pGTCGI->hStdout ), &dwMode );
if( pGTCGI->fIsConsole )
HB_GTSELF_SETDISPCP( pGT, "UTF8", NULL, HB_FALSE );
}
#endif
hb_fsSetDevMode( pGTCGI->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
HB_GTSELF_SETFLAG( pGT, HB_GTI_STDOUTCON, HB_TRUE );
}
static PHB_TASKINFO hb_taskNew( long stack_size )
{
PHB_TASKINFO pTask;
HB_PTRUINT new_size;
if( stack_size < HB_TASK_STACK_MIN )
stack_size = HB_TASK_STACK_MIN;
pTask = ( PHB_TASKINFO ) hb_xgrabz( sizeof( HB_TASKINFO ) );
pTask->stack = ( char * ) hb_xgrab( stack_size );
new_size = ( HB_PTRUINT ) pTask->stack + stack_size;
new_size &= ~ ( HB_PTRUINT ) ( HB_TASK_STACK_ALIGN - 1 );
new_size -= ( HB_PTRUINT ) pTask->stack;
pTask->stack_size = ( long ) new_size;
pTask->id = ++s_iTaskID;
pTask->state = TASK_INIT;
#if defined( HB_HAS_UCONTEXT )
/* create new execution context and initialize its private stack */
if( getcontext( &pTask->context ) == -1 )
hb_errInternal( HB_EI_ERRUNRECOV, "getcontext", NULL, NULL );
pTask->context.uc_link = NULL;
pTask->context.uc_stack.ss_sp = pTask->stack;
pTask->context.uc_stack.ss_size = pTask->stack_size;
makecontext( &pTask->context, hb_taskRun, 0 );
#endif
return pTask;
}
static PHB_I18N_TRANS hb_i18n_initialize( PHB_ITEM pTable )
{
PHB_I18N_TRANS pI18N = NULL;
if( HB_IS_HASH( pTable ) )
{
PHB_ITEM pKey, pContext, pDefContext = NULL, pValue;
pKey = hb_itemPutCConst( NULL, "CONTEXT" );
pContext = hb_hashGetItemPtr( pTable, pKey, 0 );
if( pContext )
{
pKey = hb_itemPutC( pKey, NULL );
pDefContext = hb_hashGetItemPtr( pContext, pKey, 0 );
}
if( pContext && pDefContext )
{
pI18N = ( PHB_I18N_TRANS ) hb_xgrabz( sizeof( HB_I18N_TRANS ) );
hb_atomic_set( &pI18N->iUsers, 1 );
pI18N->table = pTable;
pI18N->context_table = hb_itemNew( pContext );
pI18N->default_context = hb_itemNew( pDefContext );
pKey = hb_itemPutCConst( pKey, "BASE_CODEPAGE" );
pValue = hb_hashGetItemPtr( pTable, pKey, 0 );
if( pValue )
pI18N->base_cdpage = hb_cdpFind( hb_itemGetCPtr( pValue ) );
pKey = hb_itemPutCConst( pKey, "CODEPAGE" );
pValue = hb_hashGetItemPtr( pTable, pKey, 0 );
if( pValue )
pI18N->cdpage = hb_cdpFind( hb_itemGetCPtr( pValue ) );
pKey = hb_itemPutCConst( pKey, "BASE_LANG" );
pValue = hb_hashGetItemPtr( pTable, pKey, 0 );
if( pValue )
pI18N->base_plural_form = hb_i18n_pluralformfind( hb_itemGetCPtr( pValue ) );
pKey = hb_itemPutCConst( pKey, "LANG" );
pValue = hb_hashGetItemPtr( pTable, pKey, 0 );
if( pValue )
pI18N->plural_form = hb_i18n_pluralformfind( hb_itemGetCPtr( pValue ) );
pKey = hb_itemPutCConst( pKey, "BASE_PLURAL_EXP" );
pValue = hb_hashGetItemPtr( pTable, pKey, 0 );
if( pValue )
pI18N->base_plural_block = hb_i18n_pluralexp_compile( pValue );
pKey = hb_itemPutCConst( pKey, "PLURAL_EXP" );
pValue = hb_hashGetItemPtr( pTable, pKey, 0 );
if( pValue )
pI18N->plural_block = hb_i18n_pluralexp_compile( pValue );
}
hb_itemRelease( pKey );
}
return pI18N;
}
PHB_LPP hb_lppCreate( HB_SOCKET sd )
{
PHB_LPP pSocket;
pSocket = ( PHB_LPP ) hb_xgrabz( sizeof( HB_LPP ) );
pSocket->sd = sd;
pSocket->nLimit = 1024;
return pSocket;
}
static PHB_FILE hb_fileposNew( PHB_FILE pFile )
{
PHB_FILEPOS pFilePos = ( PHB_FILEPOS ) hb_xgrabz( sizeof( HB_FILEPOS ) );
pFilePos->pFuncs = s_fileposMethods();
pFilePos->pFile = pFile;
pFilePos->seek_pos = 0;
return ( PHB_FILE ) pFilePos;
}
/*
* Prepares a new WorkArea node.
*/
void * hb_rddNewAreaNode( LPRDDNODE pRddNode, HB_USHORT uiRddID )
{
AREAP pArea;
HB_TRACE( HB_TR_DEBUG, ( "hb_rddNewAreaNode(%p,%hu)", pRddNode, uiRddID ) );
if( pRddNode->uiAreaSize == 0 ) /* Calculate the size of WorkArea */
{
HB_USHORT uiSize;
pArea = ( AREAP ) hb_xgrabz( sizeof( AREA ) );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
if( SELF_STRUCTSIZE( pArea, &uiSize ) != HB_SUCCESS )
return NULL;
/* Need more space? */
if( uiSize > sizeof( AREA ) ) /* Size of Area changed */
{
pArea = ( AREAP ) hb_xrealloc( pArea, uiSize );
memset( pArea, 0, uiSize );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
}
pRddNode->uiAreaSize = uiSize; /* Update the size of WorkArea */
}
else
{
pArea = ( AREAP ) hb_xgrabz( pRddNode->uiAreaSize );
pArea->lprfsHost = &pRddNode->pTable;
pArea->rddID = uiRddID;
}
if( SELF_NEW( pArea ) != HB_SUCCESS )
{
SELF_RELEASE( pArea );
return NULL;
}
return ( void * ) pArea;
}
/* initialize task switching, create and register main task structure */
void hb_taskInit( void )
{
if( s_iTaskID == 0 )
{
s_mainTask = s_currTask = ( PHB_TASKINFO ) hb_xgrabz( sizeof( HB_TASKINFO ) );
/* main task uses default application stack */
s_currTask->id = ++s_iTaskID;
s_currTask->state = TASK_RUNNING;
hb_taskLink( &s_taskList, s_currTask );
}
}
static PHB_SOCKEX s_sockexNext( PHB_SOCKEX pSock, PHB_ITEM pParams )
{
PHB_SOCKEX pSockNew = NULL;
if( pSock )
{
const void * keydata = NULL, * iv = NULL;
int keylen = 0, ivlen = 0;
hb_socekxParamsGetStd( pParams, &keydata, &keylen, &iv, &ivlen, NULL, NULL );
if( keylen > 0 )
{
PHB_SOCKEX_BF pBF = ( PHB_SOCKEX_BF ) hb_xgrabz( sizeof( HB_SOCKEX_BF ) );
const HB_BYTE * pVect = ( const HB_BYTE * ) ( ivlen > 0 ? iv : NULL );
int i;
hb_blowfishInit( &pBF->bf, keydata, keylen );
for( i = 0; i < HB_BF_CIPHERBLOCK; ++i )
{
if( pVect && ivlen > 0 )
pBF->encounter[ i ] =
pBF->decounter[ i ] = pVect[ i % ivlen ];
else
pBF->encounter[ i ] =
pBF->decounter[ i ] = ( HB_BYTE ) i;
}
pSockNew = ( PHB_SOCKEX ) hb_xgrabz( sizeof( HB_SOCKEX ) );
pSockNew->sd = pSock->sd;
pSockNew->fRedirAll = HB_TRUE;
pSockNew->fShutDown = pSock->fShutDown;
pSockNew->iAutoFlush = pSock->iAutoFlush;
pSockNew->pFilter = &s_sockFilter;
pSockNew->cargo = ( void * ) pBF;
pBF->sock = pSock;
hb_socekxParamsInit( pSockNew, pParams );
}
}
return pSockNew;
}
/* create new extended socket structure */
static PHB_SOCKEX s_sockexNew( HB_SOCKET sd, PHB_ITEM pParams )
{
PHB_SOCKEX pSock;
pSock = ( PHB_SOCKEX ) hb_xgrabz( sizeof( HB_SOCKEX ) );
pSock->sd = sd;
pSock->pFilter = &s_sockFilter;
hb_socekxParamsInit( pSock, pParams );
return pSock;
}
static void memfsInit( void )
{
/* HB_CRITICAL_INIT( s_mtx ); */
s_error = 0;
s_fs.ulInodeCount = 0;
s_fs.ulInodeAlloc = HB_MEMFS_INITSIZE;
s_fs.pInodes = ( PHB_MEMFS_INODE * ) hb_xgrab( sizeof( PHB_MEMFS_INODE ) * s_fs.ulInodeAlloc );
s_fs.ulFileAlloc = HB_MEMFS_INITSIZE;
s_fs.pFiles = ( PHB_MEMFS_FILE * ) hb_xgrabz( sizeof( PHB_MEMFS_FILE ) * s_fs.ulFileAlloc );
s_fs.ulFileLast = 0;
hb_vmAtQuit( memfsExit, NULL );
}
/*
* Establish the extent of the array of fields for a WorkArea.
*/
static HB_ERRCODE hb_sdfSetFieldExtent( SDFAREAP pArea, HB_USHORT uiFieldExtent )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfSetFieldExtent(%p,%hu)", pArea, uiFieldExtent ) );
if( SUPER_SETFIELDEXTENT( &pArea->area, uiFieldExtent ) == HB_FAILURE )
return HB_FAILURE;
/* Alloc field offsets array */
if( uiFieldExtent )
pArea->pFieldOffset = ( HB_USHORT * ) hb_xgrabz( uiFieldExtent * sizeof( HB_USHORT ) );
return HB_SUCCESS;
}
static void hb_gt_cgi_Init( PHB_GT pGT, HB_FHANDLE hFilenoStdin, HB_FHANDLE hFilenoStdout, HB_FHANDLE hFilenoStderr )
{
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p,%p)", pGT, ( void * ) ( HB_PTRUINT ) hFilenoStdin, ( void * ) ( HB_PTRUINT ) hFilenoStdout, ( void * ) ( HB_PTRUINT ) hFilenoStderr ) );
HB_GTLOCAL( pGT ) = pGTCGI = ( PHB_GTCGI ) hb_xgrabz( sizeof( HB_GTCGI ) );
pGTCGI->hStdout = hFilenoStdout;
pGTCGI->szCrLf = hb_strdup( hb_conNewLine() );
pGTCGI->nCrLf = strlen( pGTCGI->szCrLf );
hb_fsSetDevMode( pGTCGI->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
HB_GTSELF_SETFLAG( pGT, HB_GTI_STDOUTCON, HB_TRUE );
}
static PHB_I18N_TRANS hb_i18n_new( void )
{
PHB_I18N_TRANS pI18N;
PHB_ITEM pKey;
pI18N = ( PHB_I18N_TRANS ) hb_xgrabz( sizeof( HB_I18N_TRANS ) );
hb_atomic_set( &pI18N->iUsers, 1 );
pI18N->table = hb_hashNew( hb_itemNew( NULL ) );
pI18N->context_table = hb_hashNew( hb_itemNew( NULL ) );
pI18N->default_context = hb_hashNew( hb_itemNew( NULL ) );
pKey = hb_itemPutCConst( NULL, "CONTEXT" );
hb_hashAdd( pI18N->table, pKey, pI18N->context_table );
pKey = hb_itemPutC( pKey, NULL );
hb_hashAdd( pI18N->context_table, pKey, pI18N->default_context );
hb_itemRelease( pKey );
return pI18N;
}
static PHB_MEMFS_INODE memfsInodeAlloc( const char * szName )
{
PHB_MEMFS_INODE pInode = ( PHB_MEMFS_INODE ) hb_xgrab( sizeof( HB_MEMFS_INODE ) );
HB_ULONG ulInode = 0;
pInode->llSize = 0;
pInode->llAlloc = HB_MEMFS_INITSIZE;
pInode->pData = ( char * ) hb_xgrabz( ( HB_SIZE ) pInode->llAlloc );
pInode->szName = hb_strdup( szName );
pInode->uiCount = 1;
pInode->uiCountRead = pInode->uiCountWrite = 0;
pInode->uiDeny = 0;
/* Insert into inode array. Inode should not exist!!! */
if( s_fs.ulInodeCount >= s_fs.ulInodeAlloc )
{
s_fs.ulInodeAlloc += s_fs.ulInodeAlloc >> 1;
s_fs.pInodes = ( PHB_MEMFS_INODE * ) hb_xrealloc( s_fs.pInodes, s_fs.ulInodeAlloc * sizeof( PHB_MEMFS_INODE ) );
}
PHB_SOCKEX hb_sockexNewSSL( HB_SOCKET sd, SSL * ssl, HB_BOOL fServer,
HB_MAXINT timeout, PHB_ITEM pSSL )
{
PHB_SOCKEX pSock = NULL;
if( sd != HB_NO_SOCKET && ssl )
{
PHB_SSLSTREAM pStream = hb_ssl_socketNew( sd, ssl, fServer, timeout, pSSL, NULL );
if( pStream )
{
pSock = ( PHB_SOCKEX ) hb_xgrabz( sizeof( HB_SOCKEX ) );
pSock->sd = sd;
pSock->fRedirAll = HB_TRUE;
pSock->fShutDown = HB_TRUE;
pSock->pFilter = &s_sockFilter;
pSock->cargo = ( void * ) pStream;
}
}
return pSock;
}
static void * hb_curl_calloc( size_t nelem, size_t elsize )
{
size_t size = nelem * elsize;
return size > 0 ? hb_xgrabz( size ) : NULL;
}
static HB_ERRCODE mysqlOpen( SQLBASEAREAP pArea )
{
MYSQL * pMySql = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pMySql;
SDDDATA * pSDDData;
PHB_ITEM pItemEof, pItem;
HB_ULONG ulIndex;
HB_USHORT uiFields, uiCount;
HB_ERRCODE errCode = 0;
HB_BOOL bError;
DBFIELDINFO pFieldInfo;
MYSQL_FIELD * pMyField;
void ** pRow;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
if( mysql_real_query( pMySql, pArea->szQuery, ( unsigned long ) strlen( pArea->szQuery ) ) )
{
hb_errRT_MySQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery,
mysql_errno( pMySql ) );
return HB_FAILURE;
}
if( ( pSDDData->pResult = mysql_store_result( pMySql ) ) == NULL )
{
hb_errRT_MySQLDD( EG_MEM, ESQLDD_INVALIDQUERY, ( const char * ) mysql_error( pMySql ), pArea->szQuery,
mysql_errno( pMySql ) );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) mysql_num_fields( pSDDData->pResult );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
bError = HB_FALSE;
for( uiCount = 0; uiCount < uiFields; uiCount++ )
{
pMyField = mysql_fetch_field_direct( pSDDData->pResult, uiCount );
pFieldInfo.atomName = pMyField->name;
pFieldInfo.uiLen = ( HB_USHORT ) pMyField->length;
pFieldInfo.uiDec = 0;
switch( pMyField->type )
{
case MYSQL_TYPE_TINY:
case MYSQL_TYPE_SHORT:
pFieldInfo.uiType = HB_FT_INTEGER;
break;
case MYSQL_TYPE_LONG:
case MYSQL_TYPE_LONGLONG:
case MYSQL_TYPE_INT24:
pFieldInfo.uiType = HB_FT_LONG;
break;
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
case MYSQL_TYPE_FLOAT:
case MYSQL_TYPE_DOUBLE:
pFieldInfo.uiType = HB_FT_DOUBLE;
pFieldInfo.uiDec = ( HB_USHORT ) pMyField->decimals;
break;
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_ENUM:
pFieldInfo.uiType = HB_FT_STRING;
break;
case MYSQL_TYPE_DATE:
pFieldInfo.uiType = HB_FT_DATE;
break;
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB:
pFieldInfo.uiType = HB_FT_MEMO;
break;
case MYSQL_TYPE_TIMESTAMP:
case MYSQL_TYPE_DATETIME:
pFieldInfo.uiType = HB_FT_TIMESTAMP;
pFieldInfo.uiLen = 8;
break;
case MYSQL_TYPE_TIME:
pFieldInfo.uiType = HB_FT_TIME;
pFieldInfo.uiLen = 4;
break;
case MYSQL_TYPE_NULL:
case MYSQL_TYPE_YEAR:
case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_SET:
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_GEOMETRY:
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) pMyField->type;
pFieldInfo.uiType = 0;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCL( NULL, pStr, pFieldInfo.uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_INTEGER:
pItem = hb_itemPutNI( NULL, 0 );
break;
case HB_FT_LONG:
pItem = hb_itemPutNL( NULL, 0 );
break;
case HB_FT_DOUBLE:
pItem = hb_itemPutND( NULL, 0.0 );
break;
case HB_FT_DATE:
pItem = hb_itemPutDS( NULL, NULL );
break;
case HB_FT_TIMESTAMP:
case HB_FT_TIME:
pItem = hb_itemPutTDT( NULL, 0, 0 );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiCount + 1, pItem );
hb_itemRelease( pItem );
#if 0
if( pFieldInfo.uiType == HB_IT_DOUBLE || pFieldInfo.uiType == HB_IT_INTEGER )
pFieldInfo.uiType = HB_IT_LONG;
#endif
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
hb_errRT_MySQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = ( HB_ULONG ) mysql_num_rows( pSDDData->pResult );
pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
pArea->ulRecMax = pArea->ulRecCount + 1;
pRow = pArea->pRow;
*pRow = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pRow++;
for( ulIndex = 1; ulIndex <= pArea->ulRecCount; ulIndex++ )
{
*pRow++ = ( void * ) mysql_row_tell( pSDDData->pResult );
mysql_fetch_row( pSDDData->pResult );
}
pArea->fFetched = HB_TRUE;
return HB_SUCCESS;
}
static PHB_SOCKEX s_sockexNext( PHB_SOCKEX pSock, PHB_ITEM pParams )
{
PHB_SOCKEX pSockNew = NULL;
if( pSock )
{
HB_BOOL fDecompressIn = HB_TRUE, fCompressOut = HB_TRUE;
int level = HB_ZLIB_COMPRESSION_DEFAULT,
strategy = HB_ZLIB_STRATEGY_DEFAULT,
windowBitsIn = MAX_WBITS, windowBitsOut = MAX_WBITS;
if( pParams && HB_IS_HASH( pParams ) )
{
PHB_ITEM pItem;
if( ( pItem = hb_hashGetCItemPtr( pParams, "zlib" ) ) != NULL &&
HB_IS_NUMERIC( pItem ) )
level = hb_itemGetNI( pItem );
if( ( pItem = hb_hashGetCItemPtr( pParams, "zs" ) ) != NULL &&
HB_IS_NUMERIC( pItem ) )
strategy = hb_itemGetNI( pItem );
if( ( pItem = hb_hashGetCItemPtr( pParams, "gzin" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
{
fDecompressIn = hb_itemGetL( pItem );
if( fDecompressIn )
windowBitsIn += 16;
}
if( ( pItem = hb_hashGetCItemPtr( pParams, "zin" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
{
if( windowBitsIn == MAX_WBITS )
fDecompressIn = hb_itemGetL( pItem );
else if( hb_itemGetL( pItem ) )
windowBitsIn += 16;
}
if( ( pItem = hb_hashGetCItemPtr( pParams, "gzout" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
{
fCompressOut = hb_itemGetL( pItem );
if( fCompressOut )
windowBitsOut += 16;
}
if( ( pItem = hb_hashGetCItemPtr( pParams, "zout" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) && windowBitsOut == MAX_WBITS )
fCompressOut = hb_itemGetL( pItem );
}
if( level != HB_ZLIB_COMPRESSION_DISABLE &&
( fDecompressIn || fCompressOut ) )
{
PHB_SOCKEX_Z pZ = ( PHB_SOCKEX_Z ) hb_xgrabz( sizeof( HB_SOCKEX_Z ) );
pSockNew = ( PHB_SOCKEX ) hb_xgrabz( sizeof( HB_SOCKEX ) );
pSockNew->sd = HB_NO_SOCKET;
pSockNew->fRedirAll = HB_TRUE;
pSockNew->pFilter = &s_sockFilter;
pSockNew->cargo = ( void * ) pZ;
pZ->z_read.zalloc = s_zsock_zalloc;
pZ->z_read.zfree = s_zsock_zfree;
pZ->z_read.opaque = Z_NULL;
pZ->z_write.zalloc = s_zsock_zalloc;
pZ->z_write.zfree = s_zsock_zfree;
pZ->z_write.opaque = Z_NULL;
pZ->z_read.next_in = NULL;
pZ->z_read.avail_in = 0;
if( level != Z_DEFAULT_COMPRESSION &&
!( level >= Z_NO_COMPRESSION && level <= Z_BEST_COMPRESSION ) )
level = Z_DEFAULT_COMPRESSION;
if( strategy != Z_FILTERED &&
#if defined( Z_RLE )
strategy != Z_RLE &&
#endif
#if defined( Z_FIXED )
strategy != Z_FIXED &&
#endif
strategy != Z_HUFFMAN_ONLY )
strategy = Z_DEFAULT_STRATEGY;
if( fDecompressIn && level != HB_ZLIB_COMPRESSION_DISABLE )
{
/* MAX_WBITS=15, decompression - support for formats:
* -15: raw, 15: ZLIB, 31: GZIP, 47: ZLIB+GZIP
*/
if( inflateInit2( &pZ->z_read, windowBitsIn ) == Z_OK )
{
pZ->fDecompressIn = HB_TRUE;
pZ->rdbuf = ( HB_BYTE * ) hb_xgrab( HB_ZSOCK_RDBUFSIZE );
}
else
level = HB_ZLIB_COMPRESSION_DISABLE;
}
if( fCompressOut && level != HB_ZLIB_COMPRESSION_DISABLE )
{
/* MAX_WBITS=15, compression format:
* -15: raw, 15: ZLIB (+6 bytes), 31: GZIP(+18 bytes)
*/
if( deflateInit2( &pZ->z_write, level,
Z_DEFLATED, windowBitsOut, HB_ZSOCK_MEM_LEVEL,
strategy ) == Z_OK )
{
pZ->fCompressOut = HB_TRUE;
pZ->wrbuf = ( HB_BYTE * ) hb_xgrab( HB_ZSOCK_WRBUFSIZE );
pZ->z_write.next_out = ( Bytef * ) pZ->wrbuf;
pZ->z_write.avail_out = HB_ZSOCK_WRBUFSIZE;
}
else
level = HB_ZLIB_COMPRESSION_DISABLE;
}
if( level != HB_ZLIB_COMPRESSION_DISABLE )
{
pSockNew->sd = pSock->sd;
pSockNew->fShutDown = pSock->fShutDown;
pSockNew->iAutoFlush = pSock->iAutoFlush;
pZ->sock = pSock;
hb_socekxParamsInit( pSockNew, pParams );
}
else
{
s_sockexClose( pSockNew, HB_FALSE );
pSockNew = NULL;
}
}
}
return pSockNew;
}
PHB_SSLSTREAM hb_ssl_socketNew( HB_SOCKET sd, SSL * ssl, HB_BOOL fServer,
HB_MAXINT timeout, int * piResult )
{
int iResult;
PHB_SSLSTREAM pStream;
HB_MAXUINT timer;
pStream = ( HB_SSLSTREAM * ) hb_xgrabz( sizeof( HB_SSLSTREAM ) );
timer = timeout <= 0 ? 0 : hb_dateMilliSeconds();
pStream->ssl = ssl;
pStream->pSSL = hb_itemNew( hb_param( 2, HB_IT_POINTER ) );
pStream->blocking = timeout < 0;
if( hb_socketSetBlockingIO( sd, pStream->blocking ) < 0 )
pStream->blocking = ! pStream->blocking;
SSL_set_mode( ssl, HB_SSL_MODE_AUTO_RETRY );
iResult = SSL_set_fd( ssl, sd );
while( iResult == 1 )
{
if( fServer )
iResult = SSL_accept( ssl );
else
iResult = SSL_connect( ssl );
if( iResult != 1 && hb_vmRequestQuery() == 0 )
{
int iError = SSL_get_error( ssl, iResult );
if( iError == SSL_ERROR_WANT_READ ||
iError == SSL_ERROR_WANT_WRITE )
{
if( timeout < 0 )
{
iResult = 1;
continue;
}
else if( timeout > 0 )
{
HB_MAXUINT timecurr = hb_dateMilliSeconds();
if( timecurr > timer )
{
timeout -= timecurr - timer;
timer = timecurr;
}
if( timeout > 0 )
{
if( iError == SSL_ERROR_WANT_READ )
iError = hb_socketSelectRead( sd, timeout );
else
iError = hb_socketSelectWrite( sd, timeout );
if( iError > 0 )
{
iResult = 1;
continue;
}
}
}
hb_socketSetError( HB_SOCKET_ERR_TIMEOUT );
}
}
break;
}
if( iResult != 1 )
{
hb_ssl_socketClose( pStream );
pStream = NULL;
}
else
pStream->blocking = hb_socketSetBlockingIO( sd, HB_FALSE ) < 0;
if( piResult )
*piResult = iResult;
return pStream;
}
static HB_ERRCODE sqlite3Open( SQLBASEAREAP pArea )
{
sqlite3 * pDb = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pDb;
sqlite3_stmt * st = NULL;
SDDDATA * pSDDData;
const char * pszQuery;
HB_SIZE nQueryLen;
void * hQuery;
HB_USHORT uiFields, uiIndex;
PHB_ITEM pItemEof, pItem;
HB_ERRCODE errCode;
char * szError;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pItem = hb_itemPutC( NULL, pArea->szQuery );
pszQuery = S_HB_ITEMGETSTR( pItem, &hQuery, &nQueryLen );
if( sqlite3_prepare_v2( pDb, pszQuery, ( int ) nQueryLen, &st, NULL ) != SQLITE_OK )
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
else
{
hb_strfree( hQuery );
hb_itemRelease( pItem );
}
if( sqlite3_step( st ) != SQLITE_ROW )
{
szError = sqlite3GetError( pDb, &errCode );
hb_errRT_SQLT3DD( EG_OPEN, ESQLDD_INVALIDQUERY, szError, pArea->szQuery, errCode );
sqlite3_finalize( st );
hb_xfree( szError );
return HB_FAILURE;
}
uiFields = ( HB_USHORT ) sqlite3_column_count( st );
SELF_SETFIELDEXTENT( ( AREAP ) pArea, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "fieldcount=%d", uiFields ) );
#endif
errCode = 0;
bError = HB_FALSE;
for( uiIndex = 0; uiIndex < uiFields; ++uiIndex )
{
DBFIELDINFO pFieldInfo;
int iDataType = sqlite3_column_type( st, uiIndex );
PHB_ITEM pName = S_HB_ITEMPUTSTR( NULL, sqlite3_column_name( st, uiIndex ) );
HB_USHORT uiNameLen = ( HB_USHORT ) hb_itemGetCLen( pName );
if( ( ( AREAP ) pArea )->uiMaxFieldNameLength < uiNameLen )
( ( AREAP ) pArea )->uiMaxFieldNameLength = uiNameLen;
pFieldInfo.atomName = hb_itemGetCPtr( pName );
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "field: name=%s type=%d len=%d", pFieldInfo.atomName, iDataType, sqlite3_column_bytes( st, uiIndex ) ) );
#endif
/* There are no field length limits stored in the SQLite3 database,
so we're resorting to setting some arbitrary default values to
make apps relying on these (f.e. Browse()/GET) to behave somewhat
better. For better results, update apps to untie UI metrics from
any database field/value widths. [vszakats] */
pFieldInfo.uiLen = 10;
pFieldInfo.uiDec = 0;
switch( iDataType )
{
case SQLITE3_TEXT:
pFieldInfo.uiType = HB_FT_STRING;
break;
case SQLITE_FLOAT:
pFieldInfo.uiType = HB_FT_LONG;
pFieldInfo.uiDec = ( HB_USHORT ) hb_setGetDecimals();
pFieldInfo.uiLen += pFieldInfo.uiDec + 1;
break;
case SQLITE_INTEGER:
pFieldInfo.uiType = HB_FT_LONG;
break;
case SQLITE_BLOB:
case SQLITE_NULL:
pFieldInfo.uiType = HB_FT_BLOB;
break;
default:
#if 0
HB_TRACE( HB_TR_ALWAYS, ( "new sql type=%d", iDataType ) );
#endif
bError = HB_TRUE;
errCode = ( HB_ERRCODE ) iDataType;
pFieldInfo.uiType = 0;
break;
}
if( ! bError )
{
switch( pFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr = ( char * ) hb_xgrab( ( HB_SIZE ) pFieldInfo.uiLen + 1 );
memset( pStr, ' ', pFieldInfo.uiLen );
pStr[ pFieldInfo.uiLen ] = '\0';
pItem = hb_itemPutCLPtr( NULL, pStr, pFieldInfo.uiLen );
break;
}
case HB_FT_BLOB:
pItem = hb_itemPutC( NULL, NULL );
break;
case HB_FT_LONG:
if( pFieldInfo.uiDec == 0 )
pItem = hb_itemPutNLLen( NULL, 0, pFieldInfo.uiLen );
else
pItem = hb_itemPutNDLen( NULL, 0.0, pFieldInfo.uiLen, pFieldInfo.uiDec );
break;
default:
pItem = hb_itemNew( NULL );
bError = HB_TRUE;
}
hb_arraySetForward( pItemEof, uiIndex + 1, pItem );
hb_itemRelease( pItem );
if( ! bError )
bError = ( SELF_ADDFIELD( ( AREAP ) pArea, &pFieldInfo ) == HB_FAILURE );
}
hb_itemRelease( pName );
if( bError )
break;
}
if( bError )
{
hb_itemRelease( pItemEof );
sqlite3_finalize( st );
hb_errRT_SQLT3DD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, errCode );
return HB_FAILURE;
}
pArea->ulRecCount = 0;
pArea->ulRecMax = SQLDD_ROWSET_INIT;
pArea->pRow = ( void ** ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( SQLDD_ROWSET_INIT * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pSDDData->pStmt = st;
return HB_SUCCESS;
}
PHB_SSLSTREAM hb_ssl_socketNew( HB_SOCKET sd, SSL * ssl, HB_BOOL fServer,
HB_MAXINT timeout, PHB_ITEM pSSL,
int * piResult )
{
int iResult;
PHB_SSLSTREAM pStream;
HB_MAXUINT timer;
pStream = ( HB_SSLSTREAM * ) hb_xgrabz( sizeof( HB_SSLSTREAM ) );
timer = timeout <= 0 ? 0 : hb_dateMilliSeconds();
pStream->ssl = ssl;
pStream->pSSL = pSSL ? hb_itemNew( pSSL ) : NULL;
pStream->blocking = timeout < 0;
if( hb_socketSetBlockingIO( sd, pStream->blocking ) < 0 )
pStream->blocking = ! pStream->blocking;
SSL_set_mode( ssl, HB_SSL_MODE_AUTO_RETRY );
iResult = SSL_set_fd( ssl, sd ); /* Truncates `sd` on win64. OpenSSL bug: https://rt.openssl.org/Ticket/Display.html?id=1928&user=guest&pass=guest */
while( iResult == 1 )
{
if( fServer )
iResult = SSL_accept( ssl );
else
iResult = SSL_connect( ssl );
if( iResult != 1 && hb_vmRequestQuery() == 0 )
{
int iError = SSL_get_error( ssl, iResult );
if( iError == SSL_ERROR_WANT_READ ||
iError == SSL_ERROR_WANT_WRITE )
{
if( timeout < 0 )
{
iResult = 1;
continue;
}
else if( timeout > 0 )
{
HB_MAXUINT timecurr = hb_dateMilliSeconds();
if( timecurr > timer )
{
timeout -= timecurr - timer;
if( timeout < 0 )
timeout = 0;
timer = timecurr;
}
if( timeout > 0 )
{
if( iError == SSL_ERROR_WANT_READ )
iError = hb_socketSelectRead( sd, timeout );
else
iError = hb_socketSelectWrite( sd, timeout );
if( iError > 0 )
{
iResult = 1;
continue;
}
}
}
hb_socketSetError( HB_SOCKET_ERR_TIMEOUT );
}
}
break;
}
if( iResult != 1 )
{
hb_ssl_socketClose( pStream );
pStream = NULL;
}
else
pStream->blocking = hb_socketSetBlockingIO( sd, HB_FALSE ) < 0;
if( piResult )
*piResult = iResult;
return pStream;
}
char * hb_verBuildDate( void )
{
return ( char * ) hb_xgrabz( 1 );
}
static HB_ERRCODE pgsqlOpen( SQLBASEAREAP pArea )
{
PGconn * pConn = ( ( SDDCONN * ) pArea->pConnection->pSDDConn )->pConn;
SDDDATA * pSDDData;
PGresult * pResult;
ExecStatusType status;
PHB_ITEM pItemEof, pItem;
HB_USHORT uiFields, uiCount;
HB_BOOL bError;
pArea->pSDDData = memset( hb_xgrab( sizeof( SDDDATA ) ), 0, sizeof( SDDDATA ) );
pSDDData = ( SDDDATA * ) pArea->pSDDData;
pResult = PQexec( pConn, pArea->szQuery );
if( ! pResult )
{
hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_LOWMEMORY, "Query failed", NULL, 0 ); /* Low memory, etc */
return HB_FAILURE;
}
status = PQresultStatus( pResult );
if( status != PGRES_TUPLES_OK && status != PGRES_COMMAND_OK )
{
hb_errRT_PostgreSQLDD( EG_OPEN, ESQLDD_INVALIDQUERY, PQresultErrorMessage( pResult ), pArea->szQuery, ( HB_ERRCODE ) status );
PQclear( pResult );
return HB_FAILURE;
}
pSDDData->pResult = pResult;
uiFields = ( HB_USHORT ) PQnfields( pResult );
SELF_SETFIELDEXTENT( &pArea->area, uiFields );
pItemEof = hb_itemArrayNew( uiFields );
pItem = hb_itemNew( NULL );
bError = HB_FALSE;
for( uiCount = 0; uiCount < uiFields; uiCount++ )
{
DBFIELDINFO dbFieldInfo;
memset( &dbFieldInfo, 0, sizeof( dbFieldInfo ) );
dbFieldInfo.atomName = PQfname( pResult, ( int ) uiCount );
switch( PQftype( pResult, ( int ) uiCount ) )
{
case BPCHAROID:
case VARCHAROID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = ( HB_USHORT ) PQfmod( pResult, uiCount ) - 4;
break;
case TEXTOID:
dbFieldInfo.uiType = HB_FT_MEMO;
dbFieldInfo.uiLen = 10;
break;
case NUMERICOID:
dbFieldInfo.uiType = HB_FT_DOUBLE;
dbFieldInfo.uiLen = ( PQfmod( pResult, uiCount ) - 4 ) >> 16;
dbFieldInfo.uiDec = ( PQfmod( pResult, uiCount ) - 4 ) & 0xFFFF;
break;
case INT2OID:
dbFieldInfo.uiType = HB_FT_INTEGER;
dbFieldInfo.uiLen = 6;
break;
case INT4OID:
dbFieldInfo.uiType = HB_FT_INTEGER;
dbFieldInfo.uiLen = 11;
break;
case INT8OID:
case OIDOID:
dbFieldInfo.uiType = HB_FT_LONG;
dbFieldInfo.uiLen = 20;
break;
case FLOAT4OID:
case FLOAT8OID:
case CASHOID: /* TODO: ??? */
dbFieldInfo.uiType = HB_FT_DOUBLE;
dbFieldInfo.uiLen = 16;
dbFieldInfo.uiDec = 2; /* TODO: hb_set.SET_DECIMALS ??? */
break;
case BOOLOID:
dbFieldInfo.uiType = HB_FT_LOGICAL;
dbFieldInfo.uiLen = 1;
break;
case DATEOID:
dbFieldInfo.uiType = HB_FT_DATE;
dbFieldInfo.uiLen = 8;
break;
case INETOID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 29;
break;
case CIDROID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 32;
break;
case MACADDROID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 17;
break;
case BITOID:
case VARBITOID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = ( HB_USHORT ) PQfsize( pResult, uiCount );
break;
case TIMEOID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 12;
break;
case TIMESTAMPOID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 23;
break;
case TIMETZOID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 15;
break;
case TIMESTAMPTZOID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 26;
break;
case NAMEOID:
dbFieldInfo.uiType = HB_FT_STRING;
dbFieldInfo.uiLen = 63;
break;
case BYTEAOID:
dbFieldInfo.uiType = HB_FT_STRING;
break;
default:
bError = HB_TRUE;
break;
}
/* printf( "field:%s \ttype:%d \tsize:%d \tformat:%d \tmod:%d err=%d\n", dbFieldInfo.atomName, PQftype( pResult, ( int ) uiCount ), PQfsize( pResult, uiCount ), PQfformat( pResult, uiCount ) , PQfmod( pResult, uiCount ), bError ); */
if( ! bError )
{
switch( dbFieldInfo.uiType )
{
case HB_FT_STRING:
{
char * pStr;
pStr = ( char * ) hb_xgrab( dbFieldInfo.uiLen + 1 );
memset( pStr, ' ', dbFieldInfo.uiLen );
pStr[ dbFieldInfo.uiLen ] = '\0';
hb_itemPutCL( pItem, pStr, dbFieldInfo.uiLen );
hb_xfree( pStr );
break;
}
case HB_FT_MEMO:
hb_itemPutC( pItem, NULL );
hb_itemSetCMemo( pItem );
break;
case HB_FT_INTEGER:
hb_itemPutNI( pItem, 0 );
break;
case HB_FT_LONG:
hb_itemPutNL( pItem, 0 );
break;
case HB_FT_DOUBLE:
hb_itemPutND( pItem, 0.0 );
break;
case HB_FT_LOGICAL:
hb_itemPutL( pItem, HB_FALSE );
break;
case HB_FT_DATE:
hb_itemPutDS( pItem, NULL );
break;
default:
hb_itemClear( pItem );
bError = HB_TRUE;
break;
}
hb_arraySetForward( pItemEof, uiCount + 1, pItem );
/* if( dbFieldInfo.uiType == HB_IT_DOUBLE || dbFieldInfo.uiType == HB_IT_INTEGER )
dbFieldInfo.uiType = HB_IT_LONG;
*/
if( ! bError )
bError = ( SELF_ADDFIELD( &pArea->area, &dbFieldInfo ) == HB_FAILURE );
}
if( bError )
break;
}
hb_itemRelease( pItem );
if( bError )
{
hb_itemClear( pItemEof );
hb_itemRelease( pItemEof );
hb_errRT_PostgreSQLDD( EG_CORRUPTION, ESQLDD_INVALIDFIELD, "Invalid field type", pArea->szQuery, 0 );
return HB_FAILURE;
}
pArea->ulRecCount = ( HB_ULONG ) PQntuples( pResult );
pArea->ulRecMax = pArea->ulRecCount + 1;
pArea->pRow = ( void ** ) hb_xgrab( ( pArea->ulRecCount + 1 ) * sizeof( void * ) );
pArea->pRowFlags = ( HB_BYTE * ) hb_xgrabz( ( pArea->ulRecCount + 1 ) * sizeof( HB_BYTE ) );
pArea->pRow[ 0 ] = pItemEof;
pArea->pRowFlags[ 0 ] = SQLDD_FLAG_CACHED;
pArea->fFetched = HB_TRUE;
return HB_SUCCESS;
}
