wxColour source cleaning. Corrections to 'const unsigned char' within wxColour docs.

[wxWidgets.git] / src / unix / gsocket.cpp

diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp
index 9713fde61e57af85da5d29582c2f010e4aebffff..874098d3b648c7a006486039d1a17cf4dd0336d7 100644 (file)
--- a/src/unix/gsocket.cpp
+++ b/src/unix/gsocket.cpp
@@ -1,27 +1,28 @@
 /* -------------------------------------------------------------------------
 /* -------------------------------------------------------------------------

- * 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 wxWindows 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$

  * -------------------------------------------------------------------------
  */
 
  * -------------------------------------------------------------------------
  */
 

-/*
- * PLEASE don't put C++ comments here - this is a C source file.
- */
+#if defined(__WATCOMC__)
+#include "wx/wxprec.h"
+#include <errno.h>
+#include <nerrno.h>
+#endif

 
 #ifndef __GSOCKET_STANDALONE__
 
 #ifndef __GSOCKET_STANDALONE__

-#include "wx/setup.h"
+#include "wx/defs.h"

 #endif
 
 #if defined(__VISAGECPP__)
 #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      */
-#include "wx/defs.h"

 #define BSD_SELECT /* use Berkley Sockets select */
 #endif
 
 #define BSD_SELECT /* use Berkley Sockets select */
 #endif
 


@@ -87,6 +88,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>


@@ -97,24 +102,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.
  */


@@ -135,23 +149,44 @@ 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"
 #else
 #  include "gsockunx.h"
 #  include "gsocket.h"
 #  include "wx/gsocket.h"
 #else
 #  include "gsockunx.h"
 #  include "gsocket.h"

+#  ifndef WXUNUSED
+#    define WXUNUSED(x)
+#  endif

 #endif /* __GSOCKET_STANDALONE__ */
 
 /* debugging helpers */
 #endif /* __GSOCKET_STANDALONE__ */
 
 /* debugging helpers */


@@ -186,17 +221,17 @@ void GSocketGUIFunctionsTableNull::OnExit()
 {}
 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
 {   return false; }
 {}
 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
 {   return false; }

-bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *socket)
+bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))

 {   return true; }
 {   return true; }

-void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *socket)
+void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket))

 {}
 {}

-void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *socket, GSocketEvent event)
+void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))

 {}
 {}

-void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *socket, GSocketEvent event)
+void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))

 {}
 {}

-void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *socket)
+void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket))

 {}
 {}

-void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *socket)
+void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket))

 {}
 /* Global initialisers */
 
 {}
 /* Global initialisers */
 


@@ -244,6 +279,7 @@ GSocket::GSocket()
   m_stream              = true;
   m_gui_dependent       = NULL;
   m_non_blocking        = false;
   m_stream              = true;
   m_gui_dependent       = NULL;
   m_non_blocking        = false;

+  m_reusable            = false;

   m_timeout             = 10*60*1000;
                                 /* 10 minutes * 60 sec * 1000 millisec */
   m_establishing        = false;
   m_timeout             = 10*60*1000;
                                 /* 10 minutes * 60 sec * 1000 millisec */
   m_establishing        = false;


@@ -292,6 +328,9 @@ void GSocket::Shutdown()
 
   assert(this);
 
 
   assert(this);
 

+  /* Don't allow events to fire after socket has been closed */
+  gs_gui_functions->Disable_Events(this);
+

   /* If socket has been created, shutdown it */
   if (m_fd != INVALID_SOCKET)
   {
   /* If socket has been created, shutdown it */
   if (m_fd != INVALID_SOCKET)
   {


@@ -371,7 +410,7 @@ GAddress *GSocket::GetLocal()
 {
   GAddress *address;
   struct sockaddr addr;
 {
   GAddress *address;
   struct sockaddr addr;

-  SOCKLEN_T size = sizeof(addr);
+  WX_SOCKLEN_T size = sizeof(addr);

   GSocketError err;
 
   assert(this);
   GSocketError err;
 
   assert(this);


@@ -387,7 +426,7 @@ GAddress *GSocket::GetLocal()
     return NULL;
   }
 
     return NULL;
   }
 

-  if (getsockname(m_fd, &addr, (SOCKLEN_T *) &size) < 0)
+  if (getsockname(m_fd, &addr, (WX_SOCKLEN_T *) &size) < 0)

   {
     m_error = GSOCK_IOERR;
     return NULL;
   {
     m_error = GSOCK_IOERR;
     return NULL;


@@ -467,11 +506,13 @@ GSocketError GSocket::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(u_long));

 #endif
 #endif

+
+  ioctl(m_fd, FIONBIO, &arg);

   gs_gui_functions->Enable_Events(this);
 
   /* allow a socket to re-bind if the socket is in the TIME_WAIT
   gs_gui_functions->Enable_Events(this);
 
   /* allow a socket to re-bind if the socket is in the TIME_WAIT


@@ -487,7 +528,7 @@ GSocketError GSocket::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();


@@ -513,16 +554,13 @@ GSocketError GSocket::SetServer()
 GSocket *GSocket::WaitConnection()
 {
   struct sockaddr from;
 GSocket *GSocket::WaitConnection()
 {
   struct sockaddr from;

-  SOCKLEN_T fromlen = sizeof(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)
   {


@@ -547,7 +585,10 @@ GSocket *GSocket::WaitConnection()
     return NULL;
   }
 
     return NULL;
   }
 

-  connection->m_fd = accept(m_fd, &from, (SOCKLEN_T *) &fromlen);
+  connection->m_fd = accept(m_fd, &from, (WX_SOCKLEN_T *) &fromlen);
+
+  /* Reenable CONNECTION events */
+  Enable(GSOCK_CONNECTION);

 
   if (connection->m_fd == INVALID_SOCKET)
   {
 
   if (connection->m_fd == INVALID_SOCKET)
   {


@@ -575,7 +616,6 @@ GSocket *GSocket::WaitConnection()
   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
   if (err != GSOCK_NOERROR)
   {
   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
   if (err != GSOCK_NOERROR)
   {

-    GAddress_destroy(connection->m_peer);

     delete connection;
     m_error = err;
     return NULL;
     delete connection;
     m_error = err;
     return NULL;


@@ -606,7 +646,7 @@ bool GSocket::SetReusable()
  *  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
  *  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()


@@ -661,16 +701,34 @@ GSocketError GSocket::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(u_long));
+#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

-  gs_gui_functions->Enable_Events(this);

 
   /* 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_non_blocking || ret == 0)
+  {
+    gs_gui_functions->Enable_Events(this);
+  }
+

   if (ret == -1)
   {
     err = errno;
   if (ret == -1)
   {
     err = errno;


@@ -691,9 +749,11 @@ GSocketError GSocket::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);
+
+        gs_gui_functions->Enable_Events(this);

 
         if (!error)
           return GSOCK_NOERROR;
 
         if (!error)
           return GSOCK_NOERROR;


@@ -780,7 +840,7 @@ GSocketError GSocket::SetNonOriented()
   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))

   {
     Close();
     m_error = GSOCK_IOERR;
   {
     Close();
     m_error = GSOCK_IOERR;


@@ -809,23 +869,25 @@ int GSocket::Read(char *buffer, int size)
   Disable(GSOCK_INPUT);
 
   /* If the socket is blocking, wait for data (with a timeout) */
   Disable(GSOCK_INPUT);
 
   /* If the socket is blocking, wait for data (with a timeout) */

-  if (Input_Timeout() == GSOCK_TIMEDOUT)
-    /* We no longer return here immediately, otherwise socket events would not be re-enabled! */
+  if (Input_Timeout() == GSOCK_TIMEDOUT) {
+    m_error = GSOCK_TIMEDOUT;
+    /* Don't return here immediately, otherwise socket events would not be
+     * re-enabled! */

     ret = -1;
     ret = -1;

+  }

   else {
     /* Read the data */
     if (m_stream)
       ret = Recv_Stream(buffer, size);
     else
       ret = Recv_Dgram(buffer, size);
   else {
     /* Read the data */
     if (m_stream)
       ret = Recv_Stream(buffer, size);
     else
       ret = Recv_Dgram(buffer, size);

-  }

 
 

-  if (ret == -1)
-  {
-    if (errno == EWOULDBLOCK)
-      m_error = GSOCK_WOULDBLOCK;
-    else
-      m_error = GSOCK_IOERR;
+    if (ret == -1) {
+      if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
+        m_error = GSOCK_WOULDBLOCK;
+      else
+        m_error = GSOCK_IOERR;
+    }

   }
 
   /* Enable events again now that we are done processing */
   }
 
   /* Enable events again now that we are done processing */


@@ -866,7 +928,7 @@ int GSocket::Write(const char *buffer, int size)
 
   if (ret == -1)
   {
 
   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" ));


@@ -911,17 +973,20 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
 
     assert(this);
 
 
     assert(this);
 

+    if (m_fd == -1)
+        return (GSOCK_LOST_FLAG & flags);
+

     /* Do not use a static struct, Linux can garble it */
     tv.tv_sec = m_timeout / 1000;
     /* Do not use a static struct, Linux can garble it */
     tv.tv_sec = m_timeout / 1000;

-    tv.tv_usec = (m_timeout % 1000) / 1000;
+    tv.tv_usec = (m_timeout % 1000) * 1000;

 
 

-    FD_ZERO(&readfds);
-    FD_ZERO(&writefds);
-    FD_ZERO(&exceptfds);
-    FD_SET(m_fd, &readfds);
+    wxFD_ZERO(&readfds);
+    wxFD_ZERO(&writefds);
+    wxFD_ZERO(&exceptfds);
+    wxFD_SET(m_fd, &readfds);

     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)

-      FD_SET(m_fd, &writefds);
-    FD_SET(m_fd, &exceptfds);
+      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);


@@ -944,11 +1009,13 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
     }
 
     /* Check for readability */
     }
 
     /* Check for readability */

-    if (FD_ISSET(m_fd, &readfds))
+    if (wxFD_ISSET(m_fd, &readfds))

     {
       char c;
 
     {
       char c;
 

-      if (recv(m_fd, &c, 1, MSG_PEEK) > 0)
+      int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
+
+      if (num > 0)

       {
         result |= GSOCK_INPUT_FLAG;
       }
       {
         result |= GSOCK_INPUT_FLAG;
       }


@@ -959,7 +1026,7 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
           result |= GSOCK_CONNECTION_FLAG;
           m_detected |= GSOCK_CONNECTION_FLAG;
         }
           result |= GSOCK_CONNECTION_FLAG;
           m_detected |= GSOCK_CONNECTION_FLAG;
         }

-        else
+        else if ((errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR))

         {
           m_detected = GSOCK_LOST_FLAG;
           m_establishing = false;
         {
           m_detected = GSOCK_LOST_FLAG;
           m_establishing = false;


@@ -971,16 +1038,16 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
     }
 
     /* Check for writability */
     }
 
     /* Check for writability */

-    if (FD_ISSET(m_fd, &writefds))
+    if (wxFD_ISSET(m_fd, &writefds))

     {
       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)
         {


@@ -1002,7 +1069,7 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
     }
 
     /* Check for exceptions and errors (is this useful in Unices?) */
     }
 
     /* Check for exceptions and errors (is this useful in Unices?) */

-    if (FD_ISSET(m_fd, &exceptfds))
+    if (wxFD_ISSET(m_fd, &exceptfds))

     {
       m_establishing = false;
       m_detected = GSOCK_LOST_FLAG;
     {
       m_establishing = false;
       m_detected = GSOCK_LOST_FLAG;


@@ -1050,7 +1117,7 @@ void GSocket::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.
  */


@@ -1075,7 +1142,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:
  *   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:


@@ -1131,7 +1198,7 @@ void GSocket::UnsetCallback(GSocketEventFlags flags)
 GSocketError GSocket::GetSockOpt(int level, int optname,
                                 void *optval, int *optlen)
 {
 GSocketError GSocket::GetSockOpt(int level, int optname,
                                 void *optval, int *optlen)
 {

-    if (getsockopt(m_fd, level, optname, optval, (SOCKLEN_T*)optlen) == 0)
+    if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)

     {
         return GSOCK_NOERROR;
     }
     {
         return GSOCK_NOERROR;
     }


@@ -1141,7 +1208,7 @@ GSocketError GSocket::GetSockOpt(int level, int optname,
 GSocketError GSocket::SetSockOpt(int level, int optname,
                                 const void *optval, int optlen)
 {
 GSocketError GSocket::SetSockOpt(int level, int optname,
                                 const void *optval, int optlen)
 {

-    if (setsockopt(m_fd, level, optname, optval, optlen) == 0)
+    if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)

     {
         return GSOCK_NOERROR;
     }
     {
         return GSOCK_NOERROR;
     }


@@ -1183,8 +1250,8 @@ GSocketError GSocket::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)
     {


@@ -1224,8 +1291,8 @@ GSocketError GSocket::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)
     {


@@ -1243,7 +1310,7 @@ GSocketError GSocket::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" ));
     }
     else {
         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
     }
     else {


@@ -1260,19 +1327,27 @@ GSocketError GSocket::Output_Timeout()
 
 int GSocket::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 GSocket::Recv_Dgram(char *buffer, int size)
 {
   struct sockaddr from;
 }
 
 int GSocket::Recv_Dgram(char *buffer, int size)
 {
   struct sockaddr from;

-  SOCKLEN_T fromlen = sizeof(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, &from, (WX_SOCKLEN_T *) &fromlen);
+  } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */

 
   if (ret == -1)
     return -1;
 
   if (ret == -1)
     return -1;


@@ -1303,13 +1378,14 @@ 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;
 }


@@ -1333,13 +1409,14 @@ int GSocket::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);


@@ -1351,6 +1428,12 @@ 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 we have already detected a LOST event, then don't try
    * to do any further processing.
    */


@@ -1363,7 +1446,9 @@ void GSocket::Detected_Read()
     return;
   }
 
     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(this, GSOCK_INPUT);
   }
   {
     CALL_CALLBACK(this, GSOCK_INPUT);
   }


@@ -1375,8 +1460,16 @@ void GSocket::Detected_Read()
     }
     else
     {
     }
     else
     {

-      CALL_CALLBACK(this, 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();
+      }

     }
   }
 }
     }
   }
 }


@@ -1398,11 +1491,11 @@ void GSocket::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)
     {


@@ -1637,7 +1730,7 @@ 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 */


@@ -1698,7 +1791,11 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
     return GSOCK_INVPORT;
   }
 
     return GSOCK_INVPORT;
   }
 

+#if defined(__WXPM__) && defined(__EMX__)
+  se = getservbyname(port, (char*)protocol);
+#else

   se = getservbyname(port, protocol);
   se = getservbyname(port, protocol);

+#endif

   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


@@ -1840,4 +1937,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__) */

-