+/////////////////////////////////////////////////////////////////////////////
+// Name: src/unix/sockunix.cpp
+// Purpose: wxSocketImpl implementation for Unix systems
+// Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia, David Elliott,
+// Vadim Zeitlin
+// Created: April 1997
+// RCS-ID: $Id$
+// Copyright: (c) 1997 Guilhem Lavaux
+// (c) 2008 Vadim Zeitlin
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+
+#include "wx/wxprec.h"
+
+#if wxUSE_SOCKETS
+
+#include "wx/private/fd.h"
+#include "wx/private/socket.h"
+#include "wx/unix/private/sockunix.h"
+#include "wx/private/gsocketiohandler.h"
+
+#if defined(__VISAGECPP__)
+#define BSD_SELECT /* use Berkeley Sockets select */
+#endif
+
+#if defined(__WATCOMC__)
+#include <errno.h>
+#include <nerrno.h>
+#endif
+
+#include <assert.h>
+#include <sys/types.h>
+#ifdef __VISAGECPP__
+#include <string.h>
+#include <sys/time.h>
+#include <types.h>
+#include <netinet/in.h>
+#endif
+#include <netdb.h>
+#include <sys/ioctl.h>
+
+#ifdef HAVE_SYS_SELECT_H
+# include <sys/select.h>
+#endif
+
+#ifdef __VMS__
+#include <socket.h>
+struct sockaddr_un
+{
+ u_char sun_len; /* sockaddr len including null */
+ u_char sun_family; /* AF_UNIX */
+ char sun_path[108]; /* path name (gag) */
+};
+#else
+#include <sys/socket.h>
+#include <sys/un.h>
+#endif
+
+#ifndef __VISAGECPP__
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#else
+#include <nerrno.h>
+# if __IBMCPP__ < 400
+#include <machine/endian.h>
+#include <socket.h>
+#include <ioctl.h>
+#include <select.h>
+#include <unistd.h>
+
+#define EBADF SOCEBADF
+
+# ifdef min
+# undef min
+# endif
+# else
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+
+#define close(a) soclose(a)
+#define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
+int _System bsdselect(int,
+ struct fd_set *,
+ struct fd_set *,
+ struct fd_set *,
+ struct timeval *);
+int _System soclose(int);
+# endif
+#endif
+#ifdef __EMX__
+#include <sys/select.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <ctype.h>
+#ifdef sun
+# include <sys/filio.h>
+#endif
+#ifdef sgi
+# include <bstring.h>
+#endif
+#ifdef _AIX
+# include <strings.h>
+#endif
+#include <signal.h>
+
+#ifndef WX_SOCKLEN_T
+
+#ifdef VMS
+# define WX_SOCKLEN_T unsigned int
+#else
+# ifdef __GLIBC__
+# if __GLIBC__ == 2
+# define WX_SOCKLEN_T socklen_t
+# endif
+# elif defined(__WXMAC__)
+# define WX_SOCKLEN_T socklen_t
+# else
+# define WX_SOCKLEN_T int
+# endif
+#endif
+
+#endif /* SOCKLEN_T */
+
+#ifndef SOCKOPTLEN_T
+#define SOCKOPTLEN_T WX_SOCKLEN_T
+#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.
+ */
+#ifndef INADDR_NONE
+#define INADDR_NONE INADDR_BROADCAST
+#endif
+
+#if defined(__VISAGECPP__) || defined(__WATCOMC__)
+
+ #define MASK_SIGNAL() {
+ #define UNMASK_SIGNAL() }
+
+#else
+ extern "C" { typedef void (*wxSigHandler)(int); }
+
+ #define MASK_SIGNAL() \
+ { \
+ wxSigHandler 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 */
+
+#if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME))
+# include "wx/thread.h"
+#endif
+
+#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)
+ {
+ *err = ENOMEM;
+ return NULL;
+ }
+ memcpy(buffer, h->h_name, len);
+ buffer[len] = '\0';
+ h->h_name = buffer;
+
+ /* track position in the buffer */
+ int pos = len + 1;
+
+ /* reuse len to store address length */
+ len = h->h_length;
+
+ /* 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 + 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)
+
+{
+ struct hostent *he = NULL;
+ *err = 0;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
+ if (gethostbyname_r(hostname, h, (char*)buffer, size, &he, err))
+ he = NULL;
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
+ he = gethostbyname_r(hostname, h, (char*)buffer, size, err);
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+ if (gethostbyname_r(hostname, h, (struct hostent_data*) buffer))
+ {
+ he = NULL;
+ *err = h_errno;
+ }
+ else
+ he = h;
+#elif defined(HAVE_GETHOSTBYNAME)
+#if wxUSE_THREADS
+ wxMutexLocker locker(nameLock);
+#endif
+ he = gethostbyname(hostname);
+ if (!he)
+ *err = h_errno;
+ else
+ he = deepCopyHostent(h, he, (char*)buffer, size, err);
+#endif
+ 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)
+{
+ struct hostent *he = NULL;
+ *err = 0;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
+ if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
+ (char*)buffer, size, &he, err))
+ he = NULL;
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
+ he = gethostbyaddr_r(addr_buf, buf_size, proto, h, (char*)buffer, size, err);
+#elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+ if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
+ (struct hostent_data*) buffer))
+ {
+ he = NULL;
+ *err = h_errno;
+ }
+ else
+ he = h;
+#elif defined(HAVE_GETHOSTBYNAME)
+#if wxUSE_THREADS
+ wxMutexLocker locker(addrLock);
+#endif
+ he = gethostbyaddr(addr_buf, buf_size, proto);
+ if (!he)
+ *err = h_errno;
+ else
+ he = deepCopyHostent(h, he, (char*)buffer, size, err);
+#endif
+ return he;
+}
+
+#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)
+ {
+ return NULL;
+ }
+ memcpy(buffer, s->s_name, len);
+ buffer[len] = '\0';
+ s->s_name = buffer;
+
+ /* track position in the buffer */
+ int pos = len + 1;
+
+ /* copy protocol */
+ len = strlen(s->s_proto);
+ 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)
+{
+ struct servent *se = NULL;
+#if defined(HAVE_FUNC_GETSERVBYNAME_R_6)
+ if (getservbyname_r(port, protocol, serv, (char*)buffer, size, &se))
+ se = NULL;
+#elif defined(HAVE_FUNC_GETSERVBYNAME_R_5)
+ se = getservbyname_r(port, protocol, serv, (char*)buffer, size);
+#elif defined(HAVE_FUNC_GETSERVBYNAME_R_4)
+ if (getservbyname_r(port, protocol, serv, (struct servent_data*) buffer))
+ se = NULL;
+ else
+ se = serv;
+#elif defined(HAVE_GETSERVBYNAME)
+#if wxUSE_THREADS
+ wxMutexLocker locker(servLock);
+#endif
+ se = getservbyname(port, protocol);
+ if (se)
+ se = deepCopyServent(serv, se, (char*)buffer, size);
+#endif
+ return se;
+}
+
+/* debugging helpers */
+#ifdef __GSOCKET_DEBUG__
+# define SOCKET_DEBUG(args) printf args
+#else
+# define SOCKET_DEBUG(args)
+#endif /* __GSOCKET_DEBUG__ */
+
+/* Constructors / Destructors for wxSocketImplUnix */
+
+wxSocketImplUnix::wxSocketImplUnix(wxSocketBase& wxsocket)
+ : wxSocketImpl(wxsocket)
+{
+ m_fds[0] =
+ m_fds[1] = -1;
+
+ m_use_events = false;
+}
+
+/*
+ * Disallow further read/write operations on this socket, close
+ * the fd and disable all callbacks.
+ */
+void wxSocketImplUnix::Shutdown()
+{
+ /* Don't allow events to fire after socket has been closed */
+ DisableEvents();
+
+ wxSocketImpl::Shutdown();
+}
+
+/*
+ * Waits for an incoming client connection. Returns a pointer to
+ * a wxSocketImplUnix object, or NULL if there was an error, in which case
+ * the last error field will be updated for the calling wxSocketImplUnix.
+ *
+ * Error codes (set in the calling wxSocketImplUnix)
+ * wxSOCKET_INVSOCK - the socket is not valid or not a server.
+ * wxSOCKET_TIMEDOUT - timeout, no incoming connections.
+ * wxSOCKET_WOULDBLOCK - the call would block and the socket is nonblocking.
+ * wxSOCKET_MEMERR - couldn't allocate memory.
+ * wxSOCKET_IOERR - low-level error.
+ */
+wxSocketImpl *wxSocketImplUnix::WaitConnection(wxSocketBase& wxsocket)
+{
+ wxSockAddr from;
+ WX_SOCKLEN_T fromlen = sizeof(from);
+ wxSocketImpl *connection;
+ wxSocketError err;
+ int arg = 1;
+
+ /* If the socket has already been created, we exit immediately */
+ if (m_fd == INVALID_SOCKET || !m_server)
+ {
+ m_error = wxSOCKET_INVSOCK;
+ return NULL;
+ }
+
+ /* Create a wxSocketImplUnix object for the new connection */
+ connection = wxSocketImplUnix::Create(wxsocket);
+
+ if (!connection)
+ {
+ m_error = wxSOCKET_MEMERR;
+ return NULL;
+ }
+
+ /* Wait for a connection (with timeout) */
+ if (Input_Timeout() == wxSOCKET_TIMEDOUT)
+ {
+ delete connection;
+ /* m_error set by Input_Timeout */
+ return NULL;
+ }
+
+ connection->m_fd = accept(m_fd, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);
+
+ /* Reenable CONNECTION events */
+ EnableEvent(wxSOCKET_CONNECTION);
+
+ if (connection->m_fd == INVALID_SOCKET)
+ {
+ if (errno == EWOULDBLOCK)
+ m_error = wxSOCKET_WOULDBLOCK;
+ else
+ m_error = wxSOCKET_IOERR;
+
+ delete connection;
+ return NULL;
+ }
+
+ /* Initialize all fields */
+ connection->m_server = false;
+ connection->m_stream = true;
+
+ /* Setup the peer address field */
+ connection->m_peer = GAddress_new();
+ if (!connection->m_peer)
+ {
+ delete connection;
+ m_error = wxSOCKET_MEMERR;
+ return NULL;
+ }
+
+ err = _GAddress_translate_from(connection->m_peer, (sockaddr*)&from, fromlen);
+ if (err != wxSOCKET_NOERROR)
+ {
+ delete connection;
+ m_error = err;
+ return NULL;
+ }
+
+#if defined(__EMX__) || defined(__VISAGECPP__)
+ ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
+#else
+ ioctl(connection->m_fd, FIONBIO, &arg);
+#endif
+ if (m_use_events)
+ connection->Notify(true);
+
+ return connection;
+}
+
+void wxSocketImplUnix::Notify(bool flag)
+{
+ if (flag == m_use_events)
+ return;
+ m_use_events = flag;
+ DoEnableEvents(flag);
+}
+
+void wxSocketImplUnix::DoEnableEvents(bool flag)
+{
+ wxSocketManager * const manager = wxSocketManager::Get();
+ if ( flag )
+ {
+ manager->Install_Callback(this, wxSOCKET_INPUT);
+ manager->Install_Callback(this, wxSOCKET_OUTPUT);
+ }
+ else // off
+ {
+ manager->Uninstall_Callback(this, wxSOCKET_INPUT);
+ manager->Uninstall_Callback(this, wxSOCKET_OUTPUT);
+ }
+}
+
+wxSocketError wxSocketImplUnix::DoHandleConnect(int ret)
+{
+ /* 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 EnableEvents() now.
+ */
+ if ( m_non_blocking || (ret == 0) )
+ EnableEvents();
+
+ if (ret == -1)
+ {
+ const int err = errno;
+
+ /* If connect failed with EINPROGRESS and the wxSocketImplUnix object
+ * is in blocking mode, we select() for the specified timeout
+ * checking for writability to see if the connection request
+ * completes.
+ */
+ if ((err == EINPROGRESS) && (!m_non_blocking))
+ {
+ if (Output_Timeout() == wxSOCKET_TIMEDOUT)
+ {
+ Close();
+ /* m_error is set in Output_Timeout */
+ return wxSOCKET_TIMEDOUT;
+ }
+ else
+ {
+ int error;
+ SOCKOPTLEN_T len = sizeof(error);
+
+ getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
+ EnableEvents();
+
+ if (!error)
+ return wxSOCKET_NOERROR;
+ }
+ }
+
+ /* If connect failed with EINPROGRESS and the wxSocketImplUnix object
+ * is set to nonblocking, we set m_error to wxSOCKET_WOULDBLOCK
+ * (and return wxSOCKET_WOULDBLOCK) but we don't close the socket;
+ * this way if the connection completes, a wxSOCKET_CONNECTION
+ * event will be generated, if enabled.
+ */
+ if ((err == EINPROGRESS) && (m_non_blocking))
+ {
+ m_establishing = true;
+ m_error = wxSOCKET_WOULDBLOCK;
+ return wxSOCKET_WOULDBLOCK;
+ }
+
+ /* If connect failed with an error other than EINPROGRESS,
+ * then the call to Connect has failed.
+ */
+ Close();
+ m_error = wxSOCKET_IOERR;
+
+ return wxSOCKET_IOERR;
+ }
+
+ return wxSOCKET_NOERROR;
+}
+
+/* Generic IO */
+
+/* Like recv(), send(), ... */
+int wxSocketImplUnix::Read(char *buffer, int size)
+{
+ int ret;
+
+ if (m_fd == INVALID_SOCKET || m_server)
+ {
+ m_error = wxSOCKET_INVSOCK;
+ return -1;
+ }
+
+ /* Disable events during query of socket status */
+ DisableEvent(wxSOCKET_INPUT);
+
+ /* If the socket is blocking, wait for data (with a timeout) */
+ if (Input_Timeout() == wxSOCKET_TIMEDOUT) {
+ m_error = wxSOCKET_TIMEDOUT;
+ /* Don't return here immediately, otherwise socket events would not be
+ * re-enabled! */
+ ret = -1;
+ }
+ else
+ {
+ /* Read the data */
+ if (m_stream)
+ ret = Recv_Stream(buffer, size);
+ else
+ ret = Recv_Dgram(buffer, size);
+
+ /*
+ * 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_stream)
+ {
+ /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */
+ if (m_use_events)
+ {
+ m_detected = wxSOCKET_LOST_FLAG;
+ Detected_Read();
+ return 0;
+ }
+ }
+ else if (ret == -1)
+ {
+ if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
+ m_error = wxSOCKET_WOULDBLOCK;
+ else
+ m_error = wxSOCKET_IOERR;
+ }
+ }
+
+ /* Enable events again now that we are done processing */
+ EnableEvent(wxSOCKET_INPUT);
+
+ return ret;
+}
+
+int wxSocketImplUnix::Write(const char *buffer, int size)
+{
+ int ret;
+
+ SOCKET_DEBUG(( "Write #1, size %d\n", size ));
+
+ if (m_fd == INVALID_SOCKET || m_server)
+ {
+ m_error = wxSOCKET_INVSOCK;
+ return -1;
+ }
+
+ SOCKET_DEBUG(( "Write #2, size %d\n", size ));
+
+ /* If the socket is blocking, wait for writability (with a timeout) */
+ if (Output_Timeout() == wxSOCKET_TIMEDOUT)
+ return -1;
+
+ SOCKET_DEBUG(( "Write #3, size %d\n", size ));
+
+ /* Write the data */
+ if (m_stream)
+ ret = Send_Stream(buffer, size);
+ else
+ ret = Send_Dgram(buffer, size);
+
+ SOCKET_DEBUG(( "Write #4, size %d\n", size ));
+
+ if (ret == -1)
+ {
+ if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
+ {
+ m_error = wxSOCKET_WOULDBLOCK;
+ SOCKET_DEBUG(( "Write error WOULDBLOCK\n" ));
+ }
+ else
+ {
+ m_error = wxSOCKET_IOERR;
+ SOCKET_DEBUG(( "Write error IOERR\n" ));
+ }
+
+ /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
+ * in MSW). Once the first OUTPUT event is received, users can assume
+ * that the socket is writable until a read operation fails. Only then
+ * will further OUTPUT events be posted.
+ */
+ EnableEvent(wxSOCKET_OUTPUT);
+
+ return -1;
+ }
+
+ SOCKET_DEBUG(( "Write #5, size %d ret %d\n", size, ret ));
+
+ return ret;
+}
+
+/* Flags */
+
+void wxSocketImplUnix::EnableEvent(wxSocketNotify event)
+{
+ if (m_use_events)
+ {
+ m_detected &= ~(1 << event);
+ wxSocketManager::Get()->Install_Callback(this, event);
+ }
+}
+
+void wxSocketImplUnix::DisableEvent(wxSocketNotify event)
+{
+ if (m_use_events)
+ {
+ m_detected |= (1 << event);
+ wxSocketManager::Get()->Uninstall_Callback(this, event);
+ }
+}
+
+/*
+ * For blocking sockets, wait until data is available or
+ * until timeout ellapses.
+ */
+wxSocketError wxSocketImplUnix::Input_Timeout()
+{
+ fd_set readfds;
+ int ret;
+
+ // Linux select() will overwrite the struct on return so make a copy
+ struct timeval tv = m_timeout;
+
+ if (!m_non_blocking)
+ {
+ wxFD_ZERO(&readfds);
+ wxFD_SET(m_fd, &readfds);
+ ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
+ if (ret == 0)
+ {
+ SOCKET_DEBUG(( "Input_Timeout, select returned 0\n" ));
+ m_error = wxSOCKET_TIMEDOUT;
+ return wxSOCKET_TIMEDOUT;
+ }
+
+ if (ret == -1)
+ {
+ SOCKET_DEBUG(( "Input_Timeout, select returned -1\n" ));
+ if (errno == EBADF) { SOCKET_DEBUG(( "Invalid file descriptor\n" )); }
+ if (errno == EINTR) { SOCKET_DEBUG(( "A non blocked signal was caught\n" )); }
+ if (errno == EINVAL) { SOCKET_DEBUG(( "The highest number descriptor is negative\n" )); }
+ if (errno == ENOMEM) { SOCKET_DEBUG(( "Not enough memory\n" )); }
+ m_error = wxSOCKET_TIMEDOUT;
+ return wxSOCKET_TIMEDOUT;
+ }
+ }
+
+ return wxSOCKET_NOERROR;
+}
+
+/*
+ * For blocking sockets, wait until data can be sent without
+ * blocking or until timeout ellapses.
+ */
+wxSocketError wxSocketImplUnix::Output_Timeout()
+{
+ fd_set writefds;
+ int ret;
+
+ // Linux select() will overwrite the struct on return so make a copy
+ struct timeval tv = m_timeout;
+
+ SOCKET_DEBUG( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
+
+ if (!m_non_blocking)
+ {
+ wxFD_ZERO(&writefds);
+ wxFD_SET(m_fd, &writefds);
+ ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
+ if (ret == 0)
+ {
+ SOCKET_DEBUG(( "Output_Timeout, select returned 0\n" ));
+ m_error = wxSOCKET_TIMEDOUT;
+ return wxSOCKET_TIMEDOUT;
+ }
+
+ if (ret == -1)
+ {
+ SOCKET_DEBUG(( "Output_Timeout, select returned -1\n" ));
+ if (errno == EBADF) { SOCKET_DEBUG(( "Invalid file descriptor\n" )); }
+ if (errno == EINTR) { SOCKET_DEBUG(( "A non blocked signal was caught\n" )); }
+ if (errno == EINVAL) { SOCKET_DEBUG(( "The highest number descriptor is negative\n" )); }
+ if (errno == ENOMEM) { SOCKET_DEBUG(( "Not enough memory\n" )); }
+ m_error = wxSOCKET_TIMEDOUT;
+ return wxSOCKET_TIMEDOUT;
+ }
+
+ if ( ! wxFD_ISSET(m_fd, &writefds) )
+ {
+ SOCKET_DEBUG(( "Output_Timeout is buggy!\n" ));
+ }
+ else
+ {
+ SOCKET_DEBUG(( "Output_Timeout seems correct\n" ));
+ }
+ }
+ else
+ {
+ SOCKET_DEBUG(( "Output_Timeout, didn't try select!\n" ));
+ }
+
+ return wxSOCKET_NOERROR;
+}
+
+int wxSocketImplUnix::Recv_Stream(char *buffer, int size)
+{
+ int ret;
+ do
+ {
+ ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
+ }
+ while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+
+ return ret;
+}
+
+int wxSocketImplUnix::Recv_Dgram(char *buffer, int size)
+{
+ wxSockAddr from;
+ WX_SOCKLEN_T fromlen = sizeof(from);
+ int ret;
+ wxSocketError err;
+
+ fromlen = sizeof(from);
+
+ do
+ {
+ ret = recvfrom(m_fd, buffer, size, 0, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);
+ }
+ while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+
+ if (ret == -1)
+ return -1;
+
+ /* Translate a system address into a wxSocketImplUnix address */
+ if (!m_peer)
+ {
+ m_peer = GAddress_new();
+ if (!m_peer)
+ {
+ m_error = wxSOCKET_MEMERR;
+ return -1;
+ }
+ }
+
+ err = _GAddress_translate_from(m_peer, (sockaddr*)&from, fromlen);
+ if (err != wxSOCKET_NOERROR)
+ {
+ GAddress_destroy(m_peer);
+ m_peer = NULL;
+ m_error = err;
+ return -1;
+ }
+
+ return ret;
+}
+
+int wxSocketImplUnix::Send_Stream(const char *buffer, int size)
+{
+ int ret;
+
+ MASK_SIGNAL();
+
+ do
+ {
+ ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
+ }
+ while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+
+ UNMASK_SIGNAL();
+
+ return ret;
+}
+
+int wxSocketImplUnix::Send_Dgram(const char *buffer, int size)
+{
+ struct sockaddr *addr;
+ int len, ret;
+ wxSocketError err;
+
+ if (!m_peer)
+ {
+ m_error = wxSOCKET_INVADDR;
+ return -1;
+ }
+
+ err = _GAddress_translate_to(m_peer, &addr, &len);
+ if (err != wxSOCKET_NOERROR)
+ {
+ m_error = err;
+ return -1;
+ }
+
+ MASK_SIGNAL();
+
+ do
+ {
+ ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
+ }
+ while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
+
+ UNMASK_SIGNAL();
+
+ /* Frees memory allocated from _GAddress_translate_to */
+ free(addr);
+
+ return ret;
+}
+
+void wxSocketImplUnix::OnStateChange(wxSocketNotify event)
+{
+ DisableEvent(event);
+ NotifyOnStateChange(event);
+
+ if ( event == wxSOCKET_LOST )
+ Shutdown();
+}
+
+void wxSocketImplUnix::Detected_Read()
+{
+ 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.
+ */
+ if ((m_detected & wxSOCKET_LOST_FLAG) != 0)
+ {
+ m_establishing = false;
+
+ OnStateChange(wxSOCKET_LOST);
+ return;
+ }
+
+ int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
+
+ if (num > 0)
+ {
+ OnStateChange(wxSOCKET_INPUT);
+ }
+ else
+ {
+ if (m_server && m_stream)
+ {
+ OnStateChange(wxSOCKET_CONNECTION);
+ }
+ else if (num == 0)
+ {
+ if (m_stream)
+ {
+ /* graceful shutdown */
+ OnStateChange(wxSOCKET_LOST);
+ }
+ else
+ {
+ /* Empty datagram received */
+ OnStateChange(wxSOCKET_INPUT);
+ }
+ }
+ else
+ {
+ /* Do not throw a lost event in cases where the socket isn't really lost */
+ if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
+ {
+ OnStateChange(wxSOCKET_INPUT);
+ }
+ else
+ {
+ OnStateChange(wxSOCKET_LOST);
+ }
+ }
+ }
+}
+
+void wxSocketImplUnix::Detected_Write()
+{
+ /* If we have already detected a LOST event, then don't try
+ * to do any further processing.
+ */
+ if ((m_detected & wxSOCKET_LOST_FLAG) != 0)
+ {
+ m_establishing = false;
+
+ OnStateChange(wxSOCKET_LOST);
+ return;
+ }
+
+ 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)
+ {
+ OnStateChange(wxSOCKET_LOST);
+ }
+ else
+ {
+ OnStateChange(wxSOCKET_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.
+ */
+ OnStateChange(wxSOCKET_OUTPUT);
+ }
+ }
+ else
+ {
+ OnStateChange(wxSOCKET_OUTPUT);
+ }
+}
+
+/*
+ * -------------------------------------------------------------------------
+ * GAddress
+ * -------------------------------------------------------------------------
+ */
+
+/* CHECK_ADDRESS verifies that the current address family is either
+ * wxSOCKET_NOFAMILY or wxSOCKET_*family*, and if it is wxSOCKET_NOFAMILY, it
+ * initalizes it to be a wxSOCKET_*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) \
+{ \
+ if (address->m_family == wxSOCKET_NOFAMILY) \
+ if (_GAddress_Init_##family(address) != wxSOCKET_NOERROR) \
+ return address->m_error; \
+ if (address->m_family != wxSOCKET_##family) \
+ { \
+ address->m_error = wxSOCKET_INVADDR; \
+ return wxSOCKET_INVADDR; \
+ } \
+}
+
+#define CHECK_ADDRESS_RETVAL(address, family, retval) \
+{ \
+ if (address->m_family == wxSOCKET_NOFAMILY) \
+ if (_GAddress_Init_##family(address) != wxSOCKET_NOERROR) \
+ return retval; \
+ if (address->m_family != wxSOCKET_##family) \
+ { \
+ address->m_error = wxSOCKET_INVADDR; \
+ return retval; \
+ } \
+}
+
+
+GAddress *GAddress_new(void)
+{
+ GAddress *address;
+
+ if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
+ return NULL;
+
+ address->m_family = wxSOCKET_NOFAMILY;
+ address->m_addr = NULL;
+ address->m_len = 0;
+
+ return address;
+}
+
+GAddress *GAddress_copy(GAddress *address)
+{
+ GAddress *addr2;
+
+ assert(address != NULL);
+
+ if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
+ return NULL;
+
+ memcpy(addr2, address, sizeof(GAddress));
+
+ if (address->m_addr && address->m_len > 0)
+ {
+ addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
+ if (addr2->m_addr == NULL)
+ {
+ free(addr2);
+ return NULL;
+ }
+ memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
+ }
+
+ return addr2;
+}
+
+void GAddress_destroy(GAddress *address)
+{
+ assert(address != NULL);
+
+ if (address->m_addr)
+ free(address->m_addr);
+
+ free(address);
+}
+
+void GAddress_SetFamily(GAddress *address, GAddressType type)
+{
+ assert(address != NULL);
+
+ address->m_family = type;
+}
+
+GAddressType GAddress_GetFamily(GAddress *address)
+{
+ assert(address != NULL);
+
+ return address->m_family;
+}
+
+wxSocketError _GAddress_translate_from(GAddress *address,
+ struct sockaddr *addr, int len)
+{
+ address->m_realfamily = addr->sa_family;
+ switch (addr->sa_family)
+ {
+ case AF_INET:
+ address->m_family = wxSOCKET_INET;
+ break;
+ case AF_UNIX:
+ address->m_family = wxSOCKET_UNIX;
+ break;
+#if wxUSE_IPV6
+ case AF_INET6:
+ address->m_family = wxSOCKET_INET6;
+ break;
+#endif // wxUSE_IPV6
+ default:
+ {
+ address->m_error = wxSOCKET_INVOP;
+ return wxSOCKET_INVOP;
+ }
+ }
+
+ if (address->m_addr)
+ free(address->m_addr);
+
+ address->m_len = len;
+ address->m_addr = (struct sockaddr *)malloc(len);
+
+ if (address->m_addr == NULL)
+ {
+ address->m_error = wxSOCKET_MEMERR;
+ return wxSOCKET_MEMERR;
+ }
+
+ memcpy(address->m_addr, addr, len);
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError _GAddress_translate_to(GAddress *address,
+ struct sockaddr **addr, int *len)
+{
+ if (!address->m_addr)
+ {
+ address->m_error = wxSOCKET_INVADDR;
+ return wxSOCKET_INVADDR;
+ }
+
+ *len = address->m_len;
+ *addr = (struct sockaddr *)malloc(address->m_len);
+ if (*addr == NULL)
+ {
+ address->m_error = wxSOCKET_MEMERR;
+ return wxSOCKET_MEMERR;
+ }
+
+ memcpy(*addr, address->m_addr, address->m_len);
+ return wxSOCKET_NOERROR;
+}
+
+/*
+ * -------------------------------------------------------------------------
+ * Internet address family
+ * -------------------------------------------------------------------------
+ */
+
+wxSocketError _GAddress_Init_INET(GAddress *address)
+{
+ address->m_len = sizeof(struct sockaddr_in);
+ address->m_addr = (struct sockaddr *) malloc(address->m_len);
+ if (address->m_addr == NULL)
+ {
+ address->m_error = wxSOCKET_MEMERR;
+ return wxSOCKET_MEMERR;
+ }
+
+ address->m_family = wxSOCKET_INET;
+ address->m_realfamily = PF_INET;
+ ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
+ ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
+{
+ struct hostent *he;
+ struct in_addr *addr;
+
+ assert(address != NULL);
+
+ CHECK_ADDRESS(address, INET);
+
+ addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
+
+ /* If it is a numeric host name, convert it now */
+#if defined(HAVE_INET_ATON)
+ if (inet_aton(hostname, addr) == 0)
+ {
+#elif defined(HAVE_INET_ADDR)
+ if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
+ {
+#else
+ /* Use gethostbyname by default */
+#ifndef __WXMAC__
+ int val = 1; /* VA doesn't like constants in conditional expressions */
+ if (val)
+#endif
+ {
+#endif
+ struct in_addr *array_addr;
+
+ /* It is a real name, we solve it */
+ struct hostent h;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+ struct hostent_data buffer;
+#else
+ char buffer[1024];
+#endif
+ int err;
+ he = wxGethostbyname_r(hostname, &h, (void*)&buffer, sizeof(buffer), &err);
+ if (he == NULL)
+ {
+ /* Reset to invalid address */
+ addr->s_addr = INADDR_NONE;
+ address->m_error = wxSOCKET_NOHOST;
+ return wxSOCKET_NOHOST;
+ }
+
+ array_addr = (struct in_addr *) *(he->h_addr_list);
+ addr->s_addr = array_addr[0].s_addr;
+ }
+
+ return wxSOCKET_NOERROR;
+}
+
+
+wxSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
+{
+ return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
+}
+
+wxSocketError GAddress_INET_SetAnyAddress(GAddress *address)
+{
+ return GAddress_INET_SetHostAddress(address, INADDR_ANY);
+}
+
+wxSocketError GAddress_INET_SetHostAddress(GAddress *address,
+ unsigned long hostaddr)
+{
+ struct in_addr *addr;
+
+ assert(address != NULL);
+
+ CHECK_ADDRESS(address, INET);
+
+ addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
+ addr->s_addr = htonl(hostaddr);
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
+ const char *protocol)
+{
+ struct servent *se;
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, INET);
+
+ if (!port)
+ {
+ address->m_error = wxSOCKET_INVPORT;
+ return wxSOCKET_INVPORT;
+ }
+
+#if defined(HAVE_FUNC_GETSERVBYNAME_R_4)
+ struct servent_data buffer;
+#else
+ char buffer[1024];
+#endif
+ struct servent serv;
+ se = wxGetservbyname_r(port, protocol, &serv,
+ (void*)&buffer, sizeof(buffer));
+ if (!se)
+ {
+ /* the cast to int suppresses compiler warnings about subscript having the
+ type char */
+ if (isdigit((int)port[0]))
+ {
+ int port_int;
+
+ port_int = atoi(port);
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr->sin_port = htons(port_int);
+ return wxSOCKET_NOERROR;
+ }
+
+ address->m_error = wxSOCKET_INVPORT;
+ return wxSOCKET_INVPORT;
+ }
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr->sin_port = se->s_port;
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
+{
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, INET);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr->sin_port = htons(port);
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
+{
+ struct hostent *he;
+ char *addr_buf;
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, INET);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr_buf = (char *)&(addr->sin_addr);
+
+ struct hostent temphost;
+#if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
+ struct hostent_data buffer;
+#else
+ char buffer[1024];
+#endif
+ int err;
+ he = wxGethostbyaddr_r(addr_buf, sizeof(addr->sin_addr), AF_INET, &temphost,
+ (void*)&buffer, sizeof(buffer), &err);
+ if (he == NULL)
+ {
+ address->m_error = wxSOCKET_NOHOST;
+ return wxSOCKET_NOHOST;
+ }
+
+ strncpy(hostname, he->h_name, sbuf);
+
+ return wxSOCKET_NOERROR;
+}
+
+unsigned long GAddress_INET_GetHostAddress(GAddress *address)
+{
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS_RETVAL(address, INET, 0);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+
+ return ntohl(addr->sin_addr.s_addr);
+}
+
+unsigned short GAddress_INET_GetPort(GAddress *address)
+{
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS_RETVAL(address, INET, 0);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ return ntohs(addr->sin_port);
+}
+
+#if wxUSE_IPV6
+/*
+ * -------------------------------------------------------------------------
+ * Internet IPv6 address family
+ * -------------------------------------------------------------------------
+ */
+
+wxSocketError _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 = wxSOCKET_MEMERR;
+ return wxSOCKET_MEMERR;
+ }
+ memset(address->m_addr,0,address->m_len);
+
+ address->m_family = wxSOCKET_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 wxSOCKET_NOERROR;
+}
+
+wxSocketError 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 = wxSOCKET_NOHOST;
+ return wxSOCKET_NOHOST;
+ }
+
+ memcpy( address->m_addr, info->ai_addr, info->ai_addrlen );
+ freeaddrinfo( info );
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError 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);
+}
+wxSocketError 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 wxSOCKET_NOERROR;
+}
+
+wxSocketError 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 = wxSOCKET_INVPORT;
+ return wxSOCKET_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 wxSOCKET_NOERROR;
+ }
+
+ address->m_error = wxSOCKET_INVPORT;
+ return wxSOCKET_INVPORT;
+ }
+
+ addr = (struct sockaddr_in6 *)address->m_addr;
+ addr->sin6_port = se->s_port;
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError 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 wxSOCKET_NOERROR;
+}
+
+wxSocketError 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 = wxSOCKET_NOHOST;
+ return wxSOCKET_NOHOST;
+ }
+
+ strncpy(hostname, he->h_name, sbuf);
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError GAddress_INET6_GetHostAddress(GAddress *address,struct in6_addr *hostaddr)
+{
+ assert(address != NULL);
+ assert(hostaddr != NULL);
+ CHECK_ADDRESS_RETVAL(address, INET6, wxSOCKET_INVADDR);
+ *hostaddr = ( (struct sockaddr_in6 *)address->m_addr )->sin6_addr;
+ return wxSOCKET_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
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef __VISAGECPP__
+wxSocketError _GAddress_Init_UNIX(GAddress *address)
+{
+ address->m_len = sizeof(struct sockaddr_un);
+ address->m_addr = (struct sockaddr *)malloc(address->m_len);
+ if (address->m_addr == NULL)
+ {
+ address->m_error = wxSOCKET_MEMERR;
+ return wxSOCKET_MEMERR;
+ }
+
+ address->m_family = wxSOCKET_UNIX;
+ address->m_realfamily = PF_UNIX;
+ ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
+ ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
+
+ return wxSOCKET_NOERROR;
+}
+
+#define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
+
+wxSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
+{
+ struct sockaddr_un *addr;
+
+ assert(address != NULL);
+
+ CHECK_ADDRESS(address, UNIX);
+
+ addr = ((struct sockaddr_un *)address->m_addr);
+ strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
+ addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
+
+ return wxSOCKET_NOERROR;
+}
+
+wxSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
+{
+ struct sockaddr_un *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, UNIX);
+
+ addr = (struct sockaddr_un *)address->m_addr;
+
+ strncpy(path, addr->sun_path, sbuf);
+
+ return wxSOCKET_NOERROR;
+}
+#endif /* !defined(__VISAGECPP__) */
+#endif /* wxUSE_SOCKETS */
projects / wxWidgets.git / commitdiff
