X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b74865fa61c17c45f65d9f59befc52516e41c9c7..0372d42ea50de251b381c22855b372a967bc04d9:/src/unix/gsocket.cpp?ds=sidebyside diff --git a/src/unix/gsocket.cpp b/src/unix/gsocket.cpp index 97eeb0153b..5cb9783b71 100644 --- a/src/unix/gsocket.cpp +++ b/src/unix/gsocket.cpp @@ -20,6 +20,7 @@ #ifndef __GSOCKET_STANDALONE__ #include "wx/defs.h" +#include "wx/private/gsocketiohandler.h" #endif #if defined(__VISAGECPP__) @@ -39,6 +40,10 @@ #include #include +#ifdef HAVE_SYS_SELECT_H +# include +#endif + #ifdef __VMS__ #include struct sockaddr_un @@ -197,40 +202,87 @@ 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 + 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, *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 +#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) @@ -252,7 +304,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); @@ -264,6 +315,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) @@ -287,7 +341,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); @@ -304,37 +357,67 @@ 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) { @@ -351,7 +434,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); @@ -368,68 +450,26 @@ struct servent *wxGetservbyname_r(const char *port, const char *protocol, # 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: */ -static GSocketGUIFunctionsTable *gs_gui_functions; - -class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable -{ -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) +bool GSocket_Init() { - 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 */ @@ -439,6 +479,8 @@ GSocket::GSocket() int i; m_fd = INVALID_SOCKET; + m_handler = NULL; + for (i=0;iInit_Socket(this); + m_ok = GSocketManager::Get()->Init_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 + if (m_use_events) + DisableEvents(); + + /* 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; } @@ -479,8 +532,9 @@ GSocket::~GSocket() if (m_fd != INVALID_SOCKET) Shutdown(); - /* Per-socket GUI-specific cleanup */ - gs_gui_functions->Destroy_Socket(this); + GSocketManager::Get()->Destroy_Socket(this); + + delete m_handler; /* Destroy private addresses */ if (m_local) @@ -488,6 +542,7 @@ GSocket::~GSocket() if (m_peer) GAddress_destroy(m_peer); + } /* GSocket_Shutdown: @@ -501,12 +556,13 @@ void GSocket::Shutdown() assert(this); /* Don't allow events to fire after socket has been closed */ - gs_gui_functions->Disable_Events(this); + if (m_use_events) + DisableEvents(); /* If socket has been created, shutdown it */ if (m_fd != INVALID_SOCKET) { - shutdown(m_fd, 2); + shutdown(m_fd, 1); Close(); } @@ -581,7 +637,7 @@ GSocketError GSocket::SetPeer(GAddress *address) GAddress *GSocket::GetLocal() { GAddress *address; - struct sockaddr addr; + wxSockAddr addr; WX_SOCKLEN_T size = sizeof(addr); GSocketError err; @@ -598,7 +654,7 @@ GAddress *GSocket::GetLocal() 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; @@ -612,7 +668,7 @@ GAddress *GSocket::GetLocal() return NULL; } - err = _GAddress_translate_from(address, &addr, size); + err = _GAddress_translate_from(address, (sockaddr*)&addr, size); if (err != GSOCK_NOERROR) { GAddress_destroy(address); @@ -681,20 +737,21 @@ 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); + if (m_use_events) + 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(u_long)); + setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg)); #endif } @@ -730,7 +787,7 @@ GSocketError GSocket::SetServer() */ GSocket *GSocket::WaitConnection() { - struct sockaddr from; + wxSockAddr from; WX_SOCKLEN_T fromlen = sizeof(from); GSocket *connection; GSocketError err; @@ -762,7 +819,7 @@ 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); @@ -791,7 +848,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; @@ -804,11 +861,28 @@ 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; + EnableEvents(flag); +} + +void GSocket::EnableEvents(bool flag) +{ + if (flag) + GSocketManager::Get()->Enable_Events(this); + else + GSocketManager::Get()->Disable_Events(this); +} + bool GSocket::SetReusable() { /* socket must not be null, and must not be in use/already bound */ @@ -822,6 +896,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: @@ -886,7 +980,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,12 +992,17 @@ GSocketError GSocket::Connect(GSocketStream stream) // 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(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(u_long)); + 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) { @@ -921,8 +1020,8 @@ GSocketError GSocket::Connect(GSocketStream stream) * call to Enable_Events now. */ - if (m_non_blocking || ret == 0) - gs_gui_functions->Enable_Events(this); + if (m_use_events && (m_non_blocking || ret == 0)) + EnableEvents(); if (ret == -1) { @@ -947,8 +1046,8 @@ 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); + if (m_use_events) + EnableEvents(); if (!error) return GSOCK_NOERROR; @@ -1028,21 +1127,36 @@ GSocketError GSocket::SetNonOriented() #else ioctl(m_fd, FIONBIO, &arg); #endif - gs_gui_functions->Enable_Events(this); + if (m_use_events) + 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; } @@ -1079,12 +1193,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)) @@ -1167,116 +1294,101 @@ int GSocket::Write(const char *buffer, int size) */ 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); - assert(this); + GSocketEventFlags result = 0; + fd_set readfds; + fd_set writefds; + fd_set exceptfds; + struct timeval tv; - if (m_fd == -1) - return (GSOCK_LOST_FLAG & flags); + 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; + /* Do not use a static struct, Linux can garble it */ + tv.tv_sec = 0; + tv.tv_usec = 0; - 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); + 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); + /* 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; + /* 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); + } - 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); + } - /* Try select now */ - if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0) - { - /* What to do here? */ - return (result & flags); - } + /* Check for exceptions and errors */ + if (wxFD_ISSET(m_fd, &exceptfds)) + { + m_establishing = false; + m_detected = GSOCK_LOST_FLAG; - /* 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); + } - /* LOST event: Abort any further processing */ - return (GSOCK_LOST_FLAG & flags); - } + /* Check for readability */ + if (wxFD_ISSET(m_fd, &readfds)) + { + result |= GSOCK_INPUT_FLAG; - /* Check for readability */ - if (wxFD_ISSET(m_fd, &readfds)) + if (m_server && m_stream) { - result |= GSOCK_INPUT_FLAG; - - if (m_server && m_stream) - { - /* 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; - } + /* 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. */ + m_detected |= GSOCK_CONNECTION_FLAG; } + } - /* Check for writability */ - if (wxFD_ISSET(m_fd, &writefds)) + /* Check for writability */ + if (wxFD_ISSET(m_fd, &writefds)) + { + if (m_establishing && !m_server) { - 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); + 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; + 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; - } + /* LOST event: Abort any further processing */ + return (GSOCK_LOST_FLAG & flags); } else { - result |= GSOCK_OUTPUT_FLAG; + m_detected |= GSOCK_CONNECTION_FLAG; } } - - return (result & flags); - - } - else - { - assert(this); - return flags & m_detected; + else + { + result |= GSOCK_OUTPUT_FLAG; + } } + + return (result | m_detected) & flags; } /* Flags */ @@ -1411,14 +1523,20 @@ GSocketError GSocket::SetSockOpt(int level, int optname, void GSocket::Enable(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) { - 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: @@ -1532,7 +1650,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; @@ -1541,7 +1659,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 */ @@ -1559,7 +1677,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); @@ -1657,6 +1775,20 @@ void GSocket::Detected_Read() { CALL_CALLBACK(this, GSOCK_CONNECTION); } + else if (num == 0) + { + if (m_stream) + { + /* graceful shutdown */ + CALL_CALLBACK(this, GSOCK_LOST); + Shutdown(); + } + else + { + /* Empty datagram received */ + CALL_CALLBACK(this, GSOCK_INPUT); + } + } else { /* Do not throw a lost event in cases where the socket isn't really lost */ @@ -1842,11 +1974,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; @@ -1968,6 +2100,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); @@ -2103,6 +2241,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