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

db/upnp: move generic code to lib/upnp/

Browse Source
This commit is contained in:
Max Kellermann
2014-01-26 11:51:56 +01:00
parent 8b6b3ff28a
commit f86f5ad224
20 changed files with 118 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/db/plugins/UpnpDatabasePlugin.cxx
View File

@@ -19,13 +19,13 @@
#include "config.h"
#include "UpnpDatabasePlugin.hxx"
#include "upnp/Domain.hxx"
#include "upnp/upnpplib.hxx"
#include "upnp/Discovery.hxx"
#include "upnp/ContentDirectoryService.hxx"
#include "lib/upnp/Domain.hxx"
#include "lib/upnp/upnpplib.hxx"
#include "lib/upnp/Discovery.hxx"
#include "lib/upnp/ContentDirectoryService.hxx"
#include "lib/upnp/Util.hxx"
#include "upnp/Directory.hxx"
#include "upnp/Tags.hxx"
#include "upnp/Util.hxx"
#include "db/DatabasePlugin.hxx"
#include "db/Selection.hxx"
#include "db/DatabaseError.hxx"

56
src/db/plugins/upnp/Action.hxx
View File

@@ -1,56 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPD_UPNP_ACTION_HXX
#define MPD_UPNP_ACTION_HXX
#include "Compiler.h"
#include <upnp/upnptools.h>
static inline constexpr unsigned
CountNameValuePairs()
{
return 0;
}
template<typename... Args>
static inline constexpr unsigned
CountNameValuePairs(gcc_unused const char *name, gcc_unused const char *value,
Args... args)
{
return 1 + CountNameValuePairs(args...);
}
/**
* A wrapper for UpnpMakeAction() that counts the number of name/value
* pairs and adds the nullptr sentinel.
*/
template<typename... Args>
static inline IXML_Document *
MakeActionHelper(const char *action_name, const char *service_type,
Args... args)
{
const unsigned n = CountNameValuePairs(args...);
return UpnpMakeAction(action_name, service_type, n,
args...,
nullptr, nullptr);
}
#endif

77
src/db/plugins/upnp/ContentDirectoryService.cxx
View File

@@ -18,41 +18,16 @@
*/
#include "config.h"
#include "ContentDirectoryService.hxx"
#include "Domain.hxx"
#include "Device.hxx"
#include "ixmlwrap.hxx"
#include "lib/upnp/ContentDirectoryService.hxx"
#include "lib/upnp/Domain.hxx"
#include "lib/upnp/ixmlwrap.hxx"
#include "lib/upnp/Action.hxx"
#include "Directory.hxx"
#include "Util.hxx"
#include "Action.hxx"
#include "util/NumberParser.hxx"
#include "util/Error.hxx"
#include <string.h>
#include <stdio.h>
ContentDirectoryService::ContentDirectoryService(const UPnPDevice &device,
const UPnPService &service)
:m_actionURL(caturl(device.URLBase, service.controlURL)),
m_serviceType(service.serviceType),
m_deviceId(device.UDN),
m_friendlyName(device.friendlyName),
m_manufacturer(device.manufacturer),
m_modelName(device.modelName),
m_rdreqcnt(200)
{
if (!m_modelName.compare("MediaTomb")) {
// Readdir by 200 entries is good for most, but MediaTomb likes
// them really big. Actually 1000 is better but I don't dare
m_rdreqcnt = 500;
}
}
ContentDirectoryService::~ContentDirectoryService()
{
/* this destructor exists here just so it won't get inlined */
}
static bool
ReadResultTag(UPnPDirContent &dirbuf, IXML_Document *response, Error &error)
{
@@ -191,50 +166,6 @@ ContentDirectoryService::search(UpnpClient_Handle hdl,
return true;
}
bool
ContentDirectoryService::getSearchCapabilities(UpnpClient_Handle hdl,
std::list<std::string> &result,
Error &error) const
{
assert(result.empty());
IXML_Document *request =
UpnpMakeAction("GetSearchCapabilities", m_serviceType.c_str(),
0,
nullptr, nullptr);
if (request == 0) {
error.Set(upnp_domain, "UpnpMakeAction() failed");
return false;
}
IXML_Document *response;
auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
m_serviceType.c_str(),
0 /*devUDN*/, request, &response);
ixmlDocument_free(request);
if (code != UPNP_E_SUCCESS) {
error.Format(upnp_domain, code,
"UpnpSendAction() failed: %s",
UpnpGetErrorMessage(code));
return false;
}
const char *s = ixmlwrap::getFirstElementValue(response, "SearchCaps");
if (s == nullptr || *s == 0) {
ixmlDocument_free(response);
return true;
}
bool success = true;
if (!csvToStrings(s, result)) {
error.Set(upnp_domain, "Bad response");
success = false;
}
ixmlDocument_free(response);
return success;
}
bool
ContentDirectoryService::getMetadata(UpnpClient_Handle hdl,
const char *objectId,

128
src/db/plugins/upnp/ContentDirectoryService.hxx
View File

@@ -1,128 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef _UPNPDIR_HXX_INCLUDED_
#define _UPNPDIR_HXX_INCLUDED_
#include <upnp/upnp.h>
#include <string>
#include <list>
class Error;
class UPnPDevice;
struct UPnPService;
class UPnPDirContent;
/**
* Content Directory Service class.
*
* This stores identity data from a directory service
* and the device it belongs to, and has methods to query
* the directory, using libupnp for handling the UPnP protocols.
*
* Note: m_rdreqcnt: number of entries requested per directory read.
* 0 means all entries. The device can still return less entries than
* requested, depending on its own limits. In general it's not optimal
* becauses it triggers issues, and is sometimes actually slower, e.g. on
* a D-Link NAS 327
*
* The value chosen may affect by the UpnpSetMaxContentLength
* (2000*1024) done during initialization, but this should be ample
*/
class ContentDirectoryService {
std::string m_actionURL;
std::string m_serviceType;
std::string m_deviceId;
std::string m_friendlyName;
std::string m_manufacturer;
std::string m_modelName;
int m_rdreqcnt; // Slice size to use when reading
public:
/**
* Construct by copying data from device and service objects.
*
* The discovery service does this: use getDirServices()
*/
ContentDirectoryService(const UPnPDevice &device,
const UPnPService &service);
/** An empty one */
ContentDirectoryService() = default;
~ContentDirectoryService();
/** Read a container's children list into dirbuf.
*
* @param objectId the UPnP object Id for the container. Root has Id "0"
* @param[out] dirbuf stores the entries we read.
*/
bool readDir(UpnpClient_Handle handle,
const char *objectId, UPnPDirContent &dirbuf,
Error &error) const;
bool readDirSlice(UpnpClient_Handle handle,
const char *objectId, unsigned offset,
unsigned count, UPnPDirContent& dirbuf,
unsigned &didread, unsigned &total,
Error &error) const;
/** Search the content directory service.
*
* @param objectId the UPnP object Id under which the search
* should be done. Not all servers actually support this below
* root. Root has Id "0"
* @param searchstring an UPnP searchcriteria string. Check the
* UPnP document: UPnP-av-ContentDirectory-v1-Service-20020625.pdf
* section 2.5.5. Maybe we'll provide an easier way some day...
* @param[out] dirbuf stores the entries we read.
*/
bool search(UpnpClient_Handle handle,
const char *objectId, const char *searchstring,
UPnPDirContent &dirbuf,
Error &error) const;
/** Read metadata for a given node.
*
* @param objectId the UPnP object Id. Root has Id "0"
* @param[out] dirbuf stores the entries we read. At most one entry will be
* returned.
*/
bool getMetadata(UpnpClient_Handle handle,
const char *objectId, UPnPDirContent &dirbuf,
Error &error) const;
/** Retrieve search capabilities
*
* @param[out] result an empty vector: no search, or a single '*' element:
* any tag can be used in a search, or a list of usable tag names.
*/
bool getSearchCapabilities(UpnpClient_Handle handle,
std::list<std::string> &result,
Error &error) const;
/** Retrieve the "friendly name" for this server, useful for display. */
const char *getFriendlyName() const {
return m_friendlyName.c_str();
}
};
#endif /* _UPNPDIR_HXX_INCLUDED_ */

134
src/db/plugins/upnp/Device.cxx
View File

@@ -1,134 +0,0 @@
/*
* 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 "lib/expat/ExpatParser.hxx"
#include "util/Error.hxx"
#include <stdlib.h>
#include <string.h>
UPnPDevice::~UPnPDevice()
{
/* this destructor exists here just so it won't get inlined */
}
/**
* An XML parser which constructs an UPnP device object from the
* device descriptor.
*/
class UPnPDeviceParser final : public CommonExpatParser {
UPnPDevice &m_device;
std::string *value;
UPnPService m_tservice;
public:
UPnPDeviceParser(UPnPDevice& device)
:m_device(device),
value(nullptr) {}
protected:
virtual void StartElement(const XML_Char *name, const XML_Char **) {
value = nullptr;
switch (name[0]) {
case 'c':
if (strcmp(name, "controlURL") == 0)
value = &m_tservice.controlURL;
break;
case 'd':
if (strcmp(name, "deviceType") == 0)
value = &m_device.deviceType;
break;
case 'f':
if (strcmp(name, "friendlyName") == 0)
value = &m_device.friendlyName;
break;
case 'm':
if (strcmp(name, "manufacturer") == 0)
value = &m_device.manufacturer;
else if (strcmp(name, "modelName") == 0)
value = &m_device.modelName;
break;
case 's':
if (strcmp(name, "serviceType") == 0)
value = &m_tservice.serviceType;
break;
case 'U':
if (strcmp(name, "UDN") == 0)
value = &m_device.UDN;
else if (strcmp(name, "URLBase") == 0)
value = &m_device.URLBase;
break;
}
}
virtual void EndElement(const XML_Char *name) {
if (value != nullptr) {
trimstring(*value);
value = nullptr;
} else if (!strcmp(name, "service")) {
m_device.services.emplace_back(std::move(m_tservice));
m_tservice.clear();
}
}
virtual void CharacterData(const XML_Char *s, int len) {
if (value != nullptr)
value->append(s, len);
}
};
bool
UPnPDevice::Parse(const std::string &url, const char *description,
Error &error)
{
{
UPnPDeviceParser mparser(*this);
if (!mparser.Parse(description, strlen(description),
true, error))
return false;
}
if (URLBase.empty()) {
// The standard says that if the URLBase value is empty, we should use
// the url the description was retrieved from. However this is
// sometimes something like http://host/desc.xml, sometimes something
// like http://host/
if (url.size() < 8) {
// ???
URLBase = url;
} else {
auto hostslash = url.find_first_of("/", 7);
if (hostslash == std::string::npos || hostslash == url.size()-1) {
URLBase = url;
} else {
URLBase = path_getfather(url);
}
}
}
return true;
}

88
src/db/plugins/upnp/Device.hxx
View File

@@ -1,88 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef _UPNPDEV_HXX_INCLUDED_
#define _UPNPDEV_HXX_INCLUDED_
#include <vector>
#include <string>
class Error;
/**
* UPnP Description phase: interpreting the device description which we
* downloaded from the URL obtained by the discovery phase.
*/
/**
* Data holder for a UPnP service, parsed from the XML description
* downloaded after discovery yielded its URL.
*/
struct UPnPService {
// e.g. urn:schemas-upnp-org:service:ConnectionManager:1
std::string serviceType;
std::string controlURL; // e.g.: /upnp/control/cm
void clear()
{
serviceType.clear();
controlURL.clear();
}
};
/**
* Data holder for a UPnP device, parsed from the XML description obtained
* during discovery.
* A device may include several services. To be of interest to us,
* one of them must be a ContentDirectory.
*/
class UPnPDevice {
public:
// e.g. urn:schemas-upnp-org:device:MediaServer:1
std::string deviceType;
// e.g. MediaTomb
std::string friendlyName;
// Unique device number. This should match the deviceID in the
// discovery message. e.g. uuid:a7bdcd12-e6c1-4c7e-b588-3bbc959eda8d
std::string UDN;
// Base for all relative URLs. e.g. http://192.168.4.4:49152/
std::string URLBase;
// Manufacturer: e.g. D-Link, PacketVideo ("manufacturer")
std::string manufacturer;
// Model name: e.g. MediaTomb, DNS-327L ("modelName")
std::string modelName;
// Services provided by this device.
std::vector<UPnPService> services;
UPnPDevice() = default;
UPnPDevice(const UPnPDevice &) = delete;
UPnPDevice(UPnPDevice &&) = default;
UPnPDevice &operator=(UPnPDevice &&) = default;
~UPnPDevice();
/** Build device from xml description downloaded from discovery
* @param url where the description came from
* @param description the xml device description
*/
bool Parse(const std::string &url, const char *description,
Error &error);
};
#endif /* _UPNPDEV_HXX_INCLUDED_ */

2
src/db/plugins/upnp/Directory.cxx
View File

@@ -19,7 +19,7 @@
#include "config.h"
#include "Directory.hxx"
#include "Util.hxx"
#include "lib/upnp/Util.hxx"
#include "lib/expat/ExpatParser.hxx"
#include "Tags.hxx"
#include "tag/TagBuilder.hxx"

318
src/db/plugins/upnp/Discovery.cxx
View File

@@ -1,318 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include "Discovery.hxx"
#include "Domain.hxx"
#include "ContentDirectoryService.hxx"
#include "upnpplib.hxx"
#include "system/Clock.hxx"
#include "Log.hxx"
#include <upnp/upnptools.h>
#include <string.h>
// The service type string we are looking for.
static constexpr char ContentDirectorySType[] = "urn:schemas-upnp-org:service:ContentDirectory:1";
// We don't include a version in comparisons, as we are satisfied with
// version 1
gcc_pure
static bool
isCDService(const char *st)
{
constexpr size_t sz = sizeof(ContentDirectorySType) - 3;
return memcmp(ContentDirectorySType, st, sz) == 0;
}
// The type of device we're asking for in search
static constexpr char MediaServerDType[] = "urn:schemas-upnp-org:device:MediaServer:1";
gcc_pure
static bool
isMSDevice(const char *st)
{
constexpr size_t sz = sizeof(MediaServerDType) - 3;
return memcmp(MediaServerDType, st, sz) == 0;
}
inline void
UPnPDeviceDirectory::LockAdd(ContentDirectoryDescriptor &&d)
{
const ScopeLock protect(mutex);
for (auto &i : directories) {
if (i.id == d.id) {
i = std::move(d);
return;
}
}
directories.emplace_back(std::move(d));
}
inline void
UPnPDeviceDirectory::LockRemove(const std::string &id)
{
const ScopeLock protect(mutex);
for (auto i = directories.begin(), end = directories.end();
i != end; ++i) {
if (i->id == id) {
directories.erase(i);
break;
}
}
}
inline void
UPnPDeviceDirectory::discoExplorer()
{
for (;;) {
DiscoveredTask *tsk = 0;
if (!discoveredQueue.take(tsk)) {
discoveredQueue.workerExit();
return;
}
// Device signals its existence and well-being. Perform the
// UPnP "description" phase by downloading and decoding the
// description document.
char *buf;
// LINE_SIZE is defined by libupnp's upnp.h...
char contentType[LINE_SIZE];
int code = UpnpDownloadUrlItem(tsk->url.c_str(), &buf, contentType);
if (code != UPNP_E_SUCCESS) {
continue;
}
// Update or insert the device
ContentDirectoryDescriptor d(std::move(tsk->deviceId),
MonotonicClockS(), tsk->expires);
{
Error error2;
bool success = d.Parse(tsk->url, buf, error2);
free(buf);
if (!success) {
delete tsk;
LogError(error2);
continue;
}
}
LockAdd(std::move(d));
delete tsk;
}
}
void *
UPnPDeviceDirectory::discoExplorer(void *ctx)
{
UPnPDeviceDirectory &directory = *(UPnPDeviceDirectory *)ctx;
directory.discoExplorer();
return (void*)1;
}
inline int
UPnPDeviceDirectory::OnAlive(Upnp_Discovery *disco)
{
if (isMSDevice(disco->DeviceType) ||
isCDService(disco->ServiceType)) {
DiscoveredTask *tp = new DiscoveredTask(disco);
if (discoveredQueue.put(tp))
return UPNP_E_FINISH;
}
return UPNP_E_SUCCESS;
}
inline int
UPnPDeviceDirectory::OnByeBye(Upnp_Discovery *disco)
{
if (isMSDevice(disco->DeviceType) ||
isCDService(disco->ServiceType)) {
// Device signals it is going off.
LockRemove(disco->DeviceId);
}
return UPNP_E_SUCCESS;
}
// This gets called for all libupnp asynchronous events, in a libupnp
// thread context.
// Example: ContentDirectories appearing and disappearing from the network
// We queue a task for our worker thread(s)
inline int
UPnPDeviceDirectory::cluCallBack(Upnp_EventType et, void *evp)
{
switch (et) {
case UPNP_DISCOVERY_SEARCH_RESULT:
case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
{
Upnp_Discovery *disco = (Upnp_Discovery *)evp;
return OnAlive(disco);
}
case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
{
Upnp_Discovery *disco = (Upnp_Discovery *)evp;
return OnByeBye(disco);
}
default:
// Ignore other events for now
break;
}
return UPNP_E_SUCCESS;
}
bool
UPnPDeviceDirectory::expireDevices(Error &error)
{
const ScopeLock protect(mutex);
const unsigned now = MonotonicClockS();
bool didsomething = false;
for (auto it = directories.begin();
it != directories.end();) {
if (now > it->expires) {
it = directories.erase(it);
didsomething = true;
} else {
it++;
}
}
if (didsomething)
return search(error);
return true;
}
UPnPDeviceDirectory::UPnPDeviceDirectory(LibUPnP *_lib)
:lib(_lib),
discoveredQueue("DiscoveredQueue"),
m_searchTimeout(2), m_lastSearch(0)
{
}
UPnPDeviceDirectory::~UPnPDeviceDirectory()
{
/* this destructor exists here just so it won't get inlined */
}
bool
UPnPDeviceDirectory::Start(Error &error)
{
if (!discoveredQueue.start(1, discoExplorer, this)) {
error.Set(upnp_domain, "Discover work queue start failed");
return false;
}
lib->SetHandler([this](Upnp_EventType type, void *event){
cluCallBack(type, event);
});
return search(error);
}
bool
UPnPDeviceDirectory::search(Error &error)
{
const unsigned now = MonotonicClockS();
if (now - m_lastSearch < 10)
return true;
m_lastSearch = now;
// We search both for device and service just in case.
int code = UpnpSearchAsync(lib->getclh(), m_searchTimeout,
ContentDirectorySType, lib);
if (code != UPNP_E_SUCCESS) {
error.Format(upnp_domain, code,
"UpnpSearchAsync() failed: %s",
UpnpGetErrorMessage(code));
return false;
}
code = UpnpSearchAsync(lib->getclh(), m_searchTimeout,
MediaServerDType, lib);
if (code != UPNP_E_SUCCESS) {
error.Format(upnp_domain, code,
"UpnpSearchAsync() failed: %s",
UpnpGetErrorMessage(code));
return false;
}
return true;
}
bool
UPnPDeviceDirectory::getDirServices(std::vector<ContentDirectoryService> &out,
Error &error)
{
// Has locking, do it before our own lock
if (!expireDevices(error))
return false;
const ScopeLock protect(mutex);
for (auto dit = directories.begin();
dit != directories.end(); dit++) {
for (const auto &service : dit->device.services) {
if (isCDService(service.serviceType.c_str())) {
out.emplace_back(dit->device, service);
}
}
}
return true;
}
bool
UPnPDeviceDirectory::getServer(const char *friendlyName,
ContentDirectoryService &server,
Error &error)
{
// Has locking, do it before our own lock
if (!expireDevices(error))
return false;
const ScopeLock protect(mutex);
for (const auto &i : directories) {
const auto &device = i.device;
if (device.friendlyName != friendlyName)
continue;
for (const auto &service : device.services) {
if (isCDService(service.serviceType.c_str())) {
server = ContentDirectoryService(device,
service);
return true;
}
}
}
error.Set(upnp_domain, "Server not found");
return false;
}

152
src/db/plugins/upnp/Discovery.hxx
View File

@@ -1,152 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef _UPNPPDISC_H_X_INCLUDED_
#define _UPNPPDISC_H_X_INCLUDED_
#include "Device.hxx"
#include "WorkQueue.hxx"
#include "thread/Mutex.hxx"
#include "util/Error.hxx"
#include <upnp/upnp.h>
#include <list>
#include <vector>
#include <string>
class LibUPnP;
class ContentDirectoryService;
/**
* Manage UPnP discovery and maintain a directory of active devices. Singleton.
*
* We are only interested in MediaServers with a ContentDirectory service
* for now, but this could be made more general, by removing the filtering.
*/
class UPnPDeviceDirectory {
/**
* Each appropriate discovery event (executing in a libupnp thread
* context) queues the following task object for processing by the
* discovery thread.
*/
struct DiscoveredTask {
std::string url;
std::string deviceId;
unsigned expires; // Seconds valid
DiscoveredTask(const Upnp_Discovery *disco)
:url(disco->Location),
deviceId(disco->DeviceId),
expires(disco->Expires) {}
};
/**
* Descriptor for one device having a Content Directory
* service found on the network.
*/
class ContentDirectoryDescriptor {
public:
std::string id;
UPnPDevice device;
/**
* The MonotonicClockS() time stamp when this device
* expires.
*/
unsigned expires;
ContentDirectoryDescriptor() = default;
ContentDirectoryDescriptor(std::string &&_id,
unsigned last, int exp)
:id(std::move(_id)), expires(last + exp + 20) {}
bool Parse(const std::string &url, const char *description,
Error &_error) {
return device.Parse(url, description, _error);
}
};
LibUPnP *const lib;
Mutex mutex;
std::list<ContentDirectoryDescriptor> directories;
WorkQueue<DiscoveredTask *> discoveredQueue;
/**
* The UPnP device search timeout, which should actually be
* called delay because it's the base of a random delay that
* the devices apply to avoid responding all at the same time.
*/
int m_searchTimeout;
/**
* The MonotonicClockS() time stamp of the last search.
*/
unsigned m_lastSearch;
public:
UPnPDeviceDirectory(LibUPnP *_lib);
~UPnPDeviceDirectory();
UPnPDeviceDirectory(const UPnPDeviceDirectory &) = delete;
UPnPDeviceDirectory& operator=(const UPnPDeviceDirectory &) = delete;
bool Start(Error &error);
/** Retrieve the directory services currently seen on the network */
bool getDirServices(std::vector<ContentDirectoryService> &, Error &);
/**
* Get server by friendly name.
*/
bool getServer(const char *friendlyName,
ContentDirectoryService &server,
Error &error);
private:
bool search(Error &error);
/**
* Look at the devices and get rid of those which have not
* been seen for too long. We do this when listing the top
* directory.
*/
bool expireDevices(Error &error);
void LockAdd(ContentDirectoryDescriptor &&d);
void LockRemove(const std::string &id);
/**
* Worker routine for the discovery queue. Get messages about
* devices appearing and disappearing, and update the
* directory pool accordingly.
*/
static void *discoExplorer(void *);
void discoExplorer();
int OnAlive(Upnp_Discovery *disco);
int OnByeBye(Upnp_Discovery *disco);
int cluCallBack(Upnp_EventType et, void *evp);
};
#endif /* _UPNPPDISC_H_X_INCLUDED_ */

23
src/db/plugins/upnp/Domain.cxx
View File

@@ -1,23 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "Domain.hxx"
#include "util/Domain.hxx"
const Domain upnp_domain("upnp");

27
src/db/plugins/upnp/Domain.hxx
View File

@@ -1,27 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPD_UPNP_DOMAIN_HXX
#define MPD_UPNP_DOMAIN_HXX
class Domain;
extern const Domain upnp_domain;
#endif

166
src/db/plugins/upnp/Util.cxx
View File

@@ -1,166 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "Util.hxx"
#include <upnp/ixml.h>
#include <assert.h>
/** Get rid of white space at both ends */
void
trimstring(std::string &s, const char *ws)
{
auto pos = s.find_first_not_of(ws);
if (pos == std::string::npos) {
s.clear();
return;
}
s.replace(0, pos, std::string());
pos = s.find_last_not_of(ws);
if (pos != std::string::npos && pos != s.length()-1)
s.replace(pos + 1, std::string::npos, std::string());
}
std::string
caturl(const std::string &s1, const std::string &s2)
{
if (s2.front() == '/') {
/* absolute path: replace the whole URI path in s1 */
auto i = s1.find("://");
if (i == s1.npos)
/* no scheme: override s1 completely */
return s2;
/* find the first slash after the host part */
i = s1.find('/', i + 3);
if (i == s1.npos)
/* there's no URI path - simply append s2 */
i = s1.length();
return s1.substr(0, i) + s2;
}
std::string out(s1);
if (out.back() != '/')
out.push_back('/');
out += s2;
return out;
}
static void
path_catslash(std::string &s)
{
if (s.empty() || s.back() != '/')
s += '/';
}
std::string
path_getfather(const std::string &s)
{
std::string father = s;
// ??
if (father.empty())
return "./";
if (father.back() == '/') {
// Input ends with /. Strip it, handle special case for root
if (father.length() == 1)
return father;
father.erase(father.length()-1);
}
auto slp = father.rfind('/');
if (slp == std::string::npos)
return "./";
father.erase(slp);
path_catslash(father);
return father;
}
std::list<std::string>
stringToTokens(const std::string &str,
const char *delims, bool skipinit)
{
std::list<std::string> tokens;
std::string::size_type startPos = 0;
// Skip initial delims, return empty if this eats all.
if (skipinit &&
(startPos = str.find_first_not_of(delims, 0)) == std::string::npos)
return tokens;
while (startPos < str.size()) {
// Find next delimiter or end of string (end of token)
auto pos = str.find_first_of(delims, startPos);
// Add token to the vector and adjust start
if (pos == std::string::npos) {
tokens.emplace_back(str, startPos);
break;
} else if (pos == startPos) {
// Dont' push empty tokens after first
if (tokens.empty())
tokens.emplace_back();
startPos = ++pos;
} else {
tokens.emplace_back(str, startPos, pos - startPos);
startPos = ++pos;
}
}
return tokens;
}
template <class T>
bool
csvToStrings(const char *s, T &tokens)
{
assert(tokens.empty());
std::string current;
while (true) {
char ch = *s++;
if (ch == 0) {
tokens.emplace_back(std::move(current));
return true;
}
if (ch == '\\') {
ch = *s++;
if (ch == 0)
return false;
} else if (ch == ',') {
tokens.emplace_back(std::move(current));
current.clear();
continue;
}
current.push_back(ch);
}
}
template bool csvToStrings<std::list<std::string>>(const char *, std::list<std::string> &);

46
src/db/plugins/upnp/Util.hxx
View File

@@ -1,46 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPD_UPNP_UTIL_HXX
#define MPD_UPNP_UTIL_HXX
#include "Compiler.h"
#include <string>
#include <list>
std::string
caturl(const std::string& s1, const std::string& s2);
void
trimstring(std::string &s, const char *ws = " \t\n");
std::string
path_getfather(const std::string &s);
gcc_pure
std::list<std::string>
stringToTokens(const std::string &str,
const char *delims = "/", bool skipinit = true);
template <class T>
bool
csvToStrings(const char *s, T &tokens);
#endif /* _UPNPP_H_X_INCLUDED_ */

206
src/db/plugins/upnp/WorkQueue.hxx
View File

@@ -1,206 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef _WORKQUEUE_H_INCLUDED_
#define _WORKQUEUE_H_INCLUDED_
#include "thread/Mutex.hxx"
#include "thread/Cond.hxx"
#include <assert.h>
#include <pthread.h>
#include <string>
#include <queue>
#define LOGINFO(X)
#define LOGERR(X)
/**
* A WorkQueue manages the synchronisation around a queue of work items,
* where a number of client threads queue tasks and a number of worker
* threads take and execute them. The goal is to introduce some level
* of parallelism between the successive steps of a previously single
* threaded pipeline. For example data extraction / data preparation / index
* update, but this could have other uses.
*
* There is no individual task status return. In case of fatal error,
* the client or worker sets an end condition on the queue. A second
* queue could conceivably be used for returning individual task
* status.
*/
template <class T>
class WorkQueue {
// Configuration
const std::string name;
// Status
// Worker threads having called exit
unsigned n_workers_exited;
bool ok;
unsigned n_threads;
pthread_t *threads;
// Synchronization
std::queue<T> queue;
Cond client_cond;
Cond worker_cond;
Mutex mutex;
public:
/** Create a WorkQueue
* @param name for message printing
* @param hi number of tasks on queue before clients blocks. Default 0
* meaning no limit. hi == -1 means that the queue is disabled.
* @param lo minimum count of tasks before worker starts. Default 1.
*/
WorkQueue(const char *_name)
:name(_name),
n_workers_exited(0),
ok(false),
n_threads(0), threads(nullptr)
{
}
~WorkQueue() {
setTerminateAndWait();
}
/** Start the worker threads.
*
* @param nworkers number of threads copies to start.
* @param start_routine thread function. It should loop
* taking (QueueWorker::take()) and executing tasks.
* @param arg initial parameter to thread function.
* @return true if ok.
*/
bool start(unsigned nworkers, void *(*workproc)(void *), void *arg)
{
const ScopeLock protect(mutex);
assert(nworkers > 0);
assert(!ok);
assert(n_threads == 0);
assert(threads == nullptr);
n_threads = nworkers;
threads = new pthread_t[n_threads];
for (unsigned i = 0; i < nworkers; i++) {
int err;
if ((err = pthread_create(&threads[i], 0, workproc, arg))) {
LOGERR(("WorkQueue:%s: pthread_create failed, err %d\n",
name.c_str(), err));
return false;
}
}
ok = true;
return true;
}
/** Add item to work queue, called from client.
*
* Sleeps if there are already too many.
*/
template<typename U>
bool put(U &&u)
{
const ScopeLock protect(mutex);
queue.emplace(std::forward<U>(u));
// Just wake one worker, there is only one new task.
worker_cond.signal();
return true;
}
/** Tell the workers to exit, and wait for them.
*/
void setTerminateAndWait()
{
const ScopeLock protect(mutex);
// Wait for all worker threads to have called workerExit()
ok = false;
while (n_workers_exited < n_threads) {
worker_cond.broadcast();
client_cond.wait(mutex);
}
// Perform the thread joins and compute overall status
// Workers return (void*)1 if ok
for (unsigned i = 0; i < n_threads; ++i) {
void *status;
pthread_join(threads[i], &status);
}
delete[] threads;
threads = nullptr;
n_threads = 0;
// Reset to start state.
n_workers_exited = 0;
}
/** Take task from queue. Called from worker.
*
* Sleeps if there are not enough. Signal if we go to sleep on empty
* queue: client may be waiting for our going idle.
*/
bool take(T &tp)
{
const ScopeLock protect(mutex);
if (!ok)
return false;
while (queue.empty()) {
worker_cond.wait(mutex);
if (!ok)
return false;
}
tp = std::move(queue.front());
queue.pop();
return true;
}
/** Advertise exit and abort queue. Called from worker
*
* This would happen after an unrecoverable error, or when
* the queue is terminated by the client. Workers never exit normally,
* except when the queue is shut down (at which point ok is set to
* false by the shutdown code anyway). The thread must return/exit
* immediately after calling this.
*/
void workerExit()
{
const ScopeLock protect(mutex);
n_workers_exited++;
ok = false;
client_cond.broadcast();
}
};
#endif /* _WORKQUEUE_H_INCLUDED_ */

44
src/db/plugins/upnp/ixmlwrap.cxx
View File

@@ -1,44 +0,0 @@
/* Copyright (C) 2013 J.F.Dockes
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "ixmlwrap.hxx"
namespace ixmlwrap {
const char *
getFirstElementValue(IXML_Document *doc, const char *name)
{
const char *ret = nullptr;
IXML_NodeList *nodes =
ixmlDocument_getElementsByTagName(doc, name);
if (nodes) {
IXML_Node *first = ixmlNodeList_item(nodes, 0);
if (first) {
IXML_Node *dnode = ixmlNode_getFirstChild(first);
if (dnode) {
ret = ixmlNode_getNodeValue(dnode);
}
}
ixmlNodeList_free(nodes);
}
return ret;
}
}

35
src/db/plugins/upnp/ixmlwrap.hxx
View File

@@ -1,35 +0,0 @@
/* Copyright (C) 2013 J.F.Dockes
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef _IXMLWRAP_H_INCLUDED_
#define _IXMLWRAP_H_INCLUDED_
#include <upnp/ixml.h>
#include <string>
namespace ixmlwrap {
/**
* Retrieve the text content for the first element of given
* name. Returns nullptr if the element does not
* contain a text node
*/
const char *getFirstElementValue(IXML_Document *doc,
const char *name);
};
#endif /* _IXMLWRAP_H_INCLUDED_ */

75
src/db/plugins/upnp/upnpplib.cxx
View File

@@ -1,75 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include "upnpplib.hxx"
#include "Domain.hxx"
#include "Log.hxx"
#include <upnp/ixml.h>
#include <upnp/upnptools.h>
static LibUPnP *theLib;
LibUPnP::LibUPnP()
{
auto code = UpnpInit(0, 0);
if (code != UPNP_E_SUCCESS) {
init_error.Format(upnp_domain, code,
"UpnpInit() failed: %s",
UpnpGetErrorMessage(code));
return;
}
UpnpSetMaxContentLength(2000*1024);
code = UpnpRegisterClient(o_callback, (void *)this, &m_clh);
if (code != UPNP_E_SUCCESS) {
init_error.Format(upnp_domain, code,
"UpnpRegisterClient() failed: %s",
UpnpGetErrorMessage(code));
return;
}
// Servers sometimes make error (e.g.: minidlna returns bad utf-8)
ixmlRelaxParser(1);
}
int
LibUPnP::o_callback(Upnp_EventType et, void* evp, void* cookie)
{
LibUPnP *ulib = (LibUPnP *)cookie;
if (ulib == nullptr) {
// Because the asyncsearch calls uses a null cookie.
ulib = theLib;
}
if (ulib->handler)
ulib->handler(et, evp);
return UPNP_E_SUCCESS;
}
LibUPnP::~LibUPnP()
{
int error = UpnpFinish();
if (error != UPNP_E_SUCCESS)
FormatError(upnp_domain, "UpnpFinish() failed: %s",
UpnpGetErrorMessage(error));
}

70
src/db/plugins/upnp/upnpplib.hxx
View File

@@ -1,70 +0,0 @@
/*
* Copyright (C) 2003-2014 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef _LIBUPNP_H_X_INCLUDED_
#define _LIBUPNP_H_X_INCLUDED_
#include "util/Error.hxx"
#include <upnp/upnp.h>
#include <functional>
/** Our link to libupnp. Initialize and keep the handle around */
class LibUPnP {
typedef std::function<void(Upnp_EventType type, void *event)> Handler;
Error init_error;
UpnpClient_Handle m_clh;
Handler handler;
static int o_callback(Upnp_EventType, void *, void *);
public:
LibUPnP();
LibUPnP(const LibUPnP &) = delete;
LibUPnP &operator=(const LibUPnP &) = delete;
~LibUPnP();
/** Check state after initialization */
bool ok() const
{
return !init_error.IsDefined();
}
/** Retrieve init error if state not ok */
const Error &GetInitError() const {
return init_error;
}
template<typename T>
void SetHandler(T &&_handler) {
handler = std::forward<T>(_handler);
}
UpnpClient_Handle getclh()
{
return m_clh;
}
};
#endif /* _LIBUPNP.H_X_INCLUDED_ */