Rename header_or_error to header_or_short_response, as it will soon be able to contai...

[cubemap] / server.cpp

diff --git a/server.cpp b/server.cpp
index 72664e33f665eda4bd09e49d22789e546b4ee81f..615e8fb31d48b137df3cdcb3acf8caa4cbf00c68 100644 (file)
--- a/server.cpp
+++ b/server.cpp
@@ -423,17 +423,17 @@ read_request_again:
                }
 
                // We've changed states, so fall through.
                }
 
                // We've changed states, so fall through.

-               assert(client->state == Client::SENDING_ERROR ||
+               assert(client->state == Client::SENDING_SHORT_RESPONSE ||

                       client->state == Client::SENDING_HEADER);
        }
                       client->state == Client::SENDING_HEADER);
        }

-       case Client::SENDING_ERROR:
+       case Client::SENDING_SHORT_RESPONSE:

        case Client::SENDING_HEADER: {
        case Client::SENDING_HEADER: {

-sending_header_or_error_again:
+sending_header_or_short_response_again:

                int ret;
                do {
                        ret = write(client->sock,
                int ret;
                do {
                        ret = write(client->sock,

-                                   client->header_or_error.data() + client->header_or_error_bytes_sent,
-                                   client->header_or_error.size() - client->header_or_error_bytes_sent);
+                                   client->header_or_short_response.data() + client->header_or_short_response_bytes_sent,
+                                   client->header_or_short_response.size() - client->header_or_short_response_bytes_sent);

                } while (ret == -1 && errno == EINTR);
 
                if (ret == -1 && errno == EAGAIN) {
                } while (ret == -1 && errno == EINTR);
 
                if (ret == -1 && errno == EAGAIN) {


@@ -451,18 +451,18 @@ sending_header_or_error_again:
                        return;
                }
                
                        return;
                }
                

-               client->header_or_error_bytes_sent += ret;
-               assert(client->header_or_error_bytes_sent <= client->header_or_error.size());
+               client->header_or_short_response_bytes_sent += ret;
+               assert(client->header_or_short_response_bytes_sent <= client->header_or_short_response.size());

 
 

-               if (client->header_or_error_bytes_sent < client->header_or_error.size()) {
+               if (client->header_or_short_response_bytes_sent < client->header_or_short_response.size()) {

                        // We haven't sent all yet. Fine; go another round.
                        // We haven't sent all yet. Fine; go another round.

-                       goto sending_header_or_error_again;
+                       goto sending_header_or_short_response_again;

                }
 
                // We're done sending the header or error! Clear it to release some memory.
                }
 
                // We're done sending the header or error! Clear it to release some memory.

-               client->header_or_error.clear();
+               client->header_or_short_response.clear();

 
 

-               if (client->state == Client::SENDING_ERROR) {
+               if (client->state == Client::SENDING_SHORT_RESPONSE) {

                        // We're done sending the error, so now close.  
                        // This is postcondition #1.
                        close_client(client);
                        // We're done sending the error, so now close.  
                        // This is postcondition #1.
                        close_client(client);


@@ -670,11 +670,11 @@ void Server::construct_header(Client *client)
 {
        Stream *stream = client->stream;
        if (stream->encoding == Stream::STREAM_ENCODING_RAW) {
 {
        Stream *stream = client->stream;
        if (stream->encoding == Stream::STREAM_ENCODING_RAW) {

-               client->header_or_error = stream->http_header +
+               client->header_or_short_response = stream->http_header +

                        "\r\n" +
                        stream->stream_header;
        } else if (stream->encoding == Stream::STREAM_ENCODING_METACUBE) {
                        "\r\n" +
                        stream->stream_header;
        } else if (stream->encoding == Stream::STREAM_ENCODING_METACUBE) {

-               client->header_or_error = stream->http_header +
+               client->header_or_short_response = stream->http_header +

                        "Content-encoding: metacube\r\n" +
                        "\r\n";
                if (!stream->stream_header.empty()) {
                        "Content-encoding: metacube\r\n" +
                        "\r\n";
                if (!stream->stream_header.empty()) {


@@ -683,10 +683,10 @@ void Server::construct_header(Client *client)
                        hdr.size = htonl(stream->stream_header.size());
                        hdr.flags = htons(METACUBE_FLAGS_HEADER);
                        hdr.csum = htons(metacube2_compute_crc(&hdr));
                        hdr.size = htonl(stream->stream_header.size());
                        hdr.flags = htons(METACUBE_FLAGS_HEADER);
                        hdr.csum = htons(metacube2_compute_crc(&hdr));

-                       client->header_or_error.append(
+                       client->header_or_short_response.append(

                                string(reinterpret_cast<char *>(&hdr), sizeof(hdr)));
                }
                                string(reinterpret_cast<char *>(&hdr), sizeof(hdr)));
                }

-               client->header_or_error.append(stream->stream_header);
+               client->header_or_short_response.append(stream->stream_header);

        } else {
                assert(false);
        }
        } else {
                assert(false);
        }


@@ -709,10 +709,10 @@ 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);
        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);

-       client->header_or_error = error;
+       client->header_or_short_response = error;

 
        // Switch states.
 
        // Switch states.

-       client->state = Client::SENDING_ERROR;
+       client->state = Client::SENDING_SHORT_RESPONSE;

 
        epoll_event ev;
        ev.events = EPOLLOUT | EPOLLET | EPOLLRDHUP;
 
        epoll_event ev;
        ev.events = EPOLLOUT | EPOLLET | EPOLLRDHUP;