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

UPnP database plugin

Browse Source 
[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
Download Patch File Download Diff File Expand all files Collapse all files

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