aboutsummaryrefslogtreecommitdiffstats
path: root/src/db/upnp
diff options
context:
space:
mode:
Diffstat (limited to 'src/db/upnp')
-rw-r--r--src/db/upnp/ContentDirectoryService.cxx316
-rw-r--r--src/db/upnp/ContentDirectoryService.hxx119
-rw-r--r--src/db/upnp/Device.cxx134
-rw-r--r--src/db/upnp/Device.hxx92
-rw-r--r--src/db/upnp/Directory.cxx194
-rw-r--r--src/db/upnp/Directory.hxx64
-rw-r--r--src/db/upnp/Discovery.cxx329
-rw-r--r--src/db/upnp/Discovery.hxx90
-rw-r--r--src/db/upnp/Domain.cxx23
-rw-r--r--src/db/upnp/Domain.hxx27
-rw-r--r--src/db/upnp/Object.hxx83
-rw-r--r--src/db/upnp/Tags.cxx33
-rw-r--r--src/db/upnp/Tags.hxx28
-rw-r--r--src/db/upnp/Util.cxx184
-rw-r--r--src/db/upnp/Util.hxx45
-rw-r--r--src/db/upnp/WorkQueue.hxx203
-rw-r--r--src/db/upnp/ixmlwrap.cxx44
-rw-r--r--src/db/upnp/ixmlwrap.hxx35
-rw-r--r--src/db/upnp/upnpplib.cxx89
-rw-r--r--src/db/upnp/upnpplib.hxx73
20 files changed, 2205 insertions, 0 deletions
diff --git a/src/db/upnp/ContentDirectoryService.cxx b/src/db/upnp/ContentDirectoryService.cxx
new file mode 100644
index 000000000..b40f55c54
--- /dev/null
+++ b/src/db/upnp/ContentDirectoryService.cxx
@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "ContentDirectoryService.hxx"
+#include "Domain.hxx"
+#include "Device.hxx"
+#include "ixmlwrap.hxx"
+#include "Directory.hxx"
+#include "Util.hxx"
+#include "upnpplib.hxx"
+#include "util/Error.hxx"
+
+#include <stdio.h>
+
+#include <upnp/upnp.h>
+#include <upnp/upnptools.h>
+
+ContentDirectoryService::ContentDirectoryService(const UPnPDevice &device,
+ const UPnPService &service)
+ :m_actionURL(caturl(device.URLBase, service.controlURL)),
+ m_serviceType(service.serviceType),
+ m_deviceId(device.UDN),
+ m_friendlyName(device.friendlyName),
+ m_manufacturer(device.manufacturer),
+ m_modelName(device.modelName),
+ m_rdreqcnt(200)
+{
+ if (!m_modelName.compare("MediaTomb")) {
+ // Readdir by 200 entries is good for most, but MediaTomb likes
+ // them really big. Actually 1000 is better but I don't dare
+ m_rdreqcnt = 500;
+ }
+}
+
+class DirBResFree {
+public:
+ IXML_Document **rqpp, **rspp;
+ DirBResFree(IXML_Document** _rqpp, IXML_Document **_rspp)
+ :rqpp(_rqpp), rspp(_rspp) {}
+ ~DirBResFree()
+ {
+ if (*rqpp)
+ ixmlDocument_free(*rqpp);
+ if (*rspp)
+ ixmlDocument_free(*rspp);
+ }
+};
+
+bool
+ContentDirectoryService::readDirSlice(const char *objectId, int offset,
+ int count, UPnPDirContent &dirbuf,
+ int *didreadp, int *totalp,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *request(0);
+ IXML_Document *response(0);
+ DirBResFree cleaner(&request, &response);
+
+ // Create request
+ char ofbuf[100], cntbuf[100];
+ sprintf(ofbuf, "%d", offset);
+ sprintf(cntbuf, "%d", count);
+ int argcnt = 6;
+ // Some devices require an empty SortCriteria, else bad params
+ request = UpnpMakeAction("Browse", m_serviceType.c_str(), argcnt,
+ "ObjectID", objectId,
+ "BrowseFlag", "BrowseDirectChildren",
+ "Filter", "*",
+ "SortCriteria", "",
+ "StartingIndex", ofbuf,
+ "RequestedCount", cntbuf,
+ nullptr, nullptr);
+ if (request == nullptr) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ int code = UpnpSendAction(hdl, m_actionURL.c_str(), m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ int didread = -1;
+ std::string tbuf = ixmlwrap::getFirstElementValue(response, "NumberReturned");
+ if (!tbuf.empty())
+ didread = atoi(tbuf.c_str());
+
+ if (count == -1 || count == 0) {
+ // TODO: what's this?
+ error.Set(upnp_domain, "got -1 or 0 entries");
+ return false;
+ }
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "TotalMatches");
+ if (!tbuf.empty())
+ *totalp = atoi(tbuf.c_str());
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "Result");
+
+ if (!dirbuf.parse(tbuf, error))
+ return false;
+
+ *didreadp = didread;
+ return true;
+}
+
+bool
+ContentDirectoryService::readDir(const char *objectId,
+ UPnPDirContent &dirbuf,
+ Error &error)
+{
+ int offset = 0;
+ int total = 1000;// Updated on first read.
+
+ while (offset < total) {
+ int count;
+ if (!readDirSlice(objectId, offset, m_rdreqcnt, dirbuf,
+ &count, &total, error))
+ return false;
+
+ offset += count;
+ }
+
+ return true;
+}
+
+bool
+ContentDirectoryService::search(const char *objectId,
+ const char *ss,
+ UPnPDirContent &dirbuf,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *request(0);
+ IXML_Document *response(0);
+
+ int offset = 0;
+ int total = 1000;// Updated on first read.
+
+ while (offset < total) {
+ DirBResFree cleaner(&request, &response);
+ char ofbuf[100];
+ sprintf(ofbuf, "%d", offset);
+ // Create request
+ int argcnt = 6;
+ request = UpnpMakeAction("Search", m_serviceType.c_str(), argcnt,
+ "ContainerID", objectId,
+ "SearchCriteria", ss,
+ "Filter", "*",
+ "SortCriteria", "",
+ "StartingIndex", ofbuf,
+ "RequestedCount", "0", // Setting a value here gets twonky into fits
+ nullptr, nullptr);
+ if (request == 0) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+ m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ int count = -1;
+ std::string tbuf =
+ ixmlwrap::getFirstElementValue(response, "NumberReturned");
+ if (!tbuf.empty())
+ count = atoi(tbuf.c_str());
+
+ if (count == -1 || count == 0) {
+ // TODO: what's this?
+ error.Set(upnp_domain, "got -1 or 0 entries");
+ return false;
+ }
+
+ offset += count;
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "TotalMatches");
+ if (!tbuf.empty())
+ total = atoi(tbuf.c_str());
+
+ tbuf = ixmlwrap::getFirstElementValue(response, "Result");
+
+ if (!dirbuf.parse(tbuf, error))
+ return false;
+ }
+
+ return true;
+}
+
+bool
+ContentDirectoryService::getSearchCapabilities(std::set<std::string> &result,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *request(0);
+ IXML_Document *response(0);
+
+ request = UpnpMakeAction("GetSearchCapabilities", m_serviceType.c_str(),
+ 0,
+ nullptr, nullptr);
+ if (request == 0) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+ m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ std::string tbuf = ixmlwrap::getFirstElementValue(response, "SearchCaps");
+
+ result.clear();
+ if (!tbuf.compare("*")) {
+ result.insert(result.end(), "*");
+ } else if (!tbuf.empty()) {
+ if (!csvToStrings(tbuf, result)) {
+ error.Set(upnp_domain, "Bad response");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool
+ContentDirectoryService::getMetadata(const char *objectId,
+ UPnPDirContent &dirbuf,
+ Error &error)
+{
+ LibUPnP *lib = LibUPnP::getLibUPnP(error);
+ if (lib == nullptr)
+ return false;
+
+ UpnpClient_Handle hdl = lib->getclh();
+
+ IXML_Document *response(0);
+
+ // Create request
+ int argcnt = 6;
+ IXML_Document *request =
+ UpnpMakeAction("Browse", m_serviceType.c_str(), argcnt,
+ "ObjectID", objectId,
+ "BrowseFlag", "BrowseMetadata",
+ "Filter", "*",
+ "SortCriteria", "",
+ "StartingIndex", "0",
+ "RequestedCount", "1",
+ nullptr, nullptr);
+ DirBResFree cleaner(&request, &response);
+ if (request == nullptr) {
+ error.Set(upnp_domain, "UpnpMakeAction() failed");
+ return false;
+ }
+
+ auto code = UpnpSendAction(hdl, m_actionURL.c_str(),
+ m_serviceType.c_str(),
+ 0 /*devUDN*/, request, &response);
+ if (code != UPNP_E_SUCCESS) {
+ error.Format(upnp_domain, code,
+ "UpnpSendAction() failed: %s",
+ UpnpGetErrorMessage(code));
+ return false;
+ }
+
+ std::string tbuf = ixmlwrap::getFirstElementValue(response, "Result");
+ return dirbuf.parse(tbuf, error);
+}
diff --git a/src/db/upnp/ContentDirectoryService.hxx b/src/db/upnp/ContentDirectoryService.hxx
new file mode 100644
index 000000000..8fc28c382
--- /dev/null
+++ b/src/db/upnp/ContentDirectoryService.hxx
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef _UPNPDIR_HXX_INCLUDED_
+#define _UPNPDIR_HXX_INCLUDED_
+
+#include <string>
+#include <set>
+
+class Error;
+class UPnPDevice;
+struct UPnPService;
+class UPnPDirContent;
+
+/**
+ * Content Directory Service class.
+ *
+ * This stores identity data from a directory service
+ * and the device it belongs to, and has methods to query
+ * the directory, using libupnp for handling the UPnP protocols.
+ *
+ * Note: m_rdreqcnt: number of entries requested per directory read.
+ * 0 means all entries. The device can still return less entries than
+ * requested, depending on its own limits. In general it's not optimal
+ * becauses it triggers issues, and is sometimes actually slower, e.g. on
+ * a D-Link NAS 327
+ *
+ * The value chosen may affect by the UpnpSetMaxContentLength
+ * (2000*1024) done during initialization, but this should be ample
+ */
+class ContentDirectoryService {
+ std::string m_actionURL;
+ std::string m_serviceType;
+ std::string m_deviceId;
+ std::string m_friendlyName;
+ std::string m_manufacturer;
+ std::string m_modelName;
+
+ int m_rdreqcnt; // Slice size to use when reading
+
+public:
+ /**
+ * Construct by copying data from device and service objects.
+ *
+ * The discovery service does this: use getDirServices()
+ */
+ ContentDirectoryService(const UPnPDevice &device,
+ const UPnPService &service);
+
+ /** An empty one */
+ ContentDirectoryService() = default;
+
+ /** Read a container's children list into dirbuf.
+ *
+ * @param objectId the UPnP object Id for the container. Root has Id "0"
+ * @param[out] dirbuf stores the entries we read.
+ */
+ bool readDir(const char *objectId, UPnPDirContent &dirbuf,
+ Error &error);
+
+ bool readDirSlice(const char *objectId, int offset,
+ int count, UPnPDirContent& dirbuf,
+ int *didread, int *total,
+ Error &error);
+
+ /** Search the content directory service.
+ *
+ * @param objectId the UPnP object Id under which the search
+ * should be done. Not all servers actually support this below
+ * root. Root has Id "0"
+ * @param searchstring an UPnP searchcriteria string. Check the
+ * UPnP document: UPnP-av-ContentDirectory-v1-Service-20020625.pdf
+ * section 2.5.5. Maybe we'll provide an easier way some day...
+ * @param[out] dirbuf stores the entries we read.
+ */
+ bool search(const char *objectId, const char *searchstring,
+ UPnPDirContent &dirbuf,
+ Error &error);
+
+ /** Read metadata for a given node.
+ *
+ * @param objectId the UPnP object Id. Root has Id "0"
+ * @param[out] dirbuf stores the entries we read. At most one entry will be
+ * returned.
+ */
+ bool getMetadata(const char *objectId, UPnPDirContent &dirbuf,
+ Error &error);
+
+ /** Retrieve search capabilities
+ *
+ * @param[out] result an empty vector: no search, or a single '*' element:
+ * any tag can be used in a search, or a list of usable tag names.
+ */
+ bool getSearchCapabilities(std::set<std::string> &result,
+ Error &error);
+
+ /** Retrieve the "friendly name" for this server, useful for display. */
+ const char *getFriendlyName() const {
+ return m_friendlyName.c_str();
+ }
+};
+
+#endif /* _UPNPDIR_HXX_INCLUDED_ */
diff --git a/src/db/upnp/Device.cxx b/src/db/upnp/Device.cxx
new file mode 100644
index 000000000..37d68c232
--- /dev/null
+++ b/src/db/upnp/Device.cxx
@@ -0,0 +1,134 @@
+/*
+ * 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::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_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();
+ }
+
+ m_path.pop_back();
+ }
+
+ virtual void CharacterData(const XML_Char *s, int len) {
+ std::string str(s, len);
+ trimstring(str);
+ switch (m_path.back()[0]) {
+ case 'c':
+ if (!m_path.back().compare("controlURL"))
+ m_tservice.controlURL += str;
+ break;
+ case 'd':
+ if (!m_path.back().compare("deviceType"))
+ m_device.deviceType += str;
+ break;
+ case 'e':
+ if (!m_path.back().compare("eventSubURL"))
+ m_tservice.eventSubURL += str;
+ break;
+ case 'f':
+ if (!m_path.back().compare("friendlyName"))
+ m_device.friendlyName += str;
+ break;
+ case 'm':
+ if (!m_path.back().compare("manufacturer"))
+ m_device.manufacturer += str;
+ else if (!m_path.back().compare("modelName"))
+ m_device.modelName += str;
+ break;
+ case 's':
+ if (!m_path.back().compare("serviceType"))
+ m_tservice.serviceType = str;
+ else if (!m_path.back().compare("serviceId"))
+ m_tservice.serviceId += str;
+ case 'S':
+ if (!m_path.back().compare("SCPDURL"))
+ m_tservice.SCPDURL = str;
+ break;
+ case 'U':
+ if (!m_path.back().compare("UDN"))
+ m_device.UDN = str;
+ else if (!m_path.back().compare("URLBase"))
+ m_device.URLBase += str;
+ break;
+ }
+ }
+};
+
+UPnPDevice::UPnPDevice(const std::string &url, const std::string &description)
+ :ok(false)
+{
+ UPnPDeviceParser mparser(*this);
+ Error error;
+ if (!mparser.Parse(description.data(), description.length(), true,
+ error)) {
+ // TODO: pass Error to caller
+ LogError(error);
+ return;
+ }
+
+ if (URLBase.empty()) {
+ // The standard says that if the URLBase value is empty, we should use
+ // the url the description was retrieved from. However this is
+ // sometimes something like http://host/desc.xml, sometimes something
+ // like http://host/
+
+ if (url.size() < 8) {
+ // ???
+ URLBase = url;
+ } else {
+ auto hostslash = url.find_first_of("/", 7);
+ if (hostslash == std::string::npos || hostslash == url.size()-1) {
+ URLBase = url;
+ } else {
+ URLBase = path_getfather(url);
+ }
+ }
+ }
+ ok = true;
+}
diff --git a/src/db/upnp/Device.hxx b/src/db/upnp/Device.hxx
new file mode 100644
index 000000000..53e1c4964
--- /dev/null
+++ b/src/db/upnp/Device.hxx
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef _UPNPDEV_HXX_INCLUDED_
+#define _UPNPDEV_HXX_INCLUDED_
+
+#include <vector>
+#include <string>
+
+class Error;
+
+/**
+ * UPnP Description phase: interpreting the device description which we
+ * downloaded from the URL obtained by the discovery phase.
+ */
+
+/**
+ * Data holder for a UPnP service, parsed from the XML description
+ * downloaded after discovery yielded its URL.
+ */
+struct UPnPService {
+ // e.g. urn:schemas-upnp-org:service:ConnectionManager:1
+ std::string serviceType;
+ // Unique Id inside device: e.g here THE ConnectionManager
+ std::string serviceId; // e.g. urn:upnp-org:serviceId:ConnectionManager
+ std::string SCPDURL; // Service description URL. e.g.: cm.xml
+ std::string controlURL; // e.g.: /upnp/control/cm
+ std::string eventSubURL; // e.g.: /upnp/event/cm
+
+ void clear()
+ {
+ serviceType.clear();
+ serviceId.clear();
+ SCPDURL.clear();
+ controlURL.clear();
+ eventSubURL.clear();
+ }
+};
+
+/**
+ * Data holder for a UPnP device, parsed from the XML description obtained
+ * during discovery.
+ * A device may include several services. To be of interest to us,
+ * one of them must be a ContentDirectory.
+ */
+class UPnPDevice {
+public:
+ bool ok;
+ // e.g. urn:schemas-upnp-org:device:MediaServer:1
+ std::string deviceType;
+ // e.g. MediaTomb
+ std::string friendlyName;
+ // Unique device number. This should match the deviceID in the
+ // discovery message. e.g. uuid:a7bdcd12-e6c1-4c7e-b588-3bbc959eda8d
+ std::string UDN;
+ // Base for all relative URLs. e.g. http://192.168.4.4:49152/
+ std::string URLBase;
+ // Manufacturer: e.g. D-Link, PacketVideo ("manufacturer")
+ std::string manufacturer;
+ // Model name: e.g. MediaTomb, DNS-327L ("modelName")
+ std::string modelName;
+ // Services provided by this device.
+ std::vector<UPnPService> services;
+
+ /** Build device from xml description downloaded from discovery
+ * @param url where the description came from
+ * @param description the xml device description
+ */
+ UPnPDevice(const std::string &url, const std::string &description);
+
+ UPnPDevice() : ok(false) {}
+};
+
+typedef std::vector<UPnPService>::iterator DevServIt;
+
+#endif /* _UPNPDEV_HXX_INCLUDED_ */
diff --git a/src/db/upnp/Directory.cxx b/src/db/upnp/Directory.cxx
new file mode 100644
index 000000000..3b6428389
--- /dev/null
+++ b/src/db/upnp/Directory.cxx
@@ -0,0 +1,194 @@
+/*
+ * 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 "Tags.hxx"
+#include "tag/TagBuilder.hxx"
+#include "tag/TagTable.hxx"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include <string.h>
+
+gcc_pure
+static UPnPDirObject::ItemClass
+ParseItemClass(const char *name)
+{
+ if (strcmp(name, "object.item.audioItem.musicTrack") == 0)
+ return UPnPDirObject::ItemClass::MUSIC;
+ else if (strcmp(name, "object.item.playlistItem") == 0)
+ return UPnPDirObject::ItemClass::PLAYLIST;
+ else
+ return UPnPDirObject::ItemClass::UNKNOWN;
+}
+
+gcc_pure
+static int
+ParseDuration(const std::string &duration)
+{
+ const auto v = stringToTokens(duration, ":");
+ if (v.size() != 3)
+ return 0;
+ return atoi(v[0].c_str())*3600 + atoi(v[1].c_str())*60 + atoi(v[2].c_str());
+}
+
+/**
+ * Transform titles to turn '/' into '_' to make them acceptable path
+ * elements. There is a very slight risk of collision in doing
+ * this. Twonky returns directory names (titles) like 'Artist/Album'.
+ */
+gcc_pure
+static std::string
+titleToPathElt(std::string &&s)
+{
+ std::replace(s.begin(), s.end(), '/', '_');
+ return s;
+}
+
+/**
+ * An XML parser which builds directory contents from DIDL lite input.
+ */
+class UPnPDirParser final : public CommonExpatParser {
+ std::vector<std::string> m_path;
+ UPnPDirObject m_tobj;
+ TagBuilder tag;
+
+public:
+ UPnPDirParser(UPnPDirContent& dir)
+ :m_dir(dir)
+ {
+ }
+ UPnPDirContent& m_dir;
+
+protected:
+ virtual void StartElement(const XML_Char *name, const XML_Char **attrs)
+ {
+ m_path.push_back(name);
+
+ switch (name[0]) {
+ case 'c':
+ if (!strcmp(name, "container")) {
+ m_tobj.clear();
+ m_tobj.type = UPnPDirObject::Type::CONTAINER;
+
+ const char *id = GetAttribute(attrs, "id");
+ if (id != nullptr)
+ m_tobj.m_id = id;
+
+ const char *pid = GetAttribute(attrs, "parentID");
+ if (pid != nullptr)
+ m_tobj.m_pid = pid;
+ }
+ break;
+
+ case 'i':
+ if (!strcmp(name, "item")) {
+ m_tobj.clear();
+ m_tobj.type = UPnPDirObject::Type::ITEM;
+
+ const char *id = GetAttribute(attrs, "id");
+ if (id != nullptr)
+ m_tobj.m_id = id;
+
+ const char *pid = GetAttribute(attrs, "parentID");
+ if (pid != nullptr)
+ m_tobj.m_pid = pid;
+ }
+ break;
+
+ case 'r':
+ if (!strcmp(name, "res")) {
+ // <res protocolInfo="http-get:*:audio/mpeg:*" size="5171496"
+ // bitrate="24576" duration="00:03:35" sampleFrequency="44100"
+ // nrAudioChannels="2">
+
+ const char *duration =
+ GetAttribute(attrs, "duration");
+ if (duration != nullptr)
+ tag.SetTime(ParseDuration(duration));
+ }
+
+ break;
+ }
+ }
+
+ bool checkobjok() {
+ if (m_tobj.m_id.empty() || m_tobj.m_pid.empty() ||
+ m_tobj.name.empty() ||
+ (m_tobj.type == UPnPDirObject::Type::ITEM &&
+ m_tobj.item_class == UPnPDirObject::ItemClass::UNKNOWN))
+ return false;
+
+ return true;
+ }
+
+ virtual void EndElement(const XML_Char *name)
+ {
+ if ((!strcmp(name, "container") || !strcmp(name, "item")) &&
+ checkobjok()) {
+ tag.Commit(m_tobj.tag);
+ m_dir.objects.push_back(std::move(m_tobj));
+ }
+
+ m_path.pop_back();
+ }
+
+ virtual void CharacterData(const XML_Char *s, int len)
+ {
+ std::string str(s, len);
+ trimstring(str);
+
+ TagType type = tag_table_lookup(upnp_tags,
+ m_path.back().c_str());
+ if (type != TAG_NUM_OF_ITEM_TYPES) {
+ tag.AddItem(type, str.c_str());
+
+ if (type == TAG_TITLE)
+ m_tobj.name = titleToPathElt(std::move(str));
+
+ return;
+ }
+
+ switch (m_path.back()[0]) {
+ case 'r':
+ if (!m_path.back().compare("res")) {
+ m_tobj.url = str;
+ }
+ break;
+ case 'u':
+ if (m_path.back() == "upnp:class") {
+ m_tobj.item_class = ParseItemClass(str.c_str());
+ break;
+ }
+ break;
+ }
+ }
+};
+
+bool
+UPnPDirContent::parse(const std::string &input, Error &error)
+{
+ UPnPDirParser parser(*this);
+ return parser.Parse(input.data(), input.length(), true, error);
+}
diff --git a/src/db/upnp/Directory.hxx b/src/db/upnp/Directory.hxx
new file mode 100644
index 000000000..80b52ff2b
--- /dev/null
+++ b/src/db/upnp/Directory.hxx
@@ -0,0 +1,64 @@
+/*
+ * 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 "Compiler.h"
+
+#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> objects;
+
+ gcc_pure
+ UPnPDirObject *FindObject(const char *name) {
+ for (auto &o : objects)
+ if (o.name == name)
+ return &o;
+
+ return nullptr;
+ }
+
+ /**
+ * Parse from DIDL-Lite XML data.
+ *
+ * Normally only used by ContentDirectoryService::readDir()
+ * This is cumulative: in general, the XML data is obtained in
+ * several documents corresponding to (offset,count) slices of the
+ * directory (container). parse() can be called repeatedly with
+ * the successive XML documents and will accumulate entries in the item
+ * and container vectors. This makes more sense if the different
+ * chunks are from the same container, but given that UPnP Ids are
+ * actually global, nothing really bad will happen if you mix
+ * up...
+ */
+ bool parse(const std::string &didltext, Error &error);
+};
+
+#endif /* _UPNPDIRCONTENT_H_X_INCLUDED_ */
diff --git a/src/db/upnp/Discovery.cxx b/src/db/upnp/Discovery.cxx
new file mode 100644
index 000000000..89f01df2a
--- /dev/null
+++ b/src/db/upnp/Discovery.cxx
@@ -0,0 +1,329 @@
+/*
+ * 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 char *const 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)
+{
+ const size_t sz = strlen(ContentDirectorySType) - 2;
+ return memcmp(ContentDirectorySType, st, sz) == 0;
+}
+
+// The type of device we're asking for in search
+static const char *const MediaServerDType = "urn:schemas-upnp-org:device:MediaServer:1";
+
+gcc_pure
+static bool
+isMSDevice(const char *st)
+{
+ const size_t sz = strlen(MediaServerDType) - 2;
+ return memcmp(MediaServerDType, st, sz) == 0;
+}
+
+/**
+ * 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;
+ if (!discoveredQueue.take(tsk)) {
+ 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;
+ }
+
+#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+ auto e = contentDirectories.m_directories.emplace(tsk->deviceId, d);
+#else
+ auto e = contentDirectories.m_directories.insert(std::make_pair(tsk->deviceId, d));
+#endif
+ 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)
+{
+ 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->SetHandler([](Upnp_EventType type, void *event){
+ cluCallBack(type, event);
+ });
+
+ 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, 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;
+}
+
+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.c_str())) {
+ out.emplace_back(dit->second.device, service);
+ }
+ }
+ }
+
+ return true;
+}
+
+bool
+UPnPDeviceDirectory::getServer(const char *friendlyName,
+ ContentDirectoryService &server)
+{
+ std::vector<ContentDirectoryService> ds;
+ if (!getDirServices(ds)) {
+ return false;
+ }
+
+ for (const auto &i : ds) {
+ if (strcmp(friendlyName, i.getFriendlyName()) == 0) {
+ server = i;
+ return true;
+ }
+ }
+
+ return false;
+}
diff --git a/src/db/upnp/Discovery.hxx b/src/db/upnp/Discovery.hxx
new file mode 100644
index 000000000..899ac83ab
--- /dev/null
+++ b/src/db/upnp/Discovery.hxx
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef _UPNPPDISC_H_X_INCLUDED_
+#define _UPNPPDISC_H_X_INCLUDED_
+
+#include "util/Error.hxx"
+
+#include <vector>
+
+#include <time.h>
+
+class ContentDirectoryService;
+
+/**
+ * Manage UPnP discovery and maintain a directory of active devices. Singleton.
+ *
+ * We are only interested in MediaServers with a ContentDirectory service
+ * for now, but this could be made more general, by removing the filtering.
+ */
+class UPnPDeviceDirectory {
+ Error error;
+
+ /**
+ * The UPnP device search timeout, which should actually be
+ * called delay because it's the base of a random delay that
+ * the devices apply to avoid responding all at the same time.
+ */
+ int m_searchTimeout;
+
+ time_t m_lastSearch;
+
+ UPnPDeviceDirectory();
+public:
+ UPnPDeviceDirectory(const UPnPDeviceDirectory &) = delete;
+ UPnPDeviceDirectory& operator=(const UPnPDeviceDirectory &) = delete;
+
+ /** This class is a singleton. Get the instance here */
+ static UPnPDeviceDirectory *getTheDir();
+
+ /** Retrieve the directory services currently seen on the network */
+ bool getDirServices(std::vector<ContentDirectoryService> &);
+
+ /**
+ * Get server by friendly name. It's a bit wasteful to copy
+ * all servers for this, we could directly walk the list. Otoh
+ * there isn't going to be millions...
+ */
+ bool getServer(const char *friendlyName,
+ ContentDirectoryService &server);
+
+ /** My health */
+ bool ok() const {
+ return !error.IsDefined();
+ }
+
+ /** My diagnostic if health is bad */
+ const Error &GetError() const {
+ return error;
+ }
+
+private:
+ bool search();
+
+ /**
+ * Look at the devices and get rid of those which have not
+ * been seen for too long. We do this when listing the top
+ * directory.
+ */
+ void expireDevices();
+};
+
+
+#endif /* _UPNPPDISC_H_X_INCLUDED_ */
diff --git a/src/db/upnp/Domain.cxx b/src/db/upnp/Domain.cxx
new file mode 100644
index 000000000..010d4c7c2
--- /dev/null
+++ b/src/db/upnp/Domain.cxx
@@ -0,0 +1,23 @@
+/*
+ * 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");
diff --git a/src/db/upnp/Domain.hxx b/src/db/upnp/Domain.hxx
new file mode 100644
index 000000000..ec01ef735
--- /dev/null
+++ b/src/db/upnp/Domain.hxx
@@ -0,0 +1,27 @@
+/*
+ * 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
diff --git a/src/db/upnp/Object.hxx b/src/db/upnp/Object.hxx
new file mode 100644
index 000000000..39b8f94f9
--- /dev/null
+++ b/src/db/upnp/Object.hxx
@@ -0,0 +1,83 @@
+/*
+ * 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 "tag/Tag.hxx"
+
+#include <string>
+
+/**
+ * UpnP Media Server directory entry, converted from XML data.
+ *
+ * This is a dumb data holder class, a struct with helpers.
+ */
+class UPnPDirObject {
+public:
+ enum class Type {
+ UNKNOWN,
+ 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 class ItemClass {
+ UNKNOWN,
+ MUSIC,
+ PLAYLIST,
+ };
+
+ std::string m_id; // ObjectId
+ std::string m_pid; // Parent ObjectId
+ std::string url;
+
+ /**
+ * A copy of "dc:title" sanitized as a file name.
+ */
+ std::string name;
+
+ std::string m_title; // dc:title. Directory name for a container.
+ Type type;
+ ItemClass item_class;
+
+ Tag tag;
+
+ UPnPDirObject() = default;
+ UPnPDirObject(UPnPDirObject &&) = default;
+ UPnPDirObject &operator=(UPnPDirObject &&) = default;
+
+ void clear()
+ {
+ m_id.clear();
+ m_pid.clear();
+ url.clear();
+ type = Type::UNKNOWN;
+ item_class = ItemClass::UNKNOWN;
+ tag.Clear();
+ }
+};
+
+#endif /* _UPNPDIRCONTENT_H_X_INCLUDED_ */
diff --git a/src/db/upnp/Tags.cxx b/src/db/upnp/Tags.cxx
new file mode 100644
index 000000000..fd65df4d0
--- /dev/null
+++ b/src/db/upnp/Tags.cxx
@@ -0,0 +1,33 @@
+/*
+ * 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 "Tags.hxx"
+#include "tag/TagTable.hxx"
+
+const struct tag_table upnp_tags[] = {
+ { "upnp:artist", TAG_ARTIST },
+ { "upnp:album", TAG_ALBUM },
+ { "upnp:originalTrackNumber", TAG_TRACK },
+ { "upnp:genre", TAG_GENRE },
+ { "dc:title", TAG_TITLE },
+
+ /* sentinel */
+ { nullptr, TAG_NUM_OF_ITEM_TYPES }
+};
diff --git a/src/db/upnp/Tags.hxx b/src/db/upnp/Tags.hxx
new file mode 100644
index 000000000..ec6d18478
--- /dev/null
+++ b/src/db/upnp/Tags.hxx
@@ -0,0 +1,28 @@
+/*
+ * 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_TAGS_HXX
+#define MPD_UPNP_TAGS_HXX
+
+/**
+ * Map UPnP property names to MPD tags.
+ */
+extern const struct tag_table upnp_tags[];
+
+#endif
diff --git a/src/db/upnp/Util.cxx b/src/db/upnp/Util.cxx
new file mode 100644
index 000000000..afe68e619
--- /dev/null
+++ b/src/db/upnp/Util.cxx
@@ -0,0 +1,184 @@
+/*
+ * 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;
+}
+
+std::vector<std::string>
+stringToTokens(const std::string &str,
+ const char *delims, bool skipinit)
+{
+ std::vector<std::string> tokens;
+
+ std::string::size_type startPos = 0;
+
+ // Skip initial delims, return empty if this eats all.
+ if (skipinit &&
+ (startPos = str.find_first_not_of(delims, 0)) == std::string::npos)
+ return tokens;
+
+ while (startPos < str.size()) {
+ // Find next delimiter or end of string (end of token)
+ auto pos = str.find_first_of(delims, startPos);
+
+ // Add token to the vector and adjust start
+ if (pos == std::string::npos) {
+ tokens.push_back(str.substr(startPos));
+ break;
+ } else if (pos == startPos) {
+ // Dont' push empty tokens after first
+ if (tokens.empty())
+ tokens.push_back(std::string());
+ startPos = ++pos;
+ } else {
+ tokens.push_back(str.substr(startPos, pos - startPos));
+ startPos = ++pos;
+ }
+ }
+
+ return tokens;
+}
+
+template <class T>
+bool
+csvToStrings(const std::string &s, T &tokens)
+{
+ std::string current;
+ tokens.clear();
+ enum states {TOKEN, ESCAPE};
+ states state = TOKEN;
+ for (unsigned int i = 0; i < s.length(); i++) {
+ switch (s[i]) {
+ case ',':
+ switch(state) {
+ case TOKEN:
+ tokens.insert(tokens.end(), current);
+ current.clear();
+ continue;
+ case ESCAPE:
+ current += ',';
+ state = TOKEN;
+ continue;
+ }
+ break;
+ case '\\':
+ switch(state) {
+ case TOKEN:
+ state=ESCAPE;
+ continue;
+ case ESCAPE:
+ current += '\\';
+ state = TOKEN;
+ continue;
+ }
+ break;
+
+ default:
+ switch(state) {
+ case ESCAPE:
+ state = TOKEN;
+ break;
+ case TOKEN:
+ break;
+ }
+ current += s[i];
+ }
+ }
+ switch(state) {
+ case TOKEN:
+ tokens.insert(tokens.end(), current);
+ break;
+ case ESCAPE:
+ return false;
+ }
+ return true;
+}
+
+//template bool csvToStrings<list<string> >(const string &, list<string> &);
+template bool csvToStrings<std::vector<std::string> >(const std::string &, std::vector<std::string> &);
+template bool csvToStrings<std::set<std::string> >(const std::string &, std::set<std::string> &);
diff --git a/src/db/upnp/Util.hxx b/src/db/upnp/Util.hxx
new file mode 100644
index 000000000..08fe5f497
--- /dev/null
+++ b/src/db/upnp/Util.hxx
@@ -0,0 +1,45 @@
+/*
+ * 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 <vector>
+
+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::vector<std::string>
+stringToTokens(const std::string &str,
+ const char *delims = "/", bool skipinit = true);
+
+template <class T>
+bool csvToStrings(const std::string& s, T &tokens);
+
+#endif /* _UPNPP_H_X_INCLUDED_ */
diff --git a/src/db/upnp/WorkQueue.hxx b/src/db/upnp/WorkQueue.hxx
new file mode 100644
index 000000000..6a672273b
--- /dev/null
+++ b/src/db/upnp/WorkQueue.hxx
@@ -0,0 +1,203 @@
+/*
+ * 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 <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(int nworkers, void *(*workproc)(void *), void *arg)
+ {
+ const ScopeLock protect(mutex);
+
+ assert(nworkers > 0);
+ assert(!ok);
+ assert(n_threads == 0);
+ assert(threads == nullptr);
+
+ threads = new pthread_t[n_threads];
+
+ for (int i = 0; i < nworkers; i++) {
+ int err;
+ if ((err = pthread_create(&threads[n_threads++], 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.
+ */
+ bool put(T t)
+ {
+ const ScopeLock protect(mutex);
+
+ queue.push(t);
+
+ // 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 = 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_ */
diff --git a/src/db/upnp/ixmlwrap.cxx b/src/db/upnp/ixmlwrap.cxx
new file mode 100644
index 000000000..247c36d5d
--- /dev/null
+++ b/src/db/upnp/ixmlwrap.cxx
@@ -0,0 +1,44 @@
+/* Copyright (C) 2013 J.F.Dockes
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the
+ * Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "ixmlwrap.hxx"
+
+namespace ixmlwrap {
+
+std::string
+getFirstElementValue(IXML_Document *doc, const char *name)
+{
+ std::string ret;
+ IXML_NodeList *nodes =
+ ixmlDocument_getElementsByTagName(doc, name);
+
+ if (nodes) {
+ IXML_Node *first = ixmlNodeList_item(nodes, 0);
+ if (first) {
+ IXML_Node *dnode = ixmlNode_getFirstChild(first);
+ if (dnode) {
+ ret = ixmlNode_getNodeValue(dnode);
+ }
+ }
+ }
+
+ if(nodes)
+ ixmlNodeList_free(nodes);
+ return ret;
+}
+
+}
diff --git a/src/db/upnp/ixmlwrap.hxx b/src/db/upnp/ixmlwrap.hxx
new file mode 100644
index 000000000..8677d691a
--- /dev/null
+++ b/src/db/upnp/ixmlwrap.hxx
@@ -0,0 +1,35 @@
+/* Copyright (C) 2013 J.F.Dockes
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the
+ * Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+#ifndef _IXMLWRAP_H_INCLUDED_
+#define _IXMLWRAP_H_INCLUDED_
+
+#include <upnp/ixml.h>
+
+#include <string>
+
+namespace ixmlwrap {
+ /**
+ * Retrieve the text content for the first element of given
+ * name. Returns an empty string if the element does not
+ * contain a text node
+ */
+ std::string getFirstElementValue(IXML_Document *doc,
+ const char *name);
+
+};
+
+#endif /* _IXMLWRAP_H_INCLUDED_ */
diff --git a/src/db/upnp/upnpplib.cxx b/src/db/upnp/upnpplib.cxx
new file mode 100644
index 000000000..508315b26
--- /dev/null
+++ b/src/db/upnp/upnpplib.cxx
@@ -0,0 +1,89 @@
+/*
+ * 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::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;
+ }
+
+ 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));
+}
diff --git a/src/db/upnp/upnpplib.hxx b/src/db/upnp/upnpplib.hxx
new file mode 100644
index 000000000..c1443624c
--- /dev/null
+++ b/src/db/upnp/upnpplib.hxx
@@ -0,0 +1,73 @@
+/*
+ * 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;
+
+ 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);
+
+ /** 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_ */
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-04 08:43:22 +0000