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

일단은 멀티로 접속이 됨..

Browse Source
This commit is contained in:
HappyTanuki
2025-06-19 02:42:49 +09:00
parent 1b79d946c3
commit fc8217a608
25 changed files with 584 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
impl/socket/address.cpp
View File

@@ -4,50 +4,6 @@
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) {
@@ -58,19 +14,18 @@ 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);
}
family = type;
}
void Address::setType(int type) {
@@ -87,12 +42,12 @@ Address::operator std::string() {
if (!port) return std::string();
if (length == sizeof(addr_in)) {
if (family == AF_INET) {
char addrStr[INET_ADDRSTRLEN];
::inet_ntop(AF_INET, &addr_in.sin_addr, addrStr, sizeof(addrStr));
return std::format("{}:{}", addrStr, port.value());
} else if (length == sizeof(addr_in6)) {
} else if (family == AF_INET6) {
char addrStr[INET6_ADDRSTRLEN];
::inet_ntop(AF_INET6, &addr_in6.sin6_addr, addrStr, sizeof(addrStr));

211
impl/socket/iocp.cpp
View File

@@ -4,7 +4,7 @@
namespace Network {
IOCP::IOCP() {
IOCP::IOCP() : IOCPThread_(nullptr), proto_(SessionProtocol::TCP) {
gen_ = std::mt19937(rd_());
jitterDist_ = std::uniform_int_distribution<int>(-10, 10);
}
@@ -40,22 +40,86 @@ void IOCP::destruct() {
#endif
}
void IOCP::registerTCPSocket(Socket& sock, std::uint32_t bufsize) {
void IOCP::registerSocket(std::shared_ptr<Socket> sock) {
#ifdef _WIN32
HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock.sock,
completionPort_, sock.sock, 0);
HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock->sock,
completionPort_, sock->sock, 0);
if (returnData == 0) completionPort_ = returnData;
#endif
}
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(bufsize);
recv_data->event = IOCPEVENT::READ;
recv_data->socket = std::make_shared<Socket>(sock);
recv_data->IOCPInstance = this;
DWORD recvbytes = 0, flags = 0;
std::future<std::vector<char>> IOCP::recvFull(std::shared_ptr<Socket> sock,
std::uint32_t bufsize) {
auto promise = std::make_shared<std::promise<std::vector<char>>>();
auto future = promise->get_future();
auto buffer = std::make_shared<std::vector<char>>();
buffer->reserve(bufsize);
std::function<void(std::uint32_t)> recvChunk;
recvChunk = [=](std::uint32_t remaining) mutable {
this->recv(sock, remaining,
[=](utils::ThreadPool* th, IOCPPASSINDATA* data) {
buffer->insert(buffer->end(), data->wsabuf.buf,
data->wsabuf.buf + data->transferredbytes);
std::uint32_t still_left =
bufsize - static_cast<std::uint32_t>(buffer->size());
if (still_left > 0) {
recvChunk(still_left);
} else {
promise->set_value(std::move(*buffer));
}
return std::list<char>();
});
};
recvChunk(bufsize);
return future;
}
std::list<char> DEFAULT_RECVALL_CALLBACK(utils::ThreadPool* th,
IOCPPASSINDATA* data) {
std::list<char> return_value;
return_value.insert(return_value.end(), data->wsabuf.buf,
data->wsabuf.buf + data->transferredbytes);
if (data->transferredbytes < data->wsabuf.len) {
auto future = data->IOCPInstance->recv(
data->socket, data->wsabuf.len - data->transferredbytes,
DEFAULT_RECVALL_CALLBACK);
auto result = future.get();
return_value.insert(return_value.end(), result.begin(), result.end());
}
return return_value;
}
std::future<std::list<char>> IOCP::recv(
std::shared_ptr<Socket> sock, std::uint32_t bufsize,
std::function<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)>
callback) {
std::lock_guard lock(*GetRecvQueueMutex(sock->sock));
auto queue = GetRecvQueue(sock->sock);
Network::IOCPPASSINDATA* data;
std::packaged_task<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)> task;
std::future<std::list<char>> future;
if (callback != nullptr) {
task = std::packaged_task<std::list<char>(utils::ThreadPool*,
IOCPPASSINDATA*)>(callback);
future = task.get_future();
data = new Network::IOCPPASSINDATA(sock, bufsize, this, std::move(task));
} else {
data = new Network::IOCPPASSINDATA(sock, bufsize, this);
}
int result = SOCKET_ERROR;
result = ::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
&flags, &recv_data->overlapped, NULL);
DWORD recvbytes = 0, flags = 0;
result = ::WSARecv(sock->sock, &data->wsabuf, 1, &recvbytes, &flags,
&data->overlapped, NULL);
if (result == SOCKET_ERROR) {
int err = ::WSAGetLastError();
if (err != WSA_IO_PENDING) {
@@ -64,82 +128,22 @@ void IOCP::registerTCPSocket(Socket& sock, std::uint32_t bufsize) {
}
}
#endif
return future;
}
void IOCP::registerUDPSocket(IOCPPASSINDATA* data, Address recv_addr) {
#ifdef _WIN32
HANDLE returnData = ::CreateIoCompletionPort(
(HANDLE)data->socket->sock, completionPort_, data->socket->sock, 0);
if (returnData == 0) completionPort_ = returnData;
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(data->bufsize);
recv_data->event = IOCPEVENT::READ;
recv_data->socket = data->socket;
DWORD recvbytes = 0, flags = 0;
int result = SOCKET_ERROR;
::WSARecvFrom(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
&flags, &recv_addr.addr, &recv_addr.length,
&recv_data->overlapped, NULL);
if (result == SOCKET_ERROR) {
int err = ::WSAGetLastError();
if (err != WSA_IO_PENDING) {
auto err_msg = std::format("WSARecv failed: {}", err);
throw std::runtime_error(err_msg);
}
}
#endif
}
int IOCP::recv(Socket& sock, std::vector<char>& data) {
std::lock_guard lock(*GetRecvQueueMutex_(sock.sock));
auto queue = GetRecvQueue_(sock.sock);
std::uint32_t left_data = data.size();
std::uint32_t copied = 0;
while (!queue->empty() && left_data != 0) {
auto front = queue->front();
queue->pop_front();
std::uint32_t offset = front.second;
std::uint32_t available = front.first.size() - offset;
std::uint32_t to_copy = (left_data < available) ? left_data : available;
::memcpy(data.data() + copied, front.first.data() + offset, to_copy);
copied += to_copy;
left_data -= to_copy;
offset += to_copy;
if (offset < front.first.size()) {
front.second = offset;
queue->push_front(front);
break;
}
}
return copied;
}
int IOCP::send(Socket& sock, std::vector<char>& data) {
auto lk = GetSendQueueMutex_(sock.sock);
auto queue = GetSendQueue_(sock.sock);
int IOCP::send(std::shared_ptr<Socket> sock, std::vector<char>& data) {
auto lk = GetSendQueueMutex(sock->sock);
auto queue = GetSendQueue(sock->sock);
std::lock_guard lock(*lk);
Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(data.size());
Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(sock, data.size(), this);
packet->event = IOCPEVENT::WRITE;
packet->socket = std::make_shared<Network::Socket>(sock);
packet->IOCPInstance = this;
::memcpy(packet->wsabuf.buf, data.data(), data.size());
packet->wsabuf.len = data.size();
queue->push_back(packet);
IOCPThread_->enqueueJob(
[this, sock = sock.sock](utils::ThreadPool* th, std::uint8_t __) {
[this, sock = sock->sock](utils::ThreadPool* th, std::uint8_t __) {
packet_sender_(sock);
},
0);
@@ -147,7 +151,7 @@ int IOCP::send(Socket& sock, std::vector<char>& data) {
}
int IOCP::GetRecvedBytes(SOCKET sock) {
auto queue = GetRecvQueue_(sock);
auto queue = GetRecvQueue(sock);
std::lock_guard lock(socket_mod_mutex_);
int bytes = 0;
@@ -178,7 +182,15 @@ void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {
data->event = IOCPEVENT::QUIT;
spdlog::debug("Disconnected. [{}]",
(std::string)(data->socket->remoteAddr));
delete data;
auto task = [this, IOCPThread, data = std::move(data)](
utils::ThreadPool* th, std::uint8_t __) {
if (data->callback.valid()) {
data->callback(th, data);
}
data->socket->destruct();
delete data;
};
IOCPThread->enqueueJob(task, 0);
IOCPThread->enqueueJob(
[this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); },
0);
@@ -187,34 +199,17 @@ void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {
data->transferredbytes = cbTransfrred;
}
std::vector<char> buf(16384); // SSL_read최대 반환 크기
int red_data = 0;
std::lock_guard lock(*GetRecvQueueMutex_(sock));
auto queue_list = GetRecvQueue_(sock);
if (data->event == IOCPEVENT::READ) {
::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;
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(data->bufsize);
recv_data->event = IOCPEVENT::READ;
recv_data->socket = data->socket;
auto task = [this, IOCPThread, data = std::move(data)](utils::ThreadPool* th,
std::uint8_t __) {
if (data->callback.valid()) data->callback(th, data);
delete data;
::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
&flags, &recv_data->overlapped, NULL);
} else { // WRITE 시, 무시한다.
spdlog::debug("writed {} bytes to {}", cbTransfrred,
(std::string)(data->socket->remoteAddr));
delete data;
}
};
IOCPThread->enqueueJob(task, 0);
IOCPThread->enqueueJob(
[this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); }, 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*>>(
@@ -224,7 +219,7 @@ std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue_(SOCKET sock) {
}
std::shared_ptr<std::list<std::pair<std::vector<char>, std::uint32_t>>>
IOCP::GetRecvQueue_(SOCKET sock) {
IOCP::GetRecvQueue(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (recv_queue_.find(sock) == recv_queue_.end()) {
recv_queue_[sock] = std::make_shared<
@@ -234,7 +229,7 @@ IOCP::GetRecvQueue_(SOCKET sock) {
return recv_queue_[sock];
}
std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex_(SOCKET sock) {
std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (send_queue_mutex_.find(sock) == send_queue_mutex_.end()) {
send_queue_mutex_[sock] = std::make_shared<std::mutex>();
@@ -242,7 +237,7 @@ std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex_(SOCKET sock) {
return send_queue_mutex_[sock];
}
std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex_(SOCKET sock) {
std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (recv_queue_mutex_.find(sock) == recv_queue_mutex_.end()) {
recv_queue_mutex_[sock] = std::make_shared<std::mutex>();
@@ -251,8 +246,8 @@ std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex_(SOCKET sock) {
}
void IOCP::packet_sender_(SOCKET sock) {
auto queue = GetSendQueue_(sock);
std::unique_lock lock(*GetSendQueueMutex_(sock));
auto queue = GetSendQueue(sock);
std::unique_lock lock(*GetSendQueueMutex(sock));
std::vector<char> buf(16384);
WSABUF wsabuf;

17
impl/socket/socket.cpp
View File

@@ -70,12 +70,13 @@ int Socket::bind(Address __addr) {
int Socket::connect(Address& serveraddr) {
std::string addr_string = serveraddr;
int retVal = -1;
if (serveraddr.family == AF_INET)
if (serveraddr.family == AF_INET) {
retVal = ::connect(sock, (const sockaddr*)&serveraddr.addr_in,
serveraddr.length);
else
} else if (serveraddr.family == AF_INET6) {
retVal = ::connect(sock, (const sockaddr*)&serveraddr.addr_in6,
serveraddr.length);
}
memcpy(&remoteAddr, &serveraddr, sizeof(Address));
if (retVal == INVALID_SOCKET) {
#ifdef _WIN32
@@ -110,12 +111,6 @@ Socket::Socket(const Socket& other_) {
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;
@@ -123,6 +118,12 @@ Socket& Socket::operator=(const Socket& other_) {
return *this;
}
Socket::Socket(Socket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(Socket));
valid_ = true;
}
Socket& Socket::operator=(Socket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(Socket));

28
impl/socket/tcp_socket.cpp
View File

@@ -10,35 +10,17 @@ int TCPSocket::listen(int __n) {
return retVal;
}
void TCPSocket::accept(TCPSocket &newSock, Address &__addr) {
void TCPSocket::accept(std::shared_ptr<TCPSocket> &newSock,
Address &__addr) {
SOCKET newsock = INVALID_SOCKET;
newsock = ::accept(sock, &__addr.addr, &__addr.length);
if (newsock == INVALID_SOCKET) {
spdlog::error("accept() errno:{} {}", errno, strerror(errno));
std::exit(EXIT_FAILURE);
}
newSock.set(newsock, domain);
memcpy(&newSock.remoteAddr, &__addr, sizeof(Address));
}
int TCPSocket::connect(Address &serveraddr) {
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) {
#ifdef _WIN32
int err = WSAGetLastError();
spdlog::error("connect() failed: WSA error {} (0x{:X})", err, err);
#endif
spdlog::error("connect()");
}
return retVal;
newSock = std::make_shared<TCPSocket>();
newSock->set(newsock, domain);
newSock->remoteAddr = __addr;
}
int TCPSocket::recv(void *__restrict __buf, size_t __n, int __flags) {