src/core/lib/iomgr/socket_utils_common_posix.cc

   1 /*
   2  *
   3  * Copyright 2015 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_UTILS_COMMON
  24
  25 #include "src/core/lib/iomgr/socket_utils.h"
  26 #include "src/core/lib/iomgr/socket_utils_posix.h"
  27
  28 #include <arpa/inet.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <limits.h>
  32 #include <netinet/in.h>
  33 #include <netinet/tcp.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <sys/socket.h>
  37 #include <sys/types.h>
  38 #include <unistd.h>
  39
  40 #include <grpc/support/alloc.h>
  41 #include <grpc/support/log.h>
  42 #include <grpc/support/sync.h>
  43
  44 #include "src/core/lib/channel/channel_args.h"
  45 #include "src/core/lib/gpr/host_port.h"
  46 #include "src/core/lib/gpr/string.h"
  47 #include "src/core/lib/iomgr/sockaddr.h"
  48 #include "src/core/lib/iomgr/sockaddr_utils.h"
  49
  50 /* set a socket to non blocking mode */
  51 grpc_error* grpc_set_socket_nonblocking(int fd, int non_blocking) {
  52   int oldflags = fcntl(fd, F_GETFL, 0);
  53   if (oldflags < 0) {
  54     return GRPC_OS_ERROR(errno, "fcntl");
  55   }
  56
  57   if (non_blocking) {
  58     oldflags |= O_NONBLOCK;
  59   } else {
  60     oldflags &= ~O_NONBLOCK;
  61   }
  62
  63   if (fcntl(fd, F_SETFL, oldflags) != 0) {
  64     return GRPC_OS_ERROR(errno, "fcntl");
  65   }
  66
  67   return GRPC_ERROR_NONE;
  68 }
  69
  70 grpc_error* grpc_set_socket_no_sigpipe_if_possible(int fd) {
  71 #ifdef GRPC_HAVE_SO_NOSIGPIPE
  72   int val = 1;
  73   int newval;
  74   socklen_t intlen = sizeof(newval);
  75   if (0 != setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &val, sizeof(val))) {
  76     return GRPC_OS_ERROR(errno, "setsockopt(SO_NOSIGPIPE)");
  77   }
  78   if (0 != getsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &newval, &intlen)) {
  79     return GRPC_OS_ERROR(errno, "getsockopt(SO_NOSIGPIPE)");
  80   }
  81   if ((newval != 0) != (val != 0)) {
  82     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set SO_NOSIGPIPE");
  83   }
  84 #endif
  85   return GRPC_ERROR_NONE;
  86 }
  87
  88 grpc_error* grpc_set_socket_ip_pktinfo_if_possible(int fd) {
  89 #ifdef GRPC_HAVE_IP_PKTINFO
  90   int get_local_ip = 1;
  91   if (0 != setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &get_local_ip,
  92                       sizeof(get_local_ip))) {
  93     return GRPC_OS_ERROR(errno, "setsockopt(IP_PKTINFO)");
  94   }
  95 #endif
  96   return GRPC_ERROR_NONE;
  97 }
  98
  99 grpc_error* grpc_set_socket_ipv6_recvpktinfo_if_possible(int fd) {
 100 #ifdef GRPC_HAVE_IPV6_RECVPKTINFO
 101   int get_local_ip = 1;
 102   if (0 != setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &get_local_ip,
 103                       sizeof(get_local_ip))) {
 104     return GRPC_OS_ERROR(errno, "setsockopt(IPV6_RECVPKTINFO)");
 105   }
 106 #endif
 107   return GRPC_ERROR_NONE;
 108 }
 109
 110 grpc_error* grpc_set_socket_sndbuf(int fd, int buffer_size_bytes) {
 111   return 0 == setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buffer_size_bytes,
 112                          sizeof(buffer_size_bytes))
 113              ? GRPC_ERROR_NONE
 114              : GRPC_OS_ERROR(errno, "setsockopt(SO_SNDBUF)");
 115 }
 116
 117 grpc_error* grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes) {
 118   return 0 == setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &buffer_size_bytes,
 119                          sizeof(buffer_size_bytes))
 120              ? GRPC_ERROR_NONE
 121              : GRPC_OS_ERROR(errno, "setsockopt(SO_RCVBUF)");
 122 }
 123
 124 /* set a socket to close on exec */
 125 grpc_error* grpc_set_socket_cloexec(int fd, int close_on_exec) {
 126   int oldflags = fcntl(fd, F_GETFD, 0);
 127   if (oldflags < 0) {
 128     return GRPC_OS_ERROR(errno, "fcntl");
 129   }
 130
 131   if (close_on_exec) {
 132     oldflags |= FD_CLOEXEC;
 133   } else {
 134     oldflags &= ~FD_CLOEXEC;
 135   }
 136
 137   if (fcntl(fd, F_SETFD, oldflags) != 0) {
 138     return GRPC_OS_ERROR(errno, "fcntl");
 139   }
 140
 141   return GRPC_ERROR_NONE;
 142 }
 143
 144 /* set a socket to reuse old addresses */
 145 grpc_error* grpc_set_socket_reuse_addr(int fd, int reuse) {
 146   int val = (reuse != 0);
 147   int newval;
 148   socklen_t intlen = sizeof(newval);
 149   if (0 != setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val))) {
 150     return GRPC_OS_ERROR(errno, "setsockopt(SO_REUSEADDR)");
 151   }
 152   if (0 != getsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &newval, &intlen)) {
 153     return GRPC_OS_ERROR(errno, "getsockopt(SO_REUSEADDR)");
 154   }
 155   if ((newval != 0) != val) {
 156     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set SO_REUSEADDR");
 157   }
 158
 159   return GRPC_ERROR_NONE;
 160 }
 161
 162 /* set a socket to reuse old addresses */
 163 grpc_error* grpc_set_socket_reuse_port(int fd, int reuse) {
 164 #ifndef SO_REUSEPORT
 165   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
 166       "SO_REUSEPORT unavailable on compiling system");
 167 #else
 168   int val = (reuse != 0);
 169   int newval;
 170   socklen_t intlen = sizeof(newval);
 171   if (0 != setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val))) {
 172     return GRPC_OS_ERROR(errno, "setsockopt(SO_REUSEPORT)");
 173   }
 174   if (0 != getsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &newval, &intlen)) {
 175     return GRPC_OS_ERROR(errno, "getsockopt(SO_REUSEPORT)");
 176   }
 177   if ((newval != 0) != val) {
 178     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set SO_REUSEPORT");
 179   }
 180
 181   return GRPC_ERROR_NONE;
 182 #endif
 183 }
 184
 185 static gpr_once g_probe_so_reuesport_once = GPR_ONCE_INIT;
 186 static int g_support_so_reuseport = false;
 187
 188 void probe_so_reuseport_once(void) {
 189 #ifndef GPR_MANYLINUX1
 190   int s = socket(AF_INET, SOCK_STREAM, 0);
 191   if (s < 0) {
 192     /* This might be an ipv6-only environment in which case 'socket(AF_INET,..)'
 193        call would fail. Try creating IPv6 socket in that case */
 194     s = socket(AF_INET6, SOCK_STREAM, 0);
 195   }
 196   if (s >= 0) {
 197     g_support_so_reuseport = GRPC_LOG_IF_ERROR(
 198         "check for SO_REUSEPORT", grpc_set_socket_reuse_port(s, 1));
 199     close(s);
 200   }
 201 #endif
 202 }
 203
 204 bool grpc_is_socket_reuse_port_supported() {
 205   gpr_once_init(&g_probe_so_reuesport_once, probe_so_reuseport_once);
 206   return g_support_so_reuseport;
 207 }
 208
 209 /* disable nagle */
 210 grpc_error* grpc_set_socket_low_latency(int fd, int low_latency) {
 211   int val = (low_latency != 0);
 212   int newval;
 213   socklen_t intlen = sizeof(newval);
 214   if (0 != setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val))) {
 215     return GRPC_OS_ERROR(errno, "setsockopt(TCP_NODELAY)");
 216   }
 217   if (0 != getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &newval, &intlen)) {
 218     return GRPC_OS_ERROR(errno, "getsockopt(TCP_NODELAY)");
 219   }
 220   if ((newval != 0) != val) {
 221     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set TCP_NODELAY");
 222   }
 223   return GRPC_ERROR_NONE;
 224 }
 225
 226 /* The default values for TCP_USER_TIMEOUT are currently configured to be in
 227  * line with the default values of KEEPALIVE_TIMEOUT as proposed in
 228  * https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md */
 229 #define DEFAULT_CLIENT_TCP_USER_TIMEOUT_MS 20000 /* 20 seconds */
 230 #define DEFAULT_SERVER_TCP_USER_TIMEOUT_MS 20000 /* 20 seconds */
 231
 232 static int g_default_client_tcp_user_timeout_ms =
 233     DEFAULT_CLIENT_TCP_USER_TIMEOUT_MS;
 234 static int g_default_server_tcp_user_timeout_ms =
 235     DEFAULT_SERVER_TCP_USER_TIMEOUT_MS;
 236 static bool g_default_client_tcp_user_timeout_enabled = false;
 237 static bool g_default_server_tcp_user_timeout_enabled = true;
 238
 239 void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client) {
 240   if (is_client) {
 241     g_default_client_tcp_user_timeout_enabled = enable;
 242     if (timeout > 0) {
 243       g_default_client_tcp_user_timeout_ms = timeout;
 244     }
 245   } else {
 246     g_default_server_tcp_user_timeout_enabled = enable;
 247     if (timeout > 0) {
 248       g_default_server_tcp_user_timeout_ms = timeout;
 249     }
 250   }
 251 }
 252
 253 /* Set TCP_USER_TIMEOUT */
 254 grpc_error* grpc_set_socket_tcp_user_timeout(
 255     int fd, const grpc_channel_args* channel_args, bool is_client) {
 256 #ifdef GRPC_HAVE_TCP_USER_TIMEOUT
 257   bool enable;
 258   int timeout;
 259   if (is_client) {
 260     enable = g_default_client_tcp_user_timeout_enabled;
 261     timeout = g_default_client_tcp_user_timeout_ms;
 262   } else {
 263     enable = g_default_server_tcp_user_timeout_enabled;
 264     timeout = g_default_server_tcp_user_timeout_ms;
 265   }
 266   if (channel_args) {
 267     for (unsigned int i = 0; i < channel_args->num_args; i++) {
 268       if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_KEEPALIVE_TIME_MS)) {
 269         const int value = grpc_channel_arg_get_integer(
 270             &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
 271         /* Continue using default if value is 0 */
 272         if (value == 0) {
 273           continue;
 274         }
 275         /* Disable if value is INT_MAX */
 276         enable = value != INT_MAX;
 277       } else if (0 == strcmp(channel_args->args[i].key,
 278                              GRPC_ARG_KEEPALIVE_TIMEOUT_MS)) {
 279         const int value = grpc_channel_arg_get_integer(
 280             &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
 281         /* Continue using default if value is 0 */
 282         if (value == 0) {
 283           continue;
 284         }
 285         timeout = value;
 286       }
 287     }
 288   }
 289   if (enable) {
 290     extern grpc_core::TraceFlag grpc_tcp_trace;
 291     if (grpc_tcp_trace.enabled()) {
 292       gpr_log(GPR_INFO, "Enabling TCP_USER_TIMEOUT with a timeout of %d ms",
 293               timeout);
 294     }
 295     int newval;
 296     socklen_t len = sizeof(newval);
 297     if (0 != setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout,
 298                         sizeof(timeout))) {
 299       gpr_log(GPR_ERROR, "setsockopt(TCP_USER_TIMEOUT) %s", strerror(errno));
 300       return GRPC_ERROR_NONE;
 301     }
 302     if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
 303       gpr_log(GPR_ERROR, "getsockopt(TCP_USER_TIMEOUT) %s", strerror(errno));
 304       return GRPC_ERROR_NONE;
 305     }
 306     if (newval != timeout) {
 307       /* Do not fail on failing to set TCP_USER_TIMEOUT for now. */
 308       gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT");
 309       return GRPC_ERROR_NONE;
 310     }
 311   }
 312 #else
 313   extern grpc_core::TraceFlag grpc_tcp_trace;
 314   if (grpc_tcp_trace.enabled()) {
 315     gpr_log(GPR_INFO, "TCP_USER_TIMEOUT not supported for this platform");
 316   }
 317 #endif /* GRPC_HAVE_TCP_USER_TIMEOUT */
 318   return GRPC_ERROR_NONE;
 319 }
 320
 321 /* set a socket using a grpc_socket_mutator */
 322 grpc_error* grpc_set_socket_with_mutator(int fd, grpc_socket_mutator* mutator) {
 323   GPR_ASSERT(mutator);
 324   if (!grpc_socket_mutator_mutate_fd(mutator, fd)) {
 325     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("grpc_socket_mutator failed.");
 326   }
 327   return GRPC_ERROR_NONE;
 328 }
 329
 330 static gpr_once g_probe_ipv6_once = GPR_ONCE_INIT;
 331 static int g_ipv6_loopback_available;
 332
 333 static void probe_ipv6_once(void) {
 334   int fd = socket(AF_INET6, SOCK_STREAM, 0);
 335   g_ipv6_loopback_available = 0;
 336   if (fd < 0) {
 337     gpr_log(GPR_INFO, "Disabling AF_INET6 sockets because socket() failed.");
 338   } else {
 339     grpc_sockaddr_in6 addr;
 340     memset(&addr, 0, sizeof(addr));
 341     addr.sin6_family = AF_INET6;
 342     addr.sin6_addr.s6_addr[15] = 1; /* [::1]:0 */
 343     if (bind(fd, reinterpret_cast<grpc_sockaddr*>(&addr), sizeof(addr)) == 0) {
 344       g_ipv6_loopback_available = 1;
 345     } else {
 346       gpr_log(GPR_INFO,
 347               "Disabling AF_INET6 sockets because ::1 is not available.");
 348     }
 349     close(fd);
 350   }
 351 }
 352
 353 int grpc_ipv6_loopback_available(void) {
 354   gpr_once_init(&g_probe_ipv6_once, probe_ipv6_once);
 355   return g_ipv6_loopback_available;
 356 }
 357
 358 /* This should be 0 in production, but it may be enabled for testing or
 359    debugging purposes, to simulate an environment where IPv6 sockets can't
 360    also speak IPv4. */
 361 int grpc_forbid_dualstack_sockets_for_testing = 0;
 362
 363 static int set_socket_dualstack(int fd) {
 364   if (!grpc_forbid_dualstack_sockets_for_testing) {
 365     const int off = 0;
 366     return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
 367   } else {
 368     /* Force an IPv6-only socket, for testing purposes. */
 369     const int on = 1;
 370     setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
 371     return 0;
 372   }
 373 }
 374
 375 static grpc_error* error_for_fd(int fd, const grpc_resolved_address* addr) {
 376   if (fd >= 0) return GRPC_ERROR_NONE;
 377   char* addr_str;
 378   grpc_sockaddr_to_string(&addr_str, addr, 0);
 379   grpc_error* err = grpc_error_set_str(GRPC_OS_ERROR(errno, "socket"),
 380                                        GRPC_ERROR_STR_TARGET_ADDRESS,
 381                                        grpc_slice_from_copied_string(addr_str));
 382   gpr_free(addr_str);
 383   return err;
 384 }
 385
 386 grpc_error* grpc_create_dualstack_socket(
 387     const grpc_resolved_address* resolved_addr, int type, int protocol,
 388     grpc_dualstack_mode* dsmode, int* newfd) {
 389   return grpc_create_dualstack_socket_using_factory(
 390       nullptr, resolved_addr, type, protocol, dsmode, newfd);
 391 }
 392
 393 static int create_socket(grpc_socket_factory* factory, int domain, int type,
 394                          int protocol) {
 395   return (factory != nullptr)
 396              ? grpc_socket_factory_socket(factory, domain, type, protocol)
 397              : socket(domain, type, protocol);
 398 }
 399
 400 grpc_error* grpc_create_dualstack_socket_using_factory(
 401     grpc_socket_factory* factory, const grpc_resolved_address* resolved_addr,
 402     int type, int protocol, grpc_dualstack_mode* dsmode, int* newfd) {
 403   const grpc_sockaddr* addr =
 404       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
 405   int family = addr->sa_family;
 406   if (family == AF_INET6) {
 407     if (grpc_ipv6_loopback_available()) {
 408       *newfd = create_socket(factory, family, type, protocol);
 409     } else {
 410       *newfd = -1;
 411       errno = EAFNOSUPPORT;
 412     }
 413     /* Check if we've got a valid dualstack socket. */
 414     if (*newfd >= 0 && set_socket_dualstack(*newfd)) {
 415       *dsmode = GRPC_DSMODE_DUALSTACK;
 416       return GRPC_ERROR_NONE;
 417     }
 418     /* If this isn't an IPv4 address, then return whatever we've got. */
 419     if (!grpc_sockaddr_is_v4mapped(resolved_addr, nullptr)) {
 420       *dsmode = GRPC_DSMODE_IPV6;
 421       return error_for_fd(*newfd, resolved_addr);
 422     }
 423     /* Fall back to AF_INET. */
 424     if (*newfd >= 0) {
 425       close(*newfd);
 426     }
 427     family = AF_INET;
 428   }
 429   *dsmode = family == AF_INET ? GRPC_DSMODE_IPV4 : GRPC_DSMODE_NONE;
 430   *newfd = create_socket(factory, family, type, protocol);
 431   return error_for_fd(*newfd, resolved_addr);
 432 }
 433
 434 uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
 435
 436 uint16_t grpc_ntohs(uint16_t netshort) { return ntohs(netshort); }
 437
 438 uint32_t grpc_htonl(uint32_t hostlong) { return htonl(hostlong); }
 439
 440 uint32_t grpc_ntohl(uint32_t netlong) { return ntohl(netlong); }
 441
 442 int grpc_inet_pton(int af, const char* src, void* dst) {
 443   return inet_pton(af, src, dst);
 444 }
 445
 446 const char* grpc_inet_ntop(int af, const void* src, char* dst, size_t size) {
 447   GPR_ASSERT(size <= (socklen_t)-1);
 448   return inet_ntop(af, src, dst, static_cast<socklen_t>(size));
 449 }
 450
 451 #endif