research/transmission_spectroscopy/TOF/Win32++/include/socket.h

   1 // Win32++   Version 7.3\r
   2 // Released: 30th November 2011\r
   3 //\r
   4 //      David Nash\r
   5 //      email: [email protected]\r
   6 //      url: https://sourceforge.net/projects/win32-framework\r
   7 //\r
   8 //\r
   9 // Copyright (c) 2005-2011  David Nash\r
  10 //\r
  11 // Permission is hereby granted, free of charge, to\r
  12 // any person obtaining a copy of this software and\r
  13 // associated documentation files (the "Software"),\r
  14 // to deal in the Software without restriction, including\r
  15 // without limitation the rights to use, copy, modify,\r
  16 // merge, publish, distribute, sublicense, and/or sell\r
  17 // copies of the Software, and to permit persons to whom\r
  18 // the Software is furnished to do so, subject to the\r
  19 // following conditions:\r
  20 //\r
  21 // The above copyright notice and this permission notice\r
  22 // shall be included in all copies or substantial portions\r
  23 // of the Software.\r
  24 //\r
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF\r
  26 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\r
  27 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\r
  28 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\r
  29 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR\r
  30 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
  31 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  32 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE\r
  33 // OR OTHER DEALINGS IN THE SOFTWARE.\r
  34 //\r
  35 ////////////////////////////////////////////////////////\r
  36 \r
  37 \r
  38 ////////////////////////////////////////////////////////\r
  39 // socket.h\r
  40 //  Declaration of the CSocket class\r
  41 //\r
  42 // The CSocket class represents a network socket. It encapsualtes many of\r
  43 // the Windows Socket SPI fuctions, providing an object-oriented approach\r
  44 // to network programming. After StartEvents is called, CSocket monitors\r
  45 // the socket and responds automatically to network events. This event\r
  46 // monitoring, for example, automatically calls OnReceive when there is\r
  47 // data on the socket to be read, and OnAccept when a server should accept\r
  48 // a connection from a client.\r
  49 \r
  50 // Users of this class should be aware that functions like OnReceive,\r
  51 // OnAccept, etc. are called on a different thread from the one CSocket is\r
  52 // instanciated on. The thread for these functions needs to respond quickly\r
  53 // to other network events, so it shouldn't be delayed. It also doesn't run\r
  54 // a message loop, so it can't be used to create windows. For these reasons\r
  55 // it might be best to use PostMessage in response to these functions in a\r
  56 // windows environment.\r
  57 \r
  58 // Refer to the network samples for an example of how to use this class to\r
  59 // create a TCP client & server, and a UDP client and server.\r
  60 \r
  61 // To compile programs with CSocket, link with ws3_32.lib for Win32,\r
  62 // and ws2.lib for Windows CE. Windows 95 systems will need to install the\r
  63 // "Windows Sockets 2.0 for Windows 95". It's available from:\r
  64 // http://support.microsoft.com/kb/182108/EN-US/\r
  65 \r
  66 // For a TCP server, inherit a class from CSocket and override OnAccept, OnDisconnect\r
  67 // and OnRecieve. Create one instance of this class and use it as a listening socket.\r
  68 // The purpose of the listening socket is to detect connections from clients and accept them.\r
  69 // For the listening socket, we do the following:\r
  70 // 1) Create the socket.\r
  71 // 2) Bind an IP address to the socket.\r
  72 // 3) Listen on the socket for incoming connection requests.\r
  73 // 4) Use StartNotifyRevents to receive notification of network events.\r
  74 // 5) Override OnAccept to accept requests on a newly created data CSocket object.\r
  75 // 6) Create a new data socket for each client connection accepted.\r
  76 // 7) The server socket uses the 'accept' function to accept an incoming connection\r
  77 //     from this new data socket.\r
  78 \r
  79 // The purpose of the data socket is to send data to, and recieve data from the client.\r
  80 // There will be one data socket for each client accepted by the server.\r
  81 // To use it we do the following:\r
  82 // * To recieve data from the client, override OnReceive and use Receive.\r
  83 // * To send data to use Send.\r
  84 // * OnDisconnect can be used to detect when the client is disconnected.\r
  85 \r
  86 // For a TCP client, inherit from CSocket and override OnReceive and OnDisconnect.\r
  87 // Create an instance of this inherited class, and  perform the following steps:\r
  88 // 1) Create the socket.\r
  89 // 2) Connect to the server.\r
  90 // 3) Use StartNotifyRevents to receive notification of network events.\r
  91 //    We are now ready to send and recieve data from the server.\r
  92 // * Use Send to send data to the server.\r
  93 // * Override OnReceive and use Recieve to receive data from the server\r
  94 // * OnDisconnect can be used to detect when the client is disconnected from the server.\r
  95 \r
  96 // Notes regarding IPv6 support\r
  97 // * IPv6 is supported on Windows Vista and above. Windows XP with SP2 provides\r
  98 //    "experimental" support, which can be enabled by entering "ipv6 install"\r
  99 //    at a command prompt.\r
 100 // * IPv6 is not supported by all compilters and devlopment environments. In\r
 101 //    particular, it is not supported by Dev-C++ or Borland 5.5. A modern\r
 102 //    Platform SDK needs to be added to Visual Studio 6 for it to support IPv6.\r
 103 // * IsIPV6Supported returns false if either the operating system or the\r
 104 //    development environment fails to support IPv6.\r
 105 //\r
 106 \r
 107 #ifndef _WIN32XX_SOCKET_H_\r
 108 #define _WIN32XX_SOCKET_H_\r
 109 \r
 110 \r
 111 #include "wincore.h"\r
 112 #include <winsock2.h>\r
 113 #include <ws2tcpip.h>\r
 114 #include <process.h>\r
 115 \r
 116 \r
 117 #define THREAD_TIMEOUT 100\r
 118 \r
 119 \r
 120 namespace Win32xx\r
 121 {\r
 122 \r
 123         typedef int  WINAPI GETADDRINFO(LPCSTR, LPCSTR, const struct addrinfo*, struct addrinfo**);\r
 124         typedef void WINAPI FREEADDRINFO(struct addrinfo*);\r
 125 \r
 126         class CSocket\r
 127         {\r
 128         public:\r
 129                 CSocket();\r
 130                 virtual ~CSocket();\r
 131 \r
 132                 // Operations\r
 133                 virtual void Accept(CSocket& rClientSock, struct sockaddr* addr, int* addrlen);\r
 134                 virtual int  Bind(LPCTSTR addr, LPCTSTR port);\r
 135                 virtual int  Bind(const struct sockaddr* name, int namelen);\r
 136                 virtual int  Connect(LPCTSTR addr, LPCTSTR port);\r
 137                 virtual int  Connect(const struct sockaddr* name, int namelen);\r
 138                 virtual bool Create( int family, int type, int protocol = IPPROTO_IP);\r
 139                 virtual void Disconnect();\r
 140                 virtual void FreeAddrInfo( struct addrinfo* ai );\r
 141                 virtual int  GetAddrInfo( LPCTSTR nodename, LPCTSTR servname, const struct addrinfo* hints, struct addrinfo** res);\r
 142                 virtual LPCTSTR GetLastError();\r
 143                 virtual int  ioCtlSocket(long cmd, u_long* argp);\r
 144                 virtual bool IsIPV6Supported();\r
 145                 virtual int  Listen(int backlog = SOMAXCONN);\r
 146                 virtual int  Receive(TCHAR* buf, int len, int flags);\r
 147                 virtual int  ReceiveFrom(TCHAR* buf, int len, int flags, struct sockaddr* from, int* fromlen);\r
 148                 virtual int  Send(LPCTSTR buf, int len, int flags);\r
 149                 virtual int  SendTo(LPCTSTR send, int len, int flags, LPCTSTR addr, LPCTSTR port);\r
 150                 virtual int  SendTo(LPCTSTR buf, int len, int flags, const struct sockaddr* to, int tolen);\r
 151 \r
 152                 virtual void StartEvents();\r
 153                 virtual void StopEvents();\r
 154 \r
 155                 // Attributes\r
 156                 virtual int  GetPeerName(struct sockaddr* name, int* namelen);\r
 157                 virtual int  GetSockName(struct sockaddr* name, int* namelen);\r
 158                 SOCKET& GetSocket() { return m_Socket; }\r
 159                 virtual int  GetSockOpt(int level, int optname, char* optval, int* optlen);\r
 160                 virtual int  SetSockOpt(int level, int optname, const char* optval, int optlen);\r
 161 \r
 162                 // Override these functions to monitor events\r
 163                 virtual void OnAccept()         {}\r
 164                 virtual void OnAddresListChange() {}\r
 165                 virtual void OnDisconnect()     {}\r
 166                 virtual void OnConnect()        {}\r
 167                 virtual void OnOutOfBand()      {}\r
 168                 virtual void OnQualityOfService() {}\r
 169                 virtual void OnReceive()        {}\r
 170                 virtual void OnRoutingChange() {}\r
 171                 virtual void OnSend()           {}\r
 172 \r
 173 \r
 174 \r
 175                 // Allow CSocket to be used as a SOCKET\r
 176                 operator SOCKET() const {return m_Socket;}\r
 177 \r
 178         private:\r
 179                 CSocket(const CSocket&);                                // Disable copy construction\r
 180                 CSocket& operator = (const CSocket&);   // Disable assignment operator\r
 181                 static UINT WINAPI EventThread(LPVOID thread_data);\r
 182 \r
 183                 CString m_ErrorMessage;\r
 184                 SOCKET m_Socket;\r
 185                 HMODULE m_hWS2_32;\r
 186                 HANDLE m_hEventThread;  // Handle to the thread\r
 187                 HANDLE m_StopRequest;   // An event to signal the event thread should stop\r
 188                 HANDLE m_Stopped;               // An event to signal the event thread is stopped\r
 189 \r
 190                 GETADDRINFO* m_pfnGetAddrInfo;          // pointer for the GetAddrInfo function\r
 191                 FREEADDRINFO* m_pfnFreeAddrInfo;        // pointer for the FreeAddrInfo function\r
 192         };\r
 193 }\r
 194 \r
 195 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
 196 \r
 197 namespace Win32xx\r
 198 {\r
 199 \r
 200         inline CSocket::CSocket() : m_Socket(INVALID_SOCKET), m_hEventThread(0)\r
 201         {\r
 202                 // Initialise the Windows Socket services\r
 203                 WSADATA wsaData;\r
 204 \r
 205                 if (0 != ::WSAStartup(MAKEWORD(2,2), &wsaData))\r
 206                         throw CWinException(_T("WSAStartup failed"));\r
 207 \r
 208                 m_hWS2_32 = ::LoadLibrary(_T("WS2_32.dll"));\r
 209                 if (0 == m_hWS2_32)\r
 210                         throw CWinException(_T("Failed to load WS2_2.dll"));\r
 211 \r
 212                 m_pfnGetAddrInfo = (GETADDRINFO*) GetProcAddress(m_hWS2_32, "getaddrinfo");\r
 213                 m_pfnFreeAddrInfo = (FREEADDRINFO*) GetProcAddress(m_hWS2_32, "freeaddrinfo");\r
 214 \r
 215                 m_StopRequest = ::CreateEvent(0, TRUE, FALSE, 0);\r
 216                 m_Stopped = ::CreateEvent(0, TRUE, FALSE, 0);\r
 217         }\r
 218 \r
 219         inline CSocket::~CSocket()\r
 220         {\r
 221                 Disconnect();\r
 222 \r
 223                 // Close handles\r
 224                 ::CloseHandle(m_StopRequest);\r
 225                 ::CloseHandle(m_Stopped);\r
 226 \r
 227                 // Terminate the  Windows Socket services\r
 228                 ::WSACleanup();\r
 229 \r
 230                 ::FreeLibrary(m_hWS2_32);\r
 231         }\r
 232 \r
 233         inline void CSocket::Accept(CSocket& rClientSock, struct sockaddr* addr, int* addrlen)\r
 234         {\r
 235                 // The accept function permits an incoming connection attempt on the socket.\r
 236 \r
 237                 rClientSock.m_Socket = ::accept(m_Socket, addr, addrlen);\r
 238                 if (INVALID_SOCKET == rClientSock.GetSocket())\r
 239                         TRACE(_T("Accept failed\n"));\r
 240         }\r
 241 \r
 242         inline int CSocket::Bind(LPCTSTR addr, LPCTSTR port)\r
 243         // The bind function associates a local address with the socket.\r
 244         {\r
 245                 int RetVal = 0;\r
 246 \r
 247                 if (IsIPV6Supported())\r
 248                 {\r
 249 \r
 250 #ifdef GetAddrInfo      // Skip the following code block for older development environments\r
 251 \r
 252                         ADDRINFO Hints= {0};\r
 253                         Hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;\r
 254                         ADDRINFO *AddrInfo;\r
 255 \r
 256                         RetVal = GetAddrInfo(addr, port, &Hints, &AddrInfo);\r
 257                         if (RetVal != 0)\r
 258                         {\r
 259                                 TRACE( _T("GetAddrInfo failed\n"));\r
 260                                 return RetVal;\r
 261                         }\r
 262 \r
 263                         // Bind the IP address to the listening socket\r
 264                         RetVal =  ::bind( m_Socket, AddrInfo->ai_addr, (int)AddrInfo->ai_addrlen );\r
 265                         if ( RetVal == SOCKET_ERROR )\r
 266                         {\r
 267                                 TRACE(_T("Bind failed\n"));\r
 268                                 return RetVal;\r
 269                         }\r
 270 \r
 271                         // Free the address information allocated by GetAddrInfo\r
 272                         FreeAddrInfo(AddrInfo);\r
 273 \r
 274 #endif\r
 275 \r
 276                 }\r
 277                 else\r
 278                 {\r
 279                         sockaddr_in clientService;\r
 280                         clientService.sin_family = AF_INET;\r
 281                         clientService.sin_addr.s_addr = inet_addr( T2A(addr) );\r
 282                         int nPort = -1;\r
 283             nPort = atoi( T2A(port) );\r
 284                         if (-1 == nPort)\r
 285                         {\r
 286                                 TRACE(_T("Invalid port number\n"));\r
 287                                 return SOCKET_ERROR;\r
 288                         }\r
 289                         clientService.sin_port = htons( (u_short)nPort );\r
 290 \r
 291                         RetVal = ::bind( m_Socket, (SOCKADDR*) &clientService, sizeof(clientService) );\r
 292                         if ( 0 != RetVal )\r
 293                                 TRACE(_T("Bind failed\n"));\r
 294                 }\r
 295 \r
 296                 return RetVal;\r
 297         }\r
 298 \r
 299         inline int CSocket::Bind(const struct sockaddr* name, int namelen)\r
 300         {\r
 301                 // The bind function associates a local address with the socket.\r
 302 \r
 303                 int Result = ::bind (m_Socket, name, namelen);\r
 304                 if ( 0 != Result )\r
 305                         TRACE(_T("Bind failed\n"));\r
 306                 return Result;\r
 307         }\r
 308 \r
 309         inline int CSocket::Connect(LPCTSTR addr, LPCTSTR port)\r
 310         // The Connect function establishes a connection to the socket.\r
 311         {\r
 312                 int RetVal = 0;\r
 313 \r
 314                 if (IsIPV6Supported())\r
 315                 {\r
 316 \r
 317 #ifdef GetAddrInfo      // Skip the following code block for older development environments\r
 318 \r
 319                         ADDRINFO Hints= {0};\r
 320                         Hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;\r
 321                         ADDRINFO *AddrInfo;\r
 322 \r
 323                         RetVal = GetAddrInfo(addr, port, &Hints, &AddrInfo);\r
 324                         if (RetVal != 0)\r
 325                         {\r
 326                                 TRACE( _T("getaddrinfo failed\n"));\r
 327                                 return SOCKET_ERROR;\r
 328                         }\r
 329 \r
 330                         // Bind the IP address to the listening socket\r
 331                         RetVal = Connect( AddrInfo->ai_addr, (int)AddrInfo->ai_addrlen );\r
 332                         if ( RetVal == SOCKET_ERROR )\r
 333                         {\r
 334                                 TRACE(_T("Connect failed\n"));\r
 335                                 return RetVal;\r
 336                         }\r
 337 \r
 338                         // Free the address information allocatied by GetAddrInfo\r
 339                         FreeAddrInfo(AddrInfo);\r
 340 \r
 341 #endif\r
 342 \r
 343                 }\r
 344                 else\r
 345                 {\r
 346                         sockaddr_in clientService;\r
 347                         clientService.sin_family = AF_INET;\r
 348                         clientService.sin_addr.s_addr = inet_addr( T2A(addr) );\r
 349                         int nPort = -1;\r
 350                         nPort = atoi( T2A(port) );\r
 351                         if (-1 == nPort)\r
 352                         {\r
 353                                 TRACE(_T("Invalid port number\n"));\r
 354                                 return SOCKET_ERROR;\r
 355                         }\r
 356                         clientService.sin_port = htons( (u_short)nPort );\r
 357 \r
 358                         RetVal = ::connect( m_Socket, (SOCKADDR*) &clientService, sizeof(clientService) );\r
 359                         if ( 0 != RetVal )\r
 360                                 TRACE(_T("Connect failed\n"));\r
 361                 }\r
 362 \r
 363                 return RetVal;\r
 364         }\r
 365 \r
 366         inline int CSocket::Connect(const struct sockaddr* name, int namelen)\r
 367         {\r
 368                 // The Connect function establishes a connection to the socket.\r
 369 \r
 370                 int Result = ::connect( m_Socket, name, namelen );\r
 371                 if ( 0 != Result )\r
 372                         TRACE(_T("Connect failed\n"));\r
 373 \r
 374                 return Result;\r
 375         }\r
 376 \r
 377         inline bool CSocket::Create( int family, int type, int protocol /*= IPPROTO_IP*/)\r
 378         {\r
 379                 // Creates the socket\r
 380 \r
 381                 // Valid values:\r
 382                 //  family:             AF_INET or AF_INET6\r
 383                 //      type:           SOCK_DGRAM, SOCK_SEQPACKET, SOCK_STREAM, SOCK_RAW\r
 384                 //      protocol:       IPPROTO_IP, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_RAW, IPPROTO_ICMP, IPPROTO_ICMPV6\r
 385 \r
 386                 m_Socket = socket(family, type, protocol);\r
 387                 if(m_Socket == INVALID_SOCKET)\r
 388                 {\r
 389                         TRACE(_T("Failed to create socket\n"));\r
 390                         return FALSE;\r
 391                 }\r
 392 \r
 393                 return TRUE;\r
 394         }\r
 395 \r
 396         inline void CSocket::Disconnect()\r
 397         {\r
 398                 ::shutdown(m_Socket, SD_BOTH);\r
 399                 StopEvents();\r
 400                 ::closesocket(m_Socket);\r
 401                 m_Socket = INVALID_SOCKET;\r
 402         }\r
 403 \r
 404         inline UINT WINAPI CSocket::EventThread(LPVOID thread_data)\r
 405         {\r
 406                 // These are the possible network event notifications:\r
 407                 //      FD_READ         Notification of readiness for reading.\r
 408                 //      FD_WRITE        Motification of readiness for writing.\r
 409                 //      FD_OOB          Notification of the arrival of Out Of Band data.\r
 410                 //      FD_ACCEPT       Notification of incoming connections.\r
 411                 //      FD_CONNECT      Notification of completed connection or multipoint join operation.\r
 412                 //      FD_CLOSE        Notification of socket closure.\r
 413                 //      FD_QOS          Notification of socket Quality Of Service changes\r
 414                 //      FD_ROUTING_INTERFACE_CHANGE     Notification of routing interface changes for the specified destination.\r
 415                 //      FD_ADDRESS_LIST_CHANGE          Notification of local address list changes for the address family of the socket.\r
 416 \r
 417                 WSANETWORKEVENTS NetworkEvents;\r
 418                 CSocket* pSocket = (CSocket*)thread_data;\r
 419                 SOCKET sClient = pSocket->m_Socket;\r
 420 \r
 421         WSAEVENT AllEvents[2];\r
 422                 AllEvents[0] = ::WSACreateEvent();\r
 423                 AllEvents[1] = (WSAEVENT)pSocket->m_StopRequest;\r
 424                 long Events = FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE |\r
 425                                   FD_QOS | FD_ROUTING_INTERFACE_CHANGE | FD_ADDRESS_LIST_CHANGE;\r
 426 \r
 427                 // Associate the network event object (hNetworkEvents) with the\r
 428                 // specified network events (Events) on socket sClient.\r
 429                 if(     SOCKET_ERROR == WSAEventSelect(sClient, AllEvents[0], Events))\r
 430                 {\r
 431                         TRACE(_T("Error in Event Select\n"));\r
 432                         ::SetEvent(pSocket->m_Stopped);\r
 433                         ::WSACloseEvent(AllEvents[0]);\r
 434                         return 0;\r
 435                 }\r
 436 \r
 437                 // loop until the stop event is set\r
 438                 for (;;) // infinite loop\r
 439                 {\r
 440                         // Wait 100 ms for a network event\r
 441                         DWORD dwResult = ::WSAWaitForMultipleEvents(2, AllEvents, FALSE, THREAD_TIMEOUT, FALSE);\r
 442 \r
 443                         // Check event for stop thread\r
 444                         if(::WaitForSingleObject(pSocket->m_StopRequest, 0) == WAIT_OBJECT_0)\r
 445                         {\r
 446                                 ::WSACloseEvent(AllEvents[0]);\r
 447                                 ::SetEvent(pSocket->m_Stopped);\r
 448                                 return 0;\r
 449                         }\r
 450 \r
 451                         if (WSA_WAIT_FAILED == dwResult)\r
 452                         {\r
 453                                 TRACE(_T("WSAWaitForMultipleEvents failed\n"));\r
 454                                 ::WSACloseEvent(AllEvents[0]);\r
 455                                 ::SetEvent(pSocket->m_Stopped);\r
 456                                 return 0;\r
 457                         }\r
 458 \r
 459                         // Proceed if a network event occurred\r
 460                         if (WSA_WAIT_TIMEOUT != dwResult)\r
 461                         {\r
 462 \r
 463                                 if ( SOCKET_ERROR == ::WSAEnumNetworkEvents(sClient, AllEvents[0], &NetworkEvents) )\r
 464                                 {\r
 465                                         TRACE(_T("WSAEnumNetworkEvents failed\n"));\r
 466                                         ::WSACloseEvent(AllEvents[0]);\r
 467                                         ::SetEvent(pSocket->m_Stopped);\r
 468                                         return 0;\r
 469                                 }\r
 470 \r
 471                                 if (NetworkEvents.lNetworkEvents & FD_ACCEPT)\r
 472                                         pSocket->OnAccept();\r
 473 \r
 474                                 if (NetworkEvents.lNetworkEvents & FD_READ)\r
 475                                         pSocket->OnReceive();\r
 476 \r
 477                                 if (NetworkEvents.lNetworkEvents & FD_WRITE)\r
 478                                         pSocket->OnSend();\r
 479 \r
 480                                 if (NetworkEvents.lNetworkEvents & FD_OOB)\r
 481                                         pSocket->OnOutOfBand();\r
 482 \r
 483                                 if (NetworkEvents.lNetworkEvents & FD_QOS)\r
 484                                         pSocket->OnQualityOfService();\r
 485 \r
 486                                 if (NetworkEvents.lNetworkEvents & FD_CONNECT)\r
 487                                         pSocket->OnConnect();\r
 488 \r
 489                                 if (NetworkEvents.lNetworkEvents & FD_ROUTING_INTERFACE_CHANGE)\r
 490                                         pSocket->OnRoutingChange();\r
 491 \r
 492                                 if (NetworkEvents.lNetworkEvents & FD_ADDRESS_LIST_CHANGE)\r
 493                                         pSocket->OnAddresListChange();\r
 494 \r
 495                                 if (NetworkEvents.lNetworkEvents & FD_CLOSE)\r
 496                                 {\r
 497                                         ::shutdown(sClient, SD_BOTH);\r
 498                                         ::closesocket(sClient);\r
 499                                         pSocket->OnDisconnect();\r
 500                                         ::WSACloseEvent(AllEvents[0]);\r
 501                                         ::SetEvent(pSocket->m_Stopped);\r
 502                                         return 0;\r
 503                                 }\r
 504                         }\r
 505                 }\r
 506         }\r
 507 \r
 508         inline int CSocket::GetAddrInfo( LPCTSTR nodename, LPCTSTR servname, const struct addrinfo* hints, struct addrinfo** res)\r
 509         {\r
 510 \r
 511 #ifdef GetAddrInfo\r
 512 \r
 513                 std::string sNodeName = T2A(nodename);\r
 514                 std::string sServName = T2A(servname);\r
 515                 return (*m_pfnGetAddrInfo)(sNodeName.c_str(), sServName.c_str(), hints, res);\r
 516 \r
 517 #else\r
 518 \r
 519                 UNREFERENCED_PARAMETER(nodename);\r
 520                 UNREFERENCED_PARAMETER(servname);\r
 521                 UNREFERENCED_PARAMETER(hints);\r
 522                 UNREFERENCED_PARAMETER(res);\r
 523 \r
 524                 throw CWinException(_T("getaddrinfo is not supported"));\r
 525 \r
 526 #endif\r
 527 \r
 528         }\r
 529 \r
 530         inline LPCTSTR CSocket::GetLastError()\r
 531         {\r
 532                 // Retrieves the most recent network error.\r
 533 \r
 534                 int ErrorCode = WSAGetLastError();\r
 535                 LPTSTR Message = NULL;\r
 536                 m_ErrorMessage = _T("");\r
 537 \r
 538                 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS |\r
 539                                           FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_MAX_WIDTH_MASK,\r
 540                                           NULL, ErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
 541                                           (LPTSTR)&Message, 1024, NULL);\r
 542 \r
 543                 if (Message)\r
 544                 {\r
 545                         m_ErrorMessage = Message;\r
 546                         ::LocalFree(Message);\r
 547                 }\r
 548 \r
 549                 return m_ErrorMessage;\r
 550         }\r
 551 \r
 552         inline int  CSocket::GetPeerName(struct sockaddr* name, int* namelen)\r
 553         {\r
 554                 int Result = ::getpeername(m_Socket, name, namelen);\r
 555                 if (0 != Result)\r
 556                         TRACE(_T("GetPeerName failed\n"));\r
 557 \r
 558                 return Result;\r
 559         }\r
 560 \r
 561         inline int  CSocket::GetSockName(struct sockaddr* name, int* namelen)\r
 562         {\r
 563                 int Result = ::getsockname(m_Socket, name, namelen);\r
 564                 if (0 != Result)\r
 565                         TRACE(_T("GetSockName Failed\n"));\r
 566 \r
 567                 return Result;\r
 568         }\r
 569 \r
 570         inline int  CSocket::GetSockOpt(int level, int optname, char* optval, int* optlen)\r
 571         {\r
 572                 int Result = ::getsockopt(m_Socket, level, optname, optval, optlen);\r
 573                 if (0 != Result)\r
 574                         TRACE(_T("GetSockOpt Failed\n"));\r
 575 \r
 576                 return Result;\r
 577         }\r
 578 \r
 579         inline void CSocket::FreeAddrInfo( struct addrinfo* ai )\r
 580         {\r
 581 \r
 582 #ifdef GetAddrInfo\r
 583 \r
 584                 (*m_pfnFreeAddrInfo)(ai);\r
 585 \r
 586 #else\r
 587 \r
 588                 UNREFERENCED_PARAMETER(ai);\r
 589 \r
 590                 throw CWinException(_T("getaddrinfo is not supported"));\r
 591 \r
 592 #endif\r
 593 \r
 594         }\r
 595 \r
 596         inline int CSocket::ioCtlSocket(long cmd, u_long* argp)\r
 597         {\r
 598                 int Result = ::ioctlsocket(m_Socket, cmd, argp);\r
 599                 if (0 != Result)\r
 600                         TRACE(_T("ioCtlSocket Failed\n"));\r
 601 \r
 602                 return Result;\r
 603         }\r
 604 \r
 605         inline bool CSocket::IsIPV6Supported()\r
 606         {\r
 607                 bool IsIPV6Supported = FALSE;\r
 608 \r
 609 #ifdef GetAddrInfo\r
 610 \r
 611                 if (m_pfnGetAddrInfo != 0 && m_pfnFreeAddrInfo != 0)\r
 612                         IsIPV6Supported = TRUE;\r
 613 \r
 614 #endif\r
 615 \r
 616                 return IsIPV6Supported;\r
 617         }\r
 618 \r
 619         inline int CSocket::Listen(int backlog /*= SOMAXCONN*/)\r
 620         {\r
 621                 int Result = ::listen(m_Socket, backlog);\r
 622                 if (0 != Result)\r
 623                         TRACE(_T("Listen Failed\n"));\r
 624 \r
 625                 return Result;\r
 626         }\r
 627 \r
 628         inline int CSocket::Receive(TCHAR* buf, int len, int flags)\r
 629         {\r
 630                 std::vector<char> vChar(len+1, '\0');\r
 631                 char* pCharArray = &vChar.front();\r
 632                 int Result = ::recv(m_Socket, pCharArray, len, flags);\r
 633                 if (SOCKET_ERROR == Result)\r
 634                         TRACE(_T("Receive failed\n"));\r
 635 \r
 636                 lstrcpyn(buf, A2T(pCharArray), len);\r
 637 \r
 638                 return Result;\r
 639         }\r
 640 \r
 641         inline int CSocket::ReceiveFrom(TCHAR* buf, int len, int flags, struct sockaddr* from, int* fromlen)\r
 642         //The ReceiveFrom function receives a datagram and stores the source address.\r
 643         {\r
 644                 std::vector<char> vChar(len+1, '\0');\r
 645                 char* pCharArray = &vChar.front();\r
 646                 int Result = ::recvfrom(m_Socket, pCharArray, len, flags, from, fromlen);\r
 647                 if (SOCKET_ERROR == Result)\r
 648                         TRACE(_T("ReceiveFrom failed\n"));\r
 649 \r
 650                 lstrcpyn(buf, A2T(pCharArray), len);\r
 651 \r
 652                 return Result;\r
 653         }\r
 654 \r
 655         inline int CSocket::Send(LPCTSTR buf, int len, int flags)\r
 656         {\r
 657                 int Result = ::send(m_Socket, T2A(buf), len, flags);\r
 658                 if (SOCKET_ERROR == Result)\r
 659                         TRACE(_T("Send failed\n"));\r
 660 \r
 661                 return Result;\r
 662         }\r
 663 \r
 664         inline int CSocket::SendTo(LPCTSTR send, int len, int flags, LPCTSTR addr, LPCTSTR port)\r
 665         // The sendto function sends data to a specific destination.\r
 666         {\r
 667                 int RetVal = 0;\r
 668 \r
 669                 if (IsIPV6Supported())\r
 670                 {\r
 671 \r
 672 #ifdef GetAddrInfo      // Skip the following code block for older development environments\r
 673 \r
 674                         ADDRINFO Hints= {0};\r
 675                         Hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;\r
 676                         ADDRINFO *AddrInfo;\r
 677 \r
 678                         RetVal = GetAddrInfo(addr, port, &Hints, &AddrInfo);\r
 679                         if (RetVal != 0)\r
 680                         {\r
 681                                 TRACE( _T("GetAddrInfo failed\n"));\r
 682                                 return SOCKET_ERROR;\r
 683                         }\r
 684 \r
 685                         RetVal = ::sendto(m_Socket, T2A(send), len, flags, AddrInfo->ai_addr, (int)AddrInfo->ai_addrlen );\r
 686                         if ( RetVal == SOCKET_ERROR )\r
 687                         {\r
 688                                 TRACE(_T("SendTo failed\n"));\r
 689                                 return RetVal;\r
 690                         }\r
 691 \r
 692                         // Free the address information allocatied by GetAddrInfo\r
 693                         FreeAddrInfo(AddrInfo);\r
 694 \r
 695 #endif\r
 696 \r
 697                 }\r
 698                 else\r
 699                 {\r
 700                         sockaddr_in clientService;\r
 701                         clientService.sin_family = AF_INET;\r
 702                         clientService.sin_addr.s_addr = inet_addr( T2A(addr) );\r
 703                         int nPort = -1;\r
 704             nPort = atoi( T2A(port));\r
 705                         if (-1 == nPort)\r
 706                         {\r
 707                                 TRACE(_T("Invalid port number\n"));\r
 708                                 return SOCKET_ERROR;\r
 709                         }\r
 710                         clientService.sin_port = htons( (u_short)nPort );\r
 711 \r
 712                         RetVal = ::sendto( m_Socket, T2A(send), len, flags, (SOCKADDR*) &clientService, sizeof(clientService) );\r
 713                         if ( SOCKET_ERROR != RetVal )\r
 714                                 TRACE(_T("SendTo failed\n"));\r
 715                 }\r
 716 \r
 717                 return RetVal;\r
 718         }\r
 719 \r
 720         inline int CSocket::SendTo(LPCTSTR buf, int len, int flags, const struct sockaddr* to, int tolen)\r
 721         // The sendto function sends data to a specific destination.\r
 722         {\r
 723                 int Result =  ::sendto(m_Socket, T2A(buf), len, flags, to, tolen);\r
 724                 if (SOCKET_ERROR == Result)\r
 725                         TRACE(_T("SendTo failed\n"));\r
 726 \r
 727                 return Result;\r
 728         }\r
 729 \r
 730         inline int CSocket::SetSockOpt(int level, int optname, const char* optval, int optlen)\r
 731         {\r
 732                 int Result = ::setsockopt(m_Socket, level, optname, optval, optlen);\r
 733                 if (0 != Result)\r
 734                         TRACE(_T("SetSockOpt failed\n"));\r
 735 \r
 736                 return Result;\r
 737         }\r
 738 \r
 739         inline void CSocket::StartEvents()\r
 740         {\r
 741                 // This function starts the thread which monitors the socket for events.\r
 742                 StopEvents();   // Ensure the thread isn't already running\r
 743                 UINT ThreadID;  // a return variable required for Win95, Win98, WinME\r
 744                 m_hEventThread = (HANDLE)::_beginthreadex(NULL, 0, CSocket::EventThread, (LPVOID) this, 0, &ThreadID);\r
 745         }\r
 746 \r
 747         inline void CSocket::StopEvents()\r
 748         {\r
 749                 // Terminates the event thread gracefully (if possible)\r
 750                 if (m_hEventThread)\r
 751                 {\r
 752                         ::SetThreadPriority(m_hEventThread, THREAD_PRIORITY_HIGHEST);\r
 753                         ::SetEvent(m_StopRequest);\r
 754 \r
 755                         for (;;)        // infinite loop\r
 756                         {\r
 757                                 // wait for the Thread stopping event to be set\r
 758                                 if ( WAIT_TIMEOUT == ::WaitForSingleObject(m_Stopped, THREAD_TIMEOUT * 10) )\r
 759                                 {\r
 760                                         // Note: An excessive delay in processing any of the notification functions\r
 761                                         // can cause us to get here. (Yes one second is an excessive delay. Its a bug!)\r
 762                                         TRACE(_T("*** Error: Event Thread won't die ***\n") );\r
 763                                 }\r
 764                                 else break;\r
 765                         }\r
 766 \r
 767                         ::CloseHandle(m_hEventThread);\r
 768                         m_hEventThread = 0;\r
 769                 }\r
 770 \r
 771                 ::ResetEvent(m_StopRequest);\r
 772                 ::ResetEvent(m_Stopped);\r
 773         }\r
 774 }\r
 775 \r
 776 \r
 777 #endif // #ifndef _WIN32XX_SOCKET_H_\r
 778 \r