use WX_ASSERT_STR/SIZET_EQUAL instead of CPPUNIT_ASSERT_EQUAL with casts

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

diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp
index 1ea7b594e54ccf215eb632a5599c6e00c44cc67a..0c8f5f9a403547afd33332ffe600d95a5fd8f365 100644 (file)
--- a/src/unix/gsocket.cpp
+++ b/src/unix/gsocket.cpp
@@ -20,6 +20,7 @@
 
 #ifndef __GSOCKET_STANDALONE__
 #include "wx/defs.h"
 
 #ifndef __GSOCKET_STANDALONE__
 #include "wx/defs.h"

+#include "wx/private/gsocketiohandler.h"

 #endif
 
 #if defined(__VISAGECPP__)
 #endif
 
 #if defined(__VISAGECPP__)


@@ -39,6 +40,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


@@ -197,40 +202,87 @@ static struct hostent * deepCopyHostent(struct hostent *h,
                                        const struct hostent *he,
                                        char *buffer, int size, int *err)
 {
                                        const struct hostent *he,
                                        char *buffer, int size, int *err)
 {

+  /* copy old structure */

   memcpy(h, he, sizeof(struct hostent));
   memcpy(h, he, sizeof(struct hostent));

+
+  /* copy name */

   int len = strlen(h->h_name);
   if (len > size)
   int len = strlen(h->h_name);
   if (len > size)

-    len = size - 1;
+  {
+    *err = ENOMEM;
+    return NULL;
+  }

   memcpy(buffer, h->h_name, len);
   buffer[len] = '\0';
   h->h_name = buffer;
   memcpy(buffer, h->h_name, len);
   buffer[len] = '\0';
   h->h_name = buffer;

-  buffer += len + 1;
-  size -= len + 1;
+
+  /* track position in the buffer */
+  int pos = len + 1;
+
+  /* reuse len to store address length */

   len = h->h_length;
   len = h->h_length;

-  for (char **p = h->h_addr_list; *p != 0; p++) {
-    if (size < len){
+
+  /* ensure pointer alignment */
+  unsigned int misalign = sizeof(char *) - pos%sizeof(char *);
+  if(misalign < sizeof(char *))
+    pos += misalign;
+
+  /* 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 *);
+
+  /* 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;
     }
       *err = ENOMEM;
       return NULL;
     }

-    memcpy(buffer, *p, len);
-    *p = buffer;
-    buffer += len;
-    size -= len;
-  }
-  for (char **q = h->h_aliases; size > 0 && *q != 0; q++){
-    len = strlen(*q);
-    if (len > size)
-      len = size - 1;
-    memcpy(buffer, *q, len);
-    buffer[len] = '\0';
-    *q = buffer;
-    buffer += len + 1;
-    size -= len + 1;
+    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
 
   return h;
 }
 #endif
 

+#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 * wxGethostbyname_r(const char *hostname, struct hostent *h,
                                   void *buffer, int size, int *err)
 


@@ -252,7 +304,6 @@ struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h,
     he = h;
 #elif defined(HAVE_GETHOSTBYNAME)
 #if wxUSE_THREADS
     he = h;
 #elif defined(HAVE_GETHOSTBYNAME)
 #if wxUSE_THREADS

-  static wxMutex nameLock;

   wxMutexLocker locker(nameLock);
 #endif
   he = gethostbyname(hostname);
   wxMutexLocker locker(nameLock);
 #endif
   he = gethostbyname(hostname);


@@ -264,6 +315,9 @@ struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h,
   return he;
 }
 
   return he;
 }
 

+#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 * wxGethostbyaddr_r(const char *addr_buf, int buf_size,
                                   int proto, struct hostent *h,
                                   void *buffer, int size, int *err)


@@ -287,7 +341,6 @@ struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size,
     he = h;
 #elif defined(HAVE_GETHOSTBYNAME)
 #if wxUSE_THREADS
     he = h;
 #elif defined(HAVE_GETHOSTBYNAME)
 #if wxUSE_THREADS

-  static wxMutex addrLock;

   wxMutexLocker locker(addrLock);
 #endif
   he = gethostbyaddr(addr_buf, buf_size, proto);
   wxMutexLocker locker(addrLock);
 #endif
   he = gethostbyaddr(addr_buf, buf_size, proto);


@@ -299,42 +352,72 @@ struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size,
   return he;
 }
 
   return he;
 }
 

-#if defined(HAVE_GETHOSTBYNAME)
+#if defined(HAVE_GETSERVBYNAME)

 static struct servent * deepCopyServent(struct servent *s,
                                        const struct servent *se,
                                        char *buffer, int size)
 {
 static struct servent * deepCopyServent(struct servent *s,
                                        const struct servent *se,
                                        char *buffer, int size)
 {

+  /* copy plain old structure */

   memcpy(s, se, sizeof(struct servent));
   memcpy(s, se, sizeof(struct servent));

+
+  /* copy name */

   int len = strlen(s->s_name);
   int len = strlen(s->s_name);

-  if (len > size)
-    len = size - 1;
+  if (len >= size)
+  {
+    return NULL;
+  }

   memcpy(buffer, s->s_name, len);
   buffer[len] = '\0';
   s->s_name = buffer;
   memcpy(buffer, s->s_name, len);
   buffer[len] = '\0';
   s->s_name = buffer;

-  buffer += len + 1;
-  size -= len + 1;
+
+  /* track position in the buffer */
+  int pos = len + 1;
+
+  /* copy protocol */

   len = strlen(s->s_proto);
   len = strlen(s->s_proto);

-  if (len > size)
-    len = size - 1;
-  memcpy(buffer, s->s_proto, len);
-  buffer[len] = '\0';
-  s->s_proto = buffer;
-  buffer += len + 1;
-  size -= len + 1;
-  for (char **q = s->s_aliases; size > 0 && *q != 0; q++){
-    len = strlen(*q);
-    if (len > size)
-      len = size - 1;
-    memcpy(buffer, *q, len);
-    buffer[len] = '\0';
-    *q = buffer;
-    buffer += len + 1;
-    size -= len + 1;
+  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
 
   return s;
 }
 #endif
 

+#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 *wxGetservbyname_r(const char *port, const char *protocol,
                                  struct servent *serv, void *buffer, int size)
 {


@@ -351,7 +434,6 @@ struct servent *wxGetservbyname_r(const char *port, const char *protocol,
     se = serv;
 #elif defined(HAVE_GETSERVBYNAME)
 #if wxUSE_THREADS
     se = serv;
 #elif defined(HAVE_GETSERVBYNAME)
 #if wxUSE_THREADS

-  static wxMutex servLock;

   wxMutexLocker locker(servLock);
 #endif
   se = getservbyname(port, protocol);
   wxMutexLocker locker(servLock);
 #endif
   se = getservbyname(port, protocol);


@@ -439,6 +521,8 @@ 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;


@@ -452,6 +536,8 @@ GSocket::GSocket()
   m_gui_dependent       = NULL;
   m_non_blocking        = false;
   m_reusable            = false;
   m_gui_dependent       = NULL;
   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_establishing        = false;
   m_timeout             = 10*60*1000;
                                 /* 10 minutes * 60 sec * 1000 millisec */
   m_establishing        = false;


@@ -482,6 +568,8 @@ GSocket::~GSocket()
   /* Per-socket GUI-specific cleanup */
   gs_gui_functions->Destroy_Socket(this);
 
   /* Per-socket GUI-specific cleanup */
   gs_gui_functions->Destroy_Socket(this);
 

+  delete m_handler;
+

   /* Destroy private addresses */
   if (m_local)
     GAddress_destroy(m_local);
   /* Destroy private addresses */
   if (m_local)
     GAddress_destroy(m_local);


@@ -506,7 +594,7 @@ void GSocket::Shutdown()
   /* 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();
   }
 


@@ -681,7 +769,7 @@ GSocketError GSocket::SetServer()
 
   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
 #ifdef SO_NOSIGPIPE
 
   /* 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));
+  setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));

 #endif
 
   ioctl(m_fd, FIONBIO, &arg);
 #endif
 
   ioctl(m_fd, FIONBIO, &arg);


@@ -691,7 +779,12 @@ GSocketError GSocket::SetServer()
      state after being previously closed.
    */
   if (m_reusable)
      state after being previously closed.
    */
   if (m_reusable)

-    setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
+  {
+    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,


@@ -817,6 +910,26 @@ bool GSocket::SetReusable()
     return false;
 }
 
     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:
 /* Client specific parts */
 
 /* GSocket_Connect:


@@ -881,7 +994,7 @@ GSocketError GSocket::Connect(GSocketStream stream)
 
   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
 #ifdef SO_NOSIGPIPE
 
   /* 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));
+  setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));

 #endif
 
 #if defined(__EMX__) || defined(__VISAGECPP__)
 #endif
 
 #if defined(__EMX__) || defined(__VISAGECPP__)


@@ -890,6 +1003,21 @@ GSocketError GSocket::Connect(GSocketStream stream)
   ioctl(m_fd, FIONBIO, &arg);
 #endif
 
   ioctl(m_fd, FIONBIO, &arg);
 #endif
 

+  // 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 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);
 


@@ -1010,19 +1138,33 @@ GSocketError GSocket::SetNonOriented()
 #endif
   gs_gui_functions->Enable_Events(this);
 
 #endif
   gs_gui_functions->Enable_Events(this);
 

-  /* Bind to the local address,
-   * and retrieve the actual address bound.
-   */
-  if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
-      (getsockname(m_fd,
-                   m_local->m_addr,
-                   (WX_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;
 }
 
   return GSOCK_NOERROR;
 }
 


@@ -1059,12 +1201,17 @@ int GSocket::Read(char *buffer, int size)
     else
       ret = Recv_Dgram(buffer, size);
 
     else
       ret = Recv_Dgram(buffer, size);
 

-    /* If recv returned zero, then the connection is lost, and errno is not set.
+    /* If recv returned zero, 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)
      * 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;
+    {
+      /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */
+      m_detected = GSOCK_LOST_FLAG;
+      Detected_Read();
+      return 0;
+    }

     else if (ret == -1)
     {
       if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
     else if (ret == -1)
     {
       if ((errno == EWOULDBLOCK) || (errno == EAGAIN))


@@ -1193,37 +1340,28 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
       return (result & flags);
     }
 
       return (result & flags);
     }
 

+    /* Check for exceptions and errors */
+    if (wxFD_ISSET(m_fd, &exceptfds))
+    {
+      m_establishing = false;
+      m_detected = GSOCK_LOST_FLAG;
+
+      /* LOST event: Abort any further processing */
+      return (GSOCK_LOST_FLAG & flags);
+    }
+

     /* Check for readability */
     if (wxFD_ISSET(m_fd, &readfds))
     {
     /* Check for readability */
     if (wxFD_ISSET(m_fd, &readfds))
     {

-      char c;
-
-      int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
+      result |= GSOCK_INPUT_FLAG;

 
 

-      if (num > 0)
+      if (m_server && m_stream)

       {
       {

-        result |= GSOCK_INPUT_FLAG;
-      }
-      else
-      {
-        if (m_server && m_stream)
-        {
-          result |= GSOCK_CONNECTION_FLAG;
-          m_detected |= GSOCK_CONNECTION_FLAG;
-        }
-        /* 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;
-
-          /* LOST event: Abort any further processing */
-          return (GSOCK_LOST_FLAG & flags);
-        }
+        /* 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. */
+        result |= GSOCK_CONNECTION_FLAG;
+        m_detected |= GSOCK_CONNECTION_FLAG;

       }
     }
 
       }
     }
 


@@ -1258,16 +1396,6 @@ GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
       }
     }
 
       }
     }
 

-    /* Check for exceptions and errors (is this useful in Unices?) */
-    if (wxFD_ISSET(m_fd, &exceptfds))
-    {
-      m_establishing = false;
-      m_detected = GSOCK_LOST_FLAG;
-
-      /* LOST event: Abort any further processing */
-      return (GSOCK_LOST_FLAG & flags);
-    }
-

     return (result & flags);
 
   }
     return (result & flags);
 
   }


@@ -1656,6 +1784,12 @@ void GSocket::Detected_Read()
     {
       CALL_CALLBACK(this, GSOCK_CONNECTION);
     }
     {
       CALL_CALLBACK(this, GSOCK_CONNECTION);
     }

+    else if (num == 0)
+    {
+      /* graceful shutdown */
+      CALL_CALLBACK(this, GSOCK_LOST);
+      Shutdown();
+    }

     else
     {
       /* Do not throw a lost event in cases where the socket isn't really lost */
     else
     {
       /* Do not throw a lost event in cases where the socket isn't really lost */


@@ -1967,6 +2101,12 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   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);