output/httpd: convert to C++

Makefile.am

@@ -101,8 +101,6 @@ mpd_headers = \
 	src/AudioCompress/compress.h \
 	src/path.h \
 	src/open.h \
-	src/output/httpd_client.h \
-	src/output/httpd_internal.h \
 	src/page.h \
 	src/Playlist.hxx \
 	src/playlist_error.h \
@@ -899,8 +897,9 @@ endif
 if ENABLE_HTTPD_OUTPUT
 liboutput_plugins_a_SOURCES += \
 	src/icy_server.c \
-	src/output/httpd_client.c \
+	src/output/HttpdInternal.hxx \
-	src/output/httpd_output_plugin.c src/output/httpd_output_plugin.h
+	src/output/HttpdClient.cxx src/output/HttpdClient.hxx \
+	src/output/HttpdOutputPlugin.cxx src/output/HttpdOutputPlugin.hxx
 endif
 
 if ENABLE_SOLARIS_OUTPUT

src/OutputList.cxx

@@ -24,7 +24,7 @@
 #include "output/ao_output_plugin.h"
 #include "output/ffado_output_plugin.h"
 #include "output/fifo_output_plugin.h"
-#include "output/httpd_output_plugin.h"
+#include "output/HttpdOutputPlugin.hxx"
 #include "output/jack_output_plugin.h"
 #include "output/mvp_output_plugin.h"
 #include "output/null_output_plugin.h"

src/output/HttpdClient.cxx

@@ -0,0 +1,592 @@
+/*
+ * Copyright (C) 2003-2011 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "HttpdClient.hxx"
+#include "HttpdInternal.hxx"
+#include "util/fifo_buffer.h"
+#include "page.h"
+#include "icy_server.h"
+#include "glib_socket.h"
+
+#include <assert.h>
+#include <string.h>
+
+#undef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "httpd_output"
+
+HttpdClient::~HttpdClient()
+{
+	if (state == RESPONSE) {
+		if (write_source_id != 0)
+			g_source_remove(write_source_id);
+
+		if (current_page != nullptr)
+			page_unref(current_page);
+
+		for (auto page : pages)
+			page_unref(page);
+	} else
+		fifo_buffer_free(input);
+
+	if (metadata)
+		page_unref(metadata);
+
+	g_source_remove(read_source_id);
+	g_io_channel_unref(channel);
+}
+
+void
+HttpdClient::Close()
+{
+	httpd_output_remove_client(httpd, this);
+}
+
+void
+HttpdClient::LockClose()
+{
+	const ScopeLock protect(httpd->mutex);
+	Close();
+}
+
+void
+HttpdClient::BeginResponse()
+{
+	assert(state != RESPONSE);
+
+	state = RESPONSE;
+	write_source_id = 0;
+	current_page = nullptr;
+
+	httpd_output_send_header(httpd, this);
+}
+
+/**
+ * Handle a line of the HTTP request.
+ */
+bool
+HttpdClient::HandleLine(const char *line)
+{
+	assert(state != RESPONSE);
+
+	if (state == REQUEST) {
+		if (strncmp(line, "GET /", 5) != 0) {
+			/* only GET is supported */
+			g_warning("malformed request line from client");
+			return false;
+		}
+
+		line = strchr(line + 5, ' ');
+		if (line == nullptr || strncmp(line + 1, "HTTP/", 5) != 0) {
+			/* HTTP/0.9 without request headers */
+			BeginResponse();
+			return true;
+		}
+
+		/* after the request line, request headers follow */
+		state = HEADERS;
+		return true;
+	} else {
+		if (*line == 0) {
+			/* empty line: request is finished */
+			BeginResponse();
+			return true;
+		}
+
+		if (g_ascii_strncasecmp(line, "Icy-MetaData: 1", 15) == 0) {
+			/* Send icy metadata */
+			metadata_requested = metadata_supported;
+			return true;
+		}
+
+		if (g_ascii_strncasecmp(line, "transferMode.dlna.org: Streaming", 32) == 0) {
+			/* Send as dlna */
+			dlna_streaming_requested = true;
+			/* metadata is not supported by dlna streaming, so disable it */
+			metadata_supported = false;
+			metadata_requested = false;
+			return true;
+		}
+
+		/* expect more request headers */
+		return true;
+	}
+}
+
+char *
+HttpdClient::ReadLine()
+{
+	assert(state != RESPONSE);
+
+	const ScopeLock protect(httpd->mutex);
+
+	size_t length;
+	const char *p = (const char *)fifo_buffer_read(input, &length);
+	if (p == nullptr)
+		/* empty input buffer */
+		return nullptr;
+
+	const char *newline = (const char *)memchr(p, '\n', length);
+	if (newline == nullptr)
+		/* incomplete line */
+		return nullptr;
+
+	char *line = g_strndup(p, newline - p);
+	fifo_buffer_consume(input, newline - p + 1);
+
+	/* remove trailing whitespace (e.g. '\r') */
+	return g_strchomp(line);
+}
+
+/**
+ * Sends the status line and response headers to the client.
+ */
+bool
+HttpdClient::SendResponse()
+{
+	char buffer[1024];
+	GError *error = nullptr;
+	GIOStatus status;
+	gsize bytes_written;
+
+	assert(state == RESPONSE);
+
+	if (dlna_streaming_requested) {
+		g_snprintf(buffer, sizeof(buffer),
+			   "HTTP/1.1 206 OK\r\n"
+			   "Content-Type: %s\r\n"
+			   "Content-Length: 10000\r\n"
+			   "Content-RangeX: 0-1000000/1000000\r\n"
+			   "transferMode.dlna.org: Streaming\r\n"
+			   "Accept-Ranges: bytes\r\n"
+			   "Connection: close\r\n"
+			   "realTimeInfo.dlna.org: DLNA.ORG_TLAG=*\r\n"
+			   "contentFeatures.dlna.org: DLNA.ORG_OP=01;DLNA.ORG_CI=0\r\n"
+			   "\r\n",
+			   httpd->content_type);
+
+	} else if (metadata_requested) {
+		gchar *metadata_header;
+
+		metadata_header =
+			icy_server_metadata_header(httpd->name, httpd->genre,
+						   httpd->website,
+						   httpd->content_type,
+						   metaint);
+
+		g_strlcpy(buffer, metadata_header, sizeof(buffer));
+
+		g_free(metadata_header);
+
+       } else { /* revert to a normal HTTP request */
+		g_snprintf(buffer, sizeof(buffer),
+			   "HTTP/1.1 200 OK\r\n"
+			   "Content-Type: %s\r\n"
+			   "Connection: close\r\n"
+			   "Pragma: no-cache\r\n"
+			   "Cache-Control: no-cache, no-store\r\n"
+			   "\r\n",
+			   httpd->content_type);
+	}
+
+	status = g_io_channel_write_chars(channel,
+					  buffer, strlen(buffer),
+					  &bytes_written, &error);
+
+	switch (status) {
+	case G_IO_STATUS_NORMAL:
+	case G_IO_STATUS_AGAIN:
+		return true;
+
+	case G_IO_STATUS_EOF:
+		/* client has disconnected */
+
+		Close();
+		return false;
+
+	case G_IO_STATUS_ERROR:
+		/* I/O error */
+
+		g_warning("failed to write to client: %s", error->message);
+		g_error_free(error);
+
+		Close();
+		return false;
+	}
+
+	/* unreachable */
+	Close();
+	return false;
+}
+
+bool
+HttpdClient::Received()
+{
+	assert(state != RESPONSE);
+
+	char *line;
+	bool success;
+
+	while ((line = ReadLine()) != nullptr) {
+		success = HandleLine(line);
+		g_free(line);
+		if (!success) {
+			assert(state != RESPONSE);
+			return false;
+		}
+
+		if (state == RESPONSE) {
+			if (!fifo_buffer_is_empty(input)) {
+				g_warning("unexpected input from client");
+				return false;
+			}
+
+			fifo_buffer_free(input);
+
+			return SendResponse();
+		}
+	}
+
+	return true;
+}
+
+bool
+HttpdClient::Read()
+{
+	size_t max_length;
+	GError *error = nullptr;
+	GIOStatus status;
+	gsize bytes_read;
+
+	if (state == RESPONSE) {
+		/* the client has already sent the request, and he
+		   must not send more */
+		char buffer[1];
+
+		status = g_io_channel_read_chars(channel, buffer,
+						 sizeof(buffer), &bytes_read,
+						 nullptr);
+		if (status == G_IO_STATUS_NORMAL)
+			g_warning("unexpected input from client");
+
+		return false;
+	}
+
+	char *p = (char *)fifo_buffer_write(input, &max_length);
+	if (p == nullptr) {
+		g_warning("buffer overflow");
+		return false;
+	}
+
+	status = g_io_channel_read_chars(channel, p, max_length,
+					 &bytes_read, &error);
+	switch (status) {
+	case G_IO_STATUS_NORMAL:
+		fifo_buffer_append(input, bytes_read);
+		return Received();
+
+	case G_IO_STATUS_AGAIN:
+		/* try again later, after select() */
+		return true;
+
+	case G_IO_STATUS_EOF:
+		/* peer disconnected */
+		return false;
+
+	case G_IO_STATUS_ERROR:
+		/* I/O error */
+		g_warning("failed to read from client: %s",
+			  error->message);
+		g_error_free(error);
+		return false;
+	}
+
+	/* unreachable */
+	return false;
+}
+
+static gboolean
+httpd_client_in_event(G_GNUC_UNUSED GIOChannel *source, GIOCondition condition,
+		      gpointer data)
+{
+	HttpdClient *client = (HttpdClient *)data;
+
+	if (condition == G_IO_IN && client->Read()) {
+		return true;
+	} else {
+		client->LockClose();
+		return false;
+	}
+}
+
+HttpdClient::HttpdClient(httpd_output *_httpd, int _fd,
+			 bool _metadata_supported)
+	:httpd(_httpd),
+	 channel(g_io_channel_new_socket(_fd)),
+	 input(fifo_buffer_new(4096)),
+	 state(REQUEST),
+	 dlna_streaming_requested(false),
+	 metadata_supported(_metadata_supported),
+	 metadata_requested(false), metadata_sent(true),
+	 metaint(8192), /*TODO: just a std value */
+	 metadata(nullptr),
+	 metadata_current_position(0), metadata_fill(0)
+{
+	/* GLib is responsible for closing the file descriptor */
+	g_io_channel_set_close_on_unref(channel, true);
+	/* NULL encoding means the stream is binary safe */
+	g_io_channel_set_encoding(channel, nullptr, nullptr);
+	/* we prefer to do buffering */
+	g_io_channel_set_buffered(channel, false);
+
+	read_source_id = g_io_add_watch(channel,
+					GIOCondition(G_IO_IN|G_IO_ERR|G_IO_HUP),
+					httpd_client_in_event, this);
+}
+
+size_t
+HttpdClient::GetQueueSize() const
+{
+	if (state != RESPONSE)
+		return 0;
+
+	size_t size = 0;
+	for (auto page : pages)
+		size += page->size;
+	return size;
+}
+
+void
+HttpdClient::CancelQueue()
+{
+	if (state != RESPONSE)
+		return;
+
+	for (auto page : pages)
+		page_unref(page);
+	pages.clear();
+
+	if (write_source_id != 0 && current_page == nullptr) {
+		g_source_remove(write_source_id);
+		write_source_id = 0;
+	}
+}
+
+static GIOStatus
+write_page_to_channel(GIOChannel *channel,
+		      const struct page *page, size_t position,
+		      gsize *bytes_written_r, GError **error)
+{
+	assert(channel != nullptr);
+	assert(page != nullptr);
+	assert(position < page->size);
+
+	return g_io_channel_write_chars(channel,
+					(const gchar*)page->data + position,
+					page->size - position,
+					bytes_written_r, error);
+}
+
+static GIOStatus
+write_n_bytes_to_channel(GIOChannel *channel, const struct page *page,
+			 size_t position, gint n,
+			 gsize *bytes_written_r, GError **error)
+{
+	GIOStatus status;
+
+	assert(channel != nullptr);
+	assert(page != nullptr);
+	assert(position < page->size);
+
+	if (n == -1) {
+		status =  write_page_to_channel (channel, page, position,
+						 bytes_written_r, error);
+	} else {
+		status = g_io_channel_write_chars(channel,
+						  (const gchar*)page->data + position,
+						  n, bytes_written_r, error);
+	}
+
+	return status;
+}
+
+int
+HttpdClient::GetBytesTillMetaData() const
+{
+	if (metadata_requested &&
+	    current_page->size - current_position > metaint - metadata_fill)
+		return metaint - metadata_fill;
+
+	return -1;
+}
+
+inline bool
+HttpdClient::Write()
+{
+	GError *error = nullptr;
+	GIOStatus status;
+	gsize bytes_written;
+
+	const ScopeLock protect(httpd->mutex);
+
+	assert(state == RESPONSE);
+
+	if (write_source_id == 0)
+		/* another thread has removed the event source while
+		   this thread was waiting for httpd->mutex */
+		return false;
+
+	if (current_page == nullptr) {
+		current_page = pages.front();
+		pages.pop_front();
+		current_position = 0;
+	}
+
+	const gint bytes_to_write = GetBytesTillMetaData();
+	if (bytes_to_write == 0) {
+		gint metadata_to_write;
+
+		metadata_to_write = metadata_current_position;
+
+		if (!metadata_sent) {
+			status = write_page_to_channel(channel,
+						       metadata,
+						       metadata_to_write,
+						       &bytes_written, &error);
+
+			metadata_current_position += bytes_written;
+
+			if (metadata->size - metadata_current_position == 0) {
+				metadata_fill = 0;
+				metadata_current_position = 0;
+				metadata_sent = true;
+			}
+		} else {
+			struct page *empty_meta;
+			guchar empty_data = 0;
+
+			empty_meta = page_new_copy(&empty_data, 1);
+
+			status = write_page_to_channel(channel,
+						       empty_meta,
+						       metadata_to_write,
+						       &bytes_written, &error);
+
+			metadata_current_position += bytes_written;
+
+			if (empty_meta->size - metadata_current_position == 0) {
+				metadata_fill = 0;
+				metadata_current_position = 0;
+			}
+		}
+
+		bytes_written = 0;
+	} else {
+		status = write_n_bytes_to_channel(channel, current_page,
+						  current_position, bytes_to_write,
+						  &bytes_written, &error);
+	}
+
+	switch (status) {
+	case G_IO_STATUS_NORMAL:
+		current_position += bytes_written;
+		assert(current_position <= current_page->size);
+
+		if (metadata_requested)
+			metadata_fill += bytes_written;
+
+		if (current_position >= current_page->size) {
+			page_unref(current_page);
+			current_page = nullptr;
+
+			if (pages.empty()) {
+				/* all pages are sent: remove the
+				   event source */
+				write_source_id = 0;
+
+				return false;
+			}
+		}
+
+		return true;
+
+	case G_IO_STATUS_AGAIN:
+		return true;
+
+	case G_IO_STATUS_EOF:
+		/* client has disconnected */
+
+		Close();
+		return false;
+
+	case G_IO_STATUS_ERROR:
+		/* I/O error */
+
+		g_warning("failed to write to client: %s", error->message);
+		g_error_free(error);
+
+		Close();
+		return false;
+	}
+
+	/* unreachable */
+	Close();
+	return false;
+}
+
+static gboolean
+httpd_client_out_event(gcc_unused GIOChannel *source,
+		       gcc_unused GIOCondition condition, gpointer data)
+{
+	assert(condition == G_IO_OUT);
+
+	HttpdClient *client = (HttpdClient *)data;
+	return client->Write();
+}
+
+void
+HttpdClient::PushPage(struct page *page)
+{
+	if (state != RESPONSE)
+		/* the client is still writing the HTTP request */
+		return;
+
+	page_ref(page);
+	pages.push_back(page);
+
+	if (write_source_id == 0)
+		write_source_id = g_io_add_watch(channel, G_IO_OUT,
+						 httpd_client_out_event,
+						 this);
+}
+
+void
+HttpdClient::PushMetaData(struct page *page)
+{
+	if (metadata) {
+		page_unref(metadata);
+		metadata = nullptr;
+	}
+
+	g_return_if_fail (page);
+
+	page_ref(page);
+	metadata = page;
+	metadata_sent = false;
+}

src/output/HttpdClient.hxx

@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_HTTPD_CLIENT_HXX
+#define MPD_OUTPUT_HTTPD_CLIENT_HXX
+
+#include "gcc.h"
+
+#include <glib.h>
+
+#include <list>
+
+#include <stddef.h>
+
+struct httpd_output;
+struct page;
+
+class HttpdClient final {
+	/**
+	 * The httpd output object this client is connected to.
+	 */
+	httpd_output *const httpd;
+
+	/**
+	 * The TCP socket.
+	 */
+	GIOChannel *channel;
+
+	/**
+	 * The GLib main loop source id for reading from the socket,
+	 * and to detect errors.
+	 */
+	guint read_source_id;
+
+	/**
+	 * The GLib main loop source id for writing to the socket.  If
+	 * 0, then there is no event source currently (because there
+	 * are no queued pages).
+	 */
+	guint write_source_id;
+
+	/**
+	 * For buffered reading.  This pointer is only valid while the
+	 * HTTP request is read.
+	 */
+	struct fifo_buffer *input;
+
+	/**
+	 * The current state of the client.
+	 */
+	enum {
+		/** reading the request line */
+		REQUEST,
+
+		/** reading the request headers */
+		HEADERS,
+
+		/** sending the HTTP response */
+		RESPONSE,
+	} state;
+
+	/**
+	 * A queue of #page objects to be sent to the client.
+	 */
+	std::list<page *> pages;
+
+	/**
+	 * The #page which is currently being sent to the client.
+	 */
+	page *current_page;
+
+	/**
+	 * The amount of bytes which were already sent from
+	 * #current_page.
+	 */
+	size_t current_position;
+
+	/**
+         * If DLNA streaming was an option.
+         */
+	bool dlna_streaming_requested;
+
+	/* ICY */
+
+	/**
+	 * Do we support sending Icy-Metadata to the client?  This is
+	 * disabled if the httpd audio output uses encoder tags.
+	 */
+	bool metadata_supported;
+
+	/**
+	 * If we should sent icy metadata.
+	 */
+	bool metadata_requested;
+
+	/**
+	 * If the current metadata was already sent to the client.
+	 */
+	bool metadata_sent;
+
+	/**
+	 * The amount of streaming data between each metadata block
+	 */
+	guint metaint;
+
+	/**
+	 * The metadata as #page which is currently being sent to the client.
+	 */
+	page *metadata;
+
+	/*
+	 * The amount of bytes which were already sent from the metadata.
+	 */
+	size_t metadata_current_position;
+
+	/**
+	 * The amount of streaming data sent to the client
+	 * since the last icy information was sent.
+	 */
+	guint metadata_fill;
+
+public:
+	/**
+	 * @param httpd the HTTP output device
+	 * @param fd the socket file descriptor
+	 */
+	HttpdClient(httpd_output *httpd, int _fd, bool _metadata_supported);
+
+	/**
+	 * Note: this does not remove the client from the
+	 * #httpd_output object.
+	 */
+	~HttpdClient();
+
+	/**
+	 * Frees the client and removes it from the server's client list.
+	 */
+	void Close();
+
+	void LockClose();
+
+	/**
+	 * Returns the total size of this client's page queue.
+	 */
+	gcc_pure
+	size_t GetQueueSize() const;
+
+	/**
+	 * Clears the page queue.
+	 */
+	void CancelQueue();
+
+	bool Read();
+
+	/**
+	 * Data has been received from the client and it is appended
+	 * to the input buffer.
+	 */
+	bool Received();
+
+	/**
+	 * Check if a complete line of input is present in the input
+	 * buffer, and duplicates it.  It is removed from the input
+	 * buffer.  The return value has to be freed with g_free().
+	 */
+	char *ReadLine();
+
+	/**
+	 * Handle a line of the HTTP request.
+	 */
+	bool HandleLine(const char *line);
+
+	/**
+	 * Switch the client to the "RESPONSE" state.
+	 */
+	void BeginResponse();
+
+	/**
+	 * Sends the status line and response headers to the client.
+	 */
+	bool SendResponse();
+
+	gcc_pure
+	int GetBytesTillMetaData() const;
+
+	bool Write();
+
+	/**
+	 * Appends a page to the client's queue.
+	 */
+	void PushPage(page *page);
+
+	/**
+	 * Sends the passed metadata.
+	 */
+	void PushMetaData(page *page);
+};
+
+#endif

src/output/HttpdInternal.hxx

@@ -25,14 +25,18 @@
 #ifndef MPD_OUTPUT_HTTPD_INTERNAL_H
 #define MPD_OUTPUT_HTTPD_INTERNAL_H
 
+#include "HttpdClient.hxx"
 #include "output_internal.h"
 #include "timer.h"
+#include "thread/Mutex.hxx"
 
 #include <glib.h>
 
+#include <forward_list>
+
 #include <stdbool.h>
 
-struct httpd_client;
+class HttpdClient;
 
 struct httpd_output {
 	struct audio_output base;
@@ -65,7 +69,7 @@ struct httpd_output {
 	 * This mutex protects the listener socket and the client
 	 * list.
 	 */
-	GMutex *mutex;
+	mutable Mutex mutex;
 
 	/**
 	 * A #timer object to synchronize this output with the
@@ -105,7 +109,7 @@ struct httpd_output {
 	 * A linked list containing all clients which are currently
 	 * connected.
 	 */
-	GList *clients;
+	std::forward_list<HttpdClient> clients;
 
 	/**
 	 * A temporary buffer for the httpd_output_read_page()
@@ -125,7 +129,7 @@ struct httpd_output {
  */
 void
 httpd_output_remove_client(struct httpd_output *httpd,
-			   struct httpd_client *client);
+			   HttpdClient *client);
 
 /**
  * Sends the encoder header to the client.  This is called right after
@@ -133,6 +137,6 @@ httpd_output_remove_client(struct httpd_output *httpd,
  */
 void
 httpd_output_send_header(struct httpd_output *httpd,
-			 struct httpd_client *client);
+			 HttpdClient *client);
 
 #endif

src/output/HttpdOutputPlugin.cxx

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2011 The Music Player Daemon Project
+ * Copyright (C) 2003-2013 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -18,9 +18,9 @@
  */
 
 #include "config.h"
-#include "httpd_output_plugin.h"
+#include "HttpdOutputPlugin.hxx"
-#include "httpd_internal.h"
+#include "HttpdInternal.hxx"
-#include "httpd_client.h"
+#include "HttpdClient.hxx"
 #include "output_api.h"
 #include "encoder_plugin.h"
 #include "encoder_list.h"
@@ -60,9 +60,9 @@ httpd_output_quark(void)
  */
 G_GNUC_PURE
 static bool
-httpd_output_has_clients(const struct httpd_output *httpd)
+httpd_output_has_clients(const httpd_output *httpd)
 {
-	return httpd->clients != NULL;
+	return !httpd->clients.empty();
 }
 
 /**
@@ -70,12 +70,10 @@ httpd_output_has_clients(const struct httpd_output *httpd)
  */
 G_GNUC_PURE
 static bool
-httpd_output_lock_has_clients(const struct httpd_output *httpd)
+httpd_output_lock_has_clients(const httpd_output *httpd)
 {
-	g_mutex_lock(httpd->mutex);
+	const ScopeLock protect(httpd->mutex);
-	bool result = httpd_output_has_clients(httpd);
+	return httpd_output_has_clients(httpd);
-	g_mutex_unlock(httpd->mutex);
-	return result;
 }
 
 static void
@@ -83,32 +81,28 @@ httpd_listen_in_event(int fd, const struct sockaddr *address,
 		      size_t address_length, int uid, void *ctx);
 
 static bool
-httpd_output_bind(struct httpd_output *httpd, GError **error_r)
+httpd_output_bind(httpd_output *httpd, GError **error_r)
 {
 	httpd->open = false;
 
-	g_mutex_lock(httpd->mutex);
+	const ScopeLock protect(httpd->mutex);
-	bool success = server_socket_open(httpd->server_socket, error_r);
+	return server_socket_open(httpd->server_socket, error_r);
-	g_mutex_unlock(httpd->mutex);
-
-	return success;
 }
 
 static void
-httpd_output_unbind(struct httpd_output *httpd)
+httpd_output_unbind(httpd_output *httpd)
 {
 	assert(!httpd->open);
 
-	g_mutex_lock(httpd->mutex);
+	const ScopeLock protect(httpd->mutex);
 	server_socket_close(httpd->server_socket);
-	g_mutex_unlock(httpd->mutex);
 }
 
 static struct audio_output *
 httpd_output_init(const struct config_param *param,
 		  GError **error)
 {
-	struct httpd_output *httpd = g_new(struct httpd_output, 1);
+	httpd_output *httpd = new httpd_output();
 	if (!ao_base_init(&httpd->base, &httpd_output_plugin, param, error)) {
 		g_free(httpd);
 		return NULL;
@@ -174,50 +168,44 @@ httpd_output_init(const struct config_param *param,
 		httpd->content_type = "application/octet-stream";
 	}
 
-	httpd->mutex = g_mutex_new();
-
 	return &httpd->base;
 }
 
 static void
 httpd_output_finish(struct audio_output *ao)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
 	if (httpd->metadata)
 		page_unref(httpd->metadata);
 
 	encoder_finish(httpd->encoder);
 	server_socket_free(httpd->server_socket);
-	g_mutex_free(httpd->mutex);
 	ao_base_finish(&httpd->base);
-	g_free(httpd);
+	delete httpd;
 }
 
 /**
- * Creates a new #httpd_client object and adds it into the
+ * Creates a new #HttpdClient object and adds it into the
  * httpd_output.clients linked list.
  */
 static void
-httpd_client_add(struct httpd_output *httpd, int fd)
+httpd_client_add(httpd_output *httpd, int fd)
 {
-	struct httpd_client *client =
+	httpd->clients.emplace_front(httpd, fd,
-		httpd_client_new(httpd, fd,
 				     httpd->encoder->plugin->tag == NULL);
-
-	httpd->clients = g_list_prepend(httpd->clients, client);
 	httpd->clients_cnt++;
 
 	/* pass metadata to client */
 	if (httpd->metadata)
-		httpd_client_send_metadata(client, httpd->metadata);
+		httpd->clients.front().PushMetaData(httpd->metadata);
 }
 
 static void
 httpd_listen_in_event(int fd, const struct sockaddr *address,
 		      size_t address_length, G_GNUC_UNUSED int uid, void *ctx)
 {
-	struct httpd_output *httpd = ctx;
+	httpd_output *httpd = (httpd_output *)ctx;
 
 	/* the listener socket has become readable - a client has
 	   connected */
@@ -238,7 +226,6 @@ httpd_listen_in_event(int fd, const struct sockaddr *address,
 			      progname, hostaddr);
 			g_free(hostaddr);
 			close_socket(fd);
-			g_mutex_unlock(httpd->mutex);
 			return;
 		}
 
@@ -249,7 +236,7 @@ httpd_listen_in_event(int fd, const struct sockaddr *address,
 	(void)address_length;
 #endif	/* HAVE_WRAP */
 
-	g_mutex_lock(httpd->mutex);
+	const ScopeLock protect(httpd->mutex);
 
 	if (fd >= 0) {
 		/* can we allow additional client */
@@ -262,8 +249,6 @@ httpd_listen_in_event(int fd, const struct sockaddr *address,
 	} else if (fd < 0 && errno != EINTR) {
 		g_warning("accept() failed: %s", g_strerror(errno));
 	}
-
-	g_mutex_unlock(httpd->mutex);
 }
 
 /**
@@ -271,7 +256,7 @@ httpd_listen_in_event(int fd, const struct sockaddr *address,
  * as a new #page object.
  */
 static struct page *
-httpd_output_read_page(struct httpd_output *httpd)
+httpd_output_read_page(httpd_output *httpd)
 {
 	if (httpd->unflushed_input >= 65536) {
 		/* we have fed a lot of input into the encoder, but it
@@ -301,7 +286,7 @@ httpd_output_read_page(struct httpd_output *httpd)
 }
 
 static bool
-httpd_output_encoder_open(struct httpd_output *httpd,
+httpd_output_encoder_open(httpd_output *httpd,
 			  struct audio_format *audio_format,
 			  GError **error)
 {
@@ -321,7 +306,7 @@ httpd_output_encoder_open(struct httpd_output *httpd,
 static bool
 httpd_output_enable(struct audio_output *ao, GError **error_r)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
 	return httpd_output_bind(httpd, error_r);
 }
@@ -329,7 +314,7 @@ httpd_output_enable(struct audio_output *ao, GError **error_r)
 static void
 httpd_output_disable(struct audio_output *ao)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
 	httpd_output_unbind(httpd);
 }
@@ -338,82 +323,75 @@ static bool
 httpd_output_open(struct audio_output *ao, struct audio_format *audio_format,
 		  GError **error)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
-	g_mutex_lock(httpd->mutex);
+	assert(httpd->clients.empty());
+
+	const ScopeLock protect(httpd->mutex);
 
 	/* open the encoder */
 
-	if (!httpd_output_encoder_open(httpd, audio_format, error)) {
+	if (!httpd_output_encoder_open(httpd, audio_format, error))
-		g_mutex_unlock(httpd->mutex);
 		return false;
-	}
 
 	/* initialize other attributes */
 
-	httpd->clients = NULL;
 	httpd->clients_cnt = 0;
 	httpd->timer = timer_new(audio_format);
 
 	httpd->open = true;
 
-	g_mutex_unlock(httpd->mutex);
 	return true;
 }
 
-static void
-httpd_client_delete(gpointer data, G_GNUC_UNUSED gpointer user_data)
-{
-	struct httpd_client *client = data;
-
-	httpd_client_free(client);
-}
-
 static void
 httpd_output_close(struct audio_output *ao)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
-	g_mutex_lock(httpd->mutex);
+	const ScopeLock protect(httpd->mutex);
 
 	httpd->open = false;
 
 	timer_free(httpd->timer);
 
-	g_list_foreach(httpd->clients, httpd_client_delete, NULL);
+	httpd->clients.clear();
-	g_list_free(httpd->clients);
 
 	if (httpd->header != NULL)
 		page_unref(httpd->header);
 
 	encoder_close(httpd->encoder);
-
-	g_mutex_unlock(httpd->mutex);
 }
 
 void
-httpd_output_remove_client(struct httpd_output *httpd,
+httpd_output_remove_client(httpd_output *httpd, HttpdClient *client)
-			   struct httpd_client *client)
 {
 	assert(httpd != NULL);
+	assert(httpd->clients_cnt > 0);
 	assert(client != NULL);
 
-	httpd->clients = g_list_remove(httpd->clients, client);
+	for (auto prev = httpd->clients.before_begin(), i = std::next(prev);;
+	     prev = i, i = std::next(prev)) {
+		assert(i != httpd->clients.end());
+		if (&*i == client) {
+			httpd->clients.erase_after(prev);
 			httpd->clients_cnt--;
+			break;
+		}
+	}
 }
 
 void
-httpd_output_send_header(struct httpd_output *httpd,
+httpd_output_send_header(httpd_output *httpd, HttpdClient *client)
-			 struct httpd_client *client)
 {
 	if (httpd->header != NULL)
-		httpd_client_send(client, httpd->header);
+		client->PushPage(httpd->header);
 }
 
 static unsigned
 httpd_output_delay(struct audio_output *ao)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
 	if (!httpd_output_lock_has_clients(httpd) && httpd->base.pause) {
 		/* if there's no client and this output is paused,
@@ -433,51 +411,35 @@ httpd_output_delay(struct audio_output *ao)
 		: 0;
 }
 
-static void
-httpd_client_check_queue(gpointer data, G_GNUC_UNUSED gpointer user_data)
-{
-	struct httpd_client *client = data;
-
-	if (httpd_client_queue_size(client) > 256 * 1024) {
-		g_debug("client is too slow, flushing its queue");
-		httpd_client_cancel(client);
-	}
-}
-
-static void
-httpd_client_send_page(gpointer data, gpointer user_data)
-{
-	struct httpd_client *client = data;
-	struct page *page = user_data;
-
-	httpd_client_send(client, page);
-}
-
 /**
  * Broadcasts a page struct to all clients.
  */
 static void
-httpd_output_broadcast_page(struct httpd_output *httpd, struct page *page)
+httpd_output_broadcast_page(httpd_output *httpd, struct page *page)
 {
 	assert(page != NULL);
 
-	g_mutex_lock(httpd->mutex);
+	const ScopeLock protect(httpd->mutex);
-	g_list_foreach(httpd->clients, httpd_client_send_page, page);
+	for (auto &client : httpd->clients)
-	g_mutex_unlock(httpd->mutex);
+		client.PushPage(page);
 }
 
 /**
  * Broadcasts data from the encoder to all clients.
  */
 static void
-httpd_output_encoder_to_clients(struct httpd_output *httpd)
+httpd_output_encoder_to_clients(httpd_output *httpd)
 {
+	httpd->mutex.lock();
+	for (auto &client : httpd->clients) {
+		if (client.GetQueueSize() > 256 * 1024) {
+			g_debug("client is too slow, flushing its queue");
+			client.CancelQueue();
+		}
+	}
+	httpd->mutex.unlock();
+
 	struct page *page;
-
-	g_mutex_lock(httpd->mutex);
-	g_list_foreach(httpd->clients, httpd_client_check_queue, NULL);
-	g_mutex_unlock(httpd->mutex);
-
 	while ((page = httpd_output_read_page(httpd)) != NULL) {
 		httpd_output_broadcast_page(httpd, page);
 		page_unref(page);
@@ -485,7 +447,7 @@ httpd_output_encoder_to_clients(struct httpd_output *httpd)
 }
 
 static bool
-httpd_output_encode_and_play(struct httpd_output *httpd,
+httpd_output_encode_and_play(httpd_output *httpd,
 			     const void *chunk, size_t size, GError **error)
 {
 	if (!encoder_write(httpd->encoder, chunk, size, error))
@@ -502,7 +464,7 @@ static size_t
 httpd_output_play(struct audio_output *ao, const void *chunk, size_t size,
 		  GError **error_r)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
 	if (httpd_output_lock_has_clients(httpd)) {
 		if (!httpd_output_encode_and_play(httpd, chunk, size, error_r))
@@ -519,10 +481,10 @@ httpd_output_play(struct audio_output *ao, const void *chunk, size_t size,
 static bool
 httpd_output_pause(struct audio_output *ao)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
 	if (httpd_output_lock_has_clients(httpd)) {
-		static const char silence[1020];
+		static const char silence[1020] = { 0 };
 		return httpd_output_play(ao, silence, sizeof(silence),
 					 NULL) > 0;
 	} else {
@@ -530,19 +492,10 @@ httpd_output_pause(struct audio_output *ao)
 	}
 }
 
-static void
-httpd_send_metadata(gpointer data, gpointer user_data)
-{
-	struct httpd_client *client = data;
-	struct page *icy_metadata = user_data;
-
-	httpd_client_send_metadata(client, icy_metadata);
-}
-
 static void
 httpd_output_tag(struct audio_output *ao, const struct tag *tag)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
 	assert(tag != NULL);
 
@@ -581,43 +534,37 @@ httpd_output_tag(struct audio_output *ao, const struct tag *tag)
 						 TAG_ARTIST, TAG_TITLE,
 						 TAG_NUM_OF_ITEM_TYPES);
 		if (httpd->metadata != NULL) {
-			g_mutex_lock(httpd->mutex);
+			const ScopeLock protect(httpd->mutex);
-			g_list_foreach(httpd->clients,
+			for (auto &client : httpd->clients)
-				       httpd_send_metadata, httpd->metadata);
+				client.PushMetaData(httpd->metadata);
-			g_mutex_unlock(httpd->mutex);
 		}
 	}
 }
 
-static void
-httpd_client_cancel_callback(gpointer data, G_GNUC_UNUSED gpointer user_data)
-{
-	struct httpd_client *client = data;
-
-	httpd_client_cancel(client);
-}
-
 static void
 httpd_output_cancel(struct audio_output *ao)
 {
-	struct httpd_output *httpd = (struct httpd_output *)ao;
+	httpd_output *httpd = (httpd_output *)ao;
 
-	g_mutex_lock(httpd->mutex);
+	const ScopeLock protect(httpd->mutex);
-	g_list_foreach(httpd->clients, httpd_client_cancel_callback, NULL);
+	for (auto &client : httpd->clients)
-	g_mutex_unlock(httpd->mutex);
+		client.CancelQueue();
 }
 
 const struct audio_output_plugin httpd_output_plugin = {
-	.name = "httpd",
+	"httpd",
-	.init = httpd_output_init,
+	nullptr,
-	.finish = httpd_output_finish,
+	httpd_output_init,
-	.enable = httpd_output_enable,
+	httpd_output_finish,
-	.disable = httpd_output_disable,
+	httpd_output_enable,
-	.open = httpd_output_open,
+	httpd_output_disable,
-	.close = httpd_output_close,
+	httpd_output_open,
-	.delay = httpd_output_delay,
+	httpd_output_close,
-	.send_tag = httpd_output_tag,
+	httpd_output_delay,
-	.play = httpd_output_play,
+	httpd_output_tag,
-	.pause = httpd_output_pause,
+	httpd_output_play,
-	.cancel = httpd_output_cancel,
+	nullptr,
+	httpd_output_cancel,
+	httpd_output_pause,
+	nullptr,
 };

src/output/HttpdOutputPlugin.hxx

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2011 The Music Player Daemon Project
+ * Copyright (C) 2003-2013 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -17,8 +17,8 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#ifndef MPD_HTTPD_OUTPUT_PLUGIN_H
+#ifndef MPD_HTTPD_OUTPUT_PLUGIN_HXX
-#define MPD_HTTPD_OUTPUT_PLUGIN_H
+#define MPD_HTTPD_OUTPUT_PLUGIN_HXX
 
 extern const struct audio_output_plugin httpd_output_plugin;
 

src/output/httpd_client.c

@@ -1,764 +0,0 @@
-/*
- * Copyright (C) 2003-2011 The Music Player Daemon Project
- * http://www.musicpd.org
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#include "config.h"
-#include "httpd_client.h"
-#include "httpd_internal.h"
-#include "util/fifo_buffer.h"
-#include "page.h"
-#include "icy_server.h"
-#include "glib_socket.h"
-
-#include <stdbool.h>
-#include <assert.h>
-#include <string.h>
-
-#undef G_LOG_DOMAIN
-#define G_LOG_DOMAIN "httpd_output"
-
-struct httpd_client {
-	/**
-	 * The httpd output object this client is connected to.
-	 */
-	struct httpd_output *httpd;
-
-	/**
-	 * The TCP socket.
-	 */
-	GIOChannel *channel;
-
-	/**
-	 * The GLib main loop source id for reading from the socket,
-	 * and to detect errors.
-	 */
-	guint read_source_id;
-
-	/**
-	 * The GLib main loop source id for writing to the socket.  If
-	 * 0, then there is no event source currently (because there
-	 * are no queued pages).
-	 */
-	guint write_source_id;
-
-	/**
-	 * For buffered reading.  This pointer is only valid while the
-	 * HTTP request is read.
-	 */
-	struct fifo_buffer *input;
-
-	/**
-	 * The current state of the client.
-	 */
-	enum {
-		/** reading the request line */
-		REQUEST,
-
-		/** reading the request headers */
-		HEADERS,
-
-		/** sending the HTTP response */
-		RESPONSE,
-	} state;
-
-	/**
-	 * A queue of #page objects to be sent to the client.
-	 */
-	GQueue *pages;
-
-	/**
-	 * The #page which is currently being sent to the client.
-	 */
-	struct page *current_page;
-
-	/**
-	 * The amount of bytes which were already sent from
-	 * #current_page.
-	 */
-	size_t current_position;
-
-        /**
-         * If DLNA streaming was an option.
-         */
-        bool dlna_streaming_requested;
-
-	/* ICY */
-
-	/**
-	 * Do we support sending Icy-Metadata to the client?  This is
-	 * disabled if the httpd audio output uses encoder tags.
-	 */
-	bool metadata_supported;
-
-	/**
-	 * If we should sent icy metadata.
-	 */
-	bool metadata_requested;
-
-	/**
-	 * If the current metadata was already sent to the client.
-	 */
-	bool metadata_sent;
-
-	/**
-	 * The amount of streaming data between each metadata block
-	 */
-	guint metaint;
-
-	/**
-	 * The metadata as #page which is currently being sent to the client.
-	 */
-	struct page *metadata;
-
-	/*
-	 * The amount of bytes which were already sent from the metadata.
-	 */
-	size_t metadata_current_position;
-
-	/**
-	 * The amount of streaming data sent to the client
-	 * since the last icy information was sent.
-	 */
-	guint metadata_fill;
-};
-
-static void
-httpd_client_unref_page(gpointer data, G_GNUC_UNUSED gpointer user_data)
-{
-	struct page *page = data;
-
-	page_unref(page);
-}
-
-void
-httpd_client_free(struct httpd_client *client)
-{
-	assert(client != NULL);
-
-	if (client->state == RESPONSE) {
-		if (client->write_source_id != 0)
-			g_source_remove(client->write_source_id);
-
-		if (client->current_page != NULL)
-			page_unref(client->current_page);
-
-		g_queue_foreach(client->pages, httpd_client_unref_page, NULL);
-		g_queue_free(client->pages);
-	} else
-		fifo_buffer_free(client->input);
-
-	if (client->metadata)
-		page_unref (client->metadata);
-
-	g_source_remove(client->read_source_id);
-	g_io_channel_unref(client->channel);
-	g_free(client);
-}
-
-/**
- * Frees the client and removes it from the server's client list.
- */
-static void
-httpd_client_close(struct httpd_client *client)
-{
-	assert(client != NULL);
-
-	httpd_output_remove_client(client->httpd, client);
-	httpd_client_free(client);
-}
-
-/**
- * Switch the client to the "RESPONSE" state.
- */
-static void
-httpd_client_begin_response(struct httpd_client *client)
-{
-	assert(client != NULL);
-	assert(client->state != RESPONSE);
-
-	client->state = RESPONSE;
-	client->write_source_id = 0;
-	client->pages = g_queue_new();
-	client->current_page = NULL;
-
-	httpd_output_send_header(client->httpd, client);
-}
-
-/**
- * Handle a line of the HTTP request.
- */
-static bool
-httpd_client_handle_line(struct httpd_client *client, const char *line)
-{
-	assert(client->state != RESPONSE);
-
-	if (client->state == REQUEST) {
-		if (strncmp(line, "GET /", 5) != 0) {
-			/* only GET is supported */
-			g_warning("malformed request line from client");
-			return false;
-		}
-
-		line = strchr(line + 5, ' ');
-		if (line == NULL || strncmp(line + 1, "HTTP/", 5) != 0) {
-			/* HTTP/0.9 without request headers */
-			httpd_client_begin_response(client);
-			return true;
-		}
-
-		/* after the request line, request headers follow */
-		client->state = HEADERS;
-		return true;
-	} else {
-		if (*line == 0) {
-			/* empty line: request is finished */
-			httpd_client_begin_response(client);
-			return true;
-		}
-
-		if (g_ascii_strncasecmp(line, "Icy-MetaData: 1", 15) == 0) {
-			/* Send icy metadata */
-			client->metadata_requested =
-				client->metadata_supported;
-			return true;
-		}
-
-		if (g_ascii_strncasecmp(line, "transferMode.dlna.org: Streaming", 32) == 0) {
-			/* Send as dlna */
-			client->dlna_streaming_requested = true;
-			/* metadata is not supported by dlna streaming, so disable it */
-			client->metadata_supported = false;
-			client->metadata_requested = false;
-			return true;
-		}
-
-		/* expect more request headers */
-		return true;
-	}
-}
-
-/**
- * Check if a complete line of input is present in the input buffer,
- * and duplicates it.  It is removed from the input buffer.  The
- * return value has to be freed with g_free().
- */
-static char *
-httpd_client_read_line(struct httpd_client *client)
-{
-	assert(client != NULL);
-	assert(client->state != RESPONSE);
-
-	const char *p, *newline;
-	size_t length;
-	char *line;
-
-	p = fifo_buffer_read(client->input, &length);
-	if (p == NULL)
-		/* empty input buffer */
-		return NULL;
-
-	newline = memchr(p, '\n', length);
-	if (newline == NULL)
-		/* incomplete line */
-		return NULL;
-
-	line = g_strndup(p, newline - p);
-	fifo_buffer_consume(client->input, newline - p + 1);
-
-	/* remove trailing whitespace (e.g. '\r') */
-	return g_strchomp(line);
-}
-
-/**
- * Sends the status line and response headers to the client.
- */
-static bool
-httpd_client_send_response(struct httpd_client *client)
-{
-	char buffer[1024];
-	GError *error = NULL;
-	GIOStatus status;
-	gsize bytes_written;
-
-	assert(client != NULL);
-	assert(client->state == RESPONSE);
-
-	if (client->dlna_streaming_requested) {
-		g_snprintf(buffer, sizeof(buffer),
-			   "HTTP/1.1 206 OK\r\n"
-			   "Content-Type: %s\r\n"
-			   "Content-Length: 10000\r\n"
-			   "Content-RangeX: 0-1000000/1000000\r\n"
-			   "transferMode.dlna.org: Streaming\r\n"
-			   "Accept-Ranges: bytes\r\n"
-			   "Connection: close\r\n"
-			   "realTimeInfo.dlna.org: DLNA.ORG_TLAG=*\r\n"
-			   "contentFeatures.dlna.org: DLNA.ORG_OP=01;DLNA.ORG_CI=0\r\n"
-			   "\r\n",
-			   client->httpd->content_type);
-
-	} else if (client->metadata_requested) {
-		gchar *metadata_header;
-
-		metadata_header = icy_server_metadata_header(
-			client->httpd->name,
-			client->httpd->genre,
-			client->httpd->website,
-			client->httpd->content_type,
-			client->metaint);
-
-		g_strlcpy(buffer, metadata_header, sizeof(buffer));
-
-		g_free(metadata_header);
-
-       } else { /* revert to a normal HTTP request */
-		g_snprintf(buffer, sizeof(buffer),
-			   "HTTP/1.1 200 OK\r\n"
-			   "Content-Type: %s\r\n"
-			   "Connection: close\r\n"
-			   "Pragma: no-cache\r\n"
-			   "Cache-Control: no-cache, no-store\r\n"
-			   "\r\n",
-			   client->httpd->content_type);
-	}
-
-	status = g_io_channel_write_chars(client->channel,
-					  buffer, strlen(buffer),
-					  &bytes_written, &error);
-
-	switch (status) {
-	case G_IO_STATUS_NORMAL:
-	case G_IO_STATUS_AGAIN:
-		return true;
-
-	case G_IO_STATUS_EOF:
-		/* client has disconnected */
-
-		httpd_client_close(client);
-		return false;
-
-	case G_IO_STATUS_ERROR:
-		/* I/O error */
-
-		g_warning("failed to write to client: %s", error->message);
-		g_error_free(error);
-
-		httpd_client_close(client);
-		return false;
-	}
-
-	/* unreachable */
-	httpd_client_close(client);
-	return false;
-}
-
-/**
- * Data has been received from the client and it is appended to the
- * input buffer.
- */
-static bool
-httpd_client_received(struct httpd_client *client)
-{
-	assert(client != NULL);
-	assert(client->state != RESPONSE);
-
-	char *line;
-	bool success;
-
-	while ((line = httpd_client_read_line(client)) != NULL) {
-		success = httpd_client_handle_line(client, line);
-		g_free(line);
-		if (!success) {
-			assert(client->state != RESPONSE);
-			return false;
-		}
-
-		if (client->state == RESPONSE) {
-			if (!fifo_buffer_is_empty(client->input)) {
-				g_warning("unexpected input from client");
-				return false;
-			}
-
-			fifo_buffer_free(client->input);
-
-			return httpd_client_send_response(client);
-		}
-	}
-
-	return true;
-}
-
-static bool
-httpd_client_read(struct httpd_client *client)
-{
-	char *p;
-	size_t max_length;
-	GError *error = NULL;
-	GIOStatus status;
-	gsize bytes_read;
-
-	if (client->state == RESPONSE) {
-		/* the client has already sent the request, and he
-		   must not send more */
-		char buffer[1];
-
-		status = g_io_channel_read_chars(client->channel, buffer,
-						 sizeof(buffer), &bytes_read,
-						 NULL);
-		if (status == G_IO_STATUS_NORMAL)
-			g_warning("unexpected input from client");
-
-		return false;
-	}
-
-	p = fifo_buffer_write(client->input, &max_length);
-	if (p == NULL) {
-		g_warning("buffer overflow");
-		return false;
-	}
-
-	status = g_io_channel_read_chars(client->channel, p, max_length,
-					 &bytes_read, &error);
-	switch (status) {
-	case G_IO_STATUS_NORMAL:
-		fifo_buffer_append(client->input, bytes_read);
-		return httpd_client_received(client);
-
-	case G_IO_STATUS_AGAIN:
-		/* try again later, after select() */
-		return true;
-
-	case G_IO_STATUS_EOF:
-		/* peer disconnected */
-		return false;
-
-	case G_IO_STATUS_ERROR:
-		/* I/O error */
-		g_warning("failed to read from client: %s",
-			  error->message);
-		g_error_free(error);
-		return false;
-	}
-
-	/* unreachable */
-	return false;
-}
-
-static gboolean
-httpd_client_in_event(G_GNUC_UNUSED GIOChannel *source, GIOCondition condition,
-		      gpointer data)
-{
-	struct httpd_client *client = data;
-	struct httpd_output *httpd = client->httpd;
-	bool ret;
-
-	g_mutex_lock(httpd->mutex);
-
-	if (condition == G_IO_IN && httpd_client_read(client)) {
-		ret = true;
-	} else {
-		httpd_client_close(client);
-		ret = false;
-	}
-
-	g_mutex_unlock(httpd->mutex);
-
-	return ret;
-}
-
-struct httpd_client *
-httpd_client_new(struct httpd_output *httpd, int fd, bool metadata_supported)
-{
-	struct httpd_client *client = g_new(struct httpd_client, 1);
-
-	client->httpd = httpd;
-
-	client->channel = g_io_channel_new_socket(fd);
-
-	/* GLib is responsible for closing the file descriptor */
-	g_io_channel_set_close_on_unref(client->channel, true);
-	/* NULL encoding means the stream is binary safe */
-	g_io_channel_set_encoding(client->channel, NULL, NULL);
-	/* we prefer to do buffering */
-	g_io_channel_set_buffered(client->channel, false);
-
-	client->read_source_id = g_io_add_watch(client->channel,
-						G_IO_IN|G_IO_ERR|G_IO_HUP,
-						httpd_client_in_event, client);
-
-	client->input = fifo_buffer_new(4096);
-	client->state = REQUEST;
-
-	client->dlna_streaming_requested = false;
-	client->metadata_supported = metadata_supported;
-	client->metadata_requested = false;
-	client->metadata_sent = true;
-	client->metaint = 8192; /*TODO: just a std value */
-	client->metadata = NULL;
-	client->metadata_current_position = 0;
-	client->metadata_fill = 0;
-
-	return client;
-}
-
-static void
-httpd_client_add_page_size(gpointer data, gpointer user_data)
-{
-	struct page *page = data;
-	size_t *size = user_data;
-
-	*size += page->size;
-}
-
-size_t
-httpd_client_queue_size(const struct httpd_client *client)
-{
-	size_t size = 0;
-
-	if (client->state != RESPONSE)
-		return 0;
-
-	g_queue_foreach(client->pages, httpd_client_add_page_size, &size);
-	return size;
-}
-
-void
-httpd_client_cancel(struct httpd_client *client)
-{
-	if (client->state != RESPONSE)
-		return;
-
-	g_queue_foreach(client->pages, httpd_client_unref_page, NULL);
-	g_queue_clear(client->pages);
-
-	if (client->write_source_id != 0 && client->current_page == NULL) {
-		g_source_remove(client->write_source_id);
-		client->write_source_id = 0;
-	}
-}
-
-static GIOStatus
-write_page_to_channel(GIOChannel *channel,
-		      const struct page *page, size_t position,
-		      gsize *bytes_written_r, GError **error)
-{
-	assert(channel != NULL);
-	assert(page != NULL);
-	assert(position < page->size);
-
-	return g_io_channel_write_chars(channel,
-					(const gchar*)page->data + position,
-					page->size - position,
-					bytes_written_r, error);
-}
-
-static GIOStatus
-write_n_bytes_to_channel(GIOChannel *channel, const struct page *page,
-			 size_t position, gint n,
-			 gsize *bytes_written_r, GError **error)
-{
-	GIOStatus status;
-
-	assert(channel != NULL);
-	assert(page != NULL);
-	assert(position < page->size);
-
-	if (n == -1) {
-		status =  write_page_to_channel (channel, page, position,
-						 bytes_written_r, error);
-	} else {
-		status = g_io_channel_write_chars(channel,
-						  (const gchar*)page->data + position,
-						  n, bytes_written_r, error);
-	}
-
-	return status;
-}
-
-static gint
-bytes_left_till_metadata (struct httpd_client *client)
-{
-	assert(client != NULL);
-
-	if (client->metadata_requested &&
-	    client->current_page->size - client->current_position
-	    > client->metaint - client->metadata_fill)
-		return client->metaint - client->metadata_fill;
-
-	return -1;
-}
-
-static gboolean
-httpd_client_out_event(GIOChannel *source,
-		       G_GNUC_UNUSED GIOCondition condition, gpointer data)
-{
-	struct httpd_client *client = data;
-	struct httpd_output *httpd = client->httpd;
-	GError *error = NULL;
-	GIOStatus status;
-	gsize bytes_written;
-	gint bytes_to_write;
-
-	g_mutex_lock(httpd->mutex);
-
-	assert(condition == G_IO_OUT);
-	assert(client->state == RESPONSE);
-
-	if (client->write_source_id == 0) {
-		/* another thread has removed the event source while
-		   this thread was waiting for httpd->mutex */
-		g_mutex_unlock(httpd->mutex);
-		return false;
-	}
-
-	if (client->current_page == NULL) {
-		client->current_page = g_queue_pop_head(client->pages);
-		client->current_position = 0;
-	}
-
-	bytes_to_write = bytes_left_till_metadata(client);
-
-	if (bytes_to_write == 0) {
-		gint metadata_to_write;
-
-		metadata_to_write = client->metadata_current_position;
-
-		if (!client->metadata_sent) {
-			status = write_page_to_channel(source,
-						       client->metadata,
-						       metadata_to_write,
-						       &bytes_written, &error);
-
-			client->metadata_current_position += bytes_written;
-
-			if (client->metadata->size
-			    - client->metadata_current_position == 0) {
-				client->metadata_fill = 0;
-				client->metadata_current_position = 0;
-				client->metadata_sent = true;
-			}
-		} else {
-			struct page *empty_meta;
-			guchar empty_data = 0;
-
-			empty_meta = page_new_copy(&empty_data, 1);
-
-			status = write_page_to_channel(source,
-						       empty_meta,
-						       metadata_to_write,
-						       &bytes_written, &error);
-
-			client->metadata_current_position += bytes_written;
-
-			if (empty_meta->size
-			    - client->metadata_current_position == 0) {
-				client->metadata_fill = 0;
-				client->metadata_current_position = 0;
-			}
-		}
-
-		bytes_written = 0;
-	} else {
-		status = write_n_bytes_to_channel(source, client->current_page,
-						  client->current_position, bytes_to_write,
-						  &bytes_written, &error);
-	}
-
-	switch (status) {
-	case G_IO_STATUS_NORMAL:
-		client->current_position += bytes_written;
-		assert(client->current_position <= client->current_page->size);
-
-		if (client->metadata_requested)
-			client->metadata_fill += bytes_written;
-
-		if (client->current_position >= client->current_page->size) {
-			page_unref(client->current_page);
-			client->current_page = NULL;
-
-			if (g_queue_is_empty(client->pages)) {
-				/* all pages are sent: remove the
-				   event source */
-				client->write_source_id = 0;
-
-				g_mutex_unlock(httpd->mutex);
-				return false;
-			}
-		}
-
-		g_mutex_unlock(httpd->mutex);
-		return true;
-
-	case G_IO_STATUS_AGAIN:
-		g_mutex_unlock(httpd->mutex);
-		return true;
-
-	case G_IO_STATUS_EOF:
-		/* client has disconnected */
-
-		httpd_client_close(client);
-		g_mutex_unlock(httpd->mutex);
-		return false;
-
-	case G_IO_STATUS_ERROR:
-		/* I/O error */
-
-		g_warning("failed to write to client: %s", error->message);
-		g_error_free(error);
-
-		httpd_client_close(client);
-		g_mutex_unlock(httpd->mutex);
-		return false;
-	}
-
-	/* unreachable */
-	httpd_client_close(client);
-	g_mutex_unlock(httpd->mutex);
-	return false;
-}
-
-void
-httpd_client_send(struct httpd_client *client, struct page *page)
-{
-	if (client->state != RESPONSE)
-		/* the client is still writing the HTTP request */
-		return;
-
-	page_ref(page);
-	g_queue_push_tail(client->pages, page);
-
-	if (client->write_source_id == 0)
-		client->write_source_id =
-			g_io_add_watch(client->channel, G_IO_OUT,
-				       httpd_client_out_event, client);
-}
-
-void
-httpd_client_send_metadata(struct httpd_client *client, struct page *page)
-{
-	if (client->metadata) {
-		page_unref(client->metadata);
-		client->metadata = NULL;
-	}
-
-	g_return_if_fail (page);
-
-	page_ref(page);
-	client->metadata = page;
-	client->metadata_sent = false;
-}

src/output/httpd_client.h

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2003-2011 The Music Player Daemon Project
- * http://www.musicpd.org
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#ifndef MPD_OUTPUT_HTTPD_CLIENT_H
-#define MPD_OUTPUT_HTTPD_CLIENT_H
-
-#include <stdbool.h>
-#include <stddef.h>
-
-struct httpd_client;
-struct httpd_output;
-struct page;
-
-/**
- * Creates a new #httpd_client object
- *
- * @param httpd the HTTP output device
- * @param fd the socket file descriptor
- */
-struct httpd_client *
-httpd_client_new(struct httpd_output *httpd, int fd, bool metadata_supported);
-
-/**
- * Frees memory and resources allocated by the #httpd_client object.
- * This does not remove it from the #httpd_output object.
- */
-void
-httpd_client_free(struct httpd_client *client);
-
-/**
- * Returns the total size of this client's page queue.
- */
-size_t
-httpd_client_queue_size(const struct httpd_client *client);
-
-/**
- * Clears the page queue.
- */
-void
-httpd_client_cancel(struct httpd_client *client);
-
-/**
- * Appends a page to the client's queue.
- */
-void
-httpd_client_send(struct httpd_client *client, struct page *page);
-
-/**
- * Sends the passed metadata.
- */
-void
-httpd_client_send_metadata(struct httpd_client *client, struct page *page);
-
-#endif