net/tools/flip_server/flip_in_mem_edsm_server.cc

   1 // Copyright (c) 2011 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 <errno.h>
   6 #include <signal.h>
   7 #include <stdio.h>
   8 #include <sys/file.h>
   9 #include <sys/stat.h>
  10
  11 #include <string>
  12 #include <vector>
  13
  14 #include "base/command_line.h"
  15 #include "base/logging.h"
  16 #include "base/synchronization/lock.h"
  17 #include "base/timer/timer.h"
  18 #include "net/tools/balsa/split.h"
  19 #include "net/tools/flip_server/acceptor_thread.h"
  20 #include "net/tools/flip_server/constants.h"
  21 #include "net/tools/flip_server/flip_config.h"
  22 #include "net/tools/flip_server/output_ordering.h"
  23 #include "net/tools/flip_server/sm_connection.h"
  24 #include "net/tools/flip_server/sm_interface.h"
  25 #include "net/tools/flip_server/spdy_interface.h"
  26 #include "net/tools/flip_server/streamer_interface.h"
  27
  28 // If true, then disables the nagle algorithm);
  29 bool FLAGS_disable_nagle = true;
  30
  31 // The number of times that accept() will be called when the
  32 //  alarm goes off when the accept_using_alarm flag is set to true.
  33 //  If set to 0, accept() will be performed until the accept queue
  34 //  is completely drained and the accept() call returns an error);
  35 int32 FLAGS_accepts_per_wake = 0;
  36
  37 // The size of the TCP accept backlog);
  38 int32 FLAGS_accept_backlog_size = 1024;
  39
  40 // If set to false a single socket will be used. If set to true
  41 //  then a new socket will be created for each accept thread.
  42 //  Note that this only works with kernels that support
  43 //  SO_REUSEPORT);
  44 bool FLAGS_reuseport = false;
  45
  46 // Flag to force spdy, even if NPN is not negotiated.
  47 bool FLAGS_force_spdy = false;
  48
  49 // The amount of time the server delays before sending back the
  50 //  reply);
  51 double FLAGS_server_think_time_in_s = 0;
  52
  53 net::FlipConfig g_proxy_config;
  54
  55 std::vector<std::string>& split(const std::string& s,
  56                                 char delim,
  57                                 std::vector<std::string>& elems) {
  58   std::stringstream ss(s);
  59   std::string item;
  60   while (std::getline(ss, item, delim)) {
  61     elems.push_back(item);
  62   }
  63   return elems;
  64 }
  65
  66 std::vector<std::string> split(const std::string& s, char delim) {
  67   std::vector<std::string> elems;
  68   return split(s, delim, elems);
  69 }
  70
  71 bool GotQuitFromStdin() {
  72   // Make stdin nonblocking. Yes this is done each time. Oh well.
  73   fcntl(0, F_SETFL, O_NONBLOCK);
  74   char c;
  75   std::string maybequit;
  76   while (read(0, &c, 1) > 0) {
  77     maybequit += c;
  78   }
  79   if (maybequit.size()) {
  80     VLOG(1) << "scanning string: \"" << maybequit << "\"";
  81   }
  82   return (maybequit.size() > 1 &&
  83           (maybequit.c_str()[0] == 'q' || maybequit.c_str()[0] == 'Q'));
  84 }
  85
  86 const char* BoolToStr(bool b) {
  87   if (b)
  88     return "true";
  89   return "false";
  90 }
  91
  92 static bool wantExit = false;
  93 static bool wantLogClose = false;
  94 void SignalHandler(int signum) {
  95   switch (signum) {
  96     case SIGTERM:
  97     case SIGINT:
  98       wantExit = true;
  99       break;
 100     case SIGHUP:
 101       wantLogClose = true;
 102       break;
 103   }
 104 }
 105
 106 static int OpenPidFile(const char* pidfile) {
 107   int fd;
 108   struct stat pid_stat;
 109   int ret;
 110
 111   fd = open(pidfile, O_RDWR | O_CREAT, 0600);
 112   if (fd == -1) {
 113     fprintf(stderr, "Could not open pid file '%s' for reading.\n", pidfile);
 114     exit(1);
 115   }
 116
 117   ret = flock(fd, LOCK_EX | LOCK_NB);
 118   if (ret == -1) {
 119     if (errno == EWOULDBLOCK) {
 120       fprintf(stderr, "Flip server is already running.\n");
 121     } else {
 122       perror("Error getting lock on pid file");
 123     }
 124     exit(1);
 125   }
 126
 127   if (fstat(fd, &pid_stat) == -1) {
 128     fprintf(
 129         stderr, "Could not stat pid file '%s': %s\n", pidfile, strerror(errno));
 130     exit(1);
 131   }
 132   if (pid_stat.st_size != 0) {
 133     if (ftruncate(fd, pid_stat.st_size) == -1) {
 134       fprintf(stderr,
 135               "Could not truncate pid file '%s': %s\n",
 136               pidfile,
 137               strerror(errno));
 138       exit(1);
 139     }
 140   }
 141
 142   char pid_str[8];
 143   snprintf(pid_str, sizeof(pid_str), "%d", getpid());
 144   int bytes = static_cast<int>(strlen(pid_str));
 145   if (write(fd, pid_str, strlen(pid_str)) != bytes) {
 146     perror("Could not write pid file");
 147     close(fd);
 148     exit(1);
 149   }
 150
 151   return fd;
 152 }
 153
 154 int main(int argc, char** argv) {
 155   unsigned int i = 0;
 156   bool wait_for_iface = false;
 157   int pidfile_fd;
 158
 159   signal(SIGPIPE, SIG_IGN);
 160   signal(SIGTERM, SignalHandler);
 161   signal(SIGINT, SignalHandler);
 162   signal(SIGHUP, SignalHandler);
 163
 164   base::CommandLine::Init(argc, argv);
 165   base::CommandLine cl(argc, argv);
 166
 167   if (cl.HasSwitch("help") || argc < 2) {
 168     printf("%s <options>\n", argv[0]);
 169     printf("  Proxy options:\n");
 170     printf(
 171         "\t--proxy<1..n>=\"<listen ip>,<listen port>,"
 172         "<ssl cert filename>,\n"
 173         "\t               <ssl key filename>,<http server ip>,"
 174         "<http server port>,\n"
 175         "\t               [https server ip],[https server port],"
 176         "<spdy only 0|1>\"\n"
 177         "\t  * The https server ip and port may be left empty if they are"
 178         " the same as\n"
 179         "\t    the http server fields.\n"
 180         "\t  * spdy only prevents non-spdy https connections from being"
 181         " passed\n"
 182         "\t    through the proxy listen ip:port.\n"
 183         "\t--forward-ip-header=<header name>\n"
 184         "\n  Server options:\n"
 185         "\t--spdy-server=\"<listen ip>,<listen port>,[ssl cert filename],"
 186         "\n\t               [ssl key filename]\"\n"
 187         "\t--http-server=\"<listen ip>,<listen port>,[ssl cert filename],"
 188         "\n\t               [ssl key filename]\"\n"
 189         "\t  * Leaving the ssl cert and key fields empty will disable ssl"
 190         " for the\n"
 191         "\t    http and spdy flip servers\n"
 192         "\n  Global options:\n"
 193         "\t--logdest=<file|system|both>\n"
 194         "\t--logfile=<logfile>\n"
 195         "\t--wait-for-iface\n"
 196         "\t  * The flip server will block until the listen ip has been"
 197         " raised.\n"
 198         "\t--ssl-session-expiry=<seconds> (default is 300)\n"
 199         "\t--ssl-disable-compression\n"
 200         "\t--idle-timeout=<seconds> (default is 300)\n"
 201         "\t--pidfile=<filepath> (default /var/run/flip-server.pid)\n"
 202         "\t--help\n");
 203     exit(0);
 204   }
 205
 206   if (cl.HasSwitch("pidfile")) {
 207     pidfile_fd = OpenPidFile(cl.GetSwitchValueASCII("pidfile").c_str());
 208   } else {
 209     pidfile_fd = OpenPidFile(PIDFILE);
 210   }
 211
 212   net::OutputOrdering::set_server_think_time_in_s(FLAGS_server_think_time_in_s);
 213
 214   if (cl.HasSwitch("forward-ip-header")) {
 215     net::SpdySM::set_forward_ip_header(
 216         cl.GetSwitchValueASCII("forward-ip-header"));
 217     net::StreamerSM::set_forward_ip_header(
 218         cl.GetSwitchValueASCII("forward-ip-header"));
 219   }
 220
 221   if (cl.HasSwitch("logdest")) {
 222     std::string log_dest_value = cl.GetSwitchValueASCII("logdest");
 223     if (log_dest_value.compare("file") == 0) {
 224       g_proxy_config.log_destination_ = logging::LOG_TO_FILE;
 225     } else if (log_dest_value.compare("system") == 0) {
 226       g_proxy_config.log_destination_ = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 227     } else if (log_dest_value.compare("both") == 0) {
 228       g_proxy_config.log_destination_ = logging::LOG_TO_ALL;
 229     } else {
 230       LOG(FATAL) << "Invalid logging destination value: " << log_dest_value;
 231     }
 232   } else {
 233     g_proxy_config.log_destination_ = logging::LOG_NONE;
 234   }
 235
 236   if (cl.HasSwitch("logfile")) {
 237     g_proxy_config.log_filename_ = cl.GetSwitchValueASCII("logfile");
 238     if (g_proxy_config.log_destination_ == logging::LOG_NONE) {
 239       g_proxy_config.log_destination_ = logging::LOG_TO_FILE;
 240     }
 241   } else if ((g_proxy_config.log_destination_ & logging::LOG_TO_FILE) != 0) {
 242     LOG(FATAL) << "Logging destination requires a log file to be specified.";
 243   }
 244
 245   if (cl.HasSwitch("wait-for-iface")) {
 246     wait_for_iface = true;
 247   }
 248
 249   if (cl.HasSwitch("ssl-session-expiry")) {
 250     std::string session_expiry = cl.GetSwitchValueASCII("ssl-session-expiry");
 251     g_proxy_config.ssl_session_expiry_ = atoi(session_expiry.c_str());
 252   }
 253
 254   if (cl.HasSwitch("ssl-disable-compression")) {
 255     g_proxy_config.ssl_disable_compression_ = true;
 256   }
 257
 258   if (cl.HasSwitch("idle-timeout")) {
 259     g_proxy_config.idle_socket_timeout_s_ =
 260         atoi(cl.GetSwitchValueASCII("idle-timeout").c_str());
 261   }
 262
 263   if (cl.HasSwitch("force_spdy"))
 264     net::SMConnection::set_force_spdy(true);
 265
 266   logging::LoggingSettings settings;
 267   settings.logging_dest = g_proxy_config.log_destination_;
 268   settings.log_file = g_proxy_config.log_filename_.c_str();
 269   settings.lock_log = logging::DONT_LOCK_LOG_FILE;
 270   logging::InitLogging(settings);
 271
 272   LOG(INFO) << "Flip SPDY proxy started with configuration:";
 273   LOG(INFO) << "Logging destination     : " << g_proxy_config.log_destination_;
 274   LOG(INFO) << "Log file                : " << g_proxy_config.log_filename_;
 275   LOG(INFO) << "Forward IP Header       : "
 276             << (net::SpdySM::forward_ip_header().length()
 277                     ? net::SpdySM::forward_ip_header()
 278                     : "<disabled>");
 279   LOG(INFO) << "Wait for interfaces     : " << (wait_for_iface ? "true"
 280                                                                : "false");
 281   LOG(INFO) << "Accept backlog size     : " << FLAGS_accept_backlog_size;
 282   LOG(INFO) << "Accepts per wake        : " << FLAGS_accepts_per_wake;
 283   LOG(INFO) << "Disable nagle           : " << (FLAGS_disable_nagle ? "true"
 284                                                                     : "false");
 285   LOG(INFO) << "Reuseport               : " << (FLAGS_reuseport ? "true"
 286                                                                 : "false");
 287   LOG(INFO) << "Force SPDY              : " << (FLAGS_force_spdy ? "true"
 288                                                                  : "false");
 289   LOG(INFO) << "SSL session expiry      : "
 290             << g_proxy_config.ssl_session_expiry_;
 291   LOG(INFO) << "SSL disable compression : "
 292             << g_proxy_config.ssl_disable_compression_;
 293   LOG(INFO) << "Connection idle timeout : "
 294             << g_proxy_config.idle_socket_timeout_s_;
 295
 296   // Proxy Acceptors
 297   while (true) {
 298     i += 1;
 299     std::stringstream name;
 300     name << "proxy" << i;
 301     if (!cl.HasSwitch(name.str())) {
 302       break;
 303     }
 304     std::string value = cl.GetSwitchValueASCII(name.str());
 305     std::vector<std::string> valueArgs = split(value, ',');
 306     CHECK_EQ((unsigned int)9, valueArgs.size());
 307     int spdy_only = atoi(valueArgs[8].c_str());
 308     // If wait_for_iface is enabled, then this call will block
 309     // indefinitely until the interface is raised.
 310     g_proxy_config.AddAcceptor(net::FLIP_HANDLER_PROXY,
 311                                valueArgs[0],
 312                                valueArgs[1],
 313                                valueArgs[2],
 314                                valueArgs[3],
 315                                valueArgs[4],
 316                                valueArgs[5],
 317                                valueArgs[6],
 318                                valueArgs[7],
 319                                spdy_only,
 320                                FLAGS_accept_backlog_size,
 321                                FLAGS_disable_nagle,
 322                                FLAGS_accepts_per_wake,
 323                                FLAGS_reuseport,
 324                                wait_for_iface,
 325                                NULL);
 326   }
 327
 328   // Spdy Server Acceptor
 329   net::MemoryCache spdy_memory_cache;
 330   if (cl.HasSwitch("spdy-server")) {
 331     spdy_memory_cache.AddFiles();
 332     std::string value = cl.GetSwitchValueASCII("spdy-server");
 333     std::vector<std::string> valueArgs = split(value, ',');
 334     while (valueArgs.size() < 4)
 335       valueArgs.push_back(std::string());
 336     g_proxy_config.AddAcceptor(net::FLIP_HANDLER_SPDY_SERVER,
 337                                valueArgs[0],
 338                                valueArgs[1],
 339                                valueArgs[2],
 340                                valueArgs[3],
 341                                std::string(),
 342                                std::string(),
 343                                std::string(),
 344                                std::string(),
 345                                0,
 346                                FLAGS_accept_backlog_size,
 347                                FLAGS_disable_nagle,
 348                                FLAGS_accepts_per_wake,
 349                                FLAGS_reuseport,
 350                                wait_for_iface,
 351                                &spdy_memory_cache);
 352   }
 353
 354   // Spdy Server Acceptor
 355   net::MemoryCache http_memory_cache;
 356   if (cl.HasSwitch("http-server")) {
 357     http_memory_cache.AddFiles();
 358     std::string value = cl.GetSwitchValueASCII("http-server");
 359     std::vector<std::string> valueArgs = split(value, ',');
 360     while (valueArgs.size() < 4)
 361       valueArgs.push_back(std::string());
 362     g_proxy_config.AddAcceptor(net::FLIP_HANDLER_HTTP_SERVER,
 363                                valueArgs[0],
 364                                valueArgs[1],
 365                                valueArgs[2],
 366                                valueArgs[3],
 367                                std::string(),
 368                                std::string(),
 369                                std::string(),
 370                                std::string(),
 371                                0,
 372                                FLAGS_accept_backlog_size,
 373                                FLAGS_disable_nagle,
 374                                FLAGS_accepts_per_wake,
 375                                FLAGS_reuseport,
 376                                wait_for_iface,
 377                                &http_memory_cache);
 378   }
 379
 380   std::vector<net::SMAcceptorThread*> sm_worker_threads_;
 381
 382   for (i = 0; i < g_proxy_config.acceptors_.size(); i++) {
 383     net::FlipAcceptor* acceptor = g_proxy_config.acceptors_[i];
 384
 385     sm_worker_threads_.push_back(new net::SMAcceptorThread(
 386         acceptor, (net::MemoryCache*)acceptor->memory_cache_));
 387     // Note that spdy_memory_cache is not threadsafe, it is merely
 388     // thread compatible. Thus, if ever we are to spawn multiple threads,
 389     // we either must make the MemoryCache threadsafe, or use
 390     // a separate MemoryCache for each thread.
 391     //
 392     // The latter is what is currently being done as we spawn
 393     // a separate thread for each http and spdy server acceptor.
 394
 395     sm_worker_threads_.back()->InitWorker();
 396     sm_worker_threads_.back()->Start();
 397   }
 398
 399   while (!wantExit) {
 400     // Close logfile when HUP signal is received. Logging system will
 401     // automatically reopen on next log message.
 402     if (wantLogClose) {
 403       wantLogClose = false;
 404       VLOG(1) << "HUP received, reopening log file.";
 405       logging::CloseLogFile();
 406     }
 407     if (GotQuitFromStdin()) {
 408       for (unsigned int i = 0; i < sm_worker_threads_.size(); ++i) {
 409         sm_worker_threads_[i]->Quit();
 410       }
 411       for (unsigned int i = 0; i < sm_worker_threads_.size(); ++i) {
 412         sm_worker_threads_[i]->Join();
 413       }
 414       break;
 415     }
 416     usleep(1000 * 10);  // 10 ms
 417   }
 418
 419   unlink(PIDFILE);
 420   close(pidfile_fd);
 421   return 0;
 422 }