From: Steinar H. Gunderson Date: Tue, 3 Apr 2018 21:29:45 +0000 (+0200) Subject: Support HTTP/1.1 persistent connections (not that useful yet). X-Git-Tag: 1.4.0~28 X-Git-Url: https://git.sesse.net/?p=cubemap;a=commitdiff_plain;h=1135808bf9df44b879994e6dac07a31eb78c2fdb;ds=sidebyside Support HTTP/1.1 persistent connections (not that useful yet). --- diff --git a/client.h b/client.h index 834ddad..ed04bc0 100644 --- a/client.h +++ b/client.h @@ -58,11 +58,21 @@ struct Client { std::string url; Stream *stream = nullptr; + // Whether we should close the connection after sending the response. + // Not relevant for READING_REQUEST. Must be true if http_11 is false. + bool close_after_response; + + // Whether the request came in over HTTP/1.1 or higher. + bool http_11; + // The header we want to send, or the response with headers if we know // it in its entirety after reading the request (typically an error). // This is nominally a copy of Stream::header, but since that might // change on reconnects etc., we keep a local copy here. Only relevant // for SENDING_HEADER or SENDING_SHORT_RESPONSE; blank otherwise. + // + // Must start with the string "HTTP/1.0 ", which will be changed to 1.1 + // if relevant. std::string header_or_short_response; // Number of bytes we've sent of the header. Only relevant for SENDING_HEADER diff --git a/httpinput.cpp b/httpinput.cpp index 05ff37c..4b34e85 100644 --- a/httpinput.cpp +++ b/httpinput.cpp @@ -271,10 +271,9 @@ bool HTTPInput::parse_response(const string &request) } } - // Set “Connection: close”. + // Erase “Connection: close”; we'll set it on the sending side if needed. // TODO: Make case-insensitive. parameters.erase("Connection"); - parameters.insert(make_pair("Connection", "close")); // Construct the new HTTP header. http_header = "HTTP/1.0 200 OK\r\n"; diff --git a/server.cpp b/server.cpp index 852ecdd..1deb087 100644 --- a/server.cpp +++ b/server.cpp @@ -526,9 +526,14 @@ sending_header_or_short_response_again: client->header_or_short_response.clear(); if (client->state == Client::SENDING_SHORT_RESPONSE) { - // We're done sending the error, so now close. - // This is postcondition #1. - close_client(client); + if (more_requests(client)) { + // We're done sending the error, but should keep on reading new requests. + goto read_request_again; + } else { + // We're done sending the error, so now close. + // This is postcondition #1. + close_client(client); + } return; } @@ -801,6 +806,7 @@ void Server::skip_lost_data(Client *client) int Server::parse_request(Client *client) { vector lines = split_lines(client->request); + client->request.clear(); if (lines.empty()) { return 400; // Bad request (empty). } @@ -818,7 +824,7 @@ int Server::parse_request(Client *client) } vector request_tokens = split_tokens(lines[0]); - if (request_tokens.size() < 2) { + if (request_tokens.size() < 3) { return 400; // Bad request (empty). } if (request_tokens[0] != "GET") { @@ -834,6 +840,24 @@ int Server::parse_request(Client *client) client->stream_pos = -1; } + // Figure out if we're supposed to close the socket after we've delivered the response. + string protocol = request_tokens[2]; + if (protocol.find("HTTP/") != 0) { + return 400; // Bad request. + } + client->close_after_response = false; + client->http_11 = true; + if (protocol == "HTTP/1.0") { + // No persistent connections. + client->close_after_response = true; + client->http_11 = false; + } else { + multimap::const_iterator connection_it = headers.find("Connection"); + if (connection_it != headers.end() && connection_it->second == "close") { + client->close_after_response = true; + } + } + map::const_iterator stream_url_map_it = stream_url_map.find(url); if (stream_url_map_it == stream_url_map.end()) { map::const_iterator ping_url_map_it = ping_url_map.find(url); @@ -849,6 +873,12 @@ int Server::parse_request(Client *client) return 503; // Service unavailable. } + // Streams currently never end, so we don't have a content-length, + // and can just as well tell the client it's Connection: close + // (otherwise, we'd have to implement chunking TE for no good reason). + // When we start to support fragments, this will change. + client->close_after_response = true; + client->stream = stream; if (setsockopt(client->sock, SOL_SOCKET, SO_MAX_PACING_RATE, &client->stream->pacing_rate, sizeof(client->stream->pacing_rate)) == -1) { if (client->stream->pacing_rate != ~0U) { @@ -863,14 +893,22 @@ int Server::parse_request(Client *client) void Server::construct_header(Client *client) { Stream *stream = client->stream; + client->header_or_short_response = stream->http_header; + if (client->http_11) { + assert(client->header_or_short_response.find("HTTP/1.0") == 0); + client->header_or_short_response[7] = '1'; // Change to HTTP/1.1. + if (client->close_after_response) { + client->header_or_short_response.append("Connection: close\r\n"); + } + } else { + assert(client->close_after_response); + } if (stream->encoding == Stream::STREAM_ENCODING_RAW) { - client->header_or_short_response = stream->http_header + - "\r\n" + - stream->stream_header; + client->header_or_short_response.append("\r\n"); } else if (stream->encoding == Stream::STREAM_ENCODING_METACUBE) { - client->header_or_short_response = stream->http_header + - "Content-encoding: metacube\r\n" + - "\r\n"; + client->header_or_short_response.append( + "Content-encoding: metacube\r\n" + "\r\n"); if (!stream->stream_header.empty()) { metacube2_block_header hdr; memcpy(hdr.sync, METACUBE2_SYNC, sizeof(hdr.sync)); @@ -880,10 +918,10 @@ void Server::construct_header(Client *client) client->header_or_short_response.append( string(reinterpret_cast(&hdr), sizeof(hdr))); } - client->header_or_short_response.append(stream->stream_header); } else { assert(false); } + client->header_or_short_response.append(stream->stream_header); // Switch states. client->state = Client::SENDING_HEADER; @@ -893,8 +931,15 @@ void Server::construct_header(Client *client) void Server::construct_error(Client *client, int error_code) { char error[256]; - snprintf(error, 256, "HTTP/1.0 %d Error\r\nContent-type: text/plain\r\n\r\nSomething went wrong. Sorry.\r\n", - error_code); + if (client->http_11 && client->close_after_response) { + snprintf(error, sizeof(error), + "HTTP/1.1 %d Error\r\nContent-type: text/plain\r\nConnection: close\r\n\r\nSomething went wrong. Sorry.\r\n", + error_code); + } else { + snprintf(error, sizeof(error), + "HTTP/1.%d %d Error\r\nContent-type: text/plain\r\nContent-length: 30\r\n\r\nSomething went wrong. Sorry.\r\n", + client->http_11, error_code); + } client->header_or_short_response = error; // Switch states. @@ -907,19 +952,20 @@ void Server::construct_204(Client *client) map::const_iterator ping_url_map_it = ping_url_map.find(client->url); assert(ping_url_map_it != ping_url_map.end()); - if (ping_url_map_it->second.empty()) { - client->header_or_short_response = - "HTTP/1.0 204 No Content\r\n" - "\r\n"; + if (client->http_11) { + client->header_or_short_response = "HTTP/1.1 204 No Content\r\n"; + if (client->close_after_response) { + client->header_or_short_response.append("Connection: close\r\n"); + } } else { - char response[256]; - snprintf(response, 256, - "HTTP/1.0 204 No Content\r\n" - "Access-Control-Allow-Origin: %s\r\n" - "\r\n", - ping_url_map_it->second.c_str()); - client->header_or_short_response = response; + client->header_or_short_response = "HTTP/1.0 204 No Content\r\n"; + assert(client->close_after_response); } + if (!ping_url_map_it->second.empty()) { + client->header_or_short_response.append("Access-Control-Allow-Origin: "); + client->header_or_short_response.append(ping_url_map_it->second); + } + client->header_or_short_response.append("\r\n"); // Switch states. client->state = Client::SENDING_SHORT_RESPONSE; @@ -971,6 +1017,24 @@ void Server::change_epoll_events(Client *client, uint32_t events) } } +bool Server::more_requests(Client *client) +{ + if (client->close_after_response) { + return false; + } + + // Switch states and reset the parsers. We don't reset statistics. + client->state = Client::READING_REQUEST; + client->url.clear(); + client->stream = NULL; + client->header_or_short_response.clear(); + client->header_or_short_response_bytes_sent = 0; + + change_epoll_events(client, EPOLLIN | EPOLLET | EPOLLRDHUP); // No TLS handshake, so no EPOLLOUT needed. + + return true; +} + void Server::process_queued_data() { { diff --git a/server.h b/server.h index 68e72c4..6007626 100644 --- a/server.h +++ b/server.h @@ -162,6 +162,11 @@ private: // Listen for a different set of epoll events. void change_epoll_events(Client *client, uint32_t events); + // If we're supposed to listen for more requests (persistent HTTP connections), + // puts the client back into READING_REQUEST, changes its epoll flags and returns + // true. + bool more_requests(Client *client); + // Parse the HTTP request. Returns a HTTP status code (200/204/400/404). int parse_request(Client *client);