src/net/tools/flip_server/create_listener.cc

   1 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/tools/flip_server/create_listener.h"
   6
   7 #include <arpa/inet.h>   // for inet_ntop
   8 #include <errno.h>       // for strerror
   9 #include <netdb.h>       // for getaddrinfo and getnameinfo
  10 #include <netinet/in.h>  // for IPPROTO_*, etc.
  11 #include <stdlib.h>      // for EXIT_FAILURE
  12 #include <netinet/tcp.h> // For TCP_NODELAY
  13 #include <sys/socket.h>  // for getaddrinfo and getnameinfo
  14 #include <sys/types.h>   // "
  15 #include <fcntl.h>
  16 #include <unistd.h>      // for exit()
  17 #include <ostream>
  18
  19 #include "base/logging.h"
  20
  21 namespace net {
  22
  23 // used to ensure we delete the addrinfo structure
  24 // alloc'd by getaddrinfo
  25 class AddrinfoGuard {
  26  protected:
  27   struct addrinfo * addrinfo_ptr_;
  28  public:
  29
  30   explicit AddrinfoGuard(struct addrinfo* addrinfo_ptr) :
  31     addrinfo_ptr_(addrinfo_ptr) {}
  32
  33   ~AddrinfoGuard() {
  34     freeaddrinfo(addrinfo_ptr_);
  35   }
  36 };
  37
  38 ////////////////////////////////////////////////////////////////////////////////
  39 ////////////////////////////////////////////////////////////////////////////////
  40
  41 // Summary:
  42 //   Closes a socket, with option to attempt it multiple times.
  43 //   Why do this? Well, if the system-call gets interrupted, close
  44 //   can fail with EINTR. In that case you should just retry.. Unfortunately,
  45 //   we can't be sure that errno is properly set since we're using a
  46 //   multithreaded approach in the filter proxy, so we should just retry.
  47 // Args:
  48 //   fd - the socket to close
  49 //   tries - the number of tries to close the socket.
  50 // Returns:
  51 //   true - if socket was closed
  52 //   false - if socket was NOT closed.
  53 // Side-effects:
  54 //   sets *fd to -1 if socket was closed.
  55 //
  56 bool CloseSocket(int *fd, int tries) {
  57   for (int i = 0; i < tries; ++i) {
  58     if (!close(*fd)) {
  59       *fd = -1;
  60       return true;
  61     }
  62   }
  63   return false;
  64 }
  65
  66 ////////////////////////////////////////////////////////////////////////////////
  67 ////////////////////////////////////////////////////////////////////////////////
  68
  69 // Sets an FD to be nonblocking.
  70 void FlipSetNonBlocking(int fd) {
  71   DCHECK_GE(fd, 0);
  72
  73   int fcntl_return = fcntl(fd, F_GETFL, 0);
  74   CHECK_NE(fcntl_return, -1)
  75     << "error doing fcntl(fd, F_GETFL, 0) fd: " << fd
  76     << " errno=" << errno;
  77
  78   if (fcntl_return & O_NONBLOCK)
  79     return;
  80
  81   fcntl_return = fcntl(fd, F_SETFL, fcntl_return | O_NONBLOCK);
  82   CHECK_NE(fcntl_return, -1)
  83     << "error doing fcntl(fd, F_SETFL, fcntl_return) fd: " << fd
  84     << " errno=" << errno;
  85 }
  86
  87 int SetDisableNagle(int fd) {
  88   int on = 1;
  89   int rc;
  90   rc = setsockopt(fd, IPPROTO_TCP,  TCP_NODELAY,
  91                   reinterpret_cast<char*>(&on), sizeof(on));
  92   if (rc < 0) {
  93     close(fd);
  94     LOG(FATAL) << "setsockopt() TCP_NODELAY: failed on fd " << fd;
  95     return 0;
  96   }
  97   return 1;
  98 }
  99
 100 // see header for documentation of this function.
 101 int CreateListeningSocket(const std::string& host,
 102                           const std::string& port,
 103                           bool is_numeric_host_address,
 104                           int backlog,
 105                           bool reuseaddr,
 106                           bool reuseport,
 107                           bool wait_for_iface,
 108                           bool disable_nagle,
 109                           int * listen_fd ) {
 110   // start out by assuming things will fail.
 111   *listen_fd = -1;
 112
 113   const char* node = NULL;
 114   const char* service = NULL;
 115
 116   if (!host.empty()) node = host.c_str();
 117   if (!port.empty()) service = port.c_str();
 118
 119   struct addrinfo *results = 0;
 120   struct addrinfo hints;
 121   memset(&hints, 0, sizeof(hints));
 122
 123   if (is_numeric_host_address) {
 124     hints.ai_flags = AI_NUMERICHOST;  // iff you know the name is numeric.
 125   }
 126   hints.ai_flags |= AI_PASSIVE;
 127
 128   hints.ai_family = PF_INET;
 129   hints.ai_socktype = SOCK_STREAM;
 130
 131   int err = 0;
 132   if ((err=getaddrinfo(node, service, &hints, &results))) {
 133     // gai_strerror -is- threadsafe, so we get to use it here.
 134     LOG(ERROR) << "getaddrinfo " << " for (" << host << ":" << port
 135                   << ") " << gai_strerror(err) << "\n";
 136     return -1;
 137   }
 138   // this will delete the addrinfo memory when we return from this function.
 139   AddrinfoGuard addrinfo_guard(results);
 140
 141   int sock = socket(results->ai_family,
 142                     results->ai_socktype,
 143                     results->ai_protocol);
 144   if (sock == -1) {
 145     LOG(ERROR) << "Unable to create socket for (" << host << ":"
 146       << port << "): " << strerror(errno) << "\n";
 147     return -1;
 148   }
 149
 150   if (reuseaddr) {
 151     // set SO_REUSEADDR on the listening socket.
 152     int on = 1;
 153     int rc;
 154     rc = setsockopt(sock, SOL_SOCKET,  SO_REUSEADDR,
 155                     reinterpret_cast<char *>(&on), sizeof(on));
 156     if (rc < 0) {
 157       close(sock);
 158       LOG(FATAL) << "setsockopt() failed fd=" << listen_fd << "\n";
 159     }
 160   }
 161 #ifndef SO_REUSEPORT
 162 #define SO_REUSEPORT 15
 163 #endif
 164   if (reuseport) {
 165     // set SO_REUSEADDR on the listening socket.
 166     int on = 1;
 167     int rc;
 168     rc = setsockopt(sock, SOL_SOCKET,  SO_REUSEPORT,
 169                     reinterpret_cast<char *>(&on), sizeof(on));
 170     if (rc < 0) {
 171       close(sock);
 172       LOG(FATAL) << "setsockopt() failed fd=" << listen_fd << "\n";
 173     }
 174   }
 175
 176   if (bind(sock, results->ai_addr, results->ai_addrlen)) {
 177     // If we are waiting for the interface to be raised, such as in an
 178     // HA environment, ignore reporting any errors.
 179     int saved_errno = errno;
 180     if ( !wait_for_iface || errno != EADDRNOTAVAIL) {
 181       LOG(ERROR) << "Bind was unsuccessful for (" << host << ":"
 182         << port << "): " << strerror(errno) << "\n";
 183     }
 184     // if we knew that we were not multithreaded, we could do the following:
 185     // " : " << strerror(errno) << "\n";
 186     if (CloseSocket(&sock, 100)) {
 187       if ( saved_errno == EADDRNOTAVAIL ) {
 188         return -3;
 189       }
 190       return -2;
 191     } else {
 192       // couldn't even close the dang socket?!
 193       LOG(ERROR) << "Unable to close the socket.. Considering this a fatal "
 194                       "error, and exiting\n";
 195       exit(EXIT_FAILURE);
 196       return -1;
 197     }
 198   }
 199
 200   if (disable_nagle) {
 201     if (!SetDisableNagle(sock)) {
 202       return -1;
 203     }
 204   }
 205
 206   if (listen(sock, backlog)) {
 207     // listen was unsuccessful.
 208     LOG(ERROR) << "Listen was unsuccessful for (" << host << ":"
 209       << port << "): " << strerror(errno) << "\n";
 210     // if we knew that we were not multithreaded, we could do the following:
 211     // " : " << strerror(errno) << "\n";
 212
 213     if (CloseSocket(&sock, 100)) {
 214       sock = -1;
 215       return -1;
 216     } else {
 217       // couldn't even close the dang socket?!
 218       LOG(FATAL) << "Unable to close the socket.. Considering this a fatal "
 219                       "error, and exiting\n";
 220     }
 221   }
 222
 223   // If we've gotten to here, Yeay! Success!
 224   *listen_fd = sock;
 225
 226   return 0;
 227 }
 228
 229 int CreateConnectedSocket( int *connect_fd,
 230                            const std::string& host,
 231                            const std::string& port,
 232                            bool is_numeric_host_address,
 233                            bool disable_nagle ) {
 234   const char* node = NULL;
 235   const char* service = NULL;
 236
 237   *connect_fd = -1;
 238   if (!host.empty())
 239     node = host.c_str();
 240   if (!port.empty())
 241     service = port.c_str();
 242
 243   struct addrinfo *results = 0;
 244   struct addrinfo hints;
 245   memset(&hints, 0, sizeof(hints));
 246
 247   if (is_numeric_host_address)
 248     hints.ai_flags = AI_NUMERICHOST;  // iff you know the name is numeric.
 249   hints.ai_flags |= AI_PASSIVE;
 250
 251   hints.ai_family = PF_INET;
 252   hints.ai_socktype = SOCK_STREAM;
 253
 254   int err = 0;
 255   if ((err=getaddrinfo(node, service, &hints, &results))) {
 256     // gai_strerror -is- threadsafe, so we get to use it here.
 257     LOG(ERROR) << "getaddrinfo for (" << node << ":" << service << "): "
 258                << gai_strerror(err);
 259     return -1;
 260   }
 261   // this will delete the addrinfo memory when we return from this function.
 262   AddrinfoGuard addrinfo_guard(results);
 263
 264   int sock = socket(results->ai_family,
 265                     results->ai_socktype,
 266                     results->ai_protocol);
 267   if (sock == -1) {
 268     LOG(ERROR) << "Unable to create socket for (" << node << ":" << service
 269                << "): " << strerror( errno );
 270     return -1;
 271   }
 272
 273   FlipSetNonBlocking( sock );
 274
 275   if (disable_nagle) {
 276     if (!SetDisableNagle(sock)) {
 277       return -1;
 278     }
 279   }
 280
 281   int ret_val = 0;
 282   if ( connect( sock, results->ai_addr, results->ai_addrlen ) ) {
 283     if ( errno != EINPROGRESS ) {
 284       LOG(ERROR) << "Connect was unsuccessful for (" << node << ":" << service
 285                  << "): " << strerror(errno);
 286       close( sock );
 287       return -1;
 288     }
 289   } else {
 290     ret_val = 1;
 291   }
 292
 293   // If we've gotten to here, Yeay! Success!
 294   *connect_fd = sock;
 295
 296   return ret_val;
 297 }
 298
 299 }  // namespace net