| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/acceptor_thread.h" | |
| 6 | |
| 7 #include <errno.h> | |
| 8 #include <netinet/in.h> | |
| 9 #include <netinet/tcp.h> // For TCP_NODELAY | |
| 10 #include <sys/socket.h> | |
| 11 #include <sys/types.h> | |
| 12 | |
| 13 #include <string> | |
| 14 | |
| 15 #include "net/tools/flip_server/constants.h" | |
| 16 #include "net/tools/flip_server/flip_config.h" | |
| 17 #include "net/tools/flip_server/sm_connection.h" | |
| 18 #include "net/tools/flip_server/spdy_ssl.h" | |
| 19 #include "openssl/err.h" | |
| 20 #include "openssl/ssl.h" | |
| 21 | |
| 22 namespace net { | |
| 23 | |
| 24 SMAcceptorThread::SMAcceptorThread(FlipAcceptor* acceptor, | |
| 25 MemoryCache* memory_cache) | |
| 26 : SimpleThread("SMAcceptorThread"), | |
| 27 acceptor_(acceptor), | |
| 28 ssl_state_(NULL), | |
| 29 use_ssl_(false), | |
| 30 idle_socket_timeout_s_(acceptor->idle_socket_timeout_s_), | |
| 31 quitting_(false), | |
| 32 memory_cache_(memory_cache) { | |
| 33 if (!acceptor->ssl_cert_filename_.empty() && | |
| 34 !acceptor->ssl_key_filename_.empty()) { | |
| 35 ssl_state_ = new SSLState; | |
| 36 bool use_npn = true; | |
| 37 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_HTTP_SERVER) { | |
| 38 use_npn = false; | |
| 39 } | |
| 40 InitSSL(ssl_state_, | |
| 41 acceptor_->ssl_cert_filename_, | |
| 42 acceptor_->ssl_key_filename_, | |
| 43 use_npn, | |
| 44 acceptor_->ssl_session_expiry_, | |
| 45 acceptor_->ssl_disable_compression_); | |
| 46 use_ssl_ = true; | |
| 47 } | |
| 48 } | |
| 49 | |
| 50 SMAcceptorThread::~SMAcceptorThread() { | |
| 51 for (std::vector<SMConnection*>::iterator i = | |
| 52 allocated_server_connections_.begin(); | |
| 53 i != allocated_server_connections_.end(); | |
| 54 ++i) { | |
| 55 delete *i; | |
| 56 } | |
| 57 delete ssl_state_; | |
| 58 } | |
| 59 | |
| 60 SMConnection* SMAcceptorThread::NewConnection() { | |
| 61 SMConnection* server = SMConnection::NewSMConnection( | |
| 62 &epoll_server_, ssl_state_, memory_cache_, acceptor_, "client_conn: "); | |
| 63 allocated_server_connections_.push_back(server); | |
| 64 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Acceptor: Making new server."; | |
| 65 return server; | |
| 66 } | |
| 67 | |
| 68 SMConnection* SMAcceptorThread::FindOrMakeNewSMConnection() { | |
| 69 if (unused_server_connections_.empty()) { | |
| 70 return NewConnection(); | |
| 71 } | |
| 72 SMConnection* server = unused_server_connections_.back(); | |
| 73 unused_server_connections_.pop_back(); | |
| 74 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Acceptor: Reusing server."; | |
| 75 return server; | |
| 76 } | |
| 77 | |
| 78 void SMAcceptorThread::InitWorker() { | |
| 79 epoll_server_.RegisterFD(acceptor_->listen_fd_, this, EPOLLIN | EPOLLET); | |
| 80 } | |
| 81 | |
| 82 void SMAcceptorThread::HandleConnection(int server_fd, | |
| 83 struct sockaddr_in* remote_addr) { | |
| 84 int on = 1; | |
| 85 int rc; | |
| 86 if (acceptor_->disable_nagle_) { | |
| 87 rc = setsockopt(server_fd, | |
| 88 IPPROTO_TCP, | |
| 89 TCP_NODELAY, | |
| 90 reinterpret_cast<char*>(&on), | |
| 91 sizeof(on)); | |
| 92 if (rc < 0) { | |
| 93 close(server_fd); | |
| 94 LOG(ERROR) << "setsockopt() failed fd=" << server_fd; | |
| 95 return; | |
| 96 } | |
| 97 } | |
| 98 | |
| 99 SMConnection* server_connection = FindOrMakeNewSMConnection(); | |
| 100 if (server_connection == NULL) { | |
| 101 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Acceptor: Closing fd " << server_fd; | |
| 102 close(server_fd); | |
| 103 return; | |
| 104 } | |
| 105 std::string remote_ip = inet_ntoa(remote_addr->sin_addr); | |
| 106 server_connection->InitSMConnection(this, | |
| 107 NULL, | |
| 108 &epoll_server_, | |
| 109 server_fd, | |
| 110 std::string(), | |
| 111 std::string(), | |
| 112 remote_ip, | |
| 113 use_ssl_); | |
| 114 if (server_connection->initialized()) | |
| 115 active_server_connections_.push_back(server_connection); | |
| 116 } | |
| 117 | |
| 118 void SMAcceptorThread::AcceptFromListenFD() { | |
| 119 if (acceptor_->accepts_per_wake_ > 0) { | |
| 120 for (int i = 0; i < acceptor_->accepts_per_wake_; ++i) { | |
| 121 struct sockaddr address; | |
| 122 socklen_t socklen = sizeof(address); | |
| 123 int fd = accept(acceptor_->listen_fd_, &address, &socklen); | |
| 124 if (fd == -1) { | |
| 125 if (errno != 11) { | |
| 126 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Acceptor: accept fail(" | |
| 127 << acceptor_->listen_fd_ << "): " << errno << ": " | |
| 128 << strerror(errno); | |
| 129 } | |
| 130 break; | |
| 131 } | |
| 132 VLOG(1) << ACCEPTOR_CLIENT_IDENT << " Accepted connection"; | |
| 133 HandleConnection(fd, (struct sockaddr_in*)&address); | |
| 134 } | |
| 135 } else { | |
| 136 while (true) { | |
| 137 struct sockaddr address; | |
| 138 socklen_t socklen = sizeof(address); | |
| 139 int fd = accept(acceptor_->listen_fd_, &address, &socklen); | |
| 140 if (fd == -1) { | |
| 141 if (errno != 11) { | |
| 142 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Acceptor: accept fail(" | |
| 143 << acceptor_->listen_fd_ << "): " << errno << ": " | |
| 144 << strerror(errno); | |
| 145 } | |
| 146 break; | |
| 147 } | |
| 148 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Accepted connection"; | |
| 149 HandleConnection(fd, (struct sockaddr_in*)&address); | |
| 150 } | |
| 151 } | |
| 152 } | |
| 153 | |
| 154 void SMAcceptorThread::HandleConnectionIdleTimeout() { | |
| 155 static time_t oldest_time = time(NULL); | |
| 156 | |
| 157 int cur_time = time(NULL); | |
| 158 // Only iterate the list if we speculate that a connection is ready to be | |
| 159 // expired | |
| 160 if ((cur_time - oldest_time) < idle_socket_timeout_s_) | |
| 161 return; | |
| 162 | |
| 163 // TODO(mbelshe): This code could be optimized, active_server_connections_ | |
| 164 // is already in-order. | |
| 165 std::list<SMConnection*>::iterator iter = active_server_connections_.begin(); | |
| 166 while (iter != active_server_connections_.end()) { | |
| 167 SMConnection* conn = *iter; | |
| 168 int elapsed_time = (cur_time - conn->last_read_time_); | |
| 169 if (elapsed_time > idle_socket_timeout_s_) { | |
| 170 conn->Cleanup("Connection idle timeout reached."); | |
| 171 iter = active_server_connections_.erase(iter); | |
| 172 continue; | |
| 173 } | |
| 174 if (conn->last_read_time_ < oldest_time) | |
| 175 oldest_time = conn->last_read_time_; | |
| 176 iter++; | |
| 177 } | |
| 178 if ((cur_time - oldest_time) >= idle_socket_timeout_s_) | |
| 179 oldest_time = cur_time; | |
| 180 } | |
| 181 | |
| 182 void SMAcceptorThread::Run() { | |
| 183 while (!quitting_.HasBeenNotified()) { | |
| 184 epoll_server_.set_timeout_in_us(10 * 1000); // 10 ms | |
| 185 epoll_server_.WaitForEventsAndExecuteCallbacks(); | |
| 186 if (tmp_unused_server_connections_.size()) { | |
| 187 VLOG(2) << "have " << tmp_unused_server_connections_.size() | |
| 188 << " additional unused connections. Total = " | |
| 189 << unused_server_connections_.size(); | |
| 190 unused_server_connections_.insert(unused_server_connections_.end(), | |
| 191 tmp_unused_server_connections_.begin(), | |
| 192 tmp_unused_server_connections_.end()); | |
| 193 tmp_unused_server_connections_.clear(); | |
| 194 } | |
| 195 HandleConnectionIdleTimeout(); | |
| 196 } | |
| 197 } | |
| 198 | |
| 199 void SMAcceptorThread::OnEvent(int fd, EpollEvent* event) { | |
| 200 if (event->in_events | EPOLLIN) { | |
| 201 VLOG(2) << ACCEPTOR_CLIENT_IDENT | |
| 202 << "Acceptor: Accepting based upon epoll events"; | |
| 203 AcceptFromListenFD(); | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 void SMAcceptorThread::SMConnectionDone(SMConnection* sc) { | |
| 208 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Done with connection."; | |
| 209 tmp_unused_server_connections_.push_back(sc); | |
| 210 } | |
| 211 | |
| 212 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master