1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/tools/flip_server/http_interface.h" 6 7 #include "net/tools/balsa/balsa_frame.h" 8 #include "net/tools/dump_cache/url_utilities.h" 9 #include "net/tools/flip_server/flip_config.h" 10 #include "net/tools/flip_server/sm_connection.h" 11 #include "net/tools/flip_server/spdy_util.h" 12 13 namespace net { 14 15 HttpSM::HttpSM(SMConnection* connection, 16 SMInterface* sm_spdy_interface, 17 MemoryCache* memory_cache, 18 FlipAcceptor* acceptor) 19 : http_framer_(new BalsaFrame), 20 stream_id_(0), 21 server_idx_(-1), 22 connection_(connection), 23 sm_spdy_interface_(sm_spdy_interface), 24 output_list_(connection->output_list()), 25 output_ordering_(connection), 26 memory_cache_(connection->memory_cache()), 27 acceptor_(acceptor) { 28 http_framer_->set_balsa_visitor(this); 29 http_framer_->set_balsa_headers(&headers_); 30 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY) 31 http_framer_->set_is_request(false); 32 } 33 HttpSM::~HttpSM() { 34 Reset(); 35 delete http_framer_; 36 } 37 38 void HttpSM::ProcessBodyData(const char* input, size_t size) { 39 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY) { 40 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Process Body Data: stream " 41 << stream_id_ << ": size " << size; 42 sm_spdy_interface_->SendDataFrame(stream_id_, input, size, 0, false); 43 } 44 } 45 46 void HttpSM::ProcessHeaders(const BalsaHeaders& headers) { 47 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_HTTP_SERVER) { 48 std::string host = 49 UrlUtilities::GetUrlHost(headers.GetHeader("Host").as_string()); 50 std::string method = headers.request_method().as_string(); 51 VLOG(1) << ACCEPTOR_CLIENT_IDENT 52 << "Received Request: " << headers.request_uri().as_string() << " " 53 << method; 54 std::string filename = 55 EncodeURL(headers.request_uri().as_string(), host, method); 56 NewStream(stream_id_, 0, filename); 57 stream_id_ += 2; 58 } else { 59 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Received Response from " 60 << connection_->server_ip_ << ":" << connection_->server_port_ 61 << " "; 62 sm_spdy_interface_->SendSynReply(stream_id_, headers); 63 } 64 } 65 66 void HttpSM::MessageDone() { 67 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY) { 68 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: MessageDone. Sending EOF: " 69 << "stream " << stream_id_; 70 sm_spdy_interface_->SendEOF(stream_id_); 71 } else { 72 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: MessageDone."; 73 } 74 } 75 76 void HttpSM::HandleHeaderError(BalsaFrame* framer) { HandleError(); } 77 78 void HttpSM::HandleChunkingError(BalsaFrame* framer) { HandleError(); } 79 80 void HttpSM::HandleBodyError(BalsaFrame* framer) { HandleError(); } 81 82 void HttpSM::HandleError() { 83 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "Error detected"; 84 } 85 86 void HttpSM::AddToOutputOrder(const MemCacheIter& mci) { 87 output_ordering_.AddToOutputOrder(mci); 88 } 89 90 void HttpSM::InitSMInterface(SMInterface* sm_spdy_interface, int32 server_idx) { 91 sm_spdy_interface_ = sm_spdy_interface; 92 server_idx_ = server_idx; 93 } 94 95 void HttpSM::InitSMConnection(SMConnectionPoolInterface* connection_pool, 96 SMInterface* sm_interface, 97 EpollServer* epoll_server, 98 int fd, 99 std::string server_ip, 100 std::string server_port, 101 std::string remote_ip, 102 bool use_ssl) { 103 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Initializing server " 104 << "connection."; 105 connection_->InitSMConnection(connection_pool, 106 sm_interface, 107 epoll_server, 108 fd, 109 server_ip, 110 server_port, 111 remote_ip, 112 use_ssl); 113 } 114 115 size_t HttpSM::ProcessReadInput(const char* data, size_t len) { 116 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Process read input: stream " 117 << stream_id_; 118 return http_framer_->ProcessInput(data, len); 119 } 120 121 size_t HttpSM::ProcessWriteInput(const char* data, size_t len) { 122 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Process write input: size " 123 << len << ": stream " << stream_id_; 124 char* dataPtr = new char[len]; 125 memcpy(dataPtr, data, len); 126 DataFrame* data_frame = new DataFrame; 127 data_frame->data = dataPtr; 128 data_frame->size = len; 129 data_frame->delete_when_done = true; 130 connection_->EnqueueDataFrame(data_frame); 131 return len; 132 } 133 134 bool HttpSM::MessageFullyRead() const { 135 return http_framer_->MessageFullyRead(); 136 } 137 138 void HttpSM::SetStreamID(uint32 stream_id) { stream_id_ = stream_id; } 139 140 bool HttpSM::Error() const { return http_framer_->Error(); } 141 142 const char* HttpSM::ErrorAsString() const { 143 return BalsaFrameEnums::ErrorCodeToString(http_framer_->ErrorCode()); 144 } 145 146 void HttpSM::Reset() { 147 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Reset: stream " << stream_id_; 148 http_framer_->Reset(); 149 } 150 151 void HttpSM::ResetForNewConnection() { 152 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY) { 153 VLOG(1) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Server connection closing " 154 << "to: " << connection_->server_ip_ << ":" 155 << connection_->server_port_ << " "; 156 } 157 // Message has not been fully read, either it is incomplete or the 158 // server is closing the connection to signal message end. 159 if (!MessageFullyRead()) { 160 VLOG(2) << "HTTP response closed before end of file detected. " 161 << "Sending EOF to spdy."; 162 sm_spdy_interface_->SendEOF(stream_id_); 163 } 164 output_ordering_.Reset(); 165 http_framer_->Reset(); 166 if (sm_spdy_interface_) { 167 sm_spdy_interface_->ResetForNewInterface(server_idx_); 168 } 169 } 170 171 void HttpSM::Cleanup() { 172 if (!(acceptor_->flip_handler_type_ == FLIP_HANDLER_HTTP_SERVER)) { 173 VLOG(2) << "HttpSM Request Fully Read; stream_id: " << stream_id_; 174 connection_->Cleanup("request complete"); 175 } 176 } 177 178 int HttpSM::PostAcceptHook() { return 1; } 179 180 void HttpSM::NewStream(uint32 stream_id, 181 uint32 priority, 182 const std::string& filename) { 183 MemCacheIter mci; 184 mci.stream_id = stream_id; 185 mci.priority = priority; 186 if (!memory_cache_->AssignFileData(filename, &mci)) { 187 // error creating new stream. 188 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Sending ErrorNotFound"; 189 SendErrorNotFound(stream_id); 190 } else { 191 AddToOutputOrder(mci); 192 } 193 } 194 195 void HttpSM::SendEOF(uint32 stream_id) { 196 SendEOFImpl(stream_id); 197 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_PROXY) { 198 sm_spdy_interface_->ResetForNewInterface(server_idx_); 199 } 200 } 201 202 void HttpSM::SendErrorNotFound(uint32 stream_id) { 203 SendErrorNotFoundImpl(stream_id); 204 } 205 206 size_t HttpSM::SendSynStream(uint32 stream_id, const BalsaHeaders& headers) { 207 return 0; 208 } 209 210 size_t HttpSM::SendSynReply(uint32 stream_id, const BalsaHeaders& headers) { 211 return SendSynReplyImpl(stream_id, headers); 212 } 213 214 void HttpSM::SendDataFrame(uint32 stream_id, 215 const char* data, 216 int64 len, 217 uint32 flags, 218 bool compress) { 219 SendDataFrameImpl(stream_id, data, len, flags, compress); 220 } 221 222 void HttpSM::SendEOFImpl(uint32 stream_id) { 223 DataFrame* df = new DataFrame; 224 df->data = "0\r\n\r\n"; 225 df->size = 5; 226 df->delete_when_done = false; 227 EnqueueDataFrame(df); 228 if (acceptor_->flip_handler_type_ == FLIP_HANDLER_HTTP_SERVER) { 229 Reset(); 230 } 231 } 232 233 void HttpSM::SendErrorNotFoundImpl(uint32 stream_id) { 234 BalsaHeaders my_headers; 235 my_headers.SetFirstlineFromStringPieces("HTTP/1.1", "404", "Not Found"); 236 my_headers.RemoveAllOfHeader("content-length"); 237 my_headers.AppendHeader("transfer-encoding", "chunked"); 238 SendSynReplyImpl(stream_id, my_headers); 239 SendDataFrame(stream_id, "page not found", 14, 0, false); 240 SendEOFImpl(stream_id); 241 output_ordering_.RemoveStreamId(stream_id); 242 } 243 244 size_t HttpSM::SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers) { 245 SimpleBuffer sb; 246 headers.WriteHeaderAndEndingToBuffer(&sb); 247 DataFrame* df = new DataFrame; 248 df->size = sb.ReadableBytes(); 249 char* buffer = new char[df->size]; 250 df->data = buffer; 251 df->delete_when_done = true; 252 sb.Read(buffer, df->size); 253 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Sending HTTP Reply header " 254 << stream_id_; 255 size_t df_size = df->size; 256 EnqueueDataFrame(df); 257 return df_size; 258 } 259 260 size_t HttpSM::SendSynStreamImpl(uint32 stream_id, 261 const BalsaHeaders& headers) { 262 SimpleBuffer sb; 263 headers.WriteHeaderAndEndingToBuffer(&sb); 264 DataFrame* df = new DataFrame; 265 df->size = sb.ReadableBytes(); 266 char* buffer = new char[df->size]; 267 df->data = buffer; 268 df->delete_when_done = true; 269 sb.Read(buffer, df->size); 270 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "Sending HTTP Reply header " 271 << stream_id_; 272 size_t df_size = df->size; 273 EnqueueDataFrame(df); 274 return df_size; 275 } 276 277 void HttpSM::SendDataFrameImpl(uint32 stream_id, 278 const char* data, 279 int64 len, 280 uint32 flags, 281 bool compress) { 282 char chunk_buf[128]; 283 snprintf(chunk_buf, sizeof(chunk_buf), "%x\r\n", (unsigned int)len); 284 std::string chunk_description(chunk_buf); 285 DataFrame* df = new DataFrame; 286 df->size = chunk_description.size() + len + 2; 287 char* buffer = new char[df->size]; 288 df->data = buffer; 289 df->delete_when_done = true; 290 memcpy(buffer, chunk_description.data(), chunk_description.size()); 291 memcpy(buffer + chunk_description.size(), data, len); 292 memcpy(buffer + chunk_description.size() + len, "\r\n", 2); 293 EnqueueDataFrame(df); 294 } 295 296 void HttpSM::EnqueueDataFrame(DataFrame* df) { 297 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: Enqueue data frame: stream " 298 << stream_id_; 299 connection_->EnqueueDataFrame(df); 300 } 301 302 void HttpSM::GetOutput() { 303 MemCacheIter* mci = output_ordering_.GetIter(); 304 if (mci == NULL) { 305 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: GetOutput: nothing to " 306 << "output!?: stream " << stream_id_; 307 return; 308 } 309 if (!mci->transformed_header) { 310 mci->bytes_sent = 311 SendSynReply(mci->stream_id, *(mci->file_data->headers())); 312 mci->transformed_header = true; 313 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: GetOutput transformed " 314 << "header stream_id: [" << mci->stream_id << "]"; 315 return; 316 } 317 if (mci->body_bytes_consumed >= mci->file_data->body().size()) { 318 SendEOF(mci->stream_id); 319 output_ordering_.RemoveStreamId(mci->stream_id); 320 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "GetOutput remove_stream_id: [" 321 << mci->stream_id << "]"; 322 return; 323 } 324 size_t num_to_write = 325 mci->file_data->body().size() - mci->body_bytes_consumed; 326 if (num_to_write > mci->max_segment_size) 327 num_to_write = mci->max_segment_size; 328 329 SendDataFrame(mci->stream_id, 330 mci->file_data->body().data() + mci->body_bytes_consumed, 331 num_to_write, 332 0, 333 true); 334 VLOG(2) << ACCEPTOR_CLIENT_IDENT << "HttpSM: GetOutput SendDataFrame[" 335 << mci->stream_id << "]: " << num_to_write; 336 mci->body_bytes_consumed += num_to_write; 337 mci->bytes_sent += num_to_write; 338 } 339 340 } // namespace net 341
