Memory leak fix, log file reopen, remote ip fix, connection idle timeout,...

net/tools/flip_server/flip_in_mem_edsm_server.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <dirent.h>
 #include <netinet/tcp.h>  // For TCP_NODELAY
 #include <sys/socket.h>
 #include <sys/types.h>
+#include <sys/file.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <openssl/err.h>
 #include <openssl/ssl.h>
 #include <signal.h>
 
 #include <deque>
 #include <iostream>
 #include <limits>
 #include <vector>
 #include <list>
@@ skipping 22 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 using std::deque;
 using std::list;
 using std::map;
 using std::ostream;
 using std::pair;
 using std::string;
 using std::vector;
 using std::cout;
+using std::cerr;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define IPV4_PRINTABLE_FORMAT(IP) (((IP)>>0)&0xff),(((IP)>>8)&0xff), \
                                  (((IP)>>16)&0xff),(((IP)>>24)&0xff)
 
 #define ACCEPTOR_CLIENT_IDENT acceptor_->listen_ip_ << ":" \
                                << acceptor_->listen_port_ << " "
 
 #define NEXT_PROTO_STRING "\x06spdy/2\x08http/1.1\x08http/1.0"
 
 #define SSL_CTX_DEFAULT_CIPHER_LIST "!aNULL:!ADH:!eNull:!LOW:!EXP:RC4+RSA:MEDIUM:HIGH"
 
+#define PIDFILE "/var/run/flip-server.pid"
+
 // If true, then disables the nagle algorithm);
 bool FLAGS_disable_nagle = true;
 
 // The number of times that accept() will be called when the
 //  alarm goes off when the accept_using_alarm flag is set to true.
 //  If set to 0, accept() will be performed until the accept queue
 //  is completely drained and the accept() call returns an error);
 int32 FLAGS_accepts_per_wake = 0;
 
 // The size of the TCP accept backlog);
@@ skipping 208 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class DataFrame {
  public:
   const char* data;
   size_t size;
   bool delete_when_done;
   size_t index;
   DataFrame() : data(NULL), size(0), delete_when_done(false), index(0) {}
-  void MaybeDelete() {
+  virtual void MaybeDelete() {
     if (delete_when_done) {
       delete[] data;
     }
   }
+  virtual ~DataFrame() {
+    MaybeDelete();
+  }
+};
+
+class SpdyFrameDataFrame : public DataFrame {
+ public:
+  SpdyFrame* frame;
+  virtual void MaybeDelete() {
+    if (delete_when_done) {
+      delete frame;
+    }
+  }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class StoreBodyAndHeadersVisitor: public BalsaVisitorInterface {
  public:
   BalsaHeaders headers;
   string body;
   bool error_;
 
@@ skipping 384 matching lines @@
 class SMInterface {
  public:
   virtual void InitSMInterface(SMInterface* sm_other_interface,
                                int32 server_idx) = 0;
   virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                                 SMInterface* sm_interface,
                                 EpollServer* epoll_server,
                                 int fd,
                                 string server_ip,
                                 string server_port,
+                                string remote_ip,
                                 bool use_ssl)  = 0;
   virtual size_t ProcessReadInput(const char* data, size_t len) = 0;
   virtual size_t ProcessWriteInput(const char* data, size_t len) = 0;
   virtual void SetStreamID(uint32 stream_id) = 0;
   virtual bool MessageFullyRead() const = 0;
   virtual bool Error() const = 0;
   virtual const char* ErrorAsString() const = 0;
   virtual void Reset() = 0;
   virtual void ResetForNewInterface(int32 server_idx) = 0;
   // ResetForNewConnection is used for interfaces which control SMConnection
@@ skipping 23 matching lines @@
 class SMConnectionInterface {
  public:
    virtual ~SMConnectionInterface() {}
    virtual void ReadyToSend() = 0;
    virtual EpollServer* epoll_server() = 0;
 };
 
 class HttpSM;
 class SMConnection;
 
-typedef list<DataFrame> OutputList;
+typedef list<DataFrame*> OutputList;
 
 class SMConnectionPoolInterface {
  public:
   virtual ~SMConnectionPoolInterface() {}
   // SMConnections will use this:
   virtual void SMConnectionDone(SMConnection* connection) = 0;
 };
 
 SMInterface* NewStreamerSM(SMConnection* connection,
                            SMInterface* sm_interface,
@@ skipping 34 matching lines @@
         ssl_state_(ssl_state),
         memory_cache_(memory_cache),
         acceptor_(acceptor),
         read_buffer_(4096*10),
         sm_spdy_interface_(NULL),
         sm_http_interface_(NULL),
         sm_streamer_interface_(NULL),
         sm_interface_(NULL),
         log_prefix_(log_prefix),
         max_bytes_sent_per_dowrite_(4096),
-        ssl_(NULL)
+        ssl_(NULL),
+        last_read_time_(0)
         {}
 
   int fd_;
   int events_;
 
   bool registered_in_epoll_server_;
   bool initialized_;
   bool protocol_detected_;
   bool connection_complete_;
 
@@ skipping 11 matching lines @@
   SMInterface* sm_spdy_interface_;
   SMInterface* sm_http_interface_;
   SMInterface* sm_streamer_interface_;
   SMInterface* sm_interface_;
   string log_prefix_;
 
   size_t max_bytes_sent_per_dowrite_;
 
   SSL* ssl_;
  public:
+  time_t last_read_time_;
   string server_ip_;
   string server_port_;
 
   EpollServer* epoll_server() { return epoll_server_; }
   OutputList* output_list() { return &output_list_; }
   MemoryCache* memory_cache() { return memory_cache_; }
   void ReadyToSend() {
     VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
             << "Setting ready to send: EPOLLIN | EPOLLOUT";
     epoll_server_->SetFDReady(fd_, EPOLLIN | EPOLLOUT);
   }
-  void EnqueueDataFrame(const DataFrame& df) {
+  void EnqueueDataFrame(DataFrame* df) {
     output_list_.push_back(df);
     VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "EnqueueDataFrame: "
-            << "size = " << df.size << ": Setting FD ready.";
+            << "size = " << df->size << ": Setting FD ready.";
     ReadyToSend();
   }
   int fd() { return fd_; }
 
  public:
   ~SMConnection() {
     if (initialized()) {
       Reset();
     }
   }
   static SMConnection* NewSMConnection(EpollServer* epoll_server,
                                        SSLState *ssl_state,
                                        MemoryCache* memory_cache,
                                        FlipAcceptor *acceptor,
                                        string log_prefix) {
     return new SMConnection(epoll_server, ssl_state, memory_cache,
                             acceptor, log_prefix);
   }
 
   bool initialized() const { return initialized_; }
   string client_ip() const { return client_ip_; }
 
   void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                         SMInterface* sm_interface,
                         EpollServer* epoll_server,
                         int fd,
                         string server_ip,
                         string server_port,
+                        string remote_ip,
                         bool use_ssl) {
     if (initialized_) {
       LOG(FATAL) << "Attempted to initialize already initialized server";
       return;
     }
 
+    client_ip_ = remote_ip;
+
     if (fd == -1) {
       // If fd == -1, then we are initializing a new connection that will
       // connect to the backend.
       //
       // ret:  -1 == error
       //        0 == connection in progress
       //        1 == connection complete
       // TODO: is_numeric_host_address value needs to be detected
       server_ip_ = server_ip;
       server_port_ = server_port;
@@ skipping 24 matching lines @@
         epoll_server_->UnregisterFD(fd_);
       }
       if (fd_ != -1) {
         VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                  << "Closing pre-existing fd";
         close(fd_);
         fd_ = -1;
       }
 
       fd_ = fd;
-      struct sockaddr sock_addr;
-      socklen_t addr_size = sizeof(sock_addr);
-      addr_size = sizeof(sock_addr);
-      int res = getsockname(fd_, &sock_addr, &addr_size);
-      if (res < 0) {
-        LOG(ERROR) << "Could not get socket address for fd " << fd_
-                   << ": getsockname: " << strerror(errno);
-      } else {
-        struct sockaddr_in *sock_addr_in = (struct sockaddr_in *)&sock_addr;
-        char ip[16];
-        snprintf(ip, sizeof(ip), "%d.%d.%d.%d",
-                IPV4_PRINTABLE_FORMAT(sock_addr_in->sin_addr.s_addr));
-        client_ip_ = ip;
-      }
     }
 
     registered_in_epoll_server_ = false;
+    // Set the last read time here as the idle checker will start from
+    // now.
+    last_read_time_ = time(NULL);
     initialized_ = true;
 
     connection_pool_ = connection_pool;
     epoll_server_ = epoll_server;
 
     if (sm_interface) {
       sm_interface_ = sm_interface;
       protocol_detected_ = true;
     }
 
@@ skipping 33 matching lines @@
           }
           // If we wrote some data, return that count.  Otherwise
           // return the stall error.
           return bytes_written > 0 ? bytes_written : rv;
         }
         bytes_written += rv;
         len -= rv;
         if (rv != chunksize)
           break;  // If we couldn't write everything, we're implicitly stalled
       }
+      if (!(flags & MSG_MORE)) {
+        int state = 0;
+        setsockopt( fd_, IPPROTO_TCP, TCP_CORK, &state, sizeof( state ) );
+        state = 1;
+        setsockopt( fd_, IPPROTO_TCP, TCP_CORK, &state, sizeof( state ) );
+      }
     } else {
       bytes_written = send(fd_, data, len, flags);
     }
     return bytes_written;
   }
 
   // the following are from the EpollCallbackInterface
   virtual void OnRegistration(EpollServer* eps, int fd, int event_mask) {
     registered_in_epoll_server_ = true;
   }
   virtual void OnModification(int fd, int event_mask) { }
   virtual void OnEvent(int fd, EpollEvent* event) {
     events_ |= event->in_events;
     HandleEvents();
     if (events_) {
       event->out_ready_mask = events_;
       events_ = 0;
     }
   }
   virtual void OnUnregistration(int fd, bool replaced) {
     registered_in_epoll_server_ = false;
   }
   virtual void OnShutdown(EpollServer* eps, int fd) {
     Cleanup("OnShutdown");
     return;
   }
 
   void Cleanup(const char* cleanup) {
-    VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Cleanup";
+    VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Cleanup: " << cleanup;
     if (!initialized_) {
       return;
     }
     Reset();
     if (connection_pool_) {
       connection_pool_->SMConnectionDone(this);
     }
     if (sm_interface_) {
       sm_interface_->ResetForNewConnection();
     }
+    last_read_time_ = 0;
   }
 
  private:
   void HandleEvents() {
     VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Received: "
             << EpollServer::EventMaskToString(events_).c_str();
 
     if (events_ & EPOLLIN) {
       if (!DoRead())
         goto handle_close_or_error;
@@ skipping 82 matching lines @@
             continue;
           default:
             VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                     << "While calling recv, got error: "
                     << (ssl_?"(ssl error)":strerror(stored_errno));
             goto error_or_close;
         }
       } else if (bytes_read > 0) {
         VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "read " << bytes_read
                  << " bytes";
+        last_read_time_ = time(NULL);
         if (!protocol_detected_) {
           if (acceptor_->flip_handler_type_ == FLIP_HANDLER_HTTP_SERVER) {
             // Http Server
             protocol_detected_ = true;
             if (!sm_http_interface_) {
               VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                       << "Created HTTP interface.";
               sm_http_interface_ = NewHttpSM(this, NULL, epoll_server_,
                                              memory_cache_, acceptor_);
             } else {
@@ skipping 151 matching lines @@
               << output_list_.size();
       if (bytes_sent >= max_bytes_sent_per_dowrite_) {
         VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                 << " byte sent >= max bytes sent per write: Setting EPOLLOUT";
         events_ |= EPOLLOUT;
         break;
       }
       if (sm_interface_ && output_list_.size() < 2) {
         sm_interface_->GetOutput();
       }
-      DataFrame& data_frame = output_list_.front();
-      const char*  bytes = data_frame.data;
-      int size = data_frame.size;
-      bytes += data_frame.index;
-      size -= data_frame.index;
+      DataFrame* data_frame = output_list_.front();
+      const char*  bytes = data_frame->data;
+      int size = data_frame->size;
+      bytes += data_frame->index;
+      size -= data_frame->index;
       DCHECK_GE(size, 0);
       if (size <= 0) {
         // Empty data frame. Indicates end of data from client.
         // Uncork the socket.
         int state = 0;
         VLOG(2) << log_prefix_ << "Empty data frame, uncorking socket.";
         setsockopt( fd_, IPPROTO_TCP, TCP_CORK, &state, sizeof( state ) );
-        data_frame.MaybeDelete();
         output_list_.pop_front();
+        delete data_frame;
         continue;
       }
 
       flags = MSG_NOSIGNAL | MSG_DONTWAIT;
       if (output_list_.size() > 1) {
         VLOG(2) << log_prefix_ << "Outlist size: " << output_list_.size()
                 << ": Adding MSG_MORE flag";
         flags |= MSG_MORE;
       }
       VLOG(2) << log_prefix_ << "Attempting to send " << size << " bytes.";
@@ skipping 12 matching lines @@
             continue;
           default:
             VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
                     << "While calling send, got error: " << stored_errno
                     << ": " << (ssl_?"":strerror(stored_errno));
             goto error_or_close;
         }
       } else if (bytes_written > 0) {
         VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Wrote: "
                 << bytes_written << " bytes";
-        data_frame.index += bytes_written;
+        data_frame->index += bytes_written;
         bytes_sent += bytes_written;
         continue;
       } else if (bytes_written == -2) {
         // -2 handles SSL_ERROR_WANT_* errors
         events_ &= ~EPOLLOUT;
         goto done;
       }
       VLOG(1) << log_prefix_ << ACCEPTOR_CLIENT_IDENT
               << "0 bytes written with send call.";
       goto error_or_close;
@@ skipping 14 matching lines @@
     return os;
   }
 
   void Reset() {
     VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Resetting";
     if (ssl_) {
       SSL_shutdown(ssl_);
       PrintSslError();
       SSL_free(ssl_);
       PrintSslError();
+      ssl_ = NULL;
     }
     if (registered_in_epoll_server_) {
       epoll_server_->UnregisterFD(fd_);
       registered_in_epoll_server_ = false;
     }
     if (fd_ >= 0) {
       VLOG(2) << log_prefix_ << ACCEPTOR_CLIENT_IDENT << "Closing connection";
       close(fd_);
       fd_ = -1;
     }
     read_buffer_.Clear();
     initialized_ = false;
     protocol_detected_ = false;
     events_ = 0;
+    for (list<DataFrame*>::iterator i =
+         output_list_.begin();
+         i != output_list_.end();
+         ++i) {
+      delete *i;
+    }
     output_list_.clear();
   }
 
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class OutputOrdering {
  public:
   typedef list<MemCacheIter> PriorityRing;
@@ skipping 221 matching lines @@
 
   void InitSMInterface(SMInterface* sm_http_interface,
                        int32 server_idx) { }
 
   void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                         SMInterface* sm_interface,
                         EpollServer* epoll_server,
                         int fd,
                         string server_ip,
                         string server_port,
+                        string remote_ip,
                         bool use_ssl) {
     VLOG(2) << ACCEPTOR_CLIENT_IDENT
             << "SpdySM: Initializing server connection.";
     connection_->InitSMConnection(connection_pool, sm_interface,
                                   epoll_server, fd, server_ip, server_port,
-                                  use_ssl);
+                                  remote_ip, use_ssl);
   }
 
  private:
   virtual void OnError(SpdyFramer* framer) {
     /* do nothing with this right now */
   }
 
   SMInterface* NewConnectionInterface() {
     SMConnection* server_connection =
       SMConnection::NewSMConnection(epoll_server_, NULL,
@@ skipping 25 matching lines @@
       server_idx = unused_server_interface_list.back();
       unused_server_interface_list.pop_back();
       sm_http_interface = server_interface_list.at(server_idx);
       VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Reusing connection on "
               << "index: " << server_idx;
     }
 
     sm_http_interface->InitSMInterface(this, server_idx);
     sm_http_interface->InitSMConnection(NULL, sm_http_interface,
                                         epoll_server_, -1,
-                                        server_ip, server_port, false);
+                                        server_ip, server_port, "", false);
 
     return sm_http_interface;
   }
 
   int SpdyHandleNewStream(const SpdyControlFrame* frame,
-                          string *http_data,
+                          string &http_data,
                           bool *is_https_scheme)
   {
     bool parsed_headers = false;
     SpdyHeaderBlock headers;
     const SpdySynStreamControlFrame* syn_stream =
       reinterpret_cast<const SpdySynStreamControlFrame*>(frame);
 
     *is_https_scheme = false;
     parsed_headers = spdy_framer_->ParseHeaderBlock(frame, &headers);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: OnSyn("
@@ skipping 26 matching lines @@
       string host = UrlUtilities::GetUrlHost(url->second);
       VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second
               << " " << uri;
       string filename = EncodeURL(uri, host, method->second);
       NewStream(syn_stream->stream_id(),
                 reinterpret_cast<const SpdySynStreamControlFrame*>(frame)->
                 priority(),
                 filename);
     } else {
       SpdyHeaderBlock::iterator version = headers.find("version");
-      *http_data += method->second + " " + uri + " " + version->second + "\r\n";
+      http_data += method->second + " " + uri + " " + version->second + "\r\n";
       VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Request: " << method->second << " "
               << uri << " " << version->second;
       for (SpdyHeaderBlock::iterator i = headers.begin();
            i != headers.end(); ++i) {
-        *http_data += i->first + ": " + i->second + "\r\n";
+        http_data += i->first + ": " + i->second + "\r\n";
         VLOG(2) << ACCEPTOR_CLIENT_IDENT << i->first.c_str() << ":"
                 << i->second.c_str();
       }
       if (g_proxy_config.forward_ip_header_enabled_) {
         // X-Client-Cluster-IP header
-        *http_data += g_proxy_config.forward_ip_header_ + ": " +
+        http_data += g_proxy_config.forward_ip_header_ + ": " +
                       connection_->client_ip() + "\r\n";
       }
-      *http_data += "\r\n";
+      http_data += "\r\n";
     }
 
     VLOG(3) << ACCEPTOR_CLIENT_IDENT << "SpdySM: HTTP Request:\n" << http_data;
     return 1;
   }
 
   virtual void OnControl(const SpdyControlFrame* frame) {
     SpdyHeaderBlock headers;
     bool parsed_headers = false;
     switch (frame->type()) {
       case SYN_STREAM:
         {
         const SpdySynStreamControlFrame* syn_stream =
             reinterpret_cast<const SpdySynStreamControlFrame*>(frame);
 
           string http_data;
           bool is_https_scheme;
-          int ret = SpdyHandleNewStream(frame, &http_data, &is_https_scheme);
+          int ret = SpdyHandleNewStream(frame, http_data, &is_https_scheme);
           if (!ret) {
             LOG(ERROR) << "SpdySM: Could not convert spdy into http.";
             break;
           }
 
           if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY) {
             string server_ip;
             string server_port;
             if (is_https_scheme) {
               server_ip = acceptor_->https_server_ip_;
@@ skipping 83 matching lines @@
     next_outgoing_stream_id_ = 2;
   }
 
   // SMInterface's Cleanup is currently only called by SMConnection after a
   // protocol message as been fully read. Spdy's SMInterface does not need
   // to do any cleanup at this time.
   // TODO (klindsay) This method is probably not being used properly and
   // some logic review and method renaming is probably in order.
   void Cleanup() {}
 
-  // Send a settings frame and possibly some NOOP packets to force
-  // opening of cwnd
+  // Send a settings frame
   int PostAcceptHook() {
     ssize_t bytes_written;
     spdy::SpdySettings settings;
     spdy::SettingsFlagsAndId settings_id(0);
     settings_id.set_id(spdy::SETTINGS_MAX_CONCURRENT_STREAMS);
     settings.push_back(spdy::SpdySetting(settings_id, 100));
     scoped_ptr<SpdySettingsControlFrame>
       settings_frame(spdy_framer_->CreateSettings(settings));
 
     char* bytes = settings_frame->data();
@@ skipping 141 matching lines @@
       string original_url = headers.GetHeader("X-Original-Url").as_string();
       block["path"] = UrlUtilities::GetUrlPath(original_url);
     } else {
       block["path"] = headers.request_uri().as_string();
     }
     CopyHeaders(block, headers);
 
     SpdySynStreamControlFrame* fsrcf =
       spdy_framer_->CreateSynStream(stream_id, 0, 0, CONTROL_FLAG_NONE, true,
                                     &block);
-    DataFrame df;
-    df.size = fsrcf->length() + SpdyFrame::size();
-    size_t df_size = df.size;
-    df.data = fsrcf->data();
-    df.delete_when_done = true;
+    SpdyFrameDataFrame* df = new SpdyFrameDataFrame;
+    df->size = fsrcf->length() + SpdyFrame::size();
+    size_t df_size = df->size;
+    df->data = fsrcf->data();
+    df->frame = fsrcf;
+    df->delete_when_done = true;
     EnqueueDataFrame(df);
 
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynStreamheader "
             << stream_id;
     return df_size;
   }
 
   size_t SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) {
     SpdyHeaderBlock block;
     CopyHeaders(block, headers);
     block["status"] = headers.response_code().as_string() + " " +
                       headers.response_reason_phrase().as_string();
     block["version"] = headers.response_version().as_string();
 
     SpdySynReplyControlFrame* fsrcf =
       spdy_framer_->CreateSynReply(stream_id, CONTROL_FLAG_NONE, true, &block);
-    DataFrame df;
-    df.size = fsrcf->length() + SpdyFrame::size();
-    size_t df_size = df.size;
-    df.data = fsrcf->data();
-    df.delete_when_done = true;
+    SpdyFrameDataFrame* df = new SpdyFrameDataFrame;
+    df->size = fsrcf->length() + SpdyFrame::size();
+    size_t df_size = df->size;
+    df->data = fsrcf->data();
+    df->frame = fsrcf;
+    df->delete_when_done = true;
     EnqueueDataFrame(df);
 
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending SynReplyheader "
             << stream_id;
     return df_size;
   }
 
   void SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
                          SpdyDataFlags flags, bool compress) {
     // Force compression off if disabled via command line.
     if (!FLAGS_use_compression)
       flags = static_cast<SpdyDataFlags>(flags & ~DATA_FLAG_COMPRESSED);
 
     // TODO(mbelshe):  We can't compress here - before going into the
     //                 priority queue.  Compression needs to be done
     //                 with late binding.
-
     if (len == 0) {
       SpdyDataFrame* fdf = spdy_framer_->CreateDataFrame(stream_id, data, len,
                                                          flags);
-      DataFrame df;
-      df.size = fdf->length() + SpdyFrame::size();
-      df.data = fdf->data();
-      df.delete_when_done = true;
+      SpdyFrameDataFrame* df = new SpdyFrameDataFrame;
+      df->size = fdf->length() + SpdyFrame::size();
+      df->data = fdf->data();
+      df->delete_when_done = true;
       EnqueueDataFrame(df);
       return;
     }
 
     // Chop data frames into chunks so that one stream can't monopolize the
     // output channel.
     while(len > 0) {
       int64 size = std::min(len, static_cast<int64>(kSpdySegmentSize));
       SpdyDataFlags chunk_flags = flags;
 
       // If we chunked this block, and the FIN flag was set, there is more
       // data coming.  So, remove the flag.
       if ((size < len) && (flags & DATA_FLAG_FIN))
         chunk_flags = static_cast<SpdyDataFlags>(chunk_flags & ~DATA_FLAG_FIN);
 
       SpdyDataFrame* fdf = spdy_framer_->CreateDataFrame(stream_id, data, size,
                                                          chunk_flags);
-      DataFrame df;
-      df.size = fdf->length() + SpdyFrame::size();
-      df.data = fdf->data();
-      df.delete_when_done = true;
+      SpdyFrameDataFrame* df = new SpdyFrameDataFrame;
+      df->size = fdf->length() + SpdyFrame::size();
+      df->data = fdf->data();
+      df->delete_when_done = true;
       EnqueueDataFrame(df);
 
       VLOG(2) << ACCEPTOR_CLIENT_IDENT << "SpdySM: Sending data frame "
               << stream_id << " [" << size << "] shrunk to " << fdf->length()
               << ", flags=" << flags;
 
       data += size;
       len -= size;
     }
   }
 
-  void EnqueueDataFrame(const DataFrame& df) {
+  void EnqueueDataFrame(DataFrame* df) {
     connection_->EnqueueDataFrame(df);
   }
 
   void GetOutput() {
     while (client_output_list_->size() < 2) {
       MemCacheIter* mci = client_output_ordering_.GetIter();
       if (mci == NULL) {
         VLOG(2) << ACCEPTOR_CLIENT_IDENT
                 << "SpdySM: GetOutput: nothing to output!?";
         return;
@@ skipping 178 matching lines @@
     sm_spdy_interface_ = sm_spdy_interface;
     server_idx_ = server_idx;
   }
 
   void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                         SMInterface* sm_interface,
                         EpollServer* epoll_server,
                         int fd,
                         string server_ip,
                         string server_port,
+                        string remote_ip,
                         bool use_ssl)
   {
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Initializing server "
             << "connection.";
     connection_->InitSMConnection(connection_pool, sm_interface,
                                   epoll_server, fd, server_ip, server_port,
-                                  use_ssl);
+                                  remote_ip, use_ssl);
   }
 
   size_t ProcessReadInput(const char* data, size_t len) {
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Process read input: stream "
             << stream_id_;
     return http_framer_->ProcessInput(data, len);
   }
 
   size_t ProcessWriteInput(const char* data, size_t len) {
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Process write input: size "
             << len << ": stream " << stream_id_;
     char * dataPtr = new char[len];
     memcpy(dataPtr, data, len);
-    DataFrame data_frame;
-    data_frame.data = (const char *)dataPtr;
-    data_frame.size = len;
-    data_frame.delete_when_done = true;
+    DataFrame* data_frame = new DataFrame;
+    data_frame->data = (const char *)dataPtr;
+    data_frame->size = len;
+    data_frame->delete_when_done = true;
     connection_->EnqueueDataFrame(data_frame);
     return len;
   }
 
   bool MessageFullyRead() const {
     return http_framer_->MessageFullyRead();
   }
 
   void SetStreamID(uint32 stream_id) {
     stream_id_ = stream_id;
@@ skipping 83 matching lines @@
 
   void SendDataFrame(uint32 stream_id, const char* data, int64 len,
                      uint32 flags, bool compress) {
     SendDataFrameImpl(stream_id, data, len, flags, compress);
   }
 
   BalsaFrame* spdy_framer() { return http_framer_; }
 
  private:
   void SendEOFImpl(uint32 stream_id) {
-    DataFrame df;
-    df.data = "0\r\n\r\n";
-    df.size = 5;
-    df.delete_when_done = false;
+    DataFrame* df = new DataFrame;
+    df->data = "0\r\n\r\n";
+    df->size = 5;
+    df->delete_when_done = false;
     EnqueueDataFrame(df);
     if (acceptor_->flip_handler_type_ == FLIP_HANDLER_HTTP_SERVER) {
       Reset();
     }
   }
 
   void SendErrorNotFoundImpl(uint32 stream_id) {
     BalsaHeaders my_headers;
     my_headers.SetFirstlineFromStringPieces("HTTP/1.1", "404", "Not Found");
     my_headers.RemoveAllOfHeader("content-length");
@@ skipping 11 matching lines @@
     my_headers.AppendHeader("transfer-encoding", "chunked");
     SendSynReplyImpl(stream_id, my_headers);
     SendDataFrame(stream_id, output->c_str(), output->size(), 0, false);
     SendEOFImpl(stream_id);
     output_ordering_.RemoveStreamId(stream_id);
   }
 
   size_t SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) {
     SimpleBuffer sb;
     headers.WriteHeaderAndEndingToBuffer(&sb);
-    DataFrame df;
-    df.size = sb.ReadableBytes();
-    char* buffer = new char[df.size];
-    df.data = buffer;
-    df.delete_when_done = true;
-    sb.Read(buffer, df.size);
+    DataFrame* df = new DataFrame;
+    df->size = sb.ReadableBytes();
+    char* buffer = new char[df->size];
+    df->data = buffer;
+    df->delete_when_done = true;
+    sb.Read(buffer, df->size);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Sending HTTP Reply header "
             << stream_id_;
-    size_t df_size = df.size;
+    size_t df_size = df->size;
     EnqueueDataFrame(df);
     return df_size;
   }
 
   size_t SendSynStreamImpl(uint32 stream_id, const BalsaHeaders& headers) {
     SimpleBuffer sb;
     headers.WriteHeaderAndEndingToBuffer(&sb);
-    DataFrame df;
-    df.size = sb.ReadableBytes();
-    char* buffer = new char[df.size];
-    df.data = buffer;
-    df.delete_when_done = true;
-    sb.Read(buffer, df.size);
+    DataFrame* df = new DataFrame;
+    df->size = sb.ReadableBytes();
+    char* buffer = new char[df->size];
+    df->data = buffer;
+    df->delete_when_done = true;
+    sb.Read(buffer, df->size);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Sending HTTP Reply header "
             << stream_id_;
-    size_t df_size = df.size;
+    size_t df_size = df->size;
     EnqueueDataFrame(df);
     return df_size;
   }
 
   void SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
                          uint32 flags, bool compress) {
     char chunk_buf[128];
     snprintf(chunk_buf, sizeof(chunk_buf), "%x\r\n", (unsigned int)len);
     string chunk_description(chunk_buf);
-    DataFrame df;
-    df.size = chunk_description.size() + len + 2;
-    char* buffer = new char[df.size];
-    df.data = buffer;
-    df.delete_when_done = true;
+    DataFrame* df = new DataFrame;
+    df->size = chunk_description.size() + len + 2;
+    char* buffer = new char[df->size];
+    df->data = buffer;
+    df->delete_when_done = true;
     memcpy(buffer, chunk_description.data(), chunk_description.size());
     memcpy(buffer + chunk_description.size(), data, len);
     memcpy(buffer + chunk_description.size() + len, "\r\n", 2);
     EnqueueDataFrame(df);
   }
 
-  void EnqueueDataFrame(const DataFrame& df) {
+  void EnqueueDataFrame(DataFrame* df) {
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Enqueue data frame: stream "
             << stream_id_;
     connection_->EnqueueDataFrame(df);
   }
 
   void GetOutput() {
     MemCacheIter* mci = output_ordering_.GetIter();
     if (mci == NULL) {
       VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: GetOutput: nothing to "
               << "output!?: stream " << stream_id_;
@@ skipping 59 matching lines @@
    {
      sm_other_interface_ = sm_other_interface;
    }
 
    void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                          SMInterface* sm_interface,
                          EpollServer* epoll_server,
                          int fd,
                          string server_ip,
                          string server_port,
+                         string remote_ip,
                          bool use_ssl)
    {
      VLOG(2) << ACCEPTOR_CLIENT_IDENT << "StreamerSM: Initializing server "
              << "connection.";
      connection_->InitSMConnection(connection_pool, sm_interface,
                                    epoll_server, fd, server_ip,
-                                   server_port, use_ssl);
+                                   server_port, remote_ip, use_ssl);
    }
 
    size_t ProcessReadInput(const char* data, size_t len) {
      return sm_other_interface_->ProcessWriteInput(data, len);
    }
 
    size_t ProcessWriteInput(const char* data, size_t len) {
      char * dataPtr = new char[len];
      memcpy(dataPtr, data, len);
-     DataFrame df;
-     df.data = (const char *)dataPtr;
-     df.size = len;
-     df.delete_when_done = true;
+     DataFrame* df = new DataFrame;
+     df->data = (const char *)dataPtr;
+     df->size = len;
+     df->delete_when_done = true;
      connection_->EnqueueDataFrame(df);
      return len;
    }
 
    bool MessageFullyRead() const {
      return false;
    }
 
    void SetStreamID(uint32 stream_id) {}
 
@@ skipping 34 matching lines @@
        sm_other_interface_ = new StreamerSM(server_connection, this,
                                             epoll_server_, acceptor_);
        sm_other_interface_->InitSMInterface(this, 0);
      }
      // The Streamer interface is used to stream HTTPS connections, so we
      // will always use the https_server_ip/port here.
      sm_other_interface_->InitSMConnection(NULL, sm_other_interface_,
                                            epoll_server_, -1,
                                            acceptor_->https_server_ip_,
                                            acceptor_->https_server_port_,
+                                           "",
                                            false);
 
      return 1;
    }
 
    void NewStream(uint32 stream_id, uint32 priority, const string& filename) {
    }
 
    void AddToOutputOrder(const MemCacheIter& mci) {
    }
@@ skipping 69 matching lines @@
                          public EpollCallbackInterface,
                          public SMConnectionPoolInterface {
   EpollServer epoll_server_;
   FlipAcceptor *acceptor_;
   SSLState *ssl_state_;
   bool use_ssl_;
 
   vector<SMConnection*> unused_server_connections_;
   vector<SMConnection*> tmp_unused_server_connections_;
   vector<SMConnection*> allocated_server_connections_;
+  list<SMConnection*> active_server_connections_;
   Notification quitting_;
   MemoryCache* memory_cache_;
  public:
 
   SMAcceptorThread(FlipAcceptor *acceptor,
                    MemoryCache* memory_cache) :
       SimpleThread("SMAcceptorThread"),
       acceptor_(acceptor),
       ssl_state_(NULL),
       use_ssl_(false),
@@ skipping 13 matching lines @@
     }
   }
 
   ~SMAcceptorThread() {
     for (vector<SMConnection*>::iterator i =
          allocated_server_connections_.begin();
          i != allocated_server_connections_.end();
          ++i) {
       delete *i;
     }
+    delete ssl_state_;
   }
 
   SMConnection* NewConnection() {
     SMConnection* server =
       SMConnection::NewSMConnection(&epoll_server_, ssl_state_,
                                     memory_cache_, acceptor_,
                                     "client_conn: ");
     allocated_server_connections_.push_back(server);
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Acceptor: Making new server.";
     return server;
   }
 
   SMConnection* FindOrMakeNewSMConnection() {
     if (unused_server_connections_.empty()) {
       return NewConnection();
     }
     SMConnection* server = unused_server_connections_.back();
     unused_server_connections_.pop_back();
     VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Acceptor: Reusing server.";
     return server;
   }
 
   void InitWorker() {
     epoll_server_.RegisterFD(acceptor_->listen_fd_, this, EPOLLIN | EPOLLET);
   }
 
-  void HandleConnection(int server_fd) {
+  void HandleConnection(int server_fd, struct sockaddr_in *remote_addr) {
     int on = 1;
     int rc;
     if (acceptor_->disable_nagle_) {
       rc = setsockopt(server_fd, IPPROTO_TCP,  TCP_NODELAY,
                       reinterpret_cast<char*>(&on), sizeof(on));
       if (rc < 0) {
         close(server_fd);
         LOG(ERROR) << "setsockopt() failed fd=" + server_fd;
         return;
       }
     }
 
     SMConnection* server_connection = FindOrMakeNewSMConnection();
     if (server_connection == NULL) {
       VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Acceptor: Closing fd " << server_fd;
       close(server_fd);
       return;
     }
+    string remote_ip = inet_ntoa(remote_addr->sin_addr);
     server_connection->InitSMConnection(this,
                                         NULL,
                                         &epoll_server_,
                                         server_fd,
-                                        "", "",
+                                        "", "", remote_ip,
                                         use_ssl_);
+    if (server_connection->initialized())
+      active_server_connections_.push_back(server_connection);
   }
 
   void AcceptFromListenFD() {
     if (acceptor_->accepts_per_wake_ > 0) {
       for (int i = 0; i < acceptor_->accepts_per_wake_; ++i) {
         struct sockaddr address;
         socklen_t socklen = sizeof(address);
         int fd = accept(acceptor_->listen_fd_, &address, &socklen);
         if (fd == -1) {
           if (errno != 11) {
             VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Acceptor: accept fail("
                     << acceptor_->listen_fd_ << "): " << errno << ": "
                     << strerror(errno);
           }
           break;
         }
         VLOG(1) << ACCEPTOR_CLIENT_IDENT << " Accepted connection";
-        HandleConnection(fd);
+        HandleConnection(fd, (struct sockaddr_in *)&address);
       }
     } else {
       while (true) {
         struct sockaddr address;
         socklen_t socklen = sizeof(address);
         int fd = accept(acceptor_->listen_fd_, &address, &socklen);
         if (fd == -1) {
           if (errno != 11) {
             VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Acceptor: accept fail("
                     << acceptor_->listen_fd_ << "): " << errno << ": "
                     << strerror(errno);
           }
           break;
         }
         VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Accepted connection";
-        HandleConnection(fd);
+        HandleConnection(fd, (struct sockaddr_in *)&address);
       }
     }
   }
 
   // EpollCallbackInteface virtual functions.
   virtual void OnRegistration(EpollServer* eps, int fd, int event_mask) { }
   virtual void OnModification(int fd, int event_mask) { }
   virtual void OnEvent(int fd, EpollEvent* event) {
     if (event->in_events | EPOLLIN) {
       VLOG(2) << ACCEPTOR_CLIENT_IDENT
               << "Acceptor: Accepting based upon epoll events";
       AcceptFromListenFD();
     }
   }
   virtual void OnUnregistration(int fd, bool replaced) { }
   virtual void OnShutdown(EpollServer* eps, int fd) { }
 
   void Quit() {
     quitting_.Notify();
   }
 
+ // Iterates through a list of active connections expiring any that have been
+ // idle longer than the configured timeout.
+ void HandleConnectionIdleTimeout() {
+   int cur_time = time(NULL);
+   static time_t oldest_time = cur_time;
+   // Only iterate the list if we speculate that a connection is ready to be
+   // expired
+   if ((cur_time - oldest_time) < g_proxy_config.idle_timeout_s_)
+     return;
+   list<SMConnection*>::iterator iter = active_server_connections_.begin();
+   while (iter != active_server_connections_.end()) {
+     SMConnection *conn = *iter;
+     int elapsed_time = (cur_time - conn->last_read_time_);
+     if (elapsed_time > g_proxy_config.idle_timeout_s_) {
+       conn->Cleanup("Connection idle timeout reached.");
+       iter = active_server_connections_.erase(iter);
+       continue;
+     }
+     if (conn->last_read_time_ < oldest_time)
+       oldest_time = conn->last_read_time_;
+     iter++;
+   }
+   if ((cur_time - oldest_time) >= g_proxy_config.idle_timeout_s_)
+     oldest_time = cur_time;
+ }
+
   void Run() {
     while (!quitting_.HasBeenNotified()) {
       epoll_server_.set_timeout_in_us(10 * 1000);  // 10 ms
       epoll_server_.WaitForEventsAndExecuteCallbacks();
       unused_server_connections_.insert(unused_server_connections_.end(),
                                         tmp_unused_server_connections_.begin(),
                                         tmp_unused_server_connections_.end());
       tmp_unused_server_connections_.clear();
+      HandleConnectionIdleTimeout();
     }
   }
 
   // SMConnections will use this:
   virtual void SMConnectionDone(SMConnection* sc) {
     VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Done with connection.";
     tmp_unused_server_connections_.push_back(sc);
   }
 };
 
@@ skipping 60 matching lines @@
 }
 
 const char* BoolToStr(bool b) {
   if (b)
     return "true";
   return "false";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+static bool wantExit = false;
+static bool wantLogClose = false;
+void SignalHandler(int signum)
+{
+  switch(signum) {
+    case SIGTERM:
+    case SIGINT:
+      wantExit = true;
+      break;
+    case SIGHUP:
+      wantLogClose = true;
+      break;
+  }
+}
+
+static int OpenPidFile(const char *pidfile)
+{
+  int fd;
+  struct stat pid_stat;
+  int ret;
+
+  fd = open(pidfile, O_RDWR | O_CREAT, 0600);
+  if (fd == -1) {
+      cerr << "Could not open pid file '" << pidfile << "' for reading.\n";
+      exit(1);
+  }
+
+  ret = flock(fd, LOCK_EX | LOCK_NB);
+  if (ret == -1) {
+    if (errno == EWOULDBLOCK) {
+      cerr << "Flip server is already running.\n";
+    } else {
+      cerr << "Error getting lock on pid file: " << strerror(errno) << "\n";
+    }
+    exit(1);
+  }
+
+  if (fstat(fd, &pid_stat) == -1) {
+    cerr << "Could not stat pid file '" << pidfile << "': " << strerror(errno)
+         << "\n";
+  }
+  if (pid_stat.st_size != 0) {
+    if (ftruncate(fd, pid_stat.st_size) == -1) {
+      cerr << "Could not truncate pid file '" << pidfile << "': "
+           << strerror(errno) << "\n";
+    }
+  }
+
+  char pid_str[8];
+  snprintf(pid_str, sizeof(pid_str), "%d", getpid());
+  int bytes = static_cast<int>(strlen(pid_str));
+  if (write(fd, pid_str, strlen(pid_str)) != bytes) {
+    cerr << "Could not write pid file: " << strerror(errno) << "\n";
+    close(fd);
+    exit(1);
+  }
+
+  return fd;
+}
+
 int main (int argc, char**argv)
 {
   unsigned int i = 0;
   bool wait_for_iface = false;
+  int pidfile_fd;
 
   signal(SIGPIPE, SIG_IGN);
+  signal(SIGTERM, SignalHandler);
+  signal(SIGINT, SignalHandler);
+  signal(SIGHUP, SignalHandler);
 
   CommandLine::Init(argc, argv);
   CommandLine cl(argc, argv);
 
   if (cl.HasSwitch("help") || argc < 2) {
     cout << argv[0] << " <options>\n";
     cout << "  Proxy options:\n";
     cout << "\t--proxy<1..n>=\"<listen ip>,<listen port>,"
          << "<ssl cert filename>,\n"
          << "\t               <ssl key filename>,<http server ip>,"
          << "<http server port>,\n"
          << "\t               [https server ip],[https server port],"
          << "<spdy only 0|1>\"\n";
     cout << "\t  * The https server ip and port may be left empty if they are"
          << " the same as\n"
          << "\t    the http server fields.\n";
     cout << "\t  * spdy only prevents non-spdy https connections from being"
          << " passed\n"
          << "\t    through the proxy listen ip:port.\n";
     cout << "\t--forward-ip-header=<header name>\n";
     cout << "\n  Server options:\n";
-    cout << "\t--spdy-server=\"<listen ip>,<listen port>,[ssl cert filename],\n"
-         << "\t               [ssl key filename]\"\n";
-    cout << "\t--http-server=\"<listen ip>,<listen port>,[ssl cert filename],\n"
-         << "\t               [ssl key filename]\"\n";
+    cout << "\t--spdy-server=\"<listen ip>,<listen port>,[ssl cert filename],"
+         << "\n\t               [ssl key filename]\"\n";
+    cout << "\t--http-server=\"<listen ip>,<listen port>,[ssl cert filename],"
+         << "\n\t               [ssl key filename]\"\n";
     cout << "\t  * Leaving the ssl cert and key fields empty will disable ssl"
          << " for the\n"
          << "\t    http and spdy flip servers\n";
     cout << "\n  Global options:\n";
     cout << "\t--logdest=<file|system|both>\n";
     cout << "\t--logfile=<logfile>\n";
     cout << "\t--wait-for-iface\n";
     cout << "\t  * The flip server will block until the listen ip has been"
          << " raised.\n";
     cout << "\t--ssl-session-expiry=<seconds> (default is 300)\n";
     cout << "\t--ssl-disable-compression\n";
+    cout << "\t--idle-timeout=<seconds> (default is 300)\n";
+    cout << "\t--pidfile=<filepath> (default /var/run/flip-server.pid)\n";
     cout << "\t--help\n";
     exit(0);
   }
 
+  if (cl.HasSwitch("pidfile")) {
+    pidfile_fd = OpenPidFile(cl.GetSwitchValueASCII("pidfile").c_str());
+  } else {
+    pidfile_fd = OpenPidFile(PIDFILE);
+  }
+
   g_proxy_config.server_think_time_in_s_ = FLAGS_server_think_time_in_s;
 
   if (cl.HasSwitch("forward-ip-header")) {
     g_proxy_config.forward_ip_header_enabled_ = true;
     g_proxy_config.forward_ip_header_ =
       cl.GetSwitchValueASCII("forward-ip-header");
   } else {
     g_proxy_config.forward_ip_header_enabled_ = false;
   }
 
@@ skipping 23 matching lines @@
              logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG) {
     LOG(FATAL) << "Logging destination requires a log file to be specified.";
   }
 
   if (cl.HasSwitch("wait-for-iface")) {
     wait_for_iface = true;
   }
 
   if (cl.HasSwitch("ssl-session-expiry")) {
     string session_expiry = cl.GetSwitchValueASCII("ssl-session-expiry");
-    g_proxy_config.ssl_session_expiry_ = atoi( session_expiry.c_str() );
+    g_proxy_config.ssl_session_expiry_ = atoi(session_expiry.c_str());
   }
 
   if (cl.HasSwitch("ssl-disable-compression")) {
     g_proxy_config.ssl_disable_compression_ = true;
   }
 
+  if (cl.HasSwitch("idle-timeout")) {
+    g_proxy_config.idle_timeout_s_ =
+      atoi(cl.GetSwitchValueASCII("idle-timeout").c_str());
+  }
+
   if (cl.HasSwitch("force_spdy"))
     FLAGS_force_spdy = true;
 
   InitLogging(g_proxy_config.log_filename_.c_str(),
               g_proxy_config.log_destination_,
               logging::DONT_LOCK_LOG_FILE,
               logging::APPEND_TO_OLD_LOG_FILE,
               logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
 
   LOG(INFO) << "Flip SPDY proxy started with configuration:";
   LOG(INFO) << "Logging destination     : " << g_proxy_config.log_destination_;
   LOG(INFO) << "Log file                : " << g_proxy_config.log_filename_;
   LOG(INFO) << "Forward IP Header       : "
             << (g_proxy_config.forward_ip_header_enabled_ ?
                 g_proxy_config.forward_ip_header_ : "(disabled)");
   LOG(INFO) << "Wait for interfaces     : " << (wait_for_iface?"true":"false");
   LOG(INFO) << "Accept backlog size     : " << FLAGS_accept_backlog_size;
   LOG(INFO) << "Accepts per wake        : " << FLAGS_accepts_per_wake;
   LOG(INFO) << "Disable nagle           : "
             << (FLAGS_disable_nagle?"true":"false");
-  LOG(INFO) << "Reuseport               : " << (FLAGS_reuseport?"true":"false");
+  LOG(INFO) << "Reuseport               : "
+            << (FLAGS_reuseport?"true":"false");
   LOG(INFO) << "Force SPDY              : "
             << (FLAGS_force_spdy?"true":"false");
   LOG(INFO) << "SSL session expiry      : "
             << g_proxy_config.ssl_session_expiry_;
   LOG(INFO) << "SSL disable compression : "
             << g_proxy_config.ssl_disable_compression_;
+  LOG(INFO) << "Connection idle timeout : " << g_proxy_config.idle_timeout_s_;
 
   // Proxy Acceptors
   while (true) {
     i += 1;
     std::stringstream name;
     name << "proxy" << i;
     if (!cl.HasSwitch(name.str())) {
       break;
     }
     string value = cl.GetSwitchValueASCII(name.str());
@@ skipping 66 matching lines @@
     // we either must make the MemoryCache threadsafe, or use
     // a separate MemoryCache for each thread.
     //
     // The latter is what is currently being done as we spawn
     // a separate thread for each http and spdy server acceptor.
 
     sm_worker_threads_.back()->InitWorker();
     sm_worker_threads_.back()->Start();
   }
 
-  while (true) {
+  while (!wantExit) {
+    // Close logfile when HUP signal is received. Logging system will
+    // automatically reopen on next log message.
+    if ( wantLogClose ) {
+      wantLogClose = false;
+      VLOG(1) << "HUP received, reopening log file.";
+      logging::CloseLogFile();
+    }
     if (GotQuitFromStdin()) {
       for (unsigned int i = 0; i < sm_worker_threads_.size(); ++i) {
         sm_worker_threads_[i]->Quit();
       }
       for (unsigned int i = 0; i < sm_worker_threads_.size(); ++i) {
         sm_worker_threads_[i]->Join();
       }
-      return 0;
+      break;
     }
     usleep(1000*10);  // 10 ms
   }
 
+  unlink(PIDFILE);
+  close(pidfile_fd);
   return 0;
 }