legacy-libs/grpc-cloned/deps/grpc/src/core/lib/iomgr/tcp_server_utils_posix_common.cc

   1 /*
   2  *
   3  * Copyright 2017 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <grpc/support/port_platform.h>
  20
  21 #include "src/core/lib/iomgr/port.h"
  22
  23 #ifdef GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON
  24
  25 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
  26
  27 #include <errno.h>
  28 #include <limits.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31
  32 #include <grpc/support/alloc.h>
  33 #include <grpc/support/log.h>
  34 #include <grpc/support/string_util.h>
  35 #include <grpc/support/sync.h>
  36
  37 #include "src/core/lib/iomgr/error.h"
  38 #include "src/core/lib/iomgr/sockaddr.h"
  39 #include "src/core/lib/iomgr/sockaddr_utils.h"
  40 #include "src/core/lib/iomgr/unix_sockets_posix.h"
  41
  42 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
  43
  44 static gpr_once s_init_max_accept_queue_size = GPR_ONCE_INIT;
  45 static int s_max_accept_queue_size;
  46
  47 /* get max listen queue size on linux */
  48 static void init_max_accept_queue_size(void) {
  49   int n = SOMAXCONN;
  50   char buf[64];
  51   FILE* fp = fopen("/proc/sys/net/core/somaxconn", "r");
  52   if (fp == nullptr) {
  53     /* 2.4 kernel. */
  54     s_max_accept_queue_size = SOMAXCONN;
  55     return;
  56   }
  57   if (fgets(buf, sizeof buf, fp)) {
  58     char* end;
  59     long i = strtol(buf, &end, 10);
  60     if (i > 0 && i <= INT_MAX && end && *end == '\n') {
  61       n = static_cast<int>(i);
  62     }
  63   }
  64   fclose(fp);
  65   s_max_accept_queue_size = n;
  66
  67   if (s_max_accept_queue_size < MIN_SAFE_ACCEPT_QUEUE_SIZE) {
  68     gpr_log(GPR_INFO,
  69             "Suspiciously small accept queue (%d) will probably lead to "
  70             "connection drops",
  71             s_max_accept_queue_size);
  72   }
  73 }
  74
  75 static int get_max_accept_queue_size(void) {
  76   gpr_once_init(&s_init_max_accept_queue_size, init_max_accept_queue_size);
  77   return s_max_accept_queue_size;
  78 }
  79
  80 static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
  81                                         const grpc_resolved_address* addr,
  82                                         unsigned port_index, unsigned fd_index,
  83                                         grpc_tcp_listener** listener) {
  84   grpc_tcp_listener* sp = nullptr;
  85   int port = -1;
  86   char* addr_str;
  87   char* name;
  88
  89   grpc_error* err =
  90       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
  91   if (err == GRPC_ERROR_NONE) {
  92     GPR_ASSERT(port > 0);
  93     grpc_sockaddr_to_string(&addr_str, addr, 1);
  94     gpr_asprintf(&name, "tcp-server-listener:%s", addr_str);
  95     gpr_mu_lock(&s->mu);
  96     s->nports++;
  97     GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
  98     sp = static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
  99     sp->next = nullptr;
 100     if (s->head == nullptr) {
 101       s->head = sp;
 102     } else {
 103       s->tail->next = sp;
 104     }
 105     s->tail = sp;
 106     sp->server = s;
 107     sp->fd = fd;
 108     sp->emfd = grpc_fd_create(fd, name, true);
 109     memcpy(&sp->addr, addr, sizeof(grpc_resolved_address));
 110     sp->port = port;
 111     sp->port_index = port_index;
 112     sp->fd_index = fd_index;
 113     sp->is_sibling = 0;
 114     sp->sibling = nullptr;
 115     GPR_ASSERT(sp->emfd);
 116     gpr_mu_unlock(&s->mu);
 117     gpr_free(addr_str);
 118     gpr_free(name);
 119   }
 120
 121   *listener = sp;
 122   return err;
 123 }
 124
 125 /* If successful, add a listener to s for addr, set *dsmode for the socket, and
 126    return the *listener. */
 127 grpc_error* grpc_tcp_server_add_addr(grpc_tcp_server* s,
 128                                      const grpc_resolved_address* addr,
 129                                      unsigned port_index, unsigned fd_index,
 130                                      grpc_dualstack_mode* dsmode,
 131                                      grpc_tcp_listener** listener) {
 132   grpc_resolved_address addr4_copy;
 133   int fd;
 134   grpc_error* err =
 135       grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, dsmode, &fd);
 136   if (err != GRPC_ERROR_NONE) {
 137     return err;
 138   }
 139   if (*dsmode == GRPC_DSMODE_IPV4 &&
 140       grpc_sockaddr_is_v4mapped(addr, &addr4_copy)) {
 141     addr = &addr4_copy;
 142   }
 143   return add_socket_to_server(s, fd, addr, port_index, fd_index, listener);
 144 }
 145
 146 /* Prepare a recently-created socket for listening. */
 147 grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server* s, int fd,
 148                                            const grpc_resolved_address* addr,
 149                                            bool so_reuseport, int* port) {
 150   grpc_resolved_address sockname_temp;
 151   grpc_error* err = GRPC_ERROR_NONE;
 152
 153   GPR_ASSERT(fd >= 0);
 154
 155   if (so_reuseport && !grpc_is_unix_socket(addr)) {
 156     err = grpc_set_socket_reuse_port(fd, 1);
 157     if (err != GRPC_ERROR_NONE) goto error;
 158   }
 159
 160   err = grpc_set_socket_nonblocking(fd, 1);
 161   if (err != GRPC_ERROR_NONE) goto error;
 162   err = grpc_set_socket_cloexec(fd, 1);
 163   if (err != GRPC_ERROR_NONE) goto error;
 164   if (!grpc_is_unix_socket(addr)) {
 165     err = grpc_set_socket_low_latency(fd, 1);
 166     if (err != GRPC_ERROR_NONE) goto error;
 167     err = grpc_set_socket_reuse_addr(fd, 1);
 168     if (err != GRPC_ERROR_NONE) goto error;
 169     err = grpc_set_socket_tcp_user_timeout(fd, s->channel_args,
 170                                            false /* is_client */);
 171     if (err != GRPC_ERROR_NONE) goto error;
 172   }
 173   err = grpc_set_socket_no_sigpipe_if_possible(fd);
 174   if (err != GRPC_ERROR_NONE) goto error;
 175
 176   if (s->channel_args) {
 177     for (size_t i = 0; i < s->channel_args->num_args; i++) {
 178       if (0 == strcmp(s->channel_args->args[i].key, GRPC_ARG_SOCKET_MUTATOR)) {
 179         GPR_ASSERT(s->channel_args->args[i].type == GRPC_ARG_POINTER);
 180         grpc_socket_mutator* mutator = static_cast<grpc_socket_mutator*>(
 181             s->channel_args->args[i].value.pointer.p);
 182         err = grpc_set_socket_with_mutator(fd, mutator);
 183         if (err != GRPC_ERROR_NONE) goto error;
 184       }
 185     }
 186   }
 187
 188   if (bind(fd, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
 189            addr->len) < 0) {
 190     err = GRPC_OS_ERROR(errno, "bind");
 191     goto error;
 192   }
 193
 194   if (listen(fd, get_max_accept_queue_size()) < 0) {
 195     err = GRPC_OS_ERROR(errno, "listen");
 196     goto error;
 197   }
 198
 199   sockname_temp.len = static_cast<socklen_t>(sizeof(struct sockaddr_storage));
 200
 201   if (getsockname(fd, reinterpret_cast<grpc_sockaddr*>(sockname_temp.addr),
 202                   &sockname_temp.len) < 0) {
 203     err = GRPC_OS_ERROR(errno, "getsockname");
 204     goto error;
 205   }
 206
 207   *port = grpc_sockaddr_get_port(&sockname_temp);
 208   return GRPC_ERROR_NONE;
 209
 210 error:
 211   GPR_ASSERT(err != GRPC_ERROR_NONE);
 212   if (fd >= 0) {
 213     close(fd);
 214   }
 215   grpc_error* ret =
 216       grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
 217                              "Unable to configure socket", &err, 1),
 218                          GRPC_ERROR_INT_FD, fd);
 219   GRPC_ERROR_UNREF(err);
 220   return ret;
 221 }
 222
 223 #endif /* GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON */