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

일단 거의 모든 버그 다 고칢..

Browse Source
This commit is contained in:
HappyTanuki
2025-05-02 11:16:25 +09:00
parent 6622cc8939
commit 14c325c428
10 changed files with 212 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
Server/src/server.cpp
View File

@@ -6,6 +6,7 @@
#include "Utils/ThreadPool.hpp"
#include "Utils/StringTokenizer.hpp"
#include "Utils/Snowflake.hpp"
#include "Socket/IOCP.hpp"
#include "Packet/Packet.hpp"
#include <iostream>
@@ -13,13 +14,16 @@
#include "precomp.hpp"
void _TCPRecvClient(Chattr::ThreadPool* thread, Chattr::TCPSocket sock, Chattr::Address addr);
void _TCPSendClient(Chattr::ThreadPool* thread, Chattr::TCPSocket sock, Chattr::Address addr, std::queue<Chattr::ResponsePacket> packets);
void _TCPRecvClient(Chattr::ThreadPool* threadPool, Chattr::IOCPPASSINDATA* data);
void _TCPSendClient(Chattr::ThreadPool* threadPool, Chattr::TCPSocket sock, std::queue<Chattr::ResponsePacket> packets);
int main() {
struct Chattr::WSAManager wsaManager;
auto config = Chattr::ConfigManager::load();
Chattr::log::setDefaultLogger(config.logLevel, config.logFileName, config.logfileSize, config.logfileCount);
Chattr::ThreadPool threadPool(0);
Chattr::IOCP iocp;
iocp.init(&threadPool, _TCPRecvClient);
// struct Chattr::WSAManager wsaManager;
Chattr::TCPSocket sock;
struct Chattr::Address serveraddr;
@@ -43,61 +47,84 @@ int main() {
#elif __linux__
pid_t pid = getpid();
#endif
spdlog::info("PID : {}", pid);
spdlog::debug("PID : {}", pid);
Chattr::ThreadPool threadPool(0);
/*int returnedIntager = 0;
int passvalue = 2;
threadPool.enqueueJob([](int& i){
spdlog::info("JobTest");
if (i == 2) {
i = 1;
return 2;
}
return 1;
}, returnedIntager, std::ref(passvalue));*/
DWORD recvbytes = 0, flags = 0;
while (true) {
spdlog::info("Waiting for connection...");
sock.accept(clientSock, clientAddr);
Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
ZeroMemory(&ptr->overlapped, sizeof(OVERLAPPED));
ptr->socket = std::move(clientSock);
ptr->recvbytes = ptr->sendbytes = 0;
ptr->wsabuf.buf = ptr->buf;
ptr->wsabuf.len = 1500;
threadPool.enqueueJob(_TCPRecvClient, std::move(clientSock), clientAddr);
iocp.registerSocket(ptr->socket.sock);
int returnData = WSARecv(ptr->socket.sock, &ptr->wsabuf, 1, &recvbytes, &flags, &ptr->overlapped, NULL);
}
}
void _TCPRecvClient(Chattr::ThreadPool* thread, Chattr::TCPSocket sock, Chattr::Address addr) {
void _TCPRecvClient(Chattr::ThreadPool* thread, Chattr::IOCPPASSINDATA* data) {
#ifdef _WIN32
DWORD tid = GetCurrentThreadId();
#elif __linux__
pthread_t tid = pthread_self();
#endif
spdlog::info("entered recvfunc on TID: {}", tid);
Chattr::Packet pack;
int packetSize = 1500;
int totalRedSize = 0;
int redSize = 0;
while (totalRedSize < packetSize) {
redSize = sock.recv(&pack.serialized, 1500 - totalRedSize, 0);
if (redSize <= 0) {
spdlog::info("Client disconnected. [{}]", (std::string)addr);
return;
}
totalRedSize += redSize;
}
// spdlog::info("Receving from: [{}]", (std::string)sock.remoteAddr);
//while (totalRedSize < packetSize) {
// redSize = data->socket.recv(&pack.serialized, 1500 - totalRedSize, 0);
//
// if (redSize <= 0) {
// // spdlog::info("Client disconnected. [{}]", (std::string)sock.remoteAddr);
// return;
// }
// totalRedSize += redSize;
//}
memcpy(pack.serialized, data->wsabuf.buf, data->wsabuf.len);
std::string recvString;
bool packetError = false;
Chattr::DataPostPacket dataPostPacket;
Chattr::ResponsePacket packet;
std::queue<Chattr::ResponsePacket> responsePackets;
switch (pack.__data.packetType) {
case Chattr::PacketType::PACKET_POST:
if (pack.__data.requestType != Chattr::RequestType::DATA){
packetError = true;
break;
}
switch (pack.__data.dataType) {
case Chattr::DataType::TEXT:
std::memcpy(&dataPostPacket.serialized, &pack, 1500);
dataPostPacket.convToH();
recvString = std::string((char *)dataPostPacket.__data.data, dataPostPacket.__data.packetLength - sizeof(std::uint16_t));
spdlog::info("Red size : {}, {} from : [{}]", redSize, recvString, (std::string)addr);
dataPostPacket.__data.packetLength = (dataPostPacket.__data.packetLength > 1487) ? 1487 : dataPostPacket.__data.packetLength;
recvString = std::string((char *)dataPostPacket.__data.data, dataPostPacket.__data.packetLength - (sizeof(std::uint16_t)*4));
spdlog::info("Red size : {}, {} from : [{}]", totalRedSize, recvString, (std::string)data->socket.remoteAddr);
break;
case Chattr::DataType::BINARY:
break;
default:
packet.__data.packetType = Chattr::PacketType::PACKET_RESPONSE;
packet.__data.requestType = Chattr::RequestType::DATA;
packet.__data.dataType = Chattr::DataType::TEXT;
packet.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
packet.__data.responseStatusCode = Chattr::ResponseStatusCode::BAD_REQUEST;
packet.convToN();
responsePackets.push(packet);
packetError = true;
break;
}
@@ -117,6 +144,13 @@ void _TCPRecvClient(Chattr::ThreadPool* thread, Chattr::TCPSocket sock, Chattr::
case Chattr::RequestType::USERS_LIST:
break;
default:
packet.__data.packetType = Chattr::PacketType::PACKET_RESPONSE;
packet.__data.requestType = Chattr::RequestType::DATA;
packet.__data.dataType = Chattr::DataType::TEXT;
packet.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
packet.__data.responseStatusCode = Chattr::ResponseStatusCode::BAD_REQUEST;
packet.convToN();
responsePackets.push(packet);
packetError = true;
break;
}
@@ -124,42 +158,48 @@ void _TCPRecvClient(Chattr::ThreadPool* thread, Chattr::TCPSocket sock, Chattr::
case Chattr::PacketType::PACKET_CONTINUE:
break;
default:
packet.__data.packetType = Chattr::PacketType::PACKET_RESPONSE;
packet.__data.requestType = Chattr::RequestType::DATA;
packet.__data.dataType = Chattr::DataType::TEXT;
packet.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
packet.__data.responseStatusCode = Chattr::ResponseStatusCode::BAD_REQUEST;
packet.convToN();
responsePackets.push(packet);
packetError = true;
break;
}
if (packetError) {
Chattr::ResponsePacket packet;
packet.__data.responseStatusCode = Chattr::ResponseStatusCode::BAD_REQUEST;
std::queue<Chattr::ResponsePacket> packs;
packet.convToN();
packs.push(packet);
thread->enqueueJob(_TCPSendClient, std::move(sock), addr, packs);
Sleep(10000);
/*if (packetError) {
thread->enqueueJob(_TCPRecvClient, data);;
}
else
thread->enqueueJob(_TCPRecvClient, std::move(sock), addr);
thread->enqueueJob(_TCPRecvClient, data);*/
}
void _TCPSendClient(Chattr::ThreadPool* thread, Chattr::TCPSocket sock, Chattr::Address addr, std::queue<Chattr::ResponsePacket> packets) {
void _TCPSendClient(Chattr::ThreadPool* thread, Chattr::TCPSocket sock, std::queue<Chattr::ResponsePacket> packets) {
Chattr::ResponsePacket pack = packets.front();
packets.pop();
int packetSize = 1500;
int totalSentSize = 0;
int sentSize = 0;
spdlog::info("Sending to: [{}]", (std::string)sock.remoteAddr);
while (totalSentSize < packetSize) {
sentSize = sock.send(&pack.serialized, 1500 - totalSentSize, 0);
if (sentSize <= 0) {
spdlog::info("Client disconnected. [{}]", (std::string)addr);
spdlog::info("Client disconnected. [{}]", (std::string)sock.remoteAddr);
return;
}
totalSentSize += sentSize;
}
if (packets.empty())
thread->enqueueJob(_TCPRecvClient, std::move(sock), addr);
/*if (packets.empty())
thread->enqueueJob(_TCPRecvClient, std::move(sock));
else
thread->enqueueJob(_TCPSendClient, std::move(sock), addr, packets);
thread->enqueueJob(_TCPSendClient, std::move(sock), packets);*/
}