bool ELFHelper :: seekDebugSegment(StreamReader& reader, size_t& address)
{
Elf32_Ehdr header;
reader.read(&header, ELF_HEADER_SIZE);
int count = header.e_phnum;
Elf32_Phdr ph_header;
bool skipRData = true;
while (count > 0) {
reader.read(&ph_header, header.e_phentsize);
if (ph_header.p_type == PT_LOAD && ph_header.p_flags == PF_R) {
if (!skipRData) {
address = ph_header.p_vaddr;
return true;
}
else skipRData = false;
}
count--;
}
return false;
}
//=================================================================================================
// Wczytuje dane wierzcho³ków z modelu (na razie dzia³a tylko dla Vec3)
//=================================================================================================
void Mesh::LoadVertexData(VertexData* vd, StreamReader& stream)
{
// read and check header
Header head;
if(!stream.Read(head))
throw "Failed to read file header.";
if(memcmp(head.format, "QMSH", 4) != 0)
throw Format("Invalid file signature '%.4s'.", head.format);
if(head.version != 20)
throw Format("Invalid file version '%d'.", head.version);
if(head.flags != F_PHYSICS)
throw Format("Invalid mesh flags '%d'.", head.flags);
vd->radius = head.radius;
// read vertices
uint size = sizeof(Vec3) * head.n_verts;
if(!stream.Ensure(size))
throw "Failed to read vertex data.";
vd->verts.resize(head.n_verts);
stream.Read(vd->verts.data(), size);
// read faces
size = sizeof(Face) * head.n_tris;
if(!stream.Ensure(size))
throw "Failed to read triangle data.";
vd->faces.resize(head.n_tris);
stream.Read(vd->faces.data(), size);
}
bool IOWrapper::seek( qint64 pos)
{
if (!m_streamReader.streamSeekable())
return false;
m_streamReader.setCurrentPos(pos);
return true;
}
void SISEmbeds::ExtractEmbeds(StreamReader& aReader )
{
iEmbeddedPkgUid = aReader.ReadInt32();
iEmbeddedPkgName = aReader.ReadDescriptor();
iEmbeddedVendorName = aReader.ReadDescriptor();
iEmbeddedPkgIndex = aReader.ReadInt32();
}
// reiserfs_read
static status_t
reiserfs_read(fs_volume *fs, fs_vnode *_node, void *cookie, off_t pos,
void *buffer, size_t *bufferSize)
{
TOUCH(fs);
// FUNCTION_START();
// Volume *volume = (Volume*)fs->private_volume;
VNode *node = (VNode*)_node->private_node;
FUNCTION(("((%Ld: %lu, %lu), %Ld, %p, %lu)\n", node->GetID(),
node->GetDirID(), node->GetObjectID(), pos, buffer,
*bufferSize));
status_t error = B_OK;
// don't read anything but files
if (!node->IsFile()) {
if (node->IsDir())
error = B_IS_A_DIRECTORY;
else
error = B_BAD_VALUE;
}
// read
StreamReader *reader = (StreamReader*)cookie;
if (error == B_OK) {
error = reader->Resume();
if (error == B_OK) {
error = reader->ReadAt(pos, buffer, *bufferSize, bufferSize);
reader->Suspend();
}
}
RETURN_ERROR(error);
}
StreamReader* FileUtil_Win32_Impl::LoadFile(const char* pszFileName)
{
if (!pszFileName || strlen(pszFileName) <= 0) return NULL;
std::string strFullPath = m_strRootPath + pszFileName;
FILE* pFile = NULL;
fopen_s(&pFile, strFullPath.c_str(), "rb");
if (pFile == NULL)
{
LOGE("open file failed: %s", strFullPath.c_str());
return NULL;
}
fseek(pFile, 0, SEEK_END);
uint nFileSize = ftell(pFile);
fseek(pFile, 0, SEEK_SET);
char* pszBuffer = new char[nFileSize+1];
int nReadSize = fread(pszBuffer, 1, nFileSize, pFile);
fclose(pFile);
pszBuffer[nFileSize] = '\0';
StreamReader* pStreamReader = new StreamReader(pszBuffer, nFileSize, true);
if (!pStreamReader || !pStreamReader->IsOK())
{
LOGE("create stream reader failed with file size: %d", nFileSize);
SAFE_DELETE(pStreamReader);
SAFE_DELETE_ARRAY(pszBuffer);
return NULL;
}
return pStreamReader;
}
// reiserfs_open
static status_t
reiserfs_open(fs_volume *fs, fs_vnode *_node, int openMode, void **cookie)
{
// FUNCTION_START();
Volume *volume = (Volume*)fs->private_volume;
VNode *node = (VNode*)_node->private_node;
FUNCTION(("node: (%Ld: %lu, %lu)\n", node->GetID(), node->GetDirID(),
node->GetObjectID()));
status_t error = B_OK;
// check the open mode
if ((openMode & O_RWMASK) == O_WRONLY || (openMode & O_RWMASK) == O_RDWR
|| (openMode & (O_TRUNC | O_CREAT))) {
error = B_READ_ONLY_DEVICE;
}
// create a StreamReader
if (error == B_OK) {
StreamReader *reader = new(nothrow) StreamReader(volume->GetTree(),
node->GetDirID(), node->GetObjectID());
if (reader) {
error = reader->Suspend();
if (error == B_OK)
*cookie = reader;
else
delete reader;
} else
error = B_NO_MEMORY;
}
RETURN_ERROR(error);
}
static int FileRead(sqlite3_file* pFile, void* pBuf, int amt, sqlite3_int64 offset64)
{
DBFile* file = (DBFile*)pFile;
StreamReader* reader = file->reader;
if (reader == NULL)
return SQLITE_IOERR_READ;
assert(offset64 >= 0);
size_t offset = (size_t)offset64; // TODO: support 64bit
reader->seek(offset);
int read = reader->readRaw(pBuf, amt);
if (read < amt)
{
uint8* fillStart = (uint8*)pBuf;
fillStart += read;
// sqlite needs us to fill zeroes when IOERR_SHORT_READ
memset(fillStart, 0, amt - read);
return SQLITE_IOERR_SHORT_READ;
}
return SQLITE_OK;
}
static void PngReaderCallback(png_structp pPngStruct, png_bytep pData, png_size_t nSize)
{
StreamReader* pStream = (StreamReader*)png_get_io_ptr(pPngStruct);
if (!pStream->Read(pData, nSize))
{
png_error(pPngStruct,"pngReaderCallback failed");
}
}
void Array2D::init(StreamReader& s)
{
for(unsigned i = 0, length = s.ber(); i < length; i++) {
unsigned index = s.ber();
insert( index, std::auto_ptr<Array1D>( new Array1D(*this, index, s) ) );
}
if( toElement().hasOwner() ) rpg2k_analyze_assert( s.eof() );
}
void SISControllerInfo::ExtractControllerInfo(StreamReader& aReader )
{
iMajor = aReader.ReadInt32();
iMinor = aReader.ReadInt32();
iBuild = aReader.ReadInt32();
iOffset = aReader.ReadInt32();
iAlgorithmType = aReader.ReadInt32();
char* controllerHash = aReader.ReadDescriptor();
delete [] controllerHash;
}
void Program::Run()
{
StreamWriter* sw = new StreamWriter(new String("test.txt"));
sw->WriteLine(new String("Hi! I'm a stream writer"));
sw->Flush();
sw->Close();
StreamReader* sr = new StreamReader(new String("test.txt"));
String* text = sr->ReadToEnd();
sr->Close();
Console::WriteLine(text);
}
SyntaxTree::Node SyntaxTree:: read(StreamReader& reader)
{
int type = reader.getDWord(-1);
ref_t arg = reader.getDWord();
int str = reader.getDWord();
if (type == -1) {
return Node();
}
else return Node(this, reader.Position(), (LexicalType)type, arg, str);
}
static string HttpGet(string url) {
HttpWebRequest req = WebRequest.Create(url)
as HttpWebRequest;
string result = null;
using (HttpWebResponse resp = req.GetResponse()
as HttpWebResponse)
{
StreamReader reader =
new StreamReader(resp.GetResponseStream());
result = reader.ReadToEnd();
}
static Error loadSectionContribs(FixedStreamArray<ContribType> &Output,
StreamReader &Reader) {
if (Reader.bytesRemaining() % sizeof(ContribType) != 0)
return make_error<RawError>(
raw_error_code::corrupt_file,
"Invalid number of bytes of section contributions");
uint32_t Count = Reader.bytesRemaining() / sizeof(ContribType);
if (auto EC = Reader.readArray(Output, Count))
return EC;
return Error::success();
}
int StreamReader::seekCallback(void *data, const uint64_t pos)
{
StreamReader *that = static_cast<StreamReader *>(data);
if (static_cast<int64_t>(pos) > that->streamSize()) { // krazy:exclude=typedefs
// attempt to seek past the end of our data.
return -1;
}
that->setCurrentPos(pos);
// this should return a true/false, but it doesn't, so assume success.
return 0;
}
std::error_code ByteStream::initialize(StreamReader &Reader, uint32_t Length) {
initialize(Length);
std::error_code EC = Reader.readBytes(Data);
if (EC)
reset();
return EC;
}
Error ByteStream::load(StreamReader &Reader, uint32_t Length) {
load(Length);
auto EC = Reader.readBytes(Data);
if (EC)
reset();
return EC;
}
Error ByteStream::initialize(StreamReader &Reader, uint32_t Length) {
initialize(Length);
auto EC = Reader.readBytes(Data);
if (EC)
reset();
return EC;
}
//=================================================================================================
// Load metadata only from mesh (points)
void Mesh::LoadMetadata(StreamReader& stream)
{
if(vb)
return;
LoadHeader(stream);
stream.SetOffset(head.points_offset);
LoadPoints(stream);
}
void SISFileDescription::ExtractSISFileDescription(StreamReader& aReader )
{
iTarget = aReader.ReadDescriptor();
iMimeType = aReader.ReadDescriptor();
iOperation = aReader.ReadInt32();
//indicates which options are applicable to the processing of this file during installation
iOperationOptions = aReader.ReadInt32();
//indicates the algorithm used to generate the hash
iAlgorithm = aReader.ReadInt32();
iHash = aReader.ReadDescriptor();
iUncompressedLengthl = aReader.ReadInt32();
iUncompressedLengthh = aReader.ReadInt32();
iIndex = aReader.ReadInt32();
iSid = aReader.ReadInt32();
}
void
FndbManager::GetIgnorableFiles (/*[in]*/ const char * lpszPath,
/*[out]*/ vector<string> & filesToBeIgnored)
{
PathName ignoreFile (lpszPath, FN_MIKTEXIGNORE, 0);
if (! File::Exists(ignoreFile))
{
return;
}
StreamReader reader (ignoreFile);
filesToBeIgnored.reserve (10);
string line;
while (reader.ReadLine(line))
{
filesToBeIgnored.push_back (line);
}
sort (filesToBeIgnored.begin(),
filesToBeIgnored.end(),
StringComparerIgnoringCase());
}
int StreamReader::readCallback(void *data, const char *cookie,
int64_t *dts, int64_t *pts, unsigned *flags, // krazy:exclude=typedefs
size_t *bufferSize, void **buffer)
{
Q_UNUSED(cookie);
Q_UNUSED(dts);
Q_UNUSED(pts);
Q_UNUSED(flags);
StreamReader *that = static_cast<StreamReader *>(data);
size_t length = BLOCKSIZE;
*buffer = new char[length];
int size = length;
bool ret = that->read(that->currentPos(), &size, static_cast<char*>(*buffer));
*bufferSize = static_cast<size_t>(size);
return ret ? 0 : -1;
}
bool Debugger :: findSignature(StreamReader& reader, char* signature)
{
reader.seek(0x08048000u);
size_t rva = 0;
ELFHelper::seekRDataSegment(reader, rva);
// load Executable image
current->readDump(rva, signature, strlen(ELENACLIENT_SIGNITURE));
signature[strlen(ELENACLIENT_SIGNITURE)] = 0;
return true;
}
bool DebugController :: loadDebugData(StreamReader& reader, bool setEntryAddress)
{
if (setEntryAddress) {
// read entry point
_entryPoint = reader.getDWord();
if (_entryPoint != 0)
setEntryAddress = false;
}
IdentifierString reference;
while (!reader.Eof()) {
// read reference
reader.readString(reference);
// define the next record position
int size = reader.getDWord() - 4;
int nextPosition = reader.Position() + size;
if (setEntryAddress) {
// if entry address was not defined take the first one
_entryPoint = reader.getDWord();
reader.seek(reader.Position() - 4);
setEntryAddress = false;
}
// // if it is a VM temporal symbol and tape debugging as allowed
// if (ConstantIdentifier::compare(reference, TAPE_SYMBOL) && _debugTape) {
// loadTapeDebugInfo(reader, size);
// }
// otherwise load standard debug info
/* else */loadSymbolDebugInfo(reference, reader);
reader.seek(nextPosition);
}
return true;
}
bool Debugger :: initDebugInfo(bool standalone, StreamReader& reader, size_t& debugInfoPtr)
{
if (standalone) {
reader.seek(0x08048000u);
_ELENA_::ELFHelper::seekDebugSegment(reader, debugInfoPtr);
}
// else if (_vmHook == 0) {
// size_t rdata = Context()->readDWord(0x4000D0);
// //HOTFIX : the actual length should be used
// _vmHook = Context()->readDWord(0x400000 + rdata + _ELENA_::align(strlen(ELENACLIENT_SIGNITURE) + 3, 4));
//
// // enable debug mode
// Context()->writeDWord(_vmHook, -1);
//
// return false;
// }
// // load VM debug section address
// else debugInfoPtr = Context()->readDWord(_vmHook + 4);
return true;
}
//=================================================================================================
void Mesh::LoadHeader(StreamReader& stream)
{
// head
if(!stream.Read(head))
throw "Failed to read file header.";
if(memcmp(head.format, "QMSH", 4) != 0)
throw Format("Invalid file signature '%.4s'.", head.format);
if(head.version < 12 || head.version > 20)
throw Format("Invalid file version '%u'.", head.version);
if(head.version < 20)
throw Format("Unsupported file version '%u'.", head.version);
if(head.n_bones >= 32)
throw Format("Too many bones (%u).", head.n_bones);
if(head.n_subs == 0)
throw "Missing model mesh!";
if(IS_SET(head.flags, F_ANIMATED) && !IS_SET(head.flags, F_STATIC))
{
if(head.n_bones == 0)
throw "No bones.";
if(head.n_groups == 0)
throw "No bone groups.";
}
}
Error NameHashTable::load(StreamReader &Stream) {
struct Header {
support::ulittle32_t Signature;
support::ulittle32_t HashVersion;
support::ulittle32_t ByteSize;
};
const Header *H;
if (auto EC = Stream.readObject(H))
return EC;
if (H->Signature != 0xEFFEEFFE)
return make_error<RawError>(raw_error_code::corrupt_file,
"Invalid hash table signature");
if (H->HashVersion != 1 && H->HashVersion != 2)
return make_error<RawError>(raw_error_code::corrupt_file,
"Unsupported hash version");
Signature = H->Signature;
HashVersion = H->HashVersion;
if (auto EC = Stream.readStreamRef(NamesBuffer, H->ByteSize))
return joinErrors(std::move(EC),
make_error<RawError>(raw_error_code::corrupt_file,
"Invalid hash table byte length"));
const support::ulittle32_t *HashCount;
if (auto EC = Stream.readObject(HashCount))
return EC;
if (auto EC = Stream.readArray(IDs, *HashCount))
return joinErrors(std::move(EC),
make_error<RawError>(raw_error_code::corrupt_file,
"Could not read bucket array"));
if (Stream.bytesRemaining() < sizeof(support::ulittle32_t))
return make_error<RawError>(raw_error_code::corrupt_file,
"Missing name count");
if (auto EC = Stream.readInteger(NameCount))
return EC;
return Error::success();
}
qint64 IOWrapper::readData(char * data, qint64 maxSize)
{
int oldSize = m_streamReader.currentBufferSize();
while (m_streamReader.currentBufferSize() < maxSize) {
m_streamReader.needData();
if (oldSize == m_streamReader.currentBufferSize()) {
break; //we didn't get any data
}
oldSize = m_streamReader.currentBufferSize();
}
qint64 bytesRead = qMin(qint64(m_streamReader.currentBufferSize()), maxSize);
{
QWriteLocker locker(&m_streamReader.m_lock);
qMemCopy(data, m_streamReader.m_buffer.data(), bytesRead);
//truncate the buffer
m_streamReader.m_buffer = m_streamReader.m_buffer.mid(bytesRead);
}
return bytesRead;
}
void Mesh::LoadPoints(StreamReader& stream)
{
uint size = Point::MIN_SIZE * head.n_points;
if(!stream.Ensure(size))
throw "Failed to read points.";
attach_points.clear();
attach_points.resize(head.n_points);
for(word i = 0; i < head.n_points; ++i)
{
Point& p = attach_points[i];
stream.Read(p.name);
stream.Read(p.mat);
stream.Read(p.bone);
stream.Read(p.type);
stream.Read(p.size);
stream.Read(p.rot);
p.rot.y = Clip(-p.rot.y);
}
}