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