mars_nwe/mars-flaim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First round of changes to support ring 0 NLMs.

Browse Source 
git-svn-id: https://svn.code.sf.net/p/flaim/code/trunk@404 0109f412-320b-0410-ab79-c3e0c5ffbbe6
This commit is contained in:
ahodgkinson
2006-05-10 22:21:40 +00:00
parent ff2b97d5a9
commit 62e33bcd7d
11 changed files with 902 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ftk/Makefile
View File

@@ -1002,13 +1002,13 @@ ifdef netware_target
endif
ifndef wc_dir
$(error Watcom compiler could not be found. Please define wc_dir.)
$(error Watcom compiler could not be found. Please define wc_dir)
endif
wc_dir := $(call normpath,$(wc_dir))
ifndef ndk_dir
$(error Netware SDK could not be found. Please define ndk_dir.)
$(error Netware SDK could not be found. Please define ndk_dir)
endif
ndk_dir := $(call normpath,$(ndk_dir))

95
ftk/src/ftk.h
View File

@@ -1,5 +1,5 @@
//------------------------------------------------------------------------------
// Desc: FLAIM toolkit definitions and interfaces
// Desc: FLAIM's cross-platform toolkit public definitions and interfaces
//
// Tabs: 3
//
@@ -146,7 +146,11 @@
#error Cannot define both FLM_32BIT and FLM_64BIT
#endif
#define FSTATIC static
#ifdef FLM_NLM
#define FSTATIC
#else
#define FSTATIC static
#endif
// Debug or release build?
@@ -321,27 +325,50 @@
= { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
#endif
#define FLMEXTC extern "C"
#define FLMEXTC extern "C"
#if defined( FLM_WIN)
#define FLMAPI __stdcall
#define FLMEXP __declspec(dllexport)
#define FLMAPI __stdcall
#define FLMEXP __declspec(dllexport)
#ifdef FLM_DEBUG
#define FINLINE inline
#define FINLINE inline
#else
#define FINLINE __forceinline
#define FINLINE __forceinline
#endif
#elif defined( FLM_NLM)
#define FLMAPI __stdcall
#define FLMEXP FLMEXTC
#define FINLINE inline
#define FLMAPI __stdcall
#define FLMEXP FLMEXTC
#define FINLINE inline
#elif defined( FLM_UNIX)
#define FLMAPI
#define FLMEXP FLMEXTC
#define FINLINE inline
#define FLMEXP FLMEXTC
#define FINLINE inline
#else
#error Platform not supported
#endif
#define f_alignedsize(n) \
((sizeof(n) + FLM_ALIGN_SIZE - 1) & ~(FLM_ALIGN_SIZE - 1) )
#if defined( FLM_GNUC)
#define f_va_start( list, name) \
__builtin_va_start( list, name)
#define f_va_arg( list, type) \
__builtin_va_arg( list, type)
#define f_va_end( list) \
__builtin_va_end( list)
#else
#define f_va_start( list, name) \
(list = (f_va_list)&(name) + f_alignedsize( name))
#define f_va_arg( list, type) \
(*(type *)((list += f_alignedsize( type)) - f_alignedsize( type)))
#define f_va_end( list) \
(list = (f_va_list)0)
#endif
// flmnovtbl keeps MS compilers from generating vtables for interfaces
@@ -1117,6 +1144,10 @@
const char * pszFileName,
const char * pszNewFileName) = 0;
virtual RCODE FLMAPI setReadOnly(
const char * pszFileName,
FLMBOOL bReadOnly) = 0;
virtual RCODE FLMAPI getSectorSize(
const char * pszFileName,
FLMUINT * puiSectorSize) = 0;
@@ -1158,6 +1189,8 @@
RCODE FLMAPI FlmGetFileSystem(
IF_FileSystem ** ppFileSystem);
IF_FileSystem * FLMAPI f_getFileSysPtr( void);
/****************************************************************************
Desc:
****************************************************************************/
@@ -1650,6 +1683,10 @@
RCODE FLMAPI FlmAllocRandomGenerator(
IF_RandomGenerator ** ppRandomGenerator);
FLMUINT32 FLMAPI f_getRandomUINT32(
FLMUINT32 ui32Low = 0,
FLMUINT32 ui32High = FLM_MAX_RANDOM);
/**********************************************************************
Desc: Atomic operations
@@ -3838,6 +3875,40 @@
FLMUINT uiMaxRespLen,
FLMUINT * puiTermChar);
void FLMAPI FTXBeep( void);
/****************************************************************************
Desc: Status and return codes
****************************************************************************/
#ifndef RC_OK
#define RC_OK( rc) ((rc) == 0)
#endif
#ifndef RC_BAD
#define RC_BAD( rc) ((rc) != 0)
#endif
#define FTK_ERROR_BASE(e) ((RCODE)((int)(0x81055000+(e))))
#define FTK_ERROR_END ((RCODE)((int)(0x81055FFF)))
const char * FLMAPI f_errorString(
RCODE rc);
RCODE FLMAPI f_mapPlatformError(
FLMINT iError,
RCODE defaultRc);
FINLINE FLMBOOL FLMAPI f_isToolkitError(
RCODE rc)
{
if( rc > FTK_ERROR_BASE( 0) && rc < FTK_ERROR_END)
{
return( TRUE);
}
return( FALSE);
}
/****************************************************************************
Desc: General errors
****************************************************************************/

1
ftk/src/ftkbtree.cpp
View File

@@ -12243,4 +12243,3 @@ void gv_ftkbtree( void)
{
}
#endif

245
ftk/src/ftkdir.cpp
View File

@@ -41,7 +41,7 @@
FSTATIC FLMBOOL f_fileMeetsFindCriteria(
F_IO_FIND_DATA * pFindData);
#elif defined( FLM_UNIX) || defined( FLM_NLM)
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
#define F_IO_FA_NORMAL 0x01 // Normal file, no attributes
#define F_IO_FA_RDONLY 0x02 // Read only attribute
@@ -66,7 +66,7 @@
char * FilePath,
struct stat * StatusRec);
#else
#elif !defined( FLM_RING_0_NLM)
#error Platform not supported
@@ -157,9 +157,24 @@ Desc:
****************************************************************************/
FLMBOOL FLMAPI F_DirHdl::currentItemIsDir( void)
{
#if defined( FLM_WIN) || defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
return( ((m_uiAttrib & F_IO_FA_DIRECTORY)
? TRUE
: FALSE));
#elif defined( FLM_NLM)
if( !m_FindData.m_pCurrentItem)
{
return( FALSE);
}
return( (m_FindData.m_pCurrentItem->DFileAttributes & SUBDIRECTORY_BIT)
? TRUE
: FALSE);
#endif
}
/****************************************************************************
@@ -174,8 +189,13 @@ FLMUINT64 FLMAPI F_DirHdl::currentItemSize( void)
#if defined( FLM_WIN)
ui64Size = (((FLMUINT64)m_FindData.findBuffer.nFileSizeHigh) << 32) +
m_FindData.findBuffer.nFileSizeLow;
#elif defined( FLM_UNIX) || defined ( FLM_NLM)
#elif defined( FLM_UNIX) || defined ( FLM_LIBC_NLM)
ui64Size = m_FindData.FileStat.st_size;
#elif defined( FLM_RING_0_NLM)
if( m_FindData.m_pCurrentItem != NULL )
{
ui64Size = m_FindData.m_pCurrentItem->DFileSize;
}
#endif
}
return( ui64Size);
@@ -184,6 +204,7 @@ FLMUINT64 FLMAPI F_DirHdl::currentItemSize( void)
/****************************************************************************
Desc: Get the next item in a directory
****************************************************************************/
#if defined( FLM_WIN) || defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE FLMAPI F_DirHdl::next( void)
{
char szFoundPath[ F_PATH_MAX_SIZE];
@@ -206,8 +227,8 @@ RCODE FLMAPI F_DirHdl::next( void)
{
m_bFirstTime = FALSE;
if( RC_BAD( m_rc = f_fileFindFirst( m_szDirectoryPath, uiSearchAttributes,
&m_FindData, szFoundPath, &uiFoundAttrib)))
if( RC_BAD( m_rc = f_fileFindFirst( m_szDirectoryPath,
uiSearchAttributes, &m_FindData, szFoundPath, &uiFoundAttrib)))
{
goto Exit;
}
@@ -242,6 +263,54 @@ Exit:
return( m_rc);
}
#endif
/****************************************************************************
Desc: Get the next item in a directory
****************************************************************************/
#if defined( FLM_RING_0_NLM)
RCODE FLMAPI F_DirHdl::next( void)
{
LONG lError = 0;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( RC_BAD( m_rc))
{
goto Exit;
}
for( ;;)
{
if( (lError = DirectorySearch( 0, m_FindData.m_lVolumeNumber,
m_FindData.m_lDirectoryNumber, LONGNameSpace,
m_FindData.m_lCurrentEntryNumber, (BYTE *)"\x02\xFF*",
-1, &m_FindData.m_pCurrentItem,
&m_FindData.m_lCurrentEntryNumber)) != 0)
{
if( (lError == ERR_NO_FILES_FOUND) || (lError == ERR_INVALID_PATH))
{
m_rc = RC_SET( NE_FLM_IO_NO_MORE_FILES);
}
else
{
m_rc = f_mapPlatformError(lError, NE_FLM_READING_FILE);
}
break;
}
if( pFileSystem->doesFileMatch(
(const char *)m_FindData.m_pCurrentItem->DFileName, m_szPattern))
{
break;
}
}
Exit:
return( m_rc);
}
#endif
/****************************************************************************
Desc: Open a directory
@@ -279,6 +348,7 @@ Exit:
/****************************************************************************
Desc: Create a directory (and parent directories if necessary).
****************************************************************************/
#if defined( FLM_WIN) || defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE FLMAPI F_DirHdl::createDir(
const char * pszDirPath)
{
@@ -335,7 +405,7 @@ RCODE FLMAPI F_DirHdl::createDir(
rc = f_mapPlatformError( GetLastError(), NE_FLM_CREATING_FILE);
}
#elif defined( FLM_UNIX) || defined( FLM_NLM)
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
if( mkdir( (char *)pszDirPath, 0777) == -1)
{
@@ -353,6 +423,51 @@ Exit:
return( rc);
}
#endif
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_RING_0_NLM)
RCODE FLMAPI F_DirHdl::createDir(
const char * pszDirPath)
{
RCODE rc = NE_FLM_OK;
FLMBYTE pucPseudoLNamePath[ F_PATH_MAX_SIZE + 1];
FLMBYTE pucLNamePath[ F_PATH_MAX_SIZE];
LONG lVolumeID;
LONG lPathID;
LONG lLNamePathCount;
LONG lNewDirectoryID;
void * pNotUsed;
LONG lErrorCode;
f_strcpy( (char *)&pucPseudoLNamePath[1], pszDirPath);
pucPseudoLNamePath[0] = (FLMBYTE)f_strlen( pszDirPath);
if( (lErrorCode = ConvertPathString( 0, 0, pucPseudoLNamePath, &lVolumeID,
&lPathID, pucLNamePath, &lLNamePathCount)) != 0)
{
goto Exit;
}
if( (lErrorCode = CreateDirectory( 0, lVolumeID, lPathID, pucLNamePath,
lLNamePathCount, LONGNameSpace, MaximumDirectoryAccessBits,
&lNewDirectoryID, &pNotUsed)) != 0)
{
goto Exit;
}
Exit:
if( lErrorCode)
{
rc = f_mapPlatformError( lErrorCode, NE_FLM_CREATING_FILE);
}
return( rc);
}
#endif
/****************************************************************************
Desc: Remove a directory
@@ -370,7 +485,7 @@ RCODE FLMAPI F_DirHdl::removeDir(
return( NE_FLM_OK);
#elif defined( FLM_UNIX) || defined( FLM_NLM)
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
if( rmdir( (char *)pszDirName) == -1)
{
@@ -378,13 +493,59 @@ RCODE FLMAPI F_DirHdl::removeDir(
}
return( NE_FLM_OK);
#elif defined( FLM_RING_0_NLM)
return( f_netwareRemoveDir( pszDirName));
#endif
}
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_RING_0_NLM)
RCODE f_netwareRemoveDir(
const char * pszDirName)
{
RCODE rc = NE_FLM_OK;
FLMBYTE pucPseudoLNamePath[ F_PATH_MAX_SIZE + 1];
FLMBYTE pucLNamePath[ F_PATH_MAX_SIZE];
LONG lVolumeID;
LONG lPathID;
LONG lLNamePathCount;
LONG lErrorCode;
f_strcpy( (char *)&pucPseudoLNamePath[1], pszDirName);
pucPseudoLNamePath[0] = (FLMBYTE)f_strlen( pszDirName);
if( (lErrorCode = ConvertPathString( 0, 0, pucPseudoLNamePath, &lVolumeID,
&lPathID, pucLNamePath, &lLNamePathCount)) != 0)
{
goto Exit;
}
if( (lErrorCode = DeleteDirectory( 0, lVolumeID, lPathID, pucLNamePath,
lLNamePathCount, LONGNameSpace)) != 0)
{
goto Exit;
}
Exit:
if( lErrorCode)
{
rc = f_mapPlatformError( lErrorCode, NE_FLM_IO_DELETING_FILE);
}
return( rc);
}
#endif
/****************************************************************************
Desc: Find the first file that matches the supplied criteria
****************************************************************************/
#ifdef FLM_WIN
RCODE f_fileFindFirst(
char * pszSearchPath,
FLMUINT uiSearchAttrib,
@@ -392,7 +553,6 @@ RCODE f_fileFindFirst(
char * pszFoundPath,
FLMUINT * puiFoundAttrib)
{
#ifdef FLM_WIN
RCODE rc = NE_FLM_OK;
char szTmpPath[ F_PATH_MAX_SIZE];
char * pszWildCard = "*.*";
@@ -469,9 +629,20 @@ Exit:
}
return( rc);
}
#endif
#else
/****************************************************************************
Desc: Find the first file that matches the supplied criteria
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE f_fileFindFirst(
char * pszSearchPath,
FLMUINT uiSearchAttrib,
F_IO_FIND_DATA * pFindData,
char * pszFoundPath,
FLMUINT * puiFoundAttrib)
{
RCODE rc = NE_FLM_OK;
char szTmpPath[ F_PATH_MAX_SIZE];
FSTATIC char pszWildCard[] = {'*',0};
@@ -571,12 +742,13 @@ Exit:
Exit:
return( rc);
#endif
}
#endif
/****************************************************************************
Desc: Find the next file that matches the supplied criteria
****************************************************************************/
#ifdef FLM_WIN
RCODE f_fileFindNext(
F_IO_FIND_DATA * pFindData,
char * pszFoundPath,
@@ -585,8 +757,6 @@ RCODE f_fileFindNext(
RCODE rc = NE_FLM_OK;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
#ifdef FLM_WIN
if( FindNextFile( pFindData->findHandle,
&(pFindData->findBuffer)) == FALSE)
{
@@ -625,8 +795,24 @@ RCODE f_fileFindNext(
*puiFoundAttrib = pFindData->findBuffer.dwFileAttributes;
#elif defined( FLM_UNIX) || defined( FLM_NLM)
int iRetVal;
Exit:
return( rc);
}
#endif
/****************************************************************************
Desc: Find the next file that matches the supplied criteria
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE f_fileFindNext(
F_IO_FIND_DATA * pFindData,
char * pszFoundPath,
FLMUINT * puiFoundAttrib)
{
RCODE rc = NE_FLM_OK;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
int iRetVal;
if( (iRetVal = Find2( pFindData)) != 0)
{
@@ -655,24 +841,20 @@ RCODE f_fileFindNext(
*puiFoundAttrib = (FLMUINT)ReturnAttributes(
pFindData->FileStat.st_mode, pszFoundPath);
#else
rc = RC_SET_AND_ASSERT( NE_FLM_NOT_IMPLEMENTED);
goto Exit;
#endif
Exit:
return( rc);
}
#endif
/****************************************************************************
Desc: Releases any memory allocated to an F_IO_FIND_DATA structure
****************************************************************************/
#ifdef FLM_WIN
void f_fileFindClose(
F_IO_FIND_DATA * pFindData)
{
#ifdef FLM_WIN
// Don't call it on an already closed or invalid handle.
if( pFindData->findHandle != INVALID_HANDLE_VALUE)
@@ -680,15 +862,24 @@ void f_fileFindClose(
FindClose( pFindData->findHandle );
pFindData->findHandle = INVALID_HANDLE_VALUE;
}
#elif defined( FLM_UNIX) || defined ( FLM_NLM)
}
#endif
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined ( FLM_LIBC_NLM)
void f_fileFindClose(
F_IO_FIND_DATA * pFindData)
{
if( pFindData->globbuf.gl_pathv)
{
pFindData->globbuf.gl_offs = 0;
globfree( &pFindData->globbuf);
pFindData->globbuf.gl_pathv = 0;
}
#endif
}
#endif
/****************************************************************************
Desc: Find the next file that matches the supplied criteria
@@ -722,7 +913,7 @@ FSTATIC FLMBOOL f_fileMeetsFindCriteria(
/****************************************************************************
Desc: Search for file names matching FindTemplate (UNIX)
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FSTATIC int Find1(
char * FindTemplate,
F_IO_FIND_DATA * DirInfo)
@@ -826,7 +1017,7 @@ FSTATIC int Find1(
/****************************************************************************
Desc: Search for file names matching FindTemplate (UNIX)
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FSTATIC int Find2(
F_IO_FIND_DATA * DirStuff)
{
@@ -916,7 +1107,7 @@ FSTATIC int Find2(
/****************************************************************************
Desc: Return file's attributes (UNIX)
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FSTATIC FLMBYTE ReturnAttributes(
mode_t FileMode,
char * fileName)
@@ -948,7 +1139,7 @@ FSTATIC FLMBYTE ReturnAttributes(
/****************************************************************************
Desc: Return file's attributes (UNIX) || (NetWare)
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FSTATIC int RetrieveFileStat(
char * FilePath,
struct stat * StatusRec)

2
ftk/src/ftkerror.cpp
View File

@@ -58,7 +58,7 @@ RCODE FLMAPI f_makeErr(
/***************************************************************************
Desc: Map POSIX errno to Flaim IO errors.
***************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE FLMAPI f_mapPlatformError(
FLMINT iError,
RCODE defaultRc)

136
ftk/src/ftkfsys.cpp
View File

@@ -184,7 +184,7 @@ public:
const char * pszFileName,
FLMUINT * puiSectorSize);
RCODE setReadOnly(
RCODE FLMAPI setReadOnly(
const char * pszFileName,
FLMBOOL bReadOnly);
@@ -785,7 +785,7 @@ RCODE F_FileSystem::removeEmptyDir(
return( NE_FLM_OK);
#elif defined( FLM_UNIX) || defined( FLM_NLM)
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
if( rmdir( pszDirPath) == -1 )
{
@@ -793,6 +793,11 @@ RCODE F_FileSystem::removeEmptyDir(
}
return( NE_FLM_OK);
#elif defined( FLM_RING_0_NLM)
return( f_netwareRemoveDir( pszDirPath));
#endif
}
@@ -811,7 +816,7 @@ RCODE FLMAPI F_FileSystem::doesFileExist(
return NE_FLM_OK;
#else
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
if( access( pszPath, F_OK) == -1)
{
@@ -820,6 +825,10 @@ RCODE FLMAPI F_FileSystem::doesFileExist(
return( NE_FLM_OK);
#elif defined( FLM_RING_0_NLM)
return( f_netwareTestIfFileExists( pszPath));
#endif
}
@@ -913,7 +922,7 @@ Exit:
return( rc);
#else
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
struct stat filestatus;
@@ -924,6 +933,80 @@ Exit:
*puiTimeStamp = (FLMUINT)filestatus.st_mtime; // st_mtime is UTC
return NE_FLM_OK;
#elif defined( FLM_RING_0_NLM)
RCODE rc = NE_FLM_OK;
FLMUINT uiTmp;
FLMBYTE ucPseudoLNamePath[ F_PATH_MAX_SIZE + 1];
FLMBYTE ucLNamePath[ F_PATH_MAX_SIZE];
LONG lVolumeID;
LONG lPathID;
LONG lLNamePathCount;
LONG lDirectoryID;
LONG lErrorCode;
struct DirectoryStructure * pFileInfo = NULL;
flmAssert( puiTimeStamp);
*puiTimeStamp = 0;
f_strcpy( (char *)&ucPseudoLNamePath[1], pszPath);
ucPseudoLNamePath[ 0] = (FLMBYTE)f_strlen( pszPath );
if( (lErrorCode = ConvertPathString( 0, 0, ucPseudoLNamePath, &lVolumeID,
&lPathID, ucLNamePath, &lLNamePathCount)) != 0)
{
goto Exit;
}
if( (lErrorCode = GetEntryFromPathStringBase( 0, lVolumeID, 0, ucLNamePath,
lLNamePathCount, LONGNameSpace, LONGNameSpace, &pFileInfo,
&lDirectoryID)) != 0)
{
goto Exit;
}
if( pFileInfo)
{
FLMUINT uiTime;
FLMUINT uiDate;
F_TMSTAMP dateTime;
LONG DayMask = 0x001F;
LONG MonthMask = 0x01E0;
LONG YearMask = 0xFE00;
LONG SecMask = 0x001F;
LONG MinMask = 0x07E0;
LONG HourMask = 0xF800;
//Get the low-order 16 bits
uiTime = (FLMUINT)pFileInfo->DLastUpdatedDateAndTime;
//Get the high-order 16 bits
uiDate = (FLMUINT)(pFileInfo->DLastUpdatedDateAndTime >> 16);
f_memset( &dateTime, 0, sizeof( dateTime));
dateTime.second = (FLMBYTE) ((uiTime & SecMask) * 2);
dateTime.minute = (FLMBYTE) ((uiTime & MinMask) >> 5);
dateTime.hour = (FLMBYTE) ((uiTime & HourMask) >> 11);
dateTime.day = (FLMBYTE) (uiDate & DayMask);
dateTime.month = (FLMBYTE) ((uiDate & MonthMask) >> 5)-1;
dateTime.year = (FLMUINT16)(((uiDate & YearMask) >> 9) + 1980);
f_timeDateToSeconds( &dateTime, &uiTmp);
*puiTimeStamp = uiTmp;
*puiTimeStamp = f_localTimeToUTC(*puiTimeStamp);
}
Exit:
if( lErrorCode != 0 )
{
rc = f_mapPlatformError( lErrorCode, NE_FLM_PARSING_FILE_NAME);
}
return( rc);
#endif
}
@@ -945,7 +1028,7 @@ FLMBOOL FLMAPI F_FileSystem::isDir(
return (FileAttr & FILE_ATTRIBUTE_DIRECTORY) ? TRUE : FALSE;
#else
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
struct stat filestatus;
@@ -955,6 +1038,32 @@ FLMBOOL FLMAPI F_FileSystem::isDir(
}
return ( S_ISDIR( filestatus.st_mode)) ? TRUE : FALSE;
#elif defined( FLM_RING_0_NLM)
LONG lIsFile;
FLMBYTE ucPseudoLNamePath[ F_PATH_MAX_SIZE + 1];
FLMBYTE ucLNamePath[ F_PATH_MAX_SIZE];
LONG lVolumeID;
LONG lPathID;
LONG lLNamePathCount;
LONG lDirectoryID;
FLMBOOL bIsDir = FALSE;
f_strcpy( (char *)&ucPseudoLNamePath[1], pszDirName);
ucPseudoLNamePath[0] = (FLMBYTE)f_strlen( pszDirName);
if( ConvertPathString( 0, 0, ucPseudoLNamePath, &lVolumeID, &lPathID,
ucLNamePath, &lLNamePathCount) == 0)
{
if( MapPathToDirectoryNumber( 0, lVolumeID, 0, ucLNamePath,
lLNamePathCount, LONGNameSpace, &lDirectoryID, &lIsFile) == 0)
{
bIsDir = (FLMBOOL)((lIsFile == 0) ? (FLMBOOL)TRUE : (FLMBOOL)FALSE);
}
}
return( bIsDir);
#endif
}
@@ -973,7 +1082,7 @@ RCODE FLMAPI F_FileSystem::deleteFile(
return( NE_FLM_OK);
#else
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
struct stat FileStat;
@@ -997,6 +1106,10 @@ RCODE FLMAPI F_FileSystem::deleteFile(
}
return( NE_FLM_OK);
#elif defined( FLM_RING_0_NLM)
return( f_netwareDeleteFile( pszFileName));
#endif
}
@@ -1244,7 +1357,7 @@ RCODE FLMAPI F_FileSystem::renameFile(
return( rc);
#else
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE rc;
FLMBOOL bSrcIsDir;
@@ -1294,6 +1407,11 @@ RCODE FLMAPI F_FileSystem::renameFile(
}
return( NE_FLM_OK);
#elif defined( FLM_RING_0_NLM)
return( f_netwareRenameFile( pszFileName, pszNewFileName));
#endif
}
@@ -1307,7 +1425,7 @@ RCODE FLMAPI F_FileSystem::getSectorSize(
#ifdef FLM_NLM
F_UNREFERENCED_PARM( pszFileName);
*puiSectorSize = F_NETWARE_SECTOR_SIZE;
*puiSectorSize = FLM_NLM_SECTOR_SIZE;
return( NE_FLM_OK);
#elif defined( FLM_WIN)
@@ -1368,7 +1486,7 @@ Exit:
/****************************************************************************
Desc: Set the Read-Only Attribute (not supported on all platforms).
****************************************************************************/
RCODE F_FileSystem::setReadOnly(
RCODE FLMAPI F_FileSystem::setReadOnly(
const char * pszFileName,
FLMBOOL bReadOnly)
{

66
ftk/src/ftkftx.cpp
View File

@@ -437,6 +437,9 @@ FSTATIC void ftxDisplaySetBackFore(
eColorType backgroundColor,
eColorType foregroundColor);
FSTATIC FLMUINT ftxMapFlmColorToWin32(
eColorType uiColor);
RCODE _ftxBackgroundThread(
IF_Thread * pThread);
@@ -444,8 +447,6 @@ FLMBOOL ftxKBTest( void);
FLMUINT ftxKBGetChar( void);
FLMBOOL ftxBeep( void);
RCODE _ftxDefaultDisplayHandler(
IF_Thread * pThread);
@@ -3301,8 +3302,10 @@ FSTATIC void ftxWin32Refresh( void)
pWinScreen->uiCols) + (uiSubloop + pWinImage->uiUlx)]);
paCell->Char.AsciiChar = pWinImage->pszBuffer[ uiOffset];
paCell->Attributes =
(WORD)(((pWinImage->pucForeAttrib[ uiOffset] & 0x8F) |
((pWinImage->pucBackAttrib[ uiOffset] << 4) & 0x7F)));
(ftxMapFlmColorToWin32(
(eColorType)pWinImage->pucForeAttrib[ uiOffset]) & 0x8F) |
((ftxMapFlmColorToWin32(
(eColorType)pWinImage->pucBackAttrib[ uiOffset]) << 4) & 0x7F);
}
}
@@ -4239,6 +4242,51 @@ FSTATIC FLMUINT ftxDisplayStrOut(
}
#endif
/****************************************************************************
Desc: Set the background and foreground colors of the "physical" screen
****************************************************************************/
FSTATIC FLMUINT ftxMapFlmColorToWin32(
eColorType uiColor)
{
switch( uiColor)
{
case FLM_BLACK:
return( 0);
case FLM_BLUE:
return( 1);
case FLM_GREEN:
return( 2);
case FLM_CYAN:
return( 3);
case FLM_RED:
return( 4);
case FLM_MAGENTA:
return( 5);
case FLM_BROWN:
return( 6);
case FLM_LIGHTGRAY:
return( 7);
case FLM_DARKGRAY:
return( 8);
case FLM_LIGHTBLUE:
return( 9);
case FLM_LIGHTGREEN:
return( 10);
case FLM_LIGHTCYAN:
return( 11);
case FLM_LIGHTRED:
return( 12);
case FLM_LIGHTMAGENTA:
return( 13);
case FLM_YELLOW:
return( 14);
case FLM_WHITE:
return( 15);
default:
return( 0);
}
}
/****************************************************************************
Desc: Set the background and foreground colors of the "physical" screen
****************************************************************************/
@@ -4251,7 +4299,8 @@ FSTATIC void ftxDisplaySetBackFore(
FLMUINT uiAttrib = 0;
uiAttrib = (foregroundColor & 0x8F) | ((backgroundColor << 4) & 0x7F);
uiAttrib = (ftxMapFlmColorToWin32( foregroundColor) & 0x8F) |
((ftxMapFlmColorToWin32( backgroundColor) << 4) & 0x7F);
SetConsoleTextAttribute( gv_hStdOut, (WORD)uiAttrib);
#else
@@ -4562,16 +4611,11 @@ Exit:
Desc: Causes the console to "beep"
Ret: If the console does not support this feature, FALSE is returned.
****************************************************************************/
FLMBOOL ftxBeep( void)
void FLMAPI FTXBeep( void)
{
#if defined( FLM_WIN)
Beep( (DWORD)2000, (DWORD)250);
return( TRUE);
#else
return( FALSE);
#endif
}

69
ftk/src/ftkmisc.cpp
View File

@@ -26,18 +26,18 @@
#include "ftksys.h"
static FLMUINT gv_uiStartupCount = 0;
static FLMUINT gv_uiSerialInitCount = 0;
static F_MUTEX gv_hSerialMutex = F_MUTEX_NULL;
static IF_RandomGenerator * gv_pSerialRandom = NULL;
static FLMUINT gv_uiRandomGenInitCount = 0;
static F_MUTEX gv_hRandomGenMutex = F_MUTEX_NULL;
static IF_RandomGenerator * gv_pRandomGenerator = NULL;
static FLMUINT32 * gv_pui32CRCTbl = NULL;
static IF_ThreadMgr * gv_pThreadMgr = NULL;
static IF_FileSystem * gv_pFileSystem = NULL;
static FLMUINT gv_uiMaxFileSize = FLM_MAXIMUM_FILE_SIZE;
static F_XML * gv_pXml = NULL;
FSTATIC RCODE f_initSerialNumberGenerator( void);
FSTATIC RCODE f_initRandomGenerator( void);
FSTATIC void f_freeSerialNumberGenerator( void);
FSTATIC void f_freeRandomGenerator( void);
FSTATIC RCODE f_initCRCTable(
FLMUINT32 ** ppui32CRCTbl);
@@ -120,7 +120,7 @@ RCODE FLMAPI ftkStartup( void)
goto Exit;
}
if( RC_BAD( rc = f_initSerialNumberGenerator()))
if( RC_BAD( rc = f_initRandomGenerator()))
{
goto Exit;
}
@@ -208,7 +208,7 @@ void FLMAPI ftkShutdown( void)
gv_pXml->Release();
}
f_freeSerialNumberGenerator();
f_freeRandomGenerator();
f_freeCharMappingTables();
f_memoryCleanup();
}
@@ -270,22 +270,19 @@ void FLMAPI f_sleep(
#endif
/****************************************************************************
Desc: This routine initializes the serial number generator. If the O/S
does not provide support for GUID generation or if the GUID
routines fail for some reason, a pseudo-GUID will be generated.
Notes: This routine should only be called once by the process.
Desc:
****************************************************************************/
FSTATIC RCODE f_initSerialNumberGenerator( void)
FSTATIC RCODE f_initRandomGenerator( void)
{
FLMUINT uiTime;
RCODE rc = NE_FLM_OK;
if (++gv_uiSerialInitCount > 1)
if (++gv_uiRandomGenInitCount > 1)
{
goto Exit;
}
if( RC_BAD( rc = f_mutexCreate( &gv_hSerialMutex)))
if( RC_BAD( rc = f_mutexCreate( &gv_hRandomGenMutex)))
{
goto Exit;
}
@@ -294,12 +291,12 @@ FSTATIC RCODE f_initSerialNumberGenerator( void)
#if defined( FLM_UNIX) || defined( FLM_NLM)
if( RC_BAD( rc = FlmAllocRandomGenerator( &gv_pSerialRandom)))
if( RC_BAD( rc = FlmAllocRandomGenerator( &gv_pRandomGenerator)))
{
goto Exit;
}
gv_pSerialRandom->setSeed( (FLMUINT32)(uiTime ^ (FLMUINT)getpid()));
gv_pRandomGenerator->setSeed( (FLMUINT32)(uiTime ^ (FLMUINT)getpid()));
#endif
Exit:
@@ -310,22 +307,22 @@ Exit:
/****************************************************************************
Desc:
****************************************************************************/
FSTATIC void f_freeSerialNumberGenerator( void)
FSTATIC void f_freeRandomGenerator( void)
{
if( (--gv_uiSerialInitCount) > 0)
if( (--gv_uiRandomGenInitCount) > 0)
{
return;
}
if( gv_pSerialRandom)
if( gv_pRandomGenerator)
{
gv_pSerialRandom->Release();
gv_pSerialRandom = NULL;
gv_pRandomGenerator->Release();
gv_pRandomGenerator = NULL;
}
if( gv_hSerialMutex != F_MUTEX_NULL)
if( gv_hRandomGenMutex != F_MUTEX_NULL)
{
f_mutexDestroy( &gv_hSerialMutex);
f_mutexDestroy( &gv_hRandomGenMutex);
}
}
@@ -360,16 +357,10 @@ RCODE FLMAPI f_createSerialNumber(
// Generate a pseudo GUID value
f_assert( gv_hSerialMutex != F_MUTEX_NULL);
f_mutexLock( gv_hSerialMutex);
UD2FBA( gv_pSerialRandom->getUINT32(), &pszSerialNum[ 0]);
UD2FBA( gv_pSerialRandom->getUINT32(), &pszSerialNum[ 4]);
UD2FBA( gv_pSerialRandom->getUINT32(), &pszSerialNum[ 8]);
UD2FBA( gv_pSerialRandom->getUINT32(), &pszSerialNum[ 12]);
f_mutexUnlock( gv_hSerialMutex);
UD2FBA( f_getRandomUINT32(), &pszSerialNum[ 0]);
UD2FBA( f_getRandomUINT32(), &pszSerialNum[ 4]);
UD2FBA( f_getRandomUINT32(), &pszSerialNum[ 8]);
UD2FBA( f_getRandomUINT32(), &pszSerialNum[ 12]);
#endif
@@ -1076,7 +1067,7 @@ FLMINT FLMAPI F_Object::Release( void)
/**********************************************************************
Desc:
**********************************************************************/
IF_FileSystem * f_getFileSysPtr( void)
IF_FileSystem * FLMAPI f_getFileSysPtr( void)
{
return( gv_pFileSystem);
}
@@ -1497,3 +1488,13 @@ IF_XML * f_getXmlObjPtr( void)
{
return( gv_pXml);
}
/****************************************************************************
Desc:
****************************************************************************/
FLMUINT32 FLMAPI f_getRandomUINT32(
FLMUINT32 ui32Low,
FLMUINT32 ui32High)
{
return( gv_pRandomGenerator->getUINT32( ui32Low, ui32High));
}

101
ftk/src/ftksem.cpp
View File

@@ -28,7 +28,7 @@
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
typedef struct
{
pthread_mutex_t lock;
@@ -82,7 +82,7 @@ void FLMAPI f_mutexDestroy(
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE FLMAPI f_mutexCreate(
F_MUTEX * phMutex)
{
@@ -139,7 +139,7 @@ Exit:
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
void FLMAPI f_mutexDestroy(
F_MUTEX * phMutex)
{
@@ -162,7 +162,7 @@ void FLMAPI f_mutexDestroy(
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
void FLMAPI f_mutexLock(
F_MUTEX hMutex)
{
@@ -173,7 +173,7 @@ void FLMAPI f_mutexLock(
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
void FLMAPI f_mutexUnlock(
F_MUTEX hMutex)
{
@@ -184,7 +184,7 @@ void FLMAPI f_mutexUnlock(
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
void FLMAPI f_assertMutexLocked(
F_MUTEX)
{
@@ -194,7 +194,7 @@ void FLMAPI f_assertMutexLocked(
/****************************************************************************
Desc: Initializes a semaphore handle on UNIX
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FINLINE int sema_init(
sema_t * pSem)
{
@@ -222,7 +222,7 @@ Exit:
/****************************************************************************
Desc: Frees a semaphore handle on UNIX
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FINLINE void sema_destroy(
sema_t * pSem)
{
@@ -234,7 +234,7 @@ FINLINE void sema_destroy(
/****************************************************************************
Desc: Waits for a semaphore to be signaled on UNIX
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FINLINE int sema_wait(
sema_t * pSem)
{
@@ -270,7 +270,7 @@ Exit:
Desc: Waits a specified number of milliseconds for a semaphore
to be signaled on UNIX
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
FINLINE int sema_timedwait(
sema_t * pSem,
unsigned int msecs)
@@ -322,7 +322,7 @@ Exit:
/****************************************************************************
Desc: Signals a semaphore on UNIX
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
int sema_signal(
sema_t * pSem)
{
@@ -339,7 +339,7 @@ int sema_signal(
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE f_semCreate(
F_SEM * phSem)
{
@@ -369,7 +369,7 @@ Exit:
/****************************************************************************
Desc:
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
void f_semDestroy(
F_SEM * phSem)
{
@@ -387,7 +387,7 @@ void f_semDestroy(
/****************************************************************************
Desc: Get the lock on a semaphore - p operation
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
RCODE f_semWait(
F_SEM hSem,
FLMUINT uiTimeout)
@@ -424,7 +424,7 @@ RCODE f_semWait(
/****************************************************************************
Desc: Get the lock on a semaphore - p operation
****************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
void FLMAPI f_semSignal(
F_SEM hSem)
{
@@ -432,6 +432,77 @@ void FLMAPI f_semSignal(
}
#endif
/*************************************************************************
Desc:
*************************************************************************/
#if defined( FLM_RING_0_NLM)
RCODE FLMAPI f_semCreate(
F_SEM * phSem)
{
if( (*phSem = (F_SEM)kSemaphoreAlloc( (BYTE *)"NOVDB", 0)) == F_SEM_NULL)
{
return( RC_SET( NE_FLM_MEM));
}
return( NE_FLM_OK);
}
#endif
/*************************************************************************
Desc:
*************************************************************************/
#if defined( FLM_RING_0_NLM)
void FLMAPI f_semDestroy(
F_SEM * phSem)
{
if (*phSem != F_SEM_NULL)
{
(void)kSemaphoreFree( (SEMAPHORE)(*phSem));
*phSem = F_SEM_NULL;
}
}
#endif
/*************************************************************************
Desc:
*************************************************************************/
#if defined( FLM_RING_0_NLM)
RCODE FLMAPI f_semWait(
F_SEM hSem,
FLMUINT uiTimeout)
{
RCODE rc = NE_FLM_OK;
if( uiTimeout == F_SEM_WAITFOREVER)
{
if( kSemaphoreWait( (SEMAPHORE)hSem) != 0)
{
rc = RC_SET( NE_FLM_ERROR_WAITING_ON_SEMPAHORE);
}
}
else
{
if( kSemaphoreTimedWait( (SEMAPHORE)hSem, (UINT)uiTimeout) != 0)
{
rc = RC_SET( NE_FLM_ERROR_WAITING_ON_SEMPAHORE);
}
}
return( rc);
}
#endif
/*************************************************************************
Desc:
*************************************************************************/
#if defined( FLM_RING_0_NLM)
void FLMAPI f_semSignal(
F_SEM hSem)
{
(void)kSemaphoreSignal( (SEMAPHORE)hSem);
}
#endif
/****************************************************************************
Desc:
****************************************************************************/

340
ftk/src/ftksys.h
View File

@@ -28,6 +28,17 @@
#define FTKSYS_H
#include "ftk.h"
#ifdef FLM_NLM
#define FLM_RING_0_NLM
#endif
// #ifndef FLM_RING_0_NLM
// #define FLM_LIBC_NLM
// #endif
#if defined( FLM_RING_0_NLM) && defined( FLM_LIBC_NLM)
#error Cannot target both LIBC and RING 0
#endif
class F_FileHdl;
class F_Thread;
@@ -45,99 +56,13 @@
#define FLM_DEFAULT_OPEN_THRESHOLD 100
#define FLM_DEFAULT_MAX_AVAIL_TIME 900
#define FLM_MAX_KEY_SIZE 1024
#define FLM_NLM_SECTOR_SIZE 512
/****************************************************************************
Desc: NLM
****************************************************************************/
#if defined( FLM_NLM)
#if defined( FLM_WATCOM_NLM)
#pragma warning 007 9
// Disable "Warning! W549: col(XX) 'sizeof' operand contains
// compiler generated information"
#pragma warning 549 9
// Disable "Warning! W656: col(XX) define this function inside its class
// definition (may improve code quality)"
#pragma warning 656 9
// Disable Warning! W555: col(XX) expression for 'while' is always
// "false"
#pragma warning 555 9
#endif
#define _POSIX_SOURCE
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
#include <library.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <glob.h>
#include <netware.h>
#include <semaphore.h>
#include <malloc.h>
#include <novsock2.h>
// The typedef for va_list in stdarg.h do not function properly when
// a va_list is passed down multiple layers as a pointer (va_list *).
// Therefore, the following definitions/typedefs were taken from a
// "fixed" version of stdarg.h implemented by DS.
// typedef unsigned long f_va_list;
#define f_argsize(x) \
((sizeof(x)+sizeof(int)-1) & ~(sizeof(int)-1))
#define f_va_start(ap, parmN) \
((void)((ap) = (unsigned long)&(parmN) + f_argsize(parmN)))
#define f_va_arg(ap, type) \
(*(type *)(((ap) += f_argsize(type)) - (f_argsize(type))))
#define f_va_end(ap) ((void)0)
#ifndef _SIZE_T
#define _SIZE_T
typedef unsigned int size_t;
#endif
#ifndef _WCHAR_T
#define _WCHAR_T
typedef unsigned short wchar_t;
#endif
#ifndef WCHAR
#define WCHAR wchar_t
#endif
#ifndef LONG
#define LONG unsigned long
#endif
#ifndef BYTE
#define BYTE unsigned char
#endif
#ifndef UINT
#define UINT unsigned int
#endif
#define F_NETWARE_SECTOR_SIZE 512
FINLINE void * f_getNLMHandle( void)
{
return( getnlmhandle());
}
#include "ftknlm.h"
#endif
/****************************************************************************
@@ -181,9 +106,6 @@
#pragma warning( disable : 4710)
#define ENDLINE ENDLINE_CRLF
#define f_va_start va_start
#define f_va_arg va_arg
#define f_va_end va_end
#endif
@@ -244,10 +166,6 @@
#include <signal.h>
#endif
#define f_va_start va_start
#define f_va_arg va_arg
#define f_va_end va_end
typedef int SOCKET;
#define INVALID_SOCKET -1
@@ -1004,7 +922,7 @@
/***************************************************************************
Desc:
***************************************************************************/
#if defined( FLM_UNIX) || defined( FLM_NLM)
#if defined( FLM_UNIX)
class F_FileHdl : public IF_FileHdl
{
public:
@@ -1187,6 +1105,207 @@
friend class F_MultiFileHdl;
};
#endif
/***************************************************************************
Desc:
***************************************************************************/
#if defined( FLM_NLM)
class F_FileHdl : public IF_FileHdl
{
public:
F_FileHdl();
virtual ~F_FileHdl();
RCODE FLMAPI flush( void);
RCODE FLMAPI read(
FLMUINT64 ui64Offset,
FLMUINT uiLength,
void * pvBuffer,
FLMUINT * puiBytesRead);
RCODE FLMAPI seek(
FLMUINT64 ui64Offset,
FLMINT iWhence,
FLMUINT64 * pui64NewOffset);
RCODE FLMAPI size(
FLMUINT64 * pui64Size);
RCODE FLMAPI tell(
FLMUINT64 * pui64Offset);
RCODE FLMAPI truncate(
FLMUINT64 ui64Size);
RCODE FLMAPI write(
FLMUINT64 ui64Offset,
FLMUINT uiLength,
const void * pvBuffer,
FLMUINT * puiBytesWritten);
RCODE FLMAPI sectorRead(
FLMUINT64 ui64ReadOffset,
FLMUINT uiBytesToRead,
void * pvBuffer,
FLMUINT * puiBytesReadRV);
RCODE FLMAPI sectorWrite(
FLMUINT64 ui64WriteOffset,
FLMUINT uiBytesToWrite,
const void * pvBuffer,
FLMUINT uiBufferSize,
void * pvBufferObj,
FLMUINT * puiBytesWrittenRV,
FLMBOOL bZeroFill = TRUE);
RCODE FLMAPI close( void);
FLMBOOL FLMAPI canDoAsync( void);
FINLINE void FLMAPI setExtendSize(
FLMUINT uiExtendSize)
{
m_uiExtendSize = uiExtendSize;
}
FINLINE void FLMAPI setMaxAutoExtendSize(
FLMUINT uiMaxAutoExtendSize)
{
m_uiMaxAutoExtendSize = uiMaxAutoExtendSize;
}
FINLINE void FLMAPI setSuballocation(
FLMBOOL bDoSuballocation)
{
m_bDoSuballocation = bDoSuballocation;
}
FINLINE FLMUINT FLMAPI getSectorSize( void)
{
return( FLM_NLM_SECTOR_SIZE);
}
FINLINE FLMUINT FLMAPI getBlockSize( void)
{
return( m_uiBlockSize);
}
FINLINE FLMBOOL FLMAPI isReadOnly( void)
{
return( m_bOpenedReadOnly);
}
RCODE FLMAPI lock( void);
RCODE FLMAPI unlock( void);
FINLINE void FLMAPI setBlockSize(
FLMUINT uiBlockSize)
{
m_uiBlockSize = uiBlockSize;
}
private:
RCODE setup( void);
RCODE create(
const char * pszFileName,
FLMUINT uiIoFlags);
RCODE createUnique(
char * pszDirName,
const char * pszFileExtension,
FLMUINT uiIoFlags);
RCODE open(
const char * pszFileName,
FLMUINT uiIoFlags);
RCODE openOrCreate(
const char * pszFileName,
FLMUINT uiAccess,
FLMBOOL bCreateFlag);
RCODE _read(
FLMUINT uiOffset,
FLMUINT uiLength,
void * pvBuffer,
FLMUINT * puiBytesRead);
RCODE _directIORead(
FLMUINT uiOffset,
FLMUINT uiLength,
void * pvBuffer,
FLMUINT * puiBytesRead);
RCODE _directIOSectorRead(
FLMUINT uiReadOffset,
FLMUINT uiBytesToRead,
void * pvBuffer,
FLMUINT * puiBytesReadRV);
RCODE _write(
FLMUINT uiWriteOffset,
FLMUINT uiBytesToWrite,
const void * pvBuffer,
FLMUINT * puiBytesWrittenRV);
RCODE _directIOWrite(
FLMUINT uiWriteOffset,
FLMUINT uiBytesToWrite,
const void * pvBuffer,
FLMUINT * puiBytesWrittenRV);
RCODE expand(
LONG lStartSector,
LONG lSectorsToAlloc);
RCODE writeSectors(
void * pvBuffer,
LONG lStartSector,
LONG lSectorCount,
IF_IOBuffer * pBufferObj,
FLMBOOL * pbDidAsync = NULL);
RCODE _directIOSectorWrite(
FLMUINT uiWriteOffset,
FLMUINT uiBytesToWrite,
const void * pvBuffer,
IF_IOBuffer * pBufferObj,
FLMUINT * puiBytesWrittenRV,
FLMBOOL bZeroFill);
char * m_pszIoPath;
FLMBOOL m_bDeleteOnClose;
FLMUINT m_uiMaxFileSize;
FLMBOOL m_bFileOpened;
FLMBOOL m_bOpenedExclusive;
FLMBOOL m_bOpenedReadOnly;
FLMUINT m_uiBlockSize;
LONG m_lFileHandle;
LONG m_lOpenAttr;
LONG m_lVolumeID;
LONG m_lLNamePathCount;
FLMBOOL m_bDoSuballocation;
FLMUINT m_uiExtendSize;
FLMUINT m_uiMaxAutoExtendSize;
FLMBOOL m_bDoDirectIO;
LONG m_lSectorsPerBlock;
LONG m_lMaxBlocks;
FLMUINT m_uiCurrentPos;
FLMBOOL m_bNSS;
FLMINT64 m_NssKey;
FLMBOOL m_bNSSFileOpen;
friend class F_FileSystem;
friend class F_MultiFileHdl;
};
#endif
/***************************************************************************
Desc:
@@ -1371,7 +1490,7 @@
FLMUINT uiSearchAttrib;
} F_IO_FIND_DATA;
#elif defined( FLM_UNIX) || defined( FLM_NLM)
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
typedef struct
{
@@ -1384,6 +1503,18 @@
char dirpath[ F_PATH_MAX_SIZE];
glob_t globbuf;
} F_IO_FIND_DATA;
#elif defined( FLM_RING_0_NLM)
typedef struct
{
LONG m_lVolumeNumber;
LONG m_lDirectoryNumber;
LONG m_lCurrentEntryNumber;
struct DirectoryStructure * m_pCurrentItem;
char m_ucTempBuffer[ F_FILENAME_SIZE];
} F_IO_FIND_DATA;
#else
#error Platform not supported
@@ -2164,8 +2295,6 @@
RCODE f_allocDirHdl(
F_DirHdl ** ppDirHdl);
IF_FileSystem * f_getFileSysPtr( void);
IF_ThreadMgr * f_getThreadMgrPtr( void);
RCODE f_verifyMetaphoneRoutines( void);
@@ -2175,5 +2304,18 @@
void f_freeCharMappingTables( void);
IF_XML * f_getXmlObjPtr( void);
RCODE f_netwareRemoveDir(
const char * pszDirName);
RCODE f_netwareTestIfFileExists(
const char * pPath);
RCODE f_netwareDeleteFile(
const char * pPath);
RCODE f_netwareRenameFile(
const char * pOldFilePath,
const char * pNewFilePath);
#endif // FTKSYS_H

60
ftk/src/ftkthrd.cpp
View File

@@ -25,9 +25,13 @@
#include "ftksys.h"
#ifdef FLM_NLM
#ifdef FLM_LIBC_NLM
void * threadStub(
void * pvThread);
#elif defined( FLM_RING_0_NLM)
void * threadStub(
void * pvUnused,
void * pvThread);
#elif defined( FLM_WIN)
unsigned __stdcall threadStub(
void * pvThread);
@@ -396,10 +400,15 @@ RCODE FLMAPI F_Thread::startThread(
RCODE rc = NE_FLM_OK;
F_ThreadMgr * pThreadMgr = (F_ThreadMgr *)f_getThreadMgrPtr();
FLMBOOL bManagerMutexLocked = FALSE;
#ifdef FLM_NLM
#ifdef FLM_LIBC_NLM
pthread_attr_t thread_attr;
pthread_t uiThreadId;
#endif
#ifdef FLM_RING_0_NLM
#ifdef FLM_NLM
void * hThread = NULL;
#endif
#endif
#ifdef FLM_WIN
unsigned uiThreadId;
#endif
@@ -495,7 +504,7 @@ RCODE FLMAPI F_Thread::startThread(
goto Exit;
}
m_uiThreadId = (FLMUINT)uiThreadId;
#elif defined( FLM_NLM)
#elif defined( FLM_LIBC_NLM)
pthread_attr_init( &thread_attr);
pthread_attr_setdetachstate( &thread_attr, PTHREAD_CREATE_DETACHED);
@@ -508,6 +517,33 @@ RCODE FLMAPI F_Thread::startThread(
m_uiThreadId = (FLMUINT)uiThreadId;
pthread_attr_destroy( &thread_attr);
#elif defined( FLM_RING_0_NLM)
#elif defined( FLM_NLM)
if( (hThread = kCreateThread(
(BYTE *)((m_pszThreadName)
? (BYTE *)m_pszThreadName
: (BYTE *)"NDSDB"),
threadStub, NULL, (LONG)m_uiStackSize,
(void *)this)) == NULL)
{
rc = RC_SET( NE_FLM_COULD_NOT_START_THREAD);
goto Exit;
}
m_uiThreadId = (FLMUINT)hThread;
if( kSetThreadLoadHandle( hThread, (LONG)f_getNLMHandle()) != 0)
{
(void)kDestroyThread( hThread);
rc = RC_SET( NE_FLM_COULD_NOT_START_THREAD);
goto Exit;
}
if( kScheduleThread( hThread) != 0)
{
(void)kDestroyThread( hThread);
rc = RC_SET( NE_FLM_COULD_NOT_START_THREAD);
goto Exit;
}
#elif defined( FLM_UNIX)
#ifdef _POSIX_THREADS
pthread_attr_init( &thread_attr);
@@ -592,9 +628,13 @@ void FLMAPI F_Thread::stopThread( void)
Desc: Begins a new thread of execution and calls the passed function.
Performs generic thread init and cleanup functions.
****************************************************************************/
#ifdef FLM_NLM
#ifdef FLM_LIBC_NLM
void * threadStub(
void * pvThread)
#elif defined( FLM_RING_0_NLM)
void * threadStub(
void * pvUnused,
void * pvThread)
#elif defined( FLM_WIN)
unsigned __stdcall threadStub(
void * pvThread)
@@ -606,7 +646,11 @@ void * threadStub(
F_Thread * pThread = (F_Thread *)pvThread;
F_ThreadMgr * pThreadMgr = (F_ThreadMgr *)f_getThreadMgrPtr();
#if defined( FLM_UNIX) || defined( FLM_NLM)
#ifdef FLM_RING_0_NLM
F_UNREFERENCED_PARM( pvUnused);
#endif
#if defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
// Block all signals (main thread will handle all signals)
sigset_t mask;
@@ -660,6 +704,8 @@ void * threadStub(
#if defined( FLM_WIN)
_endthreadex( 0);
return( 0);
#elif defined( FLM_RING_0_NLM)
kExitThread( NULL);
#endif
#if defined( FLM_NLM) || defined( FLM_UNIX)
@@ -1324,8 +1370,10 @@ FLMUINT FLMAPI f_threadId( void)
{
#ifdef FLM_WIN
return( (FLMUINT)_threadid);
#elif defined( FLM_NLM) || defined( FLM_UNIX)
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
return( (FLMUINT)pthread_self());
#elif defined( FLM_RING_0_NLM)
return( (FLMUINT)kCurrentThread());
#else
#error Platform not supprted
#endif