static void s_fileClose( PHB_FILE pFile )
{
hb_vmUnlock();
hb_fsSetError( 0 );
hb_threadEnterCriticalSection( &s_fileMtx );
if( --pFile->used == 0 )
{
if( pFile->pNext )
{
pFile->pPrev->pNext = pFile->pNext;
pFile->pNext->pPrev = pFile->pPrev;
if( pFile == s_openFiles )
{
s_openFiles = pFile->pNext;
if( pFile == s_openFiles )
s_openFiles = NULL;
}
}
if( pFile->hFile != FS_ERROR )
hb_fsClose( pFile->hFile );
if( pFile->hFileRO != FS_ERROR )
hb_fsClose( pFile->hFileRO );
if( pFile->pLocks )
hb_xfree( pFile->pLocks );
hb_xfree( pFile );
}
hb_threadLeaveCriticalSection( &s_fileMtx );
hb_vmLock();
}
/*
* Lˆ um arquivo do disco para a memoria e retorna uma string com o conteudo do
* mesmo... no segundo parametro ela retorna o tamanho de bytes lidos do arquivo.
*
* O primeiro parametro ‚ o nome do arquivo que deve ser lido do hd
* 19/11/2006 09:58:59
*/
char *xStrReadFile(char *s, ULONG * BytesRead )
{
int fh;
char *Buff;
ULONG nEnd, nStart, Length;
HB_TRACE( HB_TR_DEBUG, (" xStrReadFile( '%s' )", s ));
*BytesRead = 0; // 31/07/2008 - 16:35:30
if (!hb_spFile( ( BYTE * ) s, NULL ))
{
HB_TRACE( HB_TR_DEBUG, (" Arquivo nao existe: %s", s ));
return NULL;
} else {
HB_TRACE( HB_TR_DEBUG, (" Arquivo existe: %s", s ));
}
fh = hb_fsOpen( ( BYTE * ) s , 0 ); // 0 -> FO_READ
HB_TRACE( HB_TR_DEBUG, (" HANDLE: %d", fh ));
nEnd = hb_fsSeek( fh, 0 , 2 );
nStart = hb_fsSeek( fh , 0 , 0 );
HB_TRACE( HB_TR_DEBUG, (" Start .: %lu", nStart ));
HB_TRACE( HB_TR_DEBUG, (" End ...: %lu", nEnd ));
Length = nEnd - nStart;
Buff = (char *) hb_xgrab( Length+1 );
* BytesRead = hb_fsReadLarge( fh , ( BYTE * ) Buff, Length );
Buff[ * BytesRead ] = '\0';
hb_fsClose( fh );
return Buff;
}
static HB_SIZE ct_StrFile( const char * pFileName, const char * pcStr, HB_SIZE nLen,
HB_BOOL bOverwrite, HB_FOFFSET nOffset, HB_BOOL bTrunc )
{
HB_FHANDLE hFile;
HB_BOOL bOpen = HB_FALSE;
HB_BOOL bFile = hb_fsFile( pFileName );
HB_SIZE nWrite = 0;
if( bFile && bOverwrite )
{
hFile = hb_fsOpen( pFileName, FO_READWRITE );
bOpen = HB_TRUE;
}
else if( ! bFile || ! ct_getsafety() )
hFile = hb_fsCreate( pFileName, ct_getfcreate() );
else
hFile = FS_ERROR;
if( hFile != FS_ERROR )
{
if( nOffset )
hb_fsSeekLarge( hFile, nOffset, FS_SET );
else if( bOpen )
hb_fsSeek( hFile, 0, FS_END );
nWrite = hb_fsWriteLarge( hFile, pcStr, nLen );
if( ( nWrite == nLen ) && bOpen && bTrunc )
hb_fsWrite( hFile, NULL, 0 );
hb_fsClose( hFile );
}
return nWrite;
}
HB_FOFFSET hb_fsFSize( const char * pszFileName, HB_BOOL bUseDirEntry )
{
if( bUseDirEntry )
{
#if defined( HB_OS_WIN )
PHB_FFIND ffind = hb_fsFindFirst( pszFileName, HB_FA_ALL );
hb_fsSetIOError( ffind != NULL, 0 );
if( ffind )
{
HB_FOFFSET size = ffind->size;
hb_fsFindClose( ffind );
return size;
}
#elif defined( HB_USE_LARGEFILE64 )
char * pszFree;
HB_BOOL fResult;
struct stat64 statbuf;
pszFileName = hb_fsNameConv( pszFileName, &pszFree );
statbuf.st_size = 0;
hb_vmUnlock();
fResult = stat64( pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( pszFree )
hb_xfree( pszFree );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#else
char * pszFree;
HB_BOOL fResult;
struct stat statbuf;
pszFileName = hb_fsNameConv( pszFileName, &pszFree );
statbuf.st_size = 0;
hb_vmUnlock();
fResult = stat( ( char * ) pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( pszFree )
hb_xfree( pszFree );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#endif
}
else
{
HB_FHANDLE hFileHandle = hb_fsOpen( pszFileName, FO_READ | FO_COMPAT );
if( hFileHandle != FS_ERROR )
{
HB_FOFFSET nPos = hb_fsSeekLarge( hFileHandle, 0, FS_END );
hb_fsClose( hFileHandle );
return nPos;
}
}
return 0;
}
static HB_BOOL hb_zipGetFileInfo( const char * szFileName, HB_U32 * pulCRC, HB_BOOL * pfText )
{
HB_FHANDLE hFile;
HB_BOOL fResult;
hFile = hb_fsOpen( szFileName, FO_READ );
fResult = hb_zipGetFileInfoFromHandle( hFile, pulCRC, pfText );
if( hFile != FS_ERROR )
hb_fsClose( hFile );
return fResult;
}
void hb_dbQSortExit( LPDBQUICKSORT pQuickSort )
{
/* Close and delete temp file */
hb_fsClose( pQuickSort->hFile );
hb_fsDelete( pQuickSort->szTempName );
/* Free buffers */
hb_xfree( pQuickSort->pBuffer );
hb_xfree( pQuickSort->pSwapBufferA );
hb_xfree( pQuickSort->pSwapBufferB );
hb_xfree( pQuickSort->pCmpBufferA );
hb_xfree( pQuickSort->pCmpBufferB );
}
static PHRB_BODY hb_hrbLoadFromFile( const char * szHrb, HB_USHORT usMode )
{
char szFileName[ HB_PATH_MAX ];
PHRB_BODY pHrbBody = NULL;
PHB_FNAME pFileName;
HB_FHANDLE hFile;
/* Create full filename */
pFileName = hb_fsFNameSplit( szHrb );
if( pFileName->szExtension == NULL && hb_stackSetStruct()->HB_SET_DEFEXTENSIONS )
{
pFileName->szExtension = ".hrb";
}
hb_fsFNameMerge( szFileName, pFileName );
hb_xfree( pFileName );
/* Open as binary */
do
{
hFile = hb_fsOpen( szFileName, FO_READ );
}
while( hFile == FS_ERROR &&
hb_errRT_BASE_Ext1( EG_OPEN, 6102, NULL, szFileName, hb_fsError(),
EF_CANDEFAULT | EF_CANRETRY,
HB_ERR_ARGS_BASEPARAMS ) == E_RETRY );
if( hFile != FS_ERROR )
{
HB_SIZE nBodySize = hb_fsSeek( hFile, 0, FS_END );
if( nBodySize )
{
char * pbyBuffer;
pbyBuffer = ( char * ) hb_xgrab( nBodySize + sizeof( char ) + 1 );
hb_fsSeek( hFile, 0, FS_SET );
hb_fsReadLarge( hFile, pbyBuffer, nBodySize );
pbyBuffer[ nBodySize ] = '\0';
pHrbBody = hb_hrbLoad( ( const char * ) pbyBuffer, nBodySize, usMode, szFileName );
hb_xfree( pbyBuffer );
}
hb_fsClose( hFile );
}
return pHrbBody;
}
static char * filetoBuff( const char * fname, unsigned long * size )
{
char * buffer = NULL;
HB_FHANDLE handle = hb_fsOpen( fname, FO_READWRITE );
if( handle != FS_ERROR )
{
*size = hb_fsSeek( handle, 0, FS_END );
hb_fsSeek( handle, 0, FS_SET );
buffer = ( char * ) hb_xgrab( *size + 1 );
*size = ( unsigned long ) hb_fsReadLarge( handle, buffer, *size );
buffer[ *size ] = '\0';
hb_fsClose( handle );
}
else
*size = 0;
return buffer;
}
static HB_BOOL hb_copyfile( const char * szSource, const char * szDest, PHB_ITEM pBlock )
{
HB_BOOL bRetVal = HB_FALSE;
HB_FHANDLE fhndSource;
HB_TRACE( HB_TR_DEBUG, ( "hb_copyfile(%s, %s)", szSource, szDest ) );
while( ( fhndSource = hb_spOpen( szSource, FO_READ | FO_SHARED | FO_PRIVATE ) ) == FS_ERROR )
{
HB_USHORT uiAction = hb_errRT_BASE_Ext1( EG_OPEN, 2012, NULL, szSource, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 );
if( uiAction != E_RETRY )
break;
}
if( fhndSource != FS_ERROR )
{
HB_FHANDLE fhndDest;
while( ( fhndDest = hb_spCreate( szDest, FC_NORMAL ) ) == FS_ERROR )
{
HB_USHORT uiAction = hb_errRT_BASE_Ext1( EG_CREATE, 2012, NULL, szDest, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 );
if( uiAction != E_RETRY )
break;
}
if( fhndDest != FS_ERROR )
{
#if defined( HB_OS_UNIX )
struct stat struFileInfo;
int iSuccess = fstat( fhndSource, &struFileInfo );
#endif
HB_BYTE * buffer = ( HB_BYTE * ) hb_xgrab( BUFFER_SIZE );
HB_SIZE nRead;
bRetVal = HB_TRUE;
if( hb_itemType( pBlock ) != HB_IT_BLOCK )
pBlock = NULL;
while( ( nRead = hb_fsReadLarge( fhndSource, buffer, BUFFER_SIZE ) ) != 0 )
{
while( hb_fsWriteLarge( fhndDest, buffer, nRead ) != nRead )
{
HB_USHORT uiAction = hb_errRT_BASE_Ext1( EG_WRITE, 2016, NULL, szDest, hb_fsError(), EF_CANDEFAULT | EF_CANRETRY, 0 );
if( uiAction != E_RETRY )
{
bRetVal = HB_FALSE;
break;
}
}
if( pBlock )
{
PHB_ITEM pCnt = hb_itemPutNS( NULL, nRead );
hb_vmEvalBlockV( pBlock, 1, pCnt );
hb_itemRelease( pCnt );
}
}
hb_xfree( buffer );
#if defined( HB_OS_UNIX )
if( iSuccess == 0 )
fchmod( fhndDest, struFileInfo.st_mode );
#endif
hb_fsClose( fhndDest );
}
hb_fsClose( fhndSource );
}
return bRetVal;
}
HB_FHANDLE hb_fsProcessOpen( const char * pszFileName,
HB_FHANDLE * phStdin, HB_FHANDLE * phStdout,
HB_FHANDLE * phStderr,
HB_BOOL fDetach, HB_ULONG * pulPID )
{
HB_FHANDLE hPipeIn [ 2 ] = { FS_ERROR, FS_ERROR },
hPipeOut[ 2 ] = { FS_ERROR, FS_ERROR },
hPipeErr[ 2 ] = { FS_ERROR, FS_ERROR };
HB_FHANDLE hResult = FS_ERROR;
HB_ERRCODE errCode;
HB_BOOL fError = HB_FALSE;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessOpen(%s, %p, %p, %p, %d, %p)", pszFileName, phStdin, phStdout, phStderr, fDetach, pulPID ) );
if( phStdin != NULL )
fError = ! hb_fsPipeCreate( hPipeIn );
if( ! fError && phStdout != NULL )
fError = ! hb_fsPipeCreate( hPipeOut );
if( ! fError && phStderr != NULL )
{
if( phStdout == phStderr )
{
hPipeErr[ 0 ] = hPipeOut[ 0 ];
hPipeErr[ 1 ] = hPipeOut[ 1 ];
}
else
fError = ! hb_fsPipeCreate( hPipeErr );
}
if( ! fError )
{
#if defined( HB_OS_WIN )
PROCESS_INFORMATION pi;
STARTUPINFO si;
DWORD dwFlags = 0;
LPTSTR lpCommand = HB_CHARDUP( pszFileName );
# if ! defined( HB_OS_WIN_CE )
if( phStdin != NULL )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 1 ] ), HANDLE_FLAG_INHERIT, 0 );
if( phStdout != NULL )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 0 ] ), HANDLE_FLAG_INHERIT, 0 );
if( phStderr != NULL && phStdout != phStderr )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 0 ] ), HANDLE_FLAG_INHERIT, 0 );
# endif
memset( &pi, 0, sizeof( pi ) );
memset( &si, 0, sizeof( si ) );
si.cb = sizeof( si );
# ifdef STARTF_USESTDHANDLES
si.dwFlags = STARTF_USESTDHANDLES;
# endif
if( fDetach )
{
# ifdef STARTF_USESHOWWINDOW
si.dwFlags |= STARTF_USESHOWWINDOW;
# endif
si.wShowWindow = SW_HIDE;
si.hStdInput = ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] );
si.hStdOutput = ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] );
si.hStdError = ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] );
# ifdef DETACHED_PROCESS
dwFlags |= DETACHED_PROCESS;
# endif
}
else
{
si.hStdInput = phStdin ? ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] ) : GetStdHandle( STD_INPUT_HANDLE );
si.hStdOutput = phStdout ? ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] ) : GetStdHandle( STD_OUTPUT_HANDLE );
si.hStdError = phStderr ? ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] ) : GetStdHandle( STD_ERROR_HANDLE );
}
fError = ! CreateProcess( NULL, /* lpAppName */
lpCommand,
NULL, /* lpProcessAttr */
NULL, /* lpThreadAttr */
TRUE, /* bInheritHandles */
dwFlags, /* dwCreationFlags */
NULL, /* lpEnvironment */
NULL, /* lpCurrentDirectory */
&si,
&pi );
hb_fsSetIOError( ! fError, 0 );
hb_xfree( lpCommand );
if( ! fError )
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pi.dwProcessId;
CloseHandle( pi.hThread );
hResult = ( HB_FHANDLE ) pi.hProcess;
}
#elif defined( HB_OS_OS2 )
HFILE hNull = ( HFILE ) FS_ERROR;
ULONG ulState = 0;
APIRET ret = NO_ERROR;
PID pid = ( PID ) -1;
PHB_GT pGT;
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hFile;
ret = hb_fsOS2DosOpen( "NUL:", &hFile, &ulState, 0,
FILE_NORMAL, OPEN_ACCESS_READWRITE,
OPEN_ACTION_OPEN_IF_EXISTS );
if( ret == NO_ERROR )
hNull = ( HFILE ) hFile;
}
if( ret == NO_ERROR && phStdin != NULL )
{
ret = DosQueryFHState( hPipeIn[ 1 ], &ulState );
if( ret == NO_ERROR && ( ulState & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hPipeIn[ 1 ], ( ulState & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
}
if( ret == NO_ERROR && phStdout != NULL )
{
ret = DosQueryFHState( hPipeOut[ 0 ], &ulState );
if( ret == NO_ERROR && ( ulState & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hPipeOut[ 0 ], ( ulState & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
}
if( ret == NO_ERROR && phStderr != NULL && phStdout != phStderr )
{
ret = DosQueryFHState( hPipeErr[ 0 ], &ulState );
if( ret == NO_ERROR && ( ulState & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hPipeErr[ 0 ], ( ulState & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
}
if( ret == NO_ERROR && ( pGT = hb_gt_Base() ) != NULL )
{
ULONG ulStateIn, ulStateOut, ulStateErr;
HFILE hStdIn, hStdErr, hStdOut, hDup;
ulStateIn = ulStateOut = ulStateErr = OPEN_FLAGS_NOINHERIT;
hStdIn = hStdErr = hStdOut = ( HFILE ) FS_ERROR;
if( ret == NO_ERROR && ( phStdin != NULL || fDetach ) )
{
hDup = 0;
ret = DosDupHandle( hDup, &hStdIn );
if( ret == NO_ERROR )
{
ret = DosQueryFHState( hStdIn, &ulStateIn );
if( ret == NO_ERROR && ( ulStateIn & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hStdIn, ( ulStateIn & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
if( ret == NO_ERROR )
ret = DosDupHandle( phStdin != NULL ? ( HFILE ) hPipeIn[ 0 ] : hNull, &hDup );
}
}
if( ret == NO_ERROR && ( phStdout != NULL || fDetach ) )
{
hDup = 1;
ret = DosDupHandle( hDup, &hStdOut );
if( ret == NO_ERROR )
{
ret = DosQueryFHState( hStdOut, &ulStateOut );
if( ret == NO_ERROR && ( ulStateOut & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hStdOut, ( ulStateOut & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
if( ret == NO_ERROR )
ret = DosDupHandle( phStdout != NULL ? ( HFILE ) hPipeOut[ 1 ] : hNull, &hDup );
}
}
if( ret == NO_ERROR && ( phStderr != NULL || fDetach ) )
{
hDup = 2;
ret = DosDupHandle( hDup, &hStdErr );
if( ret == NO_ERROR )
{
ret = DosQueryFHState( hStdErr, &ulStateErr );
if( ret == NO_ERROR && ( ulStateErr & OPEN_FLAGS_NOINHERIT ) == 0 )
ret = DosSetFHState( hStdErr, ( ulStateErr & 0xFF00 ) | OPEN_FLAGS_NOINHERIT );
if( ret == NO_ERROR )
ret = DosDupHandle( phStderr != NULL ? ( HFILE ) hPipeErr[ 1 ] : hNull, &hDup );
}
}
if( ret == NO_ERROR )
{
char * pArgs = hb_buildArgsOS2( pszFileName, &ret );
char uchLoadError[ CCHMAXPATH ] = { 0 };
RESULTCODES ChildRC = { 0, 0 };
if( pArgs )
{
ret = DosExecPgm( uchLoadError, sizeof( uchLoadError ),
fDetach ? EXEC_BACKGROUND : EXEC_ASYNCRESULT,
( PCSZ ) pArgs, NULL /* env */,
&ChildRC,
( PCSZ ) pArgs );
if( ret == NO_ERROR )
pid = ChildRC.codeTerminate;
hb_freeArgsOS2( pArgs );
}
}
if( hNull != ( HFILE ) FS_ERROR )
DosClose( hNull );
if( hStdIn != ( HFILE ) FS_ERROR )
{
hDup = 0;
DosDupHandle( hStdIn, &hDup );
DosClose( hStdIn );
if( ( ulStateIn & OPEN_FLAGS_NOINHERIT ) == 0 )
DosSetFHState( hDup, ulStateIn & 0xFF00 );
}
if( hStdOut != ( HFILE ) FS_ERROR )
{
hDup = 1;
DosDupHandle( hStdOut, &hDup );
DosClose( hStdOut );
if( ( ulStateOut & OPEN_FLAGS_NOINHERIT ) == 0 )
DosSetFHState( hDup, ulStateOut & 0xFF00 );
}
if( hStdErr != ( HFILE ) FS_ERROR )
{
hDup = 2;
DosDupHandle( hStdErr, &hDup );
DosClose( hStdErr );
if( ( ulStateErr & OPEN_FLAGS_NOINHERIT ) == 0 )
DosSetFHState( hDup, ulStateErr & 0xFF00 );
}
hb_gt_BaseFree( pGT );
}
else
{
if( hNull != ( HFILE ) FS_ERROR )
DosClose( hNull );
if( ret == NO_ERROR )
ret = ( APIRET ) FS_ERROR;
}
fError = ret != NO_ERROR;
if( ! fError )
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
hb_fsSetError( ( HB_ERRCODE ) ret );
#elif defined( HB_OS_UNIX ) && \
! defined( HB_OS_VXWORKS ) && ! defined( HB_OS_SYMBIAN )
char ** argv = hb_buildArgs( pszFileName );
pid_t pid = fork();
if( pid == -1 )
fError = HB_TRUE;
else if( pid != 0 ) /* parent process */
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
else /* child process */
{
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hNull = open( "/dev/null", O_RDWR );
if( ! phStdin )
dup2( hNull, 0 );
if( ! phStdout )
dup2( hNull, 1 );
if( ! phStderr )
dup2( hNull, 2 );
if( hNull != FS_ERROR )
hb_fsClose( hNull );
}
if( phStdin != NULL )
{
dup2( hPipeIn[ 0 ], 0 );
hb_fsClose( hPipeIn[ 1 ] );
}
if( phStdout != NULL )
{
dup2( hPipeOut[ 1 ], 1 );
hb_fsClose( hPipeOut[ 0 ] );
}
if( phStderr != NULL )
{
dup2( hPipeErr[ 1 ], 2 );
if( phStdout != phStderr )
hb_fsClose( hPipeErr[ 0 ] );
}
/* close all non std* handles */
{
int iMaxFD, i;
iMaxFD = sysconf( _SC_OPEN_MAX );
if( iMaxFD < 3 )
iMaxFD = 1024;
for( i = 3; i < iMaxFD; ++i )
hb_fsClose( i );
}
/* reset extended process attributes */
if( setuid( getuid() ) == -1 ) {}
if( setgid( getgid() ) == -1 ) {}
/* execute command */
{
# if defined( __WATCOMC__ )
execvp( argv[ 0 ], ( const char ** ) argv );
# else
execvp( argv[ 0 ], argv );
# endif
exit( -1 );
}
}
hb_fsSetIOError( ! fError, 0 );
hb_freeArgs( argv );
#elif defined( HB_OS_OS2 ) || defined( HB_OS_WIN )
int hStdIn, hStdOut, hStdErr;
char ** argv;
int pid;
hStdIn = dup( 0 );
hStdOut = dup( 1 );
hStdErr = dup( 2 );
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hNull = open( "NUL:", O_RDWR );
if( ! phStdin )
dup2( hNull, 0 );
if( ! phStdout )
dup2( hNull, 1 );
if( ! phStderr )
dup2( hNull, 2 );
if( hNull != FS_ERROR )
close( hNull );
}
if( phStdin != NULL )
dup2( hPipeIn[ 0 ], 0 );
if( phStdout != NULL )
dup2( hPipeOut[ 1 ], 1 );
if( phStderr != NULL )
dup2( hPipeErr[ 1 ], 2 );
argv = hb_buildArgs( pszFileName );
#if defined( _MSC_VER ) || defined( __LCC__ ) || \
defined( __XCC__ ) || defined( __POCC__ )
pid = _spawnvp( _P_NOWAIT, argv[ 0 ], argv );
#elif defined( __MINGW32__ ) || defined( __WATCOMC__ )
pid = spawnvp( P_NOWAIT, argv[ 0 ], ( const char * const * ) argv );
#else
pid = spawnvp( P_NOWAIT, argv[ 0 ], ( char * const * ) argv );
#endif
hb_freeArgs( argv );
dup2( hStdIn, 0 );
close( hStdIn );
dup2( hStdOut, 1 );
close( hStdOut );
dup2( hStdErr, 2 );
close( hStdErr );
if( pid < 0 )
fError = HB_TRUE;
else if( pid != 0 ) /* parent process */
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
hb_fsSetIOError( ! fError, 0 );
#else
int iTODO; /* TODO: for given platform */
HB_SYMBOL_UNUSED( pszFileName );
HB_SYMBOL_UNUSED( fDetach );
HB_SYMBOL_UNUSED( pulPID );
hb_fsSetError( ( HB_ERRCODE ) FS_ERROR );
#endif
}
errCode = hb_fsError();
if( hPipeIn[ 0 ] != FS_ERROR )
hb_fsClose( hPipeIn[ 0 ] );
if( hPipeIn[ 1 ] != FS_ERROR )
hb_fsClose( hPipeIn[ 1 ] );
if( hPipeOut[ 0 ] != FS_ERROR )
hb_fsClose( hPipeOut[ 0 ] );
if( hPipeOut[ 1 ] != FS_ERROR )
hb_fsClose( hPipeOut[ 1 ] );
if( phStdout != phStderr )
{
if( hPipeErr[ 0 ] != FS_ERROR )
hb_fsClose( hPipeErr[ 0 ] );
if( hPipeErr[ 1 ] != FS_ERROR )
hb_fsClose( hPipeErr[ 1 ] );
}
hb_fsSetError( errCode );
return hResult;
}
static int hb_fsProcessExec( const char * pszFileName,
HB_FHANDLE hStdin, HB_FHANDLE hStdout,
HB_FHANDLE hStderr )
{
int iResult = FS_ERROR;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessExec(%s, %p, %p, %p)", pszFileName, ( void * ) ( HB_PTRUINT ) hStdin, ( void * ) ( HB_PTRUINT ) hStdout, ( void * ) ( HB_PTRUINT ) hStderr ) );
#if defined( HB_OS_WIN_CE )
{
LPTSTR lpAppName, lpParams;
HB_BOOL fError;
HB_SYMBOL_UNUSED( hStdin );
HB_SYMBOL_UNUSED( hStdout );
HB_SYMBOL_UNUSED( hStderr );
hb_getCommand( pszFileName, &lpAppName, &lpParams );
hb_vmUnlock();
fError = ! CreateProcess( lpAppName, /* lpAppName */
lpParams, /* lpCommandLine */
NULL, /* lpProcessAttr */
NULL, /* lpThreadAttr */
FALSE, /* bInheritHandles */
0, /* dwCreationFlags */
NULL, /* lpEnvironment */
NULL, /* lpCurrentDirectory */
NULL, /* lpStartupInfo */
NULL ); /* lpProcessInformation */
hb_fsSetIOError( ! fError, 0 );
if( ! fError )
iResult = 0;
hb_vmLock();
if( lpAppName )
hb_xfree( lpAppName );
if( lpParams )
hb_xfree( lpParams );
}
#elif defined( HB_OS_DOS ) || defined( HB_OS_WIN ) || defined( HB_OS_OS2 ) || \
defined( HB_OS_UNIX )
{
int iStdIn, iStdOut, iStdErr;
char ** argv;
argv = hb_buildArgs( pszFileName );
hb_vmUnlock();
iStdIn = iStdOut = iStdErr = FS_ERROR;
if( hStdin != FS_ERROR )
{
iStdIn = dup( 0 );
dup2( hStdin, 0 );
}
if( hStdout != FS_ERROR )
{
iStdOut = dup( 1 );
dup2( hStdout, 1 );
}
if( hStderr != FS_ERROR )
{
iStdErr = dup( 2 );
dup2( hStderr, 2 );
}
#if defined( HB_OS_UNIX ) && ! defined( HB_OS_VXWORKS ) && ! defined( HB_OS_SYMBIAN )
{
pid_t pid = fork();
if( pid == 0 )
{
/* close all non std* handles */
{
int iMaxFD, i;
iMaxFD = sysconf( _SC_OPEN_MAX );
if( iMaxFD < 3 )
iMaxFD = 1024;
for( i = 3; i < iMaxFD; ++i )
hb_fsClose( i );
}
/* reset extended process attributes */
( void ) setuid( getuid() );
( void ) setgid( getgid() );
/* execute command */
execvp( argv[ 0 ], argv );
exit( -1 );
}
else if( pid != -1 )
{
int iStatus;
iResult = waitpid( pid, &iStatus, 0 );
#ifdef ERESTARTSYS
if( iResult < 0 && errno != ERESTARTSYS )
#else
if( iResult < 0 )
#endif
iResult = -2;
else if( iResult == 0 )
iResult = -1;
else
iResult = WIFEXITED( iStatus ) ? WEXITSTATUS( iStatus ) : 0;
}
}
#elif defined( _MSC_VER ) || defined( __LCC__ ) || \
defined( __XCC__ ) || defined( __POCC__ )
iResult = _spawnvp( _P_WAIT, argv[ 0 ], argv );
#elif defined( __MINGW32__ ) || defined( __WATCOMC__ )
iResult = spawnvp( P_WAIT, argv[ 0 ], ( const char * const * ) argv );
#else
iResult = spawnvp( P_WAIT, argv[ 0 ], ( char * const * ) argv );
#endif
hb_fsSetIOError( iResult >= 0, 0 );
if( iStdIn != FS_ERROR )
{
dup2( iStdIn, 0 );
close( iStdIn );
}
if( iStdOut != FS_ERROR )
{
dup2( iStdOut, 1 );
close( iStdOut );
}
if( iStdErr != FS_ERROR )
{
dup2( iStdErr, 2 );
close( iStdErr );
}
hb_vmLock();
hb_freeArgs( argv );
}
#else
{
int iTODO; /* TODO: for given platform */
HB_SYMBOL_UNUSED( pszFileName );
HB_SYMBOL_UNUSED( hStdin );
HB_SYMBOL_UNUSED( hStdout );
HB_SYMBOL_UNUSED( hStderr );
hb_fsSetError( ( HB_ERRCODE ) FS_ERROR );
}
#endif
return iResult;
}
int hb_fsProcessRun( const char * pszFileName,
const char * pStdInBuf, HB_SIZE nStdInLen,
char ** pStdOutPtr, HB_SIZE * pulStdOut,
char ** pStdErrPtr, HB_SIZE * pulStdErr,
HB_BOOL fDetach )
{
HB_FHANDLE hStdin, hStdout, hStderr, *phStdin, *phStdout, *phStderr;
char * pOutBuf, *pErrBuf;
HB_SIZE nOutSize, nErrSize, nOutBuf, nErrBuf;
int iResult;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessRun(%s, %p, %" HB_PFS "u, %p, %p, %p, %p, %d)", pStdInBuf, pStdInBuf, nStdInLen, pStdOutPtr, pulStdOut, pStdErrPtr, pulStdErr, fDetach ) );
nOutBuf = nErrBuf = nOutSize = nErrSize = 0;
pOutBuf = pErrBuf = NULL;
hStdin = hStdout = hStderr = FS_ERROR;
phStdin = pStdInBuf ? &hStdin : NULL;
phStdout = pStdOutPtr && pulStdOut ? &hStdout : NULL;
phStderr = pStdErrPtr && pulStdErr ?
( pStdOutPtr == pStdErrPtr ? phStdout : &hStderr ) : NULL;
#if defined( HB_PROCESS_USEFILES )
{
#if defined( HB_OS_WIN_CE )
# define _HB_NULLHANDLE() FS_ERROR
#elif defined( HB_OS_UNIX )
# define _HB_NULLHANDLE() open( "/dev/null", O_RDWR )
#else
# define _HB_NULLHANDLE() open( "NUL:", O_RDWR )
#endif
char sTmpIn[ HB_PATH_MAX ];
char sTmpOut[ HB_PATH_MAX ];
char sTmpErr[ HB_PATH_MAX ];
HB_SYMBOL_UNUSED( phStdin );
HB_SYMBOL_UNUSED( nOutSize );
HB_SYMBOL_UNUSED( nErrSize );
sTmpIn[ 0 ] = sTmpOut[ 0 ] = sTmpErr[ 0 ] = '\0';
if( pStdInBuf )
{
hStdin = hb_fsCreateTempEx( sTmpIn, NULL, NULL, NULL, FC_NORMAL );
if( nStdInLen )
{
hb_fsWriteLarge( hStdin, pStdInBuf, nStdInLen );
hb_fsSeek( hStdin, 0, FS_SET );
}
}
else if( fDetach )
hStdin = _HB_NULLHANDLE();
if( pStdOutPtr && pulStdOut )
hStdout = hb_fsCreateTempEx( sTmpOut, NULL, NULL, NULL, FC_NORMAL );
else if( fDetach )
hStdout = _HB_NULLHANDLE();
if( pStdErrPtr && pulStdErr )
{
if( phStdout == phStderr )
hStderr = hStdout;
else
hStderr = hb_fsCreateTempEx( sTmpErr, NULL, NULL, NULL, FC_NORMAL );
}
else if( fDetach )
hStderr = _HB_NULLHANDLE();
iResult = hb_fsProcessExec( pszFileName, hStdin, hStdout, hStderr );
if( hStdin != FS_ERROR )
{
hb_fsClose( hStdin );
if( sTmpIn[ 0 ] )
hb_fsDelete( sTmpIn );
}
if( hStdout != FS_ERROR )
{
if( pStdOutPtr && pulStdOut )
{
nOutBuf = hb_fsSeek( hStdout, 0, FS_END );
if( nOutBuf )
{
pOutBuf = ( char * ) hb_xgrab( nOutBuf + 1 );
hb_fsSeek( hStdout, 0, FS_SET );
nOutBuf = hb_fsReadLarge( hStdout, pOutBuf, nOutBuf );
}
}
hb_fsClose( hStdout );
if( sTmpOut[ 0 ] )
hb_fsDelete( sTmpOut );
}
if( hStderr != FS_ERROR && hStderr != hStdout )
{
if( pStdErrPtr && pulStdErr )
{
nErrBuf = hb_fsSeek( hStderr, 0, FS_END );
if( nErrBuf )
{
pErrBuf = ( char * ) hb_xgrab( nErrBuf + 1 );
hb_fsSeek( hStderr, 0, FS_SET );
nErrBuf = hb_fsReadLarge( hStderr, pErrBuf, nErrBuf );
}
}
hb_fsClose( hStderr );
if( sTmpErr[ 0 ] )
hb_fsDelete( sTmpErr );
}
}
#else /* ! HB_PROCESS_USEFILES */
{
HB_FHANDLE hProcess;
hb_vmUnlock();
iResult = -1;
hProcess = hb_fsProcessOpen( pszFileName, phStdin, phStdout, phStderr,
fDetach, NULL );
if( hProcess != FS_ERROR )
{
#if defined( HB_OS_WIN )
HB_BOOL fFinished = HB_FALSE, fBlocked;
int iPipeCount = 0;
if( nStdInLen == 0 && hStdin != FS_ERROR )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
}
if( hStdout == hStderr )
hStderr = FS_ERROR;
if( hStdin != FS_ERROR )
++iPipeCount;
if( hStdout != FS_ERROR )
++iPipeCount;
if( hStderr != FS_ERROR )
++iPipeCount;
fBlocked = iPipeCount <= 1;
if( ! fBlocked )
{
if( hStdin != FS_ERROR )
hb_fsPipeUnblock( hStdin );
if( hStdout != FS_ERROR )
hb_fsPipeUnblock( hStdout );
if( hStderr != FS_ERROR )
hb_fsPipeUnblock( hStderr );
}
for( ;; )
{
DWORD dwResult, dwWait;
HB_SIZE nLen;
dwWait = 1000;
if( hStdout != FS_ERROR )
{
if( nOutBuf == nOutSize )
{
if( nOutSize == 0 )
nOutSize = HB_STD_BUFFER_SIZE;
else
nOutSize += nOutSize >> 1;
pOutBuf = ( char * ) hb_xrealloc( pOutBuf, nOutSize + 1 );
}
nLen = hb_fsReadLarge( hStdout, pOutBuf + nOutBuf, nOutSize - nOutBuf );
if( nLen > 0 )
nOutBuf += nLen;
else if( fBlocked )
{
hb_fsClose( hStdout );
hStdout = FS_ERROR;
--iPipeCount;
}
dwWait = nLen > 0 ? 0 : 10;
}
if( hStderr != FS_ERROR )
{
if( nErrBuf == nErrSize )
{
if( nErrSize == 0 )
nErrSize = HB_STD_BUFFER_SIZE;
else
nErrSize += nErrSize >> 1;
pErrBuf = ( char * ) hb_xrealloc( pErrBuf, nErrSize + 1 );
}
nLen = hb_fsReadLarge( hStderr, pErrBuf + nErrBuf, nErrSize - nErrBuf );
if( nLen > 0 )
nErrBuf += nLen;
else if( fBlocked )
{
hb_fsClose( hStderr );
hStderr = FS_ERROR;
--iPipeCount;
}
if( dwWait )
dwWait = nLen > 0 ? 0 : 10;
}
if( fFinished )
{
if( dwWait != 0 )
break;
}
else if( hStdin != FS_ERROR )
{
nLen = ! fBlocked && nStdInLen > 4096 ? 4096 : nStdInLen;
nLen = hb_fsWriteLarge( hStdin, pStdInBuf, nLen );
pStdInBuf += nLen;
nStdInLen -= nLen;
if( nStdInLen == 0 || ( fBlocked && nLen == 0 ) )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
--iPipeCount;
}
else if( dwWait )
dwWait = nLen > 0 ? 0 : 10;
}
if( iPipeCount == 0 )
dwWait = INFINITE;
dwResult = WaitForSingleObject( ( HANDLE ) hb_fsGetOsHandle( hProcess ), dwWait );
if( dwResult == WAIT_OBJECT_0 )
{
if( GetExitCodeProcess( ( HANDLE ) hb_fsGetOsHandle( hProcess ), &dwResult ) )
iResult = ( int ) dwResult;
else
iResult = -2;
fFinished = HB_TRUE;
}
}
if( hStdin != FS_ERROR )
hb_fsClose( hStdin );
if( hStdout != FS_ERROR )
hb_fsClose( hStdout );
if( hStderr != FS_ERROR )
hb_fsClose( hStderr );
CloseHandle( ( HANDLE ) hb_fsGetOsHandle( hProcess ) );
#elif defined( HB_OS_OS2 ) || defined( HB_OS_WIN )
HB_MAXINT nTimeOut = 0;
int iPipeCount = 0;
if( nStdInLen == 0 && hStdin != FS_ERROR )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
}
if( hStdout == hStderr )
hStderr = FS_ERROR;
if( hStdin != FS_ERROR )
++iPipeCount;
if( hStdout != FS_ERROR )
++iPipeCount;
if( hStderr != FS_ERROR )
++iPipeCount;
while( iPipeCount > 0 )
{
HB_MAXINT nNextTOut = 10;
HB_SIZE nLen;
if( hStdin != FS_ERROR )
{
if( iPipeCount == 1 )
nLen = hb_fsWriteLarge( hStdin, pStdInBuf, nStdInLen );
else
nLen = hb_fsPipeWrite( hStdin, pStdInBuf, nStdInLen, nTimeOut );
if( nLen == ( HB_SIZE ) ( iPipeCount == 1 ? 0 : FS_ERROR ) )
nStdInLen = 0;
else if( nLen > 0 )
{
pStdInBuf += nLen;
nStdInLen -= nLen;
nNextTOut = 0;
}
if( nStdInLen == 0 )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
--iPipeCount;
}
}
if( hStdout != FS_ERROR )
{
if( nOutBuf == nOutSize )
{
if( nOutSize == 0 )
nOutSize = HB_STD_BUFFER_SIZE;
else
nOutSize += nOutSize >> 1;
pOutBuf = ( char * ) hb_xrealloc( pOutBuf, nOutSize + 1 );
}
if( iPipeCount == 1 )
nLen = hb_fsReadLarge( hStdout, pOutBuf + nOutBuf, nOutSize - nOutBuf );
else
nLen = hb_fsPipeRead( hStdout, pOutBuf + nOutBuf, nOutSize - nOutBuf, nTimeOut );
if( nLen == ( HB_SIZE ) ( iPipeCount == 1 ? 0 : FS_ERROR ) )
{
hb_fsClose( hStdout );
hStdout = FS_ERROR;
--iPipeCount;
}
else if( nLen > 0 )
{
nOutBuf += nLen;
nNextTOut = 0;
}
}
if( hStderr != FS_ERROR )
{
if( nErrBuf == nErrSize )
{
if( nErrSize == 0 )
nErrSize = HB_STD_BUFFER_SIZE;
else
nErrSize += nErrSize >> 1;
pErrBuf = ( char * ) hb_xrealloc( pErrBuf, nErrSize + 1 );
}
if( iPipeCount == 1 )
nLen = hb_fsReadLarge( hStderr, pErrBuf + nErrBuf, nErrSize - nErrBuf );
else
nLen = hb_fsPipeRead( hStderr, pErrBuf + nErrBuf, nErrSize - nErrBuf, nTimeOut );
if( nLen == ( HB_SIZE ) ( iPipeCount == 1 ? 0 : FS_ERROR ) )
{
hb_fsClose( hStderr );
hStderr = FS_ERROR;
--iPipeCount;
}
else if( nLen > 0 )
{
nErrBuf += nLen;
nNextTOut = 0;
}
}
nTimeOut = nNextTOut;
}
if( hStdin != FS_ERROR )
hb_fsClose( hStdin );
if( hStdout != FS_ERROR )
hb_fsClose( hStdout );
if( hStderr != FS_ERROR )
hb_fsClose( hStderr );
iResult = hb_fsProcessValue( hProcess, HB_TRUE );
#elif defined( HB_OS_UNIX ) && ! defined( HB_OS_SYMBIAN )
if( nStdInLen == 0 && hStdin != FS_ERROR )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
}
if( hStdout == hStderr )
hStderr = FS_ERROR;
if( hStdin != FS_ERROR )
hb_fsPipeUnblock( hStdin );
if( hStdout != FS_ERROR )
hb_fsPipeUnblock( hStdout );
if( hStderr != FS_ERROR )
hb_fsPipeUnblock( hStderr );
for( ;; )
{
HB_BOOL fStdout, fStderr, fStdin;
HB_SIZE nLen;
#if defined( HB_HAS_POLL )
{
struct pollfd fds[ 3 ];
nfds_t nfds = 0;
if( hStdout != FS_ERROR )
{
fds[ nfds ].fd = hStdout;
fds[ nfds ].events = POLLIN;
fds[ nfds++ ].revents = 0;
}
if( hStderr != FS_ERROR )
{
fds[ nfds ].fd = hStderr;
fds[ nfds ].events = POLLIN;
fds[ nfds++ ].revents = 0;
}
if( hStdin != FS_ERROR )
{
fds[ nfds ].fd = hStdin;
fds[ nfds ].events = POLLOUT;
fds[ nfds++ ].revents = 0;
}
if( nfds == 0 )
break;
iResult = poll( fds, nfds, -1 );
hb_fsSetIOError( iResult >= 0, 0 );
if( iResult == -1 && hb_fsOsError() == ( HB_ERRCODE ) EINTR &&
hb_vmRequestQuery() == 0 )
continue;
else if( iResult <= 0 )
break;
nfds = 0;
fStdout = fStderr = fStdin = HB_FALSE;
if( hStdout != FS_ERROR )
{
if( ( fds[ nfds ].revents & POLLIN ) != 0 )
fStdout = HB_TRUE;
else if( ( fds[ nfds ].revents & ( POLLHUP | POLLNVAL | POLLERR ) ) != 0 )
{
hb_fsClose( hStdout );
hStdout = FS_ERROR;
}
nfds++;
}
if( hStderr != FS_ERROR )
{
if( ( fds[ nfds ].revents & POLLIN ) != 0 )
fStderr = HB_TRUE;
else if( ( fds[ nfds ].revents & ( POLLHUP | POLLNVAL | POLLERR ) ) != 0 )
{
hb_fsClose( hStderr );
hStderr = FS_ERROR;
}
nfds++;
}
if( hStdin != FS_ERROR )
{
if( ( fds[ nfds ].revents & POLLOUT ) != 0 )
fStdin = HB_TRUE;
else if( ( fds[ nfds ].revents & ( POLLHUP | POLLNVAL | POLLERR ) ) != 0 )
{
hb_fsClose( hStdin );
hStderr = FS_ERROR;
}
}
}
#else /* ! HB_HAS_POLL */
{
fd_set rfds, wfds, *prfds, *pwfds;
HB_FHANDLE fdMax;
fdMax = 0;
prfds = pwfds = NULL;
if( hStdout != FS_ERROR || hStderr != FS_ERROR )
{
FD_ZERO( &rfds );
if( hStdout != FS_ERROR )
{
FD_SET( hStdout, &rfds );
if( hStdout > fdMax )
fdMax = hStdout;
}
if( hStderr != FS_ERROR )
{
FD_SET( hStderr, &rfds );
if( hStderr > fdMax )
fdMax = hStderr;
}
prfds = &rfds;
}
if( hStdin != FS_ERROR )
{
FD_ZERO( &wfds );
FD_SET( hStdin, &wfds );
if( hStdin > fdMax )
fdMax = hStdin;
pwfds = &wfds;
}
if( prfds == NULL && pwfds == NULL )
break;
iResult = select( fdMax + 1, prfds, pwfds, NULL, NULL );
hb_fsSetIOError( iResult >= 0, 0 );
if( iResult == -1 && hb_fsOsError() != ( HB_ERRCODE ) EINTR &&
hb_vmRequestQuery() == 0 )
continue;
else if( iResult <= 0 )
break;
fStdout = hStdout != FS_ERROR && FD_ISSET( hStdout, &rfds );
fStderr = hStderr != FS_ERROR && FD_ISSET( hStderr, &rfds );
fStdin = hStdin != FS_ERROR && FD_ISSET( hStdin, &wfds );
}
#endif /* ! HB_HAS_POLL */
if( fStdout )
{
if( nOutBuf == nOutSize )
{
if( nOutSize == 0 )
nOutSize = HB_STD_BUFFER_SIZE;
else
nOutSize += nOutSize >> 1;
pOutBuf = ( char * ) hb_xrealloc( pOutBuf, nOutSize + 1 );
}
nLen = hb_fsReadLarge( hStdout, pOutBuf + nOutBuf, nOutSize - nOutBuf );
if( nLen == 0 )
{
/* zero bytes read after positive Select()
* - writing process closed the pipe
*/
hb_fsClose( hStdout );
hStdout = FS_ERROR;
}
else
nOutBuf += nLen;
}
if( fStderr )
{
if( nErrBuf == nErrSize )
{
if( nErrSize == 0 )
nErrSize = HB_STD_BUFFER_SIZE;
else
nErrSize += nErrSize >> 1;
pErrBuf = ( char * ) hb_xrealloc( pErrBuf, nErrSize + 1 );
}
nLen = hb_fsReadLarge( hStderr, pErrBuf + nErrBuf, nErrSize - nErrBuf );
if( nLen == 0 )
{
/* zero bytes read after positive Select()
* - writing process closed the pipe
*/
hb_fsClose( hStderr );
hStderr = FS_ERROR;
}
else
nErrBuf += nLen;
}
if( fStdin )
{
nLen = hb_fsWriteLarge( hStdin, pStdInBuf, nStdInLen );
pStdInBuf += nLen;
nStdInLen -= nLen;
if( nStdInLen == 0 )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
}
}
}
if( hStdin != FS_ERROR )
hb_fsClose( hStdin );
if( hStdout != FS_ERROR )
hb_fsClose( hStdout );
if( hStderr != FS_ERROR )
hb_fsClose( hStderr );
iResult = hb_fsProcessValue( hProcess, HB_TRUE );
#else
int iTODO;
HB_SYMBOL_UNUSED( nStdInLen );
HB_SYMBOL_UNUSED( nOutSize );
HB_SYMBOL_UNUSED( nErrSize );
#endif
}
hb_vmLock();
}
static HB_BOOL hb_copyfile( const char * szSource, const char * szDest )
{
HB_BOOL bRetVal = HB_FALSE;
HB_FHANDLE fhndSource;
PHB_ITEM pError = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_copyfile(%s, %s)", szSource, szDest ) );
do
{
fhndSource = hb_fsExtOpen( szSource, NULL,
FO_READ | FXO_DEFAULTS | FXO_SHARELOCK,
NULL, pError );
if( fhndSource == FS_ERROR )
{
pError = hb_errRT_FileError( pError, NULL, EG_OPEN, 2012, szSource );
if( hb_errLaunch( pError ) != E_RETRY )
break;
}
}
while( fhndSource == FS_ERROR );
if( fhndSource != FS_ERROR )
{
HB_FHANDLE fhndDest;
do
{
fhndDest = hb_fsExtOpen( szDest, NULL,
FXO_TRUNCATE | FO_READWRITE | FO_EXCLUSIVE |
FXO_DEFAULTS | FXO_SHARELOCK,
NULL, pError );
if( fhndDest == FS_ERROR )
{
pError = hb_errRT_FileError( pError, NULL, EG_CREATE, 2012, szDest );
if( hb_errLaunch( pError ) != E_RETRY )
break;
}
}
while( fhndDest == FS_ERROR );
if( fhndDest != FS_ERROR )
{
#if defined( HB_OS_UNIX )
struct stat struFileInfo;
int iSuccess = fstat( fhndSource, &struFileInfo );
#endif
void * buffer;
HB_USHORT usRead;
buffer = hb_xgrab( BUFFER_SIZE );
bRetVal = HB_TRUE;
while( ( usRead = hb_fsRead( fhndSource, buffer, BUFFER_SIZE ) ) != 0 )
{
while( hb_fsWrite( fhndDest, buffer, usRead ) != usRead )
{
pError = hb_errRT_FileError( pError, NULL, EG_WRITE, 2016, szDest );
if( hb_errLaunch( pError ) != E_RETRY )
{
bRetVal = HB_FALSE;
break;
}
}
}
hb_xfree( buffer );
#if defined( HB_OS_UNIX )
if( iSuccess == 0 )
fchmod( fhndDest, struFileInfo.st_mode );
#endif
hb_fsClose( fhndDest );
}
hb_fsClose( fhndSource );
}
if( pError )
hb_itemRelease( pError );
return bRetVal;
}
static PHB_FILE s_fileExtOpen( PHB_FILE_FUNCS pFuncs, const char * pszFileName, const char * pDefExt,
HB_FATTR nExFlags, const char * pPaths,
PHB_ITEM pError )
{
PHB_FILE pFile = NULL;
#if defined( HB_OS_UNIX )
HB_BOOL fSeek = HB_FALSE;
# if defined( HB_USE_LARGEFILE64 )
struct stat64 statbuf;
# else
struct stat statbuf;
# endif
#endif
HB_BOOL fResult, fShared;
int iMode;
HB_FHANDLE hFile;
char * pszFile;
HB_SYMBOL_UNUSED( pFuncs );
fShared = ( nExFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE ) ) == 0;
iMode = ( int ) ( nExFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) );
pszFile = hb_fsExtName( pszFileName, pDefExt, nExFlags, pPaths );
hb_vmUnlock();
#if ! defined( HB_OS_UNIX )
fResult = HB_TRUE;
#else
# if defined( HB_USE_SHARELOCKS ) && ! defined( HB_USE_BSDLOCKS )
if( nExFlags & FXO_SHARELOCK )
{
if( iMode == FO_WRITE && fShared )
{
if( access( ( char * ) pszFile, R_OK ) == 0 ||
access( ( char * ) pszFile, F_OK ) != 0 )
{
nExFlags = ( nExFlags ^ FO_WRITE ) | FO_READWRITE;
iMode = FO_READWRITE;
}
else
nExFlags ^= FXO_SHARELOCK;
}
else if( iMode == FO_READ && ! fShared )
{
nExFlags &= ~ ( HB_FATTR ) ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE );
fShared = HB_TRUE;
}
}
# endif
hb_threadEnterCriticalSection( &s_fileMtx );
# if defined( HB_USE_LARGEFILE64 )
fResult = stat64( ( char * ) pszFile, &statbuf ) == 0;
# else
fResult = stat( ( char * ) pszFile, &statbuf ) == 0;
# endif
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
pFile = hb_fileFind( ( HB_ULONG ) statbuf.st_dev,
( HB_ULONG ) statbuf.st_ino );
if( pFile )
{
if( ! fShared || ! pFile->shared || ( nExFlags & FXO_TRUNCATE ) != 0 )
{
fResult = HB_FALSE;
pFile = NULL;
}
else if( pFile->mode != FO_READWRITE && pFile->mode != iMode )
{
iMode = FO_READWRITE;
pFile = NULL;
}
else
{
pFile->used++;
if( ( nExFlags & FXO_NOSEEKPOS ) == 0 )
{
# if defined( HB_OS_VXWORKS )
fSeek = ! S_ISFIFO( statbuf.st_mode );
# else
fSeek = ! S_ISFIFO( statbuf.st_mode ) && ! S_ISSOCK( statbuf.st_mode );
# endif
}
}
}
}
else
fResult = HB_TRUE;
if( fResult && pFile == NULL )
#endif /* HB_OS_UNIX */
{
hFile = hb_fsExtOpen( pszFile, NULL,
nExFlags & ~ ( HB_FATTR ) ( FXO_DEFAULTS | FXO_COPYNAME ),
NULL, NULL );
if( hFile != FS_ERROR )
{
HB_ULONG device = 0, inode = 0;
#if ! defined( HB_OS_UNIX )
hb_threadEnterCriticalSection( &s_fileMtx );
#else
# if defined( HB_USE_LARGEFILE64 )
if( fstat64( hFile, &statbuf ) == 0 )
# else
if( fstat( hFile, &statbuf ) == 0 )
# endif
{
device = ( HB_ULONG ) statbuf.st_dev;
inode = ( HB_ULONG ) statbuf.st_ino;
if( ( nExFlags & FXO_NOSEEKPOS ) == 0 )
{
# if defined( HB_OS_VXWORKS )
fSeek = ! S_ISFIFO( statbuf.st_mode );
# else
fSeek = ! S_ISFIFO( statbuf.st_mode ) && ! S_ISSOCK( statbuf.st_mode );
# endif
}
}
#endif /* HB_OS_UNIX */
pFile = hb_fileNew( hFile, fShared, iMode, device, inode, HB_TRUE );
if( pFile->hFile != hFile )
{
if( pFile->mode != FO_READWRITE && iMode == FO_READWRITE )
{
HB_FHANDLE hTemp = pFile->hFileRO;
pFile->hFileRO = pFile->hFile;
pFile->hFile = hFile;
pFile->mode = iMode;
hFile = hTemp;
}
if( ! fShared || ! pFile->shared || pFile->mode != FO_READWRITE )
{
fResult = HB_FALSE;
if( pFile->hFileRO == FS_ERROR && pFile->uiLocks != 0 )
{
pFile->hFileRO = hFile;
hFile = FS_ERROR;
}
}
if( pFile->uiLocks == 0 )
{
#if ! defined( HB_USE_SHARELOCKS ) || defined( HB_USE_BSDLOCKS )
if( pFile->hFileRO != FS_ERROR )
{
hb_fsClose( pFile->hFileRO );
pFile->hFileRO = FS_ERROR;
}
#endif
if( hFile != FS_ERROR )
{
hb_fsClose( hFile );
hFile = FS_ERROR;
#if defined( HB_USE_SHARELOCKS ) && ! defined( HB_USE_BSDLOCKS )
/* TOFIX: possible race condition */
hb_fsLockLarge( pFile->hFile, HB_SHARELOCK_POS, HB_SHARELOCK_SIZE,
FL_LOCK | FLX_SHARED );
#endif
}
}
if( !fResult )
{
if( pFile )
{
--pFile->used;
pFile = NULL;
}
if( hFile != FS_ERROR )
{
/* TOFIX: possible race condition in MT mode,
* close() is not safe due to existing locks
* which are removed.
*/
hb_fsClose( hFile );
}
}
}
#if ! defined( HB_OS_UNIX )
hb_threadLeaveCriticalSection( &s_fileMtx );
#endif
}
}
#if defined( HB_OS_UNIX )
hb_threadLeaveCriticalSection( &s_fileMtx );
if( pFile && fSeek )
pFile = hb_fileposNew( pFile );
#endif
if( ! fResult )
hb_fsSetError( ( nExFlags & FXO_TRUNCATE ) ? 5 : 32 );
if( ( nExFlags & FXO_COPYNAME ) != 0 && pFile )
hb_strncpy( ( char * ) HB_UNCONST( pszFileName ), pszFile, HB_PATH_MAX - 1 );
if( pError )
{
hb_errPutFileName( pError, pszFile );
if( ! fResult )
{
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutGenCode( pError, ( HB_ERRCODE ) ( ( nExFlags & FXO_TRUNCATE ) ? EG_CREATE : EG_OPEN ) );
}
}
hb_xfree( pszFile );
hb_vmLock();
return pFile;
}
static PHB_FILE s_fileExtOpen( PHB_FILE_FUNCS pFuncs, const char * pszFileName, const char * pDefExt,
HB_USHORT uiExFlags, const char * pPaths,
PHB_ITEM pError )
{
PHB_FILE pFile = NULL;
#if defined( HB_OS_UNIX )
HB_BOOL fResult, fSeek = HB_FALSE;
# if defined( HB_USE_LARGEFILE64 )
struct stat64 statbuf;
# else
struct stat statbuf;
# endif
#endif
HB_BOOL fShared, fReadonly;
HB_FHANDLE hFile;
char * pszFile;
HB_SYMBOL_UNUSED( pFuncs );
fShared = ( uiExFlags & ( FO_DENYREAD | FO_DENYWRITE | FO_EXCLUSIVE ) ) == 0;
fReadonly = ( uiExFlags & ( FO_READ | FO_WRITE | FO_READWRITE ) ) == FO_READ;
pszFile = hb_fsExtName( pszFileName, pDefExt, uiExFlags, pPaths );
hb_vmUnlock();
#if defined( HB_OS_UNIX )
# if defined( HB_USE_LARGEFILE64 )
fResult = stat64( ( char * ) pszFile, &statbuf ) == 0;
# else
fResult = stat( ( char * ) pszFile, &statbuf ) == 0;
# endif
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
hb_threadEnterCriticalSection( &s_fileMtx );
pFile = hb_fileFind( statbuf.st_dev, statbuf.st_ino );
if( pFile )
{
if( ! fShared || ! pFile->shared || ( uiExFlags & FXO_TRUNCATE ) != 0 )
fResult = HB_FALSE;
else if( ! fReadonly && pFile->readonly )
pFile = NULL;
else
pFile->used++;
if( ( uiExFlags & FXO_NOSEEKPOS ) == 0 )
{
# if defined( HB_OS_VXWORKS )
fSeek = ! S_ISFIFO( statbuf.st_mode );
# else
fSeek = ! S_ISFIFO( statbuf.st_mode ) && ! S_ISSOCK( statbuf.st_mode );
# endif
}
}
hb_threadLeaveCriticalSection( &s_fileMtx );
}
if( pFile )
{
if( ! fResult )
{
hb_fsSetError( ( uiExFlags & FXO_TRUNCATE ) ? 5 : 32 );
pFile = NULL;
}
else if( uiExFlags & FXO_COPYNAME )
hb_strncpy( ( char * ) pszFileName, pszFile, HB_PATH_MAX - 1 );
if( pError )
{
hb_errPutFileName( pError, pszFile );
if( ! fResult )
{
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutGenCode( pError, ( HB_ERRCODE ) ( ( uiExFlags & FXO_TRUNCATE ) ? EG_CREATE : EG_OPEN ) );
}
}
}
else
#endif
{
hFile = hb_fsExtOpen( pszFileName, pDefExt, uiExFlags, pPaths, pError );
if( hFile != FS_ERROR )
{
HB_ULONG device = 0, inode = 0;
#if defined( HB_OS_UNIX )
# if defined( HB_USE_LARGEFILE64 )
if( fstat64( hFile, &statbuf ) == 0 )
# else
if( fstat( hFile, &statbuf ) == 0 )
# endif
{
device = ( HB_ULONG ) statbuf.st_dev;
inode = ( HB_ULONG ) statbuf.st_ino;
if( ( uiExFlags & FXO_NOSEEKPOS ) == 0 )
{
# if defined( HB_OS_VXWORKS )
fSeek = ! S_ISFIFO( statbuf.st_mode );
# else
fSeek = ! S_ISFIFO( statbuf.st_mode ) && ! S_ISSOCK( statbuf.st_mode );
# endif
}
}
#endif
hb_threadEnterCriticalSection( &s_fileMtx );
pFile = hb_fileNew( hFile, fShared, fReadonly, device, inode, HB_TRUE );
if( pFile->hFile != hFile )
{
if( pFile->hFileRO == FS_ERROR && ! fReadonly && pFile->readonly )
{
pFile->hFileRO = pFile->hFile;
pFile->hFile = hFile;
pFile->readonly = HB_FALSE;
hFile = FS_ERROR;
}
if( pFile->uiLocks == 0 )
{
#if ! defined( HB_USE_SHARELOCKS ) || defined( HB_USE_BSDLOCKS )
if( pFile->hFileRO != FS_ERROR )
{
hb_fsClose( pFile->hFileRO );
pFile->hFileRO = FS_ERROR;
}
#endif
if( hFile != FS_ERROR )
{
hb_fsClose( hFile );
hFile = FS_ERROR;
#if defined( HB_USE_SHARELOCKS ) && ! defined( HB_USE_BSDLOCKS )
/* TOFIX: possible race condition */
hb_fsLockLarge( hFile, HB_SHARELOCK_POS, HB_SHARELOCK_SIZE,
FL_LOCK | FLX_SHARED );
#endif
}
}
}
else
hFile = FS_ERROR;
hb_threadLeaveCriticalSection( &s_fileMtx );
if( hFile != FS_ERROR )
{
/* TOFIX: possible race condition in MT mode,
* close() is not safe due to existing locks
* which are removed.
*/
hb_fsClose( hFile );
}
}
}
hb_xfree( pszFile );
#if defined( HB_OS_UNIX )
if( pFile && fSeek )
pFile = hb_fileposNew( pFile );
#endif
hb_vmLock();
return pFile;
}
HB_BOOL hb_printerIsReady( const char * pszPrinterName )
{
HB_BOOL bIsPrinter;
#if defined( HB_OS_DOS )
/* NOTE: MS-DOS specific solution, using BIOS interrupt */
{
int iPort;
if( pszPrinterName == NULL )
pszPrinterName = "LPT1";
if( hb_strnicmp( pszPrinterName, "PRN", 3 ) == 0 )
{
union REGS regs;
regs.h.ah = 2;
regs.HB_XREGS.dx = 0; /* LPT1 */
HB_DOS_INT86( 0x17, ®s, ®s );
bIsPrinter = ( regs.h.ah == 0x90 );
}
else if( strlen( pszPrinterName ) >= 4 &&
hb_strnicmp( pszPrinterName, "LPT", 3 ) == 0 &&
( iPort = atoi( pszPrinterName + 3 ) ) > 0 )
{
union REGS regs;
regs.h.ah = 2;
regs.HB_XREGS.dx = iPort - 1;
HB_DOS_INT86( 0x17, ®s, ®s );
bIsPrinter = ( regs.h.ah == 0x90 );
}
else
bIsPrinter = HB_FALSE;
}
#else
/* NOTE: Platform independent method, at least it will compile and run
on any platform, but the result may not be the expected one,
since Unix/Linux doesn't support LPT/COM by nature, other OSs
may not reflect the actual physical presence of the printer when
trying to open it, since we are talking to the spooler.
[vszakats] */
{
HB_FHANDLE fhnd;
if( pszPrinterName == NULL )
#if defined( HB_OS_UNIX )
pszPrinterName = "/dev/lp0";
#else
pszPrinterName = "LPT1";
#endif
fhnd = hb_fsOpen( pszPrinterName, FO_WRITE | FO_SHARED | FO_PRIVATE );
bIsPrinter = ( fhnd != FS_ERROR );
hb_fsClose( fhnd );
}
#endif
return bIsPrinter;
}
static int hb_zipStoreFile( zipFile hZip, const char * szFileName, const char * szName, const char * szPassword, const char * szComment )
{
char * szZipName, * pString;
HB_FHANDLE hFile;
HB_SIZE nLen;
HB_FATTR ulExtAttr;
zip_fileinfo zfi;
int iResult;
HB_BOOL fError;
HB_BOOL fText;
HB_U32 ulCRC;
if( szName )
{
/* change path separators to '/' */
szZipName = hb_strdup( szName );
nLen = strlen( szZipName );
pString = szZipName;
while( nLen-- )
{
if( pString[ nLen ] == '\\' )
pString[ nLen ] = '/';
}
}
else
{
/* get file name */
szZipName = hb_strdup( szFileName );
nLen = strlen( szZipName );
pString = szZipName;
while( nLen-- )
{
if( pString[ nLen ] == '/' || pString[ nLen ] == '\\' )
{
memmove( szZipName, &pString[ nLen + 1 ], strlen( szZipName ) - nLen );
break;
}
}
}
memset( &zfi, 0, sizeof( zfi ) );
fError = HB_FALSE;
ulExtAttr = 0;
#if defined( HB_OS_WIN )
{
LPTSTR lpFileNameFree;
LPCTSTR lpFileName = HB_FSNAMECONV( szFileName, &lpFileNameFree );
DWORD attr = GetFileAttributes( lpFileName );
if( attr != INVALID_FILE_ATTRIBUTES )
{
ulExtAttr = hb_translateExtAttr( szFileName, attr &
( FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN |
FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY |
FILE_ATTRIBUTE_ARCHIVE ) );
}
else
fError = HB_TRUE;
if( lpFileNameFree )
hb_xfree( lpFileNameFree );
}
#elif defined( HB_OS_UNIX )
{
struct stat statbuf;
struct tm st;
char * pszFree;
if( stat( hb_fsNameConv( szFileName, &pszFree ), &statbuf ) == 0 )
{
if( S_ISDIR( statbuf.st_mode ) )
{
ulExtAttr |= 0x40000000;
ulExtAttr |= 0x10; /* FILE_ATTRIBUTE_DIRECTORY */
}
else
{
ulExtAttr |= 0x80000000;
ulExtAttr |= 0x20; /* FILE_ATTRIBUTE_ARCHIVE */
}
ulExtAttr |= ( ( statbuf.st_mode & S_IXOTH ) ? 0x00010000 : 0 ) |
( ( statbuf.st_mode & S_IWOTH ) ? 0x00020000 : 0 ) |
( ( statbuf.st_mode & S_IROTH ) ? 0x00040000 : 0 ) |
( ( statbuf.st_mode & S_IXGRP ) ? 0x00080000 : 0 ) |
( ( statbuf.st_mode & S_IWGRP ) ? 0x00100000 : 0 ) |
( ( statbuf.st_mode & S_IRGRP ) ? 0x00200000 : 0 ) |
( ( statbuf.st_mode & S_IXUSR ) ? 0x00400000 : 0 ) |
( ( statbuf.st_mode & S_IWUSR ) ? 0x00800000 : 0 ) |
( ( statbuf.st_mode & S_IRUSR ) ? 0x01000000 : 0 );
# if defined( HB_HAS_LOCALTIME_R )
localtime_r( &statbuf.st_mtime, &st );
# else
st = *localtime( &statbuf.st_mtime );
# endif
zfi.tmz_date.tm_sec = st.tm_sec;
zfi.tmz_date.tm_min = st.tm_min;
zfi.tmz_date.tm_hour = st.tm_hour;
zfi.tmz_date.tm_mday = st.tm_mday;
zfi.tmz_date.tm_mon = st.tm_mon;
zfi.tmz_date.tm_year = st.tm_year;
}
else
fError = HB_TRUE;
if( pszFree )
hb_xfree( pszFree );
}
#elif defined( HB_OS_DOS )
{
# if defined( __DJGPP__ ) || defined( __RSX32__ ) || defined( __GNUC__ )
int attr;
char * pszFree;
attr = _chmod( hb_fsNameConv( szFileName, &pszFree ), 0, 0 );
if( pszFree )
hb_xfree( pszFree );
if( attr != -1 )
# else
HB_FATTR attr;
if( hb_fsGetAttr( szFileName, &attr ) )
# endif
{
ulExtAttr = attr & ( HB_FA_READONLY | HB_FA_HIDDEN | HB_FA_SYSTEM |
HB_FA_DIRECTORY | HB_FA_ARCHIVE );
ulExtAttr = hb_translateExtAttr( szFileName, ulExtAttr );
}
else
fError = HB_TRUE;
}
#elif defined( HB_OS_OS2 )
{
FILESTATUS3 fs3;
APIRET ulrc;
HB_FATTR ulAttr;
char * pszFree;
ulrc = DosQueryPathInfo( ( PCSZ ) hb_fsNameConv( szFileName, &pszFree ), FIL_STANDARD, &fs3, sizeof( fs3 ) );
if( pszFree )
hb_xfree( pszFree );
if( ulrc == NO_ERROR )
{
ulAttr = 0;
if( fs3.attrFile & FILE_READONLY )
ulAttr |= HB_FA_READONLY;
if( fs3.attrFile & FILE_HIDDEN )
ulAttr |= HB_FA_HIDDEN;
if( fs3.attrFile & FILE_SYSTEM )
ulAttr |= HB_FA_SYSTEM;
if( fs3.attrFile & FILE_DIRECTORY )
ulAttr |= HB_FA_DIRECTORY;
if( fs3.attrFile & FILE_ARCHIVED )
ulAttr |= HB_FA_ARCHIVE;
ulExtAttr = hb_translateExtAttr( szFileName, ulAttr );
zfi.tmz_date.tm_sec = fs3.ftimeLastWrite.twosecs * 2;
zfi.tmz_date.tm_min = fs3.ftimeLastWrite.minutes;
zfi.tmz_date.tm_hour = fs3.ftimeLastWrite.hours;
zfi.tmz_date.tm_mday = fs3.fdateLastWrite.day;
zfi.tmz_date.tm_mon = fs3.fdateLastWrite.month;
zfi.tmz_date.tm_year = fs3.fdateLastWrite.year + 1980;
}
else
fError = HB_TRUE;
}
#else
{
HB_FATTR attr;
if( ! hb_fsGetAttr( szFileName, &attr ) )
ulExtAttr = 0x81B60020; /* FILE_ATTRIBUTE_ARCHIVE | rw-rw-rw- */
else
{
ulExtAttr = attr & ( HB_FA_READONLY | HB_FA_HIDDEN | HB_FA_SYSTEM |
HB_FA_DIRECTORY | HB_FA_ARCHIVE );
ulExtAttr = hb_translateExtAttr( szFileName, ulExtAttr );
}
}
#endif
if( fError )
{
hb_xfree( szZipName );
return -200;
}
fText = HB_FALSE;
ulCRC = 0;
zfi.external_fa = ulExtAttr;
/* TODO: zip.exe test: 0 for binary file, 1 for text. Does not depend on
extension. We should analyse content of file to determine this??? */
zfi.internal_fa = 0;
if( ulExtAttr & 0x40000000 )
{
iResult = zipOpenNewFileInZip3( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC );
if( iResult == 0 )
zipCloseFileInZip( hZip );
}
else
{
hFile = hb_fsOpen( szFileName, FO_READ );
if( hFile != FS_ERROR )
{
#if defined( HB_OS_WIN )
{
FILETIME ftutc, ft;
SYSTEMTIME st;
if( GetFileTime( ( HANDLE ) hb_fsGetOsHandle( hFile ), NULL, NULL, &ftutc ) &&
FileTimeToLocalFileTime( &ftutc, &ft ) &&
FileTimeToSystemTime( &ft, &st ) )
{
zfi.tmz_date.tm_sec = st.wSecond;
zfi.tmz_date.tm_min = st.wMinute;
zfi.tmz_date.tm_hour = st.wHour;
zfi.tmz_date.tm_mday = st.wDay;
zfi.tmz_date.tm_mon = st.wMonth - 1;
zfi.tmz_date.tm_year = st.wYear;
}
}
#endif
if( szPassword )
{
if( hb_zipGetFileInfo( szFileName, &ulCRC, &fText ) )
zfi.internal_fa = fText ? 1 : 0;
}
iResult = zipOpenNewFileInZip3( hZip, szZipName, &zfi, NULL, 0, NULL, 0, szComment,
Z_DEFLATED, Z_DEFAULT_COMPRESSION, 0,
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
szPassword, ulCRC );
if( iResult == 0 )
{
pString = ( char * ) hb_xgrab( HB_Z_IOBUF_SIZE );
while( ( nLen = hb_fsReadLarge( hFile, pString, HB_Z_IOBUF_SIZE ) ) > 0 )
zipWriteInFileInZip( hZip, pString, ( unsigned ) nLen );
hb_xfree( pString );
zipCloseFileInZip( hZip );
}
hb_fsClose( hFile );
}
else
iResult = -200 - hb_fsError();
}
hb_xfree( szZipName );
return iResult;
}
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;
}
static int hb_unzipExtractCurrentFile( unzFile hUnzip, const char * szFileName, const char * szPassword )
{
char szName[ HB_PATH_MAX ];
HB_SIZE nPos, nLen;
char cSep, * pString;
unz_file_info ufi;
int iResult;
HB_FHANDLE hFile;
iResult = unzGetCurrentFileInfo( hUnzip, &ufi, szName, HB_PATH_MAX - 1,
NULL, 0, NULL, 0 );
if( iResult != UNZ_OK )
return iResult;
iResult = unzOpenCurrentFilePassword( hUnzip, szPassword );
if( iResult != UNZ_OK )
return iResult;
if( szFileName )
hb_strncpy( szName, szFileName, sizeof( szName ) - 1 );
nLen = strlen( szName );
/* Test shows that files in subfolders can be stored to zip file without
explicitly adding folder. So, let's create a required path */
nPos = 1;
while( nPos < nLen )
{
cSep = szName[ nPos ];
/* allow both path separators, ignore terminating path separator */
if( ( cSep == '\\' || cSep == '/' ) && nPos < nLen - 1 )
{
szName[ nPos ] = '\0';
hb_fsMkDir( szName );
szName[ nPos ] = cSep;
}
nPos++;
}
if( ufi.external_fa & 0x40000000 ) /* DIRECTORY */
{
hb_fsMkDir( szName );
iResult = UNZ_OK;
}
else
{
hFile = hb_fsCreate( szName, FC_NORMAL );
if( hFile != FS_ERROR )
{
pString = ( char * ) hb_xgrab( HB_Z_IOBUF_SIZE );
while( ( iResult = unzReadCurrentFile( hUnzip, pString, HB_Z_IOBUF_SIZE ) ) > 0 )
hb_fsWriteLarge( hFile, pString, ( HB_SIZE ) iResult );
hb_xfree( pString );
#if defined( HB_OS_WIN )
{
FILETIME ftutc, ft;
SYSTEMTIME st;
st.wSecond = ( WORD ) ufi.tmu_date.tm_sec;
st.wMinute = ( WORD ) ufi.tmu_date.tm_min;
st.wHour = ( WORD ) ufi.tmu_date.tm_hour;
st.wDay = ( WORD ) ufi.tmu_date.tm_mday;
st.wMonth = ( WORD ) ufi.tmu_date.tm_mon + 1;
st.wYear = ( WORD ) ufi.tmu_date.tm_year;
st.wMilliseconds = 0;
if( SystemTimeToFileTime( &st, &ft ) &&
LocalFileTimeToFileTime( &ft, &ftutc ) )
{
SetFileTime( ( HANDLE ) hb_fsGetOsHandle( hFile ), &ftutc, &ftutc, &ftutc );
}
}
#endif
hb_fsClose( hFile );
}
else
iResult = -200 - hb_fsError();
}
unzCloseCurrentFile( hUnzip );
#if defined( HB_OS_WIN )
{
LPTSTR lpFileNameFree;
LPCTSTR lpFileName = HB_FSNAMECONV( szName, &lpFileNameFree );
SetFileAttributes( ( LPCTSTR ) lpFileName, ufi.external_fa & 0xFF );
if( lpFileNameFree )
hb_xfree( lpFileNameFree );
}
#elif defined( HB_OS_UNIX ) || defined( __DJGPP__ )
{
struct utimbuf utim;
struct tm st;
time_t tim;
char * pszFree;
const char * szNameOS = hb_fsNameConv( szName, &pszFree );
# if defined( __DJGPP__ )
_chmod( szNameOS, 1, ufi.external_fa & 0xFF );
# else
HB_FATTR ulAttr = ufi.external_fa;
if( ( ulAttr & 0xFFFF0000 ) == 0 )
ulAttr = hb_translateExtAttr( szName, ulAttr );
chmod( szNameOS,
( ( ulAttr & 0x00010000 ) ? S_IXOTH : 0 ) |
( ( ulAttr & 0x00020000 ) ? S_IWOTH : 0 ) |
( ( ulAttr & 0x00040000 ) ? S_IROTH : 0 ) |
( ( ulAttr & 0x00080000 ) ? S_IXGRP : 0 ) |
( ( ulAttr & 0x00100000 ) ? S_IWGRP : 0 ) |
( ( ulAttr & 0x00200000 ) ? S_IRGRP : 0 ) |
( ( ulAttr & 0x00400000 ) ? S_IXUSR : 0 ) |
( ( ulAttr & 0x00800000 ) ? S_IWUSR : 0 ) |
( ( ulAttr & 0x01000000 ) ? S_IRUSR : 0 ) );
# endif
memset( &st, 0, sizeof( st ) );
st.tm_sec = ufi.tmu_date.tm_sec;
st.tm_min = ufi.tmu_date.tm_min;
st.tm_hour = ufi.tmu_date.tm_hour;
st.tm_mday = ufi.tmu_date.tm_mday;
st.tm_mon = ufi.tmu_date.tm_mon;
st.tm_year = ufi.tmu_date.tm_year - 1900;
tim = mktime( &st );
# if defined( HB_HAS_LOCALTIME_R )
gmtime_r( &tim, &st );
# else
st = *gmtime( &tim );
# endif
utim.actime = utim.modtime = mktime( &st );
utime( szNameOS, &utim );
if( pszFree )
hb_xfree( pszFree );
}
#elif defined( HB_OS_DOS )
{
# if defined( __RSX32__ ) || defined( __GNUC__ )
char * pszFree;
_chmod( hb_fsNameConv( szName, &pszFree ), 1, ufi.external_fa & 0xFF );
if( pszFree )
hb_xfree( pszFree );
# else
hb_fsSetAttr( szName, ufi.external_fa & 0xFF );
# endif
}
#elif defined( HB_OS_OS2 )
{
FILESTATUS3 fs3;
APIRET ulrc;
HB_FATTR ulAttr = FILE_NORMAL;
int iAttr = ufi.external_fa & 0xFF;
char * pszFree;
const char * szNameOS = hb_fsNameConv( szName, &pszFree );
if( iAttr & HB_FA_READONLY )
ulAttr |= FILE_READONLY;
if( iAttr & HB_FA_HIDDEN )
ulAttr |= FILE_HIDDEN;
if( iAttr & HB_FA_SYSTEM )
ulAttr |= FILE_SYSTEM;
if( iAttr & HB_FA_ARCHIVE )
ulAttr |= FILE_ARCHIVED;
ulrc = DosQueryPathInfo( ( PCSZ ) szNameOS, FIL_STANDARD, &fs3, sizeof( fs3 ) );
if( ulrc == NO_ERROR )
{
FDATE fdate;
FTIME ftime;
fdate.year = ufi.tmu_date.tm_year - 1980;
fdate.month = ufi.tmu_date.tm_mon;
fdate.day = ufi.tmu_date.tm_mday;
ftime.hours = ufi.tmu_date.tm_hour;
ftime.minutes = ufi.tmu_date.tm_min;
ftime.twosecs = ufi.tmu_date.tm_sec / 2;
fs3.attrFile = ulAttr;
fs3.fdateCreation = fs3.fdateLastAccess = fs3.fdateLastWrite = fdate;
fs3.ftimeCreation = fs3.ftimeLastAccess = fs3.ftimeLastWrite = ftime;
ulrc = DosSetPathInfo( ( PCSZ ) szNameOS, FIL_STANDARD,
&fs3, sizeof( fs3 ), DSPI_WRTTHRU );
}
if( pszFree )
hb_xfree( pszFree );
}
#else
{
hb_fsSetAttr( szName, ufi.external_fa );
}
#endif
return iResult;
}
HB_FHANDLE hb_fsProcessOpen( const char * pszFilename,
HB_FHANDLE * phStdin, HB_FHANDLE * phStdout,
HB_FHANDLE * phStderr,
HB_BOOL fDetach, HB_ULONG * pulPID )
{
HB_FHANDLE hPipeIn [ 2 ] = { FS_ERROR, FS_ERROR },
hPipeOut[ 2 ] = { FS_ERROR, FS_ERROR },
hPipeErr[ 2 ] = { FS_ERROR, FS_ERROR };
HB_FHANDLE hResult = FS_ERROR;
HB_BOOL fError = HB_FALSE;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessOpen(%s, %p, %p, %p, %d, %p)", pszFilename, phStdin, phStdout, phStderr, fDetach, pulPID ) );
if( phStdin != NULL )
fError = ! hb_fsPipeCreate( hPipeIn );
if( ! fError && phStdout != NULL )
fError = ! hb_fsPipeCreate( hPipeOut );
if( ! fError && phStderr != NULL )
{
if( phStdout == phStderr )
{
hPipeErr[ 0 ] = hPipeOut[ 0 ];
hPipeErr[ 1 ] = hPipeOut[ 1 ];
}
else
fError = ! hb_fsPipeCreate( hPipeErr );
}
if( ! fError )
{
#if defined( HB_OS_WIN )
PROCESS_INFORMATION pi;
STARTUPINFO si;
DWORD dwFlags = 0;
LPTSTR lpCommand = HB_CHARDUP( pszFilename );
# if ! defined( HB_OS_WIN_CE )
if( phStdin != NULL )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 1 ] ), HANDLE_FLAG_INHERIT, 0 );
if( phStdout != NULL )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 0 ] ), HANDLE_FLAG_INHERIT, 0 );
if( phStderr != NULL && phStdout != phStderr )
SetHandleInformation( ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 0 ] ), HANDLE_FLAG_INHERIT, 0 );
# endif
memset( &pi, 0, sizeof( pi ) );
memset( &si, 0, sizeof( si ) );
si.cb = sizeof( si );
# ifdef STARTF_USESTDHANDLES
si.dwFlags = STARTF_USESTDHANDLES;
# endif
if( fDetach )
{
# ifdef STARTF_USESHOWWINDOW
si.dwFlags |= STARTF_USESHOWWINDOW;
# endif
si.wShowWindow = SW_HIDE;
si.hStdInput = ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] );
si.hStdOutput = ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] );
si.hStdError = ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] );
# ifdef DETACHED_PROCESS
dwFlags |= DETACHED_PROCESS;
# endif
}
else
{
si.hStdInput = phStdin ? ( HANDLE ) hb_fsGetOsHandle( hPipeIn [ 0 ] ) : GetStdHandle( STD_INPUT_HANDLE );
si.hStdOutput = phStdout ? ( HANDLE ) hb_fsGetOsHandle( hPipeOut[ 1 ] ) : GetStdHandle( STD_OUTPUT_HANDLE );
si.hStdError = phStderr ? ( HANDLE ) hb_fsGetOsHandle( hPipeErr[ 1 ] ) : GetStdHandle( STD_ERROR_HANDLE );
}
fError = ! CreateProcess( NULL, /* lpAppName */
lpCommand,
NULL, /* lpProcessAttr */
NULL, /* lpThreadAttr */
TRUE, /* bInheritHandles */
dwFlags, /* dwCreationFlags */
NULL, /* lpEnvironment */
NULL, /* lpCurrentDirectory */
&si,
&pi );
hb_fsSetIOError( ! fError, 0 );
hb_xfree( lpCommand );
if( ! fError )
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pi.dwProcessId;
CloseHandle( pi.hThread );
hResult = ( HB_FHANDLE ) pi.hProcess;
}
#elif defined( HB_OS_UNIX ) && \
! defined( HB_OS_VXWORKS ) && ! defined( HB_OS_SYMBIAN )
pid_t pid = fork();
if( pid == -1 )
fError = HB_TRUE;
else if( pid != 0 ) /* parent process */
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
else /* child process */
{
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hNull = open( "/dev/null", O_RDWR );
if( ! phStdin )
dup2( hNull, 0 );
if( ! phStdout )
dup2( hNull, 1 );
if( ! phStderr )
dup2( hNull, 2 );
if( hNull != FS_ERROR )
hb_fsClose( hNull );
}
if( phStdin != NULL )
{
dup2( hPipeIn[ 0 ], 0 );
hb_fsClose( hPipeIn[ 1 ] );
}
if( phStdout != NULL )
{
dup2( hPipeOut[ 1 ], 1 );
hb_fsClose( hPipeOut[ 0 ] );
}
if( phStderr != NULL )
{
dup2( hPipeErr[ 1 ], 2 );
if( phStdout != phStderr )
hb_fsClose( hPipeErr[ 0 ] );
}
/* close all non std* handles */
{
int iMaxFD, i;
iMaxFD = sysconf( _SC_OPEN_MAX );
if( iMaxFD < 3 )
iMaxFD = 1024;
for( i = 3; i < iMaxFD; ++i )
hb_fsClose( i );
}
/* reset extended process attributes */
setuid( getuid() );
setgid( getgid() );
/* execute command */
{
char ** argv;
argv = hb_buildArgs( pszFilename );
# if defined( __WATCOMC__ )
execvp( argv[ 0 ], ( const char ** ) argv );
# else
execvp( argv[ 0 ], argv );
# endif
hb_freeArgs( argv );
exit( -1 );
}
}
#elif defined( HB_OS_OS2 ) || defined( HB_OS_WIN )
int hStdIn, hStdOut, hStdErr;
char ** argv;
int pid;
hStdIn = dup( 0 );
hStdOut = dup( 1 );
hStdErr = dup( 2 );
if( fDetach && ( ! phStdin || ! phStdout || ! phStderr ) )
{
HB_FHANDLE hNull = open( "NUL:", O_RDWR );
if( ! phStdin )
dup2( hNull, 0 );
if( ! phStdout )
dup2( hNull, 1 );
if( ! phStderr )
dup2( hNull, 2 );
if( hNull != FS_ERROR )
close( hNull );
}
if( phStdin != NULL )
dup2( hPipeIn[ 0 ], 0 );
if( phStdout != NULL )
dup2( hPipeOut[ 1 ], 1 );
if( phStderr != NULL )
dup2( hPipeErr[ 1 ], 2 );
argv = hb_buildArgs( pszFilename );
#if defined( _MSC_VER ) || defined( __LCC__ ) || \
defined( __XCC__ ) || defined( __POCC__ )
pid = _spawnvp( _P_NOWAIT, argv[ 0 ], argv );
#elif defined( __MINGW32__ ) || defined( __WATCOMC__ )
pid = spawnvp( P_NOWAIT, argv[ 0 ], ( const char * const * ) argv );
#else
pid = spawnvp( P_NOWAIT, argv[ 0 ], ( char * const * ) argv );
#endif
hb_freeArgs( argv );
dup2( hStdIn, 0 );
close( hStdIn );
dup2( hStdOut, 1 );
close( hStdOut );
dup2( hStdErr, 2 );
close( hStdErr );
if( pid < 0 )
fError = HB_TRUE;
else if( pid != 0 ) /* parent process */
{
if( phStdin != NULL )
{
*phStdin = ( HB_FHANDLE ) hPipeIn[ 1 ];
hPipeIn[ 1 ] = FS_ERROR;
}
if( phStdout != NULL )
{
*phStdout = ( HB_FHANDLE ) hPipeOut[ 0 ];
hPipeOut[ 0 ] = FS_ERROR;
}
if( phStderr != NULL )
{
*phStderr = ( HB_FHANDLE ) hPipeErr[ 0 ];
hPipeErr[ 0 ] = FS_ERROR;
}
if( pulPID )
*pulPID = pid;
hResult = ( HB_FHANDLE ) pid;
}
#else
int iTODO; /* TODO: for given platform */
HB_SYMBOL_UNUSED( pszFilename );
HB_SYMBOL_UNUSED( fDetach );
HB_SYMBOL_UNUSED( pulPID );
hb_fsSetError( ( HB_ERRCODE ) FS_ERROR );
#endif
}
hb_fsSetIOError( ! fError, 0 );
if( hPipeIn[ 0 ] != FS_ERROR )
hb_fsClose( hPipeIn[ 0 ] );
if( hPipeIn[ 1 ] != FS_ERROR )
hb_fsClose( hPipeIn[ 1 ] );
if( hPipeOut[ 0 ] != FS_ERROR )
hb_fsClose( hPipeOut[ 0 ] );
if( hPipeOut[ 1 ] != FS_ERROR )
hb_fsClose( hPipeOut[ 1 ] );
if( phStdout != phStderr )
{
if( hPipeErr[ 0 ] != FS_ERROR )
hb_fsClose( hPipeErr[ 0 ] );
if( hPipeErr[ 1 ] != FS_ERROR )
hb_fsClose( hPipeErr[ 1 ] );
}
return hResult;
}
int hb_fsProcessRun( const char * pszFilename,
const char * pStdInBuf, HB_SIZE nStdInLen,
char ** pStdOutPtr, HB_SIZE * pulStdOut,
char ** pStdErrPtr, HB_SIZE * pulStdErr,
HB_BOOL fDetach )
{
HB_FHANDLE hStdin, hStdout, hStderr, *phStdin, *phStdout, *phStderr;
char * pOutBuf, *pErrBuf;
HB_SIZE nOutSize, nErrSize, nOutBuf, nErrBuf;
int iResult;
HB_TRACE( HB_TR_DEBUG, ( "hb_fsProcessRun(%s, %p, %" HB_PFS "u, %p, %p, %p, %p, %d)", pStdInBuf, pStdInBuf, nStdInLen, pStdOutPtr, pulStdOut, pStdErrPtr, pulStdErr, fDetach ) );
nOutBuf = nErrBuf = nOutSize = nErrSize = 0;
pOutBuf = pErrBuf = NULL;
hStdin = hStdout = hStderr = FS_ERROR;
phStdin = pStdInBuf ? &hStdin : NULL;
phStdout = pStdOutPtr && pulStdOut ? &hStdout : NULL;
phStderr = pStdErrPtr && pulStdErr ?
( pStdOutPtr == pStdErrPtr ? phStdout : &hStderr ) : NULL;
#if defined( HB_OS_DOS ) || defined( HB_OS_OS2 ) || defined( HB_OS_WIN_CE )
{
#if defined( HB_OS_WIN_CE )
# define _HB_NULLHANDLE() FS_ERROR
#elif defined( HB_OS_UNIX )
# define _HB_NULLHANDLE() open( "/dev/null", O_RDWR )
#else
# define _HB_NULLHANDLE() open( "NUL:", O_RDWR )
#endif
char sTmpIn[ HB_PATH_MAX ];
char sTmpOut[ HB_PATH_MAX ];
char sTmpErr[ HB_PATH_MAX ];
HB_SYMBOL_UNUSED( phStdin );
HB_SYMBOL_UNUSED( nOutSize );
HB_SYMBOL_UNUSED( nErrSize );
sTmpIn[ 0 ] = sTmpOut[ 0 ] = sTmpErr[ 0 ] = '\0';
if( pStdInBuf )
{
hStdin = hb_fsCreateTempEx( sTmpIn, NULL, NULL, NULL, FC_NORMAL );
if( nStdInLen )
{
hb_fsWriteLarge( hStdin, pStdInBuf, nStdInLen );
hb_fsSeek( hStdin, 0, FS_SET );
}
}
else if( fDetach )
hStdin = _HB_NULLHANDLE();
if( pStdOutPtr && pulStdOut )
hStdout = hb_fsCreateTempEx( sTmpOut, NULL, NULL, NULL, FC_NORMAL );
else if( fDetach )
hStdout = _HB_NULLHANDLE();
if( pStdErrPtr && pulStdErr )
{
if( phStdout == phStderr )
hStderr = hStdout;
else
hStderr = hb_fsCreateTempEx( sTmpErr, NULL, NULL, NULL, FC_NORMAL );
}
else if( fDetach )
hStderr = _HB_NULLHANDLE();
iResult = hb_fsProcessExec( pszFilename, hStdin, hStdout, hStderr );
if( hStdin != FS_ERROR )
{
hb_fsClose( hStdin );
if( sTmpIn[ 0 ] )
hb_fsDelete( sTmpIn );
}
if( hStdout != FS_ERROR )
{
if( pStdOutPtr && pulStdOut )
{
nOutBuf = hb_fsSeek( hStdout, 0, FS_END );
if( nOutBuf )
{
pOutBuf = ( char * ) hb_xgrab( nOutBuf + 1 );
hb_fsSeek( hStdout, 0, FS_SET );
nOutBuf = hb_fsReadLarge( hStdout, pOutBuf, nOutBuf );
}
}
hb_fsClose( hStdout );
if( sTmpOut[ 0 ] )
hb_fsDelete( sTmpOut );
}
if( hStderr != FS_ERROR && hStderr != hStdout )
{
if( pStdErrPtr && pulStdErr )
{
nErrBuf = hb_fsSeek( hStderr, 0, FS_END );
if( nErrBuf )
{
pErrBuf = ( char * ) hb_xgrab( nErrBuf + 1 );
hb_fsSeek( hStderr, 0, FS_SET );
nErrBuf = hb_fsReadLarge( hStderr, pErrBuf, nErrBuf );
}
}
hb_fsClose( hStderr );
if( sTmpErr[ 0 ] )
hb_fsDelete( sTmpErr );
}
}
#else
{
HB_FHANDLE hProcess;
hb_vmUnlock();
iResult = -1;
hProcess = hb_fsProcessOpen( pszFilename, phStdin, phStdout, phStderr,
fDetach, NULL );
if( hProcess != FS_ERROR )
{
#if defined( HB_OS_WIN )
HB_BOOL fFinished = HB_FALSE;
int iPipeCount = 0;
if( nStdInLen == 0 && hStdin != FS_ERROR )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
}
if( hStdin != FS_ERROR )
++iPipeCount;
if( hStdout != FS_ERROR )
++iPipeCount;
if( hStderr != FS_ERROR )
++iPipeCount;
if( iPipeCount > 1 )
{
if( hStdin != FS_ERROR )
hb_fsPipeUnblock( hStdin );
if( hStdout != FS_ERROR )
hb_fsPipeUnblock( hStdout );
if( hStderr != FS_ERROR )
hb_fsPipeUnblock( hStderr );
}
for( ;; )
{
DWORD dwResult, dwWait;
HB_SIZE nLen;
dwWait = 1000;
if( hStdout != FS_ERROR )
{
if( nOutBuf == nOutSize )
{
nOutSize += HB_STD_BUFFER_SIZE;
pOutBuf = ( char * ) hb_xrealloc( pOutBuf, nOutSize + 1 );
}
nLen = hb_fsReadLarge( hStdout, pOutBuf + nOutBuf, nOutSize - nOutBuf );
if( nLen > 0 )
nOutBuf += nLen;
else if( iPipeCount == 1 )
{
hb_fsClose( hStdout );
hStdout = FS_ERROR;
iPipeCount = 0;
}
dwWait = nLen > 0 ? 0 : 10;
}
if( hStderr != FS_ERROR )
{
if( nErrBuf == nErrSize )
{
nErrSize += HB_STD_BUFFER_SIZE;
pErrBuf = ( char * ) hb_xrealloc( pErrBuf, nErrSize + 1 );
}
nLen = hb_fsReadLarge( hStderr, pErrBuf + nErrBuf, nErrSize - nErrBuf );
if( nLen > 0 )
nErrBuf += nLen;
else if( iPipeCount == 1 )
{
hb_fsClose( hStderr );
hStderr = FS_ERROR;
iPipeCount = 0;
}
if( dwWait )
dwWait = nLen > 0 ? 0 : 10;
}
if( fFinished )
{
if( dwWait != 0 )
break;
}
else if( hStdin != FS_ERROR )
{
nLen = hb_fsWriteLarge( hStdin, pStdInBuf, nStdInLen );
pStdInBuf += nLen;
nStdInLen -= nLen;
if( nStdInLen == 0 || ( iPipeCount == 1 && nLen == 0 ) )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
if( iPipeCount == 1 )
iPipeCount = 0;
}
else if( dwWait )
dwWait = nLen > 0 ? 0 : 10;
}
if( iPipeCount == 0 )
dwWait = INFINITE;
dwResult = WaitForSingleObject( ( HANDLE ) hb_fsGetOsHandle( hProcess ), dwWait );
if( dwResult == WAIT_OBJECT_0 )
{
if( GetExitCodeProcess( ( HANDLE ) hb_fsGetOsHandle( hProcess ), &dwResult ) )
iResult = ( int ) dwResult;
else
iResult = -2;
fFinished = HB_TRUE;
}
}
if( hStdin != FS_ERROR )
hb_fsClose( hStdin );
if( hStdout != FS_ERROR )
hb_fsClose( hStdout );
if( hStderr != FS_ERROR )
hb_fsClose( hStderr );
CloseHandle( ( HANDLE ) hb_fsGetOsHandle( hProcess ) );
#elif defined( HB_OS_UNIX ) && ! defined( HB_OS_SYMBIAN )
fd_set rfds, wfds, *prfds, *pwfds;
HB_FHANDLE fdMax;
HB_SIZE ul;
int n;
if( nStdInLen == 0 && hStdin != FS_ERROR )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
}
if( hStdin != FS_ERROR )
hb_fsPipeUnblock( hStdin );
if( hStdout != FS_ERROR )
hb_fsPipeUnblock( hStdout );
if( hStderr != FS_ERROR )
hb_fsPipeUnblock( hStderr );
for( ;; )
{
fdMax = 0;
prfds = pwfds = NULL;
if( hStdout != FS_ERROR || hStderr != FS_ERROR )
{
FD_ZERO( &rfds );
if( hStdout != FS_ERROR )
{
FD_SET( hStdout, &rfds );
if( hStdout > fdMax )
fdMax = hStdout;
}
if( hStderr != FS_ERROR )
{
FD_SET( hStderr, &rfds );
if( hStderr > fdMax )
fdMax = hStderr;
}
prfds = &rfds;
}
if( hStdin != FS_ERROR )
{
FD_ZERO( &wfds );
FD_SET( hStdin, &wfds );
if( hStdin > fdMax )
fdMax = hStdin;
pwfds = &wfds;
}
if( prfds == NULL && pwfds == NULL )
break;
n = select( fdMax + 1, prfds, pwfds, NULL, NULL );
if( n > 0 )
{
if( hStdout != FS_ERROR && FD_ISSET( hStdout, &rfds ) )
{
if( nOutBuf == nOutSize )
{
nOutSize += HB_STD_BUFFER_SIZE;
pOutBuf = ( char * ) hb_xrealloc( pOutBuf, nOutSize + 1 );
}
ul = hb_fsReadLarge( hStdout, pOutBuf + nOutBuf, nOutSize - nOutBuf );
if( ul == 0 )
{
/* zero bytes read after positive Select()
* - writing process closed the pipe
*/
hb_fsClose( hStdout );
hStdout = FS_ERROR;
}
else
nOutBuf += ul;
}
if( hStderr != FS_ERROR && FD_ISSET( hStderr, &rfds ) )
{
if( nErrBuf == nErrSize )
{
nErrSize += HB_STD_BUFFER_SIZE;
pErrBuf = ( char * ) hb_xrealloc( pErrBuf, nErrSize + 1 );
}
ul = hb_fsReadLarge( hStderr, pErrBuf + nErrBuf, nErrSize - nErrBuf );
if( ul == 0 )
{
/* zero bytes read after positive Select()
* - writing process closed the pipe
*/
hb_fsClose( hStderr );
hStderr = FS_ERROR;
}
else
nErrBuf += ul;
}
if( hStdin != FS_ERROR && FD_ISSET( hStdin, &wfds ) )
{
ul = hb_fsWriteLarge( hStdin, pStdInBuf, nStdInLen );
pStdInBuf += ul;
nStdInLen -= ul;
if( nStdInLen == 0 )
{
hb_fsClose( hStdin );
hStdin = FS_ERROR;
}
}
}
else
break;
}
if( hStdin != FS_ERROR )
hb_fsClose( hStdin );
if( hStdout != FS_ERROR )
hb_fsClose( hStdout );
if( hStderr != FS_ERROR )
hb_fsClose( hStderr );
iResult = hb_fsProcessValue( hProcess, HB_TRUE );
#else
int iTODO;
HB_SYMBOL_UNUSED( nStdInLen );
#endif
hb_vmLock();
}
}
#endif
if( phStdout )
{
*pStdOutPtr = pOutBuf;
*pulStdOut = nOutBuf;
}
if( phStderr && phStdout != phStderr )
{
*pStdErrPtr = pErrBuf;
*pulStdErr = nErrBuf;
}
return iResult;
}
HB_BOOL hb_fsCopy( const char * pszSource, const char * pszDest )
{
HB_ERRCODE errCode;
HB_BOOL bRetVal;
HB_FHANDLE fhndSource;
HB_FHANDLE fhndDest;
/* TODO: Change to use hb_fileExtOpen() */
if( ( fhndSource = hb_fsExtOpen( pszSource, NULL, FO_READ | FXO_SHARELOCK, NULL, NULL ) ) != FS_ERROR )
{
/* TODO: Change to use hb_fileExtOpen() */
if( ( fhndDest = hb_fsExtOpen( pszDest, NULL, FXO_TRUNCATE | FO_READWRITE | FO_EXCLUSIVE | FXO_SHARELOCK, NULL, NULL ) ) != FS_ERROR )
{
#if defined( HB_OS_UNIX )
struct stat struFileInfo;
int iSuccess = fstat( fhndSource, &struFileInfo );
#endif
HB_SIZE nBytesRead;
void * pbyBuffer = hb_xgrab( HB_FSCOPY_BUFFERSIZE );
for( ;; )
{
if( ( nBytesRead = hb_fsReadLarge( fhndSource, pbyBuffer, HB_FSCOPY_BUFFERSIZE ) ) > 0 )
{
if( nBytesRead != hb_fsWriteLarge( fhndDest, pbyBuffer, nBytesRead ) )
{
errCode = hb_fsError();
bRetVal = HB_FALSE;
break;
}
}
else
{
errCode = hb_fsError();
bRetVal = ( errCode == 0 );
break;
}
}
hb_xfree( pbyBuffer );
#if defined( HB_OS_UNIX )
if( iSuccess == 0 )
fchmod( fhndDest, struFileInfo.st_mode );
#endif
hb_fsClose( fhndDest );
}
else
{
errCode = hb_fsError();
bRetVal = HB_FALSE;
}
hb_fsClose( fhndSource );
}
else
{
errCode = hb_fsError();
bRetVal = HB_FALSE;
}
hb_fsSetFError( errCode );
return bRetVal;
}
HB_FOFFSET hb_fsFSize( const char * pszFileName, HB_BOOL bUseDirEntry )
{
if( bUseDirEntry )
{
#if defined( HB_OS_WIN )
typedef BOOL ( WINAPI * _HB_GETFILEATTRIBUTESEX )( LPCTSTR, GET_FILEEX_INFO_LEVELS, LPVOID );
static _HB_GETFILEATTRIBUTESEX s_pGetFileAttributesEx = ( _HB_GETFILEATTRIBUTESEX ) -1;
if( s_pGetFileAttributesEx == ( _HB_GETFILEATTRIBUTESEX ) -1 )
{
HMODULE hModule = GetModuleHandle( TEXT( "kernel32.dll" ) );
if( hModule )
s_pGetFileAttributesEx = ( _HB_GETFILEATTRIBUTESEX )
HB_WINAPI_GETPROCADDRESST( hModule, "GetFileAttributesEx" );
else
s_pGetFileAttributesEx = NULL;
}
if( s_pGetFileAttributesEx )
{
LPCTSTR lpFileName;
LPTSTR lpFree;
WIN32_FILE_ATTRIBUTE_DATA attrex;
HB_BOOL fResult;
lpFileName = HB_FSNAMECONV( pszFileName, &lpFree );
memset( &attrex, 0, sizeof( attrex ) );
fResult = s_pGetFileAttributesEx( lpFileName, GetFileExInfoStandard, &attrex ) &&
( attrex.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) == 0;
hb_fsSetIOError( fResult, 0 );
if( lpFree )
hb_xfree( lpFree );
if( fResult )
return ( HB_FOFFSET ) attrex.nFileSizeLow +
( ( HB_FOFFSET ) attrex.nFileSizeHigh << 32 );
}
else
{
PHB_FFIND ffind = hb_fsFindFirst( pszFileName, HB_FA_ALL );
hb_fsSetIOError( ffind != NULL, 0 );
if( ffind )
{
HB_FOFFSET size = ffind->size;
hb_fsFindClose( ffind );
return size;
}
}
#elif defined( HB_USE_LARGEFILE64 )
char * pszFree;
HB_BOOL fResult;
struct stat64 statbuf;
pszFileName = hb_fsNameConv( pszFileName, &pszFree );
statbuf.st_size = 0;
hb_vmUnlock();
fResult = stat64( pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( pszFree )
hb_xfree( pszFree );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#else
char * pszFree;
HB_BOOL fResult;
struct stat statbuf;
pszFileName = hb_fsNameConv( pszFileName, &pszFree );
statbuf.st_size = 0;
hb_vmUnlock();
fResult = stat( ( char * ) pszFileName, &statbuf ) == 0;
hb_fsSetIOError( fResult, 0 );
hb_vmLock();
if( pszFree )
hb_xfree( pszFree );
if( fResult )
return ( HB_FOFFSET ) statbuf.st_size;
#endif
}
else
{
HB_FHANDLE hFileHandle = hb_fsOpen( pszFileName, FO_READ | FO_COMPAT );
if( hFileHandle != FS_ERROR )
{
HB_FOFFSET nPos = hb_fsSeekLarge( hFileHandle, 0, FS_END );
hb_fsClose( hFileHandle );
return nPos;
}
}
return 0;
}