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

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
+}
+
+}