HLH_Sock.cpp

   1 /*******************************************************************************
   2  *    File Name : HLH_Sock.cpp
   3  *
   4  *       Author : Henry He
   5  * Created Time : 2009-10-8 13:56:06
   6  *  Description :
   7  ******************************************************************************/
   8
   9
  10 /*******************************************************************************
  11  * Desc : Includes Files
  12  ******************************************************************************/
  13
  14
  15 #include "HLH_utils/typedef.h"
  16 #include "HLH_utils/HLH_Sock.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  * Desc : Member Functions
  43  ******************************************************************************/
  44
  45
  46
  47
  48
  49 /******************************************************************************
  50  * Desc : Constructor / Deconstructor
  51  ******************************************************************************/
  52
  53
  54
  55 /******************************************************************************
  56  * Func : HLH_Sock::HLH_Sock
  57  * Desc : Constructor of HLH_Sock
  58  * Args : NONE
  59  * Outs : NONE
  60  ******************************************************************************/
  61 HLH_Sock::HLH_Sock ()
  62 {
  63
  64   // Init member variables
  65   m_fdSocket     = -1;
  66   m_bCreated    = false;
  67
  68   // Init Mutexs
  69   m_zhmMainMutex.Init ();
  70   m_zhmSendMutex.Init ();
  71   m_zhmRecvMutex.Init ();
  72 }
  73
  74
  75
  76 /******************************************************************************
  77  * Func : HLH_Sock::~HLH_Sock
  78  * Desc : Deconstructor of HLH_Sock
  79  * Args : NONE
  80  * Outs : NONE
  81  ******************************************************************************/
  82 HLH_Sock::~HLH_Sock ()
  83 {
  84   Destroy ();
  85 }
  86
  87
  88
  89 /******************************************************************************
  90  * Desc : Common Operations
  91  ******************************************************************************/
  92
  93
  94
  95
  96
  97 /******************************************************************************
  98  * Func : HLH_Sock::Create
  99  * Desc : Initialize the socket and bind it
 100  * Args : zhsSockType         socket type
 101  *        zhsSockAddr         address to be binded
 102  *        bNonblocking        whether create this socket nonblocking
 103  *                            (default is blocking)
 104  * Outs : if success, return 0, otherwise return error code
 105  ******************************************************************************/
 106 int HLH_Sock::Create (HLH_SockType zhsSockType,
 107     const HLH_SockAddr &zhsSockAddr, bool bNonblocking)
 108 {
 109   int nRetVal;
 110   int nFlags;
 111
 112   // Lock before process
 113   m_zhmMainMutex.Lock ();
 114
 115   if (m_bCreated) {
 116     // Unlock after process
 117     m_zhmMainMutex.Unlock ();
 118                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("already created") );
 119     return HLH_SOCK_ERR_ALREADY_CREATED;
 120   }
 121
 122   // Create socket
 123   switch (zhsSockType) {
 124     case HLH_SOCK_TYPE_STREAM:
 125       m_fdSocket = socket (AF_INET, SOCK_STREAM, 0);
 126       break;
 127
 128     case HLH_SOCK_TYPE_DGRAM:
 129       m_fdSocket = socket (AF_INET, SOCK_DGRAM, 0);
 130       break;
 131
 132     default:
 133                         HLH_DEBUG ( HLH_DEBUG_UTILS, ("sock type not supported") );
 134       goto failed;
 135   }
 136
 137   if (m_fdSocket < 0) {
 138                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("can't create socket") );
 139     goto failed;
 140   }
 141
 142   // Set Nonblocking if request
 143   if (bNonblocking) {
 144     nFlags  = fcntl (m_fdSocket, F_GETFL, 0);
 145     nRetVal = fcntl (m_fdSocket, F_SETFL, nFlags|O_NONBLOCK);
 146
 147     if (nRetVal < 0) {
 148                         HLH_DEBUG ( HLH_DEBUG_MAIN, ("can't set nonblock") );
 149       goto failed;
 150     }
 151   }
 152
 153   // Bind on specific address
 154   nRetVal = bind (  m_fdSocket, zhsSockAddr.GetAddrPointer (),
 155       zhsSockAddr.GetAddrLen ()  );
 156
 157   if (nRetVal < 0) {
 158                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("can't bind on address") );
 159     goto failed;
 160   }
 161
 162   // Prepare fd_set for poll
 163   FD_ZERO (&m_fsReadSet);
 164   FD_ZERO (&m_fsWriteSet);
 165   FD_ZERO (&m_fsErrorSet);
 166
 167   FD_SET (m_fdSocket, &m_fsReadSet);
 168   FD_SET (m_fdSocket, &m_fsWriteSet);
 169   FD_SET (m_fdSocket, &m_fsErrorSet);
 170
 171   // Notify that this socket has been create
 172   m_bCreated = true;
 173
 174   // Unlock after process
 175   m_zhmMainMutex.Unlock ();
 176   return 0;
 177
 178 failed:
 179
 180   // Close socket if failed after create
 181   if (m_fdSocket >= 0) {
 182     close (m_fdSocket);
 183     m_fdSocket = -1;
 184   }
 185
 186   // Unlock after process
 187   m_zhmMainMutex.Unlock ();
 188
 189   return HLH_SOCK_ERR_CANT_CREATE;
 190
 191 }
 192
 193
 194 /******************************************************************************
 195  * Func : HLH_Sock::Create
 196  * Desc : Initialize the socket from a initialized socket file descriptor
 197  * Args : fdSock              file descriptor to create from
 198  * Outs : if success return 0, otherwise return error code
 199  ******************************************************************************/
 200 int HLH_Sock::Create (int fdSock, bool bNonblocking)
 201 {
 202
 203   int nRetVal;
 204   int nFlags;
 205
 206   // Lock before process
 207   m_zhmMainMutex.Lock ();
 208
 209   if (m_bCreated) {
 210     // Unlock after process
 211     m_zhmMainMutex.Unlock ();
 212                 HLH_DEBUG ( HLH_DEBUG_MAIN, ("already created") );
 213     return HLH_SOCK_ERR_ALREADY_CREATED;
 214   }
 215
 216   m_fdSocket = fdSock;
 217
 218   // Set Nonblocking if request
 219   if (bNonblocking) {
 220     nFlags  = fcntl (m_fdSocket, F_GETFL, 0);
 221     nRetVal = fcntl (m_fdSocket, F_SETFL, nFlags|O_NONBLOCK);
 222
 223     if (nRetVal < 0) {
 224                         HLH_DEBUG ( HLH_DEBUG_MAIN, ("can't set nonblock") );
 225       goto failed;
 226     }
 227   }
 228
 229
 230   // Prepare fd_set for poll
 231   FD_ZERO (&m_fsReadSet);
 232   FD_ZERO (&m_fsWriteSet);
 233   FD_ZERO (&m_fsErrorSet);
 234
 235   FD_SET (m_fdSocket, &m_fsReadSet);
 236   FD_SET (m_fdSocket, &m_fsWriteSet);
 237   FD_SET (m_fdSocket, &m_fsErrorSet);
 238
 239   // Notify that this socket has been created
 240   m_bCreated = true;
 241
 242   // Unlock after process
 243   m_zhmMainMutex.Unlock ();
 244
 245   return 0;
 246
 247 failed:
 248
 249   // Unlock after process
 250   m_zhmMainMutex.Unlock ();
 251
 252   return HLH_SOCK_ERR_CANT_CREATE;
 253
 254 }
 255
 256
 257 /******************************************************************************
 258  * Func : HLH_Sock::Destroy
 259  * Desc : Destroy the socket, will wait for send/pollwait operations
 260  * Args : NONE
 261  * Outs : If success, return 0, otherwise return error code
 262  ******************************************************************************/
 263 int HLH_Sock::Destroy ()
 264 {
 265
 266   // Wait for send operations
 267   m_zhmSendMutex.Lock ();
 268
 269   // Wait for operations other than read/write
 270   m_zhmMainMutex.Lock ();
 271
 272   // if not create, can't close
 273   if (!m_bCreated) {
 274     // Unlock operations other than read/write
 275     m_zhmMainMutex.Unlock ();
 276
 277     // Unlock send operations
 278     m_zhmSendMutex.Unlock ();
 279
 280     return HLH_SOCK_ERR_NOT_CREATED;
 281   }
 282
 283
 284   // Receive operations won't be waited
 285
 286   // Close the socket now
 287   close (m_fdSocket);
 288   m_fdSocket = -1;
 289   m_bCreated = false;
 290
 291
 292   // Unlock operations other than read/write
 293   m_zhmMainMutex.Unlock ();
 294
 295   // Unlock send operations
 296   m_zhmSendMutex.Unlock ();
 297
 298   return 0;
 299 }
 300
 301
 302
 303
 304 /******************************************************************************
 305  * Func : HLH_Sock::IsCreated
 306  * Desc : Whether this socket created
 307  * Args : NONE
 308  * Outs : If created return true, otherwise return false
 309  ******************************************************************************/
 310 bool HLH_Sock::IsCreated ()
 311 {
 312   bool bCreated;
 313
 314   m_zhmMainMutex.Lock ();
 315   bCreated = m_bCreated;
 316   m_zhmMainMutex.Unlock ();
 317
 318   return bCreated;
 319 }
 320
 321
 322
 323
 324 /******************************************************************************
 325  * Func : HLH_Sock::Listen
 326  * Desc : Listen for socket connections and limit the queue of incoming connections
 327  * Args : unQueue           length of listen queue
 328  * Outs : if success, return 0, otherwise return error code
 329  ******************************************************************************/
 330 int HLH_Sock::Listen (UINT32 unQueue)
 331 {
 332   int nRetVal;
 333
 334   // Lock before process
 335   m_zhmMainMutex.Lock ();
 336
 337   // Can't listen on socket which is not created
 338   if (!m_bCreated) {
 339     // Unlock after process
 340     m_zhmMainMutex.Unlock ();
 341
 342                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 343     return HLH_SOCK_ERR_NOT_CREATED;
 344   }
 345
 346   nRetVal = listen (m_fdSocket, unQueue);
 347   if (nRetVal < 0) {
 348                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("listen failed") );
 349     goto failed;
 350   }
 351
 352   // Unlock after process
 353   m_zhmMainMutex.Unlock ();
 354
 355   return 0;
 356
 357 failed:
 358   // Unlock after process
 359   m_zhmMainMutex.Unlock ();
 360
 361   return HLH_SOCK_ERR_FAILED;
 362 }
 363
 364
 365 /******************************************************************************
 366  * Func : HLH_Sock::Connect
 367  * Desc : Requests a connection to be made on a socket
 368  * Args : zhsPeekAddr             address to connect
 369  * Outs : if success, return 0, otherwise return error code
 370  ******************************************************************************/
 371 int HLH_Sock::Connect (const HLH_SockAddr &zhsPeekAddr)
 372 {
 373   int nRetVal;
 374
 375   // Lock before process
 376   m_zhmMainMutex.Lock ();
 377
 378   // Can't Connect on socket which is not created
 379   if (!m_bCreated) {
 380     // Unlock after process
 381     m_zhmMainMutex.Unlock ();
 382
 383                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 384     return HLH_SOCK_ERR_NOT_CREATED;
 385   }
 386
 387   // Connect to specific address
 388   nRetVal = connect (  m_fdSocket, zhsPeekAddr.GetAddrPointer (),
 389       zhsPeekAddr.GetAddrLen ()  );
 390   if (nRetVal < 0) {
 391                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("connect failed") );
 392     goto failed;
 393   }
 394
 395   // Unlock after process
 396   m_zhmMainMutex.Unlock ();
 397
 398   return 0;
 399
 400 failed:
 401   // Unlock after process
 402   m_zhmMainMutex.Unlock ();
 403
 404   return HLH_SOCK_ERR_FAILED;
 405 }
 406
 407
 408 /******************************************************************************
 409  * Func : HLH_Sock::Accept
 410  * Desc : Extracts the first connection on the queue of pending connections,
 411  *        creates a new socket with the same socket type protocol and address family as the specified socket,
 412  *        and allocates a new file descriptor for that socket
 413  * Args : zhsPeerAddr             address of peer comming in
 414  * Outs : if success, return 0, otherwise return error code
 415  ******************************************************************************/
 416 int HLH_Sock::Accept (HLH_SockAddr &zhsPeerAddr)
 417 {
 418   int                 nRetVal;
 419   socklen_t           slLen;
 420
 421   // Lock before process
 422   m_zhmMainMutex.Lock ();
 423
 424   // Can't Accept on socket which is not created
 425   if (!m_bCreated) {
 426     // Unlock after process
 427     m_zhmMainMutex.Unlock ();
 428
 429                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 430     return HLH_SOCK_ERR_NOT_CREATED;
 431   }
 432
 433   // Wait and accept connections
 434   slLen = zhsPeerAddr.GetAddrLen ();
 435   nRetVal = accept ( m_fdSocket, zhsPeerAddr.GetAddrPointer(), &slLen );
 436   if (nRetVal < 0) {
 437                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("accept failed") );
 438     goto failed;
 439   }
 440
 441   // Unlock after process
 442   m_zhmMainMutex.Unlock ();
 443
 444   return nRetVal;
 445
 446 failed:
 447   // Unlock after process
 448   m_zhmMainMutex.Unlock ();
 449
 450   return HLH_SOCK_ERR_FAILED;
 451 }
 452
 453
 454 /******************************************************************************
 455  * Func : HLH_Sock::Send
 456  * Desc : Initiates transmission of a message from the specified socket to its peer
 457  * Args : pvBuf         pointer of buffer
 458  *        unLen         length of buffer
 459  *        unFlags       flags used by send ()
 460  * Outs : if success return the length of data send, otherwise error code
 461  ******************************************************************************/
 462 int HLH_Sock::Send (const void *pvBuf, UINT32 unLen, UINT32 unFlags)
 463 {
 464   int nRetVal;
 465
 466   // Lock the send mutex
 467   m_zhmSendMutex.Lock ();
 468
 469   // Lock before process
 470   m_zhmMainMutex.Lock ();
 471
 472   // Can't send on socket not created
 473   if (!m_bCreated) {
 474
 475     // Unlock after process
 476     m_zhmMainMutex.Unlock ();
 477
 478     // Unlock send mutex
 479     m_zhmSendMutex.Unlock ();
 480
 481                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 482     return HLH_SOCK_ERR_NOT_CREATED;
 483   }
 484
 485   // Unlock after process
 486   m_zhmMainMutex.Unlock ();
 487
 488   // Send the data now
 489   nRetVal = send (m_fdSocket, pvBuf, unLen, unFlags/*|MSG_NOSIGNAL*/);
 490
 491   // Unlock send mutex after send
 492   m_zhmSendMutex.Unlock ();
 493
 494   if (nRetVal < 0) {
 495                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("send failed") );
 496     goto failed;
 497   }
 498
 499   return nRetVal;
 500 failed:
 501   // Unlock send mutex
 502   m_zhmSendMutex.Unlock ();
 503
 504   return HLH_SOCK_ERR_FAILED;
 505 }
 506
 507
 508 /******************************************************************************
 509  * Func : HLH_Sock::Recv
 510  * Desc : Receives a message from a connection-mode or connectionless-mode socket
 511  * Args : pvBuf             pointer to buffer
 512  *        unLen             length of buffer
 513  *        unFlags           flags used by recv ()
 514  * Outs : if success, return length of data received, otherwise return error code
 515  ******************************************************************************/
 516 int HLH_Sock::Recv (void *pvBuf, UINT32 unLen, UINT32 unFlags)
 517 {
 518   int nRetVal;
 519
 520   // Lock before Receiving
 521   m_zhmRecvMutex.Lock ();
 522
 523   // Lock before process
 524   m_zhmMainMutex.Lock ();
 525   if (!m_bCreated) {
 526
 527     // Unlock receive mutex
 528     m_zhmRecvMutex.Unlock ();
 529
 530     // Unlock after process
 531     m_zhmMainMutex.Unlock ();
 532
 533                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 534     return HLH_SOCK_ERR_NOT_CREATED;
 535   }
 536
 537   // Unlock after process
 538   m_zhmMainMutex.Unlock ();
 539
 540   nRetVal = recv (m_fdSocket, pvBuf, unLen, unFlags/*|MSG_NOSIGNAL*/);
 541
 542   // Unlock after receiving
 543   m_zhmRecvMutex.Unlock ();
 544
 545   if (nRetVal < 0) {
 546                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("receive failed") );
 547     goto failed;
 548   }
 549
 550   return nRetVal;
 551
 552 failed:
 553   return HLH_SOCK_ERR_FAILED;
 554
 555 }
 556
 557
 558 /******************************************************************************
 559  * Func : HLH_Sock::SendTo
 560  * Desc : Sends a message through a connection-mode or connectionless-mode socket
 561  * Args : pvBuf         pointer of buffer
 562  *        unLen         length of buffer
 563  *        zhsSockAddr   address of peer
 564  *        unFlags       flags used by send ()
 565  * Outs : if success return the length of data send, otherwise error code
 566  ******************************************************************************/
 567 int HLH_Sock::SendTo (const void *pvBuf, UINT32 unLen,
 568     const HLH_SockAddr &zhsSockAddr, UINT32 unFlags)
 569 {
 570   int nRetVal;
 571
 572   // Lock the send mutex
 573   m_zhmSendMutex.Lock ();
 574
 575   // Lock before process
 576   m_zhmMainMutex.Lock ();
 577
 578   if (!m_bCreated) {
 579     // Unlock after process
 580     m_zhmMainMutex.Unlock ();
 581
 582     // Unlock send mutex
 583     m_zhmSendMutex.Unlock ();
 584
 585                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 586     return HLH_SOCK_ERR_NOT_CREATED;
 587   }
 588
 589   // Unlock after process
 590   m_zhmMainMutex.Unlock ();
 591
 592   // Send the data now
 593   nRetVal = sendto ( m_fdSocket, pvBuf, unLen, unFlags,
 594       zhsSockAddr.GetAddrPointer (), zhsSockAddr.GetAddrLen () );
 595
 596   // Unlock send mutex after send
 597   m_zhmSendMutex.Unlock ();
 598
 599   if (nRetVal < 0) {
 600                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("sendto failed") );
 601     goto failed;
 602   }
 603
 604   return nRetVal;
 605
 606 failed:
 607   return HLH_SOCK_ERR_FAILED;
 608
 609 }
 610
 611
 612 /******************************************************************************
 613  * Func : HLH_Sock::RecvFrom
 614  * Desc : Receives a message from a connection-mode or connectionless-mode socket
 615  * Args : pvBuf             pointer to buffer
 616  *        unLen             length of buffer
 617  *        zhsPeerAddr       used to store peer address
 618  *        unFlags           flags used by recv ()
 619  * Outs : if success, return length of data received, otherwise return error code
 620  ******************************************************************************/
 621 int HLH_Sock::RecvFrom (void *pvBuf, UINT32 unLen,
 622     HLH_SockAddr &zhsPeekAddr, UINT32 unFlags)
 623 {
 624   int           nRetVal;
 625   socklen_t     slLen;
 626
 627   // Lock before Receiving
 628   m_zhmRecvMutex.Lock ();
 629
 630   // Lock before process
 631   m_zhmMainMutex.Lock ();
 632   if (!m_bCreated) {
 633     // Unlock after process
 634     m_zhmMainMutex.Unlock ();
 635
 636     // Unlock after Receiving
 637     m_zhmRecvMutex.Unlock ();
 638
 639                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 640     return HLH_SOCK_ERR_NOT_CREATED;
 641   }
 642
 643   // Unlock after process
 644   m_zhmMainMutex.Unlock ();
 645
 646   // Send the data now
 647   slLen = zhsPeekAddr.GetAddrLen ();
 648   nRetVal = recvfrom (m_fdSocket, pvBuf, unLen, unFlags,
 649       zhsPeekAddr.GetAddrPointer (), &slLen);
 650
 651   // Unlock after receiving
 652   m_zhmRecvMutex.Unlock ();
 653
 654   // Format return value
 655   if (nRetVal < 0) {
 656                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("recvfrom failed") );
 657     goto failed;
 658   }
 659
 660   return nRetVal;
 661
 662 failed:
 663   return HLH_SOCK_ERR_FAILED;
 664
 665 }
 666
 667
 668
 669
 670
 671 /******************************************************************************
 672  * Desc : Poll Operations
 673  ******************************************************************************/
 674
 675
 676
 677
 678 /******************************************************************************
 679  * Func : HLH_Sock::Poll
 680  * Desc : Poll for specific events
 681  * Args : unPollType            poll type
 682  * Outs : if success return number of events, otherwise return error code
 683  ******************************************************************************/
 684 int HLH_Sock::Poll (UINT32 &unPollType)
 685 {
 686   fd_set    fsReadSet;
 687   fd_set    fsWriteSet;
 688   fd_set    fsErrorSet;
 689
 690   int       nRetVal;
 691   UINT32    unPollTypeNew;
 692
 693   // Lock before process
 694   m_zhmMainMutex.Lock ();
 695
 696   if (!m_bCreated) {
 697     // Unlock after process
 698     m_zhmMainMutex.Unlock ();
 699
 700                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 701     return HLH_SOCK_ERR_NOT_CREATED;
 702   }
 703
 704   memcpy ( &fsReadSet,  &m_fsReadSet,  sizeof (fd_set) );
 705   memcpy ( &fsWriteSet, &m_fsWriteSet, sizeof (fd_set) );
 706   memcpy ( &fsErrorSet, &m_fsErrorSet, sizeof (fd_set) );
 707
 708   // Unlock after process,
 709   // Unlock before poll as we may want to close before poll successed
 710   m_zhmMainMutex.Unlock ();
 711
 712   // Poll for specific event
 713   nRetVal = select ( m_fdSocket + 1,
 714       unPollType & HLH_SOCK_POLL_READ  ? &fsReadSet  : NULL,
 715       unPollType & HLH_SOCK_POLL_WRITE ? &fsWriteSet : NULL,
 716       unPollType & HLH_SOCK_POLL_ERROR ? &fsErrorSet : NULL,
 717       NULL
 718       );
 719
 720   if (nRetVal < 0) {
 721                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("select failed") );
 722     goto failed;
 723   }
 724
 725   // Set return value
 726
 727   unPollTypeNew = 0;
 728
 729   if (  ( unPollType & HLH_SOCK_POLL_READ )
 730       && FD_ISSET (m_fdSocket, &fsReadSet)  ) {
 731     unPollTypeNew |= HLH_SOCK_POLL_READ;
 732   }
 733
 734   if (  ( unPollType & HLH_SOCK_POLL_WRITE )
 735       && FD_ISSET (m_fdSocket, &fsWriteSet)  ) {
 736     unPollTypeNew |= HLH_SOCK_POLL_WRITE;
 737   }
 738
 739   if (  ( unPollType & HLH_SOCK_POLL_ERROR )
 740       && FD_ISSET (m_fdSocket, &fsErrorSet)  ) {
 741     unPollTypeNew |= HLH_SOCK_POLL_ERROR;
 742   }
 743
 744   unPollType = unPollTypeNew;
 745
 746   return nRetVal;
 747
 748 failed:
 749
 750   return HLH_SOCK_ERR_FAILED;
 751 }
 752
 753
 754 /******************************************************************************
 755  * Func : HLH_Sock::PollWait
 756  * Desc : Poll for specific events until time eclipsed
 757  * Args : unPollType            poll type
 758  *        zhtTime               time to wait before poll success
 759  * Outs : if success return number of events, otherwise return error code
 760  *        if failed, the time left will return in zhtTime
 761  ******************************************************************************/
 762 int HLH_Sock::PollWait (UINT32 &unPollType, HLH_Time &zhtTime)
 763 {
 764   fd_set          fsReadSet;
 765   fd_set          fsWriteSet;
 766   fd_set          fsErrorSet;
 767
 768   int             nRetVal;
 769   UINT32          unPollTypeNew;
 770
 771   struct timeval  tvTime;
 772
 773   // Lock before process
 774   m_zhmMainMutex.Lock ();
 775
 776   if (!m_bCreated) {
 777     // Unlock after process
 778     m_zhmMainMutex.Unlock ();
 779
 780                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("not created") );
 781     return HLH_SOCK_ERR_NOT_CREATED;
 782   }
 783
 784   memcpy ( &fsReadSet,  &m_fsReadSet,  sizeof (fd_set) );
 785   memcpy ( &fsWriteSet, &m_fsWriteSet, sizeof (fd_set) );
 786   memcpy ( &fsErrorSet, &m_fsErrorSet, sizeof (fd_set) );
 787
 788   // Poll for specific event
 789   tvTime = zhtTime.GetTimeVal ();
 790
 791   // Unlock after process
 792   m_zhmMainMutex.Unlock ();
 793
 794   nRetVal = select ( m_fdSocket + 1,
 795       unPollType & HLH_SOCK_POLL_READ  ? &fsReadSet  : NULL,
 796       unPollType & HLH_SOCK_POLL_WRITE ? &fsWriteSet : NULL,
 797       unPollType & HLH_SOCK_POLL_ERROR ? &fsErrorSet : NULL,
 798       &tvTime
 799       );
 800
 801   if (nRetVal < 0) {
 802                 HLH_DEBUG ( HLH_DEBUG_UTILS, ("select failed") );
 803     goto failed;
 804   }
 805
 806   // Return the time left
 807   zhtTime.SetTime (tvTime);
 808
 809   // Set return value
 810
 811   unPollTypeNew = 0;
 812
 813   if (  ( unPollType & HLH_SOCK_POLL_READ )
 814       && FD_ISSET (m_fdSocket, &fsReadSet)  ) {
 815     unPollTypeNew |= HLH_SOCK_POLL_READ;
 816   }
 817
 818   if (  ( unPollType & HLH_SOCK_POLL_WRITE )
 819       && FD_ISSET (m_fdSocket, &fsWriteSet)  ) {
 820     unPollTypeNew |= HLH_SOCK_POLL_WRITE;
 821   }
 822
 823   if (  ( unPollType & HLH_SOCK_POLL_ERROR )
 824       && FD_ISSET (m_fdSocket, &fsErrorSet)  ) {
 825     unPollTypeNew |= HLH_SOCK_POLL_ERROR;
 826   }
 827
 828   unPollType = unPollTypeNew;
 829
 830   return nRetVal;
 831
 832 failed:
 833   return HLH_SOCK_ERR_FAILED;
 834
 835 }
 836
 837
 838
 839