tcp/udp 추가, todo:iocp openssl 지원하도록 업데이트하기

impl/session/session.cpp

@@ -0,0 +1,10 @@
+#include "session/session.h"
+
+#include "utils/thread_pool.h"
+
+namespace happytanuki {
+
+Session::Session(utils::ThreadPool* tp, SessionProtocol proto) {
+}
+
+}  // namespace happytanuki

impl/socket/address.cpp

@@ -0,0 +1,105 @@
+#include "socket/address.h"
+
+#include <format>
+
+#include "precomp.h"
+
+namespace Socket {
+
+Address::Address() { zeroFill(); }
+
+Address::Address(int type, gsl::czstring presentationAddr, std::uint16_t port) {
+  set(type, presentationAddr, port);
+}
+
+void Address::zeroFill() { memset(&addr_in6, 0, sizeof(addr_in6)); }
+
+void Address::set(int type, gsl::czstring presentationAddr,
+                  std::uint16_t port) {
+  zeroFill();
+
+  if (type == AF_INET) {
+    addr_in.sin_family = AF_INET;
+    ::inet_pton(AF_INET, presentationAddr, &addr_in.sin_addr);
+    addr_in.sin_port = htons(port);
+    length = sizeof(sockaddr_in);
+  } else if (type == AF_INET6) {
+    addr_in6.sin6_family = AF_INET6;
+    ::inet_pton(AF_INET6, presentationAddr, &addr_in6.sin6_addr);
+    addr_in6.sin6_port = htons(port);
+    length = sizeof(sockaddr_in6);
+  }
+}
+
+void Address::set(int type, in_addr_t addr, std::uint16_t port) {
+  zeroFill();
+
+  if (type == AF_INET) {
+    addr_in.sin_family = AF_INET;
+    addr_in.sin_addr.s_addr = htonl(addr);
+    addr_in.sin_port = htons(port);
+    length = sizeof(sockaddr_in);
+  }
+}
+
+void Address::set(int type, in_addr addr, std::uint16_t port) {
+  zeroFill();
+
+  if (type == AF_INET) {
+    addr_in.sin_family = AF_INET;
+    addr_in.sin_addr = addr;
+    addr_in.sin_port = htons(port);
+    length = sizeof(sockaddr_in);
+  }
+}
+
+void Address::set(int type, in6_addr addr, std::uint16_t port) {
+  zeroFill();
+
+  if (type == AF_INET6) {
+    addr_in6.sin6_family = AF_INET6;
+    addr_in6.sin6_addr = addr;
+    addr_in6.sin6_port = htons(port);
+    length = sizeof(sockaddr_in6);
+  }
+}
+
+void Address::setType(int type) {
+  zeroFill();
+
+  if (type == AF_INET)
+    length = sizeof(sockaddr_in);
+  else if (type == AF_INET6)
+    length = sizeof(sockaddr_in6);
+}
+
+Address::operator std::string() {
+  std::optional<std::uint16_t> port = getPort();
+
+  if (!port) return std::string();
+
+  if (length == sizeof(addr_in)) {
+    char addrStr[INET_ADDRSTRLEN];
+    ::inet_ntop(AF_INET, &addr_in.sin_addr, addrStr, sizeof(addrStr));
+
+    return std::format("{}:{}", addrStr, port.value());
+  } else if (length == sizeof(addr_in6)) {
+    char addrStr[INET6_ADDRSTRLEN];
+    ::inet_ntop(AF_INET6, &addr_in6.sin6_addr, addrStr, sizeof(addrStr));
+
+    return std::format("{}:{}", addrStr, port.value());
+  }
+
+  return std::string();
+}
+
+std::uint16_t Address::getPort() {
+  if (length == sizeof(addr_in))
+    return ntohs(addr_in.sin_port);
+  else if (length == sizeof(addr_in6))
+    return ntohs(addr_in6.sin6_port);
+  else
+    return 0;
+}
+
+}  // namespace Chattr

impl/socket/iocp.cpp

@@ -0,0 +1,69 @@
+#include "socket/iocp.h"
+
+#include "utils/thread_pool.h"
+
+namespace Socket {
+
+IOCP::IOCP() {}
+
+IOCP::~IOCP() { destruct(); }
+
+void IOCP::destruct() {
+#ifdef __linux__
+  uint64_t u = 1;
+  ::write(epollDetroyerFd, &u, sizeof(uint64_t));
+  close(epollfd_);
+#endif
+}
+
+void IOCP::registerSocket(IOCPPASSINDATA* data) {
+  data->event = IOCPEVENT::READ;
+#ifdef _WIN32
+  HANDLE returnData = ::CreateIoCompletionPort(
+      (HANDLE)data->socket->sock, completionPort_, data->socket->sock, 0);
+  if (returnData == 0) completionPort_ = returnData;
+#elif __linux__
+  int flags = ::fcntl(data->socket->sock, F_GETFL);
+  flags |= O_NONBLOCK;
+  fcntl(data->socket->sock, F_SETFL, flags);
+
+  struct epoll_event ev;
+  ev.events = EPOLLIN | EPOLLONESHOT;
+  data->sendQueue = std::make_shared<std::queue<IOCPPASSINDATA*>>();
+  ev.data.ptr = data;
+  int rc = epoll_ctl(epollfd_, EPOLL_CTL_ADD, data->socket->sock, &ev);
+  if (rc < 0) log::critical("epoll_ctl()");
+#endif
+}
+
+int IOCP::recv(IOCPPASSINDATA* data, int bufferCount) {
+  data->event = IOCPEVENT::READ;
+#ifdef _WIN32
+  DWORD recvbytes = 0, flags = 0;
+  return ::WSARecv(data->socket->sock, &data->wsabuf, bufferCount, &recvbytes,
+                   &flags, &data->overlapped, NULL);
+#elif __linux__
+  struct epoll_event ev;
+  ev.events = EPOLLIN | EPOLLONESHOT;
+  ev.data.ptr = data;
+  return ::epoll_ctl(epollfd_, EPOLL_CTL_MOD, data->socket->sock, &ev);
+#endif
+}
+
+int IOCP::send(IOCPPASSINDATA* data, int bufferCount,
+               int __flags) {
+  data->event = IOCPEVENT::WRITE;
+#ifdef _WIN32
+  DWORD sendbytes = 0;
+  return ::WSASend(data->socket->sock, &data->wsabuf, bufferCount, &sendbytes,
+                   __flags, &data->overlapped, NULL);
+#elif __linux__
+  struct epoll_event ev;
+  ev.events = EPOLLIN | EPOLLOUT | EPOLLONESHOT;
+  ev.data.ptr = data;
+  data->sendQueue->push(data);
+  return ::epoll_ctl(epollfd_, EPOLL_CTL_MOD, data->socket->sock, &ev);
+#endif
+}
+
+}  // namespace Chattr

impl/socket/tcp_socket.cpp

@@ -0,0 +1,42 @@
+#include "socket/tcp_socket.h"
+
+namespace Socket {
+
+int TCPSocket::init(int domain) { return init(domain, SOCK_STREAM, 0); }
+
+int TCPSocket::listen(int __n) {
+  int retVal = ::listen(sock, __n);
+  if (retVal == INVALID_SOCKET) spdlog::error("listen()");
+  return retVal;
+}
+
+void TCPSocket::accept(TCPSocket &newSock, Address &__addr) {
+  newSock.set(::accept(sock, &__addr.addr, &__addr.length), domain);
+  memcpy(&newSock.remoteAddr, &__addr, sizeof(Address));
+  if (newSock.sock == INVALID_SOCKET) spdlog::error("accept()");
+}
+
+int TCPSocket::connect(Address &serveraddr) {
+  int retVal =
+      ::connect(sock, (struct sockaddr *)&serveraddr.addr, serveraddr.length);
+  memcpy(&remoteAddr, &serveraddr, sizeof(Address));
+  if (retVal == INVALID_SOCKET) spdlog::error("connect()");
+  return retVal;
+}
+
+int TCPSocket::recv(void *__restrict __buf, size_t __n, int __flags) {
+  int retVal = ::recv(sock, (char *)__buf, __n, __flags);
+  if (retVal == SOCKET_ERROR) {
+    if (errno == EAGAIN || errno == EWOULDBLOCK) return retVal;
+    spdlog::error("recv()");
+  }
+  return retVal;
+}
+
+int TCPSocket::send(const void *__buf, size_t __n, int __flags) {
+  int retVal = ::send(sock, (char *)__buf, __n, __flags);
+  if (retVal == SOCKET_ERROR) spdlog::error("send()");
+  return retVal;
+}
+
+}  // namespace Socket

impl/socket/udp_socket.cpp

@@ -0,0 +1,112 @@
+#include "socket/udp_socket.h"
+
+namespace Socket {
+
+UDPSocket::UDPSocket(int domain, int type, int protocol) {
+  init(domain, type, protocol);
+}
+
+UDPSocket::~UDPSocket() { destruct(); }
+
+int UDPSocket::init(int domain, int type, int protocol) {
+  this->domain = domain;
+
+  sock = ::socket(domain, type, protocol);
+  if (sock == INVALID_SOCKET) spdlog::critical("socket()");
+
+  valid_ = true;
+
+  return 0;
+}
+
+void UDPSocket::destruct() {
+  if (!valid_) return;
+#ifdef _WIN32
+  ::closesocket(sock);
+#elif __linux__
+  ::close(sock);
+#endif
+  valid_ = false;
+}
+
+UDPSocket::operator SOCKET() {
+  if (valid_) {
+    valid_ = false;
+    return sock;
+  }
+  spdlog::critical("No valid socket created.");
+  return INVALID_SOCKET;
+}
+
+void UDPSocket::set(const SOCKET __sock, int __domain) {
+  if (__sock == INVALID_SOCKET) {
+    spdlog::critical("socket()");
+    std::exit(EXIT_FAILURE);
+  }
+
+  destruct();
+
+  sock = __sock;
+  valid_ = true;
+};
+
+int UDPSocket::setsockopt(int level, int optname, const char* optval,
+                               int optlen) {
+  return ::setsockopt(sock, level, optname, optval, optlen);
+}
+
+int UDPSocket::bind(Address __addr) {
+  bindAddr = __addr;
+  int retVal = ::bind(sock, &__addr.addr, __addr.length);
+  if (retVal == INVALID_SOCKET) {
+    spdlog::critical("bind()");
+    std::exit(EXIT_FAILURE);
+  }
+  return retVal;
+}
+
+int UDPSocket::recvfrom(void* __restrict __buf, size_t __n, int __flags,
+                        struct Address& __addr) {
+  std::lock_guard<std::mutex> lock(readMutex);
+  int retVal = ::recvfrom(sock, (char*)__buf, __n, __flags, &__addr.addr,
+                          &__addr.length);
+  if (retVal == SOCKET_ERROR) spdlog::error("recvfrom()");
+  return retVal;
+}
+
+int UDPSocket::sendto(const void* __buf, size_t __n, int __flags,
+                      struct Address __addr) {
+  std::lock_guard<std::mutex> lock(writeMutex);
+  int retVal =
+      ::sendto(sock, (char*)__buf, __n, __flags, &__addr.addr, __addr.length);
+  if (retVal == SOCKET_ERROR) spdlog::error("sendto()");
+  return retVal;
+}
+
+UDPSocket::UDPSocket(const UDPSocket& other_) {
+  memcpy(this, &other_, sizeof(UDPSocket));
+  valid_ = false;
+}
+
+UDPSocket::UDPSocket(UDPSocket&& other_) noexcept {
+  other_.valid_ = false;
+  memcpy(this, &other_, sizeof(UDPSocket));
+  valid_ = true;
+}
+
+UDPSocket& UDPSocket::operator=(const UDPSocket& other_) {
+  memcpy(this, &other_, sizeof(UDPSocket));
+  valid_ = false;
+
+  return *this;
+}
+
+UDPSocket& UDPSocket::operator=(UDPSocket&& other_) noexcept {
+  other_.valid_ = false;
+  memcpy(this, &other_, sizeof(UDPSocket));
+  valid_ = true;
+
+  return *this;
+}
+
+}  // namespace Socket

impl/socket/wsa_manager.cpp

@@ -0,0 +1,20 @@
+#include "socket/wsa_manager.h"
+
+namespace Socket {
+WSAManager::WSAManager() {
+#ifdef _WIN32
+	WSADATA wsa;
+  if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
+    spdlog::critical("WSAStartup()");
+    std::exit(EXIT_FAILURE);
+  }
+#endif
+}
+
+WSAManager::~WSAManager() {
+#ifdef _WIN32
+	WSACleanup();
+#endif
+}
+
+}

impl/transport/transport.cpp

@@ -0,0 +1,10 @@
+#include "transport/transport.h"
+
+namespace happytanuki {
+Transport::Transport(utils::ThreadPool* tp) { tp_ = tp; }
+
+void Transport::Send() {}
+
+void Transport::Recv() {}
+
+}  // namespace happytanuki

impl/utils/generate_id.cpp

@@ -0,0 +1,32 @@
+#include "utils/snowflake.h"
+
+#include <thread>
+
+namespace utils {
+
+static struct EpochInitializer {
+  EpochInitializer() { EPOCH = std::chrono::system_clock::now(); }
+  std::chrono::system_clock::time_point EPOCH;
+} epochInitializer;
+
+Snowflake GenerateID() {
+  static std::mutex snowflakeGenerateMutex_;
+
+  std::lock_guard<std::mutex> lock(snowflakeGenerateMutex_);
+
+  std::size_t tid =
+      std::hash<std::thread::id>{}(std::this_thread::get_id());
+
+  thread_local static int sequence = 0;
+  Snowflake id = {};
+
+  auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
+      std::chrono::system_clock::now() - epochInitializer.EPOCH);
+  id.timestamp = timestamp.count();
+  id.instance = tid;
+  id.sequence = sequence++;
+
+  return id;
+}
+
+};  // namespace Chattr

impl/utils/log.cpp

@@ -0,0 +1,27 @@
+#include "utils/log.h"
+
+#include "spdlog/sinks/rotating_file_sink.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
+#ifdef _WIN32
+#include "spdlog/sinks/msvc_sink.h"
+#endif
+
+namespace utils {
+
+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);
+}
+
+}  // namespace Chattr::log

impl/utils/thread_pool.cpp

@@ -0,0 +1,82 @@
+#include "utils/thread_pool.h"
+#include "precomp.h"
+
+namespace utils {
+
+ThreadPool::ThreadPool() : ThreadPool(0) {}
+
+ThreadPool::ThreadPool(std::uint32_t numThreads) { init(numThreads); }
+
+ThreadPool::~ThreadPool() { terminate(); }
+
+void ThreadPool::init(std::uint32_t numThreads) {
+  int numCPU = numThreads;
+  if (numThreads == 0) {
+#ifdef _WIN32
+    SYSTEM_INFO sysinfo;
+    GetSystemInfo(&sysinfo);
+    numCPU = sysinfo.dwNumberOfProcessors;
+#elif __linux__
+    numCPU = sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+    spdlog::info("Auto-detected cpu count: {}", numCPU);
+    if (numCPU == 1 || numCPU == 2) {
+      numCPU = 4;
+      spdlog::info(
+          "Set ThreadPool Worker count to: {} due to program to oprate "
+          "concurrently",
+          numCPU);
+    } else {
+      spdlog::info("Set ThreadPool Worker count to: {}", numCPU);
+    }
+  }
+  threadCount = numCPU;
+  workers_.reserve(numCPU);
+
+  while (numCPU--) workers_.emplace_back([this]() { this->Worker(); });
+}
+
+void ThreadPool::terminate() {
+  terminate_ = true;
+  jobQueueCV_.notify_all();
+
+  spdlog::debug("waiting for threads to end their jobs...");
+  for (auto& t : workers_) t.join();
+}
+
+void ThreadPool::respawnWorker(std::uint32_t numThreads) {
+  terminate();
+  terminate_ = false;
+  init(numThreads);
+}
+
+void* ThreadPool::Worker() {
+#ifdef _WIN32
+  DWORD pid = GetCurrentThreadId();
+#elif __linux__
+  pthread_t pid = pthread_self();
+#endif
+  spdlog::trace("ThreadPool Worker : {} up", pid);
+  while (!terminate_) {
+    std::unique_lock<std::mutex> lock(jobQueueMutex);
+    jobQueueCV_.wait(lock,
+                     [this]() { return !this->jobs_.empty() || terminate_; });
+    if (this->jobs_.empty() || terminate_) {
+      jobs_ = std::queue<std::packaged_task<void()>>();
+      break;
+    }
+    if (this->jobs_.empty()) continue;
+
+    auto job = std::move(jobs_.front());
+    jobs_.pop();
+    lock.unlock();
+
+    spdlog::trace("ThreadPool Worker : {} Executing a job", pid);
+    job();
+  }
+  spdlog::trace("ThreadPool Worker : {} down", pid);
+
+  return nullptr;
+}
+
+}  // namespace Chattr