* Authors: Guilhem Lavaux,
* Guillermo Rodriguez Garcia <guille@iies.es> (maintainer)
* Purpose: GSocket main Unix file
+ * Licence: The wxWindows licence
* CVSID: $Id$
* -------------------------------------------------------------------------
*/
#ifdef __VMS__
#include <socket.h>
-struct sockaddr_un {
+struct sockaddr_un
+{
u_char sun_len; /* sockaddr len including null */
u_char sun_family; /* AF_UNIX */
char sun_path[108]; /* path name (gag) */
#define INVALID_SOCKET -1
#endif
+/* UnixWare reportedly needs this for FIONBIO definition */
+#ifdef __UNIXWARE__
+#include <sys/filio.h>
+#endif
+
/*
* INADDR_BROADCAST is identical to INADDR_NONE which is not defined
* on all systems. INADDR_BROADCAST should be fine to indicate an error.
/* debugging helpers */
#ifdef __GSOCKET_DEBUG__
- #define GSocket_Debug(args) printf args
+# define GSocket_Debug(args) printf args
#else
- #define GSocket_Debug(args)
-#endif // __GSOCKET_DEBUG__
+# define GSocket_Debug(args)
+#endif /* __GSOCKET_DEBUG__ */
/* Global initialisers */
-bool GSocket_Init(void)
+int GSocket_Init(void)
{
- return TRUE;
+ return 1;
}
void GSocket_Cleanup(void)
return socket;
}
+void GSocket_close(GSocket *socket)
+{
+ _GSocket_Disable_Events(socket);
+ close(socket->m_fd);
+ socket->m_fd = INVALID_SOCKET;
+}
+
void GSocket_destroy(GSocket *socket)
{
assert(socket != NULL);
if (socket->m_fd != INVALID_SOCKET)
{
shutdown(socket->m_fd, 2);
- close(socket->m_fd);
- socket->m_fd = INVALID_SOCKET;
+ GSocket_close(socket);
}
/* Disable GUI callbacks */
socket->m_cbacks[evt] = NULL;
socket->m_detected = GSOCK_LOST_FLAG;
- _GSocket_Disable_Events(socket);
}
/* Address handling */
*/
GSocketError GSocket_SetServer(GSocket *sck)
{
- int type;
int arg = 1;
assert(sck != NULL);
(SOCKLEN_T *) &sck->m_local->m_len) != 0) ||
(listen(sck->m_fd, 5) != 0))
{
- close(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
sck->m_error = GSOCK_IOERR;
return GSOCK_IOERR;
}
{
if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT)
{
- close(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
/* sck->m_error is set in _GSocket_Output_Timeout */
return GSOCK_TIMEDOUT;
}
/* If connect failed with an error other than EINPROGRESS,
* then the call to GSocket_Connect has failed.
*/
- close(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
sck->m_error = GSOCK_IOERR;
return GSOCK_IOERR;
}
sck->m_local->m_addr,
(SOCKLEN_T *) &sck->m_local->m_len) != 0))
{
- close(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
sck->m_error = GSOCK_IOERR;
return GSOCK_IOERR;
}
FD_SET(socket->m_fd, &writefds);
FD_SET(socket->m_fd, &exceptfds);
- /* Check known state first */
- result |= (GSOCK_CONNECTION_FLAG & socket->m_detected & flags);
- result |= (GSOCK_LOST_FLAG & socket->m_detected & flags);
+ /* Check 'sticky' CONNECTION flag first */
+ result |= (GSOCK_CONNECTION_FLAG & socket->m_detected);
+
+ /* If we have already detected a LOST event, then don't try
+ * to do any further processing.
+ */
+ if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
+ {
+ socket->m_establishing = FALSE;
+
+ return (GSOCK_LOST_FLAG & flags);
+ }
/* Try select now */
if (select(socket->m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
- return result;
+ {
+ /* What to do here? */
+ return (result & flags);
+ }
/* Check for readability */
if (FD_ISSET(socket->m_fd, &readfds))
if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0)
{
- result |= (GSOCK_INPUT_FLAG & flags);
+ result |= GSOCK_INPUT_FLAG;
}
else
{
if (socket->m_server && socket->m_stream)
{
- result |= (GSOCK_CONNECTION_FLAG & flags);
+ result |= GSOCK_CONNECTION_FLAG;
socket->m_detected |= GSOCK_CONNECTION_FLAG;
}
else
{
- result |= (GSOCK_LOST_FLAG & flags);
socket->m_detected = GSOCK_LOST_FLAG;
+ socket->m_establishing = FALSE;
+
+ /* LOST event: Abort any further processing */
+ return (GSOCK_LOST_FLAG & flags);
}
}
}
if (error)
{
- result |= (GSOCK_LOST_FLAG & flags);
socket->m_detected = GSOCK_LOST_FLAG;
+
+ /* LOST event: Abort any further processing */
+ return (GSOCK_LOST_FLAG & flags);
}
else
{
- result |= (GSOCK_CONNECTION_FLAG & flags);
+ result |= GSOCK_CONNECTION_FLAG;
socket->m_detected |= GSOCK_CONNECTION_FLAG;
}
}
else
{
- result |= (GSOCK_OUTPUT_FLAG & flags);
+ result |= GSOCK_OUTPUT_FLAG;
}
}
/* Check for exceptions and errors (is this useful in Unices?) */
if (FD_ISSET(socket->m_fd, &exceptfds))
{
- result |= (GSOCK_LOST_FLAG & flags);
socket->m_establishing = FALSE;
socket->m_detected = GSOCK_LOST_FLAG;
+
+ /* LOST event: Abort any further processing */
+ return (GSOCK_LOST_FLAG & flags);
}
- return result;
+ return (result & flags);
#else
* Sets the socket to non-blocking mode. All IO calls will return
* immediately.
*/
-void GSocket_SetNonBlocking(GSocket *socket, bool non_block)
+void GSocket_SetNonBlocking(GSocket *socket, int non_block)
{
assert(socket != NULL);
+ GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
+
socket->m_non_blocking = non_block;
}
if (ret == -1)
{
GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
- if (errno == EBADF) GSocket_Debug(( "Invalid file descriptor\n" ));
- if (errno == EINTR) GSocket_Debug(( "A non blocked signal was caught\n" ));
- if (errno == EINVAL) GSocket_Debug(( "The highest number descriptor is negative\n" ));
- if (errno == ENOMEM) GSocket_Debug(( "Not enough memory\n" ));
+ if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
+ if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
+ if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
+ if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
socket->m_error = GSOCK_TIMEDOUT;
return GSOCK_TIMEDOUT;
}
tv.tv_sec = (socket->m_timeout / 1000);
tv.tv_usec = (socket->m_timeout % 1000) * 1000;
+ GSocket_Debug( ("m_non_blocking has: %d\n", (int)socket->m_non_blocking) );
+
if (!socket->m_non_blocking)
{
FD_ZERO(&writefds);
if (ret == -1)
{
GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
- if (errno == EBADF) GSocket_Debug(( "Invalid file descriptor\n" ));
- if (errno == EINTR) GSocket_Debug(( "A non blocked signal was caught\n" ));
- if (errno == EINVAL) GSocket_Debug(( "The highest number descriptor is negative\n" ));
- if (errno == ENOMEM) GSocket_Debug(( "Not enough memory\n" ));
+ if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
+ if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
+ if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
+ if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
socket->m_error = GSOCK_TIMEDOUT;
return GSOCK_TIMEDOUT;
}
- if ( ! FD_ISSET(socket->m_fd, &writefds) )
- GSocket_Debug(( "GSocket_Output_Timeout is buggy!" ));
- else
- GSocket_Debug(( "GSocket_Output_Timeout seems correct" ));
+ if ( ! FD_ISSET(socket->m_fd, &writefds) ) {
+ GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
+ }
+ else {
+ GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
+ }
}
else
{
- GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!" ));
+ GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
}
return GSOCK_NOERROR;
{
char c;
+ /* If we have already detected a LOST event, then don't try
+ * to do any further processing.
+ */
+ if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
+ {
+ socket->m_establishing = FALSE;
+
+ CALL_CALLBACK(socket, GSOCK_LOST);
+ GSocket_Shutdown(socket);
+ return;
+ }
+
if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0)
{
CALL_CALLBACK(socket, GSOCK_INPUT);
else
{
CALL_CALLBACK(socket, GSOCK_LOST);
+ GSocket_Shutdown(socket);
}
}
}
void _GSocket_Detected_Write(GSocket *socket)
{
+ /* If we have already detected a LOST event, then don't try
+ * to do any further processing.
+ */
+ if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
+ {
+ socket->m_establishing = FALSE;
+
+ CALL_CALLBACK(socket, GSOCK_LOST);
+ GSocket_Shutdown(socket);
+ return;
+ }
+
if (socket->m_establishing && !socket->m_server)
{
int error;
if (error)
{
CALL_CALLBACK(socket, GSOCK_LOST);
+ GSocket_Shutdown(socket);
}
else
{
* -------------------------------------------------------------------------
*/
-/* CHECK_ADDRESS verifies that the current family is either GSOCK_NOFAMILY
- * or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it initalizes address
- * to be a GSOCK_*family*. In other cases, it returns GSOCK_INVADDR.
+/* CHECK_ADDRESS verifies that the current address family is either
+ * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
+ * initalizes it to be a GSOCK_*family*. In other cases, it returns
+ * an appropiate error code.
+ *
+ * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
*/
-#define CHECK_ADDRESS(address, family, retval) \
+#define CHECK_ADDRESS(address, family) \
{ \
if (address->m_family == GSOCK_NOFAMILY) \
if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
return address->m_error; \
if (address->m_family != GSOCK_##family) \
+ { \
+ address->m_error = GSOCK_INVADDR; \
+ return GSOCK_INVADDR; \
+ } \
+}
+
+#define CHECK_ADDRESS_RETVAL(address, family, retval) \
+{ \
+ if (address->m_family == GSOCK_NOFAMILY) \
+ if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
+ return retval; \
+ if (address->m_family != GSOCK_##family) \
{ \
address->m_error = GSOCK_INVADDR; \
return retval; \
} \
}
+
GAddress *GAddress_new(void)
{
GAddress *address;
memcpy(addr2, address, sizeof(GAddress));
- if (address->m_addr)
+ if (address->m_addr && address->m_len > 0)
{
addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
if (addr2->m_addr == NULL)
*len = address->m_len;
*addr = (struct sockaddr *)malloc(address->m_len);
- if (*addr == NULL) {
+ if (*addr == NULL)
+ {
address->m_error = GSOCK_MEMERR;
return GSOCK_MEMERR;
}
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
addr->s_addr = hostaddr;
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
if (!port)
{
se = getservbyname(port, protocol);
if (!se)
{
- if (isdigit(port[0]))
+ /* the cast to int suppresses compiler warnings about subscript having the
+ type char */
+ if (isdigit((int)port[0]))
{
int port_int;
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = (struct sockaddr_in *)address->m_addr;
addr->sin_port = htons(port);
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = (struct sockaddr_in *)address->m_addr;
addr_buf = (char *)&(addr->sin_addr);
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, 0);
+ CHECK_ADDRESS_RETVAL(address, INET, 0);
addr = (struct sockaddr_in *)address->m_addr;
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, 0);
+ CHECK_ADDRESS_RETVAL(address, INET, 0);
addr = (struct sockaddr_in *)address->m_addr;
return ntohs(addr->sin_port);
((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
- return TRUE;
+ return GSOCK_NOERROR;
}
+#define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
+
GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
{
struct sockaddr_un *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, UNIX, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, UNIX);
addr = ((struct sockaddr_un *)address->m_addr);
- memcpy(addr->sun_path, path, strlen(path));
+ strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
+ addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
return GSOCK_NOERROR;
}
struct sockaddr_un *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, UNIX, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, UNIX);
addr = (struct sockaddr_un *)address->m_addr;
projects / wxWidgets.git / blobdiff