Start implementation of ELF view and add stream objects

1 files changed, 358 insertions, 92 deletions

diff --git a/binaryninjaapi.cpp b/binaryninjaapi.cpp
index 532f4403..95bb71be 100644
--- a/binaryninjaapi.cpp
+++ b/binaryninjaapi.cpp
@@ -480,272 +480,538 @@ bool BinaryView::Navigate(const string& view, uint64_t offset)
 }
 
 
-BNDefaultEndianness BinaryView::GetDefaultEndianness() const
+DataBuffer BinaryView::ReadBuffer(uint64_t offset, size_t len)
 {
-	return BNGetDefaultEndianness(m_view);
+	BNDataBuffer* result = BNReadViewBuffer(m_view, offset, len);
+	return DataBuffer(result);
 }
 
 
-void BinaryView::SetDefaultEndianness(BNDefaultEndianness endian)
+size_t BinaryView::WriteBuffer(uint64_t offset, const DataBuffer& data)
 {
-	BNSetDefaultEndianness(m_view, endian);
+	return BNWriteViewBuffer(m_view, offset, data.GetBufferObject());
 }
 
 
-uint8_t BinaryView::Read8(uint64_t offset)
+size_t BinaryView::InsertBuffer(uint64_t offset, const DataBuffer& data)
 {
-	return BNRead8(m_view, offset);
+	return BNInsertViewBuffer(m_view, offset, data.GetBufferObject());
 }
 
 
-uint16_t BinaryView::Read16(uint64_t offset)
+vector<BNModificationStatus> BinaryView::GetModification(uint64_t offset, size_t len)
 {
-	return BNRead16(m_view, offset);
+	BNModificationStatus* mod = new BNModificationStatus[len];
+	len = BNGetModificationArray(m_view, offset, mod, len);
+
+	vector<BNModificationStatus> result;
+	for (size_t i = 0; i < len; i++)
+		result.push_back(mod[i]);
+
+	delete[] mod;
+	return result;
 }
 
 
-uint32_t BinaryView::Read32(uint64_t offset)
+uint64_t BinaryView::GetEnd() const
 {
-	return BNRead32(m_view, offset);
+	return BNGetEndOffset(m_view);
 }
 
 
-uint64_t BinaryView::Read64(uint64_t offset)
+bool BinaryView::Save(const string& path)
 {
-	return BNRead64(m_view, offset);
+	return BNSaveToFilename(m_view, path.c_str());
 }
 
 
-uint16_t BinaryView::ReadLE16(uint64_t offset)
+void BinaryView::RegisterNotification(BinaryDataNotification* notify)
 {
-	return BNReadLE16(m_view, offset);
+	BNRegisterDataNotification(m_view, notify->GetCallbacks());
 }
 
 
-uint32_t BinaryView::ReadLE32(uint64_t offset)
+void BinaryView::UnregisterNotification(BinaryDataNotification* notify)
 {
-	return BNReadLE32(m_view, offset);
+	BNUnregisterDataNotification(m_view, notify->GetCallbacks());
 }
 
 
-uint64_t BinaryView::ReadLE64(uint64_t offset)
+CoreBinaryView::CoreBinaryView(BNBinaryView* view): BinaryView(view)
 {
-	return BNReadLE64(m_view, offset);
 }
 
 
-uint16_t BinaryView::ReadBE16(uint64_t offset)
+size_t CoreBinaryView::Read(void* dest, uint64_t offset, size_t len)
 {
-	return BNReadBE16(m_view, offset);
+	return BNReadViewData(m_view, dest, offset, len);
 }
 
 
-uint32_t BinaryView::ReadBE32(uint64_t offset)
+size_t CoreBinaryView::Write(uint64_t offset, const void* data, size_t len)
 {
-	return BNReadBE32(m_view, offset);
+	return BNWriteViewData(m_view, offset, data, len);
 }
 
 
-uint64_t BinaryView::ReadBE64(uint64_t offset)
+size_t CoreBinaryView::Insert(uint64_t offset, const void* data, size_t len)
 {
-	return BNReadBE64(m_view, offset);
+	return BNInsertViewData(m_view, offset, data, len);
 }
 
 
-DataBuffer BinaryView::ReadBuffer(uint64_t offset, size_t len)
+size_t CoreBinaryView::Remove(uint64_t offset, uint64_t len)
 {
-	BNDataBuffer* result = BNReadBuffer(m_view, offset, len);
-	return DataBuffer(result);
+	return BNRemoveViewData(m_view, offset, len);
+}
+
+
+BNModificationStatus CoreBinaryView::GetModification(uint64_t offset)
+{
+	return BNGetModification(m_view, offset);
 }
 
 
-bool BinaryView::Write8(uint64_t offset, uint8_t val)
+uint64_t CoreBinaryView::GetStart() const
 {
-	return BNWrite8(m_view, offset, val);
+	return BNGetStartOffset(m_view);
 }
 
 
-bool BinaryView::Write16(uint64_t offset, uint16_t val)
+uint64_t CoreBinaryView::GetLength() const
 {
-	return BNWrite16(m_view, offset, val);
+	return BNGetViewLength(m_view);
 }
 
 
-bool BinaryView::Write32(uint64_t offset, uint32_t val)
+bool CoreBinaryView::Save(FileAccessor* file)
 {
-	return BNWrite32(m_view, offset, val);
+	return BNSaveToFile(m_view, file->GetCallbacks());
 }
 
 
-bool BinaryView::Write64(uint64_t offset, uint64_t val)
+BinaryData::BinaryData(FileMetadata* file): CoreBinaryView(BNCreateBinaryDataView(file->GetFileObject()))
 {
-	return BNWrite64(m_view, offset, val);
 }
 
 
-bool BinaryView::WriteLE16(uint64_t offset, uint16_t val)
+BinaryData::BinaryData(FileMetadata* file, const DataBuffer& data):
+	CoreBinaryView(BNCreateBinaryDataViewFromBuffer(file->GetFileObject(), data.GetBufferObject()))
 {
-	return BNWriteLE16(m_view, offset, val);
 }
 
 
-bool BinaryView::WriteLE32(uint64_t offset, uint32_t val)
+BinaryData::BinaryData(FileMetadata* file, const void* data, size_t len):
+	CoreBinaryView(BNCreateBinaryDataViewFromData(file->GetFileObject(), data, len))
 {
-	return BNWriteLE32(m_view, offset, val);
 }
 
 
-bool BinaryView::WriteLE64(uint64_t offset, uint64_t val)
+BinaryData::BinaryData(FileMetadata* file, const string& path):
+	CoreBinaryView(BNCreateBinaryDataViewFromFilename(file->GetFileObject(), path.c_str()))
 {
-	return BNWriteLE64(m_view, offset, val);
 }
 
 
-bool BinaryView::WriteBE16(uint64_t offset, uint16_t val)
+BinaryData::BinaryData(FileMetadata* file, FileAccessor* accessor):
+	CoreBinaryView(BNCreateBinaryDataViewFromFile(file->GetFileObject(), accessor->GetCallbacks()))
 {
-	return BNWriteBE16(m_view, offset, val);
 }
 
 
-bool BinaryView::WriteBE32(uint64_t offset, uint32_t val)
+BinaryReader::BinaryReader(BinaryView* data, BNEndianness endian): m_view(data)
 {
-	return BNWriteBE32(m_view, offset, val);
+	m_stream = BNCreateBinaryReader(data->GetViewObject());
+	BNSetBinaryReaderEndianness(m_stream, endian);
 }
 
 
-bool BinaryView::WriteBE64(uint64_t offset, uint64_t val)
+BinaryReader::~BinaryReader()
 {
-	return BNWriteBE64(m_view, offset, val);
+	BNFreeBinaryReader(m_stream);
 }
 
 
-size_t BinaryView::WriteBuffer(uint64_t offset, const DataBuffer& data)
+BNEndianness BinaryReader::GetEndianness() const
 {
-	return BNWriteBuffer(m_view, offset, data.GetBufferObject());
+	return BNGetBinaryReaderEndianness(m_stream);
 }
 
 
-size_t BinaryView::InsertBuffer(uint64_t offset, const DataBuffer& data)
+void BinaryReader::SetEndianness(BNEndianness endian)
 {
-	return BNInsertBuffer(m_view, offset, data.GetBufferObject());
+	BNSetBinaryReaderEndianness(m_stream, endian);
 }
 
 
-vector<BNModificationStatus> BinaryView::GetModification(uint64_t offset, size_t len)
+void BinaryReader::Read(void* dest, size_t len)
 {
-	BNModificationStatus* mod = new BNModificationStatus[len];
-	len = BNGetModificationArray(m_view, offset, mod, len);
+	if (!BNReadData(m_stream, dest, len))
+		throw ReadException();
+}
 
-	vector<BNModificationStatus> result;
-	for (size_t i = 0; i < len; i++)
-		result.push_back(mod[i]);
 
-	delete[] mod;
+uint8_t BinaryReader::Read8()
+{
+	uint8_t result;
+	if (!BNRead8(m_stream, &result))
+		throw ReadException();
 	return result;
 }
 
 
-uint64_t BinaryView::GetEnd() const
+uint16_t BinaryReader::Read16()
 {
-	return BNGetEndOffset(m_view);
+	uint16_t result;
+	if (!BNRead16(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-bool BinaryView::Save(const string& path)
+uint32_t BinaryReader::Read32()
 {
-	return BNSaveToFilename(m_view, path.c_str());
+	uint32_t result;
+	if (!BNRead32(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-void BinaryView::RegisterNotification(BinaryDataNotification* notify)
+uint64_t BinaryReader::Read64()
 {
-	BNRegisterDataNotification(m_view, notify->GetCallbacks());
+	uint64_t result;
+	if (!BNRead64(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-void BinaryView::UnregisterNotification(BinaryDataNotification* notify)
+uint16_t BinaryReader::ReadLE16()
 {
-	BNUnregisterDataNotification(m_view, notify->GetCallbacks());
+	uint16_t result;
+	if (!BNReadLE16(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-CoreBinaryView::CoreBinaryView(BNBinaryView* view): BinaryView(view)
+uint32_t BinaryReader::ReadLE32()
 {
+	uint32_t result;
+	if (!BNReadLE32(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-size_t CoreBinaryView::Read(void* dest, uint64_t offset, size_t len)
+uint64_t BinaryReader::ReadLE64()
 {
-	return BNReadData(m_view, dest, offset, len);
+	uint64_t result;
+	if (!BNReadLE64(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-size_t CoreBinaryView::Write(uint64_t offset, const void* data, size_t len)
+uint16_t BinaryReader::ReadBE16()
 {
-	return BNWriteData(m_view, offset, data, len);
+	uint16_t result;
+	if (!BNReadBE16(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-size_t CoreBinaryView::Insert(uint64_t offset, const void* data, size_t len)
+uint32_t BinaryReader::ReadBE32()
 {
-	return BNInsertData(m_view, offset, data, len);
+	uint32_t result;
+	if (!BNReadBE32(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-size_t CoreBinaryView::Remove(uint64_t offset, uint64_t len)
+uint64_t BinaryReader::ReadBE64()
 {
-	return BNRemoveData(m_view, offset, len);
+	uint64_t result;
+	if (!BNReadBE64(m_stream, &result))
+		throw ReadException();
+	return result;
 }
 
 
-BNModificationStatus CoreBinaryView::GetModification(uint64_t offset)
+bool BinaryReader::TryRead(void* dest, size_t len)
 {
-	return BNGetModification(m_view, offset);
+	return BNReadData(m_stream, dest, len);
 }
 
 
-uint64_t CoreBinaryView::GetStart() const
+bool BinaryReader::TryRead8(uint8_t& result)
 {
-	return BNGetStartOffset(m_view);
+	return BNRead8(m_stream, &result);
 }
 
 
-uint64_t CoreBinaryView::GetLength() const
+bool BinaryReader::TryRead16(uint16_t& result)
 {
-	return BNGetViewLength(m_view);
+	return BNRead16(m_stream, &result);
 }
 
 
-bool CoreBinaryView::Save(FileAccessor* file)
+bool BinaryReader::TryRead32(uint32_t& result)
 {
-	return BNSaveToFile(m_view, file->GetCallbacks());
+	return BNRead32(m_stream, &result);
 }
 
 
-BinaryData::BinaryData(FileMetadata* file): CoreBinaryView(BNCreateBinaryDataView(file->GetFileObject()))
+bool BinaryReader::TryRead64(uint64_t& result)
 {
+	return BNRead64(m_stream, &result);
 }
 
 
-BinaryData::BinaryData(FileMetadata* file, const DataBuffer& data):
-	CoreBinaryView(BNCreateBinaryDataViewFromBuffer(file->GetFileObject(), data.GetBufferObject()))
+bool BinaryReader::TryReadLE16(uint16_t& result)
 {
+	return BNReadLE16(m_stream, &result);
 }
 
 
-BinaryData::BinaryData(FileMetadata* file, const void* data, size_t len):
-	CoreBinaryView(BNCreateBinaryDataViewFromData(file->GetFileObject(), data, len))
+bool BinaryReader::TryReadLE32(uint32_t& result)
 {
+	return BNReadLE32(m_stream, &result);
 }
 
 
-BinaryData::BinaryData(FileMetadata* file, const string& path):
-	CoreBinaryView(BNCreateBinaryDataViewFromFilename(file->GetFileObject(), path.c_str()))
+bool BinaryReader::TryReadLE64(uint64_t& result)
 {
+	return BNReadLE64(m_stream, &result);
 }
 
 
-BinaryData::BinaryData(FileMetadata* file, FileAccessor* accessor):
-	CoreBinaryView(BNCreateBinaryDataViewFromFile(file->GetFileObject(), accessor->GetCallbacks()))
+bool BinaryReader::TryReadBE16(uint16_t& result)
+{
+	return BNReadBE16(m_stream, &result);
+}
+
+
+bool BinaryReader::TryReadBE32(uint32_t& result)
+{
+	return BNReadBE32(m_stream, &result);
+}
+
+
+bool BinaryReader::TryReadBE64(uint64_t& result)
+{
+	return BNReadBE64(m_stream, &result);
+}
+
+
+uint64_t BinaryReader::GetOffset() const
+{
+	return BNGetReaderPosition(m_stream);
+}
+
+
+void BinaryReader::Seek(uint64_t offset)
+{
+	BNSeekBinaryReader(m_stream, offset);
+}
+
+
+void BinaryReader::SeekRelative(int64_t offset)
+{
+	BNSeekBinaryReaderRelative(m_stream, offset);
+}
+
+
+bool BinaryReader::IsEndOfFile() const
+{
+	return BNIsEndOfFile(m_stream);
+}
+
+
+BinaryWriter::BinaryWriter(BinaryView* data, BNEndianness endian): m_view(data)
+{
+	m_stream = BNCreateBinaryWriter(data->GetViewObject());
+	BNSetBinaryWriterEndianness(m_stream, endian);
+}
+
+
+BinaryWriter::~BinaryWriter()
+{
+	BNFreeBinaryWriter(m_stream);
+}
+
+
+BNEndianness BinaryWriter::GetEndianness() const
+{
+	return BNGetBinaryWriterEndianness(m_stream);
+}
+
+
+void BinaryWriter::SetEndianness(BNEndianness endian)
+{
+	BNSetBinaryWriterEndianness(m_stream, endian);
+}
+
+
+void BinaryWriter::Write(const void* src, size_t len)
+{
+	if (!BNWriteData(m_stream, src, len))
+		throw WriteException();
+}
+
+
+void BinaryWriter::Write8(uint8_t val)
+{
+	if (!BNWrite8(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::Write16(uint16_t val)
+{
+	if (!BNWrite16(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::Write32(uint32_t val)
+{
+	if (!BNWrite32(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::Write64(uint64_t val)
+{
+	if (!BNWrite64(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::WriteLE16(uint16_t val)
+{
+	if (!BNWriteLE16(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::WriteLE32(uint32_t val)
+{
+	if (!BNWriteLE32(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::WriteLE64(uint64_t val)
+{
+	if (!BNWriteLE64(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::WriteBE16(uint16_t val)
+{
+	if (!BNWriteBE16(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::WriteBE32(uint32_t val)
+{
+	if (!BNWriteBE32(m_stream, val))
+		throw WriteException();
+}
+
+
+void BinaryWriter::WriteBE64(uint64_t val)
+{
+	if (!BNWriteBE64(m_stream, val))
+		throw WriteException();
+}
+
+
+bool BinaryWriter::TryWrite(const void* src, size_t len)
+{
+	return BNWriteData(m_stream, src, len);
+}
+
+
+bool BinaryWriter::TryWrite8(uint8_t val)
+{
+	return BNWrite8(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWrite16(uint16_t val)
+{
+	return BNWrite16(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWrite32(uint32_t val)
+{
+	return BNWrite32(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWrite64(uint64_t val)
+{
+	return BNWrite64(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWriteLE16(uint16_t val)
+{
+	return BNWriteLE16(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWriteLE32(uint32_t val)
+{
+	return BNWriteLE32(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWriteLE64(uint64_t val)
+{
+	return BNWriteLE64(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWriteBE16(uint16_t val)
+{
+	return BNWriteBE16(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWriteBE32(uint32_t val)
+{
+	return BNWriteBE32(m_stream, val);
+}
+
+
+bool BinaryWriter::TryWriteBE64(uint64_t val)
+{
+	return BNWriteBE64(m_stream, val);
+}
+
+
+uint64_t BinaryWriter::GetOffset() const
+{
+	return BNGetWriterPosition(m_stream);
+}
+
+
+void BinaryWriter::Seek(uint64_t offset)
+{
+	BNSeekBinaryWriter(m_stream, offset);
+}
+
+
+void BinaryWriter::SeekRelative(int64_t offset)
 {
+	BNSeekBinaryWriterRelative(m_stream, offset);
 }