Write our own HTTP client instead of using curl. Not finished yet (missing URL parsin...

[cubemap] / server.cpp

diff --git a/server.cpp b/server.cpp
index d8c68fc4f5117df388d9d9c852f351ce92f8d330..f06685ab02224ea654b85d82f09d35a5dc456a5c 100644 (file)
--- a/server.cpp
+++ b/server.cpp
@@ -3,7 +3,6 @@
 #include <stdint.h>
 #include <assert.h>
 #include <arpa/inet.h>
-#include <curl/curl.h>
 #include <sys/socket.h>
 #include <pthread.h>
 #include <sys/types.h>
@@ -109,6 +108,7 @@ void Stream::wake_up_all_clients()
 Server::Server()
 {
        pthread_mutex_init(&mutex, NULL);
+       pthread_mutex_init(&queued_data_mutex, NULL);
 
        epoll_fd = epoll_create(1024);  // Size argument is ignored.
        if (epoll_fd == -1) {
@@ -178,6 +178,8 @@ void Server::do_work()
                        return;
                }
 
+               process_queued_data();
+
                for (int i = 0; i < nfds; ++i) {
                        int fd = events[i].data.fd;
                        assert(clients.count(fd) != 0);
@@ -203,8 +205,11 @@ void Server::do_work()
        }
 }
 
-CubemapStateProto Server::serialize() const
+CubemapStateProto Server::serialize()
 {
+       // We don't serialize anything queued, so empty the queues.
+       process_queued_data();
+
        CubemapStateProto serialized;
        for (map<int, Client>::const_iterator client_it = clients.begin();
             client_it != clients.end();
@@ -219,9 +224,14 @@ CubemapStateProto Server::serialize() const
        return serialized;
 }
 
+void Server::add_client_deferred(int sock)
+{
+       MutexLock lock(&queued_data_mutex);
+       queued_add_clients.push_back(sock);
+}
+
 void Server::add_client(int sock)
 {
-       MutexLock lock(&mutex);
        clients.insert(make_pair(sock, Client(sock)));
 
        // Start listening on data from this socket.
@@ -297,14 +307,15 @@ void Server::set_header(const string &stream_id, const string &header)
                }
        }
 }
-       
-void Server::add_data(const string &stream_id, const char *data, size_t bytes)
+
+void Server::add_data_deferred(const string &stream_id, const char *data, size_t bytes)
 {
-       if (bytes == 0) {
-               return;
-       }
+       MutexLock lock(&queued_data_mutex);
+       queued_data[stream_id].append(string(data, data + bytes));
+}
 
-       MutexLock lock(&mutex);
+void Server::add_data(const string &stream_id, const char *data, size_t bytes)
+{
        Stream *stream = find_stream(stream_id);
        size_t pos = stream->data_size % BACKLOG_SIZE;
        stream->data_size += bytes;
@@ -350,34 +361,27 @@ read_request_again:
                        return;
                }
 
-               // Guard against overlong requests gobbling up all of our space.
-               if (client->request.size() + ret > MAX_CLIENT_REQUEST) {
+               RequestParseStatus status = wait_for_double_newline(&client->request, buf, ret);
+       
+               switch (status) {
+               case RP_OUT_OF_SPACE:
                        fprintf(stderr, "WARNING: fd %d sent overlong request!\n", client->sock);
                        close_client(client);
                        return;
-               }       
-
-               // See if we have \r\n\r\n anywhere in the request. We start three bytes
-               // before what we just appended, in case we just got the final character.
-               size_t existing_req_bytes = client->request.size();
-               client->request.append(string(buf, buf + ret));
-       
-               size_t start_at = (existing_req_bytes >= 3 ? existing_req_bytes - 3 : 0);
-               const char *ptr = reinterpret_cast<char *>(
-                       memmem(client->request.data() + start_at, client->request.size() - start_at,
-                              "\r\n\r\n", 4));
-               if (ptr == NULL) {
+               case RP_NOT_FINISHED_YET:
                        // OK, we don't have the entire header yet. Fine; we'll get it later.
                        // See if there's more data for us.
                        goto read_request_again;
-               }
-
-               if (ptr != client->request.data() + client->request.size() - 4) {
+               case RP_EXTRA_DATA:
                        fprintf(stderr, "WARNING: fd %d had junk data after request!\n", client->sock);
                        close_client(client);
                        return;
+               case RP_FINISHED:
+                       break;
                }
 
+               assert(status == RP_FINISHED);
+
                int error_code = parse_request(client);
                if (error_code == 200) {
                        construct_header(client);
@@ -608,3 +612,20 @@ Stream *Server::find_stream(const string &stream_id)
        assert(it != streams.end());
        return it->second;
 }
+
+void Server::process_queued_data()
+{
+       MutexLock lock(&queued_data_mutex);
+
+       for (size_t i = 0; i < queued_add_clients.size(); ++i) {
+               add_client(queued_add_clients[i]);
+       }
+       queued_add_clients.clear();     
+       
+       for (map<string, string>::iterator queued_it = queued_data.begin();
+            queued_it != queued_data.end();
+            ++queued_it) {
+               add_data(queued_it->first, queued_it->second.data(), queued_it->second.size());
+       }
+       queued_data.clear();
+}