HLH_UDPSock.cpp

   1 /*******************************************************************************
   2  *    File Name : HLH_UDPSock.cpp
   3  *
   4  *       Author : Henry He
   5  * Created Time : 2009-10-10 16:36:17
   6  *  Description :
   7  ******************************************************************************/
   8
   9
  10
  11
  12 /*******************************************************************************
  13  * Desc : Includes Files
  14  ******************************************************************************/
  15
  16 #include "HLH_utils/HLH_UDPSock.h"
  17
  18
  19 /*******************************************************************************
  20  * Desc : Macro Definations
  21  ******************************************************************************/
  22
  23
  24 /*******************************************************************************
  25  * Desc : Type Definations
  26  ******************************************************************************/
  27
  28
  29 /*******************************************************************************
  30  * Desc : Global Variables
  31  ******************************************************************************/
  32
  33
  34 /*******************************************************************************
  35  * Desc : File Variables
  36  ******************************************************************************/
  37
  38
  39
  40
  41
  42
  43 /******************************************************************************
  44  * Desc : Member Functions
  45  ******************************************************************************/
  46
  47
  48
  49
  50
  51 /******************************************************************************
  52  * Func : HLH_UDPSock::HLH_UDPSock
  53  * Desc : Constuctor of HLH_UDPSock
  54  * Args : NONE
  55  * Outs : NONE
  56  ******************************************************************************/
  57 HLH_UDPSock::HLH_UDPSock ()
  58 {
  59   m_zhmMutex.Init ();
  60   m_bCreated = false;
  61 }
  62
  63
  64 /******************************************************************************
  65  * Func : HLH_UDPSock::~HLH_UDPSock
  66  * Desc : Deconstructor of HLH_UDPSock
  67  * Args : NONE
  68  * Outs : NONE
  69  ******************************************************************************/
  70 HLH_UDPSock::~HLH_UDPSock ()
  71 {
  72   Destroy ();
  73 }
  74
  75
  76
  77
  78
  79 /******************************************************************************
  80  * Desc : Operations
  81  ******************************************************************************/
  82
  83
  84
  85
  86
  87 /******************************************************************************
  88  * Func : HLH_UDPSock::Create
  89  * Desc : Create UDP socket and bind it to zhsBindAddr,
  90  *        then create thread to handle receive event
  91  * Args : zhsBindAddr               address of bindding
  92  * Outs : If success return 0, otherwise return error code.
  93  ******************************************************************************/
  94 int HLH_UDPSock::Create (const HLH_SockAddr &zhsBindAddr)
  95 {
  96
  97   int nRetVal;
  98
  99   // Lock before process
 100   m_zhmMutex.Lock ();
 101
 102   // Check if this instance created
 103   if (m_bCreated) {
 104     // Unlock this instance
 105     m_zhmMutex.Unlock ();
 106
 107                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("already created") );
 108     return HLH_UDPSOCK_ERR_ALREADY_CREATED;
 109   }
 110
 111   // Init supper class HLH_Sock first
 112   nRetVal = HLH_Sock::Create (HLH_SOCK_TYPE_DGRAM, zhsBindAddr, false);
 113   if (nRetVal < 0) {
 114                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("create HLH_Sock failed") );
 115     goto fail;
 116   }
 117
 118   // Clear the receive handler list
 119   m_slRecvHandlerList.clear ();
 120
 121   // Start receive thread
 122   nRetVal = m_zhtRecvThread.Start (RecvThreadFunc, this);
 123   if (nRetVal < 0) {
 124                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("start received thread failed") );
 125     goto fail;
 126   }
 127
 128   // Notify that this instance created
 129   m_bCreated   = true;
 130   m_bConnected = false;
 131
 132   // Unlock after process
 133   m_zhmMutex.Unlock ();
 134
 135   return 0;
 136
 137 fail:
 138
 139   // Close the socket if needed
 140   if ( HLH_Sock::IsCreated () ) {
 141     HLH_Sock::Destroy ();
 142   }
 143
 144   // Unlock after process
 145   m_zhmMutex.Unlock ();
 146
 147   return HLH_UDPSOCK_ERR_CANT_CREATE;
 148 }
 149
 150
 151 /******************************************************************************
 152  * Func : HLH_UDPSock::Destroy
 153  * Desc : Destroy this UDP socket
 154  * Args : NONE
 155  * Outs : NONE
 156  ******************************************************************************/
 157 void HLH_UDPSock::Destroy ()
 158 {
 159   // Stop receive thread
 160   m_zhtRecvThread.Stop ();
 161
 162   // Lock this instance
 163   m_zhmMutex.Lock ();
 164
 165
 166   // Check if this instance created
 167   if (!m_bCreated) {
 168     // Unlock this instance
 169     m_zhmMutex.Unlock ();
 170
 171     return;
 172   }
 173
 174   // Clear receiver list
 175   m_slRecvHandlerList.clear ();
 176
 177   // Destroy this socket
 178   HLH_Sock::Destroy ();
 179
 180   m_bCreated = false;
 181   m_bConnected = false;
 182
 183   // Unlock this instance
 184   m_zhmMutex.Unlock ();
 185 }
 186
 187
 188 /******************************************************************************
 189  * Func : HLH_UDPSock::IsCreated
 190  * Desc : Whether this instance created
 191  * Args : NONE
 192  * Outs : If success return 0, otherwise return error code.
 193  ******************************************************************************/
 194 bool HLH_UDPSock::IsCreated ()
 195 {
 196   bool bCreated;
 197
 198   m_zhmMutex.Lock ();
 199   bCreated = m_bCreated;
 200   m_zhmMutex.Unlock ();
 201
 202   return bCreated;
 203 }
 204
 205
 206
 207
 208 /******************************************************************************
 209  * Func : HLH_UDPSock::AddRecvHandler
 210  * Desc : Add receive handler to this socket
 211  * Args : zorOnRecv       Funtion to handle receive event
 212  *        pvOnRecvParam   Parameter to \c zorOnRecv ()
 213  * Outs : if success, return 0, otherwise return error code
 214  ******************************************************************************/
 215 void HLH_UDPSock::AddRecvHandler (OnRecvFunc zorOnRecv, void *pvOnRecvParam)
 216 {
 217
 218   RecvHandler   zrhRecvHandler;
 219
 220   // Lock before process
 221   m_zhmMutex.Lock ();
 222
 223   // Put this handler into the list
 224   zrhRecvHandler.m_zorOnRecv   = zorOnRecv;
 225   zrhRecvHandler.m_pvOnRecvParam = pvOnRecvParam;
 226
 227   m_slRecvHandlerList.push_back (zrhRecvHandler);
 228
 229   // Lock after process
 230   m_zhmMutex.Unlock ();
 231 }
 232
 233
 234 /******************************************************************************
 235  * Func : HLH_UDPSock::DelRecvHandler
 236  * Desc : Delete receive handler from receive handler list
 237  * Args : zorOnRecv       Funtion to handle receive event
 238  *        pvOnRecvParam   Parameter to \c zorOnRecv ()
 239  * Outs : NONE
 240  ******************************************************************************/
 241 void HLH_UDPSock::DelRecvHandler (OnRecvFunc zorOnRecv, void *pvOnRecvParam)
 242 {
 243
 244   RecvHandler   zrhRecvHandler;
 245
 246   // Lock before process
 247   m_zhmMutex.Lock ();
 248
 249   // Remove this receiver handler
 250   zrhRecvHandler.m_zorOnRecv   = zorOnRecv;
 251   zrhRecvHandler.m_pvOnRecvParam = pvOnRecvParam;
 252
 253   m_slRecvHandlerList.remove (zrhRecvHandler);
 254
 255   // Unlock after process
 256   m_zhmMutex.Unlock ();
 257 }
 258
 259
 260 /******************************************************************************
 261  * Func : HLH_UDPSock::ClearRecvHandlerList
 262  * Desc : Clear the receive handler list
 263  * Args : NONE
 264  * Outs : NONE
 265  ******************************************************************************/
 266 void HLH_UDPSock::ClearRecvHandlerList ()
 267 {
 268   // Lock before process
 269   m_zhmMutex.Lock ();
 270
 271   // Clear the receive handler list
 272   m_slRecvHandlerList.clear ();
 273
 274   // Unlock after process
 275   m_zhmMutex.Unlock ();
 276 }
 277
 278 /******************************************************************************
 279  * Func : HLH_UDPSock::__RecvThreadFunc
 280  * Desc : Thread function to call receive handler functions
 281  * Args : zhtRecvThread         Thread that call \c RecvThreadFunc ()
 282  * Outs :
 283  ******************************************************************************/
 284 void HLH_UDPSock::__RecvThreadFunc ( HLH_Thread &zhtRecvThread )
 285 {
 286
 287   int           nRetVal;
 288
 289   UINT32        unLen;
 290   UINT32        unPollType;
 291   HLH_Time      zhtPollTime;
 292
 293   UINT8         acRecvBuf [HLH_UDPSOCK_MAX_RECEIVE_LENGTH];
 294   HLH_SockAddr  zhsPeerAddr;
 295   HLH_SockAddr  zhsConnAddr;
 296
 297   std::list<RecvHandler>::iterator slIt;
 298
 299   // Signal to zhtRecvThread that this thread functions runned
 300   zhtRecvThread.ThreadStarted ();
 301
 302
 303
 304   // Can't process socket not created
 305   if ( !IsCreated () ) {
 306                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("not created") );
 307     return;
 308   }
 309
 310
 311   do {
 312
 313     // Poll for receive events
 314     unPollType = HLH_SOCK_POLL_READ;
 315     zhtPollTime.SetTime (HLH_UDPSOCK_DEFAULT_POLLWAIT_SECONDS, 0);
 316
 317     nRetVal = PollWait (unPollType, zhtPollTime);
 318
 319     // If there is any data received
 320     if ( nRetVal > 0 ) {
 321
 322       // Receive the data
 323       nRetVal = RecvFrom (acRecvBuf, sizeof(acRecvBuf), zhsPeerAddr);
 324       if (nRetVal < 0) {
 325         // XXX: do nothing if receive error
 326         goto check_stop;
 327       }
 328       unLen = nRetVal;
 329
 330       // If connected, check the source ip, otherwise accept all
 331       nRetVal = GetConnectAddr (zhsConnAddr);
 332       if ( nRetVal < 0 || zhsConnAddr == zhsPeerAddr ) {
 333         // Call receive handler call back function
 334         for ( slIt = m_slRecvHandlerList.begin ();
 335             slIt != m_slRecvHandlerList.end (); slIt ++ ) {
 336           slIt->m_zorOnRecv (slIt->m_pvOnRecvParam, acRecvBuf, unLen, zhsPeerAddr);
 337         }
 338       } else {
 339         HLH_DEBUG ( HLH_DEBUG_MAIN, ("ignore package") );
 340       }
 341
 342     }
 343
 344 check_stop:
 345     // Check if stop request
 346     if ( zhtRecvThread.IsStopping () ) {
 347       return;
 348     }
 349
 350   } while (1);
 351
 352 }
 353
 354
 355 /******************************************************************************
 356  * Func : HLH_UDPSock::RecvThreadFunc
 357  * Desc : Wrapper of __RecvThreadFunc
 358  * Args : zhtRecvThread         Thread that call this function
 359  * Outs : Always return NULL.
 360  ******************************************************************************/
 361 void * HLH_UDPSock::RecvThreadFunc (HLH_Thread &zhtRecvThread, void *pvThis)
 362 {
 363   ASSERT (pvThis != NULL);
 364   ( (HLH_UDPSock*) pvThis )->__RecvThreadFunc (zhtRecvThread);
 365   return NULL;
 366 }
 367
 368
 369 /******************************************************************************
 370  * Func : HLH_UDPSock::Connect
 371  * Desc : Reload of HLH_Sock::Connect ()
 372  * Args : zhsPeekAddr             address to connect
 373  * Outs : if success, return 0, otherwise return error code
 374  ******************************************************************************/
 375 int HLH_UDPSock::Connect (const HLH_SockAddr &zhsSockAddr)
 376 {
 377   int nRetVal;
 378
 379   // Lock this instance
 380   m_zhmMutex.Lock ();
 381
 382   nRetVal = HLH_Sock::Connect (zhsSockAddr);
 383   if (nRetVal < 0) {
 384     goto failed;
 385   }
 386
 387   // Notify that this instance is created
 388   m_bConnected = true;
 389   m_zhsConnectAddr = zhsSockAddr;
 390
 391   // Unlock this instance
 392   m_zhmMutex.Unlock ();
 393
 394   return 0;
 395
 396 failed:
 397   // Unlock this instance
 398   m_zhmMutex.Unlock ();
 399
 400   return HLH_UDPSOCK_ERR_FAILED;
 401 }
 402
 403 /******************************************************************************
 404  * Func : HLH_UDPSock::GetConnectAddr
 405  * Desc : Get the address of peer if connected
 406  * Args : zhsConnectAddr      Space to save the address get
 407  * Outs : If success return 0, otherwise return error code.
 408  ******************************************************************************/
 409 int HLH_UDPSock::GetConnectAddr (HLH_SockAddr & zhsConnectAddr)
 410 {
 411   // Lock this instance
 412   m_zhmMutex.Lock ();
 413   if (!m_bCreated || !m_bConnected) {
 414     // Unlock this instance
 415     m_zhmMutex.Unlock ();
 416     HLH_DEBUG ( HLH_DEBUG_UTILS, ("not connected") );
 417     return HLH_UDPSOCK_ERR_NOT_CREATED;
 418   }
 419
 420   zhsConnectAddr = m_zhsConnectAddr;
 421
 422   // Unlock this instance
 423   m_zhmMutex.Unlock ();
 424
 425   return 0;
 426 }
 427
 428