]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/gsocket.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
added a unit test for input/output file streams and fixed the problem it exposed...
[wxWidgets.git] / src / unix / gsocket.cpp
diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp
index c580a78d331625fd259c4393dfcd1bde27bbd8bd..1d1b9cec698620fa8075b03c4acf143fd9aa1a92 100644 (file)
--- a/src/unix/gsocket.cpp
+++ b/src/unix/gsocket.cpp
@@ -1,26 +1,31 @@
 /* -------------------------------------------------------------------------
 /* -------------------------------------------------------------------------
- * Project: GSocket (Generic Socket) for WX
- * Name:    gsocket.c
- * Authors: David Elliott (C++ conversion, maintainer)
- *          Guilhem Lavaux,
- *          Guillermo Rodriguez Garcia <guille@iies.es>
- * Purpose: GSocket main Unix and OS/2 file
- * Licence: The wxWidgets licence
- * CVSID:   $Id$
+ * Project:     GSocket (Generic Socket) for WX
+ * Name:        gsocket.c
+ * Copyright:   (c) Guilhem Lavaux
+ * Licence:     wxWindows Licence
+ * Authors:     David Elliott (C++ conversion, maintainer)
+ *              Guilhem Lavaux,
+ *              Guillermo Rodriguez Garcia <guille@iies.es>
+ * Purpose:     GSocket main Unix and OS/2 file
+ * Licence:     The wxWindows licence
+ * CVSID:       $Id$
  * -------------------------------------------------------------------------
  */
 
  * -------------------------------------------------------------------------
  */
 
+#if defined(__WATCOMC__)
 #include "wx/wxprec.h"
 #include "wx/wxprec.h"
-#ifndef WX_PRECOMP
-    #include "wx/app.h"
-    #include "wx/apptrait.h"
-#endif //ndef WX_PRECOMP
+#include <errno.h>
+#include <nerrno.h>
+#endif
 
 
-#if defined(__VISAGECPP__)
-/* Seems to be needed by Visual Age C++, though I don't see how it manages
-   to not break on including a C++ header into a plain C source file      */
+#ifndef __GSOCKET_STANDALONE__
 #include "wx/defs.h"
 #include "wx/defs.h"
-#define BSD_SELECT /* use Berkley Sockets select */
+#include "wx/private/gsocketiohandler.h"
+#include "wx/thread.h" // for wxThread::IsMain() used in assert
+#endif
+
+#if defined(__VISAGECPP__)
+#define BSD_SELECT /* use Berkeley Sockets select */
 #endif
 
 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
 #endif
 
 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
@@ -36,6 +41,10 @@
 #include <netdb.h>
 #include <sys/ioctl.h>
 
 #include <netdb.h>
 #include <sys/ioctl.h>
 
+#ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#endif
+
 #ifdef __VMS__
 #include <socket.h>
 struct sockaddr_un
 #ifdef __VMS__
 #include <socket.h>
 struct sockaddr_un
@@ -85,6 +94,10 @@ int _System bsdselect(int,
 int _System soclose(int);
 #  endif
 #endif
 int _System soclose(int);
 #  endif
 #endif
+#ifdef __EMX__
+#include <sys/select.h>
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
@@ -95,24 +108,33 @@ int _System soclose(int);
 #ifdef sgi
 #  include <bstring.h>
 #endif
 #ifdef sgi
 #  include <bstring.h>
 #endif
+#ifdef _AIX
+#  include <strings.h>
+#endif
 #include <signal.h>
 
 #include <signal.h>
 
-#ifndef SOCKLEN_T
+#ifndef WX_SOCKLEN_T
 
 #ifdef VMS
 
 #ifdef VMS
-#  define SOCKLEN_T unsigned int
+#  define WX_SOCKLEN_T unsigned int
 #else
 #  ifdef __GLIBC__
 #    if __GLIBC__ == 2
 #else
 #  ifdef __GLIBC__
 #    if __GLIBC__ == 2
-#      define SOCKLEN_T socklen_t
+#      define WX_SOCKLEN_T socklen_t
 #    endif
 #    endif
+#  elif defined(__WXMAC__)
+#    define WX_SOCKLEN_T socklen_t
 #  else
 #  else
-#    define SOCKLEN_T int
+#    define WX_SOCKLEN_T int
 #  endif
 #endif
 
 #endif /* SOCKLEN_T */
 
 #  endif
 #endif
 
 #endif /* SOCKLEN_T */
 
+#ifndef SOCKOPTLEN_T
+#define SOCKOPTLEN_T WX_SOCKLEN_T
+#endif
+
 /*
  * MSW defines this, Unices don't.
  */
 /*
  * MSW defines this, Unices don't.
  */
@@ -133,112 +155,333 @@ int _System soclose(int);
 #define INADDR_NONE INADDR_BROADCAST
 #endif
 
 #define INADDR_NONE INADDR_BROADCAST
 #endif
 
-#define MASK_SIGNAL()                       \
-{                                           \
-  void (*old_handler)(int);                 \
-                                            \
-  old_handler = signal(SIGPIPE, SIG_IGN);
+#if defined(__VISAGECPP__) || defined(__WATCOMC__)
 
 
-#define UNMASK_SIGNAL()                     \
-  signal(SIGPIPE, old_handler);             \
-}
+    #define MASK_SIGNAL() {
+    #define UNMASK_SIGNAL() }
+
+#else
+    extern "C" { typedef void (*wxSigHandler)(int); }
 
 
+    #define MASK_SIGNAL()                       \
+    {                                           \
+        wxSigHandler old_handler = signal(SIGPIPE, SIG_IGN);
+
+    #define UNMASK_SIGNAL()                     \
+        signal(SIGPIPE, old_handler);           \
+    }
+
+#endif
+
+/* If a SIGPIPE is issued by a socket call on a remotely closed socket,
+   the program will "crash" unless it explicitly handles the SIGPIPE.
+   By using MSG_NOSIGNAL, the SIGPIPE is suppressed. Later, we will
+   use SO_NOSIGPIPE (if available), the BSD equivalent. */
+#ifdef MSG_NOSIGNAL
+#  define GSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL
+#else /* MSG_NOSIGNAL not available (FreeBSD including OS X) */
+#  define GSOCKET_MSG_NOSIGNAL 0
+#endif /* MSG_NOSIGNAL */
 
 #ifndef __GSOCKET_STANDALONE__
 #  include "wx/unix/gsockunx.h"
 
 #ifndef __GSOCKET_STANDALONE__
 #  include "wx/unix/gsockunx.h"
+#  include "wx/unix/private.h"
 #  include "wx/gsocket.h"
 #  include "wx/gsocket.h"
+#if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME))
+#  include "wx/thread.h"
+#endif
 #else
 #  include "gsockunx.h"
 #  include "gsocket.h"
 #else
 #  include "gsockunx.h"
 #  include "gsocket.h"
+#  ifndef WXUNUSED
+#    define WXUNUSED(x)
+#  endif
 #endif /* __GSOCKET_STANDALONE__ */
 
 #endif /* __GSOCKET_STANDALONE__ */
 
-/* debugging helpers */
-#ifdef __GSOCKET_DEBUG__
-#  define GSocket_Debug(args) printf args
-#else
-#  define GSocket_Debug(args)
-#endif /* __GSOCKET_DEBUG__ */
+#if defined(HAVE_GETHOSTBYNAME)
+static struct hostent * deepCopyHostent(struct hostent *h,
+                                       const struct hostent *he,
+                                       char *buffer, int size, int *err)
+{
+  /* copy old structure */
+  memcpy(h, he, sizeof(struct hostent));
 
 
-///////////////////////////////////////////////////////////////////////////
-// GSocketBSDGUIShim
-struct GSocketGUIFunctionsTable *GSocketBSDGUIShim::ms_gui_functions = NULL;
+  /* copy name */
+  int len = strlen(h->h_name);
+  if (len > size)
+  {
+    *err = ENOMEM;
+    return NULL;
+  }
+  memcpy(buffer, h->h_name, len);
+  buffer[len] = '\0';
+  h->h_name = buffer;
 
 
-void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *guifunc)
-{
-  GSocketBSDGUIShim::ms_gui_functions = guifunc;
-}
-         
-inline bool GSocketBSDGUIShim::UseGUI()
-{
-    return ms_gui_functions;
-}
+  /* track position in the buffer */
+  int pos = len + 1;
 
 
-inline bool GSocketBSDGUIShim::GUI_Init()
-{
-    return (ms_gui_functions)?ms_gui_functions->GUI_Init():true;
-}
+  /* reuse len to store address length */
+  len = h->h_length;
 
 
-inline void GSocketBSDGUIShim::GUI_Cleanup()
-{
-    if (ms_gui_functions) ms_gui_functions->GUI_Cleanup();
-}
+  /* ensure pointer alignment */
+  unsigned int misalign = sizeof(char *) - pos%sizeof(char *);
+  if(misalign < sizeof(char *))
+    pos += misalign;
 
 
-GSocketBSDGUIShim::GSocketBSDGUIShim()
-{
-    m_ok = (ms_gui_functions ? ms_gui_functions->GUI_Init_Socket(this) : true);
-}
+  /* leave space for pointer list */
+  char **p = h->h_addr_list, **q;
+  char **h_addr_list = (char **)(buffer + pos);
+  while(*(p++) != 0)
+    pos += sizeof(char *);
 
 
-GSocketBSDGUIShim::~GSocketBSDGUIShim()
-{
-    if (ms_gui_functions) ms_gui_functions->GUI_Destroy_Socket(this);
+  /* copy addresses and fill new pointer list */
+  for (p = h->h_addr_list, q = h_addr_list; *p != 0; p++, q++)
+  {
+    if (size < pos + len)
+    {
+      *err = ENOMEM;
+      return NULL;
+    }
+    memcpy(buffer + pos, *p, len); /* copy content */
+    *q = buffer + pos; /* set copied pointer to copied content */
+    pos += len;
+  }
+  *++q = 0; /* null terminate the pointer list */
+  h->h_addr_list = h_addr_list; /* copy pointer to pointers */
+
+  /* ensure word alignment of pointers */
+  misalign = sizeof(char *) - pos%sizeof(char *);
+  if(misalign < sizeof(char *))
+    pos += misalign;
+
+  /* leave space for pointer list */
+  p = h->h_aliases;
+  char **h_aliases = (char **)(buffer + pos);
+  while(*(p++) != 0)
+    pos += sizeof(char *);
+
+  /* copy aliases and fill new pointer list */
+  for (p = h->h_aliases, q = h_aliases; *p != 0; p++, q++)
+  {
+    len = strlen(*p);
+    if (size <= pos + len)
+    {
+      *err = ENOMEM;
+      return NULL;
+    }
+    memcpy(buffer + pos, *p, len); /* copy content */
+    buffer[pos + len] = '\0';
+    *q = buffer + pos; /* set copied pointer to copied content */
+    pos += len + 1;
+  }
+  *++q = 0; /* null terminate the pointer list */
+  h->h_aliases = h_aliases; /* copy pointer to pointers */
+
+  return h;
 }
 }
+#endif
 
 
-void GSocketBSDGUIShim::EventLoop_Enable_Events()
-{
-    if (ms_gui_functions) ms_gui_functions->Enable_Events(this);
+#if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS
+static wxMutex nameLock;
+#endif
+struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h,
+                                  void *buffer, int size, int *err)
+
+{
+  struct hostent *he = NULL;
+  *err = 0;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
+  if (gethostbyname_r(hostname, h, (char*)buffer, size, &he, err))
+    he = NULL;
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
+  he = gethostbyname_r(hostname, h, (char*)buffer, size, err);
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+  if (gethostbyname_r(hostname, h, (struct hostent_data*) buffer))
+  {
+    he = NULL;
+    *err = h_errno;
+  }
+  else
+    he = h;
+#elif defined(HAVE_GETHOSTBYNAME)
+#if wxUSE_THREADS
+  wxMutexLocker locker(nameLock);
+#endif
+  he = gethostbyname(hostname);
+  if (!he)
+    *err = h_errno;
+  else
+    he = deepCopyHostent(h, he, (char*)buffer, size, err);
+#endif
+  return he;
 }
 
 }
 
-void GSocketBSDGUIShim::EventLoop_Disable_Events()
-{
-    if (ms_gui_functions) ms_gui_functions->Disable_Events(this);
+#if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS
+static wxMutex addrLock;
+#endif
+struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size,
+                                  int proto, struct hostent *h,
+                                  void *buffer, int size, int *err)
+{
+  struct hostent *he = NULL;
+  *err = 0;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
+  if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
+                     (char*)buffer, size, &he, err))
+    he = NULL;
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
+  he = gethostbyaddr_r(addr_buf, buf_size, proto, h, (char*)buffer, size, err);
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+  if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
+                       (struct hostent_data*) buffer))
+  {
+    he = NULL;
+    *err = h_errno;
+  }
+  else
+    he = h;
+#elif defined(HAVE_GETHOSTBYNAME)
+#if wxUSE_THREADS
+  wxMutexLocker locker(addrLock);
+#endif
+  he = gethostbyaddr(addr_buf, buf_size, proto);
+  if (!he)
+    *err = h_errno;
+  else
+    he = deepCopyHostent(h, he, (char*)buffer, size, err);
+#endif
+  return he;
 }
 
 }
 
-void GSocketBSDGUIShim::EventLoop_Install_Callback(GSocketEvent event)
+#if defined(HAVE_GETSERVBYNAME)
+static struct servent * deepCopyServent(struct servent *s,
+                                       const struct servent *se,
+                                       char *buffer, int size)
 {
 {
-    if (ms_gui_functions) ms_gui_functions->Install_Callback(this, event);
+  /* copy plain old structure */
+  memcpy(s, se, sizeof(struct servent));
+
+  /* copy name */
+  int len = strlen(s->s_name);
+  if (len >= size)
+  {
+    return NULL;
+  }
+  memcpy(buffer, s->s_name, len);
+  buffer[len] = '\0';
+  s->s_name = buffer;
+
+  /* track position in the buffer */
+  int pos = len + 1;
+
+  /* copy protocol */
+  len = strlen(s->s_proto);
+  if (pos + len >= size)
+  {
+    return NULL;
+  }
+  memcpy(buffer + pos, s->s_proto, len);
+  buffer[pos + len] = '\0';
+  s->s_proto = buffer + pos;
+
+  /* track position in the buffer */
+  pos += len + 1;
+
+  /* ensure pointer alignment */
+  unsigned int misalign = sizeof(char *) - pos%sizeof(char *);
+  if(misalign < sizeof(char *))
+    pos += misalign;
+
+  /* leave space for pointer list */
+  char **p = s->s_aliases, **q;
+  char **s_aliases = (char **)(buffer + pos);
+  while(*(p++) != 0)
+    pos += sizeof(char *);
+
+  /* copy addresses and fill new pointer list */
+  for (p = s->s_aliases, q = s_aliases; *p != 0; p++, q++){
+    len = strlen(*p);
+    if (size <= pos + len)
+    {
+      return NULL;
+    }
+    memcpy(buffer + pos, *p, len); /* copy content */
+    buffer[pos + len] = '\0';
+    *q = buffer + pos; /* set copied pointer to copied content */
+    pos += len + 1;
+  }
+  *++q = 0; /* null terminate the pointer list */
+  s->s_aliases = s_aliases; /* copy pointer to pointers */
+  return s;
 }
 }
+#endif
 
 
-void GSocketBSDGUIShim::EventLoop_Uninstall_Callback(GSocketEvent event)
-{
-    if (ms_gui_functions) ms_gui_functions->Uninstall_Callback(this, event);
+#if defined(HAVE_GETSERVBYNAME) && wxUSE_THREADS
+static wxMutex servLock;
+#endif
+struct servent *wxGetservbyname_r(const char *port, const char *protocol,
+                                 struct servent *serv, void *buffer, int size)
+{
+  struct servent *se = NULL;
+#if defined(HAVE_FUNC_GETSERVBYNAME_R_6)
+  if (getservbyname_r(port, protocol, serv, (char*)buffer, size, &se))
+    se = NULL;
+#elif defined(HAVE_FUNC_GETSERVBYNAME_R_5)
+  se = getservbyname_r(port, protocol, serv, (char*)buffer, size);
+#elif defined(HAVE_FUNC_GETSERVBYNAME_R_4)
+  if (getservbyname_r(port, protocol, serv, (struct servent_data*) buffer))
+    se = NULL;
+  else
+    se = serv;
+#elif defined(HAVE_GETSERVBYNAME)
+#if wxUSE_THREADS
+  wxMutexLocker locker(servLock);
+#endif
+  se = getservbyname(port, protocol);
+  if (se)
+    se = deepCopyServent(serv, se, (char*)buffer, size);
+#endif
+  return se;
 }
 
 }
 
-///////////////////////////////////////////////////////////////////////////
-// GSocketBSD
+/* debugging helpers */
+#ifdef __GSOCKET_DEBUG__
+#  define GSocket_Debug(args) printf args
+#else
+#  define GSocket_Debug(args)
+#endif /* __GSOCKET_DEBUG__ */
 
 
-static struct GSocketBaseFunctionsTable gs_base_functions =
-{
-    GSocketBSD::_GSocket_Detected_Read,
-    GSocketBSD::_GSocket_Detected_Write
-};
+#if wxUSE_IPV6
+typedef struct sockaddr_storage wxSockAddr;
+#else
+typedef struct sockaddr wxSockAddr;
+#endif
 
 
-/* Global initialisers */
+/* Table of GUI-related functions. We must call them indirectly because
+ * of wxBase and GUI separation: */
 
 
-int GSocket_Init(void)
+bool GSocket_Init()
 {
 {
-    return GSocketBSDGUIShim::GUI_Init();
+    GSocketManager * const manager = GSocketManager::Get();
+    return manager && manager->OnInit();
 }
 
 }
 
-void GSocket_Cleanup(void)
+void GSocket_Cleanup()
 {
 {
-    GSocketBSDGUIShim::GUI_Cleanup();
+    GSocketManager * const manager = GSocketManager::Get();
+    if ( manager )
+        manager->OnExit();
 }
 
 }
 
-GSocketBSD::GSocketBSD()
+/* Constructors / Destructors for GSocket */
+
+GSocket::GSocket()
 {
   int i;
 
   m_fd                  = INVALID_SOCKET;
 {
   int i;
 
   m_fd                  = INVALID_SOCKET;
+  m_handler             = NULL;
+
   for (i=0;i<GSOCK_MAX_EVENT;i++)
   {
     m_cbacks[i]         = NULL;
   for (i=0;i<GSOCK_MAX_EVENT;i++)
   {
     m_cbacks[i]         = NULL;
@@ -247,53 +490,80 @@ GSocketBSD::GSocketBSD()
   m_local               = NULL;
   m_peer                = NULL;
   m_error               = GSOCK_NOERROR;
   m_local               = NULL;
   m_peer                = NULL;
   m_error               = GSOCK_NOERROR;
-  m_server              = FALSE;
-  m_stream              = TRUE;
+  m_server              = false;
+  m_stream              = true;
   m_gui_dependent       = NULL;
   m_gui_dependent       = NULL;
-  m_non_blocking        = FALSE;
+  m_non_blocking        = false;
+  m_reusable            = false;
+  m_broadcast           = false;
+  m_dobind              = true;
   m_timeout             = 10*60*1000;
                                 /* 10 minutes * 60 sec * 1000 millisec */
   m_timeout             = 10*60*1000;
                                 /* 10 minutes * 60 sec * 1000 millisec */
-  m_establishing        = FALSE;
+  m_establishing        = false;
+  m_use_events          = false;
+  m_initialRecvBufferSize = -1;
+  m_initialSendBufferSize = -1;
 
 
-  m_functions           = &gs_base_functions;
-
-  m_ok = true;
+  m_ok = GSocketManager::Get()->Init_Socket(this);
 }
 
 }
 
-void GSocketBSD::Close()
+void GSocket::Close()
 {
 {
-    EventLoop_Disable_Events();
-// gsockosx.c calls CFSocketInvalidate which closes the socket for us
-#if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)))
-    close(m_fd);
-#endif
+    if (m_use_events)
+        DisableEvents();
+
+    /*  When running on OS X, the gsockosx implementation of GSocketGUIFunctionsTable
+        will close the socket during Disable_Events.  However, it will only do this
+        if it is being used.  That is, it won't do it in a console program.  To
+        ensure we get the right behavior, we have gsockosx set m_fd = INVALID_SOCKET
+        if it has closed the socket which indicates to us (at runtime, instead of
+        at compile time as this had been before) that the socket has already
+        been closed.
+     */
+    if(m_fd != INVALID_SOCKET)
+        close(m_fd);
     m_fd = INVALID_SOCKET;
 }
 
     m_fd = INVALID_SOCKET;
 }
 
-GSocketBSD::~GSocketBSD()
+GSocket::~GSocket()
 {
 {
+  assert(this);
+
+  /* Check that the socket is really shutdowned */
+  if (m_fd != INVALID_SOCKET)
+    Shutdown();
+
+  GSocketManager::Get()->Destroy_Socket(this);
+
+  delete m_handler;
+
   /* Destroy private addresses */
   if (m_local)
     GAddress_destroy(m_local);
 
   if (m_peer)
     GAddress_destroy(m_peer);
   /* Destroy private addresses */
   if (m_local)
     GAddress_destroy(m_local);
 
   if (m_peer)
     GAddress_destroy(m_peer);
+
 }
 
 /* GSocket_Shutdown:
  *  Disallow further read/write operations on this socket, close
  *  the fd and disable all callbacks.
  */
 }
 
 /* GSocket_Shutdown:
  *  Disallow further read/write operations on this socket, close
  *  the fd and disable all callbacks.
  */
-void GSocketBSD::Shutdown()
+void GSocket::Shutdown()
 {
   int evt;
 
   assert(this);
 
 {
   int evt;
 
   assert(this);
 
+  /* Don't allow events to fire after socket has been closed */
+  if (m_use_events)
+    DisableEvents();
+
   /* If socket has been created, shutdown it */
   if (m_fd != INVALID_SOCKET)
   {
   /* If socket has been created, shutdown it */
   if (m_fd != INVALID_SOCKET)
   {
-    shutdown(m_fd, 2);
+    shutdown(m_fd, 1);
     Close();
   }
 
     Close();
   }
 
@@ -320,7 +590,7 @@ void GSocketBSD::Shutdown()
  *    GSOCK_INVSOCK - the socket is not valid.
  *    GSOCK_INVADDR - the address is not valid.
  */
  *    GSOCK_INVSOCK - the socket is not valid.
  *    GSOCK_INVADDR - the address is not valid.
  */
-GSocketError GSocketBSD::SetLocal(GAddress *address)
+GSocketError GSocket::SetLocal(GAddress *address)
 {
   assert(this);
 
 {
   assert(this);
 
@@ -346,7 +616,7 @@ GSocketError GSocketBSD::SetLocal(GAddress *address)
   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
 
-GSocketError GSocketBSD::SetPeer(GAddress *address)
+GSocketError GSocket::SetPeer(GAddress *address)
 {
   assert(this);
 
 {
   assert(this);
 
@@ -365,11 +635,11 @@ GSocketError GSocketBSD::SetPeer(GAddress *address)
   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
 
-GAddress *GSocketBSD::GetLocal()
+GAddress *GSocket::GetLocal()
 {
   GAddress *address;
 {
   GAddress *address;
-  struct sockaddr addr;
-  SOCKLEN_T size = sizeof(addr);
+  wxSockAddr addr;
+  WX_SOCKLEN_T size = sizeof(addr);
   GSocketError err;
 
   assert(this);
   GSocketError err;
 
   assert(this);
@@ -385,7 +655,7 @@ GAddress *GSocketBSD::GetLocal()
     return NULL;
   }
 
     return NULL;
   }
 
-  if (getsockname(m_fd, &addr, (SOCKLEN_T *) &size) < 0)
+  if (getsockname(m_fd, (sockaddr*)&addr, (WX_SOCKLEN_T *) &size) < 0)
   {
     m_error = GSOCK_IOERR;
     return NULL;
   {
     m_error = GSOCK_IOERR;
     return NULL;
@@ -399,7 +669,7 @@ GAddress *GSocketBSD::GetLocal()
     return NULL;
   }
 
     return NULL;
   }
 
-  err = _GAddress_translate_from(address, &addr, size);
+  err = _GAddress_translate_from(address, (sockaddr*)&addr, size);
   if (err != GSOCK_NOERROR)
   {
     GAddress_destroy(address);
   if (err != GSOCK_NOERROR)
   {
     GAddress_destroy(address);
@@ -410,7 +680,7 @@ GAddress *GSocketBSD::GetLocal()
   return address;
 }
 
   return address;
 }
 
-GAddress *GSocketBSD::GetPeer()
+GAddress *GSocket::GetPeer()
 {
   assert(this);
 
 {
   assert(this);
 
@@ -427,13 +697,13 @@ GAddress *GSocketBSD::GetPeer()
  *  Sets up this socket as a server. The local address must have been
  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
  *  Sets up this socket as a server. The local address must have been
  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
- * 
+ *
  *  Error codes:
  *    GSOCK_INVSOCK - the socket is in use.
  *    GSOCK_INVADDR - the local address has not been set.
  *  Error codes:
  *    GSOCK_INVSOCK - the socket is in use.
  *    GSOCK_INVADDR - the local address has not been set.
- *    GSOCK_IOERR   - low-level error. 
+ *    GSOCK_IOERR   - low-level error.
  */
  */
-GSocketError GSocketBSD::SetServer()
+GSocketError GSocket::SetServer()
 {
   int arg = 1;
 
 {
   int arg = 1;
 
@@ -454,9 +724,8 @@ GSocketError GSocketBSD::SetServer()
   }
 
   /* Initialize all fields */
   }
 
   /* Initialize all fields */
-  m_stream   = TRUE;
-  m_server   = TRUE;
-  m_oriented = TRUE;
+  m_stream   = true;
+  m_server   = true;
 
   /* Create the socket */
   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 
   /* Create the socket */
   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
@@ -466,17 +735,26 @@ GSocketError GSocketBSD::SetServer()
     m_error = GSOCK_IOERR;
     return GSOCK_IOERR;
   }
     m_error = GSOCK_IOERR;
     return GSOCK_IOERR;
   }
-#if defined(__EMX__) || defined(__VISAGECPP__)
-  ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
-#else
-  ioctl(m_fd, FIONBIO, &arg);
+
+  /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
+#ifdef SO_NOSIGPIPE
+  setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));
 #endif
 #endif
-  EventLoop_Enable_Events();
+
+  ioctl(m_fd, FIONBIO, &arg);
+  if (m_use_events)
+    EnableEvents();
 
   /* allow a socket to re-bind if the socket is in the TIME_WAIT
      state after being previously closed.
    */
 
   /* allow a socket to re-bind if the socket is in the TIME_WAIT
      state after being previously closed.
    */
-  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));
+#ifdef SO_REUSEPORT
+    setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
+#endif
+  }
 
   /* Bind to the local address,
    * retrieve the actual address bound,
 
   /* Bind to the local address,
    * retrieve the actual address bound,
@@ -485,7 +763,7 @@ GSocketError GSocketBSD::SetServer()
   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
       (getsockname(m_fd,
                    m_local->m_addr,
   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();
       (listen(m_fd, 5) != 0))
   {
     Close();
@@ -506,21 +784,18 @@ GSocketError GSocketBSD::SetServer()
  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
  *    GSOCK_MEMERR     - couldn't allocate memory.
  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
  *    GSOCK_MEMERR     - couldn't allocate memory.
- *    GSOCK_IOERR      - low-level error. 
+ *    GSOCK_IOERR      - low-level error.
  */
  */
-GSocket *GSocketBSD::WaitConnection()
+GSocket *GSocket::WaitConnection()
 {
 {
-  struct sockaddr from;
-  SOCKLEN_T fromlen = sizeof(from);
+  wxSockAddr from;
+  WX_SOCKLEN_T fromlen = sizeof(from);
   GSocket *connection;
   GSocketError err;
   int arg = 1;
 
   assert(this);
 
   GSocket *connection;
   GSocketError err;
   int arg = 1;
 
   assert(this);
 
-  /* Reenable CONNECTION events */
-  Enable(GSOCK_CONNECTION);
-
   /* If the socket has already been created, we exit immediately */
   if (m_fd == INVALID_SOCKET || !m_server)
   {
   /* If the socket has already been created, we exit immediately */
   if (m_fd == INVALID_SOCKET || !m_server)
   {
@@ -533,7 +808,6 @@ GSocket *GSocketBSD::WaitConnection()
 
   if (!connection)
   {
 
   if (!connection)
   {
-    delete connection;
     m_error = GSOCK_MEMERR;
     return NULL;
   }
     m_error = GSOCK_MEMERR;
     return NULL;
   }
@@ -546,7 +820,10 @@ GSocket *GSocketBSD::WaitConnection()
     return NULL;
   }
 
     return NULL;
   }
 
-  connection->m_fd = accept(m_fd, &from, (SOCKLEN_T *) &fromlen);
+  connection->m_fd = accept(m_fd, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);
+
+  /* Reenable CONNECTION events */
+  Enable(GSOCK_CONNECTION);
 
   if (connection->m_fd == INVALID_SOCKET)
   {
 
   if (connection->m_fd == INVALID_SOCKET)
   {
@@ -560,9 +837,8 @@ GSocket *GSocketBSD::WaitConnection()
   }
 
   /* Initialize all fields */
   }
 
   /* Initialize all fields */
-  connection->m_server   = FALSE;
-  connection->m_stream   = TRUE;
-  connection->m_oriented = TRUE;
+  connection->m_server   = false;
+  connection->m_stream   = true;
 
   /* Setup the peer address field */
   connection->m_peer = GAddress_new();
 
   /* Setup the peer address field */
   connection->m_peer = GAddress_new();
@@ -572,31 +848,86 @@ GSocket *GSocketBSD::WaitConnection()
     m_error = GSOCK_MEMERR;
     return NULL;
   }
     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)
   {
   if (err != GSOCK_NOERROR)
   {
-    GAddress_destroy(connection->m_peer);
     delete connection;
     m_error = err;
     return NULL;
   }
     delete connection;
     m_error = err;
     return NULL;
   }
+
 #if defined(__EMX__) || defined(__VISAGECPP__)
   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 #else
   ioctl(connection->m_fd, FIONBIO, &arg);
 #endif
 #if defined(__EMX__) || defined(__VISAGECPP__)
   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 #else
   ioctl(connection->m_fd, FIONBIO, &arg);
 #endif
-  connection->EventLoop_Enable_Events();
+  if (m_use_events)
+    connection->Notify(true);
 
   return connection;
 }
 
 
   return connection;
 }
 
+void GSocket::Notify(bool flag)
+{
+    if (flag == m_use_events)
+        return;
+#if wxUSE_THREADS
+    // it is not safe to attach or detach i/o descriptor in child thread
+    wxASSERT_MSG( wxThread::IsMain(), "should be called in main thread only" );
+#endif
+    m_use_events = flag;
+    EnableEvents(flag);
+}
+
+void GSocket::EnableEvents(bool flag)
+{
+    if (flag)
+        GSocketManager::Get()->Enable_Events(this);
+    else
+        GSocketManager::Get()->Disable_Events(this);
+}
+
+bool GSocket::SetReusable()
+{
+    /* socket must not be null, and must not be in use/already bound */
+    if (this && m_fd == INVALID_SOCKET)
+    {
+        m_reusable = true;
+
+        return true;
+    }
+
+    return false;
+}
+
+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
 /* 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()
  *  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()
@@ -613,9 +944,9 @@ GSocket *GSocketBSD::WaitConnection()
  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
  *    GSOCK_MEMERR     - couldn't allocate memory.
  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
  *    GSOCK_MEMERR     - couldn't allocate memory.
- *    GSOCK_IOERR      - low-level error. 
+ *    GSOCK_IOERR      - low-level error.
  */
  */
-GSocketError GSocketBSD::Connect(GSocketStream stream)
+GSocketError GSocket::Connect(GSocketStream stream)
 {
   int err, ret;
   int arg = 1;
 {
   int err, ret;
   int arg = 1;
@@ -639,9 +970,8 @@ GSocketError GSocketBSD::Connect(GSocketStream stream)
 
   /* Streamed or dgram socket? */
   m_stream   = (stream == GSOCK_STREAMED);
 
   /* Streamed or dgram socket? */
   m_stream   = (stream == GSOCK_STREAMED);
-  m_oriented = TRUE;
-  m_server   = FALSE;
-  m_establishing = FALSE;
+  m_server   = false;
+  m_establishing = false;
 
   /* Create the socket */
   m_fd = socket(m_peer->m_realfamily,
 
   /* Create the socket */
   m_fd = socket(m_peer->m_realfamily,
@@ -652,16 +982,52 @@ GSocketError GSocketBSD::Connect(GSocketStream stream)
     m_error = GSOCK_IOERR;
     return GSOCK_IOERR;
   }
     m_error = GSOCK_IOERR;
     return GSOCK_IOERR;
   }
+
+  /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
+#ifdef SO_NOSIGPIPE
+  setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));
+#endif
+
 #if defined(__EMX__) || defined(__VISAGECPP__)
   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 #else
   ioctl(m_fd, FIONBIO, &arg);
 #endif
 #if defined(__EMX__) || defined(__VISAGECPP__)
   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 #else
   ioctl(m_fd, FIONBIO, &arg);
 #endif
-  EventLoop_Enable_Events();
+
+  // If the reuse flag is set, use the applicable socket reuse flags(s)
+  if (m_reusable)
+  {
+    setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
+#ifdef SO_REUSEPORT
+    setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
+#endif
+  }
+
+  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);
 
 
   /* Connect it to the peer address, with a timeout (see below) */
   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
 
+  /* We only call Enable_Events if we know we aren't shutting down the socket.
+   * NB: Enable_Events needs to be called whether the socket is blocking or
+   * non-blocking, it just shouldn't be called prior to knowing there is a
+   * connection _if_ blocking sockets are being used.
+   * If connect above returns 0, we are already connected and need to make the
+   * call to Enable_Events now.
+   */
+
+  if (m_use_events && (m_non_blocking || ret == 0))
+    EnableEvents();
+
   if (ret == -1)
   {
     err = errno;
   if (ret == -1)
   {
     err = errno;
@@ -682,9 +1048,11 @@ GSocketError GSocketBSD::Connect(GSocketStream stream)
       else
       {
         int error;
       else
       {
         int error;
-        SOCKLEN_T len = sizeof(error);
+        SOCKOPTLEN_T len = sizeof(error);
 
 
-        getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len);
+        getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
+        if (m_use_events)
+            EnableEvents();
 
         if (!error)
           return GSOCK_NOERROR;
 
         if (!error)
           return GSOCK_NOERROR;
@@ -699,7 +1067,7 @@ GSocketError GSocketBSD::Connect(GSocketStream stream)
      */
     if ((err == EINPROGRESS) && (m_non_blocking))
     {
      */
     if ((err == EINPROGRESS) && (m_non_blocking))
     {
-      m_establishing = TRUE;
+      m_establishing = true;
       m_error = GSOCK_WOULDBLOCK;
       return GSOCK_WOULDBLOCK;
     }
       m_error = GSOCK_WOULDBLOCK;
       return GSOCK_WOULDBLOCK;
     }
@@ -709,6 +1077,7 @@ GSocketError GSocketBSD::Connect(GSocketStream stream)
      */
     Close();
     m_error = GSOCK_IOERR;
      */
     Close();
     m_error = GSOCK_IOERR;
+
     return GSOCK_IOERR;
   }
 
     return GSOCK_IOERR;
   }
 
@@ -728,7 +1097,7 @@ GSocketError GSocketBSD::Connect(GSocketStream stream)
  *    GSOCK_INVADDR - the local address has not been set.
  *    GSOCK_IOERR   - low-level error.
  */
  *    GSOCK_INVADDR - the local address has not been set.
  *    GSOCK_IOERR   - low-level error.
  */
-GSocketError GSocketBSD::SetNonOriented()
+GSocketError GSocket::SetNonOriented()
 {
   int arg = 1;
 
 {
   int arg = 1;
 
@@ -747,9 +1116,8 @@ GSocketError GSocketBSD::SetNonOriented()
   }
 
   /* Initialize all fields */
   }
 
   /* Initialize all fields */
-  m_stream   = FALSE;
-  m_server   = FALSE;
-  m_oriented = FALSE;
+  m_stream   = false;
+  m_server   = false;
 
   /* Create the socket */
   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
 
   /* Create the socket */
   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
@@ -764,77 +1132,112 @@ GSocketError GSocketBSD::SetNonOriented()
 #else
   ioctl(m_fd, FIONBIO, &arg);
 #endif
 #else
   ioctl(m_fd, FIONBIO, &arg);
 #endif
-  EventLoop_Enable_Events();
+  if (m_use_events)
+    EnableEvents();
 
 
-  /* 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));
+#ifdef SO_REUSEPORT
+    setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
+#endif
   }
 
   }
 
+  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;
 }
 
 /* Generic IO */
 
 /* Like recv(), send(), ... */
   return GSOCK_NOERROR;
 }
 
 /* Generic IO */
 
 /* Like recv(), send(), ... */
-int GSocketBSD::Read(char *buffer, int size)
+int GSocket::Read(char *buffer, int size)
 {
   int ret;
 
   assert(this);
 
 {
   int ret;
 
   assert(this);
 
-  /* When using CFSocket we MUST NOT reenable events until we finish reading */
-#ifndef __DARWIN__
-  /* Reenable INPUT events */
-  Enable(GSOCK_INPUT);
-#endif
-
   if (m_fd == INVALID_SOCKET || m_server)
   {
     m_error = GSOCK_INVSOCK;
     return -1;
   }
 
   if (m_fd == INVALID_SOCKET || m_server)
   {
     m_error = GSOCK_INVSOCK;
     return -1;
   }
 
-  /* If the socket is blocking, wait for data (with a timeout) */
-  if (Input_Timeout() == GSOCK_TIMEDOUT)
-    return -1;
+  /* Disable events during query of socket status */
+  Disable(GSOCK_INPUT);
 
 
-  /* Read the data */
-  if (m_stream)
-    ret = Recv_Stream(buffer, size);
+  /* If the socket is blocking, wait for data (with a timeout) */
+  if (Input_Timeout() == GSOCK_TIMEDOUT) {
+    m_error = GSOCK_TIMEDOUT;
+    /* Don't return here immediately, otherwise socket events would not be
+     * re-enabled! */
+    ret = -1;
+  }
   else
   else
-    ret = Recv_Dgram(buffer, size);
-    
-  if (ret == -1)
   {
   {
-    if (errno == EWOULDBLOCK)
-      m_error = GSOCK_WOULDBLOCK;
+    /* Read the data */
+    if (m_stream)
+      ret = Recv_Stream(buffer, size);
     else
     else
-      m_error = GSOCK_IOERR;
+      ret = Recv_Dgram(buffer, size);
+
+    /*
+     * If recv returned zero for a TCP socket (if m_stream == NULL, it's an UDP
+     * socket and empty datagrams are possible), then the connection has been
+     * gracefully closed.
+     *
+     * Otherwise, recv has returned an error (-1), in which case we have lost
+     * the socket only if errno does _not_ indicate that there may be more data
+     * to read.
+     */
+    if ((ret == 0) && m_stream)
+    {
+      /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */
+      if (m_use_events)
+      {
+        m_detected = GSOCK_LOST_FLAG;
+        Detected_Read();
+        return 0;
+      }
+    }
+    else if (ret == -1)
+    {
+      if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
+        m_error = GSOCK_WOULDBLOCK;
+      else
+        m_error = GSOCK_IOERR;
+    }
   }
   }
-  
-#ifdef __DARWIN__
-  /* Reenable INPUT events */
+
+  /* Enable events again now that we are done processing */
   Enable(GSOCK_INPUT);
   Enable(GSOCK_INPUT);
-#endif
 
   return ret;
 }
 
 
   return ret;
 }
 
-int GSocketBSD::Write(const char *buffer, int size)
-{                        
+int GSocket::Write(const char *buffer, int size)
+{
   int ret;
 
   assert(this);
   int ret;
 
   assert(this);
-  
+
   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
 
   if (m_fd == INVALID_SOCKET || m_server)
   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
 
   if (m_fd == INVALID_SOCKET || m_server)
@@ -856,12 +1259,12 @@ int GSocketBSD::Write(const char *buffer, int size)
     ret = Send_Stream(buffer, size);
   else
     ret = Send_Dgram(buffer, size);
     ret = Send_Stream(buffer, size);
   else
     ret = Send_Dgram(buffer, size);
-    
+
   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
 
   if (ret == -1)
   {
   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
 
   if (ret == -1)
   {
-    if (errno == EWOULDBLOCK)
+    if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
     {
       m_error = GSOCK_WOULDBLOCK;
       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
     {
       m_error = GSOCK_WOULDBLOCK;
       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
@@ -878,9 +1281,10 @@ int GSocketBSD::Write(const char *buffer, int size)
      * will further OUTPUT events be posted.
      */
     Enable(GSOCK_OUTPUT);
      * will further OUTPUT events be posted.
      */
     Enable(GSOCK_OUTPUT);
+
     return -1;
   }
     return -1;
   }
-  
+
   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
 
   return ret;
   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
 
   return ret;
@@ -893,129 +1297,103 @@ int GSocketBSD::Write(const char *buffer, int size)
  *  performed. This function won't block, regardless of the
  *  mode (blocking | nonblocking) of the socket.
  */
  *  performed. This function won't block, regardless of the
  *  mode (blocking | nonblocking) of the socket.
  */
-GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags)
+GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
 {
 {
-  if (!GSocketBSDGUIShim::UseGUI())
-  {
+  assert(this);
 
 
-    GSocketEventFlags result = 0;
-    fd_set readfds;
-    fd_set writefds;
-    fd_set exceptfds;
-    struct timeval tv;
+  GSocketEventFlags result = 0;
+  fd_set readfds;
+  fd_set writefds;
+  fd_set exceptfds;
+  struct timeval tv;
 
 
-    /* Do not use a static struct, Linux can garble it */
-    tv.tv_sec = m_timeout / 1000;
-    tv.tv_usec = (m_timeout % 1000) / 1000;
+  if (m_fd == -1)
+    return (GSOCK_LOST_FLAG & flags);
 
 
-    assert(this);
+  /* Do not use a static struct, Linux can garble it */
+  tv.tv_sec = 0;
+  tv.tv_usec = 0;
 
 
-    FD_ZERO(&readfds);
-    FD_ZERO(&writefds);
-    FD_ZERO(&exceptfds);
-    FD_SET(m_fd, &readfds);
-    if (flags & GSOCK_OUTPUT_FLAG)
-      FD_SET(m_fd, &writefds);
-    FD_SET(m_fd, &exceptfds);
+  wxFD_ZERO(&readfds);
+  wxFD_ZERO(&writefds);
+  wxFD_ZERO(&exceptfds);
+  wxFD_SET(m_fd, &readfds);
+  if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
+    wxFD_SET(m_fd, &writefds);
+  wxFD_SET(m_fd, &exceptfds);
 
 
-    /* Check 'sticky' CONNECTION flag first */
-    result |= (GSOCK_CONNECTION_FLAG & m_detected);
+  /* 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;
+  /* 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);
+  }
 
 
-      return (GSOCK_LOST_FLAG & flags);
-    }
+  /* Try select now */
+  if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) < 0)
+  {
+    /* What to do here? */
+    return (result & flags);
+  }
 
 
-    /* Try select now */
-    if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
-    {
-      /* What to do here? */
-      return (result & flags);
-    }
+  /* Check for exceptions and errors */
+  if (wxFD_ISSET(m_fd, &exceptfds))
+  {
+    m_establishing = false;
+    m_detected = GSOCK_LOST_FLAG;
 
 
-    /* Check for readability */
-    if (FD_ISSET(m_fd, &readfds))
-    {
-      char c;
+    /* LOST event: Abort any further processing */
+    return (GSOCK_LOST_FLAG & flags);
+  }
 
 
-      if (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 readability */
+  if (wxFD_ISSET(m_fd, &readfds))
+  {
+    result |= GSOCK_INPUT_FLAG;
 
 
-    /* Check for writability */
-    if (FD_ISSET(m_fd, &writefds))
+    if (m_server && m_stream)
     {
     {
-      if (m_establishing && !m_server)
-      {
-        int error;
-        SOCKLEN_T len = sizeof(error);
-
-        m_establishing = FALSE;
+      /* This is a TCP server socket that detected a connection.
+         While the INPUT_FLAG is also set, it doesn't matter on
+         this kind of  sockets, as we can only Accept() from them. */
+      m_detected |= GSOCK_CONNECTION_FLAG;
+    }
+  }
 
 
-        getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
+  /* Check for writability */
+  if (wxFD_ISSET(m_fd, &writefds))
+  {
+    if (m_establishing && !m_server)
+    {
+      int error;
+      SOCKOPTLEN_T len = sizeof(error);
+      m_establishing = false;
+      getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
 
 
-        if (error)
-        {
-          m_detected = GSOCK_LOST_FLAG;
+      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;
-        }
+        /* LOST event: Abort any further processing */
+        return (GSOCK_LOST_FLAG & flags);
       }
       else
       {
       }
       else
       {
-        result |= GSOCK_OUTPUT_FLAG;
+        m_detected |= GSOCK_CONNECTION_FLAG;
       }
     }
       }
     }
-
-    /* Check for exceptions and errors (is this useful in Unices?) */
-    if (FD_ISSET(m_fd, &exceptfds))
+    else
     {
     {
-      m_establishing = FALSE;
-      m_detected = GSOCK_LOST_FLAG;
-
-      /* LOST event: Abort any further processing */
-      return (GSOCK_LOST_FLAG & flags);
+      result |= GSOCK_OUTPUT_FLAG;
     }
     }
-
-    return (result & flags);
-
   }
   }
-  else
-  {
 
 
-    assert(this);
-    return flags & m_detected;
-
-  }
+  return (result | m_detected) & flags;
 }
 
 /* Flags */
 }
 
 /* Flags */
@@ -1024,7 +1402,7 @@ GSocketEventFlags GSocketBSD::Select(GSocketEventFlags flags)
  *  Sets the socket to non-blocking mode. All IO calls will return
  *  immediately.
  */
  *  Sets the socket to non-blocking mode. All IO calls will return
  *  immediately.
  */
-void GSocketBSD::SetNonBlocking(int non_block)
+void GSocket::SetNonBlocking(bool non_block)
 {
   assert(this);
 
 {
   assert(this);
 
@@ -1037,7 +1415,7 @@ void GSocketBSD::SetNonBlocking(int non_block)
  *  Sets the timeout for blocking calls. Time is expressed in
  *  milliseconds.
  */
  *  Sets the timeout for blocking calls. Time is expressed in
  *  milliseconds.
  */
-void GSocketBSD::SetTimeout(unsigned long millisec)
+void GSocket::SetTimeout(unsigned long millisec)
 {
   assert(this);
 
 {
   assert(this);
 
@@ -1045,11 +1423,11 @@ void GSocketBSD::SetTimeout(unsigned long millisec)
 }
 
 /* GSocket_GetError:
 }
 
 /* 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.
  */
  *  operations do not clear this back to GSOCK_NOERROR, so use it only
  *  after an error.
  */
-GSocketError GSocketBSD::GetError()
+GSocketError WXDLLIMPEXP_NET GSocket::GetError()
 {
   assert(this);
 
 {
   assert(this);
 
@@ -1063,14 +1441,14 @@ GSocketError GSocketBSD::GetError()
  *   operation, there is still data available, the callback function will
  *   be called again.
  * GSOCK_OUTPUT:
  *   operation, there is still data available, the callback function will
  *   be called again.
  * GSOCK_OUTPUT:
- *   The socket is available for writing. That is, the next write call 
+ *   The socket is available for writing. That is, the next write call
  *   won't block. This event is generated only once, when the connection is
  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
  *   when the output buffer empties again. This means that the app should
  *   assume that it can write since the first OUTPUT event, and no more
  *   OUTPUT events will be generated unless an error occurs.
  * GSOCK_CONNECTION:
  *   won't block. This event is generated only once, when the connection is
  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
  *   when the output buffer empties again. This means that the app should
  *   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:
  *   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:
@@ -1086,7 +1464,7 @@ GSocketError GSocketBSD::GetError()
  *
  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
  */
  *
  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
  */
-void GSocketBSD::SetCallback(GSocketEventFlags flags,
+void GSocket::SetCallback(GSocketEventFlags flags,
                          GSocketCallback callback, char *cdata)
 {
   int count;
                          GSocketCallback callback, char *cdata)
 {
   int count;
@@ -1107,7 +1485,7 @@ void GSocketBSD::SetCallback(GSocketEventFlags flags,
  *  Disables all callbacks specified by 'flags', which may be a
  *  combination of flags OR'ed toghether.
  */
  *  Disables all callbacks specified by 'flags', which may be a
  *  combination of flags OR'ed toghether.
  */
-void GSocketBSD::UnsetCallback(GSocketEventFlags flags)
+void GSocket::UnsetCallback(GSocketEventFlags flags)
 {
   int count;
 
 {
   int count;
 
@@ -1123,31 +1501,54 @@ void GSocketBSD::UnsetCallback(GSocketEventFlags flags)
   }
 }
 
   }
 }
 
+GSocketError GSocket::GetSockOpt(int level, int optname,
+                                void *optval, int *optlen)
+{
+    if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
+        return GSOCK_NOERROR;
 
 
-#define CALL_CALLBACK(event) {                                  \
-  Disable(event);                                      \
-  if (m_cbacks[event])                                          \
-    m_cbacks[event](this, event, m_data[event]);      \
+    return GSOCK_OPTERR;
 }
 
 }
 
+GSocketError GSocket::SetSockOpt(int level, int optname,
+                                const void *optval, int optlen)
+{
+    if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
+        return GSOCK_NOERROR;
 
 
-void GSocketBSD::Enable(GSocketEvent event)
+    return GSOCK_OPTERR;
+}
+
+#define CALL_CALLBACK(socket, event) {                                  \
+  socket->Disable(event);                                               \
+  if (socket->m_cbacks[event])                                          \
+    socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
+}
+
+
+void GSocket::Enable(GSocketEvent event)
 {
 {
-  m_detected &= ~(1 << event);
-  EventLoop_Install_Callback(event);
+    if (m_use_events)
+    {
+        m_detected &= ~(1 << event);
+        GSocketManager::Get()->Install_Callback(this, event);
+    }
 }
 
 }
 
-void GSocketBSD::Disable(GSocketEvent event)
+void GSocket::Disable(GSocketEvent event)
 {
 {
-  m_detected |= (1 << event);
-  EventLoop_Uninstall_Callback(event);
+    if (m_use_events)
+    {
+        m_detected |= (1 << event);
+        GSocketManager::Get()->Uninstall_Callback(this, event);
+    }
 }
 
 /* _GSocket_Input_Timeout:
  *  For blocking sockets, wait until data is available or
  *  until timeout ellapses.
  */
 }
 
 /* _GSocket_Input_Timeout:
  *  For blocking sockets, wait until data is available or
  *  until timeout ellapses.
  */
-GSocketError GSocketBSD::Input_Timeout()
+GSocketError GSocket::Input_Timeout()
 {
   struct timeval tv;
   fd_set readfds;
 {
   struct timeval tv;
   fd_set readfds;
@@ -1159,8 +1560,8 @@ GSocketError GSocketBSD::Input_Timeout()
 
   if (!m_non_blocking)
   {
 
   if (!m_non_blocking)
   {
-    FD_ZERO(&readfds);
-    FD_SET(m_fd, &readfds);
+    wxFD_ZERO(&readfds);
+    wxFD_SET(m_fd, &readfds);
     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
     if (ret == 0)
     {
     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
     if (ret == 0)
     {
@@ -1168,6 +1569,7 @@ GSocketError GSocketBSD::Input_Timeout()
       m_error = GSOCK_TIMEDOUT;
       return GSOCK_TIMEDOUT;
     }
       m_error = GSOCK_TIMEDOUT;
       return GSOCK_TIMEDOUT;
     }
+
     if (ret == -1)
     {
       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
     if (ret == -1)
     {
       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
@@ -1179,6 +1581,7 @@ GSocketError GSocketBSD::Input_Timeout()
       return GSOCK_TIMEDOUT;
     }
   }
       return GSOCK_TIMEDOUT;
     }
   }
+
   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
 
@@ -1186,7 +1589,7 @@ GSocketError GSocketBSD::Input_Timeout()
  *  For blocking sockets, wait until data can be sent without
  *  blocking or until timeout ellapses.
  */
  *  For blocking sockets, wait until data can be sent without
  *  blocking or until timeout ellapses.
  */
-GSocketError GSocketBSD::Output_Timeout()
+GSocketError GSocket::Output_Timeout()
 {
   struct timeval tv;
   fd_set writefds;
 {
   struct timeval tv;
   fd_set writefds;
@@ -1200,8 +1603,8 @@ GSocketError GSocketBSD::Output_Timeout()
 
   if (!m_non_blocking)
   {
 
   if (!m_non_blocking)
   {
-    FD_ZERO(&writefds);
-    FD_SET(m_fd, &writefds);
+    wxFD_ZERO(&writefds);
+    wxFD_SET(m_fd, &writefds);
     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
     if (ret == 0)
     {
     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
     if (ret == 0)
     {
@@ -1209,6 +1612,7 @@ GSocketError GSocketBSD::Output_Timeout()
       m_error = GSOCK_TIMEDOUT;
       return GSOCK_TIMEDOUT;
     }
       m_error = GSOCK_TIMEDOUT;
       return GSOCK_TIMEDOUT;
     }
+
     if (ret == -1)
     {
       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
     if (ret == -1)
     {
       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
@@ -1219,10 +1623,13 @@ GSocketError GSocketBSD::Output_Timeout()
       m_error = GSOCK_TIMEDOUT;
       return GSOCK_TIMEDOUT;
     }
       m_error = GSOCK_TIMEDOUT;
       return GSOCK_TIMEDOUT;
     }
-    if ( ! FD_ISSET(m_fd, &writefds) ) {
+
+    if ( ! wxFD_ISSET(m_fd, &writefds) )
+    {
         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
     }
         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
     }
-    else {
+    else
+    {
         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
     }
   }
         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
     }
   }
@@ -1234,21 +1641,32 @@ GSocketError GSocketBSD::Output_Timeout()
   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
 
-int GSocketBSD::Recv_Stream(char *buffer, int size)
+int GSocket::Recv_Stream(char *buffer, int size)
 {
 {
-  return recv(m_fd, buffer, size, 0);
+  int ret;
+  do
+  {
+    ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
+  }
+  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+
+  return ret;
 }
 
 }
 
-int GSocketBSD::Recv_Dgram(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;
 
   fromlen = sizeof(from);
 
   int ret;
   GSocketError err;
 
   fromlen = sizeof(from);
 
-  ret = recvfrom(m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen);
+  do
+  {
+    ret = recvfrom(m_fd, buffer, size, 0, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);
+  }
+  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
 
   if (ret == -1)
     return -1;
 
   if (ret == -1)
     return -1;
@@ -1263,7 +1681,8 @@ int GSocketBSD::Recv_Dgram(char *buffer, int size)
       return -1;
     }
   }
       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);
   if (err != GSOCK_NOERROR)
   {
     GAddress_destroy(m_peer);
@@ -1275,22 +1694,24 @@ int GSocketBSD::Recv_Dgram(char *buffer, int size)
   return ret;
 }
 
   return ret;
 }
 
-int GSocketBSD::Send_Stream(const char *buffer, int size)
+int GSocket::Send_Stream(const char *buffer, int size)
 {
   int ret;
 
 {
   int ret;
 
-#ifndef __VISAGECPP__
   MASK_SIGNAL();
   MASK_SIGNAL();
-  ret = send(m_fd, buffer, size, 0);
+
+  do
+  {
+    ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
+  }
+  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+
   UNMASK_SIGNAL();
   UNMASK_SIGNAL();
-#else
-  ret = send(m_fd, (char *)buffer, size, 0);
-#endif
 
   return ret;
 }
 
 
   return ret;
 }
 
-int GSocketBSD::Send_Dgram(const char *buffer, int size)
+int GSocket::Send_Dgram(const char *buffer, int size)
 {
   struct sockaddr *addr;
   int len, ret;
 {
   struct sockaddr *addr;
   int len, ret;
@@ -1309,13 +1730,15 @@ int GSocketBSD::Send_Dgram(const char *buffer, int size)
     return -1;
   }
 
     return -1;
   }
 
-#ifndef __VISAGECPP__
   MASK_SIGNAL();
   MASK_SIGNAL();
-  ret = sendto(m_fd, buffer, size, 0, addr, len);
+
+  do
+  {
+    ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
+  }
+  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+
   UNMASK_SIGNAL();
   UNMASK_SIGNAL();
-#else
-  ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
-#endif
 
   /* Frees memory allocated from _GAddress_translate_to */
   free(addr);
 
   /* Frees memory allocated from _GAddress_translate_to */
   free(addr);
@@ -1323,50 +1746,80 @@ int GSocketBSD::Send_Dgram(const char *buffer, int size)
   return ret;
 }
 
   return ret;
 }
 
-void GSocketBSD::Detected_Read()
+void GSocket::Detected_Read()
 {
   char c;
 
 {
   char c;
 
+  /* Safeguard against straggling call to Detected_Read */
+  if (m_fd == INVALID_SOCKET)
+  {
+    return;
+  }
+
   /* If we have already detected a LOST event, then don't try
    * to do any further processing.
    */
   if ((m_detected & GSOCK_LOST_FLAG) != 0)
   {
   /* 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;
+    m_establishing = false;
 
 
-    CALL_CALLBACK(GSOCK_LOST);
+    CALL_CALLBACK(this, GSOCK_LOST);
     Shutdown();
     return;
   }
 
     Shutdown();
     return;
   }
 
-  if (recv(m_fd, &c, 1, MSG_PEEK) > 0)
+  int num =  recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
+
+  if (num > 0)
   {
   {
-    CALL_CALLBACK(GSOCK_INPUT);
+    CALL_CALLBACK(this, GSOCK_INPUT);
   }
   else
   {
     if (m_server && m_stream)
     {
   }
   else
   {
     if (m_server && m_stream)
     {
-      CALL_CALLBACK(GSOCK_CONNECTION);
+      CALL_CALLBACK(this, GSOCK_CONNECTION);
+    }
+    else if (num == 0)
+    {
+      if (m_stream)
+      {
+        /* graceful shutdown */
+        CALL_CALLBACK(this, GSOCK_LOST);
+        Shutdown();
+      }
+      else
+      {
+        /* Empty datagram received */
+        CALL_CALLBACK(this, GSOCK_INPUT);
+      }
     }
     else
     {
     }
     else
     {
-      CALL_CALLBACK(GSOCK_LOST);
-      Shutdown();
+      /* Do not throw a lost event in cases where the socket isn't really lost */
+      if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
+      {
+        CALL_CALLBACK(this, GSOCK_INPUT);
+      }
+      else
+      {
+        CALL_CALLBACK(this, GSOCK_LOST);
+        Shutdown();
+      }
     }
   }
 }
 
     }
   }
 }
 
-void GSocketBSD::Detected_Write()
+void GSocket::Detected_Write()
 {
   /* If we have already detected a LOST event, then don't try
    * to do any further processing.
    */
   if ((m_detected & GSOCK_LOST_FLAG) != 0)
   {
 {
   /* 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;
+    m_establishing = false;
 
 
-    CALL_CALLBACK(GSOCK_LOST);
+    CALL_CALLBACK(this, GSOCK_LOST);
     Shutdown();
     return;
   }
     Shutdown();
     return;
   }
@@ -1374,60 +1827,45 @@ void GSocketBSD::Detected_Write()
   if (m_establishing && !m_server)
   {
     int error;
   if (m_establishing && !m_server)
   {
     int error;
-    SOCKLEN_T len = sizeof(error);
+    SOCKOPTLEN_T len = sizeof(error);
 
 
-    m_establishing = FALSE;
+    m_establishing = false;
 
 
-    getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
+    getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
 
     if (error)
     {
 
     if (error)
     {
-      CALL_CALLBACK(GSOCK_LOST);
+      CALL_CALLBACK(this, GSOCK_LOST);
       Shutdown();
     }
     else
     {
       Shutdown();
     }
     else
     {
-      CALL_CALLBACK(GSOCK_CONNECTION);
+      CALL_CALLBACK(this, GSOCK_CONNECTION);
       /* We have to fire this event by hand because CONNECTION (for clients)
        * and OUTPUT are internally the same and we just disabled CONNECTION
        * events with the above macro.
        */
       /* We have to fire this event by hand because CONNECTION (for clients)
        * and OUTPUT are internally the same and we just disabled CONNECTION
        * events with the above macro.
        */
-      CALL_CALLBACK(GSOCK_OUTPUT);
+      CALL_CALLBACK(this, GSOCK_OUTPUT);
     }
   }
   else
   {
     }
   }
   else
   {
-    CALL_CALLBACK(GSOCK_OUTPUT);
+    CALL_CALLBACK(this, GSOCK_OUTPUT);
   }
 }
 
 /* Compatibility functions for GSocket */
 GSocket *GSocket_new(void)
 {
   }
 }
 
 /* Compatibility functions for GSocket */
 GSocket *GSocket_new(void)
 {
-    GSocket *newsocket = new GSocketBSDGUIShim();
-    if(newsocket->IsOk())
+    GSocket *newsocket = new GSocket();
+    if (newsocket->IsOk())
         return newsocket;
         return newsocket;
-    delete newsocket;
-    return NULL;
-}
-
-void GSocket_destroy(GSocket *socket)
-{
-    assert(socket);
 
 
-    /* Check that the socket is really shutdowned */
-    if (socket->m_fd != INVALID_SOCKET)
-      socket->Shutdown();
+    delete newsocket;
 
 
-    delete socket;
+    return NULL;
 }
 
 }
 
-void GSocketBSD::_GSocket_Detected_Read(GSocket *socket)
-{   socket->Detected_Read(); }
-
-void GSocketBSD::_GSocket_Detected_Write(GSocket *socket)
-{   socket->Detected_Write(); }
-
 /*
  * -------------------------------------------------------------------------
  * GAddress
 /*
  * -------------------------------------------------------------------------
  * GAddress
@@ -1541,11 +1979,11 @@ GSocketError _GAddress_translate_from(GAddress *address,
     case AF_UNIX:
       address->m_family = GSOCK_UNIX;
       break;
     case AF_UNIX:
       address->m_family = GSOCK_UNIX;
       break;
-#ifdef AF_INET6
+#if wxUSE_IPV6
     case AF_INET6:
       address->m_family = GSOCK_INET6;
       break;
     case AF_INET6:
       address->m_family = GSOCK_INET6;
       break;
-#endif
+#endif // wxUSE_IPV6
     default:
     {
       address->m_error = GSOCK_INVOP;
     default:
     {
       address->m_error = GSOCK_INVOP;
@@ -1564,6 +2002,7 @@ GSocketError _GAddress_translate_from(GAddress *address,
     address->m_error = GSOCK_MEMERR;
     return GSOCK_MEMERR;
   }
     address->m_error = GSOCK_MEMERR;
     return GSOCK_MEMERR;
   }
+
   memcpy(address->m_addr, addr, len);
 
   return GSOCK_NOERROR;
   memcpy(address->m_addr, addr, len);
 
   return GSOCK_NOERROR;
@@ -1630,30 +2069,48 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   if (inet_aton(hostname, addr) == 0)
   {
 #elif defined(HAVE_INET_ADDR)
   if (inet_aton(hostname, addr) == 0)
   {
 #elif defined(HAVE_INET_ADDR)
-  if ( (addr->s_addr = inet_addr(hostname)) == -1 )
+  if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
   {
 #else
   /* Use gethostbyname by default */
   {
 #else
   /* Use gethostbyname by default */
-  int val = 1;  //VA doesn't like constants in conditional expressions at all
+#ifndef __WXMAC__
+  int val = 1;  /* VA doesn't like constants in conditional expressions */
   if (val)
   if (val)
+#endif
   {
 #endif
     struct in_addr *array_addr;
 
     /* It is a real name, we solve it */
   {
 #endif
     struct in_addr *array_addr;
 
     /* It is a real name, we solve it */
-    if ((he = gethostbyname(hostname)) == NULL)
+    struct hostent h;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+    struct hostent_data buffer;
+#else
+    char buffer[1024];
+#endif
+    int err;
+    he = wxGethostbyname_r(hostname, &h, (void*)&buffer, sizeof(buffer), &err);
+    if (he == NULL)
     {
       /* Reset to invalid address */
       addr->s_addr = INADDR_NONE;
       address->m_error = GSOCK_NOHOST;
       return GSOCK_NOHOST;
     }
     {
       /* Reset to invalid address */
       addr->s_addr = INADDR_NONE;
       address->m_error = GSOCK_NOHOST;
       return GSOCK_NOHOST;
     }
+
     array_addr = (struct in_addr *) *(he->h_addr_list);
     addr->s_addr = array_addr[0].s_addr;
   }
     array_addr = (struct in_addr *) *(he->h_addr_list);
     addr->s_addr = array_addr[0].s_addr;
   }
+
   return GSOCK_NOERROR;
 }
 
   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);
 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
 {
   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
@@ -1669,7 +2126,7 @@ GSocketError GAddress_INET_SetHostAddress(GAddress *address,
   CHECK_ADDRESS(address, INET);
 
   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
   CHECK_ADDRESS(address, INET);
 
   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
-  addr->s_addr = hostaddr;
+  addr->s_addr = htonl(hostaddr);
 
   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
@@ -1688,8 +2145,15 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
     address->m_error = GSOCK_INVPORT;
     return GSOCK_INVPORT;
   }
     address->m_error = GSOCK_INVPORT;
     return GSOCK_INVPORT;
   }
- 
-  se = getservbyname(port, protocol);
+
+#if defined(HAVE_FUNC_GETSERVBYNAME_R_4)
+    struct servent_data buffer;
+#else
+  char buffer[1024];
+#endif
+  struct servent serv;
+  se = wxGetservbyname_r(port, protocol, &serv,
+                        (void*)&buffer, sizeof(buffer));
   if (!se)
   {
     /* the cast to int suppresses compiler warnings about subscript having the
   if (!se)
   {
     /* the cast to int suppresses compiler warnings about subscript having the
@@ -1720,7 +2184,7 @@ GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
 
   assert(address != NULL);
   CHECK_ADDRESS(address, INET);
 
   assert(address != NULL);
   CHECK_ADDRESS(address, INET);
- 
+
   addr = (struct sockaddr_in *)address->m_addr;
   addr->sin_port = htons(port);
 
   addr = (struct sockaddr_in *)address->m_addr;
   addr->sin_port = htons(port);
 
@@ -1733,13 +2197,21 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t
   char *addr_buf;
   struct sockaddr_in *addr;
 
   char *addr_buf;
   struct sockaddr_in *addr;
 
-  assert(address != NULL); 
+  assert(address != NULL);
   CHECK_ADDRESS(address, INET);
 
   addr = (struct sockaddr_in *)address->m_addr;
   addr_buf = (char *)&(addr->sin_addr);
 
   CHECK_ADDRESS(address, INET);
 
   addr = (struct sockaddr_in *)address->m_addr;
   addr_buf = (char *)&(addr->sin_addr);
 
-  he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
+  struct hostent temphost;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+  struct hostent_data buffer;
+#else
+  char buffer[1024];
+#endif
+  int err;
+  he = wxGethostbyaddr_r(addr_buf, sizeof(addr->sin_addr), AF_INET, &temphost,
+                        (void*)&buffer, sizeof(buffer), &err);
   if (he == NULL)
   {
     address->m_error = GSOCK_NOHOST;
   if (he == NULL)
   {
     address->m_error = GSOCK_NOHOST;
@@ -1755,25 +2227,188 @@ unsigned long GAddress_INET_GetHostAddress(GAddress *address)
 {
   struct sockaddr_in *addr;
 
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL); 
-  CHECK_ADDRESS_RETVAL(address, INET, 0); 
+  assert(address != NULL);
+  CHECK_ADDRESS_RETVAL(address, INET, 0);
 
   addr = (struct sockaddr_in *)address->m_addr;
 
 
   addr = (struct sockaddr_in *)address->m_addr;
 
-  return addr->sin_addr.s_addr;
+  return ntohl(addr->sin_addr.s_addr);
 }
 
 unsigned short GAddress_INET_GetPort(GAddress *address)
 {
   struct sockaddr_in *addr;
 
 }
 
 unsigned short GAddress_INET_GetPort(GAddress *address)
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL); 
-  CHECK_ADDRESS_RETVAL(address, INET, 0); 
+  assert(address != NULL);
+  CHECK_ADDRESS_RETVAL(address, INET, 0);
 
   addr = (struct sockaddr_in *)address->m_addr;
   return ntohs(addr->sin_port);
 }
 
 
   addr = (struct sockaddr_in *)address->m_addr;
   return ntohs(addr->sin_port);
 }
 
+#if wxUSE_IPV6
+/*
+ * -------------------------------------------------------------------------
+ * Internet IPv6 address family
+ * -------------------------------------------------------------------------
+ */
+
+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)
+{
+  assert(address != NULL);
+  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)
+{
+  assert(address != NULL);
+
+  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)
+{
+  assert(address != NULL);
+
+  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;
+
+  assert(address != NULL);
+  CHECK_ADDRESS(address, INET6);
+
+  if (!port)
+  {
+    address->m_error = GSOCK_INVPORT;
+    return GSOCK_INVPORT;
+  }
+
+  se = getservbyname(port, protocol);
+  if (!se)
+  {
+    if (isdigit(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;
+
+  assert(address != NULL);
+  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;
+
+  assert(address != NULL);
+  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)
+{
+  assert(address != NULL);
+  assert(hostaddr != NULL);
+  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)
+{
+  assert(address != NULL);
+  CHECK_ADDRESS_RETVAL(address, INET6, 0);
+
+  return ntohs( ((struct sockaddr_in6 *)address->m_addr)->sin6_port );
+}
+
+#endif // wxUSE_IPV6
+
 /*
  * -------------------------------------------------------------------------
  * Unix address family
 /*
  * -------------------------------------------------------------------------
  * Unix address family
@@ -1805,9 +2440,9 @@ GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
 {
   struct sockaddr_un *addr;
 
 {
   struct sockaddr_un *addr;
 
-  assert(address != NULL); 
+  assert(address != NULL);
 
 
-  CHECK_ADDRESS(address, UNIX); 
+  CHECK_ADDRESS(address, UNIX);
 
   addr = ((struct sockaddr_un *)address->m_addr);
   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
 
   addr = ((struct sockaddr_un *)address->m_addr);
   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
@@ -1831,4 +2466,3 @@ GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
 }
 #endif  /* !defined(__VISAGECPP__) */
 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
 }
 #endif  /* !defined(__VISAGECPP__) */
 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
-
wxWidgets (Impactor)