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

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) {