Database*: move to db/

30 files changed, 4575 insertions, 0 deletions

diff --git a/src/db/plugins/LazyDatabase.cxx b/src/db/plugins/LazyDatabase.cxx
new file mode 100644
index 000000000..6a01ffb82
--- /dev/null
+++ b/src/db/plugins/LazyDatabase.cxx
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2003-2014 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 "LazyDatabase.hxx"
+
+#include <assert.h>
+
+LazyDatabase::~LazyDatabase()
+{
+	assert(!open);
+
+	delete db;
+}
+
+bool
+LazyDatabase::EnsureOpen(Error &error) const
+{
+	if (open)
+		return true;
+
+	if (!db->Open(error))
+		return false;
+
+	open = true;
+	return true;
+}
+
+void
+LazyDatabase::Close()
+{
+	if (open) {
+		open = false;
+		db->Close();
+	}
+}
+
+const LightSong *
+LazyDatabase::GetSong(const char *uri, Error &error) const
+{
+	return EnsureOpen(error)
+		? db->GetSong(uri, error)
+		: nullptr;
+}
+
+void
+LazyDatabase::ReturnSong(const LightSong *song) const
+{
+	assert(open);
+
+	db->ReturnSong(song);
+}
+
+bool
+LazyDatabase::Visit(const DatabaseSelection &selection,
+		    VisitDirectory visit_directory,
+		    VisitSong visit_song,
+		    VisitPlaylist visit_playlist,
+		    Error &error) const
+{
+	return EnsureOpen(error) &&
+		db->Visit(selection, visit_directory, visit_song,
+			  visit_playlist, error);
+}
+
+bool
+LazyDatabase::VisitUniqueTags(const DatabaseSelection &selection,
+			      TagType tag_type,
+			      VisitString visit_string,
+			      Error &error) const
+{
+	return EnsureOpen(error) &&
+		db->VisitUniqueTags(selection, tag_type, visit_string, error);
+}
+
+bool
+LazyDatabase::GetStats(const DatabaseSelection &selection,
+		       DatabaseStats &stats, Error &error) const
+{
+	return EnsureOpen(error) && db->GetStats(selection, stats, error);
+}
+
+time_t
+LazyDatabase::GetUpdateStamp() const
+{
+	return open ? db->GetUpdateStamp() : 0;
+}
diff --git a/src/db/plugins/LazyDatabase.hxx b/src/db/plugins/LazyDatabase.hxx
new file mode 100644
index 000000000..336b8558f
--- /dev/null
+++ b/src/db/plugins/LazyDatabase.hxx
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2003-2014 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_LAZY_DATABASE_PLUGIN_HXX
+#define MPD_LAZY_DATABASE_PLUGIN_HXX
+
+#include "db/DatabasePlugin.hxx"
+
+/**
+ * A wrapper for a #Database object that gets opened on the first
+ * database access.  This works around daemonization problems with
+ * some plugins.
+ */
+class LazyDatabase final : public Database {
+	Database *const db;
+
+	mutable bool open;
+
+public:
+	gcc_nonnull_all
+	LazyDatabase(Database *_db)
+		:db(_db), open(false) {}
+
+	virtual ~LazyDatabase();
+
+	virtual void Close() override;
+
+	virtual const LightSong *GetSong(const char *uri_utf8,
+					 Error &error) const override;
+	virtual void ReturnSong(const LightSong *song) const;
+
+	virtual bool Visit(const DatabaseSelection &selection,
+			   VisitDirectory visit_directory,
+			   VisitSong visit_song,
+			   VisitPlaylist visit_playlist,
+			   Error &error) const override;
+
+	virtual bool VisitUniqueTags(const DatabaseSelection &selection,
+				     TagType tag_type,
+				     VisitString visit_string,
+				     Error &error) const override;
+
+	virtual bool GetStats(const DatabaseSelection &selection,
+			      DatabaseStats &stats,
+			      Error &error) const override;
+
+	virtual time_t GetUpdateStamp() const override;
+
+private:
+	bool EnsureOpen(Error &error) const;
+};
+
+#endif
diff --git a/src/db/plugins/ProxyDatabasePlugin.cxx b/src/db/plugins/ProxyDatabasePlugin.cxx
new file mode 100644
index 000000000..daa963c7d
--- /dev/null
+++ b/src/db/plugins/ProxyDatabasePlugin.cxx
@@ -0,0 +1,782 @@
+/*
+ * Copyright (C) 2003-2014 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 "ProxyDatabasePlugin.hxx"
+#include "db/DatabasePlugin.hxx"
+#include "db/DatabaseListener.hxx"
+#include "db/Selection.hxx"
+#include "db/DatabaseError.hxx"
+#include "PlaylistInfo.hxx"
+#include "db/LightDirectory.hxx"
+#include "db/LightSong.hxx"
+#include "SongFilter.hxx"
+#include "Compiler.h"
+#include "config/ConfigData.hxx"
+#include "tag/TagBuilder.hxx"
+#include "tag/Tag.hxx"
+#include "util/Error.hxx"
+#include "util/Domain.hxx"
+#include "protocol/Ack.hxx"
+#include "Main.hxx"
+#include "event/SocketMonitor.hxx"
+#include "event/IdleMonitor.hxx"
+#include "Log.hxx"
+
+#include <mpd/client.h>
+#include <mpd/async.h>
+
+#include <cassert>
+#include <string>
+#include <list>
+
+class ProxySong : public LightSong {
+	Tag tag2;
+
+public:
+	explicit ProxySong(const mpd_song *song);
+};
+
+class AllocatedProxySong : public ProxySong {
+	mpd_song *const song;
+
+public:
+	explicit AllocatedProxySong(mpd_song *_song)
+		:ProxySong(_song), song(_song) {}
+
+	~AllocatedProxySong() {
+		mpd_song_free(song);
+	}
+};
+
+class ProxyDatabase final : public Database, SocketMonitor, IdleMonitor {
+	DatabaseListener &listener;
+
+	std::string host;
+	unsigned port;
+
+	struct mpd_connection *connection;
+
+	/* this is mutable because GetStats() must be "const" */
+	mutable time_t update_stamp;
+
+	/**
+	 * The libmpdclient idle mask that was removed from the other
+	 * MPD.  This will be handled by the next OnIdle() call.
+	 */
+	unsigned idle_received;
+
+	/**
+	 * Is the #connection currently "idle"?  That is, did we send
+	 * the "idle" command to it?
+	 */
+	bool is_idle;
+
+public:
+	ProxyDatabase(EventLoop &_loop, DatabaseListener &_listener)
+		:SocketMonitor(_loop), IdleMonitor(_loop),
+		 listener(_listener) {}
+
+	static Database *Create(EventLoop &loop, DatabaseListener &listener,
+				const config_param &param,
+				Error &error);
+
+	virtual bool Open(Error &error) override;
+	virtual void Close() override;
+	virtual const LightSong *GetSong(const char *uri_utf8,
+				     Error &error) const override;
+	virtual void ReturnSong(const LightSong *song) const;
+
+	virtual bool Visit(const DatabaseSelection &selection,
+			   VisitDirectory visit_directory,
+			   VisitSong visit_song,
+			   VisitPlaylist visit_playlist,
+			   Error &error) const override;
+
+	virtual bool VisitUniqueTags(const DatabaseSelection &selection,
+				     TagType tag_type,
+				     VisitString visit_string,
+				     Error &error) const override;
+
+	virtual bool GetStats(const DatabaseSelection &selection,
+			      DatabaseStats &stats,
+			      Error &error) const override;
+
+	virtual time_t GetUpdateStamp() const override {
+		return update_stamp;
+	}
+
+private:
+	bool Configure(const config_param &param, Error &error);
+
+	bool Connect(Error &error);
+	bool CheckConnection(Error &error);
+	bool EnsureConnected(Error &error);
+
+	void Disconnect();
+
+	/* virtual methods from SocketMonitor */
+	virtual bool OnSocketReady(unsigned flags) override;
+
+	/* virtual methods from IdleMonitor */
+	virtual void OnIdle() override;
+};
+
+static constexpr Domain libmpdclient_domain("libmpdclient");
+
+static constexpr struct {
+	TagType d;
+	enum mpd_tag_type s;
+} tag_table[] = {
+	{ TAG_ARTIST, MPD_TAG_ARTIST },
+	{ TAG_ALBUM, MPD_TAG_ALBUM },
+	{ TAG_ALBUM_ARTIST, MPD_TAG_ALBUM_ARTIST },
+	{ TAG_TITLE, MPD_TAG_TITLE },
+	{ TAG_TRACK, MPD_TAG_TRACK },
+	{ TAG_NAME, MPD_TAG_NAME },
+	{ TAG_GENRE, MPD_TAG_GENRE },
+	{ TAG_DATE, MPD_TAG_DATE },
+	{ TAG_COMPOSER, MPD_TAG_COMPOSER },
+	{ TAG_PERFORMER, MPD_TAG_PERFORMER },
+	{ TAG_COMMENT, MPD_TAG_COMMENT },
+	{ TAG_DISC, MPD_TAG_DISC },
+	{ TAG_MUSICBRAINZ_ARTISTID, MPD_TAG_MUSICBRAINZ_ARTISTID },
+	{ TAG_MUSICBRAINZ_ALBUMID, MPD_TAG_MUSICBRAINZ_ALBUMID },
+	{ TAG_MUSICBRAINZ_ALBUMARTISTID,
+	  MPD_TAG_MUSICBRAINZ_ALBUMARTISTID },
+	{ TAG_MUSICBRAINZ_TRACKID, MPD_TAG_MUSICBRAINZ_TRACKID },
+	{ TAG_NUM_OF_ITEM_TYPES, MPD_TAG_COUNT }
+};
+
+static void
+Copy(TagBuilder &tag, TagType d_tag,
+     const struct mpd_song *song, enum mpd_tag_type s_tag)
+{
+
+	for (unsigned i = 0;; ++i) {
+		const char *value = mpd_song_get_tag(song, s_tag, i);
+		if (value == nullptr)
+			break;
+
+		tag.AddItem(d_tag, value);
+	}
+}
+
+ProxySong::ProxySong(const mpd_song *song)
+{
+	directory = nullptr;
+	uri = mpd_song_get_uri(song);
+	tag = &tag2;
+	mtime = mpd_song_get_last_modified(song);
+	start_ms = mpd_song_get_start(song) * 1000;
+	end_ms = mpd_song_get_end(song) * 1000;
+
+	TagBuilder tag_builder;
+	tag_builder.SetTime(mpd_song_get_duration(song));
+
+	for (const auto *i = &tag_table[0]; i->d != TAG_NUM_OF_ITEM_TYPES; ++i)
+		Copy(tag_builder, i->d, song, i->s);
+
+	tag_builder.Commit(tag2);
+}
+
+gcc_const
+static enum mpd_tag_type
+Convert(TagType tag_type)
+{
+	for (auto i = &tag_table[0]; i->d != TAG_NUM_OF_ITEM_TYPES; ++i)
+		if (i->d == tag_type)
+			return i->s;
+
+	return MPD_TAG_COUNT;
+}
+
+static bool
+CheckError(struct mpd_connection *connection, Error &error)
+{
+	const auto code = mpd_connection_get_error(connection);
+	if (code == MPD_ERROR_SUCCESS)
+		return true;
+
+	if (code == MPD_ERROR_SERVER) {
+		/* libmpdclient's "enum mpd_server_error" is the same
+		   as our "enum ack" */
+		const auto server_error =
+			mpd_connection_get_server_error(connection);
+		error.Set(ack_domain, (int)server_error,
+			  mpd_connection_get_error_message(connection));
+	} else {
+		error.Set(libmpdclient_domain, (int)code,
+			  mpd_connection_get_error_message(connection));
+	}
+
+	mpd_connection_clear_error(connection);
+	return false;
+}
+
+static bool
+SendConstraints(mpd_connection *connection, const SongFilter::Item &item)
+{
+	switch (item.GetTag()) {
+		mpd_tag_type tag;
+
+#if LIBMPDCLIENT_CHECK_VERSION(2,9,0)
+	case LOCATE_TAG_BASE_TYPE:
+		if (mpd_connection_cmp_server_version(connection, 0, 18, 0) < 0)
+			/* requires MPD 0.18 */
+			return true;
+
+		return mpd_search_add_base_constraint(connection,
+						      MPD_OPERATOR_DEFAULT,
+						      item.GetValue().c_str());
+#endif
+
+	case LOCATE_TAG_FILE_TYPE:
+		return mpd_search_add_uri_constraint(connection,
+						     MPD_OPERATOR_DEFAULT,
+						     item.GetValue().c_str());
+
+	case LOCATE_TAG_ANY_TYPE:
+		return mpd_search_add_any_tag_constraint(connection,
+							 MPD_OPERATOR_DEFAULT,
+							 item.GetValue().c_str());
+
+	default:
+		tag = Convert(TagType(item.GetTag()));
+		if (tag == MPD_TAG_COUNT)
+			return true;
+
+		return mpd_search_add_tag_constraint(connection,
+						     MPD_OPERATOR_DEFAULT,
+						     tag,
+						     item.GetValue().c_str());
+	}
+}
+
+static bool
+SendConstraints(mpd_connection *connection, const SongFilter &filter)
+{
+	for (const auto &i : filter.GetItems())
+		if (!SendConstraints(connection, i))
+			return false;
+
+	return true;
+}
+
+static bool
+SendConstraints(mpd_connection *connection, const DatabaseSelection &selection)
+{
+#if LIBMPDCLIENT_CHECK_VERSION(2,9,0)
+	if (!selection.uri.empty() &&
+	    mpd_connection_cmp_server_version(connection, 0, 18, 0) >= 0) {
+		/* requires MPD 0.18 */
+		if (!mpd_search_add_base_constraint(connection,
+						    MPD_OPERATOR_DEFAULT,
+						    selection.uri.c_str()))
+			return false;
+	}
+#endif
+
+	if (selection.filter != nullptr &&
+	    !SendConstraints(connection, *selection.filter))
+		return false;
+
+	return true;
+}
+
+Database *
+ProxyDatabase::Create(EventLoop &loop, DatabaseListener &listener,
+		      const config_param &param, Error &error)
+{
+	ProxyDatabase *db = new ProxyDatabase(loop, listener);
+	if (!db->Configure(param, error)) {
+		delete db;
+		db = nullptr;
+	}
+
+	return db;
+}
+
+bool
+ProxyDatabase::Configure(const config_param &param, gcc_unused Error &error)
+{
+	host = param.GetBlockValue("host", "");
+	port = param.GetBlockValue("port", 0u);
+
+	return true;
+}
+
+bool
+ProxyDatabase::Open(Error &error)
+{
+	if (!Connect(error))
+		return false;
+
+	update_stamp = 0;
+
+	return true;
+}
+
+void
+ProxyDatabase::Close()
+{
+	if (connection != nullptr)
+		Disconnect();
+}
+
+bool
+ProxyDatabase::Connect(Error &error)
+{
+	const char *_host = host.empty() ? nullptr : host.c_str();
+	connection = mpd_connection_new(_host, port, 0);
+	if (connection == nullptr) {
+		error.Set(libmpdclient_domain, (int)MPD_ERROR_OOM,
+			  "Out of memory");
+		return false;
+	}
+
+	idle_received = unsigned(-1);
+	is_idle = false;
+
+	SocketMonitor::Open(mpd_async_get_fd(mpd_connection_get_async(connection)));
+	IdleMonitor::Schedule();
+
+	if (!CheckError(connection, error)) {
+		if (connection != nullptr)
+			Disconnect();
+
+		return false;
+	}
+
+	return true;
+}
+
+bool
+ProxyDatabase::CheckConnection(Error &error)
+{
+	assert(connection != nullptr);
+
+	if (!mpd_connection_clear_error(connection)) {
+		Disconnect();
+		return Connect(error);
+	}
+
+	if (is_idle) {
+		unsigned idle = mpd_run_noidle(connection);
+		if (idle == 0 && !CheckError(connection, error)) {
+			Disconnect();
+			return false;
+		}
+
+		idle_received |= idle;
+		is_idle = false;
+		IdleMonitor::Schedule();
+	}
+
+	return true;
+}
+
+bool
+ProxyDatabase::EnsureConnected(Error &error)
+{
+	return connection != nullptr
+		? CheckConnection(error)
+		: Connect(error);
+}
+
+void
+ProxyDatabase::Disconnect()
+{
+	assert(connection != nullptr);
+
+	IdleMonitor::Cancel();
+	SocketMonitor::Steal();
+
+	mpd_connection_free(connection);
+	connection = nullptr;
+}
+
+bool
+ProxyDatabase::OnSocketReady(gcc_unused unsigned flags)
+{
+	assert(connection != nullptr);
+
+	if (!is_idle) {
+		// TODO: can this happen?
+		IdleMonitor::Schedule();
+		return false;
+	}
+
+	unsigned idle = (unsigned)mpd_recv_idle(connection, false);
+	if (idle == 0) {
+		Error error;
+		if (!CheckError(connection, error)) {
+			LogError(error);
+			Disconnect();
+			return false;
+		}
+	}
+
+	/* let OnIdle() handle this */
+	idle_received |= idle;
+	is_idle = false;
+	IdleMonitor::Schedule();
+	return false;
+}
+
+void
+ProxyDatabase::OnIdle()
+{
+	assert(connection != nullptr);
+
+	/* handle previous idle events */
+
+	if (idle_received & MPD_IDLE_DATABASE)
+		listener.OnDatabaseModified();
+
+	idle_received = 0;
+
+	/* send a new idle command to the other MPD */
+
+	if (is_idle)
+		// TODO: can this happen?
+		return;
+
+	if (!mpd_send_idle_mask(connection, MPD_IDLE_DATABASE)) {
+		Error error;
+		if (!CheckError(connection, error))
+			LogError(error);
+
+		SocketMonitor::Steal();
+		mpd_connection_free(connection);
+		connection = nullptr;
+		return;
+	}
+
+	is_idle = true;
+	SocketMonitor::ScheduleRead();
+}
+
+const LightSong *
+ProxyDatabase::GetSong(const char *uri, Error &error) const
+{
+	// TODO: eliminate the const_cast
+	if (!const_cast<ProxyDatabase *>(this)->EnsureConnected(error))
+		return nullptr;
+
+	if (!mpd_send_list_meta(connection, uri)) {
+		CheckError(connection, error);
+		return nullptr;
+	}
+
+	struct mpd_song *song = mpd_recv_song(connection);
+	if (!mpd_response_finish(connection) &&
+	    !CheckError(connection, error)) {
+		if (song != nullptr)
+			mpd_song_free(song);
+		return nullptr;
+	}
+
+	if (song == nullptr) {
+		error.Format(db_domain, DB_NOT_FOUND, "No such song: %s", uri);
+		return nullptr;
+	}
+
+	return new AllocatedProxySong(song);
+}
+
+void
+ProxyDatabase::ReturnSong(const LightSong *_song) const
+{
+	assert(_song != nullptr);
+
+	AllocatedProxySong *song = (AllocatedProxySong *)
+		const_cast<LightSong *>(_song);
+	delete song;
+}
+
+static bool
+Visit(struct mpd_connection *connection, const char *uri,
+      bool recursive, const SongFilter *filter,
+      VisitDirectory visit_directory, VisitSong visit_song,
+      VisitPlaylist visit_playlist, Error &error);
+
+static bool
+Visit(struct mpd_connection *connection,
+      bool recursive, const SongFilter *filter,
+      const struct mpd_directory *directory,
+      VisitDirectory visit_directory, VisitSong visit_song,
+      VisitPlaylist visit_playlist, Error &error)
+{
+	const char *path = mpd_directory_get_path(directory);
+#if LIBMPDCLIENT_CHECK_VERSION(2,9,0)
+	time_t mtime = mpd_directory_get_last_modified(directory);
+#else
+	time_t mtime = 0;
+#endif
+
+	if (visit_directory &&
+	    !visit_directory(LightDirectory(path, mtime), error))
+		return false;
+
+	if (recursive &&
+	    !Visit(connection, path, recursive, filter,
+		   visit_directory, visit_song, visit_playlist, error))
+		return false;
+
+	return true;
+}
+
+gcc_pure
+static bool
+Match(const SongFilter *filter, const LightSong &song)
+{
+	return filter == nullptr || filter->Match(song);
+}
+
+static bool
+Visit(const SongFilter *filter,
+      const mpd_song *_song,
+      VisitSong visit_song, Error &error)
+{
+	if (!visit_song)
+		return true;
+
+	const ProxySong song(_song);
+	return !Match(filter, song) || visit_song(song, error);
+}
+
+static bool
+Visit(const struct mpd_playlist *playlist,
+      VisitPlaylist visit_playlist, Error &error)
+{
+	if (!visit_playlist)
+		return true;
+
+	PlaylistInfo p(mpd_playlist_get_path(playlist),
+		       mpd_playlist_get_last_modified(playlist));
+
+	return visit_playlist(p, LightDirectory::Root(), error);
+}
+
+class ProxyEntity {
+	struct mpd_entity *entity;
+
+public:
+	explicit ProxyEntity(struct mpd_entity *_entity)
+		:entity(_entity) {}
+
+	ProxyEntity(const ProxyEntity &other) = delete;
+
+	ProxyEntity(ProxyEntity &&other)
+		:entity(other.entity) {
+		other.entity = nullptr;
+	}
+
+	~ProxyEntity() {
+		if (entity != nullptr)
+			mpd_entity_free(entity);
+	}
+
+	ProxyEntity &operator=(const ProxyEntity &other) = delete;
+
+	operator const struct mpd_entity *() const {
+		return entity;
+	}
+};
+
+static std::list<ProxyEntity>
+ReceiveEntities(struct mpd_connection *connection)
+{
+	std::list<ProxyEntity> entities;
+	struct mpd_entity *entity;
+	while ((entity = mpd_recv_entity(connection)) != nullptr)
+		entities.push_back(ProxyEntity(entity));
+
+	mpd_response_finish(connection);
+	return entities;
+}
+
+static bool
+Visit(struct mpd_connection *connection, const char *uri,
+      bool recursive, const SongFilter *filter,
+      VisitDirectory visit_directory, VisitSong visit_song,
+      VisitPlaylist visit_playlist, Error &error)
+{
+	if (!mpd_send_list_meta(connection, uri))
+		return CheckError(connection, error);
+
+	std::list<ProxyEntity> entities(ReceiveEntities(connection));
+	if (!CheckError(connection, error))
+		return false;
+
+	for (const auto &entity : entities) {
+		switch (mpd_entity_get_type(entity)) {
+		case MPD_ENTITY_TYPE_UNKNOWN:
+			break;
+
+		case MPD_ENTITY_TYPE_DIRECTORY:
+			if (!Visit(connection, recursive, filter,
+				   mpd_entity_get_directory(entity),
+				   visit_directory, visit_song, visit_playlist,
+				   error))
+				return false;
+			break;
+
+		case MPD_ENTITY_TYPE_SONG:
+			if (!Visit(filter,
+				   mpd_entity_get_song(entity), visit_song,
+				   error))
+				return false;
+			break;
+
+		case MPD_ENTITY_TYPE_PLAYLIST:
+			if (!Visit(mpd_entity_get_playlist(entity),
+				   visit_playlist, error))
+				return false;
+			break;
+		}
+	}
+
+	return CheckError(connection, error);
+}
+
+static bool
+SearchSongs(struct mpd_connection *connection,
+	    const DatabaseSelection &selection,
+	    VisitSong visit_song,
+	    Error &error)
+{
+	assert(selection.recursive);
+	assert(visit_song);
+
+	const bool exact = selection.filter == nullptr ||
+		!selection.filter->HasFoldCase();
+
+	if (!mpd_search_db_songs(connection, exact) ||
+	    !SendConstraints(connection, selection) ||
+	    !mpd_search_commit(connection))
+		return CheckError(connection, error);
+
+	bool result = true;
+	struct mpd_song *song;
+	while (result && (song = mpd_recv_song(connection)) != nullptr) {
+		AllocatedProxySong song2(song);
+
+		result = !Match(selection.filter, song2) ||
+			visit_song(song2, error);
+	}
+
+	mpd_response_finish(connection);
+	return result && CheckError(connection, error);
+}
+
+bool
+ProxyDatabase::Visit(const DatabaseSelection &selection,
+		     VisitDirectory visit_directory,
+		     VisitSong visit_song,
+		     VisitPlaylist visit_playlist,
+		     Error &error) const
+{
+	// TODO: eliminate the const_cast
+	if (!const_cast<ProxyDatabase *>(this)->EnsureConnected(error))
+		return nullptr;
+
+	if (!visit_directory && !visit_playlist && selection.recursive)
+		/* this optimized code path can only be used under
+		   certain conditions */
+		return ::SearchSongs(connection, selection, visit_song, error);
+
+	/* fall back to recursive walk (slow!) */
+	return ::Visit(connection, selection.uri.c_str(),
+		       selection.recursive, selection.filter,
+		       visit_directory, visit_song, visit_playlist,
+		       error);
+}
+
+bool
+ProxyDatabase::VisitUniqueTags(const DatabaseSelection &selection,
+			       TagType tag_type,
+			       VisitString visit_string,
+			       Error &error) const
+{
+	// TODO: eliminate the const_cast
+	if (!const_cast<ProxyDatabase *>(this)->EnsureConnected(error))
+		return nullptr;
+
+	enum mpd_tag_type tag_type2 = Convert(tag_type);
+	if (tag_type2 == MPD_TAG_COUNT) {
+		error.Set(libmpdclient_domain, "Unsupported tag");
+		return false;
+	}
+
+	if (!mpd_search_db_tags(connection, tag_type2))
+		return CheckError(connection, error);
+
+	if (!SendConstraints(connection, selection))
+		return CheckError(connection, error);
+
+	if (!mpd_search_commit(connection))
+		return CheckError(connection, error);
+
+	bool result = true;
+
+	struct mpd_pair *pair;
+	while (result &&
+	       (pair = mpd_recv_pair_tag(connection, tag_type2)) != nullptr) {
+		result = visit_string(pair->value, error);
+		mpd_return_pair(connection, pair);
+	}
+
+	return mpd_response_finish(connection) &&
+		CheckError(connection, error) &&
+		result;
+}
+
+bool
+ProxyDatabase::GetStats(const DatabaseSelection &selection,
+			DatabaseStats &stats, Error &error) const
+{
+	// TODO: match
+	(void)selection;
+
+	// TODO: eliminate the const_cast
+	if (!const_cast<ProxyDatabase *>(this)->EnsureConnected(error))
+		return nullptr;
+
+	struct mpd_stats *stats2 =
+		mpd_run_stats(connection);
+	if (stats2 == nullptr)
+		return CheckError(connection, error);
+
+	update_stamp = (time_t)mpd_stats_get_db_update_time(stats2);
+
+	stats.song_count = mpd_stats_get_number_of_songs(stats2);
+	stats.total_duration = mpd_stats_get_db_play_time(stats2);
+	stats.artist_count = mpd_stats_get_number_of_artists(stats2);
+	stats.album_count = mpd_stats_get_number_of_albums(stats2);
+	mpd_stats_free(stats2);
+
+	return true;
+}
+
+const DatabasePlugin proxy_db_plugin = {
+	"proxy",
+	ProxyDatabase::Create,
+};
diff --git a/src/db/plugins/ProxyDatabasePlugin.hxx b/src/db/plugins/ProxyDatabasePlugin.hxx
new file mode 100644
index 000000000..699d374b5
--- /dev/null
+++ b/src/db/plugins/ProxyDatabasePlugin.hxx
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2003-2014 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_PROXY_DATABASE_PLUGIN_HXX
+#define MPD_PROXY_DATABASE_PLUGIN_HXX
+
+struct DatabasePlugin;
+
+extern const DatabasePlugin proxy_db_plugin;
+
+#endif
diff --git a/src/db/plugins/SimpleDatabasePlugin.cxx b/src/db/plugins/SimpleDatabasePlugin.cxx
new file mode 100644
index 000000000..55e08b6d7
--- /dev/null
+++ b/src/db/plugins/SimpleDatabasePlugin.cxx
@@ -0,0 +1,336 @@
+/*
+ * Copyright (C) 2003-2014 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 "SimpleDatabasePlugin.hxx"
+#include "db/Selection.hxx"
+#include "db/Helpers.hxx"
+#include "db/LightDirectory.hxx"
+#include "db/Directory.hxx"
+#include "db/Song.hxx"
+#include "SongFilter.hxx"
+#include "db/DatabaseSave.hxx"
+#include "db/DatabaseLock.hxx"
+#include "db/DatabaseError.hxx"
+#include "fs/TextFile.hxx"
+#include "config/ConfigData.hxx"
+#include "fs/FileSystem.hxx"
+#include "util/Error.hxx"
+#include "util/Domain.hxx"
+#include "Log.hxx"
+
+#include <errno.h>
+
+static constexpr Domain simple_db_domain("simple_db");
+
+Database *
+SimpleDatabase::Create(gcc_unused EventLoop &loop,
+		       gcc_unused DatabaseListener &listener,
+		       const config_param &param, Error &error)
+{
+	SimpleDatabase *db = new SimpleDatabase();
+	if (!db->Configure(param, error)) {
+		delete db;
+		db = nullptr;
+	}
+
+	return db;
+}
+
+bool
+SimpleDatabase::Configure(const config_param &param, Error &error)
+{
+	path = param.GetBlockPath("path", error);
+	if (path.IsNull()) {
+		if (!error.IsDefined())
+			error.Set(simple_db_domain,
+				  "No \"path\" parameter specified");
+		return false;
+	}
+
+	path_utf8 = path.ToUTF8();
+
+	return true;
+}
+
+bool
+SimpleDatabase::Check(Error &error) const
+{
+	assert(!path.IsNull());
+
+	/* Check if the file exists */
+	if (!CheckAccess(path)) {
+		/* If the file doesn't exist, we can't check if we can write
+		 * it, so we are going to try to get the directory path, and
+		 * see if we can write a file in that */
+		const auto dirPath = path.GetDirectoryName();
+
+		/* Check that the parent part of the path is a directory */
+		struct stat st;
+		if (!StatFile(dirPath, st)) {
+			error.FormatErrno("Couldn't stat parent directory of db file "
+					  "\"%s\"",
+					  path_utf8.c_str());
+			return false;
+		}
+
+		if (!S_ISDIR(st.st_mode)) {
+			error.Format(simple_db_domain,
+				     "Couldn't create db file \"%s\" because the "
+				     "parent path is not a directory",
+				     path_utf8.c_str());
+			return false;
+		}
+
+#ifndef WIN32
+		/* Check if we can write to the directory */
+		if (!CheckAccess(dirPath, X_OK | W_OK)) {
+			const int e = errno;
+			const std::string dirPath_utf8 = dirPath.ToUTF8();
+			error.FormatErrno(e, "Can't create db file in \"%s\"",
+					  dirPath_utf8.c_str());
+			return false;
+		}
+#endif
+		return true;
+	}
+
+	/* Path exists, now check if it's a regular file */
+	struct stat st;
+	if (!StatFile(path, st)) {
+		error.FormatErrno("Couldn't stat db file \"%s\"",
+				  path_utf8.c_str());
+		return false;
+	}
+
+	if (!S_ISREG(st.st_mode)) {
+		error.Format(simple_db_domain,
+			     "db file \"%s\" is not a regular file",
+			     path_utf8.c_str());
+		return false;
+	}
+
+#ifndef WIN32
+	/* And check that we can write to it */
+	if (!CheckAccess(path, R_OK | W_OK)) {
+		error.FormatErrno("Can't open db file \"%s\" for reading/writing",
+				  path_utf8.c_str());
+		return false;
+	}
+#endif
+
+	return true;
+}
+
+bool
+SimpleDatabase::Load(Error &error)
+{
+	assert(!path.IsNull());
+	assert(root != nullptr);
+
+	TextFile file(path);
+	if (file.HasFailed()) {
+		error.FormatErrno("Failed to open database file \"%s\"",
+				  path_utf8.c_str());
+		return false;
+	}
+
+	if (!db_load_internal(file, *root, error))
+		return false;
+
+	struct stat st;
+	if (StatFile(path, st))
+		mtime = st.st_mtime;
+
+	return true;
+}
+
+bool
+SimpleDatabase::Open(Error &error)
+{
+	root = Directory::NewRoot();
+	mtime = 0;
+
+#ifndef NDEBUG
+	borrowed_song_count = 0;
+#endif
+
+	if (!Load(error)) {
+		delete root;
+
+		LogError(error);
+		error.Clear();
+
+		if (!Check(error))
+			return false;
+
+		root = Directory::NewRoot();
+	}
+
+	return true;
+}
+
+void
+SimpleDatabase::Close()
+{
+	assert(root != nullptr);
+	assert(borrowed_song_count == 0);
+
+	delete root;
+}
+
+const LightSong *
+SimpleDatabase::GetSong(const char *uri, Error &error) const
+{
+	assert(root != nullptr);
+	assert(borrowed_song_count == 0);
+
+	db_lock();
+	const Song *song = root->LookupSong(uri);
+	db_unlock();
+	if (song == nullptr) {
+		error.Format(db_domain, DB_NOT_FOUND,
+			     "No such song: %s", uri);
+		return nullptr;
+	}
+
+	light_song = song->Export();
+
+#ifndef NDEBUG
+	++borrowed_song_count;
+#endif
+
+	return &light_song;
+}
+
+void
+SimpleDatabase::ReturnSong(gcc_unused const LightSong *song) const
+{
+	assert(song == &light_song);
+
+#ifndef NDEBUG
+	assert(borrowed_song_count > 0);
+	--borrowed_song_count;
+#endif
+}
+
+gcc_pure
+const Directory *
+SimpleDatabase::LookupDirectory(const char *uri) const
+{
+	assert(root != nullptr);
+	assert(uri != nullptr);
+
+	ScopeDatabaseLock protect;
+	return root->LookupDirectory(uri);
+}
+
+bool
+SimpleDatabase::Visit(const DatabaseSelection &selection,
+		      VisitDirectory visit_directory,
+		      VisitSong visit_song,
+		      VisitPlaylist visit_playlist,
+		      Error &error) const
+{
+	ScopeDatabaseLock protect;
+
+	const Directory *directory = root->LookupDirectory(selection.uri.c_str());
+	if (directory == nullptr) {
+		if (visit_song) {
+			Song *song = root->LookupSong(selection.uri.c_str());
+			if (song != nullptr) {
+				const LightSong song2 = song->Export();
+				return !selection.Match(song2) ||
+					visit_song(song2, error);
+			}
+		}
+
+		error.Set(db_domain, DB_NOT_FOUND, "No such directory");
+		return false;
+	}
+
+	if (selection.recursive && visit_directory &&
+	    !visit_directory(directory->Export(), error))
+		return false;
+
+	return directory->Walk(selection.recursive, selection.filter,
+			       visit_directory, visit_song, visit_playlist,
+			       error);
+}
+
+bool
+SimpleDatabase::VisitUniqueTags(const DatabaseSelection &selection,
+				TagType tag_type,
+				VisitString visit_string,
+				Error &error) const
+{
+	return ::VisitUniqueTags(*this, selection, tag_type, visit_string,
+				 error);
+}
+
+bool
+SimpleDatabase::GetStats(const DatabaseSelection &selection,
+			 DatabaseStats &stats, Error &error) const
+{
+	return ::GetStats(*this, selection, stats, error);
+}
+
+bool
+SimpleDatabase::Save(Error &error)
+{
+	db_lock();
+
+	LogDebug(simple_db_domain, "removing empty directories from DB");
+	root->PruneEmpty();
+
+	LogDebug(simple_db_domain, "sorting DB");
+	root->Sort();
+
+	db_unlock();
+
+	LogDebug(simple_db_domain, "writing DB");
+
+	FILE *fp = FOpen(path, FOpenMode::WriteText);
+	if (!fp) {
+		error.FormatErrno("unable to write to db file \"%s\"",
+				  path_utf8.c_str());
+		return false;
+	}
+
+	db_save_internal(fp, *root);
+
+	if (ferror(fp)) {
+		error.SetErrno("Failed to write to database file");
+		fclose(fp);
+		return false;
+	}
+
+	fclose(fp);
+
+	struct stat st;
+	if (StatFile(path, st))
+		mtime = st.st_mtime;
+
+	return true;
+}
+
+const DatabasePlugin simple_db_plugin = {
+	"simple",
+	SimpleDatabase::Create,
+};
diff --git a/src/db/plugins/SimpleDatabasePlugin.hxx b/src/db/plugins/SimpleDatabasePlugin.hxx
new file mode 100644
index 000000000..137a60884
--- /dev/null
+++ b/src/db/plugins/SimpleDatabasePlugin.hxx
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2003-2014 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_SIMPLE_DATABASE_PLUGIN_HXX
+#define MPD_SIMPLE_DATABASE_PLUGIN_HXX
+
+#include "db/DatabasePlugin.hxx"
+#include "fs/AllocatedPath.hxx"
+#include "db/LightSong.hxx"
+#include "Compiler.h"
+
+#include <cassert>
+
+struct Directory;
+
+class SimpleDatabase : public Database {
+	AllocatedPath path;
+	std::string path_utf8;
+
+	Directory *root;
+
+	time_t mtime;
+
+	/**
+	 * A buffer for GetSong().
+	 */
+	mutable LightSong light_song;
+
+#ifndef NDEBUG
+	mutable unsigned borrowed_song_count;
+#endif
+
+	SimpleDatabase()
+		:path(AllocatedPath::Null()) {}
+
+public:
+	gcc_pure
+	Directory *GetRoot() {
+		assert(root != NULL);
+
+		return root;
+	}
+
+	bool Save(Error &error);
+
+	static Database *Create(EventLoop &loop, DatabaseListener &listener,
+				const config_param &param,
+				Error &error);
+
+	virtual bool Open(Error &error) override;
+	virtual void Close() override;
+
+	virtual const LightSong *GetSong(const char *uri_utf8,
+					 Error &error) const override;
+	virtual void ReturnSong(const LightSong *song) const;
+
+	virtual bool Visit(const DatabaseSelection &selection,
+			   VisitDirectory visit_directory,
+			   VisitSong visit_song,
+			   VisitPlaylist visit_playlist,
+			   Error &error) const override;
+
+	virtual bool VisitUniqueTags(const DatabaseSelection &selection,
+				     TagType tag_type,
+				     VisitString visit_string,
+				     Error &error) const override;
+
+	virtual bool GetStats(const DatabaseSelection &selection,
+			      DatabaseStats &stats,
+			      Error &error) const override;
+
+	virtual time_t GetUpdateStamp() const override {
+		return mtime;
+	}
+
+protected:
+	bool Configure(const config_param &param, Error &error);
+
+	gcc_pure
+	bool Check(Error &error) const;
+
+	bool Load(Error &error);
+
+	gcc_pure
+	const Directory *LookupDirectory(const char *uri) const;
+};
+
+extern const DatabasePlugin simple_db_plugin;
+
+#endif
diff --git a/src/db/plugins/UpnpDatabasePlugin.cxx b/src/db/plugins/UpnpDatabasePlugin.cxx
new file mode 100644
index 000000000..10575fc94
--- /dev/null
+++ b/src/db/plugins/UpnpDatabasePlugin.cxx
@@ -0,0 +1,785 @@
+/*
+ * Copyright (C) 2003-2014 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 "UpnpDatabasePlugin.hxx"
+#include "upnp/Domain.hxx"
+#include "upnp/upnpplib.hxx"
+#include "upnp/Discovery.hxx"
+#include "upnp/ContentDirectoryService.hxx"
+#include "upnp/Directory.hxx"
+#include "upnp/Tags.hxx"
+#include "upnp/Util.hxx"
+#include "db/DatabasePlugin.hxx"
+#include "db/Selection.hxx"
+#include "db/DatabaseError.hxx"
+#include "db/LightDirectory.hxx"
+#include "db/LightSong.hxx"
+#include "config/ConfigData.hxx"
+#include "tag/TagBuilder.hxx"
+#include "tag/TagTable.hxx"
+#include "util/Error.hxx"
+#include "util/Domain.hxx"
+#include "fs/Traits.hxx"
+#include "Log.hxx"
+#include "SongFilter.hxx"
+
+#include <string>
+#include <vector>
+#include <set>
+
+#include <assert.h>
+#include <string.h>
+
+static const char *const rootid = "0";
+
+class UpnpSong : public LightSong {
+	std::string uri2, real_uri2;
+
+	Tag tag2;
+
+public:
+	UpnpSong(UPnPDirObject &&object, std::string &&_uri)
+		:uri2(std::move(_uri)),
+		 real_uri2(std::move(object.url)),
+		 tag2(std::move(object.tag)) {
+		directory = nullptr;
+		uri = uri2.c_str();
+		real_uri = real_uri2.c_str();
+		tag = &tag2;
+		mtime = 0;
+		start_ms = end_ms = 0;
+	}
+};
+
+class UpnpDatabase : public Database {
+	LibUPnP *m_lib;
+	UPnPDeviceDirectory *m_superdir;
+
+public:
+	static Database *Create(EventLoop &loop, DatabaseListener &listener,
+				const config_param &param,
+				Error &error);
+
+	virtual bool Open(Error &error) override;
+	virtual void Close() override;
+	virtual const LightSong *GetSong(const char *uri_utf8,
+					 Error &error) const override;
+	virtual void ReturnSong(const LightSong *song) const;
+
+	virtual bool Visit(const DatabaseSelection &selection,
+			   VisitDirectory visit_directory,
+			   VisitSong visit_song,
+			   VisitPlaylist visit_playlist,
+			   Error &error) const override;
+
+	virtual bool VisitUniqueTags(const DatabaseSelection &selection,
+				     TagType tag_type,
+				     VisitString visit_string,
+				     Error &error) const override;
+
+	virtual bool GetStats(const DatabaseSelection &selection,
+			      DatabaseStats &stats,
+			      Error &error) const override;
+	virtual time_t GetUpdateStamp() const {return 0;}
+
+protected:
+	bool Configure(const config_param &param, Error &error);
+
+private:
+	bool VisitServer(const ContentDirectoryService &server,
+			 const std::list<std::string> &vpath,
+			 const DatabaseSelection &selection,
+			 VisitDirectory visit_directory,
+			 VisitSong visit_song,
+			 VisitPlaylist visit_playlist,
+			 Error &error) const;
+
+	/**
+	 * Run an UPnP search according to MPD parameters, and
+	 * visit_song the results.
+	 */
+	bool SearchSongs(const ContentDirectoryService &server,
+			 const char *objid,
+			 const DatabaseSelection &selection,
+			 VisitSong visit_song,
+			 Error &error) const;
+
+	bool SearchSongs(const ContentDirectoryService &server,
+			 const char *objid,
+			 const DatabaseSelection &selection,
+			 UPnPDirContent& dirbuf,
+			 Error &error) const;
+
+	bool Namei(const ContentDirectoryService &server,
+		   const std::list<std::string> &vpath,
+		   UPnPDirObject &dirent,
+		   Error &error) const;
+
+	/**
+	 * Take server and objid, return metadata.
+	 */
+	bool ReadNode(const ContentDirectoryService &server,
+		      const char *objid, UPnPDirObject& dirent,
+		      Error &error) const;
+
+	/**
+	 * Get the path for an object Id. This works much like pwd,
+	 * except easier cause our inodes have a parent id. Not used
+	 * any more actually (see comments in SearchSongs).
+	 */
+	bool BuildPath(const ContentDirectoryService &server,
+		       const UPnPDirObject& dirent, std::string &idpath,
+		       Error &error) const;
+};
+
+Database *
+UpnpDatabase::Create(gcc_unused EventLoop &loop,
+		     gcc_unused DatabaseListener &listener,
+		     const config_param &param, Error &error)
+{
+	UpnpDatabase *db = new UpnpDatabase();
+	if (!db->Configure(param, error)) {
+		delete db;
+		return nullptr;
+	}
+
+	/* libupnp loses its ability to receive multicast messages
+	   apparently due to daemonization; using the LazyDatabase
+	   wrapper works around this problem */
+	return db;
+}
+
+inline bool
+UpnpDatabase::Configure(const config_param &, Error &)
+{
+	return true;
+}
+
+bool
+UpnpDatabase::Open(Error &error)
+{
+	m_lib = new LibUPnP();
+	if (!m_lib->ok()) {
+		error.Set(m_lib->GetInitError());
+		delete m_lib;
+		return false;
+	}
+
+	m_superdir = new UPnPDeviceDirectory(m_lib);
+	if (!m_superdir->Start(error)) {
+		delete m_superdir;
+		delete m_lib;
+		return false;
+	}
+
+	// Wait for device answers. This should be consistent with the value set
+	// in the lib (currently 2)
+	sleep(2);
+	return true;
+}
+
+void
+UpnpDatabase::Close()
+{
+	delete m_superdir;
+	delete m_lib;
+}
+
+void
+UpnpDatabase::ReturnSong(const LightSong *_song) const
+{
+	assert(_song != nullptr);
+
+	UpnpSong *song = (UpnpSong *)const_cast<LightSong *>(_song);
+	delete song;
+}
+
+// Get song info by path. We can receive either the id path, or the titles
+// one
+const LightSong *
+UpnpDatabase::GetSong(const char *uri, Error &error) const
+{
+	auto vpath = stringToTokens(uri, "/", true);
+	if (vpath.size() < 2) {
+		error.Format(db_domain, DB_NOT_FOUND, "No such song: %s", uri);
+		return nullptr;
+	}
+
+	ContentDirectoryService server;
+	if (!m_superdir->getServer(vpath.front().c_str(), server, error))
+		return nullptr;
+
+	vpath.pop_front();
+
+	UPnPDirObject dirent;
+	if (vpath.front() != rootid) {
+		if (!Namei(server, vpath, dirent, error))
+			return nullptr;
+	} else {
+		if (!ReadNode(server, vpath.back().c_str(), dirent,
+			      error))
+			return nullptr;
+	}
+
+	return new UpnpSong(std::move(dirent), uri);
+}
+
+/**
+ * Double-quote a string, adding internal backslash escaping.
+ */
+static void
+dquote(std::string &out, const char *in)
+{
+	out.push_back('"');
+
+	for (; *in != 0; ++in) {
+		switch(*in) {
+		case '\\':
+		case '"':
+			out.push_back('\\');
+			break;
+		}
+
+		out.push_back(*in);
+	}
+
+	out.push_back('"');
+}
+
+// Run an UPnP search, according to MPD parameters. Return results as
+// UPnP items
+bool
+UpnpDatabase::SearchSongs(const ContentDirectoryService &server,
+			  const char *objid,
+			  const DatabaseSelection &selection,
+			  UPnPDirContent &dirbuf,
+			  Error &error) const
+{
+	const SongFilter *filter = selection.filter;
+	if (selection.filter == nullptr)
+		return true;
+
+	std::list<std::string> searchcaps;
+	if (!server.getSearchCapabilities(m_lib->getclh(), searchcaps, error))
+		return false;
+
+	if (searchcaps.empty())
+		return true;
+
+	std::string cond;
+	for (const auto &item : filter->GetItems()) {
+		switch (auto tag = item.GetTag()) {
+		case LOCATE_TAG_ANY_TYPE:
+			{
+				if (!cond.empty()) {
+					cond += " and ";
+				}
+				cond += '(';
+				bool first(true);
+				for (const auto& cap : searchcaps) {
+					if (first)
+						first = false;
+					else
+						cond += " or ";
+					cond += cap;
+					if (item.GetFoldCase()) {
+						cond += " contains ";
+					} else {
+						cond += " = ";
+					}
+					dquote(cond, item.GetValue().c_str());
+				}
+				cond += ')';
+			}
+			break;
+
+		default:
+			/* Unhandled conditions like
+			   LOCATE_TAG_BASE_TYPE or
+			   LOCATE_TAG_FILE_TYPE won't have a
+			   corresponding upnp prop, so they will be
+			   skipped */
+			if (tag == TAG_ALBUM_ARTIST)
+				tag = TAG_ARTIST;
+
+			// TODO: support LOCATE_TAG_ANY_TYPE etc.
+			const char *name = tag_table_lookup(upnp_tags,
+							    TagType(tag));
+			if (name == nullptr)
+				continue;
+
+			if (!cond.empty()) {
+				cond += " and ";
+			}
+			cond += name;
+
+			/* FoldCase doubles up as contains/equal
+			   switch. UpNP search is supposed to be
+			   case-insensitive, but at least some servers
+			   have the same convention as mpd (e.g.:
+			   minidlna) */
+			if (item.GetFoldCase()) {
+				cond += " contains ";
+			} else {
+				cond += " = ";
+			}
+			dquote(cond, item.GetValue().c_str());
+		}
+	}
+
+	return server.search(m_lib->getclh(),
+			     objid, cond.c_str(), dirbuf,
+			     error);
+}
+
+static bool
+visitSong(const UPnPDirObject &meta, const char *path,
+	  const DatabaseSelection &selection,
+	  VisitSong visit_song, Error& error)
+{
+	if (!visit_song)
+		return true;
+
+	LightSong song;
+	song.directory = nullptr;
+	song.uri = path;
+	song.real_uri = meta.url.c_str();
+	song.tag = &meta.tag;
+	song.mtime = 0;
+	song.start_ms = song.end_ms = 0;
+
+	return !selection.Match(song) || visit_song(song, error);
+}
+
+/**
+ * Build synthetic path based on object id for search results. The use
+ * of "rootid" is arbitrary, any name that is not likely to be a top
+ * directory name would fit.
+ */
+static std::string
+songPath(const std::string &servername,
+	 const std::string &objid)
+{
+	return servername + "/" + rootid + "/" + objid;
+}
+
+bool
+UpnpDatabase::SearchSongs(const ContentDirectoryService &server,
+			  const char *objid,
+			  const DatabaseSelection &selection,
+			  VisitSong visit_song,
+			  Error &error) const
+{
+	UPnPDirContent dirbuf;
+	if (!visit_song)
+		return true;
+	if (!SearchSongs(server, objid, selection, dirbuf, error))
+		return false;
+
+	for (auto &dirent : dirbuf.objects) {
+		if (dirent.type != UPnPDirObject::Type::ITEM ||
+		    dirent.item_class != UPnPDirObject::ItemClass::MUSIC)
+			continue;
+
+		// We get song ids as the result of the UPnP search. But our
+		// client expects paths (e.g. we get 1$4$3788 from minidlna,
+		// but we need to translate to /Music/All_Music/Satisfaction).
+		// We can do this in two ways:
+		//  - Rebuild a normal path using BuildPath() which is a kind of pwd
+		//  - Build a bogus path based on the song id.
+		// The first method is nice because the returned paths are pretty, but
+		// it has two big problems:
+		//  - The song paths are ambiguous: e.g. minidlna returns all search
+		//    results as being from the "All Music" directory, which can
+		//    contain several songs with the same title (but different objids)
+		//  - The performance of BuildPath() is atrocious on very big
+		//    directories, even causing timeouts in clients. And of
+		//    course, 'All Music' is very big.
+		// So we return synthetic and ugly paths based on the object id,
+		// which we later have to detect.
+		const std::string path = songPath(server.getFriendlyName(),
+						  dirent.m_id);
+		if (!visitSong(std::move(dirent), path.c_str(),
+			       selection, visit_song,
+			       error))
+			return false;
+	}
+
+	return true;
+}
+
+bool
+UpnpDatabase::ReadNode(const ContentDirectoryService &server,
+		       const char *objid, UPnPDirObject &dirent,
+		       Error &error) const
+{
+	UPnPDirContent dirbuf;
+	if (!server.getMetadata(m_lib->getclh(), objid, dirbuf, error))
+		return false;
+
+	if (dirbuf.objects.size() == 1) {
+		dirent = std::move(dirbuf.objects.front());
+	} else {
+		error.Format(upnp_domain, "Bad resource");
+		return false;
+	}
+
+	return true;
+}
+
+bool
+UpnpDatabase::BuildPath(const ContentDirectoryService &server,
+			const UPnPDirObject& idirent,
+			std::string &path,
+			Error &error) const
+{
+	const char *pid = idirent.m_id.c_str();
+	path.clear();
+	UPnPDirObject dirent;
+	while (strcmp(pid, rootid) != 0) {
+		if (!ReadNode(server, pid, dirent, error))
+			return false;
+		pid = dirent.m_pid.c_str();
+
+		if (path.empty())
+			path = dirent.name;
+		else
+			path = PathTraitsUTF8::Build(dirent.name.c_str(),
+						     path.c_str());
+	}
+
+	path = PathTraitsUTF8::Build(server.getFriendlyName(),
+				     path.c_str());
+	return true;
+}
+
+// Take server and internal title pathname and return objid and metadata.
+bool
+UpnpDatabase::Namei(const ContentDirectoryService &server,
+		    const std::list<std::string> &vpath,
+		    UPnPDirObject &odirent,
+		    Error &error) const
+{
+	if (vpath.empty()) {
+		// looking for root info
+		if (!ReadNode(server, rootid, odirent, error))
+			return false;
+
+		return true;
+	}
+
+	const UpnpClient_Handle handle = m_lib->getclh();
+
+	std::string objid(rootid);
+
+	// Walk the path elements, read each directory and try to find the next one
+	for (auto i = vpath.begin(), last = std::prev(vpath.end());; ++i) {
+		UPnPDirContent dirbuf;
+		if (!server.readDir(handle, objid.c_str(), dirbuf, error))
+			return false;
+
+		// Look for the name in the sub-container list
+		UPnPDirObject *child = dirbuf.FindObject(i->c_str());
+		if (child == nullptr) {
+			error.Format(db_domain, DB_NOT_FOUND,
+				     "No such object");
+			return false;
+		}
+
+		if (i == last) {
+			odirent = std::move(*child);
+			return true;
+		}
+
+		if (child->type != UPnPDirObject::Type::CONTAINER) {
+			error.Format(db_domain, DB_NOT_FOUND,
+				     "Not a container");
+			return false;
+		}
+
+		objid = std::move(child->m_id);
+	}
+}
+
+static bool
+VisitItem(const UPnPDirObject &object, const char *uri,
+	  const DatabaseSelection &selection,
+	  VisitSong visit_song, VisitPlaylist visit_playlist,
+	  Error &error)
+{
+	assert(object.type == UPnPDirObject::Type::ITEM);
+
+	switch (object.item_class) {
+	case UPnPDirObject::ItemClass::MUSIC:
+		return !visit_song ||
+			visitSong(object, uri,
+				  selection, visit_song, error);
+
+	case UPnPDirObject::ItemClass::PLAYLIST:
+		if (visit_playlist) {
+			/* Note: I've yet to see a
+			   playlist item (playlists
+			   seem to be usually handled
+			   as containers, so I'll
+			   decide what to do when I
+			   see one... */
+		}
+
+		return true;
+
+	case UPnPDirObject::ItemClass::UNKNOWN:
+		return true;
+	}
+
+	assert(false);
+	gcc_unreachable();
+}
+
+static bool
+VisitObject(const UPnPDirObject &object, const char *uri,
+	    const DatabaseSelection &selection,
+	    VisitDirectory visit_directory,
+	    VisitSong visit_song,
+	    VisitPlaylist visit_playlist,
+	    Error &error)
+{
+	switch (object.type) {
+	case UPnPDirObject::Type::UNKNOWN:
+		assert(false);
+		gcc_unreachable();
+
+	case UPnPDirObject::Type::CONTAINER:
+		return !visit_directory ||
+			visit_directory(LightDirectory(uri, 0), error);
+
+	case UPnPDirObject::Type::ITEM:
+		return VisitItem(object, uri, selection,
+				 visit_song, visit_playlist,
+				 error);
+	}
+
+	assert(false);
+	gcc_unreachable();
+}
+
+// vpath is a parsed and writeable version of selection.uri. There is
+// really just one path parameter.
+bool
+UpnpDatabase::VisitServer(const ContentDirectoryService &server,
+			  const std::list<std::string> &vpath,
+			  const DatabaseSelection &selection,
+			  VisitDirectory visit_directory,
+			  VisitSong visit_song,
+			  VisitPlaylist visit_playlist,
+			  Error &error) const
+{
+	/* If the path begins with rootid, we know that this is a
+	   song, not a directory (because that's how we set things
+	   up). Just visit it. Note that the choice of rootid is
+	   arbitrary, any value not likely to be the name of a top
+	   directory would be ok. */
+	/* !Note: this *can't* be handled by Namei further down,
+	   because the path is not valid for traversal. Besides, it's
+	   just faster to access the target node directly */
+	if (!vpath.empty() && vpath.front() == rootid) {
+		switch (vpath.size()) {
+		case 1:
+			return true;
+
+		case 2:
+			break;
+
+		default:
+			error.Format(db_domain, DB_NOT_FOUND,
+				     "Not found");
+			return false;
+		}
+
+		if (visit_song) {
+			UPnPDirObject dirent;
+			if (!ReadNode(server, vpath.back().c_str(), dirent,
+				      error))
+				return false;
+
+			if (dirent.type != UPnPDirObject::Type::ITEM ||
+			    dirent.item_class != UPnPDirObject::ItemClass::MUSIC) {
+				error.Format(db_domain, DB_NOT_FOUND,
+					     "Not found");
+				return false;
+			}
+
+			std::string path = songPath(server.getFriendlyName(),
+						    dirent.m_id);
+			if (!visitSong(std::move(dirent), path.c_str(),
+				       selection,
+				       visit_song, error))
+				return false;
+		}
+		return true;
+	}
+
+	// Translate the target path into an object id and the associated metadata.
+	UPnPDirObject tdirent;
+	if (!Namei(server, vpath, tdirent, error))
+		return false;
+
+	/* If recursive is set, this is a search... No use sending it
+	   if the filter is empty. In this case, we implement limited
+	   recursion (1-deep) here, which will handle the "add dir"
+	   case. */
+	if (selection.recursive && selection.filter)
+		return SearchSongs(server, tdirent.m_id.c_str(), selection,
+				   visit_song, error);
+
+	const char *const base_uri = selection.uri.empty()
+		? server.getFriendlyName()
+		: selection.uri.c_str();
+
+	if (tdirent.type == UPnPDirObject::Type::ITEM) {
+		return VisitItem(tdirent, base_uri,
+				 selection,
+				 visit_song, visit_playlist,
+				 error);
+	}
+
+	/* Target was a a container. Visit it. We could read slices
+	   and loop here, but it's not useful as mpd will only return
+	   data to the client when we're done anyway. */
+	UPnPDirContent dirbuf;
+	if (!server.readDir(m_lib->getclh(), tdirent.m_id.c_str(), dirbuf,
+			    error))
+		return false;
+
+	for (auto &dirent : dirbuf.objects) {
+		const std::string uri = PathTraitsUTF8::Build(base_uri,
+							      dirent.name.c_str());
+		if (!VisitObject(dirent, uri.c_str(),
+				 selection,
+				 visit_directory,
+				 visit_song, visit_playlist,
+				 error))
+			return false;
+	}
+
+	return true;
+}
+
+// Deal with the possibly multiple servers, call VisitServer if needed.
+bool
+UpnpDatabase::Visit(const DatabaseSelection &selection,
+		    VisitDirectory visit_directory,
+		    VisitSong visit_song,
+		    VisitPlaylist visit_playlist,
+		    Error &error) const
+{
+	auto vpath = stringToTokens(selection.uri, "/", true);
+	if (vpath.empty()) {
+		std::vector<ContentDirectoryService> servers;
+		if (!m_superdir->getDirServices(servers, error))
+			return false;
+
+		for (const auto &server : servers) {
+			if (visit_directory) {
+				const LightDirectory d(server.getFriendlyName(), 0);
+				if (!visit_directory(d, error))
+					return false;
+			}
+
+			if (selection.recursive &&
+			    !VisitServer(server, vpath, selection,
+					 visit_directory, visit_song, visit_playlist,
+					 error))
+				return false;
+		}
+
+		return true;
+	}
+
+	// We do have a path: the first element selects the server
+	std::string servername(std::move(vpath.front()));
+	vpath.pop_front();
+
+	ContentDirectoryService server;
+	if (!m_superdir->getServer(servername.c_str(), server, error))
+		return false;
+
+	return VisitServer(server, vpath, selection,
+			   visit_directory, visit_song, visit_playlist, error);
+}
+
+bool
+UpnpDatabase::VisitUniqueTags(const DatabaseSelection &selection,
+			      TagType tag,
+			      VisitString visit_string,
+			      Error &error) const
+{
+	if (!visit_string)
+		return true;
+
+	std::vector<ContentDirectoryService> servers;
+	if (!m_superdir->getDirServices(servers, error))
+		return false;
+
+	std::set<std::string> values;
+	for (auto& server : servers) {
+		UPnPDirContent dirbuf;
+		if (!SearchSongs(server, rootid, selection, dirbuf, error))
+			return false;
+
+		for (const auto &dirent : dirbuf.objects) {
+			if (dirent.type != UPnPDirObject::Type::ITEM ||
+			    dirent.item_class != UPnPDirObject::ItemClass::MUSIC)
+				continue;
+
+			const char *value = dirent.tag.GetValue(tag);
+			if (value != nullptr) {
+#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+				values.emplace(value);
+#else
+				values.insert(value);
+#endif
+			}
+		}
+	}
+
+	for (const auto& value : values)
+		if (!visit_string(value.c_str(), error))
+			return false;
+
+	return true;
+}
+
+bool
+UpnpDatabase::GetStats(const DatabaseSelection &,
+		       DatabaseStats &stats, Error &) const
+{
+	/* Note: this gets called before the daemonizing so we can't
+	   reallyopen this would be a problem if we had real stats */
+	stats.song_count = 0;
+	stats.total_duration = 0;
+	stats.artist_count = 0;
+	stats.album_count = 0;
+	return true;
+}
+
+const DatabasePlugin upnp_db_plugin = {
+	"upnp",
+	UpnpDatabase::Create,
+};
diff --git a/src/db/plugins/UpnpDatabasePlugin.hxx b/src/db/plugins/UpnpDatabasePlugin.hxx
new file mode 100644
index 000000000..0228405cd
--- /dev/null
+++ b/src/db/plugins/UpnpDatabasePlugin.hxx
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2003-2014 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_UPNP_DATABASE_PLUGIN_HXX
+#define MPD_UPNP_DATABASE_PLUGIN_HXX
+
+struct DatabasePlugin;
+
+extern const DatabasePlugin upnp_db_plugin;
+
+#endif
diff --git a/src/db/plugins/upnp/Action.hxx b/src/db/plugins/upnp/Action.hxx
new file mode 100644
index 000000000..28c88be92
--- /dev/null
+++ b/src/db/plugins/upnp/Action.hxx
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2003-2014 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_UPNP_ACTION_HXX
+#define MPD_UPNP_ACTION_HXX
+
+#include "Compiler.h"
+
+#include <upnp/upnptools.h>
+
+static inline constexpr unsigned
+CountNameValuePairs()
+{
+	return 0;
+}
+
+template<typename... Args>
+static inline constexpr unsigned
+CountNameValuePairs(gcc_unused const char *name, gcc_unused const char *value,
+		    Args... args)
+{
+	return 1 + CountNameValuePairs(args...);
+}
+
+/**
+ * A wrapper for UpnpMakeAction() that counts the number of name/value
+ * pairs and adds the nullptr sentinel.
+ */
+template<typename... Args>
+static inline IXML_Document *
+MakeActionHelper(const char *action_name, const char *service_type,
+		 Args... args)
+{
+	const unsigned n = CountNameValuePairs(args...);
+	return UpnpMakeAction(action_name, service_type, n,
+			      args...,
+			      nullptr, nullptr);
+}
+
+#endif
diff --git a/src/db/plugins/upnp/ContentDirectoryService.cxx b/src/db/plugins/upnp/ContentDirectoryService.cxx
new file mode 100644
index 000000000..35445e09d
--- /dev/null
+++ b/src/db/plugins/upnp/ContentDirectoryService.cxx
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2003-2014 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 "ContentDirectoryService.hxx"
+#include "Domain.hxx"
+#include "Device.hxx"
+#include "ixmlwrap.hxx"
+#include "Directory.hxx"
+#include "Util.hxx"
+#include "Action.hxx"
+#include "util/NumberParser.hxx"
+#include "util/Error.hxx"
+
+#include <string.h>
+#include <stdio.h>
+
+ContentDirectoryService::ContentDirectoryService(const UPnPDevice &device,
+						 const UPnPService &service)
+	:m_actionURL(caturl(device.URLBase, service.controlURL)),
+	 m_serviceType(service.serviceType),
+	 m_deviceId(device.UDN),
+	 m_friendlyName(device.friendlyName),
+	 m_manufacturer(device.manufacturer),
+	 m_modelName(device.modelName),
+	 m_rdreqcnt(200)
+{
+	if (!m_modelName.compare("MediaTomb")) {
+		// Readdir by 200 entries is good for most, but MediaTomb likes
+		// them really big. Actually 1000 is better but I don't dare
+		m_rdreqcnt = 500;
+	}
+}
+
+ContentDirectoryService::~ContentDirectoryService()
+{
+	/* this destructor exists here just so it won't get inlined */
+}
+
+static bool
+ReadResultTag(UPnPDirContent &dirbuf, IXML_Document *response, Error &error)
+{
+	const char *p = ixmlwrap::getFirstElementValue(response, "Result");
+	if (p == nullptr)
+		p = "";
+
+	return dirbuf.parse(p, error);
+}
+
+inline bool
+ContentDirectoryService::readDirSlice(UpnpClient_Handle hdl,
+				      const char *objectId, unsigned offset,
+				      unsigned count, UPnPDirContent &dirbuf,
+				      unsigned &didreadp, unsigned &totalp,
+				      Error &error) const
+{
+	// Create request
+	char ofbuf[100], cntbuf[100];
+	sprintf(ofbuf, "%u", offset);
+	sprintf(cntbuf, "%u", count);
+	// Some devices require an empty SortCriteria, else bad params
+	IXML_Document *request =
+		MakeActionHelper("Browse", m_serviceType.c_str(),
+				 "ObjectID", objectId,
+				 "BrowseFlag", "BrowseDirectChildren",
+				 "Filter", "*",
+				 "SortCriteria", "",
+				 "StartingIndex", ofbuf,
+				 "RequestedCount", cntbuf);
+	if (request == nullptr) {
+		error.Set(upnp_domain, "UpnpMakeAction() failed");
+		return false;
+	}
+
+	IXML_Document *response;
+	int code = UpnpSendAction(hdl, m_actionURL.c_str(), m_serviceType.c_str(),
+				  0 /*devUDN*/, request, &response);
+	ixmlDocument_free(request);
+	if (code != UPNP_E_SUCCESS) {
+		error.Format(upnp_domain, code,
+			     "UpnpSendAction() failed: %s",
+			     UpnpGetErrorMessage(code));
+		return false;
+	}
+
+	const char *value = ixmlwrap::getFirstElementValue(response, "NumberReturned");
+	didreadp = value != nullptr
+		? ParseUnsigned(value)
+		: 0;
+
+	value = ixmlwrap::getFirstElementValue(response, "TotalMatches");
+	if (value != nullptr)
+		totalp = ParseUnsigned(value);
+
+	bool success = ReadResultTag(dirbuf, response, error);
+	ixmlDocument_free(response);
+	return success;
+}
+
+bool
+ContentDirectoryService::readDir(UpnpClient_Handle handle,
+				 const char *objectId,
+				 UPnPDirContent &dirbuf,
+				 Error &error) const
+{
+	unsigned offset = 0, total = -1, count;
+
+	do {
+		if (!readDirSlice(handle, objectId, offset, m_rdreqcnt, dirbuf,
+				  count, total, error))
+			return false;
+
+		offset += count;
+	} while (count > 0 && offset < total);
+
+	return true;
+}
+
+bool
+ContentDirectoryService::search(UpnpClient_Handle hdl,
+				const char *objectId,
+				const char *ss,
+				UPnPDirContent &dirbuf,
+				Error &error) const
+{
+	unsigned offset = 0, total = -1, count;
+
+	do {
+		char ofbuf[100];
+		sprintf(ofbuf, "%d", offset);
+
+		IXML_Document *request =
+			MakeActionHelper("Search", m_serviceType.c_str(),
+					 "ContainerID", objectId,
+					 "SearchCriteria", ss,
+					 "Filter", "*",
+					 "SortCriteria", "",
+					 "StartingIndex", ofbuf,
+					 "RequestedCount", "0"); // Setting a value here gets twonky into fits
+		if (request == 0) {
+			error.Set(upnp_domain, "UpnpMakeAction() failed");
+			return false;
+		}
+
+		IXML_Document *response;
+		auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+					   m_serviceType.c_str(),
+					   0 /*devUDN*/, request, &response);
+		ixmlDocument_free(request);
+		if (code != UPNP_E_SUCCESS) {
+			error.Format(upnp_domain, code,
+				     "UpnpSendAction() failed: %s",
+				     UpnpGetErrorMessage(code));
+			return false;
+		}
+
+		const char *value =
+			ixmlwrap::getFirstElementValue(response, "NumberReturned");
+		count = value != nullptr
+			? ParseUnsigned(value)
+			: 0;
+
+		offset += count;
+
+		value = ixmlwrap::getFirstElementValue(response, "TotalMatches");
+		if (value != nullptr)
+			total = ParseUnsigned(value);
+
+		bool success = ReadResultTag(dirbuf, response, error);
+		ixmlDocument_free(response);
+		if (!success)
+			return false;
+	} while (count > 0 && offset < total);
+
+	return true;
+}
+
+bool
+ContentDirectoryService::getSearchCapabilities(UpnpClient_Handle hdl,
+					       std::list<std::string> &result,
+					       Error &error) const
+{
+	assert(result.empty());
+
+	IXML_Document *request =
+		UpnpMakeAction("GetSearchCapabilities", m_serviceType.c_str(),
+			       0,
+			       nullptr, nullptr);
+	if (request == 0) {
+		error.Set(upnp_domain, "UpnpMakeAction() failed");
+		return false;
+	}
+
+	IXML_Document *response;
+	auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+				   m_serviceType.c_str(),
+				   0 /*devUDN*/, request, &response);
+	ixmlDocument_free(request);
+	if (code != UPNP_E_SUCCESS) {
+		error.Format(upnp_domain, code,
+			     "UpnpSendAction() failed: %s",
+			     UpnpGetErrorMessage(code));
+		return false;
+	}
+
+	const char *s = ixmlwrap::getFirstElementValue(response, "SearchCaps");
+	if (s == nullptr || *s == 0) {
+		ixmlDocument_free(response);
+		return true;
+	}
+
+	bool success = true;
+	if (!csvToStrings(s, result)) {
+		error.Set(upnp_domain, "Bad response");
+		success = false;
+	}
+
+	ixmlDocument_free(response);
+	return success;
+}
+
+bool
+ContentDirectoryService::getMetadata(UpnpClient_Handle hdl,
+				     const char *objectId,
+				     UPnPDirContent &dirbuf,
+				     Error &error) const
+{
+	// Create request
+	IXML_Document *request =
+		MakeActionHelper("Browse", m_serviceType.c_str(),
+				 "ObjectID", objectId,
+				 "BrowseFlag", "BrowseMetadata",
+				 "Filter", "*",
+				 "SortCriteria", "",
+				 "StartingIndex", "0",
+				 "RequestedCount", "1");
+	if (request == nullptr) {
+		error.Set(upnp_domain, "UpnpMakeAction() failed");
+		return false;
+	}
+
+	IXML_Document *response;
+	auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+				   m_serviceType.c_str(),
+				   0 /*devUDN*/, request, &response);
+	ixmlDocument_free(request);
+	if (code != UPNP_E_SUCCESS) {
+		error.Format(upnp_domain, code,
+			     "UpnpSendAction() failed: %s",
+			     UpnpGetErrorMessage(code));
+		return false;
+	}
+
+	bool success = ReadResultTag(dirbuf, response, error);
+	ixmlDocument_free(response);
+	return success;
+}
diff --git a/src/db/plugins/upnp/ContentDirectoryService.hxx b/src/db/plugins/upnp/ContentDirectoryService.hxx
new file mode 100644
index 000000000..24be5dfbf
--- /dev/null
+++ b/src/db/plugins/upnp/ContentDirectoryService.hxx
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2003-2014 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 _UPNPDIR_HXX_INCLUDED_
+#define _UPNPDIR_HXX_INCLUDED_
+
+#include <upnp/upnp.h>
+
+#include <string>
+#include <list>
+
+class Error;
+class UPnPDevice;
+struct UPnPService;
+class UPnPDirContent;
+
+/**
+ * Content Directory Service class.
+ *
+ * This stores identity data from a directory service
+ * and the device it belongs to, and has methods to query
+ * the directory, using libupnp for handling the UPnP protocols.
+ *
+ * Note: m_rdreqcnt: number of entries requested per directory read.
+ * 0 means all entries. The device can still return less entries than
+ * requested, depending on its own limits. In general it's not optimal
+ * becauses it triggers issues, and is sometimes actually slower, e.g. on
+ * a D-Link NAS 327
+ *
+ * The value chosen may affect by the UpnpSetMaxContentLength
+ * (2000*1024) done during initialization, but this should be ample
+ */
+class ContentDirectoryService {
+	std::string m_actionURL;
+	std::string m_serviceType;
+	std::string m_deviceId;
+	std::string m_friendlyName;
+	std::string m_manufacturer;
+	std::string m_modelName;
+
+	int m_rdreqcnt; // Slice size to use when reading
+
+public:
+	/**
+	 * Construct by copying data from device and service objects.
+	 *
+	 * The discovery service does this: use getDirServices()
+	 */
+	ContentDirectoryService(const UPnPDevice &device,
+				const UPnPService &service);
+
+	/** An empty one */
+	ContentDirectoryService() = default;
+
+	~ContentDirectoryService();
+
+	/** Read a container's children list into dirbuf.
+	 *
+	 * @param objectId the UPnP object Id for the container. Root has Id "0"
+	 * @param[out] dirbuf stores the entries we read.
+	 */
+	bool readDir(UpnpClient_Handle handle,
+		     const char *objectId, UPnPDirContent &dirbuf,
+		     Error &error) const;
+
+	bool readDirSlice(UpnpClient_Handle handle,
+			  const char *objectId, unsigned offset,
+			  unsigned count, UPnPDirContent& dirbuf,
+			  unsigned &didread, unsigned &total,
+			  Error &error) const;
+
+	/** Search the content directory service.
+	 *
+	 * @param objectId the UPnP object Id under which the search
+	 * should be done. Not all servers actually support this below
+	 * root. Root has Id "0"
+	 * @param searchstring an UPnP searchcriteria string. Check the
+	 * UPnP document: UPnP-av-ContentDirectory-v1-Service-20020625.pdf
+	 * section 2.5.5. Maybe we'll provide an easier way some day...
+	 * @param[out] dirbuf stores the entries we read.
+	 */
+	bool search(UpnpClient_Handle handle,
+		    const char *objectId, const char *searchstring,
+		    UPnPDirContent &dirbuf,
+		    Error &error) const;
+
+	/** Read metadata for a given node.
+	 *
+	 * @param objectId the UPnP object Id. Root has Id "0"
+	 * @param[out] dirbuf stores the entries we read. At most one entry will be
+	 *   returned.
+	 */
+	bool getMetadata(UpnpClient_Handle handle,
+			 const char *objectId, UPnPDirContent &dirbuf,
+			 Error &error) const;
+
+	/** Retrieve search capabilities
+	 *
+	 * @param[out] result an empty vector: no search, or a single '*' element:
+	 *     any tag can be used in a search, or a list of usable tag names.
+	 */
+	bool getSearchCapabilities(UpnpClient_Handle handle,
+				   std::list<std::string> &result,
+				   Error &error) const;
+
+	/** Retrieve the "friendly name" for this server, useful for display. */
+	const char *getFriendlyName() const {
+		return m_friendlyName.c_str();
+	}
+};
+
+#endif /* _UPNPDIR_HXX_INCLUDED_ */
diff --git a/src/db/plugins/upnp/Device.cxx b/src/db/plugins/upnp/Device.cxx
new file mode 100644
index 000000000..7bec1cccd
--- /dev/null
+++ b/src/db/plugins/upnp/Device.cxx
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2003-2014 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 "Device.hxx"
+#include "Util.hxx"
+#include "Expat.hxx"
+#include "util/Error.hxx"
+
+#include <stdlib.h>
+
+#include <string.h>
+
+UPnPDevice::~UPnPDevice()
+{
+	/* this destructor exists here just so it won't get inlined */
+}
+
+/**
+ * An XML parser which constructs an UPnP device object from the
+ * device descriptor.
+ */
+class UPnPDeviceParser final : public CommonExpatParser {
+	UPnPDevice &m_device;
+
+	std::string *value;
+
+	UPnPService m_tservice;
+
+public:
+	UPnPDeviceParser(UPnPDevice& device)
+		:m_device(device),
+		 value(nullptr) {}
+
+protected:
+	virtual void StartElement(const XML_Char *name, const XML_Char **) {
+		value = nullptr;
+
+		switch (name[0]) {
+		case 'c':
+			if (strcmp(name, "controlURL") == 0)
+				value = &m_tservice.controlURL;
+			break;
+		case 'd':
+			if (strcmp(name, "deviceType") == 0)
+				value = &m_device.deviceType;
+			break;
+		case 'f':
+			if (strcmp(name, "friendlyName") == 0)
+				value = &m_device.friendlyName;
+			break;
+		case 'm':
+			if (strcmp(name, "manufacturer") == 0)
+				value = &m_device.manufacturer;
+			else if (strcmp(name, "modelName") == 0)
+				value = &m_device.modelName;
+			break;
+		case 's':
+			if (strcmp(name, "serviceType") == 0)
+				value = &m_tservice.serviceType;
+			break;
+		case 'U':
+			if (strcmp(name, "UDN") == 0)
+				value = &m_device.UDN;
+			else if (strcmp(name, "URLBase") == 0)
+				value = &m_device.URLBase;
+			break;
+		}
+	}
+
+	virtual void EndElement(const XML_Char *name) {
+		if (value != nullptr) {
+			trimstring(*value);
+			value = nullptr;
+		} else if (!strcmp(name, "service")) {
+			m_device.services.emplace_back(std::move(m_tservice));
+			m_tservice.clear();
+		}
+	}
+
+	virtual void CharacterData(const XML_Char *s, int len) {
+		if (value != nullptr)
+			value->append(s, len);
+	}
+};
+
+bool
+UPnPDevice::Parse(const std::string &url, const char *description,
+		  Error &error)
+{
+	{
+		UPnPDeviceParser mparser(*this);
+		if (!mparser.Parse(description, strlen(description),
+				   true, error))
+			return false;
+	}
+
+	if (URLBase.empty()) {
+		// The standard says that if the URLBase value is empty, we should use
+		// the url the description was retrieved from. However this is
+		// sometimes something like http://host/desc.xml, sometimes something
+		// like http://host/
+
+		if (url.size() < 8) {
+			// ???
+			URLBase = url;
+		} else {
+			auto hostslash = url.find_first_of("/", 7);
+			if (hostslash == std::string::npos || hostslash == url.size()-1) {
+				URLBase = url;
+			} else {
+				URLBase = path_getfather(url);
+			}
+		}
+	}
+
+	return true;
+}
diff --git a/src/db/plugins/upnp/Device.hxx b/src/db/plugins/upnp/Device.hxx
new file mode 100644
index 000000000..dd7ecac2d
--- /dev/null
+++ b/src/db/plugins/upnp/Device.hxx
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2003-2014 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 _UPNPDEV_HXX_INCLUDED_
+#define _UPNPDEV_HXX_INCLUDED_
+
+#include <vector>
+#include <string>
+
+class Error;
+
+/**
+ * UPnP Description phase: interpreting the device description which we
+ * downloaded from the URL obtained by the discovery phase.
+ */
+
+/**
+ * Data holder for a UPnP service, parsed from the XML description
+ * downloaded after discovery yielded its URL.
+ */
+struct UPnPService {
+	// e.g. urn:schemas-upnp-org:service:ConnectionManager:1
+	std::string serviceType;
+	std::string controlURL; // e.g.: /upnp/control/cm
+
+	void clear()
+	{
+		serviceType.clear();
+		controlURL.clear();
+	}
+};
+
+/**
+ * Data holder for a UPnP device, parsed from the XML description obtained
+ * during discovery.
+ * A device may include several services. To be of interest to us,
+ * one of them must be a ContentDirectory.
+ */
+class UPnPDevice {
+public:
+	// e.g. urn:schemas-upnp-org:device:MediaServer:1
+	std::string deviceType;
+	// e.g. MediaTomb
+	std::string friendlyName;
+	// Unique device number. This should match the deviceID in the
+	// discovery message. e.g. uuid:a7bdcd12-e6c1-4c7e-b588-3bbc959eda8d
+	std::string UDN;
+	// Base for all relative URLs. e.g. http://192.168.4.4:49152/
+	std::string URLBase;
+	// Manufacturer: e.g. D-Link, PacketVideo ("manufacturer")
+	std::string manufacturer;
+	// Model name: e.g. MediaTomb, DNS-327L ("modelName")
+	std::string modelName;
+	// Services provided by this device.
+	std::vector<UPnPService> services;
+
+	UPnPDevice() = default;
+	UPnPDevice(const UPnPDevice &) = delete;
+	UPnPDevice(UPnPDevice &&) = default;
+	UPnPDevice &operator=(UPnPDevice &&) = default;
+
+	~UPnPDevice();
+
+	/** Build device from xml description downloaded from discovery
+	 * @param url where the description came from
+	 * @param description the xml device description
+	 */
+	bool Parse(const std::string &url, const char *description,
+		   Error &error);
+};
+
+#endif /* _UPNPDEV_HXX_INCLUDED_ */
diff --git a/src/db/plugins/upnp/Directory.cxx b/src/db/plugins/upnp/Directory.cxx
new file mode 100644
index 000000000..adb8b213a
--- /dev/null
+++ b/src/db/plugins/upnp/Directory.cxx
@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) 2003-2014 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 "Directory.hxx"
+#include "Util.hxx"
+#include "Expat.hxx"
+#include "Tags.hxx"
+#include "tag/TagBuilder.hxx"
+#include "tag/TagTable.hxx"
+#include "util/NumberParser.hxx"
+
+#include <algorithm>
+#include <string>
+
+#include <string.h>
+
+UPnPDirContent::~UPnPDirContent()
+{
+	/* this destructor exists here just so it won't get inlined */
+}
+
+gcc_pure gcc_nonnull_all
+static bool
+CompareStringLiteral(const char *literal, const char *value, size_t length)
+{
+	return length == strlen(literal) &&
+		memcmp(literal, value, length) == 0;
+}
+
+gcc_pure
+static UPnPDirObject::ItemClass
+ParseItemClass(const char *name, size_t length)
+{
+	if (CompareStringLiteral("object.item.audioItem.musicTrack",
+				 name, length))
+		return UPnPDirObject::ItemClass::MUSIC;
+	else if (CompareStringLiteral("object.item.playlistItem",
+				      name, length))
+		return UPnPDirObject::ItemClass::PLAYLIST;
+	else
+		return UPnPDirObject::ItemClass::UNKNOWN;
+}
+
+gcc_pure
+static int
+ParseDuration(const char *duration)
+{
+	char *endptr;
+
+	unsigned result = ParseUnsigned(duration, &endptr);
+	if (endptr == duration || *endptr != ':')
+		return 0;
+
+	result *= 60;
+	duration = endptr + 1;
+	result += ParseUnsigned(duration, &endptr);
+	if (endptr == duration || *endptr != ':')
+		return 0;
+
+	result *= 60;
+	duration = endptr + 1;
+	result += ParseUnsigned(duration, &endptr);
+	if (endptr == duration || *endptr != 0)
+		return 0;
+
+	return result;
+}
+
+/**
+ * Transform titles to turn '/' into '_' to make them acceptable path
+ * elements. There is a very slight risk of collision in doing
+ * this. Twonky returns directory names (titles) like 'Artist/Album'.
+ */
+gcc_pure
+static std::string
+titleToPathElt(std::string &&s)
+{
+	std::replace(s.begin(), s.end(), '/', '_');
+	return s;
+}
+
+/**
+ * An XML parser which builds directory contents from DIDL lite input.
+ */
+class UPnPDirParser final : public CommonExpatParser {
+	UPnPDirContent &m_dir;
+
+	enum {
+		NONE,
+		RES,
+		CLASS,
+	} state;
+
+	/**
+	 * If not equal to #TAG_NUM_OF_ITEM_TYPES, then we're
+	 * currently reading an element containing a tag value.  The
+	 * value is being constructed in #value.
+	 */
+	TagType tag_type;
+
+	/**
+	 * The text inside the current element.
+	 */
+	std::string value;
+
+	UPnPDirObject m_tobj;
+	TagBuilder tag;
+
+public:
+	UPnPDirParser(UPnPDirContent& dir)
+		:m_dir(dir),
+		 state(NONE),
+		 tag_type(TAG_NUM_OF_ITEM_TYPES)
+	{
+	}
+
+protected:
+	virtual void StartElement(const XML_Char *name, const XML_Char **attrs)
+	{
+		if (m_tobj.type != UPnPDirObject::Type::UNKNOWN &&
+		    tag_type == TAG_NUM_OF_ITEM_TYPES) {
+			tag_type = tag_table_lookup(upnp_tags, name);
+			if (tag_type != TAG_NUM_OF_ITEM_TYPES)
+				return;
+		} else {
+			assert(tag_type == TAG_NUM_OF_ITEM_TYPES);
+		}
+
+		switch (name[0]) {
+		case 'c':
+			if (!strcmp(name, "container")) {
+				m_tobj.clear();
+				m_tobj.type = UPnPDirObject::Type::CONTAINER;
+
+				const char *id = GetAttribute(attrs, "id");
+				if (id != nullptr)
+					m_tobj.m_id = id;
+
+				const char *pid = GetAttribute(attrs, "parentID");
+				if (pid != nullptr)
+					m_tobj.m_pid = pid;
+			}
+			break;
+
+		case 'i':
+			if (!strcmp(name, "item")) {
+				m_tobj.clear();
+				m_tobj.type = UPnPDirObject::Type::ITEM;
+
+				const char *id = GetAttribute(attrs, "id");
+				if (id != nullptr)
+					m_tobj.m_id = id;
+
+				const char *pid = GetAttribute(attrs, "parentID");
+				if (pid != nullptr)
+					m_tobj.m_pid = pid;
+			}
+			break;
+
+		case 'r':
+			if (!strcmp(name, "res")) {
+				// <res protocolInfo="http-get:*:audio/mpeg:*" size="5171496"
+				// bitrate="24576" duration="00:03:35" sampleFrequency="44100"
+				// nrAudioChannels="2">
+
+				const char *duration =
+					GetAttribute(attrs, "duration");
+				if (duration != nullptr)
+					tag.SetTime(ParseDuration(duration));
+
+				state = RES;
+			}
+
+			break;
+
+		case 'u':
+			if (strcmp(name, "upnp:class") == 0)
+				state = CLASS;
+		}
+	}
+
+	bool checkobjok() {
+		if (m_tobj.m_id.empty() || m_tobj.m_pid.empty() ||
+		    m_tobj.name.empty() ||
+		    (m_tobj.type == UPnPDirObject::Type::ITEM &&
+		     m_tobj.item_class == UPnPDirObject::ItemClass::UNKNOWN))
+			return false;
+
+		return true;
+	}
+
+	virtual void EndElement(const XML_Char *name)
+	{
+		if (tag_type != TAG_NUM_OF_ITEM_TYPES) {
+			assert(m_tobj.type != UPnPDirObject::Type::UNKNOWN);
+
+			tag.AddItem(tag_type, value.c_str());
+
+			if (tag_type == TAG_TITLE)
+				m_tobj.name = titleToPathElt(std::move(value));
+
+			value.clear();
+			tag_type = TAG_NUM_OF_ITEM_TYPES;
+			return;
+		}
+
+		if ((!strcmp(name, "container") || !strcmp(name, "item")) &&
+		    checkobjok()) {
+			tag.Commit(m_tobj.tag);
+			m_dir.objects.emplace_back(std::move(m_tobj));
+		}
+
+		state = NONE;
+	}
+
+	virtual void CharacterData(const XML_Char *s, int len)
+	{
+		if (tag_type != TAG_NUM_OF_ITEM_TYPES) {
+			assert(m_tobj.type != UPnPDirObject::Type::UNKNOWN);
+
+			value.append(s, len);
+			return;
+		}
+
+		switch (state) {
+		case NONE:
+			break;
+
+		case RES:
+			m_tobj.url.assign(s, len);
+			break;
+
+		case CLASS:
+			m_tobj.item_class = ParseItemClass(s, len);
+			break;
+		}
+	}
+};
+
+bool
+UPnPDirContent::parse(const char *input, Error &error)
+{
+	UPnPDirParser parser(*this);
+	return parser.Parse(input, strlen(input), true, error);
+}
diff --git a/src/db/plugins/upnp/Directory.hxx b/src/db/plugins/upnp/Directory.hxx
new file mode 100644
index 000000000..433979900
--- /dev/null
+++ b/src/db/plugins/upnp/Directory.hxx
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2003-2014 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_UPNP_DIRECTORY_HXX
+#define MPD_UPNP_DIRECTORY_HXX
+
+#include "Object.hxx"
+#include "Compiler.h"
+
+#include <string>
+#include <vector>
+
+class Error;
+
+/**
+ * Image of a MediaServer Directory Service container (directory),
+ * possibly containing items and subordinate containers.
+ */
+class UPnPDirContent {
+public:
+	std::vector<UPnPDirObject> objects;
+
+	~UPnPDirContent();
+
+	gcc_pure
+	UPnPDirObject *FindObject(const char *name) {
+		for (auto &o : objects)
+			if (o.name == name)
+				return &o;
+
+		return nullptr;
+	}
+
+	/**
+	 * Parse from DIDL-Lite XML data.
+	 *
+	 * Normally only used by ContentDirectoryService::readDir()
+	 * This is cumulative: in general, the XML data is obtained in
+	 * several documents corresponding to (offset,count) slices of the
+	 * directory (container). parse() can be called repeatedly with
+	 * the successive XML documents and will accumulate entries in the item
+	 * and container vectors. This makes more sense if the different
+	 * chunks are from the same container, but given that UPnP Ids are
+	 * actually global, nothing really bad will happen if you mix
+	 * up...
+	 */
+	bool parse(const char *didltext, Error &error);
+};
+
+#endif /* _UPNPDIRCONTENT_H_X_INCLUDED_ */
diff --git a/src/db/plugins/upnp/Discovery.cxx b/src/db/plugins/upnp/Discovery.cxx
new file mode 100644
index 000000000..5203dba83
--- /dev/null
+++ b/src/db/plugins/upnp/Discovery.cxx
@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2003-2014 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 "Discovery.hxx"
+#include "Domain.hxx"
+#include "ContentDirectoryService.hxx"
+#include "upnpplib.hxx"
+#include "system/Clock.hxx"
+#include "Log.hxx"
+
+#include <upnp/upnptools.h>
+
+#include <string.h>
+
+// The service type string we are looking for.
+static constexpr char ContentDirectorySType[] = "urn:schemas-upnp-org:service:ContentDirectory:1";
+
+// We don't include a version in comparisons, as we are satisfied with
+// version 1
+gcc_pure
+static bool
+isCDService(const char *st)
+{
+	constexpr size_t sz = sizeof(ContentDirectorySType) - 3;
+	return memcmp(ContentDirectorySType, st, sz) == 0;
+}
+
+// The type of device we're asking for in search
+static constexpr char MediaServerDType[] = "urn:schemas-upnp-org:device:MediaServer:1";
+
+gcc_pure
+static bool
+isMSDevice(const char *st)
+{
+	constexpr size_t sz = sizeof(MediaServerDType) - 3;
+	return memcmp(MediaServerDType, st, sz) == 0;
+}
+
+inline void
+UPnPDeviceDirectory::LockAdd(ContentDirectoryDescriptor &&d)
+{
+	const ScopeLock protect(mutex);
+
+	for (auto &i : directories) {
+		if (i.id == d.id) {
+			i = std::move(d);
+			return;
+		}
+	}
+
+	directories.emplace_back(std::move(d));
+}
+
+inline void
+UPnPDeviceDirectory::LockRemove(const std::string &id)
+{
+	const ScopeLock protect(mutex);
+
+	for (auto i = directories.begin(), end = directories.end();
+	     i != end; ++i) {
+		if (i->id == id) {
+			directories.erase(i);
+			break;
+		}
+	}
+}
+
+inline void
+UPnPDeviceDirectory::discoExplorer()
+{
+	for (;;) {
+		DiscoveredTask *tsk = 0;
+		if (!discoveredQueue.take(tsk)) {
+			discoveredQueue.workerExit();
+			return;
+		}
+
+		// Device signals its existence and well-being. Perform the
+		// UPnP "description" phase by downloading and decoding the
+		// description document.
+		char *buf;
+		// LINE_SIZE is defined by libupnp's upnp.h...
+		char contentType[LINE_SIZE];
+		int code = UpnpDownloadUrlItem(tsk->url.c_str(), &buf, contentType);
+		if (code != UPNP_E_SUCCESS) {
+			continue;
+		}
+
+		// Update or insert the device
+		ContentDirectoryDescriptor d(std::move(tsk->deviceId),
+					     MonotonicClockS(), tsk->expires);
+
+		{
+			Error error2;
+			bool success = d.Parse(tsk->url, buf, error2);
+			free(buf);
+			if (!success) {
+				delete tsk;
+				LogError(error2);
+				continue;
+			}
+		}
+
+		LockAdd(std::move(d));
+		delete tsk;
+	}
+}
+
+void *
+UPnPDeviceDirectory::discoExplorer(void *ctx)
+{
+	UPnPDeviceDirectory &directory = *(UPnPDeviceDirectory *)ctx;
+	directory.discoExplorer();
+	return (void*)1;
+}
+
+inline int
+UPnPDeviceDirectory::OnAlive(Upnp_Discovery *disco)
+{
+	if (isMSDevice(disco->DeviceType) ||
+	    isCDService(disco->ServiceType)) {
+		DiscoveredTask *tp = new DiscoveredTask(disco);
+		if (discoveredQueue.put(tp))
+			return UPNP_E_FINISH;
+	}
+
+	return UPNP_E_SUCCESS;
+}
+
+inline int
+UPnPDeviceDirectory::OnByeBye(Upnp_Discovery *disco)
+{
+	if (isMSDevice(disco->DeviceType) ||
+	    isCDService(disco->ServiceType)) {
+		// Device signals it is going off.
+		LockRemove(disco->DeviceId);
+	}
+
+	return UPNP_E_SUCCESS;
+}
+
+// This gets called for all libupnp asynchronous events, in a libupnp
+// thread context.
+// Example: ContentDirectories appearing and disappearing from the network
+// We queue a task for our worker thread(s)
+inline int
+UPnPDeviceDirectory::cluCallBack(Upnp_EventType et, void *evp)
+{
+	switch (et) {
+	case UPNP_DISCOVERY_SEARCH_RESULT:
+	case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
+		{
+			Upnp_Discovery *disco = (Upnp_Discovery *)evp;
+			return OnAlive(disco);
+		}
+
+	case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
+		{
+			Upnp_Discovery *disco = (Upnp_Discovery *)evp;
+			return OnByeBye(disco);
+		}
+
+	default:
+		// Ignore other events for now
+		break;
+	}
+
+	return UPNP_E_SUCCESS;
+}
+
+bool
+UPnPDeviceDirectory::expireDevices(Error &error)
+{
+	const ScopeLock protect(mutex);
+	const unsigned now = MonotonicClockS();
+	bool didsomething = false;
+
+	for (auto it = directories.begin();
+	     it != directories.end();) {
+		if (now > it->expires) {
+			it = directories.erase(it);
+			didsomething = true;
+		} else {
+			it++;
+		}
+	}
+
+	if (didsomething)
+		return search(error);
+
+	return true;
+}
+
+UPnPDeviceDirectory::UPnPDeviceDirectory(LibUPnP *_lib)
+	:lib(_lib),
+	 discoveredQueue("DiscoveredQueue"),
+	 m_searchTimeout(2), m_lastSearch(0)
+{
+}
+
+UPnPDeviceDirectory::~UPnPDeviceDirectory()
+{
+	/* this destructor exists here just so it won't get inlined */
+}
+
+bool
+UPnPDeviceDirectory::Start(Error &error)
+{
+	if (!discoveredQueue.start(1, discoExplorer, this)) {
+		error.Set(upnp_domain, "Discover work queue start failed");
+		return false;
+	}
+
+	lib->SetHandler([this](Upnp_EventType type, void *event){
+			cluCallBack(type, event);
+		});
+
+	return search(error);
+}
+
+bool
+UPnPDeviceDirectory::search(Error &error)
+{
+	const unsigned now = MonotonicClockS();
+	if (now - m_lastSearch < 10)
+		return true;
+	m_lastSearch = now;
+
+	// We search both for device and service just in case.
+	int code = UpnpSearchAsync(lib->getclh(), m_searchTimeout,
+				   ContentDirectorySType, lib);
+	if (code != UPNP_E_SUCCESS) {
+		error.Format(upnp_domain, code,
+			     "UpnpSearchAsync() failed: %s",
+			     UpnpGetErrorMessage(code));
+		return false;
+	}
+
+	code = UpnpSearchAsync(lib->getclh(), m_searchTimeout,
+			       MediaServerDType, lib);
+	if (code != UPNP_E_SUCCESS) {
+		error.Format(upnp_domain, code,
+			     "UpnpSearchAsync() failed: %s",
+			     UpnpGetErrorMessage(code));
+		return false;
+	}
+
+	return true;
+}
+
+bool
+UPnPDeviceDirectory::getDirServices(std::vector<ContentDirectoryService> &out,
+				    Error &error)
+{
+	// Has locking, do it before our own lock
+	if (!expireDevices(error))
+		return false;
+
+	const ScopeLock protect(mutex);
+
+	for (auto dit = directories.begin();
+	     dit != directories.end(); dit++) {
+		for (const auto &service : dit->device.services) {
+			if (isCDService(service.serviceType.c_str())) {
+				out.emplace_back(dit->device, service);
+			}
+		}
+	}
+
+	return true;
+}
+
+bool
+UPnPDeviceDirectory::getServer(const char *friendlyName,
+			       ContentDirectoryService &server,
+			       Error &error)
+{
+	// Has locking, do it before our own lock
+	if (!expireDevices(error))
+		return false;
+
+	const ScopeLock protect(mutex);
+
+	for (const auto &i : directories) {
+		const auto &device = i.device;
+
+		if (device.friendlyName != friendlyName)
+			continue;
+
+		for (const auto &service : device.services) {
+			if (isCDService(service.serviceType.c_str())) {
+				server = ContentDirectoryService(device,
+								 service);
+				return true;
+			}
+		}
+	}
+
+	error.Set(upnp_domain, "Server not found");
+	return false;
+}
diff --git a/src/db/plugins/upnp/Discovery.hxx b/src/db/plugins/upnp/Discovery.hxx
new file mode 100644
index 000000000..4c64fe420
--- /dev/null
+++ b/src/db/plugins/upnp/Discovery.hxx
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2003-2014 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 _UPNPPDISC_H_X_INCLUDED_
+#define _UPNPPDISC_H_X_INCLUDED_
+
+#include "Device.hxx"
+#include "WorkQueue.hxx"
+#include "thread/Mutex.hxx"
+#include "util/Error.hxx"
+
+#include <upnp/upnp.h>
+
+#include <list>
+#include <vector>
+#include <string>
+
+class LibUPnP;
+class ContentDirectoryService;
+
+/**
+ * Manage UPnP discovery and maintain a directory of active devices. Singleton.
+ *
+ * We are only interested in MediaServers with a ContentDirectory service
+ * for now, but this could be made more general, by removing the filtering.
+ */
+class UPnPDeviceDirectory {
+	/**
+	 * Each appropriate discovery event (executing in a libupnp thread
+	 * context) queues the following task object for processing by the
+	 * discovery thread.
+	 */
+	struct DiscoveredTask {
+		std::string url;
+		std::string deviceId;
+		unsigned expires; // Seconds valid
+
+		DiscoveredTask(const Upnp_Discovery *disco)
+			:url(disco->Location),
+			  deviceId(disco->DeviceId),
+			  expires(disco->Expires) {}
+	};
+
+	/**
+	 * Descriptor for one device having a Content Directory
+	 * service found on the network.
+	 */
+	class ContentDirectoryDescriptor {
+	public:
+		std::string id;
+
+		UPnPDevice device;
+
+		/**
+		 * The MonotonicClockS() time stamp when this device
+		 * expires.
+		 */
+		unsigned expires;
+
+		ContentDirectoryDescriptor() = default;
+
+		ContentDirectoryDescriptor(std::string &&_id,
+					   unsigned last, int exp)
+			:id(std::move(_id)), expires(last + exp + 20) {}
+
+		bool Parse(const std::string &url, const char *description,
+			   Error &_error) {
+			return device.Parse(url, description, _error);
+		}
+	};
+
+	LibUPnP *const lib;
+
+	Mutex mutex;
+	std::list<ContentDirectoryDescriptor> directories;
+	WorkQueue<DiscoveredTask *> discoveredQueue;
+
+	/**
+	 * The UPnP device search timeout, which should actually be
+	 * called delay because it's the base of a random delay that
+	 * the devices apply to avoid responding all at the same time.
+	 */
+	int m_searchTimeout;
+
+	/**
+	 * The MonotonicClockS() time stamp of the last search.
+	 */
+	unsigned m_lastSearch;
+
+public:
+	UPnPDeviceDirectory(LibUPnP *_lib);
+	~UPnPDeviceDirectory();
+
+	UPnPDeviceDirectory(const UPnPDeviceDirectory &) = delete;
+	UPnPDeviceDirectory& operator=(const UPnPDeviceDirectory &) = delete;
+
+	bool Start(Error &error);
+
+	/** Retrieve the directory services currently seen on the network */
+	bool getDirServices(std::vector<ContentDirectoryService> &, Error &);
+
+	/**
+	 * Get server by friendly name.
+	 */
+	bool getServer(const char *friendlyName,
+		       ContentDirectoryService &server,
+		       Error &error);
+
+private:
+	bool search(Error &error);
+
+	/**
+	 * Look at the devices and get rid of those which have not
+	 * been seen for too long. We do this when listing the top
+	 * directory.
+	 */
+	bool expireDevices(Error &error);
+
+	void LockAdd(ContentDirectoryDescriptor &&d);
+	void LockRemove(const std::string &id);
+
+	/**
+	 * Worker routine for the discovery queue. Get messages about
+	 * devices appearing and disappearing, and update the
+	 * directory pool accordingly.
+	 */
+	static void *discoExplorer(void *);
+	void discoExplorer();
+
+	int OnAlive(Upnp_Discovery *disco);
+	int OnByeBye(Upnp_Discovery *disco);
+	int cluCallBack(Upnp_EventType et, void *evp);
+};
+
+
+#endif /* _UPNPPDISC_H_X_INCLUDED_ */
diff --git a/src/db/plugins/upnp/Domain.cxx b/src/db/plugins/upnp/Domain.cxx
new file mode 100644
index 000000000..010d4c7c2
--- /dev/null
+++ b/src/db/plugins/upnp/Domain.cxx
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2003-2014 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 "Domain.hxx"
+#include "util/Domain.hxx"
+
+const Domain upnp_domain("upnp");
diff --git a/src/db/plugins/upnp/Domain.hxx b/src/db/plugins/upnp/Domain.hxx
new file mode 100644
index 000000000..ec01ef735
--- /dev/null
+++ b/src/db/plugins/upnp/Domain.hxx
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2003-2014 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_UPNP_DOMAIN_HXX
+#define MPD_UPNP_DOMAIN_HXX
+
+class Domain;
+
+extern const Domain upnp_domain;
+
+#endif
diff --git a/src/db/plugins/upnp/Object.cxx b/src/db/plugins/upnp/Object.cxx
new file mode 100644
index 000000000..703fb0be4
--- /dev/null
+++ b/src/db/plugins/upnp/Object.cxx
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2003-2014 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 "Object.hxx"
+
+UPnPDirObject::~UPnPDirObject()
+{
+	/* this destructor exists here just so it won't get inlined */
+}
diff --git a/src/db/plugins/upnp/Object.hxx b/src/db/plugins/upnp/Object.hxx
new file mode 100644
index 000000000..16a66c774
--- /dev/null
+++ b/src/db/plugins/upnp/Object.hxx
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2003-2014 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_UPNP_OBJECT_HXX
+#define MPD_UPNP_OBJECT_HXX
+
+#include "tag/Tag.hxx"
+
+#include <string>
+
+/**
+ * UpnP Media Server directory entry, converted from XML data.
+ *
+ * This is a dumb data holder class, a struct with helpers.
+ */
+class UPnPDirObject {
+public:
+	enum class Type {
+		UNKNOWN,
+		ITEM,
+		CONTAINER,
+	};
+
+	// There are actually several kinds of containers:
+	// object.container.storageFolder, object.container.person,
+	// object.container.playlistContainer etc., but they all seem to
+	// behave the same as far as we're concerned. Otoh, musicTrack
+	// items are special to us, and so should playlists, but I've not
+	// seen one of the latter yet (servers seem to use containers for
+	// playlists).
+	enum class ItemClass {
+		UNKNOWN,
+		MUSIC,
+		PLAYLIST,
+	};
+
+	std::string m_id; // ObjectId
+	std::string m_pid; // Parent ObjectId
+	std::string url;
+
+	/**
+	 * A copy of "dc:title" sanitized as a file name.
+	 */
+	std::string name;
+
+	Type type;
+	ItemClass item_class;
+
+	Tag tag;
+
+	UPnPDirObject() = default;
+	UPnPDirObject(UPnPDirObject &&) = default;
+
+	~UPnPDirObject();
+
+	UPnPDirObject &operator=(UPnPDirObject &&) = default;
+
+	void clear()
+	{
+		m_id.clear();
+		m_pid.clear();
+		url.clear();
+		type = Type::UNKNOWN;
+		item_class = ItemClass::UNKNOWN;
+		tag.Clear();
+	}
+};
+
+#endif /* _UPNPDIRCONTENT_H_X_INCLUDED_ */
diff --git a/src/db/plugins/upnp/Tags.cxx b/src/db/plugins/upnp/Tags.cxx
new file mode 100644
index 000000000..fd65df4d0
--- /dev/null
+++ b/src/db/plugins/upnp/Tags.cxx
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2003-2014 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 "Tags.hxx"
+#include "tag/TagTable.hxx"
+
+const struct tag_table upnp_tags[] = {
+	{ "upnp:artist", TAG_ARTIST },
+	{ "upnp:album", TAG_ALBUM },
+	{ "upnp:originalTrackNumber", TAG_TRACK },
+	{ "upnp:genre", TAG_GENRE },
+	{ "dc:title", TAG_TITLE },
+
+	/* sentinel */
+	{ nullptr, TAG_NUM_OF_ITEM_TYPES }
+};
diff --git a/src/db/plugins/upnp/Tags.hxx b/src/db/plugins/upnp/Tags.hxx
new file mode 100644
index 000000000..ec6d18478
--- /dev/null
+++ b/src/db/plugins/upnp/Tags.hxx
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2003-2014 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_UPNP_TAGS_HXX
+#define MPD_UPNP_TAGS_HXX
+
+/**
+ * Map UPnP property names to MPD tags.
+ */
+extern const struct tag_table upnp_tags[];
+
+#endif
diff --git a/src/db/plugins/upnp/Util.cxx b/src/db/plugins/upnp/Util.cxx
new file mode 100644
index 000000000..cf34a47d3
--- /dev/null
+++ b/src/db/plugins/upnp/Util.cxx
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2003-2014 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 "Util.hxx"
+
+#include <upnp/ixml.h>
+
+#include <assert.h>
+
+/** Get rid of white space at both ends */
+void
+trimstring(std::string &s, const char *ws)
+{
+	auto pos = s.find_first_not_of(ws);
+	if (pos == std::string::npos) {
+		s.clear();
+		return;
+	}
+	s.replace(0, pos, std::string());
+
+	pos = s.find_last_not_of(ws);
+	if (pos != std::string::npos && pos != s.length()-1)
+		s.replace(pos + 1, std::string::npos, std::string());
+}
+
+std::string
+caturl(const std::string &s1, const std::string &s2)
+{
+	if (s2.front() == '/') {
+		/* absolute path: replace the whole URI path in s1 */
+
+		auto i = s1.find("://");
+		if (i == s1.npos)
+			/* no scheme: override s1 completely */
+			return s2;
+
+		/* find the first slash after the host part */
+		i = s1.find('/', i + 3);
+		if (i == s1.npos)
+			/* there's no URI path - simply append s2 */
+			i = s1.length();
+
+		return s1.substr(0, i) + s2;
+	}
+
+	std::string out(s1);
+	if (out.back() != '/')
+		out.push_back('/');
+
+	out += s2;
+	return out;
+}
+
+static void
+path_catslash(std::string &s)
+{
+	if (s.empty() || s.back() != '/')
+		s += '/';
+}
+
+std::string
+path_getfather(const std::string &s)
+{
+	std::string father = s;
+
+	// ??
+	if (father.empty())
+		return "./";
+
+	if (father.back() == '/') {
+		// Input ends with /. Strip it, handle special case for root
+		if (father.length() == 1)
+			return father;
+		father.erase(father.length()-1);
+	}
+
+	auto slp = father.rfind('/');
+	if (slp == std::string::npos)
+		return "./";
+
+	father.erase(slp);
+	path_catslash(father);
+	return father;
+}
+
+std::list<std::string>
+stringToTokens(const std::string &str,
+	       const char *delims, bool skipinit)
+{
+	std::list<std::string> tokens;
+
+	std::string::size_type startPos = 0;
+
+	// Skip initial delims, return empty if this eats all.
+	if (skipinit &&
+	    (startPos = str.find_first_not_of(delims, 0)) == std::string::npos)
+		return tokens;
+
+	while (startPos < str.size()) {
+		// Find next delimiter or end of string (end of token)
+		auto pos = str.find_first_of(delims, startPos);
+
+		// Add token to the vector and adjust start
+		if (pos == std::string::npos) {
+			tokens.emplace_back(str, startPos);
+			break;
+		} else if (pos == startPos) {
+			// Dont' push empty tokens after first
+			if (tokens.empty())
+				tokens.emplace_back();
+			startPos = ++pos;
+		} else {
+			tokens.emplace_back(str, startPos, pos - startPos);
+			startPos = ++pos;
+		}
+	}
+
+	return tokens;
+}
+
+template <class T>
+bool
+csvToStrings(const char *s, T &tokens)
+{
+	assert(tokens.empty());
+
+	std::string current;
+
+	while (true) {
+		char ch = *s++;
+		if (ch == 0) {
+			tokens.emplace_back(std::move(current));
+			return true;
+		}
+
+		if (ch == '\\') {
+			ch = *s++;
+			if (ch == 0)
+				return false;
+		} else if (ch == ',') {
+			tokens.emplace_back(std::move(current));
+			current.clear();
+			continue;
+		}
+
+		current.push_back(ch);
+	}
+}
+
+template bool csvToStrings<std::list<std::string>>(const char *, std::list<std::string> &);
diff --git a/src/db/plugins/upnp/Util.hxx b/src/db/plugins/upnp/Util.hxx
new file mode 100644
index 000000000..58e382faa
--- /dev/null
+++ b/src/db/plugins/upnp/Util.hxx
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2003-2014 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_UPNP_UTIL_HXX
+#define MPD_UPNP_UTIL_HXX
+
+#include "Compiler.h"
+
+#include <string>
+#include <list>
+
+std::string
+caturl(const std::string& s1, const std::string& s2);
+
+void
+trimstring(std::string &s, const char *ws = " \t\n");
+
+std::string
+path_getfather(const std::string &s);
+
+gcc_pure
+std::list<std::string>
+stringToTokens(const std::string &str,
+	       const char *delims = "/", bool skipinit = true);
+
+template <class T>
+bool
+csvToStrings(const char *s, T &tokens);
+
+#endif /* _UPNPP_H_X_INCLUDED_ */
diff --git a/src/db/plugins/upnp/WorkQueue.hxx b/src/db/plugins/upnp/WorkQueue.hxx
new file mode 100644
index 000000000..fe8ce53f9
--- /dev/null
+++ b/src/db/plugins/upnp/WorkQueue.hxx
@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2003-2014 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 _WORKQUEUE_H_INCLUDED_
+#define _WORKQUEUE_H_INCLUDED_
+
+#include "thread/Mutex.hxx"
+#include "thread/Cond.hxx"
+
+#include <assert.h>
+#include <pthread.h>
+
+#include <string>
+#include <queue>
+
+#define LOGINFO(X)
+#define LOGERR(X)
+
+/**
+ * A WorkQueue manages the synchronisation around a queue of work items,
+ * where a number of client threads queue tasks and a number of worker
+ * threads take and execute them. The goal is to introduce some level
+ * of parallelism between the successive steps of a previously single
+ * threaded pipeline. For example data extraction / data preparation / index
+ * update, but this could have other uses.
+ *
+ * There is no individual task status return. In case of fatal error,
+ * the client or worker sets an end condition on the queue. A second
+ * queue could conceivably be used for returning individual task
+ * status.
+ */
+template <class T>
+class WorkQueue {
+	// Configuration
+	const std::string name;
+
+	// Status
+	// Worker threads having called exit
+	unsigned n_workers_exited;
+	bool ok;
+
+	unsigned n_threads;
+	pthread_t *threads;
+
+	// Synchronization
+	std::queue<T> queue;
+	Cond client_cond;
+	Cond worker_cond;
+	Mutex mutex;
+
+public:
+	/** Create a WorkQueue
+	 * @param name for message printing
+	 * @param hi number of tasks on queue before clients blocks. Default 0
+	 *    meaning no limit. hi == -1 means that the queue is disabled.
+	 * @param lo minimum count of tasks before worker starts. Default 1.
+	 */
+	WorkQueue(const char *_name)
+		:name(_name),
+		 n_workers_exited(0),
+		 ok(false),
+		 n_threads(0), threads(nullptr)
+	{
+	}
+
+	~WorkQueue() {
+		setTerminateAndWait();
+	}
+
+	/** Start the worker threads.
+	 *
+	 * @param nworkers number of threads copies to start.
+	 * @param start_routine thread function. It should loop
+	 *      taking (QueueWorker::take()) and executing tasks.
+	 * @param arg initial parameter to thread function.
+	 * @return true if ok.
+	 */
+	bool start(unsigned nworkers, void *(*workproc)(void *), void *arg)
+	{
+		const ScopeLock protect(mutex);
+
+		assert(nworkers > 0);
+		assert(!ok);
+		assert(n_threads == 0);
+		assert(threads == nullptr);
+
+		n_threads = nworkers;
+		threads = new pthread_t[n_threads];
+
+		for  (unsigned i = 0; i < nworkers; i++) {
+			int err;
+			if ((err = pthread_create(&threads[i], 0, workproc, arg))) {
+				LOGERR(("WorkQueue:%s: pthread_create failed, err %d\n",
+					name.c_str(), err));
+				return false;
+			}
+		}
+
+		ok = true;
+		return true;
+	}
+
+	/** Add item to work queue, called from client.
+	 *
+	 * Sleeps if there are already too many.
+	 */
+	template<typename U>
+	bool put(U &&u)
+	{
+		const ScopeLock protect(mutex);
+
+		queue.emplace(std::forward<U>(u));
+
+		// Just wake one worker, there is only one new task.
+		worker_cond.signal();
+
+		return true;
+	}
+
+
+	/** Tell the workers to exit, and wait for them.
+	 */
+	void setTerminateAndWait()
+	{
+		const ScopeLock protect(mutex);
+
+		// Wait for all worker threads to have called workerExit()
+		ok = false;
+		while (n_workers_exited < n_threads) {
+			worker_cond.broadcast();
+			client_cond.wait(mutex);
+		}
+
+		// Perform the thread joins and compute overall status
+		// Workers return (void*)1 if ok
+		for (unsigned i = 0; i < n_threads; ++i) {
+			void *status;
+			pthread_join(threads[i], &status);
+		}
+
+		delete[] threads;
+		threads = nullptr;
+		n_threads = 0;
+
+		// Reset to start state.
+		n_workers_exited = 0;
+	}
+
+	/** Take task from queue. Called from worker.
+	 *
+	 * Sleeps if there are not enough. Signal if we go to sleep on empty
+	 * queue: client may be waiting for our going idle.
+	 */
+	bool take(T &tp)
+	{
+		const ScopeLock protect(mutex);
+
+		if (!ok)
+			return false;
+
+		while (queue.empty()) {
+			worker_cond.wait(mutex);
+			if (!ok)
+				return false;
+		}
+
+		tp = std::move(queue.front());
+		queue.pop();
+		return true;
+	}
+
+	/** Advertise exit and abort queue. Called from worker
+	 *
+	 * This would happen after an unrecoverable error, or when
+	 * the queue is terminated by the client. Workers never exit normally,
+	 * except when the queue is shut down (at which point ok is set to
+	 * false by the shutdown code anyway). The thread must return/exit
+	 * immediately after calling this.
+	 */
+	void workerExit()
+	{
+		const ScopeLock protect(mutex);
+
+		n_workers_exited++;
+		ok = false;
+		client_cond.broadcast();
+	}
+};
+
+#endif /* _WORKQUEUE_H_INCLUDED_ */
diff --git a/src/db/plugins/upnp/ixmlwrap.cxx b/src/db/plugins/upnp/ixmlwrap.cxx
new file mode 100644
index 000000000..6a2829cf9
--- /dev/null
+++ b/src/db/plugins/upnp/ixmlwrap.cxx
@@ -0,0 +1,44 @@
+/* Copyright (C) 2013 J.F.Dockes
+ *   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.,
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#include "ixmlwrap.hxx"
+
+namespace ixmlwrap {
+
+const char *
+getFirstElementValue(IXML_Document *doc, const char *name)
+{
+	const char *ret = nullptr;
+	IXML_NodeList *nodes =
+		ixmlDocument_getElementsByTagName(doc, name);
+
+	if (nodes) {
+		IXML_Node *first = ixmlNodeList_item(nodes, 0);
+		if (first) {
+			IXML_Node *dnode = ixmlNode_getFirstChild(first);
+			if (dnode) {
+				ret = ixmlNode_getNodeValue(dnode);
+			}
+		}
+
+		ixmlNodeList_free(nodes);
+	}
+
+	return ret;
+}
+
+}
diff --git a/src/db/plugins/upnp/ixmlwrap.hxx b/src/db/plugins/upnp/ixmlwrap.hxx
new file mode 100644
index 000000000..0d519a323
--- /dev/null
+++ b/src/db/plugins/upnp/ixmlwrap.hxx
@@ -0,0 +1,35 @@
+/* Copyright (C) 2013 J.F.Dockes
+ *   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.,
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+#ifndef _IXMLWRAP_H_INCLUDED_
+#define _IXMLWRAP_H_INCLUDED_
+
+#include <upnp/ixml.h>
+
+#include <string>
+
+namespace ixmlwrap {
+	/**
+	 * Retrieve the text content for the first element of given
+	 * name.  Returns nullptr if the element does not
+	 * contain a text node
+	 */
+	const char *getFirstElementValue(IXML_Document *doc,
+					 const char *name);
+
+};
+
+#endif /* _IXMLWRAP_H_INCLUDED_ */
diff --git a/src/db/plugins/upnp/upnpplib.cxx b/src/db/plugins/upnp/upnpplib.cxx
new file mode 100644
index 000000000..27b4e0564
--- /dev/null
+++ b/src/db/plugins/upnp/upnpplib.cxx
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2003-2014 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 "upnpplib.hxx"
+#include "Domain.hxx"
+#include "Log.hxx"
+
+#include <upnp/ixml.h>
+#include <upnp/upnptools.h>
+
+static LibUPnP *theLib;
+
+LibUPnP::LibUPnP()
+{
+	auto code = UpnpInit(0, 0);
+	if (code != UPNP_E_SUCCESS) {
+		init_error.Format(upnp_domain, code,
+				  "UpnpInit() failed: %s",
+				  UpnpGetErrorMessage(code));
+		return;
+	}
+
+	UpnpSetMaxContentLength(2000*1024);
+
+	code = UpnpRegisterClient(o_callback, (void *)this, &m_clh);
+	if (code != UPNP_E_SUCCESS) {
+		init_error.Format(upnp_domain, code,
+				  "UpnpRegisterClient() failed: %s",
+				  UpnpGetErrorMessage(code));
+		return;
+	}
+
+	// Servers sometimes make error (e.g.: minidlna returns bad utf-8)
+	ixmlRelaxParser(1);
+}
+
+int
+LibUPnP::o_callback(Upnp_EventType et, void* evp, void* cookie)
+{
+	LibUPnP *ulib = (LibUPnP *)cookie;
+	if (ulib == nullptr) {
+		// Because the asyncsearch calls uses a null cookie.
+		ulib = theLib;
+	}
+
+	if (ulib->handler)
+		ulib->handler(et, evp);
+
+	return UPNP_E_SUCCESS;
+}
+
+LibUPnP::~LibUPnP()
+{
+	int error = UpnpFinish();
+	if (error != UPNP_E_SUCCESS)
+		FormatError(upnp_domain, "UpnpFinish() failed: %s",
+			    UpnpGetErrorMessage(error));
+}
diff --git a/src/db/plugins/upnp/upnpplib.hxx b/src/db/plugins/upnp/upnpplib.hxx
new file mode 100644
index 000000000..6759aa16d
--- /dev/null
+++ b/src/db/plugins/upnp/upnpplib.hxx
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2003-2014 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 _LIBUPNP_H_X_INCLUDED_
+#define _LIBUPNP_H_X_INCLUDED_
+
+#include "util/Error.hxx"
+
+#include <upnp/upnp.h>
+
+#include <functional>
+
+/** Our link to libupnp. Initialize and keep the handle around */
+class LibUPnP {
+	typedef std::function<void(Upnp_EventType type, void *event)> Handler;
+
+	Error init_error;
+	UpnpClient_Handle m_clh;
+
+	Handler handler;
+
+	static int o_callback(Upnp_EventType, void *, void *);
+
+public:
+	LibUPnP();
+
+	LibUPnP(const LibUPnP &) = delete;
+	LibUPnP &operator=(const LibUPnP &) = delete;
+
+	~LibUPnP();
+
+	/** Check state after initialization */
+	bool ok() const
+	{
+		return !init_error.IsDefined();
+	}
+
+	/** Retrieve init error if state not ok */
+	const Error &GetInitError() const {
+		return init_error;
+	}
+
+	template<typename T>
+	void SetHandler(T &&_handler) {
+		handler = std::forward<T>(_handler);
+	}
+
+	UpnpClient_Handle getclh()
+	{
+		return m_clh;
+	}
+};
+
+#endif /* _LIBUPNP.H_X_INCLUDED_ */