result_t BinarySerializeNode::getAttr ( const char* _key, const wchar** _pValue ) const
{
ex_check_return( false, EResult::read_failed, "wchar not support yet!" );
uint strlen = 0;
ReadFromBuffer ( &strlen, sizeof(uint) );
uint restSize = m_Capacity - m_CurPos;
if ( restSize < strlen )
{
return EResult::read_failed;
}
// DISABLE {
// m_WStrings.push_back ( wstring_t( (wchar*)((int8*)m_pData + m_CurPos), strlen ) );
// *_pValue = m_WStrings.back().c_str();
// } DISABLE end
// TODO {
// TEMP HACK {
// NOTE: this process will make the string go to the string id table, so that
// it will not be delete after the xml serialize.
// char* utf8 = (char*)ex_stack_malloc( strlen * sizeof(wchar) );
// utf16_to_utf8( (wchar*)((int8*)m_pData + m_CurPos), utf8 );
// string_id_t sid(utf8);
// *_pValue = sid.c_str();
// } TEMP HACK end
// } TODO end
m_CurPos += strlen * sizeof(wchar);
return EResult::ok;
}
result_t BinarySerializeNode::getAttr ( const char* _key, const char** _pValue ) const
{
uint strlen = 0;
ReadFromBuffer ( &strlen, sizeof(uint) );
uint restSize = m_Capacity - m_CurPos;
if ( restSize < strlen )
{
return EResult::read_failed;
}
// DISABLE {
// m_Strings.push_back ( string_t( (char*)((int8*)m_pData + m_CurPos), strlen ) );
// *_pValue = m_Strings.back().c_str();
// } DISABLE end
// TEMP HACK {
// NOTE: this process will make the string go to the string id table, so that
// it will not be delete after the xml serialize.
string_id_t sid( (char*)((int8*)m_pData + m_CurPos) );
*_pValue = sid.c_str();
// } TEMP HACK end
m_CurPos += strlen;
return EResult::ok;
}
LeaseSet::LeaseSet (const uint8_t * buf, size_t len):
m_IsValid (true)
{
m_Buffer = new uint8_t[len];
memcpy (m_Buffer, buf, len);
m_BufferLen = len;
ReadFromBuffer ();
}
bool IOBuffer::ReadFromString(string binary) {
SANITY_INPUT_BUFFER;
if (!ReadFromBuffer((uint8_t *) binary.data(), (uint32_t) binary.length())) {
SANITY_INPUT_BUFFER;
return false;
}
SANITY_INPUT_BUFFER;
return true;
}
bool IOBuffer::ReadFromInputBuffer(const IOBuffer &buffer, uint32_t size) {
SANITY_INPUT_BUFFER;
if (!ReadFromBuffer(buffer._pBuffer + buffer._consumed, size)) {
SANITY_INPUT_BUFFER;
return false;
}
SANITY_INPUT_BUFFER;
return true;
}
void
StructuredCloneHelper::ReadFromBuffer(nsISupports* aParent,
JSContext* aCx,
uint64_t* aBuffer,
size_t aBufferLength,
JS::MutableHandle<JS::Value> aValue,
ErrorResult& aRv)
{
ReadFromBuffer(aParent, aCx, aBuffer, aBufferLength,
JS_STRUCTURED_CLONE_VERSION, aValue, aRv);
}
void
StructuredCloneIPCHelper::Read(JSContext* aCx,
JS::MutableHandle<JS::Value> aValue,
ErrorResult &aRv)
{
MOZ_ASSERT(mData);
nsIGlobalObject *global = xpc::NativeGlobal(JS::CurrentGlobalOrNull(aCx));
MOZ_ASSERT(global);
ReadFromBuffer(global, aCx, mData, mDataLength, aValue, aRv);
}
bool EQEmu::PFS::Archive::InflateByFileOffset(uint32_t offset, uint32_t size, const std::vector<char> &in_buffer, std::vector<char> &out_buffer) {
out_buffer.resize(size);
memset(&out_buffer[0], 0, size);
uint32_t position = offset;
uint32_t inflate = 0;
while (inflate < size) {
std::vector<char> temp_buffer;
ReadFromBuffer(uint32_t, deflate_length, in_buffer, position);
ReadFromBuffer(uint32_t, inflate_length, in_buffer, position + 4);
temp_buffer.resize(deflate_length + 1);
ReadFromBufferLength(&temp_buffer[0], deflate_length, in_buffer, position + 8);
EQEmu::InflateData(&temp_buffer[0], deflate_length, &out_buffer[inflate], inflate_length);
inflate += inflate_length;
position += deflate_length + 8;
}
return true;
}
int CSerial_Base::UnSerialize(const char* pBuffer )
{
if (pBuffer == 0)
return 0 ;
//读出类名
int len = strlen((char*)pBuffer) + 1 ;
//根据类名判断能否逆串行化
if (strcmp(pBuffer,GetPacketClassInfo()->m_lpszPacketName) !=0)
return 0 ;
ReadFromBuffer(pBuffer+len);
return GetSize();
}
void LeaseSet::Update (const uint8_t * buf, size_t len)
{
m_Leases.clear ();
if (len > m_BufferLen)
{
auto oldBuffer = m_Buffer;
m_Buffer = new uint8_t[len];
delete[] oldBuffer;
}
memcpy (m_Buffer, buf, len);
m_BufferLen = len;
ReadFromBuffer (false);
}
bool EQEmu::PFS::Archive::StoreBlocksByFileOffset(uint32_t offset, uint32_t size, const std::vector<char> &in_buffer, std::string filename) {
uint32_t position = offset;
uint32_t block_size = 0;
uint32_t inflate = 0;
while (inflate < size) {
ReadFromBuffer(uint32_t, deflate_length, in_buffer, position);
ReadFromBuffer(uint32_t, inflate_length, in_buffer, position + 4);
inflate += inflate_length;
position += deflate_length + 8;
}
block_size = position - offset;
std::vector<char> tbuffer;
tbuffer.resize(block_size);
memcpy(&tbuffer[0], &in_buffer[offset], block_size);
files[filename] = tbuffer;
files_uncompressed_size[filename] = size;
return true;
}
int ReadNlFromFile(FILE *fd, String my_string)
{
static char buffer[MAX_LONG_MESSAGE+1];
static char *startPos = buffer;
static char *endPos = buffer;
int num_read;
if (!CommandInBuffer(buffer, startPos, endPos)) {
num_read = ReadFromFile(fd, buffer, &startPos, &endPos);
if (num_read == 0)
return(EOF);
}
return(ReadFromBuffer(my_string, buffer, &startPos, &endPos));
}
LeaseSet::LeaseSet (std::shared_ptr<const i2p::tunnel::TunnelPool> pool):
m_IsValid (true)
{
if (!pool) return;
// header
auto localDestination = pool->GetLocalDestination ();
if (!localDestination)
{
m_Buffer = nullptr;
m_BufferLen = 0;
m_IsValid = false;
LogPrint (eLogError, "LeaseSet: Destination for local LeaseSet doesn't exist");
return;
}
m_Buffer = new uint8_t[MAX_LS_BUFFER_SIZE];
m_BufferLen = localDestination->GetIdentity ()->ToBuffer (m_Buffer, MAX_LS_BUFFER_SIZE);
memcpy (m_Buffer + m_BufferLen, localDestination->GetEncryptionPublicKey (), 256);
m_BufferLen += 256;
auto signingKeyLen = localDestination->GetIdentity ()->GetSigningPublicKeyLen ();
memset (m_Buffer + m_BufferLen, 0, signingKeyLen);
m_BufferLen += signingKeyLen;
auto tunnels = pool->GetInboundTunnels (5); // 5 tunnels maximum
m_Buffer[m_BufferLen] = tunnels.size (); // num leases
m_BufferLen++;
// leases
for (auto it: tunnels)
{
memcpy (m_Buffer + m_BufferLen, it->GetNextIdentHash (), 32);
m_BufferLen += 32; // gateway id
htobe32buf (m_Buffer + m_BufferLen, it->GetNextTunnelID ());
m_BufferLen += 4; // tunnel id
uint64_t ts = it->GetCreationTime () + i2p::tunnel::TUNNEL_EXPIRATION_TIMEOUT - i2p::tunnel::TUNNEL_EXPIRATION_THRESHOLD; // 1 minute before expiration
ts *= 1000; // in milliseconds
ts += rand () % 6; // + random milliseconds 0-5
htobe64buf (m_Buffer + m_BufferLen, ts);
m_BufferLen += 8; // end date
}
// signature
localDestination->Sign (m_Buffer, m_BufferLen, m_Buffer + m_BufferLen);
m_BufferLen += localDestination->GetIdentity ()->GetSignatureLen ();
LogPrint (eLogDebug, "LeaseSet: Local LeaseSet of ", tunnels.size (), " leases created");
ReadFromBuffer ();
}
void
SharedMessagePortMessage::Read(nsISupports* aParent,
JSContext* aCx,
JS::MutableHandle<JS::Value> aValue,
ErrorResult& aRv)
{
if (mData.IsEmpty()) {
return;
}
auto* data = reinterpret_cast<uint64_t*>(mData.Elements());
size_t dataLen = mData.Length();
MOZ_ASSERT(!(dataLen % sizeof(*data)));
ReadFromBuffer(aParent, aCx, data, dataLen, aValue, aRv);
NS_WARN_IF(aRv.Failed());
Free();
}
// Load an exist node from disk to init
// <btree>: b-tree of this node
// <block>: address of file of this node
void BNode::InitFromFile(BTree* btree, int block) {
btree_ = btree;
block_ = block;
int block_length = btree_->file()->block_length();
capacity_ = (block_length - GetHeaderSize()) / GetEntrySize();
// init <key_>
key_ = new float[capacity_];
for (int i = 0; i < capacity_; i++) {
key_[i] = FLOAT_MIN;
}
// init <son_>
son_ = new int[capacity_];
memset(son_, -1, sizeof(int) * capacity_);
char* buf = new char[block_length];
btree_->file()->ReadBlock(buf, block);
ReadFromBuffer(buf);
delete[] buf;
}
result_t BinarySerializeNode::getAttr ( const char* _key, char* _pValue ) const
{
return ReadFromBuffer ( (void*)_pValue, sizeof(char) );
}
void IOBuffer::ReadFromInputBuffer(IOBuffer *pInputBuffer, uint32_t start, uint32_t size) {
SANITY_INPUT_BUFFER;
ReadFromBuffer(GETIBPOINTER(*pInputBuffer) + start, size);
SANITY_INPUT_BUFFER;
}
void PixelBuffer::Acquire(EngineParams& params)
{
size_t bufSize = params.width * params.height * sizeof(float) * 4;
ReadFromBuffer(params.queue, pb, CL_TRUE, 0, bufSize, pixels);
}
bool EQEmu::PFS::Archive::Open(std::string filename) {
Close();
std::vector<char> buffer;
FILE *f = fopen(filename.c_str(), "rb");
if (f) {
fseek(f, 0, SEEK_END);
size_t sz = ftell(f);
rewind(f);
buffer.resize(sz);
size_t res = fread(&buffer[0], 1, sz, f);
if (res != sz) {
return false;
}
fclose(f);
}
else {
return false;
}
char magic[4];
ReadFromBuffer(uint32_t, dir_offset, buffer, 0);
ReadFromBufferLength(magic, 4, buffer, 4);
if(magic[0] != 'P' || magic[1] != 'F' || magic[2] != 'S' || magic[3] != ' ') {
return false;
}
ReadFromBuffer(uint32_t, dir_count, buffer, dir_offset);
std::vector<std::tuple<int32_t, uint32_t, uint32_t>> directory_entries;
std::vector<std::tuple<int32_t, std::string>> filename_entries;
for(uint32_t i = 0; i < dir_count; ++i) {
ReadFromBuffer(int32_t, crc, buffer, dir_offset + 4 + (i * 12));
ReadFromBuffer(uint32_t, offset, buffer, dir_offset + 8 + (i * 12));
ReadFromBuffer(uint32_t, size, buffer, dir_offset + 12 + (i * 12));
if (crc == 0x61580ac9) {
std::vector<char> filename_buffer;
if(!InflateByFileOffset(offset, size, buffer, filename_buffer)) {
return false;
}
uint32_t filename_pos = 0;
ReadFromBuffer(uint32_t, filename_count, filename_buffer, filename_pos);
filename_pos += 4;
for(uint32_t j = 0; j < filename_count; ++j) {
ReadFromBuffer(uint32_t, filename_length, filename_buffer, filename_pos);
filename_pos += 4;
std::string filename;
filename.resize(filename_length - 1);
ReadFromBufferLength(&filename[0], filename_length, filename_buffer, filename_pos);
filename_pos += filename_length;
std::transform(filename.begin(), filename.end(), filename.begin(), ::tolower);
int32_t crc = EQEmu::PFS::CRC::Instance().Get(filename);
filename_entries.push_back(std::make_tuple(crc, filename));
}
} else {
directory_entries.push_back(std::make_tuple(crc, offset, size));
}
}
auto iter = directory_entries.begin();
while(iter != directory_entries.end()) {
int32_t crc = std::get<0>((*iter));
auto f_iter = filename_entries.begin();
while(f_iter != filename_entries.end()) {
int32_t f_crc = std::get<0>((*f_iter));
if(crc == f_crc) {
uint32_t offset = std::get<1>((*iter));
uint32_t size = std::get<2>((*iter));
std::string filename = std::get<1>((*f_iter));
if (!StoreBlocksByFileOffset(offset, size, buffer, filename)) {
return false;
}
break;
}
++f_iter;
}
++iter;
}
uint32_t footer_offset = dir_offset + 4 + (12 * dir_count);
if (footer_offset == buffer.size()) {
footer = false;
} else {
char magic[5];
ReadFromBufferLength(magic, 5, buffer, footer_offset);
ReadFromBuffer(uint32_t, date, buffer, footer_offset + 5);
footer = true;
footer_date = date;
}
return true;
}
