oysteikt
/
mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

UPnP database plugin 

[mk: renamed source files, applied coding style, reduced bloat, using
MPD's threading library, using MPD's error reporting and logging
library and refactoring, fixed lots of bugs]
This commit is contained in:
Jean-Francois Dockes 2013-11-01 19:26:01 +01:00 committed by Max Kellermann
parent 12b139beaf
commit 406452f019
25 changed files with 3292 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Makefile.am
View File

@ -407,6 +407,24 @@ DB_LIBS = \
libdb_plugins.a \
$(LIBMPDCLIENT_LIBS)
if HAVE_LIBUPNP
libdb_plugins_a_SOURCES += \
src/db/UpnpDatabasePlugin.cxx src/db/UpnpDatabasePlugin.hxx \
src/db/upnp/ContentDirectoryService.cxx src/db/upnp/ContentDirectoryService.hxx \
src/db/upnp/Device.cxx src/db/upnp/Device.hxx \
src/db/upnp/Directory.cxx src/db/upnp/Directory.hxx \
src/db/upnp/Discovery.cxx src/db/upnp/Discovery.hxx \
src/db/upnp/Domain.cxx src/db/upnp/Domain.hxx \
src/db/upnp/ixmlwrap.cxx src/db/upnp/ixmlwrap.hxx \
src/db/upnp/upnpplib.cxx src/db/upnp/upnpplib.hxx \
src/db/upnp/Util.cxx src/db/upnp/Util.hxx \
src/db/upnp/WorkQueue.hxx \
src/db/upnp/Object.hxx
DB_LIBS += \
$(EXPAT_LIBS) \
$(UPNP_LIBS)
endif
# archive plugins
if ENABLE_ARCHIVE
@ -1200,6 +1218,10 @@ test_DumpDatabase_SOURCES = test/DumpDatabase.cxx \
src/TagSave.cxx \
src/SongFilter.cxx
if HAVE_LIBUPNP
test_DumpDatabase_SOURCES += src/Expat.cxx
endif
test_run_input_LDADD = \
$(INPUT_LIBS) \
$(ARCHIVE_LIBS) \

2
NEWS
View File

@ -2,6 +2,8 @@ ver 0.19 (not yet released)
* protocol
- new commands "addtagid", "cleartagid"
- "lsinfo" and "readcomments" allowed for remote files
* database
- upnp: new plugin
* playlist
- soundcloud: use https instead of http
* archive

23
configure.ac
View File

@ -234,6 +234,11 @@ AC_ARG_ENABLE(expat,
[enable the expat XML parser]),,
enable_expat=auto)
AC_ARG_ENABLE(upnp,
AS_HELP_STRING([--enable-upnp],
[enable UPnP client support (default: auto)]),,
enable_upnp=auto)
AC_ARG_ENABLE(adplug,
AS_HELP_STRING([--enable-adplug],
[enable the AdPlug decoder plugin (default: auto)]),,
@ -900,6 +905,24 @@ fi
AM_CONDITIONAL(ENABLE_BZIP2_TEST, test x$BZIP2 != xno)
dnl ---------------------------------- libupnp ---------------------------------
if test x$enable_expat = xno; then
if test x$enable_upnp = xauto; then
AC_MSG_WARN([expat disabled -- disabling UPnP])
enable_upnp=no
elif test x$enable_upnp = xyes; then
AC_MSG_ERROR([expat disabled -- required for UPnP])
fi
fi
MPD_AUTO_PKG(upnp, UPNP, [libupnp],
[UPnP client support], [libupnp not found])
if test x$enable_upnp = xyes; then
AC_DEFINE(HAVE_LIBUPNP, 1, [Define when libupnp is used])
fi
AM_CONDITIONAL(HAVE_LIBUPNP, test x$enable_upnp = xyes)
dnl --------------------------------- libzzip ---------------------------------
MPD_AUTO_PKG(zzip, ZZIP, [zziplib >= 0.13],
[libzzip archive library], [libzzip not found])

4
src/DatabaseRegistry.cxx
View File

@ -21,6 +21,7 @@
#include "DatabaseRegistry.hxx"
#include "db/SimpleDatabasePlugin.hxx"
#include "db/ProxyDatabasePlugin.hxx"
#include "db/UpnpDatabasePlugin.hxx"
#include <string.h>
@ -28,6 +29,9 @@ const DatabasePlugin *const database_plugins[] = {
&simple_db_plugin,
#ifdef HAVE_LIBMPDCLIENT
&proxy_db_plugin,
#endif
#ifdef HAVE_LIBUPNP
&upnp_db_plugin,
#endif
nullptr
};

923
src/db/UpnpDatabasePlugin.cxx Normal file
View File

@ -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,
};

27
src/db/UpnpDatabasePlugin.hxx Normal file
View File

@ -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

316
src/db/upnp/ContentDirectoryService.cxx Normal file
View File

@ -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);
}

119
src/db/upnp/ContentDirectoryService.hxx Normal file
View File

@ -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_ */

140
src/db/upnp/Device.cxx Normal file
View File

@ -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;
}

92
src/db/upnp/Device.hxx Normal file
View File

@ -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_ */

177
src/db/upnp/Directory.cxx Normal file
View File

@ -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);
}

55
src/db/upnp/Directory.hxx Normal file
View File

@ -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_ */

326
src/db/upnp/Discovery.cxx Normal file
View File

@ -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;
}

90
src/db/upnp/Discovery.hxx Normal file
View File

@ -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_ */

23
src/db/upnp/Domain.cxx Normal file
View File

@ -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");

27
src/db/upnp/Domain.hxx Normal file
View File

@ -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

79
src/db/upnp/Object.hxx Normal file
View File

@ -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_ */

149
src/db/upnp/Util.cxx Normal file
View File

@ -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> &);

46
src/db/upnp/Util.hxx Normal file
View File

@ -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_ */

327
src/db/upnp/WorkQueue.hxx Normal file
View File

@ -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_ */

44
src/db/upnp/ixmlwrap.cxx Normal file
View File

@ -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;
}
}

35
src/db/upnp/ixmlwrap.hxx Normal file
View File

@ -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_ */

144
src/db/upnp/upnpplib.cxx Normal file
View File

@ -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));
}

93
src/db/upnp/upnpplib.hxx Normal file
View File

@ -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_ */

9
test/DumpDatabase.cxx
View File

@ -39,6 +39,15 @@ using std::endl;
#include <stdlib.h>
#ifdef HAVE_LIBUPNP
#include "InputStream.hxx"
size_t
InputStream::LockRead(void *, size_t, Error &)
{
return 0;
}
#endif
static bool
DumpDirectory(const Directory &directory, Error &)
{