룸 내의 유저만 조회 기능 추가

Client/src/ClientManager/ClientManager.cpp

@@ -142,6 +142,8 @@ PacketSet ClientManager::packetParser(Packet Packet) {
             return PacketSet::ROOMEXITREQUEST;
         case RequestType::USERS_LIST:
             return PacketSet::USERSLISTREQUEST;
+        case RequestType::ROOM_USERS_LIST:
+            return PacketSet::ROOMUSERSLISTREQUEST;
         case RequestType::DATA:
             return PacketSet::INVALID;
         }
@@ -160,6 +162,8 @@ PacketSet ClientManager::packetParser(Packet Packet) {
             return PacketSet::ROOMEXITRESPONSE;
         case RequestType::USERS_LIST:
             return PacketSet::USERSLISTRESPONSE;
+        case RequestType::ROOM_USERS_LIST:
+            return PacketSet::ROOMUSERSLISTRESPONSE;
         case RequestType::DATA:
             return PacketSet::RESPONSE;
         default:
@@ -215,7 +219,7 @@ void ClientManager::processUsersListResponsePacket(UsersListResponsePacket users
 
 void ClientManager::processDataPostPacket(DataPostPacket dataPostPacket, IOCPPASSINDATA* data) {
     Snowflake sentUserId;
-    ::memcpy(&sentUserId.snowflake, dataPostPacket.__data.destId, sizeof(Snowflake));
+    ::memcpy(&sentUserId.snowflake, dataPostPacket.__data.sourceId, sizeof(Snowflake));
     std::string sentUserName = userNames_[sentUserId];
     std::string message((char*)dataPostPacket.__data.data, dataPostPacket.__data.packetLength - (sizeof(std::uint16_t) * 5));
 
@@ -267,21 +271,41 @@ void ClientManager::registerUser(std::string userName) {
 }
 
 void ClientManager::getUserList() {
-    UsersListRequestPacket usersListRequestPacket;
+    if (inRoom_) {
-    usersListRequestPacket.__data.packetType = PacketCategory::PACKET_REQUEST;
+        RoomUsersListRequestPacket roomUsersListRequestPacket;
-    usersListRequestPacket.__data.requestType = RequestType::USERS_LIST;
+        roomUsersListRequestPacket.__data.packetType = PacketCategory::PACKET_REQUEST;
-    usersListRequestPacket.__data.dataType = DataType::BINARY;
+        roomUsersListRequestPacket.__data.requestType = RequestType::ROOM_USERS_LIST;
-    usersListRequestPacket.__data.packetLength = 0;
+        roomUsersListRequestPacket.__data.dataType = DataType::BINARY;
+        roomUsersListRequestPacket.__data.packetLength = sizeof(Snowflake);
+        memcpy(roomUsersListRequestPacket.__data.roomId, &myRoomID_.snowflake, sizeof(Snowflake));
 
-    int packetLength = usersListRequestPacket.__data.packetLength;
+        int packetLength = roomUsersListRequestPacket.__data.packetLength;
 
-    data_->recvbytes = data_->sendbytes = 0;
+        data_->recvbytes = data_->sendbytes = 0;
-    data_->transferredbytes = 0;
+        data_->transferredbytes = 0;
-    data_->wsabuf.len = packetLength + 8;
+        data_->wsabuf.len = packetLength + 8;
 
-    usersListRequestPacket.convToN();
+        roomUsersListRequestPacket.convToN();
-    memcpy(data_->wsabuf.buf, usersListRequestPacket.serialized, packetLength + 8);
+        memcpy(data_->wsabuf.buf, roomUsersListRequestPacket.serialized, packetLength + 8);
-    iocp_.send(data_, 1, 0);
+        iocp_.send(data_, 1, 0);
+    }
+    else {
+        UsersListRequestPacket usersListRequestPacket;
+        usersListRequestPacket.__data.packetType = PacketCategory::PACKET_REQUEST;
+        usersListRequestPacket.__data.requestType = RequestType::USERS_LIST;
+        usersListRequestPacket.__data.dataType = DataType::BINARY;
+        usersListRequestPacket.__data.packetLength = 0;
+
+        int packetLength = usersListRequestPacket.__data.packetLength;
+
+        data_->recvbytes = data_->sendbytes = 0;
+        data_->transferredbytes = 0;
+        data_->wsabuf.len = packetLength + 8;
+
+        usersListRequestPacket.convToN();
+        memcpy(data_->wsabuf.buf, usersListRequestPacket.serialized, packetLength + 8);
+        iocp_.send(data_, 1, 0);
+    }
 }
 
 void ClientManager::createRoom(std::string roomName) {

Server/include/ServerManager/ServerManager.hpp

@@ -48,12 +48,14 @@ public:
     void processRoomJoinRequestPacket(RoomJoinRequestPacket roomJoinRequestPacket, IOCPPASSINDATA* data);
     void processRoomExitRequestPacket(RoomExitRequestPacket roomExitRequestPacket, IOCPPASSINDATA* data);
     void processUsersListRequestPacket(UsersListRequestPacket usersListRequestPacket, IOCPPASSINDATA* data);
+    void processUsersListInRoomRequestPacket(RoomUsersListRequestPacket roomUsersListRequestPacket, IOCPPASSINDATA* data);
     void processDataPostPacket(DataPostPacket dataPostPacket, IOCPPASSINDATA* data);
     void processContinuePacket(ContinuePacket continuePacket, IOCPPASSINDATA* data);
 
     bool registerUser(std::string userName, std::shared_ptr<TCPSocket> sock);
     void deleteUser(Snowflake UID);
     std::vector<std::pair<Snowflake, std::string>> getUserList();
+    std::vector<std::pair<Snowflake, std::string>> getUserListInRoom(Snowflake RID);
 
     Snowflake createRoom(std::string roomName);
     void deleteRoom(Snowflake RID);

Server/src/ServerManager/ServerManager.cpp

@@ -148,6 +148,8 @@ PacketSet ServerManager::packetParser(Packet Packet) {
             return PacketSet::ROOMEXITREQUEST;
         case RequestType::USERS_LIST:
             return PacketSet::USERSLISTREQUEST;
+        case RequestType::ROOM_USERS_LIST:
+            return PacketSet::ROOMUSERSLISTREQUEST;
         case RequestType::DATA:
             return PacketSet::INVALID;
         }
@@ -166,6 +168,8 @@ PacketSet ServerManager::packetParser(Packet Packet) {
             return PacketSet::ROOMEXITRESPONSE;
         case RequestType::USERS_LIST:
             return PacketSet::USERSLISTRESPONSE;
+        case RequestType::ROOM_USERS_LIST:
+            return PacketSet::ROOMUSERSLISTRESPONSE;
         case RequestType::DATA:
             return PacketSet::INVALID;
         }
@@ -340,7 +344,37 @@ void ServerManager::processUsersListRequestPacket(UsersListRequestPacket usersLi
     }
 }
 
-void ServerManager::processDataPostPacket(DataPostPacket dataPostPacket, IOCPPASSINDATA* data) {
+void ServerManager::processUsersListInRoomRequestPacket(RoomUsersListRequestPacket roomUsersListRequestPacket, IOCPPASSINDATA *data) {
+    std::unique_lock<std::mutex> lock(resourceMutex_);
+    Snowflake roomID;
+    ::memcpy(&roomID.snowflake, roomUsersListRequestPacket.__data.roomId, sizeof(Snowflake));
+    auto usersList = getUserListInRoom(roomID);
+
+    for (auto user : usersList) {
+        UsersListResponsePacket usersListResponsePacket;
+        usersListResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
+        usersListResponsePacket.__data.requestType = Chattr::RequestType::USERS_LIST;
+        usersListResponsePacket.__data.dataType = Chattr::DataType::BINARY;
+        usersListResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(std::uint32_t) + sizeof(Snowflake) + user.second.size();
+        usersListResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::RES_OK;
+        usersListResponsePacket.__data.usersCount = usersList.size();
+        ::memcpy(usersListResponsePacket.__data.userId, &user.first, sizeof(Snowflake));
+        ::memcpy(usersListResponsePacket.__data.name, user.second.c_str(), user.second.size());
+
+        int packetLength = usersListResponsePacket.__data.packetLength;
+
+        Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA(*data);
+        ptr->wsabuf.len = packetLength + 8;
+
+        usersListResponsePacket.convToN();
+        memcpy(ptr->wsabuf.buf, usersListResponsePacket.serialized, packetLength + 8);
+        data->sendbytes = packetLength + 8;
+        data->IOCPInstance->send(ptr, 1, 0);
+    }
+}
+
+void ServerManager::processDataPostPacket(DataPostPacket dataPostPacket, IOCPPASSINDATA *data)
+{
     std::unique_lock<std::mutex> lock(resourceMutex_);
     Snowflake destID;
     ::memcpy(&destID.snowflake, dataPostPacket.__data.destId, sizeof(Snowflake));
@@ -373,12 +407,12 @@ void ServerManager::processDataPostPacket(DataPostPacket dataPostPacket, IOCPPAS
 
     int packetLength = dataPostPacket.__data.packetLength;
 
+    dataPostPacket.convToN();
     for (auto dest : destinationSockets) {
         Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA(*data);
         ptr->socket = dest;
         ptr->wsabuf.len = packetLength + 8;
 
-        dataPostPacket.convToN();
         memcpy(ptr->wsabuf.buf, dataPostPacket.serialized, packetLength + 8);
         data->sendbytes = packetLength + 8;
         data->IOCPInstance->send(ptr, 1, 0);
@@ -459,6 +493,17 @@ std::vector<std::pair<Snowflake, std::string>> ServerManager::getUserList() {
     return userList;
 }
 
+std::vector<std::pair<Snowflake, std::string>> ServerManager::getUserListInRoom(Snowflake RID) {
+    std::vector<std::pair<Snowflake, std::string>> userList;
+    userList.reserve(rooms_[RID].size());
+
+    for (auto user : rooms_[RID])
+        userList.push_back({ user.first, userNames_[user.first] });
+
+    return userList;
+
+}
+
 Snowflake ServerManager::createRoom(std::string roomName) {
     Snowflake RID = GenerateID();
     roomNames_[RID] = roomName;
@@ -494,6 +539,7 @@ void ServerManager::run() {
     while (true) {
         spdlog::info("Waiting for connection...");
         listenSock_.accept(clientSock_, clientAddr_);
+        spdlog::trace("Accepted connection from {}, [{}]", clientSock_.sock, (std::string)clientAddr_);
         Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
         ptr->socket = std::make_shared<TCPSocket>(std::move(clientSock_));
         ptr->wsabuf.len = 1500;

include/Packet/Packet.hpp

@@ -12,6 +12,7 @@ enum class PacketSet {
     ROOMJOINREQUEST,
     ROOMEXITREQUEST,
     USERSLISTREQUEST,
+    ROOMUSERSLISTREQUEST,
     DATAPOST,
     CONTINUE,
     RESPONSE,
@@ -21,6 +22,7 @@ enum class PacketSet {
     ROOMJOINRESPONSE,
     ROOMEXITRESPONSE,
     USERSLISTRESPONSE,
+    ROOMUSERSLISTRESPONSE,
     INVALID
 };
 
@@ -38,6 +40,7 @@ enum class RequestType : std::uint8_t {
     ROOM_JOIN,
     ROOM_EXIT,
     USERS_LIST,
+    ROOM_USERS_LIST,
     DATA
 };
 
@@ -142,6 +145,35 @@ public:
 
 class alignas(4) UsersListRequestPacket : public Packet {};
 
+class alignas(4) RoomUsersListRequestPacket : public Packet {
+public:
+    union {
+        struct {
+            PacketCategory      packetType;
+            RequestType         requestType;
+            DataType            dataType;
+            std::uint16_t       packetLength;
+            std::uint16_t       roomId[4];
+            std::uint8_t        data[];
+        } __data;
+        std::uint8_t serialized[1500] = "";
+    };
+    std::uint8_t* convToN() {
+        __data.packetLength = ::htons(__data.packetLength);
+        for (int i = 0; i < 4; i++) {
+            __data.roomId[i] = ::htons(__data.roomId[i]);
+        }
+        return serialized;
+    }
+    std::uint8_t* convToH() {
+        __data.packetLength = ::ntohs(__data.packetLength);
+        for (int i = 0; i < 4; i++) {
+            __data.roomId[i] = ::ntohs(__data.roomId[i]);
+        }
+        return serialized;
+    }
+};
+
 class alignas(4) DataPostPacket : public Packet {
 public:
     union {

include/Socket/IOCP.hpp

@@ -151,9 +151,11 @@ public:
                     return;
                 }
                 else {
-                    spdlog::error("recv() [{}]", strerror(errno));
+                    rootIocpData->event = IOCPEVENT::QUIT;
+                    spdlog::debug("Disconnected. [{}]", (std::string)(rootIocpData->socket->remoteAddr));
                     ::epoll_ctl(epollfd, EPOLL_CTL_DEL, rootIocpData->socket->sock, NULL);
-                    delete rootIocpData;
+                    threadPool->enqueueJob(callback, rootIocpData);
+                    // delete rootIocpData;
                     return;
                 }
             }
@@ -168,9 +170,11 @@ public:
                 redSize = ptr->socket->recv(ptr->buf + totalRedSize, headerSize - totalRedSize, 0);
                 
                 if (redSize == SOCKET_ERROR) {
-                    spdlog::error("recv() [{}]", strerror(errno));
+                    ptr->event = IOCPEVENT::QUIT;
+                    spdlog::debug("Disconnected. [{}]", (std::string)(ptr->socket->remoteAddr));
                     ::epoll_ctl(epollfd, EPOLL_CTL_DEL, ptr->socket->sock, NULL);
-                    delete ptr;
+                    threadPool->enqueueJob(callback, ptr);
+                    // delete ptr;
                     return;
                 }
                 else if (redSize == 0) {
@@ -198,9 +202,11 @@ public:
                         spdlog::trace("No data to read on {}", tid);
                         return;
                     }
-                    spdlog::error("recv() [{}]", strerror(errno));
+                    ptr->event = IOCPEVENT::QUIT;
+                    spdlog::debug("Disconnected. [{}]", (std::string)(ptr->socket->remoteAddr));
                     ::epoll_ctl(epollfd, EPOLL_CTL_DEL, ptr->socket->sock, NULL);
-                    delete ptr;
+                    threadPool->enqueueJob(callback, ptr);
+                    // delete ptr;
                     return;
                 }
                 else if (redSize == 0) {