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

iocp가 udp, tcp, tls, quic 전부 지원하도록 수정 중...

Browse Source
This commit is contained in:
HappyTanuki
2025-06-02 04:30:23 +09:00
parent a65483a9c3
commit 3f052a5f7f
3 changed files with 198 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
include/socket/iocp.h
View File

@@ -35,6 +35,8 @@ struct IOCPPASSINDATA {
IOCPEVENT event;
std::shared_ptr<Socket> socket;
SSL* ssl;
BIO* rbio; // bio는 ssl별로 달라야 하므로 분리해야 함..
BIO* wbio;
std::uint32_t transferredbytes;
WSABUF wsabuf;
std::uint32_t bufsize;
@@ -52,6 +54,7 @@ struct IOCPPASSINDATA {
IOCPInstance = nullptr;
wsabuf.buf = new char[bufsize];
wsabuf.len = bufsize;
}
IOCPPASSINDATA(const IOCPPASSINDATA& other)
: event(other.event),
@@ -65,12 +68,13 @@ struct IOCPPASSINDATA {
#endif
{
std::memset(&overlapped, 0, sizeof(overlapped));
wsabuf.buf = new char[bufsize];
wsabuf.buf = new char[other.bufsize];
wsabuf.len = other.bufsize;
std::memcpy(wsabuf.buf, other.wsabuf.buf, other.wsabuf.len);
}
~IOCPPASSINDATA() {
if (wsabuf.buf != nullptr) delete wsabuf.buf;
if (wsabuf.buf != nullptr) delete[] wsabuf.buf;
}
IOCPPASSINDATA& operator=(const IOCPPASSINDATA& other) {
@@ -84,7 +88,9 @@ struct IOCPPASSINDATA {
#ifdef __linux__
sendQueue = other.sendQueue;
#endif
wsabuf.buf = new char[bufsize];
if (wsabuf.buf != nullptr) delete[] wsabuf.buf;
wsabuf.buf = new char[other.bufsize];
wsabuf.len = other.bufsize;
std::memcpy(wsabuf.buf, other.wsabuf.buf, other.wsabuf.len);
}
return *this;
@@ -95,11 +101,7 @@ class IOCP {
public:
~IOCP();
template <typename... _args>
void init(utils::ThreadPool* __IOCPThread, SessionProtocol proto,
std::function<void(utils::ThreadPool*, IOCPPASSINDATA*, _args&&...)>
callback,
_args&&... args) {
void init(utils::ThreadPool* __IOCPThread, SessionProtocol proto) {
IOCPThread_ = __IOCPThread;
proto_ = proto;
@@ -121,7 +123,9 @@ class IOCP {
__IOCPThread->respawnWorker(tCount * 2);
for (int i = 0; i < tCount; i++)
__IOCPThread->enqueueJob(iocpWatcher_, IOCPThread_, callback, args...);
IOCPThread_->enqueueJob(
[this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); },
0);
#endif
}
@@ -129,50 +133,68 @@ class IOCP {
void registerSocket(IOCPPASSINDATA* data);
int send(std::vector<IOCPPASSINDATA> data);
// data는 한 가지 소켓에 보내는 패킷만 담아야 합니다
int send(SOCKET sock, std::vector<IOCPPASSINDATA>& data);
int recv(IOCPPASSINDATA& data);
private:
#ifdef _WIN32
template <typename... _args>
void iocpWatcher_(
utils::ThreadPool* IOCPThread,
std::function<void(utils::ThreadPool*, IOCPPASSINDATA*, _args&&...)>
callback,
_args&&... args) {
void iocpWatcher_(utils::ThreadPool* IOCPThread) {
IOCPPASSINDATA* data;
SOCKET sock;
DWORD cbTransfrred;
int retVal = GetQueuedCompletionStatus(completionPort_, &cbTransfrred,
(PULONG_PTR)&sock,
(LPOVERLAPPED*)&data, INFINITE);
if (retVal == 0 || cbTransfrred == 0) {
data->event = IOCPEVENT::QUIT;
spdlog::debug("Disconnected. [{}]",
(std::string)(data->socket->remoteAddr));
delete data;
} else {
if (data->event == IOCPEVENT::READ &&
(proto_ == SessionProtocol::TLS || proto_ == SessionProtocol::QUIC)) {
::BIO_write(rbio_, data->wsabuf.buf, cbTransfrred);
::SSL_read_ex(data->ssl, data->wsabuf.buf, data->bufsize);
}
data->transferredbytes = cbTransfrred;
}
IOCPThread->enqueueJob(callback, IOCPThread, data, args...);
IOCPThread->enqueueJob(iocpWatcher_, callback, args...);
};
#elif __linux__
std::vector<char> buf(16384); // SSL_read최대 반환 크기
int red_data = 0;
auto queue_list = GetRecvQueue_(data->socket->sock);
if (data->event == IOCPEVENT::READ) {
if (proto_ == SessionProtocol::TLS || proto_ == SessionProtocol::QUIC) {
::BIO_write(rbio_, data->wsabuf.buf, cbTransfrred);
#endif
void packet_sender_(utils::ThreadPool* IOCPThread) {
#ifdef _WIN32
std::lock_guard<std::mutex> lock(send_queue_mutex_);
#elif __linux__
#endif
while ((red_data = ::SSL_read(data->ssl, buf.data(), buf.size())) > 0) {
queue_list->emplace_back(std::make_pair(
std::vector<char>(buf.begin(), buf.begin() + red_data), 0));
}
} else {
::memcpy(buf.data(), data->wsabuf.buf, data->transferredbytes);
queue_list->emplace_back(std::make_pair(
std::vector<char>(buf.begin(),
buf.begin() + data->transferredbytes),
0));
}
DWORD recvbytes = 0, flags = 0;
::WSARecv(data->socket->sock, &data->wsabuf, 1, &recvbytes, &flags,
&data->overlapped, NULL);
} else { // WRITE 시, 무시한다.
delete data;
}
IOCPThread->enqueueJob(
[this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); },
0);
}
#elif __linux__
#endif
std::shared_ptr<std::list<IOCPPASSINDATA>> GetSendQueue_(SOCKET sock);
std::shared_ptr<std::list<std::pair<std::vector<char>, std::uint32_t>>>
GetRecvQueue_(SOCKET sock);
std::shared_ptr<std::mutex> GetSendQueueMutex_(SOCKET sock);
std::shared_ptr<std::mutex> GetRecvQueueMutex_(SOCKET sock);
void packet_sender_(SOCKET sock);
struct WSAManager* wsaManager = WSAManager::GetInstance();
utils::ThreadPool* IOCPThread_;
@@ -182,7 +204,8 @@ class IOCP {
SessionProtocol proto_;
// 밑의 unordered_map들에 키를 추가/제거 하려는 스레드는 이 뮤텍스를 잡아야 함.
// 밑의 unordered_map들에 키를 추가/제거 하려는 스레드는 이 뮤텍스를 잡아야
// 함.
std::mutex socket_mod_mutex_;
// 각 소켓별 뮤텍스. 다른 스레드가 읽는 중이라면 수신 순서 보장을 위해 다른
@@ -192,11 +215,12 @@ class IOCP {
// 채워야 함. (항시 socket에 대한 큐에 대해 읽기 시도가 행해질 수 있어야
// 한다는 뜻임) EPOLLIN에 대해서는 ONESHOT으로 등록해 놓고 읽는 도중에 버퍼에
// 새 값이 채워질 수 있으므로 읽기가 끝나고 나서 재등록한다
std::unordered_map<SOCKET, std::mutex> recv_queue_mutex_;
std::unordered_map<SOCKET, std::shared_ptr<std::mutex>> recv_queue_mutex_;
// 각 소켓별 패킷, int는 그 vector의 시작 인덱스(vector의 끝까지 다 읽었으면
// 그 vector는 list에서 삭제되어야 하며, 데이터는 평문으로 변환하여 저장한다)
std::unordered_map<SOCKET,
std::list<std::pair<std::vector<char>, std::uint32_t>>>
std::unordered_map<
SOCKET,
std::shared_ptr<std::list<std::pair<std::vector<char>, std::uint32_t>>>>
recv_queue_;
// 각 소켓별 뮤텍스. 다른 스레드가 쓰는 중이라면 송신 순서 보장을 위해 다른
@@ -206,13 +230,15 @@ class IOCP {
// 윈도우에서는 송신을 iocp가 대행하기 때문에 이 큐가 필요 없는 것처럼 느껴질
// 수 있으나, 송신 순서를 보장하기 위해 WSASend를 한 스레드가 연속해서
// 호출해야만 하는데 이는 한번 쓰기 호출 시에 송신 중 데이터를 추가하려는
// 스레드가 데이터를 추가하고 미전송된 경우를 대비하여 최대 1개까지의 스레드가
// 대기하도록 한다. 리눅스에서도 send_queue에 데이터를 쌓고 최대 1개까지의
// 스레드가 대기하도록 한다.
std::unordered_map<SOCKET, std::atomic_flag> pending_try_empty_;
std::unordered_map<SOCKET, std::atomic_flag> sending_;
std::unordered_map<SOCKET, std::mutex> send_queue_mutex_;
std::unordered_map<SOCKET, std::list<IOCPPASSINDATA>> send_queue_;
// 스레드가 데이터를 추가하고 미전송된 경우를 대비하여 스레드가 대기하도록
// 한다. 리눅스에서도 send_queue에 데이터를 쌓고 스레드가 대기하도록 한다.
std::unordered_map<SOCKET, std::shared_ptr<std::mutex>> send_queue_mutex_;
std::unordered_map<SOCKET, std::shared_ptr<std::list<IOCPPASSINDATA>>>
send_queue_;
// 쓰기 싫었지만 쓰기 큐를 직렬화 하는 것 밖에 좋은 수가 생각이 안 남..
/*std::mutex send_queue_mutex_;
std::condition_variable cv_send_queue_;
std::list<IOCPPASSINDATA> send_queue_;*/
#ifdef _WIN32
HANDLE completionPort_ = INVALID_HANDLE_VALUE;