X-Git-Url: https://git.sesse.net/?p=cubemap;a=blobdiff_plain;f=server.cpp;h=08f2afdfc907c38d8858de1715b46ce0ac2c179a;hp=d6b5b5b8b783446ce08e87972b34430b9bf4e547;hb=5f72b6466cca4da0b8de29f4526a6cde23c5368e;hpb=a31f0050d6f82fdfec7218dfbe86f777777e3029 diff --git a/server.cpp b/server.cpp index d6b5b5b..08f2afd 100644 --- a/server.cpp +++ b/server.cpp @@ -13,6 +13,7 @@ #include #include #include +#include #include "metacube.h" #include "server.h" @@ -75,7 +76,7 @@ void Server::add_client(int sock) MutexLock lock(&mutex); Client new_client; new_client.sock = sock; - new_client.client_request.reserve(1024); + new_client.request.reserve(1024); new_client.state = Client::READING_REQUEST; new_client.header_bytes_sent = 0; new_client.bytes_sent = 0; @@ -107,7 +108,26 @@ 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) { - // TODO + if (bytes == 0) { + return; + } + + MutexLock lock(&mutex); + assert(streams.count(stream_id) != 0); + Stream *stream = &streams[stream_id]; + size_t pos = stream->data_size % BACKLOG_SIZE; + stream->data_size += bytes; + + if (pos + bytes > BACKLOG_SIZE) { + size_t to_copy = BACKLOG_SIZE - pos; + memcpy(stream->data + pos, data, to_copy); + data += to_copy; + bytes -= to_copy; + pos = 0; + } + + memcpy(stream->data + pos, data, bytes); + wake_up_all_clients(); } void Server::process_client(Client *client) @@ -131,7 +151,7 @@ void Server::process_client(Client *client) } // Guard against overlong requests gobbling up all of our space. - if (client->client_request.size() + ret > MAX_CLIENT_REQUEST) { + if (client->request.size() + ret > MAX_CLIENT_REQUEST) { fprintf(stderr, "WARNING: fd %d sent overlong request!\n", client->sock); close_client(client); return; @@ -139,19 +159,19 @@ void Server::process_client(Client *client) // 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->client_request.size(); - client->client_request.append(string(buf, buf + ret)); + 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( - memmem(client->client_request.data() + start_at, client->client_request.size() - start_at, + memmem(client->request.data() + start_at, client->request.size() - start_at, "\r\n\r\n", 4)); if (ptr == NULL) { // OK, we don't have the entire header yet. Fine; we'll get it later. return; } - if (ptr != client->client_request.data() + client->client_request.size() - 4) { + if (ptr != client->request.data() + client->request.size() - 4) { fprintf(stderr, "WARNING: fd %d had junk data after request!\n", client->sock); close_client(client); return; @@ -201,10 +221,18 @@ void Server::process_client(Client *client) } // See if we need to split across the circular buffer. - int ret; + ssize_t ret; if ((client->bytes_sent % BACKLOG_SIZE) + bytes_to_send > BACKLOG_SIZE) { - // TODO: writev - assert(false); + size_t bytes_first_part = BACKLOG_SIZE - (client->bytes_sent % BACKLOG_SIZE); + + iovec iov[2]; + iov[0].iov_base = const_cast(stream.data + (client->bytes_sent % BACKLOG_SIZE)); + iov[0].iov_len = bytes_first_part; + + iov[1].iov_base = const_cast(stream.data); + iov[1].iov_len = bytes_to_send - bytes_first_part; + + ret = writev(client->sock, iov, 2); } else { ret = write(client->sock, stream.data + (client->bytes_sent % BACKLOG_SIZE), @@ -215,11 +243,15 @@ void Server::process_client(Client *client) close_client(client); return; } - client->bytes_sent += ret; + client->bytes_sent += ret; + + if (client->bytes_sent == stream.data_size) { + // We don't have any more data for this client, so put it to sleep. + put_client_to_sleep(client); + } break; } default: - // TODO assert(false); } } @@ -228,9 +260,10 @@ void Server::parse_request(Client *client) { // TODO: Actually parse the request. :-) client->stream_id = "stream"; + client->request.clear(); // Construct the header. - client->header = "HTTP/1.0 200 OK\r\nContent-type: todo/fixme\r\n\r\n" + + client->header = "HTTP/1.0 200 OK\r\n Content-type: video/x-flv\r\nCache-Control: no-cache\r\nContent-type: todo/fixme\r\n\r\n" + streams[client->stream_id].header; // Switch states. @@ -252,8 +285,41 @@ void Server::close_client(Client *client) perror("epoll_ctl(EPOLL_CTL_DEL)"); exit(1); } + + // This client could be sleeping, so we'll need to fix that. (Argh, O(n).) + vector::iterator new_end = + remove(sleeping_clients.begin(), sleeping_clients.end(), client->sock); + sleeping_clients.erase(new_end, sleeping_clients.end()); // Bye-bye! close(client->sock); clients.erase(client->sock); } + +void Server::put_client_to_sleep(Client *client) +{ + epoll_event ev; + ev.events = EPOLLRDHUP; + ev.data.fd = client->sock; + + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, client->sock, &ev) == -1) { + perror("epoll_ctl(EPOLL_CTL_MOD)"); + exit(1); + } + + sleeping_clients.push_back(client->sock); +} + +void Server::wake_up_all_clients() +{ + for (unsigned i = 0; i < sleeping_clients.size(); ++i) { + epoll_event ev; + ev.events = EPOLLOUT | EPOLLRDHUP; + ev.data.fd = sleeping_clients[i]; + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, sleeping_clients[i], &ev) == -1) { + perror("epoll_ctl(EPOLL_CTL_MOD)"); + exit(1); + } + } + sleeping_clients.clear(); +}