+/* -------------------------------------------------------------------------
+ * Project: GSocket (Generic Socket) for WX
+ * Name: gsocket.c
+ * Purpose: GSocket main Unix file
+ * CVSID: $Id$
+ * Log: $Log$
+ * Log: Revision 1.1 1999/07/22 17:51:54 GL
+ * Log: Added GSocket for Unix (only GTK for the moment)
+ * Log: Updated wxSocket to use GSocket API
+ * Log: Added a progress bar to client.cpp
+ * Log: Added CopyTo to wxMemoryOutputStream to copy the internal buffer to a specified buffer.
+ * Log: Various changes/fixes to the high-level protocols FTP/HTTP
+ * Log: Various Unicode fixes
+ * Log: Removed sckint.*
+ * Log:
+ * Log: Revision 1.2 1999/07/18 15:52:34 guilhem
+ * Log: * Copyright, etc.
+ * Log:
+ * -------------------------------------------------------------------------
+ */
+
+#include <assert.h>
+#include <sys/ioctl.h>
+#ifdef vms
+#include <socket.h>
+#else
+#include <sys/socket.h>
+#endif
+#include <sys/un.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef sun
+#include <sys/filio.h>
+#endif
+
+#ifdef sgi
+ #include <bstring.h>
+#endif
+
+#include <signal.h>
+
+#include <wx/gsocket.h>
+#include "gsockunx.h"
+
+/* Constructors / Destructors */
+
+GSocket *GSocket_new()
+{
+ int i;
+ GSocket *socket;
+
+ socket = (GSocket *)malloc(sizeof(GSocket));
+
+ socket->m_fd = -1;
+ for (i=0;i<GSOCK_MAX_EVENT;i++) {
+ socket->m_fbacks[i] = NULL;
+ socket->m_iocalls[i] = FALSE;
+ }
+ socket->m_local = NULL;
+ socket->m_peer = NULL;
+ socket->m_error = GSOCK_NOERROR;
+ socket->m_server = FALSE;
+ socket->m_stream = TRUE;
+ socket->m_gui_dependent = NULL;
+ socket->m_blocking = FALSE;
+
+ _GSocket_GUI_Init(socket);
+
+ return socket;
+}
+
+void GSocket_destroy(GSocket *socket)
+{
+ assert(socket != NULL);
+
+ _GSocket_GUI_Destroy(socket);
+
+ if (socket->m_fd != -1)
+ GSocket_Shutdown(socket);
+
+ if (socket->m_local)
+ GAddress_destroy(socket->m_local);
+
+ if (socket->m_peer)
+ GAddress_destroy(socket->m_peer);
+
+ free(socket);
+}
+
+void GSocket_Shutdown(GSocket *socket)
+{
+ int evt;
+
+ assert(socket != NULL);
+
+ if (socket->m_fd != -1) {
+ shutdown(socket->m_fd, 2);
+ close(socket->m_fd);
+ socket->m_fd = -1;
+ }
+
+ for (evt=0;evt<GSOCK_MAX_EVENT;evt++)
+ _GSocket_Uninstall_Fallback(socket, evt);
+}
+
+/* Address handling */
+
+GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address)
+{
+ if (socket == NULL || (socket->m_fd != -1 && !socket->m_server))
+ return GSOCK_INVSOCK;
+
+ if (address == NULL || address->m_family == GSOCK_NOFAMILY)
+ return GSOCK_INVADDR;
+
+ if (socket->m_local)
+ GAddress_destroy(socket->m_local);
+
+ socket->m_local = GAddress_copy(address);
+
+ return GSOCK_NOERROR;
+}
+
+GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address)
+{
+ if (socket == NULL)
+ return GSOCK_INVSOCK;
+
+ if (address == NULL || address->m_family == GSOCK_NOFAMILY) {
+ socket->m_error = GSOCK_INVADDR;
+ return GSOCK_INVADDR;
+ }
+
+ if (socket->m_peer)
+ GAddress_destroy(socket->m_peer);
+
+ socket->m_peer = GAddress_copy(address);
+
+ return GSOCK_NOERROR;
+}
+
+GAddress *GSocket_GetLocal(GSocket *socket)
+{
+ GAddress *address;
+ struct sockaddr addr;
+ socklen_t size;
+
+ assert(socket != NULL);
+
+ if (socket->m_local)
+ return GAddress_copy(socket->m_local);
+
+ if (socket->m_fd == -1) {
+ socket->m_error = GSOCK_INVSOCK;
+ return NULL;
+ }
+
+ size = sizeof(addr);
+
+ if (getsockname(socket->m_fd, &addr, &size) < 0) {
+ socket->m_error = GSOCK_IOERR;
+ return NULL;
+ }
+
+ address = GAddress_new();
+ _GAddress_translate_from(address, &addr, size);
+
+ return address;
+}
+
+GAddress *GSocket_GetPeer(GSocket *socket)
+{
+ assert(socket != NULL);
+
+ if (socket->m_peer)
+ return GAddress_copy(socket->m_peer);
+
+ return NULL;
+}
+
+/* Server specific parts */
+
+/*
+ GSocket_SetServer() setup the socket as a server. It uses the "Local" field
+ of GSocket. "Local" must be set by GSocket_SetLocal() before
+ GSocket_SetServer() is called. GSOCK_INVSOCK if socket has been initialized.
+ In the other cases, it returns GSOCK_INVADDR.
+*/
+GSocketError GSocket_SetServer(GSocket *sck)
+{
+ int type;
+
+ assert(sck != NULL);
+
+ if (sck->m_fd != -1) {
+ sck->m_error = GSOCK_INVSOCK;
+ return GSOCK_INVSOCK;
+ }
+
+ if (!sck->m_local) {
+ sck->m_error = GSOCK_INVADDR;
+ return GSOCK_INVADDR;
+ }
+
+ if (sck->m_stream)
+ type = SOCK_STREAM;
+ else
+ type = SOCK_DGRAM;
+
+ sck->m_fd = socket(sck->m_local->m_realfamily, type, 0);
+
+ if (sck->m_fd == -1) {
+ sck->m_error = GSOCK_IOERR;
+ return GSOCK_IOERR;
+ }
+
+ if (bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) < 0) {
+ close(sck->m_fd);
+ sck->m_fd = -1;
+ sck->m_error = GSOCK_IOERR;
+ return GSOCK_IOERR;
+ }
+
+ if (listen(sck->m_fd, 5) < 0) {
+ close(sck->m_fd);
+ sck->m_fd = -1;
+ sck->m_error = GSOCK_IOERR;
+ return GSOCK_IOERR;
+ }
+
+ sck->m_server = TRUE;
+
+ return GSOCK_NOERROR;
+
+}
+
+/*
+ GSocket_WaitConnection() waits for an incoming client connection.
+*/
+GSocket *GSocket_WaitConnection(GSocket *socket)
+{
+ GSocket *connection;
+
+ assert(socket != NULL);
+
+ if (socket->m_fd == -1 || !socket->m_server) {
+ socket->m_error = GSOCK_INVSOCK;
+ return NULL;
+ }
+
+ _GSocket_Enable(socket, GSOCK_CONNECTION);
+
+ connection = GSocket_new();
+
+ connection->m_fd = accept(socket->m_fd, NULL, NULL);
+ if (connection->m_fd == -1) {
+ GSocket_destroy(connection);
+ socket->m_error = GSOCK_IOERR;
+ return NULL;
+ }
+
+ connection->m_stream = TRUE;
+ connection->m_server = FALSE;
+ connection->m_oriented = TRUE;
+
+ return connection;
+}
+
+/* Non oriented connections */
+
+GSocketError GSocket_SetNonOriented(GSocket *sck)
+{
+ assert(sck != NULL);
+
+ if (sck->m_fd != -1) {
+ sck->m_error = GSOCK_INVSOCK;
+ return GSOCK_INVSOCK;
+ }
+
+ if (!sck->m_local) {
+ sck->m_error = GSOCK_INVADDR;
+ return GSOCK_INVADDR;
+ }
+
+ sck->m_stream = FALSE;
+ sck->m_server = FALSE;
+ sck->m_oriented = FALSE;
+
+ sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0);
+
+ if (bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) < 0) {
+ close(sck->m_fd);
+ sck->m_fd = -1;
+ sck->m_error = GSOCK_IOERR;
+ return GSOCK_IOERR;
+ }
+
+ return GSOCK_NOERROR;
+}
+
+/* Client specific parts */
+
+/*
+ GSocket_Connect() establishes a client connection to a server using the "Peer"
+ field of GSocket. "Peer" must be set by GSocket_SetPeer() before
+ GSocket_Connect() is called. In the other case, it returns GSOCK_INVADDR.
+*/
+GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream)
+{
+ int type;
+
+ assert(sck != NULL);
+
+ if (sck->m_fd != -1) {
+ sck->m_error = GSOCK_INVSOCK;
+ return GSOCK_INVSOCK;
+ }
+
+ if (!sck->m_peer) {
+ sck->m_error = GSOCK_INVADDR;
+ return GSOCK_INVADDR;
+ }
+
+ sck->m_stream = (stream == GSOCK_STREAMED);
+ sck->m_oriented = TRUE;
+
+ if (sck->m_stream)
+ type = SOCK_STREAM;
+ else
+ type = SOCK_DGRAM;
+
+ sck->m_fd = socket(sck->m_peer->m_realfamily, type, 0);
+
+ if (sck->m_fd == -1) {
+ sck->m_error = GSOCK_IOERR;
+ return GSOCK_IOERR;
+ }
+
+ if (connect(sck->m_fd, sck->m_peer->m_addr,
+ sck->m_peer->m_len) != 0) {
+ close(sck->m_fd);
+ sck->m_fd = -1;
+ sck->m_error = GSOCK_IOERR;
+ return GSOCK_IOERR;
+ }
+
+ sck->m_server = FALSE;
+
+ return GSOCK_NOERROR;
+}
+
+/* Generic IO */
+
+/* Like recv(), send(), ... */
+int GSocket_Read(GSocket *socket, char *buffer, int size)
+{
+ assert(socket != NULL);
+
+ if (socket->m_fd == -1 || socket->m_server) {
+ socket->m_error = GSOCK_INVSOCK;
+ return -1;
+ }
+
+ _GSocket_Enable(socket, GSOCK_INPUT);
+
+ if (socket->m_oriented)
+ return _GSocket_Recv_Stream(socket, buffer, size);
+ else
+ return _GSocket_Recv_Dgram(socket, buffer, size);
+}
+
+int GSocket_Write(GSocket *socket, const char *buffer,
+ int size)
+{
+ assert(socket != NULL);
+
+ if (socket->m_fd == -1 || socket->m_server) {
+ socket->m_error = GSOCK_INVSOCK;
+ return -1;
+ }
+
+ _GSocket_Enable(socket, GSOCK_OUTPUT);
+
+ if (socket->m_oriented)
+ return _GSocket_Send_Stream(socket, buffer, size);
+ else
+ return _GSocket_Send_Dgram(socket, buffer, size);
+}
+
+bool GSocket_DataAvailable(GSocket *socket)
+{
+ fd_set read_set;
+ struct timeval tv;
+
+ assert(socket != NULL);
+
+ if (socket->m_fd == -1 || socket->m_server) {
+ socket->m_error = GSOCK_INVSOCK;
+ return FALSE;
+ }
+
+ FD_ZERO(&read_set);
+ FD_SET(socket->m_fd, &read_set);
+
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+
+ select(socket->m_fd+1, &read_set, NULL, NULL, &tv);
+
+ return FD_ISSET(socket->m_fd, &read_set);
+}
+
+/* Flags */
+
+/*
+ GSocket_SetBlocking() puts the socket in non-blocking mode. This is useful
+ if we don't want to wait.
+*/
+void GSocket_SetBlocking(GSocket *socket, bool block)
+{
+ assert(socket != NULL);
+
+ socket->m_blocking = block;
+
+ if (socket->m_fd != -1)
+ ioctl(socket->m_fd, FIONBIO, &block);
+}
+
+/*
+ GSocket_GetError() returns the last error occured on the socket stream.
+*/
+
+GSocketError GSocket_GetError(GSocket *socket)
+{
+ assert(socket != NULL);
+
+ return socket->m_error;
+}
+
+/* Callbacks */
+
+/*
+ Only one fallback is possible for each event (INPUT, OUTPUT, CONNECTION)
+ INPUT: The function is called when there is at least a byte in the
+ input buffer
+ OUTPUT: The function is called when the system is sure the next write call
+ will not block
+ CONNECTION: Two cases is possible:
+ Client socket -> the connection is established
+ Server socket -> a client request a connection
+ LOST: the connection is lost
+
+ SetFallback accepts a combination of these flags so a same callback can
+ receive different events.
+
+ An event is generated only once and its state is reseted when the relative
+ IO call is requested.
+ For example: INPUT -> GSocket_Read()
+ CONNECTION -> GSocket_Accept()
+*/
+void GSocket_SetFallback(GSocket *socket, GSocketEventFlags event,
+ GSocketFallback fallback, char *cdata)
+{
+ int count;
+
+ assert (socket != NULL);
+
+ for (count=0;count<GSOCK_MAX_EVENT;count++) {
+ if ((event & (1 << count)) != 0) {
+ socket->m_fbacks[count] = fallback;
+ socket->m_data[count] = cdata;
+
+ _GSocket_Install_Fallback(socket, count);
+ _GSocket_Enable(socket, count);
+ }
+ }
+}
+
+/*
+ UnsetFallback will disables all fallbacks specified by "event".
+ NOTE: event may be a combination of flags
+*/
+void GSocket_UnsetFallback(GSocket *socket, GSocketEventFlags event)
+{
+ int count = 0;
+
+ assert(socket != NULL);
+
+ for (count=0;count<GSOCK_MAX_EVENT;count++) {
+ if ((event & (1 << count)) != 0) {
+ _GSocket_Disable(socket, count);
+ socket->m_fbacks[count] = NULL;
+ _GSocket_Uninstall_Fallback(socket, count);
+ }
+ }
+}
+
+#define CALL_FALLBACK(socket, event) \
+if (socket->m_iocalls[event] && \
+ socket->m_fbacks[event]) {\
+ _GSocket_Disable(socket, event); \
+ socket->m_fbacks[event](socket, event, \
+ socket->m_data[event]); \
+}
+
+#define MASK_SIGNAL() \
+{ \
+ void (*old_handler)(int); \
+\
+ old_handler = signal(SIGPIPE, SIG_IGN);
+
+#define UNMASK_SIGNAL() \
+ signal(SIGPIPE, old_handler); \
+}
+
+void _GSocket_Enable(GSocket *socket, GSocketEvent event)
+{
+ socket->m_iocalls[event] = TRUE;
+ if (socket->m_fbacks[event])
+ _GSocket_Install_Fallback(socket, event);
+}
+
+void _GSocket_Disable(GSocket *socket, GSocketEvent event)
+{
+ socket->m_iocalls[event] = FALSE;
+ if (socket->m_fbacks[event])
+ _GSocket_Uninstall_Fallback(socket, event);
+}
+
+int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size)
+{
+ int ret;
+
+ MASK_SIGNAL();
+ ret = recv(socket->m_fd, buffer, size, 0);
+ UNMASK_SIGNAL();
+ if (ret == -1) {
+ socket->m_error = GSOCK_IOERR;
+ return -1;
+ }
+ return ret;
+}
+
+int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size)
+{
+ struct sockaddr from;
+ int fromlen, ret;
+
+ fromlen = sizeof(from);
+
+ MASK_SIGNAL();
+ ret = recvfrom(socket->m_fd, buffer, size, 0, &from, &fromlen);
+ UNMASK_SIGNAL();
+ if (ret == -1) {
+ socket->m_error = GSOCK_IOERR;
+ return -1;
+ }
+
+ if (!socket->m_peer)
+ socket->m_peer = GAddress_new();
+ _GAddress_translate_from(socket->m_peer, &from, fromlen);
+
+ return ret;
+}
+
+int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size)
+{
+ int ret;
+
+ MASK_SIGNAL();
+ ret = send(socket->m_fd, buffer, size, 0);
+ UNMASK_SIGNAL();
+ if (ret == -1) {
+ socket->m_error = GSOCK_IOERR;
+ return -1;
+ }
+ return ret;
+}
+
+int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size)
+{
+ struct sockaddr *addr;
+ int len, ret;
+
+ if (!socket->m_peer) {
+ socket->m_error = GSOCK_INVADDR;
+ return -1;
+ }
+
+ _GAddress_translate_to(socket->m_peer, &addr, &len);
+
+ MASK_SIGNAL();
+ ret = sendto(socket->m_fd, buffer, size, 0, addr, len);
+ UNMASK_SIGNAL();
+ if (ret == -1) {
+ socket->m_error = GSOCK_IOERR;
+ return -1;
+ }
+
+ free(addr);
+
+ return ret;
+}
+
+void _GSocket_Detected_Read(GSocket *socket)
+{
+ char c;
+ int ret;
+
+ if (socket->m_stream) {
+ ret = recv(socket->m_fd, &c, 1, MSG_PEEK);
+
+ if (ret < 0 && socket->m_server) {
+ CALL_FALLBACK(socket, GSOCK_CONNECTION);
+ return;
+ }
+
+ if (ret > 0) {
+ CALL_FALLBACK(socket, GSOCK_INPUT);
+ } else {
+ CALL_FALLBACK(socket, GSOCK_LOST);
+ }
+ }
+}
+
+void _GSocket_Detected_Write(GSocket *socket)
+{
+ CALL_FALLBACK(socket, GSOCK_OUTPUT);
+}
+
+#undef CALL_FALLBACK
+#undef MASK_SIGNAL
+#undef UNMASK_SIGNAL
+
+/*
+ * -------------------------------------------------------------------------
+ * GAddress
+ * -------------------------------------------------------------------------
+ */
+
+#define CHECK_ADDRESS(address, family, retval) \
+{ \
+ if (address->m_family == GSOCK_NOFAMILY) \
+ _GAddress_Init_##family(address); \
+ if (address->m_family != GSOCK_##family) {\
+ address->m_error = GSOCK_INVADDR; \
+ return retval; \
+ } \
+}
+
+GAddress *GAddress_new()
+{
+ GAddress *address;
+
+ address = (GAddress *)malloc(sizeof(GAddress));
+
+ address->m_family = GSOCK_NOFAMILY;
+ address->m_addr = NULL;
+ address->m_len = 0;
+
+ return address;
+}
+
+GAddress *GAddress_copy(GAddress *address)
+{
+ GAddress *addr2;
+
+ assert(address != NULL);
+
+ addr2 = (GAddress *)malloc(sizeof(GAddress));
+ memcpy(addr2, address, sizeof(GAddress));
+
+ if (address->m_addr) {
+ addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
+ memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
+ }
+
+ return addr2;
+}
+
+void GAddress_destroy(GAddress *address)
+{
+ assert(address != NULL);
+
+ 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;
+}
+
+void _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 = GSOCK_INET;
+ break;
+ case AF_UNIX:
+ address->m_family = GSOCK_UNIX;
+ break;
+ case AF_INET6:
+ address->m_family = GSOCK_INET6;
+ break;
+ default:
+ /* TODO error */
+ }
+
+ if (address->m_addr)
+ free(address->m_addr);
+
+ address->m_len = len;
+ address->m_addr = (struct sockaddr *)malloc(len);
+ memcpy(address->m_addr, addr, len);
+}
+
+void _GAddress_translate_to(GAddress *address,
+ struct sockaddr **addr, int *len)
+{
+ if (!address->m_addr) {
+ /* TODO error */
+ return;
+ }
+
+ *len = address->m_len;
+ *addr = (struct sockaddr *)malloc(address->m_len);
+ memcpy(*addr, address->m_addr, address->m_len);
+}
+
+/*
+ * -------------------------------------------------------------------------
+ * Internet address family
+ * -------------------------------------------------------------------------
+ */
+
+void _GAddress_Init_INET(GAddress *address)
+{
+ address->m_len = sizeof(struct sockaddr_in);
+ address->m_addr = (struct sockaddr *)malloc(address->m_len);
+ address->m_family = GSOCK_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;
+}
+
+GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
+{
+ struct hostent *he;
+ struct in_addr *addr;
+
+ assert(address != NULL);
+
+ CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+
+ addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
+
+ /* only name for the moment */
+ if (inet_aton(hostname, addr) == 0) {
+ struct in_addr *array_addr;
+
+ if ((he = gethostbyname(hostname)) == NULL) {
+ address->m_error = GSOCK_NOHOST;
+ return GSOCK_NOHOST;
+ }
+ array_addr = (struct in_addr *) *(he->h_addr_list);
+ addr->s_addr = array_addr[0].s_addr;
+ }
+ return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET_SetHostAddress(GAddress *address,
+ unsigned long hostaddr)
+{
+ struct in_addr *addr;
+
+ assert(address != NULL);
+
+ CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+
+ addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
+ addr->s_addr = hostaddr;
+
+ return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port)
+{
+ struct servent *se;
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+
+ if (!port) {
+ address->m_error = GSOCK_INVPORT;
+ return GSOCK_INVOP;
+ }
+
+ /* TODO: TCP or UDP */
+ se = getservbyname(port, "tcp");
+ if (!se) {
+ if (isdigit(port[0])) {
+ int port_int;
+
+ port_int = atoi(port);
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr->sin_port = htons(port_int);
+ return GSOCK_NOERROR;
+ }
+
+ address->m_error = GSOCK_INVPORT;
+ return GSOCK_INVPORT;
+ }
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr->sin_port = se->s_port;
+
+ return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
+{
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr->sin_port = htons(port);
+
+ return GSOCK_NOERROR;
+}
+
+GSocketError 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, GSOCK_INVADDR);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ addr_buf = (char *)&(addr->sin_addr);
+
+ he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
+ if (he == NULL) {
+ address->m_error = GSOCK_NOHOST;
+ return GSOCK_NOHOST;
+ }
+
+ strncpy(hostname, he->h_name, sbuf);
+
+ return GSOCK_NOERROR;
+}
+
+unsigned long GAddress_INET_GetHostAddress(GAddress *address)
+{
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, INET, 0);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+
+ return addr->sin_addr.s_addr;
+}
+
+unsigned short GAddress_INET_GetPort(GAddress *address)
+{
+ struct sockaddr_in *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, INET, 0);
+
+ addr = (struct sockaddr_in *)address->m_addr;
+ return ntohs(addr->sin_port);
+}
+
+/*
+ * -------------------------------------------------------------------------
+ * Unix address family
+ * -------------------------------------------------------------------------
+ */
+
+void _GAddress_Init_UNIX(GAddress *address)
+{
+ address->m_len = sizeof(struct sockaddr_un);
+ address->m_addr = (struct sockaddr *)malloc(address->m_len);
+ address->m_family = GSOCK_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;
+}
+
+GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
+{
+ struct sockaddr_un *addr;
+
+ assert(address != NULL);
+
+ CHECK_ADDRESS(address, UNIX, GSOCK_INVADDR);
+
+ addr = ((struct sockaddr_un *)address->m_addr);
+ memcpy(addr->sun_path, path, strlen(path));
+
+ return GSOCK_NOERROR;
+}
+
+GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
+{
+ struct sockaddr_un *addr;
+
+ assert(address != NULL);
+ CHECK_ADDRESS(address, UNIX, GSOCK_INVADDR);
+
+ addr = (struct sockaddr_un *)address->m_addr;
+
+ strncpy(path, addr->sun_path, sbuf);
+
+ return GSOCK_NOERROR;
+}
projects / wxWidgets.git / commitdiff
