xbmc/network/EventServer.cpp

   1 /*
   2  *      Copyright (C) 2005-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 "system.h"
  22
  23 #ifdef HAS_EVENT_SERVER
  24
  25 #include "EventServer.h"
  26 #include "EventPacket.h"
  27 #include "EventClient.h"
  28 #include "Socket.h"
  29 #include "threads/CriticalSection.h"
  30 #include "Application.h"
  31 #include "interfaces/builtins/Builtins.h"
  32 #include "input/ButtonTranslator.h"
  33 #include "threads/SingleLock.h"
  34 #include "Zeroconf.h"
  35 #include "guilib/GUIAudioManager.h"
  36 #include "input/Key.h"
  37 #include "utils/log.h"
  38 #include "utils/SystemInfo.h"
  39 #include "Util.h"
  40 #include <map>
  41 #include <queue>
  42 #include <cassert>
  43
  44 using namespace EVENTSERVER;
  45 using namespace EVENTPACKET;
  46 using namespace EVENTCLIENT;
  47 using namespace SOCKETS;
  48
  49 /************************************************************************/
  50 /* CEventServer                                                         */
  51 /************************************************************************/
  52 CEventServer* CEventServer::m_pInstance = NULL;
  53 CEventServer::CEventServer() : CThread("EventServer")
  54 {
  55   m_pSocket       = NULL;
  56   m_pPacketBuffer = NULL;
  57   m_bStop         = false;
  58   m_bRunning      = false;
  59   m_bRefreshSettings = false;
  60
  61   // default timeout in ms for receiving a single packet
  62   m_iListenTimeout = 1000;
  63 }
  64
  65 void CEventServer::RemoveInstance()
  66 {
  67   if (m_pInstance)
  68   {
  69     delete m_pInstance;
  70     m_pInstance=NULL;
  71   }
  72 }
  73
  74 CEventServer* CEventServer::GetInstance()
  75 {
  76   if (!m_pInstance)
  77   {
  78     m_pInstance = new CEventServer();
  79   }
  80   return m_pInstance;
  81 }
  82
  83 void CEventServer::StartServer()
  84 {
  85   CSingleLock lock(m_critSection);
  86   if(m_bRunning)
  87     return;
  88
  89   // set default port
  90   m_iPort = CSettings::GetInstance().GetInt(CSettings::SETTING_SERVICES_ESPORT);
  91   assert(m_iPort <= 65535 && m_iPort >= 1);
  92
  93   // max clients
  94   m_iMaxClients = CSettings::GetInstance().GetInt(CSettings::SETTING_SERVICES_ESMAXCLIENTS);
  95   if (m_iMaxClients < 0)
  96   {
  97     CLog::Log(LOGERROR, "ES: Invalid maximum number of clients specified %d", m_iMaxClients);
  98     m_iMaxClients = 20;
  99   }
 100
 101   CThread::Create();
 102 }
 103
 104 void CEventServer::StopServer(bool bWait)
 105 {
 106   CZeroconf::GetInstance()->RemoveService("services.eventserver");
 107   StopThread(bWait);
 108 }
 109
 110 void CEventServer::Cleanup()
 111 {
 112   if (m_pSocket)
 113   {
 114     m_pSocket->Close();
 115     delete m_pSocket;
 116     m_pSocket = NULL;
 117   }
 118
 119   if (m_pPacketBuffer)
 120   {
 121     free(m_pPacketBuffer);
 122     m_pPacketBuffer = NULL;
 123   }
 124   CSingleLock lock(m_critSection);
 125
 126   std::map<unsigned long, CEventClient*>::iterator iter = m_clients.begin();
 127   while (iter != m_clients.end())
 128   {
 129     if (iter->second)
 130     {
 131       delete iter->second;
 132     }
 133     m_clients.erase(iter);
 134     iter =  m_clients.begin();
 135   }
 136 }
 137
 138 int CEventServer::GetNumberOfClients()
 139 {
 140   CSingleLock lock(m_critSection);
 141   return m_clients.size();
 142 }
 143
 144 void CEventServer::Process()
 145 {
 146   while(!m_bStop)
 147   {
 148     Run();
 149     if (!m_bStop)
 150       Sleep(1000);
 151   }
 152 }
 153
 154 void CEventServer::Run()
 155 {
 156   CSocketListener listener;
 157   int packetSize = 0;
 158
 159   CLog::Log(LOGNOTICE, "ES: Starting UDP Event server on port %d", m_iPort);
 160
 161   Cleanup();
 162
 163   // create socket and initialize buffer
 164   m_pSocket = CSocketFactory::CreateUDPSocket();
 165   if (!m_pSocket)
 166   {
 167     CLog::Log(LOGERROR, "ES: Could not create socket, aborting!");
 168     return;
 169   }
 170   m_pPacketBuffer = (unsigned char *)malloc(PACKET_SIZE);
 171
 172   if (!m_pPacketBuffer)
 173   {
 174     CLog::Log(LOGERROR, "ES: Out of memory, could not allocate packet buffer");
 175     return;
 176   }
 177
 178   // bind to IP and start listening on port
 179   int port_range = CSettings::GetInstance().GetInt(CSettings::SETTING_SERVICES_ESPORTRANGE);
 180   if (port_range < 1 || port_range > 100)
 181   {
 182     CLog::Log(LOGERROR, "ES: Invalid port range specified %d, defaulting to 10", port_range);
 183     port_range = 10;
 184   }
 185   if (!m_pSocket->Bind(!CSettings::GetInstance().GetBool(CSettings::SETTING_SERVICES_ESALLINTERFACES), m_iPort, port_range))
 186   {
 187     CLog::Log(LOGERROR, "ES: Could not listen on port %d", m_iPort);
 188     return;
 189   }
 190
 191   // publish service
 192   std::vector<std::pair<std::string, std::string> > txt;
 193   CZeroconf::GetInstance()->PublishService("servers.eventserver",
 194                                "_xbmc-events._udp",
 195                                CSysInfo::GetDeviceName(),
 196                                m_iPort,
 197                                txt);
 198
 199   // add our socket to the 'select' listener
 200   listener.AddSocket(m_pSocket);
 201
 202   m_bRunning = true;
 203
 204   while (!m_bStop)
 205   {
 206     try
 207     {
 208       // start listening until we timeout
 209       if (listener.Listen(m_iListenTimeout))
 210       {
 211         CAddress addr;
 212         if ((packetSize = m_pSocket->Read(addr, PACKET_SIZE, (void *)m_pPacketBuffer)) > -1)
 213         {
 214           ProcessPacket(addr, packetSize);
 215         }
 216       }
 217     }
 218     catch (...)
 219     {
 220       CLog::Log(LOGERROR, "ES: Exception caught while listening for socket");
 221       break;
 222     }
 223
 224     // process events and queue the necessary actions and button codes
 225     ProcessEvents();
 226
 227     // refresh client list
 228     RefreshClients();
 229
 230     // broadcast
 231     // BroadcastBeacon();
 232   }
 233
 234   CLog::Log(LOGNOTICE, "ES: UDP Event server stopped");
 235   m_bRunning = false;
 236   Cleanup();
 237 }
 238
 239 void CEventServer::ProcessPacket(CAddress& addr, int pSize)
 240 {
 241   // check packet validity
 242   CEventPacket* packet = new CEventPacket(pSize, m_pPacketBuffer);
 243   if(packet == NULL)
 244   {
 245     CLog::Log(LOGERROR, "ES: Out of memory, cannot accept packet");
 246     return;
 247   }
 248
 249   unsigned int clientToken;
 250
 251   if (!packet->IsValid())
 252   {
 253     CLog::Log(LOGDEBUG, "ES: Received invalid packet");
 254     delete packet;
 255     return;
 256   }
 257
 258   clientToken = packet->ClientToken();
 259   if (!clientToken)
 260     clientToken = addr.ULong(); // use IP if packet doesn't have a token
 261
 262   CSingleLock lock(m_critSection);
 263
 264   // first check if we have a client for this address
 265   std::map<unsigned long, CEventClient*>::iterator iter = m_clients.find(clientToken);
 266
 267   if ( iter == m_clients.end() )
 268   {
 269     if ( m_clients.size() >= (unsigned int)m_iMaxClients)
 270     {
 271       CLog::Log(LOGWARNING, "ES: Cannot accept any more clients, maximum client count reached");
 272       delete packet;
 273       return;
 274     }
 275
 276     // new client
 277     CEventClient* client = new CEventClient ( addr );
 278     if (client==NULL)
 279     {
 280       CLog::Log(LOGERROR, "ES: Out of memory, cannot accept new client connection");
 281       delete packet;
 282       return;
 283     }
 284
 285     m_clients[clientToken] = client;
 286   }
 287   m_clients[clientToken]->AddPacket(packet);
 288 }
 289
 290 void CEventServer::RefreshClients()
 291 {
 292   CSingleLock lock(m_critSection);
 293   std::map<unsigned long, CEventClient*>::iterator iter = m_clients.begin();
 294
 295   while ( iter != m_clients.end() )
 296   {
 297     if (! (iter->second->Alive()))
 298     {
 299       CLog::Log(LOGNOTICE, "ES: Client %s from %s timed out", iter->second->Name().c_str(),
 300                 iter->second->Address().Address());
 301       delete iter->second;
 302       m_clients.erase(iter);
 303       iter = m_clients.begin();
 304     }
 305     else
 306     {
 307       if (m_bRefreshSettings)
 308       {
 309         iter->second->RefreshSettings();
 310       }
 311       ++iter;
 312     }
 313   }
 314   m_bRefreshSettings = false;
 315 }
 316
 317 void CEventServer::ProcessEvents()
 318 {
 319   CSingleLock lock(m_critSection);
 320   std::map<unsigned long, CEventClient*>::iterator iter = m_clients.begin();
 321
 322   while (iter != m_clients.end())
 323   {
 324     iter->second->ProcessEvents();
 325     ++iter;
 326   }
 327 }
 328
 329 bool CEventServer::ExecuteNextAction()
 330 {
 331   CSingleLock lock(m_critSection);
 332
 333   CEventAction actionEvent;
 334   std::map<unsigned long, CEventClient*>::iterator iter = m_clients.begin();
 335
 336   while (iter != m_clients.end())
 337   {
 338     if (iter->second->GetNextAction(actionEvent))
 339     {
 340       // Leave critical section before processing action
 341       lock.Leave();
 342       switch(actionEvent.actionType)
 343       {
 344       case AT_EXEC_BUILTIN:
 345         CBuiltins::GetInstance().Execute(actionEvent.actionName);
 346         break;
 347
 348       case AT_BUTTON:
 349         {
 350           int actionID;
 351           CButtonTranslator::TranslateActionString(actionEvent.actionName.c_str(), actionID);
 352           CAction action(actionID, 1.0f, 0.0f, actionEvent.actionName);
 353           g_audioManager.PlayActionSound(action);
 354           g_application.OnAction(action);
 355         }
 356         break;
 357       }
 358       return true;
 359     }
 360     ++iter;
 361   }
 362
 363   return false;
 364 }
 365
 366 unsigned int CEventServer::GetButtonCode(std::string& strMapName, bool& isAxis, float& fAmount, bool &isJoystick)
 367 {
 368   CSingleLock lock(m_critSection);
 369   std::map<unsigned long, CEventClient*>::iterator iter = m_clients.begin();
 370   unsigned int bcode = 0;
 371
 372   while (iter != m_clients.end())
 373   {
 374     bcode = iter->second->GetButtonCode(strMapName, isAxis, fAmount, isJoystick);
 375     if (bcode)
 376       return bcode;
 377     ++iter;
 378   }
 379   return bcode;
 380 }
 381
 382 bool CEventServer::GetMousePos(float &x, float &y)
 383 {
 384   CSingleLock lock(m_critSection);
 385   std::map<unsigned long, CEventClient*>::iterator iter = m_clients.begin();
 386
 387   while (iter != m_clients.end())
 388   {
 389     if (iter->second->GetMousePos(x, y))
 390       return true;
 391     ++iter;
 392   }
 393   return false;
 394 }
 395
 396 #endif // HAS_EVENT_SERVER