lib/libUPnP/Platinum/Source/Core/PltDeviceData.cpp

   1 /*****************************************************************
   2 |
   3 |   Platinum - Device Data
   4 |
   5 | Copyright (c) 2004-2010, Plutinosoft, LLC.
   6 | All rights reserved.
   7 | http://www.plutinosoft.com
   8 |
   9 | This program is free software; you can redistribute it and/or
  10 | modify it under the terms of the GNU General Public License
  11 | as published by the Free Software Foundation; either version 2
  12 | of the License, or (at your option) any later version.
  13 |
  14 | OEMs, ISVs, VARs and other distributors that combine and
  15 | distribute commercially licensed software with Platinum software
  16 | and do not wish to distribute the source code for the commercially
  17 | licensed software under version 2, or (at your option) any later
  18 | version, of the GNU General Public License (the "GPL") must enter
  19 | into a commercial license agreement with Plutinosoft, LLC.
  20 | licensing@plutinosoft.com
  21 |
  22 | This program is distributed in the hope that it will be useful,
  23 | but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 | GNU General Public License for more details.
  26 |
  27 | You should have received a copy of the GNU General Public License
  28 | along with this program; see the file LICENSE.txt. If not, write to
  29 | the Free Software Foundation, Inc.,
  30 | 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  31 | http://www.gnu.org/licenses/gpl-2.0.html
  32 |
  33 ****************************************************************/
  34
  35 /*----------------------------------------------------------------------
  36 |   includes
  37 +---------------------------------------------------------------------*/
  38 #include "PltDeviceData.h"
  39 #include "PltService.h"
  40 #include "PltUPnP.h"
  41 #include "PltUtilities.h"
  42
  43 NPT_SET_LOCAL_LOGGER("platinum.core.devicedata")
  44
  45 /*----------------------------------------------------------------------
  46 |   PLT_DeviceData::PLT_DeviceData
  47 +---------------------------------------------------------------------*/
  48 PLT_DeviceData::PLT_DeviceData(NPT_HttpUrl      description_url,
  49                                const char*      uuid,
  50                                NPT_TimeInterval lease_time,
  51                                const char*      device_type,
  52                                const char*      friendly_name) :
  53     m_Manufacturer("Plutinosoft LLC"),
  54     m_ManufacturerURL("http://www.plutinosoft.com"),
  55     m_UUID(uuid),
  56     m_URLDescription(description_url),
  57     m_DeviceType(device_type),
  58     m_FriendlyName(friendly_name),
  59     m_BootId(0),
  60     m_NextBootId(0)
  61 {
  62     if (uuid == NULL || strlen(uuid) == 0) {
  63         PLT_UPnPMessageHelper::GenerateGUID(m_UUID);
  64     }
  65
  66     SetLeaseTime(lease_time);
  67     SetURLBase(m_URLDescription);
  68     UpdateConfigId();
  69 }
  70
  71 /*----------------------------------------------------------------------
  72 |   PLT_DeviceData::~PLT_DeviceData
  73 +---------------------------------------------------------------------*/
  74 PLT_DeviceData::~PLT_DeviceData()
  75 {
  76     Cleanup();
  77 }
  78
  79 /*----------------------------------------------------------------------
  80 |   PLT_DeviceData::Cleanup
  81 +---------------------------------------------------------------------*/
  82 void
  83 PLT_DeviceData::Cleanup()
  84 {
  85     m_Services.Apply(NPT_ObjectDeleter<PLT_Service>());
  86     m_Services.Clear();
  87     m_EmbeddedDevices.Clear();
  88     m_Icons.Clear();
  89 }
  90
  91 /*----------------------------------------------------------------------
  92 |   PLT_DeviceData::SetDescriptionUrl
  93 +---------------------------------------------------------------------*/
  94 NPT_Result
  95 PLT_DeviceData::SetDescriptionUrl(NPT_HttpUrl& url)
  96 {
  97     NPT_CHECK_FATAL(SetURLBase(url));
  98     m_URLDescription = url;
  99     return NPT_SUCCESS;
 100 }
 101
 102 /*----------------------------------------------------------------------
 103 |   PLT_DeviceData::GetDescriptionUrl
 104 +---------------------------------------------------------------------*/
 105 NPT_String
 106 PLT_DeviceData::GetDescriptionUrl(const char* ip_address)
 107 {
 108     NPT_HttpUrl url = m_URLDescription;
 109
 110     // replace host with ip address specified
 111     if (ip_address) url.SetHost(ip_address);
 112     return url.ToString();
 113 }
 114
 115 /*----------------------------------------------------------------------
 116 |   PLT_DeviceData::SetURLBase
 117 +---------------------------------------------------------------------*/
 118 NPT_Result
 119 PLT_DeviceData::SetURLBase(NPT_HttpUrl& url)
 120 {
 121     // only http scheme supported
 122     m_URLBase.SetScheme(url.GetScheme());
 123
 124     // update port if any
 125     if (url.GetPort() != NPT_URL_INVALID_PORT) m_URLBase.SetPort(url.GetPort());
 126
 127     // update host if any
 128     if (!url.GetHost().IsEmpty()) m_URLBase.SetHost(url.GetHost());
 129
 130     // update path
 131     NPT_String path = url.GetPath();
 132
 133     // remove trailing file according to RFC 2396
 134     if (!path.EndsWith("/")) {
 135         int index = path.ReverseFind('/');
 136         if (index < 0) return NPT_FAILURE;
 137         path.SetLength(index+1);
 138     }
 139     m_URLBase.SetPath(path, true);
 140
 141     return NPT_SUCCESS;
 142 }
 143
 144 /*----------------------------------------------------------------------
 145 |   PLT_DeviceData::GetURLBase
 146 +---------------------------------------------------------------------*/
 147 NPT_HttpUrl
 148 PLT_DeviceData::GetURLBase()
 149 {
 150     return m_URLBase;
 151 }
 152
 153 /*----------------------------------------------------------------------
 154 |   PLT_DeviceData::NormalizeURL
 155 +---------------------------------------------------------------------*/
 156 NPT_HttpUrl
 157 PLT_DeviceData::NormalizeURL(const NPT_String& url)
 158 {
 159     if (url.StartsWith("http://")) return NPT_HttpUrl(url);
 160
 161     NPT_HttpUrl norm_url = m_URLBase;
 162     if (url.StartsWith("/")) {
 163         norm_url.ParsePathPlus(url);
 164     } else {
 165         norm_url.ParsePathPlus(norm_url.GetPath() + url);
 166     }
 167
 168     return norm_url;
 169 }
 170
 171 /*----------------------------------------------------------------------
 172 |   PLT_DeviceData::GetIconUrl
 173 +---------------------------------------------------------------------*/
 174 NPT_String
 175 PLT_DeviceData::GetIconUrl(const char* mimetype,
 176                            NPT_Int32   maxsize,
 177                            NPT_Int32   maxdepth)
 178 {
 179     PLT_DeviceIcon icon;
 180
 181     for (NPT_Cardinal i=0; i<m_Icons.GetItemCount(); i++) {
 182         if ((mimetype && m_Icons[i].m_MimeType != mimetype) ||
 183             (maxsize  && m_Icons[i].m_Width > maxsize)      ||
 184             (maxsize  && m_Icons[i].m_Height > maxsize)     ||
 185             (maxdepth && m_Icons[i].m_Depth > maxdepth))
 186             continue;
 187
 188         // pick the biggest and better resolution we can
 189         if (icon.m_Width  >= m_Icons[i].m_Width  ||
 190             icon.m_Height >= m_Icons[i].m_Height ||
 191             icon.m_Depth  >= m_Icons[i].m_Depth  ||
 192             m_Icons[i].m_UrlPath.IsEmpty())
 193             continue;
 194
 195         icon = m_Icons[i];
 196     }
 197
 198     if (icon.m_UrlPath == "") return "";
 199
 200     return NormalizeURL(icon.m_UrlPath).ToString();
 201 }
 202
 203 /*----------------------------------------------------------------------
 204 |   PLT_DeviceData::UpdateConfigId
 205 +---------------------------------------------------------------------*/
 206 void
 207 PLT_DeviceData::UpdateConfigId()
 208 {
 209     NPT_UInt32 nextConfigId = NPT_System::GetRandomInteger() & 0xFFFFFF;
 210     if (m_ConfigId == nextConfigId) {
 211         // prevent value to underflow
 212         nextConfigId>0?--nextConfigId:++nextConfigId;
 213     }
 214
 215     m_ConfigId = nextConfigId;
 216 }
 217
 218 /*----------------------------------------------------------------------
 219 |   PLT_DeviceData::SetBootId
 220 +---------------------------------------------------------------------*/
 221 void
 222 PLT_DeviceData::SetBootId(NPT_UInt32 bootId)
 223 {
 224     m_BootId = bootId;
 225 }
 226
 227 /*----------------------------------------------------------------------
 228  |   PLT_DeviceData::SetNextBootId
 229  +---------------------------------------------------------------------*/
 230 void
 231 PLT_DeviceData::SetNextBootId(NPT_UInt32 nextBootId)
 232 {
 233     m_NextBootId = nextBootId;
 234 }
 235
 236 /*----------------------------------------------------------------------
 237 |   PLT_DeviceData::GenerateNextBootId
 238 +---------------------------------------------------------------------*/
 239 NPT_UInt32
 240 PLT_DeviceData::GenerateNextBootId()
 241 {
 242     NPT_TimeStamp now;
 243     NPT_System::GetCurrentTimeStamp(now);
 244     NPT_UInt32 value = (NPT_UInt32)now.ToSeconds();
 245     if (value == m_BootId) ++value;
 246     return value;
 247 }
 248
 249 /*----------------------------------------------------------------------
 250 |   PLT_DeviceData::SetLeaseTime
 251 +---------------------------------------------------------------------*/
 252 NPT_Result
 253 PLT_DeviceData::SetLeaseTime(NPT_TimeInterval lease_time, NPT_TimeStamp lease_time_last_update /* = 0 */)
 254 {
 255     // Enforce 10 seconds min lease time
 256     m_LeaseTime = (lease_time.ToSeconds()>=10)?lease_time:*PLT_Constants::GetInstance().GetDefaultDeviceLease();
 257
 258     // get current time as last update time if none passed
 259     if ((double)lease_time_last_update == 0.) {
 260         NPT_System::GetCurrentTimeStamp(lease_time_last_update);
 261     }
 262     m_LeaseTimeLastUpdate = lease_time_last_update;
 263     return NPT_SUCCESS;
 264 }
 265
 266 /*----------------------------------------------------------------------
 267 |   PLT_DeviceData::GetLeaseTimeLastUpdate
 268 +---------------------------------------------------------------------*/
 269 NPT_TimeStamp
 270 PLT_DeviceData::GetLeaseTimeLastUpdate()
 271 {
 272     return m_LeaseTimeLastUpdate;
 273 }
 274
 275 /*----------------------------------------------------------------------
 276 |   PLT_DeviceData::operator const char*()
 277 +---------------------------------------------------------------------*/
 278 PLT_DeviceData::operator const char*()
 279 {
 280     NPT_StringOutputStreamReference stream(new NPT_StringOutputStream);
 281     stream->WriteString("Device GUID: ");
 282     stream->WriteString((const char*)m_UUID);
 283
 284     stream->WriteString("Device Type: ");
 285     stream->WriteString((const char*)m_DeviceType);
 286
 287     stream->WriteString("Device Base Url: ");
 288     stream->WriteString((const char*)GetURLBase().ToString());
 289
 290     stream->WriteString("Device Friendly Name: ");
 291     stream->WriteString((const char*)m_FriendlyName);
 292
 293     m_Representation = stream->GetString();
 294     return m_Representation;
 295 }
 296
 297 /*----------------------------------------------------------------------
 298 |   PLT_DeviceData::AddEmbeddedDevice
 299 +---------------------------------------------------------------------*/
 300 NPT_Result
 301 PLT_DeviceData::AddEmbeddedDevice(PLT_DeviceDataReference& device)
 302 {
 303     UpdateConfigId();
 304
 305     device->m_ParentUUID = m_UUID;
 306     return m_EmbeddedDevices.Add(device);
 307 }
 308
 309 /*----------------------------------------------------------------------
 310 |   PLT_DeviceData::RemoveEmbeddedDevice
 311 +---------------------------------------------------------------------*/
 312 NPT_Result
 313 PLT_DeviceData::RemoveEmbeddedDevice(PLT_DeviceDataReference& device)
 314 {
 315     for (NPT_Cardinal i=0;
 316          i<m_EmbeddedDevices.GetItemCount();
 317          i++) {
 318         if (m_EmbeddedDevices[i] == device) {
 319             UpdateConfigId();
 320             return m_EmbeddedDevices.Erase(i);
 321         }
 322     }
 323
 324     return NPT_ERROR_NO_SUCH_ITEM;
 325 }
 326
 327 /*----------------------------------------------------------------------
 328 |   PLT_DeviceData::AddService
 329 +---------------------------------------------------------------------*/
 330 NPT_Result
 331 PLT_DeviceData::AddService(PLT_Service* service)
 332 {
 333     if (service->GetServiceType() == "" ||
 334         service->GetServiceID()   == "" ||
 335         service->GetSCPDURL()     == "" ||
 336         service->GetControlURL()  == "" ||
 337         service->GetEventSubURL() == "") {
 338         return NPT_ERROR_INVALID_PARAMETERS;
 339     }
 340     UpdateConfigId();
 341     return m_Services.Add(service);
 342 }
 343
 344 /*----------------------------------------------------------------------
 345 |   PLT_DeviceData::RemoveService
 346 +---------------------------------------------------------------------*/
 347 NPT_Result
 348 PLT_DeviceData::RemoveService(PLT_Service* service)
 349 {
 350         for (NPT_Cardinal i=0;
 351          i<m_Services.GetItemCount();
 352          i++) {
 353         if (m_Services[i] == service) {
 354             UpdateConfigId();
 355             return m_Services.Erase(i);
 356         }
 357     }
 358
 359     return NPT_ERROR_NO_SUCH_ITEM;
 360 }
 361
 362 /*----------------------------------------------------------------------
 363 |   PLT_GetDescriptionIterator class
 364 +---------------------------------------------------------------------*/
 365 template <class T>
 366 class PLT_GetDescriptionIterator
 367 {
 368 public:
 369     PLT_GetDescriptionIterator(NPT_XmlElementNode* parent) :
 370       m_Parent(parent) {}
 371
 372       NPT_Result operator()(T& data) const {
 373           return data->GetDescription(m_Parent);
 374       }
 375
 376 private:
 377     NPT_XmlElementNode* m_Parent;
 378 };
 379
 380 /*----------------------------------------------------------------------
 381 |   PLT_DeviceData::GetDescription
 382 +---------------------------------------------------------------------*/
 383 NPT_Result
 384 PLT_DeviceData::GetDescription(NPT_XmlElementNode* root, NPT_XmlElementNode** device_out)
 385 {
 386     NPT_XmlElementNode* device = new NPT_XmlElementNode("device");
 387     if (device_out) *device_out = device;
 388
 389     NPT_CHECK_SEVERE(root->AddChild(device));
 390
 391     // device properties
 392     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "deviceType", m_DeviceType));
 393     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "friendlyName", m_FriendlyName));
 394     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "manufacturer", m_Manufacturer));
 395     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "manufacturerURL", m_ManufacturerURL));
 396     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "modelDescription", m_ModelDescription));
 397     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "modelName", m_ModelName));
 398     if (!m_ModelNumber.IsEmpty()) NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "modelNumber", m_ModelNumber));
 399     if (!m_SerialNumber.IsEmpty()) NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "serialNumber", m_SerialNumber));
 400     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "modelURL", m_ModelURL)); // moved after modelNumber to go around a bug in UCTT
 401     NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "UDN", "uuid:" + m_UUID));
 402
 403     if (!m_PresentationURL.IsEmpty()) {
 404         NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(device, "presentationURL", m_PresentationURL));
 405     }
 406
 407     // Extra info not in UPnP specs
 408     NPT_CHECK(OnAddExtraInfo(device));
 409
 410     // DLNA support
 411     if (!m_DlnaDoc.IsEmpty()) {
 412         NPT_XmlElementNode* dlnadoc = new NPT_XmlElementNode("dlna", "X_DLNADOC");
 413         NPT_CHECK_SEVERE(dlnadoc->SetNamespaceUri("dlna", "urn:schemas-dlna-org:device-1-0"));
 414         dlnadoc->AddText(m_DlnaDoc);
 415         device->AddChild(dlnadoc);
 416     }
 417     if (!m_DlnaCap.IsEmpty()) {
 418         NPT_XmlElementNode* dlnacap = new NPT_XmlElementNode("dlna", "X_DLNACAP");
 419         NPT_CHECK_SEVERE(dlnacap->SetNamespaceUri("dlna", "urn:schemas-dlna-org:device-1-0"));
 420         dlnacap->AddText(m_DlnaCap);
 421         device->AddChild(dlnacap);
 422     }
 423
 424     // icons
 425     if (m_Icons.GetItemCount()) {
 426         NPT_XmlElementNode* icons = new NPT_XmlElementNode("iconList");
 427         NPT_CHECK_SEVERE(device->AddChild(icons));
 428         for (NPT_Cardinal i=0; i<m_Icons.GetItemCount(); i++) {
 429             NPT_XmlElementNode* icon = new NPT_XmlElementNode("icon");
 430             NPT_CHECK_SEVERE(icons->AddChild(icon));
 431             NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(icon, "mimetype", m_Icons[i].m_MimeType));
 432             NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(icon, "width", NPT_String::FromInteger(m_Icons[i].m_Width)));
 433             NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(icon, "height", NPT_String::FromInteger(m_Icons[i].m_Height)));
 434             NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(icon, "depth", NPT_String::FromInteger(m_Icons[i].m_Depth)));
 435             NPT_CHECK_SEVERE(PLT_XmlHelper::AddChildText(icon, "url", m_Icons[i].m_UrlPath));
 436         }
 437     }
 438
 439     // services
 440     NPT_XmlElementNode* services = new NPT_XmlElementNode("serviceList");
 441     NPT_CHECK_SEVERE(device->AddChild(services));
 442     NPT_CHECK_SEVERE(m_Services.ApplyUntil(PLT_GetDescriptionIterator<PLT_Service*>(services),
 443                                            NPT_UntilResultNotEquals(NPT_SUCCESS)));
 444
 445     // PS3 support
 446     if (!m_AggregationFlags.IsEmpty()) {
 447         NPT_XmlElementNode* aggr = new NPT_XmlElementNode("av", "aggregationFlags");
 448         NPT_CHECK_SEVERE(aggr->SetNamespaceUri("av", "urn:schemas-sonycom:av"));
 449         aggr->AddText(m_AggregationFlags);
 450         device->AddChild(aggr);
 451     }
 452
 453     // embedded devices
 454     if (m_EmbeddedDevices.GetItemCount()) {
 455         NPT_XmlElementNode* deviceList = new NPT_XmlElementNode("deviceList");
 456         NPT_CHECK_SEVERE(device->AddChild(deviceList));
 457
 458         NPT_CHECK_SEVERE(m_EmbeddedDevices.ApplyUntil(
 459             PLT_GetDescriptionIterator<PLT_DeviceDataReference>(deviceList),
 460             NPT_UntilResultNotEquals(NPT_SUCCESS)));
 461     }
 462
 463     return NPT_SUCCESS;
 464 }
 465
 466 /*----------------------------------------------------------------------
 467 |   PLT_DeviceData::GetDescription
 468 +---------------------------------------------------------------------*/
 469 NPT_Result
 470 PLT_DeviceData::GetDescription(NPT_String& desc)
 471 {
 472     NPT_Result res;
 473     NPT_XmlElementNode* spec = NULL;
 474     NPT_XmlElementNode* root = new NPT_XmlElementNode("root");
 475
 476     NPT_CHECK_LABEL_SEVERE(res = root->SetNamespaceUri("", "urn:schemas-upnp-org:device-1-0"), cleanup);
 477     NPT_CHECK_LABEL_SEVERE(res = root->SetNamespaceUri("dlna", "urn:schemas-dlna-org:device-1-0"), cleanup);
 478     NPT_CHECK_LABEL_SEVERE(res = root->SetAttribute("", "configId", NPT_String::FromInteger(m_ConfigId)), cleanup);
 479
 480     // add spec version
 481     spec = new NPT_XmlElementNode("specVersion");
 482     NPT_CHECK_LABEL_SEVERE(res = root->AddChild(spec), cleanup);
 483     NPT_CHECK_LABEL_SEVERE(res = PLT_XmlHelper::AddChildText(spec, "major", "1"), cleanup);
 484     NPT_CHECK_LABEL_SEVERE(res = PLT_XmlHelper::AddChildText(spec, "minor", "1"), cleanup);
 485
 486     // get device xml
 487     NPT_CHECK_LABEL_SEVERE(res = GetDescription(root), cleanup);
 488
 489     // serialize node
 490     NPT_CHECK_LABEL_SEVERE(res = PLT_XmlHelper::Serialize(*root, desc, true, 2), cleanup);
 491
 492 cleanup:
 493     delete root;
 494     return res;
 495 }
 496
 497 /*----------------------------------------------------------------------
 498 |   PLT_DeviceData::SetDescription
 499 +---------------------------------------------------------------------*/
 500 NPT_Result
 501 PLT_DeviceData::SetDescription(PLT_DeviceDataReference&      root_device,
 502                                NPT_TimeInterval              leasetime,
 503                                NPT_HttpUrl                   description_url,
 504                                const char*                   description,
 505                                const NPT_HttpRequestContext& context)
 506 {
 507     NPT_XmlParser       parser;
 508     NPT_XmlNode*        tree = NULL;
 509     NPT_Result          res;
 510     NPT_XmlElementNode* root = NULL;
 511     NPT_String          URLBase;
 512     NPT_String          configId;
 513
 514     // create new device if none passed
 515     if (root_device.IsNull()) {
 516         root_device = new PLT_DeviceData(description_url, "", leasetime);
 517     }
 518
 519     res = parser.Parse(description, tree);
 520     NPT_CHECK_LABEL_SEVERE(res, cleanup);
 521
 522     root = tree->AsElementNode();
 523     if (!root ||
 524         root->GetTag() != "root" ||
 525         !root->GetNamespace() ||
 526         *root->GetNamespace() != "urn:schemas-upnp-org:device-1-0") {
 527         NPT_LOG_INFO_1("root namespace is invalid: %s",
 528             (root&&root->GetNamespace())?root->GetNamespace()->GetChars():"null");
 529         NPT_CHECK_LABEL_SEVERE(NPT_FAILURE, cleanup);
 530     }
 531
 532     // look for optional URLBase element
 533     if (NPT_SUCCEEDED(PLT_XmlHelper::GetChildText(root, "URLBase", URLBase))) {
 534         NPT_HttpUrl url(URLBase);
 535                 // Some devices like Connect360 try to be funny - not so
 536         if (url.GetHost().ToLowercase() == "localhost" ||
 537             url.GetHost().ToLowercase() == "127.0.0.1") {
 538             url.SetHost(context.GetRemoteAddress().GetIpAddress().ToString());
 539         }
 540         root_device->SetURLBase(url);
 541     } else {
 542         // No URLBase, derive from description url
 543         root_device->SetURLBase(description_url);
 544     }
 545
 546     // at least one root device child element is required
 547     NPT_XmlElementNode* device;
 548     if (!(device = PLT_XmlHelper::GetChild(root, "device"))) {
 549         NPT_CHECK_LABEL_SEVERE(NPT_FAILURE, cleanup);
 550     }
 551
 552     res = SetDescriptionDevice(root_device, device, context);
 553
 554     // reset configId if and set it back from root attribute
 555     root_device->m_ConfigId = 0;
 556     if (NPT_SUCCEEDED(PLT_XmlHelper::GetAttribute(root, "configId", configId))) {
 557         NPT_UInt32 value;
 558         if (NPT_SUCCEEDED(configId.ToInteger32(value))) {
 559             root_device->m_ConfigId = value;
 560         }
 561     }
 562
 563 cleanup:
 564     // delete the tree
 565     delete tree;
 566     return res;
 567 }
 568
 569 /*----------------------------------------------------------------------
 570 |   PLT_DeviceData::SetDescriptionDevice
 571 +---------------------------------------------------------------------*/
 572 NPT_Result
 573 PLT_DeviceData::SetDescriptionDevice(PLT_DeviceDataReference&      device,
 574                                      NPT_XmlElementNode*           device_node,
 575                                      const NPT_HttpRequestContext& context)
 576 {
 577     NPT_Result res;
 578
 579     device->m_LocalIfaceIp = context.GetLocalAddress().GetIpAddress();
 580
 581     NPT_CHECK_SEVERE(PLT_XmlHelper::GetChildText(device_node, "deviceType", device->m_DeviceType));
 582     NPT_CHECK_SEVERE(PLT_XmlHelper::GetChildText(device_node, "UDN", device->m_UUID));
 583
 584     // remove uuid: prefix
 585     if (device->m_UUID.StartsWith("uuid:")) {
 586         device->m_UUID = ((const char*)device->m_UUID)+5;
 587     }
 588
 589     // optional attributes
 590     PLT_XmlHelper::GetChildText(device_node, "friendlyName", device->m_FriendlyName);
 591     PLT_XmlHelper::GetChildText(device_node, "manufacturer", device->m_Manufacturer);
 592     PLT_XmlHelper::GetChildText(device_node, "manufacturerURL", device->m_ManufacturerURL);
 593     PLT_XmlHelper::GetChildText(device_node, "modelDescription", device->m_ModelDescription);
 594     PLT_XmlHelper::GetChildText(device_node, "modelName", device->m_ModelName);
 595     PLT_XmlHelper::GetChildText(device_node, "modelURL", device->m_ModelURL);
 596     PLT_XmlHelper::GetChildText(device_node, "modelNumber", device->m_ModelNumber);
 597     PLT_XmlHelper::GetChildText(device_node, "serialNumber", device->m_SerialNumber);
 598     PLT_XmlHelper::GetChildText(device_node, "presentationURL", device->m_PresentationURL);
 599
 600     // enumerate icons
 601     NPT_XmlElementNode* iconList = PLT_XmlHelper::GetChild(device_node, "iconList");
 602     if (iconList) {
 603         NPT_Array<NPT_XmlElementNode*> icons;
 604         PLT_XmlHelper::GetChildren(iconList, icons, "icon");
 605
 606         for (NPT_Cardinal k=0 ; k<icons.GetItemCount(); k++) {
 607             PLT_DeviceIcon icon;
 608             NPT_String integer, height, depth;
 609
 610             PLT_XmlHelper::GetChildText(icons[k], "mimetype", icon.m_MimeType);
 611             PLT_XmlHelper::GetChildText(icons[k], "url", icon.m_UrlPath);
 612
 613             if(NPT_SUCCEEDED(PLT_XmlHelper::GetChildText(icons[k], "width", integer)))
 614                 NPT_ParseInteger32(integer, icon.m_Width);
 615             if(NPT_SUCCEEDED(PLT_XmlHelper::GetChildText(icons[k], "height", integer)))
 616                 NPT_ParseInteger32(integer, icon.m_Height);
 617             if(NPT_SUCCEEDED(PLT_XmlHelper::GetChildText(icons[k], "depth", integer)))
 618                 NPT_ParseInteger32(integer, icon.m_Depth);
 619
 620             device->m_Icons.Add(icon);
 621         }
 622     }
 623
 624     // enumerate device services
 625     NPT_XmlElementNode* serviceList = PLT_XmlHelper::GetChild(device_node, "serviceList");
 626     if (serviceList) {
 627         NPT_Array<NPT_XmlElementNode*> services;
 628         PLT_XmlHelper::GetChildren(serviceList, services, "service");
 629         for( int k = 0 ; k < (int)services.GetItemCount(); k++) {
 630             NPT_String type, id, url;
 631             PLT_XmlHelper::GetChildText(services[k], "serviceType", type);
 632             PLT_XmlHelper::GetChildText(services[k], "serviceId", id);
 633             PLT_Service* service = new PLT_Service(device.AsPointer(), type, id, NULL);
 634
 635             PLT_XmlHelper::GetChildText(services[k], "SCPDURL", url);
 636             service->SetSCPDURL(url);
 637
 638             PLT_XmlHelper::GetChildText(services[k], "controlURL", url);
 639             service->SetControlURL(url);
 640
 641             PLT_XmlHelper::GetChildText(services[k], "eventSubURL", url);
 642             service->SetEventSubURL(url);
 643
 644             if (NPT_FAILED(res = device->AddService(service))) {
 645                 delete service;
 646                 return res;
 647             }
 648         }
 649     }
 650
 651     // enumerate embedded devices
 652     NPT_XmlElementNode* deviceList = PLT_XmlHelper::GetChild(device_node, "deviceList");
 653     if (deviceList) {
 654         NPT_Array<NPT_XmlElementNode*> devices;
 655         PLT_XmlHelper::GetChildren(deviceList, devices, "device");
 656         for (int k = 0; k<(int)devices.GetItemCount(); k++) {
 657             // create an embedded device with same url base and leasetime as parent
 658             PLT_DeviceDataReference embedded_device(new PLT_DeviceData(device->m_URLDescription, "", device->m_LeaseTime));
 659             NPT_CHECK_SEVERE(PLT_DeviceData::SetDescriptionDevice(embedded_device, devices[k], context));
 660             device->AddEmbeddedDevice(embedded_device);
 661         }
 662     }
 663
 664     // TODO: Parse extra DLNA stuff
 665
 666     return NPT_SUCCESS;
 667 }
 668
 669
 670 /*----------------------------------------------------------------------
 671 |   PLT_DeviceData::FindEmbeddedDevice
 672 +---------------------------------------------------------------------*/
 673 NPT_Result
 674 PLT_DeviceData::FindEmbeddedDevice(const char*              uuid,
 675                                    PLT_DeviceDataReference& device)
 676 {
 677     NPT_Result res = NPT_ContainerFind(m_EmbeddedDevices,
 678         PLT_DeviceDataFinder(uuid),
 679         device);
 680     if (NPT_SUCCEEDED(res)) return res;
 681
 682     for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
 683         res = m_EmbeddedDevices[i]->FindEmbeddedDevice(
 684             uuid,
 685             device);
 686         if (NPT_SUCCEEDED(res)) return res;
 687     }
 688
 689     return NPT_FAILURE;
 690 }
 691
 692 /*----------------------------------------------------------------------
 693 |   PLT_DeviceData::FindEmbeddedDeviceByType
 694 +---------------------------------------------------------------------*/
 695 NPT_Result
 696 PLT_DeviceData::FindEmbeddedDeviceByType(const char*              type,
 697                                          PLT_DeviceDataReference& device)
 698 {
 699     NPT_Result res = NPT_ContainerFind(m_EmbeddedDevices,
 700         PLT_DeviceDataFinderByType(type),
 701         device);
 702     if (NPT_SUCCEEDED(res)) return res;
 703
 704     for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
 705         res = m_EmbeddedDevices[i]->FindEmbeddedDeviceByType(
 706             type,
 707             device);
 708         if (NPT_SUCCEEDED(res)) return res;
 709     }
 710
 711     return NPT_FAILURE;
 712 }
 713
 714 /*----------------------------------------------------------------------
 715 |   PLT_DeviceData::FindServiceById
 716 +---------------------------------------------------------------------*/
 717 NPT_Result
 718 PLT_DeviceData::FindServiceById(const char* id, PLT_Service*& service)
 719 {
 720     // do not try to find it within embedded devices, since different
 721     // embedded devices could have an identical service
 722     return NPT_ContainerFind(m_Services,
 723         PLT_ServiceIDFinder(id),
 724         service);
 725 }
 726
 727 /*----------------------------------------------------------------------
 728 |   PLT_DeviceData::FindServiceByType
 729 +---------------------------------------------------------------------*/
 730 NPT_Result
 731 PLT_DeviceData::FindServiceByType(const char* type, PLT_Service*& service)
 732 {
 733     // do not try to find it within embedded devices, since different
 734     // embedded devices could have an identical service
 735     return NPT_ContainerFind(m_Services,
 736         PLT_ServiceTypeFinder(type),
 737         service);
 738 }
 739
 740 /*----------------------------------------------------------------------
 741 |   PLT_DeviceData::FindServiceByName
 742 +---------------------------------------------------------------------*/
 743 NPT_Result
 744 PLT_DeviceData::FindServiceByName(const char* name, PLT_Service*& service)
 745 {
 746     // do not try to find it within embedded devices, since different
 747     // embedded devices could have an identical service
 748     return NPT_ContainerFind(m_Services,
 749         PLT_ServiceNameFinder(name),
 750         service);
 751 }
 752
 753 /*----------------------------------------------------------------------
 754 |   PLT_DeviceData::FindServiceBySCPDURL
 755 +---------------------------------------------------------------------*/
 756 NPT_Result
 757 PLT_DeviceData::FindServiceBySCPDURL(const char*   url,
 758                                      PLT_Service*& service,
 759                                      bool          recursive /* = false */)
 760 {
 761     NPT_Result res = NPT_ContainerFind(
 762         m_Services,
 763         PLT_ServiceSCPDURLFinder(url),
 764         service);
 765     if (NPT_SUCCEEDED(res)) return res;
 766
 767     if (recursive) {
 768                 for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
 769             res = m_EmbeddedDevices[i]->FindServiceBySCPDURL(
 770                 url,
 771                 service,
 772                 recursive);
 773             if (NPT_SUCCEEDED(res)) return res;
 774         }
 775     }
 776
 777     return NPT_FAILURE;
 778 }
 779
 780 /*----------------------------------------------------------------------
 781 |   PLT_DeviceData::FindServiceByControlURL
 782 +---------------------------------------------------------------------*/
 783 NPT_Result
 784 PLT_DeviceData::FindServiceByControlURL(const char*   url,
 785                                         PLT_Service*& service,
 786                                         bool          recursive /* = false */)
 787 {
 788     NPT_Result res = NPT_ContainerFind(m_Services,
 789         PLT_ServiceControlURLFinder(url),
 790         service);
 791     if (NPT_SUCCEEDED(res)) return res;
 792
 793     if (recursive) {
 794                 for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
 795             res = m_EmbeddedDevices[i]->FindServiceByControlURL(
 796                 url,
 797                 service,
 798                 recursive);
 799             if (NPT_SUCCEEDED(res)) return res;
 800         }
 801     }
 802
 803     return NPT_FAILURE;
 804 }
 805
 806 /*----------------------------------------------------------------------
 807 |   PLT_DeviceData::FindServiceByEventSubURL
 808 +---------------------------------------------------------------------*/
 809 NPT_Result
 810 PLT_DeviceData::FindServiceByEventSubURL(const char*   url,
 811                                          PLT_Service*& service,
 812                                          bool          recursive /* = false */)
 813 {
 814     NPT_Result res = NPT_ContainerFind(m_Services,
 815         PLT_ServiceEventSubURLFinder(url),
 816         service);
 817     if (NPT_SUCCEEDED(res)) return res;
 818
 819     if (recursive) {
 820         for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
 821             res = m_EmbeddedDevices[i]->FindServiceByEventSubURL(
 822                 url,
 823                 service,
 824                 recursive);
 825             if (NPT_SUCCEEDED(res)) return res;
 826         }
 827     }
 828
 829     return NPT_FAILURE;
 830 }