X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/385ebb5d8109bbdfa60137ccd650d7c78e0747e5..ac52d2b0fc5d688fd882c54a60592c9c9ce61a29:/src/unix/gsocket.cpp diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp index d417f12da8..6efa6b76ad 100644 --- a/src/unix/gsocket.cpp +++ b/src/unix/gsocket.cpp @@ -12,21 +12,24 @@ * ------------------------------------------------------------------------- */ -#if defined(__WATCOMC__) #include "wx/wxprec.h" -#include -#include -#endif -#ifndef __GSOCKET_STANDALONE__ -#include "wx/defs.h" -#endif +#if wxUSE_SOCKETS + +#include "wx/gsocket.h" + +#include "wx/private/fd.h" +#include "wx/private/socket.h" +#include "wx/private/gsocketiohandler.h" #if defined(__VISAGECPP__) #define BSD_SELECT /* use Berkeley Sockets select */ #endif -#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) +#if defined(__WATCOMC__) +#include +#include +#endif #include #include @@ -36,17 +39,13 @@ #include #include #endif -#ifdef __NETBSD__ -#ifndef _NETBSD_SOURCE -#define _NETBSD_SOURCE -#endif -#ifndef _LIBC -#define _LIBC -#endif -#endif #include #include +#ifdef HAVE_SYS_SELECT_H +# include +#endif + #ifdef __VMS__ #include struct sockaddr_un @@ -137,13 +136,6 @@ int _System soclose(int); #define SOCKOPTLEN_T WX_SOCKLEN_T #endif -/* - * MSW defines this, Unices don't. - */ -#ifndef INVALID_SOCKET -#define INVALID_SOCKET -1 -#endif - /* UnixWare reportedly needs this for FIONBIO definition */ #ifdef __UNIXWARE__ #include @@ -185,60 +177,96 @@ int _System soclose(int); # define GSOCKET_MSG_NOSIGNAL 0 #endif /* MSG_NOSIGNAL */ -#ifndef __GSOCKET_STANDALONE__ -# include "wx/unix/gsockunx.h" -# include "wx/unix/private.h" -# include "wx/gsocket.h" #if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME)) # include "wx/thread.h" #endif -#else -# include "gsockunx.h" -# include "gsocket.h" -# ifndef WXUNUSED -# define WXUNUSED(x) -# endif -#endif /* __GSOCKET_STANDALONE__ */ #if defined(HAVE_GETHOSTBYNAME) static struct hostent * deepCopyHostent(struct hostent *h, const struct hostent *he, char *buffer, int size, int *err) { + /* copy old structure */ memcpy(h, he, sizeof(struct hostent)); + + /* copy name */ 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; - 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; - 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, *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 */ + *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; + } + 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 +#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) @@ -260,7 +288,6 @@ struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h, he = h; #elif defined(HAVE_GETHOSTBYNAME) #if wxUSE_THREADS - static wxMutex nameLock; wxMutexLocker locker(nameLock); #endif he = gethostbyname(hostname); @@ -272,6 +299,9 @@ struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h, 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) @@ -295,7 +325,6 @@ struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size, he = h; #elif defined(HAVE_GETHOSTBYNAME) #if wxUSE_THREADS - static wxMutex addrLock; wxMutexLocker locker(addrLock); #endif he = gethostbyaddr(addr_buf, buf_size, proto); @@ -307,42 +336,72 @@ struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size, 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) { + /* copy plain old structure */ memcpy(s, se, sizeof(struct servent)); + + /* copy 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; - buffer += len + 1; - size -= len + 1; + + /* track position in the buffer */ + int pos = len + 1; + + /* copy protocol */ 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 +#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) { @@ -359,7 +418,6 @@ struct servent *wxGetservbyname_r(const char *port, const char *protocol, se = serv; #elif defined(HAVE_GETSERVBYNAME) #if wxUSE_THREADS - static wxMutex servLock; wxMutexLocker locker(servLock); #endif se = getservbyname(port, protocol); @@ -379,123 +437,33 @@ struct servent *wxGetservbyname_r(const char *port, const char *protocol, /* Table of GUI-related functions. We must call them indirectly because * of wxBase and GUI separation: */ -static GSocketGUIFunctionsTable *gs_gui_functions; - -class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable +bool GSocket_Init() { -public: - virtual bool OnInit(); - virtual void OnExit(); - virtual bool CanUseEventLoop(); - virtual bool Init_Socket(GSocket *socket); - virtual void Destroy_Socket(GSocket *socket); - virtual void Install_Callback(GSocket *socket, GSocketEvent event); - virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event); - virtual void Enable_Events(GSocket *socket); - virtual void Disable_Events(GSocket *socket); -}; - -bool GSocketGUIFunctionsTableNull::OnInit() -{ return true; } -void GSocketGUIFunctionsTableNull::OnExit() -{} -bool GSocketGUIFunctionsTableNull::CanUseEventLoop() -{ return false; } -bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket)) -{ return true; } -void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket)) -{} -void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event)) -{} -void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event)) -{} -void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket)) -{} -void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket)) -{} -/* Global initialisers */ - -void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc) -{ - gs_gui_functions = guifunc; + GSocketManager * const manager = GSocketManager::Get(); + return manager && manager->OnInit(); } -int GSocket_Init(void) +void GSocket_Cleanup() { - if (!gs_gui_functions) - { - static GSocketGUIFunctionsTableNull table; - gs_gui_functions = &table; - } - if ( !gs_gui_functions->OnInit() ) - return 0; - return 1; -} - -void GSocket_Cleanup(void) -{ - if (gs_gui_functions) - { - gs_gui_functions->OnExit(); - } + GSocketManager * const manager = GSocketManager::Get(); + if ( manager ) + manager->OnExit(); } /* Constructors / Destructors for GSocket */ -GSocket::GSocket() +GSocket::GSocket(wxSocketBase& wxsocket) + : GSocketBase(wxsocket) { - int i; + m_handler = NULL; - m_fd = INVALID_SOCKET; - for (i=0;iInit_Socket(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 - m_fd = INVALID_SOCKET; + m_use_events = false; } GSocket::~GSocket() { - assert(this); - - /* Check that the socket is really shutdowned */ - if (m_fd != INVALID_SOCKET) - Shutdown(); - - /* Per-socket GUI-specific cleanup */ - gs_gui_functions->Destroy_Socket(this); - - /* Destroy private addresses */ - if (m_local) - GAddress_destroy(m_local); - - if (m_peer) - GAddress_destroy(m_peer); + delete m_handler; } /* GSocket_Shutdown: @@ -504,142 +472,10 @@ GSocket::~GSocket() */ void GSocket::Shutdown() { - int evt; - - assert(this); - - /* Don't allow events to fire after socket has been closed */ - gs_gui_functions->Disable_Events(this); + /* Don't allow events to fire after socket has been closed */ + DisableEvents(); - /* If socket has been created, shutdown it */ - if (m_fd != INVALID_SOCKET) - { - shutdown(m_fd, 2); - Close(); - } - - /* Disable GUI callbacks */ - for (evt = 0; evt < GSOCK_MAX_EVENT; evt++) - m_cbacks[evt] = NULL; - - m_detected = GSOCK_LOST_FLAG; -} - -/* Address handling */ - -/* GSocket_SetLocal: - * GSocket_GetLocal: - * GSocket_SetPeer: - * GSocket_GetPeer: - * Set or get the local or peer address for this socket. The 'set' - * functions return GSOCK_NOERROR on success, an error code otherwise. - * The 'get' functions return a pointer to a GAddress object on success, - * or NULL otherwise, in which case they set the error code of the - * corresponding GSocket. - * - * Error codes: - * GSOCK_INVSOCK - the socket is not valid. - * GSOCK_INVADDR - the address is not valid. - */ -GSocketError GSocket::SetLocal(GAddress *address) -{ - assert(this); - - /* the socket must be initialized, or it must be a server */ - if ((m_fd != INVALID_SOCKET && !m_server)) - { - m_error = GSOCK_INVSOCK; - return GSOCK_INVSOCK; - } - - /* check address */ - if (address == NULL || address->m_family == GSOCK_NOFAMILY) - { - m_error = GSOCK_INVADDR; - return GSOCK_INVADDR; - } - - if (m_local) - GAddress_destroy(m_local); - - m_local = GAddress_copy(address); - - return GSOCK_NOERROR; -} - -GSocketError GSocket::SetPeer(GAddress *address) -{ - assert(this); - - /* check address */ - if (address == NULL || address->m_family == GSOCK_NOFAMILY) - { - m_error = GSOCK_INVADDR; - return GSOCK_INVADDR; - } - - if (m_peer) - GAddress_destroy(m_peer); - - m_peer = GAddress_copy(address); - - return GSOCK_NOERROR; -} - -GAddress *GSocket::GetLocal() -{ - GAddress *address; - struct sockaddr addr; - WX_SOCKLEN_T size = sizeof(addr); - GSocketError err; - - assert(this); - - /* try to get it from the m_local var first */ - if (m_local) - return GAddress_copy(m_local); - - /* else, if the socket is initialized, try getsockname */ - if (m_fd == INVALID_SOCKET) - { - m_error = GSOCK_INVSOCK; - return NULL; - } - - if (getsockname(m_fd, &addr, (WX_SOCKLEN_T *) &size) < 0) - { - m_error = GSOCK_IOERR; - return NULL; - } - - /* got a valid address from getsockname, create a GAddress object */ - address = GAddress_new(); - if (address == NULL) - { - m_error = GSOCK_MEMERR; - return NULL; - } - - err = _GAddress_translate_from(address, &addr, size); - if (err != GSOCK_NOERROR) - { - GAddress_destroy(address); - m_error = err; - return NULL; - } - - return address; -} - -GAddress *GSocket::GetPeer() -{ - assert(this); - - /* try to get it from the m_peer var */ - if (m_peer) - return GAddress_copy(m_peer); - - return NULL; + GSocketBase::Shutdown(); } /* Server specific parts */ @@ -689,17 +525,22 @@ GSocketError GSocket::SetServer() /* 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); - gs_gui_functions->Enable_Events(this); + EnableEvents(); /* allow a socket to re-bind if the socket is in the TIME_WAIT 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, @@ -731,9 +572,9 @@ GSocketError GSocket::SetServer() * GSOCK_MEMERR - couldn't allocate memory. * GSOCK_IOERR - low-level error. */ -GSocket *GSocket::WaitConnection() +GSocket *GSocket::WaitConnection(wxSocketBase& wxsocket) { - struct sockaddr from; + wxSockAddr from; WX_SOCKLEN_T fromlen = sizeof(from); GSocket *connection; GSocketError err; @@ -749,7 +590,7 @@ GSocket *GSocket::WaitConnection() } /* Create a GSocket object for the new connection */ - connection = GSocket_new(); + connection = GSocket::Create(wxsocket); if (!connection) { @@ -765,10 +606,10 @@ GSocket *GSocket::WaitConnection() 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); + EnableEvent(GSOCK_CONNECTION); if (connection->m_fd == INVALID_SOCKET) { @@ -794,7 +635,7 @@ GSocket *GSocket::WaitConnection() 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; @@ -807,11 +648,35 @@ GSocket *GSocket::WaitConnection() #else ioctl(connection->m_fd, FIONBIO, &arg); #endif - gs_gui_functions->Enable_Events(connection); + if (m_use_events) + connection->Notify(true); return connection; } +void GSocket::Notify(bool flag) +{ + if (flag == m_use_events) + return; + m_use_events = flag; + DoEnableEvents(flag); +} + +void GSocket::DoEnableEvents(bool flag) +{ + GSocketManager * const manager = GSocketManager::Get(); + if ( flag ) + { + manager->Install_Callback(this, GSOCK_INPUT); + manager->Install_Callback(this, GSOCK_OUTPUT); + } + else // off + { + manager->Uninstall_Callback(this, GSOCK_INPUT); + manager->Uninstall_Callback(this, GSOCK_OUTPUT); + } +} + bool GSocket::SetReusable() { /* socket must not be null, and must not be in use/already bound */ @@ -825,6 +690,26 @@ bool GSocket::SetReusable() 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: @@ -858,7 +743,7 @@ GSocketError GSocket::Connect(GSocketStream stream) assert(this); /* Enable CONNECTION events (needed for nonblocking connections) */ - Enable(GSOCK_CONNECTION); + EnableEvent(GSOCK_CONNECTION); if (m_fd != INVALID_SOCKET) { @@ -889,7 +774,7 @@ GSocketError GSocket::Connect(GSocketStream stream) /* 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__) @@ -898,19 +783,38 @@ GSocketError GSocket::Connect(GSocketStream stream) 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 (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) + { + 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); - /* 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 + /* We only call EnableEvents() if we know we aren't shutting down the socket. + * NB: EnableEvents() 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. + * call to EnableEvents() now. */ - - if (m_non_blocking || ret == 0) - gs_gui_functions->Enable_Events(this); + if ( m_non_blocking || (ret == 0) ) + EnableEvents(); if (ret == -1) { @@ -935,8 +839,7 @@ GSocketError GSocket::Connect(GSocketStream stream) SOCKOPTLEN_T len = sizeof(error); getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len); - - gs_gui_functions->Enable_Events(this); + EnableEvents(); if (!error) return GSOCK_NOERROR; @@ -1016,21 +919,35 @@ GSocketError GSocket::SetNonOriented() #else ioctl(m_fd, FIONBIO, &arg); #endif - gs_gui_functions->Enable_Events(this); + EnableEvents(); - /* 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; } @@ -1050,7 +967,7 @@ int GSocket::Read(char *buffer, int size) } /* Disable events during query of socket status */ - Disable(GSOCK_INPUT); + DisableEvent(GSOCK_INPUT); /* If the socket is blocking, wait for data (with a timeout) */ if (Input_Timeout() == GSOCK_TIMEDOUT) { @@ -1067,12 +984,25 @@ int GSocket::Read(char *buffer, int size) else ret = Recv_Dgram(buffer, size); - /* 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 recv returned zero for a TCP socket (if m_stream == NULL, it's an UDP + * socket and empty datagrams are possible), 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) - m_error = GSOCK_IOERR; + if ((ret == 0) && m_stream) + { + /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */ + if (m_use_events) + { + m_detected = GSOCK_LOST_FLAG; + Detected_Read(); + return 0; + } + } else if (ret == -1) { if ((errno == EWOULDBLOCK) || (errno == EAGAIN)) @@ -1083,7 +1013,7 @@ int GSocket::Read(char *buffer, int size) } /* Enable events again now that we are done processing */ - Enable(GSOCK_INPUT); + EnableEvent(GSOCK_INPUT); return ret; } @@ -1136,7 +1066,7 @@ int GSocket::Write(const char *buffer, int size) * that the socket is writable until a read operation fails. Only then * will further OUTPUT events be posted. */ - Enable(GSOCK_OUTPUT); + EnableEvent(GSOCK_OUTPUT); return -1; } @@ -1146,146 +1076,6 @@ int GSocket::Write(const char *buffer, int size) return ret; } -/* GSocket_Select: - * Polls the socket to determine its status. This function will - * check for the events specified in the 'flags' parameter, and - * it will return a mask indicating which operations can be - * performed. This function won't block, regardless of the - * mode (blocking | nonblocking) of the socket. - */ -GSocketEventFlags GSocket::Select(GSocketEventFlags flags) -{ - if (!gs_gui_functions->CanUseEventLoop()) - { - - GSocketEventFlags result = 0; - fd_set readfds; - fd_set writefds; - fd_set exceptfds; - struct timeval tv; - - 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; - - wxFD_ZERO(&readfds); - wxFD_ZERO(&writefds); - wxFD_ZERO(&exceptfds); - wxFD_SET(m_fd, &readfds); - if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG) - wxFD_SET(m_fd, &writefds); - wxFD_SET(m_fd, &exceptfds); - - /* Check 'sticky' CONNECTION flag first */ - result |= (GSOCK_CONNECTION_FLAG & m_detected); - - /* If we have already detected a LOST event, then don't try - * to do any further processing. - */ - if ((m_detected & GSOCK_LOST_FLAG) != 0) - { - m_establishing = false; - - return (GSOCK_LOST_FLAG & flags); - } - - /* Try select now */ - if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0) - { - /* What to do here? */ - return (result & flags); - } - - /* Check for readability */ - if (wxFD_ISSET(m_fd, &readfds)) - { - char c; - - int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL); - - if (num > 0) - { - 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); - } - } - } - - /* Check for writability */ - if (wxFD_ISSET(m_fd, &writefds)) - { - if (m_establishing && !m_server) - { - int error; - SOCKOPTLEN_T len = sizeof(error); - - m_establishing = false; - - getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len); - - if (error) - { - m_detected = GSOCK_LOST_FLAG; - - /* LOST event: Abort any further processing */ - return (GSOCK_LOST_FLAG & flags); - } - else - { - result |= GSOCK_CONNECTION_FLAG; - m_detected |= GSOCK_CONNECTION_FLAG; - } - } - else - { - result |= GSOCK_OUTPUT_FLAG; - } - } - - /* 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); - - } - else - { - assert(this); - return flags & m_detected; - } -} - /* Flags */ /* GSocket_SetNonBlocking: @@ -1301,17 +1091,6 @@ void GSocket::SetNonBlocking(bool non_block) m_non_blocking = non_block; } -/* GSocket_SetTimeout: - * Sets the timeout for blocking calls. Time is expressed in - * milliseconds. - */ -void GSocket::SetTimeout(unsigned long millisec) -{ - assert(this); - - m_timeout = millisec; -} - /* GSocket_GetError: * Returns the last error occurred for this socket. Note that successful * operations do not clear this back to GSOCK_NOERROR, so use it only @@ -1324,73 +1103,6 @@ GSocketError WXDLLIMPEXP_NET GSocket::GetError() return m_error; } -/* Callbacks */ - -/* GSOCK_INPUT: - * There is data to be read in the input buffer. If, after a read - * operation, there is still data available, the callback function will - * be called again. - * GSOCK_OUTPUT: - * The socket is available for writing. That is, the next write call - * won't block. This event is generated only once, when the connection is - * first established, and then only if a call failed with GSOCK_WOULDBLOCK, - * when the output buffer empties again. This means that the app should - * 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 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: - * The connection is lost (or a connection request failed); this could - * be due to a failure, or due to the peer closing it gracefully. - */ - -/* GSocket_SetCallback: - * Enables the callbacks specified by 'flags'. Note that 'flags' - * may be a combination of flags OR'ed toghether, so the same - * callback function can be made to accept different events. - * The callback function must have the following prototype: - * - * void function(GSocket *socket, GSocketEvent event, char *cdata) - */ -void GSocket::SetCallback(GSocketEventFlags flags, - GSocketCallback callback, char *cdata) -{ - int count; - - assert(this); - - for (count = 0; count < GSOCK_MAX_EVENT; count++) - { - if ((flags & (1 << count)) != 0) - { - m_cbacks[count] = callback; - m_data[count] = cdata; - } - } -} - -/* GSocket_UnsetCallback: - * Disables all callbacks specified by 'flags', which may be a - * combination of flags OR'ed toghether. - */ -void GSocket::UnsetCallback(GSocketEventFlags flags) -{ - int count; - - assert(this); - - for (count = 0; count < GSOCK_MAX_EVENT; count++) - { - if ((flags & (1 << count)) != 0) - { - m_cbacks[count] = NULL; - m_data[count] = NULL; - } - } -} - GSocketError GSocket::GetSockOpt(int level, int optname, void *optval, int *optlen) { @@ -1409,23 +1121,22 @@ GSocketError GSocket::SetSockOpt(int level, int optname, return GSOCK_OPTERR; } -#define CALL_CALLBACK(socket, event) { \ - socket->Disable(event); \ - if (socket->m_cbacks[event]) \ - socket->m_cbacks[event](socket, event, socket->m_data[event]); \ -} - - -void GSocket::Enable(GSocketEvent event) +void GSocket::EnableEvent(GSocketEvent event) { - m_detected &= ~(1 << event); - gs_gui_functions->Install_Callback(this, event); + if (m_use_events) + { + m_detected &= ~(1 << event); + GSocketManager::Get()->Install_Callback(this, event); + } } -void GSocket::Disable(GSocketEvent event) +void GSocket::DisableEvent(GSocketEvent event) { - m_detected |= (1 << event); - gs_gui_functions->Uninstall_Callback(this, event); + if (m_use_events) + { + m_detected |= (1 << event); + GSocketManager::Get()->Uninstall_Callback(this, event); + } } /* _GSocket_Input_Timeout: @@ -1434,13 +1145,11 @@ void GSocket::Disable(GSocketEvent event) */ GSocketError GSocket::Input_Timeout() { - struct timeval tv; fd_set readfds; int ret; - /* Linux select() will overwrite the struct on return */ - tv.tv_sec = (m_timeout / 1000); - tv.tv_usec = (m_timeout % 1000) * 1000; + // Linux select() will overwrite the struct on return so make a copy + struct timeval tv = m_timeout; if (!m_non_blocking) { @@ -1475,13 +1184,11 @@ GSocketError GSocket::Input_Timeout() */ GSocketError GSocket::Output_Timeout() { - struct timeval tv; fd_set writefds; int ret; - /* Linux select() will overwrite the struct on return */ - tv.tv_sec = (m_timeout / 1000); - tv.tv_usec = (m_timeout % 1000) * 1000; + // Linux select() will overwrite the struct on return so make a copy + struct timeval tv = m_timeout; GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) ); @@ -1539,7 +1246,7 @@ int GSocket::Recv_Stream(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; @@ -1548,7 +1255,7 @@ int GSocket::Recv_Dgram(char *buffer, int size) 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 */ @@ -1566,7 +1273,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); @@ -1630,6 +1337,15 @@ int GSocket::Send_Dgram(const char *buffer, int size) return ret; } +void GSocket::OnStateChange(GSocketEvent event) +{ + DisableEvent(event); + NotifyOnStateChange(event); + + if ( event == GSOCK_LOST ) + Shutdown(); +} + void GSocket::Detected_Read() { char c; @@ -1647,8 +1363,7 @@ void GSocket::Detected_Read() { m_establishing = false; - CALL_CALLBACK(this, GSOCK_LOST); - Shutdown(); + OnStateChange(GSOCK_LOST); return; } @@ -1656,25 +1371,37 @@ void GSocket::Detected_Read() if (num > 0) { - CALL_CALLBACK(this, GSOCK_INPUT); + OnStateChange(GSOCK_INPUT); } else { if (m_server && m_stream) { - CALL_CALLBACK(this, GSOCK_CONNECTION); + OnStateChange(GSOCK_CONNECTION); + } + else if (num == 0) + { + if (m_stream) + { + /* graceful shutdown */ + OnStateChange(GSOCK_LOST); + } + else + { + /* Empty datagram received */ + OnStateChange(GSOCK_INPUT); + } } else { /* 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); + OnStateChange(GSOCK_INPUT); } else { - CALL_CALLBACK(this, GSOCK_LOST); - Shutdown(); + OnStateChange(GSOCK_LOST); } } } @@ -1689,8 +1416,7 @@ void GSocket::Detected_Write() { m_establishing = false; - CALL_CALLBACK(this, GSOCK_LOST); - Shutdown(); + OnStateChange(GSOCK_LOST); return; } @@ -1705,37 +1431,24 @@ void GSocket::Detected_Write() if (error) { - CALL_CALLBACK(this, GSOCK_LOST); - Shutdown(); + OnStateChange(GSOCK_LOST); } else { - CALL_CALLBACK(this, GSOCK_CONNECTION); + OnStateChange(GSOCK_CONNECTION); /* We have to fire this event by hand because CONNECTION (for clients) * and OUTPUT are internally the same and we just disabled CONNECTION * events with the above macro. */ - CALL_CALLBACK(this, GSOCK_OUTPUT); + OnStateChange(GSOCK_OUTPUT); } } else { - CALL_CALLBACK(this, GSOCK_OUTPUT); + OnStateChange(GSOCK_OUTPUT); } } -/* Compatibility functions for GSocket */ -GSocket *GSocket_new(void) -{ - GSocket *newsocket = new GSocket(); - if (newsocket->IsOk()) - return newsocket; - - delete newsocket; - - return NULL; -} - /* * ------------------------------------------------------------------------- * GAddress @@ -1849,11 +1562,11 @@ GSocketError _GAddress_translate_from(GAddress *address, case AF_UNIX: address->m_family = GSOCK_UNIX; break; -#ifdef AF_INET6 +#if wxUSE_IPV6 case AF_INET6: address->m_family = GSOCK_INET6; break; -#endif +#endif // wxUSE_IPV6 default: { address->m_error = GSOCK_INVOP; @@ -1975,6 +1688,12 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) 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); @@ -2110,6 +1829,169 @@ unsigned short GAddress_INET_GetPort(GAddress *address) 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 @@ -2166,4 +2048,4 @@ GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf) return GSOCK_NOERROR; } #endif /* !defined(__VISAGECPP__) */ -#endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */ +#endif /* wxUSE_SOCKETS */