send wxEVT_MENU_CLOSE at least sometimes

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

diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp
index 3ab997e9b79f6f0a2b605f1fa26edb5451260731..b4294370c14042e16660dd27e53b526a10231a41 100644 (file)
--- a/src/unix/gsocket.cpp
+++ b/src/unix/gsocket.cpp
@@ -12,10 +12,6 @@
  * -------------------------------------------------------------------------
  */
 
  * -------------------------------------------------------------------------
  */
 

-/*
- * PLEASE don't put C++ comments here - this is a C source file.
- */
-

 #if defined(__WATCOMC__)
 #include "wx/wxprec.h"
 #include <errno.h>
 #if defined(__WATCOMC__)
 #include "wx/wxprec.h"
 #include <errno.h>


@@ -23,14 +19,11 @@
 #endif
 
 #ifndef __GSOCKET_STANDALONE__
 #endif
 
 #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 */
+#define BSD_SELECT /* use Berkeley Sockets select */

 #endif
 
 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
 #endif
 
 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)


@@ -114,26 +107,26 @@ int _System soclose(int);
 #endif
 #include <signal.h>
 
 #endif
 #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
 #  elif defined(__WXMAC__)
 #    endif
 #  elif defined(__WXMAC__)

-#    define SOCKLEN_T socklen_t
+#    define WX_SOCKLEN_T socklen_t

 #  else
 #  else

-#    define SOCKLEN_T int
+#    define WX_SOCKLEN_T int

 #  endif
 #endif
 
 #endif /* SOCKLEN_T */
 
 #ifndef SOCKOPTLEN_T
 #  endif
 #endif
 
 #endif /* SOCKLEN_T */
 
 #ifndef SOCKOPTLEN_T

-#define SOCKOPTLEN_T SOCKLEN_T
+#define SOCKOPTLEN_T WX_SOCKLEN_T

 #endif
 
 /*
 #endif
 
 /*


@@ -162,12 +155,11 @@ int _System soclose(int);
     #define UNMASK_SIGNAL() }
 
 #else
     #define UNMASK_SIGNAL() }
 
 #else

+    extern "C" { typedef void (*wxSigHandler)(int); }

 
     #define MASK_SIGNAL()                       \
     {                                           \
 
     #define MASK_SIGNAL()                       \
     {                                           \

-        void (*old_handler)(int);               \
-                                                \
-        old_handler = signal(SIGPIPE, SIG_IGN);
+        wxSigHandler old_handler = signal(SIGPIPE, SIG_IGN);

 
     #define UNMASK_SIGNAL()                     \
         signal(SIGPIPE, old_handler);           \
 
     #define UNMASK_SIGNAL()                     \
         signal(SIGPIPE, old_handler);           \


@@ -187,6 +179,7 @@ int _System soclose(int);
 
 #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 "wx/gsocket.h"
 #else
 #  include "gsockunx.h"


@@ -335,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)
   {


@@ -414,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);


@@ -430,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;


@@ -532,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();


@@ -558,7 +554,7 @@ 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;
   GSocket *connection;
   GSocketError err;
   int arg = 1;


@@ -589,7 +585,7 @@ 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);
 
   /* Reenable CONNECTION events */
   Enable(GSOCK_CONNECTION);


@@ -617,6 +613,7 @@ GSocket *GSocket::WaitConnection()
     m_error = GSOCK_MEMERR;
     return NULL;
   }
     m_error = GSOCK_MEMERR;
     return NULL;
   }

+

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


@@ -624,6 +621,7 @@ GSocket *GSocket::WaitConnection()
     m_error = err;
     return NULL;
   }
     m_error = err;
     return NULL;
   }

+

 #if defined(__EMX__) || defined(__VISAGECPP__)
   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 #else
 #if defined(__EMX__) || defined(__VISAGECPP__)
   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 #else


@@ -637,10 +635,13 @@ GSocket *GSocket::WaitConnection()
 bool GSocket::SetReusable()
 {
     /* socket must not be null, and must not be in use/already bound */
 bool GSocket::SetReusable()
 {
     /* socket must not be null, and must not be in use/already bound */

-    if (this && m_fd == INVALID_SOCKET) {
+    if (this && m_fd == INVALID_SOCKET)
+    {

         m_reusable = true;
         m_reusable = true;

+

         return true;
     }
         return true;
     }

+

     return false;
 }
 
     return false;
 }
 


@@ -720,12 +721,16 @@ GSocketError GSocket::Connect(GSocketStream stream)
   /* 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 e aren't shutting down the socket */
+  /* 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)
-  {
+  if (m_non_blocking || ret == 0)

     gs_gui_functions->Enable_Events(this);
     gs_gui_functions->Enable_Events(this);

-  }

 
   if (ret == -1)
   {
 
   if (ret == -1)
   {


@@ -776,6 +781,7 @@ GSocketError GSocket::Connect(GSocketStream stream)
      */
     Close();
     m_error = GSOCK_IOERR;
      */
     Close();
     m_error = GSOCK_IOERR;

+

     return GSOCK_IOERR;
   }
 
     return GSOCK_IOERR;
   }
 


@@ -838,7 +844,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;


@@ -867,23 +873,33 @@ 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 {
+  }
+  else
+  {

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

-  }

 
 

-  if (ret == -1)
-  {
-    if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
-      m_error = GSOCK_WOULDBLOCK;
-    else
+    /* If recv returned zero, then the connection is lost, and errno is not set.
+     * 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_error = GSOCK_IOERR;
       m_error = GSOCK_IOERR;

+    else 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 */


@@ -941,6 +957,7 @@ int GSocket::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;
   }
 


@@ -969,17 +986,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;
     tv.tv_usec = (m_timeout % 1000) * 1000;
 
     /* Do not use a static struct, Linux can garble it */
     tv.tv_sec = m_timeout / 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);


@@ -1002,7 +1022,7 @@ 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;
 


@@ -1019,7 +1039,12 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
           result |= GSOCK_CONNECTION_FLAG;
           m_detected |= GSOCK_CONNECTION_FLAG;
         }
           result |= GSOCK_CONNECTION_FLAG;
           m_detected |= GSOCK_CONNECTION_FLAG;
         }

-        else if ((errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR))
+        /* If recv returned zero, then the connection is lost, and errno is not set.
+         * 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.
+         */
+        else if (num == 0 ||
+                 (errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR))

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


@@ -1031,7 +1056,7 @@ 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)
       {
     {
       if (m_establishing && !m_server)
       {


@@ -1062,7 +1087,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;


@@ -1076,10 +1101,8 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
   }
   else
   {
   }
   else
   {

-

     assert(this);
     return flags & m_detected;
     assert(this);
     return flags & m_detected;

-

   }
 }
 
   }
 }
 


@@ -1192,9 +1215,8 @@ GSocketError GSocket::GetSockOpt(int level, int optname,
                                 void *optval, int *optlen)
 {
     if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
                                 void *optval, int *optlen)
 {
     if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)

-    {

         return GSOCK_NOERROR;
         return GSOCK_NOERROR;

-    }
+

     return GSOCK_OPTERR;
 }
 
     return GSOCK_OPTERR;
 }
 


@@ -1202,9 +1224,8 @@ GSocketError GSocket::SetSockOpt(int level, int optname,
                                 const void *optval, int optlen)
 {
     if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
                                 const void *optval, int optlen)
 {
     if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)

-    {

         return GSOCK_NOERROR;
         return GSOCK_NOERROR;

-    }
+

     return GSOCK_OPTERR;
 }
 
     return GSOCK_OPTERR;
 }
 


@@ -1243,8 +1264,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)
     {


@@ -1252,6 +1273,7 @@ GSocketError GSocket::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" ));


@@ -1263,6 +1285,7 @@ GSocketError GSocket::Input_Timeout()
       return GSOCK_TIMEDOUT;
     }
   }
       return GSOCK_TIMEDOUT;
     }
   }

+

   return GSOCK_NOERROR;
 }
 
   return GSOCK_NOERROR;
 }
 


@@ -1284,8 +1307,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)
     {


@@ -1293,6 +1316,7 @@ GSocketError GSocket::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" ));


@@ -1303,10 +1327,13 @@ 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" ));
     }
         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" ));
     }
   }


@@ -1324,14 +1351,16 @@ int GSocket::Recv_Stream(char *buffer, int size)
   do
   {
     ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
   do
   {
     ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);

-  } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+  }
+  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+

   return ret;
 }
 
 int GSocket::Recv_Dgram(char *buffer, int size)
 {
   struct sockaddr from;
   return ret;
 }
 
 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;
 
   int ret;
   GSocketError err;
 


@@ -1339,8 +1368,9 @@ int GSocket::Recv_Dgram(char *buffer, int size)
 
   do
   {
 
   do
   {

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


@@ -1355,6 +1385,7 @@ int GSocket::Recv_Dgram(char *buffer, int size)
       return -1;
     }
   }
       return -1;
     }
   }

+

   err = _GAddress_translate_from(m_peer, &from, fromlen);
   if (err != GSOCK_NOERROR)
   {
   err = _GAddress_translate_from(m_peer, &from, fromlen);
   if (err != GSOCK_NOERROR)
   {


@@ -1376,7 +1407,8 @@ int GSocket::Send_Stream(const char *buffer, int size)
   do
   {
     ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
   do
   {
     ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);

-  } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+  }
+  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */

 
   UNMASK_SIGNAL();
 
 
   UNMASK_SIGNAL();
 


@@ -1407,7 +1439,8 @@ int GSocket::Send_Dgram(const char *buffer, int size)
   do
   {
     ret = sendto(m_fd, (char *)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 */
+  }
+  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */

 
   UNMASK_SIGNAL();
 
 
   UNMASK_SIGNAL();
 


@@ -1515,9 +1548,11 @@ void GSocket::Detected_Write()
 GSocket *GSocket_new(void)
 {
     GSocket *newsocket = new GSocket();
 GSocket *GSocket_new(void)
 {
     GSocket *newsocket = new GSocket();

-    if(newsocket->IsOk())
+    if (newsocket->IsOk())

         return newsocket;
         return newsocket;

+

     delete newsocket;
     delete newsocket;

+

     return NULL;
 }
 
     return NULL;
 }
 


@@ -1657,6 +1692,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;


@@ -1743,9 +1779,11 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
       address->m_error = GSOCK_NOHOST;
       return GSOCK_NOHOST;
     }
       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;
 }