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

todo: iocp recv안되는 문제 해결하기

Browse Source
This commit is contained in:
HappyTanuki
2025-06-04 02:33:00 +09:00
parent 3f052a5f7f
commit c0e0279e5c
15 changed files with 363 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
impl/socket/address.cpp
View File

@@ -1,13 +1,53 @@
#include "socket/address.h"
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <format>
namespace Network {
//void Address::set(int type, gsl::czstring presentationAddr,
// std::uint16_t port) {
// zeroFill();
// setType(type);
//
// if (type == AF_INET) {
// ::inet_pton(AF_INET, presentationAddr, &addr_in.sin_addr);
// addr_in.sin_port = htons(port);
// } else if (type == AF_INET6) {
// ::inet_pton(AF_INET6, presentationAddr, &addr_in6.sin6_addr);
// addr_in6.sin6_port = htons(port);
// }
//
// BIO_ADDRINFO* res;
// if (!BIO_lookup_ex(presentationAddr, std::to_string(port).c_str(),
// BIO_LOOKUP_CLIENT, type, SOCK_DGRAM, 0, &res)) {
// ::BIO_ADDRINFO_free(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), type, 0, 0);
// if (sock == -1)
// continue;
// else {
// auto bio_addr = ::BIO_ADDRINFO_address(ai);
// BIO_ADDR_rawaddress(bio_addr, &addr, (unsigned long long*)&length);
// bio_addr_info = ::BIO_ADDR_dup(bio_addr);
//
// break;
// }
// }
//
// if (sock != -1)
// ::close(sock);
//
// ::BIO_ADDRINFO_free(res);
//
// addr_in.sin_family = type;
// addr_in.sin_port = htons(port);
//}
Address::Address() { zeroFill(); }
Address::Address(int type, gsl::czstring presentationAddr, std::uint16_t port) {
@@ -19,56 +59,22 @@ 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);
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");
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);
}
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);
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);
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);
addr_in6.sin6_family = type;
addr_in6.sin6_addr = addr;
addr_in6.sin6_port = htons(port);
}
void Address::setType(int type) {
family = type;
zeroFill();
if (type == AF_INET)
length = sizeof(sockaddr_in);
@@ -77,20 +83,29 @@ void Address::setType(int type) {
}
Address::operator std::string() {
char addrStr[INET6_ADDRSTRLEN];
std::optional<std::uint16_t> port = getPort();
if (family != AF_INET && family != AF_INET6 || !getPort())
return std::string();
if (!port) return std::string();
::inet_ntop(family, &addr, addrStr, sizeof(addrStr));
if (length == sizeof(addr_in)) {
char addrStr[INET_ADDRSTRLEN];
::inet_ntop(AF_INET, &addr_in.sin_addr, addrStr, sizeof(addrStr));
return std::format("{}:{}", addrStr, getPort());
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();
}
std::uint16_t Address::getPort() const {
if (family == AF_INET)
if (length == sizeof(addr_in))
return ntohs(addr_in.sin_port);
else if (family == AF_INET6)
else if (length == sizeof(addr_in6))
return ntohs(addr_in6.sin6_port);
else
return 0;

44
impl/socket/iocp.cpp
View File

@@ -4,6 +4,11 @@
namespace Network {
IOCP::IOCP() {
gen_ = std::mt19937(rd_());
jitterDist_ = std::uniform_int_distribution<int>(-10, 10);
}
IOCP::~IOCP() { destruct(); }
void IOCP::destruct() {
@@ -22,15 +27,16 @@ void IOCP::registerSocket(IOCPPASSINDATA* data) {
DWORD recvbytes = 0, flags = 0;
::WSARecv(data->socket->sock, &data->wsabuf, 1, &recvbytes, &flags,
&data->overlapped, NULL);
#endif
}
int IOCP::recv(IOCPPASSINDATA& data) {
SOCKET sock = data.socket->sock;
int IOCP::recv(IOCPPASSINDATA* data) {
SOCKET sock = data->socket->sock;
std::lock_guard lock(*GetRecvQueueMutex_(sock));
auto queue = GetRecvQueue_(sock);
std::uint32_t left_data = data.wsabuf.len;
std::uint32_t left_data = data->wsabuf.len;
std::uint32_t copied = 0;
while (!queue->empty() && left_data != 0) {
@@ -41,7 +47,7 @@ int IOCP::recv(IOCPPASSINDATA& data) {
std::uint32_t available = front.first.size() - offset;
std::uint32_t to_copy = (left_data < available) ? left_data : available;
::memcpy(data.wsabuf.buf + copied, front.first.data() + offset, to_copy);
::memcpy(data->wsabuf.buf + copied, front.first.data() + offset, to_copy);
copied += to_copy;
left_data -= to_copy;
offset += to_copy;
@@ -56,11 +62,13 @@ int IOCP::recv(IOCPPASSINDATA& data) {
return copied;
}
int IOCP::send(SOCKET sock, std::vector<IOCPPASSINDATA>& data) {
std::lock_guard lock(*send_queue_mutex_[sock]);
for (auto it : data) {
it.event = IOCPEVENT::WRITE;
send_queue_[sock]->push_back(it);
int IOCP::send(SOCKET sock, std::vector<IOCPPASSINDATA*>* data) {
auto lk = GetSendQueueMutex_(sock);
auto queue = GetSendQueue_(sock);
std::lock_guard lock(*lk);
for (auto& it : *data) {
it->event = IOCPEVENT::WRITE;
queue->push_back(it);
}
IOCPThread_->enqueueJob(
@@ -71,11 +79,11 @@ int IOCP::send(SOCKET sock, std::vector<IOCPPASSINDATA>& data) {
return 0;
}
std::shared_ptr<std::list<IOCPPASSINDATA>> IOCP::GetSendQueue_(SOCKET sock) {
std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue_(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (send_queue_.find(sock) == send_queue_.end()) {
send_queue_[sock] = std::make_shared<std::list<IOCPPASSINDATA>>(
std::list<IOCPPASSINDATA>());
send_queue_[sock] = std::make_shared<std::list<IOCPPASSINDATA*>>(
std::list<IOCPPASSINDATA*>());
}
return send_queue_[sock];
}
@@ -118,14 +126,14 @@ void IOCP::packet_sender_(SOCKET sock) {
while (!queue->empty()) {
auto front = queue->front();
queue->pop_front();
front.event = IOCPEVENT::WRITE;
front->event = IOCPEVENT::WRITE;
int data_len = 0;
if (proto_ == SessionProtocol::TLS || proto_ == SessionProtocol::QUIC) {
int ret = ::SSL_write(front.ssl, front.wsabuf.buf, front.wsabuf.len);
int ret = ::SSL_write(front->ssl, front->wsabuf.buf, front->wsabuf.len);
if (ret <= 0) {
int err = ::SSL_get_error(front.ssl, ret);
int err = ::SSL_get_error(front->ssl, ret);
if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
queue->push_front(front);
break;
@@ -135,7 +143,7 @@ void IOCP::packet_sender_(SOCKET sock) {
break;
}
while ((data_len = ::BIO_read(wbio_, buf.data(), buf.size())) > 0) {
while ((data_len = ::BIO_read(front->wbio, buf.data(), buf.size())) > 0) {
wsabuf.buf = buf.data();
wsabuf.len = data_len;
@@ -143,8 +151,8 @@ void IOCP::packet_sender_(SOCKET sock) {
}
} else {
data_len = front.wsabuf.len;
wsabuf.buf = front.wsabuf.buf;
data_len = front->wsabuf.len;
wsabuf.buf = front->wsabuf.buf;
wsabuf.len = data_len;
::WSASend(sock, &wsabuf, 1, &sendbytes, 0, nullptr, nullptr);
}

20
impl/socket/tcp_socket.cpp
View File

@@ -17,10 +17,22 @@ void TCPSocket::accept(TCPSocket &newSock, Address &__addr) {
}
int TCPSocket::connect(Address &serveraddr) {
int retVal =
::connect(sock, (struct sockaddr *)&serveraddr.addr, serveraddr.length);
std::string addr_string = serveraddr;
int retVal = -1;
if (serveraddr.family == AF_INET)
retVal = ::connect(sock, (const sockaddr *)&serveraddr.addr_in,
serveraddr.length);
else
retVal = ::connect(sock, (const sockaddr *)&serveraddr.addr_in6,
serveraddr.length);
memcpy(&remoteAddr, &serveraddr, sizeof(Address));
if (retVal == INVALID_SOCKET) spdlog::error("connect()");
if (retVal == INVALID_SOCKET) {
#ifdef _WIN32
int err = WSAGetLastError();
spdlog::error("connect() failed: WSA error {} (0x{:X})", err, err);
#endif
spdlog::error("connect()");
}
return retVal;
}
@@ -39,4 +51,4 @@ int TCPSocket::send(const void *__buf, size_t __n, int __flags) {
return retVal;
}
} // namespace Socket
} // namespace Network

2
impl/utils/log.cpp
View File

@@ -19,7 +19,7 @@ void setDefaultLogger(spdlog::level::level_enum logLevel,
sinks.push_back(std::make_shared<spdlog::sinks::msvc_sink_mt>());
#endif
auto chatteringLogger = std::make_shared<spdlog::logger>(
"Chattering Logger", begin(sinks), end(sinks));
"Logger", begin(sinks), end(sinks));
chatteringLogger->set_level(logLevel);
spdlog::set_default_logger(chatteringLogger);
}

15
impl/utils/thread_pool.cpp
View File

@@ -1,15 +1,14 @@
#include "utils/thread_pool.h"
#include "precomp.h"
namespace utils {
ThreadPool::ThreadPool() : ThreadPool(0) {}
ThreadPool::ThreadPool(std::uint32_t numThreads) { init(numThreads); }
ThreadPool::ThreadPool(std::uint32_t numThreads) { init_(numThreads); }
ThreadPool::~ThreadPool() { terminate(); }
void ThreadPool::init(std::uint32_t numThreads) {
void ThreadPool::init_(std::uint32_t numThreads) {
int numCPU = numThreads;
if (numThreads == 0) {
#ifdef _WIN32
@@ -31,9 +30,9 @@ void ThreadPool::init(std::uint32_t numThreads) {
}
}
threadCount = numCPU;
workers_.reserve(numCPU);
workers_.resize(numCPU);
while (numCPU--) workers_.emplace_back([this]() { this->Worker(); });
while (numCPU--) workers_[numCPU] = std::thread([this]() { this->Worker(); });
}
void ThreadPool::terminate() {
@@ -47,7 +46,7 @@ void ThreadPool::terminate() {
void ThreadPool::respawnWorker(std::uint32_t numThreads) {
terminate();
terminate_ = false;
init(numThreads);
init_(numThreads);
}
void* ThreadPool::Worker() {
@@ -79,4 +78,4 @@ void* ThreadPool::Worker() {
return nullptr;
}
} // namespace Chattr
} // namespace utils