OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/server/http_server.h" | 5 #include "net/server/http_server.h" |
6 | 6 |
7 #include "base/compiler_specific.h" | 7 #include "base/compiler_specific.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "base/stl_util.h" | 9 #include "base/stl_util.h" |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
11 #include "base/strings/string_util.h" | 11 #include "base/strings/string_util.h" |
12 #include "base/strings/stringprintf.h" | 12 #include "base/strings/stringprintf.h" |
13 #include "base/sys_byteorder.h" | 13 #include "base/sys_byteorder.h" |
14 #include "build/build_config.h" | 14 #include "build/build_config.h" |
15 #include "net/base/net_errors.h" | 15 #include "net/base/net_errors.h" |
16 #include "net/server/http_connection.h" | 16 #include "net/server/http_connection.h" |
17 #include "net/server/http_server_request_info.h" | 17 #include "net/server/http_server_request_info.h" |
18 #include "net/server/http_server_response_info.h" | 18 #include "net/server/http_server_response_info.h" |
19 #include "net/server/web_socket.h" | 19 #include "net/server/web_socket.h" |
20 #include "net/socket/tcp_listen_socket.h" | 20 #include "net/socket/server_socket.h" |
| 21 #include "net/socket/stream_socket.h" |
| 22 #include "net/socket/tcp_server_socket.h" |
21 | 23 |
22 namespace net { | 24 namespace net { |
23 | 25 |
24 HttpServer::HttpServer(const StreamListenSocketFactory& factory, | 26 HttpServer::HttpServer(scoped_ptr<ServerSocket> server_socket, |
25 HttpServer::Delegate* delegate) | 27 HttpServer::Delegate* delegate) |
26 : delegate_(delegate), | 28 : server_socket_(server_socket.Pass()), |
27 server_(factory.CreateAndListen(this)) { | 29 delegate_(delegate), |
| 30 last_id_(0), |
| 31 weak_ptr_factory_(this) { |
| 32 DCHECK(server_socket_); |
| 33 DoAcceptLoop(); |
| 34 } |
| 35 |
| 36 HttpServer::~HttpServer() { |
| 37 STLDeleteContainerPairSecondPointers( |
| 38 id_to_connection_.begin(), id_to_connection_.end()); |
28 } | 39 } |
29 | 40 |
30 void HttpServer::AcceptWebSocket( | 41 void HttpServer::AcceptWebSocket( |
31 int connection_id, | 42 int connection_id, |
32 const HttpServerRequestInfo& request) { | 43 const HttpServerRequestInfo& request) { |
33 HttpConnection* connection = FindConnection(connection_id); | 44 HttpConnection* connection = FindConnection(connection_id); |
34 if (connection == NULL) | 45 if (connection == NULL) |
35 return; | 46 return; |
36 | 47 DCHECK(connection->web_socket()); |
37 DCHECK(connection->web_socket_.get()); | 48 connection->web_socket()->Accept(request); |
38 connection->web_socket_->Accept(request); | |
39 } | 49 } |
40 | 50 |
41 void HttpServer::SendOverWebSocket(int connection_id, | 51 void HttpServer::SendOverWebSocket(int connection_id, |
42 const std::string& data) { | 52 const std::string& data) { |
43 HttpConnection* connection = FindConnection(connection_id); | 53 HttpConnection* connection = FindConnection(connection_id); |
44 if (connection == NULL) | 54 if (connection == NULL) |
45 return; | 55 return; |
46 DCHECK(connection->web_socket_.get()); | 56 DCHECK(connection->web_socket()); |
47 connection->web_socket_->Send(data); | 57 connection->web_socket()->Send(data); |
48 } | 58 } |
49 | 59 |
50 void HttpServer::SendRaw(int connection_id, const std::string& data) { | 60 void HttpServer::SendRaw(int connection_id, const std::string& data) { |
51 HttpConnection* connection = FindConnection(connection_id); | 61 HttpConnection* connection = FindConnection(connection_id); |
52 if (connection == NULL) | 62 if (connection == NULL) |
53 return; | 63 return; |
54 connection->Send(data); | 64 |
| 65 bool writing_in_progress = !connection->write_buf()->IsEmpty(); |
| 66 if (connection->write_buf()->Append(data) && !writing_in_progress) |
| 67 DoWriteLoop(connection); |
55 } | 68 } |
56 | 69 |
57 void HttpServer::SendResponse(int connection_id, | 70 void HttpServer::SendResponse(int connection_id, |
58 const HttpServerResponseInfo& response) { | 71 const HttpServerResponseInfo& response) { |
59 HttpConnection* connection = FindConnection(connection_id); | 72 SendRaw(connection_id, response.Serialize()); |
60 if (connection == NULL) | |
61 return; | |
62 connection->Send(response); | |
63 } | 73 } |
64 | 74 |
65 void HttpServer::Send(int connection_id, | 75 void HttpServer::Send(int connection_id, |
66 HttpStatusCode status_code, | 76 HttpStatusCode status_code, |
67 const std::string& data, | 77 const std::string& data, |
68 const std::string& content_type) { | 78 const std::string& content_type) { |
69 HttpServerResponseInfo response(status_code); | 79 HttpServerResponseInfo response(status_code); |
70 response.SetBody(data, content_type); | 80 response.SetContentHeaders(data.size(), content_type); |
71 SendResponse(connection_id, response); | 81 SendResponse(connection_id, response); |
| 82 SendRaw(connection_id, data); |
72 } | 83 } |
73 | 84 |
74 void HttpServer::Send200(int connection_id, | 85 void HttpServer::Send200(int connection_id, |
75 const std::string& data, | 86 const std::string& data, |
76 const std::string& content_type) { | 87 const std::string& content_type) { |
77 Send(connection_id, HTTP_OK, data, content_type); | 88 Send(connection_id, HTTP_OK, data, content_type); |
78 } | 89 } |
79 | 90 |
80 void HttpServer::Send404(int connection_id) { | 91 void HttpServer::Send404(int connection_id) { |
81 SendResponse(connection_id, HttpServerResponseInfo::CreateFor404()); | 92 SendResponse(connection_id, HttpServerResponseInfo::CreateFor404()); |
82 } | 93 } |
83 | 94 |
84 void HttpServer::Send500(int connection_id, const std::string& message) { | 95 void HttpServer::Send500(int connection_id, const std::string& message) { |
85 SendResponse(connection_id, HttpServerResponseInfo::CreateFor500(message)); | 96 SendResponse(connection_id, HttpServerResponseInfo::CreateFor500(message)); |
86 } | 97 } |
87 | 98 |
88 void HttpServer::Close(int connection_id) { | 99 void HttpServer::Close(int connection_id) { |
89 HttpConnection* connection = FindConnection(connection_id); | 100 HttpConnection* connection = FindConnection(connection_id); |
90 if (connection == NULL) | 101 if (connection == NULL) |
91 return; | 102 return; |
92 | 103 |
93 // Initiating close from server-side does not lead to the DidClose call. | 104 id_to_connection_.erase(connection_id); |
94 // Do it manually here. | 105 delegate_->OnClose(connection_id); |
95 DidClose(connection->socket_.get()); | 106 |
| 107 // The call stack might have callbacks which still have the pointer of |
| 108 // connection. Instead of referencing connection with ID all the time, |
| 109 // destroys the connection in next run loop to make sure any pending |
| 110 // callbacks in the call stack return. |
| 111 base::MessageLoopProxy::current()->DeleteSoon(FROM_HERE, connection); |
96 } | 112 } |
97 | 113 |
98 int HttpServer::GetLocalAddress(IPEndPoint* address) { | 114 int HttpServer::GetLocalAddress(IPEndPoint* address) { |
99 if (!server_) | 115 return server_socket_->GetLocalAddress(address); |
100 return ERR_SOCKET_NOT_CONNECTED; | 116 } |
101 return server_->GetLocalAddress(address); | 117 |
102 } | 118 void HttpServer::SetReceiveBufferSize(int connection_id, int32 size) { |
103 | 119 HttpConnection* connection = FindConnection(connection_id); |
104 void HttpServer::DidAccept(StreamListenSocket* server, | 120 DCHECK(connection); |
105 scoped_ptr<StreamListenSocket> socket) { | 121 connection->read_buf()->set_max_buffer_size(size); |
106 HttpConnection* connection = new HttpConnection(this, socket.Pass()); | 122 } |
| 123 |
| 124 void HttpServer::SetSendBufferSize(int connection_id, int32 size) { |
| 125 HttpConnection* connection = FindConnection(connection_id); |
| 126 DCHECK(connection); |
| 127 connection->write_buf()->set_max_buffer_size(size); |
| 128 } |
| 129 |
| 130 void HttpServer::DoAcceptLoop() { |
| 131 int rv; |
| 132 do { |
| 133 rv = server_socket_->Accept(&accepted_socket_, |
| 134 base::Bind(&HttpServer::OnAcceptCompleted, |
| 135 weak_ptr_factory_.GetWeakPtr())); |
| 136 if (rv == ERR_IO_PENDING) |
| 137 return; |
| 138 rv = HandleAcceptResult(rv); |
| 139 } while (rv == OK); |
| 140 } |
| 141 |
| 142 void HttpServer::OnAcceptCompleted(int rv) { |
| 143 if (HandleAcceptResult(rv) == OK) |
| 144 DoAcceptLoop(); |
| 145 } |
| 146 |
| 147 int HttpServer::HandleAcceptResult(int rv) { |
| 148 if (rv < 0) { |
| 149 LOG(ERROR) << "Accept error: rv=" << rv; |
| 150 return rv; |
| 151 } |
| 152 |
| 153 HttpConnection* connection = |
| 154 new HttpConnection(++last_id_, accepted_socket_.Pass()); |
107 id_to_connection_[connection->id()] = connection; | 155 id_to_connection_[connection->id()] = connection; |
108 // TODO(szym): Fix socket access. Make HttpConnection the Delegate. | 156 DoReadLoop(connection); |
109 socket_to_connection_[connection->socket_.get()] = connection; | 157 return OK; |
110 } | 158 } |
111 | 159 |
112 void HttpServer::DidRead(StreamListenSocket* socket, | 160 void HttpServer::DoReadLoop(HttpConnection* connection) { |
113 const char* data, | 161 int rv; |
114 int len) { | 162 do { |
115 HttpConnection* connection = FindConnection(socket); | 163 HttpConnection::ReadIOBuffer* read_buf = connection->read_buf(); |
116 DCHECK(connection != NULL); | 164 // Increases read buffer size if necessary. |
117 if (connection == NULL) | 165 if (read_buf->RemainingCapacity() == 0 && !read_buf->IncreaseCapacity()) { |
| 166 Close(connection->id()); |
| 167 return; |
| 168 } |
| 169 |
| 170 rv = connection->socket()->Read( |
| 171 read_buf, |
| 172 read_buf->RemainingCapacity(), |
| 173 base::Bind(&HttpServer::OnReadCompleted, |
| 174 weak_ptr_factory_.GetWeakPtr(), connection->id())); |
| 175 if (rv == ERR_IO_PENDING) |
| 176 return; |
| 177 rv = HandleReadResult(connection, rv); |
| 178 } while (rv == OK); |
| 179 } |
| 180 |
| 181 void HttpServer::OnReadCompleted(int connection_id, int rv) { |
| 182 HttpConnection* connection = FindConnection(connection_id); |
| 183 if (!connection) // It might be closed right before by write error. |
118 return; | 184 return; |
119 | 185 |
120 connection->recv_data_.append(data, len); | 186 if (HandleReadResult(connection, rv) == OK) |
121 while (connection->recv_data_.length()) { | 187 DoReadLoop(connection); |
122 if (connection->web_socket_.get()) { | 188 } |
| 189 |
| 190 int HttpServer::HandleReadResult(HttpConnection* connection, int rv) { |
| 191 if (rv <= 0) { |
| 192 Close(connection->id()); |
| 193 return rv == 0 ? ERR_CONNECTION_CLOSED : rv; |
| 194 } |
| 195 |
| 196 HttpConnection::ReadIOBuffer* read_buf = connection->read_buf(); |
| 197 read_buf->DidRead(rv); |
| 198 |
| 199 // Handles http requests or websocket messages. |
| 200 while (read_buf->GetSize() > 0) { |
| 201 if (connection->web_socket()) { |
123 std::string message; | 202 std::string message; |
124 WebSocket::ParseResult result = connection->web_socket_->Read(&message); | 203 WebSocket::ParseResult result = connection->web_socket()->Read(&message); |
125 if (result == WebSocket::FRAME_INCOMPLETE) | 204 if (result == WebSocket::FRAME_INCOMPLETE) |
126 break; | 205 break; |
127 | 206 |
128 if (result == WebSocket::FRAME_CLOSE || | 207 if (result == WebSocket::FRAME_CLOSE || |
129 result == WebSocket::FRAME_ERROR) { | 208 result == WebSocket::FRAME_ERROR) { |
130 Close(connection->id()); | 209 Close(connection->id()); |
131 break; | 210 return ERR_CONNECTION_CLOSED; |
132 } | 211 } |
133 delegate_->OnWebSocketMessage(connection->id(), message); | 212 delegate_->OnWebSocketMessage(connection->id(), message); |
| 213 if (HasClosedConnection(connection)) |
| 214 return ERR_CONNECTION_CLOSED; |
134 continue; | 215 continue; |
135 } | 216 } |
136 | 217 |
137 HttpServerRequestInfo request; | 218 HttpServerRequestInfo request; |
138 size_t pos = 0; | 219 size_t pos = 0; |
139 if (!ParseHeaders(connection, &request, &pos)) | 220 if (!ParseHeaders(read_buf->StartOfBuffer(), read_buf->GetSize(), |
| 221 &request, &pos)) { |
140 break; | 222 break; |
| 223 } |
141 | 224 |
142 // Sets peer address if exists. | 225 // Sets peer address if exists. |
143 socket->GetPeerAddress(&request.peer); | 226 connection->socket()->GetPeerAddress(&request.peer); |
144 | 227 |
145 if (request.HasHeaderValue("connection", "upgrade")) { | 228 if (request.HasHeaderValue("connection", "upgrade")) { |
146 connection->web_socket_.reset(WebSocket::CreateWebSocket(connection, | 229 scoped_ptr<WebSocket> websocket( |
147 request, | 230 WebSocket::CreateWebSocket(this, connection, request, &pos)); |
148 &pos)); | 231 if (!websocket) // Not enough data was received. |
149 | |
150 if (!connection->web_socket_.get()) // Not enough data was received. | |
151 break; | 232 break; |
| 233 connection->SetWebSocket(websocket.Pass()); |
| 234 read_buf->DidConsume(pos); |
152 delegate_->OnWebSocketRequest(connection->id(), request); | 235 delegate_->OnWebSocketRequest(connection->id(), request); |
153 connection->Shift(pos); | 236 if (HasClosedConnection(connection)) |
| 237 return ERR_CONNECTION_CLOSED; |
154 continue; | 238 continue; |
155 } | 239 } |
156 | 240 |
157 const char kContentLength[] = "content-length"; | 241 const char kContentLength[] = "content-length"; |
158 if (request.headers.count(kContentLength)) { | 242 if (request.headers.count(kContentLength) > 0) { |
159 size_t content_length = 0; | 243 size_t content_length = 0; |
160 const size_t kMaxBodySize = 100 << 20; | 244 const size_t kMaxBodySize = 100 << 20; |
161 if (!base::StringToSizeT(request.GetHeaderValue(kContentLength), | 245 if (!base::StringToSizeT(request.GetHeaderValue(kContentLength), |
162 &content_length) || | 246 &content_length) || |
163 content_length > kMaxBodySize) { | 247 content_length > kMaxBodySize) { |
164 connection->Send(HttpServerResponseInfo::CreateFor500( | 248 SendResponse(connection->id(), |
165 "request content-length too big or unknown: " + | 249 HttpServerResponseInfo::CreateFor500( |
166 request.GetHeaderValue(kContentLength))); | 250 "request content-length too big or unknown: " + |
167 DidClose(socket); | 251 request.GetHeaderValue(kContentLength))); |
168 break; | 252 Close(connection->id()); |
| 253 return ERR_CONNECTION_CLOSED; |
169 } | 254 } |
170 | 255 |
171 if (connection->recv_data_.length() - pos < content_length) | 256 if (read_buf->GetSize() - pos < content_length) |
172 break; // Not enough data was received yet. | 257 break; // Not enough data was received yet. |
173 request.data = connection->recv_data_.substr(pos, content_length); | 258 request.data.assign(read_buf->StartOfBuffer() + pos, content_length); |
174 pos += content_length; | 259 pos += content_length; |
175 } | 260 } |
176 | 261 |
| 262 read_buf->DidConsume(pos); |
177 delegate_->OnHttpRequest(connection->id(), request); | 263 delegate_->OnHttpRequest(connection->id(), request); |
178 connection->Shift(pos); | 264 if (HasClosedConnection(connection)) |
179 } | 265 return ERR_CONNECTION_CLOSED; |
180 } | 266 } |
181 | 267 |
182 void HttpServer::DidClose(StreamListenSocket* socket) { | 268 return OK; |
183 HttpConnection* connection = FindConnection(socket); | 269 } |
184 DCHECK(connection != NULL); | 270 |
185 id_to_connection_.erase(connection->id()); | 271 void HttpServer::DoWriteLoop(HttpConnection* connection) { |
186 socket_to_connection_.erase(connection->socket_.get()); | 272 int rv = OK; |
187 delete connection; | 273 HttpConnection::QueuedWriteIOBuffer* write_buf = connection->write_buf(); |
188 } | 274 while (rv == OK && write_buf->GetSizeToWrite() > 0) { |
189 | 275 rv = connection->socket()->Write( |
190 HttpServer::~HttpServer() { | 276 write_buf, |
191 STLDeleteContainerPairSecondPointers( | 277 write_buf->GetSizeToWrite(), |
192 id_to_connection_.begin(), id_to_connection_.end()); | 278 base::Bind(&HttpServer::OnWriteCompleted, |
193 } | 279 weak_ptr_factory_.GetWeakPtr(), connection->id())); |
| 280 if (rv == ERR_IO_PENDING || rv == OK) |
| 281 return; |
| 282 rv = HandleWriteResult(connection, rv); |
| 283 } |
| 284 } |
| 285 |
| 286 void HttpServer::OnWriteCompleted(int connection_id, int rv) { |
| 287 HttpConnection* connection = FindConnection(connection_id); |
| 288 if (!connection) // It might be closed right before by read error. |
| 289 return; |
| 290 |
| 291 if (HandleWriteResult(connection, rv) == OK) |
| 292 DoWriteLoop(connection); |
| 293 } |
| 294 |
| 295 int HttpServer::HandleWriteResult(HttpConnection* connection, int rv) { |
| 296 if (rv < 0) { |
| 297 Close(connection->id()); |
| 298 return rv; |
| 299 } |
| 300 |
| 301 connection->write_buf()->DidConsume(rv); |
| 302 return OK; |
| 303 } |
| 304 |
| 305 namespace { |
194 | 306 |
195 // | 307 // |
196 // HTTP Request Parser | 308 // HTTP Request Parser |
197 // This HTTP request parser uses a simple state machine to quickly parse | 309 // This HTTP request parser uses a simple state machine to quickly parse |
198 // through the headers. The parser is not 100% complete, as it is designed | 310 // through the headers. The parser is not 100% complete, as it is designed |
199 // for use in this simple test driver. | 311 // for use in this simple test driver. |
200 // | 312 // |
201 // Known issues: | 313 // Known issues: |
202 // - does not handle whitespace on first HTTP line correctly. Expects | 314 // - does not handle whitespace on first HTTP line correctly. Expects |
203 // a single space between the method/url and url/protocol. | 315 // a single space between the method/url and url/protocol. |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
248 case '\r': | 360 case '\r': |
249 return INPUT_CR; | 361 return INPUT_CR; |
250 case '\n': | 362 case '\n': |
251 return INPUT_LF; | 363 return INPUT_LF; |
252 case ':': | 364 case ':': |
253 return INPUT_COLON; | 365 return INPUT_COLON; |
254 } | 366 } |
255 return INPUT_DEFAULT; | 367 return INPUT_DEFAULT; |
256 } | 368 } |
257 | 369 |
258 bool HttpServer::ParseHeaders(HttpConnection* connection, | 370 } // namespace |
| 371 |
| 372 bool HttpServer::ParseHeaders(const char* data, |
| 373 size_t data_len, |
259 HttpServerRequestInfo* info, | 374 HttpServerRequestInfo* info, |
260 size_t* ppos) { | 375 size_t* ppos) { |
261 size_t& pos = *ppos; | 376 size_t& pos = *ppos; |
262 size_t data_len = connection->recv_data_.length(); | |
263 int state = ST_METHOD; | 377 int state = ST_METHOD; |
264 std::string buffer; | 378 std::string buffer; |
265 std::string header_name; | 379 std::string header_name; |
266 std::string header_value; | 380 std::string header_value; |
267 while (pos < data_len) { | 381 while (pos < data_len) { |
268 char ch = connection->recv_data_[pos++]; | 382 char ch = data[pos++]; |
269 int input = charToInput(ch); | 383 int input = charToInput(ch); |
270 int next_state = parser_state[state][input]; | 384 int next_state = parser_state[state][input]; |
271 | 385 |
272 bool transition = (next_state != state); | 386 bool transition = (next_state != state); |
273 HttpServerRequestInfo::HeadersMap::iterator it; | 387 HttpServerRequestInfo::HeadersMap::iterator it; |
274 if (transition) { | 388 if (transition) { |
275 // Do any actions based on state transitions. | 389 // Do any actions based on state transitions. |
276 switch (state) { | 390 switch (state) { |
277 case ST_METHOD: | 391 case ST_METHOD: |
278 info->method = buffer; | 392 info->method = buffer; |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
330 return false; | 444 return false; |
331 } | 445 } |
332 | 446 |
333 HttpConnection* HttpServer::FindConnection(int connection_id) { | 447 HttpConnection* HttpServer::FindConnection(int connection_id) { |
334 IdToConnectionMap::iterator it = id_to_connection_.find(connection_id); | 448 IdToConnectionMap::iterator it = id_to_connection_.find(connection_id); |
335 if (it == id_to_connection_.end()) | 449 if (it == id_to_connection_.end()) |
336 return NULL; | 450 return NULL; |
337 return it->second; | 451 return it->second; |
338 } | 452 } |
339 | 453 |
340 HttpConnection* HttpServer::FindConnection(StreamListenSocket* socket) { | 454 // This is called after any delegate callbacks are called to check if Close() |
341 SocketToConnectionMap::iterator it = socket_to_connection_.find(socket); | 455 // has been called during callback processing. Using the pointer of connection, |
342 if (it == socket_to_connection_.end()) | 456 // |connection| is safe here because Close() deletes the connection in next run |
343 return NULL; | 457 // loop. |
344 return it->second; | 458 bool HttpServer::HasClosedConnection(HttpConnection* connection) { |
| 459 return FindConnection(connection->id()) != connection; |
345 } | 460 } |
346 | 461 |
347 } // namespace net | 462 } // namespace net |
OLD | NEW |