Support HTTP/1.1 persistent connections (not that useful yet).

diff --git a/client.h b/client.h
index 834ddad9cd2227e7b302674d33e67d49783ca1f1..ed04bc02f888f85572364d1b363a7ce01b59175a 100644 (file)
--- 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 05ff37ce4ab2c1032a251a8a574d1741c854f17d..4b34e85ddd146d5a2dd240aea551bd9498757f14 100644 (file)
--- 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 852ecddf1f6212bfb1efb93d050d4fc37473a673..1deb087b056dc2ff1bf3cf426d71fff8c090d29b 100644 (file)
--- 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<string> 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<string> 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<string, string>::const_iterator connection_it = headers.find("Connection");
+               if (connection_it != headers.end() && connection_it->second == "close") {
+                       client->close_after_response = true;
+               }
+       }
+
        map<string, int>::const_iterator stream_url_map_it = stream_url_map.find(url);
        if (stream_url_map_it == stream_url_map.end()) {
                map<string, string>::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<char *>(&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<string, string>::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 68e72c4d543165e938a3e63810395727629c85ae..6007626dd57d5e14953b4f9b905e94fbc08d74c9 100644 (file)
--- 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);