| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "server.h" | |
| #include <algorithm> | |
| #include <cstdio> | |
| #include <cstring> | |
| #include <sstream> | |
| #include "session.h" | |
| #include "errorcodes.h" | |
| #include "uri_info.h" | |
| #include "logging.h" | |
| #define SERVER_DEFAULT_PAGE "<html><head><title>WebDriver</title></head><body><p id='main'>This is the initial start page for the WebDriver server.</p></body></html>" | |
| #define SERVER_DEFAULT_WHITELIST "127.0.0.1" | |
| #define SERVER_DEFAULT_BLACKLIST "-0.0.0.0/0" | |
| #define HTML_CONTENT_TYPE "text/html" | |
| #define JSON_CONTENT_TYPE "application/json" | |
| #if defined(WINDOWS) | |
| #include <cstdarg> | |
| inline int wd_snprintf(char* str, size_t size, const char* format, ...) { | |
| va_list args; | |
| va_start(args, format); | |
| int count = _vscprintf(format, args); | |
| if (str != NULL && size > 0) { | |
| count = _vsnprintf_s(str, size, _TRUNCATE, format, args); | |
| } | |
| va_end(args); | |
| return count; | |
| } | |
| #define snprintf wd_snprintf | |
| #endif | |
| namespace webdriver { | |
| Server::Server(const int port) { | |
| this->Initialize(port, "", "", "", ""); | |
| } | |
| Server::Server(const int port, const std::string& host) { | |
| this->Initialize(port, host, "", "", ""); | |
| } | |
| Server::Server(const int port, | |
| const std::string& host, | |
| const std::string& log_level, | |
| const std::string& log_file) { | |
| this->Initialize(port, host, log_level, log_file, ""); | |
| } | |
| Server::Server(const int port, | |
| const std::string& host, | |
| const std::string& log_level, | |
| const std::string& log_file, | |
| const std::string& acl) { | |
| this->Initialize(port, host, log_level, log_file, acl); | |
| } | |
| Server::~Server(void) { | |
| SessionMap::iterator it = this->sessions_.begin(); | |
| for (; it != this->sessions_.end(); ++it) { | |
| std::string session_id = it->first; | |
| this->ShutDownSession(session_id); | |
| } | |
| } | |
| void Server::Initialize(const int port, | |
| const std::string& host, | |
| const std::string& log_level, | |
| const std::string& log_file, | |
| const std::string& acl) { | |
| LOG::Level(log_level); | |
| LOG::File(log_file); | |
| LOG(INFO) << "Starting WebDriver server on port: '" | |
| << port << "' on host: '" << host << "'"; | |
| this->port_ = port; | |
| this->host_ = host; | |
| if (acl.size() > 0) { | |
| this->ProcessWhitelist(acl); | |
| } | |
| this->PopulateCommandRepository(); | |
| } | |
| void Server::ProcessWhitelist(const std::string& whitelist) { | |
| std::string input_copy = whitelist; | |
| while (input_copy.size() > 0) { | |
| size_t delimiter_pos = input_copy.find(","); | |
| std::string token = input_copy.substr(0, delimiter_pos); | |
| if (delimiter_pos == std::string::npos) { | |
| input_copy = ""; | |
| } else { | |
| input_copy = input_copy.substr(delimiter_pos + 1); | |
| } | |
| this->whitelist_.push_back(token); | |
| } | |
| } | |
| std::string Server::GetListeningPorts(const bool use_ipv6) { | |
| std::string port_format_string = "%s:%d"; | |
| if (this->host_.size() == 0) { | |
| // If the host name is an empty string, then we want to bind | |
| // to the local loopback address on both IPv4 and IPv6 if we | |
| // can. Using the addresses in the listening port format string | |
| // will prevent connection from external IP addresses. | |
| port_format_string = "%s127.0.0.1:%d"; | |
| if (use_ipv6) { | |
| port_format_string.append(",[::1]:%d"); | |
| } | |
| } else if (this->whitelist_.size() > 0) { | |
| // If there are white-listed IP addresses, we can only use IPv4, | |
| // and we don't want the colon in the listening ports string. | |
| // Instead, we want to bind to all adapters, and use the access | |
| // control list to determine which addresses can connect. So to | |
| // remove the host from the format string, when we use printf to | |
| // format, the %s will be replaced by an empty string. | |
| port_format_string = "%s%d"; | |
| } | |
| int formatted_string_size = snprintf(NULL, | |
| 0, | |
| port_format_string.c_str(), | |
| this->host_.c_str(), | |
| this->port_, | |
| this->port_) + 1; | |
| std::vector<char> listening_ports_buffer(formatted_string_size); | |
| snprintf(&listening_ports_buffer[0], | |
| formatted_string_size, | |
| port_format_string.c_str(), | |
| this->host_.c_str(), | |
| this->port_, | |
| this->port_); | |
| return &listening_ports_buffer[0]; | |
| } | |
| std::string Server::GetAccessControlList() { | |
| std::string acl = ""; | |
| if (this->whitelist_.size() > 0) { | |
| acl = SERVER_DEFAULT_BLACKLIST; | |
| for (std::vector<std::string>::const_iterator it = this->whitelist_.begin(); | |
| it < this->whitelist_.end(); | |
| ++it) { | |
| acl.append(",+").append(*it); | |
| } | |
| LOG(DEBUG) << "Civetweb ACL is " << acl; | |
| } | |
| return acl; | |
| } | |
| void Server::GenerateOptionsList(std::vector<const char*>* options) { | |
| std::map<std::string, std::string>::const_iterator it = this->options_.begin(); | |
| for (; it != this->options_.end(); ++it) { | |
| options->push_back(it->first.c_str()); | |
| options->push_back(it->second.c_str()); | |
| } | |
| options->push_back(NULL); | |
| } | |
| int Server::OnNewHttpRequest(struct mg_connection* conn) { | |
| mg_context* context = mg_get_context(conn); | |
| Server* current_server = reinterpret_cast<Server*>(mg_get_user_data(context)); | |
| const mg_request_info* request_info = mg_get_request_info(conn); | |
| int handler_result_code = current_server->ProcessRequest(conn, request_info); | |
| return handler_result_code; | |
| } | |
| bool Server::Start() { | |
| LOG(TRACE) << "Entering Server::Start"; | |
| std::string listening_port_option = this->GetListeningPorts(true); | |
| this->options_["listening_ports"] = listening_port_option; | |
| std::string acl_option = this->GetAccessControlList(); | |
| if (acl_option.size() > 0) { | |
| this->options_["access_control_list"] = acl_option; | |
| } | |
| this->options_["enable_keep_alive"] = "yes"; | |
| std::vector<const char*> options; | |
| this->GenerateOptionsList(&options); | |
| mg_callbacks callbacks = {}; | |
| callbacks.begin_request = &OnNewHttpRequest; | |
| context_ = mg_start(&callbacks, this, &options[0]); | |
| if (context_ == NULL) { | |
| std::string ipv4_port_option = this->GetListeningPorts(false); | |
| if (listening_port_option == ipv4_port_option) { | |
| // If the IPv4 and IPv6 versions of the port option string | |
| // are equal, then either a host to bind to or an ACL was | |
| // specified, so there is no need to retry. | |
| LOG(WARN) << "Failed to start Civetweb"; | |
| return false; | |
| } else { | |
| // If we fail, a host and ACL aren't specified, we might not | |
| // be able to bind to an IPv6 address. Try again to bind to | |
| // the IPv4 loopback only. | |
| LOG(INFO) << "Failed first attempt to start Civetweb. Attempt start with IPv4 only"; | |
| this->options_["listening_ports"] = listening_port_option; | |
| options.clear(); | |
| this->GenerateOptionsList(&options); | |
| context_ = mg_start(&callbacks, this, &options[0]); | |
| if (context_ == NULL) { | |
| LOG(WARN) << "Failed to start Civetweb"; | |
| return false; | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| void Server::Stop() { | |
| LOG(TRACE) << "Entering Server::Stop"; | |
| if (context_) { | |
| mg_stop(context_); | |
| context_ = NULL; | |
| } | |
| } | |
| int Server::ProcessRequest(struct mg_connection* conn, | |
| const struct mg_request_info* request_info) { | |
| LOG(TRACE) << "Entering Server::ProcessRequest"; | |
| int http_response_code = 0; | |
| std::string http_verb = request_info->request_method; | |
| std::string request_body = "{}"; | |
| if (http_verb == "POST") { | |
| request_body = this->ReadRequestBody(conn, request_info); | |
| } | |
| LOG(TRACE) << "Process request with:" | |
| << " URI: " << request_info->local_uri | |
| << " HTTP verb: " << http_verb << std::endl | |
| << "body: " << request_body; | |
| if (strcmp(request_info->local_uri, "/") == 0) { | |
| this->SendHttpOk(conn, | |
| request_info, | |
| SERVER_DEFAULT_PAGE, | |
| HTML_CONTENT_TYPE); | |
| http_response_code = 0; | |
| } else if (strcmp(request_info->local_uri, "/shutdown") == 0) { | |
| this->SendHttpOk(conn, | |
| request_info, | |
| SERVER_DEFAULT_PAGE, | |
| HTML_CONTENT_TYPE); | |
| http_response_code = 0; | |
| this->ShutDown(); | |
| } else { | |
| std::string serialized_response = this->DispatchCommand(request_info->local_uri, | |
| http_verb, | |
| request_body); | |
| http_response_code = this->SendResponseToClient(conn, | |
| request_info, | |
| serialized_response); | |
| } | |
| return http_response_code; | |
| } | |
| void Server::AddCommand(const std::string& url, | |
| const std::string& http_verb, | |
| const std::string& command_name) { | |
| if (this->commands_.find(url) == this->commands_.end()) { | |
| this->commands_[url] = std::shared_ptr<UriInfo>( | |
| new UriInfo(url, http_verb, command_name)); | |
| } else { | |
| this->commands_[url]->AddHttpVerb(http_verb, command_name); | |
| } | |
| } | |
| void Server::ShutDownSession(const std::string& session_id) { | |
| LOG(TRACE) << "Entering Server::ShutDownSession"; | |
| SessionMap::iterator it = this->sessions_.find(session_id); | |
| if (it != this->sessions_.end()) { | |
| it->second->ShutDown(); | |
| this->sessions_.erase(session_id); | |
| } else { | |
| LOG(DEBUG) << "Shutdown session is not found"; | |
| } | |
| } | |
| std::string Server::ReadRequestBody(struct mg_connection* conn, | |
| const struct mg_request_info* request_info) { | |
| LOG(TRACE) << "Entering Server::ReadRequestBody"; | |
| std::string request_body = ""; | |
| int content_length = 0; | |
| for (int header_index = 0; header_index < 64; ++header_index) { | |
| if (request_info->http_headers[header_index].name == NULL) { | |
| break; | |
| } | |
| std::string header_name(request_info->http_headers[header_index].name); | |
| std::transform(header_name.begin(), | |
| header_name.end(), | |
| header_name.begin(), | |
| ::tolower); | |
| if (header_name.compare("content-length") == 0) { | |
| content_length = atoi(request_info->http_headers[header_index].value); | |
| break; | |
| } | |
| } | |
| if (content_length != 0) { | |
| std::vector<char> buffer(content_length + 1); | |
| int bytes_read = 0; | |
| while (bytes_read < content_length) { | |
| bytes_read += mg_read(conn, | |
| &buffer[bytes_read], | |
| content_length - bytes_read); | |
| } | |
| buffer[content_length] = '\0'; | |
| request_body.append(&buffer[0]); | |
| } | |
| return request_body; | |
| } | |
| std::string Server::DispatchCommand(const std::string& uri, | |
| const std::string& http_verb, | |
| const std::string& command_body) { | |
| LOG(TRACE) << "Entering Server::DispatchCommand"; | |
| std::string session_id = ""; | |
| std::string locator_parameters = ""; | |
| std::string serialized_response = ""; | |
| std::string command = this->LookupCommand(uri, | |
| http_verb, | |
| &session_id, | |
| &locator_parameters); | |
| LOG(DEBUG) << "Command: " << http_verb << " " << uri << " " << command_body; | |
| if (command == webdriver::CommandType::NoCommand) { | |
| Response invalid_command_response; | |
| if (locator_parameters.size() > 0) { | |
| std::string unknown_method_body = "Invalid method requested: "; | |
| unknown_method_body.append(http_verb); | |
| unknown_method_body.append(" is not a valid HTTP verb for "); | |
| unknown_method_body.append(uri); | |
| unknown_method_body.append("; acceptable verbs are: "); | |
| unknown_method_body.append(locator_parameters); | |
| invalid_command_response.SetErrorResponse(ERROR_UNKNOWN_METHOD, | |
| unknown_method_body); | |
| invalid_command_response.AddAdditionalData("verbs", locator_parameters); | |
| } else { | |
| std::string unknown_command_body = "Command not found: "; | |
| unknown_command_body.append(http_verb); | |
| unknown_command_body.append(" "); | |
| unknown_command_body.append(uri); | |
| invalid_command_response.SetErrorResponse(ERROR_UNKNOWN_COMMAND, | |
| unknown_command_body); | |
| } | |
| serialized_response = invalid_command_response.Serialize(); | |
| } else if (command == webdriver::CommandType::Status) { | |
| // Status command must be handled by the server, not by the session. | |
| serialized_response = this->GetStatus(); | |
| } else if (command == webdriver::CommandType::GetSessionList) { | |
| // GetSessionList command must be handled by the server, | |
| // not by the session. | |
| serialized_response = this->ListSessions(); | |
| } else { | |
| SessionHandle session_handle; | |
| if (command != webdriver::CommandType::NewSession && | |
| !this->LookupSession(session_id, &session_handle)) { | |
| if (command == webdriver::CommandType::Quit) { | |
| // Calling quit on an invalid session should be a no-op. | |
| // Hand-code the response for quit on an invalid (already | |
| // quit) session. | |
| serialized_response.append("{ \"value\" : null }"); | |
| } else { | |
| Response invalid_session_id_response; | |
| std::string invalid_session_message = "session "; | |
| invalid_session_message.append(session_id); | |
| invalid_session_message.append(" does not exist"); | |
| invalid_session_id_response.SetErrorResponse(ERROR_INVALID_SESSION_ID, | |
| invalid_session_message); | |
| serialized_response = invalid_session_id_response.Serialize(); | |
| } | |
| } else { | |
| if (command == webdriver::CommandType::NewSession && | |
| this->sessions_.size() > 0) { | |
| std::string session_exists_message = "Only one session may "; | |
| session_exists_message.append("be created at a time, and a "); | |
| session_exists_message.append("session already exists."); | |
| Response session_exists_response; | |
| session_exists_response.SetErrorResponse(ERROR_SESSION_NOT_CREATED, | |
| session_exists_message); | |
| serialized_response = session_exists_response.Serialize(); | |
| } else { | |
| // Compile the serialized JSON representation of the command by hand. | |
| std::string serialized_command = "{ \"name\" : \"" + command + "\""; | |
| serialized_command.append(", \"locator\" : "); | |
| serialized_command.append(locator_parameters); | |
| serialized_command.append(", \"parameters\" : "); | |
| serialized_command.append(command_body); | |
| serialized_command.append(" }"); | |
| if (command == webdriver::CommandType::NewSession) { | |
| session_handle = this->InitializeSession(); | |
| } | |
| bool session_is_valid = session_handle->ExecuteCommand( | |
| serialized_command, | |
| &serialized_response); | |
| if (command == webdriver::CommandType::NewSession) { | |
| Response new_session_response; | |
| new_session_response.Deserialize(serialized_response); | |
| this->sessions_[new_session_response.GetSessionId()] = session_handle; | |
| } | |
| if (!session_is_valid) { | |
| this->ShutDownSession(session_id); | |
| } | |
| } | |
| } | |
| } | |
| LOG(DEBUG) << "Response: " << serialized_response; | |
| return serialized_response; | |
| } | |
| std::string Server::ListSessions() { | |
| LOG(TRACE) << "Entering Server::ListSessions"; | |
| // Manually construct the serialized command for getting | |
| // session capabilities. | |
| std::string get_caps_command = "{ \"name\" : \"" + | |
| webdriver::CommandType::GetSessionCapabilities | |
| + "\"" + | |
| ", \"locator\" : {}, \"parameters\" : {} }"; | |
| Json::Value sessions(Json::arrayValue); | |
| SessionMap::iterator it = this->sessions_.begin(); | |
| for (; it != this->sessions_.end(); ++it) { | |
| // Each element of the GetSessionList command is an object with two | |
| // named properties, "id" and "capabilities". We already know the | |
| // ID, so we execute the GetSessionCapabilities command on each session | |
| // to be able to return the capabilities. | |
| Json::Value session_descriptor; | |
| session_descriptor["id"] = it->first; | |
| SessionHandle session = it->second; | |
| std::string serialized_session_response; | |
| session->ExecuteCommand(get_caps_command, &serialized_session_response); | |
| Response session_response; | |
| session_response.Deserialize(serialized_session_response); | |
| session_descriptor["capabilities"] = session_response.value(); | |
| sessions.append(session_descriptor); | |
| } | |
| Response response; | |
| response.SetSuccessResponse(sessions); | |
| return response.Serialize(); | |
| } | |
| bool Server::LookupSession(const std::string& session_id, | |
| SessionHandle* session_handle) { | |
| LOG(TRACE) << "Entering Server::LookupSession"; | |
| SessionMap::iterator it = this->sessions_.find(session_id); | |
| if (it == this->sessions_.end()) { | |
| return false; | |
| } | |
| *session_handle = it->second; | |
| return true; | |
| } | |
| int Server::SendResponseToClient(struct mg_connection* conn, | |
| const struct mg_request_info* request_info, | |
| const std::string& serialized_response) { | |
| LOG(TRACE) << "Entering Server::SendResponseToClient"; | |
| int return_code = 0; | |
| if (serialized_response.size() > 0) { | |
| Response response; | |
| response.Deserialize(serialized_response); | |
| return_code = response.GetHttpResponseCode(); | |
| if (return_code == 0) { | |
| this->SendHttpOk(conn, | |
| request_info, | |
| serialized_response, | |
| HTML_CONTENT_TYPE); | |
| return_code = 200; | |
| } else if (return_code == 200) { | |
| this->SendHttpOk(conn, | |
| request_info, | |
| serialized_response, | |
| JSON_CONTENT_TYPE); | |
| } else if (return_code == 303) { | |
| std::string location = response.value().asString(); | |
| response.SetSuccessResponse(response.value()); | |
| this->SendHttpSeeOther(conn, request_info, location); | |
| return_code = 303; | |
| } else if (return_code == 400) { | |
| this->SendHttpBadRequest(conn, request_info, serialized_response); | |
| return_code = 400; | |
| } else if (return_code == 404) { | |
| this->SendHttpNotFound(conn, request_info, serialized_response); | |
| return_code = 404; | |
| } else if (return_code == 405) { | |
| std::string allowed_verbs = ""; | |
| Json::Value additional_data = response.additional_data(); | |
| if (additional_data.isObject() && additional_data.isMember("verbs")) { | |
| allowed_verbs = additional_data["verbs"].asString(); | |
| } | |
| this->SendHttpMethodNotAllowed(conn, | |
| request_info, | |
| allowed_verbs, | |
| serialized_response); | |
| return_code = 405; | |
| } else if (return_code == 501) { | |
| this->SendHttpNotImplemented(conn, | |
| request_info, | |
| ""); | |
| return_code = 501; | |
| } else { | |
| this->SendHttpInternalError(conn, request_info, serialized_response); | |
| return_code = 500; | |
| } | |
| } | |
| return return_code; | |
| } | |
| // The standard HTTP Status codes are implemented below. Chrome uses | |
| // OK, See Other, Not Found, Method Not Allowed, and Internal Error. | |
| // Internal Error, HTTP 500, is used as a catch all for any issue | |
| // not covered in the JSON protocol. | |
| void Server::SendHttpOk(struct mg_connection* connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& body, | |
| const std::string& content_type) { | |
| LOG(TRACE) << "Entering Server::SendHttpOk"; | |
| std::string body_to_send = body + "\r\n"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 200 OK\r\n" | |
| << "Content-Length: " << strlen(body_to_send.c_str()) << "\r\n" | |
| << "Content-Type: " << content_type << "; charset=utf-8\r\n" | |
| << "Cache-Control: no-cache\r\n" | |
| << "Vary: Accept-Charset, Accept-Encoding, Accept-Language, Accept\r\n" | |
| << "Accept-Ranges: bytes\r\n\r\n"; | |
| if (strcmp(request_info->request_method, "HEAD") != 0) { | |
| out << body_to_send; | |
| } | |
| mg_write(connection, out.str().c_str(), out.str().size()); | |
| } | |
| void Server::SendHttpBadRequest(struct mg_connection* const connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& body) { | |
| LOG(TRACE) << "Entering Server::SendHttpBadRequest"; | |
| std::string body_to_send = body + "\r\n"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 400 Bad Request\r\n" | |
| << "Content-Length: " << strlen(body_to_send.c_str()) << "\r\n" | |
| << "Content-Type: application/json; charset=utf-8\r\n" | |
| << "Cache-Control: no-cache\r\n" | |
| << "Vary: Accept-Charset, Accept-Encoding, Accept-Language, Accept\r\n" | |
| << "Accept-Ranges: bytes\r\n\r\n"; | |
| if (strcmp(request_info->request_method, "HEAD") != 0) { | |
| out << body_to_send; | |
| } | |
| mg_printf(connection, "%s", out.str().c_str()); | |
| } | |
| void Server::SendHttpInternalError(struct mg_connection* connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& body) { | |
| LOG(TRACE) << "Entering Server::SendHttpInternalError"; | |
| std::string body_to_send = body + "\r\n"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 500 Internal Server Error\r\n" | |
| << "Content-Length: " << strlen(body_to_send.c_str()) << "\r\n" | |
| << "Content-Type: application/json; charset=utf-8\r\n" | |
| << "Cache-Control: no-cache\r\n" | |
| << "Vary: Accept-Charset, Accept-Encoding, Accept-Language, Accept\r\n" | |
| << "Accept-Ranges: bytes\r\n\r\n"; | |
| if (strcmp(request_info->request_method, "HEAD") != 0) { | |
| out << body_to_send; | |
| } | |
| mg_write(connection, out.str().c_str(), out.str().size()); | |
| } | |
| void Server::SendHttpNotFound(struct mg_connection* const connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& body) { | |
| LOG(TRACE) << "Entering Server::SendHttpNotFound"; | |
| std::string body_to_send = body + "\r\n"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 404 Not Found\r\n" | |
| << "Content-Length: " << strlen(body_to_send.c_str()) << "\r\n" | |
| << "Content-Type: application/json; charset=utf-8\r\n" | |
| << "Cache-Control: no-cache\r\n" | |
| << "Vary: Accept-Charset, Accept-Encoding, Accept-Language, Accept\r\n" | |
| << "Accept-Ranges: bytes\r\n\r\n"; | |
| if (strcmp(request_info->request_method, "HEAD") != 0) { | |
| out << body_to_send; | |
| } | |
| mg_printf(connection, "%s", out.str().c_str()); | |
| } | |
| void Server::SendHttpMethodNotAllowed( | |
| struct mg_connection* connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& allowed_methods, | |
| const std::string& body) { | |
| LOG(TRACE) << "Entering Server::SendHttpMethodNotAllowed"; | |
| std::string body_to_send = body + "\r\n"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 405 Method Not Allowed\r\n" | |
| << "Content-Type: text/html\r\n" | |
| << "Content-Length: " << strlen(body_to_send.c_str()) << "\r\n" | |
| << "Allow: " << allowed_methods << "\r\n\r\n"; | |
| if (strcmp(request_info->request_method, "HEAD") != 0) { | |
| out << body_to_send; | |
| } | |
| mg_write(connection, out.str().c_str(), out.str().size()); | |
| } | |
| void Server::SendHttpTimeout(struct mg_connection* connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& body) { | |
| LOG(TRACE) << "Entering Server::SendHttpTimeout"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 408 Timeout\r\n\r\n" | |
| << "Content-Length: " << strlen(body.c_str()) << "\r\n" | |
| << "Content-Type: application/json; charset=utf-8\r\n" | |
| << "Cache-Control: no-cache\r\n" | |
| << "Vary: Accept-Charset, Accept-Encoding, Accept-Language, Accept\r\n" | |
| << "Accept-Ranges: bytes\r\n\r\n"; | |
| mg_write(connection, out.str().c_str(), out.str().size()); | |
| } | |
| void Server::SendHttpNotImplemented(struct mg_connection* connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& body) { | |
| LOG(TRACE) << "Entering Server::SendHttpNotImplemented"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 501 Not Implemented\r\n\r\n"; | |
| mg_write(connection, out.str().c_str(), out.str().size()); | |
| } | |
| void Server::SendHttpSeeOther(struct mg_connection* connection, | |
| const struct mg_request_info* request_info, | |
| const std::string& location) { | |
| LOG(TRACE) << "Entering Server::SendHttpSeeOther"; | |
| std::ostringstream out; | |
| out << "HTTP/1.1 303 See Other\r\n" | |
| << "Location: " << location << "\r\n" | |
| << "Content-Type: text/html\r\n" | |
| << "Content-Length: 0\r\n\r\n"; | |
| mg_write(connection, out.str().c_str(), out.str().size()); | |
| } | |
| std::string Server::LookupCommand(const std::string& uri, | |
| const std::string& http_verb, | |
| std::string* session_id, | |
| std::string* locator) { | |
| LOG(TRACE) << "Entering Server::LookupCommand"; | |
| std::string value = webdriver::CommandType::NoCommand; | |
| std::vector<std::string> url_fragments; | |
| UriInfo::ParseUri(uri, &url_fragments, NULL); | |
| UrlMap::const_iterator it = this->commands_.begin(); | |
| for (; it != this->commands_.end(); ++it) { | |
| std::vector<std::string> locator_param_names; | |
| std::vector<std::string> locator_param_values; | |
| if (it->second->IsUriMatch(url_fragments, | |
| &locator_param_names, | |
| &locator_param_values)) { | |
| if (it->second->HasHttpVerb(http_verb, &value)) { | |
| std::string param = this->ConstructLocatorParameterJson( | |
| locator_param_names, locator_param_values, session_id); | |
| locator->append(param); | |
| } else { | |
| locator->append(it->second->GetSupportedVerbs()); | |
| } | |
| break; | |
| } | |
| } | |
| return value; | |
| } | |
| std::string Server::ConstructLocatorParameterJson( | |
| std::vector<std::string> locator_param_names, | |
| std::vector<std::string> locator_param_values, | |
| std::string* session_id) { | |
| std::string param = "{"; | |
| size_t param_count = locator_param_names.size(); | |
| for (unsigned int i = 0; i < param_count; i++) { | |
| if (i != 0) { | |
| param.append(","); | |
| } | |
| param.append(" \""); | |
| param.append(locator_param_names[i]); | |
| param.append("\" : \""); | |
| param.append(locator_param_values[i]); | |
| param.append("\""); | |
| if (locator_param_names[i] == "sessionid") { | |
| session_id->append(locator_param_values[i]); | |
| } | |
| } | |
| param.append(" }"); | |
| return param; | |
| } | |
| void Server::PopulateCommandRepository() { | |
| LOG(TRACE) << "Entering Server::PopulateCommandRepository"; | |
| this->AddCommand("/session", "POST", webdriver::CommandType::NewSession); | |
| this->AddCommand("/session/:sessionid", "DELETE", webdriver::CommandType::Quit); | |
| this->AddCommand("/status", "GET", webdriver::CommandType::Status); | |
| this->AddCommand("/session/:sessionid/timeouts", "GET", webdriver::CommandType::GetTimeouts); | |
| this->AddCommand("/session/:sessionid/timeouts", "POST", webdriver::CommandType::SetTimeouts); | |
| this->AddCommand("/session/:sessionid/url", "GET", webdriver::CommandType::GetCurrentUrl); | |
| this->AddCommand("/session/:sessionid/url", "POST", webdriver::CommandType::Get); | |
| this->AddCommand("/session/:sessionid/back", "POST", webdriver::CommandType::GoBack); | |
| this->AddCommand("/session/:sessionid/forward", "POST", webdriver::CommandType::GoForward); | |
| this->AddCommand("/session/:sessionid/refresh", "POST", webdriver::CommandType::Refresh); | |
| this->AddCommand("/session/:sessionid/title", "GET", webdriver::CommandType::GetTitle); | |
| this->AddCommand("/session/:sessionid/window", "GET", webdriver::CommandType::GetCurrentWindowHandle); | |
| this->AddCommand("/session/:sessionid/window", "POST", webdriver::CommandType::SwitchToWindow); | |
| this->AddCommand("/session/:sessionid/window", "DELETE", webdriver::CommandType::CloseWindow); | |
| this->AddCommand("/session/:sessionid/window/handles", "GET", webdriver::CommandType::GetWindowHandles); | |
| this->AddCommand("/session/:sessionid/window/new", "POST", webdriver::CommandType::NewWindow); | |
| this->AddCommand("/session/:sessionid/frame", "POST", webdriver::CommandType::SwitchToFrame); | |
| this->AddCommand("/session/:sessionid/frame/parent", "POST", webdriver::CommandType::SwitchToParentFrame); | |
| this->AddCommand("/session/:sessionid/window/rect", "GET", webdriver::CommandType::GetWindowRect); | |
| this->AddCommand("/session/:sessionid/window/rect", "POST", webdriver::CommandType::SetWindowRect); | |
| this->AddCommand("/session/:sessionid/window/maximize", "POST", webdriver::CommandType::MaximizeWindow); | |
| this->AddCommand("/session/:sessionid/window/minimize", "POST", webdriver::CommandType::MinimizeWindow); | |
| this->AddCommand("/session/:sessionid/window/fullscreen", "POST", webdriver::CommandType::FullscreenWindow); | |
| this->AddCommand("/session/:sessionid/element/active", "GET", webdriver::CommandType::GetActiveElement); | |
| this->AddCommand("/session/:sessionid/element", "POST", webdriver::CommandType::FindElement); | |
| this->AddCommand("/session/:sessionid/elements", "POST", webdriver::CommandType::FindElements); | |
| this->AddCommand("/session/:sessionid/element/:id/element", "POST", webdriver::CommandType::FindChildElement); | |
| this->AddCommand("/session/:sessionid/element/:id/elements", "POST", webdriver::CommandType::FindChildElements); | |
| this->AddCommand("/session/:sessionid/element/:id/selected", "GET", webdriver::CommandType::IsElementSelected); | |
| this->AddCommand("/session/:sessionid/element/:id/attribute/:name", "GET", webdriver::CommandType::GetElementAttribute); | |
| this->AddCommand("/session/:sessionid/element/:id/property/:name", "GET", webdriver::CommandType::GetElementProperty); | |
| this->AddCommand("/session/:sessionid/element/:id/css/:propertyName", "GET", webdriver::CommandType::GetElementValueOfCssProperty); | |
| this->AddCommand("/session/:sessionid/element/:id/text", "GET", webdriver::CommandType::GetElementText); | |
| this->AddCommand("/session/:sessionid/element/:id/name", "GET", webdriver::CommandType::GetElementTagName); | |
| this->AddCommand("/session/:sessionid/element/:id/rect", "GET", webdriver::CommandType::GetElementRect); | |
| this->AddCommand("/session/:sessionid/element/:id/enabled", "GET", webdriver::CommandType::IsElementEnabled); | |
| this->AddCommand("/session/:sessionid/element/:id/click", "POST", webdriver::CommandType::ClickElement); | |
| this->AddCommand("/session/:sessionid/element/:id/clear", "POST", webdriver::CommandType::ClearElement); | |
| this->AddCommand("/session/:sessionid/element/:id/value", "POST", webdriver::CommandType::SendKeysToElement); | |
| this->AddCommand("/session/:sessionid/source", "GET", webdriver::CommandType::GetPageSource); | |
| this->AddCommand("/session/:sessionid/execute/sync", "POST", webdriver::CommandType::ExecuteScript); | |
| this->AddCommand("/session/:sessionid/execute/async", "POST", webdriver::CommandType::ExecuteAsyncScript); | |
| this->AddCommand("/session/:sessionid/cookie", "GET", webdriver::CommandType::GetAllCookies); | |
| this->AddCommand("/session/:sessionid/cookie/:name", "GET", webdriver::CommandType::GetNamedCookie); | |
| this->AddCommand("/session/:sessionid/cookie", "POST", webdriver::CommandType::AddCookie); | |
| this->AddCommand("/session/:sessionid/cookie", "DELETE", webdriver::CommandType::DeleteAllCookies); | |
| this->AddCommand("/session/:sessionid/cookie/:name", "DELETE", webdriver::CommandType::DeleteNamedCookie); | |
| this->AddCommand("/session/:sessionid/actions", "POST", webdriver::CommandType::Actions); | |
| this->AddCommand("/session/:sessionid/actions", "DELETE", webdriver::CommandType::ReleaseActions); | |
| this->AddCommand("/session/:sessionid/alert/dismiss", "POST", webdriver::CommandType::DismissAlert); | |
| this->AddCommand("/session/:sessionid/alert/accept", "POST", webdriver::CommandType::AcceptAlert); | |
| this->AddCommand("/session/:sessionid/alert/text", "GET", webdriver::CommandType::GetAlertText); | |
| this->AddCommand("/session/:sessionid/alert/text", "POST", webdriver::CommandType::SendKeysToAlert); | |
| this->AddCommand("/session/:sessionid/screenshot", "GET", webdriver::CommandType::Screenshot); | |
| this->AddCommand("/session/:sessionid/element/:id/screenshot", "GET", webdriver::CommandType::ElementScreenshot); | |
| // Additional commands required to be supported, but not defined | |
| // in the specification. | |
| this->AddCommand("/session/:sessionid/alert/credentials", "POST", webdriver::CommandType::SetAlertCredentials); | |
| this->AddCommand("/session/:sessionid/element/:id/displayed", "GET", webdriver::CommandType::IsElementDisplayed); | |
| this->AddCommand("/session/:sessionid/element/:id/equals/:other", "GET", webdriver::CommandType::ElementEquals); | |
| this->AddCommand("/sessions", "GET", webdriver::CommandType::GetSessionList); | |
| this->AddCommand("/session/:sessionid", "GET", webdriver::CommandType::GetSessionCapabilities); | |
| this->AddCommand("/session/:sessionid/ime/available_engines", "GET", webdriver::CommandType::ListAvailableImeEngines); | |
| this->AddCommand("/session/:sessionid/ime/active_engines", "GET", webdriver::CommandType::GetActiveImeEngine); | |
| this->AddCommand("/session/:sessionid/ime/activated", "GET", webdriver::CommandType::IsImeActivated); | |
| this->AddCommand("/session/:sessionid/ime/activate", "POST", webdriver::CommandType::ActivateImeEngine); | |
| this->AddCommand("/session/:sessionid/ime/deactivate", "POST", webdriver::CommandType::DeactivateImeEngine); | |
| } | |
| } // namespace webdriver |