src/lib/launchpad-common/server_socket.cc

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "launchpad-common/server_socket.hh"
  18
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <limits.h>
  22 #include <sys/socket.h>
  23 #include <sys/types.h>
  24 #include <sys/un.h>
  25 #include <unistd.h>
  26
  27 #include "launchpad-common/exception.hh"
  28 #include "launchpad-common/log_private.hh"
  29
  30 namespace launchpad {
  31
  32 ServerSocket::ServerSocket() {
  33   fd_ = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
  34   if (fd_ < 0) {
  35     fd_ = -errno;
  36     _E("socket() is failed. errno(%d)", errno);
  37     THROW(fd_);
  38   }
  39 }
  40
  41 ServerSocket::ServerSocket(int fd) : fd_(fd) {}
  42
  43 ServerSocket::~ServerSocket() {
  44   Close();
  45 }
  46
  47 std::unique_ptr<ClientSocket> ServerSocket::Accept() {
  48   struct sockaddr_un addr = { 0, };
  49   socklen_t len = static_cast<socklen_t>(sizeof(struct sockaddr_un));
  50   auto* addr_ptr = reinterpret_cast<struct sockaddr*>(&addr);
  51   int client_fd = accept(GetFd(), addr_ptr, &len);
  52   if (client_fd == -1) {
  53     _E("accept() is failed. errno(%d)", errno);
  54     return nullptr;
  55   }
  56
  57   return std::unique_ptr<ClientSocket>(new ClientSocket(client_fd));
  58 }
  59
  60 void ServerSocket::Bind(const std::string& bindpoint) {
  61   struct sockaddr_un sockaddr = { 0, };
  62   sockaddr.sun_family = AF_UNIX;
  63   snprintf(sockaddr.sun_path, sizeof(sockaddr.sun_path), "%s",
  64       bindpoint.c_str());
  65   struct sockaddr* sockaddr_ptr = reinterpret_cast<struct sockaddr*>(&sockaddr);
  66   socklen_t len = static_cast<socklen_t>(sizeof(sockaddr));
  67
  68   unlink(bindpoint.c_str());
  69   int ret = bind(GetFd(), sockaddr_ptr, len);
  70   if (ret < 0) {
  71     ret = -errno;
  72     _E("bind() is failed. errno(%d)", errno);
  73     THROW(ret);
  74   }
  75 }
  76
  77 void ServerSocket::Close() {
  78   if (fd_ > -1) {
  79     close(fd_);
  80     fd_ = -1;
  81   }
  82 }
  83
  84 void ServerSocket::Listen(int backlog) {
  85   int ret = listen(fd_, backlog);
  86   if (ret < 0) {
  87     ret = -errno;
  88     _E("listen() is failed. errno(%d)", errno);
  89     THROW(ret);
  90   }
  91 }
  92
  93 int ServerSocket::GetReceiveBufferSize() {
  94   int value;
  95   socklen_t len = sizeof(int);
  96   int ret = getsockopt(fd_, SOL_SOCKET, SO_RCVBUF,
  97       reinterpret_cast<void*>(&value), &len);
  98   if (ret < 0) {
  99     ret = -errno;
 100     _E("getsockopt() is failed. errno(%d)", errno);
 101     THROW(ret);
 102   }
 103
 104   return value;
 105 }
 106
 107 int ServerSocket::GetSendBufferSize() {
 108   int value;
 109   socklen_t len = sizeof(int);
 110   int ret = getsockopt(fd_, SOL_SOCKET, SO_SNDBUF,
 111       reinterpret_cast<void*>(&value), &len);
 112   if (ret < 0) {
 113     ret = -errno;
 114     _E("getsockopt() is failed. errno(%d)", errno);
 115     THROW(ret);
 116   }
 117
 118   return value;
 119 }
 120
 121 void ServerSocket::SetReceiveBufferSize(int size) {
 122   socklen_t len = sizeof(size);
 123   int ret = setsockopt(fd_, SOL_SOCKET, SO_RCVBUF, &size, len);
 124   if (ret < 0) {
 125     ret = -errno;
 126     _E("setsockopt() is failed. errno(%d)", errno);
 127     THROW(ret);
 128   }
 129 }
 130
 131 void ServerSocket::SetSendBufferSize(int size) {
 132   socklen_t len = sizeof(size);
 133   int ret = setsockopt(fd_, SOL_SOCKET, SO_SNDBUF, &size, len);
 134   if (ret < 0) {
 135     ret = -errno;
 136     _E("setsockopt() is failed. errno(%d)", errno);
 137     THROW(ret);
 138   }
 139 }
 140
 141 bool ServerSocket::IsClosed() const {
 142   return fd_ < 0;
 143 }
 144
 145 int ServerSocket::GetFd() const {
 146   return fd_;
 147 }
 148
 149 int ServerSocket::RemoveFd() {
 150   int fd = fd_;
 151   fd_ = -1;
 152   return fd;
 153 }
 154
 155 void ServerSocket::SetCloseOnExec(bool do_close) {
 156   int flags = fcntl(fd_, F_GETFD);
 157   int ret = fcntl(fd_, F_SETFD,
 158       do_close ? flags | FD_CLOEXEC : flags & ~FD_CLOEXEC);
 159   if (ret != 0)
 160     _E("fcntl() is failed. errno(%d)", errno);
 161 }
 162
 163 }  // namespace launchpad