code.vuplus.com Git - vuplus_xbmc/blob - xbmc/network/WakeOnAccess.cpp

   1 /*
   2  *      Copyright (C) 2013 Team XBMC
   3  *      http://xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include <limits.h>
  22 #include <netinet/in.h>
  23 #include <sys/socket.h>
  24 #include <arpa/inet.h>
  25
  26 #include "system.h"
  27 #include "network/Network.h"
  28 #include "Application.h"
  29 #include "DNSNameCache.h"
  30 #include "dialogs/GUIDialogProgress.h"
  31 #include "dialogs/GUIDialogKaiToast.h"
  32 #include "filesystem/SpecialProtocol.h"
  33 #include "guilib/GUIWindowManager.h"
  34 #include "guilib/LocalizeStrings.h"
  35 #include "settings/AdvancedSettings.h"
  36 #include "settings/Settings.h"
  37 #include "settings/MediaSourceSettings.h"
  38 #include "utils/JobManager.h"
  39 #include "utils/log.h"
  40 #include "utils/XMLUtils.h"
  41 #include "utils/URIUtils.h"
  42 #include "utils/StringUtils.h"
  43
  44 #include "WakeOnAccess.h"
  45
  46 using namespace std;
  47
  48 #define DEFAULT_NETWORK_INIT_SEC      (20)   // wait 20 sec for network after startup or resume
  49 #define DEFAULT_NETWORK_SETTLE_MS     (500)  // require 500ms of consistent network availability before trusting it
  50
  51 #define DEFAULT_TIMEOUT_SEC (5*60)           // at least 5 minutes between each magic packets
  52 #define DEFAULT_WAIT_FOR_ONLINE_SEC_1 (40)   // wait at 40 seconds after sending magic packet
  53 #define DEFAULT_WAIT_FOR_ONLINE_SEC_2 (40)   // same for extended wait
  54 #define DEFAULT_WAIT_FOR_SERVICES_SEC (5)    // wait 5 seconds after host go online to launch file sharing deamons
  55
  56 static int GetTotalSeconds(const CDateTimeSpan& ts)
  57 {
  58   int hours = ts.GetHours() + ts.GetDays() * 24;
  59   int minutes = ts.GetMinutes() + hours * 60;
  60   return ts.GetSeconds() + minutes * 60;
  61 }
  62
  63 static unsigned long HostToIP(const CStdString& host)
  64 {
  65   CStdString ip;
  66   CDNSNameCache::Lookup(host, ip);
  67   return inet_addr(ip.c_str());
  68 }
  69
  70 CWakeOnAccess::WakeUpEntry::WakeUpEntry (bool isAwake)
  71   : timeout (0, 0, 0, DEFAULT_TIMEOUT_SEC)
  72   , wait_online1_sec(DEFAULT_WAIT_FOR_ONLINE_SEC_1)
  73   , wait_online2_sec(DEFAULT_WAIT_FOR_ONLINE_SEC_2)
  74   , wait_services_sec(DEFAULT_WAIT_FOR_SERVICES_SEC)
  75   , ping_port(0), ping_mode(0)
  76 {
  77   nextWake = CDateTime::GetCurrentDateTime();
  78
  79   if (isAwake)
  80     nextWake += timeout;
  81 }
  82
  83 //**
  84
  85 class CMACDiscoveryJob : public CJob
  86 {
  87 public:
  88   CMACDiscoveryJob(const CStdString& host) : m_host(host) {}
  89
  90   virtual bool DoWork();
  91
  92   const CStdString& GetMAC() const { return m_macAddres; }
  93   const CStdString& GetHost() const { return m_host; }
  94
  95 private:
  96   CStdString m_macAddres;
  97   CStdString m_host;
  98 };
  99
 100 bool CMACDiscoveryJob::DoWork()
 101 {
 102   unsigned long ipAddress = HostToIP(m_host);
 103
 104   if (ipAddress == INADDR_NONE)
 105   {
 106     CLog::Log(LOGERROR, "%s - can't determine ip of '%s'", __FUNCTION__, m_host.c_str());
 107     return false;
 108   }
 109
 110   vector<CNetworkInterface*>& ifaces = g_application.getNetwork().GetInterfaceList();
 111   for (vector<CNetworkInterface*>::const_iterator it = ifaces.begin(); it != ifaces.end(); ++it)
 112   {
 113     if ((*it)->GetHostMacAddress(ipAddress, m_macAddres))
 114       return true;
 115   }
 116
 117   return false;
 118 }
 119
 120 //**
 121
 122 class WaitCondition
 123 {
 124 public:
 125   virtual bool SuccessWaiting () const { return false; }
 126 };
 127
 128 //
 129
 130 class NestDetect
 131 {
 132 public:
 133   NestDetect() : m_gui_thread (g_application.IsCurrentThread())
 134   {
 135     if (m_gui_thread)
 136       ++m_nest;
 137   }
 138   ~NestDetect()
 139   {
 140     if (m_gui_thread)
 141       m_nest--;
 142   }
 143   static int Level()
 144   {
 145     return m_nest;
 146   }
 147   bool IsNested() const
 148   {
 149     return m_gui_thread && m_nest > 1;
 150   }
 151
 152 private:
 153   static int m_nest;
 154   const bool m_gui_thread;
 155 };
 156 int NestDetect::m_nest = 0;
 157
 158 //
 159
 160 class ProgressDialogHelper
 161 {
 162 public:
 163   ProgressDialogHelper (const CStdString& heading) : m_dialog(0)
 164   {
 165     if (g_application.IsCurrentThread())
 166       m_dialog = (CGUIDialogProgress*) g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
 167
 168     if (m_dialog)
 169     {
 170       m_dialog->SetHeading (heading);
 171       m_dialog->SetLine(0, "");
 172       m_dialog->SetLine(1, "");
 173       m_dialog->SetLine(2, "");
 174
 175       int nest_level = NestDetect::Level();
 176       if (nest_level > 1)
 177       {
 178         CStdString nest = StringUtils::Format("Nesting:%d", nest_level);
 179         m_dialog->SetLine(2, nest);
 180       }
 181     }
 182   }
 183   ~ProgressDialogHelper ()
 184   {
 185     if (m_dialog)
 186       m_dialog->Close();
 187   }
 188
 189   bool HasDialog() const { return m_dialog != 0; }
 190
 191   enum wait_result { TimedOut, Canceled, Success };
 192
 193   wait_result ShowAndWait (const WaitCondition& waitObj, unsigned timeOutSec, const CStdString& line1)
 194   {
 195     unsigned timeOutMs = timeOutSec * 1000;
 196
 197     if (m_dialog)
 198     {
 199       m_dialog->SetLine(1, line1);
 200
 201       m_dialog->SetPercentage(1); // avoid flickering by starting at 1% ..
 202     }
 203
 204     XbmcThreads::EndTime end_time (timeOutMs);
 205
 206     while (!end_time.IsTimePast())
 207     {
 208       if (waitObj.SuccessWaiting())
 209         return Success;
 210
 211       if (m_dialog)
 212       {
 213         if (!m_dialog->IsActive())
 214           m_dialog->StartModal();
 215
 216         if (m_dialog->IsCanceled())
 217           return Canceled;
 218
 219         m_dialog->Progress();
 220
 221         unsigned ms_passed = timeOutMs - end_time.MillisLeft();
 222
 223         int percentage = (ms_passed * 100) / timeOutMs;
 224         m_dialog->SetPercentage(max(percentage, 1)); // avoid flickering , keep minimum 1%
 225       }
 226
 227       Sleep (m_dialog ? 20 : 200);
 228     }
 229
 230     return TimedOut;
 231   }
 232
 233 private:
 234   CGUIDialogProgress* m_dialog;
 235 };
 236
 237 class NetworkStartWaiter : public WaitCondition
 238 {
 239 public:
 240   NetworkStartWaiter (unsigned settle_time_ms, const CStdString& host) : m_settle_time_ms (settle_time_ms), m_host(host)
 241   {
 242   }
 243   virtual bool SuccessWaiting () const
 244   {
 245     unsigned long address = ntohl(HostToIP(m_host));
 246     bool online = g_application.getNetwork().HasInterfaceForIP(address);
 247
 248     if (!online) // setup endtime so we dont return true until network is consistently connected
 249       m_end.Set (m_settle_time_ms);
 250
 251     return online && m_end.IsTimePast();
 252   }
 253 private:
 254   mutable XbmcThreads::EndTime m_end;
 255   unsigned m_settle_time_ms;
 256   const CStdString m_host;
 257 };
 258
 259 class PingResponseWaiter : public WaitCondition, private IJobCallback
 260 {
 261 public:
 262   PingResponseWaiter (bool async, const CWakeOnAccess::WakeUpEntry& server)
 263     : m_server(server), m_jobId(0), m_hostOnline(false)
 264   {
 265     if (async)
 266     {
 267       CJob* job = new CHostProberJob(server);
 268       m_jobId = CJobManager::GetInstance().AddJob(job, this);
 269     }
 270   }
 271   ~PingResponseWaiter()
 272   {
 273     CJobManager::GetInstance().CancelJob(m_jobId);
 274   }
 275   virtual bool SuccessWaiting () const
 276   {
 277     return m_jobId ? m_hostOnline : Ping(m_server);
 278   }
 279
 280   virtual void OnJobComplete(unsigned int jobID, bool success, CJob *job)
 281   {
 282     m_hostOnline = success;
 283   }
 284
 285   static bool Ping (const CWakeOnAccess::WakeUpEntry& server)
 286   {
 287     ULONG dst_ip = HostToIP(server.host);
 288
 289     return g_application.getNetwork().PingHost(dst_ip, server.ping_port, 2000, server.ping_mode & 1);
 290   }
 291
 292 private:
 293   class CHostProberJob : public CJob
 294   {
 295     public:
 296       CHostProberJob(const CWakeOnAccess::WakeUpEntry& server) : m_server (server) {}
 297
 298       virtual bool DoWork()
 299       {
 300         while (!ShouldCancel(0,0))
 301         {
 302           if (PingResponseWaiter::Ping(m_server))
 303             return true;
 304         }
 305         return false;
 306       }
 307
 308     private:
 309       const CWakeOnAccess::WakeUpEntry& m_server;
 310   };
 311
 312   const CWakeOnAccess::WakeUpEntry& m_server;
 313   unsigned int m_jobId;
 314   bool m_hostOnline;
 315 };
 316
 317 //
 318
 319 CWakeOnAccess::CWakeOnAccess()
 320   : m_netinit_sec(DEFAULT_NETWORK_INIT_SEC)    // wait for network to connect
 321   , m_netsettle_ms(DEFAULT_NETWORK_SETTLE_MS)  // wait for network to settle
 322   , m_enabled(false)
 323 {
 324 }
 325
 326 CWakeOnAccess &CWakeOnAccess::Get()
 327 {
 328   static CWakeOnAccess sWakeOnAccess;
 329   return sWakeOnAccess;
 330 }
 331
 332 void CWakeOnAccess::WakeUpHost(const CURL& url)
 333 {
 334   CStdString hostName = url.GetHostName();
 335
 336   if (!hostName.IsEmpty())
 337     WakeUpHost (hostName, url.Get());
 338 }
 339
 340 void CWakeOnAccess::WakeUpHost (const CStdString& hostName, const string& customMessage)
 341 {
 342   if (!IsEnabled())
 343     return; // bail if feature is turned off
 344
 345   WakeUpEntry server;
 346
 347   if (FindOrTouchHostEntry(hostName, server))
 348   {
 349     CLog::Log(LOGNOTICE,"WakeOnAccess [%s] trigged by accessing : %s", hostName.c_str(), customMessage.c_str());
 350
 351     NestDetect nesting ; // detect recursive calls on gui thread..
 352
 353     if (nesting.IsNested()) // we might get in trouble if it gets called back in loop
 354       CLog::Log(LOGWARNING,"WakeOnAccess recursively called on gui-thread [%d]", NestDetect::Level());
 355
 356     WakeUpHost(server);
 357
 358     TouchHostEntry(hostName);
 359   }
 360 }
 361
 362 #define LOCALIZED(id) g_localizeStrings.Get(id)
 363
 364 void CWakeOnAccess::WakeUpHost(const WakeUpEntry& server)
 365 {
 366   CStdString heading = StringUtils::Format(LOCALIZED(13027), server.host.c_str());
 367
 368   ProgressDialogHelper dlg (heading);
 369
 370   {
 371     NetworkStartWaiter waitObj (m_netsettle_ms, server.host); // wait until network connected before sending wake-on-lan
 372
 373     if (dlg.ShowAndWait (waitObj, m_netinit_sec, LOCALIZED(13028)) != ProgressDialogHelper::Success)
 374     {
 375       CLog::Log(LOGNOTICE,"WakeOnAccess timeout/cancel while waiting for network");
 376       return; // timedout or canceled
 377     }
 378   }
 379
 380   {
 381     ULONG dst_ip = HostToIP(server.host);
 382
 383     if (g_application.getNetwork().PingHost(dst_ip, server.ping_port, 500)) // quick ping with short timeout to not block too long
 384     {
 385       CLog::Log(LOGNOTICE,"WakeOnAccess success exit, server already running");
 386       return;
 387     }
 388   }
 389
 390   if (!g_application.getNetwork().WakeOnLan(server.mac.c_str()))
 391   {
 392     CLog::Log(LOGERROR,"WakeOnAccess failed to send. (Is it blocked by firewall?)");
 393
 394     if (g_application.IsCurrentThread() || !g_application.m_pPlayer->IsPlaying())
 395       CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, heading, LOCALIZED(13029));
 396     return;
 397   }
 398
 399   {
 400     PingResponseWaiter waitObj (dlg.HasDialog(), server); // wait for ping response ..
 401
 402     ProgressDialogHelper::wait_result
 403       result = dlg.ShowAndWait (waitObj, server.wait_online1_sec, LOCALIZED(13030));
 404
 405     if (result == ProgressDialogHelper::TimedOut)
 406       result = dlg.ShowAndWait (waitObj, server.wait_online2_sec, LOCALIZED(13031));
 407
 408     if (result != ProgressDialogHelper::Success)
 409     {
 410       CLog::Log(LOGNOTICE,"WakeOnAccess timeout/cancel while waiting for response");
 411       return; // timedout or canceled
 412     }
 413   }
 414
 415   {
 416     WaitCondition waitObj ; // wait uninteruptable fixed time for services ..
 417
 418     dlg.ShowAndWait (waitObj, server.wait_services_sec, LOCALIZED(13032));
 419
 420     CLog::Log(LOGNOTICE,"WakeOnAccess sequence completed, server started");
 421   }
 422 }
 423
 424 bool CWakeOnAccess::FindOrTouchHostEntry (const CStdString& hostName, WakeUpEntry& result)
 425 {
 426   CSingleLock lock (m_entrylist_protect);
 427
 428   bool need_wakeup = false;
 429
 430   for (EntriesVector::iterator i = m_entries.begin();i != m_entries.end(); ++i)
 431   {
 432     WakeUpEntry& server = *i;
 433
 434     if (hostName.Equals(server.host.c_str()))
 435     {
 436       CDateTime now = CDateTime::GetCurrentDateTime();
 437
 438       if (now > server.nextWake)
 439       {
 440         result = server;
 441         need_wakeup = true;
 442       }
 443       else // 'touch' next wakeup time
 444       {
 445         server.nextWake = now + server.timeout;
 446       }
 447
 448       break;
 449     }
 450   }
 451
 452   return need_wakeup;
 453 }
 454
 455 void CWakeOnAccess::TouchHostEntry (const CStdString& hostName)
 456 {
 457   CSingleLock lock (m_entrylist_protect);
 458
 459   for (EntriesVector::iterator i = m_entries.begin();i != m_entries.end(); ++i)
 460   {
 461     WakeUpEntry& server = *i;
 462
 463     if (hostName.Equals(server.host.c_str()))
 464     {
 465       server.nextWake = CDateTime::GetCurrentDateTime() + server.timeout;
 466       return;
 467     }
 468   }
 469 }
 470
 471 static void AddHost (const CStdString& host, vector<string>& hosts)
 472 {
 473   for (vector<string>::const_iterator it = hosts.begin(); it != hosts.end(); ++it)
 474     if (host.Equals((*it).c_str()))
 475       return; // allready there ..
 476
 477   if (!host.IsEmpty())
 478     hosts.push_back(host);
 479 }
 480
 481 static void AddHostFromDatabase(const DatabaseSettings& setting, vector<string>& hosts)
 482 {
 483   if (setting.type.Equals("mysql"))
 484     AddHost(setting.host, hosts);
 485 }
 486
 487 void CWakeOnAccess::QueueMACDiscoveryForHost(const CStdString& host)
 488 {
 489   if (IsEnabled())
 490   {
 491     if (URIUtils::IsHostOnLAN(host, true))
 492       CJobManager::GetInstance().AddJob(new CMACDiscoveryJob(host), this);
 493     else
 494       CLog::Log(LOGNOTICE, "%s - skip Mac discovery for non-local host '%s'", __FUNCTION__, host.c_str());
 495   }
 496 }
 497
 498 static void AddHostsFromMediaSource(const CMediaSource& source, std::vector<std::string>& hosts)
 499 {
 500   for (CStdStringArray::const_iterator it = source.vecPaths.begin() ; it != source.vecPaths.end(); it++)
 501   {
 502     CURL url = *it;
 503
 504     AddHost (url.GetHostName(), hosts);
 505   }
 506 }
 507
 508 static void AddHostsFromVecSource(const VECSOURCES& sources, vector<string>& hosts)
 509 {
 510   for (VECSOURCES::const_iterator it = sources.begin(); it != sources.end(); it++)
 511     AddHostsFromMediaSource(*it, hosts);
 512 }
 513
 514 static void AddHostsFromVecSource(const VECSOURCES* sources, vector<string>& hosts)
 515 {
 516   if (sources)
 517     AddHostsFromVecSource(*sources, hosts);
 518 }
 519
 520 void CWakeOnAccess::QueueMACDiscoveryForAllRemotes()
 521 {
 522   vector<string> hosts;
 523
 524   // add media sources
 525   CMediaSourceSettings& ms = CMediaSourceSettings::Get();
 526
 527   AddHostsFromVecSource(ms.GetSources("video"), hosts);
 528   AddHostsFromVecSource(ms.GetSources("music"), hosts);
 529   AddHostsFromVecSource(ms.GetSources("files"), hosts);
 530   AddHostsFromVecSource(ms.GetSources("pictures"), hosts);
 531   AddHostsFromVecSource(ms.GetSources("programs"), hosts);
 532
 533   // add mysql servers
 534   AddHostFromDatabase(g_advancedSettings.m_databaseVideo, hosts);
 535   AddHostFromDatabase(g_advancedSettings.m_databaseMusic, hosts);
 536   AddHostFromDatabase(g_advancedSettings.m_databaseEpg, hosts);
 537   AddHostFromDatabase(g_advancedSettings.m_databaseTV, hosts);
 538
 539   // add from path substitutions ..
 540   for (CAdvancedSettings::StringMapping::iterator i = g_advancedSettings.m_pathSubstitutions.begin(); i != g_advancedSettings.m_pathSubstitutions.end(); ++i)
 541   {
 542     CURL url = i->second;
 543
 544     AddHost (url.GetHostName(), hosts);
 545   }
 546
 547   for (vector<string>::const_iterator it = hosts.begin(); it != hosts.end(); it++)
 548     QueueMACDiscoveryForHost(*it);
 549 }
 550
 551 void CWakeOnAccess::SaveMACDiscoveryResult(const CStdString& host, const CStdString& mac)
 552 {
 553   CLog::Log(LOGNOTICE, "%s - Mac discovered for host '%s' -> '%s'", __FUNCTION__, host.c_str(), mac.c_str());
 554
 555   CStdString heading = LOCALIZED(13033);
 556
 557   for (EntriesVector::iterator i = m_entries.begin(); i != m_entries.end(); ++i)
 558   {
 559     if (host.Equals(i->host.c_str()))
 560     {
 561       CLog::Log(LOGDEBUG, "%s - Update existing entry for host '%s'", __FUNCTION__, host.c_str());
 562       if (!mac.Equals(i->mac.c_str()))
 563       {
 564         if (IsEnabled()) // show notification only if we have general feature enabled
 565         {
 566           CStdString message = StringUtils::Format(LOCALIZED(13034), host.c_str());
 567           CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, heading, message, 4000, true, 3000);
 568         }
 569
 570         i->mac = mac;
 571         SaveToXML();
 572       }
 573
 574       return;
 575     }
 576   }
 577
 578   // not found entry to update - create using default values
 579   WakeUpEntry entry (true);
 580   entry.host = host;
 581   entry.mac  = mac;
 582   m_entries.push_back(entry);
 583
 584   CLog::Log(LOGDEBUG, "%s - Create new entry for host '%s'", __FUNCTION__, host.c_str());
 585   if (IsEnabled()) // show notification only if we have general feature enabled
 586   {
 587     CStdString message = StringUtils::Format(LOCALIZED(13035), host.c_str());
 588     CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, heading, message, 4000, true, 3000);
 589   }
 590
 591   SaveToXML();
 592 }
 593
 594 void CWakeOnAccess::OnJobComplete(unsigned int jobID, bool success, CJob *job)
 595 {
 596   CMACDiscoveryJob* discoverJob = (CMACDiscoveryJob*)job;
 597
 598   const CStdString& host = discoverJob->GetHost();
 599   const CStdString& mac = discoverJob->GetMAC();
 600
 601   if (success)
 602   {
 603     CSingleLock lock (m_entrylist_protect);
 604
 605     SaveMACDiscoveryResult(host, mac);
 606   }
 607   else
 608   {
 609     CLog::Log(LOGERROR, "%s - Mac discovery failed for host '%s'", __FUNCTION__, host.c_str());
 610
 611     if (IsEnabled())
 612     {
 613       CStdString heading = LOCALIZED(13033);
 614       CStdString message = StringUtils::Format(LOCALIZED(13036), host.c_str());
 615       CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, heading, message, 4000, true, 3000);
 616     }
 617   }
 618 }
 619
 620 CStdString CWakeOnAccess::GetSettingFile()
 621 {
 622   return CSpecialProtocol::TranslatePath("special://masterprofile/wakeonlan.xml");
 623 }
 624
 625 void CWakeOnAccess::OnSettingsLoaded()
 626 {
 627   CSingleLock lock (m_entrylist_protect);
 628
 629   LoadFromXML();
 630 }
 631
 632 void CWakeOnAccess::OnSettingsSaved() const
 633 {
 634   bool enabled = CSettings::Get().GetBool("powermanagement.wakeonaccess");
 635
 636   if (enabled != IsEnabled())
 637   {
 638     CWakeOnAccess& woa = CWakeOnAccess::Get();
 639
 640     woa.SetEnabled(enabled);
 641
 642     if (enabled)
 643       woa.QueueMACDiscoveryForAllRemotes();
 644   }
 645 }
 646
 647 void CWakeOnAccess::LoadFromXML()
 648 {
 649   bool enabled = CSettings::Get().GetBool("powermanagement.wakeonaccess");
 650   SetEnabled(enabled);
 651
 652   CXBMCTinyXML xmlDoc;
 653   if (!xmlDoc.LoadFile(GetSettingFile()))
 654   {
 655     CLog::Log(LOGNOTICE, "%s - unable to load:%s", __FUNCTION__, GetSettingFile().c_str());
 656     return;
 657   }
 658
 659   TiXmlElement* pRootElement = xmlDoc.RootElement();
 660   if (strcmpi(pRootElement->Value(), "onaccesswakeup"))
 661   {
 662     CLog::Log(LOGERROR, "%s - XML file %s doesnt contain <onaccesswakeup>", __FUNCTION__, GetSettingFile().c_str());
 663     return;
 664   }
 665
 666   m_entries.clear();
 667
 668   CLog::Log(LOGNOTICE,"WakeOnAccess - Load settings :");
 669
 670   int tmp;
 671   if (XMLUtils::GetInt(pRootElement, "netinittimeout", tmp, 0, 5 * 60))
 672     m_netinit_sec = tmp;
 673   CLog::Log(LOGNOTICE,"  -Network init timeout : [%d] sec", m_netinit_sec);
 674
 675   if (XMLUtils::GetInt(pRootElement, "netsettletime", tmp, 0, 5 * 1000))
 676     m_netsettle_ms = tmp;
 677   CLog::Log(LOGNOTICE,"  -Network settle time  : [%d] ms", m_netsettle_ms);
 678
 679   const TiXmlNode* pWakeUp = pRootElement->FirstChildElement("wakeup");
 680   while (pWakeUp)
 681   {
 682     WakeUpEntry entry;
 683
 684     CStdString strtmp;
 685     if (XMLUtils::GetString(pWakeUp, "host", strtmp))
 686       entry.host = strtmp;
 687
 688     if (XMLUtils::GetString(pWakeUp, "mac", strtmp))
 689       entry.mac = strtmp;
 690
 691     if (entry.host.empty())
 692       CLog::Log(LOGERROR, "%s - Missing <host> tag or it's empty", __FUNCTION__);
 693     else if (entry.mac.empty())
 694        CLog::Log(LOGERROR, "%s - Missing <mac> tag or it's empty", __FUNCTION__);
 695     else
 696     {
 697       if (XMLUtils::GetInt(pWakeUp, "pingport", tmp, 0, USHRT_MAX))
 698         entry.ping_port = (unsigned short) tmp;
 699
 700       if (XMLUtils::GetInt(pWakeUp, "pingmode", tmp, 0, USHRT_MAX))
 701         entry.ping_mode = (unsigned short) tmp;
 702
 703       if (XMLUtils::GetInt(pWakeUp, "timeout", tmp, 10, 12 * 60 * 60))
 704         entry.timeout.SetDateTimeSpan (0, 0, 0, tmp);
 705
 706       if (XMLUtils::GetInt(pWakeUp, "waitonline", tmp, 0, 10 * 60)) // max 10 minutes
 707         entry.wait_online1_sec = tmp;
 708
 709       if (XMLUtils::GetInt(pWakeUp, "waitonline2", tmp, 0, 10 * 60)) // max 10 minutes
 710         entry.wait_online2_sec = tmp;
 711
 712       if (XMLUtils::GetInt(pWakeUp, "waitservices", tmp, 0, 5 * 60)) // max 5 minutes
 713         entry.wait_services_sec = tmp;
 714
 715       CLog::Log(LOGNOTICE,"  Registering wakeup entry:");
 716       CLog::Log(LOGNOTICE,"    HostName        : %s", entry.host.c_str());
 717       CLog::Log(LOGNOTICE,"    MacAddress      : %s", entry.mac.c_str());
 718       CLog::Log(LOGNOTICE,"    PingPort        : %d", entry.ping_port);
 719       CLog::Log(LOGNOTICE,"    PingMode        : %d", entry.ping_mode);
 720       CLog::Log(LOGNOTICE,"    Timeout         : %d (sec)", GetTotalSeconds(entry.timeout));
 721       CLog::Log(LOGNOTICE,"    WaitForOnline   : %d (sec)", entry.wait_online1_sec);
 722       CLog::Log(LOGNOTICE,"    WaitForOnlineEx : %d (sec)", entry.wait_online2_sec);
 723       CLog::Log(LOGNOTICE,"    WaitForServices : %d (sec)", entry.wait_services_sec);
 724
 725       m_entries.push_back(entry);
 726     }
 727
 728     pWakeUp = pWakeUp->NextSiblingElement("wakeup"); // get next one
 729   }
 730 }
 731
 732 void CWakeOnAccess::SaveToXML()
 733 {
 734   CXBMCTinyXML xmlDoc;
 735   TiXmlElement xmlRootElement("onaccesswakeup");
 736   TiXmlNode *pRoot = xmlDoc.InsertEndChild(xmlRootElement);
 737   if (!pRoot) return;
 738
 739   XMLUtils::SetInt(pRoot, "netinittimeout", m_netinit_sec);
 740   XMLUtils::SetInt(pRoot, "netsettletime", m_netsettle_ms);
 741
 742   for (EntriesVector::const_iterator i = m_entries.begin(); i != m_entries.end(); ++i)
 743   {
 744     TiXmlElement xmlSetting("wakeup");
 745     TiXmlNode* pWakeUpNode = pRoot->InsertEndChild(xmlSetting);
 746     if (pWakeUpNode)
 747     {
 748       XMLUtils::SetString(pWakeUpNode, "host", i->host);
 749       XMLUtils::SetString(pWakeUpNode, "mac", i->mac);
 750       XMLUtils::SetInt(pWakeUpNode, "pingport", i->ping_port);
 751       XMLUtils::SetInt(pWakeUpNode, "pingmode", i->ping_mode);
 752       XMLUtils::SetInt(pWakeUpNode, "timeout", GetTotalSeconds(i->timeout));
 753       XMLUtils::SetInt(pWakeUpNode, "waitonline", i->wait_online1_sec);
 754       XMLUtils::SetInt(pWakeUpNode, "waitonline2", i->wait_online2_sec);
 755       XMLUtils::SetInt(pWakeUpNode, "waitservices", i->wait_services_sec);
 756     }
 757   }
 758
 759   xmlDoc.SaveFile(GetSettingFile());
 760 }