src/msw/sockmsw.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:       src/msw/sockmsw.cpp
   3 // Purpose:    MSW-specific socket code
   4 // Authors:    Guilhem Lavaux, Guillermo Rodriguez Garcia
   5 // Created:    April 1997
   6 // Copyright:  (C) 1999-1997, Guilhem Lavaux
   7 //             (C) 1999-2000, Guillermo Rodriguez Garcia
   8 //             (C) 2008 Vadim Zeitlin
   9 // RCS_ID:     $Id$
  10 // License:    wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #ifdef __BORLANDC__
  18     #pragma hdrstop
  19 #endif
  20
  21 #if wxUSE_SOCKETS
  22
  23 /* including rasasync.h (included from windows.h itself included from
  24  * wx/setup.h and/or winsock.h results in this warning for
  25  * RPCNOTIFICATION_ROUTINE
  26  */
  27 #ifdef _MSC_VER
  28 #   pragma warning(disable:4115) /* named type definition in parentheses */
  29 #endif
  30
  31 #include "wx/private/socket.h"
  32 #include "wx/apptrait.h"
  33 #include "wx/thread.h"
  34 #include "wx/dynlib.h"
  35
  36 extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
  37 #define INSTANCE wxGetInstance()
  38
  39 #ifdef __WXWINCE__
  40 /*
  41  * As WSAAsyncSelect is not present on WinCE, it now uses WSACreateEvent,
  42  * WSAEventSelect, WSAWaitForMultipleEvents and WSAEnumNetworkEvents. When
  43  * enabling eventhandling for a socket a new thread it created that keeps track
  44  * of the events and posts a messageto the hidden window to use the standard
  45  * message loop.
  46  */
  47 #include "wx/msw/wince/net.h"
  48 #include "wx/hashmap.h"
  49 WX_DECLARE_HASH_MAP(int,bool,wxIntegerHash,wxIntegerEqual,SocketHash);
  50
  51 #ifndef isdigit
  52 #define isdigit(x) (x > 47 && x < 58)
  53 #endif
  54 #include "wx/msw/wince/net.h"
  55
  56 #endif // __WXWINCE__
  57
  58 #ifdef _MSC_VER
  59 #  pragma warning(default:4115) /* named type definition in parentheses */
  60 #endif
  61
  62 #define CLASSNAME  TEXT("_wxSocket_Internal_Window_Class")
  63
  64 /* implemented in utils.cpp */
  65 extern "C" WXDLLIMPEXP_BASE HWND
  66 wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc);
  67
  68 /* Maximum number of different wxSocket objects at a given time.
  69  * This value can be modified at will, but it CANNOT be greater
  70  * than (0x7FFF - WM_USER + 1)
  71  */
  72 #define MAXSOCKETS 1024
  73
  74 #if (MAXSOCKETS > (0x7FFF - WM_USER + 1))
  75 #error "MAXSOCKETS is too big!"
  76 #endif
  77
  78 #ifndef __WXWINCE__
  79 typedef int (PASCAL *WSAAsyncSelect_t)(SOCKET,HWND,u_int,long);
  80 #else
  81 /* Typedef the needed function prototypes and the WSANETWORKEVENTS structure
  82 */
  83 typedef struct _WSANETWORKEVENTS {
  84        long lNetworkEvents;
  85        int iErrorCode[10];
  86 } WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
  87 typedef HANDLE (PASCAL *WSACreateEvent_t)();
  88 typedef int (PASCAL *WSAEventSelect_t)(SOCKET,HANDLE,long);
  89 typedef int (PASCAL *WSAWaitForMultipleEvents_t)(long,HANDLE,BOOL,long,BOOL);
  90 typedef int (PASCAL *WSAEnumNetworkEvents_t)(SOCKET,HANDLE,LPWSANETWORKEVENTS);
  91 #endif //__WXWINCE__
  92
  93 LRESULT CALLBACK wxSocket_Internal_WinProc(HWND, UINT, WPARAM, LPARAM);
  94
  95 /* Global variables */
  96
  97 static HWND hWin;
  98 wxCRIT_SECT_DECLARE_MEMBER(gs_critical);
  99 static wxSocketImplMSW *socketList[MAXSOCKETS];
 100 static int firstAvailable;
 101
 102 #ifndef __WXWINCE__
 103 static WSAAsyncSelect_t gs_WSAAsyncSelect = NULL;
 104 #else
 105 static SocketHash socketHash;
 106 static unsigned int currSocket;
 107 HANDLE hThread[MAXSOCKETS];
 108 static WSACreateEvent_t gs_WSACreateEvent = NULL;
 109 static WSAEventSelect_t gs_WSAEventSelect = NULL;
 110 static WSAWaitForMultipleEvents_t gs_WSAWaitForMultipleEvents = NULL;
 111 static WSAEnumNetworkEvents_t gs_WSAEnumNetworkEvents = NULL;
 112 /* This structure will be used to pass data on to the thread that handles socket events.
 113 */
 114 typedef struct thread_data{
 115     HWND hEvtWin;
 116     unsigned long msgnumber;
 117     unsigned long fd;
 118     unsigned long lEvent;
 119 }thread_data;
 120 #endif
 121
 122 #ifdef __WXWINCE__
 123 /* This thread handles socket events on WinCE using WSAEventSelect() as
 124  * WSAAsyncSelect is not supported. When an event occurs for the socket, it is
 125  * checked what kind of event happend and the correct message gets posted so
 126  * that the hidden window can handle it as it would in other MSW builds.
 127 */
 128 DWORD WINAPI SocketThread(LPVOID data)
 129 {
 130     WSANETWORKEVENTS NetworkEvents;
 131     thread_data* d = (thread_data *)data;
 132
 133     HANDLE NetworkEvent = gs_WSACreateEvent();
 134     gs_WSAEventSelect(d->fd, NetworkEvent, d->lEvent);
 135
 136     while(socketHash[d->fd] == true)
 137     {
 138         if ((gs_WSAWaitForMultipleEvents(1, &NetworkEvent, FALSE,INFINITE, FALSE)) == WAIT_FAILED)
 139         {
 140             printf("WSAWaitForMultipleEvents failed with error %d\n", WSAGetLastError());
 141             return 0;
 142         }
 143         if (gs_WSAEnumNetworkEvents(d->fd ,NetworkEvent, &NetworkEvents) == SOCKET_ERROR)
 144         {
 145             printf("WSAEnumNetworkEvents failed with error %d\n", WSAGetLastError());
 146             return 0;
 147         }
 148
 149         long flags = NetworkEvents.lNetworkEvents;
 150         if (flags & FD_READ)
 151             ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_READ);
 152         if (flags & FD_WRITE)
 153             ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_WRITE);
 154         if (flags & FD_OOB)
 155             ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_OOB);
 156         if (flags & FD_ACCEPT)
 157             ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_ACCEPT);
 158         if (flags & FD_CONNECT)
 159             ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CONNECT);
 160         if (flags & FD_CLOSE)
 161             ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CLOSE);
 162
 163     }
 164     gs_WSAEventSelect(d->fd, NetworkEvent, 0);
 165     ExitThread(0);
 166     return 0;
 167 }
 168 #endif
 169
 170 // ----------------------------------------------------------------------------
 171 // MSW implementation of wxSocketManager
 172 // ----------------------------------------------------------------------------
 173
 174 class wxSocketMSWManager : public wxSocketManager
 175 {
 176 public:
 177     virtual bool OnInit();
 178     virtual void OnExit();
 179
 180     virtual wxSocketImpl *CreateSocket(wxSocketBase& wxsocket)
 181     {
 182         return new wxSocketImplMSW(wxsocket);
 183     }
 184     virtual void Install_Callback(wxSocketImpl *socket, wxSocketNotify event);
 185     virtual void Uninstall_Callback(wxSocketImpl *socket, wxSocketNotify event);
 186
 187 private:
 188     static wxDynamicLibrary gs_wsock32dll;
 189 };
 190
 191 wxDynamicLibrary wxSocketMSWManager::gs_wsock32dll;
 192
 193 bool wxSocketMSWManager::OnInit()
 194 {
 195   static LPCTSTR pclassname = NULL;
 196   int i;
 197
 198   /* Create internal window for event notifications */
 199   hWin = wxCreateHiddenWindow(&pclassname, CLASSNAME, wxSocket_Internal_WinProc);
 200   if (!hWin)
 201       return false;
 202
 203   /* Initialize socket list */
 204   for (i = 0; i < MAXSOCKETS; i++)
 205   {
 206     socketList[i] = NULL;
 207   }
 208   firstAvailable = 0;
 209
 210   // we don't link with wsock32.dll (or ws2 in CE case) statically to avoid
 211   // dependencies on it for all the application using wx even if they don't use
 212   // sockets
 213 #ifdef __WXWINCE__
 214     #define WINSOCK_DLL_NAME _T("ws2.dll")
 215 #else
 216     #define WINSOCK_DLL_NAME _T("wsock32.dll")
 217 #endif
 218
 219     gs_wsock32dll.Load(WINSOCK_DLL_NAME, wxDL_VERBATIM | wxDL_QUIET);
 220     if ( !gs_wsock32dll.IsLoaded() )
 221         return false;
 222
 223 #ifndef __WXWINCE__
 224     wxDL_INIT_FUNC(gs_, WSAAsyncSelect, gs_wsock32dll);
 225     if ( !gs_WSAAsyncSelect )
 226         return false;
 227 #else
 228     wxDL_INIT_FUNC(gs_, WSAEventSelect, gs_wsock32dll);
 229     if ( !gs_WSAEventSelect )
 230         return false;
 231
 232     wxDL_INIT_FUNC(gs_, WSACreateEvent, gs_wsock32dll);
 233     if ( !gs_WSACreateEvent )
 234         return false;
 235
 236     wxDL_INIT_FUNC(gs_, WSAWaitForMultipleEvents, gs_wsock32dll);
 237     if ( !gs_WSAWaitForMultipleEvents )
 238         return false;
 239
 240     wxDL_INIT_FUNC(gs_, WSAEnumNetworkEvents, gs_wsock32dll);
 241     if ( !gs_WSAEnumNetworkEvents )
 242         return false;
 243
 244     currSocket = 0;
 245 #endif // !__WXWINCE__/__WXWINCE__
 246
 247   // finally initialize WinSock
 248   WSADATA wsaData;
 249   return WSAStartup((1 << 8) | 1, &wsaData) == 0;
 250 }
 251
 252 void wxSocketMSWManager::OnExit()
 253 {
 254 #ifdef __WXWINCE__
 255 /* Delete the threads here */
 256     for(unsigned int i=0; i < currSocket; i++)
 257         CloseHandle(hThread[i]);
 258 #endif
 259   /* Destroy internal window */
 260   DestroyWindow(hWin);
 261   UnregisterClass(CLASSNAME, INSTANCE);
 262
 263   WSACleanup();
 264
 265   gs_wsock32dll.Unload();
 266 }
 267
 268 /* Per-socket GUI initialization / cleanup */
 269
 270 wxSocketImplMSW::wxSocketImplMSW(wxSocketBase& wxsocket)
 271     : wxSocketImpl(wxsocket)
 272 {
 273   /* Allocate a new message number for this socket */
 274   wxCRIT_SECT_LOCKER(lock, gs_critical);
 275
 276   int i = firstAvailable;
 277   while (socketList[i] != NULL)
 278   {
 279     i = (i + 1) % MAXSOCKETS;
 280
 281     if (i == firstAvailable)    /* abort! */
 282     {
 283       m_msgnumber = 0; // invalid
 284       return;
 285     }
 286   }
 287   socketList[i] = this;
 288   firstAvailable = (i + 1) % MAXSOCKETS;
 289   m_msgnumber = (i + WM_USER);
 290 }
 291
 292 wxSocketImplMSW::~wxSocketImplMSW()
 293 {
 294   /* Remove the socket from the list */
 295   wxCRIT_SECT_LOCKER(lock, gs_critical);
 296
 297   if ( m_msgnumber )
 298   {
 299       // we need to remove any pending messages for this socket to avoid having
 300       // them sent to a new socket which could reuse the same message number as
 301       // soon as we destroy this one
 302       MSG msg;
 303       while ( ::PeekMessage(&msg, hWin, m_msgnumber, m_msgnumber, PM_REMOVE) )
 304           ;
 305
 306       socketList[m_msgnumber - WM_USER] = NULL;
 307   }
 308   //else: the socket has never been created successfully
 309 }
 310
 311 /* Windows proc for asynchronous event handling */
 312
 313 LRESULT CALLBACK wxSocket_Internal_WinProc(HWND hWnd,
 314                                            UINT uMsg,
 315                                            WPARAM wParam,
 316                                            LPARAM lParam)
 317 {
 318     if ( uMsg < WM_USER || uMsg > (WM_USER + MAXSOCKETS - 1))
 319         return DefWindowProc(hWnd, uMsg, wParam, lParam);
 320
 321     wxSocketImplMSW *socket;
 322     wxSocketNotify event;
 323     {
 324         wxCRIT_SECT_LOCKER(lock, gs_critical);
 325
 326         socket = socketList[(uMsg - WM_USER)];
 327         event = (wxSocketNotify) -1;
 328
 329         /* Check that the socket still exists (it has not been
 330          * destroyed) and for safety, check that the m_fd field
 331          * is what we expect it to be.
 332          */
 333         if ((socket != NULL) && ((WPARAM)socket->m_fd == wParam))
 334         {
 335             switch WSAGETSELECTEVENT(lParam)
 336             {
 337                 case FD_READ:    event = wxSOCKET_INPUT; break;
 338                 case FD_WRITE:   event = wxSOCKET_OUTPUT; break;
 339                 case FD_ACCEPT:  event = wxSOCKET_CONNECTION; break;
 340                 case FD_CONNECT:
 341                                  {
 342                                      if (WSAGETSELECTERROR(lParam) != 0)
 343                                          event = wxSOCKET_LOST;
 344                                      else
 345                                          event = wxSOCKET_CONNECTION;
 346                                      break;
 347                                  }
 348                 case FD_CLOSE:   event = wxSOCKET_LOST; break;
 349             }
 350
 351             if (event != -1)
 352             {
 353                 if (event == wxSOCKET_LOST)
 354                     socket->m_detected = wxSOCKET_LOST_FLAG;
 355                 else
 356                     socket->m_detected |= (1 << event);
 357             }
 358         }
 359     } // unlock gs_critical
 360
 361     if ( socket )
 362         socket->NotifyOnStateChange(event);
 363
 364     return (LRESULT) 0;
 365 }
 366
 367 /*
 368  *  Enable all event notifications; we need to be notified of all
 369  *  events for internal processing, but we will only notify users
 370  *  when an appropriate callback function has been installed.
 371  */
 372 void wxSocketMSWManager::Install_Callback(wxSocketImpl *socket_,
 373                                          wxSocketNotify WXUNUSED(event))
 374 {
 375     wxSocketImplMSW * const socket = static_cast<wxSocketImplMSW *>(socket_);
 376
 377   if (socket->m_fd != INVALID_SOCKET)
 378   {
 379     /* We could probably just subscribe to all events regardless
 380      * of the socket type, but MS recommends to do it this way.
 381      */
 382     long lEvent = socket->m_server?
 383                   FD_ACCEPT : (FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE);
 384 #ifndef __WXWINCE__
 385     gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, lEvent);
 386 #else
 387 /*
 388 *  WinCE creates a thread for socket event handling.
 389 *  All needed parameters get passed through the thread_data structure.
 390 */
 391
 392     thread_data* d = new thread_data;
 393     d->lEvent = lEvent;
 394     d->hEvtWin = hWin;
 395     d->msgnumber = socket->m_msgnumber;
 396     d->fd = socket->m_fd;
 397     socketHash[socket->m_fd] = true;
 398     hThread[currSocket++] = CreateThread(NULL, 0, &SocketThread,(LPVOID)d, 0, NULL);
 399 #endif
 400   }
 401 }
 402
 403 /*
 404  *  Disable event notifications (used when shutting down the socket)
 405  */
 406 void wxSocketMSWManager::Uninstall_Callback(wxSocketImpl *socket_,
 407                                            wxSocketNotify WXUNUSED(event))
 408 {
 409     wxSocketImplMSW * const socket = static_cast<wxSocketImplMSW *>(socket_);
 410
 411   if (socket->m_fd != INVALID_SOCKET)
 412   {
 413 #ifndef __WXWINCE__
 414     gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, 0);
 415 #else
 416     //Destroy the thread
 417     socketHash[socket->m_fd] = false;
 418 #endif
 419   }
 420 }
 421
 422 // set the wxBase variable to point to our wxSocketManager implementation
 423 //
 424 // see comments in wx/apptrait.h for the explanation of why do we do it
 425 // like this
 426 static struct ManagerSetter
 427 {
 428     ManagerSetter()
 429     {
 430         static wxSocketMSWManager s_manager;
 431         wxAppTraits::SetDefaultSocketManager(&s_manager);
 432     }
 433 } gs_managerSetter;
 434
 435 // ============================================================================
 436 // wxSocketImpl implementation
 437 // ============================================================================
 438
 439 /* static */
 440 wxSocketImpl *wxSocketImpl::Create(wxSocketBase& wxsocket)
 441 {
 442     return new wxSocketImplMSW(wxsocket);
 443 }
 444
 445 void wxSocketImplMSW::DoClose()
 446 {
 447     wxSocketManager::Get()->
 448         Uninstall_Callback(this, wxSOCKET_MAX_EVENT /* unused anyhow */);
 449
 450     closesocket(m_fd);
 451 }
 452
 453 /*
 454  *  Waits for an incoming client connection. Returns a pointer to
 455  *  a wxSocketImpl object, or NULL if there was an error, in which case
 456  *  the last error field will be updated for the calling wxSocketImpl.
 457  *
 458  *  Error codes (set in the calling wxSocketImpl)
 459  *    wxSOCKET_INVSOCK    - the socket is not valid or not a server.
 460  *    wxSOCKET_TIMEDOUT   - timeout, no incoming connections.
 461  *    wxSOCKET_WOULDBLOCK - the call would block and the socket is nonblocking.
 462  *    wxSOCKET_MEMERR     - couldn't allocate memory.
 463  *    wxSOCKET_IOERR      - low-level error.
 464  */
 465 wxSocketImpl *wxSocketImplMSW::WaitConnection(wxSocketBase& wxsocket)
 466 {
 467   wxSocketImpl *connection;
 468   wxSockAddr from;
 469   WX_SOCKLEN_T fromlen = sizeof(from);
 470   wxSocketError err;
 471   u_long arg = 1;
 472
 473   /* Reenable CONNECTION events */
 474   m_detected &= ~wxSOCKET_CONNECTION_FLAG;
 475
 476   /* If the socket has already been created, we exit immediately */
 477   if (m_fd == INVALID_SOCKET || !m_server)
 478   {
 479     m_error = wxSOCKET_INVSOCK;
 480     return NULL;
 481   }
 482
 483   /* Create a wxSocketImpl object for the new connection */
 484   connection = wxSocketImplMSW::Create(wxsocket);
 485
 486   if (!connection)
 487   {
 488     m_error = wxSOCKET_MEMERR;
 489     return NULL;
 490   }
 491
 492   /* Wait for a connection (with timeout) */
 493   if (Input_Timeout() == wxSOCKET_TIMEDOUT)
 494   {
 495     delete connection;
 496     /* m_error set by Input_Timeout */
 497     return NULL;
 498   }
 499
 500   connection->m_fd = accept(m_fd, (sockaddr*)&from, &fromlen);
 501
 502   if (connection->m_fd == INVALID_SOCKET)
 503   {
 504     if (WSAGetLastError() == WSAEWOULDBLOCK)
 505       m_error = wxSOCKET_WOULDBLOCK;
 506     else
 507       m_error = wxSOCKET_IOERR;
 508
 509     delete connection;
 510     return NULL;
 511   }
 512
 513   /* Initialize all fields */
 514   connection->m_server   = false;
 515   connection->m_stream   = true;
 516
 517   /* Setup the peer address field */
 518   connection->m_peer = GAddress_new();
 519   if (!connection->m_peer)
 520   {
 521     delete connection;
 522     m_error = wxSOCKET_MEMERR;
 523     return NULL;
 524   }
 525   err = _GAddress_translate_from(connection->m_peer, (sockaddr*)&from, fromlen);
 526   if (err != wxSOCKET_NOERROR)
 527   {
 528     GAddress_destroy(connection->m_peer);
 529     delete connection;
 530     m_error = err;
 531     return NULL;
 532   }
 533
 534   ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg);
 535   wxSocketManager::Get()->Install_Callback(connection);
 536
 537   return connection;
 538 }
 539
 540 wxSocketError wxSocketImplMSW::DoHandleConnect(int ret)
 541 {
 542     // TODO: review this
 543     if (ret == SOCKET_ERROR)
 544     {
 545         int err = WSAGetLastError();
 546
 547         /* If connect failed with EWOULDBLOCK and the wxSocketImpl object
 548          * is in blocking mode, we select() for the specified timeout
 549          * checking for writability to see if the connection request
 550          * completes.
 551          */
 552         if ((err == WSAEWOULDBLOCK) && (!m_non_blocking))
 553         {
 554             err = Connect_Timeout();
 555
 556             if (err != wxSOCKET_NOERROR)
 557             {
 558                 Close();
 559                 /* m_error is set in Connect_Timeout */
 560             }
 561
 562             return (wxSocketError) err;
 563         }
 564
 565         /* If connect failed with EWOULDBLOCK and the wxSocketImpl object
 566          * is set to nonblocking, we set m_error to wxSOCKET_WOULDBLOCK
 567          * (and return wxSOCKET_WOULDBLOCK) but we don't close the socket;
 568          * this way if the connection completes, a wxSOCKET_CONNECTION
 569          * event will be generated, if enabled.
 570          */
 571         if ((err == WSAEWOULDBLOCK) && (m_non_blocking))
 572         {
 573             m_establishing = true;
 574             m_error = wxSOCKET_WOULDBLOCK;
 575             return wxSOCKET_WOULDBLOCK;
 576         }
 577
 578         /* If connect failed with an error other than EWOULDBLOCK,
 579          * then the call to Connect() has failed.
 580          */
 581         Close();
 582         m_error = wxSOCKET_IOERR;
 583         return wxSOCKET_IOERR;
 584     }
 585
 586     return wxSOCKET_NOERROR;
 587 }
 588
 589 /* Generic IO */
 590
 591 /* Like recv(), send(), ... */
 592 int wxSocketImplMSW::Read(void *buffer, int size)
 593 {
 594   int ret;
 595
 596   /* Reenable INPUT events */
 597   m_detected &= ~wxSOCKET_INPUT_FLAG;
 598
 599   if (m_fd == INVALID_SOCKET || m_server)
 600   {
 601     m_error = wxSOCKET_INVSOCK;
 602     return -1;
 603   }
 604
 605   /* If the socket is blocking, wait for data (with a timeout) */
 606   if (Input_Timeout() == wxSOCKET_TIMEDOUT)
 607   {
 608     m_error = wxSOCKET_TIMEDOUT;
 609     return -1;
 610   }
 611
 612   /* Read the data */
 613   if (m_stream)
 614     ret = Recv_Stream(buffer, size);
 615   else
 616     ret = Recv_Dgram(buffer, size);
 617
 618   if (ret == SOCKET_ERROR)
 619   {
 620     if (WSAGetLastError() != WSAEWOULDBLOCK)
 621       m_error = wxSOCKET_IOERR;
 622     else
 623       m_error = wxSOCKET_WOULDBLOCK;
 624     return -1;
 625   }
 626
 627   return ret;
 628 }
 629
 630 int wxSocketImplMSW::Write(const void *buffer, int size)
 631 {
 632   int ret;
 633
 634   if (m_fd == INVALID_SOCKET || m_server)
 635   {
 636     m_error = wxSOCKET_INVSOCK;
 637     return -1;
 638   }
 639
 640   /* If the socket is blocking, wait for writability (with a timeout) */
 641   if (Output_Timeout() == wxSOCKET_TIMEDOUT)
 642     return -1;
 643
 644   /* Write the data */
 645   if (m_stream)
 646     ret = Send_Stream(buffer, size);
 647   else
 648     ret = Send_Dgram(buffer, size);
 649
 650   if (ret == SOCKET_ERROR)
 651   {
 652     if (WSAGetLastError() != WSAEWOULDBLOCK)
 653       m_error = wxSOCKET_IOERR;
 654     else
 655       m_error = wxSOCKET_WOULDBLOCK;
 656
 657     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
 658      * does). Once the first OUTPUT event is received, users can assume
 659      * that the socket is writable until a read operation fails. Only then
 660      * will further OUTPUT events be posted.
 661      */
 662     m_detected &= ~wxSOCKET_OUTPUT_FLAG;
 663     return -1;
 664   }
 665
 666   return ret;
 667 }
 668
 669 /* Internals (IO) */
 670
 671 /*
 672  *  For blocking sockets, wait until data is available or
 673  *  until timeout ellapses.
 674  */
 675 wxSocketError wxSocketImplMSW::Input_Timeout()
 676 {
 677   fd_set readfds;
 678
 679   if (!m_non_blocking)
 680   {
 681     FD_ZERO(&readfds);
 682     FD_SET(m_fd, &readfds);
 683     if (select(0, &readfds, NULL, NULL, &m_timeout) == 0)
 684     {
 685       m_error = wxSOCKET_TIMEDOUT;
 686       return wxSOCKET_TIMEDOUT;
 687     }
 688   }
 689   return wxSOCKET_NOERROR;
 690 }
 691
 692 /*
 693  *  For blocking sockets, wait until data can be sent without
 694  *  blocking or until timeout ellapses.
 695  */
 696 wxSocketError wxSocketImplMSW::Output_Timeout()
 697 {
 698   fd_set writefds;
 699
 700   if (!m_non_blocking)
 701   {
 702     FD_ZERO(&writefds);
 703     FD_SET(m_fd, &writefds);
 704     if (select(0, NULL, &writefds, NULL, &m_timeout) == 0)
 705     {
 706       m_error = wxSOCKET_TIMEDOUT;
 707       return wxSOCKET_TIMEDOUT;
 708     }
 709   }
 710   return wxSOCKET_NOERROR;
 711 }
 712
 713 /*
 714  *  For blocking sockets, wait until the connection is
 715  *  established or fails, or until timeout ellapses.
 716  */
 717 wxSocketError wxSocketImplMSW::Connect_Timeout()
 718 {
 719   fd_set writefds;
 720   fd_set exceptfds;
 721
 722   FD_ZERO(&writefds);
 723   FD_ZERO(&exceptfds);
 724   FD_SET(m_fd, &writefds);
 725   FD_SET(m_fd, &exceptfds);
 726   if (select(0, NULL, &writefds, &exceptfds, &m_timeout) == 0)
 727   {
 728     m_error = wxSOCKET_TIMEDOUT;
 729     return wxSOCKET_TIMEDOUT;
 730   }
 731   if (!FD_ISSET(m_fd, &writefds))
 732   {
 733     m_error = wxSOCKET_IOERR;
 734     return wxSOCKET_IOERR;
 735   }
 736
 737   return wxSOCKET_NOERROR;
 738 }
 739
 740 int wxSocketImplMSW::Recv_Stream(void *buffer, int size)
 741 {
 742     return recv(m_fd, static_cast<char *>(buffer), size, 0);
 743 }
 744
 745 int wxSocketImplMSW::Recv_Dgram(void *buffer, int size)
 746 {
 747   wxSockAddr from;
 748   WX_SOCKLEN_T fromlen = sizeof(from);
 749   int ret;
 750   wxSocketError err;
 751
 752   ret = recvfrom(m_fd, static_cast<char *>(buffer),
 753                  size, 0, &from, &fromlen);
 754
 755   if (ret == SOCKET_ERROR)
 756     return SOCKET_ERROR;
 757
 758   /* Translate a system address into a wxSocketImpl address */
 759   if (!m_peer)
 760   {
 761     m_peer = GAddress_new();
 762     if (!m_peer)
 763     {
 764       m_error = wxSOCKET_MEMERR;
 765       return -1;
 766     }
 767   }
 768   err = _GAddress_translate_from(m_peer, (sockaddr*)&from, fromlen);
 769   if (err != wxSOCKET_NOERROR)
 770   {
 771     GAddress_destroy(m_peer);
 772     m_peer  = NULL;
 773     m_error = err;
 774     return -1;
 775   }
 776
 777   return ret;
 778 }
 779
 780 int wxSocketImplMSW::Send_Stream(const void *buffer, int size)
 781 {
 782   return send(m_fd, static_cast<const char *>(buffer), size, 0);
 783 }
 784
 785 int wxSocketImplMSW::Send_Dgram(const void *buffer, int size)
 786 {
 787   struct sockaddr *addr;
 788   int len, ret;
 789   wxSocketError err;
 790
 791   if (!m_peer)
 792   {
 793     m_error = wxSOCKET_INVADDR;
 794     return -1;
 795   }
 796
 797   err = _GAddress_translate_to(m_peer, &addr, &len);
 798   if (err != wxSOCKET_NOERROR)
 799   {
 800     m_error = err;
 801     return -1;
 802   }
 803
 804   ret = sendto(m_fd, static_cast<const char *>(buffer), size, 0, addr, len);
 805
 806   /* Frees memory allocated by _GAddress_translate_to */
 807   free(addr);
 808
 809   return ret;
 810 }
 811
 812 /*
 813  * -------------------------------------------------------------------------
 814  * GAddress
 815  * -------------------------------------------------------------------------
 816  */
 817
 818 /* CHECK_ADDRESS verifies that the current address family is either
 819  * wxSOCKET_NOFAMILY or wxSOCKET_*family*, and if it is wxSOCKET_NOFAMILY, it
 820  * initalizes it to be a wxSOCKET_*family*. In other cases, it returns
 821  * an appropiate error code.
 822  *
 823  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
 824  */
 825 #define CHECK_ADDRESS(address, family)                              \
 826 {                                                                   \
 827   if (address->m_family == wxSOCKET_NOFAMILY)                          \
 828     if (_GAddress_Init_##family(address) != wxSOCKET_NOERROR)          \
 829       return address->m_error;                                      \
 830   if (address->m_family != wxSOCKET_##family)                          \
 831   {                                                                 \
 832     address->m_error = wxSOCKET_INVADDR;                               \
 833     return wxSOCKET_INVADDR;                                           \
 834   }                                                                 \
 835 }
 836
 837 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
 838 {                                                                   \
 839   if (address->m_family == wxSOCKET_NOFAMILY)                          \
 840     if (_GAddress_Init_##family(address) != wxSOCKET_NOERROR)          \
 841       return retval;                                                \
 842   if (address->m_family != wxSOCKET_##family)                          \
 843   {                                                                 \
 844     address->m_error = wxSOCKET_INVADDR;                               \
 845     return retval;                                                  \
 846   }                                                                 \
 847 }
 848
 849
 850 GAddress *GAddress_new()
 851 {
 852   GAddress *address;
 853
 854   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
 855     return NULL;
 856
 857   address->m_family = wxSOCKET_NOFAMILY;
 858   address->m_addr   = NULL;
 859   address->m_len    = 0;
 860
 861   return address;
 862 }
 863
 864 GAddress *GAddress_copy(GAddress *address)
 865 {
 866   GAddress *addr2;
 867
 868   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
 869     return NULL;
 870
 871   memcpy(addr2, address, sizeof(GAddress));
 872
 873   if (address->m_addr)
 874   {
 875     addr2->m_addr = (struct sockaddr *) malloc(addr2->m_len);
 876     if (addr2->m_addr == NULL)
 877     {
 878       free(addr2);
 879       return NULL;
 880     }
 881     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
 882   }
 883
 884   return addr2;
 885 }
 886
 887 void GAddress_destroy(GAddress *address)
 888 {
 889   if (address->m_addr)
 890     free(address->m_addr);
 891
 892   free(address);
 893 }
 894
 895 void GAddress_SetFamily(GAddress *address, GAddressType type)
 896 {
 897   address->m_family = type;
 898 }
 899
 900 GAddressType GAddress_GetFamily(GAddress *address)
 901 {
 902   return address->m_family;
 903 }
 904
 905 wxSocketError _GAddress_translate_from(GAddress *address,
 906                                       struct sockaddr *addr, int len)
 907 {
 908   address->m_realfamily = addr->sa_family;
 909   switch (addr->sa_family)
 910   {
 911     case AF_INET:
 912       address->m_family = wxSOCKET_INET;
 913       break;
 914     case AF_UNIX:
 915       address->m_family = wxSOCKET_UNIX;
 916       break;
 917 #if wxUSE_IPV6
 918     case AF_INET6:
 919       address->m_family = wxSOCKET_INET6;
 920       break;
 921 #endif
 922     default:
 923     {
 924       address->m_error = wxSOCKET_INVOP;
 925       return wxSOCKET_INVOP;
 926     }
 927   }
 928
 929   if (address->m_addr)
 930     free(address->m_addr);
 931
 932   address->m_len = len;
 933   address->m_addr = (struct sockaddr *) malloc(len);
 934
 935   if (address->m_addr == NULL)
 936   {
 937     address->m_error = wxSOCKET_MEMERR;
 938     return wxSOCKET_MEMERR;
 939   }
 940   memcpy(address->m_addr, addr, len);
 941
 942   return wxSOCKET_NOERROR;
 943 }
 944
 945 wxSocketError _GAddress_translate_to(GAddress *address,
 946                                     struct sockaddr **addr, int *len)
 947 {
 948   if (!address->m_addr)
 949   {
 950     address->m_error = wxSOCKET_INVADDR;
 951     return wxSOCKET_INVADDR;
 952   }
 953
 954   *len = address->m_len;
 955   *addr = (struct sockaddr *) malloc(address->m_len);
 956   if (*addr == NULL)
 957   {
 958     address->m_error = wxSOCKET_MEMERR;
 959     return wxSOCKET_MEMERR;
 960   }
 961
 962   memcpy(*addr, address->m_addr, address->m_len);
 963   return wxSOCKET_NOERROR;
 964 }
 965
 966 /*
 967  * -------------------------------------------------------------------------
 968  * Internet address family
 969  * -------------------------------------------------------------------------
 970  */
 971
 972 wxSocketError _GAddress_Init_INET(GAddress *address)
 973 {
 974   address->m_len  = sizeof(struct sockaddr_in);
 975   address->m_addr = (struct sockaddr *) malloc(address->m_len);
 976   if (address->m_addr == NULL)
 977   {
 978     address->m_error = wxSOCKET_MEMERR;
 979     return wxSOCKET_MEMERR;
 980   }
 981
 982   address->m_family = wxSOCKET_INET;
 983   address->m_realfamily = AF_INET;
 984   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
 985   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
 986
 987   return wxSOCKET_NOERROR;
 988 }
 989
 990 wxSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
 991 {
 992   struct hostent *he;
 993   struct in_addr *addr;
 994
 995   CHECK_ADDRESS(address, INET);
 996
 997   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
 998
 999   addr->s_addr = inet_addr(hostname);
1000
1001   /* If it is a numeric host name, convert it now */
1002   if (addr->s_addr == INADDR_NONE)
1003   {
1004     struct in_addr *array_addr;
1005
1006     /* It is a real name, we solve it */
1007     if ((he = gethostbyname(hostname)) == NULL)
1008     {
1009       /* addr->s_addr = INADDR_NONE just done by inet_addr() above */
1010       address->m_error = wxSOCKET_NOHOST;
1011       return wxSOCKET_NOHOST;
1012     }
1013     array_addr = (struct in_addr *) *(he->h_addr_list);
1014     addr->s_addr = array_addr[0].s_addr;
1015   }
1016   return wxSOCKET_NOERROR;
1017 }
1018
1019 wxSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
1020 {
1021   return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
1022 }
1023
1024 wxSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1025 {
1026   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1027 }
1028
1029 wxSocketError GAddress_INET_SetHostAddress(GAddress *address,
1030                                           unsigned long hostaddr)
1031 {
1032   struct in_addr *addr;
1033
1034   CHECK_ADDRESS(address, INET);
1035
1036   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1037   addr->s_addr = htonl(hostaddr);
1038
1039   return wxSOCKET_NOERROR;
1040 }
1041
1042 wxSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1043                                        const char *protocol)
1044 {
1045   struct servent *se;
1046   struct sockaddr_in *addr;
1047
1048   CHECK_ADDRESS(address, INET);
1049
1050   if (!port)
1051   {
1052     address->m_error = wxSOCKET_INVPORT;
1053     return wxSOCKET_INVPORT;
1054   }
1055
1056   se = getservbyname(port, protocol);
1057   if (!se)
1058   {
1059     if (isdigit(port[0]))
1060     {
1061       int port_int;
1062
1063       port_int = atoi(port);
1064       addr = (struct sockaddr_in *)address->m_addr;
1065       addr->sin_port = htons((u_short) port_int);
1066       return wxSOCKET_NOERROR;
1067     }
1068
1069     address->m_error = wxSOCKET_INVPORT;
1070     return wxSOCKET_INVPORT;
1071   }
1072
1073   addr = (struct sockaddr_in *)address->m_addr;
1074   addr->sin_port = se->s_port;
1075
1076   return wxSOCKET_NOERROR;
1077 }
1078
1079 wxSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1080 {
1081   struct sockaddr_in *addr;
1082
1083   CHECK_ADDRESS(address, INET);
1084
1085   addr = (struct sockaddr_in *)address->m_addr;
1086   addr->sin_port = htons(port);
1087
1088   return wxSOCKET_NOERROR;
1089 }
1090
1091 wxSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1092 {
1093   struct hostent *he;
1094   char *addr_buf;
1095   struct sockaddr_in *addr;
1096
1097   CHECK_ADDRESS(address, INET);
1098
1099   addr = (struct sockaddr_in *)address->m_addr;
1100   addr_buf = (char *)&(addr->sin_addr);
1101
1102   he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1103   if (he == NULL)
1104   {
1105     address->m_error = wxSOCKET_NOHOST;
1106     return wxSOCKET_NOHOST;
1107   }
1108
1109   strncpy(hostname, he->h_name, sbuf);
1110
1111   return wxSOCKET_NOERROR;
1112 }
1113
1114 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1115 {
1116   struct sockaddr_in *addr;
1117
1118   CHECK_ADDRESS_RETVAL(address, INET, 0);
1119
1120   addr = (struct sockaddr_in *)address->m_addr;
1121
1122   return ntohl(addr->sin_addr.s_addr);
1123 }
1124
1125 unsigned short GAddress_INET_GetPort(GAddress *address)
1126 {
1127   struct sockaddr_in *addr;
1128
1129   CHECK_ADDRESS_RETVAL(address, INET, 0);
1130
1131   addr = (struct sockaddr_in *)address->m_addr;
1132   return ntohs(addr->sin_port);
1133 }
1134
1135
1136 #if wxUSE_IPV6
1137 /*
1138  * -------------------------------------------------------------------------
1139  * Internet IPv6 address family
1140  * -------------------------------------------------------------------------
1141  */
1142 #include "ws2tcpip.h"
1143
1144 #ifdef __VISUALC__
1145     #pragma comment(lib,"ws2_32")
1146 #endif // __VISUALC__
1147
1148 wxSocketError _GAddress_Init_INET6(GAddress *address)
1149 {
1150   struct in6_addr any_address = IN6ADDR_ANY_INIT;
1151   address->m_len  = sizeof(struct sockaddr_in6);
1152   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1153   if (address->m_addr == NULL)
1154   {
1155     address->m_error = wxSOCKET_MEMERR;
1156     return wxSOCKET_MEMERR;
1157   }
1158   memset(address->m_addr,0,address->m_len);
1159
1160   address->m_family = wxSOCKET_INET6;
1161   address->m_realfamily = AF_INET6;
1162   ((struct sockaddr_in6 *)address->m_addr)->sin6_family = AF_INET6;
1163   ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = any_address;
1164
1165   return wxSOCKET_NOERROR;
1166 }
1167
1168 wxSocketError GAddress_INET6_SetHostName(GAddress *address, const char *hostname)
1169 {
1170   CHECK_ADDRESS(address, INET6);
1171
1172   addrinfo hints;
1173   memset( & hints, 0, sizeof( hints ) );
1174   hints.ai_family = AF_INET6;
1175   addrinfo * info = 0;
1176   if ( getaddrinfo( hostname, "0", & hints, & info ) || ! info )
1177   {
1178     address->m_error = wxSOCKET_NOHOST;
1179     return wxSOCKET_NOHOST;
1180   }
1181
1182   memcpy( address->m_addr, info->ai_addr, info->ai_addrlen );
1183   freeaddrinfo( info );
1184   return wxSOCKET_NOERROR;
1185 }
1186
1187 wxSocketError GAddress_INET6_SetAnyAddress(GAddress *address)
1188 {
1189   CHECK_ADDRESS(address, INET6);
1190
1191   struct in6_addr addr;
1192   memset( & addr, 0, sizeof( addr ) );
1193   return GAddress_INET6_SetHostAddress(address, addr);
1194 }
1195 wxSocketError GAddress_INET6_SetHostAddress(GAddress *address,
1196                                           struct in6_addr hostaddr)
1197 {
1198   CHECK_ADDRESS(address, INET6);
1199
1200   ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = hostaddr;
1201
1202   return wxSOCKET_NOERROR;
1203 }
1204
1205 wxSocketError GAddress_INET6_SetPortName(GAddress *address, const char *port,
1206                                        const char *protocol)
1207 {
1208   struct servent *se;
1209   struct sockaddr_in6 *addr;
1210
1211   CHECK_ADDRESS(address, INET6);
1212
1213   if (!port)
1214   {
1215     address->m_error = wxSOCKET_INVPORT;
1216     return wxSOCKET_INVPORT;
1217   }
1218
1219   se = getservbyname(port, protocol);
1220   if (!se)
1221   {
1222     if (isdigit((unsigned char) port[0]))
1223     {
1224       int port_int;
1225
1226       port_int = atoi(port);
1227       addr = (struct sockaddr_in6 *)address->m_addr;
1228       addr->sin6_port = htons((u_short) port_int);
1229       return wxSOCKET_NOERROR;
1230     }
1231
1232     address->m_error = wxSOCKET_INVPORT;
1233     return wxSOCKET_INVPORT;
1234   }
1235
1236   addr = (struct sockaddr_in6 *)address->m_addr;
1237   addr->sin6_port = se->s_port;
1238
1239   return wxSOCKET_NOERROR;
1240 }
1241
1242 wxSocketError GAddress_INET6_SetPort(GAddress *address, unsigned short port)
1243 {
1244   struct sockaddr_in6 *addr;
1245
1246   CHECK_ADDRESS(address, INET6);
1247
1248   addr = (struct sockaddr_in6 *)address->m_addr;
1249   addr->sin6_port = htons(port);
1250
1251   return wxSOCKET_NOERROR;
1252 }
1253
1254 wxSocketError GAddress_INET6_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1255 {
1256   struct hostent *he;
1257   char *addr_buf;
1258   struct sockaddr_in6 *addr;
1259
1260   CHECK_ADDRESS(address, INET6);
1261
1262   addr = (struct sockaddr_in6 *)address->m_addr;
1263   addr_buf = (char *)&(addr->sin6_addr);
1264
1265   he = gethostbyaddr(addr_buf, sizeof(addr->sin6_addr), AF_INET6);
1266   if (he == NULL)
1267   {
1268     address->m_error = wxSOCKET_NOHOST;
1269     return wxSOCKET_NOHOST;
1270   }
1271
1272   strncpy(hostname, he->h_name, sbuf);
1273
1274   return wxSOCKET_NOERROR;
1275 }
1276
1277 wxSocketError GAddress_INET6_GetHostAddress(GAddress *address,struct in6_addr *hostaddr)
1278 {
1279   CHECK_ADDRESS_RETVAL(address, INET6, wxSOCKET_INVADDR);
1280   *hostaddr = ( (struct sockaddr_in6 *)address->m_addr )->sin6_addr;
1281   return wxSOCKET_NOERROR;
1282 }
1283
1284 unsigned short GAddress_INET6_GetPort(GAddress *address)
1285 {
1286   CHECK_ADDRESS_RETVAL(address, INET6, 0);
1287
1288   return ntohs( ((struct sockaddr_in6 *)address->m_addr)->sin6_port );
1289 }
1290
1291 #endif // wxUSE_IPV6
1292
1293 /*
1294  * -------------------------------------------------------------------------
1295  * Unix address family
1296  * -------------------------------------------------------------------------
1297  */
1298
1299 wxSocketError _GAddress_Init_UNIX(GAddress *address)
1300 {
1301   address->m_error = wxSOCKET_INVADDR;
1302   return wxSOCKET_INVADDR;
1303 }
1304
1305 wxSocketError GAddress_UNIX_SetPath(GAddress *address, const char *WXUNUSED(path))
1306 {
1307   address->m_error = wxSOCKET_INVADDR;
1308   return wxSOCKET_INVADDR;
1309 }
1310
1311 wxSocketError GAddress_UNIX_GetPath(GAddress *address, char *WXUNUSED(path), size_t WXUNUSED(sbuf))
1312 {
1313   address->m_error = wxSOCKET_INVADDR;
1314   return wxSOCKET_INVADDR;
1315 }
1316
1317 #endif  // wxUSE_SOCKETS