components/devtools_service/devtools_http_server.cc

   1 // Copyright 2015 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 "components/devtools_service/devtools_http_server.h"
   6
   7 #include <string.h>
   8
   9 #include <string>
  10
  11 #include "base/bind.h"
  12 #include "base/json/json_writer.h"
  13 #include "base/logging.h"
  14 #include "base/stl_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/values.h"
  17 #include "components/devtools_service/devtools_agent_host.h"
  18 #include "components/devtools_service/devtools_registry_impl.h"
  19 #include "components/devtools_service/devtools_service.h"
  20 #include "mojo/application/public/cpp/application_impl.h"
  21 #include "mojo/services/network/public/cpp/web_socket_read_queue.h"
  22 #include "mojo/services/network/public/cpp/web_socket_write_queue.h"
  23 #include "mojo/services/network/public/interfaces/net_address.mojom.h"
  24 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
  25 #include "mojo/services/network/public/interfaces/web_socket.mojom.h"
  26 #include "third_party/mojo/src/mojo/public/cpp/system/data_pipe.h"
  27
  28 namespace devtools_service {
  29
  30 namespace {
  31
  32 const char kPageUrlPrefix[] = "/devtools/page/";
  33 const char kBrowserUrlPrefix[] = "/devtools/browser";
  34 const char kJsonRequestUrlPrefix[] = "/json";
  35
  36 const char kActivateCommand[] = "activate";
  37 const char kCloseCommand[] = "close";
  38 const char kListCommand[] = "list";
  39 const char kNewCommand[] = "new";
  40 const char kVersionCommand[] = "version";
  41
  42 const char kTargetIdField[] = "id";
  43 const char kTargetTypeField[] = "type";
  44 const char kTargetTitleField[] = "title";
  45 const char kTargetDescriptionField[] = "description";
  46 const char kTargetUrlField[] = "url";
  47 const char kTargetWebSocketDebuggerUrlField[] = "webSocketDebuggerUrl";
  48 const char kTargetDevtoolsFrontendUrlField[] = "devtoolsFrontendUrl";
  49
  50 std::string GetHeaderValue(const mojo::HttpRequest& request,
  51                            const std::string& name) {
  52   for (size_t i = 0; i < request.headers.size(); ++i) {
  53     if (name == request.headers[i]->name)
  54       return request.headers[i]->value;
  55   }
  56
  57   return std::string();
  58 }
  59
  60 bool ParseJsonPath(const std::string& path,
  61                    std::string* command,
  62                    std::string* target_id) {
  63   // Fall back to list in case of empty query.
  64   if (path.empty()) {
  65     *command = kListCommand;
  66     return true;
  67   }
  68
  69   if (path.find("/") != 0) {
  70     // Malformed command.
  71     return false;
  72   }
  73   *command = path.substr(1);
  74
  75   size_t separator_pos = command->find("/");
  76   if (separator_pos != std::string::npos) {
  77     *target_id = command->substr(separator_pos + 1);
  78     *command = command->substr(0, separator_pos);
  79   }
  80   return true;
  81 }
  82
  83 mojo::HttpResponsePtr MakeResponse(uint32_t status_code,
  84                                    const std::string& content_type,
  85                                    const std::string& body) {
  86   mojo::HttpResponsePtr response(mojo::HttpResponse::New());
  87   response->headers.resize(2);
  88   response->headers[0] = mojo::HttpHeader::New();
  89   response->headers[0]->name = "Content-Length";
  90   response->headers[0]->value =
  91       base::StringPrintf("%lu", static_cast<unsigned long>(body.size()));
  92   response->headers[1] = mojo::HttpHeader::New();
  93   response->headers[1]->name = "Content-Type";
  94   response->headers[1]->value = content_type;
  95
  96   if (!body.empty()) {
  97     uint32_t num_bytes = static_cast<uint32_t>(body.size());
  98     MojoCreateDataPipeOptions options;
  99     options.struct_size = sizeof(MojoCreateDataPipeOptions);
 100     options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
 101     options.element_num_bytes = 1;
 102     options.capacity_num_bytes = num_bytes;
 103     mojo::DataPipe data_pipe(options);
 104     response->body = data_pipe.consumer_handle.Pass();
 105     MojoResult result =
 106         WriteDataRaw(data_pipe.producer_handle.get(), body.data(), &num_bytes,
 107                      MOJO_WRITE_DATA_FLAG_ALL_OR_NONE);
 108     CHECK_EQ(MOJO_RESULT_OK, result);
 109   }
 110   return response.Pass();
 111 }
 112
 113 mojo::HttpResponsePtr MakeJsonResponse(uint32_t status_code,
 114                                        base::Value* value,
 115                                        const std::string& message) {
 116   // Serialize value and message.
 117   std::string json_value;
 118   if (value) {
 119     base::JSONWriter::WriteWithOptions(
 120         *value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json_value);
 121   }
 122
 123   return MakeResponse(status_code, "application/json; charset=UTF-8",
 124                       json_value + message);
 125 }
 126
 127 class WebSocketRelayer : public DevToolsAgentHost::Delegate,
 128                          public mojo::WebSocketClient {
 129  public:
 130   // Creates a WebSocketRelayer instance and sets it as the delegate of
 131   // |agent_host|.
 132   //
 133   // The object destroys itself when either of the following happens:
 134   // - |agent_host| is dead and the object finishes all pending sends (if any)
 135   //   to the Web socket; or
 136   // - the underlying pipe of |web_socket| is closed and the object finishes all
 137   //   pending receives (if any) from the Web socket.
 138   static mojo::WebSocketClientPtr SetUp(
 139       DevToolsAgentHost* agent_host,
 140       mojo::WebSocketPtr web_socket,
 141       mojo::ScopedDataPipeProducerHandle send_stream) {
 142     DCHECK(agent_host);
 143     DCHECK(web_socket);
 144     DCHECK(send_stream.is_valid());
 145
 146     mojo::WebSocketClientPtr web_socket_client;
 147     new WebSocketRelayer(agent_host, web_socket.Pass(), send_stream.Pass(),
 148                          &web_socket_client);
 149     return web_socket_client.Pass();
 150   }
 151
 152  private:
 153   WebSocketRelayer(DevToolsAgentHost* agent_host,
 154                    mojo::WebSocketPtr web_socket,
 155                    mojo::ScopedDataPipeProducerHandle send_stream,
 156                    mojo::WebSocketClientPtr* web_socket_client)
 157       : agent_host_(agent_host),
 158         binding_(this, web_socket_client),
 159         web_socket_(web_socket.Pass()),
 160         send_stream_(send_stream.Pass()),
 161         write_send_stream_(new mojo::WebSocketWriteQueue(send_stream_.get())),
 162         pending_send_count_(0),
 163         pending_receive_count_(0) {
 164     web_socket_.set_connection_error_handler([this]() { OnConnectionError(); });
 165     agent_host->SetDelegate(this);
 166   }
 167
 168   ~WebSocketRelayer() override {
 169     if (agent_host_)
 170       agent_host_->SetDelegate(nullptr);
 171   }
 172
 173   // DevToolsAgentHost::Delegate implementation.
 174   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
 175                                const std::string& message) override {
 176     if (!web_socket_)
 177       return;
 178
 179     // TODO(yzshen): It shouldn't be an issue to pass an empty message. However,
 180     // WebSocket{Read,Write}Queue doesn't handle that correctly.
 181     if (message.empty())
 182       return;
 183
 184     pending_send_count_++;
 185     uint32_t size = static_cast<uint32_t>(message.size());
 186     write_send_stream_->Write(
 187         &message[0], size,
 188         base::Bind(&WebSocketRelayer::OnFinishedWritingSendStream,
 189                    base::Unretained(this), size));
 190   }
 191
 192   void OnAgentHostClosed(DevToolsAgentHost* agent_host) override {
 193     DispatchProtocolMessage(agent_host_,
 194                             "{ \"method\": \"Inspector.detached\", "
 195                             "\"params\": { \"reason\": \"target_closed\" } }");
 196
 197     // No need to call SetDelegate(nullptr) on |agent_host_| because it is going
 198     // away.
 199     agent_host_ = nullptr;
 200
 201     if (ShouldSelfDestruct())
 202       delete this;
 203   }
 204
 205   // WebSocketClient implementation.
 206   void DidConnect(const mojo::String& selected_subprotocol,
 207                   const mojo::String& extensions,
 208                   mojo::ScopedDataPipeConsumerHandle receive_stream) override {
 209     receive_stream_ = receive_stream.Pass();
 210     read_receive_stream_.reset(
 211         new mojo::WebSocketReadQueue(receive_stream_.get()));
 212   }
 213
 214   void DidReceiveData(bool fin,
 215                       mojo::WebSocket::MessageType type,
 216                       uint32_t num_bytes) override {
 217     if (!agent_host_)
 218       return;
 219
 220     // TODO(yzshen): It shouldn't be an issue to pass an empty message. However,
 221     // WebSocket{Read,Write}Queue doesn't handle that correctly.
 222     if (num_bytes == 0)
 223       return;
 224
 225     pending_receive_count_++;
 226     read_receive_stream_->Read(
 227         num_bytes, base::Bind(&WebSocketRelayer::OnFinishedReadingReceiveStream,
 228                               base::Unretained(this), num_bytes));
 229   }
 230
 231   void DidReceiveFlowControl(int64_t quota) override {}
 232
 233   void DidFail(const mojo::String& message) override {}
 234
 235   void DidClose(bool was_clean,
 236                 uint16_t code,
 237                 const mojo::String& reason) override {}
 238
 239   void OnConnectionError() {
 240     web_socket_ = nullptr;
 241     binding_.Close();
 242
 243     if (ShouldSelfDestruct())
 244       delete this;
 245   }
 246
 247   void OnFinishedWritingSendStream(uint32_t num_bytes, const char* buffer) {
 248     DCHECK_GT(pending_send_count_, 0u);
 249     pending_send_count_--;
 250
 251     if (web_socket_ && buffer)
 252       web_socket_->Send(true, mojo::WebSocket::MESSAGE_TYPE_TEXT, num_bytes);
 253
 254     if (ShouldSelfDestruct())
 255       delete this;
 256   }
 257
 258   void OnFinishedReadingReceiveStream(uint32_t num_bytes, const char* data) {
 259     DCHECK_GT(pending_receive_count_, 0u);
 260     pending_receive_count_--;
 261
 262     if (agent_host_ && data)
 263       agent_host_->SendProtocolMessageToAgent(std::string(data, num_bytes));
 264
 265     if (ShouldSelfDestruct())
 266       delete this;
 267   }
 268
 269   bool ShouldSelfDestruct() const {
 270     return (!agent_host_ && pending_send_count_ == 0) ||
 271            (!web_socket_ && pending_receive_count_ == 0);
 272   }
 273
 274   DevToolsAgentHost* agent_host_;
 275   mojo::Binding<WebSocketClient> binding_;
 276   mojo::WebSocketPtr web_socket_;
 277
 278   mojo::ScopedDataPipeProducerHandle send_stream_;
 279   scoped_ptr<mojo::WebSocketWriteQueue> write_send_stream_;
 280   size_t pending_send_count_;
 281
 282   mojo::ScopedDataPipeConsumerHandle receive_stream_;
 283   scoped_ptr<mojo::WebSocketReadQueue> read_receive_stream_;
 284   size_t pending_receive_count_;
 285
 286   DISALLOW_COPY_AND_ASSIGN(WebSocketRelayer);
 287 };
 288
 289 }  // namespace
 290
 291 class DevToolsHttpServer::HttpConnectionDelegateImpl
 292     : public mojo::HttpConnectionDelegate {
 293  public:
 294   HttpConnectionDelegateImpl(
 295       DevToolsHttpServer* owner,
 296       mojo::HttpConnectionPtr connection,
 297       mojo::InterfaceRequest<HttpConnectionDelegate> delegate_request)
 298       : owner_(owner),
 299         connection_(connection.Pass()),
 300         binding_(this, delegate_request.Pass()) {
 301     DCHECK(owner_);
 302     DCHECK(connection_);
 303     DCHECK(binding_.is_bound());
 304
 305     auto error_handler = [this]() { owner_->OnConnectionClosed(this); };
 306     connection_.set_connection_error_handler(error_handler);
 307     binding_.set_connection_error_handler(error_handler);
 308   }
 309
 310   mojo::HttpConnection* connection() { return connection_.get(); }
 311
 312  private:
 313   // mojo::HttpConnectionDelegate implementation:
 314   void OnReceivedRequest(mojo::HttpRequestPtr request,
 315                          const OnReceivedRequestCallback& callback) override {
 316     owner_->OnReceivedRequest(this, request.Pass(), callback);
 317   }
 318
 319   void OnReceivedWebSocketRequest(
 320       mojo::HttpRequestPtr request,
 321       const OnReceivedWebSocketRequestCallback& callback) override {
 322     owner_->OnReceivedWebSocketRequest(this, request.Pass(), callback);
 323   }
 324
 325   DevToolsHttpServer* const owner_;
 326   mojo::HttpConnectionPtr connection_;
 327   mojo::Binding<HttpConnectionDelegate> binding_;
 328
 329   DISALLOW_COPY_AND_ASSIGN(HttpConnectionDelegateImpl);
 330 };
 331
 332 DevToolsHttpServer::DevToolsHttpServer(DevToolsService* service,
 333                                        uint16_t remote_debugging_port)
 334     : service_(service), remote_debugging_port_(remote_debugging_port) {
 335   VLOG(1) << "Remote debugging HTTP server is started on port "
 336           << remote_debugging_port << ".";
 337   mojo::NetworkServicePtr network_service;
 338   mojo::URLRequestPtr request(mojo::URLRequest::New());
 339   request->url = "mojo:network_service";
 340   service_->application()->ConnectToService(request.Pass(), &network_service);
 341
 342   mojo::NetAddressPtr local_address(mojo::NetAddress::New());
 343   local_address->family = mojo::NET_ADDRESS_FAMILY_IPV4;
 344   local_address->ipv4 = mojo::NetAddressIPv4::New();
 345   local_address->ipv4->port = remote_debugging_port;
 346   local_address->ipv4->addr.resize(4);
 347   local_address->ipv4->addr[0] = 127;
 348   local_address->ipv4->addr[1] = 0;
 349   local_address->ipv4->addr[2] = 0;
 350   local_address->ipv4->addr[3] = 1;
 351
 352   mojo::HttpServerDelegatePtr http_server_delegate;
 353   http_server_delegate_binding_.reset(
 354       new mojo::Binding<mojo::HttpServerDelegate>(this, &http_server_delegate));
 355   network_service->CreateHttpServer(
 356       local_address.Pass(), http_server_delegate.Pass(),
 357       mojo::NetworkService::CreateHttpServerCallback());
 358 }
 359
 360 DevToolsHttpServer::~DevToolsHttpServer() {
 361   STLDeleteElements(&connections_);
 362 }
 363
 364 void DevToolsHttpServer::OnConnected(
 365     mojo::HttpConnectionPtr connection,
 366     mojo::InterfaceRequest<mojo::HttpConnectionDelegate> delegate) {
 367   connections_.insert(
 368       new HttpConnectionDelegateImpl(this, connection.Pass(), delegate.Pass()));
 369 }
 370
 371 void DevToolsHttpServer::OnReceivedRequest(
 372     HttpConnectionDelegateImpl* connection,
 373     mojo::HttpRequestPtr request,
 374     const OnReceivedRequestCallback& callback) {
 375   DCHECK(connections_.find(connection) != connections_.end());
 376
 377   if (request->url.get().find(kJsonRequestUrlPrefix) == 0) {
 378     mojo::HttpResponsePtr response = ProcessJsonRequest(request.Pass());
 379     if (response)
 380       callback.Run(response.Pass());
 381     else
 382       OnConnectionClosed(connection);
 383   } else {
 384     // TODO(yzshen): Implement it.
 385     NOTIMPLEMENTED();
 386     callback.Run(MakeResponse(404, "text/html", "Not implemented yet!"));
 387   }
 388 }
 389
 390 void DevToolsHttpServer::OnReceivedWebSocketRequest(
 391     HttpConnectionDelegateImpl* connection,
 392     mojo::HttpRequestPtr request,
 393     const OnReceivedWebSocketRequestCallback& callback) {
 394   DCHECK(connections_.find(connection) != connections_.end());
 395
 396   std::string path = request->url;
 397   size_t browser_pos = path.find(kBrowserUrlPrefix);
 398   if (browser_pos == 0) {
 399     // TODO(yzshen): Implement it.
 400     NOTIMPLEMENTED();
 401     callback.Run(nullptr, mojo::ScopedDataPipeConsumerHandle(), nullptr);
 402     return;
 403   }
 404
 405   size_t pos = path.find(kPageUrlPrefix);
 406   if (pos != 0) {
 407     callback.Run(nullptr, mojo::ScopedDataPipeConsumerHandle(), nullptr);
 408     return;
 409   }
 410
 411   std::string target_id = path.substr(strlen(kPageUrlPrefix));
 412   DevToolsAgentHost* agent = service_->registry()->GetAgentById(target_id);
 413   if (!agent || agent->IsAttached()) {
 414     callback.Run(nullptr, mojo::ScopedDataPipeConsumerHandle(), nullptr);
 415     return;
 416   }
 417
 418   mojo::WebSocketPtr web_socket;
 419   mojo::InterfaceRequest<mojo::WebSocket> web_socket_request =
 420       mojo::GetProxy(&web_socket);
 421   mojo::DataPipe data_pipe;
 422   mojo::WebSocketClientPtr web_socket_client = WebSocketRelayer::SetUp(
 423       agent, web_socket.Pass(), data_pipe.producer_handle.Pass());
 424   callback.Run(web_socket_request.Pass(), data_pipe.consumer_handle.Pass(),
 425                web_socket_client.Pass());
 426 }
 427
 428 void DevToolsHttpServer::OnConnectionClosed(
 429     HttpConnectionDelegateImpl* connection) {
 430   DCHECK(connections_.find(connection) != connections_.end());
 431
 432   delete connection;
 433   connections_.erase(connection);
 434 }
 435
 436 mojo::HttpResponsePtr DevToolsHttpServer::ProcessJsonRequest(
 437     mojo::HttpRequestPtr request) {
 438   // Trim "/json".
 439   std::string path = request->url.get().substr(strlen(kJsonRequestUrlPrefix));
 440
 441   // Trim query.
 442   size_t query_pos = path.find("?");
 443   if (query_pos != std::string::npos)
 444     path = path.substr(0, query_pos);
 445
 446   // Trim fragment.
 447   size_t fragment_pos = path.find("#");
 448   if (fragment_pos != std::string::npos)
 449     path = path.substr(0, fragment_pos);
 450
 451   std::string command;
 452   std::string target_id;
 453   if (!ParseJsonPath(path, &command, &target_id))
 454     return MakeJsonResponse(404, nullptr,
 455                             "Malformed query: " + request->url.get());
 456
 457   if (command == kVersionCommand || command == kNewCommand ||
 458       command == kActivateCommand || command == kCloseCommand) {
 459     NOTIMPLEMENTED();
 460     return MakeJsonResponse(404, nullptr,
 461                             "Not implemented yet: " + request->url.get());
 462   }
 463
 464   if (command == kListCommand) {
 465     DevToolsRegistryImpl::Iterator iter(service_->registry());
 466     if (iter.IsAtEnd()) {
 467       // If no agent is available, return a nullptr to indicate that the
 468       // connection should be closed.
 469       return nullptr;
 470     }
 471
 472     std::string host = GetHeaderValue(*request, "host");
 473     if (host.empty()) {
 474       host = base::StringPrintf("127.0.0.1:%u",
 475                                 static_cast<unsigned>(remote_debugging_port_));
 476     }
 477
 478     base::ListValue list_value;
 479     for (; !iter.IsAtEnd(); iter.Advance()) {
 480       scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
 481
 482       // TODO(yzshen): Add more information.
 483       dict_value->SetString(kTargetDescriptionField, std::string());
 484       dict_value->SetString(kTargetDevtoolsFrontendUrlField, std::string());
 485       dict_value->SetString(kTargetIdField, iter.value()->id());
 486       dict_value->SetString(kTargetTitleField, std::string());
 487       dict_value->SetString(kTargetTypeField, "page");
 488       dict_value->SetString(kTargetUrlField, std::string());
 489       dict_value->SetString(
 490           kTargetWebSocketDebuggerUrlField,
 491           base::StringPrintf("ws://%s%s%s", host.c_str(), kPageUrlPrefix,
 492                              iter.value()->id().c_str()));
 493       list_value.Append(dict_value.Pass());
 494     }
 495     return MakeJsonResponse(200, &list_value, std::string());
 496   }
 497
 498   return MakeJsonResponse(404, nullptr, "Unknown command: " + command);
 499 }
 500
 501 }  // namespace devtools_service