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; }