Add TCP support (#12)

Reviewed-on: #12
Co-authored-by: Persson-dev <sim16.prib@gmail.com>
Co-committed-by: Persson-dev <sim16.prib@gmail.com>

src/sp/common/DataBuffer.cpp

@@ -8,6 +8,8 @@ namespace sp {
 
 DataBuffer::DataBuffer() : m_ReadOffset(0) {}
 
+DataBuffer::DataBuffer(std::size_t a_InitialSize) : m_Buffer(a_InitialSize), m_ReadOffset(0) {}
+
 DataBuffer::DataBuffer(const DataBuffer& other) : m_Buffer(other.m_Buffer), m_ReadOffset(other.m_ReadOffset) {}
 
 DataBuffer::DataBuffer(DataBuffer&& other) : m_Buffer(std::move(other.m_Buffer)), m_ReadOffset(std::move(other.m_ReadOffset)) {}

src/sp/extensions/Compress.cpp

@@ -11,7 +11,7 @@ static DataBuffer Inflate(const std::uint8_t* source, std::size_t size, std::siz
 	DataBuffer result;
 	result.Resize(uncompressedSize);
 
-	uncompress(static_cast<Bytef*>(result.data()), static_cast<uLongf*>(&uncompressedSize), static_cast<const Bytef*>(source),
+	uncompress(static_cast<Bytef*>(result.data()), reinterpret_cast<uLongf*>(&uncompressedSize), static_cast<const Bytef*>(source),
 		static_cast<uLong>(size));
 
 	assert(result.GetSize() == uncompressedSize);

src/sp/extensions/TcpListener.cpp

@@ -0,0 +1,114 @@
+#include <sp/extensions/tcp/TcpListener.h>
+
+
+#ifdef _WIN32
+
+// Windows
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#define ioctl ioctlsocket
+#define WOULDBLOCK WSAEWOULDBLOCK
+#define MSG_DONTWAIT 0
+
+#else
+
+// Linux/Unix
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define closesocket close
+#define WOULDBLOCK EWOULDBLOCK
+#define SD_BOTH SHUT_RDWR
+
+#endif
+
+
+
+#ifndef INVALID_SOCKET
+#define INVALID_SOCKET -1
+#endif
+
+
+namespace sp {
+namespace io {
+
+TcpListener::TcpListener(std::uint16_t a_Port, int a_MaxConnexions) {
+	if ((m_Handle = static_cast<SocketHandle>(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))) < 0) {
+		throw SocketError("Failed to create server socket");
+	}
+
+	struct sockaddr_in address;
+	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = INADDR_ANY;
+	address.sin_port = htons(a_Port);
+
+	if (bind(m_Handle, reinterpret_cast<sockaddr*>(&address), sizeof(address)) < 0)
+		throw SocketError("Failed to create server socket");
+
+	if (listen(m_Handle, a_MaxConnexions) < 0)
+		throw SocketError("Failed to create server socket");
+
+	socklen_t len = sizeof(address);
+	if (getsockname(m_Handle, reinterpret_cast<sockaddr*>(&address), &len) < 0)
+		throw SocketError("Failed to create server socket");
+
+	m_Port = ntohs(address.sin_port);
+	m_MaxConnections = a_MaxConnexions;
+}
+
+
+TcpListener::~TcpListener() {
+	Close();
+}
+
+std::unique_ptr<TcpSocket> TcpListener::Accept() {
+	sockaddr remoteAddress;
+	int addrlen = sizeof(remoteAddress);
+
+	auto newSocket = std::make_unique<TcpSocket>();
+
+	newSocket->m_Handle = static_cast<SocketHandle>(
+		accept(m_Handle, reinterpret_cast<sockaddr*>(&remoteAddress), reinterpret_cast<socklen_t*>(&addrlen)));
+
+	if (newSocket->m_Handle < 0)
+		return nullptr;
+
+	newSocket->m_Status = TcpSocket::Status::Connected;
+	return newSocket;
+}
+
+void TcpListener::Close() {
+	if (m_Handle > 0) {
+		closesocket(m_Handle);
+		shutdown(m_Handle, SD_BOTH);
+	}
+}
+
+bool TcpListener::SetBlocking(bool a_Blocking) {
+	unsigned long mode = !a_Blocking;
+
+	if (ioctl(m_Handle, FIONBIO, &mode) < 0) {
+		return false;
+	}
+
+	return true;
+}
+
+std::uint16_t TcpListener::GetListeningPort() const {
+	return m_Port;
+}
+
+int TcpListener::GetMaximumConnections() const {
+	return m_MaxConnections;
+}
+
+}  // namespace io
+}  // namespace sp

src/sp/extensions/TcpSocket.cpp

@@ -0,0 +1,164 @@
+#include <sp/extensions/tcp/TcpSocket.h>
+
+#ifdef _WIN32
+
+// Windows
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#define ioctl ioctlsocket
+#define WOULDBLOCK WSAEWOULDBLOCK
+#define MSG_DONTWAIT 0
+
+#else
+
+// Linux/Unix
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define closesocket close
+#define WOULDBLOCK EWOULDBLOCK
+
+#endif
+
+
+
+#ifndef INVALID_SOCKET
+#define INVALID_SOCKET -1
+#endif
+
+
+namespace sp {
+namespace io {
+
+TcpSocket::IOInterface() : m_Handle(static_cast<SocketHandle>(INVALID_SOCKET)), m_Status(Status::Disconnected) {}
+
+TcpSocket::IOInterface(const std::string& a_Host, std::uint16_t a_Port) : IOInterface() {
+	Connect(a_Host, a_Port);
+}
+
+TcpSocket::IOInterface(IOInterface&& a_Other) {
+	std::swap(m_Handle, a_Other.m_Handle);
+	std::swap(m_Status, a_Other.m_Status);
+}
+
+TcpSocket::~IOInterface() {}
+
+void TcpSocket::Connect(const std::string& a_Host, std::uint16_t a_Port) {
+	struct addrinfo hints {};
+
+	struct addrinfo* result = nullptr;
+
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	m_Status = Status::Error;
+
+	if (getaddrinfo(a_Host.c_str(), std::to_string(static_cast<int>(a_Port)).c_str(), &hints, &result) != 0) {
+		throw SocketError("Failed to get address info");
+	}
+
+	m_Handle = static_cast<SocketHandle>(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+	if (m_Handle < 0) {
+		throw SocketError("Failed to create socket");
+	}
+
+	struct addrinfo* ptr = nullptr;
+	for (ptr = result; ptr != nullptr; ptr = ptr->ai_next) {
+		struct sockaddr* sockaddr = ptr->ai_addr;
+		if (connect(m_Handle, sockaddr, sizeof(sockaddr_in)) == 0) {
+			break;
+		}
+	}
+
+	freeaddrinfo(result);
+
+	if (!ptr) {
+		throw SocketError("Could not find a suitable interface for connecting");
+	}
+
+	m_Status = Status::Connected;
+}
+
+DataBuffer TcpSocket::Read(std::size_t a_Amount) {
+	DataBuffer buffer(a_Amount);
+
+	std::size_t totalRecieved = 0;
+
+	while (totalRecieved < a_Amount) {
+		int recvAmount =
+			recv(m_Handle, reinterpret_cast<char*>(buffer.data() + totalRecieved), static_cast<int>(a_Amount - totalRecieved), 0);
+		if (recvAmount <= 0) {
+#if defined(_WIN32) || defined(WIN32)
+			int err = WSAGetLastError();
+#else
+			int err = errno;
+#endif
+			if (err == WOULDBLOCK) {
+				// we are in non blocking mode and nothing is available
+				return {};
+			}
+
+			Disconnect();
+			m_Status = Status::Error;
+			throw SocketError("Error while reading");
+		}
+		totalRecieved += recvAmount;
+	}
+	return buffer;
+}
+
+void TcpSocket::Write(const sp::DataBuffer& a_Data) {
+	if (GetStatus() != Status::Connected)
+		return;
+
+	std::size_t sent = 0;
+
+	while (sent < a_Data.GetSize()) {
+		int cur = send(m_Handle, reinterpret_cast<const char*>(a_Data.data() + sent), static_cast<int>(a_Data.GetSize() - sent), 0);
+
+		if (cur <= 0) {
+			Disconnect();
+			m_Status = Status::Error;
+			return;
+		}
+		sent += static_cast<std::size_t>(cur);
+	}
+}
+
+bool TcpSocket::SetBlocking(bool a_Block) {
+	unsigned long mode = !a_Block;
+
+	if (ioctl(m_Handle, FIONBIO, &mode) < 0) {
+		return false;
+	}
+
+	return true;
+}
+
+TcpSocket::Status TcpSocket::GetStatus() const {
+	return m_Status;
+}
+
+void TcpSocket::Disconnect() {
+	if (m_Handle > 0)
+		closesocket(m_Handle);
+	m_Status = Status::Disconnected;
+}
+
+TcpSocket& TcpSocket::operator=(IOInterface&& a_Other) {
+	std::swap(m_Handle, a_Other.m_Handle);
+	std::swap(m_Status, a_Other.m_Status);
+	return *this;
+}
+
+}  // namespace io
+}  // namespace sp