/* -------------------------------------------------------------------------
- * 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__
#include "wx/setup.h"
#endif
#endif
#include <signal.h>
-#ifndef SOCKLEN_T
+#ifndef WX_SOCKLEN_T
#ifdef VMS
-# define SOCKLEN_T unsigned int
+# define WX_SOCKLEN_T unsigned int
#else
# ifdef __GLIBC__
# if __GLIBC__ == 2
-# define SOCKLEN_T socklen_t
+# define WX_SOCKLEN_T socklen_t
# endif
+# elif defined(__WXMAC__)
+# define WX_SOCKLEN_T socklen_t
# else
-# define SOCKLEN_T int
+# define WX_SOCKLEN_T int
# endif
#endif
#endif /* SOCKLEN_T */
#ifndef SOCKOPTLEN_T
-#define SOCKOPTLEN_T SOCKLEN_T
+#define SOCKOPTLEN_T WX_SOCKLEN_T
#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
+
+ #define MASK_SIGNAL() \
+ { \
+ void (*old_handler)(int); \
+ \
+ 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"
#else
# include "gsockunx.h"
# include "gsocket.h"
+# ifndef WXUNUSED
+# define WXUNUSED(x)
+# endif
#endif /* __GSOCKET_STANDALONE__ */
/* debugging helpers */
{}
bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
{ return false; }
-bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *socket)
+bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))
{ 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 */
{
GAddress *address;
struct sockaddr addr;
- SOCKLEN_T size = sizeof(addr);
+ WX_SOCKLEN_T size = sizeof(addr);
GSocketError err;
assert(this);
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 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
+
ioctl(m_fd, FIONBIO, &arg);
gs_gui_functions->Enable_Events(this);
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();
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);
- /* Reenable CONNECTION events */
- Enable(GSOCK_CONNECTION);
-
/* If the socket has already been created, we exit immediately */
if (m_fd == INVALID_SOCKET || !m_server)
{
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)
{
* 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()
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
- 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);
+ /* We only call Enable_Events if we know e aren't shutting down the socket */
+
+ if (m_non_blocking)
+ {
+ gs_gui_functions->Enable_Events(this);
+ }
+
if (ret == -1)
{
err = errno;
getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
+ gs_gui_functions->Enable_Events(this);
+
if (!error)
return GSOCK_NOERROR;
}
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;
if (ret == -1)
{
- if (errno == EWOULDBLOCK)
+ if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
m_error = GSOCK_WOULDBLOCK;
else
m_error = GSOCK_IOERR;
if (ret == -1)
{
- if (errno == EWOULDBLOCK)
+ if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
{
m_error = GSOCK_WOULDBLOCK;
GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
{
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_CONNECTION_FLAG;
m_detected |= GSOCK_CONNECTION_FLAG;
}
- else
+ else if ((errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR))
{
m_detected = GSOCK_LOST_FLAG;
m_establishing = false;
}
/* 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.
*/
* 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:
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;
- SOCKLEN_T fromlen = sizeof(from);
+ WX_SOCKLEN_T 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;
{
int ret;
-#ifndef __VISAGECPP__
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();
-#else
- ret = send(m_fd, (char *)buffer, size, 0);
-#endif
return ret;
}
return -1;
}
-#ifndef __VISAGECPP__
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();
-#else
- ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
-#endif
/* Frees memory allocated from _GAddress_translate_to */
free(addr);
{
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.
*/
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);
}
}
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();
+ }
}
}
}
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 */
}
#endif /* !defined(__VISAGECPP__) */
#endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
-
projects / wxWidgets.git / blobdiff