src/UPnPBase.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2004-2008 Marcelo Roberto Jimenez ( phoenix@amule.org )
   5 // Copyright (c) 2006-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26 #define UPNP_C
  27
  28 #include "UPnPBase.h"
  29
  30
  31 #include <dlfcn.h>              // For dlopen(), dlsym(), dlclose()
  32 #include <algorithm>            // For transform()
  33
  34
  35 #ifdef __GNUC__
  36         #if __GNUC__ >= 4
  37                 #define REINTERPRET_CAST(x) reinterpret_cast<x>
  38         #endif
  39 #endif
  40 #ifndef REINTERPRET_CAST
  41         // Let's hope that function pointers are equal in size to data pointers
  42         #define REINTERPRET_CAST(x) (x)
  43 #endif
  44
  45
  46 /**
  47  * Case insensitive std::string comparison
  48  */
  49 bool stdStringIsEqualCI(const std::string &s1, const std::string &s2)
  50 {
  51         std::string ns1(s1);
  52         std::string ns2(s2);
  53         std::transform(ns1.begin(), ns1.end(), ns1.begin(), tolower);
  54         std::transform(ns2.begin(), ns2.end(), ns2.begin(), tolower);
  55         return ns1 == ns2;
  56 }
  57
  58
  59 CUPnPPortMapping::CUPnPPortMapping(
  60         int port,
  61         const std::string &protocol,
  62         bool enabled,
  63         const std::string &description)
  64 :
  65 m_port(),
  66 m_protocol(protocol),
  67 m_enabled(enabled ? "1" : "0"),
  68 m_description(description),
  69 m_key()
  70 {
  71         std::ostringstream oss;
  72         oss << port;
  73         m_port = oss.str();
  74         m_key = m_protocol + m_port;
  75 }
  76
  77
  78 const std::string &CUPnPLib::UPNP_ROOT_DEVICE =
  79         "upnp:rootdevice";
  80
  81 const std::string &CUPnPLib::UPNP_DEVICE_IGW =
  82         "urn:schemas-upnp-org:device:InternetGatewayDevice:1";
  83 const std::string &CUPnPLib::UPNP_DEVICE_WAN =
  84         "urn:schemas-upnp-org:device:WANDevice:1";
  85 const std::string &CUPnPLib::UPNP_DEVICE_WAN_CONNECTION =
  86         "urn:schemas-upnp-org:device:WANConnectionDevice:1";
  87 const std::string &CUPnPLib::UPNP_DEVICE_LAN =
  88         "urn:schemas-upnp-org:device:LANDevice:1";
  89
  90 const std::string &CUPnPLib::UPNP_SERVICE_LAYER3_FORWARDING =
  91         "urn:schemas-upnp-org:service:Layer3Forwarding:1";
  92 const std::string &CUPnPLib::UPNP_SERVICE_WAN_COMMON_INTERFACE_CONFIG =
  93         "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1";
  94 const std::string &CUPnPLib::UPNP_SERVICE_WAN_IP_CONNECTION =
  95         "urn:schemas-upnp-org:service:WANIPConnection:1";
  96 const std::string &CUPnPLib::UPNP_SERVICE_WAN_PPP_CONNECTION =
  97         "urn:schemas-upnp-org:service:WANPPPConnection:1";
  98
  99
 100 CUPnPLib::CUPnPLib(CUPnPControlPoint &ctrlPoint)
 101 :
 102 m_ctrlPoint(ctrlPoint)
 103 {
 104 }
 105
 106
 107 std::string CUPnPLib::GetUPnPErrorMessage(int code) const
 108 {
 109         return UpnpGetErrorMessage(code);
 110 }
 111
 112
 113 std::string CUPnPLib::processUPnPErrorMessage(
 114         const std::string &messsage,
 115         int errorCode,
 116         const DOMString errorString,
 117         IXML_Document *doc) const
 118 {
 119         std::ostringstream msg;
 120         if (errorString == NULL || *errorString == 0) {
 121                 errorString = "Not available";
 122         }
 123         if (errorCode > 0) {
 124                 msg << "Error: " <<
 125                         messsage <<
 126                         ": Error code :'";
 127                 if (doc) {
 128                         CUPnPError e(*this, doc);
 129                         msg << e.getErrorCode() <<
 130                                 "', Error description :'" <<
 131                                 e.getErrorDescription() <<
 132                                 "'.";
 133                 } else {
 134                         msg << errorCode <<
 135                                 "', Error description :'" <<
 136                                 errorString <<
 137                                 "'.";
 138                 }
 139                 AddLogLineU(false, logUPnP, msg);
 140         } else {
 141                 msg << "Error: " <<
 142                         messsage <<
 143                         ": UPnP SDK error: " <<
 144                         GetUPnPErrorMessage(errorCode) <<
 145                         " (" << errorCode << ").";
 146                 AddLogLineU(false, logUPnP, msg);
 147         }
 148
 149         return msg.str();
 150 }
 151
 152
 153 void CUPnPLib::ProcessActionResponse(
 154         IXML_Document *RespDoc,
 155         const std::string &actionName) const
 156 {
 157         std::ostringstream msg;
 158         msg << "Response: ";
 159         IXML_Element *root = Element_GetRootElement(RespDoc);
 160         IXML_Element *child = Element_GetFirstChild(root);
 161         if (child) {
 162                 while (child) {
 163                         const DOMString childTag = Element_GetTag(child);
 164                         std::string childValue = Element_GetTextValue(child);
 165                         msg << "\n    " <<
 166                                 childTag << "='" <<
 167                                 childValue << "'";
 168                         child = Element_GetNextSibling(child);
 169                 }
 170         } else {
 171                 msg << "\n    Empty response for action '" <<
 172                         actionName << "'.";
 173         }
 174         AddDebugLogLineM(false, logUPnP, msg);
 175 }
 176
 177
 178 /*!
 179  * \brief Returns the root node of a given document.
 180  */
 181 IXML_Element *CUPnPLib::Element_GetRootElement(
 182         IXML_Document *doc) const
 183 {
 184         IXML_Element *root = REINTERPRET_CAST(IXML_Element *)(
 185                 ixmlNode_getFirstChild(
 186                         REINTERPRET_CAST(IXML_Node *)(doc)));
 187
 188         return root;
 189 }
 190
 191
 192 /*!
 193  * \brief Returns the first child of a given element.
 194  */
 195 IXML_Element *CUPnPLib::Element_GetFirstChild(
 196         IXML_Element *parent) const
 197 {
 198         IXML_Node *node = REINTERPRET_CAST(IXML_Node *)(parent);
 199         IXML_Node *child = ixmlNode_getFirstChild(node);
 200
 201         return REINTERPRET_CAST(IXML_Element *)(child);
 202 }
 203
 204
 205 /*!
 206  * \brief Returns the next sibling of a given child.
 207  */
 208 IXML_Element *CUPnPLib::Element_GetNextSibling(
 209         IXML_Element *child) const
 210 {
 211         IXML_Node *node = REINTERPRET_CAST(IXML_Node *)(child);
 212         IXML_Node *sibling = ixmlNode_getNextSibling(node);
 213
 214         return REINTERPRET_CAST(IXML_Element *)(sibling);
 215 }
 216
 217
 218 /*!
 219  * \brief Returns the element tag (name)
 220  */
 221 const DOMString CUPnPLib::Element_GetTag(
 222         IXML_Element *element) const
 223 {
 224         IXML_Node *node = REINTERPRET_CAST(IXML_Node *)(element);
 225         const DOMString tag = ixmlNode_getNodeName(node);
 226
 227         return tag;
 228 }
 229
 230
 231 /*!
 232  * \brief Returns the TEXT node value of the current node.
 233  */
 234 const std::string CUPnPLib::Element_GetTextValue(
 235         IXML_Element *element) const
 236 {
 237         if (!element) {
 238                 return stdEmptyString;
 239         }
 240         IXML_Node *text = ixmlNode_getFirstChild(
 241                 REINTERPRET_CAST(IXML_Node *)(element));
 242         const DOMString s = ixmlNode_getNodeValue(text);
 243         std::string ret;
 244         if (s) {
 245                 ret = s;
 246         }
 247
 248         return ret;
 249 }
 250
 251
 252 /*!
 253  * \brief Returns the TEXT node value of the first child matching tag.
 254  */
 255 const std::string CUPnPLib::Element_GetChildValueByTag(
 256         IXML_Element *element,
 257         const DOMString tag) const
 258 {
 259         IXML_Element *child =
 260                 Element_GetFirstChildByTag(element, tag);
 261
 262         return Element_GetTextValue(child);
 263 }
 264
 265
 266 /*!
 267  * \brief Returns the first child element that matches the requested tag or
 268  * NULL if not found.
 269  */
 270 IXML_Element *CUPnPLib::Element_GetFirstChildByTag(
 271         IXML_Element *element,
 272         const DOMString tag) const
 273 {
 274         if (!element || !tag) {
 275                 return NULL;
 276         }
 277
 278         IXML_Node *node = REINTERPRET_CAST(IXML_Node *)(element);
 279         IXML_Node *child = ixmlNode_getFirstChild(node);
 280         const DOMString childTag = ixmlNode_getNodeName(child);
 281         while(child && childTag && strcmp(tag, childTag)) {
 282                 child = ixmlNode_getNextSibling(child);
 283                 childTag = ixmlNode_getNodeName(child);
 284         }
 285
 286         return REINTERPRET_CAST(IXML_Element *)(child);
 287 }
 288
 289
 290 /*!
 291  * \brief Returns the next sibling element that matches the requested tag. Should be
 292  * used with the return value of Element_GetFirstChildByTag().
 293  */
 294 IXML_Element *CUPnPLib::Element_GetNextSiblingByTag(
 295         IXML_Element *element, const DOMString tag) const
 296 {
 297         if (!element || !tag) {
 298                 return NULL;
 299         }
 300
 301         IXML_Node *child = REINTERPRET_CAST(IXML_Node *)(element);
 302         const DOMString childTag = NULL;
 303         do {
 304                 child = ixmlNode_getNextSibling(child);
 305                 childTag = ixmlNode_getNodeName(child);
 306         } while(child && childTag && strcmp(tag, childTag));
 307
 308         return REINTERPRET_CAST(IXML_Element *)(child);
 309 }
 310
 311
 312 const std::string CUPnPLib::Element_GetAttributeByTag(
 313         IXML_Element *element, const DOMString tag) const
 314 {
 315         IXML_NamedNodeMap *NamedNodeMap = ixmlNode_getAttributes(
 316                 REINTERPRET_CAST(IXML_Node *)(element));
 317         IXML_Node *attribute = ixmlNamedNodeMap_getNamedItem(NamedNodeMap, tag);
 318         const DOMString s = ixmlNode_getNodeValue(attribute);
 319         std::string ret;
 320         if (s) {
 321                 ret = s;
 322         }
 323         ixmlNamedNodeMap_free(NamedNodeMap);
 324
 325         return ret;
 326 }
 327
 328
 329 CUPnPError::CUPnPError(
 330         const CUPnPLib &upnpLib,
 331         IXML_Document *errorDoc)
 332 :
 333 m_root            (upnpLib.Element_GetRootElement(errorDoc)),
 334 m_ErrorCode       (upnpLib.Element_GetChildValueByTag(m_root, "errorCode")),
 335 m_ErrorDescription(upnpLib.Element_GetChildValueByTag(m_root, "errorDescription"))
 336 {
 337 }
 338
 339
 340 CUPnPArgument::CUPnPArgument(
 341         const CUPnPControlPoint &upnpControlPoint,
 342         CUPnPLib &upnpLib,
 343         IXML_Element *argument,
 344         const std::string &WXUNUSED(SCPDURL))
 345 :
 346 m_UPnPControlPoint(upnpControlPoint),
 347 m_name                (upnpLib.Element_GetChildValueByTag(argument, "name")),
 348 m_direction           (upnpLib.Element_GetChildValueByTag(argument, "direction")),
 349 m_retval              (upnpLib.Element_GetFirstChildByTag(argument, "retval")),
 350 m_relatedStateVariable(upnpLib.Element_GetChildValueByTag(argument, "relatedStateVariable"))
 351 {
 352         std::ostringstream msg;
 353         msg <<  "\n    Argument:"                  <<
 354                 "\n        name: "                 << m_name <<
 355                 "\n        direction: "            << m_direction <<
 356                 "\n        retval: "               << m_retval <<
 357                 "\n        relatedStateVariable: " << m_relatedStateVariable;
 358         AddDebugLogLineM(false, logUPnP, msg);
 359 }
 360
 361
 362 CUPnPAction::CUPnPAction(
 363         const CUPnPControlPoint &upnpControlPoint,
 364         CUPnPLib &upnpLib,
 365         IXML_Element *action,
 366         const std::string &SCPDURL)
 367 :
 368 m_UPnPControlPoint(upnpControlPoint),
 369 m_ArgumentList(upnpControlPoint, upnpLib, action, SCPDURL),
 370 m_name(upnpLib.Element_GetChildValueByTag(action, "name"))
 371 {
 372         std::ostringstream msg;
 373         msg <<  "\n    Action:"    <<
 374                 "\n        name: " << m_name;
 375         AddDebugLogLineM(false, logUPnP, msg);
 376 }
 377
 378
 379 CUPnPAllowedValue::CUPnPAllowedValue(
 380         const CUPnPControlPoint &upnpControlPoint,
 381         CUPnPLib &upnpLib,
 382         IXML_Element *allowedValue,
 383         const std::string &WXUNUSED(SCPDURL))
 384 :
 385 m_UPnPControlPoint(upnpControlPoint),
 386 m_allowedValue(upnpLib.Element_GetTextValue(allowedValue))
 387 {
 388         std::ostringstream msg;
 389         msg <<  "\n    AllowedValue:"      <<
 390                 "\n        allowedValue: " << m_allowedValue;
 391         AddDebugLogLineM(false, logUPnP, msg);
 392 }
 393
 394
 395 CUPnPStateVariable::CUPnPStateVariable(
 396         const CUPnPControlPoint &upnpControlPoint,
 397         CUPnPLib &upnpLib,
 398         IXML_Element *stateVariable,
 399         const std::string &SCPDURL)
 400 :
 401 m_UPnPControlPoint(upnpControlPoint),
 402 m_AllowedValueList(upnpControlPoint, upnpLib, stateVariable, SCPDURL),
 403 m_name        (upnpLib.Element_GetChildValueByTag(stateVariable, "name")),
 404 m_dataType    (upnpLib.Element_GetChildValueByTag(stateVariable, "dataType")),
 405 m_defaultValue(upnpLib.Element_GetChildValueByTag(stateVariable, "defaultValue")),
 406 m_sendEvents  (upnpLib.Element_GetAttributeByTag (stateVariable, "sendEvents"))
 407 {
 408         std::ostringstream msg;
 409         msg <<  "\n    StateVariable:"     <<
 410                 "\n        name: "         << m_name <<
 411                 "\n        dataType: "     << m_dataType <<
 412                 "\n        defaultValue: " << m_defaultValue <<
 413                 "\n        sendEvents: "   << m_sendEvents;
 414         AddDebugLogLineM(false, logUPnP, msg);
 415 }
 416
 417
 418 CUPnPSCPD::CUPnPSCPD(
 419         const CUPnPControlPoint &upnpControlPoint,
 420         CUPnPLib &upnpLib,
 421         IXML_Element *scpd,
 422         const std::string &SCPDURL)
 423 :
 424 m_UPnPControlPoint(upnpControlPoint),
 425 m_ActionList(upnpControlPoint, upnpLib, scpd, SCPDURL),
 426 m_ServiceStateTable(upnpControlPoint, upnpLib, scpd, SCPDURL),
 427 m_SCPDURL(SCPDURL)
 428 {
 429 }
 430
 431
 432 CUPnPArgumentValue::CUPnPArgumentValue()
 433 :
 434 m_argument(),
 435 m_value()
 436 {
 437 }
 438
 439
 440 CUPnPArgumentValue::CUPnPArgumentValue(
 441         const std::string &argument, const std::string &value)
 442 :
 443 m_argument(argument),
 444 m_value(value)
 445 {
 446 }
 447
 448
 449 CUPnPService::CUPnPService(
 450         const CUPnPControlPoint &upnpControlPoint,
 451         CUPnPLib &upnpLib,
 452         IXML_Element *service,
 453         const std::string &URLBase)
 454 :
 455 m_UPnPControlPoint(upnpControlPoint),
 456 m_upnpLib(upnpLib),
 457 m_serviceType(upnpLib.Element_GetChildValueByTag(service, "serviceType")),
 458 m_serviceId  (upnpLib.Element_GetChildValueByTag(service, "serviceId")),
 459 m_SCPDURL    (upnpLib.Element_GetChildValueByTag(service, "SCPDURL")),
 460 m_controlURL (upnpLib.Element_GetChildValueByTag(service, "controlURL")),
 461 m_eventSubURL(upnpLib.Element_GetChildValueByTag(service, "eventSubURL")),
 462 m_timeout(1801),
 463 m_SCPD(NULL)
 464 {
 465         std::ostringstream msg;
 466         int errcode;
 467
 468         std::vector<char> vscpdURL(URLBase.length() + m_SCPDURL.length() + 1);
 469         char *scpdURL = &vscpdURL[0];
 470         errcode = UpnpResolveURL(
 471                 URLBase.c_str(),
 472                 m_SCPDURL.c_str(),
 473                 scpdURL);
 474         if( errcode != UPNP_E_SUCCESS ) {
 475                 msg << "Error generating scpdURL from " <<
 476                         "|" << URLBase << "|" <<
 477                         m_SCPDURL << "|.";
 478                 AddDebugLogLineM(false, logUPnP, msg);
 479         } else {
 480                 m_absSCPDURL = scpdURL;
 481         }
 482
 483         std::vector<char> vcontrolURL(
 484                 URLBase.length() + m_controlURL.length() + 1);
 485         char *controlURL = &vcontrolURL[0];
 486         errcode = UpnpResolveURL(
 487                 URLBase.c_str(),
 488                 m_controlURL.c_str(),
 489                 controlURL);
 490         if( errcode != UPNP_E_SUCCESS ) {
 491                 msg << "Error generating controlURL from " <<
 492                         "|" << URLBase << "|" <<
 493                         m_controlURL << "|.";
 494                 AddDebugLogLineM(false, logUPnP, msg);
 495         } else {
 496                 m_absControlURL = controlURL;
 497         }
 498
 499         std::vector<char> veventURL(
 500                 URLBase.length() + m_eventSubURL.length() + 1);
 501         char *eventURL = &veventURL[0];
 502         errcode = UpnpResolveURL(
 503                 URLBase.c_str(),
 504                 m_eventSubURL.c_str(),
 505                 eventURL);
 506         if( errcode != UPNP_E_SUCCESS ) {
 507                 msg << "Error generating eventURL from " <<
 508                         "|" << URLBase << "|" <<
 509                         m_eventSubURL << "|.";
 510                 AddDebugLogLineM(false, logUPnP, msg);
 511         } else {
 512                 m_absEventSubURL = eventURL;
 513         }
 514
 515         msg <<  "\n    Service:"             <<
 516                 "\n        serviceType: "    << m_serviceType <<
 517                 "\n        serviceId: "      << m_serviceId <<
 518                 "\n        SCPDURL: "        << m_SCPDURL <<
 519                 "\n        absSCPDURL: "     << m_absSCPDURL <<
 520                 "\n        controlURL: "     << m_controlURL <<
 521                 "\n        absControlURL: "  << m_absControlURL <<
 522                 "\n        eventSubURL: "    << m_eventSubURL <<
 523                 "\n        absEventSubURL: " << m_absEventSubURL;
 524         AddDebugLogLineM(false, logUPnP, msg);
 525
 526         if (m_serviceType == upnpLib.UPNP_SERVICE_WAN_IP_CONNECTION ||
 527             m_serviceType == upnpLib.UPNP_SERVICE_WAN_PPP_CONNECTION) {
 528 #if 0
 529             m_serviceType == upnpLib.UPNP_SERVICE_WAN_PPP_CONNECTION ||
 530             m_serviceType == upnpLib.UPNP_SERVICE_WAN_COMMON_INTERFACE_CONFIG ||
 531             m_serviceType == upnpLib.UPNP_SERVICE_LAYER3_FORWARDING) {
 532 #endif
 533 #if 0
 534 //#warning Delete this code on release.
 535                 if (!upnpLib.m_ctrlPoint.WanServiceDetected()) {
 536                         // This condition can be used to suspend the parse
 537                         // of the XML tree.
 538 #endif
 539 //#warning Delete this code when m_WanService is no longer used.
 540                         upnpLib.m_ctrlPoint.SetWanService(this);
 541                         // Log it
 542                         msg.str("");
 543                         msg << "WAN Service Detected: '" <<
 544                                 m_serviceType << "'.";
 545                         AddDebugLogLineM(true, logUPnP, msg);
 546                         // Subscribe
 547                         upnpLib.m_ctrlPoint.Subscribe(*this);
 548 #if 0
 549 //#warning Delete this code on release.
 550                 } else {
 551                         msg.str("");
 552                         msg << "WAN service detected again: '" <<
 553                                 m_serviceType <<
 554                                 "'. Will only use the first instance.";
 555                         AddDebugLogLineM(true, logUPnP, msg);
 556                 }
 557 #endif
 558         } else {
 559                 msg.str("");
 560                 msg << "Uninteresting service detected: '" <<
 561                         m_serviceType << "'. Ignoring.";
 562                 AddDebugLogLineM(true, logUPnP, msg);
 563         }
 564 }
 565
 566
 567 CUPnPService::~CUPnPService()
 568 {
 569 }
 570
 571
 572 bool CUPnPService::Execute(
 573         const std::string &ActionName,
 574         const std::vector<CUPnPArgumentValue> &ArgValue) const
 575 {
 576         std::ostringstream msg;
 577         if (m_SCPD.get() == NULL) {
 578                 msg << "Service without SCPD Document, cannot execute action '" << ActionName <<
 579                         "' for service '" << GetServiceType() << "'.";
 580                 AddDebugLogLineM(false, logUPnP, msg);
 581                 return false;
 582         }
 583         std::ostringstream msgAction("Sending action ");
 584         // Check for correct action name
 585         ActionList::const_iterator itAction =
 586                 m_SCPD->GetActionList().find(ActionName);
 587         if (itAction == m_SCPD->GetActionList().end()) {
 588                 msg << "Invalid action name '" << ActionName <<
 589                         "' for service '" << GetServiceType() << "'.";
 590                 AddDebugLogLineM(false, logUPnP, msg);
 591                 return false;
 592         }
 593         msgAction << ActionName << "(";
 594         bool firstTime = true;
 595         // Check for correct Argument/Value pairs
 596         const CUPnPAction &action = *(itAction->second);
 597         for (unsigned int i = 0; i < ArgValue.size(); ++i) {
 598                 ArgumentList::const_iterator itArg =
 599                         action.GetArgumentList().find(ArgValue[i].GetArgument());
 600                 if (itArg == action.GetArgumentList().end()) {
 601                         msg << "Invalid argument name '" << ArgValue[i].GetArgument() <<
 602                                 "' for action '" << action.GetName() <<
 603                                 "' for service '" << GetServiceType() << "'.";
 604                         AddDebugLogLineM(false, logUPnP, msg);
 605                         return false;
 606                 }
 607                 const CUPnPArgument &argument = *(itArg->second);
 608                 if (tolower(argument.GetDirection()[0]) != 'i' ||
 609                     tolower(argument.GetDirection()[1]) != 'n') {
 610                         msg << "Invalid direction for argument '" <<
 611                                 ArgValue[i].GetArgument() <<
 612                                 "' for action '" << action.GetName() <<
 613                                 "' for service '" << GetServiceType() << "'.";
 614                         AddDebugLogLineM(false, logUPnP, msg);
 615                         return false;
 616                 }
 617                 const std::string relatedStateVariableName =
 618                         argument.GetRelatedStateVariable();
 619                 if (!relatedStateVariableName.empty()) {
 620                         ServiceStateTable::const_iterator itSVT =
 621                                 m_SCPD->GetServiceStateTable().
 622                                 find(relatedStateVariableName);
 623                         if (itSVT == m_SCPD->GetServiceStateTable().end()) {
 624                                 msg << "Inconsistent Service State Table, did not find '" <<
 625                                         relatedStateVariableName <<
 626                                         "' for argument '" << argument.GetName() <<
 627                                         "' for action '" << action.GetName() <<
 628                                         "' for service '" << GetServiceType() << "'.";
 629                                 AddDebugLogLineM(false, logUPnP, msg);
 630                                 return false;
 631                         }
 632                         const CUPnPStateVariable &stateVariable = *(itSVT->second);
 633                         if (    !stateVariable.GetAllowedValueList().empty() &&
 634                                 stateVariable.GetAllowedValueList().find(ArgValue[i].GetValue()) ==
 635                                         stateVariable.GetAllowedValueList().end()) {
 636                                 msg << "Value not allowed '" << ArgValue[i].GetValue() <<
 637                                         "' for state variable '" << relatedStateVariableName <<
 638                                         "' for argument '" << argument.GetName() <<
 639                                         "' for action '" << action.GetName() <<
 640                                         "' for service '" << GetServiceType() << "'.";
 641                                 AddDebugLogLineM(false, logUPnP, msg);
 642                                 return false;
 643                         }
 644                 }
 645                 if (firstTime) {
 646                         firstTime = false;
 647                 } else {
 648                         msgAction << ", ";
 649                 }
 650                 msgAction <<
 651                         ArgValue[i].GetArgument() <<
 652                         "='" <<
 653                         ArgValue[i].GetValue() <<
 654                         "'";
 655         }
 656         msgAction << ")";
 657         AddDebugLogLineM(false, logUPnP, msgAction);
 658         // Everything is ok, make the action
 659         IXML_Document *ActionDoc = NULL;
 660         if (ArgValue.size()) {
 661                 for (unsigned int i = 0; i < ArgValue.size(); ++i) {
 662                         int ret = UpnpAddToAction(
 663                                 &ActionDoc,
 664                                 action.GetName().c_str(),
 665                                 GetServiceType().c_str(),
 666                                 ArgValue[i].GetArgument().c_str(),
 667                                 ArgValue[i].GetValue().c_str());
 668                         if (ret != UPNP_E_SUCCESS) {
 669                                 m_upnpLib.processUPnPErrorMessage(
 670                                         "UpnpAddToAction", ret, NULL, NULL);
 671                                 return false;
 672                         }
 673                 }
 674         } else {
 675                 ActionDoc = UpnpMakeAction(
 676                         action.GetName().c_str(),
 677                         GetServiceType().c_str(),
 678                         0, NULL);
 679                 if (!ActionDoc) {
 680                         msg << "Error: UpnpMakeAction returned NULL.";
 681                         AddLogLineU(false, logUPnP, msg);
 682                         return false;
 683                 }
 684         }
 685 #if 0
 686         // Send the action asynchronously
 687         UpnpSendActionAsync(
 688                 m_UPnPControlPoint.GetUPnPClientHandle(),
 689                 GetAbsControlURL().c_str(),
 690                 GetServiceType().c_str(),
 691                 NULL, ActionDoc,
 692                 static_cast<Upnp_FunPtr>(&CUPnPControlPoint::Callback),
 693                 NULL);
 694         return true;
 695 #endif
 696
 697         // Send the action synchronously
 698         IXML_Document *RespDoc = NULL;
 699         int ret = UpnpSendAction(
 700                 m_UPnPControlPoint.GetUPnPClientHandle(),
 701                 GetAbsControlURL().c_str(),
 702                 GetServiceType().c_str(),
 703                 NULL, ActionDoc, &RespDoc);
 704         if (ret != UPNP_E_SUCCESS) {
 705                 m_upnpLib.processUPnPErrorMessage(
 706                         "UpnpSendAction", ret, NULL, RespDoc);
 707                 ixmlDocument_free(ActionDoc);
 708                 ixmlDocument_free(RespDoc);
 709                 return false;
 710         }
 711         ixmlDocument_free(ActionDoc);
 712
 713         // Check the response document
 714         m_upnpLib.ProcessActionResponse(
 715                 RespDoc, action.GetName());
 716
 717         // Free the response document
 718         ixmlDocument_free(RespDoc);
 719
 720         return true;
 721 }
 722
 723
 724 const std::string CUPnPService::GetStateVariable(
 725         const std::string &stateVariableName) const
 726 {
 727         std::ostringstream msg;
 728         DOMString StVarVal;
 729         int ret = UpnpGetServiceVarStatus(
 730                 m_UPnPControlPoint.GetUPnPClientHandle(),
 731                 GetAbsControlURL().c_str(),
 732                 stateVariableName.c_str(),
 733                 &StVarVal);
 734         if (ret != UPNP_E_SUCCESS) {
 735                 msg << "GetStateVariable(\"" <<
 736                         stateVariableName <<
 737                         "\"): in a call to UpnpGetServiceVarStatus";
 738                 m_upnpLib.processUPnPErrorMessage(
 739                         msg.str(), ret, StVarVal, NULL);
 740                 return stdEmptyString;
 741         }
 742         msg << "GetStateVariable: " <<
 743                 stateVariableName <<
 744                 "='" <<
 745                 StVarVal <<
 746                 "'.";
 747         AddDebugLogLineM(false, logUPnP, msg);
 748         return stdEmptyString;
 749 }
 750
 751
 752 CUPnPDevice::CUPnPDevice(
 753         const CUPnPControlPoint &upnpControlPoint,
 754         CUPnPLib &upnpLib,
 755         IXML_Element *device,
 756         const std::string &URLBase)
 757 :
 758 m_UPnPControlPoint(upnpControlPoint),
 759 m_DeviceList(upnpControlPoint, upnpLib, device, URLBase),
 760 m_ServiceList(upnpControlPoint, upnpLib, device, URLBase),
 761 m_deviceType       (upnpLib.Element_GetChildValueByTag(device, "deviceType")),
 762 m_friendlyName     (upnpLib.Element_GetChildValueByTag(device, "friendlyName")),
 763 m_manufacturer     (upnpLib.Element_GetChildValueByTag(device, "manufacturer")),
 764 m_manufacturerURL  (upnpLib.Element_GetChildValueByTag(device, "manufacturerURL")),
 765 m_modelDescription (upnpLib.Element_GetChildValueByTag(device, "modelDescription")),
 766 m_modelName        (upnpLib.Element_GetChildValueByTag(device, "modelName")),
 767 m_modelNumber      (upnpLib.Element_GetChildValueByTag(device, "modelNumber")),
 768 m_modelURL         (upnpLib.Element_GetChildValueByTag(device, "modelURL")),
 769 m_serialNumber     (upnpLib.Element_GetChildValueByTag(device, "serialNumber")),
 770 m_UDN              (upnpLib.Element_GetChildValueByTag(device, "UDN")),
 771 m_UPC              (upnpLib.Element_GetChildValueByTag(device, "UPC")),
 772 m_presentationURL  (upnpLib.Element_GetChildValueByTag(device, "presentationURL"))
 773 {
 774         std::ostringstream msg;
 775         int presURLlen = strlen(URLBase.c_str()) +
 776                 strlen(m_presentationURL.c_str()) + 2;
 777         std::vector<char> vpresURL(presURLlen);
 778         char* presURL = &vpresURL[0];
 779         int errcode = UpnpResolveURL(
 780                 URLBase.c_str(),
 781                 m_presentationURL.c_str(),
 782                 presURL);
 783         if (errcode != UPNP_E_SUCCESS) {
 784                 msg << "Error generating presentationURL from " <<
 785                         "|" << URLBase << "|" <<
 786                         m_presentationURL << "|.";
 787                 AddDebugLogLineM(false, logUPnP, msg);
 788         } else {
 789                 m_presentationURL = presURL;
 790         }
 791
 792         msg.str("");
 793         msg <<  "\n    Device: "                <<
 794                 "\n        friendlyName: "      << m_friendlyName <<
 795                 "\n        deviceType: "        << m_deviceType <<
 796                 "\n        manufacturer: "      << m_manufacturer <<
 797                 "\n        manufacturerURL: "   << m_manufacturerURL <<
 798                 "\n        modelDescription: "  << m_modelDescription <<
 799                 "\n        modelName: "         << m_modelName <<
 800                 "\n        modelNumber: "       << m_modelNumber <<
 801                 "\n        modelURL: "          << m_modelURL <<
 802                 "\n        serialNumber: "      << m_serialNumber <<
 803                 "\n        UDN: "               << m_UDN <<
 804                 "\n        UPC: "               << m_UPC <<
 805                 "\n        presentationURL: "   << m_presentationURL;
 806         AddDebugLogLineM(false, logUPnP, msg);
 807 }
 808
 809
 810 CUPnPRootDevice::CUPnPRootDevice(
 811         const CUPnPControlPoint &upnpControlPoint,
 812         CUPnPLib &upnpLib,
 813         IXML_Element *rootDevice,
 814         const std::string &OriginalURLBase,
 815         const std::string &FixedURLBase,
 816         const char *location,
 817         int expires)
 818 :
 819 CUPnPDevice(upnpControlPoint, upnpLib, rootDevice, FixedURLBase),
 820 m_UPnPControlPoint(upnpControlPoint),
 821 m_URLBase(OriginalURLBase),
 822 m_location(location),
 823 m_expires(expires)
 824 {
 825         std::ostringstream msg;
 826         msg <<
 827                 "\n    Root Device: "       <<
 828                 "\n        URLBase: "       << m_URLBase <<
 829                 "\n        Fixed URLBase: " << FixedURLBase <<
 830                 "\n        location: "      << m_location <<
 831                 "\n        expires: "       << m_expires;
 832         AddDebugLogLineM(false, logUPnP, msg);
 833 }
 834
 835
 836 CUPnPControlPoint *CUPnPControlPoint::s_CtrlPoint = NULL;
 837
 838
 839 CUPnPControlPoint::CUPnPControlPoint(unsigned short udpPort)
 840 :
 841 m_upnpLib(*this),
 842 m_UPnPClientHandle(),
 843 m_RootDeviceMap(),
 844 m_ServiceMap(),
 845 m_ActivePortMappingsMap(),
 846 m_RootDeviceListMutex(),
 847 m_IGWDeviceDetected(false),
 848 m_WanService(NULL)
 849 {
 850         // Pointer to self
 851         s_CtrlPoint = this;
 852         // Null string at first
 853         std::ostringstream msg;
 854
 855         // Start UPnP
 856         int ret;
 857         char *ipAddress = NULL;
 858         unsigned short port = 0;
 859         ret = UpnpInit(ipAddress, udpPort);
 860         if (ret != UPNP_E_SUCCESS) {
 861                 msg << "error(UpnpInit): Error code ";
 862                 goto error;
 863         }
 864         port = UpnpGetServerPort();
 865         ipAddress = UpnpGetServerIpAddress();
 866         msg << "bound to " << ipAddress << ":" <<
 867                 port << ".";
 868         AddLogLineU(false, logUPnP, msg);
 869         msg.str("");
 870         ret = UpnpRegisterClient(
 871                 static_cast<Upnp_FunPtr>(&CUPnPControlPoint::Callback),
 872                 &m_UPnPClientHandle,
 873                 &m_UPnPClientHandle);
 874         if (ret != UPNP_E_SUCCESS) {
 875                 msg << "error(UpnpRegisterClient): Error registering callback: ";
 876                 goto error;
 877         }
 878
 879         // We could ask for just the right device here. If the root device
 880         // contains the device we want, it will respond with the full XML doc,
 881         // including the root device and every sub-device it has.
 882         //
 883         // But lets find out what we have in our network by calling UPNP_ROOT_DEVICE.
 884         //
 885         // We should not search twice, because this will produce two
 886         // UPNP_DISCOVERY_SEARCH_TIMEOUT events, and we might end with problems
 887         // on the mutex.
 888         ret = UpnpSearchAsync(m_UPnPClientHandle, 3, m_upnpLib.UPNP_ROOT_DEVICE.c_str(), NULL);
 889         //ret = UpnpSearchAsync(m_UPnPClientHandle, 3, m_upnpLib.UPNP_DEVICE_IGW.c_str(), this);
 890         //ret = UpnpSearchAsync(m_UPnPClientHandle, 3, m_upnpLib.UPNP_DEVICE_LAN.c_str(), this);
 891         //ret = UpnpSearchAsync(m_UPnPClientHandle, 3, m_upnpLib.UPNP_DEVICE_WAN_CONNECTION.c_str(), this);
 892         if (ret != UPNP_E_SUCCESS) {
 893                 msg << "error(UpnpSearchAsync): Error sending search request: ";
 894                 goto error;
 895         }
 896
 897         // Wait for the UPnP initialization to complete.
 898         {
 899                 // Lock the search timeout mutex
 900                 m_WaitForSearchTimeoutMutex.Lock();
 901
 902                 // Lock it again, so that we block. Unlocking will only happen
 903                 // when the UPNP_DISCOVERY_SEARCH_TIMEOUT event occurs at the
 904                 // callback.
 905                 CUPnPMutexLocker lock(m_WaitForSearchTimeoutMutex);
 906         }
 907         return;
 908
 909         // Error processing
 910 error:
 911         UpnpFinish();
 912         msg << ret << ": " << m_upnpLib.GetUPnPErrorMessage(ret) << ".";
 913         throw CUPnPException(msg);
 914 }
 915
 916
 917 CUPnPControlPoint::~CUPnPControlPoint()
 918 {
 919         for(    RootDeviceMap::iterator it = m_RootDeviceMap.begin();
 920                 it != m_RootDeviceMap.end();
 921                 ++it) {
 922                 delete it->second;
 923         }
 924         // Remove all first
 925         // RemoveAll();
 926         UpnpUnRegisterClient(m_UPnPClientHandle);
 927         UpnpFinish();
 928 }
 929
 930
 931 bool CUPnPControlPoint::AddPortMappings(
 932         std::vector<CUPnPPortMapping> &upnpPortMapping)
 933 {
 934         std::ostringstream msg;
 935         if (!WanServiceDetected()) {
 936                 msg <<  "UPnP Error: "
 937                         "CUPnPControlPoint::AddPortMapping: "
 938                         "WAN Service not detected.";
 939                 AddLogLineU(true, logUPnP, msg);
 940                 return false;
 941         }
 942
 943         int n = upnpPortMapping.size();
 944         bool ok = false;
 945
 946         // Check the number of port mappings before
 947         std::istringstream PortMappingNumberOfEntries(
 948                 m_WanService->GetStateVariable(
 949                         "PortMappingNumberOfEntries"));
 950         unsigned long oldNumberOfEntries;
 951         PortMappingNumberOfEntries >> oldNumberOfEntries;
 952
 953         // Add the enabled port mappings
 954         for (int i = 0; i < n; ++i) {
 955                 if (upnpPortMapping[i].getEnabled() == "1") {
 956                         // Add the mapping to the control point
 957                         // active mappings list
 958                         m_ActivePortMappingsMap[upnpPortMapping[i].getKey()] =
 959                                 upnpPortMapping[i];
 960
 961                         // Add the port mapping
 962                         PrivateAddPortMapping(upnpPortMapping[i]);
 963                 }
 964         }
 965
 966         // Test some variables, this is deprecated, might not work
 967         // with some routers
 968         m_WanService->GetStateVariable("ConnectionType");
 969         m_WanService->GetStateVariable("PossibleConnectionTypes");
 970         m_WanService->GetStateVariable("ConnectionStatus");
 971         m_WanService->GetStateVariable("Uptime");
 972         m_WanService->GetStateVariable("LastConnectionError");
 973         m_WanService->GetStateVariable("RSIPAvailable");
 974         m_WanService->GetStateVariable("NATEnabled");
 975         m_WanService->GetStateVariable("ExternalIPAddress");
 976         m_WanService->GetStateVariable("PortMappingNumberOfEntries");
 977         m_WanService->GetStateVariable("PortMappingLeaseDuration");
 978
 979         // Just for testing
 980         std::vector<CUPnPArgumentValue> argval;
 981         argval.resize(0);
 982         m_WanService->Execute("GetStatusInfo", argval);
 983
 984 #if 0
 985         // These do not work. Their value must be requested for a
 986         // specific port mapping.
 987         m_WanService->GetStateVariable("PortMappingEnabled");
 988         m_WanService->GetStateVariable("RemoteHost");
 989         m_WanService->GetStateVariable("ExternalPort");
 990         m_WanService->GetStateVariable("InternalPort");
 991         m_WanService->GetStateVariable("PortMappingProtocol");
 992         m_WanService->GetStateVariable("InternalClient");
 993         m_WanService->GetStateVariable("PortMappingDescription");
 994 #endif
 995
 996         // Debug only
 997         msg.str("");
 998         msg << "CUPnPControlPoint::DeletePortMappings: "
 999                 "m_ActivePortMappingsMap.size() == " <<
1000                 m_ActivePortMappingsMap.size();
1001         AddDebugLogLineM(false, logUPnP, msg);
1002
1003         // Not very good, must find a better test
1004         PortMappingNumberOfEntries.str(
1005                 m_WanService->GetStateVariable(
1006                         "PortMappingNumberOfEntries"));
1007         unsigned long newNumberOfEntries;
1008         PortMappingNumberOfEntries >> newNumberOfEntries;
1009         ok = newNumberOfEntries - oldNumberOfEntries == 4;
1010
1011         return ok;
1012 }
1013
1014
1015 void CUPnPControlPoint::RefreshPortMappings()
1016 {
1017         for (   PortMappingMap::iterator it = m_ActivePortMappingsMap.begin();
1018                 it != m_ActivePortMappingsMap.end();
1019                 ++it) {
1020                 PrivateAddPortMapping(it->second);
1021         }
1022
1023         // For testing
1024         m_WanService->GetStateVariable("PortMappingNumberOfEntries");
1025 }
1026
1027
1028 bool CUPnPControlPoint::PrivateAddPortMapping(
1029         CUPnPPortMapping &upnpPortMapping)
1030 {
1031         // Get an IP address. The UPnP server one must do.
1032         std::string ipAddress(UpnpGetServerIpAddress());
1033
1034         // Start building the action
1035         std::string actionName("AddPortMapping");
1036         std::vector<CUPnPArgumentValue> argval(8);
1037
1038         // Action parameters
1039         argval[0].SetArgument("NewRemoteHost");
1040         argval[0].SetValue("");
1041         argval[1].SetArgument("NewExternalPort");
1042         argval[1].SetValue(upnpPortMapping.getPort());
1043         argval[2].SetArgument("NewProtocol");
1044         argval[2].SetValue(upnpPortMapping.getProtocol());
1045         argval[3].SetArgument("NewInternalPort");
1046         argval[3].SetValue(upnpPortMapping.getPort());
1047         argval[4].SetArgument("NewInternalClient");
1048         argval[4].SetValue(ipAddress);
1049         argval[5].SetArgument("NewEnabled");
1050         argval[5].SetValue("1");
1051         argval[6].SetArgument("NewPortMappingDescription");
1052         argval[6].SetValue(upnpPortMapping.getDescription());
1053         argval[7].SetArgument("NewLeaseDuration");
1054         argval[7].SetValue("0");
1055
1056         // Execute
1057         bool ret = true;
1058         for (ServiceMap::iterator it = m_ServiceMap.begin();
1059              it != m_ServiceMap.end(); ++it) {
1060                 ret &= it->second->Execute(actionName, argval);
1061         }
1062
1063         return ret;
1064 }
1065
1066
1067 bool CUPnPControlPoint::DeletePortMappings(
1068         std::vector<CUPnPPortMapping> &upnpPortMapping)
1069 {
1070         std::ostringstream msg;
1071         if (!WanServiceDetected()) {
1072                 msg <<  "UPnP Error: "
1073                         "CUPnPControlPoint::DeletePortMapping: "
1074                         "WAN Service not detected.";
1075                 AddLogLineU(true, logUPnP, msg);
1076                 return false;
1077         }
1078
1079         int n = upnpPortMapping.size();
1080         bool ok = false;
1081
1082         // Check the number of port mappings before
1083         std::istringstream PortMappingNumberOfEntries(
1084                 m_WanService->GetStateVariable(
1085                         "PortMappingNumberOfEntries"));
1086         unsigned long oldNumberOfEntries;
1087         PortMappingNumberOfEntries >> oldNumberOfEntries;
1088
1089         // Delete the enabled port mappings
1090         for (int i = 0; i < n; ++i) {
1091                 if (upnpPortMapping[i].getEnabled() == "1") {
1092                         // Delete the mapping from the control point
1093                         // active mappings list
1094                         PortMappingMap::iterator it =
1095                                 m_ActivePortMappingsMap.find(
1096                                         upnpPortMapping[i].getKey());
1097                         if (it != m_ActivePortMappingsMap.end()) {
1098                                 m_ActivePortMappingsMap.erase(it);
1099                         } else {
1100                                 msg <<  "UPnP Error: "
1101                                         "CUPnPControlPoint::DeletePortMapping: "
1102                                         "Mapping was not found in the active "
1103                                         "mapping map.";
1104                                 AddLogLineU(true, logUPnP, msg);
1105                         }
1106
1107                         // Delete the port mapping
1108                         PrivateDeletePortMapping(upnpPortMapping[i]);
1109                 }
1110         }
1111
1112         // Debug only
1113         msg.str("");
1114         msg << "CUPnPControlPoint::DeletePortMappings: "
1115                 "m_ActivePortMappingsMap.size() == " <<
1116                 m_ActivePortMappingsMap.size();
1117         AddDebugLogLineM(false, logUPnP, msg);
1118
1119         // Not very good, must find a better test
1120         PortMappingNumberOfEntries.str(
1121                 m_WanService->GetStateVariable(
1122                         "PortMappingNumberOfEntries"));
1123         unsigned long newNumberOfEntries;
1124         PortMappingNumberOfEntries >> newNumberOfEntries;
1125         ok = oldNumberOfEntries - newNumberOfEntries == 4;
1126
1127         return ok;
1128 }
1129
1130
1131 bool CUPnPControlPoint::PrivateDeletePortMapping(
1132         CUPnPPortMapping &upnpPortMapping)
1133 {
1134         // Start building the action
1135         std::string actionName("DeletePortMapping");
1136         std::vector<CUPnPArgumentValue> argval(3);
1137
1138         // Action parameters
1139         argval[0].SetArgument("NewRemoteHost");
1140         argval[0].SetValue("");
1141         argval[1].SetArgument("NewExternalPort");
1142         argval[1].SetValue(upnpPortMapping.getPort());
1143         argval[2].SetArgument("NewProtocol");
1144         argval[2].SetValue(upnpPortMapping.getProtocol());
1145
1146         // Execute
1147         bool ret = true;
1148         for (ServiceMap::iterator it = m_ServiceMap.begin();
1149              it != m_ServiceMap.end(); ++it) {
1150                 ret &= it->second->Execute(actionName, argval);
1151         }
1152
1153         return ret;
1154 }
1155
1156
1157 // This function is static
1158 int CUPnPControlPoint::Callback(Upnp_EventType EventType, void *Event, void * /*Cookie*/)
1159 {
1160         std::ostringstream msg;
1161         std::ostringstream msg2;
1162         // Somehow, this is unreliable. UPNP_DISCOVERY_ADVERTISEMENT_ALIVE events
1163         // happen with a wrong cookie and... boom!
1164         // CUPnPControlPoint *upnpCP = static_cast<CUPnPControlPoint *>(Cookie);
1165         CUPnPControlPoint *upnpCP = CUPnPControlPoint::s_CtrlPoint;
1166
1167         //fprintf(stderr, "Callback: %d, Cookie: %p\n", EventType, Cookie);
1168         switch (EventType) {
1169         case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
1170                 //fprintf(stderr, "Callback: UPNP_DISCOVERY_ADVERTISEMENT_ALIVE\n");
1171                 msg << "error(UPNP_DISCOVERY_ADVERTISEMENT_ALIVE): ";
1172                 msg2<< "UPNP_DISCOVERY_ADVERTISEMENT_ALIVE: ";
1173                 goto upnpDiscovery;
1174         case UPNP_DISCOVERY_SEARCH_RESULT: {
1175                 //fprintf(stderr, "Callback: UPNP_DISCOVERY_SEARCH_RESULT\n");
1176                 msg << "error(UPNP_DISCOVERY_SEARCH_RESULT): ";
1177                 msg2<< "UPNP_DISCOVERY_SEARCH_RESULT: ";
1178                 // UPnP Discovery
1179 upnpDiscovery:
1180                 struct Upnp_Discovery *d_event = (struct Upnp_Discovery *)Event;
1181                 IXML_Document *doc = NULL;
1182                 int ret;
1183                 if (d_event->ErrCode != UPNP_E_SUCCESS) {
1184                         msg << upnpCP->m_upnpLib.GetUPnPErrorMessage(d_event->ErrCode) << ".";
1185                         AddDebugLogLineM(true, logUPnP, msg);
1186                 }
1187                 // Get the XML tree device description in doc
1188                 ret = UpnpDownloadXmlDoc(d_event->Location, &doc);
1189                 if (ret != UPNP_E_SUCCESS) {
1190                         msg << "Error retrieving device description from " <<
1191                                 d_event->Location << ": " <<
1192                                 upnpCP->m_upnpLib.GetUPnPErrorMessage(ret) <<
1193                                 "(" << ret << ").";
1194                         AddDebugLogLineM(true, logUPnP, msg);
1195                 } else {
1196                         msg2 << "Retrieving device description from " <<
1197                                 d_event->Location << ".";
1198                         AddDebugLogLineM(false, logUPnP, msg2);
1199                 }
1200                 if (doc) {
1201                         // Get the root node
1202                         IXML_Element *root =
1203                                 upnpCP->m_upnpLib.Element_GetRootElement(doc);
1204                         // Extract the URLBase
1205                         const std::string urlBase = upnpCP->m_upnpLib.
1206                                 Element_GetChildValueByTag(root, "URLBase");
1207                         // Get the root device
1208                         IXML_Element *rootDevice = upnpCP->m_upnpLib.
1209                                 Element_GetFirstChildByTag(root, "device");
1210                         // Extract the deviceType
1211                         std::string devType(upnpCP->m_upnpLib.
1212                                 Element_GetChildValueByTag(rootDevice, "deviceType"));
1213                         // Only add device if it is an InternetGatewayDevice
1214                         if (stdStringIsEqualCI(devType, upnpCP->m_upnpLib.UPNP_DEVICE_IGW)) {
1215                                 // This condition can be used to auto-detect
1216                                 // the UPnP device we are interested in.
1217                                 // Obs.: Don't block the entry here on this
1218                                 // condition! There may be more than one device,
1219                                 // and the first that enters may not be the one
1220                                 // we are interested in!
1221                                 upnpCP->SetIGWDeviceDetected(true);
1222                                 // Log it if not UPNP_DISCOVERY_ADVERTISEMENT_ALIVE,
1223                                 // we don't want to spam our logs.
1224                                 if (EventType != UPNP_DISCOVERY_ADVERTISEMENT_ALIVE) {
1225                                         msg.str("Internet Gateway Device Detected.");
1226                                         AddLogLineU(true, logUPnP, msg);
1227                                 }
1228                                 // Add the root device to our list
1229                                 upnpCP->AddRootDevice(rootDevice, urlBase,
1230                                         d_event->Location, d_event->Expires);
1231                         }
1232                         // Free the XML doc tree
1233                         ixmlDocument_free(doc);
1234                 }
1235                 break;
1236         }
1237         case UPNP_DISCOVERY_SEARCH_TIMEOUT: {
1238                 //fprintf(stderr, "Callback: UPNP_DISCOVERY_SEARCH_TIMEOUT\n");
1239                 // Search timeout
1240                 msg << "UPNP_DISCOVERY_SEARCH_TIMEOUT.";
1241                 AddDebugLogLineM(false, logUPnP, msg);
1242
1243                 // Unlock the search timeout mutex
1244                 upnpCP->m_WaitForSearchTimeoutMutex.Unlock();
1245
1246                 break;
1247         }
1248         case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE: {
1249                 //fprintf(stderr, "Callback: UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE\n");
1250                 // UPnP Device Removed
1251                 struct Upnp_Discovery *dab_event = (struct Upnp_Discovery *)Event;
1252                 if (dab_event->ErrCode != UPNP_E_SUCCESS) {
1253                         msg << "error(UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE): " <<
1254                                 upnpCP->m_upnpLib.GetUPnPErrorMessage(dab_event->ErrCode) <<
1255                                 ".";
1256                         AddDebugLogLineM(true, logUPnP, msg);
1257                 }
1258                 std::string devType = dab_event->DeviceType;
1259                 // Check for an InternetGatewayDevice and removes it from the list
1260                 std::transform(devType.begin(), devType.end(), devType.begin(), tolower);
1261                 if (stdStringIsEqualCI(devType, upnpCP->m_upnpLib.UPNP_DEVICE_IGW)) {
1262                         upnpCP->RemoveRootDevice(dab_event->DeviceId);
1263                 }
1264                 break;
1265         }
1266         case UPNP_EVENT_RECEIVED: {
1267                 //fprintf(stderr, "Callback: UPNP_EVENT_RECEIVED\n");
1268                 // Event reveived
1269                 struct Upnp_Event *e_event = (struct Upnp_Event *)Event;
1270                 const std::string Sid = e_event->Sid;
1271                 // Parses the event
1272                 upnpCP->OnEventReceived(Sid, e_event->EventKey, e_event->ChangedVariables);
1273                 break;
1274         }
1275         case UPNP_EVENT_SUBSCRIBE_COMPLETE:
1276                 //fprintf(stderr, "Callback: UPNP_EVENT_SUBSCRIBE_COMPLETE\n");
1277                 msg << "error(UPNP_EVENT_SUBSCRIBE_COMPLETE): ";
1278                 goto upnpEventRenewalComplete;
1279         case UPNP_EVENT_UNSUBSCRIBE_COMPLETE:
1280                 //fprintf(stderr, "Callback: UPNP_EVENT_UNSUBSCRIBE_COMPLETE\n");
1281                 msg << "error(UPNP_EVENT_UNSUBSCRIBE_COMPLETE): ";
1282                 goto upnpEventRenewalComplete;
1283         case UPNP_EVENT_RENEWAL_COMPLETE: {
1284                 //fprintf(stderr, "Callback: UPNP_EVENT_RENEWAL_COMPLETE\n");
1285                 msg << "error(UPNP_EVENT_RENEWAL_COMPLETE): ";
1286 upnpEventRenewalComplete:
1287                 struct Upnp_Event_Subscribe *es_event =
1288                         (struct Upnp_Event_Subscribe *)Event;
1289                 if (es_event->ErrCode != UPNP_E_SUCCESS) {
1290                         msg << "Error in Event Subscribe Callback";
1291                         upnpCP->m_upnpLib.processUPnPErrorMessage(
1292                                 msg.str(), es_event->ErrCode, NULL, NULL);
1293                 } else {
1294 #if 0
1295                         TvCtrlPointHandleSubscribeUpdate(
1296                                 es_event->PublisherUrl,
1297                                 es_event->Sid,
1298                                 es_event->TimeOut );
1299 #endif
1300                 }
1301
1302                 break;
1303         }
1304
1305         case UPNP_EVENT_AUTORENEWAL_FAILED:
1306                 //fprintf(stderr, "Callback: UPNP_EVENT_AUTORENEWAL_FAILED\n");
1307                 msg << "error(UPNP_EVENT_AUTORENEWAL_FAILED): ";
1308                 msg2 << "UPNP_EVENT_AUTORENEWAL_FAILED: ";
1309                 goto upnpEventSubscriptionExpired;
1310         case UPNP_EVENT_SUBSCRIPTION_EXPIRED: {
1311                 //fprintf(stderr, "Callback: UPNP_EVENT_SUBSCRIPTION_EXPIRED\n");
1312                 msg << "error(UPNP_EVENT_SUBSCRIPTION_EXPIRED): ";
1313                 msg2 << "UPNP_EVENT_SUBSCRIPTION_EXPIRED: ";
1314 upnpEventSubscriptionExpired:
1315                 struct Upnp_Event_Subscribe *es_event =
1316                         (struct Upnp_Event_Subscribe *)Event;
1317                 Upnp_SID newSID;
1318                 int TimeOut = 1801;
1319                 int ret = UpnpSubscribe(
1320                         upnpCP->m_UPnPClientHandle,
1321                         es_event->PublisherUrl,
1322                         &TimeOut,
1323                         newSID);
1324                 if (ret != UPNP_E_SUCCESS) {
1325                         msg << "Error Subscribing to EventURL";
1326                         upnpCP->m_upnpLib.processUPnPErrorMessage(
1327                                 msg.str(), es_event->ErrCode, NULL, NULL);
1328                 } else {
1329                         ServiceMap::iterator it =
1330                                 upnpCP->m_ServiceMap.find(es_event->PublisherUrl);
1331                         if (it != upnpCP->m_ServiceMap.end()) {
1332                                 CUPnPService &service = *(it->second);
1333                                 service.SetTimeout(TimeOut);
1334                                 service.SetSID(newSID);
1335                                 msg2 << "Re-subscribed to EventURL '" <<
1336                                         es_event->PublisherUrl <<
1337                                         "' with SID == '" <<
1338                                         newSID << "'.";
1339                                 AddDebugLogLineM(true, logUPnP, msg2);
1340                                 // In principle, we should test to see if the
1341                                 // service is the same. But here we only have one
1342                                 // service, so...
1343                                 upnpCP->RefreshPortMappings();
1344                         } else {
1345                                 msg << "Error: did not find service " <<
1346                                         newSID << " in the service map.";
1347                                 AddDebugLogLineM(true, logUPnP, msg);
1348                         }
1349                 }
1350                 break;
1351         }
1352         case UPNP_CONTROL_ACTION_COMPLETE: {
1353                 //fprintf(stderr, "Callback: UPNP_CONTROL_ACTION_COMPLETE\n");
1354                 // This is here if we choose to do this asynchronously
1355                 struct Upnp_Action_Complete *a_event =
1356                         (struct Upnp_Action_Complete *)Event;
1357                 if (a_event->ErrCode != UPNP_E_SUCCESS) {
1358                         upnpCP->m_upnpLib.processUPnPErrorMessage(
1359                                 "UpnpSendActionAsync",
1360                                 a_event->ErrCode, NULL,
1361                                 a_event->ActionResult);
1362                 } else {
1363                         // Check the response document
1364                         upnpCP->m_upnpLib.ProcessActionResponse(
1365                                 a_event->ActionResult,
1366                                 "<UpnpSendActionAsync>");
1367                 }
1368                 /* No need for any processing here, just print out results.
1369                  * Service state table updates are handled by events.
1370                  */
1371                 break;
1372         }
1373         case UPNP_CONTROL_GET_VAR_COMPLETE: {
1374                 //fprintf(stderr, "Callback: UPNP_CONTROL_GET_VAR_COMPLETE\n");
1375                 msg << "error(UPNP_CONTROL_GET_VAR_COMPLETE): ";
1376                 struct Upnp_State_Var_Complete *sv_event =
1377                         (struct Upnp_State_Var_Complete *)Event;
1378                 if (sv_event->ErrCode != UPNP_E_SUCCESS) {
1379                         msg << "m_UpnpGetServiceVarStatusAsync";
1380                         upnpCP->m_upnpLib.processUPnPErrorMessage(
1381                                 msg.str(), sv_event->ErrCode, NULL, NULL);
1382                 } else {
1383 #if 0
1384                         // Warning: The use of UpnpGetServiceVarStatus and
1385                         // UpnpGetServiceVarStatusAsync is deprecated by the
1386                         // UPnP forum.
1387                         TvCtrlPointHandleGetVar(
1388                                 sv_event->CtrlUrl,
1389                                 sv_event->StateVarName,
1390                                 sv_event->CurrentVal );
1391 #endif
1392                 }
1393                 break;
1394         }
1395         // ignore these cases, since this is not a device
1396         case UPNP_CONTROL_GET_VAR_REQUEST:
1397                 //fprintf(stderr, "Callback: UPNP_CONTROL_GET_VAR_REQUEST\n");
1398                 msg << "error(UPNP_CONTROL_GET_VAR_REQUEST): ";
1399                 goto eventSubscriptionRequest;
1400         case UPNP_CONTROL_ACTION_REQUEST:
1401                 //fprintf(stderr, "Callback: UPNP_CONTROL_ACTION_REQUEST\n");
1402                 msg << "error(UPNP_CONTROL_ACTION_REQUEST): ";
1403                 goto eventSubscriptionRequest;
1404         case UPNP_EVENT_SUBSCRIPTION_REQUEST:
1405                 //fprintf(stderr, "Callback: UPNP_EVENT_SUBSCRIPTION_REQUEST\n");
1406                 msg << "error(UPNP_EVENT_SUBSCRIPTION_REQUEST): ";
1407 eventSubscriptionRequest:
1408                 msg << "This is not a UPnP Device, this is a UPnP Control Point, event ignored.";
1409                 AddDebugLogLineM(true, logUPnP, msg);
1410                 break;
1411         default:
1412                 // Humm, this is not good, we forgot to handle something...
1413                 fprintf(stderr,
1414                         "Callback: default... Unknown event:'%d', not good.\n",
1415                         EventType);
1416                 msg << "error(UPnP::Callback): Event not handled:'" <<
1417                         EventType << "'.";
1418                 fprintf(stderr, "%s\n", msg.str().c_str());
1419                 AddDebugLogLineM(true, logUPnP, msg);
1420                 // Better not throw in the callback. Who would catch it?
1421                 //throw CUPnPException(msg);
1422                 break;
1423         }
1424
1425         return 0;
1426 }
1427
1428
1429 void CUPnPControlPoint::OnEventReceived(
1430                 const std::string &Sid,
1431                 int EventKey,
1432                 IXML_Document *ChangedVariablesDoc)
1433 {
1434         std::ostringstream msg;
1435         msg << "UPNP_EVENT_RECEIVED:" <<
1436                 "\n    SID: " << Sid <<
1437                 "\n    Key: " << EventKey <<
1438                 "\n    Property list:";
1439         IXML_Element *root =
1440                 m_upnpLib.Element_GetRootElement(ChangedVariablesDoc);
1441         IXML_Element *child =
1442                 m_upnpLib.Element_GetFirstChild(root);
1443         if (child) {
1444                 while (child) {
1445                         IXML_Element *child2 =
1446                                 m_upnpLib.Element_GetFirstChild(child);
1447                         const DOMString childTag =
1448                                 m_upnpLib.Element_GetTag(child2);
1449                         std::string childValue =
1450                                 m_upnpLib.Element_GetTextValue(child2);
1451                         msg << "\n        " <<
1452                                 childTag << "='" <<
1453                                 childValue << "'";
1454                         child = m_upnpLib.Element_GetNextSibling(child);
1455                 }
1456         } else {
1457                 msg << "\n    Empty property list.";
1458         }
1459         AddDebugLogLineM(true, logUPnP, msg);
1460         // Freeing that doc segfaults. Probably should not be freed.
1461         //ixmlDocument_free(ChangedVariablesDoc);
1462 }
1463
1464
1465 void CUPnPControlPoint::AddRootDevice(
1466         IXML_Element *rootDevice, const std::string &urlBase,
1467         const char *location, int expires)
1468 {
1469         // Lock the Root Device List
1470         CUPnPMutexLocker lock(m_RootDeviceListMutex);
1471
1472         // Root node's URLBase
1473         std::string OriginalURLBase(urlBase);
1474         std::string FixedURLBase(OriginalURLBase.empty() ?
1475                 location :
1476                 OriginalURLBase);
1477
1478         // Get the UDN (Unique Device Name)
1479         std::string UDN(
1480                 m_upnpLib.Element_GetChildValueByTag(rootDevice, "UDN"));
1481         RootDeviceMap::iterator it = m_RootDeviceMap.find(UDN);
1482         bool alreadyAdded = it != m_RootDeviceMap.end();
1483         if (alreadyAdded) {
1484                 // Just set the expires field
1485                 it->second->SetExpires(expires);
1486         } else {
1487                 // Add a new root device to the root device list
1488                 CUPnPRootDevice *upnpRootDevice = new CUPnPRootDevice(
1489                         *this, m_upnpLib, rootDevice,
1490                         OriginalURLBase, FixedURLBase,
1491                         location, expires);
1492                 m_RootDeviceMap[upnpRootDevice->GetUDN()] = upnpRootDevice;
1493         }
1494 }
1495
1496
1497 void CUPnPControlPoint::RemoveRootDevice(const char *udn)
1498 {
1499         // Lock the Root Device List
1500         CUPnPMutexLocker lock(m_RootDeviceListMutex);
1501
1502         // Remove
1503         std::string UDN(udn);
1504         RootDeviceMap::iterator it = m_RootDeviceMap.find(UDN);
1505         if (it != m_RootDeviceMap.end()) {
1506                 delete it->second;
1507                 m_RootDeviceMap.erase(UDN);
1508         }
1509 }
1510
1511
1512 void CUPnPControlPoint::Subscribe(CUPnPService &service)
1513 {
1514         std::ostringstream msg;
1515
1516         IXML_Document *scpdDoc = NULL;
1517         int errcode = UpnpDownloadXmlDoc(
1518                 service.GetAbsSCPDURL().c_str(), &scpdDoc);
1519         if (errcode == UPNP_E_SUCCESS) {
1520                 // Get the root node of this service (the SCPD Document)
1521                 IXML_Element *scpdRoot =
1522                         m_upnpLib.Element_GetRootElement(scpdDoc);
1523                 CUPnPSCPD *scpd = new CUPnPSCPD(*this, m_upnpLib,
1524                         scpdRoot, service.GetAbsSCPDURL());
1525                 service.SetSCPD(scpd);
1526                 m_ServiceMap[service.GetAbsEventSubURL()] = &service;
1527                 msg << "Successfully retrieved SCPD Document for service " <<
1528                         service.GetServiceType() << ", absEventSubURL: " <<
1529                         service.GetAbsEventSubURL() << ".";
1530                 AddLogLineU(true, logUPnP, msg);
1531                 msg.str("");
1532
1533                 // Now try to subscribe to this service. If the subscription
1534                 // is not successfull, we will not be notified about events,
1535                 // but it may be possible to use the service anyway.
1536                 errcode = UpnpSubscribe(m_UPnPClientHandle,
1537                         service.GetAbsEventSubURL().c_str(),
1538                         service.GetTimeoutAddr(),
1539                         service.GetSID());
1540                 if (errcode == UPNP_E_SUCCESS) {
1541                         msg << "Successfully subscribed to service " <<
1542                                 service.GetServiceType() << ", absEventSubURL: " <<
1543                                 service.GetAbsEventSubURL() << ".";
1544                         AddLogLineU(true, logUPnP, msg);
1545                 } else {
1546                         msg << "Error subscribing to service " <<
1547                                 service.GetServiceType() << ", absEventSubURL: " <<
1548                                 service.GetAbsEventSubURL() << ", error: " <<
1549                                 m_upnpLib.GetUPnPErrorMessage(errcode) << ".";
1550                         goto error;
1551                 }
1552         } else {
1553                 msg << "Error getting SCPD Document from " <<
1554                         service.GetAbsSCPDURL() << ".";
1555                 AddLogLineU(true, logUPnP, msg);
1556         }
1557
1558         return;
1559
1560         // Error processing
1561 error:
1562         AddLogLineU(true, logUPnP, msg);
1563 }
1564
1565
1566 void CUPnPControlPoint::Unsubscribe(CUPnPService &service)
1567 {
1568         ServiceMap::iterator it = m_ServiceMap.find(service.GetAbsEventSubURL());
1569         if (it != m_ServiceMap.end()) {
1570                 m_ServiceMap.erase(it);
1571                 UpnpUnSubscribe(m_UPnPClientHandle, service.GetSID());
1572         }
1573 }
1574
1575
1576 // File_checked_for_headers