Socket::Adapter &sock,

const ServerSettings &settings,

ServerControls &controls

) noexcept

: ServerProtocol(sock, settings, controls)

{

const Http::StatusCode status,

std::vector<std::pair<std::string, std::string> > &headers,

const std::chrono::milliseconds &timeout,

const bool endStream

) const {

static const std::unordered_map<int, std::string> status_list {

{ 200, "OK" },

{ 206, "Partial Content" },

{ 304, "Not Modified" },

{ 400, "Bad Request" },

{ 404, "Not Found" },

{ 413, "Request Entity Too Large" },

{ 416, "Requested Range Not Satisfiable" },

{ 500, "Internal Server Error" },

};

std::string str = "HTTP/1.1 " + std::to_string(static_cast<int>(status) );

auto const it = status_list.find(static_cast<int>(status) );

if (status_list.cend() != it) {

const std::string &status = it->second;

str += ' ' + status;

}

str += "\r\n";

for (auto const &header : headers) {

str += header.first + ": " + header.second + "\r\n";

}

str += "\r\n";

return this->sock.nonblock_send(str, timeout) > 0; // >= 0

const void *src,

size_t size,

const std::chrono::milliseconds &timeout,

DataTransfer *dt

) const {

const long send_size = this->sock.nonblock_send(

src,

size,

timeout

);

if (send_size > 0) {

dt->send_total += static_cast<size_t>(send_size);

}

return send_size;

std::vector<char> &buf,

const struct Request &req,

const std::string &rootDir

) const {

Utils::packNumber(buf, static_cast<size_t>(Transfer::ProtocolVariant::HTTP_1) );

Utils::packString(buf, rootDir);

Utils::packString(buf, req.host);

Utils::packString(buf, req.path);

Utils::packString(buf, req.method);

Utils::packContainer(buf, req.incoming_headers);

Utils::packContainer(buf, req.incoming_data);

Utils::packFilesIncoming(buf, req.incoming_files);

return true;

struct Request &req,

const void *src

) const {

Utils::unpackContainer(

req.outgoing_headers,

reinterpret_cast<const uint8_t *>(src)

);

const Socket::Adapter &sock,

struct Request &req,

std::vector<char> &buf,

std::string &str_buf

) {

// Получить данные запроса от клиента

const long recv_size = sock.nonblock_recv(

buf,

req.timeout

);

if (recv_size < 0 && str_buf.empty() ) {

return false;

}

if (recv_size > 0) { // Если данные были получены

str_buf.append(

buf.cbegin(),

buf.cbegin() + recv_size

);

}

return true;

struct Request &req,

std::string &str_buf

) {

// Если запрос пустой

if (str_buf.empty() ) {

return Http::StatusCode::BAD_REQUEST;

}

// Поиск конца заголовков (пустая строка)

size_t headers_end = str_buf.find("\r\n\r\n");

// Если найден конец заголовков

if (std::string::npos == headers_end) {

return Http::StatusCode::BAD_REQUEST;

}

headers_end += 2;

size_t str_cur = 0;

// Поиск конца первого заголовка

size_t str_end = str_buf.find("\r\n");

// Если не найден конец заголовка

if (std::string::npos == str_end) {

return Http::StatusCode::BAD_REQUEST;

}

// Установка конца строки (для поиска)

str_buf[str_end] = '\0';

// Разделить метод запроса и параметры запроса

size_t delimiter = str_buf.find(' ', str_cur);

// Получить метод запроса (GET, POST, PUT, DELETE, ...)

req.method = str_buf.substr(

str_cur,

delimiter - str_cur

);

Utils::toLower(req.method);

// Сохранить метод и параметры запроса

// rp.incoming_headers[rp.method] = str_buf.substr(delimiter + 1, str_end - delimiter - 1);

delimiter += 1;

// Найти окончание URI

size_t uri_end = str_buf.find(' ', delimiter);

// Если окончание не найдено

if (std::string::npos == uri_end) {

uri_end = str_end;

// то версия протокола HTTP - 0.9

// const std::string version = "0.9";

} else {

// Если окончание найдено

str_buf[uri_end] = '\0';

const size_t ver_beg = uri_end + 6; // Пропустить "HTTP/"

if (ver_beg < str_end) {

// Получить версию протокола HTTP

// const std::string version = str_buf.substr(ver_beg, str_end - ver_beg);

}

}

// Сохранить полную ссылку URI

req.path = str_buf.substr(delimiter, uri_end - delimiter);

// Переход к обработке следующего заголовка

str_cur = str_end + 2;

// Поиск конца заголовка

str_end = str_buf.find("\r\n", str_cur);

// Установка конца заголовка

str_buf[str_end] = '\0';

// Цикл извлечения заголовков запроса

for (

;

str_cur != headers_end;

str_end = str_buf.find("\r\n", str_cur), str_buf[str_end] = '\0'

) {

// Поиск разделителя названия заголовка и его значения

delimiter = str_buf.find(':', str_cur);

// Если разделитель найден в текущей строке

if (delimiter < str_end)

{

std::string header_name = str_buf.substr(

str_cur,

delimiter - str_cur

);

Utils::toLower(header_name);

std::string header_value = str_buf.substr(

delimiter + 1,

str_end - delimiter - 1

);

// Удалить лишние пробелы в начале и в конце строки

Utils::trim(header_value);

// Сохранить заголовок и его значение

req.incoming_headers.emplace(

std::move(header_name),

std::move(header_value)

);

}

// Перейти к следующей строке

str_cur = str_end + 2;

}

str_buf.erase(0, headers_end + 2);

return Http::StatusCode::EMPTY;

struct Request &req,

std::string &str_buf,

const ServerApplicationSettings &appSets

) const {

// Определить вариант данных запроса (заодно проверить, есть ли данные)

auto const it = req.incoming_headers.find("content-type");

if (req.incoming_headers.cend() == it) {

return Http::StatusCode::EMPTY;

}

// Получить значение заголовка

const std::string &header_value = it->second;

std::string data_variant_name; // Название варианта данных запроса

std::unordered_map<std::string, std::string> content_params;

// Определить, содержит ли тип данных запроса дополнительные параметры

size_t delimiter = header_value.find(';');

// Если есть дополнительные параметры - извлекаем их

if (std::string::npos != delimiter)

{

data_variant_name = header_value.substr(0, delimiter);

Utils::trim(data_variant_name);

for (

size_t str_param_cur = delimiter + 1, str_param_end = 0;

std::string::npos != str_param_end;

str_param_cur = str_param_end + 1

) {

str_param_end = header_value.find(';', str_param_cur);

delimiter = header_value.find('=', str_param_cur);

if (delimiter >= str_param_end)

{

std::string param_name = header_value.substr(

str_param_cur,

std::string::npos != str_param_end

? str_param_end - str_param_cur

: std::string::npos

);

Utils::trim(param_name);

content_params.emplace(

std::move(param_name),

std::string()

);

}

else

{

std::string param_name = header_value.substr(

str_param_cur,

delimiter - str_param_cur

);

Utils::trim(param_name);

++delimiter;

std::string param_value = header_value.substr(

delimiter,

std::string::npos != str_param_end

? str_param_end - delimiter

: std::string::npos

);

Utils::trim(param_value);

content_params.emplace(

std::move(param_name),

std::move(param_value)

);

}

}

} else {

data_variant_name = header_value;

}

// Поиск варианта данных по имени типа

auto const variant = this->settings.variants.find(data_variant_name);

// Если сервер не поддерживает формат полученных данных

if (this->settings.variants.cend() == variant) {

return Http::StatusCode::BAD_REQUEST;

}

const DataVariant::Abstract *data_variant = variant->second;

// Получить длину запроса в байтах

size_t data_length = 0;

auto const it_len = req.incoming_headers.find("content-length");

if (req.incoming_headers.cend() != it_len) {

data_length = std::strtoull(

it_len->second.c_str(),

nullptr,

10

);

}

// Если размер запроса превышает лимит (если лимит был установлен)

if (data_length > appSets.request_max_size && 0 != appSets.request_max_size) {

return Http::StatusCode::REQUEST_ENTITY_TOO_LARGE;

}

Transfer::request_data *rd = static_cast<Transfer::request_data *>(&req);

DataVariant::DataReceiver dr {

data_variant,

data_variant->createStateStruct(rd, content_params),

data_length,

0, 0, nullptr,

};

std::string data_buf;

if (str_buf.length() <= data_length) {

dr.recv_total = str_buf.length();

data_buf.swap(str_buf);

} else {

data_buf.assign(

str_buf, 0, data_length

);

str_buf.erase(0, data_length);

dr.recv_total = data_buf.size();

}

bool result = data_variant->parse(data_buf, rd, &dr);

while (result && dr.full_size > dr.recv_total)

{

std::vector<char> buf(

dr.full_size - dr.recv_total >= 512 * 1024

? 512 * 1024

: dr.full_size - dr.recv_total

);

long recv_size = this->sock.nonblock_recv(

buf.data(),

buf.size(),

req.timeout

);

if (recv_size <= 0) {

result = false;

break;

}

dr.recv_total += static_cast<size_t>(recv_size);

data_buf.erase(

0, data_buf.length() - dr.left

);

data_buf.append(

buf.data(),

0, static_cast<size_t>(recv_size)

);

dr.left = 0;

result = data_variant->parse(data_buf, rd, &dr);

}

data_variant->destroyStateStruct(dr.ss);

if (false == result) {

for (auto const &it : req.incoming_files) {

std::remove(it.second.getTmpName().c_str() );

}

return Http::StatusCode::BAD_REQUEST;

}

if (dr.left) {

str_buf.assign(

data_buf,

data_buf.length() - dr.left,

data_buf.length()

);

}

return Http::StatusCode::EMPTY;

const Socket::Adapter &sock,

const struct Request &req,

const Http::StatusCode statusCode

) {

static const std::unordered_map<int, std::string> status_list {

{ 400, "Bad Request" },

{ 404, "Not Found" },

{ 413, "Request Entity Too Large" },

};

auto const it = status_list.find(static_cast<int>(statusCode) );

if (status_list.cend() != it) {

const std::string &status = it->second;

std::string headers("HTTP/1.1 " + std::to_string(static_cast<int>(statusCode) ) + ' ' + status + "\r\n\r\n");

sock.nonblock_send(headers, req.timeout);

}

struct Request &req,

const bool isSecureConnection

) {

auto const it_in_connection = req.incoming_headers.find("connection");

auto const it_out_connection = req.outgoing_headers.find("connection");

if (

req.incoming_headers.cend() != it_in_connection &&

req.outgoing_headers.cend() != it_out_connection

) {

const std::string connection_in = Utils::getLowerString(it_in_connection->second);

const std::string connection_out = Utils::getLowerString(it_out_connection->second);

auto const incoming_params = Utils::explode(connection_in, ',');

auto const it = std::find(

incoming_params.cbegin(),

incoming_params.cend(),

connection_out

);

if (incoming_params.cend() != it)

{

const std::string &inc = *it;

if ("keep-alive" == inc)

{

--req.keep_alive_count;

if (0 < req.keep_alive_count) {

req.connection_params |= ConnectionParams::CONNECTION_REUSE;

}

}

else if ("upgrade" == inc)

{

auto const it_out_upgrade = req.outgoing_headers.find("upgrade");

if (req.outgoing_headers.cend() != it_out_upgrade)

{

const std::string upgrade = Utils::getLowerString(it_out_upgrade->second);

if ("h2" == upgrade) {

if (isSecureConnection) {

req.protocol_variant = Transfer::ProtocolVariant::HTTP_2;

req.connection_params |= ConnectionParams::CONNECTION_REUSE;

}

}

else if ("h2c" == upgrade) {

if (false == isSecureConnection) {

req.protocol_variant = Transfer::ProtocolVariant::HTTP_2;

req.connection_params |= ConnectionParams::CONNECTION_REUSE;

}

}

else if ("websocket" == upgrade) {

req.connection_params |= ConnectionParams::CONNECTION_LEAVE_OPEN;

}

}

}

}

}

struct Request &req,

std::vector<char> &buf,

std::string &str_buf

) const {

if (getRequest(this->sock, req, buf, str_buf) == false) {

return;

}

Http::StatusCode error_code = getRequestHeaders(req, str_buf);

if (error_code != Http::StatusCode::EMPTY) {

sendStatus(this->sock, req, error_code);

return;

}

const ServerApplicationSettings *app_sets = this->getApplicationSettings(

req,

this->sock.get_tls_session() != nullptr

);

// Если приложение не найдено

if (nullptr == app_sets) {

sendStatus(this->sock, req, Http::StatusCode::NOT_FOUND);

return;

}

error_code = this->getRequestData(req, str_buf, *app_sets);

if (error_code != Http::StatusCode::EMPTY) {

sendStatus(this->sock, req, error_code);

return;

}

this->runApplication(req, *app_sets);

for (auto const &it : req.incoming_files) {

std::remove(it.second.getTmpName().c_str() );

}

if (EXIT_SUCCESS == req.app_exit_code) {

getConnectionParams(

req,

this->sock.get_tls_session() != nullptr

);

Sendfile::xSendfile(

std::ref(*this),

req,

this->settings.mimes_types

);

}