HappyTanuki/Np_Term
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

iocp 구현하기

Browse Source
This commit is contained in:
HappyTanuki
2025-05-31 03:19:58 +09:00
parent 466a80f02b
commit a65483a9c3
55 changed files with 608 additions and 683 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
impl/precomp.cpp Normal file
View File

@@ -0,0 +1,3 @@
#include "precomp.h"
int close(int sock) { return ::closesocket(sock); }

67
impl/session/session.cpp
View File

@@ -1,10 +1,71 @@
#include "session/session.h"
#include "socket/tcp_socket.h"
#include "socket/udp_socket.h"
#include "utils/thread_pool.h"
namespace happytanuki {
namespace Network {
Session::Session(utils::ThreadPool* tp, SessionProtocol proto) {
Session::Session(gsl::not_null<Network::IOCP*> iocp, utils::ThreadPool* tp,
SessionType type, SessionProtocol proto, Network::Address addr)
: iocp_(iocp), tp_(tp), proto_(proto) {
switch (proto) {
case SessionProtocol::UDP:
case SessionProtocol::QUIC: {
Network::UDPSocket* sock = new Network::UDPSocket();
sock_ = sock;
sock->init(addr.family);
switch (type) {
case SessionType::CONNECT:
ssl_ctx_ = ::SSL_CTX_new(::OSSL_QUIC_client_method());
if (ssl_ctx_ == nullptr) {
spdlog::critical("SSL_CTX_new()");
std::exit(EXIT_FAILURE);
}
::SSL_CTX_set_verify(ssl_ctx_, SSL_VERIFY_PEER, NULL);
if (!::SSL_CTX_set_default_verify_paths(ssl_ctx_)) {
spdlog::critical("SSL_CTX_set_default_verify_paths()");
std::exit(EXIT_FAILURE);
}
break;
case SessionType::LISTEN:
sock->bind(addr);
break;
default:
std::exit(EXIT_FAILURE);
}
} break;
case SessionProtocol::TCP:
case SessionProtocol::TLS: {
Network::TCPSocket* sock = new Network::TCPSocket();
sock_ = sock;
sock->init(addr.family);
switch (type) {
case SessionType::CONNECT:
sock->connect(addr);
break;
case SessionType::LISTEN:
sock->bind(addr);
sock->listen(SOMAXCONN);
break;
default:
std::exit(EXIT_FAILURE);
}
} break;
default:
std::exit(EXIT_FAILURE);
}
ssl_ = ::SSL_new(ssl_ctx_);
if (ssl_ == nullptr) {
spdlog::critical("SSL_new()");
std::exit(EXIT_FAILURE);
}
}
} // namespace happytanuki
Session::~Session() {
if (sock_ != nullptr) delete sock_;
}
} // namespace Network

94
impl/socket/address.cpp
View File

@@ -1,10 +1,12 @@
#include "socket/address.h"
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <format>
#include "precomp.h"
namespace Socket {
namespace Network {
Address::Address() { zeroFill(); }
@@ -17,55 +19,56 @@ void Address::zeroFill() { memset(&addr_in6, 0, sizeof(addr_in6)); }
void Address::set(int type, gsl::czstring presentationAddr,
std::uint16_t port) {
zeroFill();
setType(type);
if (type == AF_INET) {
addr_in.sin_family = AF_INET;
::inet_pton(AF_INET, presentationAddr, &addr_in.sin_addr);
addr_in.sin_port = htons(port);
length = sizeof(sockaddr_in);
} else if (type == AF_INET6) {
addr_in6.sin6_family = AF_INET6;
::inet_pton(AF_INET6, presentationAddr, &addr_in6.sin6_addr);
addr_in6.sin6_port = htons(port);
length = sizeof(sockaddr_in6);
BIO_ADDRINFO* res;
if (!BIO_lookup_ex(presentationAddr, std::to_string(port).c_str(),
BIO_LOOKUP_CLIENT, type, SOCK_DGRAM, 0, &res)) {
throw std::runtime_error("can't resolve address");
}
int sock = -1;
for (const BIO_ADDRINFO* ai = res; ai != nullptr;
ai = ::BIO_ADDRINFO_next(ai)) {
sock = BIO_socket(BIO_ADDRINFO_family(ai), SOCK_DGRAM, 0, 0);
if (sock == -1) continue;
}
::close(sock);
addr_in.sin_family = type;
::inet_pton(type, presentationAddr, &addr_in.sin_addr);
addr_in.sin_port = htons(port);
}
void Address::set(int type, in_addr_t addr, std::uint16_t port) {
zeroFill();
setType(type);
if (type == AF_INET) {
addr_in.sin_family = AF_INET;
addr_in.sin_addr.s_addr = htonl(addr);
addr_in.sin_port = htons(port);
length = sizeof(sockaddr_in);
}
addr_in.sin_family = type;
addr_in.sin_addr.s_addr = htonl(addr);
addr_in.sin_port = htons(port);
}
void Address::set(int type, in_addr addr, std::uint16_t port) {
zeroFill();
setType(type);
if (type == AF_INET) {
addr_in.sin_family = AF_INET;
addr_in.sin_addr = addr;
addr_in.sin_port = htons(port);
length = sizeof(sockaddr_in);
}
addr_in.sin_family = type;
addr_in.sin_addr = addr;
addr_in.sin_port = htons(port);
}
void Address::set(int type, in6_addr addr, std::uint16_t port) {
zeroFill();
setType(type);
if (type == AF_INET6) {
addr_in6.sin6_family = AF_INET6;
addr_in6.sin6_addr = addr;
addr_in6.sin6_port = htons(port);
length = sizeof(sockaddr_in6);
}
addr_in6.sin6_family = type;
addr_in6.sin6_addr = addr;
addr_in6.sin6_port = htons(port);
}
void Address::setType(int type) {
zeroFill();
family = type;
if (type == AF_INET)
length = sizeof(sockaddr_in);
@@ -74,32 +77,23 @@ void Address::setType(int type) {
}
Address::operator std::string() {
std::optional<std::uint16_t> port = getPort();
char addrStr[INET6_ADDRSTRLEN];
if (!port) return std::string();
if (family != AF_INET && family != AF_INET6 || !getPort())
return std::string();
if (length == sizeof(addr_in)) {
char addrStr[INET_ADDRSTRLEN];
::inet_ntop(AF_INET, &addr_in.sin_addr, addrStr, sizeof(addrStr));
::inet_ntop(family, &addr, addrStr, sizeof(addrStr));
return std::format("{}:{}", addrStr, port.value());
} else if (length == sizeof(addr_in6)) {
char addrStr[INET6_ADDRSTRLEN];
::inet_ntop(AF_INET6, &addr_in6.sin6_addr, addrStr, sizeof(addrStr));
return std::format("{}:{}", addrStr, port.value());
}
return std::string();
return std::format("{}:{}", addrStr, getPort());
}
std::uint16_t Address::getPort() {
if (length == sizeof(addr_in))
std::uint16_t Address::getPort() const {
if (family == AF_INET)
return ntohs(addr_in.sin_port);
else if (length == sizeof(addr_in6))
else if (family == AF_INET6)
return ntohs(addr_in6.sin6_port);
else
return 0;
}
} // namespace Chattr
} // namespace Network

66
impl/socket/iocp.cpp
View File

@@ -2,68 +2,52 @@
#include "utils/thread_pool.h"
namespace Socket {
IOCP::IOCP() {}
namespace Network {
IOCP::~IOCP() { destruct(); }
void IOCP::destruct() {
#ifdef __linux__
uint64_t u = 1;
::write(epollDetroyerFd, &u, sizeof(uint64_t));
close(epollfd_);
#endif
}
void IOCP::registerSocket(IOCPPASSINDATA* data) {
data->event = IOCPEVENT::READ;
#ifdef _WIN32
HANDLE returnData = ::CreateIoCompletionPort(
(HANDLE)data->socket->sock, completionPort_, data->socket->sock, 0);
if (returnData == 0) completionPort_ = returnData;
#elif __linux__
int flags = ::fcntl(data->socket->sock, F_GETFL);
flags |= O_NONBLOCK;
fcntl(data->socket->sock, F_SETFL, flags);
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLONESHOT;
data->sendQueue = std::make_shared<std::queue<IOCPPASSINDATA*>>();
ev.data.ptr = data;
int rc = epoll_ctl(epollfd_, EPOLL_CTL_ADD, data->socket->sock, &ev);
if (rc < 0) log::critical("epoll_ctl()");
#endif
}
int IOCP::recv(IOCPPASSINDATA* data, int bufferCount) {
data->event = IOCPEVENT::READ;
//int IOCP::recv(IOCPPASSINDATA* data, int bufferCount) {
// data->event = IOCPEVENT::READ;
//#ifdef _WIN32
// DWORD recvbytes = 0, flags = 0;
// return ::WSARecv(data->socket->sock, &data->wsabuf, bufferCount, &recvbytes,
// &flags, &data->overlapped, NULL);
//#endif
//}
//
//int IOCP::send(IOCPPASSINDATA* data, int bufferCount, int __flags) {
// data->event = IOCPEVENT::WRITE;
//#ifdef _WIN32
// DWORD sendbytes = 0;
// return ::WSASend(data->socket->sock, &data->wsabuf, bufferCount, &sendbytes,
// __flags, &data->overlapped, NULL);
//#endif
//}
int IOCP::recv(IOCPPASSINDATA& data) {
data.event = IOCPEVENT::READ;
#ifdef _WIN32
DWORD recvbytes = 0, flags = 0;
return ::WSARecv(data->socket->sock, &data->wsabuf, bufferCount, &recvbytes,
&flags, &data->overlapped, NULL);
#elif __linux__
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLONESHOT;
ev.data.ptr = data;
return ::epoll_ctl(epollfd_, EPOLL_CTL_MOD, data->socket->sock, &ev);
#endif
}
int IOCP::send(IOCPPASSINDATA* data, int bufferCount,
int __flags) {
data->event = IOCPEVENT::WRITE;
int IOCP::send(std::vector<IOCPPASSINDATA> data) {
data.event = IOCPEVENT::WRITE;
#ifdef _WIN32
DWORD sendbytes = 0;
return ::WSASend(data->socket->sock, &data->wsabuf, bufferCount, &sendbytes,
__flags, &data->overlapped, NULL);
#elif __linux__
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLOUT | EPOLLONESHOT;
ev.data.ptr = data;
data->sendQueue->push(data);
return ::epoll_ctl(epollfd_, EPOLL_CTL_MOD, data->socket->sock, &ev);
#endif
}
} // namespace Chattr
} // namespace Network

112
impl/socket/socket.cpp Normal file
View File

@@ -0,0 +1,112 @@
#include "socket/socket.h"
namespace Network {
Socket::Socket(int domain, int type, int protocol) {
init(domain, type, protocol);
}
Socket::~Socket() { destruct(); }
int Socket::init(int domain, int type, int protocol) {
this->domain = domain;
sock = ::socket(domain, type, protocol);
if (sock == INVALID_SOCKET) spdlog::critical("socket()");
valid_ = true;
return 0;
}
void Socket::destruct() {
if (!valid_) return;
#ifdef _WIN32
::closesocket(sock);
#elif __linux__
::close(sock);
#endif
valid_ = false;
}
Socket::operator SOCKET() {
if (valid_) {
valid_ = false;
return sock;
}
spdlog::critical("No valid socket created.");
return INVALID_SOCKET;
}
void Socket::set(const SOCKET __sock, int __domain) {
if (__sock == INVALID_SOCKET) {
spdlog::critical("socket()");
std::exit(EXIT_FAILURE);
}
destruct();
sock = __sock;
valid_ = true;
};
int Socket::setsockopt(int level, int optname, const char* optval,
int optlen) {
return ::setsockopt(sock, level, optname, optval, optlen);
}
int Socket::bind(Address __addr) {
bindAddr = __addr;
int retVal = ::bind(sock, &__addr.addr, __addr.length);
if (retVal == INVALID_SOCKET) {
spdlog::critical("bind()");
std::exit(EXIT_FAILURE);
}
return retVal;
}
int Socket::recvfrom(void* __restrict __buf, size_t __n, int __flags,
struct Address& __addr) {
std::lock_guard<std::mutex> lock(readMutex);
int retVal = ::recvfrom(sock, (char*)__buf, __n, __flags, &__addr.addr,
&__addr.length);
if (retVal == SOCKET_ERROR) spdlog::error("recvfrom()");
return retVal;
}
int Socket::sendto(const void* __buf, size_t __n, int __flags,
struct Address __addr) {
std::lock_guard<std::mutex> lock(writeMutex);
int retVal =
::sendto(sock, (char*)__buf, __n, __flags, &__addr.addr, __addr.length);
if (retVal == SOCKET_ERROR) spdlog::error("sendto()");
return retVal;
}
Socket::Socket(const Socket& other_) {
memcpy(this, &other_, sizeof(Socket));
valid_ = false;
}
Socket::Socket(Socket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(Socket));
valid_ = true;
}
Socket& Socket::operator=(const Socket& other_) {
memcpy(this, &other_, sizeof(Socket));
valid_ = false;
return *this;
}
Socket& Socket::operator=(Socket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(Socket));
valid_ = true;
return *this;
}
} // namespace Socket

2
impl/socket/tcp_socket.cpp
View File

@@ -1,6 +1,6 @@
#include "socket/tcp_socket.h"
namespace Socket {
namespace Network {
int TCPSocket::init(int domain) { return init(domain, SOCK_STREAM, 0); }

111
impl/socket/udp_socket.cpp
View File

@@ -1,112 +1,7 @@
#include "socket/udp_socket.h"
namespace Socket {
namespace Network {
UDPSocket::UDPSocket(int domain, int type, int protocol) {
init(domain, type, protocol);
}
int UDPSocket::init(int domain) { return init(domain, SOCK_DGRAM, 0); }
UDPSocket::~UDPSocket() { destruct(); }
int UDPSocket::init(int domain, int type, int protocol) {
this->domain = domain;
sock = ::socket(domain, type, protocol);
if (sock == INVALID_SOCKET) spdlog::critical("socket()");
valid_ = true;
return 0;
}
void UDPSocket::destruct() {
if (!valid_) return;
#ifdef _WIN32
::closesocket(sock);
#elif __linux__
::close(sock);
#endif
valid_ = false;
}
UDPSocket::operator SOCKET() {
if (valid_) {
valid_ = false;
return sock;
}
spdlog::critical("No valid socket created.");
return INVALID_SOCKET;
}
void UDPSocket::set(const SOCKET __sock, int __domain) {
if (__sock == INVALID_SOCKET) {
spdlog::critical("socket()");
std::exit(EXIT_FAILURE);
}
destruct();
sock = __sock;
valid_ = true;
};
int UDPSocket::setsockopt(int level, int optname, const char* optval,
int optlen) {
return ::setsockopt(sock, level, optname, optval, optlen);
}
int UDPSocket::bind(Address __addr) {
bindAddr = __addr;
int retVal = ::bind(sock, &__addr.addr, __addr.length);
if (retVal == INVALID_SOCKET) {
spdlog::critical("bind()");
std::exit(EXIT_FAILURE);
}
return retVal;
}
int UDPSocket::recvfrom(void* __restrict __buf, size_t __n, int __flags,
struct Address& __addr) {
std::lock_guard<std::mutex> lock(readMutex);
int retVal = ::recvfrom(sock, (char*)__buf, __n, __flags, &__addr.addr,
&__addr.length);
if (retVal == SOCKET_ERROR) spdlog::error("recvfrom()");
return retVal;
}
int UDPSocket::sendto(const void* __buf, size_t __n, int __flags,
struct Address __addr) {
std::lock_guard<std::mutex> lock(writeMutex);
int retVal =
::sendto(sock, (char*)__buf, __n, __flags, &__addr.addr, __addr.length);
if (retVal == SOCKET_ERROR) spdlog::error("sendto()");
return retVal;
}
UDPSocket::UDPSocket(const UDPSocket& other_) {
memcpy(this, &other_, sizeof(UDPSocket));
valid_ = false;
}
UDPSocket::UDPSocket(UDPSocket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(UDPSocket));
valid_ = true;
}
UDPSocket& UDPSocket::operator=(const UDPSocket& other_) {
memcpy(this, &other_, sizeof(UDPSocket));
valid_ = false;
return *this;
}
UDPSocket& UDPSocket::operator=(UDPSocket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(UDPSocket));
valid_ = true;
return *this;
}
} // namespace Socket
} // namespace Network

2
impl/socket/wsa_manager.cpp
View File

@@ -1,6 +1,6 @@
#include "socket/wsa_manager.h"
namespace Socket {
namespace Network {
WSAManager::WSAManager() {
#ifdef _WIN32
WSADATA wsa;

4
impl/transport/transport.cpp
View File

@@ -1,10 +1,10 @@
#include "transport/transport.h"
namespace happytanuki {
namespace Network {
Transport::Transport(utils::ThreadPool* tp) { tp_ = tp; }
void Transport::Send() {}
void Transport::Recv() {}
} // namespace happytanuki
} // namespace Network