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-04 14:31:30 +09:00
parent 63428ebf4d
commit e0a371d536
16 changed files with 908 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
Server/include/ServerManager/ServerManager.hpp
View File

@@ -16,27 +16,29 @@ public:
void init(_Callable _IOCPClient) {
auto config = ConfigManager::load();
log::setDefaultLogger(config.logLevel, config.logFileName, config.logfileSize, config.logfileCount);
threadPool_.init(2);
threadPool_.init(0);
iocp_.init(&threadPool_, _IOCPClient);
struct Address serveraddr;
if (config.ipVersion == 4) {
listenSock_.init(AF_INET);
serveraddr.set(AF_INET, INADDR_ANY, config.listenPort);
serveraddr.set(AF_INET, config.IP, config.Port);
clientAddr_.setType(AF_INET);
}
else if (config.ipVersion == 6) {
listenSock_.init(AF_INET6);
serveraddr.set(AF_INET6, in6addr_any, config.listenPort);
serveraddr.set(AF_INET6, config.IP, config.Port);
clientAddr_.setType(AF_INET6);
}
listenSock_.bind(serveraddr);
listenSock_.listen(SOMAXCONN);
spdlog::info("Server listening on [{}]", (std::string)serveraddr);
}
void init() {
init([this](ThreadPool* thread, IOCPPASSINDATA* data) {
_IOCPClient(thread, data);
this->_IOCPClient(thread, data);
});
}
@@ -53,7 +55,7 @@ public:
void deleteUser(Snowflake UID);
std::vector<std::pair<Snowflake, std::string>> getUserList();
void createRoom(std::string roomName);
Snowflake createRoom(std::string roomName);
void deleteRoom(Snowflake RID);
std::vector<std::pair<Snowflake, std::string>> getRoomList();

136
Server/src/ServerManager/ServerManager.cpp
View File

@@ -175,7 +175,7 @@ void ServerManager::processLoginRequestPacket(LoginRequestPacket loginRequestPac
LoginResponsePacket loginResponsePacket;
loginResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
loginResponsePacket.__data.requestType = Chattr::RequestType::LOGIN;
loginResponsePacket.__data.dataType = Chattr::DataType::TEXT;
loginResponsePacket.__data.dataType = Chattr::DataType::BINARY;
loginResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(Snowflake);
loginResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
Snowflake yourId = userSocket2UID_[data->socket];
@@ -189,15 +189,101 @@ void ServerManager::processLoginRequestPacket(LoginRequestPacket loginRequestPac
}
void ServerManager::processRoomCreateRequestPacket(RoomCreateRequestPacket roomCreateRequestPacket, Chattr::IOCPPASSINDATA* data) {
std::string roomName(
(char*)roomCreateRequestPacket.__data.data,
roomCreateRequestPacket.__data.packetLength);
Snowflake RID = createRoom(roomName);
RoomCreateResponsePacket roomCreateResponsePacket;
roomCreateResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
roomCreateResponsePacket.__data.requestType = Chattr::RequestType::ROOM_CREATE;
roomCreateResponsePacket.__data.dataType = Chattr::DataType::BINARY;
roomCreateResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(Snowflake);
roomCreateResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
::memcpy(roomCreateResponsePacket.__data.createdRoomId, &RID, sizeof(Snowflake));
roomCreateResponsePacket.convToN();
memcpy(data->wsabuf.buf, roomCreateResponsePacket.serialized, 18);
data->sendbytes = 18;
data->wsabuf.len = 18;
data->IOCPInstance->send(data, 1, 0);
}
void ServerManager::processRoomListRequest(RoomListRequestPacket roomListRequestPacket, Chattr::IOCPPASSINDATA* data) {
auto roomsList = getRoomList();
for (auto room : roomsList) {
RoomListResponsePacket roomListResponsePacket;
roomListResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
roomListResponsePacket.__data.requestType = Chattr::RequestType::ROOM_LIST;
roomListResponsePacket.__data.dataType = Chattr::DataType::BINARY;
roomListResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(std::uint32_t) + sizeof(Snowflake) + room.second.size();
roomListResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
roomListResponsePacket.__data.roomCount = roomsList.size();
::memcpy(roomListResponsePacket.__data.roomId, &room.first, sizeof(Snowflake));
::memcpy(roomListResponsePacket.__data.name, room.second.c_str(), room.second.size());
int packetLength = roomListResponsePacket.__data.packetLength;
Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
::memset(&ptr->overlapped, 0, sizeof(OVERLAPPED));
ptr->socket = data->socket;
ptr->recvbytes = ptr->sendbytes = 0;
ptr->wsabuf.buf = ptr->buf;
ptr->wsabuf.len = packetLength + 8;
ptr->IOCPInstance = data->IOCPInstance;
roomListResponsePacket.convToN();
memcpy(ptr->wsabuf.buf, roomListResponsePacket.serialized, packetLength + 8);
data->sendbytes = packetLength + 8;
data->IOCPInstance->send(ptr, 1, 0);
}
}
void ServerManager::processRoomJoinRequestPacket(RoomJoinRequestPacket roomJoinRequestPacket, Chattr::IOCPPASSINDATA* data) {
Snowflake myID, roomID;
::memcpy(&myID.snowflake, roomJoinRequestPacket.__data.myId, sizeof(Snowflake));
::memcpy(&roomID.snowflake, roomJoinRequestPacket.__data.roomId, sizeof(Snowflake));
joinRoom(myID, roomID);
RoomJoinResponsePacket roomJoinResponsePacket;
roomJoinResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
roomJoinResponsePacket.__data.requestType = Chattr::RequestType::ROOM_JOIN;
roomJoinResponsePacket.__data.dataType = Chattr::DataType::BINARY;
roomJoinResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
roomJoinResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
int packetLength = roomJoinResponsePacket.__data.packetLength;
roomJoinResponsePacket.convToN();
::memcpy(data->wsabuf.buf, roomJoinResponsePacket.serialized, 10);
data->sendbytes = 10;
data->wsabuf.len = 10;
data->IOCPInstance->send(data, 1, 0);
}
void ServerManager::processRoomExitRequestPacket(RoomExitRequestPacket roomExitRequestPacket, Chattr::IOCPPASSINDATA* data) {
Snowflake myID, roomID;
::memcpy(&myID.snowflake, roomExitRequestPacket.__data.myId, sizeof(Snowflake));
::memcpy(&roomID.snowflake, roomExitRequestPacket.__data.roomId, sizeof(Snowflake));
exitRoom(myID, roomID);
RoomExitResponsePacket roomExitResponsePacket;
roomExitResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
roomExitResponsePacket.__data.requestType = Chattr::RequestType::ROOM_EXIT;
roomExitResponsePacket.__data.dataType = Chattr::DataType::BINARY;
roomExitResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
roomExitResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
int packetLength = roomExitResponsePacket.__data.packetLength;
roomExitResponsePacket.convToN();
::memcpy(data->wsabuf.buf, roomExitResponsePacket.serialized, 10);
data->sendbytes = 10;
data->wsabuf.len = 10;
data->IOCPInstance->send(data, 1, 0);
}
void ServerManager::processUsersListRequestPacket(UsersListRequestPacket usersListRequestPacket, Chattr::IOCPPASSINDATA* data) {
@@ -281,6 +367,51 @@ void ServerManager::processDataPostPacket(DataPostPacket dataPostPacket, IOCPPAS
}
void ServerManager::processContinuePacket(ContinuePacket continuePacket, IOCPPASSINDATA* data) {
Snowflake destID;
::memcpy(&destID.snowflake, continuePacket.__data.destId, sizeof(Snowflake));
std::vector<std::shared_ptr<TCPSocket>> destinationSockets;
if (userNames_.find(destID) != userNames_.end())
destinationSockets.push_back(UID2userSocket_[destID]);
else
for (auto user : rooms_[destID])
destinationSockets.push_back(user.second);
spdlog::info("Received [{}] from : [{}] to : [{}]",
std::string((char*)continuePacket.__data.data, continuePacket.__data.packetLength - (sizeof(std::uint16_t) * 5)),
(std::string)data->socket->remoteAddr,
destID.snowflake);
ResponsePacket responsePacket;
responsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
responsePacket.__data.requestType = Chattr::RequestType::DATA;
responsePacket.__data.dataType = Chattr::DataType::TEXT;
responsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
responsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
responsePacket.convToN();
memcpy(data->wsabuf.buf, responsePacket.serialized, 10);
data->sendbytes = 10;
data->wsabuf.len = 10;
data->IOCPInstance->send(data, 1, 0);
int packetLength = continuePacket.__data.packetLength;
for (auto dest : destinationSockets) {
Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
::memset(&ptr->overlapped, 0, sizeof(OVERLAPPED));
ptr->socket = dest;
ptr->recvbytes = ptr->sendbytes = 0;
ptr->wsabuf.buf = ptr->buf;
ptr->wsabuf.len = packetLength + 6;
ptr->IOCPInstance = data->IOCPInstance;
continuePacket.convToN();
memcpy(ptr->wsabuf.buf, continuePacket.serialized, packetLength + 6);
data->sendbytes = packetLength + 6;
data->IOCPInstance->send(ptr, 1, 0);
}
}
void ServerManager::registerUser(std::string userName, std::shared_ptr<TCPSocket> sock) {
@@ -310,11 +441,12 @@ std::vector<std::pair<Snowflake, std::string>> ServerManager::getUserList() {
return userList;
}
void ServerManager::createRoom(std::string roomName) {
Snowflake ServerManager::createRoom(std::string roomName) {
std::lock_guard<std::mutex> lock(resourceMutex_);
Snowflake RID = GenerateID();
roomNames_[RID] = roomName;
rooms_[RID] = std::unordered_map<Snowflake, std::shared_ptr<TCPSocket>>();
return RID;
}
void ServerManager::deleteRoom(Snowflake RID) {

25
Server/src/Socket/Log.cpp Normal file
View File

@@ -0,0 +1,25 @@
#include "Socket/Log.hpp"
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/sinks/rotating_file_sink.h"
#ifdef _WIN32
#include "spdlog/sinks/msvc_sink.h"
#endif
#include "precomp.hpp"
namespace Chattr::log {
void setDefaultLogger(spdlog::level::level_enum logLevel, gsl::czstring logFileName, std::uint32_t logFileSize, std::uint32_t logFileCount) {
std::vector<spdlog::sink_ptr> sinks;
sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(logFileName, logFileSize, logFileCount, false));
#ifdef _WIN32
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));
chatteringLogger->set_level(logLevel);
spdlog::set_default_logger(chatteringLogger);
}
}

9
Server/src/Utils/ConfigManager.cpp
View File

@@ -13,7 +13,8 @@ ConfigManager::Config ConfigManager::load() {
if (!configfile.is_open()) {
std::ofstream defaultConfig("config.json", std::ios::out);
config.configJsonRoot["IP Version"] = 6;
config.configJsonRoot["Listen Port"] = 9010;
config.configJsonRoot["IP"] = "::";
config.configJsonRoot["Port"] = 9010;
config.configJsonRoot["LogLevel"] = 1;
config.configJsonRoot["LogfileName"] = "Chattering.log";
config.configJsonRoot["LogfileSize"] = UINT32_MAX;
@@ -30,8 +31,10 @@ ConfigManager::Config ConfigManager::load() {
if (config.ipVersion != 4 && config.ipVersion != 6)
throw std::runtime_error("Invalid IP Version.");
config.listenPort = config.configJsonRoot["Listen Port"].asInt();
if (config.listenPort < 0 || config.listenPort > 65535)
config.IP = config.configJsonRoot["IP"].asCString();
config.Port = config.configJsonRoot["Port"].asInt();
if (config.Port < 0 || config.Port > 65535)
throw std::runtime_error("Invalid listen port.");
int ll_ = config.configJsonRoot["LogLevel"].asInt();