sandboxed-api/oss-internship-2020/curl/tests/test_utils.cc
Christian Blichmann d451478e26 Change license link to HTTPS URL
PiperOrigin-RevId: 424811734
Change-Id: If5ea692edc56ddc9c99fd478673df41c0246e9cc
2022-01-28 01:39:09 -08:00

281 lines
8.6 KiB
C++

// Copyright 2020 Google LLC
//
// Licensed 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
//
// https://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 "test_utils.h" // NOLINT(build/include)
#include <absl/strings/match.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <memory>
#include <thread> // NOLINT(build/c++11)
#include "absl/status/statusor.h"
#include "sandboxed_api/util/status_macros.h"
namespace curl::tests {
int CurlTestUtils::port_;
std::thread CurlTestUtils::server_thread_;
absl::Status CurlTestUtils::CurlTestSetUp() {
// Initialize sandbox2 and SAPI
sandbox_ = std::make_unique<curl::CurlSapiSandbox>();
SAPI_RETURN_IF_ERROR(sandbox_->Init());
api_ = std::make_unique<curl::CurlApi>(sandbox_.get());
// Initialize curl
SAPI_ASSIGN_OR_RETURN(curl::CURL * curl_handle, api_->curl_easy_init());
if (!curl_handle) {
return absl::UnavailableError("curl_easy_init returned nullptr");
}
curl_ = std::make_unique<sapi::v::RemotePtr>(curl_handle);
int curl_code = 0;
// Specify request URL
sapi::v::ConstCStr sapi_url(kUrl);
SAPI_ASSIGN_OR_RETURN(
curl_code, api_->curl_easy_setopt_ptr(curl_.get(), curl::CURLOPT_URL,
sapi_url.PtrBefore()));
if (curl_code != curl::CURLE_OK) {
return absl::UnavailableError(absl::StrCat(
"curl_easy_setopt_ptr returned with the error code ", curl_code));
}
// Set port
SAPI_ASSIGN_OR_RETURN(curl_code, api_->curl_easy_setopt_long(
curl_.get(), curl::CURLOPT_PORT, port_));
if (curl_code != curl::CURLE_OK) {
return absl::UnavailableError(absl::StrCat(
"curl_easy_setopt_long returned with the error code ", curl_code));
}
// Generate pointer to the WriteToMemory callback
void* function_ptr;
SAPI_RETURN_IF_ERROR(
sandbox_->rpc_channel()->Symbol("WriteToMemory", &function_ptr));
sapi::v::RemotePtr remote_function_ptr(function_ptr);
// Set WriteToMemory as the write function
SAPI_ASSIGN_OR_RETURN(curl_code, api_->curl_easy_setopt_ptr(
curl_.get(), curl::CURLOPT_WRITEFUNCTION,
&remote_function_ptr));
if (curl_code != curl::CURLE_OK) {
return absl::UnavailableError(absl::StrCat(
"curl_easy_setopt_ptr returned with the error code ", curl_code));
}
// Pass memory chunk object to the callback
chunk_ = std::make_unique<sapi::v::LenVal>(0);
SAPI_ASSIGN_OR_RETURN(
curl_code, api_->curl_easy_setopt_ptr(
curl_.get(), curl::CURLOPT_WRITEDATA, chunk_->PtrBoth()));
if (curl_code != curl::CURLE_OK) {
return absl::UnavailableError(absl::StrCat(
"curl_easy_setopt_ptr returned with the error code ", curl_code));
}
return absl::OkStatus();
}
absl::Status CurlTestUtils::CurlTestTearDown() {
// Cleanup curl
return api_->curl_easy_cleanup(curl_.get());
}
absl::StatusOr<std::string> CurlTestUtils::PerformRequest() {
// Perform the request
SAPI_ASSIGN_OR_RETURN(int curl_code, api_->curl_easy_perform(curl_.get()));
if (curl_code != curl::CURLE_OK) {
return absl::UnavailableError(absl::StrCat(
"curl_easy_perform returned with the error code ", curl_code));
}
// Get pointer to the memory chunk
SAPI_RETURN_IF_ERROR(sandbox_->TransferFromSandboxee(chunk_.get()));
return std::string(reinterpret_cast<char*>(chunk_->GetData()));
}
namespace {
// Read the socket until str is completely read
std::string ReadUntil(const int socket, const std::string& str,
const size_t max_request_size) {
std::string str_read;
str_read.reserve(max_request_size);
// Read one char at a time until str is suffix of buf
while (!absl::EndsWith(str_read, str)) {
char next_char;
if (str_read.size() >= max_request_size ||
read(socket, &next_char, 1) < 1) {
return "";
}
str_read += next_char;
}
return str_read;
}
// Parse HTTP headers to return the Content-Length
ssize_t GetContentLength(const std::string& headers) {
constexpr char kContentLength[] = "Content-Length: ";
// Find the Content-Length header
const auto length_header_start = headers.find(kContentLength);
// There is no Content-Length field
if (length_header_start == std::string::npos) {
return 0;
}
// Find Content-Length string
const auto length_start = length_header_start + strlen(kContentLength);
const auto length_bytes = headers.find("\r\n", length_start) - length_start;
// length_bytes exceeds maximum
if (length_bytes >= 64) {
return -1;
}
// Convert string to int and return
return std::stoi(headers.substr(length_start, length_bytes));
}
// Read exactly content_bytes from the socket
std::string ReadExact(int socket, size_t content_bytes) {
std::string str_read;
str_read.reserve(content_bytes);
// Read one char at a time until all chars are read
while (str_read.size() < content_bytes) {
char next_char;
if (read(socket, &next_char, 1) < 1) {
return "";
}
str_read += next_char;
}
return str_read;
}
// Listen on the socket and answer back to requests
void ServerLoop(int listening_socket, sockaddr_in socket_address) {
socklen_t socket_address_size = sizeof(socket_address);
// Listen on the socket (maximum 1 connection)
if (listen(listening_socket, 1) == -1) {
return;
}
// Keep accepting connections until the thread is terminated
// (i.e. server_thread_ is assigned to a new thread or destroyed)
for (;;) {
// File descriptor to the connection socket
// This blocks the thread until a connection is established
int accepted_socket =
accept(listening_socket, reinterpret_cast<sockaddr*>(&socket_address),
reinterpret_cast<socklen_t*>(&socket_address_size));
if (accepted_socket == -1) {
return;
}
constexpr int kMaxRequestSize = 4096;
// Read until the end of the headers
std::string headers =
ReadUntil(accepted_socket, "\r\n\r\n", kMaxRequestSize);
if (headers == "") {
close(accepted_socket);
return;
}
// Get the length of the request content
ssize_t content_length = GetContentLength(headers);
if (content_length > kMaxRequestSize - headers.size() ||
content_length < 0) {
close(accepted_socket);
return;
}
// Read the request content
std::string content = ReadExact(accepted_socket, content_length);
// Prepare a response for the request
std::string http_response =
"HTTP/1.1 200 OK\nContent-Type: text/plain\nContent-Length: ";
if (headers.substr(0, 3) == "GET") {
http_response += "2\r\n\r\nOK";
} else if (headers.substr(0, 4) == "POST") {
http_response +=
std::to_string(content.size()) + "\r\n\r\n" + std::string{content};
} else {
close(accepted_socket);
return;
}
// Ignore any errors, the connection will be closed anyway
write(accepted_socket, http_response.c_str(), http_response.size());
// Close the socket
close(accepted_socket);
}
}
} // namespace
void CurlTestUtils::StartMockServer() {
// Get the socket file descriptor
int listening_socket = socket(AF_INET, SOCK_STREAM, 0);
// Create the socket address object
// The port is set to 0, meaning that it will be auto assigned
// Only local connections can access this socket
sockaddr_in socket_address{AF_INET, 0, htonl(INADDR_LOOPBACK)};
socklen_t socket_address_size = sizeof(socket_address);
if (listening_socket == -1) {
return;
}
// Bind the file descriptor to the socket address object
if (bind(listening_socket, reinterpret_cast<sockaddr*>(&socket_address),
socket_address_size) == -1) {
return;
}
// Assign an available port to the socket address object
if (getsockname(listening_socket,
reinterpret_cast<sockaddr*>(&socket_address),
&socket_address_size) == -1) {
return;
}
// Get the port number
port_ = ntohs(socket_address.sin_port);
// Set server_thread_ operation to socket listening
server_thread_ = std::thread(ServerLoop, listening_socket, socket_address);
}
} // namespace curl::tests