src/msw/gsocket.cpp

   1 /* -------------------------------------------------------------------------
   2  * Project:     GSocket (Generic Socket)
   3  * Name:        src/msw/gsocket.cpp
   4  * Copyright:   (c) Guilhem Lavaux
   5  * Licence:     wxWindows Licence
   6  * Author:      Guillermo Rodriguez Garcia <guille@iies.es>
   7  * Purpose:     GSocket main MSW file
   8  * Licence:     The wxWindows licence
   9  * CVSID:       $Id$
  10  * -------------------------------------------------------------------------
  11  */
  12
  13 // For compilers that support precompilation, includes "wx.h".
  14 #include "wx/wxprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #ifdef _MSC_VER
  21    /* RPCNOTIFICATION_ROUTINE in rasasync.h (included from winsock.h),
  22     * warning: conditional expression is constant.
  23     */
  24 #  pragma warning(disable:4115)
  25    /* FD_SET,
  26     * warning: named type definition in parentheses.
  27     */
  28 #  pragma warning(disable:4127)
  29    /* GAddress_UNIX_GetPath,
  30     * warning: unreferenced formal parameter.
  31     */
  32 #  pragma warning(disable:4100)
  33
  34 #ifdef __WXWINCE__
  35     /* windows.h results in tons of warnings at max warning level */
  36 #   ifdef _MSC_VER
  37 #       pragma warning(push, 1)
  38 #   endif
  39 #   include <windows.h>
  40 #   ifdef _MSC_VER
  41 #       pragma warning(pop)
  42 #       pragma warning(disable:4514)
  43 #   endif
  44 #endif
  45
  46 #endif /* _MSC_VER */
  47
  48 #if defined(__CYGWIN__)
  49     //CYGWIN gives annoying warning about runtime stuff if we don't do this
  50 #   define USE_SYS_TYPES_FD_SET
  51 #   include <sys/types.h>
  52 #endif
  53
  54 #include <winsock.h>
  55
  56 #include "wx/platform.h"
  57
  58 #if wxUSE_SOCKETS
  59
  60 #include "wx/gsocket.h"
  61 #include "wx/link.h"
  62
  63 wxFORCE_LINK_MODULE(gsockmsw)
  64
  65 #ifdef __WXWINCE__
  66 #ifndef isdigit
  67 #define isdigit(x) (x > 47 && x < 58)
  68 #endif
  69 #include "wx/msw/wince/net.h"
  70 #endif
  71
  72 #include <string.h>
  73 #include <stdio.h>
  74 #include <stdlib.h>
  75 #include <stddef.h>
  76 #include <ctype.h>
  77
  78 /* if we use configure for MSW WX_SOCKLEN_T will be already defined */
  79 #ifndef WX_SOCKLEN_T
  80 #  define WX_SOCKLEN_T int
  81 #endif
  82
  83 #if wxUSE_IPV6
  84 typedef struct sockaddr_storage wxSockAddr;
  85 #else
  86 typedef struct sockaddr wxSockAddr;
  87 #endif
  88
  89 bool GSocket_Init()
  90 {
  91   WSADATA wsaData;
  92
  93   GSocketManager * const manager = GSocketManager::Get();
  94   if ( !manager || !manager->OnInit() )
  95       return false;
  96
  97   /* Initialize WinSocket */
  98   return WSAStartup((1 << 8) | 1, &wsaData) == 0;
  99 }
 100
 101 void GSocket_Cleanup()
 102 {
 103   GSocketManager * const manager = GSocketManager::Get();
 104   if ( manager )
 105     manager->OnExit();
 106
 107   /* Cleanup WinSocket */
 108   WSACleanup();
 109 }
 110
 111 /* Constructors / Destructors for GSocket */
 112
 113 void GSocket::Close()
 114 {
 115     GSocketManager::Get()->Disable_Events(this);
 116     closesocket(m_fd);
 117     m_fd = INVALID_SOCKET;
 118 }
 119
 120 /* Address handling */
 121
 122 /* GSocket_SetLocal:
 123  * GSocket_GetLocal:
 124  * GSocket_SetPeer:
 125  * GSocket_GetPeer:
 126  *  Set or get the local or peer address for this socket. The 'set'
 127  *  functions return GSOCK_NOERROR on success, an error code otherwise.
 128  *  The 'get' functions return a pointer to a GAddress object on success,
 129  *  or NULL otherwise, in which case they set the error code of the
 130  *  corresponding GSocket.
 131  *
 132  *  Error codes:
 133  *    GSOCK_INVSOCK - the socket is not valid.
 134  *    GSOCK_INVADDR - the address is not valid.
 135  */
 136 GSocketError GSocket::SetLocal(GAddress *address)
 137 {
 138   /* the socket must be initialized, or it must be a server */
 139   if (m_fd != INVALID_SOCKET && !m_server)
 140   {
 141     m_error = GSOCK_INVSOCK;
 142     return GSOCK_INVSOCK;
 143   }
 144
 145   /* check address */
 146   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 147   {
 148     m_error = GSOCK_INVADDR;
 149     return GSOCK_INVADDR;
 150   }
 151
 152   if (m_local)
 153     GAddress_destroy(m_local);
 154
 155   m_local = GAddress_copy(address);
 156
 157   return GSOCK_NOERROR;
 158 }
 159
 160 GSocketError GSocket::SetPeer(GAddress *address)
 161 {
 162   /* check address */
 163   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 164   {
 165     m_error = GSOCK_INVADDR;
 166     return GSOCK_INVADDR;
 167   }
 168
 169   if (m_peer)
 170     GAddress_destroy(m_peer);
 171
 172   m_peer = GAddress_copy(address);
 173
 174   return GSOCK_NOERROR;
 175 }
 176
 177 GAddress *GSocket::GetLocal()
 178 {
 179   GAddress *address;
 180   wxSockAddr addr;
 181   WX_SOCKLEN_T size = sizeof(addr);
 182   GSocketError err;
 183
 184   /* try to get it from the m_local var first */
 185   if (m_local)
 186     return GAddress_copy(m_local);
 187
 188   /* else, if the socket is initialized, try getsockname */
 189   if (m_fd == INVALID_SOCKET)
 190   {
 191     m_error = GSOCK_INVSOCK;
 192     return NULL;
 193   }
 194
 195   if (getsockname(m_fd, (sockaddr*)&addr, &size) == SOCKET_ERROR)
 196   {
 197     m_error = GSOCK_IOERR;
 198     return NULL;
 199   }
 200
 201   /* got a valid address from getsockname, create a GAddress object */
 202   if ((address = GAddress_new()) == NULL)
 203   {
 204      m_error = GSOCK_MEMERR;
 205      return NULL;
 206   }
 207
 208   if ((err = _GAddress_translate_from(address, (sockaddr*)&addr, size)) != GSOCK_NOERROR)
 209   {
 210      GAddress_destroy(address);
 211      m_error = err;
 212      return NULL;
 213   }
 214
 215   return address;
 216 }
 217
 218 GAddress *GSocket::GetPeer()
 219 {
 220   /* try to get it from the m_peer var */
 221   if (m_peer)
 222     return GAddress_copy(m_peer);
 223
 224   return NULL;
 225 }
 226
 227 /* Server specific parts */
 228
 229 /* GSocket_SetServer:
 230  *  Sets up this socket as a server. The local address must have been
 231  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
 232  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
 233  *
 234  *  Error codes:
 235  *    GSOCK_INVSOCK - the socket is in use.
 236  *    GSOCK_INVADDR - the local address has not been set.
 237  *    GSOCK_IOERR   - low-level error.
 238  */
 239 GSocketError GSocket::SetServer()
 240 {
 241   u_long arg = 1;
 242
 243   /* must not be in use */
 244   if (m_fd != INVALID_SOCKET)
 245   {
 246     m_error = GSOCK_INVSOCK;
 247     return GSOCK_INVSOCK;
 248   }
 249
 250   /* the local addr must have been set */
 251   if (!m_local)
 252   {
 253     m_error = GSOCK_INVADDR;
 254     return GSOCK_INVADDR;
 255   }
 256
 257   /* Initialize all fields */
 258   m_server   = true;
 259   m_stream   = true;
 260
 261   /* Create the socket */
 262   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 263
 264   if (m_fd == INVALID_SOCKET)
 265   {
 266     m_error = GSOCK_IOERR;
 267     return GSOCK_IOERR;
 268   }
 269
 270   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
 271   GSocketManager::Get()->Enable_Events(this);
 272
 273   /* allow a socket to re-bind if the socket is in the TIME_WAIT
 274      state after being previously closed.
 275    */
 276   if (m_reusable)
 277   {
 278     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
 279   }
 280
 281   /* Bind to the local address,
 282    * retrieve the actual address bound,
 283    * and listen up to 5 connections.
 284    */
 285   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 286       (getsockname(m_fd,
 287                    m_local->m_addr,
 288                    (WX_SOCKLEN_T *)&m_local->m_len) != 0) ||
 289       (listen(m_fd, 5) != 0))
 290   {
 291     Close();
 292     m_error = GSOCK_IOERR;
 293     return GSOCK_IOERR;
 294   }
 295
 296   return GSOCK_NOERROR;
 297 }
 298
 299 /* GSocket_WaitConnection:
 300  *  Waits for an incoming client connection. Returns a pointer to
 301  *  a GSocket object, or NULL if there was an error, in which case
 302  *  the last error field will be updated for the calling GSocket.
 303  *
 304  *  Error codes (set in the calling GSocket)
 305  *    GSOCK_INVSOCK    - the socket is not valid or not a server.
 306  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
 307  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
 308  *    GSOCK_MEMERR     - couldn't allocate memory.
 309  *    GSOCK_IOERR      - low-level error.
 310  */
 311 GSocket *GSocket::WaitConnection(wxSocketBase& wxsocket)
 312 {
 313   GSocket *connection;
 314   wxSockAddr from;
 315   WX_SOCKLEN_T fromlen = sizeof(from);
 316   GSocketError err;
 317   u_long arg = 1;
 318
 319   /* Reenable CONNECTION events */
 320   m_detected &= ~GSOCK_CONNECTION_FLAG;
 321
 322   /* If the socket has already been created, we exit immediately */
 323   if (m_fd == INVALID_SOCKET || !m_server)
 324   {
 325     m_error = GSOCK_INVSOCK;
 326     return NULL;
 327   }
 328
 329   /* Create a GSocket object for the new connection */
 330   connection = GSocket::Create(wxsocket);
 331
 332   if (!connection)
 333   {
 334     m_error = GSOCK_MEMERR;
 335     return NULL;
 336   }
 337
 338   /* Wait for a connection (with timeout) */
 339   if (Input_Timeout() == GSOCK_TIMEDOUT)
 340   {
 341     delete connection;
 342     /* m_error set by _GSocket_Input_Timeout */
 343     return NULL;
 344   }
 345
 346   connection->m_fd = accept(m_fd, (sockaddr*)&from, &fromlen);
 347
 348   if (connection->m_fd == INVALID_SOCKET)
 349   {
 350     if (WSAGetLastError() == WSAEWOULDBLOCK)
 351       m_error = GSOCK_WOULDBLOCK;
 352     else
 353       m_error = GSOCK_IOERR;
 354
 355     delete connection;
 356     return NULL;
 357   }
 358
 359   /* Initialize all fields */
 360   connection->m_server   = false;
 361   connection->m_stream   = true;
 362
 363   /* Setup the peer address field */
 364   connection->m_peer = GAddress_new();
 365   if (!connection->m_peer)
 366   {
 367     delete connection;
 368     m_error = GSOCK_MEMERR;
 369     return NULL;
 370   }
 371   err = _GAddress_translate_from(connection->m_peer, (sockaddr*)&from, fromlen);
 372   if (err != GSOCK_NOERROR)
 373   {
 374     GAddress_destroy(connection->m_peer);
 375     delete connection;
 376     m_error = err;
 377     return NULL;
 378   }
 379
 380   ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg);
 381   GSocketManager::Get()->Enable_Events(connection);
 382
 383   return connection;
 384 }
 385
 386 /* GSocket_SetReusable:
 387 *  Simply sets the m_resuable flag on the socket. GSocket_SetServer will
 388 *  make the appropriate setsockopt() call.
 389 *  Implemented as a GSocket function because clients (ie, wxSocketServer)
 390 *  don't have access to the GSocket struct information.
 391 *  Returns true if the flag was set correctly, false if an error occurred
 392 *  (ie, if the parameter was NULL)
 393 */
 394 bool GSocket::SetReusable()
 395 {
 396     /* socket must not be null, and must not be in use/already bound */
 397     if (this && m_fd == INVALID_SOCKET) {
 398         m_reusable = true;
 399         return true;
 400     }
 401     return false;
 402 }
 403
 404 /* GSocket_SetBroadcast:
 405 *  Simply sets the m_broadcast flag on the socket. GSocket_SetServer will
 406 *  make the appropriate setsockopt() call.
 407 *  Implemented as a GSocket function because clients (ie, wxSocketServer)
 408 *  don't have access to the GSocket struct information.
 409 *  Returns true if the flag was set correctly, false if an error occurred
 410 *  (ie, if the parameter was NULL)
 411 */
 412 bool GSocket::SetBroadcast()
 413 {
 414     /* socket must not be in use/already bound */
 415     if (m_fd == INVALID_SOCKET) {
 416         m_broadcast = true;
 417         return true;
 418     }
 419     return false;
 420 }
 421
 422 bool GSocket::DontDoBind()
 423 {
 424     /* socket must not be in use/already bound */
 425     if (m_fd == INVALID_SOCKET) {
 426         m_dobind = false;
 427         return true;
 428     }
 429     return false;
 430 }
 431
 432 /* Client specific parts */
 433
 434 /* GSocket_Connect:
 435  *  For stream (connection oriented) sockets, GSocket_Connect() tries
 436  *  to establish a client connection to a server using the peer address
 437  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
 438  *  connection has been successfully established, or one of the error
 439  *  codes listed below. Note that for nonblocking sockets, a return
 440  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
 441  *  request can be completed later; you should use GSocket_Select()
 442  *  to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
 443  *  corresponding asynchronous events.
 444  *
 445  *  For datagram (non connection oriented) sockets, GSocket_Connect()
 446  *  just sets the peer address established with GSocket_SetPeer() as
 447  *  default destination.
 448  *
 449  *  Error codes:
 450  *    GSOCK_INVSOCK    - the socket is in use or not valid.
 451  *    GSOCK_INVADDR    - the peer address has not been established.
 452  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
 453  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
 454  *    GSOCK_MEMERR     - couldn't allocate memory.
 455  *    GSOCK_IOERR      - low-level error.
 456  */
 457 GSocketError GSocket::Connect(GSocketStream stream)
 458 {
 459   int ret, err;
 460   u_long arg = 1;
 461
 462   /* Enable CONNECTION events (needed for nonblocking connections) */
 463   m_detected &= ~GSOCK_CONNECTION_FLAG;
 464
 465   if (m_fd != INVALID_SOCKET)
 466   {
 467     m_error = GSOCK_INVSOCK;
 468     return GSOCK_INVSOCK;
 469   }
 470
 471   if (!m_peer)
 472   {
 473     m_error = GSOCK_INVADDR;
 474     return GSOCK_INVADDR;
 475   }
 476
 477   /* Streamed or dgram socket? */
 478   m_stream   = (stream == GSOCK_STREAMED);
 479   m_server   = false;
 480   m_establishing = false;
 481
 482   /* Create the socket */
 483   m_fd = socket(m_peer->m_realfamily,
 484                      m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
 485
 486   if (m_fd == INVALID_SOCKET)
 487   {
 488     m_error = GSOCK_IOERR;
 489     return GSOCK_IOERR;
 490   }
 491
 492   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
 493   GSocketManager::Get()->Enable_Events(this);
 494
 495   // If the reuse flag is set, use the applicable socket reuse flag
 496   if (m_reusable)
 497   {
 498      setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
 499   }
 500
 501   if (m_initialRecvBufferSize >= 0)
 502     setsockopt(m_fd, SOL_SOCKET, SO_RCVBUF, (const char*)&m_initialRecvBufferSize, sizeof(m_initialRecvBufferSize));
 503   if (m_initialSendBufferSize >= 0)
 504     setsockopt(m_fd, SOL_SOCKET, SO_SNDBUF, (const char*)&m_initialSendBufferSize, sizeof(m_initialSendBufferSize));
 505
 506   // If a local address has been set, then we need to bind to it before calling connect
 507   if (m_local && m_local->m_addr)
 508   {
 509     bind(m_fd, m_local->m_addr, m_local->m_len);
 510   }
 511
 512   /* Connect it to the peer address, with a timeout (see below) */
 513   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
 514
 515   if (ret == SOCKET_ERROR)
 516   {
 517     err = WSAGetLastError();
 518
 519     /* If connect failed with EWOULDBLOCK and the GSocket object
 520      * is in blocking mode, we select() for the specified timeout
 521      * checking for writability to see if the connection request
 522      * completes.
 523      */
 524     if ((err == WSAEWOULDBLOCK) && (!m_non_blocking))
 525     {
 526       err = Connect_Timeout();
 527
 528       if (err != GSOCK_NOERROR)
 529       {
 530         Close();
 531         /* m_error is set in _GSocket_Connect_Timeout */
 532       }
 533
 534       return (GSocketError) err;
 535     }
 536
 537     /* If connect failed with EWOULDBLOCK and the GSocket object
 538      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
 539      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
 540      * this way if the connection completes, a GSOCK_CONNECTION
 541      * event will be generated, if enabled.
 542      */
 543     if ((err == WSAEWOULDBLOCK) && (m_non_blocking))
 544     {
 545       m_establishing = true;
 546       m_error = GSOCK_WOULDBLOCK;
 547       return GSOCK_WOULDBLOCK;
 548     }
 549
 550     /* If connect failed with an error other than EWOULDBLOCK,
 551      * then the call to GSocket_Connect() has failed.
 552      */
 553     Close();
 554     m_error = GSOCK_IOERR;
 555     return GSOCK_IOERR;
 556   }
 557
 558   return GSOCK_NOERROR;
 559 }
 560
 561 /* Datagram sockets */
 562
 563 /* GSocket_SetNonOriented:
 564  *  Sets up this socket as a non-connection oriented (datagram) socket.
 565  *  Before using this function, the local address must have been set
 566  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
 567  *  on success, or one of the following otherwise.
 568  *
 569  *  Error codes:
 570  *    GSOCK_INVSOCK - the socket is in use.
 571  *    GSOCK_INVADDR - the local address has not been set.
 572  *    GSOCK_IOERR   - low-level error.
 573  */
 574 GSocketError GSocket::SetNonOriented()
 575 {
 576   u_long arg = 1;
 577
 578   if (m_fd != INVALID_SOCKET)
 579   {
 580     m_error = GSOCK_INVSOCK;
 581     return GSOCK_INVSOCK;
 582   }
 583
 584   if (!m_local)
 585   {
 586     m_error = GSOCK_INVADDR;
 587     return GSOCK_INVADDR;
 588   }
 589
 590   /* Initialize all fields */
 591   m_stream   = false;
 592   m_server   = false;
 593
 594   /* Create the socket */
 595   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
 596
 597   if (m_fd == INVALID_SOCKET)
 598   {
 599     m_error = GSOCK_IOERR;
 600     return GSOCK_IOERR;
 601   }
 602
 603   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
 604   GSocketManager::Get()->Enable_Events(this);
 605
 606   if (m_reusable)
 607   {
 608     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
 609   }
 610   if (m_broadcast)
 611   {
 612     setsockopt(m_fd, SOL_SOCKET, SO_BROADCAST, (const char*)&arg, sizeof(arg));
 613   }
 614   if (m_dobind)
 615   {
 616     /* Bind to the local address,
 617      * and retrieve the actual address bound.
 618      */
 619     if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 620         (getsockname(m_fd,
 621                      m_local->m_addr,
 622                      (WX_SOCKLEN_T *)&m_local->m_len) != 0))
 623     {
 624       Close();
 625       m_error = GSOCK_IOERR;
 626       return GSOCK_IOERR;
 627     }
 628   }
 629
 630   return GSOCK_NOERROR;
 631 }
 632
 633 /* Generic IO */
 634
 635 /* Like recv(), send(), ... */
 636 int GSocket::Read(char *buffer, int size)
 637 {
 638   int ret;
 639
 640   /* Reenable INPUT events */
 641   m_detected &= ~GSOCK_INPUT_FLAG;
 642
 643   if (m_fd == INVALID_SOCKET || m_server)
 644   {
 645     m_error = GSOCK_INVSOCK;
 646     return -1;
 647   }
 648
 649   /* If the socket is blocking, wait for data (with a timeout) */
 650   if (Input_Timeout() == GSOCK_TIMEDOUT)
 651   {
 652     m_error = GSOCK_TIMEDOUT;
 653     return -1;
 654   }
 655
 656   /* Read the data */
 657   if (m_stream)
 658     ret = Recv_Stream(buffer, size);
 659   else
 660     ret = Recv_Dgram(buffer, size);
 661
 662   if (ret == SOCKET_ERROR)
 663   {
 664     if (WSAGetLastError() != WSAEWOULDBLOCK)
 665       m_error = GSOCK_IOERR;
 666     else
 667       m_error = GSOCK_WOULDBLOCK;
 668     return -1;
 669   }
 670
 671   return ret;
 672 }
 673
 674 int GSocket::Write(const char *buffer, int size)
 675 {
 676   int ret;
 677
 678   if (m_fd == INVALID_SOCKET || m_server)
 679   {
 680     m_error = GSOCK_INVSOCK;
 681     return -1;
 682   }
 683
 684   /* If the socket is blocking, wait for writability (with a timeout) */
 685   if (Output_Timeout() == GSOCK_TIMEDOUT)
 686     return -1;
 687
 688   /* Write the data */
 689   if (m_stream)
 690     ret = Send_Stream(buffer, size);
 691   else
 692     ret = Send_Dgram(buffer, size);
 693
 694   if (ret == SOCKET_ERROR)
 695   {
 696     if (WSAGetLastError() != WSAEWOULDBLOCK)
 697       m_error = GSOCK_IOERR;
 698     else
 699       m_error = GSOCK_WOULDBLOCK;
 700
 701     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
 702      * does). Once the first OUTPUT event is received, users can assume
 703      * that the socket is writable until a read operation fails. Only then
 704      * will further OUTPUT events be posted.
 705      */
 706     m_detected &= ~GSOCK_OUTPUT_FLAG;
 707     return -1;
 708   }
 709
 710   return ret;
 711 }
 712
 713 /* Attributes */
 714
 715 /* GSocket_SetNonBlocking:
 716  *  Sets the socket to non-blocking mode. All IO calls will return
 717  *  immediately.
 718  */
 719 void GSocket::SetNonBlocking(bool non_block)
 720 {
 721   m_non_blocking = non_block;
 722 }
 723
 724 /* GSocket_GetError:
 725  *  Returns the last error occurred for this socket. Note that successful
 726  *  operations do not clear this back to GSOCK_NOERROR, so use it only
 727  *  after an error.
 728  */
 729 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
 730 {
 731   return m_error;
 732 }
 733
 734 GSocketError GSocket::GetSockOpt(int level, int optname,
 735                                 void *optval, int *optlen)
 736 {
 737     if (getsockopt(m_fd, level, optname, (char*)optval, optlen) == 0)
 738     {
 739         return GSOCK_NOERROR;
 740     }
 741     return GSOCK_OPTERR;
 742 }
 743
 744 GSocketError GSocket::SetSockOpt(int level, int optname,
 745                                 const void *optval, int optlen)
 746 {
 747     if (setsockopt(m_fd, level, optname, (char*)optval, optlen) == 0)
 748     {
 749         return GSOCK_NOERROR;
 750     }
 751     return GSOCK_OPTERR;
 752 }
 753
 754 /* Internals (IO) */
 755
 756 /* _GSocket_Input_Timeout:
 757  *  For blocking sockets, wait until data is available or
 758  *  until timeout ellapses.
 759  */
 760 GSocketError GSocket::Input_Timeout()
 761 {
 762   fd_set readfds;
 763
 764   if (!m_non_blocking)
 765   {
 766     FD_ZERO(&readfds);
 767     FD_SET(m_fd, &readfds);
 768     if (select(0, &readfds, NULL, NULL, &m_timeout) == 0)
 769     {
 770       m_error = GSOCK_TIMEDOUT;
 771       return GSOCK_TIMEDOUT;
 772     }
 773   }
 774   return GSOCK_NOERROR;
 775 }
 776
 777 /* _GSocket_Output_Timeout:
 778  *  For blocking sockets, wait until data can be sent without
 779  *  blocking or until timeout ellapses.
 780  */
 781 GSocketError GSocket::Output_Timeout()
 782 {
 783   fd_set writefds;
 784
 785   if (!m_non_blocking)
 786   {
 787     FD_ZERO(&writefds);
 788     FD_SET(m_fd, &writefds);
 789     if (select(0, NULL, &writefds, NULL, &m_timeout) == 0)
 790     {
 791       m_error = GSOCK_TIMEDOUT;
 792       return GSOCK_TIMEDOUT;
 793     }
 794   }
 795   return GSOCK_NOERROR;
 796 }
 797
 798 /* _GSocket_Connect_Timeout:
 799  *  For blocking sockets, wait until the connection is
 800  *  established or fails, or until timeout ellapses.
 801  */
 802 GSocketError GSocket::Connect_Timeout()
 803 {
 804   fd_set writefds;
 805   fd_set exceptfds;
 806
 807   FD_ZERO(&writefds);
 808   FD_ZERO(&exceptfds);
 809   FD_SET(m_fd, &writefds);
 810   FD_SET(m_fd, &exceptfds);
 811   if (select(0, NULL, &writefds, &exceptfds, &m_timeout) == 0)
 812   {
 813     m_error = GSOCK_TIMEDOUT;
 814     return GSOCK_TIMEDOUT;
 815   }
 816   if (!FD_ISSET(m_fd, &writefds))
 817   {
 818     m_error = GSOCK_IOERR;
 819     return GSOCK_IOERR;
 820   }
 821
 822   return GSOCK_NOERROR;
 823 }
 824
 825 int GSocket::Recv_Stream(char *buffer, int size)
 826 {
 827   return recv(m_fd, buffer, size, 0);
 828 }
 829
 830 int GSocket::Recv_Dgram(char *buffer, int size)
 831 {
 832   wxSockAddr from;
 833   WX_SOCKLEN_T fromlen = sizeof(from);
 834   int ret;
 835   GSocketError err;
 836
 837   ret = recvfrom(m_fd, buffer, size, 0, (sockaddr*)&from, &fromlen);
 838
 839   if (ret == SOCKET_ERROR)
 840     return SOCKET_ERROR;
 841
 842   /* Translate a system address into a GSocket address */
 843   if (!m_peer)
 844   {
 845     m_peer = GAddress_new();
 846     if (!m_peer)
 847     {
 848       m_error = GSOCK_MEMERR;
 849       return -1;
 850     }
 851   }
 852   err = _GAddress_translate_from(m_peer, (sockaddr*)&from, fromlen);
 853   if (err != GSOCK_NOERROR)
 854   {
 855     GAddress_destroy(m_peer);
 856     m_peer  = NULL;
 857     m_error = err;
 858     return -1;
 859   }
 860
 861   return ret;
 862 }
 863
 864 int GSocket::Send_Stream(const char *buffer, int size)
 865 {
 866   return send(m_fd, buffer, size, 0);
 867 }
 868
 869 int GSocket::Send_Dgram(const char *buffer, int size)
 870 {
 871   struct sockaddr *addr;
 872   int len, ret;
 873   GSocketError err;
 874
 875   if (!m_peer)
 876   {
 877     m_error = GSOCK_INVADDR;
 878     return -1;
 879   }
 880
 881   err = _GAddress_translate_to(m_peer, &addr, &len);
 882   if (err != GSOCK_NOERROR)
 883   {
 884     m_error = err;
 885     return -1;
 886   }
 887
 888   ret = sendto(m_fd, buffer, size, 0, addr, len);
 889
 890   /* Frees memory allocated by _GAddress_translate_to */
 891   free(addr);
 892
 893   return ret;
 894 }
 895
 896 /*
 897  * -------------------------------------------------------------------------
 898  * GAddress
 899  * -------------------------------------------------------------------------
 900  */
 901
 902 /* CHECK_ADDRESS verifies that the current address family is either
 903  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
 904  * initalizes it to be a GSOCK_*family*. In other cases, it returns
 905  * an appropiate error code.
 906  *
 907  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
 908  */
 909 #define CHECK_ADDRESS(address, family)                              \
 910 {                                                                   \
 911   if (address->m_family == GSOCK_NOFAMILY)                          \
 912     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
 913       return address->m_error;                                      \
 914   if (address->m_family != GSOCK_##family)                          \
 915   {                                                                 \
 916     address->m_error = GSOCK_INVADDR;                               \
 917     return GSOCK_INVADDR;                                           \
 918   }                                                                 \
 919 }
 920
 921 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
 922 {                                                                   \
 923   if (address->m_family == GSOCK_NOFAMILY)                          \
 924     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
 925       return retval;                                                \
 926   if (address->m_family != GSOCK_##family)                          \
 927   {                                                                 \
 928     address->m_error = GSOCK_INVADDR;                               \
 929     return retval;                                                  \
 930   }                                                                 \
 931 }
 932
 933
 934 GAddress *GAddress_new()
 935 {
 936   GAddress *address;
 937
 938   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
 939     return NULL;
 940
 941   address->m_family = GSOCK_NOFAMILY;
 942   address->m_addr   = NULL;
 943   address->m_len    = 0;
 944
 945   return address;
 946 }
 947
 948 GAddress *GAddress_copy(GAddress *address)
 949 {
 950   GAddress *addr2;
 951
 952   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
 953     return NULL;
 954
 955   memcpy(addr2, address, sizeof(GAddress));
 956
 957   if (address->m_addr)
 958   {
 959     addr2->m_addr = (struct sockaddr *) malloc(addr2->m_len);
 960     if (addr2->m_addr == NULL)
 961     {
 962       free(addr2);
 963       return NULL;
 964     }
 965     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
 966   }
 967
 968   return addr2;
 969 }
 970
 971 void GAddress_destroy(GAddress *address)
 972 {
 973   if (address->m_addr)
 974     free(address->m_addr);
 975
 976   free(address);
 977 }
 978
 979 void GAddress_SetFamily(GAddress *address, GAddressType type)
 980 {
 981   address->m_family = type;
 982 }
 983
 984 GAddressType GAddress_GetFamily(GAddress *address)
 985 {
 986   return address->m_family;
 987 }
 988
 989 GSocketError _GAddress_translate_from(GAddress *address,
 990                                       struct sockaddr *addr, int len)
 991 {
 992   address->m_realfamily = addr->sa_family;
 993   switch (addr->sa_family)
 994   {
 995     case AF_INET:
 996       address->m_family = GSOCK_INET;
 997       break;
 998     case AF_UNIX:
 999       address->m_family = GSOCK_UNIX;
1000       break;
1001 #if wxUSE_IPV6
1002     case AF_INET6:
1003       address->m_family = GSOCK_INET6;
1004       break;
1005 #endif
1006     default:
1007     {
1008       address->m_error = GSOCK_INVOP;
1009       return GSOCK_INVOP;
1010     }
1011   }
1012
1013   if (address->m_addr)
1014     free(address->m_addr);
1015
1016   address->m_len = len;
1017   address->m_addr = (struct sockaddr *) malloc(len);
1018
1019   if (address->m_addr == NULL)
1020   {
1021     address->m_error = GSOCK_MEMERR;
1022     return GSOCK_MEMERR;
1023   }
1024   memcpy(address->m_addr, addr, len);
1025
1026   return GSOCK_NOERROR;
1027 }
1028
1029 GSocketError _GAddress_translate_to(GAddress *address,
1030                                     struct sockaddr **addr, int *len)
1031 {
1032   if (!address->m_addr)
1033   {
1034     address->m_error = GSOCK_INVADDR;
1035     return GSOCK_INVADDR;
1036   }
1037
1038   *len = address->m_len;
1039   *addr = (struct sockaddr *) malloc(address->m_len);
1040   if (*addr == NULL)
1041   {
1042     address->m_error = GSOCK_MEMERR;
1043     return GSOCK_MEMERR;
1044   }
1045
1046   memcpy(*addr, address->m_addr, address->m_len);
1047   return GSOCK_NOERROR;
1048 }
1049
1050 /*
1051  * -------------------------------------------------------------------------
1052  * Internet address family
1053  * -------------------------------------------------------------------------
1054  */
1055
1056 GSocketError _GAddress_Init_INET(GAddress *address)
1057 {
1058   address->m_len  = sizeof(struct sockaddr_in);
1059   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1060   if (address->m_addr == NULL)
1061   {
1062     address->m_error = GSOCK_MEMERR;
1063     return GSOCK_MEMERR;
1064   }
1065
1066   address->m_family = GSOCK_INET;
1067   address->m_realfamily = AF_INET;
1068   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1069   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1070
1071   return GSOCK_NOERROR;
1072 }
1073
1074 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1075 {
1076   struct hostent *he;
1077   struct in_addr *addr;
1078
1079   CHECK_ADDRESS(address, INET);
1080
1081   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1082
1083   addr->s_addr = inet_addr(hostname);
1084
1085   /* If it is a numeric host name, convert it now */
1086   if (addr->s_addr == INADDR_NONE)
1087   {
1088     struct in_addr *array_addr;
1089
1090     /* It is a real name, we solve it */
1091     if ((he = gethostbyname(hostname)) == NULL)
1092     {
1093       /* addr->s_addr = INADDR_NONE just done by inet_addr() above */
1094       address->m_error = GSOCK_NOHOST;
1095       return GSOCK_NOHOST;
1096     }
1097     array_addr = (struct in_addr *) *(he->h_addr_list);
1098     addr->s_addr = array_addr[0].s_addr;
1099   }
1100   return GSOCK_NOERROR;
1101 }
1102
1103 GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
1104 {
1105   return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
1106 }
1107
1108 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1109 {
1110   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1111 }
1112
1113 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1114                                           unsigned long hostaddr)
1115 {
1116   struct in_addr *addr;
1117
1118   CHECK_ADDRESS(address, INET);
1119
1120   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1121   addr->s_addr = htonl(hostaddr);
1122
1123   return GSOCK_NOERROR;
1124 }
1125
1126 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1127                                        const char *protocol)
1128 {
1129   struct servent *se;
1130   struct sockaddr_in *addr;
1131
1132   CHECK_ADDRESS(address, INET);
1133
1134   if (!port)
1135   {
1136     address->m_error = GSOCK_INVPORT;
1137     return GSOCK_INVPORT;
1138   }
1139
1140   se = getservbyname(port, protocol);
1141   if (!se)
1142   {
1143     if (isdigit(port[0]))
1144     {
1145       int port_int;
1146
1147       port_int = atoi(port);
1148       addr = (struct sockaddr_in *)address->m_addr;
1149       addr->sin_port = htons((u_short) port_int);
1150       return GSOCK_NOERROR;
1151     }
1152
1153     address->m_error = GSOCK_INVPORT;
1154     return GSOCK_INVPORT;
1155   }
1156
1157   addr = (struct sockaddr_in *)address->m_addr;
1158   addr->sin_port = se->s_port;
1159
1160   return GSOCK_NOERROR;
1161 }
1162
1163 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1164 {
1165   struct sockaddr_in *addr;
1166
1167   CHECK_ADDRESS(address, INET);
1168
1169   addr = (struct sockaddr_in *)address->m_addr;
1170   addr->sin_port = htons(port);
1171
1172   return GSOCK_NOERROR;
1173 }
1174
1175 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1176 {
1177   struct hostent *he;
1178   char *addr_buf;
1179   struct sockaddr_in *addr;
1180
1181   CHECK_ADDRESS(address, INET);
1182
1183   addr = (struct sockaddr_in *)address->m_addr;
1184   addr_buf = (char *)&(addr->sin_addr);
1185
1186   he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1187   if (he == NULL)
1188   {
1189     address->m_error = GSOCK_NOHOST;
1190     return GSOCK_NOHOST;
1191   }
1192
1193   strncpy(hostname, he->h_name, sbuf);
1194
1195   return GSOCK_NOERROR;
1196 }
1197
1198 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1199 {
1200   struct sockaddr_in *addr;
1201
1202   CHECK_ADDRESS_RETVAL(address, INET, 0);
1203
1204   addr = (struct sockaddr_in *)address->m_addr;
1205
1206   return ntohl(addr->sin_addr.s_addr);
1207 }
1208
1209 unsigned short GAddress_INET_GetPort(GAddress *address)
1210 {
1211   struct sockaddr_in *addr;
1212
1213   CHECK_ADDRESS_RETVAL(address, INET, 0);
1214
1215   addr = (struct sockaddr_in *)address->m_addr;
1216   return ntohs(addr->sin_port);
1217 }
1218
1219
1220 #if wxUSE_IPV6
1221 /*
1222  * -------------------------------------------------------------------------
1223  * Internet IPv6 address family
1224  * -------------------------------------------------------------------------
1225  */
1226 #include "ws2tcpip.h"
1227
1228 #ifdef __VISUALC__
1229     #pragma comment(lib,"ws2_32")
1230 #endif // __VISUALC__
1231
1232 GSocketError _GAddress_Init_INET6(GAddress *address)
1233 {
1234   struct in6_addr any_address = IN6ADDR_ANY_INIT;
1235   address->m_len  = sizeof(struct sockaddr_in6);
1236   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1237   if (address->m_addr == NULL)
1238   {
1239     address->m_error = GSOCK_MEMERR;
1240     return GSOCK_MEMERR;
1241   }
1242   memset(address->m_addr,0,address->m_len);
1243
1244   address->m_family = GSOCK_INET6;
1245   address->m_realfamily = AF_INET6;
1246   ((struct sockaddr_in6 *)address->m_addr)->sin6_family = AF_INET6;
1247   ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = any_address;
1248
1249   return GSOCK_NOERROR;
1250 }
1251
1252 GSocketError GAddress_INET6_SetHostName(GAddress *address, const char *hostname)
1253 {
1254   CHECK_ADDRESS(address, INET6);
1255
1256   addrinfo hints;
1257   memset( & hints, 0, sizeof( hints ) );
1258   hints.ai_family = AF_INET6;
1259   addrinfo * info = 0;
1260   if ( getaddrinfo( hostname, "0", & hints, & info ) || ! info )
1261   {
1262     address->m_error = GSOCK_NOHOST;
1263     return GSOCK_NOHOST;
1264   }
1265
1266   memcpy( address->m_addr, info->ai_addr, info->ai_addrlen );
1267   freeaddrinfo( info );
1268   return GSOCK_NOERROR;
1269 }
1270
1271 GSocketError GAddress_INET6_SetAnyAddress(GAddress *address)
1272 {
1273   CHECK_ADDRESS(address, INET6);
1274
1275   struct in6_addr addr;
1276   memset( & addr, 0, sizeof( addr ) );
1277   return GAddress_INET6_SetHostAddress(address, addr);
1278 }
1279 GSocketError GAddress_INET6_SetHostAddress(GAddress *address,
1280                                           struct in6_addr hostaddr)
1281 {
1282   CHECK_ADDRESS(address, INET6);
1283
1284   ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = hostaddr;
1285
1286   return GSOCK_NOERROR;
1287 }
1288
1289 GSocketError GAddress_INET6_SetPortName(GAddress *address, const char *port,
1290                                        const char *protocol)
1291 {
1292   struct servent *se;
1293   struct sockaddr_in6 *addr;
1294
1295   CHECK_ADDRESS(address, INET6);
1296
1297   if (!port)
1298   {
1299     address->m_error = GSOCK_INVPORT;
1300     return GSOCK_INVPORT;
1301   }
1302
1303   se = getservbyname(port, protocol);
1304   if (!se)
1305   {
1306     if (isdigit((unsigned char) port[0]))
1307     {
1308       int port_int;
1309
1310       port_int = atoi(port);
1311       addr = (struct sockaddr_in6 *)address->m_addr;
1312       addr->sin6_port = htons((u_short) port_int);
1313       return GSOCK_NOERROR;
1314     }
1315
1316     address->m_error = GSOCK_INVPORT;
1317     return GSOCK_INVPORT;
1318   }
1319
1320   addr = (struct sockaddr_in6 *)address->m_addr;
1321   addr->sin6_port = se->s_port;
1322
1323   return GSOCK_NOERROR;
1324 }
1325
1326 GSocketError GAddress_INET6_SetPort(GAddress *address, unsigned short port)
1327 {
1328   struct sockaddr_in6 *addr;
1329
1330   CHECK_ADDRESS(address, INET6);
1331
1332   addr = (struct sockaddr_in6 *)address->m_addr;
1333   addr->sin6_port = htons(port);
1334
1335   return GSOCK_NOERROR;
1336 }
1337
1338 GSocketError GAddress_INET6_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1339 {
1340   struct hostent *he;
1341   char *addr_buf;
1342   struct sockaddr_in6 *addr;
1343
1344   CHECK_ADDRESS(address, INET6);
1345
1346   addr = (struct sockaddr_in6 *)address->m_addr;
1347   addr_buf = (char *)&(addr->sin6_addr);
1348
1349   he = gethostbyaddr(addr_buf, sizeof(addr->sin6_addr), AF_INET6);
1350   if (he == NULL)
1351   {
1352     address->m_error = GSOCK_NOHOST;
1353     return GSOCK_NOHOST;
1354   }
1355
1356   strncpy(hostname, he->h_name, sbuf);
1357
1358   return GSOCK_NOERROR;
1359 }
1360
1361 GSocketError GAddress_INET6_GetHostAddress(GAddress *address,struct in6_addr *hostaddr)
1362 {
1363   CHECK_ADDRESS_RETVAL(address, INET6, GSOCK_INVADDR);
1364   *hostaddr = ( (struct sockaddr_in6 *)address->m_addr )->sin6_addr;
1365   return GSOCK_NOERROR;
1366 }
1367
1368 unsigned short GAddress_INET6_GetPort(GAddress *address)
1369 {
1370   CHECK_ADDRESS_RETVAL(address, INET6, 0);
1371
1372   return ntohs( ((struct sockaddr_in6 *)address->m_addr)->sin6_port );
1373 }
1374
1375 #endif // wxUSE_IPV6
1376
1377 /*
1378  * -------------------------------------------------------------------------
1379  * Unix address family
1380  * -------------------------------------------------------------------------
1381  */
1382
1383 GSocketError _GAddress_Init_UNIX(GAddress *address)
1384 {
1385   address->m_error = GSOCK_INVADDR;
1386   return GSOCK_INVADDR;
1387 }
1388
1389 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *WXUNUSED(path))
1390 {
1391   address->m_error = GSOCK_INVADDR;
1392   return GSOCK_INVADDR;
1393 }
1394
1395 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *WXUNUSED(path), size_t WXUNUSED(sbuf))
1396 {
1397   address->m_error = GSOCK_INVADDR;
1398   return GSOCK_INVADDR;
1399 }
1400
1401 #endif  // wxUSE_SOCKETS