X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f6afe7fdf1de812bbc656a1ef832088e56412ae3..f369c7c2841c0534424f2c184783c1a2070012cf:/src/msw/gsocket.cpp?ds=sidebyside

diff --git a/src/msw/gsocket.cpp b/src/msw/gsocket.cpp
index 83fb30a935..8cc501a98e 100644
--- a/src/msw/gsocket.cpp
+++ b/src/msw/gsocket.cpp
@@ -1,10 +1,12 @@
 /* -------------------------------------------------------------------------
- * Project: GSocket (Generic Socket)
- * Name:    gsocket.cpp
- * Author:  Guillermo Rodriguez Garcia <guille@iies.es>
- * Purpose: GSocket main MSW file
- * Licence: The wxWindows licence
- * CVSID:   $Id$
+ * Project:     GSocket (Generic Socket)
+ * Name:        src/msw/gsocket.cpp
+ * Copyright:   (c) Guilhem Lavaux
+ * Licence:     wxWindows Licence
+ * Author:      Guillermo Rodriguez Garcia <guille@iies.es>
+ * Purpose:     GSocket main MSW file
+ * Licence:     The wxWindows licence
+ * CVSID:       $Id$
  * -------------------------------------------------------------------------
  */
 
@@ -51,25 +53,16 @@
 
 #include <winsock.h>
 
-#ifndef __GSOCKET_STANDALONE__
-#   include "wx/platform.h"
-#   include "wx/setup.h"
-#endif
+#include "wx/platform.h"
 
-#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
+#if wxUSE_SOCKETS
 
-#ifndef __GSOCKET_STANDALONE__
-#  include "wx/msw/gsockmsw.h"
-#  include "wx/gsocket.h"
-#else
-#  include "gsockmsw.h"
-#  include "gsocket.h"
-#endif /* __GSOCKET_STANDALONE__ */
+#include "wx/gsocket.h"
+#include "wx/link.h"
 
-#ifndef __WXWINCE__
-#include <assert.h>
-#else
-#define assert(x)
+wxFORCE_LINK_MODULE(gsockmsw)
+
+#ifdef __WXWINCE__
 #ifndef isdigit
 #define isdigit(x) (x > 47 && x < 58)
 #endif
@@ -82,73 +75,34 @@
 #include <stddef.h>
 #include <ctype.h>
 
-/* if we use configure for MSW SOCKLEN_T will be already defined */
-#ifndef SOCKLEN_T
-#  define SOCKLEN_T int
+/* if we use configure for MSW WX_SOCKLEN_T will be already defined */
+#ifndef WX_SOCKLEN_T
+#  define WX_SOCKLEN_T int
 #endif
 
-/* Table of GUI-related functions. We must call them indirectly because
- * of wxBase and GUI separation: */
-
-static GSocketGUIFunctionsTable *gs_gui_functions;
-
-class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable
-{
-public:
-    virtual bool OnInit();
-    virtual void OnExit();
-    virtual bool CanUseEventLoop();
-    virtual bool Init_Socket(GSocket *socket);
-    virtual void Destroy_Socket(GSocket *socket);
-    virtual void Enable_Events(GSocket *socket);
-    virtual void Disable_Events(GSocket *socket);
-};
-
-bool GSocketGUIFunctionsTableNull::OnInit()
-{   return true; }
-void GSocketGUIFunctionsTableNull::OnExit()
-{}
-bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
-{   return false; }
-bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))
-{   return true; }
-void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket))
-{}
-void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket))
-{}
-void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket))
-{}
-/* Global initialisers */
-
-void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc)
-{
-  gs_gui_functions = guifunc;
-}
+#if wxUSE_IPV6
+typedef struct sockaddr_storage wxSockAddr;
+#else
+typedef struct sockaddr wxSockAddr;
+#endif
 
-int GSocket_Init(void)
+bool GSocket_Init()
 {
   WSADATA wsaData;
 
-  if (!gs_gui_functions)
-  {
-    static GSocketGUIFunctionsTableNull table;
-    gs_gui_functions = &table;
-  }
-  if ( !gs_gui_functions->OnInit() )
-  {
-    return 0;
-  }
+  GSocketManager * const manager = GSocketManager::Get();
+  if ( !manager || !manager->OnInit() )
+      return false;
 
   /* Initialize WinSocket */
-  return (WSAStartup((1 << 8) | 1, &wsaData) == 0);
+  return WSAStartup((1 << 8) | 1, &wsaData) == 0;
 }
 
-void GSocket_Cleanup(void)
+void GSocket_Cleanup()
 {
-  if (gs_gui_functions)
-  {
-      gs_gui_functions->OnExit();
-  }
+  GSocketManager * const manager = GSocketManager::Get();
+  if ( manager )
+    manager->OnExit();
 
   /* Cleanup WinSocket */
   WSACleanup();
@@ -176,25 +130,24 @@ GSocket::GSocket()
   m_timeout.tv_usec = 0;
   m_establishing    = false;
   m_reusable        = false;
+  m_broadcast       = false;
+  m_dobind          = true;
+  m_initialRecvBufferSize = -1;
+  m_initialSendBufferSize = -1;
 
-  assert(gs_gui_functions);
-  /* Per-socket GUI-specific initialization */
-  m_ok = gs_gui_functions->Init_Socket(this);
+  m_ok = GSocketManager::Get()->Init_Socket(this);
 }
 
 void GSocket::Close()
 {
-    gs_gui_functions->Disable_Events(this);
+    GSocketManager::Get()->Disable_Events(this);
     closesocket(m_fd);
     m_fd = INVALID_SOCKET;
 }
 
 GSocket::~GSocket()
 {
-  assert(this);
-
-  /* Per-socket GUI-specific cleanup */
-  gs_gui_functions->Destroy_Socket(this);
+  GSocketManager::Get()->Destroy_Socket(this);
 
   /* Check that the socket is really shutdowned */
   if (m_fd != INVALID_SOCKET)
@@ -216,12 +169,10 @@ void GSocket::Shutdown()
 {
   int evt;
 
-  assert(this);
-
   /* If socket has been created, shutdown it */
   if (m_fd != INVALID_SOCKET)
   {
-    shutdown(m_fd, 2);
+    shutdown(m_fd, 1 /* SD_SEND */);
     Close();
   }
 
@@ -250,8 +201,6 @@ void GSocket::Shutdown()
  */
 GSocketError GSocket::SetLocal(GAddress *address)
 {
-  assert(this);
-
   /* the socket must be initialized, or it must be a server */
   if (m_fd != INVALID_SOCKET && !m_server)
   {
@@ -276,8 +225,6 @@ GSocketError GSocket::SetLocal(GAddress *address)
 
 GSocketError GSocket::SetPeer(GAddress *address)
 {
-  assert(this);
-
   /* check address */
   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
   {
@@ -296,12 +243,10 @@ GSocketError GSocket::SetPeer(GAddress *address)
 GAddress *GSocket::GetLocal()
 {
   GAddress *address;
-  struct sockaddr addr;
-  SOCKLEN_T size = sizeof(addr);
+  wxSockAddr addr;
+  WX_SOCKLEN_T size = sizeof(addr);
   GSocketError err;
 
-  assert(this);
-
   /* try to get it from the m_local var first */
   if (m_local)
     return GAddress_copy(m_local);
@@ -313,7 +258,7 @@ GAddress *GSocket::GetLocal()
     return NULL;
   }
 
-  if (getsockname(m_fd, &addr, &size) == SOCKET_ERROR)
+  if (getsockname(m_fd, (sockaddr*)&addr, &size) == SOCKET_ERROR)
   {
     m_error = GSOCK_IOERR;
     return NULL;
@@ -326,7 +271,7 @@ GAddress *GSocket::GetLocal()
      return NULL;
   }
 
-  if ((err = _GAddress_translate_from(address, &addr, size)) != GSOCK_NOERROR)
+  if ((err = _GAddress_translate_from(address, (sockaddr*)&addr, size)) != GSOCK_NOERROR)
   {
      GAddress_destroy(address);
      m_error = err;
@@ -338,8 +283,6 @@ GAddress *GSocket::GetLocal()
 
 GAddress *GSocket::GetPeer()
 {
-  assert(this);
-
   /* try to get it from the m_peer var */
   if (m_peer)
     return GAddress_copy(m_peer);
@@ -363,8 +306,6 @@ GSocketError GSocket::SetServer()
 {
   u_long arg = 1;
 
-  assert(this);
-
   /* must not be in use */
   if (m_fd != INVALID_SOCKET)
   {
@@ -393,13 +334,14 @@ GSocketError GSocket::SetServer()
   }
 
   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
-  gs_gui_functions->Enable_Events(this);
+  GSocketManager::Get()->Enable_Events(this);
 
   /* allow a socket to re-bind if the socket is in the TIME_WAIT
      state after being previously closed.
    */
-  if (m_reusable) {
-    setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
+  if (m_reusable)
+  {
+    setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
   }
 
   /* Bind to the local address,
@@ -409,7 +351,7 @@ GSocketError GSocket::SetServer()
   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
       (getsockname(m_fd,
                    m_local->m_addr,
-                   (SOCKLEN_T *)&m_local->m_len) != 0) ||
+                   (WX_SOCKLEN_T *)&m_local->m_len) != 0) ||
       (listen(m_fd, 5) != 0))
   {
     Close();
@@ -435,13 +377,11 @@ GSocketError GSocket::SetServer()
 GSocket *GSocket::WaitConnection()
 {
   GSocket *connection;
-  struct sockaddr from;
-  SOCKLEN_T fromlen = sizeof(from);
+  wxSockAddr from;
+  WX_SOCKLEN_T fromlen = sizeof(from);
   GSocketError err;
   u_long arg = 1;
 
-  assert(this);
-
   /* Reenable CONNECTION events */
   m_detected &= ~GSOCK_CONNECTION_FLAG;
 
@@ -469,7 +409,7 @@ GSocket *GSocket::WaitConnection()
     return NULL;
   }
 
-  connection->m_fd = accept(m_fd, &from, &fromlen);
+  connection->m_fd = accept(m_fd, (sockaddr*)&from, &fromlen);
 
   if (connection->m_fd == INVALID_SOCKET)
   {
@@ -494,7 +434,7 @@ GSocket *GSocket::WaitConnection()
     m_error = GSOCK_MEMERR;
     return NULL;
   }
-  err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
+  err = _GAddress_translate_from(connection->m_peer, (sockaddr*)&from, fromlen);
   if (err != GSOCK_NOERROR)
   {
     GAddress_destroy(connection->m_peer);
@@ -504,7 +444,7 @@ GSocket *GSocket::WaitConnection()
   }
 
   ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg);
-  gs_gui_functions->Enable_Events(connection);
+  GSocketManager::Get()->Enable_Events(connection);
 
   return connection;
 }
@@ -514,7 +454,7 @@ GSocket *GSocket::WaitConnection()
 *  make the appropriate setsockopt() call.
 *  Implemented as a GSocket function because clients (ie, wxSocketServer)
 *  don't have access to the GSocket struct information.
-*  Returns true if the flag was set correctly, false if an error occured
+*  Returns true if the flag was set correctly, false if an error occurred
 *  (ie, if the parameter was NULL)
 */
 bool GSocket::SetReusable()
@@ -527,13 +467,41 @@ bool GSocket::SetReusable()
     return false;
 }
 
+/* GSocket_SetBroadcast:
+*  Simply sets the m_broadcast flag on the socket. GSocket_SetServer will
+*  make the appropriate setsockopt() call.
+*  Implemented as a GSocket function because clients (ie, wxSocketServer)
+*  don't have access to the GSocket struct information.
+*  Returns true if the flag was set correctly, false if an error occurred
+*  (ie, if the parameter was NULL)
+*/
+bool GSocket::SetBroadcast()
+{
+    /* socket must not be in use/already bound */
+    if (m_fd == INVALID_SOCKET) {
+        m_broadcast = true;
+        return true;
+    }
+    return false;
+}
+
+bool GSocket::DontDoBind()
+{
+    /* socket must not be in use/already bound */
+    if (m_fd == INVALID_SOCKET) {
+        m_dobind = false;
+        return true;
+    }
+    return false;
+}
+
 /* Client specific parts */
 
 /* GSocket_Connect:
  *  For stream (connection oriented) sockets, GSocket_Connect() tries
  *  to establish a client connection to a server using the peer address
  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
- *  connection has been succesfully established, or one of the error
+ *  connection has been successfully established, or one of the error
  *  codes listed below. Note that for nonblocking sockets, a return
  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
  *  request can be completed later; you should use GSocket_Select()
@@ -557,8 +525,6 @@ GSocketError GSocket::Connect(GSocketStream stream)
   int ret, err;
   u_long arg = 1;
 
-  assert(this);
-
   /* Enable CONNECTION events (needed for nonblocking connections) */
   m_detected &= ~GSOCK_CONNECTION_FLAG;
 
@@ -590,7 +556,24 @@ GSocketError GSocket::Connect(GSocketStream stream)
   }
 
   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
-  gs_gui_functions->Enable_Events(this);
+  GSocketManager::Get()->Enable_Events(this);
+
+  // If the reuse flag is set, use the applicable socket reuse flag
+  if (m_reusable)
+  {
+     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
+  }
+
+  if (m_initialRecvBufferSize >= 0)
+    setsockopt(m_fd, SOL_SOCKET, SO_RCVBUF, (const char*)&m_initialRecvBufferSize, sizeof(m_initialRecvBufferSize));
+  if (m_initialSendBufferSize >= 0)
+    setsockopt(m_fd, SOL_SOCKET, SO_SNDBUF, (const char*)&m_initialSendBufferSize, sizeof(m_initialSendBufferSize));
+
+  // If a local address has been set, then we need to bind to it before calling connect
+  if (m_local && m_local->m_addr)
+  {
+    bind(m_fd, m_local->m_addr, m_local->m_len);
+  }
 
   /* Connect it to the peer address, with a timeout (see below) */
   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
@@ -658,8 +641,6 @@ GSocketError GSocket::SetNonOriented()
 {
   u_long arg = 1;
 
-  assert(this);
-
   if (m_fd != INVALID_SOCKET)
   {
     m_error = GSOCK_INVSOCK;
@@ -686,19 +667,30 @@ GSocketError GSocket::SetNonOriented()
   }
 
   ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
-  gs_gui_functions->Enable_Events(this);
+  GSocketManager::Get()->Enable_Events(this);
 
-  /* Bind to the local address,
-   * and retrieve the actual address bound.
-   */
-  if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
-      (getsockname(m_fd,
-                   m_local->m_addr,
-                   (SOCKLEN_T *)&m_local->m_len) != 0))
+  if (m_reusable)
   {
-    Close();
-    m_error = GSOCK_IOERR;
-    return GSOCK_IOERR;
+    setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
+  }
+  if (m_broadcast)
+  {
+    setsockopt(m_fd, SOL_SOCKET, SO_BROADCAST, (const char*)&arg, sizeof(arg));
+  }
+  if (m_dobind)
+  {
+    /* Bind to the local address,
+     * and retrieve the actual address bound.
+     */
+    if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
+        (getsockname(m_fd,
+                     m_local->m_addr,
+                     (WX_SOCKLEN_T *)&m_local->m_len) != 0))
+    {
+      Close();
+      m_error = GSOCK_IOERR;
+      return GSOCK_IOERR;
+    }
   }
 
   return GSOCK_NOERROR;
@@ -711,8 +703,6 @@ int GSocket::Read(char *buffer, int size)
 {
   int ret;
 
-  assert(this);
-
   /* Reenable INPUT events */
   m_detected &= ~GSOCK_INPUT_FLAG;
 
@@ -724,7 +714,10 @@ int GSocket::Read(char *buffer, int size)
 
   /* If the socket is blocking, wait for data (with a timeout) */
   if (Input_Timeout() == GSOCK_TIMEDOUT)
+  {
+    m_error = GSOCK_TIMEDOUT;
     return -1;
+  }
 
   /* Read the data */
   if (m_stream)
@@ -748,8 +741,6 @@ int GSocket::Write(const char *buffer, int size)
 {
   int ret;
 
-  assert(this);
-
   if (m_fd == INVALID_SOCKET || m_server)
   {
     m_error = GSOCK_INVSOCK;
@@ -794,119 +785,7 @@ int GSocket::Write(const char *buffer, int size)
  */
 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
 {
-  if (!gs_gui_functions->CanUseEventLoop())
-  {
-    GSocketEventFlags result = 0;
-    fd_set readfds;
-    fd_set writefds;
-    fd_set exceptfds;
-
-    assert(this);
-
-    FD_ZERO(&readfds);
-    FD_ZERO(&writefds);
-    FD_ZERO(&exceptfds);
-    FD_SET(m_fd, &readfds);
-    if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
-      FD_SET(m_fd, &writefds);
-    FD_SET(m_fd, &exceptfds);
-
-    /* Check 'sticky' CONNECTION flag first */
-    result |= (GSOCK_CONNECTION_FLAG & m_detected);
-
-    /* If we have already detected a LOST event, then don't try
-     * to do any further processing.
-     */
-    if ((m_detected & GSOCK_LOST_FLAG) != 0)
-    {
-      m_establishing = false;
-
-      return (GSOCK_LOST_FLAG & flags);
-    }
-
-    /* Try select now */
-    if (select(m_fd + 1, &readfds, &writefds, &exceptfds,
-        &m_timeout) <= 0)
-    {
-      /* What to do here? */
-      return (result & flags);
-    }
-
-    /* Check for readability */
-    if (FD_ISSET(m_fd, &readfds))
-    {
-      char c;
-
-      if (!m_stream || recv(m_fd, &c, 1, MSG_PEEK) > 0)
-      {
-        result |= GSOCK_INPUT_FLAG;
-      }
-      else
-      {
-        if (m_server && m_stream)
-        {
-          result |= GSOCK_CONNECTION_FLAG;
-          m_detected |= GSOCK_CONNECTION_FLAG;
-        }
-        else
-        {
-          m_detected = GSOCK_LOST_FLAG;
-          m_establishing = false;
-
-          /* LOST event: Abort any further processing */
-          return (GSOCK_LOST_FLAG & flags);
-        }
-      }
-    }
-
-    /* Check for writability */
-    if (FD_ISSET(m_fd, &writefds))
-    {
-      if (m_establishing && !m_server)
-      {
-        int error;
-        SOCKLEN_T len = sizeof(error);
-
-        m_establishing = false;
-
-        getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
-
-        if (error)
-        {
-          m_detected = GSOCK_LOST_FLAG;
-
-          /* LOST event: Abort any further processing */
-          return (GSOCK_LOST_FLAG & flags);
-        }
-        else
-        {
-          result |= GSOCK_CONNECTION_FLAG;
-          m_detected |= GSOCK_CONNECTION_FLAG;
-        }
-      }
-      else
-      {
-        result |= GSOCK_OUTPUT_FLAG;
-      }
-    }
-
-    /* Check for exceptions and errors (is this useful in Unices?) */
-    if (FD_ISSET(m_fd, &exceptfds))
-    {
-      m_establishing = false;
-      m_detected = GSOCK_LOST_FLAG;
-
-      /* LOST event: Abort any further processing */
-      return (GSOCK_LOST_FLAG & flags);
-    }
-
-    return (result & flags);
-  }
-  else /* USE_GUI() */
-  {
-    assert(this);
-    return flags & m_detected;
-  }
+  return flags & m_detected;
 }
 
 /* Attributes */
@@ -917,8 +796,6 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
  */
 void GSocket::SetNonBlocking(bool non_block)
 {
-  assert(this);
-
   m_non_blocking = non_block;
 }
 
@@ -928,21 +805,17 @@ void GSocket::SetNonBlocking(bool non_block)
  */
 void GSocket::SetTimeout(unsigned long millis)
 {
-  assert(this);
-
   m_timeout.tv_sec  = (millis / 1000);
   m_timeout.tv_usec = (millis % 1000) * 1000;
 }
 
 /* GSocket_GetError:
- *  Returns the last error occured for this socket. Note that successful
+ *  Returns the last error occurred for this socket. Note that successful
  *  operations do not clear this back to GSOCK_NOERROR, so use it only
  *  after an error.
  */
 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
 {
-  assert(this);
-
   return m_error;
 }
 
@@ -960,7 +833,7 @@ GSocketError WXDLLIMPEXP_NET GSocket::GetError()
  *   assume that it can write since the first OUTPUT event, and no more
  *   OUTPUT events will be generated unless an error occurs.
  * GSOCK_CONNECTION:
- *   Connection succesfully established, for client sockets, or incoming
+ *   Connection successfully established, for client sockets, or incoming
  *   client connection, for server sockets. Wait for this event (also watch
  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
  * GSOCK_LOST:
@@ -981,8 +854,6 @@ void GSocket::SetCallback(GSocketEventFlags flags,
 {
   int count;
 
-  assert(this);
-
   for (count = 0; count < GSOCK_MAX_EVENT; count++)
   {
     if ((flags & (1 << count)) != 0)
@@ -1001,8 +872,6 @@ void GSocket::UnsetCallback(GSocketEventFlags flags)
 {
   int count;
 
-  assert(this);
-
   for (count = 0; count < GSOCK_MAX_EVENT; count++)
   {
     if ((flags & (1 << count)) != 0)
@@ -1111,12 +980,12 @@ int GSocket::Recv_Stream(char *buffer, int size)
 
 int GSocket::Recv_Dgram(char *buffer, int size)
 {
-  struct sockaddr from;
-  SOCKLEN_T fromlen = sizeof(from);
+  wxSockAddr from;
+  WX_SOCKLEN_T fromlen = sizeof(from);
   int ret;
   GSocketError err;
 
-  ret = recvfrom(m_fd, buffer, size, 0, &from, &fromlen);
+  ret = recvfrom(m_fd, buffer, size, 0, (sockaddr*)&from, &fromlen);
 
   if (ret == SOCKET_ERROR)
     return SOCKET_ERROR;
@@ -1131,7 +1000,7 @@ int GSocket::Recv_Dgram(char *buffer, int size)
       return -1;
     }
   }
-  err = _GAddress_translate_from(m_peer, &from, fromlen);
+  err = _GAddress_translate_from(m_peer, (sockaddr*)&from, fromlen);
   if (err != GSOCK_NOERROR)
   {
     GAddress_destroy(m_peer);
@@ -1176,7 +1045,7 @@ int GSocket::Send_Dgram(const char *buffer, int size)
 }
 
 /* Compatibility functions for GSocket */
-GSocket *GSocket_new(void)
+GSocket *GSocket_new()
 {
     GSocket *newsocket = new GSocket();
     if(newsocket->IsOk())
@@ -1224,7 +1093,7 @@ GSocket *GSocket_new(void)
 }
 
 
-GAddress *GAddress_new(void)
+GAddress *GAddress_new()
 {
   GAddress *address;
 
@@ -1242,8 +1111,6 @@ GAddress *GAddress_copy(GAddress *address)
 {
   GAddress *addr2;
 
-  assert(address != NULL);
-
   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
     return NULL;
 
@@ -1265,8 +1132,6 @@ GAddress *GAddress_copy(GAddress *address)
 
 void GAddress_destroy(GAddress *address)
 {
-  assert(address != NULL);
-
   if (address->m_addr)
     free(address->m_addr);
 
@@ -1275,15 +1140,11 @@ void GAddress_destroy(GAddress *address)
 
 void GAddress_SetFamily(GAddress *address, GAddressType type)
 {
-  assert(address != NULL);
-
   address->m_family = type;
 }
 
 GAddressType GAddress_GetFamily(GAddress *address)
 {
-  assert(address != NULL);
-
   return address->m_family;
 }
 
@@ -1299,7 +1160,7 @@ GSocketError _GAddress_translate_from(GAddress *address,
     case AF_UNIX:
       address->m_family = GSOCK_UNIX;
       break;
-#ifdef AF_INET6
+#if wxUSE_IPV6
     case AF_INET6:
       address->m_family = GSOCK_INET6;
       break;
@@ -1377,8 +1238,6 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   struct hostent *he;
   struct in_addr *addr;
 
-  assert(address != NULL);
-
   CHECK_ADDRESS(address, INET);
 
   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
@@ -1403,6 +1262,11 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   return GSOCK_NOERROR;
 }
 
+GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
+{
+  return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
+}
+
 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
 {
   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
@@ -1413,12 +1277,10 @@ GSocketError GAddress_INET_SetHostAddress(GAddress *address,
 {
   struct in_addr *addr;
 
-  assert(address != NULL);
-
   CHECK_ADDRESS(address, INET);
 
   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
-  addr->s_addr = htonl(hostaddr);;
+  addr->s_addr = htonl(hostaddr);
 
   return GSOCK_NOERROR;
 }
@@ -1429,7 +1291,6 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
   struct servent *se;
   struct sockaddr_in *addr;
 
-  assert(address != NULL);
   CHECK_ADDRESS(address, INET);
 
   if (!port)
@@ -1465,7 +1326,6 @@ GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL);
   CHECK_ADDRESS(address, INET);
 
   addr = (struct sockaddr_in *)address->m_addr;
@@ -1480,7 +1340,6 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t
   char *addr_buf;
   struct sockaddr_in *addr;
 
-  assert(address != NULL);
   CHECK_ADDRESS(address, INET);
 
   addr = (struct sockaddr_in *)address->m_addr;
@@ -1502,7 +1361,6 @@ unsigned long GAddress_INET_GetHostAddress(GAddress *address)
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL);
   CHECK_ADDRESS_RETVAL(address, INET, 0);
 
   addr = (struct sockaddr_in *)address->m_addr;
@@ -1514,13 +1372,170 @@ unsigned short GAddress_INET_GetPort(GAddress *address)
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL);
   CHECK_ADDRESS_RETVAL(address, INET, 0);
 
   addr = (struct sockaddr_in *)address->m_addr;
   return ntohs(addr->sin_port);
 }
 
+
+#if wxUSE_IPV6
+/*
+ * -------------------------------------------------------------------------
+ * Internet IPv6 address family
+ * -------------------------------------------------------------------------
+ */
+#include "ws2tcpip.h"
+
+#ifdef __VISUALC__
+    #pragma comment(lib,"ws2_32")
+#endif // __VISUALC__
+
+GSocketError _GAddress_Init_INET6(GAddress *address)
+{
+  struct in6_addr any_address = IN6ADDR_ANY_INIT;
+  address->m_len  = sizeof(struct sockaddr_in6);
+  address->m_addr = (struct sockaddr *) malloc(address->m_len);
+  if (address->m_addr == NULL)
+  {
+    address->m_error = GSOCK_MEMERR;
+    return GSOCK_MEMERR;
+  }
+  memset(address->m_addr,0,address->m_len);
+
+  address->m_family = GSOCK_INET6;
+  address->m_realfamily = AF_INET6;
+  ((struct sockaddr_in6 *)address->m_addr)->sin6_family = AF_INET6;
+  ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = any_address;
+
+  return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET6_SetHostName(GAddress *address, const char *hostname)
+{
+  CHECK_ADDRESS(address, INET6);
+
+  addrinfo hints;
+  memset( & hints, 0, sizeof( hints ) );
+  hints.ai_family = AF_INET6;
+  addrinfo * info = 0;
+  if ( getaddrinfo( hostname, "0", & hints, & info ) || ! info )
+  {
+    address->m_error = GSOCK_NOHOST;
+    return GSOCK_NOHOST;
+  }
+
+  memcpy( address->m_addr, info->ai_addr, info->ai_addrlen );
+  freeaddrinfo( info );
+  return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET6_SetAnyAddress(GAddress *address)
+{
+  CHECK_ADDRESS(address, INET6);
+
+  struct in6_addr addr;
+  memset( & addr, 0, sizeof( addr ) );
+  return GAddress_INET6_SetHostAddress(address, addr);
+}
+GSocketError GAddress_INET6_SetHostAddress(GAddress *address,
+                                          struct in6_addr hostaddr)
+{
+  CHECK_ADDRESS(address, INET6);
+
+  ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = hostaddr;
+
+  return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET6_SetPortName(GAddress *address, const char *port,
+                                       const char *protocol)
+{
+  struct servent *se;
+  struct sockaddr_in6 *addr;
+
+  CHECK_ADDRESS(address, INET6);
+
+  if (!port)
+  {
+    address->m_error = GSOCK_INVPORT;
+    return GSOCK_INVPORT;
+  }
+
+  se = getservbyname(port, protocol);
+  if (!se)
+  {
+    if (isdigit((unsigned char) port[0]))
+    {
+      int port_int;
+
+      port_int = atoi(port);
+      addr = (struct sockaddr_in6 *)address->m_addr;
+      addr->sin6_port = htons((u_short) port_int);
+      return GSOCK_NOERROR;
+    }
+
+    address->m_error = GSOCK_INVPORT;
+    return GSOCK_INVPORT;
+  }
+
+  addr = (struct sockaddr_in6 *)address->m_addr;
+  addr->sin6_port = se->s_port;
+
+  return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET6_SetPort(GAddress *address, unsigned short port)
+{
+  struct sockaddr_in6 *addr;
+
+  CHECK_ADDRESS(address, INET6);
+
+  addr = (struct sockaddr_in6 *)address->m_addr;
+  addr->sin6_port = htons(port);
+
+  return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET6_GetHostName(GAddress *address, char *hostname, size_t sbuf)
+{
+  struct hostent *he;
+  char *addr_buf;
+  struct sockaddr_in6 *addr;
+
+  CHECK_ADDRESS(address, INET6);
+
+  addr = (struct sockaddr_in6 *)address->m_addr;
+  addr_buf = (char *)&(addr->sin6_addr);
+
+  he = gethostbyaddr(addr_buf, sizeof(addr->sin6_addr), AF_INET6);
+  if (he == NULL)
+  {
+    address->m_error = GSOCK_NOHOST;
+    return GSOCK_NOHOST;
+  }
+
+  strncpy(hostname, he->h_name, sbuf);
+
+  return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET6_GetHostAddress(GAddress *address,struct in6_addr *hostaddr)
+{
+  CHECK_ADDRESS_RETVAL(address, INET6, GSOCK_INVADDR);
+  *hostaddr = ( (struct sockaddr_in6 *)address->m_addr )->sin6_addr;
+  return GSOCK_NOERROR;
+}
+
+unsigned short GAddress_INET6_GetPort(GAddress *address)
+{
+  CHECK_ADDRESS_RETVAL(address, INET6, 0);
+
+  return ntohs( ((struct sockaddr_in6 *)address->m_addr)->sin6_port );
+}
+
+#endif // wxUSE_IPV6
+
 /*
  * -------------------------------------------------------------------------
  * Unix address family
@@ -1529,32 +1544,20 @@ unsigned short GAddress_INET_GetPort(GAddress *address)
 
 GSocketError _GAddress_Init_UNIX(GAddress *address)
 {
-  assert (address != NULL);
   address->m_error = GSOCK_INVADDR;
   return GSOCK_INVADDR;
 }
 
 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *WXUNUSED(path))
 {
-  assert (address != NULL);
   address->m_error = GSOCK_INVADDR;
   return GSOCK_INVADDR;
 }
 
 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *WXUNUSED(path), size_t WXUNUSED(sbuf))
 {
-  assert (address != NULL);
   address->m_error = GSOCK_INVADDR;
   return GSOCK_INVADDR;
 }
 
-#else /* !wxUSE_SOCKETS */
-
-/*
- * Translation unit shouldn't be empty, so include this typedef to make the
- * compiler (VC++ 6.0, for example) happy
- */
-typedef void (*wxDummy)();
-
-#endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
-
+#endif  // wxUSE_SOCKETS