diff options
Diffstat (limited to 'src/db/UpnpDatabasePlugin.cxx')
-rw-r--r-- | src/db/UpnpDatabasePlugin.cxx | 860 |
1 files changed, 860 insertions, 0 deletions
diff --git a/src/db/UpnpDatabasePlugin.cxx b/src/db/UpnpDatabasePlugin.cxx new file mode 100644 index 000000000..68a24cb4f --- /dev/null +++ b/src/db/UpnpDatabasePlugin.cxx @@ -0,0 +1,860 @@ +/* + * 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 "upnp/Util.hxx" +#include "LazyDatabase.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"; + +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 } +}; + +class UpnpDatabase : public Database { + LibUPnP *m_lib; + UPnPDeviceDirectory *m_superdir; + Directory *m_root; + +public: + UpnpDatabase() + : m_lib(0), m_superdir(0), m_root(0) + {} + + static Database *Create(EventLoop &loop, DatabaseListener &listener, + const config_param ¶m, + 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 ¶m, Error &error); + +private: + 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; +}; + +Database * +UpnpDatabase::Create(gcc_unused EventLoop &loop, + gcc_unused DatabaseListener &listener, + const config_param ¶m, Error &error) +{ + UpnpDatabase *db = new UpnpDatabase(); + if (!db->Configure(param, error)) { + delete db; + return nullptr; + } + + /* libupnp loses its ability to receive multicast messages + apparently due to daemonization; using the LazyDatabase + wrapper works around this problem */ + return new LazyDatabase(db); +} + +bool +UpnpDatabase::Configure(const config_param &, Error &) +{ + return true; +} + +bool +UpnpDatabase::Open(Error &error) +{ + if (m_root) + return true; + + m_lib = LibUPnP::getLibUPnP(error); + if (!m_lib) + return false; + + 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; +} + +// 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) +{ + if (*uri == 0) + uri = dirent.url.c_str(); + + Song *s = Song::NewFile(uri, nullptr); + + TagBuilder tag; + + if (dirent.duration > 0) + tag.SetTime(dirent.duration); + + tag.AddItem(TAG_TITLE, titleToPathElt(dirent.m_title).c_str()); + + for (auto i = upnp_tags; i->name != nullptr; ++i) { + const char *value = dirent.getprop(i->name); + if (value != nullptr) + tag.AddItem(i->type, value); + } + + 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 (!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; +} + +/** + * 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; + + const char *value = dirent.getprop(name); + if (value == nullptr) + return false; + + tagvalue = value; + 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.type == UPnPDirObject::Type::ITEM) { + // Target is a song. Not too sure we ever get there actually, maybe + // this is always catched by the special uri test above. + switch (tdirent.item_class) { + case UPnPDirObject::ItemClass::MUSIC: + if (visit_song) + return visitSong(tdirent, "", selection, visit_song, + error); + break; + + case UPnPDirObject::ItemClass::PLAYLIST: + if (visit_playlist) { + /* Note: I've yet to see a playlist + item (playlists seem to be usually + handled as containers, so I'll decide + what to do when I see one... */ + } + break; + + case UPnPDirObject::ItemClass::UNKNOWN: + break; + } + + 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) { + switch (dirent.item_class) { + case UPnPDirObject::ItemClass::MUSIC: + if (visit_song) { + /* 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; + } + + break; + + case UPnPDirObject::ItemClass::PLAYLIST: + if (visit_playlist) { + /* Note: I've yet to see a + playlist item (playlists + seem to be usually handled + as containers, so I'll + decide what to do when I + see one... */ + } + + break; + + case UPnPDirObject::ItemClass::UNKNOWN: + break; + } + } + } + + 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 +{ + 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 (!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, +}; |