| // 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 |
