FINLINE void releaseLockFile(
const char * pszBasePath,
FLMBOOL bDelete)
{
#ifndef FLM_UNIX
F_UNREFERENCED_PARM( bDelete);
F_UNREFERENCED_PARM( pszBasePath);
#endif
if( m_pLockFileHdl)
{
// Release the lock file
(void)m_pLockFileHdl->closeFile();
m_pLockFileHdl->Release();
m_pLockFileHdl = NULL;
#ifdef FLM_UNIX
if( bDelete)
{
IF_FileSystem * pFileSystem = f_getFileSysPtr();
char szTmpPath[ F_PATH_MAX_SIZE];
// Delete the lock file
f_strcpy( szTmpPath, pszBasePath);
pFileSystem->pathAppend( szTmpPath, "64.LCK");
pFileSystem->deleteFile( szTmpPath);
}
#endif
}
}
RCODE FTKAPI F_DirHdl::next( void)
{
char szFoundPath[ F_PATH_MAX_SIZE];
char szDummyPath[ F_PATH_MAX_SIZE];
FLMUINT uiSearchAttributes;
FLMUINT uiFoundAttrib;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( RC_BAD( m_rc))
{
goto Exit;
}
uiSearchAttributes =
F_IO_FA_NORMAL | F_IO_FA_RDONLY | F_IO_FA_ARCHIVE | F_IO_FA_DIRECTORY;
for( ;;)
{
if( m_bFirstTime)
{
m_bFirstTime = FALSE;
if( RC_BAD( m_rc = f_fileFindFirst( m_szDirectoryPath,
uiSearchAttributes, &m_FindData, szFoundPath, &uiFoundAttrib)))
{
goto Exit;
}
m_bFindOpen = TRUE;
m_uiAttrib = uiFoundAttrib;
}
else
{
if( RC_BAD( m_rc = f_fileFindNext( &m_FindData,
szFoundPath, &uiFoundAttrib)))
{
goto Exit;
}
m_uiAttrib = uiFoundAttrib;
}
if( RC_BAD( m_rc = pFileSystem->pathReduce( szFoundPath,
szDummyPath, m_szFileName)))
{
goto Exit;
}
if( pFileSystem->doesFileMatch( m_szFileName, m_szPattern))
{
break;
}
}
Exit:
return( m_rc);
}
FINLINE void dataFilePath(
FLMUINT uiFileNum,
char * pszPath)
{
char szFileName[ 13];
IF_FileSystem * pFileSystem = f_getFileSysPtr();
f_strcpy( pszPath, m_szPath);
formatFileNum( uiFileNum, szFileName);
pFileSystem->pathAppend( pszPath, szFileName);
}
RCODE f_fileFindNext(
F_IO_FIND_DATA * pFindData,
char * pszFoundPath,
FLMUINT * puiFoundAttrib)
{
RCODE rc = NE_FLM_OK;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( FindNextFile( pFindData->findHandle,
&(pFindData->findBuffer)) == FALSE)
{
rc = f_mapPlatformError( GetLastError(), NE_FLM_READING_FILE);
goto Exit;
}
// Loop until a file with correct attributes is found
for( ;;)
{
if( f_fileMeetsFindCriteria( pFindData))
{
break;
}
if( FindNextFile( pFindData->findHandle,
&(pFindData->findBuffer)) == FALSE)
{
rc = f_mapPlatformError( GetLastError(), NE_FLM_READING_FILE);
goto Exit;
}
}
// Append the file name to the path name
f_strcpy( pszFoundPath, pFindData->szSearchPath);
if( RC_BAD( rc = pFileSystem->pathAppend( pszFoundPath,
(char *)pFindData->findBuffer.cFileName)))
{
goto Exit;
}
// Return the found file attribute
*puiFoundAttrib = pFindData->findBuffer.dwFileAttributes;
Exit:
return( rc);
}
/****************************************************************************
Desc: Creates a new 64-bit "file"
****************************************************************************/
RCODE F_MultiFileHdl::createFile(
const char * pszPath)
{
RCODE rc = NE_FLM_OK;
FLMBOOL bCreatedDir = FALSE;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( m_bOpen)
{
rc = RC_SET_AND_ASSERT( NE_FLM_FAILURE);
goto Exit;
}
if( RC_BAD( rc = pFileSystem->createDir( pszPath)))
{
goto Exit;
}
f_strcpy( m_szPath, pszPath);
bCreatedDir = TRUE;
// Create the lock file
if( RC_BAD( rc = createLockFile( m_szPath)))
{
goto Exit;
}
// Initialize the EOF to 0 and set the state to open
m_ui64EOF = 0;
m_bOpen = TRUE;
Exit:
// Release the lock file
if( RC_BAD( rc))
{
(void)releaseLockFile( m_szPath, TRUE);
if( bCreatedDir)
{
(void)pFileSystem->removeDir( m_szPath);
}
}
return( rc);
}
RCODE FTKAPI 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.lVolumeNumber,
m_FindData.lDirectoryNumber, LONGNameSpace,
m_FindData.lCurrentEntryNumber, (BYTE *)"\x02\xFF*",
-1, &m_FindData.pCurrentItem,
&m_FindData.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.pCurrentItem->DFileName, m_szPattern))
{
break;
}
}
Exit:
return( m_rc);
}
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)
{
// If there were no more files found then return no more files
// instead of mapping to error path not found or io error.
// To return no more files ret_val is ENOENT (set in Find2)
// and errno is not set
if( iRetVal == ENOENT && errno == 0)
{
return( RC_SET( NE_FLM_IO_NO_MORE_FILES));
}
return( f_mapPlatformError( errno, NE_FLM_READING_FILE));
}
// Append the file name to the path name
f_strcpy( pszFoundPath, pFindData->search_path);
if( RC_BAD( rc = pFileSystem->pathAppend( pszFoundPath,
(char *)pFindData->name)))
{
goto Exit;
}
*puiFoundAttrib = (FLMUINT)ReturnAttributes(
pFindData->FileStat.st_mode, pszFoundPath);
Exit:
return( rc);
}
/****************************************************************************
Desc: Read the ini file and parse its contents
****************************************************************************/
RCODE FTKAPI F_IniFile::read(
const char * pszFileName)
{
RCODE rc = NE_FLM_OK;
FLMBOOL bMore = FALSE;
FLMBOOL bEOF = FALSE;
#define INITIAL_READ_BUF_SIZE 100
FLMUINT uiReadBufSize = 0;
FLMUINT uiBytesAvail = 0;
FLMUINT uiBytesInLine = 0;
char * pszReadBuf = NULL;
FLMUINT uiLineNum = 0;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
f_assert( m_bReady);
f_assert( !m_pFileHdl);
// Open the file
if (RC_BAD( rc = f_alloc( f_strlen( pszFileName) + 1, &m_pszFileName)))
{
goto Exit;
}
f_strcpy( m_pszFileName, pszFileName);
// It's not an error if the file doesn't exist. If it does exist,
// we'll read in its data.
if( RC_BAD( pFileSystem->openFile( pszFileName,
FLM_IO_RDONLY, &m_pFileHdl)))
{
goto Exit;
}
m_uiFileOffset = 0;
// Read in and parse the file
uiReadBufSize = INITIAL_READ_BUF_SIZE;
if (RC_BAD( rc = f_alloc( uiReadBufSize, &pszReadBuf)))
{
goto Exit;
}
// Read in and parse each line in the file...
while (!bEOF)
{
uiLineNum++;
uiBytesAvail = uiReadBufSize;
if( RC_BAD( rc = readLine( pszReadBuf, &uiBytesAvail, &bMore)) &&
rc != NE_FLM_IO_END_OF_FILE)
{
goto Exit;
}
if (rc == NE_FLM_IO_END_OF_FILE)
{
bEOF = TRUE;
}
// While there are more bytes in the line, re-alloc the buffer, and do
// another read.
uiBytesInLine = uiBytesAvail;
while( bMore)
{
uiBytesAvail = uiReadBufSize;
uiReadBufSize *= 2;
if (RC_BAD( rc = f_realloc( uiReadBufSize, &pszReadBuf)))
{
goto Exit;
}
if (RC_BAD( rc = readLine( pszReadBuf+uiBytesAvail,
&uiBytesAvail, &bMore)) &&
(rc != NE_FLM_IO_END_OF_FILE) )
{
goto Exit;
}
if( rc == NE_FLM_IO_END_OF_FILE)
{
bEOF = TRUE;
}
uiBytesInLine += uiBytesAvail;
}
if ( (RC_OK( rc) || (rc == NE_FLM_IO_END_OF_FILE)) &&
(uiBytesInLine > 0) )
{
// NumBytes will be 0 if the line was blank. No need
// to call parseBuffer in this case
if (RC_BAD( rc = parseBuffer( pszReadBuf, uiBytesInLine)))
{
if (rc == NE_FLM_SYNTAX)
{
rc = NE_FLM_OK;
}
else
{
goto Exit;
}
}
}
}
Exit:
// Close the file
if( m_pFileHdl)
{
m_pFileHdl->closeFile();
m_pFileHdl->Release();
m_pFileHdl = NULL;
}
// Free the buffer
if (pszReadBuf)
{
f_free( &pszReadBuf);
}
if (rc == NE_FLM_IO_END_OF_FILE)
{
rc = NE_FLM_OK;
}
return rc;
}
/****************************************************************************
Desc: This routine obtains exclusive access to a 64-bit file by creating
a .lck file. The object holds the .lck file open as long as the
64-bit file is open.
****************************************************************************/
RCODE F_MultiFileHdl::createLockFile(
const char * pszBasePath)
{
RCODE rc = NE_FLM_OK;
char szLockPath [F_PATH_MAX_SIZE];
F_FileHdl * pLockFileHdl = NULL;
FLMUINT uiIoFlags = FLM_IO_RDWR | FLM_IO_EXCL | FLM_IO_SH_DENYRW;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
f_strcpy( szLockPath, pszBasePath);
pFileSystem->pathAppend( szLockPath, "64.LCK");
// Attempt to create the lock file. If it fails, the lock file
// may have been left because of a crash. Hence, we first try
// to delete the file. If that succeeds, we then attempt to
// create the file again. If it, or the 2nd create fail, we simply
// return an access denied error.
if( RC_BAD( rc = f_allocFileHdl( &pLockFileHdl)))
{
goto Exit;
}
#ifndef FLM_UNIX
// On Unix, we do not want to delete the file because it
// will succeed even if someone else has the file open.
uiIoFlags |= FLM_IO_DELETE_ON_RELEASE;
#endif
if( RC_BAD( pLockFileHdl->createFile( szLockPath, uiIoFlags)))
{
#ifndef FLM_UNIX
if (RC_BAD( pFileSystem->deleteFile( szLockPath)))
{
rc = RC_SET( NE_FLM_IO_ACCESS_DENIED);
goto Exit;
}
else if (RC_BAD( pLockFileHdl->createFile( szLockPath, uiIoFlags)))
{
rc = RC_SET( NE_FLM_IO_ACCESS_DENIED);
goto Exit;
}
#else
if( RC_BAD( pLockFileHdl->openFile( szLockPath, uiIoFlags)))
{
rc = RC_SET( NE_FLM_IO_ACCESS_DENIED);
goto Exit;
}
#endif
}
#ifdef FLM_UNIX
if( RC_BAD( pLockFileHdl->lock()))
{
rc = RC_SET( NE_FLM_IO_ACCESS_DENIED);
goto Exit;
}
#endif
m_pLockFileHdl = pLockFileHdl;
pLockFileHdl = NULL;
Exit:
if (pLockFileHdl)
{
(void)pLockFileHdl->closeFile();
pLockFileHdl->Release();
pLockFileHdl = NULL;
}
return( rc);
}
/****************************************************************************
Desc: Returns the requested file handle
****************************************************************************/
RCODE F_MultiFileHdl::getFileHdl(
FLMUINT uiFileNum,
FLMBOOL bGetForWrite,
IF_FileHdl ** ppFileHdl)
{
RCODE rc = NE_FLM_OK;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
FLMUINT uiSlot;
IF_FileHdl * pTmpHdl;
char szPath[ F_PATH_MAX_SIZE];
f_assert( m_bOpen);
*ppFileHdl = NULL;
uiSlot = uiFileNum % F_MULTI_FHDL_LIST_SIZE;
pTmpHdl = m_pFileHdlList[ uiSlot].pFileHdl;
if( pTmpHdl && m_pFileHdlList[ uiSlot].uiFileNum != uiFileNum)
{
if( RC_BAD( rc = pTmpHdl->flush()))
{
goto Exit;
}
pTmpHdl->closeFile();
pTmpHdl->Release();
pTmpHdl = NULL;
f_memset( &m_pFileHdlList[ uiSlot], 0, sizeof( FH_INFO));
}
if( !pTmpHdl)
{
dataFilePath( uiFileNum, szPath);
if( RC_BAD( rc = pFileSystem->openFile( szPath,
FLM_IO_RDWR, &pTmpHdl)))
{
if( rc == NE_FLM_IO_PATH_NOT_FOUND && bGetForWrite)
{
if( RC_BAD( rc = pFileSystem->createFile( szPath,
FLM_IO_RDWR, &pTmpHdl)))
{
goto Exit;
}
}
else
{
goto Exit;
}
}
m_pFileHdlList[ uiSlot].pFileHdl = pTmpHdl;
m_pFileHdlList[ uiSlot].uiFileNum = uiFileNum;
f_assert( !m_pFileHdlList[ uiSlot].bDirty);
}
*ppFileHdl = m_pFileHdlList[ uiSlot].pFileHdl;
if( bGetForWrite)
{
m_pFileHdlList[ uiSlot].bDirty = TRUE;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Opens an existing 64-bit file
****************************************************************************/
RCODE F_MultiFileHdl::openFile(
const char * pszPath)
{
RCODE rc = NE_FLM_OK;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
IF_DirHdl * pDir = NULL;
FLMUINT uiTmp;
FLMUINT uiHighFileNum = 0;
FLMUINT64 ui64HighOffset = 0;
if( m_bOpen)
{
rc = RC_SET_AND_ASSERT( NE_FLM_FAILURE);
goto Exit;
}
if( RC_BAD( pFileSystem->doesFileExist( pszPath)) ||
!pFileSystem->isDir( pszPath))
{
rc = RC_SET( NE_FLM_IO_PATH_NOT_FOUND);
goto Exit;
}
f_strcpy( m_szPath, pszPath);
// Create the lock file
if( RC_BAD( rc = createLockFile( m_szPath)))
{
goto Exit;
}
// Need to determine the current EOF
if( RC_BAD( rc = pFileSystem->openDir( m_szPath, (char *)"*.64", &pDir)))
{
goto Exit;
}
// Find all data files to determine the EOF
for( rc = pDir->next(); !RC_BAD( rc); rc = pDir->next())
{
if( RC_OK( getFileNum( pDir->currentItemName(), &uiTmp)))
{
if( uiTmp >= uiHighFileNum)
{
uiHighFileNum = uiTmp;
ui64HighOffset = pDir->currentItemSize();
}
}
}
rc = NE_FLM_OK;
m_ui64EOF = (((FLMUINT64)uiHighFileNum) * m_uiMaxFileSize) + ui64HighOffset;
m_bOpen = TRUE;
Exit:
if( pDir)
{
pDir->Release();
}
// Release the lock file
if( RC_BAD( rc))
{
releaseLockFile( m_szPath, FALSE);
}
return( rc);
}
/****************************************************************************
Desc: Creates a new 64-bit file with a unique, generated name
****************************************************************************/
RCODE F_MultiFileHdl::createUniqueFile(
const char * pszPath, // Directory where the file is to be created
const char * pszFileExtension) // Extension to be used on the new file.
{
RCODE rc = NE_FLM_OK;
FLMUINT uiCount;
FLMBOOL bModext = TRUE;
FLMBOOL bCreatedDir = FALSE;
FLMUINT uiBaseTime = 0;
FLMBYTE ucHighByte = 0;
char szDirName[ F_FILENAME_SIZE];
char szTmpPath[ F_PATH_MAX_SIZE];
char szBasePath[ F_PATH_MAX_SIZE];
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( m_bOpen)
{
rc = RC_SET_AND_ASSERT( NE_FLM_FAILURE);
goto Exit;
}
if( !pszPath || pszPath[ 0] == '\0')
{
#if defined( FLM_UNIX)
f_strcpy( szBasePath, "./");
#elif defined( FLM_NLM)
f_strcpy( szBasePath, "SYS:_NETWARE");
#else
szBasePath[ 0] = '\0';
#endif
}
else
{
f_strcpy( szBasePath, pszPath);
}
if ((pszFileExtension) && (f_strlen( pszFileExtension) >= 3))
{
bModext = FALSE;
}
uiCount = 0;
szDirName[ 0] = '\0';
do
{
pFileSystem->pathCreateUniqueName( &uiBaseTime, szDirName,
pszFileExtension, &ucHighByte, bModext);
f_strcpy( szTmpPath, szBasePath);
pFileSystem->pathAppend( szTmpPath, szDirName);
rc = pFileSystem->createDir( szTmpPath);
} while ((rc != NE_FLM_OK) && (uiCount++ < 20));
if( RC_BAD( rc))
{
goto Exit;
}
f_strcpy( m_szPath, szTmpPath);
bCreatedDir = TRUE;
// Create the lock file
if( RC_BAD( rc = createLockFile( m_szPath)))
{
goto Exit;
}
// Initialize the EOF to 0 and set the state to open
m_ui64EOF = 0;
m_bOpen = TRUE;
Exit:
// Release the lock file
if( RC_BAD( rc))
{
releaseLockFile( m_szPath, TRUE);
if( bCreatedDir)
{
(void)pFileSystem->removeDir( m_szPath);
}
}
return( rc);
}
/****************************************************************************
Desc: Removes a 64-bit file
****************************************************************************/
RCODE F_MultiFileHdl::deleteMultiFile(
const char * pszPath)
{
RCODE rc = NE_FLM_OK;
IF_DirHdl * pDir = NULL;
char szTmpPath[ F_PATH_MAX_SIZE];
IF_FileSystem * pFileSystem = f_getFileSysPtr();
// Can't use this handle to delete something if we already
// have a file open.
if( m_bOpen)
{
// Can't jump to exit, because it calls releaseLockFile
return( RC_SET_AND_ASSERT( NE_FLM_FAILURE));
}
if( RC_BAD( rc = pFileSystem->doesFileExist( pszPath)))
{
goto Exit;
}
if( !pFileSystem->isDir( pszPath))
{
// If the path specifies a single file rather than a
// 64-bit directory, just go ahead and delete the file.
rc = pFileSystem->deleteFile( pszPath);
goto Exit;
}
if( RC_BAD( rc = createLockFile( pszPath)))
{
goto Exit;
}
if( RC_OK( pFileSystem->openDir( pszPath, "*.64", &pDir)))
{
// Remove all data files
for( rc = pDir->next(); !RC_BAD( rc) ; rc = pDir->next())
{
pDir->currentItemPath( szTmpPath);
f_assert( f_strstr( szTmpPath, ".64") != 0);
(void)pFileSystem->deleteFile( szTmpPath);
}
pDir->Release();
pDir = NULL;
rc = NE_FLM_OK;
}
// Release and delete the lock file
(void)releaseLockFile( pszPath, TRUE);
// Remove the directory
(void)pFileSystem->removeDir( pszPath);
Exit:
(void)releaseLockFile( pszPath, FALSE);
return( rc);
}
/****************************************************************************
Desc: Copies the data stored in the INI_LINE structs to the ini file
****************************************************************************/
RCODE FTKAPI F_IniFile::write( void)
{
RCODE rc = NE_FLM_OK;
FLMUINT uiBytesWritten;
INI_LINE * pCurLine = NULL;
FLMUINT uiFileOffset = 0;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
f_assert( m_bReady);
if (!m_bModified)
{
// Nothing needs to be written
goto Exit;
}
// Open the file
f_assert( !m_pFileHdl);
if (RC_BAD( rc = pFileSystem->createFile( m_pszFileName,
FLM_IO_RDWR, &m_pFileHdl)))
{
goto Exit;
}
pCurLine = m_pFirstLine;
while (pCurLine)
{
if (pCurLine->pszParamName)
{
// Output the param name
if (RC_BAD (rc = m_pFileHdl->write( uiFileOffset,
f_strlen( pCurLine->pszParamName), pCurLine->pszParamName,
&uiBytesWritten)))
{
goto Exit;
}
uiFileOffset += uiBytesWritten;
if (pCurLine->pszParamValue)
{
// Output the "=" and the value
if (RC_BAD (rc = m_pFileHdl->write( uiFileOffset, 1,
(void *)"=", &uiBytesWritten)))
{
goto Exit;
}
uiFileOffset += uiBytesWritten;
if (RC_BAD (rc = m_pFileHdl->write( uiFileOffset,
f_strlen( pCurLine->pszParamValue), pCurLine->pszParamValue,
&uiBytesWritten)))
{
goto Exit;
}
uiFileOffset += uiBytesWritten;
}
}
if (pCurLine->pszComment)
{
// Output the comment
if (pCurLine->pszParamName)
{
if (RC_BAD (rc = m_pFileHdl->write( uiFileOffset, 2,
(void *)" #", &uiBytesWritten)))
{
goto Exit;
}
}
else
{
if (RC_BAD (rc = m_pFileHdl->write( uiFileOffset, 1,
(void *)"#", &uiBytesWritten)))
{
goto Exit;
}
}
uiFileOffset += uiBytesWritten;
if (RC_BAD (rc = m_pFileHdl->write( uiFileOffset,
f_strlen( pCurLine->pszComment), pCurLine->pszComment,
&uiBytesWritten)))
{
goto Exit;
}
uiFileOffset += uiBytesWritten;
}
// Write out a newline...
if (RC_BAD (rc = m_pFileHdl->write( uiFileOffset, f_strlen( "\n"),
(void *)"\n", &uiBytesWritten)))
{
goto Exit;
}
uiFileOffset += uiBytesWritten;
pCurLine = pCurLine->pNext;
}
m_bModified = FALSE;
Exit:
if (m_pFileHdl)
{
m_pFileHdl->closeFile();
m_pFileHdl->Release();
m_pFileHdl = NULL;
}
return( rc);
}
RCODE FTKAPI F_DirHdl::createDir(
const char * pszDirPath)
{
RCODE rc = NE_FLM_OK;
char * pszParentDir = NULL;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( RC_BAD( rc = f_alloc( F_PATH_MAX_SIZE, &pszParentDir)))
{
goto Exit;
}
// Discover the parent directory of the given one
if( RC_BAD( rc = pFileSystem->pathReduce( pszDirPath,
pszParentDir, NULL)))
{
goto Exit;
}
// If pathReduce couldn't reduce the path at all, then an
// invalid path was supplied.
if( f_strcmp( pszDirPath, pszParentDir) == 0)
{
rc = RC_SET( NE_FLM_IO_INVALID_FILENAME);
goto Exit;
}
// If a parent directory was found, and it doesn't already exist, create it
if( *pszParentDir)
{
// If the "parent" is actually a regular file we need to return an error
if( RC_OK( pFileSystem->doesFileExist( pszParentDir)))
{
if( !pFileSystem->isDir( pszParentDir))
{
rc = RC_SET( NE_FLM_IO_ACCESS_DENIED);
goto Exit;
}
}
else if( RC_BAD( rc = createDir( pszParentDir)))
{
goto Exit;
}
}
#if defined( FLM_WIN)
if( !CreateDirectory((LPTSTR)pszDirPath, NULL))
{
rc = f_mapPlatformError( GetLastError(), NE_FLM_CREATING_FILE);
}
#elif defined( FLM_UNIX) || defined( FLM_LIBC_NLM)
if( mkdir( (char *)pszDirPath, 0777) == -1)
{
rc = f_mapPlatformError( errno, NE_FLM_CREATING_FILE);
}
#endif
Exit:
if( pszParentDir)
{
f_free( &pszParentDir);
}
return( rc);
}
/****************************************************************************
Desc:
****************************************************************************/
RCODE createUnitTest(
const char * configPath,
const char * buildNum,
const char * environment,
const char * user,
unitTestData * uTD)
{
RCODE rc = FERR_OK;
IF_FileHdl * pConfigFileHdl = NULL;
IF_FileHdl * pCSVFileHdl = NULL;
FLMBYTE buffer[ MAX_BUFFER_SIZE] = "";
FLMUINT uiSize = MAX_BUFFER_SIZE;
FLMUINT64 ui64Tmp;
char * strPos1 = NULL;
char * strPos2 = NULL;
IF_FileSystem * pFileSystem = NULL;
if( !configPath || !buildNum || !environment || !uTD || !user)
{
flmAssert(0);
}
if( f_strlen(user) > MAX_SMALL_BUFFER_SIZE)
{
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
goto Exit;
}
else
{
f_strcpy( uTD->userName, user);
}
if( f_strlen(environment) > MAX_SMALL_BUFFER_SIZE)
{
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
goto Exit;
}
else
{
f_strcpy( uTD->environment, environment);
}
if( f_strlen( buildNum) > MAX_SMALL_BUFFER_SIZE)
{
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
goto Exit;
}
else
{
f_strcpy( uTD->buildNumber, buildNum);
}
if( RC_BAD( rc = FlmGetFileSystem( &pFileSystem)))
{
goto Exit;
}
if( configPath[ 0])
{
if( RC_BAD( rc = pFileSystem->openFile(
configPath, FLM_IO_RDONLY | FLM_IO_SH_DENYNONE, &pConfigFileHdl)))
{
goto Exit;
}
if( RC_BAD( rc = pConfigFileHdl->size( &ui64Tmp)))
{
goto Exit;
}
uiSize = (FLMUINT)ui64Tmp;
if( RC_BAD( rc = pConfigFileHdl->read( 0, uiSize, buffer, &uiSize)))
{
goto Exit;
}
#ifdef FLM_WIN
{
char szTemp[ MAX_BUFFER_SIZE];
char * pszTemp = szTemp;
FLMUINT uiNewSize = uiSize;
for( unsigned int i = 0; i < uiSize; i++)
{
if( ((i + 1) < uiSize)
&& (buffer[i] == 0x0D && buffer[ i + 1] == 0x0A))
{
*pszTemp++ = 0x0A;
i++;
uiNewSize--;
}
else
{
*pszTemp++ = buffer[ i];
}
}
f_memcpy( buffer, szTemp, uiNewSize);
uiSize = uiNewSize;
}
#endif
// Get the FOLDER
strPos1 = f_strchr( (const char *)buffer, ':');
strPos2 = f_strchr( (const char *)strPos1, '\n');
if( !strPos1 || !strPos2)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
for( strPos1++; *strPos1 == ' ' || *strPos1 == '\t'; strPos1++);
if( strPos2-strPos1 > MAX_SMALL_BUFFER_SIZE)
{
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
goto Exit;
}
f_strncpy( uTD->folder, strPos1, strPos2-strPos1);
uTD->folder[ strPos2 - strPos1] = '\0';
// Get the ATTRIBUTES
strPos1 = f_strchr( (const char *)strPos1, ':');
strPos2 = f_strchr( (const char *)strPos1, '\n');
if( !strPos1 || !strPos2)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
for( strPos1++;*strPos1 == ' ' || *strPos1 == '\t';strPos1++);
if( strPos2-strPos1 > MAX_SMALL_BUFFER_SIZE)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
f_strncpy( uTD->attrs, strPos1, strPos2-strPos1);
uTD->attrs[strPos2-strPos1] = '\0';
// Get the CSVFILE
strPos1 = f_strchr( (const char *)strPos1, ':');
strPos2 = f_strchr( (const char *)strPos1, '\n');
// Allow for possible \r
if( *( --strPos2) != '\r')
{
strPos2++;
}
if( !strPos1 || !strPos2)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
for( strPos1++;*strPos1 == ' ' || *strPos1 == '\t';strPos1++);
if( strPos2-strPos1 > MAX_SMALL_BUFFER_SIZE)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
f_strncpy( uTD->csvFilename, strPos1, strPos2-strPos1);
uTD->csvFilename[ strPos2 - strPos1] = '\0';
if( RC_BAD( rc = pFileSystem->openFile( uTD->csvFilename,
FLM_IO_RDWR | FLM_IO_SH_DENYNONE, &pCSVFileHdl)))
{
if ( rc == FERR_IO_PATH_NOT_FOUND)
{
// Create the file and write the header
if( RC_BAD( rc = f_filecat( uTD->csvFilename, DATA_ORDER)))
{
goto Exit;
}
}
}
else
{
goto Exit;
}
}
Exit:
if( pConfigFileHdl)
{
pConfigFileHdl->Release();
}
if( pCSVFileHdl)
{
pCSVFileHdl->Release();
}
if( pFileSystem)
{
pFileSystem->Release();
}
return( rc);
}
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};
int iRetVal;
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( !pszSearchPath)
{
rc = RC_SET( NE_FLM_IO_PATH_NOT_FOUND);
goto Exit;
}
f_strcpy( szTmpPath, pszSearchPath);
if( RC_BAD( rc = pFileSystem->pathAppend( szTmpPath, pszWildCard)))
{
goto Exit;
}
f_memset( pFindData, 0, sizeof( F_IO_FIND_DATA));
if( uiSearchAttrib & F_IO_FA_DIRECTORY)
{
pFindData->mode_flag |= S_IFDIR;
}
if( uiSearchAttrib & F_IO_FA_RDONLY)
{
pFindData->mode_flag |= S_IREAD;
}
iRetVal = Find1( (char*)szTmpPath, pFindData);
if( iRetVal != 0)
{
// If there were no more files found then return no more files
// instead of mapping to error path not found or io error.
// To return no more files ret_val is ENOENT (set in Find2)
// and errno is not set
if( iRetVal == ENOENT && errno == 0)
{
rc = RC_SET( NE_FLM_IO_NO_MORE_FILES);
}
else
{
rc = f_mapPlatformError( errno, NE_FLM_READING_FILE);
}
goto Exit;
}
// filter out ".." (PARENT) and "." (CURRENT) directories
if( uiSearchAttrib & F_IO_FA_DIRECTORY )
{
while( (f_strcmp( pFindData->name, "..") == 0) ||
(f_strcmp( pFindData->name, ".") == 0))
{
if( (iRetVal = Find2( pFindData)) != 0)
{
// If there were no more files found then return no more files
// instead of mapping to error path not found or io error.
// To return no more files ret_val is ENOENT (set in Find2)
// and errno is not set
if( iRetVal == ENOENT && errno == 0)
{
rc = RC_SET( NE_FLM_IO_NO_MORE_FILES);
}
else
{
rc = f_mapPlatformError( errno, NE_FLM_READING_FILE);
}
goto Exit;
}
}
}
// Append the file name to the path name
f_strcpy( pszFoundPath, pszSearchPath);
if( RC_BAD( rc = pFileSystem->pathAppend( pszFoundPath,
(char *)pFindData->name)))
{
goto Exit;
}
*puiFoundAttrib = (FLMUINT)ReturnAttributes(
pFindData->FileStat.st_mode, pszFoundPath);
// Save the search path in the NE_FLM_IO_FIND_DATA struct
// for a find next call
f_strcpy( pFindData->search_path, pszSearchPath);
Exit:
return( rc);
}
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];
char * pszWildCard = "*.*";
IF_FileSystem * pFileSystem = f_getFileSysPtr();
f_memset( pFindData, 0, sizeof( F_IO_FIND_DATA));
pFindData->findHandle = INVALID_HANDLE_VALUE;
pFindData->uiSearchAttrib = uiSearchAttrib;
if( !pszSearchPath)
{
rc = RC_SET( NE_FLM_IO_PATH_NOT_FOUND);
goto Exit;
}
f_strcpy( pFindData->szSearchPath, pszSearchPath);
if( uiSearchAttrib & F_IO_FA_NORMAL )
{
uiSearchAttrib |= F_IO_FA_ARCHIVE;
}
f_strcpy( szTmpPath, pszSearchPath);
if( RC_BAD( rc = pFileSystem->pathAppend( szTmpPath, pszWildCard)))
{
goto Exit;
}
if( (pFindData->findHandle = FindFirstFile( (LPTSTR)szTmpPath,
&(pFindData->findBuffer))) == INVALID_HANDLE_VALUE)
{
rc = f_mapPlatformError( GetLastError(), NE_FLM_OPENING_FILE);
goto Exit;
}
// Loop until a file with correct attributes is found
for( ;;)
{
if( f_fileMeetsFindCriteria( pFindData))
{
break;
}
if( FindNextFile( pFindData->findHandle,
&(pFindData->findBuffer)) == FALSE)
{
rc = f_mapPlatformError( GetLastError(), NE_FLM_READING_FILE);
goto Exit;
}
}
// Append the file name to the path name
f_strcpy( pszFoundPath, pFindData->szSearchPath);
if( RC_BAD( rc = pFileSystem->pathAppend( pszFoundPath,
(char *)pFindData->findBuffer.cFileName)))
{
goto Exit;
}
// Return the found file attribute
*puiFoundAttrib = pFindData->findBuffer.dwFileAttributes;
Exit:
if( RC_BAD( rc) && pFindData &&
pFindData->findHandle != INVALID_HANDLE_VALUE)
{
f_fileFindClose( pFindData);
}
return( rc);
}
/****************************************************************************
Desc:
*****************************************************************************/
RCODE F_DynamicList::dumpToFile()
{
RCODE rc = NE_FLM_OK;
DLIST_NODE * pTmp;
FLMUINT uiLoop;
IF_FileHdl * pFileHdl = NULL;
#define DLST_RESP_SIZE 256
char szResponse[ DLST_RESP_SIZE];
FLMUINT uiTermChar;
FTX_SCREEN * pScreen;
IF_FileSystem * pFileSystem = NULL;
if( RC_BAD( rc = FlmGetFileSystem( &pFileSystem)))
{
goto Exit;
}
f_strcpy( szResponse, (const char *)DLIST_DUMPFILE_PATH);
FTXWinGetScreen( m_pListWin, &pScreen);
FTXGetInput(
pScreen,
"enter filename to dump to",
szResponse,
DLST_RESP_SIZE-1,
&uiTermChar);
if ( uiTermChar != FKB_ENTER)
{
goto Exit;
}
if (RC_BAD( rc = pFileSystem->doesFileExist( szResponse)))
{
//create file if it doesn't already exist
if ( rc == NE_FLM_IO_PATH_NOT_FOUND)
{
rc = pFileSystem->createFile( szResponse, FLM_IO_RDWR, &pFileHdl);
}
else
{
goto Exit_local;
}
}
else
{
rc = pFileSystem->openFile( szResponse, FLM_IO_RDWR, &pFileHdl);
}
TEST_RC_LOCAL( rc);
{
FLMUINT64 ui64FileSize = 0;
FLMUINT uiBytesWritten = 0;
//figure out size of file currently, so you can append to it
pFileHdl->size( &ui64FileSize);
pTmp = m_pFirst;
uiLoop = 0;
while( pTmp)
{
FLMBYTE * pszNextLine = (FLMBYTE*)(pTmp->pvData);
TEST_RC_LOCAL( rc = pFileHdl->write(
ui64FileSize, //offset to current file size
f_strlen( (const char *)pszNextLine),
pszNextLine,
&uiBytesWritten));
ui64FileSize += uiBytesWritten;
TEST_RC_LOCAL( rc = pFileHdl->write(
ui64FileSize, //add in newline
1,
(FLMBYTE*)"\n",
&uiBytesWritten));
ui64FileSize += uiBytesWritten;
pTmp = pTmp->pNext;
}
(void)pFileHdl->closeFile();
}
Exit_local:
{//give success/fail message
char szMessage[ 256];
FLMUINT uiChar;
FTXWinGetScreen( m_pListWin, &pScreen);
if ( RC_OK( rc))
{
f_sprintf( szMessage,
"contents of focused list appended to %s", DLIST_DUMPFILE_PATH);
}
else
{
f_sprintf( szMessage, "error rc=%u dumping to file %s",
(unsigned)rc, DLIST_DUMPFILE_PATH);
}
FTXDisplayMessage( pScreen, FLM_RED, FLM_WHITE, szMessage,
"press ESC or ENTER to close dialog", &uiChar);
}
Exit:
if (pFileHdl)
{
pFileHdl->Release();
pFileHdl = NULL;
}
if( pFileSystem)
{
pFileSystem->Release();
}
return rc;
}
/****************************************************************************
Desc: Closes all data files associated with the object
****************************************************************************/
void F_MultiFileHdl::closeFile(
FLMBOOL bDelete)
{
RCODE rc = NE_FLM_OK;
FLMUINT uiLoop;
IF_DirHdl * pDir = NULL;
char szTmpPath[ F_PATH_MAX_SIZE];
IF_FileSystem * pFileSystem = f_getFileSysPtr();
if( !m_bOpen)
{
return;
}
for( uiLoop = 0; uiLoop < F_MULTI_FHDL_LIST_SIZE; uiLoop++)
{
if( m_pFileHdlList[ uiLoop].pFileHdl)
{
if( m_pFileHdlList[ uiLoop].bDirty)
{
(void)m_pFileHdlList[ uiLoop].pFileHdl->flush();
}
m_pFileHdlList[ uiLoop].pFileHdl->closeFile();
m_pFileHdlList[ uiLoop].pFileHdl->Release();
f_memset( &m_pFileHdlList[ uiLoop], 0, sizeof( FH_INFO));
}
}
m_ui64EOF = 0;
m_bOpen = FALSE;
if( bDelete)
{
if( RC_OK( pFileSystem->openDir(
m_szPath, "*.64", &pDir)))
{
// Remove all data files
for( rc = pDir->next(); !RC_BAD( rc) ; rc = pDir->next())
{
pDir->currentItemPath( szTmpPath);
f_assert( f_strstr( szTmpPath, ".64") != 0);
(void)pFileSystem->deleteFile( szTmpPath);
}
pDir->Release();
pDir = NULL;
}
// Release and delete the lock file
(void)releaseLockFile( m_szPath, TRUE);
// Remove the directory
(void)pFileSystem->removeDir( m_szPath);
}
else
{
(void)releaseLockFile( m_szPath, FALSE);
}
}
