aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/DatabaseRegistry.cxx4
-rw-r--r--src/db/UpnpDatabasePlugin.cxx923
-rw-r--r--src/db/UpnpDatabasePlugin.hxx27
-rw-r--r--src/db/upnp/ContentDirectoryService.cxx316
-rw-r--r--src/db/upnp/ContentDirectoryService.hxx119
-rw-r--r--src/db/upnp/Device.cxx140
-rw-r--r--src/db/upnp/Device.hxx92
-rw-r--r--src/db/upnp/Directory.cxx177
-rw-r--r--src/db/upnp/Directory.hxx55
-rw-r--r--src/db/upnp/Discovery.cxx326
-rw-r--r--src/db/upnp/Discovery.hxx90
-rw-r--r--src/db/upnp/Domain.cxx23
-rw-r--r--src/db/upnp/Domain.hxx27
-rw-r--r--src/db/upnp/Object.hxx79
-rw-r--r--src/db/upnp/Util.cxx149
-rw-r--r--src/db/upnp/Util.hxx46
-rw-r--r--src/db/upnp/WorkQueue.hxx327
-rw-r--r--src/db/upnp/ixmlwrap.cxx44
-rw-r--r--src/db/upnp/ixmlwrap.hxx35
-rw-r--r--src/db/upnp/upnpplib.cxx144
-rw-r--r--src/db/upnp/upnpplib.hxx93
21 files changed, 3236 insertions, 0 deletions
diff --git a/src/DatabaseRegistry.cxx b/src/DatabaseRegistry.cxx
index 4ce4a62cb..6937d51c1 100644
--- a/src/DatabaseRegistry.cxx
+++ b/src/DatabaseRegistry.cxx
@@ -21,6 +21,7 @@
#include "DatabaseRegistry.hxx"
#include "db/SimpleDatabasePlugin.hxx"
#include "db/ProxyDatabasePlugin.hxx"
+#include "db/UpnpDatabasePlugin.hxx"
#include <string.h>
@@ -29,6 +30,9 @@ const DatabasePlugin *const database_plugins[] = {
#ifdef HAVE_LIBMPDCLIENT
&proxy_db_plugin,
#endif
+#ifdef HAVE_LIBUPNP
+ &upnp_db_plugin,
+#endif
nullptr
};
diff --git a/src/db/UpnpDatabasePlugin.cxx b/src/db/UpnpDatabasePlugin.cxx
new file mode 100644
index 000000000..c619316ef
--- /dev/null
+++ b/src/db/UpnpDatabasePlugin.cxx
@@ -0,0 +1,923 @@
+/*
+ * Copyright (C) 2003-2012 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 "DatabasePlugin.hxx"
+#include "DatabaseSelection.hxx"
+#include "DatabaseError.hxx"
+#include "PlaylistVector.hxx"
+#include "Directory.hxx"
+#include "Song.hxx"
+#include "ConfigData.hxx"
+#include "tag/TagBuilder.hxx"
+#include "tag/TagTable.hxx"
+#include "util/Error.hxx"
+#include "util/Domain.hxx"
+#include "Log.hxx"
+#include "SongFilter.hxx"
+
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+
+#include <assert.h>
+#include <string.h>
+
+static const char *const rootid = "0";
+
+class UpnpDatabase : public Database {
+ LibUPnP *m_lib;
+ UPnPDeviceDirectory *m_superdir;
+ Directory *m_root;
+ std::string m_upnplog;
+
+public:
+ UpnpDatabase()
+ : m_lib(0), m_superdir(0), m_root(0)
+ {}
+
+ static Database *Create(const config_param &param,
+ Error &error);
+
+ virtual bool Open(Error &error) override;
+ virtual void Close() override;
+ virtual Song *GetSong(const char *uri_utf8,
+ Error &error) const override;
+ virtual void ReturnSong(Song *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 reallyOpen(Error &error);
+ bool VisitServer(ContentDirectoryService* server,
+ const std::vector<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(ContentDirectoryService* server,
+ const char *objid,
+ const DatabaseSelection &selection,
+ VisitSong visit_song,
+ Error &error) const;
+
+ bool SearchSongs(ContentDirectoryService* server,
+ const char *objid,
+ const DatabaseSelection &selection,
+ UPnPDirContent& dirbuf,
+ Error &error) const;
+
+ bool Namei(ContentDirectoryService* server,
+ const std::vector<std::string> &vpath,
+ std::string &oobjid, UPnPDirObject &dirent,
+ Error &error) const;
+
+ /**
+ * Take server and objid, return metadata.
+ */
+ bool ReadNode(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(ContentDirectoryService* server,
+ const UPnPDirObject& dirent, std::string &idpath,
+ Error &error) const;
+};
+
+gcc_pure
+static std::vector<std::string>
+stringToTokens(const std::string &str,
+ const char *delims = "/", bool skipinit = true)
+{
+ std::vector<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.push_back(str.substr(startPos));
+ break;
+ } else if (pos == startPos) {
+ // Dont' push empty tokens after first
+ if (tokens.empty())
+ tokens.push_back(std::string());
+ startPos = ++pos;
+ } else {
+ tokens.push_back(str.substr(startPos, pos - startPos));
+ startPos = ++pos;
+ }
+ }
+
+ return tokens;
+}
+
+Database *
+UpnpDatabase::Create(const config_param &param, Error &error)
+{
+ UpnpDatabase *db = new UpnpDatabase();
+ if (db && !db->Configure(param, error)) {
+ delete db;
+ db = nullptr;
+ }
+ return db;
+}
+
+bool
+UpnpDatabase::Configure(const config_param& param, Error&)
+{
+ m_upnplog = param.GetBlockValue("upnplog", "");
+ return true;
+}
+
+// Open is called before mpd daemonizes, and daemonizing messes with
+// the UpNP lib (it loses its ability to receive mcast messages
+// apparently).
+// So we delay actual opening until the first client call.
+//
+// Unfortunately the servers may take a few seconds to answer the
+// first search on the network, so we would either have to sleep for a
+// relatively long time (maybe 5S), or accept that the directory may
+// not be complete on the first client call. There is no simple
+// solution to this issue, we would need a call from mpd after daemonizing.
+bool
+UpnpDatabase::Open(Error &)
+{
+ return true;
+}
+
+bool UpnpDatabase::reallyOpen(Error &error)
+{
+ if (m_root)
+ return true;
+
+ m_lib = LibUPnP::getLibUPnP(error);
+ if (!m_lib)
+ return false;
+
+ if (!m_upnplog.empty()) {
+ m_lib->setLogFileName(m_upnplog);
+ }
+ m_superdir = UPnPDeviceDirectory::getTheDir();
+ if (!m_superdir || !m_superdir->ok()) {
+ error.Set(upnp_domain, "Discovery services startup failed");
+ return false;
+ }
+
+ m_root = Directory::NewRoot();
+ // Wait for device answers. This should be consistent with the value set
+ // in the lib (currently 2)
+ sleep(2);
+ return true;
+}
+
+void
+UpnpDatabase::Close()
+{
+ if (m_root)
+ delete m_root;
+ // TBD decide what we do with the lib and superdir objects
+}
+
+void
+UpnpDatabase::ReturnSong(Song *song) const
+{
+ assert(song != nullptr);
+
+ song->Free();
+}
+
+/**
+ * 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(const std::string &in)
+{
+ std::string out;
+ for (auto it = in.begin(); it != in.end(); it++) {
+ if (*it == '/') {
+ out += '_';
+ } else {
+ out += *it;
+ }
+ }
+ return out;
+}
+
+gcc_pure
+static int
+upnpDurationToSeconds(const std::string &duration)
+{
+ const auto v = stringToTokens(duration, ":");
+ if (v.size() != 3)
+ return 0;
+ return atoi(v[0].c_str())*3600 + atoi(v[1].c_str())*60 + atoi(v[2].c_str());
+}
+
+// Upnp element to mpd tag number correspondance.
+// Don't know the upnp equivalent if any: TAG_ALBUM_ARTIST TAG_NAME
+// TAG_DATE TAG_COMPOSER TAG_PERFORMER TAG_COMMENT TAG_DISC
+static std::map<std::string, TagType> propToTag = {
+ {"upnp:artist", TAG_ARTIST},
+ {"upnp:album", TAG_ALBUM},
+ {"upnp:originalTrackNumber", TAG_TRACK},
+ {"upnp:genre", TAG_GENRE},
+ {"dc:title", TAG_TITLE},
+};
+
+// If uri is empty, we use the object's url instead. This happens
+// when the target of a Visit() is a song, which only happens when
+// "add"ing AFAIK. Visit() calls us with a null uri so that the url
+// appropriate for fetching is used instead.
+static Song *
+upnpItemToSong(const UPnPDirObject &dirent, const char *uri)
+{
+ std::string url(uri);
+ if (url.empty())
+ dirent.getprop("url", url);
+
+ Song *s = Song::NewFile(url.c_str(), nullptr);
+
+ // I don't think that upnp returns this.
+ s->mtime = time(0);
+
+ s->start_ms = 0;
+ std::string sprop("0:0:0");
+ dirent.getprop("duration", sprop);
+ int seconds = upnpDurationToSeconds(sprop);
+ s->end_ms = seconds * 1000;
+
+ TagBuilder tag;
+ tag.SetTime(seconds);
+
+ tag.AddItem(TAG_TITLE, titleToPathElt(dirent.m_title).c_str());
+
+ for (auto &pt : propToTag)
+ if (dirent.getprop(pt.first, sprop))
+ tag.AddItem(pt.second, sprop.c_str());
+
+ s->tag = tag.CommitNew();
+ return s;
+}
+
+// Get song info by path. We can receive either the id path, or the titles
+// one
+Song *
+UpnpDatabase::GetSong(const char *uri, Error &error) const
+{
+ if (!const_cast<UpnpDatabase *>(this)->reallyOpen(error))
+ return nullptr;
+
+ if (!m_superdir || !m_superdir->ok()) {
+ error.Set(upnp_domain,
+ "UpnpDatabase::GetSong() superdir is sick");
+ return nullptr;
+ }
+
+ Song *song = nullptr;
+ auto vpath = stringToTokens(uri, "/", true);
+ if (vpath.size() >= 2) {
+ ContentDirectoryService server;
+ if (!m_superdir->getServer(vpath[0].c_str(), server)) {
+ error.Set(upnp_domain, "server not found");
+ return nullptr;
+ }
+
+ vpath.erase(vpath.begin());
+ UPnPDirObject dirent;
+ if (vpath[0].compare(rootid)) {
+ std::string objid;
+ if (!Namei(&server, vpath, objid, dirent, error))
+ return nullptr;
+ } else {
+ if (!ReadNode(&server, vpath.back().c_str(), dirent,
+ error))
+ return nullptr;
+ }
+ song = upnpItemToSong(dirent, "");
+ }
+ if (song == nullptr)
+ error.Format(db_domain, DB_NOT_FOUND, "No such song: %s", uri);
+
+ return song;
+}
+
+static 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 }
+};
+
+/**
+ * Retrieve the value for an MPD tag from an object entry.
+ */
+static bool
+getTagValue(UPnPDirObject& dirent, TagType tag,
+ std::string &tagvalue)
+{
+ if (tag == TAG_TITLE) {
+ if (!dirent.m_title.empty()) {
+ tagvalue = titleToPathElt(dirent.m_title);
+ return true;
+ }
+ return false;
+ }
+
+ const char *name = tag_table_lookup(upnp_tags, tag);
+ if (name == nullptr)
+ return false;
+
+ std::string propvalue;
+ dirent.getprop(name, propvalue);
+ if (propvalue.empty())
+ return false;
+ tagvalue = propvalue;
+ return true;
+}
+
+/**
+ * Double-quote a string, adding internal backslash escaping.
+ */
+static void
+dquote(std::string &out, const char *in)
+{
+ out.append(1, '"');
+
+ for (; *in != 0; ++in) {
+ switch(*in) {
+ case '\\':
+ case '"':
+ out.append(1, '\\');
+ out.append(1, *in);
+ break;
+
+ default:
+ out.append(1, *in);
+ }
+ }
+
+ out.append(1, '"');
+}
+
+// Run an UPnP search, according to MPD parameters. Return results as
+// UPnP items
+bool
+UpnpDatabase::SearchSongs(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::set<std::string> searchcaps;
+ if (!server->getSearchCapabilities(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(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;
+ Song *s = upnpItemToSong(meta, path);
+ if (!selection.Match(*s))
+ return true;
+ bool success = visit_song(*s, error);
+ s->Free();
+ return success;
+}
+
+/**
+ * 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 const std::string
+songPath(const std::string &servername,
+ const std::string &objid)
+{
+ return servername + "/" + rootid + "/" + objid;
+}
+
+bool
+UpnpDatabase::SearchSongs(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 (const auto &dirent : dirbuf.m_items) {
+ // 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.
+ std::string path = songPath(server->getFriendlyName(),
+ dirent.m_id);
+ //BuildPath(server, dirent, path);
+ if (!visitSong(dirent, path.c_str(), selection, visit_song,
+ error))
+ return false;
+ }
+
+ return true;
+}
+
+bool
+UpnpDatabase::ReadNode(ContentDirectoryService *server,
+ const char *objid, UPnPDirObject &dirent,
+ Error &error) const
+{
+ UPnPDirContent dirbuf;
+ if (!server->getMetadata(objid, dirbuf, error))
+ return false;
+
+ if (dirbuf.m_containers.size() == 1) {
+ dirent = dirbuf.m_containers[0];
+ } else if (dirbuf.m_items.size() == 1) {
+ dirent = dirbuf.m_items[0];
+ } else {
+ error.Format(upnp_domain, "Bad resource");
+ return false;
+ }
+
+ return true;
+}
+
+bool
+UpnpDatabase::BuildPath(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();
+ path = titleToPathElt(dirent.m_title) + (path.empty()? "" : "/" + path);
+ }
+ path = std::string(server->getFriendlyName()) + "/" + path;
+ return true;
+}
+
+// Take server and internal title pathname and return objid and metadata.
+bool
+UpnpDatabase::Namei(ContentDirectoryService* server,
+ const std::vector<std::string> &vpath,
+ std::string &oobjid, UPnPDirObject &odirent,
+ Error &error) const
+{
+ oobjid.clear();
+ std::string objid(rootid);
+
+ if (vpath.empty()) {
+ // looking for root info
+ if (!ReadNode(server, rootid, odirent, error))
+ return false;
+
+ oobjid = rootid;
+ return true;
+ }
+
+ // Walk the path elements, read each directory and try to find the next one
+ for (unsigned int i = 0; i < vpath.size(); i++) {
+ UPnPDirContent dirbuf;
+ if (!server->readDir(objid.c_str(), dirbuf, error))
+ return false;
+
+ bool found = false;
+
+ // Look for the name in the sub-container list
+ for (auto& dirent : dirbuf.m_containers) {
+ if (!vpath[i].compare(titleToPathElt(dirent.m_title.c_str()))) {
+ objid = dirent.m_id; // Next readdir target
+ found = true;
+ if (i == vpath.size() - 1) {
+ // The last element in the path was found and it's
+ // a container, we're done
+ oobjid = objid;
+ odirent = dirent;
+ return true;
+ }
+ break;
+ }
+ }
+ if (found)
+ continue;
+
+ // Path elt was not a container, look at the items list
+ for (auto& dirent : dirbuf.m_items) {
+ if (!vpath[i].compare(titleToPathElt(dirent.m_title.c_str()))) {
+ // If this is the last path elt, we found the target,
+ // else it does not exist
+ if (i == vpath.size() - 1) {
+ oobjid = objid;
+ odirent = dirent;
+ return true;
+ } else {
+ return true;
+ }
+ }
+ }
+
+ // Neither container nor item, we're done.
+ if (!found)
+ break;
+ }
+
+ return true;
+}
+
+// vpath is a parsed and writeable version of selection.uri. There is
+// really just one path parameter.
+bool
+UpnpDatabase::VisitServer(ContentDirectoryService* server,
+ const std::vector<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[0].compare(rootid)) {
+ if (visit_song) {
+ UPnPDirObject dirent;
+ if (!ReadNode(server, vpath.back().c_str(), dirent,
+ error))
+ return false;
+
+ if (!visitSong(dirent, "", selection,
+ visit_song, error))
+ return false;
+ }
+ return true;
+ }
+
+ // Translate the target path into an object id and the associated metadata.
+ std::string objid;
+ UPnPDirObject tdirent;
+ if (!Namei(server, vpath, objid, tdirent, error))
+ return false;
+
+ if (objid.empty())
+ // Not found, not a fatal error
+ return true;
+
+ /* 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, objid.c_str(), selection,
+ visit_song, error);
+
+ if (tdirent.m_type == UPnPDirObject::item) {
+ // Target is a song. Not too sure we ever get there actually, maybe
+ // this is always catched by the special uri test above.
+ if (visit_song &&
+ tdirent.m_iclass == UPnPDirObject::audioItem_musicTrack) {
+ return visitSong(tdirent, "", selection, visit_song,
+ error);
+ } else if (visit_playlist &&
+ tdirent.m_iclass == UPnPDirObject::audioItem_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;
+ }
+
+ /* 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(objid.c_str(), dirbuf, error))
+ return false;
+
+ if (visit_directory) {
+ for (auto& dirent : dirbuf.m_containers) {
+ Directory d((selection.uri + "/" +
+ titleToPathElt(dirent.m_title)).c_str(),
+ m_root);
+ if (!visit_directory(d, error))
+ return false;
+ }
+ }
+
+ if (visit_song || visit_playlist) {
+ for (const auto &dirent : dirbuf.m_items) {
+ if (visit_song &&
+ dirent.m_iclass == UPnPDirObject::audioItem_musicTrack) {
+ /* We identify songs by giving them a
+ special path. The Id is enough to
+ fetch them from the server
+ anyway. */
+
+ std::string p;
+ if (!selection.recursive)
+ p = selection.uri + "/" +
+ titleToPathElt(dirent.m_title);
+
+ if (!visitSong(dirent, p.c_str(),
+ selection, visit_song, error))
+ return false;
+ } else if (visit_playlist &&
+ dirent.m_iclass == UPnPDirObject::audioItem_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;
+}
+
+// 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
+{
+ if (!const_cast<UpnpDatabase *>(this)->reallyOpen(error))
+ return false;
+
+ std::vector<ContentDirectoryService> servers;
+ if (!m_superdir || !m_superdir->ok() ||
+ !m_superdir->getDirServices(servers)) {
+ error.Set(upnp_domain,
+ "UpnpDatabase::Visit() superdir is sick");
+ return false;
+ }
+
+ auto vpath = stringToTokens(selection.uri, "/", true);
+ if (vpath.empty()) {
+ if (!selection.recursive) {
+ // If the path is empty and recursive is not set, synthetize a
+ // pseudo-directory from the list of servers.
+ if (visit_directory) {
+ for (auto& server : servers) {
+ Directory d(server.getFriendlyName(), m_root);
+ if (!visit_directory(d, error))
+ return false;
+ }
+ }
+ } else {
+ // Recursive is set: visit each server
+ for (auto& server : servers) {
+ if (!VisitServer(&server, std::vector<std::string>(), 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(vpath[0]);
+ vpath.erase(vpath.begin());
+
+ ContentDirectoryService* server = 0;
+ for (auto& dir : servers) {
+ if (!servername.compare(dir.getFriendlyName())) {
+ server = &dir;
+ break;
+ }
+ }
+ if (server == 0) {
+ FormatDebug(db_domain, "UpnpDatabase::Visit: server %s not found\n",
+ vpath[0].c_str());
+ return true;
+ }
+ 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 (!const_cast<UpnpDatabase *>(this)->reallyOpen(error))
+ return false;
+
+ if (!visit_string)
+ return true;
+
+ std::vector<ContentDirectoryService> servers;
+ if (!m_superdir || !m_superdir->ok() ||
+ !m_superdir->getDirServices(servers)) {
+ error.Set(upnp_domain,
+ "UpnpDatabase::Visit() superdir is sick");
+ return false;
+ }
+
+ std::set<std::string> values;
+ for (auto& server : servers) {
+ UPnPDirContent dirbuf;
+ if (!SearchSongs(&server, rootid, selection, dirbuf, error))
+ return false;
+
+ for (auto &dirent : dirbuf.m_items) {
+ std::string tagvalue;
+ if (getTagValue(dirent, tag, tagvalue))
+ values.emplace(std::move(tagvalue));
+ }
+ }
+
+ 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/UpnpDatabasePlugin.hxx b/src/db/UpnpDatabasePlugin.hxx
new file mode 100644
index 000000000..7fe2dde60
--- /dev/null
+++ b/src/db/UpnpDatabasePlugin.hxx
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2003-2011 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_UPNP_DATABASE_PLUGIN_HXX
+#define MPD_UPNP_DATABASE_PLUGIN_HXX
+
+struct DatabasePlugin;
+
+extern const DatabasePlugin upnp_db_plugin;
+
+#endif
diff --git a/src/db/upnp/ContentDirectoryService.cxx b/src/db/upnp/ContentDirectoryService.cxx
new file mode 100644
index 000000000..b40f55c54
--- /dev/null
+++ b/src/db/upnp/ContentDirectoryService.cxx
@@ -0,0 +1,316 @@
+/*
+ * 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 "upnpplib.hxx"
+#include "util/Error.hxx"
+
+#include <stdio.h>
+
+#include <upnp/upnp.h>
+#include <upnp/upnptools.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;
+ }
+}
+
+class DirBResFree {
+public:
+ IXML_Document **rqpp, **rspp;
+ DirBResFree(IXML_Document** _rqpp, IXML_Document **_rspp)
+ :rqpp(_rqpp), rspp(_rspp) {}
+ ~DirBResFree()
+ {
+ if (*rqpp)
+ ixmlDocument_free(*rqpp);
+ if (*rspp)
+ ixmlDocument_free(*rspp);
+ }
+};
+
+bool
+ContentDirectoryService::readDirSlice(const char *objectId, int offset,
+ int count, UPnPDirContent &dirbuf,
+ int *didreadp, int *totalp,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *request(0);
+ IXML_Document *response(0);
+ DirBResFree cleaner(&request, &response);
+
+ // Create request
+ char ofbuf[100], cntbuf[100];
+ sprintf(ofbuf, "%d", offset);
+ sprintf(cntbuf, "%d", count);
+ int argcnt = 6;
+ // Some devices require an empty SortCriteria, else bad params
+ request = UpnpMakeAction("Browse", m_serviceType.c_str(), argcnt,
+ "ObjectID", objectId,
+ "BrowseFlag", "BrowseDirectChildren",
+ "Filter", "*",
+ "SortCriteria", "",
+ "StartingIndex", ofbuf,
+ "RequestedCount", cntbuf,
+ nullptr, nullptr);
+ if (request == nullptr) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ int code = UpnpSendAction(hdl, m_actionURL.c_str(), m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ int didread = -1;
+ std::string tbuf = ixmlwrap::getFirstElementValue(response, "NumberReturned");
+ if (!tbuf.empty())
+ didread = atoi(tbuf.c_str());
+
+ if (count == -1 || count == 0) {
+ // TODO: what's this?
+ error.Set(upnp_domain, "got -1 or 0 entries");
+ return false;
+ }
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "TotalMatches");
+ if (!tbuf.empty())
+ *totalp = atoi(tbuf.c_str());
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "Result");
+
+ if (!dirbuf.parse(tbuf, error))
+ return false;
+
+ *didreadp = didread;
+ return true;
+}
+
+bool
+ContentDirectoryService::readDir(const char *objectId,
+ UPnPDirContent &dirbuf,
+ Error &error)
+{
+ int offset = 0;
+ int total = 1000;// Updated on first read.
+
+ while (offset < total) {
+ int count;
+ if (!readDirSlice(objectId, offset, m_rdreqcnt, dirbuf,
+ &count, &total, error))
+ return false;
+
+ offset += count;
+ }
+
+ return true;
+}
+
+bool
+ContentDirectoryService::search(const char *objectId,
+ const char *ss,
+ UPnPDirContent &dirbuf,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *request(0);
+ IXML_Document *response(0);
+
+ int offset = 0;
+ int total = 1000;// Updated on first read.
+
+ while (offset < total) {
+ DirBResFree cleaner(&request, &response);
+ char ofbuf[100];
+ sprintf(ofbuf, "%d", offset);
+ // Create request
+ int argcnt = 6;
+ request = UpnpMakeAction("Search", m_serviceType.c_str(), argcnt,
+ "ContainerID", objectId,
+ "SearchCriteria", ss,
+ "Filter", "*",
+ "SortCriteria", "",
+ "StartingIndex", ofbuf,
+ "RequestedCount", "0", // Setting a value here gets twonky into fits
+ nullptr, nullptr);
+ if (request == 0) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+ m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ int count = -1;
+ std::string tbuf =
+ ixmlwrap::getFirstElementValue(response, "NumberReturned");
+ if (!tbuf.empty())
+ count = atoi(tbuf.c_str());
+
+ if (count == -1 || count == 0) {
+ // TODO: what's this?
+ error.Set(upnp_domain, "got -1 or 0 entries");
+ return false;
+ }
+
+ offset += count;
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "TotalMatches");
+ if (!tbuf.empty())
+ total = atoi(tbuf.c_str());
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "Result");
+
+ if (!dirbuf.parse(tbuf, error))
+ return false;
+ }
+
+ return true;
+}
+
+bool
+ContentDirectoryService::getSearchCapabilities(std::set<std::string> &result,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *request(0);
+ IXML_Document *response(0);
+
+ request = UpnpMakeAction("GetSearchCapabilities", m_serviceType.c_str(),
+ 0,
+ nullptr, nullptr);
+ if (request == 0) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+ m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ std::string tbuf = ixmlwrap::getFirstElementValue(response, "SearchCaps");
+
+ result.clear();
+ if (!tbuf.compare("*")) {
+ result.insert(result.end(), "*");
+ } else if (!tbuf.empty()) {
+ if (!csvToStrings(tbuf, result)) {
+ error.Set(upnp_domain, "Bad response");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool
+ContentDirectoryService::getMetadata(const char *objectId,
+ UPnPDirContent &dirbuf,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *response(0);
+
+ // Create request
+ int argcnt = 6;
+ IXML_Document *request =
+ UpnpMakeAction("Browse", m_serviceType.c_str(), argcnt,
+ "ObjectID", objectId,
+ "BrowseFlag", "BrowseMetadata",
+ "Filter", "*",
+ "SortCriteria", "",
+ "StartingIndex", "0",
+ "RequestedCount", "1",
+ nullptr, nullptr);
+ DirBResFree cleaner(&request, &response);
+ if (request == nullptr) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+ m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ std::string tbuf = ixmlwrap::getFirstElementValue(response, "Result");
+ return dirbuf.parse(tbuf, error);
+}
diff --git a/src/db/upnp/ContentDirectoryService.hxx b/src/db/upnp/ContentDirectoryService.hxx
new file mode 100644
index 000000000..8fc28c382
--- /dev/null
+++ b/src/db/upnp/ContentDirectoryService.hxx
@@ -0,0 +1,119 @@
+/*
+ * 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 <string>
+#include <set>
+
+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;
+
+ /** 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(const char *objectId, UPnPDirContent &dirbuf,
+ Error &error);
+
+ bool readDirSlice(const char *objectId, int offset,
+ int count, UPnPDirContent& dirbuf,
+ int *didread, int *total,
+ Error &error);
+
+ /** 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(const char *objectId, const char *searchstring,
+ UPnPDirContent &dirbuf,
+ Error &error);
+
+ /** 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(const char *objectId, UPnPDirContent &dirbuf,
+ Error &error);
+
+ /** 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(std::set<std::string> &result,
+ Error &error);
+
+ /** 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/upnp/Device.cxx b/src/db/upnp/Device.cxx
new file mode 100644
index 000000000..c1cfab07a
--- /dev/null
+++ b/src/db/upnp/Device.cxx
@@ -0,0 +1,140 @@
+/*
+ * 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 "Log.hxx"
+#include "util/Error.hxx"
+
+#include <stdlib.h>
+
+#include <string.h>
+
+/**
+ * An XML parser which constructs an UPnP device object from the
+ * device descriptor.
+ */
+class UPnPDeviceParser final : public CommonExpatParser {
+ UPnPDevice &m_device;
+ std::string m_tabs;
+ std::vector<std::string> m_path;
+ UPnPService m_tservice;
+
+public:
+ UPnPDeviceParser(UPnPDevice& device)
+ :m_device(device) {}
+
+protected:
+ virtual void StartElement(const XML_Char *name, const XML_Char **) {
+ m_tabs.push_back('\t');
+ m_path.push_back(name);
+ }
+
+ virtual void EndElement(const XML_Char *name) {
+ if (!strcmp(name, "service")) {
+ m_device.services.push_back(m_tservice);
+ m_tservice.clear();
+ }
+ if (m_tabs.size())
+ m_tabs.erase(m_tabs.size()-1);
+ m_path.pop_back();
+ }
+
+ virtual void CharacterData(const XML_Char *s, int len) {
+ if (len == 0)
+ return;
+
+ std::string str(s, len);
+ trimstring(str);
+ switch (m_path.back()[0]) {
+ case 'c':
+ if (!m_path.back().compare("controlURL"))
+ m_tservice.controlURL += str;
+ break;
+ case 'd':
+ if (!m_path.back().compare("deviceType"))
+ m_device.deviceType += str;
+ break;
+ case 'e':
+ if (!m_path.back().compare("eventSubURL"))
+ m_tservice.eventSubURL += str;
+ break;
+ case 'f':
+ if (!m_path.back().compare("friendlyName"))
+ m_device.friendlyName += str;
+ break;
+ case 'm':
+ if (!m_path.back().compare("manufacturer"))
+ m_device.manufacturer += str;
+ else if (!m_path.back().compare("modelName"))
+ m_device.modelName += str;
+ break;
+ case 's':
+ if (!m_path.back().compare("serviceType"))
+ m_tservice.serviceType = str;
+ else if (!m_path.back().compare("serviceId"))
+ m_tservice.serviceId += str;
+ case 'S':
+ if (!m_path.back().compare("SCPDURL"))
+ m_tservice.SCPDURL = str;
+ break;
+ case 'U':
+ if (!m_path.back().compare("UDN"))
+ m_device.UDN = str;
+ else if (!m_path.back().compare("URLBase"))
+ m_device.URLBase += str;
+ break;
+ }
+ }
+};
+
+UPnPDevice::UPnPDevice(const std::string &url, const std::string &description)
+ :ok(false)
+{
+ UPnPDeviceParser mparser(*this);
+ Error error;
+ if (!mparser.Parse(description.data(), description.length(), true,
+ error)) {
+ // TODO: pass Error to caller
+ LogError(error);
+ return;
+ }
+
+ 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);
+ }
+ }
+ }
+ ok = true;
+}
diff --git a/src/db/upnp/Device.hxx b/src/db/upnp/Device.hxx
new file mode 100644
index 000000000..53e1c4964
--- /dev/null
+++ b/src/db/upnp/Device.hxx
@@ -0,0 +1,92 @@
+/*
+ * 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;
+ // Unique Id inside device: e.g here THE ConnectionManager
+ std::string serviceId; // e.g. urn:upnp-org:serviceId:ConnectionManager
+ std::string SCPDURL; // Service description URL. e.g.: cm.xml
+ std::string controlURL; // e.g.: /upnp/control/cm
+ std::string eventSubURL; // e.g.: /upnp/event/cm
+
+ void clear()
+ {
+ serviceType.clear();
+ serviceId.clear();
+ SCPDURL.clear();
+ controlURL.clear();
+ eventSubURL.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:
+ bool ok;
+ // 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;
+
+ /** Build device from xml description downloaded from discovery
+ * @param url where the description came from
+ * @param description the xml device description
+ */
+ UPnPDevice(const std::string &url, const std::string &description);
+
+ UPnPDevice() : ok(false) {}
+};
+
+typedef std::vector<UPnPService>::iterator DevServIt;
+
+#endif /* _UPNPDEV_HXX_INCLUDED_ */
diff --git a/src/db/upnp/Directory.cxx b/src/db/upnp/Directory.cxx
new file mode 100644
index 000000000..895e767be
--- /dev/null
+++ b/src/db/upnp/Directory.cxx
@@ -0,0 +1,177 @@
+/*
+ * 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 <string>
+#include <vector>
+#include <map>
+
+#include <string.h>
+
+static const char *const upnptags[] = {
+ "upnp:artist",
+ "upnp:album",
+ "upnp:genre",
+ "upnp:originalTrackNumber",
+ "upnp:class",
+};
+static const int nupnptags = sizeof(upnptags) / sizeof(char*);
+
+/**
+ * An XML parser which builds directory contents from DIDL lite input.
+ */
+class UPnPDirParser final : public CommonExpatParser {
+ struct StackEl {
+ StackEl(const std::string& nm) : name(nm) {}
+ std::string name;
+ std::map<std::string,std::string> attributes;
+ };
+
+ std::vector<StackEl> m_path;
+ UPnPDirObject m_tobj;
+ std::map<std::string, UPnPDirObject::ItemClass> m_okitems;
+
+public:
+ UPnPDirParser(UPnPDirContent& dir)
+ :m_dir(dir)
+ {
+ m_okitems["object.item.audioItem.musicTrack"] =
+ UPnPDirObject::audioItem_musicTrack;
+ m_okitems["object.item.playlistItem"] =
+ UPnPDirObject::audioItem_playlist;
+ }
+ UPnPDirContent& m_dir;
+
+protected:
+ virtual void StartElement(const XML_Char *name, const XML_Char **attrs)
+ {
+ m_path.push_back(StackEl(name));
+ for (int i = 0; attrs[i] != 0; i += 2) {
+ m_path.back().attributes[attrs[i]] = attrs[i+1];
+ }
+
+ switch (name[0]) {
+ case 'c':
+ if (!strcmp(name, "container")) {
+ m_tobj.clear();
+ m_tobj.m_type = UPnPDirObject::container;
+ m_tobj.m_id = m_path.back().attributes["id"];
+ m_tobj.m_pid = m_path.back().attributes["parentID"];
+ }
+ break;
+ case 'i':
+ if (!strcmp(name, "item")) {
+ m_tobj.clear();
+ m_tobj.m_type = UPnPDirObject::item;
+ m_tobj.m_id = m_path.back().attributes["id"];
+ m_tobj.m_pid = m_path.back().attributes["parentID"];
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ bool checkobjok() {
+ bool ok = !m_tobj.m_id.empty() && !m_tobj.m_pid.empty() &&
+ !m_tobj.m_title.empty();
+
+ if (ok && m_tobj.m_type == UPnPDirObject::item) {
+ auto it = m_okitems.find(m_tobj.m_props["upnp:class"]);
+ if (it == m_okitems.end()) {
+ PLOGINF("checkobjok: found object of unknown class: [%s]\n",
+ m_tobj.m_props["upnp:class"].c_str());
+ ok = false;
+ } else {
+ m_tobj.m_iclass = it->second;
+ }
+ }
+
+ if (!ok) {
+ PLOGINF("checkobjok: skip: id [%s] pid [%s] clss [%s] tt [%s]\n",
+ m_tobj.m_id.c_str(), m_tobj.m_pid.c_str(),
+ m_tobj.m_props["upnp:class"].c_str(),
+ m_tobj.m_title.c_str());
+ }
+ return ok;
+ }
+
+ virtual void EndElement(const XML_Char *name)
+ {
+ if (!strcmp(name, "container")) {
+ if (checkobjok()) {
+ m_dir.m_containers.push_back(m_tobj);
+ }
+ } else if (!strcmp(name, "item")) {
+ if (checkobjok()) {
+ m_dir.m_items.push_back(m_tobj);
+ }
+ } else if (!strcmp(name, "res")) {
+ // <res protocolInfo="http-get:*:audio/mpeg:*" size="5171496"
+ // bitrate="24576" duration="00:03:35" sampleFrequency="44100"
+ // nrAudioChannels="2">
+ std::string s;
+ s="protocolInfo";m_tobj.m_props[s] = m_path.back().attributes[s];
+ s="size";m_tobj.m_props[s] = m_path.back().attributes[s];
+ s="bitrate";m_tobj.m_props[s] = m_path.back().attributes[s];
+ s="duration";m_tobj.m_props[s] = m_path.back().attributes[s];
+ s="sampleFrequency";m_tobj.m_props[s] = m_path.back().attributes[s];
+ s="nrAudioChannels";m_tobj.m_props[s] = m_path.back().attributes[s];
+ }
+
+ m_path.pop_back();
+ }
+
+ virtual void CharacterData(const XML_Char *s, int len)
+ {
+ if (s == 0 || *s == 0)
+ return;
+ std::string str(s, len);
+ trimstring(str);
+ switch (m_path.back().name[0]) {
+ case 'd':
+ if (!m_path.back().name.compare("dc:title"))
+ m_tobj.m_title += str;
+ break;
+ case 'r':
+ if (!m_path.back().name.compare("res")) {
+ m_tobj.m_props["url"] += str;
+ }
+ break;
+ case 'u':
+ for (int i = 0; i < nupnptags; i++) {
+ if (!m_path.back().name.compare(upnptags[i])) {
+ m_tobj.m_props[upnptags[i]] += str;
+ }
+ }
+ break;
+ }
+ }
+};
+
+bool
+UPnPDirContent::parse(const std::string &input, Error &error)
+{
+ UPnPDirParser parser(*this);
+ return parser.Parse(input.data(), input.length(), true, error);
+}
diff --git a/src/db/upnp/Directory.hxx b/src/db/upnp/Directory.hxx
new file mode 100644
index 000000000..55dc09c71
--- /dev/null
+++ b/src/db/upnp/Directory.hxx
@@ -0,0 +1,55 @@
+/*
+ * 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 <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> m_containers;
+ std::vector<UPnPDirObject> m_items;
+
+ /**
+ * 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 std::string &didltext, Error &error);
+};
+
+#endif /* _UPNPDIRCONTENT_H_X_INCLUDED_ */
diff --git a/src/db/upnp/Discovery.cxx b/src/db/upnp/Discovery.cxx
new file mode 100644
index 000000000..4065874a6
--- /dev/null
+++ b/src/db/upnp/Discovery.cxx
@@ -0,0 +1,326 @@
+/*
+ * 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 "Device.hxx"
+#include "Domain.hxx"
+#include "ContentDirectoryService.hxx"
+#include "WorkQueue.hxx"
+#include "upnpplib.hxx"
+#include "thread/Mutex.hxx"
+
+#include <upnp/upnp.h>
+#include <upnp/upnptools.h>
+
+#include <string.h>
+
+#include <map>
+
+// The service type string we are looking for.
+static const std::string ContentDirectorySType("urn:schemas-upnp-org:service:ContentDirectory:1");
+
+// We don't include a version in comparisons, as we are satisfied with
+// version 1
+static bool
+isCDService(const std::string &st)
+{
+ const std::string::size_type sz(ContentDirectorySType.size()-2);
+ return !ContentDirectorySType.compare(0, sz, st, 0, sz);
+}
+
+// The type of device we're asking for in search
+static const std::string MediaServerDType("urn:schemas-upnp-org:device:MediaServer:1") ;
+
+static bool
+isMSDevice(const std::string &st)
+{
+ const std::string::size_type sz(MediaServerDType.size()-2);
+ return !MediaServerDType.compare(0, sz, st, 0, sz);
+}
+
+/**
+ * Each appropriate discovery event (executing in a libupnp thread
+ * context) queues the following task object for processing by the
+ * discovery thread.
+ */
+struct DiscoveredTask {
+ bool alive;
+ std::string url;
+ std::string deviceId;
+ int expires; // Seconds valid
+
+ DiscoveredTask(bool _alive, const Upnp_Discovery *disco)
+ : alive(_alive), url(disco->Location),
+ deviceId(disco->DeviceId),
+ expires(disco->Expires) {}
+
+};
+static WorkQueue<DiscoveredTask *> discoveredQueue("DiscoveredQueue");
+
+// Descriptor for one device having a Content Directory service found
+// on the network.
+class ContentDirectoryDescriptor {
+public:
+ ContentDirectoryDescriptor(const std::string &url,
+ const std::string &description,
+ time_t last, int exp)
+ :device(url, description), last_seen(last), expires(exp+20) {}
+ UPnPDevice device;
+ time_t last_seen;
+ int expires; // seconds valid
+};
+
+// A ContentDirectoryPool holds the characteristics of the servers
+// currently on the network.
+// The map is referenced by deviceId (==UDN)
+// The class is instanciated as a static (unenforced) singleton.
+class ContentDirectoryPool {
+public:
+ Mutex m_mutex;
+ std::map<std::string, ContentDirectoryDescriptor> m_directories;
+};
+
+static ContentDirectoryPool contentDirectories;
+
+// Worker routine for the discovery queue. Get messages about devices
+// appearing and disappearing, and update the directory pool
+// accordingly.
+static void *
+discoExplorer(void *)
+{
+ for (;;) {
+ DiscoveredTask *tsk = 0;
+ size_t qsz;
+ if (!discoveredQueue.take(&tsk, &qsz)) {
+ discoveredQueue.workerExit();
+ return (void*)1;
+ }
+
+ const ScopeLock protect(contentDirectories.m_mutex);
+ if (!tsk->alive) {
+ // Device signals it is going off.
+ auto it = contentDirectories.m_directories.find(tsk->deviceId);
+ if (it != contentDirectories.m_directories.end()) {
+ contentDirectories.m_directories.erase(it);
+ }
+ } else {
+ // 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;
+ }
+ std::string sdesc(buf);
+
+ // Update or insert the device
+ ContentDirectoryDescriptor d(tsk->url, sdesc,
+ time(0), tsk->expires);
+ if (!d.device.ok) {
+ continue;
+ }
+
+ auto e = contentDirectories.m_directories.emplace(tsk->deviceId, d);
+ if (!e.second)
+ e.first->second = d;
+ }
+ delete tsk;
+ }
+}
+
+// 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)
+// It seems that this can get called by several threads. We have a
+// mutex just for clarifying the message printing, the workqueue is
+// mt-safe of course.
+static int
+cluCallBack(Upnp_EventType et, void *evp, void *)
+{
+ static Mutex cblock;
+ const ScopeLock protect(cblock);
+
+ switch (et) {
+ case UPNP_DISCOVERY_SEARCH_RESULT:
+ case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
+ {
+ Upnp_Discovery *disco = (Upnp_Discovery *)evp;
+ if (isMSDevice(disco->DeviceType) ||
+ isCDService(disco->ServiceType)) {
+ DiscoveredTask *tp = new DiscoveredTask(1, disco);
+ if (discoveredQueue.put(tp))
+ return UPNP_E_FINISH;
+ }
+ break;
+ }
+
+ case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
+ {
+ Upnp_Discovery *disco = (Upnp_Discovery *)evp;
+
+ if (isMSDevice(disco->DeviceType) ||
+ isCDService(disco->ServiceType)) {
+ DiscoveredTask *tp = new DiscoveredTask(0, disco);
+ if (discoveredQueue.put(tp))
+ return UPNP_E_FINISH;
+ }
+ break;
+ }
+
+ default:
+ // Ignore other events for now
+ break;
+ }
+
+ return UPNP_E_SUCCESS;
+}
+
+void
+UPnPDeviceDirectory::expireDevices()
+{
+ const ScopeLock protect(contentDirectories.m_mutex);
+ time_t now = time(0);
+ bool didsomething = false;
+
+ for (auto it = contentDirectories.m_directories.begin();
+ it != contentDirectories.m_directories.end();) {
+ if (now - it->second.last_seen > it->second.expires) {
+ it = contentDirectories.m_directories.erase(it);
+ didsomething = true;
+ } else {
+ it++;
+ }
+ }
+
+ if (didsomething)
+ search();
+}
+
+UPnPDeviceDirectory::UPnPDeviceDirectory()
+ :m_searchTimeout(2), m_lastSearch(0)
+{
+ if (!discoveredQueue.start(1, discoExplorer, 0)) {
+ error.Set(upnp_domain, "Discover work queue start failed");
+ return;
+ }
+
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return;
+
+ lib->registerHandler(UPNP_DISCOVERY_SEARCH_RESULT, cluCallBack, this);
+ lib->registerHandler(UPNP_DISCOVERY_ADVERTISEMENT_ALIVE,
+ cluCallBack, this);
+ lib->registerHandler(UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE,
+ cluCallBack, this);
+
+ search();
+}
+
+bool
+UPnPDeviceDirectory::search()
+{
+ time_t now = time(0);
+ if (now - m_lastSearch < 10)
+ return true;
+ m_lastSearch = now;
+
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ // We search both for device and service just in case.
+ int code = UpnpSearchAsync(lib->getclh(), m_searchTimeout,
+ ContentDirectorySType.c_str(), 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.c_str(), lib);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSearchAsync() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ return true;
+}
+
+UPnPDeviceDirectory *UPnPDeviceDirectory::getTheDir()
+{
+ // TODO: elimate static variable
+ static UPnPDeviceDirectory *theDevDir;
+ if (theDevDir == nullptr)
+ theDevDir = new UPnPDeviceDirectory();
+ if (theDevDir && !theDevDir->ok())
+ return 0;
+ return theDevDir;
+}
+
+bool
+UPnPDeviceDirectory::getDirServices(std::vector<ContentDirectoryService> &out)
+{
+ if (!ok())
+ return false;
+
+ // Has locking, do it before our own lock
+ expireDevices();
+
+ const ScopeLock protect(contentDirectories.m_mutex);
+
+ for (auto dit = contentDirectories.m_directories.begin();
+ dit != contentDirectories.m_directories.end(); dit++) {
+ for (const auto &service : dit->second.device.services) {
+ if (isCDService(service.serviceType)) {
+ out.emplace_back(dit->second.device, service);
+ }
+ }
+ }
+
+ return true;
+}
+
+bool
+UPnPDeviceDirectory::getServer(const char *friendlyName,
+ ContentDirectoryService &server)
+{
+ std::vector<ContentDirectoryService> ds;
+ if (!getDirServices(ds)) {
+ return false;
+ }
+
+ for (const auto &i : ds) {
+ if (strcmp(friendlyName, i.getFriendlyName()) == 0) {
+ server = i;
+ return true;
+ }
+ }
+
+ return false;
+}
diff --git a/src/db/upnp/Discovery.hxx b/src/db/upnp/Discovery.hxx
new file mode 100644
index 000000000..899ac83ab
--- /dev/null
+++ b/src/db/upnp/Discovery.hxx
@@ -0,0 +1,90 @@
+/*
+ * 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 "util/Error.hxx"
+
+#include <vector>
+
+#include <time.h>
+
+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 {
+ Error error;
+
+ /**
+ * 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;
+
+ time_t m_lastSearch;
+
+ UPnPDeviceDirectory();
+public:
+ UPnPDeviceDirectory(const UPnPDeviceDirectory &) = delete;
+ UPnPDeviceDirectory& operator=(const UPnPDeviceDirectory &) = delete;
+
+ /** This class is a singleton. Get the instance here */
+ static UPnPDeviceDirectory *getTheDir();
+
+ /** Retrieve the directory services currently seen on the network */
+ bool getDirServices(std::vector<ContentDirectoryService> &);
+
+ /**
+ * Get server by friendly name. It's a bit wasteful to copy
+ * all servers for this, we could directly walk the list. Otoh
+ * there isn't going to be millions...
+ */
+ bool getServer(const char *friendlyName,
+ ContentDirectoryService &server);
+
+ /** My health */
+ bool ok() const {
+ return !error.IsDefined();
+ }
+
+ /** My diagnostic if health is bad */
+ const Error &GetError() const {
+ return error;
+ }
+
+private:
+ bool search();
+
+ /**
+ * 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.
+ */
+ void expireDevices();
+};
+
+
+#endif /* _UPNPPDISC_H_X_INCLUDED_ */
diff --git a/src/db/upnp/Domain.cxx b/src/db/upnp/Domain.cxx
new file mode 100644
index 000000000..12984bd19
--- /dev/null
+++ b/src/db/upnp/Domain.cxx
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "Domain.hxx"
+#include "util/Domain.hxx"
+
+const Domain upnp_domain("upnp");
diff --git a/src/db/upnp/Domain.hxx b/src/db/upnp/Domain.hxx
new file mode 100644
index 000000000..e249aa5dc
--- /dev/null
+++ b/src/db/upnp/Domain.hxx
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_UPNP_DOMAIN_HXX
+#define MPD_UPNP_DOMAIN_HXX
+
+class Domain;
+
+extern const Domain upnp_domain;
+
+#endif
diff --git a/src/db/upnp/Object.hxx b/src/db/upnp/Object.hxx
new file mode 100644
index 000000000..c05f39e47
--- /dev/null
+++ b/src/db/upnp/Object.hxx
@@ -0,0 +1,79 @@
+/*
+ * 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 <string>
+#include <map>
+
+/**
+ * UpnP Media Server directory entry, converted from XML data.
+ *
+ * This is a dumb data holder class, a struct with helpers.
+ */
+class UPnPDirObject {
+public:
+ enum ObjType {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 ItemClass {audioItem_musicTrack, audioItem_playlist};
+
+ std::string m_id; // ObjectId
+ std::string m_pid; // Parent ObjectId
+ std::string m_title; // dc:title. Directory name for a container.
+ ObjType m_type; // item or container
+ ItemClass m_iclass;
+ // Properties as gathered from the XML document (url, artist, etc.)
+ // The map keys are the XML tag or attribute names.
+ std::map<std::string, std::string> m_props;
+
+ /** Get named property
+ * @param property name (e.g. upnp:artist, upnp:album,
+ * upnp:originalTrackNumber, upnp:genre). Use m_title instead
+ * for dc:title.
+ * @param[out] value
+ * @return true if found.
+ */
+ bool getprop(const std::string &name, std::string &value) const
+ {
+ auto it = m_props.find(name);
+ if (it == m_props.end())
+ return false;
+ value = it->second;
+ return true;
+ }
+
+ void clear()
+ {
+ m_id.clear();
+ m_pid.clear();
+ m_title.clear();
+ m_type = (ObjType)-1;
+ m_iclass = (ItemClass)-1;
+ m_props.clear();
+ }
+};
+
+#endif /* _UPNPDIRCONTENT_H_X_INCLUDED_ */
diff --git a/src/db/upnp/Util.cxx b/src/db/upnp/Util.cxx
new file mode 100644
index 000000000..52d2bc63f
--- /dev/null
+++ b/src/db/upnp/Util.cxx
@@ -0,0 +1,149 @@
+/*
+ * 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 <string>
+#include <map>
+#include <vector>
+#include <set>
+
+#include <upnp/ixml.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)
+{
+ std::string out(s1);
+ if (out[out.size()-1] == '/') {
+ if (s2[0] == '/')
+ out.erase(out.size()-1);
+ } else {
+ if (s2[0] != '/')
+ out.push_back('/');
+ }
+ out += s2;
+ return out;
+}
+
+static void
+path_catslash(std::string &s)
+{
+ if (s.empty() || s[s.length() - 1] != '/')
+ s += '/';
+}
+
+std::string
+path_getfather(const std::string &s)
+{
+ std::string father = s;
+
+ // ??
+ if (father.empty())
+ return "./";
+
+ if (father[father.length() - 1] == '/') {
+ // 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;
+}
+
+template <class T>
+bool
+csvToStrings(const std::string &s, T &tokens)
+{
+ std::string current;
+ tokens.clear();
+ enum states {TOKEN, ESCAPE};
+ states state = TOKEN;
+ for (unsigned int i = 0; i < s.length(); i++) {
+ switch (s[i]) {
+ case ',':
+ switch(state) {
+ case TOKEN:
+ tokens.insert(tokens.end(), current);
+ current.clear();
+ continue;
+ case ESCAPE:
+ current += ',';
+ state = TOKEN;
+ continue;
+ }
+ break;
+ case '\\':
+ switch(state) {
+ case TOKEN:
+ state=ESCAPE;
+ continue;
+ case ESCAPE:
+ current += '\\';
+ state = TOKEN;
+ continue;
+ }
+ break;
+
+ default:
+ switch(state) {
+ case ESCAPE:
+ state = TOKEN;
+ break;
+ case TOKEN:
+ break;
+ }
+ current += s[i];
+ }
+ }
+ switch(state) {
+ case TOKEN:
+ tokens.insert(tokens.end(), current);
+ break;
+ case ESCAPE:
+ return false;
+ }
+ return true;
+}
+
+//template bool csvToStrings<list<string> >(const string &, list<string> &);
+template bool csvToStrings<std::vector<std::string> >(const std::string &, std::vector<std::string> &);
+template bool csvToStrings<std::set<std::string> >(const std::string &, std::set<std::string> &);
diff --git a/src/db/upnp/Util.hxx b/src/db/upnp/Util.hxx
new file mode 100644
index 000000000..2fdc3890f
--- /dev/null
+++ b/src/db/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 <string>
+
+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);
+
+template <class T>
+bool csvToStrings(const std::string& s, T &tokens);
+
+#define UPNPP_DEBUG
+
+#if defined(UPNPP_DEBUG) && defined(DEBUG)
+#include <upnp/upnpdebug.h>
+#define PLOGINF(...) UpnpPrintf(UPNP_INFO, API, __FILE__, __LINE__, __VA_ARGS__)
+#else
+#define PLOGINF(...)
+#endif
+
+#endif /* _UPNPP_H_X_INCLUDED_ */
diff --git a/src/db/upnp/WorkQueue.hxx b/src/db/upnp/WorkQueue.hxx
new file mode 100644
index 000000000..851f81837
--- /dev/null
+++ b/src/db/upnp/WorkQueue.hxx
@@ -0,0 +1,327 @@
+/*
+ * 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 <pthread.h>
+#include <time.h>
+
+#include <string>
+#include <queue>
+#include <unordered_map>
+
+//#include "debuglog.h"
+#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 {
+ /**
+ * Store per-worker-thread data. Just an initialized timespec,
+ * and used at the moment.
+ */
+ class WQTData {
+ public:
+ WQTData() {wstart.tv_sec = 0; wstart.tv_nsec = 0;}
+ struct timespec wstart;
+ };
+
+ // Configuration
+ std::string m_name;
+ size_t m_high;
+ size_t m_low;
+
+ // Status
+ // Worker threads having called exit
+ unsigned int m_workers_exited;
+ bool m_ok;
+
+ // Per-thread data. The data is not used currently, this could be
+ // a set<pthread_t>
+ std::unordered_map<pthread_t, WQTData> m_worker_threads;
+
+ // Synchronization
+ std::queue<T> m_queue;
+ Cond m_ccond;
+ Cond m_wcond;
+ Mutex m_mutex;
+ // Client/Worker threads currently waiting for a job
+ unsigned int m_clients_waiting;
+ unsigned int m_workers_waiting;
+
+ // Statistics
+ unsigned int m_tottasks;
+ unsigned int m_nowake;
+ unsigned int m_workersleeps;
+ unsigned int m_clientsleeps;
+
+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, size_t hi = 0, size_t lo = 1)
+ :m_name(name), m_high(hi), m_low(lo),
+ m_workers_exited(0),
+ m_ok(true),
+ m_clients_waiting(0), m_workers_waiting(0),
+ m_tottasks(0), m_nowake(0), m_workersleeps(0), m_clientsleeps(0)
+ {
+ }
+
+ ~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(int nworkers, void *(*workproc)(void *), void *arg)
+ {
+ const ScopeLock protect(m_mutex);
+
+ for (int i = 0; i < nworkers; i++) {
+ int err;
+ pthread_t thr;
+ if ((err = pthread_create(&thr, 0, workproc, arg))) {
+ LOGERR(("WorkQueue:%s: pthread_create failed, err %d\n",
+ m_name.c_str(), err));
+ return false;
+ }
+ m_worker_threads.insert(std::make_pair(thr, WQTData()));
+ }
+ return true;
+ }
+
+ /** Add item to work queue, called from client.
+ *
+ * Sleeps if there are already too many.
+ */
+ bool put(T t)
+ {
+ const ScopeLock protect(m_mutex);
+
+ if (!ok()) {
+ LOGERR(("WorkQueue::put:%s: !ok or mutex_lock failed\n",
+ m_name.c_str()));
+ return false;
+ }
+
+ while (ok() && m_high > 0 && m_queue.size() >= m_high) {
+ m_clientsleeps++;
+ // Keep the order: we test ok() AFTER the sleep...
+ m_clients_waiting++;
+ m_ccond.wait(m_mutex);
+ if (!ok()) {
+ m_clients_waiting--;
+ return false;
+ }
+ m_clients_waiting--;
+ }
+
+ m_queue.push(t);
+ if (m_workers_waiting > 0) {
+ // Just wake one worker, there is only one new task.
+ m_wcond.signal();
+ } else {
+ m_nowake++;
+ }
+
+ return true;
+ }
+
+ /**
+ * Wait until the queue is inactive. Called from client.
+ *
+ * Waits until the task queue is empty and the workers are all
+ * back sleeping. Used by the client to wait for all current work
+ * to be completed, when it needs to perform work that couldn't be
+ * done in parallel with the worker's tasks, or before shutting
+ * down. Work can be resumed after calling this. Note that the
+ * only thread which can call it safely is the client just above
+ * (which can control the task flow), else there could be
+ * tasks in the intermediate queues.
+ * To rephrase: there is no warranty on return that the queue is actually
+ * idle EXCEPT if the caller knows that no jobs are still being created.
+ * It would be possible to transform this into a safe call if some kind
+ * of suspend condition was set on the queue by waitIdle(), to be reset by
+ * some kind of "resume" call. Not currently the case.
+ */
+ bool waitIdle()
+ {
+ const ScopeLock protect(m_mutex);
+
+ if (!ok()) {
+ LOGERR(("WorkQueue::waitIdle:%s: not ok or can't lock\n",
+ m_name.c_str()));
+ return false;
+ }
+
+ // We're done when the queue is empty AND all workers are back
+ // waiting for a task.
+ while (ok() && (m_queue.size() > 0 ||
+ m_workers_waiting != m_worker_threads.size())) {
+ m_clients_waiting++;
+ m_ccond.wait(m_mutex);
+ m_clients_waiting--;
+ }
+
+ return ok();
+ }
+
+
+ /** Tell the workers to exit, and wait for them.
+ *
+ * Does not bother about tasks possibly remaining on the queue, so
+ * should be called after waitIdle() for an orderly shutdown.
+ */
+ void setTerminateAndWait()
+ {
+ const ScopeLock protect(m_mutex);
+
+ if (m_worker_threads.empty())
+ // Already called ?
+ return;
+
+ // Wait for all worker threads to have called workerExit()
+ m_ok = false;
+ while (m_workers_exited < m_worker_threads.size()) {
+ m_wcond.broadcast();
+ m_clients_waiting++;
+ m_ccond.wait(m_mutex);
+ m_clients_waiting--;
+ }
+
+ // Perform the thread joins and compute overall status
+ // Workers return (void*)1 if ok
+ while (!m_worker_threads.empty()) {
+ void *status;
+ auto it = m_worker_threads.begin();
+ pthread_join(it->first, &status);
+ m_worker_threads.erase(it);
+ }
+
+ // Reset to start state.
+ m_workers_exited = m_clients_waiting = m_workers_waiting =
+ m_tottasks = m_nowake = m_workersleeps = m_clientsleeps = 0;
+ m_ok = true;
+ }
+
+ /** 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, size_t *szp = 0)
+ {
+ const ScopeLock protect(m_mutex);
+
+ if (!ok()) {
+ return false;
+ }
+
+ while (ok() && m_queue.size() < m_low) {
+ m_workersleeps++;
+ m_workers_waiting++;
+ if (m_queue.empty())
+ m_ccond.broadcast();
+ m_wcond.wait(m_mutex);
+ if (!ok()) {
+ // !ok is a normal condition when shutting down
+ if (ok()) {
+ LOGERR(("WorkQueue::take:%s: cond_wait failed or !ok\n",
+ m_name.c_str()));
+ }
+ m_workers_waiting--;
+ return false;
+ }
+ m_workers_waiting--;
+ }
+
+ m_tottasks++;
+ *tp = m_queue.front();
+ if (szp)
+ *szp = m_queue.size();
+ m_queue.pop();
+ if (m_clients_waiting > 0) {
+ // No reason to wake up more than one client thread
+ m_ccond.signal();
+ } else {
+ m_nowake++;
+ }
+ 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 m_ok is set to
+ * false by the shutdown code anyway). The thread must return/exit
+ * immediately after calling this.
+ */
+ void workerExit()
+ {
+ const ScopeLock protect(m_mutex);
+
+ m_workers_exited++;
+ m_ok = false;
+ m_ccond.broadcast();
+ }
+
+ size_t qsize()
+ {
+ const ScopeLock protect(m_mutex);
+
+ size_t sz = m_queue.size();
+ return sz;
+ }
+
+private:
+ bool ok()
+ {
+ return m_ok && m_workers_exited == 0 && !m_worker_threads.empty();
+ }
+};
+
+#endif /* _WORKQUEUE_H_INCLUDED_ */
diff --git a/src/db/upnp/ixmlwrap.cxx b/src/db/upnp/ixmlwrap.cxx
new file mode 100644
index 000000000..247c36d5d
--- /dev/null
+++ b/src/db/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 {
+
+std::string
+getFirstElementValue(IXML_Document *doc, const char *name)
+{
+ std::string ret;
+ 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);
+ }
+ }
+ }
+
+ if(nodes)
+ ixmlNodeList_free(nodes);
+ return ret;
+}
+
+}
diff --git a/src/db/upnp/ixmlwrap.hxx b/src/db/upnp/ixmlwrap.hxx
new file mode 100644
index 000000000..8677d691a
--- /dev/null
+++ b/src/db/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 an empty string if the element does not
+ * contain a text node
+ */
+ std::string getFirstElementValue(IXML_Document *doc,
+ const char *name);
+
+};
+
+#endif /* _IXMLWRAP_H_INCLUDED_ */
diff --git a/src/db/upnp/upnpplib.cxx b/src/db/upnp/upnpplib.cxx
new file mode 100644
index 000000000..27dd9557a
--- /dev/null
+++ b/src/db/upnp/upnpplib.cxx
@@ -0,0 +1,144 @@
+/*
+ * 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 "Util.hxx"
+#include "Log.hxx"
+
+#include <string>
+#include <sstream>
+#include <map>
+#include <vector>
+#include <set>
+
+#include <upnp/ixml.h>
+#include <upnp/upnpdebug.h>
+
+static LibUPnP *theLib;
+
+LibUPnP *
+LibUPnP::getLibUPnP(Error &error)
+{
+ if (theLib == nullptr)
+ theLib = new LibUPnP;
+
+ if (!theLib->ok()) {
+ error.Set(theLib->GetInitError());
+ return nullptr;
+ }
+
+ return 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;
+ }
+
+ setMaxContentLength(2000*1024);
+#ifdef DEBUG
+ UpnpCloseLog();
+#endif
+
+ 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);
+}
+
+void LibUPnP::setMaxContentLength(int bytes)
+{
+ UpnpSetMaxContentLength(bytes);
+}
+
+bool LibUPnP::setLogFileName(const std::string& fn)
+{
+ const ScopeLock protect(m_mutex);
+
+ if (fn.empty()) {
+ UpnpCloseLog();
+ } else {
+ UpnpSetLogLevel(UPNP_INFO);
+ UpnpSetLogFileNames(fn.c_str(), fn.c_str());
+ int code = UpnpInitLog();
+ if (code != UPNP_E_SUCCESS) {
+ FormatError(upnp_domain, "UpnpInitLog() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+ }
+
+ return true;
+}
+
+void
+LibUPnP::registerHandler(Upnp_EventType et, Upnp_FunPtr handler, void *cookie)
+{
+ const ScopeLock protect(m_mutex);
+
+ if (handler == nullptr)
+ m_handlers.erase(et);
+ else
+ m_handlers.emplace(et, Handler(handler, cookie));
+}
+
+std::string
+LibUPnP::errAsString(const std::string& who, int code)
+{
+ std::ostringstream os;
+ os << who << " :" << code << ": " << UpnpGetErrorMessage(code);
+ return os.str();
+}
+
+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;
+ }
+
+ auto it = ulib->m_handlers.find(et);
+ if (it != ulib->m_handlers.end()) {
+ (it->second.handler)(et, evp, it->second.cookie);
+ }
+ 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/upnp/upnpplib.hxx b/src/db/upnp/upnpplib.hxx
new file mode 100644
index 000000000..fa3454072
--- /dev/null
+++ b/src/db/upnp/upnpplib.hxx
@@ -0,0 +1,93 @@
+/*
+ * 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 "thread/Mutex.hxx"
+#include "util/Error.hxx"
+
+#include <string>
+#include <map>
+
+#include <upnp/upnp.h>
+#include <upnp/upnptools.h>
+
+/** Our link to libupnp. Initialize and keep the handle around */
+class LibUPnP {
+ // A Handler object records the data from registerHandler.
+ class Handler {
+ public:
+ Handler(Upnp_FunPtr h, void *c)
+ : handler(h), cookie(c) {}
+ Upnp_FunPtr handler;
+ void *cookie;
+ };
+
+ Error init_error;
+ UpnpClient_Handle m_clh;
+ Mutex m_mutex;
+ std::map<Upnp_EventType, Handler> m_handlers;
+
+ LibUPnP();
+
+ LibUPnP(const LibUPnP &) = delete;
+ LibUPnP &operator=(const LibUPnP &) = delete;
+
+ static int o_callback(Upnp_EventType, void *, void *);
+
+public:
+ ~LibUPnP();
+
+ /** Retrieve the singleton LibUPnP object */
+ static LibUPnP *getLibUPnP(Error &error);
+
+ /** Set log file name and activate logging.
+ *
+ * @param fn file name to use. Use empty string to turn logging off
+ */
+ bool setLogFileName(const std::string& fn);
+
+ /** Set max library buffer size for reading content from servers.
+ * The default is 200k and should be ok */
+ void setMaxContentLength(int bytes);
+
+ /** 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;
+ }
+
+ void registerHandler(Upnp_EventType et, Upnp_FunPtr handler, void *cookie);
+
+ UpnpClient_Handle getclh()
+ {
+ return m_clh;
+ }
+
+ /** Translate integer error code (UPNP_E_XXX) to string */
+ static std::string errAsString(const std::string& who, int code);
+};
+
+#endif /* _LIBUPNP.H_X_INCLUDED_ */