check that the version of __sync_sub_and_fetch that returns a value is supported...

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

diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp
index eeee3fa8cca875d04ede6be217549614574a471a..1c4e899b15e46ebf1cc3cda6cae27b52ea8ab19c 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__)


@@ -449,6 +450,12 @@ struct servent *wxGetservbyname_r(const char *port, const char *protocol,
 #  define GSocket_Debug(args)
 #endif /* __GSOCKET_DEBUG__ */
 
 #  define GSocket_Debug(args)
 #endif /* __GSOCKET_DEBUG__ */
 

+#if wxUSE_IPV6
+typedef struct sockaddr_storage wxSockAddr;
+#else
+typedef struct sockaddr wxSockAddr;
+#endif
+

 /* Table of GUI-related functions. We must call them indirectly because
  * of wxBase and GUI separation: */
 
 /* Table of GUI-related functions. We must call them indirectly because
  * of wxBase and GUI separation: */
 


@@ -520,6 +527,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;


@@ -533,9 +542,13 @@ 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;

+  m_initialRecvBufferSize = -1;
+  m_initialSendBufferSize = -1;

 
   assert(gs_gui_functions);
   /* Per-socket GUI-specific initialization */
 
   assert(gs_gui_functions);
   /* Per-socket GUI-specific initialization */


@@ -545,10 +558,17 @@ GSocket::GSocket()
 void GSocket::Close()
 {
     gs_gui_functions->Disable_Events(this);
 void GSocket::Close()
 {
     gs_gui_functions->Disable_Events(this);

-    /* gsockosx.c calls CFSocketInvalidate which closes the socket for us */
-#if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)))
-    close(m_fd);
-#endif
+
+    /*  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;
 }
 


@@ -563,6 +583,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);


@@ -662,7 +684,7 @@ GSocketError GSocket::SetPeer(GAddress *address)
 GAddress *GSocket::GetLocal()
 {
   GAddress *address;
 GAddress *GSocket::GetLocal()
 {
   GAddress *address;

-  struct sockaddr addr;
+  wxSockAddr addr;

   WX_SOCKLEN_T size = sizeof(addr);
   GSocketError err;
 
   WX_SOCKLEN_T size = sizeof(addr);
   GSocketError err;
 


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

-  if (getsockname(m_fd, &addr, (WX_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;


@@ -693,7 +715,7 @@ GAddress *GSocket::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);


@@ -811,7 +833,7 @@ GSocketError GSocket::SetServer()
  */
 GSocket *GSocket::WaitConnection()
 {
  */
 GSocket *GSocket::WaitConnection()
 {

-  struct sockaddr from;
+  wxSockAddr from;

   WX_SOCKLEN_T fromlen = sizeof(from);
   GSocket *connection;
   GSocketError err;
   WX_SOCKLEN_T fromlen = sizeof(from);
   GSocket *connection;
   GSocketError err;


@@ -843,7 +865,7 @@ GSocket *GSocket::WaitConnection()
     return NULL;
   }
 
     return NULL;
   }
 

-  connection->m_fd = accept(m_fd, &from, (WX_SOCKLEN_T *) &fromlen);
+  connection->m_fd = accept(m_fd, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);

 
   /* Reenable CONNECTION events */
   Enable(GSOCK_CONNECTION);
 
   /* Reenable CONNECTION events */
   Enable(GSOCK_CONNECTION);


@@ -872,7 +894,7 @@ GSocket *GSocket::WaitConnection()
     return NULL;
   }
 
     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)
   {
     delete connection;
   if (err != GSOCK_NOERROR)
   {
     delete connection;


@@ -903,6 +925,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:


@@ -985,6 +1027,11 @@ GSocketError GSocket::Connect(GSocketStream stream)
 #endif
   }
 
 #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)
   {
   // If a local address has been set, then we need to bind to it before calling connect
   if (m_local && m_local->m_addr)
   {


@@ -1119,19 +1166,25 @@ GSocketError GSocket::SetNonOriented()
 #endif
   }
 
 #endif
   }
 

-  /* 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_broadcast)

   {
   {

-    Close();
-    m_error = GSOCK_IOERR;
-    return GSOCK_IOERR;
+    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;
 }
 


@@ -1168,17 +1221,16 @@ 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;
       m_detected = GSOCK_LOST_FLAG;

-      Close();
-      // Signal an error for return
-      return -1;
+      Detected_Read();
+      return 0;

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


@@ -1627,7 +1679,7 @@ int GSocket::Recv_Stream(char *buffer, int size)
 
 int GSocket::Recv_Dgram(char *buffer, int size)
 {
 
 int GSocket::Recv_Dgram(char *buffer, int size)
 {

-  struct sockaddr from;
+  wxSockAddr from;

   WX_SOCKLEN_T fromlen = sizeof(from);
   int ret;
   GSocketError err;
   WX_SOCKLEN_T fromlen = sizeof(from);
   int ret;
   GSocketError err;


@@ -1636,7 +1688,7 @@ int GSocket::Recv_Dgram(char *buffer, int size)
 
   do
   {
 
   do
   {

-    ret = recvfrom(m_fd, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen);
+    ret = recvfrom(m_fd, buffer, size, 0, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);

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


@@ -1654,7 +1706,7 @@ int GSocket::Recv_Dgram(char *buffer, int size)
     }
   }
 
     }
   }
 

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


@@ -1752,6 +1804,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 */


@@ -1937,11 +1995,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;


@@ -2063,6 +2121,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);


@@ -2198,6 +2262,169 @@ unsigned short GAddress_INET_GetPort(GAddress *address)
   return ntohs(addr->sin_port);
 }
 
   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