void DynamicBufferConverter<DataType, ConvertTo>::convert(std::vector<ConvertTo> & ConvertedVector, DynamicBuffer<DataType> const & Buffer) { int NumItems = Buffer.length() / sizeof(ConvertTo); ConvertedVector.resize(NumItems); const char * tBuf = Buffer.getBuffer(); for (int lp = 0; lp < NumItems; lp ++) memcpy(&ConvertedVector[lp], tBuf + (lp * sizeof(ConvertTo)), sizeof(ConvertTo)); }
void write_buffer(DynamicBuffer& b, string_view s) { b.commit(boost::asio::buffer_copy( b.prepare(s.size()), boost::asio::buffer( s.data(), s.size()))); }
void get(DynamicBuffer & outData) const { outData.clear(); outData.reserve(getTotalSize()); for (const auto & str : mParts) { outData.insert(outData.end(), str.begin(), str.end()); } }
static Ref<Sound> decode_pcm8s_codec (const Buffer * buf, ALint channel_count, ALint bits_per_sample, ALfloat sample_frequency) { DynamicBuffer copy; copy.assign(*buf); int8_t *d = (int8_t *)copy.begin(); std::size_t i; for (i = 0; i < copy.size(); i++) d[i] += (int8_t) 128; return new Sound(data_format(channel_count, bits_per_sample), sample_frequency, ©); }
void read_fh2(frame_header& fh, DynamicBuffer& db, role_type role, close_code::value& code) { using boost::asio::buffer; using boost::asio::buffer_copy; using boost::asio::buffer_size; using namespace boost::endian; switch(fh.len) { case 126: { std::uint8_t b[2]; assert(buffer_size(db.data()) >= sizeof(b)); db.consume(buffer_copy(buffer(b), db.data())); fh.len = big_uint16_to_native(&b[0]); // length not canonical if(fh.len < 126) { code = close_code::protocol_error; return; } break; } case 127: { std::uint8_t b[8]; assert(buffer_size(db.data()) >= sizeof(b)); db.consume(buffer_copy(buffer(b), db.data())); fh.len = big_uint64_to_native(&b[0]); // length not canonical if(fh.len < 65536) { code = close_code::protocol_error; return; } break; } } if(fh.mask) { std::uint8_t b[4]; assert(buffer_size(db.data()) >= sizeof(b)); db.consume(buffer_copy(buffer(b), db.data())); fh.key = little_uint32_to_native(&b[0]); } else { // initialize this otherwise operator== breaks fh.key = 0; } code = close_code::none; }
static bool match(DynamicBuffer& db, char const(&s)[N]) { using boost::asio::buffer; using boost::asio::buffer_copy; if(db.size() < N-1) return false; static_string<N-1> t; t.resize(N-1); buffer_copy(buffer(t.data(), t.size()), db.data()); if(t != s) return false; db.consume(N-1); return true; }
size_type do_prepares(std::size_t repeat, std::size_t count, std::size_t size) { timer t; size_type total = 0; for(auto i = repeat; i--;) { DynamicBuffer b; for(auto j = count; j--;) { auto const n = fill(b.prepare(size)); b.commit(n); total += n; } } return throughput(t.elapsed(), total); }
void body(DynamicBuffer& db) { if(! rand(4)) { write(db, "Content-Length: 0\r\n\r\n"); return; } if(rand(2)) { auto const len = rand(500); write(db, "Content-Length: ", len, "\r\n\r\n"); for(auto const& b : db.prepare(len)) { auto p = boost::asio::buffer_cast<char*>(b); auto n = boost::asio::buffer_size(b); while(n--) *p++ = static_cast<char>(32 + rand(26+26+10+6)); } db.commit(len); } else { auto len = rand(500); write(db, "Transfer-Encoding: chunked\r\n\r\n"); while(len > 0) { auto n = (std::min)(1 + rand(300), len); len -= n; write(db, to_hex(n), "\r\n"); for(auto const& b : db.prepare(n)) { auto p = boost::asio::buffer_cast<char*>(b); auto m = boost::asio::buffer_size(b); while(m--) *p++ = static_cast<char>(32 + rand(26+26+10+6)); } db.commit(n); write(db, "\r\n"); } write(db, "0\r\n\r\n"); } }
void write(DynamicBuffer& db, frame_header const& fh) { using boost::asio::buffer; using boost::asio::buffer_copy; using namespace boost::endian; std::size_t n; std::uint8_t b[14]; b[0] = (fh.fin ? 0x80 : 0x00) | static_cast<std::uint8_t>(fh.op); if(fh.rsv1) b[0] |= 0x40; if(fh.rsv2) b[0] |= 0x20; if(fh.rsv3) b[0] |= 0x10; b[1] = fh.mask ? 0x80 : 0x00; if(fh.len <= 125) { b[1] |= fh.len; n = 2; } else if(fh.len <= 65535) { b[1] |= 126; ::new(&b[2]) big_uint16_buf_t{ (std::uint16_t)fh.len}; n = 4; } else { b[1] |= 127; ::new(&b[2]) big_uint64_buf_t{fh.len}; n = 10; } if(fh.mask) { native_to_little_uint32(fh.key, &b[n]); n += 4; } db.commit(buffer_copy( db.prepare(n), buffer(b))); }
void ChunkFile::Chunk::write() { DynamicBuffer<uint8_t> buffer; auto writer = makeWriter(buffer, 1024); XOR_CHUNKFILE_OP("Writing subchunk count: %zu\n", m_chunks.size()); writer.writeLength(static_cast<uint>(m_chunks.size())); XOR_CHUNKFILE_OP("Writing chunk data size: %zu\n", m_data.sizeBytes()); writer.writeLength(static_cast<uint>(m_data.sizeBytes())); for (auto &&kv : m_chunks) { kv.second->write(); XOR_CHUNKFILE_OP("Writing subchunk name: %s\n", kv.first.cStr()); writer.writeString(kv.first); XOR_CHUNKFILE_OP("Writing subchunk block: (%lld, %lld)\n", static_cast<lld>(kv.second->m_block.begin), static_cast<lld>(kv.second->m_block.end)); writer.write(FileBlock(kv.second->m_block)); } auto totalBytes = buffer.sizeBytes() + m_data.sizeBytes(); m_file->obtainBlock(m_block, totalBytes); m_dataBlock.begin = m_block.end - static_cast<int64_t>(m_data.sizeBytes()); m_dataBlock.end = m_block.end; auto dst = m_file->span(m_block); XOR_CHUNKFILE_OP("Writing chunk header: %zu bytes\n", buffer.sizeBytes()); memcpy(dst.data(), buffer.data(), buffer.sizeBytes()); XOR_CHUNKFILE_OP("Writing chunk data: %zu bytes\n", m_data.sizeBytes()); memcpy(dst.data() + buffer.sizeBytes(), m_data.data(), m_data.sizeBytes()); }
size_type do_hints(std::size_t repeat, std::size_t count, std::size_t size) { timer t; size_type total = 0; for(auto i = repeat; i--;) { DynamicBuffer b; for(auto j = count; j--;) { for(auto remain = size; remain;) { auto const n = fill(b.prepare( read_size(b, remain))); b.commit(n); remain -= n; total += n; } } } return throughput(t.elapsed(), total); }
void testNeedMore() { error_code ec; std::size_t used; { DynamicBuffer b; parser_type<true> p; ostream(b) << "GET / HTTP/1.1\r\n"; used = p.put(b.data(), ec); BEAST_EXPECTS(ec == error::need_more, ec.message()); b.consume(used); ec.assign(0, ec.category()); ostream(b) << "User-Agent: test\r\n" "\r\n"; used = p.put(b.data(), ec); BEAST_EXPECTS(! ec, ec.message()); b.consume(used); BEAST_EXPECT(p.is_done()); BEAST_EXPECT(p.is_header_done()); } }
/** * \brief Read from the socket, info a buffer * \param Buffer The buffer to read into * \return Number of bytes read from socket **/ int Socket::readIntoBuffer(DynamicBuffer<char> & Buffer) { char Packet[PACKET_SIZE]; int TotalBytesRead = 0; int BytesRead; do { if ((BytesRead = read(Packet, PACKET_SIZE)) == -1) { #ifndef WIN32 switch (errno) { case EINPROGRESS: case EALREADY: case EAGAIN: #else switch (WSAGetLastError()) { case WSAEINPROGRESS: case WSAEALREADY: case WSAEWOULDBLOCK: #endif // this is just fine return TotalBytesRead; default: cdbg << "Socket Read Error -- " << strerror(errno) << endl; handleSocketDisconnect(); return TotalBytesRead; } } if (BytesRead > 0) { Buffer.addToBuffer(Packet, BytesRead); addToMessageBuffer(Packet, BytesRead); TotalBytesRead += BytesRead; } } while ( (BytesRead == PACKET_SIZE) && (BytesRead > 0) ); return TotalBytesRead; } /** * \brief Set the socket's address from internal structures **/ void Socket::setAddress() { mAddress = inet_ntoa(mSockAddr.sin_addr); }
status_t BHttpRequest::_MakeRequest() { delete fSocket; if (fSSL) fSocket = new(std::nothrow) CheckedSecureSocket(this); else fSocket = new(std::nothrow) BSocket(); if (fSocket == NULL) return B_NO_MEMORY; _EmitDebug(B_URL_PROTOCOL_DEBUG_TEXT, "Connection to %s on port %d.", fUrl.Authority().String(), fRemoteAddr.Port()); status_t connectError = fSocket->Connect(fRemoteAddr); if (connectError != B_OK) { _EmitDebug(B_URL_PROTOCOL_DEBUG_ERROR, "Socket connection error %s", strerror(connectError)); return connectError; } //! ProtocolHook:ConnectionOpened if (fListener != NULL) fListener->ConnectionOpened(this); _EmitDebug(B_URL_PROTOCOL_DEBUG_TEXT, "Connection opened, sending request."); _SendRequest(); _SendHeaders(); fSocket->Write("\r\n", 2); _EmitDebug(B_URL_PROTOCOL_DEBUG_TEXT, "Request sent."); _SendPostData(); fRequestStatus = kRequestInitialState; // Receive loop bool receiveEnd = false; bool parseEnd = false; bool readByChunks = false; bool decompress = false; status_t readError = B_OK; ssize_t bytesRead = 0; ssize_t bytesReceived = 0; ssize_t bytesTotal = 0; off_t bytesUnpacked = 0; char* inputTempBuffer = new(std::nothrow) char[kHttpBufferSize]; ssize_t inputTempSize = kHttpBufferSize; ssize_t chunkSize = -1; DynamicBuffer decompressorStorage; BDataIO* decompressingStream; ObjectDeleter<BDataIO> decompressingStreamDeleter; while (!fQuit && !(receiveEnd && parseEnd)) { if (!receiveEnd) { fSocket->WaitForReadable(); BStackOrHeapArray<char, 4096> chunk(kHttpBufferSize); bytesRead = fSocket->Read(chunk, kHttpBufferSize); if (bytesRead < 0) { readError = bytesRead; break; } else if (bytesRead == 0) receiveEnd = true; fInputBuffer.AppendData(chunk, bytesRead); } else bytesRead = 0; if (fRequestStatus < kRequestStatusReceived) { _ParseStatus(); //! ProtocolHook:ResponseStarted if (fRequestStatus >= kRequestStatusReceived && fListener != NULL) fListener->ResponseStarted(this); } if (fRequestStatus < kRequestHeadersReceived) { _ParseHeaders(); if (fRequestStatus >= kRequestHeadersReceived) { _ResultHeaders() = fHeaders; //! ProtocolHook:HeadersReceived if (fListener != NULL) fListener->HeadersReceived(this); // Parse received cookies if (fContext != NULL) { for (int32 i = 0; i < fHeaders.CountHeaders(); i++) { if (fHeaders.HeaderAt(i).NameIs("Set-Cookie")) { fContext->GetCookieJar().AddCookie( fHeaders.HeaderAt(i).Value(), fUrl); } } } if (BString(fHeaders["Transfer-Encoding"]) == "chunked") readByChunks = true; BString contentEncoding(fHeaders["Content-Encoding"]); // We don't advertise "deflate" support (see above), but we // still try to decompress it, if a server ever sends a deflate // stream despite it not being in our Accept-Encoding list. if (contentEncoding == "gzip" || contentEncoding == "deflate") { decompress = true; readError = BZlibCompressionAlgorithm() .CreateDecompressingOutputStream(&decompressorStorage, NULL, decompressingStream); if (readError != B_OK) break; decompressingStreamDeleter.SetTo(decompressingStream); } int32 index = fHeaders.HasHeader("Content-Length"); if (index != B_ERROR) bytesTotal = atoi(fHeaders.HeaderAt(index).Value()); else bytesTotal = -1; } } if (fRequestStatus >= kRequestHeadersReceived) { // If Transfer-Encoding is chunked, we should read a complete // chunk in buffer before handling it if (readByChunks) { if (chunkSize >= 0) { if ((ssize_t)fInputBuffer.Size() >= chunkSize + 2) { // 2 more bytes to handle the closing CR+LF bytesRead = chunkSize; if (inputTempSize < chunkSize + 2) { delete[] inputTempBuffer; inputTempSize = chunkSize + 2; inputTempBuffer = new(std::nothrow) char[inputTempSize]; } if (inputTempBuffer == NULL) { readError = B_NO_MEMORY; break; } fInputBuffer.RemoveData(inputTempBuffer, chunkSize + 2); chunkSize = -1; } else { // Not enough data, try again later bytesRead = -1; } } else { BString chunkHeader; if (_GetLine(chunkHeader) == B_ERROR) { chunkSize = -1; bytesRead = -1; } else { // Format of a chunk header: // <chunk size in hex>[; optional data] int32 semiColonIndex = chunkHeader.FindFirst(';', 0); // Cut-off optional data if present if (semiColonIndex != -1) { chunkHeader.Remove(semiColonIndex, chunkHeader.Length() - semiColonIndex); } chunkSize = strtol(chunkHeader.String(), NULL, 16); PRINT(("BHP[%p] Chunk %s=%ld\n", this, chunkHeader.String(), chunkSize)); if (chunkSize == 0) fRequestStatus = kRequestContentReceived; bytesRead = -1; } } // A chunk of 0 bytes indicates the end of the chunked transfer if (bytesRead == 0) receiveEnd = true; } else { bytesRead = fInputBuffer.Size(); if (bytesRead > 0) { if (inputTempSize < bytesRead) { inputTempSize = bytesRead; delete[] inputTempBuffer; inputTempBuffer = new(std::nothrow) char[bytesRead]; } if (inputTempBuffer == NULL) { readError = B_NO_MEMORY; break; } fInputBuffer.RemoveData(inputTempBuffer, bytesRead); } } if (bytesRead >= 0) { bytesReceived += bytesRead; if (fListener != NULL) { if (decompress) { readError = decompressingStream->WriteExactly( inputTempBuffer, bytesRead); if (readError != B_OK) break; ssize_t size = decompressorStorage.Size(); BStackOrHeapArray<char, 4096> buffer(size); size = decompressorStorage.Read(buffer, size); if (size > 0) { fListener->DataReceived(this, buffer, bytesUnpacked, size); bytesUnpacked += size; } } else if (bytesRead > 0) { fListener->DataReceived(this, inputTempBuffer, bytesReceived - bytesRead, bytesRead); } fListener->DownloadProgress(this, bytesReceived, std::max((ssize_t)0, bytesTotal)); } if (bytesTotal >= 0 && bytesReceived >= bytesTotal) receiveEnd = true; if (decompress && receiveEnd) { readError = decompressingStream->Flush(); if (readError == B_BUFFER_OVERFLOW) readError = B_OK; if (readError != B_OK) break; ssize_t size = decompressorStorage.Size(); BStackOrHeapArray<char, 4096> buffer(size); size = decompressorStorage.Read(buffer, size); if (fListener != NULL && size > 0) { fListener->DataReceived(this, buffer, bytesUnpacked, size); bytesUnpacked += size; } } } } parseEnd = (fInputBuffer.Size() == 0); } fSocket->Disconnect(); delete[] inputTempBuffer; if (readError != B_OK) return readError; return fQuit ? B_INTERRUPTED : B_OK; }
status_t BHttpRequest::_MakeRequest() { if (fSocket == NULL) return B_NO_MEMORY; _EmitDebug(B_URL_PROTOCOL_DEBUG_TEXT, "Connection to %s on port %d.", fUrl.Authority().String(), fRemoteAddr.Port()); status_t connectError = fSocket->Connect(fRemoteAddr); if (connectError != B_OK) { _EmitDebug(B_URL_PROTOCOL_DEBUG_ERROR, "Socket connection error %s", strerror(connectError)); return connectError; } //! ProtocolHook:ConnectionOpened if (fListener != NULL) fListener->ConnectionOpened(this); _EmitDebug(B_URL_PROTOCOL_DEBUG_TEXT, "Connection opened, sending request."); _SendRequest(); _SendHeaders(); fSocket->Write("\r\n", 2); _EmitDebug(B_URL_PROTOCOL_DEBUG_TEXT, "Request sent."); if (fRequestMethod == B_HTTP_POST && fOptPostFields != NULL) { if (fOptPostFields->GetFormType() != B_HTTP_FORM_MULTIPART) { BString outputBuffer = fOptPostFields->RawData(); _EmitDebug(B_URL_PROTOCOL_DEBUG_TRANSFER_OUT, "%s", outputBuffer.String()); fSocket->Write(outputBuffer.String(), outputBuffer.Length()); } else { for (BHttpForm::Iterator it = fOptPostFields->GetIterator(); const BHttpFormData* currentField = it.Next(); ) { _EmitDebug(B_URL_PROTOCOL_DEBUG_TRANSFER_OUT, it.MultipartHeader().String()); fSocket->Write(it.MultipartHeader().String(), it.MultipartHeader().Length()); switch (currentField->Type()) { default: case B_HTTPFORM_UNKNOWN: ASSERT(0); break; case B_HTTPFORM_STRING: fSocket->Write(currentField->String().String(), currentField->String().Length()); break; case B_HTTPFORM_FILE: { BFile upFile(currentField->File().Path(), B_READ_ONLY); char readBuffer[kHttpBufferSize]; ssize_t readSize; readSize = upFile.Read(readBuffer, sizeof(readBuffer)); while (readSize > 0) { fSocket->Write(readBuffer, readSize); readSize = upFile.Read(readBuffer, sizeof(readBuffer)); } break; } case B_HTTPFORM_BUFFER: fSocket->Write(currentField->Buffer(), currentField->BufferSize()); break; } fSocket->Write("\r\n", 2); } BString footer = fOptPostFields->GetMultipartFooter(); fSocket->Write(footer.String(), footer.Length()); } } else if ((fRequestMethod == B_HTTP_POST || fRequestMethod == B_HTTP_PUT) && fOptInputData != NULL) { for (;;) { char outputTempBuffer[kHttpBufferSize]; ssize_t read = fOptInputData->Read(outputTempBuffer, sizeof(outputTempBuffer)); if (read <= 0) break; if (fOptInputDataSize < 0) { // Chunked transfer char hexSize[16]; size_t hexLength = sprintf(hexSize, "%ld", read); fSocket->Write(hexSize, hexLength); fSocket->Write("\r\n", 2); fSocket->Write(outputTempBuffer, read); fSocket->Write("\r\n", 2); } else { fSocket->Write(outputTempBuffer, read); } } if (fOptInputDataSize < 0) { // Chunked transfer terminating sequence fSocket->Write("0\r\n\r\n", 5); } } fRequestStatus = kRequestInitialState; // Receive loop bool receiveEnd = false; bool parseEnd = false; bool readByChunks = false; bool decompress = false; status_t readError = B_OK; ssize_t bytesRead = 0; ssize_t bytesReceived = 0; ssize_t bytesTotal = 0; char* inputTempBuffer = new(std::nothrow) char[kHttpBufferSize]; ssize_t inputTempSize = kHttpBufferSize; ssize_t chunkSize = -1; DynamicBuffer decompressorStorage; BPrivate::ZlibDecompressor decompressor(&decompressorStorage); while (!fQuit && !(receiveEnd && parseEnd)) { if (!receiveEnd) { fSocket->WaitForReadable(); BNetBuffer chunk(kHttpBufferSize); bytesRead = fSocket->Read(chunk.Data(), kHttpBufferSize); if (bytesRead < 0) { readError = bytesRead; break; } else if (bytesRead == 0) receiveEnd = true; fInputBuffer.AppendData(chunk.Data(), bytesRead); } else bytesRead = 0; if (fRequestStatus < kRequestStatusReceived) { _ParseStatus(); //! ProtocolHook:ResponseStarted if (fRequestStatus >= kRequestStatusReceived && fListener != NULL) fListener->ResponseStarted(this); } if (fRequestStatus < kRequestHeadersReceived) { _ParseHeaders(); if (fRequestStatus >= kRequestHeadersReceived) { _ResultHeaders() = fHeaders; //! ProtocolHook:HeadersReceived if (fListener != NULL) fListener->HeadersReceived(this); // Parse received cookies if (fContext != NULL) { for (int32 i = 0; i < fHeaders.CountHeaders(); i++) { if (fHeaders.HeaderAt(i).NameIs("Set-Cookie")) { fContext->GetCookieJar().AddCookie( fHeaders.HeaderAt(i).Value(), fUrl); } } } if (BString(fHeaders["Transfer-Encoding"]) == "chunked") readByChunks = true; BString contentEncoding(fHeaders["Content-Encoding"]); if (contentEncoding == "gzip" || contentEncoding == "deflate") { decompress = true; decompressor.Init(); } int32 index = fHeaders.HasHeader("Content-Length"); if (index != B_ERROR) bytesTotal = atoi(fHeaders.HeaderAt(index).Value()); else bytesTotal = 0; } } if (fRequestStatus >= kRequestHeadersReceived) { // If Transfer-Encoding is chunked, we should read a complete // chunk in buffer before handling it if (readByChunks) { if (chunkSize >= 0) { if ((ssize_t)fInputBuffer.Size() >= chunkSize + 2) { // 2 more bytes to handle the closing CR+LF bytesRead = chunkSize; if (inputTempSize < chunkSize + 2) { delete[] inputTempBuffer; inputTempSize = chunkSize + 2; inputTempBuffer = new(std::nothrow) char[inputTempSize]; } if (inputTempBuffer == NULL) { readError = B_NO_MEMORY; break; } fInputBuffer.RemoveData(inputTempBuffer, chunkSize + 2); chunkSize = -1; } else { // Not enough data, try again later bytesRead = -1; } } else { BString chunkHeader; if (_GetLine(chunkHeader) == B_ERROR) { chunkSize = -1; bytesRead = -1; } else { // Format of a chunk header: // <chunk size in hex>[; optional data] int32 semiColonIndex = chunkHeader.FindFirst(';', 0); // Cut-off optional data if present if (semiColonIndex != -1) { chunkHeader.Remove(semiColonIndex, chunkHeader.Length() - semiColonIndex); } chunkSize = strtol(chunkHeader.String(), NULL, 16); PRINT(("BHP[%p] Chunk %s=%ld\n", this, chunkHeader.String(), chunkSize)); if (chunkSize == 0) fRequestStatus = kRequestContentReceived; bytesRead = -1; } } // A chunk of 0 bytes indicates the end of the chunked transfer if (bytesRead == 0) receiveEnd = true; } else { bytesRead = fInputBuffer.Size(); if (bytesRead > 0) { if (inputTempSize < bytesRead) { inputTempSize = bytesRead; delete[] inputTempBuffer; inputTempBuffer = new(std::nothrow) char[bytesRead]; } if (inputTempBuffer == NULL) { readError = B_NO_MEMORY; break; } fInputBuffer.RemoveData(inputTempBuffer, bytesRead); } } if (bytesRead > 0) { bytesReceived += bytesRead; if (fListener != NULL) { if (decompress) { decompressor.DecompressNext(inputTempBuffer, bytesRead); ssize_t size = decompressorStorage.Size(); BStackOrHeapArray<char, 4096> buffer(size); size = decompressorStorage.Read(buffer, size); if (size > 0) { fListener->DataReceived(this, buffer, size); } } else { fListener->DataReceived(this, inputTempBuffer, bytesRead); } fListener->DownloadProgress(this, bytesReceived, bytesTotal); } if (bytesTotal > 0 && bytesReceived >= bytesTotal) { receiveEnd = true; if (decompress) { decompressor.Finish(); ssize_t size = decompressorStorage.Size(); BStackOrHeapArray<char, 4096> buffer(size); size = decompressorStorage.Read(buffer, size); if (fListener != NULL && size > 0) { fListener->DataReceived(this, buffer, size); } } } } } parseEnd = (fInputBuffer.Size() == 0); } fSocket->Disconnect(); delete[] inputTempBuffer; if (readError != B_OK) return readError; return fQuit ? B_INTERRUPTED : B_OK; }
static void png_write_to_buffer (png_structp png_writer, png_bytep data, png_size_t length) { DynamicBuffer * buffer = (DynamicBuffer*)png_get_io_ptr(png_writer); buffer->append(length, data); }
void VertexArray::add_attribute_I(const DynamicBuffer& _buffer, uint _index, uint _offs, uint _stride, uint _size, GLenum _type) const { gl::VertexArrayVertexBuffer(vao, _index, _buffer.get_handle(), _offs, _stride); gl::VertexArrayAttribIFormat(vao, _index, _size, _type, 0u); gl::EnableVertexArrayAttrib(vao, _index); }
std::size_t read_fh1(frame_header& fh, DynamicBuffer& db, role_type role, close_code::value& code) { using boost::asio::buffer; using boost::asio::buffer_copy; using boost::asio::buffer_size; std::uint8_t b[2]; assert(buffer_size(db.data()) >= sizeof(b)); db.consume(buffer_copy(buffer(b), db.data())); std::size_t need; fh.len = b[1] & 0x7f; switch(fh.len) { case 126: need = 2; break; case 127: need = 8; break; default: need = 0; } fh.mask = (b[1] & 0x80) != 0; if(fh.mask) need += 4; fh.op = static_cast<opcode>(b[0] & 0x0f); fh.fin = (b[0] & 0x80) != 0; fh.rsv1 = (b[0] & 0x40) != 0; fh.rsv2 = (b[0] & 0x20) != 0; fh.rsv3 = (b[0] & 0x10) != 0; // invalid length for control message if(is_control(fh.op) && fh.len > 125) { code = close_code::protocol_error; return 0; } // reserved bits not cleared if(fh.rsv1 || fh.rsv2 || fh.rsv3) { code = close_code::protocol_error; return 0; } // reserved opcode if(is_reserved(fh.op)) { code = close_code::protocol_error; return 0; } // fragmented control message if(is_control(fh.op) && ! fh.fin) { code = close_code::protocol_error; return 0; } // unmasked frame from client if(role == role_type::server && ! fh.mask) { code = close_code::protocol_error; return 0; } // masked frame from server if(role == role_type::client && fh.mask) { code = close_code::protocol_error; return 0; } code = close_code::none; return need; }
int main(int argc, char **argv) { dynamic_list_t dl; DynamicBuffer *dw = new DynamicBuffer(&dl); for (unsigned int i = 0; i < 1000; ++i) { dw->append("test", strlen("test")); } cout << "Added elements, num_elements: " << dw->num_elements() << ", buffer_size: " << dw->buffer_size() << ", real_buffer_size: " << dw->real_buffer_size() << endl; DynamicBuffer *dr = new DynamicBuffer(&dl, dw->buffer(), dw->buffer_size()); cout << "Read buffer opened, num_elements: " << dr->num_elements() << ", buffer_size: " << dr->buffer_size() << ", real_buffer_size: " << dr->real_buffer_size() << endl; while (dr->has_next()) { char tmp[1024]; memset(tmp, 0, sizeof(tmp)); size_t size; void * buf = dr->next(&size); strncpy(tmp, (const char *)buf, size); printf("Read string (%lu bytes): '%s'\n", (unsigned long int)size, tmp); } delete dw; delete dr; }
Buffer* Buffer::copy(string& s) { DynamicBuffer* b = new DynamicBuffer(s.length()); strncpy(b->getModifiableData(), s.data(), s.length()); return b; }
Buffer* Buffer::wrap(long l) { DynamicBuffer* b = new DynamicBuffer(8); b->putLong(0, l); return b; }
Buffer* Buffer::wrap(int i) { DynamicBuffer* b = new DynamicBuffer(4); b->putInt(0, i); return b; }