bool Body::hasPendingActivity() const
{
if (executionContext()->activeDOMObjectsAreStopped())
return false;
if (!bodyBuffer())
return false;
return bodyBuffer()->hasPendingActivity();
}
ScriptPromise Body::text(ScriptState* scriptState)
{
ScriptPromise promise = rejectInvalidConsumption(scriptState);
if (!promise.isEmpty())
return promise;
// See above comment.
if (!scriptState->executionContext())
return ScriptPromise();
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
promise = resolver->promise();
if (bodyBuffer()) {
bodyBuffer()->startLoading(scriptState->executionContext(), FetchDataLoader::createLoaderAsString(), new BodyTextConsumer(resolver));
} else {
resolver->resolve(String());
}
return promise;
}
ScriptPromise Body::json(ScriptState* scriptState)
{
ScriptPromise promise = rejectInvalidConsumption(scriptState);
if (!promise.isEmpty())
return promise;
// See above comment.
if (!scriptState->executionContext())
return ScriptPromise();
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
promise = resolver->promise();
if (bodyBuffer()) {
bodyBuffer()->startLoading(scriptState->executionContext(), FetchDataLoader::createLoaderAsString(), new BodyJsonConsumer(resolver));
} else {
resolver->reject(V8ThrowException::createSyntaxError(scriptState->isolate(), "Unexpected end of input"));
}
return promise;
}
/* static */ bool DictFileWritingUtils::createEmptyV3DictFile(const char *const filePath,
const HeaderReadWriteUtils::AttributeMap *const attributeMap) {
BufferWithExtendableBuffer headerBuffer(0 /* originalBuffer */, 0 /* originalBufferSize */);
HeaderPolicy headerPolicy(FormatUtils::VERSION_3, attributeMap);
headerPolicy.writeHeaderToBuffer(&headerBuffer, true /* updatesLastUpdatedTime */,
true /* updatesLastDecayedTime */, 0 /* unigramCount */, 0 /* bigramCount */,
0 /* extendedRegionSize */);
BufferWithExtendableBuffer bodyBuffer(0 /* originalBuffer */, 0 /* originalBufferSize */);
if (!DynamicPatriciaTrieWritingUtils::writeEmptyDictionary(&bodyBuffer, 0 /* rootPos */)) {
return false;
}
return flushAllHeaderAndBodyToFile(filePath, &headerBuffer, &bodyBuffer);
}
ScriptPromise Body::blob(ScriptState* scriptState)
{
ScriptPromise promise = rejectInvalidConsumption(scriptState);
if (!promise.isEmpty())
return promise;
// See above comment.
if (!scriptState->executionContext())
return ScriptPromise();
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
promise = resolver->promise();
if (bodyBuffer()) {
bodyBuffer()->startLoading(scriptState->executionContext(), FetchDataLoader::createLoaderAsBlobHandle(mimeType()), new BodyBlobConsumer(resolver));
} else {
OwnPtr<BlobData> blobData = BlobData::create();
blobData->setContentType(mimeType());
resolver->resolve(Blob::create(BlobDataHandle::create(blobData.release(), 0)));
}
return promise;
}
ScriptPromise Body::text(ScriptState* scriptState)
{
if (bodyUsed())
return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Already read"));
// See above comment.
if (!scriptState->executionContext())
return ScriptPromise();
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
bodyBuffer()->startLoading(scriptState->executionContext(), FetchDataLoader::createLoaderAsString(), new BodyTextConsumer(resolver));
return promise;
}
ScriptPromise Body::arrayBuffer(ScriptState* scriptState)
{
ScriptPromise promise = rejectInvalidConsumption(scriptState);
if (!promise.isEmpty())
return promise;
// When the main thread sends a V8::TerminateExecution() signal to a worker
// thread, any V8 API on the worker thread starts returning an empty
// handle. This can happen in Body::readAsync. To avoid the situation, we
// first check the ExecutionContext and return immediately if it's already
// gone (which means that the V8::TerminateExecution() signal has been sent
// to this worker thread).
if (!scriptState->executionContext())
return ScriptPromise();
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
promise = resolver->promise();
if (bodyBuffer()) {
bodyBuffer()->startLoading(scriptState->executionContext(), FetchDataLoader::createLoaderAsArrayBuffer(), new BodyArrayBufferConsumer(resolver));
} else {
resolver->resolve(DOMArrayBuffer::create(0u, 1));
}
return promise;
}
ScriptPromise Body::arrayBuffer(ScriptState* scriptState)
{
if (bodyUsed())
return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Already read"));
// When the main thread sends a V8::TerminateExecution() signal to a worker
// thread, any V8 API on the worker thread starts returning an empty
// handle. This can happen in Body::readAsync. To avoid the situation, we
// first check the ExecutionContext and return immediately if it's already
// gone (which means that the V8::TerminateExecution() signal has been sent
// to this worker thread).
if (!scriptState->executionContext())
return ScriptPromise();
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
bodyBuffer()->startLoading(scriptState->executionContext(), FetchDataLoader::createLoaderAsArrayBuffer(), new BodyArrayBufferConsumer(resolver));
return promise;
}
ReadableByteStream* Body::body()
{
UseCounter::count(executionContext(), UseCounter::FetchBodyStream);
return bodyBuffer()->stream();
}
void ClientConnection::threadMain()
{
while (m_running)
{
char headerBuffer[sizeof(CommsProtocolHeader)];
auto headerBytesRead = m_socket->read(&headerBuffer, sizeof(headerBuffer), true);
if (headerBytesRead == sizeof(headerBuffer))
{
CommsProtocolHeader* header = reinterpret_cast<CommsProtocolHeader*>(headerBuffer);
if (CommsProtocolHeader::isValid(*header))
{
// We received a valid header
auto bytesToRead = header->length;
std::string body;
while (bytesToRead)
{
int payload = bytesToRead < 1024 ? bytesToRead : 1024;
std::vector<char> bodyBuffer(payload + 1);
bodyBuffer[payload] = 0;
auto bytesRead = m_socket->read(bodyBuffer.data(), bodyBuffer.size() - 1, true);
if (bytesRead == payload)
{
body += bodyBuffer.data();
bytesToRead -= bytesRead;
}
else
{
DBG("Error reading message body");
close();
break;
}
}
DBG("Body received: " << body);
std::string response = "Thanks for the data!";
m_socket->write(response.c_str(), response.length() + 1);
}
else
{
// We received an invalid header, just move on
DBG("Invalid header received: " << headerBuffer);
}
}
else if (headerBytesRead == 0)
{
DBG("No bytes received when attempting to receive header, closing");
close();
}
else if (headerBytesRead < 0)
{
DBG("Error whilst attempting to receive header, closing");
close();
}
else
{
DBG("Incorrect header size, received " << headerBytesRead << ", should be " << String(sizeof(CommsProtocolHeader)));
close();
}
}
}
ReadableByteStream* Body::body()
{
return bodyBuffer() ? bodyBuffer()->stream() : nullptr;
}
