bool indri::index::DiskKeyfileVocabularyIterator::nextEntry(const char *skipTo) {
assert(skipTo!=NULL);
if (_justStartedIteration) {
// position the iterator at the first
// item that matches...
_justStartedIteration=false;
// get an iterator to the first term here
indri::file::BulkTreeIterator *findIterator=_bulkTree.findFirst(skipTo);
if (!findIterator) return false;
// replace the current iterator with the new one
if (_bulkIterator) delete _bulkIterator;
_bulkIterator=findIterator;
if (!_readData()) return false;
} else {
// get the next item...
// assume all items w/ the same prefix are clumped together
_bulkIterator->nextEntry();
if (!_readData()) return false;
}
// make sure we're not at the end
if (_bulkIterator->finished()) {
return false;
}
// get the current entry
indri::index::DiskTermData* thisEntry=currentEntry();
if (!thisEntry) return false;
// make sure we're still in the patten
if (strstr(thisEntry->termData->term, skipTo)==thisEntry->termData->term) {
return true;
}
// just to be certain - check the next entry...
// read the next item...
_bulkIterator->nextEntry();
if (!_readData()) return false;
// ensure we're not finished
if (_bulkIterator->finished()) return false;
// get the next entry...
thisEntry=currentEntry();
if (!thisEntry) return false;
// check it.
if (strstr(thisEntry->termData->term, skipTo)==thisEntry->termData->term) {
return true;
}
// ok - I'm satisfied that we're done...
return false;
}
void indri::index::DiskKeyfileVocabularyIterator::startIteration() {
_acquire();
_bulkIterator->startIteration();
_readData();
_justStartedIteration=true;
}
void AbstractCommand::setSocket(QTcpSocket* socket)
{
debugOutput(0, "AbstractCommand::setSocket()");
Q_ASSERT(socket);
m_socket = socket;
connect(m_socket, SIGNAL(readyRead()), this, SLOT(_readData()));
reportSuccess();
}
bool IsoFilesystem::getFileData(file_handle_t iFile, unsigned char *pBuffer)
{
if(iFile <= 0 || static_cast<size_t>(iFile) > m_iNumFiles)
{
_setError("Invalid file handle.");
return false;
}
else
{
return _seekToSector(m_pFiles[iFile - 1].iSector) &&
_readData(m_pFiles[iFile - 1].iSize, pBuffer);
}
}
bool IsoFilesystem::initialise(FILE* fRawFile)
{
m_fRawFile = fRawFile;
_clear();
// Until we know better, assume that sectors are 2048 bytes.
m_iSectorSize = 2048;
// The first 16 sectors are reserved for bootable media.
// Volume descriptor records follow this, with one record per sector.
for(uint32_t iSector = 16; _seekToSector(iSector); ++iSector)
{
unsigned char aBuffer[190];
if(!_readData(sizeof(aBuffer), aBuffer))
break;
// CD001 is a standard identifier, \x01 is a version number
if(memcmp(aBuffer + 1, "CD001\x01", 6) == 0)
{
if(aBuffer[0] == VDT_PRIVARY_VOLUME)
{
m_iSectorSize = ReadNativeInt<uint16_t>(aBuffer + 128);
_findHospDirectory(aBuffer + 156, 34, 0);
if(m_iNumFiles == 0)
{
_setError("Could not find Theme Hospital data directory.");
return false;
}
else
{
return true;
}
}
else if(aBuffer[0] == VDT_TERMINATOR)
break;
}
}
_setError("Could not find primary volume descriptor.");
return false;
}
bool indri::index::DiskKeyfileVocabularyIterator::nextEntry() {
_bulkIterator->nextEntry();
_justStartedIteration=false;
return _readData();
}
bool CScriptFunctionData::readDataFromStack_scriptFunctionCall(int stackHandle,const int* expectedArguments,int requiredArgumentCount,const char* functionName)
{ // use this when reading data returned from a Lua function call from a plugin
bool retVal=_readData(stackHandle,expectedArguments,requiredArgumentCount,functionName,"return arguments.","Return argument ",_outData);
simPopStackItem(stackHandle,0); // clears the stack
return(retVal);
}
bool CScriptFunctionData::readDataFromStack(int stackHandle,const int* expectedArguments,int requiredArgumentCount,const char* functionName)
{ // use this when reading data from a script from inside of a custom script function call
bool retVal=_readData(stackHandle,expectedArguments,requiredArgumentCount,functionName,"arguments.","Argument ",_inData);
simPopStackItem(stackHandle,0); // clears the stack (which will serve as return value container from now)
return(retVal);
}
void IsoFilesystem::_buildFileLookupTable(uint32_t iSector, int iDirEntsSize, const char* sPrefix)
{
// Sanity check
// Apart from at the root level, directory record arrays must take up whole
// sectors, whose sizes are powers of two and at least 2048.
// Path lengths shouldn't exceed 256 either (or at least not for the files
// which we're interested in).
size_t iLen = strlen(sPrefix);
if((iLen != 0 && (iDirEntsSize & 0x7FF)) || (iLen > 256))
return;
unsigned char *pBuffer = new unsigned char[iDirEntsSize];
if(!_seekToSector(iSector) || !_readData(iDirEntsSize, pBuffer))
{
delete[] pBuffer;
return;
}
unsigned char *pDirEnt = pBuffer;
for(; iDirEntsSize > 0; iDirEntsSize -= *pDirEnt, pDirEnt += *pDirEnt)
{
// There is zero padding so that no record spans multiple sectors.
if(*pDirEnt == 0)
{
--iDirEntsSize, ++pDirEnt;
continue;
}
uint32_t iDataSector = ReadNativeInt<uint32_t>(pDirEnt + 2);
uint32_t iDataLength = ReadNativeInt<uint32_t>(pDirEnt + 10);
uint8_t iFlags = pDirEnt[25];
uint8_t iIdentLength = pDirEnt[32];
_trimIdentifierVersion(pDirEnt + 33, iIdentLength);
// Build new path
char *sPath = new char[iLen + iIdentLength + 2];
memcpy(sPath, sPrefix, iLen);
#ifdef _MSC_VER
#pragma warning(disable: 4996)
#endif
std::transform(pDirEnt + 33, pDirEnt + 33 + iIdentLength, sPath + iLen, _normalise);
#ifdef _MSC_VER
#pragma warning(default: 4996)
#endif
sPath[iLen + iIdentLength] = 0;
if(iFlags & DEF_DIRECTORY)
{
// None of the directories which we're interested in have length 1.
// This also avoids the dummy "current" and "parent" directories.
if(iIdentLength > 1)
{
sPath[iLen + iIdentLength] = m_cPathSeparator;
sPath[iLen + iIdentLength + 1] = 0;
_buildFileLookupTable(iDataSector, iDataLength, sPath);
}
}
else
{
_file_t *pFile = _allocFileRecord();
pFile->sPath = sPath;
pFile->iSector = iDataSector;
pFile->iSize = iDataLength;
sPath = NULL;
}
delete[] sPath;
}
delete[] pBuffer;
if(iLen == 0)
{
// The lookup table will be ordered by the underlying ordering of the
// disk, which isn't quite the ordering we want.
qsort(m_pFiles, m_iNumFiles, sizeof(_file_t), _fileNameComp);
}
}
int IsoFilesystem::_findHospDirectory(const unsigned char *pDirEnt, int iDirEntsSize, int iLevel)
{
// Sanity check
// Apart from at the root level, directory record arrays must take up whole
// sectors, whose sizes are powers of two and at least 2048.
// The formal limit on directory depth is 8, so hitting 16 is insane.
if((iLevel != 0 && (iDirEntsSize & 0x7FF)) || iLevel > 16)
return 0;
unsigned char *pBuffer = NULL;
uint32_t iBufferSize = 0;
for(; iDirEntsSize > 0; iDirEntsSize -= *pDirEnt, pDirEnt += *pDirEnt)
{
// There is zero padding so that no record spans multiple sectors.
if(*pDirEnt == 0)
{
--iDirEntsSize, ++pDirEnt;
continue;
}
uint32_t iDataSector = ReadNativeInt<uint32_t>(pDirEnt + 2);
uint32_t iDataLength = ReadNativeInt<uint32_t>(pDirEnt + 10);
uint8_t iFlags = pDirEnt[25];
uint8_t iIdentLength = pDirEnt[32];
_trimIdentifierVersion(pDirEnt + 33, iIdentLength);
if(iFlags & DEF_DIRECTORY)
{
// The names "\x00" and "\x01" are used for the current directory
// the parent directory respectively. We only want to visit these
// when at the root level.
if(iLevel == 0 || iIdentLength != 1 || pDirEnt[33] > 1)
{
if(iDataLength > iBufferSize)
{
delete[] pBuffer;
iBufferSize = iDataLength;
pBuffer = new unsigned char[iBufferSize];
}
if(_seekToSector(iDataSector) && _readData(iDataLength, pBuffer))
{
int iFoundLevel = _findHospDirectory(pBuffer, iDataLength, iLevel + 1);
if(iFoundLevel != 0)
{
if(iFoundLevel == 2)
_buildFileLookupTable(iDataSector, iDataLength, "");
delete[] pBuffer;
return iFoundLevel + 1;
}
}
}
}
else
{
// Look for VBLK-0.TAB to serve as indication that we've found the
// Theme Hospital data.
if(iIdentLength == 10)
{
const char sName[10] = {'V','B','L','K','-','0','.','T','A','B'};
int i = 0;
for(; i < 10; ++i)
{
if(_normalise(pDirEnt[33 + i]) != sName[i])
break;
}
if(i == 10)
{
return 1;
}
}
}
}
delete[] pBuffer;
return 0;
}
