Shutdown microhttpd on shutdown.

[nageru] / httpd.cpp

diff --git a/httpd.cpp b/httpd.cpp
index ed46f52566832d6faa1ac63e0edfe071d8030e6b..d0be7a3bfd47faacbebb950ba5c915c174ade57e 100644 (file)
--- a/httpd.cpp
+++ b/httpd.cpp
@@ -1,3 +1,4 @@
+#include <arpa/inet.h>
 #include <assert.h>
 #include <microhttpd.h>
 #include <stdio.h>
@@ -10,6 +11,7 @@
 
 #include "defs.h"
 #include "flags.h"
+#include "metacube2.h"
 #include "timebase.h"
 
 struct MHD_Connection;
@@ -21,14 +23,23 @@ HTTPD::HTTPD()
 {
 }
 
+HTTPD::~HTTPD()
+{
+       MHD_quiesce_daemon(mhd);
+       for (Stream *stream : streams) {
+               stream->stop();
+       }
+       MHD_stop_daemon(mhd);
+}
+
 void HTTPD::start(int port)
 {
-       MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_POLL_INTERNALLY | MHD_USE_DUAL_STACK,
-                        port,
-                        nullptr, nullptr,
-                        &answer_to_connection_thunk, this,
-                        MHD_OPTION_NOTIFY_COMPLETED, &request_completed_thunk, this, 
-                        MHD_OPTION_END);
+       mhd = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION | MHD_USE_POLL_INTERNALLY | MHD_USE_DUAL_STACK,
+                              port,
+                              nullptr, nullptr,
+                              &answer_to_connection_thunk, this,
+                              MHD_OPTION_NOTIFY_COMPLETED, &request_completed_thunk, this,
+                              MHD_OPTION_END);
 }
 
 void HTTPD::add_data(const char *buf, size_t size, bool keyframe)
@@ -53,7 +64,15 @@ int HTTPD::answer_to_connection(MHD_Connection *connection,
                                const char *version, const char *upload_data,
                                size_t *upload_data_size, void **con_cls)
 {
-       HTTPD::Stream *stream = new HTTPD::Stream;
+       // See if the URL ends in “.metacube”.
+       HTTPD::Stream::Framing framing;
+       if (strstr(url, ".metacube") == url + strlen(url) - strlen(".metacube")) {
+               framing = HTTPD::Stream::FRAMING_METACUBE;
+       } else {
+               framing = HTTPD::Stream::FRAMING_RAW;
+       }
+
+       HTTPD::Stream *stream = new HTTPD::Stream(framing);
        stream->add_data(header.data(), header.size(), Stream::DATA_TYPE_HEADER);
        {
                unique_lock<mutex> lock(streams_mutex);
@@ -64,6 +83,11 @@ int HTTPD::answer_to_connection(MHD_Connection *connection,
        // Does not strictly have to be equal to MUX_BUFFER_SIZE.
        MHD_Response *response = MHD_create_response_from_callback(
                (size_t)-1, MUX_BUFFER_SIZE, &HTTPD::Stream::reader_callback_thunk, stream, &HTTPD::free_stream);
+
+       // TODO: Content-type?
+       if (framing == HTTPD::Stream::FRAMING_METACUBE) {
+               MHD_add_response_header(response, "Content-encoding", "metacube");
+       }
        int ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
        //MHD_destroy_response(response);
 
@@ -107,7 +131,10 @@ ssize_t HTTPD::Stream::reader_callback_thunk(void *cls, uint64_t pos, char *buf,
 ssize_t HTTPD::Stream::reader_callback(uint64_t pos, char *buf, size_t max)
 {
        unique_lock<mutex> lock(buffer_mutex);
-       has_buffered_data.wait(lock, [this]{ return !buffered_data.empty(); });
+       has_buffered_data.wait(lock, [this]{ return should_quit || !buffered_data.empty(); });
+       if (should_quit) {
+               return 0;
+       }
 
        ssize_t ret = 0;
        while (max > 0 && !buffered_data.empty()) {
@@ -148,7 +175,28 @@ void HTTPD::Stream::add_data(const char *buf, size_t buf_size, HTTPD::Stream::Da
        }
 
        unique_lock<mutex> lock(buffer_mutex);
+
+       if (framing == FRAMING_METACUBE) {
+               metacube2_block_header hdr;
+               memcpy(hdr.sync, METACUBE2_SYNC, sizeof(hdr.sync));
+               hdr.size = htonl(buf_size);
+               int flags = 0;
+               if (data_type == DATA_TYPE_HEADER) {
+                       flags |= METACUBE_FLAGS_HEADER;
+               } else if (data_type == DATA_TYPE_OTHER) {
+                       flags |= METACUBE_FLAGS_NOT_SUITABLE_FOR_STREAM_START;
+               }
+               hdr.flags = htons(flags);
+               hdr.csum = htons(metacube2_compute_crc(&hdr));
+               buffered_data.emplace_back((char *)&hdr, sizeof(hdr));
+       }
        buffered_data.emplace_back(buf, buf_size);
        has_buffered_data.notify_all(); 
 }
 
+void HTTPD::Stream::stop()
+{
+       unique_lock<mutex> lock(buffer_mutex);
+       should_quit = true;
+       has_buffered_data.notify_all();
+}