Fix an ineffective assert.

[cubemap] / server.cpp

diff --git a/server.cpp b/server.cpp
index c12bc8dee370e7e51f692b2d3f5a52aab3cce0e8..5c1f31bef451300f5cdf335261a7c9fd2aaedbae 100644 (file)
--- a/server.cpp
+++ b/server.cpp
@@ -435,7 +435,6 @@ void Server::set_hls_backlog_margin(int stream_index, size_t hls_backlog_margin)
 {
        lock_guard<mutex> lock(mu);
        assert(stream_index >= 0 && stream_index < ssize_t(streams.size()));
-       assert(hls_backlog_margin >= 0);
        assert(hls_backlog_margin < streams[stream_index]->backlog_size);
        streams[stream_index]->hls_backlog_margin = hls_backlog_margin;
 }
@@ -525,7 +524,7 @@ void Server::process_client(Client *client)
 {
        switch (client->state) {
        case Client::READING_REQUEST: {
-               if (client->tls_context != nullptr) {
+               if (client->tls_context != nullptr && !client->in_ktls_mode) {
                        if (send_pending_tls_data(client)) {
                                // send_pending_tls_data() hit postconditions #1 or #4.
                                return;
@@ -536,10 +535,10 @@ read_request_again:
                // Try to read more of the request.
                char buf[1024];
                int ret;
-               if (client->tls_context == nullptr) {
-                       ret = read_nontls_data(client, buf, sizeof(buf));
+               if (client->tls_context == nullptr || client->in_ktls_mode) {
+                       ret = read_plain_data(client, buf, sizeof(buf));
                        if (ret == -1) {
-                               // read_nontls_data() hit postconditions #1 or #2.
+                               // read_plain_data() hit postconditions #1 or #2.
                                return;
                        }
                } else {
@@ -571,22 +570,6 @@ read_request_again:
 
                assert(status == RP_FINISHED);
 
-               if (client->tls_context && !client->in_ktls_mode && tls_established(client->tls_context)) {
-                       // We're ready to enter kTLS mode, unless we still have some
-                       // handshake data to send (which then must be sent as non-kTLS).
-                       if (send_pending_tls_data(client)) {
-                               // send_pending_tls_data() hit postconditions #1 or #4.
-                               return;
-                       }
-                       ret = tls_make_ktls(client->tls_context, client->sock);
-                       if (ret < 0) {
-                               log_tls_error("tls_make_ktls", ret);
-                               close_client(client);
-                               return;
-                       }
-                       client->in_ktls_mode = true;
-               }
-
                int error_code = parse_request(client);
                if (error_code == 200) {
                        if (client->serving_hls_playlist) {
@@ -666,7 +649,7 @@ sending_header_or_short_response_again:
                } else if (client->stream_pos_end != Client::STREAM_POS_NO_END) {
                        // We're sending a fragment, and should have all of it,
                        // so start sending right away.
-                       assert(client->stream_pos >= 0);
+                       assert(ssize_t(client->stream_pos) >= 0);
                        client->state = Client::SENDING_DATA;
                        goto sending_data;
                } else if (stream->prebuffering_bytes == 0) {
@@ -688,7 +671,7 @@ sending_header_or_short_response_again:
                        // 100 kB prebuffer but end up sending a 10 MB GOP.
                        assert(client->stream_pos == Client::STREAM_POS_AT_END);
                        assert(client->stream_pos_end == Client::STREAM_POS_NO_END);
-                       deque<size_t>::const_iterator starting_point_it =
+                       deque<uint64_t>::const_iterator starting_point_it =
                                lower_bound(stream->suitable_starting_points.begin(),
                                            stream->suitable_starting_points.end(),
                                            stream->bytes_received - stream->prebuffering_bytes);
@@ -886,7 +869,7 @@ send_data_again:
        goto send_data_again;
 }
 
-int Server::read_nontls_data(Client *client, char *buf, size_t max_size)
+int Server::read_plain_data(Client *client, char *buf, size_t max_size)
 {
        int ret;
        do {
@@ -915,6 +898,8 @@ int Server::read_nontls_data(Client *client, char *buf, size_t max_size)
 int Server::read_tls_data(Client *client, char *buf, size_t max_size)
 {
 read_again:
+       assert(!client->in_ktls_mode);
+
        int ret;
        do {
                ret = read(client->sock, buf, max_size);
@@ -965,6 +950,22 @@ read_again:
                return -1;
        }
 
+       if (tls_established(client->tls_context)) {
+               // We're ready to enter kTLS mode, unless we still have some
+               // handshake data to send (which then must be sent as non-kTLS).
+               if (send_pending_tls_data(client)) {
+                       // send_pending_tls_data() hit postconditions #1 or #4.
+                       return -1;
+               }
+               int err = tls_make_ktls(client->tls_context, client->sock);  // Don't overwrite ret.
+               if (err < 0) {
+                       log_tls_error("tls_make_ktls", ret);
+                       close_client(client);
+                       return -1;
+               }
+               client->in_ktls_mode = true;
+       }
+
        assert(ret > 0);
        return ret;
 }