RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 02:57:44 +00:00
Code Issues Activity Actions

LibWebSocket: Switch to using Core::Stream

Browse source 
As LibTLS now supports the Core::Stream APIs, we can get rid of the
split paths for TCP/TLS and significantly simplify the code as well.
Provided to you free of charge by the Core::Stream-ification team :^)
This commit is contained in:
Ali Mohammad Pur 2022-02-04 14:13:30 +03:30 • committed by Andreas Kling
parent d66c513131
commit 3f614a8fca
11 changed files with 142 additions and 348 deletions
Download patch file Download diff file Expand all files Collapse all files

20
Userland/Libraries/LibWebSocket/Impl/AbstractWebSocketImpl.cpp
View file

@ -1,20 +0,0 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibWebSocket/Impl/AbstractWebSocketImpl.h>
namespace WebSocket {
AbstractWebSocketImpl::AbstractWebSocketImpl(Core::Object* parent)
: Object(parent)
{
}
AbstractWebSocketImpl::~AbstractWebSocketImpl()
{
}
}

43
Userland/Libraries/LibWebSocket/Impl/AbstractWebSocketImpl.h
View file

@ -1,43 +0,0 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Span.h>
#include <AK/String.h>
#include <LibCore/Object.h>
#include <LibWebSocket/ConnectionInfo.h>
namespace WebSocket {
class AbstractWebSocketImpl : public Core::Object {
C_OBJECT_ABSTRACT(AbstractWebSocketImpl);
public:
virtual ~AbstractWebSocketImpl() override;
explicit AbstractWebSocketImpl(Core::Object* parent = nullptr);
virtual void connect(ConnectionInfo const&) = 0;
virtual bool can_read_line() = 0;
virtual String read_line(size_t size) = 0;
virtual bool can_read() = 0;
virtual ByteBuffer read(int max_size) = 0;
virtual bool send(ReadonlyBytes) = 0;
virtual bool eof() = 0;
virtual void discard_connection() = 0;
Function<void()> on_connected;
Function<void()> on_connection_error;
Function<void()> on_ready_to_read;
};
}

84
Userland/Libraries/LibWebSocket/Impl/TCPWebSocketConnectionImpl.cpp
View file

@ -1,84 +0,0 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibWebSocket/Impl/TCPWebSocketConnectionImpl.h>
namespace WebSocket {
TCPWebSocketConnectionImpl::TCPWebSocketConnectionImpl(Core::Object* parent)
: AbstractWebSocketImpl(parent)
{
}
TCPWebSocketConnectionImpl::~TCPWebSocketConnectionImpl()
{
discard_connection();
}
void TCPWebSocketConnectionImpl::connect(ConnectionInfo const& connection)
{
VERIFY(!m_socket);
VERIFY(on_connected);
VERIFY(on_connection_error);
VERIFY(on_ready_to_read);
m_socket = Core::TCPSocket::construct(this);
m_notifier = Core::Notifier::construct(m_socket->fd(), Core::Notifier::Read);
m_notifier->on_ready_to_read = [this] {
on_ready_to_read();
};
m_socket->on_connected = [this] {
on_connected();
};
bool success = m_socket->connect(connection.url().host(), connection.url().port_or_default());
if (!success) {
deferred_invoke([this] {
on_connection_error();
});
}
}
bool TCPWebSocketConnectionImpl::send(ReadonlyBytes data)
{
return m_socket->write(data);
}
bool TCPWebSocketConnectionImpl::can_read_line()
{
return m_socket->can_read_line();
}
String TCPWebSocketConnectionImpl::read_line(size_t size)
{
return m_socket->read_line(size);
}
bool TCPWebSocketConnectionImpl::can_read()
{
return m_socket->can_read();
}
ByteBuffer TCPWebSocketConnectionImpl::read(int max_size)
{
return m_socket->read(max_size);
}
bool TCPWebSocketConnectionImpl::eof()
{
return m_socket->eof();
}
void TCPWebSocketConnectionImpl::discard_connection()
{
if (!m_socket)
return;
m_socket->on_ready_to_read = nullptr;
remove_child(*m_socket);
m_socket = nullptr;
}
}

47
Userland/Libraries/LibWebSocket/Impl/TCPWebSocketConnectionImpl.h
View file

@ -1,47 +0,0 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Span.h>
#include <AK/String.h>
#include <LibCore/Notifier.h>
#include <LibCore/Object.h>
#include <LibCore/TCPSocket.h>
#include <LibWebSocket/ConnectionInfo.h>
#include <LibWebSocket/Impl/AbstractWebSocketImpl.h>
namespace WebSocket {
class TCPWebSocketConnectionImpl final : public AbstractWebSocketImpl {
C_OBJECT(TCPWebSocketConnectionImpl);
public:
virtual ~TCPWebSocketConnectionImpl() override;
virtual void connect(ConnectionInfo const& connection) override;
virtual bool can_read_line() override;
virtual String read_line(size_t size) override;
virtual bool can_read() override;
virtual ByteBuffer read(int max_size) override;
virtual bool send(ReadonlyBytes data) override;
virtual bool eof() override;
virtual void discard_connection() override;
private:
explicit TCPWebSocketConnectionImpl(Core::Object* parent = nullptr);
RefPtr<Core::Notifier> m_notifier;
RefPtr<Core::TCPSocket> m_socket;
};
}

87
Userland/Libraries/LibWebSocket/Impl/TLSv12WebSocketConnectionImpl.cpp
View file

@ -1,87 +0,0 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibWebSocket/Impl/TLSv12WebSocketConnectionImpl.h>
namespace WebSocket {
TLSv12WebSocketConnectionImpl::TLSv12WebSocketConnectionImpl(Core::Object* parent)
: AbstractWebSocketImpl(parent)
{
}
TLSv12WebSocketConnectionImpl::~TLSv12WebSocketConnectionImpl()
{
discard_connection();
}
void TLSv12WebSocketConnectionImpl::connect(ConnectionInfo const& connection)
{
VERIFY(!m_socket);
VERIFY(on_connected);
VERIFY(on_connection_error);
VERIFY(on_ready_to_read);
m_socket = TLS::TLSv12::connect(connection.url().host(), connection.url().port_or_default()).release_value_but_fixme_should_propagate_errors();
m_socket->on_tls_error = [this](TLS::AlertDescription) {
on_connection_error();
};
m_socket->on_ready_to_read = [this] {
on_ready_to_read();
};
m_socket->on_tls_finished = [this] {
on_connection_error();
};
m_socket->on_tls_certificate_request = [](auto&) {
// FIXME : Once we handle TLS certificate requests, handle it here as well.
};
on_connected();
}
bool TLSv12WebSocketConnectionImpl::send(ReadonlyBytes data)
{
return m_socket->write_or_error(data);
}
bool TLSv12WebSocketConnectionImpl::can_read_line()
{
return m_socket->can_read_line();
}
String TLSv12WebSocketConnectionImpl::read_line(size_t size)
{
return m_socket->read_line(size);
}
bool TLSv12WebSocketConnectionImpl::can_read()
{
return m_socket->can_read();
}
ByteBuffer TLSv12WebSocketConnectionImpl::read(int max_size)
{
auto buffer = ByteBuffer::create_uninitialized(max_size).release_value_but_fixme_should_propagate_errors();
auto nread = m_socket->read(buffer).release_value_but_fixme_should_propagate_errors();
return buffer.slice(0, nread);
}
bool TLSv12WebSocketConnectionImpl::eof()
{
return m_socket->is_eof();
}
void TLSv12WebSocketConnectionImpl::discard_connection()
{
if (!m_socket)
return;
m_socket->on_tls_error = nullptr;
m_socket->on_tls_finished = nullptr;
m_socket->on_tls_certificate_request = nullptr;
m_socket->on_ready_to_read = nullptr;
m_socket = nullptr;
}
}

45
Userland/Libraries/LibWebSocket/Impl/TLSv12WebSocketConnectionImpl.h
View file

@ -1,45 +0,0 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Span.h>
#include <AK/String.h>
#include <LibCore/Object.h>
#include <LibTLS/TLSv12.h>
#include <LibWebSocket/ConnectionInfo.h>
#include <LibWebSocket/Impl/AbstractWebSocketImpl.h>
namespace WebSocket {
class TLSv12WebSocketConnectionImpl final : public AbstractWebSocketImpl {
C_OBJECT(TLSv12WebSocketConnectionImpl);
public:
virtual ~TLSv12WebSocketConnectionImpl() override;
void connect(ConnectionInfo const& connection) override;
virtual bool can_read_line() override;
virtual String read_line(size_t size) override;
virtual bool can_read() override;
virtual ByteBuffer read(int max_size) override;
virtual bool send(ReadonlyBytes data) override;
virtual bool eof() override;
virtual void discard_connection() override;
private:
explicit TLSv12WebSocketConnectionImpl(Core::Object* parent = nullptr);
OwnPtr<TLS::TLSv12> m_socket;
};
}

73
Userland/Libraries/LibWebSocket/Impl/WebSocketImpl.cpp Normal file
View file

@ -0,0 +1,73 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
* Copyright (c) 2022, Ali Mohammad Pur <mpfard@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibWebSocket/Impl/WebSocketImpl.h>
namespace WebSocket {
WebSocketImpl::WebSocketImpl(Core::Object* parent)
: Object(parent)
{
}
WebSocketImpl::~WebSocketImpl()
{
}
void WebSocketImpl::connect(ConnectionInfo const& connection_info)
{
VERIFY(!m_socket);
VERIFY(on_connected);
VERIFY(on_connection_error);
VERIFY(on_ready_to_read);
auto socket_result = [&]() -> ErrorOr<NonnullOwnPtr<Core::Stream::BufferedSocketBase>> {
if (connection_info.is_secure()) {
TLS::Options options;
options.set_alert_handler([this](auto) {
on_connection_error();
});
return TRY(Core::Stream::BufferedSocket<TLS::TLSv12>::create(
TRY(TLS::TLSv12::connect(connection_info.url().host(), connection_info.url().port_or_default(), move(options)))));
}
return TRY(Core::Stream::BufferedTCPSocket::create(
TRY(Core::Stream::TCPSocket::connect(connection_info.url().host(), connection_info.url().port_or_default()))));
}();
if (socket_result.is_error()) {
deferred_invoke([this] {
on_connection_error();
});
return;
}
m_socket = socket_result.release_value();
m_socket->on_ready_to_read = [this] {
on_ready_to_read();
};
deferred_invoke([this] {
on_connected();
});
}
ErrorOr<ByteBuffer> WebSocketImpl::read(int max_size)
{
auto buffer = TRY(ByteBuffer::create_uninitialized(max_size));
auto nread = TRY(m_socket->read(buffer));
return buffer.slice(0, nread);
}
ErrorOr<String> WebSocketImpl::read_line(size_t size)
{
auto buffer = TRY(ByteBuffer::create_uninitialized(size));
auto nread = TRY(m_socket->read_line(buffer));
return String::copy(buffer.span().slice(0, nread));
}
}

50
Userland/Libraries/LibWebSocket/Impl/WebSocketImpl.h Normal file
View file

@ -0,0 +1,50 @@
/*
* Copyright (c) 2021, Dex♪ <dexes.ttp@gmail.com>
* Copyright (c) 2022, Ali Mohammad Pur <mpfard@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Span.h>
#include <AK/String.h>
#include <LibCore/Object.h>
#include <LibWebSocket/ConnectionInfo.h>
namespace WebSocket {
class WebSocketImpl : public Core::Object {
C_OBJECT(WebSocketImpl);
public:
virtual ~WebSocketImpl() override;
explicit WebSocketImpl(Core::Object* parent = nullptr);
void connect(ConnectionInfo const&);
bool can_read_line() { return MUST(m_socket->can_read_line()); }
ErrorOr<String> read_line(size_t size);
bool can_read() { return MUST(m_socket->can_read_without_blocking()); }
ErrorOr<ByteBuffer> read(int max_size);
bool send(ReadonlyBytes bytes) { return m_socket->write_or_error(bytes); }
bool eof() { return m_socket->is_eof(); }
void discard_connection()
{
m_socket.clear();
}
Function<void()> on_connected;
Function<void()> on_connection_error;
Function<void()> on_ready_to_read;
private:
OwnPtr<Core::Stream::BufferedSocketBase> m_socket;
};
}