yourchat/server.cpp

#include "server.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <thread>
#include <future>
#include <functional>
#include <strings.h>
#include <unistd.h>
#include <json/json.h>
#include <iostream>
#include <netinet/tcp.h>
#include <sstream>

namespace Yc {
    namespace Lib {

        Server::Server(Yc::Lib::Config *config) :
                _config(config),
                _stop(false) {
            struct sockaddr_in serverAddr;
            int opt = true;
            _socket = socket(AF_INET, SOCK_STREAM, 0);
            setsockopt(_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt));
            int flags = 1;
            setsockopt(_socket, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
            serverAddr.sin_family = AF_INET;
            serverAddr.sin_addr.s_addr = INADDR_ANY;
            serverAddr.sin_port = htons(1235);
            if (bind(_socket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
                std::cout << "bind not possible" << std::endl;
                exit(-1);
            }
            createRooms(config->group("rooms"));
        }

        void Server::run() {
            if (listen(_socket, 5) < 0) {
                std::cout << "listen not possible" << std::endl;
                exit(-1);
            }
            timeval origTv;
            origTv.tv_sec = 5;
            origTv.tv_usec = 0;
            int _maxSd  = _socket;
            while (!_stop) {
                timeval tv(origTv);
                fd_set fd;
                FD_ZERO(&fd);
                FD_SET(_socket, &fd);
                if (select(_maxSd + 1, &fd, NULL, NULL, &tv) > 0) {
                    std::async(std::launch::async, &Server::handleRequest, this);
                }
            }
        }

        std::vector<std::string> Server::roomList() {
            std::vector<std::string> list;
            for (auto &room: _rooms) {
                list.push_back(room->name());
            }
            return list;
        }

        Json::Value Server::jsonRoomList() {
            Json::Value list;
            for (auto &room: _rooms) {
                list.append(room->name());
            }
            return list;
        }

        void Server::createRooms(Json::Value roomList) {
            for (auto &room: roomList)  {
                std::vector<std::string> allowedUsers;
                for (auto &user: room["allowed"]) {
                    allowedUsers.push_back(user.asString());
                }
                Room *newRoom = new Room(this, room["name"].asString(), room["password"].asString(), allowedUsers);
                _rooms.push_back(newRoom);
            }
        }

        void Server::handleRequest() {
            struct sockaddr_in sockAddr;
            socklen_t sockAddrLen = sizeof(sockAddr);
            int userSock = accept(_socket, (struct sockaddr *)&sockAddr, &sockAddrLen);
            if (userSock < 0) {
                return;
            }
            int flags = 1;
            setsockopt(userSock, IPPROTO_TCP, TCP_NODELAY, (void *)&flags, sizeof(flags));
            std::string msg("");
            char buffer[256];
            bzero(buffer, 256);
            while (int received = recv(userSock, buffer, 255, 0) > 0) {
                msg += std::string(buffer);
                if (received < 255) {
                    break;
                }
            }
            if (msg == "") {
                return;
            }
            inputSwitcher(userSock, msg);
        }

        void Server::inputSwitcher(int userSocket, std::string input) {
            Json::Value inputTree;
            Json::CharReaderBuilder rbuilder;
            std::unique_ptr<Json::CharReader> const reader(rbuilder.newCharReader());
            JSONCPP_STRING inputJsonString(input);
            reader->parse(inputJsonString.data(), inputJsonString.data() + inputJsonString.size(), &inputTree, NULL);
            if (inputTree["type"] == "init") {
                initUser(userSocket, inputTree);
            }
        }

        bool Server::userExists(std::string userName) {
            for (auto &room: _rooms) {
                if (room->userNameExists(userName)) {
                    return true;
                }
            }
            return false;
        }

        void Server::initUser(int userSocket, Json::Value data) {
            if (userExists(data["name"].asString())) {
                close(userSocket);
                return;
            }
            std::string room = data["room"].asString();
            bool added(false);
            for (auto &room: _rooms) {
                if (room->name() == data["room"].asString()) {
                    if (room->addUser(data["name"].asString(), data["color"].asString(), data["password"].asString(), userSocket)) {
                        added = true;
                        break;
                    }
                }
            }
            if (!added) {
                close(userSocket);
            }
        }
    } // namespace Lib
} // namespace Yp