net/tools/flip_server/http_interface.cc

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