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 #ifndef __GSOCKET_STANDALONE__
  57 #   include "wx/platform.h"
  58 #endif
  59
  60 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
  61
  62 #ifndef __GSOCKET_STANDALONE__
  63 #  include "wx/msw/gsockmsw.h"
  64 #  include "wx/gsocket.h"
  65 #else
  66 #  include "gsockmsw.h"
  67 #  include "gsocket.h"
  68 #endif /* __GSOCKET_STANDALONE__ */
  69
  70 #ifndef __WXWINCE__
  71 #include <assert.h>
  72 #else
  73 #define assert(x)
  74 #ifndef isdigit
  75 #define isdigit(x) (x > 47 && x < 58)
  76 #endif
  77 #include "wx/msw/wince/net.h"
  78 #endif
  79
  80 #include <string.h>
  81 #include <stdio.h>
  82 #include <stdlib.h>
  83 #include <stddef.h>
  84 #include <ctype.h>
  85
  86 /* if we use configure for MSW WX_SOCKLEN_T will be already defined */
  87 #ifndef WX_SOCKLEN_T
  88 #  define WX_SOCKLEN_T int
  89 #endif
  90
  91 /* Table of GUI-related functions. We must call them indirectly because
  92  * of wxBase and GUI separation: */
  93
  94 static GSocketGUIFunctionsTable *gs_gui_functions;
  95
  96 class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable
  97 {
  98 public:
  99     virtual bool OnInit();
 100     virtual void OnExit();
 101     virtual bool CanUseEventLoop();
 102     virtual bool Init_Socket(GSocket *socket);
 103     virtual void Destroy_Socket(GSocket *socket);
 104     virtual void Enable_Events(GSocket *socket);
 105     virtual void Disable_Events(GSocket *socket);
 106 };
 107
 108 bool GSocketGUIFunctionsTableNull::OnInit()
 109 {   return true; }
 110 void GSocketGUIFunctionsTableNull::OnExit()
 111 {}
 112 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
 113 {   return false; }
 114 bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))
 115 {   return true; }
 116 void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket))
 117 {}
 118 void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket))
 119 {}
 120 void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket))
 121 {}
 122 /* Global initialisers */
 123
 124 void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc)
 125 {
 126   gs_gui_functions = guifunc;
 127 }
 128
 129 int GSocket_Init(void)
 130 {
 131   WSADATA wsaData;
 132
 133   if (!gs_gui_functions)
 134   {
 135     static GSocketGUIFunctionsTableNull table;
 136     gs_gui_functions = &table;
 137   }
 138   if ( !gs_gui_functions->OnInit() )
 139   {
 140     return 0;
 141   }
 142
 143   /* Initialize WinSocket */
 144   return (WSAStartup((1 << 8) | 1, &wsaData) == 0);
 145 }
 146
 147 void GSocket_Cleanup(void)
 148 {
 149   if (gs_gui_functions)
 150   {
 151       gs_gui_functions->OnExit();
 152   }
 153
 154   /* Cleanup WinSocket */
 155   WSACleanup();
 156 }
 157
 158 /* Constructors / Destructors for GSocket */
 159
 160 GSocket::GSocket()
 161 {
 162   int i;
 163
 164   m_fd              = INVALID_SOCKET;
 165   for (i = 0; i < GSOCK_MAX_EVENT; i++)
 166   {
 167     m_cbacks[i]     = NULL;
 168   }
 169   m_detected        = 0;
 170   m_local           = NULL;
 171   m_peer            = NULL;
 172   m_error           = GSOCK_NOERROR;
 173   m_server          = false;
 174   m_stream          = true;
 175   m_non_blocking    = false;
 176   m_timeout.tv_sec  = 10 * 60;  /* 10 minutes */
 177   m_timeout.tv_usec = 0;
 178   m_establishing    = false;
 179   m_reusable        = false;
 180
 181   assert(gs_gui_functions);
 182   /* Per-socket GUI-specific initialization */
 183   m_ok = gs_gui_functions->Init_Socket(this);
 184 }
 185
 186 void GSocket::Close()
 187 {
 188     gs_gui_functions->Disable_Events(this);
 189     closesocket(m_fd);
 190     m_fd = INVALID_SOCKET;
 191 }
 192
 193 GSocket::~GSocket()
 194 {
 195   assert(this);
 196
 197   /* Per-socket GUI-specific cleanup */
 198   gs_gui_functions->Destroy_Socket(this);
 199
 200   /* Check that the socket is really shutdowned */
 201   if (m_fd != INVALID_SOCKET)
 202     Shutdown();
 203
 204   /* Destroy private addresses */
 205   if (m_local)
 206     GAddress_destroy(m_local);
 207
 208   if (m_peer)
 209     GAddress_destroy(m_peer);
 210 }
 211
 212 /* GSocket_Shutdown:
 213  *  Disallow further read/write operations on this socket, close
 214  *  the fd and disable all callbacks.
 215  */
 216 void GSocket::Shutdown()
 217 {
 218   int evt;
 219
 220   assert(this);
 221
 222   /* If socket has been created, shutdown it */
 223   if (m_fd != INVALID_SOCKET)
 224   {
 225     shutdown(m_fd, 2);
 226     Close();
 227   }
 228
 229   /* Disable GUI callbacks */
 230   for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
 231     m_cbacks[evt] = NULL;
 232
 233   m_detected = GSOCK_LOST_FLAG;
 234 }
 235
 236 /* Address handling */
 237
 238 /* GSocket_SetLocal:
 239  * GSocket_GetLocal:
 240  * GSocket_SetPeer:
 241  * GSocket_GetPeer:
 242  *  Set or get the local or peer address for this socket. The 'set'
 243  *  functions return GSOCK_NOERROR on success, an error code otherwise.
 244  *  The 'get' functions return a pointer to a GAddress object on success,
 245  *  or NULL otherwise, in which case they set the error code of the
 246  *  corresponding GSocket.
 247  *
 248  *  Error codes:
 249  *    GSOCK_INVSOCK - the socket is not valid.
 250  *    GSOCK_INVADDR - the address is not valid.
 251  */
 252 GSocketError GSocket::SetLocal(GAddress *address)
 253 {
 254   assert(this);
 255
 256   /* the socket must be initialized, or it must be a server */
 257   if (m_fd != INVALID_SOCKET && !m_server)
 258   {
 259     m_error = GSOCK_INVSOCK;
 260     return GSOCK_INVSOCK;
 261   }
 262
 263   /* check address */
 264   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 265   {
 266     m_error = GSOCK_INVADDR;
 267     return GSOCK_INVADDR;
 268   }
 269
 270   if (m_local)
 271     GAddress_destroy(m_local);
 272
 273   m_local = GAddress_copy(address);
 274
 275   return GSOCK_NOERROR;
 276 }
 277
 278 GSocketError GSocket::SetPeer(GAddress *address)
 279 {
 280   assert(this);
 281
 282   /* check address */
 283   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 284   {
 285     m_error = GSOCK_INVADDR;
 286     return GSOCK_INVADDR;
 287   }
 288
 289   if (m_peer)
 290     GAddress_destroy(m_peer);
 291
 292   m_peer = GAddress_copy(address);
 293
 294   return GSOCK_NOERROR;
 295 }
 296
 297 GAddress *GSocket::GetLocal()
 298 {
 299   GAddress *address;
 300   struct sockaddr addr;
 301   WX_SOCKLEN_T size = sizeof(addr);
 302   GSocketError err;
 303
 304   assert(this);
 305
 306   /* try to get it from the m_local var first */
 307   if (m_local)
 308     return GAddress_copy(m_local);
 309
 310   /* else, if the socket is initialized, try getsockname */
 311   if (m_fd == INVALID_SOCKET)
 312   {
 313     m_error = GSOCK_INVSOCK;
 314     return NULL;
 315   }
 316
 317   if (getsockname(m_fd, &addr, &size) == SOCKET_ERROR)
 318   {
 319     m_error = GSOCK_IOERR;
 320     return NULL;
 321   }
 322
 323   /* got a valid address from getsockname, create a GAddress object */
 324   if ((address = GAddress_new()) == NULL)
 325   {
 326      m_error = GSOCK_MEMERR;
 327      return NULL;
 328   }
 329
 330   if ((err = _GAddress_translate_from(address, &addr, size)) != GSOCK_NOERROR)
 331   {
 332      GAddress_destroy(address);
 333      m_error = err;
 334      return NULL;
 335   }
 336
 337   return address;
 338 }
 339
 340 GAddress *GSocket::GetPeer()
 341 {
 342   assert(this);
 343
 344   /* try to get it from the m_peer var */
 345   if (m_peer)
 346     return GAddress_copy(m_peer);
 347
 348   return NULL;
 349 }
 350
 351 /* Server specific parts */
 352
 353 /* GSocket_SetServer:
 354  *  Sets up this socket as a server. The local address must have been
 355  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
 356  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
 357  *
 358  *  Error codes:
 359  *    GSOCK_INVSOCK - the socket is in use.
 360  *    GSOCK_INVADDR - the local address has not been set.
 361  *    GSOCK_IOERR   - low-level error.
 362  */
 363 GSocketError GSocket::SetServer()
 364 {
 365   u_long arg = 1;
 366
 367   assert(this);
 368
 369   /* must not be in use */
 370   if (m_fd != INVALID_SOCKET)
 371   {
 372     m_error = GSOCK_INVSOCK;
 373     return GSOCK_INVSOCK;
 374   }
 375
 376   /* the local addr must have been set */
 377   if (!m_local)
 378   {
 379     m_error = GSOCK_INVADDR;
 380     return GSOCK_INVADDR;
 381   }
 382
 383   /* Initialize all fields */
 384   m_server   = true;
 385   m_stream   = true;
 386
 387   /* Create the socket */
 388   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 389
 390   if (m_fd == INVALID_SOCKET)
 391   {
 392     m_error = GSOCK_IOERR;
 393     return GSOCK_IOERR;
 394   }
 395
 396   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
 397   gs_gui_functions->Enable_Events(this);
 398
 399   /* allow a socket to re-bind if the socket is in the TIME_WAIT
 400      state after being previously closed.
 401    */
 402   if (m_reusable) {
 403     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
 404   }
 405
 406   /* Bind to the local address,
 407    * retrieve the actual address bound,
 408    * and listen up to 5 connections.
 409    */
 410   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 411       (getsockname(m_fd,
 412                    m_local->m_addr,
 413                    (WX_SOCKLEN_T *)&m_local->m_len) != 0) ||
 414       (listen(m_fd, 5) != 0))
 415   {
 416     Close();
 417     m_error = GSOCK_IOERR;
 418     return GSOCK_IOERR;
 419   }
 420
 421   return GSOCK_NOERROR;
 422 }
 423
 424 /* GSocket_WaitConnection:
 425  *  Waits for an incoming client connection. Returns a pointer to
 426  *  a GSocket object, or NULL if there was an error, in which case
 427  *  the last error field will be updated for the calling GSocket.
 428  *
 429  *  Error codes (set in the calling GSocket)
 430  *    GSOCK_INVSOCK    - the socket is not valid or not a server.
 431  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
 432  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
 433  *    GSOCK_MEMERR     - couldn't allocate memory.
 434  *    GSOCK_IOERR      - low-level error.
 435  */
 436 GSocket *GSocket::WaitConnection()
 437 {
 438   GSocket *connection;
 439   struct sockaddr from;
 440   WX_SOCKLEN_T fromlen = sizeof(from);
 441   GSocketError err;
 442   u_long arg = 1;
 443
 444   assert(this);
 445
 446   /* Reenable CONNECTION events */
 447   m_detected &= ~GSOCK_CONNECTION_FLAG;
 448
 449   /* If the socket has already been created, we exit immediately */
 450   if (m_fd == INVALID_SOCKET || !m_server)
 451   {
 452     m_error = GSOCK_INVSOCK;
 453     return NULL;
 454   }
 455
 456   /* Create a GSocket object for the new connection */
 457   connection = GSocket_new();
 458
 459   if (!connection)
 460   {
 461     m_error = GSOCK_MEMERR;
 462     return NULL;
 463   }
 464
 465   /* Wait for a connection (with timeout) */
 466   if (Input_Timeout() == GSOCK_TIMEDOUT)
 467   {
 468     delete connection;
 469     /* m_error set by _GSocket_Input_Timeout */
 470     return NULL;
 471   }
 472
 473   connection->m_fd = accept(m_fd, &from, &fromlen);
 474
 475   if (connection->m_fd == INVALID_SOCKET)
 476   {
 477     if (WSAGetLastError() == WSAEWOULDBLOCK)
 478       m_error = GSOCK_WOULDBLOCK;
 479     else
 480       m_error = GSOCK_IOERR;
 481
 482     delete connection;
 483     return NULL;
 484   }
 485
 486   /* Initialize all fields */
 487   connection->m_server   = false;
 488   connection->m_stream   = true;
 489
 490   /* Setup the peer address field */
 491   connection->m_peer = GAddress_new();
 492   if (!connection->m_peer)
 493   {
 494     delete connection;
 495     m_error = GSOCK_MEMERR;
 496     return NULL;
 497   }
 498   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
 499   if (err != GSOCK_NOERROR)
 500   {
 501     GAddress_destroy(connection->m_peer);
 502     delete connection;
 503     m_error = err;
 504     return NULL;
 505   }
 506
 507   ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg);
 508   gs_gui_functions->Enable_Events(connection);
 509
 510   return connection;
 511 }
 512
 513 /* GSocket_SetReusable:
 514 *  Simply sets the m_resuable flag on the socket. GSocket_SetServer will
 515 *  make the appropriate setsockopt() call.
 516 *  Implemented as a GSocket function because clients (ie, wxSocketServer)
 517 *  don't have access to the GSocket struct information.
 518 *  Returns true if the flag was set correctly, false if an error occurred
 519 *  (ie, if the parameter was NULL)
 520 */
 521 bool GSocket::SetReusable()
 522 {
 523     /* socket must not be null, and must not be in use/already bound */
 524     if (this && m_fd == INVALID_SOCKET) {
 525         m_reusable = true;
 526         return true;
 527     }
 528     return false;
 529 }
 530
 531 /* Client specific parts */
 532
 533 /* GSocket_Connect:
 534  *  For stream (connection oriented) sockets, GSocket_Connect() tries
 535  *  to establish a client connection to a server using the peer address
 536  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
 537  *  connection has been successfully established, or one of the error
 538  *  codes listed below. Note that for nonblocking sockets, a return
 539  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
 540  *  request can be completed later; you should use GSocket_Select()
 541  *  to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
 542  *  corresponding asynchronous events.
 543  *
 544  *  For datagram (non connection oriented) sockets, GSocket_Connect()
 545  *  just sets the peer address established with GSocket_SetPeer() as
 546  *  default destination.
 547  *
 548  *  Error codes:
 549  *    GSOCK_INVSOCK    - the socket is in use or not valid.
 550  *    GSOCK_INVADDR    - the peer address has not been established.
 551  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
 552  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
 553  *    GSOCK_MEMERR     - couldn't allocate memory.
 554  *    GSOCK_IOERR      - low-level error.
 555  */
 556 GSocketError GSocket::Connect(GSocketStream stream)
 557 {
 558   int ret, err;
 559   u_long arg = 1;
 560
 561   assert(this);
 562
 563   /* Enable CONNECTION events (needed for nonblocking connections) */
 564   m_detected &= ~GSOCK_CONNECTION_FLAG;
 565
 566   if (m_fd != INVALID_SOCKET)
 567   {
 568     m_error = GSOCK_INVSOCK;
 569     return GSOCK_INVSOCK;
 570   }
 571
 572   if (!m_peer)
 573   {
 574     m_error = GSOCK_INVADDR;
 575     return GSOCK_INVADDR;
 576   }
 577
 578   /* Streamed or dgram socket? */
 579   m_stream   = (stream == GSOCK_STREAMED);
 580   m_server   = false;
 581   m_establishing = false;
 582
 583   /* Create the socket */
 584   m_fd = socket(m_peer->m_realfamily,
 585                      m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
 586
 587   if (m_fd == INVALID_SOCKET)
 588   {
 589     m_error = GSOCK_IOERR;
 590     return GSOCK_IOERR;
 591   }
 592
 593   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
 594   gs_gui_functions->Enable_Events(this);
 595
 596   // If the reuse flag is set, use the applicable socket reuse flag
 597   if (m_reusable)
 598   {
 599      setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
 600   }
 601
 602   // If a local address has been set, then we need to bind to it before calling connect
 603   if (m_local && m_local->m_addr)
 604   {
 605     bind(m_fd, m_local->m_addr, m_local->m_len);
 606   }
 607
 608   /* Connect it to the peer address, with a timeout (see below) */
 609   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
 610
 611   if (ret == SOCKET_ERROR)
 612   {
 613     err = WSAGetLastError();
 614
 615     /* If connect failed with EWOULDBLOCK and the GSocket object
 616      * is in blocking mode, we select() for the specified timeout
 617      * checking for writability to see if the connection request
 618      * completes.
 619      */
 620     if ((err == WSAEWOULDBLOCK) && (!m_non_blocking))
 621     {
 622       err = Connect_Timeout();
 623
 624       if (err != GSOCK_NOERROR)
 625       {
 626         Close();
 627         /* m_error is set in _GSocket_Connect_Timeout */
 628       }
 629
 630       return (GSocketError) err;
 631     }
 632
 633     /* If connect failed with EWOULDBLOCK and the GSocket object
 634      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
 635      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
 636      * this way if the connection completes, a GSOCK_CONNECTION
 637      * event will be generated, if enabled.
 638      */
 639     if ((err == WSAEWOULDBLOCK) && (m_non_blocking))
 640     {
 641       m_establishing = true;
 642       m_error = GSOCK_WOULDBLOCK;
 643       return GSOCK_WOULDBLOCK;
 644     }
 645
 646     /* If connect failed with an error other than EWOULDBLOCK,
 647      * then the call to GSocket_Connect() has failed.
 648      */
 649     Close();
 650     m_error = GSOCK_IOERR;
 651     return GSOCK_IOERR;
 652   }
 653
 654   return GSOCK_NOERROR;
 655 }
 656
 657 /* Datagram sockets */
 658
 659 /* GSocket_SetNonOriented:
 660  *  Sets up this socket as a non-connection oriented (datagram) socket.
 661  *  Before using this function, the local address must have been set
 662  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
 663  *  on success, or one of the following otherwise.
 664  *
 665  *  Error codes:
 666  *    GSOCK_INVSOCK - the socket is in use.
 667  *    GSOCK_INVADDR - the local address has not been set.
 668  *    GSOCK_IOERR   - low-level error.
 669  */
 670 GSocketError GSocket::SetNonOriented()
 671 {
 672   u_long arg = 1;
 673
 674   assert(this);
 675
 676   if (m_fd != INVALID_SOCKET)
 677   {
 678     m_error = GSOCK_INVSOCK;
 679     return GSOCK_INVSOCK;
 680   }
 681
 682   if (!m_local)
 683   {
 684     m_error = GSOCK_INVADDR;
 685     return GSOCK_INVADDR;
 686   }
 687
 688   /* Initialize all fields */
 689   m_stream   = false;
 690   m_server   = false;
 691
 692   /* Create the socket */
 693   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
 694
 695   if (m_fd == INVALID_SOCKET)
 696   {
 697     m_error = GSOCK_IOERR;
 698     return GSOCK_IOERR;
 699   }
 700
 701   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
 702   gs_gui_functions->Enable_Events(this);
 703
 704   /* Bind to the local address,
 705    * and retrieve the actual address bound.
 706    */
 707   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 708       (getsockname(m_fd,
 709                    m_local->m_addr,
 710                    (WX_SOCKLEN_T *)&m_local->m_len) != 0))
 711   {
 712     Close();
 713     m_error = GSOCK_IOERR;
 714     return GSOCK_IOERR;
 715   }
 716
 717   return GSOCK_NOERROR;
 718 }
 719
 720 /* Generic IO */
 721
 722 /* Like recv(), send(), ... */
 723 int GSocket::Read(char *buffer, int size)
 724 {
 725   int ret;
 726
 727   assert(this);
 728
 729   /* Reenable INPUT events */
 730   m_detected &= ~GSOCK_INPUT_FLAG;
 731
 732   if (m_fd == INVALID_SOCKET || m_server)
 733   {
 734     m_error = GSOCK_INVSOCK;
 735     return -1;
 736   }
 737
 738   /* If the socket is blocking, wait for data (with a timeout) */
 739   if (Input_Timeout() == GSOCK_TIMEDOUT)
 740   {
 741     m_error = GSOCK_TIMEDOUT;
 742     return -1;
 743   }
 744
 745   /* Read the data */
 746   if (m_stream)
 747     ret = Recv_Stream(buffer, size);
 748   else
 749     ret = Recv_Dgram(buffer, size);
 750
 751   if (ret == SOCKET_ERROR)
 752   {
 753     if (WSAGetLastError() != WSAEWOULDBLOCK)
 754       m_error = GSOCK_IOERR;
 755     else
 756       m_error = GSOCK_WOULDBLOCK;
 757     return -1;
 758   }
 759
 760   return ret;
 761 }
 762
 763 int GSocket::Write(const char *buffer, int size)
 764 {
 765   int ret;
 766
 767   assert(this);
 768
 769   if (m_fd == INVALID_SOCKET || m_server)
 770   {
 771     m_error = GSOCK_INVSOCK;
 772     return -1;
 773   }
 774
 775   /* If the socket is blocking, wait for writability (with a timeout) */
 776   if (Output_Timeout() == GSOCK_TIMEDOUT)
 777     return -1;
 778
 779   /* Write the data */
 780   if (m_stream)
 781     ret = Send_Stream(buffer, size);
 782   else
 783     ret = Send_Dgram(buffer, size);
 784
 785   if (ret == SOCKET_ERROR)
 786   {
 787     if (WSAGetLastError() != WSAEWOULDBLOCK)
 788       m_error = GSOCK_IOERR;
 789     else
 790       m_error = GSOCK_WOULDBLOCK;
 791
 792     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
 793      * does). Once the first OUTPUT event is received, users can assume
 794      * that the socket is writable until a read operation fails. Only then
 795      * will further OUTPUT events be posted.
 796      */
 797     m_detected &= ~GSOCK_OUTPUT_FLAG;
 798     return -1;
 799   }
 800
 801   return ret;
 802 }
 803
 804 /* GSocket_Select:
 805  *  Polls the socket to determine its status. This function will
 806  *  check for the events specified in the 'flags' parameter, and
 807  *  it will return a mask indicating which operations can be
 808  *  performed. This function won't block, regardless of the
 809  *  mode (blocking | nonblocking) of the socket.
 810  */
 811 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
 812 {
 813   if (!gs_gui_functions->CanUseEventLoop())
 814   {
 815     GSocketEventFlags result = 0;
 816     fd_set readfds;
 817     fd_set writefds;
 818     fd_set exceptfds;
 819
 820     assert(this);
 821
 822     FD_ZERO(&readfds);
 823     FD_ZERO(&writefds);
 824     FD_ZERO(&exceptfds);
 825     FD_SET(m_fd, &readfds);
 826     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
 827       FD_SET(m_fd, &writefds);
 828     FD_SET(m_fd, &exceptfds);
 829
 830     /* Check 'sticky' CONNECTION flag first */
 831     result |= (GSOCK_CONNECTION_FLAG & m_detected);
 832
 833     /* If we have already detected a LOST event, then don't try
 834      * to do any further processing.
 835      */
 836     if ((m_detected & GSOCK_LOST_FLAG) != 0)
 837     {
 838       m_establishing = false;
 839
 840       return (GSOCK_LOST_FLAG & flags);
 841     }
 842
 843     /* Try select now */
 844     if (select(m_fd + 1, &readfds, &writefds, &exceptfds,
 845         &m_timeout) <= 0)
 846     {
 847       /* What to do here? */
 848       return (result & flags);
 849     }
 850
 851     /* Check for exceptions and errors */
 852     if (FD_ISSET(m_fd, &exceptfds))
 853     {
 854       m_establishing = false;
 855       m_detected = GSOCK_LOST_FLAG;
 856
 857       /* LOST event: Abort any further processing */
 858       return (GSOCK_LOST_FLAG & flags);
 859     }
 860
 861     /* Check for readability */
 862     if (FD_ISSET(m_fd, &readfds))
 863     {
 864       result |= GSOCK_INPUT_FLAG;
 865
 866       if (m_server && m_stream)
 867       {
 868         /* This is a TCP server socket that detected a connection.
 869            While the INPUT_FLAG is also set, it doesn't matter on
 870            this kind of  sockets, as we can only Accept() from them. */
 871         result |= GSOCK_CONNECTION_FLAG;
 872         m_detected |= GSOCK_CONNECTION_FLAG;
 873       }
 874     }
 875
 876     /* Check for writability */
 877     if (FD_ISSET(m_fd, &writefds))
 878     {
 879       if (m_establishing && !m_server)
 880       {
 881         int error;
 882         WX_SOCKLEN_T len = sizeof(error);
 883
 884         m_establishing = false;
 885
 886         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
 887
 888         if (error)
 889         {
 890           m_detected = GSOCK_LOST_FLAG;
 891
 892           /* LOST event: Abort any further processing */
 893           return (GSOCK_LOST_FLAG & flags);
 894         }
 895         else
 896         {
 897           result |= GSOCK_CONNECTION_FLAG;
 898           m_detected |= GSOCK_CONNECTION_FLAG;
 899         }
 900       }
 901       else
 902       {
 903         result |= GSOCK_OUTPUT_FLAG;
 904       }
 905     }
 906
 907     return (result & flags);
 908   }
 909   else /* USE_GUI() */
 910   {
 911     assert(this);
 912     return flags & m_detected;
 913   }
 914 }
 915
 916 /* Attributes */
 917
 918 /* GSocket_SetNonBlocking:
 919  *  Sets the socket to non-blocking mode. All IO calls will return
 920  *  immediately.
 921  */
 922 void GSocket::SetNonBlocking(bool non_block)
 923 {
 924   assert(this);
 925
 926   m_non_blocking = non_block;
 927 }
 928
 929 /* GSocket_SetTimeout:
 930  *  Sets the timeout for blocking calls. Time is expressed in
 931  *  milliseconds.
 932  */
 933 void GSocket::SetTimeout(unsigned long millis)
 934 {
 935   assert(this);
 936
 937   m_timeout.tv_sec  = (millis / 1000);
 938   m_timeout.tv_usec = (millis % 1000) * 1000;
 939 }
 940
 941 /* GSocket_GetError:
 942  *  Returns the last error occurred for this socket. Note that successful
 943  *  operations do not clear this back to GSOCK_NOERROR, so use it only
 944  *  after an error.
 945  */
 946 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
 947 {
 948   assert(this);
 949
 950   return m_error;
 951 }
 952
 953 /* Callbacks */
 954
 955 /* GSOCK_INPUT:
 956  *   There is data to be read in the input buffer. If, after a read
 957  *   operation, there is still data available, the callback function will
 958  *   be called again.
 959  * GSOCK_OUTPUT:
 960  *   The socket is available for writing. That is, the next write call
 961  *   won't block. This event is generated only once, when the connection is
 962  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
 963  *   when the output buffer empties again. This means that the app should
 964  *   assume that it can write since the first OUTPUT event, and no more
 965  *   OUTPUT events will be generated unless an error occurs.
 966  * GSOCK_CONNECTION:
 967  *   Connection successfully established, for client sockets, or incoming
 968  *   client connection, for server sockets. Wait for this event (also watch
 969  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
 970  * GSOCK_LOST:
 971  *   The connection is lost (or a connection request failed); this could
 972  *   be due to a failure, or due to the peer closing it gracefully.
 973  */
 974
 975 /* GSocket_SetCallback:
 976  *  Enables the callbacks specified by 'flags'. Note that 'flags'
 977  *  may be a combination of flags OR'ed toghether, so the same
 978  *  callback function can be made to accept different events.
 979  *  The callback function must have the following prototype:
 980  *
 981  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
 982  */
 983 void GSocket::SetCallback(GSocketEventFlags flags,
 984                          GSocketCallback callback, char *cdata)
 985 {
 986   int count;
 987
 988   assert(this);
 989
 990   for (count = 0; count < GSOCK_MAX_EVENT; count++)
 991   {
 992     if ((flags & (1 << count)) != 0)
 993     {
 994       m_cbacks[count] = callback;
 995       m_data[count] = cdata;
 996     }
 997   }
 998 }
 999
1000 /* GSocket_UnsetCallback:
1001  *  Disables all callbacks specified by 'flags', which may be a
1002  *  combination of flags OR'ed toghether.
1003  */
1004 void GSocket::UnsetCallback(GSocketEventFlags flags)
1005 {
1006   int count;
1007
1008   assert(this);
1009
1010   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1011   {
1012     if ((flags & (1 << count)) != 0)
1013     {
1014       m_cbacks[count] = NULL;
1015       m_data[count] = NULL;
1016     }
1017   }
1018 }
1019
1020 GSocketError GSocket::GetSockOpt(int level, int optname,
1021                                 void *optval, int *optlen)
1022 {
1023     if (getsockopt(m_fd, level, optname, (char*)optval, optlen) == 0)
1024     {
1025         return GSOCK_NOERROR;
1026     }
1027     return GSOCK_OPTERR;
1028 }
1029
1030 GSocketError GSocket::SetSockOpt(int level, int optname,
1031                                 const void *optval, int optlen)
1032 {
1033     if (setsockopt(m_fd, level, optname, (char*)optval, optlen) == 0)
1034     {
1035         return GSOCK_NOERROR;
1036     }
1037     return GSOCK_OPTERR;
1038 }
1039
1040 /* Internals (IO) */
1041
1042 /* _GSocket_Input_Timeout:
1043  *  For blocking sockets, wait until data is available or
1044  *  until timeout ellapses.
1045  */
1046 GSocketError GSocket::Input_Timeout()
1047 {
1048   fd_set readfds;
1049
1050   if (!m_non_blocking)
1051   {
1052     FD_ZERO(&readfds);
1053     FD_SET(m_fd, &readfds);
1054     if (select(0, &readfds, NULL, NULL, &m_timeout) == 0)
1055     {
1056       m_error = GSOCK_TIMEDOUT;
1057       return GSOCK_TIMEDOUT;
1058     }
1059   }
1060   return GSOCK_NOERROR;
1061 }
1062
1063 /* _GSocket_Output_Timeout:
1064  *  For blocking sockets, wait until data can be sent without
1065  *  blocking or until timeout ellapses.
1066  */
1067 GSocketError GSocket::Output_Timeout()
1068 {
1069   fd_set writefds;
1070
1071   if (!m_non_blocking)
1072   {
1073     FD_ZERO(&writefds);
1074     FD_SET(m_fd, &writefds);
1075     if (select(0, NULL, &writefds, NULL, &m_timeout) == 0)
1076     {
1077       m_error = GSOCK_TIMEDOUT;
1078       return GSOCK_TIMEDOUT;
1079     }
1080   }
1081   return GSOCK_NOERROR;
1082 }
1083
1084 /* _GSocket_Connect_Timeout:
1085  *  For blocking sockets, wait until the connection is
1086  *  established or fails, or until timeout ellapses.
1087  */
1088 GSocketError GSocket::Connect_Timeout()
1089 {
1090   fd_set writefds;
1091   fd_set exceptfds;
1092
1093   FD_ZERO(&writefds);
1094   FD_ZERO(&exceptfds);
1095   FD_SET(m_fd, &writefds);
1096   FD_SET(m_fd, &exceptfds);
1097   if (select(0, NULL, &writefds, &exceptfds, &m_timeout) == 0)
1098   {
1099     m_error = GSOCK_TIMEDOUT;
1100     return GSOCK_TIMEDOUT;
1101   }
1102   if (!FD_ISSET(m_fd, &writefds))
1103   {
1104     m_error = GSOCK_IOERR;
1105     return GSOCK_IOERR;
1106   }
1107
1108   return GSOCK_NOERROR;
1109 }
1110
1111 int GSocket::Recv_Stream(char *buffer, int size)
1112 {
1113   return recv(m_fd, buffer, size, 0);
1114 }
1115
1116 int GSocket::Recv_Dgram(char *buffer, int size)
1117 {
1118   struct sockaddr from;
1119   WX_SOCKLEN_T fromlen = sizeof(from);
1120   int ret;
1121   GSocketError err;
1122
1123   ret = recvfrom(m_fd, buffer, size, 0, &from, &fromlen);
1124
1125   if (ret == SOCKET_ERROR)
1126     return SOCKET_ERROR;
1127
1128   /* Translate a system address into a GSocket address */
1129   if (!m_peer)
1130   {
1131     m_peer = GAddress_new();
1132     if (!m_peer)
1133     {
1134       m_error = GSOCK_MEMERR;
1135       return -1;
1136     }
1137   }
1138   err = _GAddress_translate_from(m_peer, &from, fromlen);
1139   if (err != GSOCK_NOERROR)
1140   {
1141     GAddress_destroy(m_peer);
1142     m_peer  = NULL;
1143     m_error = err;
1144     return -1;
1145   }
1146
1147   return ret;
1148 }
1149
1150 int GSocket::Send_Stream(const char *buffer, int size)
1151 {
1152   return send(m_fd, buffer, size, 0);
1153 }
1154
1155 int GSocket::Send_Dgram(const char *buffer, int size)
1156 {
1157   struct sockaddr *addr;
1158   int len, ret;
1159   GSocketError err;
1160
1161   if (!m_peer)
1162   {
1163     m_error = GSOCK_INVADDR;
1164     return -1;
1165   }
1166
1167   err = _GAddress_translate_to(m_peer, &addr, &len);
1168   if (err != GSOCK_NOERROR)
1169   {
1170     m_error = err;
1171     return -1;
1172   }
1173
1174   ret = sendto(m_fd, buffer, size, 0, addr, len);
1175
1176   /* Frees memory allocated by _GAddress_translate_to */
1177   free(addr);
1178
1179   return ret;
1180 }
1181
1182 /* Compatibility functions for GSocket */
1183 GSocket *GSocket_new(void)
1184 {
1185     GSocket *newsocket = new GSocket();
1186     if(newsocket->IsOk())
1187         return newsocket;
1188     delete newsocket;
1189     return NULL;
1190 }
1191
1192
1193 /*
1194  * -------------------------------------------------------------------------
1195  * GAddress
1196  * -------------------------------------------------------------------------
1197  */
1198
1199 /* CHECK_ADDRESS verifies that the current address family is either
1200  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1201  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1202  * an appropiate error code.
1203  *
1204  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1205  */
1206 #define CHECK_ADDRESS(address, family)                              \
1207 {                                                                   \
1208   if (address->m_family == GSOCK_NOFAMILY)                          \
1209     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1210       return address->m_error;                                      \
1211   if (address->m_family != GSOCK_##family)                          \
1212   {                                                                 \
1213     address->m_error = GSOCK_INVADDR;                               \
1214     return GSOCK_INVADDR;                                           \
1215   }                                                                 \
1216 }
1217
1218 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1219 {                                                                   \
1220   if (address->m_family == GSOCK_NOFAMILY)                          \
1221     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1222       return retval;                                                \
1223   if (address->m_family != GSOCK_##family)                          \
1224   {                                                                 \
1225     address->m_error = GSOCK_INVADDR;                               \
1226     return retval;                                                  \
1227   }                                                                 \
1228 }
1229
1230
1231 GAddress *GAddress_new(void)
1232 {
1233   GAddress *address;
1234
1235   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1236     return NULL;
1237
1238   address->m_family = GSOCK_NOFAMILY;
1239   address->m_addr   = NULL;
1240   address->m_len    = 0;
1241
1242   return address;
1243 }
1244
1245 GAddress *GAddress_copy(GAddress *address)
1246 {
1247   GAddress *addr2;
1248
1249   assert(address != NULL);
1250
1251   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1252     return NULL;
1253
1254   memcpy(addr2, address, sizeof(GAddress));
1255
1256   if (address->m_addr)
1257   {
1258     addr2->m_addr = (struct sockaddr *) malloc(addr2->m_len);
1259     if (addr2->m_addr == NULL)
1260     {
1261       free(addr2);
1262       return NULL;
1263     }
1264     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1265   }
1266
1267   return addr2;
1268 }
1269
1270 void GAddress_destroy(GAddress *address)
1271 {
1272   assert(address != NULL);
1273
1274   if (address->m_addr)
1275     free(address->m_addr);
1276
1277   free(address);
1278 }
1279
1280 void GAddress_SetFamily(GAddress *address, GAddressType type)
1281 {
1282   assert(address != NULL);
1283
1284   address->m_family = type;
1285 }
1286
1287 GAddressType GAddress_GetFamily(GAddress *address)
1288 {
1289   assert(address != NULL);
1290
1291   return address->m_family;
1292 }
1293
1294 GSocketError _GAddress_translate_from(GAddress *address,
1295                                       struct sockaddr *addr, int len)
1296 {
1297   address->m_realfamily = addr->sa_family;
1298   switch (addr->sa_family)
1299   {
1300     case AF_INET:
1301       address->m_family = GSOCK_INET;
1302       break;
1303     case AF_UNIX:
1304       address->m_family = GSOCK_UNIX;
1305       break;
1306 #ifdef AF_INET6
1307     case AF_INET6:
1308       address->m_family = GSOCK_INET6;
1309       break;
1310 #endif
1311     default:
1312     {
1313       address->m_error = GSOCK_INVOP;
1314       return GSOCK_INVOP;
1315     }
1316   }
1317
1318   if (address->m_addr)
1319     free(address->m_addr);
1320
1321   address->m_len = len;
1322   address->m_addr = (struct sockaddr *) malloc(len);
1323
1324   if (address->m_addr == NULL)
1325   {
1326     address->m_error = GSOCK_MEMERR;
1327     return GSOCK_MEMERR;
1328   }
1329   memcpy(address->m_addr, addr, len);
1330
1331   return GSOCK_NOERROR;
1332 }
1333
1334 GSocketError _GAddress_translate_to(GAddress *address,
1335                                     struct sockaddr **addr, int *len)
1336 {
1337   if (!address->m_addr)
1338   {
1339     address->m_error = GSOCK_INVADDR;
1340     return GSOCK_INVADDR;
1341   }
1342
1343   *len = address->m_len;
1344   *addr = (struct sockaddr *) malloc(address->m_len);
1345   if (*addr == NULL)
1346   {
1347     address->m_error = GSOCK_MEMERR;
1348     return GSOCK_MEMERR;
1349   }
1350
1351   memcpy(*addr, address->m_addr, address->m_len);
1352   return GSOCK_NOERROR;
1353 }
1354
1355 /*
1356  * -------------------------------------------------------------------------
1357  * Internet address family
1358  * -------------------------------------------------------------------------
1359  */
1360
1361 GSocketError _GAddress_Init_INET(GAddress *address)
1362 {
1363   address->m_len  = sizeof(struct sockaddr_in);
1364   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1365   if (address->m_addr == NULL)
1366   {
1367     address->m_error = GSOCK_MEMERR;
1368     return GSOCK_MEMERR;
1369   }
1370
1371   address->m_family = GSOCK_INET;
1372   address->m_realfamily = AF_INET;
1373   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1374   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1375
1376   return GSOCK_NOERROR;
1377 }
1378
1379 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1380 {
1381   struct hostent *he;
1382   struct in_addr *addr;
1383
1384   assert(address != NULL);
1385
1386   CHECK_ADDRESS(address, INET);
1387
1388   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1389
1390   addr->s_addr = inet_addr(hostname);
1391
1392   /* If it is a numeric host name, convert it now */
1393   if (addr->s_addr == INADDR_NONE)
1394   {
1395     struct in_addr *array_addr;
1396
1397     /* It is a real name, we solve it */
1398     if ((he = gethostbyname(hostname)) == NULL)
1399     {
1400       /* addr->s_addr = INADDR_NONE just done by inet_addr() above */
1401       address->m_error = GSOCK_NOHOST;
1402       return GSOCK_NOHOST;
1403     }
1404     array_addr = (struct in_addr *) *(he->h_addr_list);
1405     addr->s_addr = array_addr[0].s_addr;
1406   }
1407   return GSOCK_NOERROR;
1408 }
1409
1410 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1411 {
1412   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1413 }
1414
1415 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1416                                           unsigned long hostaddr)
1417 {
1418   struct in_addr *addr;
1419
1420   assert(address != NULL);
1421
1422   CHECK_ADDRESS(address, INET);
1423
1424   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1425   addr->s_addr = htonl(hostaddr);
1426
1427   return GSOCK_NOERROR;
1428 }
1429
1430 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1431                                        const char *protocol)
1432 {
1433   struct servent *se;
1434   struct sockaddr_in *addr;
1435
1436   assert(address != NULL);
1437   CHECK_ADDRESS(address, INET);
1438
1439   if (!port)
1440   {
1441     address->m_error = GSOCK_INVPORT;
1442     return GSOCK_INVPORT;
1443   }
1444
1445   se = getservbyname(port, protocol);
1446   if (!se)
1447   {
1448     if (isdigit(port[0]))
1449     {
1450       int port_int;
1451
1452       port_int = atoi(port);
1453       addr = (struct sockaddr_in *)address->m_addr;
1454       addr->sin_port = htons((u_short) port_int);
1455       return GSOCK_NOERROR;
1456     }
1457
1458     address->m_error = GSOCK_INVPORT;
1459     return GSOCK_INVPORT;
1460   }
1461
1462   addr = (struct sockaddr_in *)address->m_addr;
1463   addr->sin_port = se->s_port;
1464
1465   return GSOCK_NOERROR;
1466 }
1467
1468 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1469 {
1470   struct sockaddr_in *addr;
1471
1472   assert(address != NULL);
1473   CHECK_ADDRESS(address, INET);
1474
1475   addr = (struct sockaddr_in *)address->m_addr;
1476   addr->sin_port = htons(port);
1477
1478   return GSOCK_NOERROR;
1479 }
1480
1481 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1482 {
1483   struct hostent *he;
1484   char *addr_buf;
1485   struct sockaddr_in *addr;
1486
1487   assert(address != NULL);
1488   CHECK_ADDRESS(address, INET);
1489
1490   addr = (struct sockaddr_in *)address->m_addr;
1491   addr_buf = (char *)&(addr->sin_addr);
1492
1493   he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1494   if (he == NULL)
1495   {
1496     address->m_error = GSOCK_NOHOST;
1497     return GSOCK_NOHOST;
1498   }
1499
1500   strncpy(hostname, he->h_name, sbuf);
1501
1502   return GSOCK_NOERROR;
1503 }
1504
1505 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1506 {
1507   struct sockaddr_in *addr;
1508
1509   assert(address != NULL);
1510   CHECK_ADDRESS_RETVAL(address, INET, 0);
1511
1512   addr = (struct sockaddr_in *)address->m_addr;
1513
1514   return ntohl(addr->sin_addr.s_addr);
1515 }
1516
1517 unsigned short GAddress_INET_GetPort(GAddress *address)
1518 {
1519   struct sockaddr_in *addr;
1520
1521   assert(address != NULL);
1522   CHECK_ADDRESS_RETVAL(address, INET, 0);
1523
1524   addr = (struct sockaddr_in *)address->m_addr;
1525   return ntohs(addr->sin_port);
1526 }
1527
1528 /*
1529  * -------------------------------------------------------------------------
1530  * Unix address family
1531  * -------------------------------------------------------------------------
1532  */
1533
1534 GSocketError _GAddress_Init_UNIX(GAddress *address)
1535 {
1536   assert (address != NULL);
1537   address->m_error = GSOCK_INVADDR;
1538   return GSOCK_INVADDR;
1539 }
1540
1541 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *WXUNUSED(path))
1542 {
1543   assert (address != NULL);
1544   address->m_error = GSOCK_INVADDR;
1545   return GSOCK_INVADDR;
1546 }
1547
1548 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *WXUNUSED(path), size_t WXUNUSED(sbuf))
1549 {
1550   assert (address != NULL);
1551   address->m_error = GSOCK_INVADDR;
1552   return GSOCK_INVADDR;
1553 }
1554
1555 #else /* !wxUSE_SOCKETS */
1556
1557 /*
1558  * Translation unit shouldn't be empty, so include this typedef to make the
1559  * compiler (VC++ 6.0, for example) happy
1560  */
1561 typedef void (*wxDummy)();
1562
1563 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */