Fix an unlikely leak in HTTPInput.

[cubemap] / httpinput.cpp

diff --git a/httpinput.cpp b/httpinput.cpp
index 05ff37ce4ab2c1032a251a8a574d1741c854f17d..cbffe3ae26292e11dd550156fce840120dd3031e 100644 (file)
--- a/httpinput.cpp
+++ b/httpinput.cpp
@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <errno.h>
+#include <math.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <poll.h>
@@ -166,6 +167,7 @@ int HTTPInput::lookup_and_connect(const string &host, const string &port)
                if (ioctl(sock, FIONBIO, &one) == -1) {
                        log_perror("ioctl(FIONBIO)");
                        safe_close(sock);
+                       freeaddrinfo(base_ai);
                        return -1;                      
                }
 
@@ -248,17 +250,15 @@ bool HTTPInput::parse_response(const string &request)
                return false;
        }
 
-       multimap<string, string> parameters = extract_headers(lines, url);
+       HTTPHeaderMultimap parameters = extract_headers(lines, url);
 
        // Remove “Content-encoding: metacube”.
-       // TODO: Make case-insensitive.
-       const auto encoding_it = parameters.find("Content-encoding");
+       const auto encoding_it = parameters.find("Content-Encoding");
        if (encoding_it != parameters.end() && encoding_it->second == "metacube") {
                parameters.erase(encoding_it);
        }
 
        // Change “Server: foo” to “Server: metacube/0.1 (reflecting: foo)”
-       // TODO: Make case-insensitive.
        // XXX: Use a Via: instead?
        if (parameters.count("Server") == 0) {
                parameters.insert(make_pair("Server", SERVER_IDENTIFICATION));
@@ -271,10 +271,8 @@ bool HTTPInput::parse_response(const string &request)
                }
        }
 
-       // Set “Connection: close”.
-       // TODO: Make case-insensitive.
+       // Erase “Connection: close”; we'll set it on the sending side if needed.
        parameters.erase("Connection");
-       parameters.insert(make_pair("Connection", "close"));
 
        // Construct the new HTTP header.
        http_header = "HTTP/1.0 200 OK\r\n";
@@ -569,7 +567,7 @@ void HTTPInput::process_data(char *ptr, size_t bytes)
 
        if (encoding == Input::INPUT_ENCODING_RAW) {
                for (int stream_index : stream_indices) {
-                       servers->add_data(stream_index, ptr, bytes, /*metacube_flags=*/0);
+                       servers->add_data(stream_index, ptr, bytes, /*metacube_flags=*/0, /*pts=*/RationalPTS());
                }
                return;
        }
@@ -660,8 +658,9 @@ void HTTPInput::process_data(char *ptr, size_t bytes)
                                }
                        }
                        for (int stream_index : stream_indices) {
-                               servers->add_data(stream_index, inner_data, size, flags);
+                               servers->add_data(stream_index, inner_data, size, flags, next_block_pts);
                        }
+                       next_block_pts = RationalPTS();
                }
 
                // Consume the block. This isn't the most efficient way of dealing with things
@@ -704,25 +703,36 @@ void HTTPInput::process_metacube_metadata_block(const metacube2_block_header &hd
        }
 
        uint64_t type = be64toh(*(const uint64_t *)payload);
-       if (type != METACUBE_METADATA_TYPE_ENCODER_TIMESTAMP) {
-               // Unknown metadata block, ignore.
-               return;
-       }
-
-       timespec now;
-       clock_gettime(CLOCK_REALTIME, &now);
+       if (type == METACUBE_METADATA_TYPE_ENCODER_TIMESTAMP) {
+               timespec now;
+               clock_gettime(CLOCK_REALTIME, &now);
+
+               const metacube2_timestamp_packet *pkt = (const metacube2_timestamp_packet *)payload;
+               if (payload_size != sizeof(*pkt)) {
+                       log(WARNING, "[%s] Metacube timestamp block of wrong size (%d bytes); ignoring.",
+                               url.c_str(), payload_size);
+                       return;
+               }
 
-       const metacube2_timestamp_packet *pkt = (const metacube2_timestamp_packet *)payload;
-       if (payload_size != sizeof(*pkt)) {
-               log(WARNING, "[%s] Metacube timestamp block of wrong size (%d bytes); ignoring.",
-                       url.c_str(), payload_size);
+               double elapsed = now.tv_sec - be64toh(pkt->tv_sec) +
+                       1e-9 * (now.tv_nsec - long(be64toh(pkt->tv_nsec)));
+               {
+                       lock_guard<mutex> lock(stats_mutex);
+                       stats.latency_sec = elapsed;
+               }
+       } else if (type == METACUBE_METADATA_TYPE_NEXT_BLOCK_PTS) {
+               const metacube2_pts_packet *pkt = (const metacube2_pts_packet *)payload;
+               if (payload_size != sizeof(*pkt)) {
+                       log(WARNING, "[%s] Metacube pts block of wrong size (%d bytes); ignoring.",
+                               url.c_str(), payload_size);
+                       return;
+               }
+               next_block_pts.pts = be64toh(pkt->pts);
+               next_block_pts.timebase_num = be64toh(pkt->timebase_num);
+               next_block_pts.timebase_den = be64toh(pkt->timebase_den);
+       } else {
+               // Unknown metadata block, ignore
+               log(INFO, "[%s] Metadata block %llu\n", url.c_str(), type);
                return;
        }
-
-       double elapsed = now.tv_sec - be64toh(pkt->tv_sec) +
-               1e-9 * (now.tv_nsec - long(be64toh(pkt->tv_nsec)));
-       {
-               lock_guard<mutex> lock(stats_mutex);
-               stats.latency_sec = elapsed;
-       }
 }