1 /* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket) for WX
4 * Copyright: (c) Guilhem Lavaux
5 * Licence: wxWindows Licence
6 * Authors: David Elliott (C++ conversion, maintainer)
8 * Guillermo Rodriguez Garcia <guille@iies.es>
9 * Purpose: GSocket main Unix and OS/2 file
10 * Licence: The wxWindows licence
12 * -------------------------------------------------------------------------
15 #if defined(__WATCOMC__)
16 #include "wx/wxprec.h"
21 #ifndef __GSOCKET_STANDALONE__
25 #if defined(__VISAGECPP__)
26 #define BSD_SELECT /* use Berkeley Sockets select */
29 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
32 #include <sys/types.h>
37 #include <netinet/in.h>
40 #include <sys/ioctl.h>
42 #ifdef HAVE_SYS_SELECT_H
43 # include <sys/select.h>
50 u_char sun_len
; /* sockaddr len including null */
51 u_char sun_family
; /* AF_UNIX */
52 char sun_path
[108]; /* path name (gag) */
55 #include <sys/socket.h>
61 #include <netinet/in.h>
62 #include <arpa/inet.h>
69 #include <machine/endian.h>
75 #define EBADF SOCEBADF
81 #include <sys/socket.h>
82 #include <sys/ioctl.h>
83 #include <sys/select.h>
85 #define close(a) soclose(a)
86 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
87 int _System
bsdselect(int,
92 int _System
soclose(int);
96 #include <sys/select.h>
104 # include <sys/filio.h>
107 # include <bstring.h>
110 # include <strings.h>
117 # define WX_SOCKLEN_T unsigned int
121 # define WX_SOCKLEN_T socklen_t
123 # elif defined(__WXMAC__)
124 # define WX_SOCKLEN_T socklen_t
126 # define WX_SOCKLEN_T int
130 #endif /* SOCKLEN_T */
133 #define SOCKOPTLEN_T WX_SOCKLEN_T
137 * MSW defines this, Unices don't.
139 #ifndef INVALID_SOCKET
140 #define INVALID_SOCKET -1
143 /* UnixWare reportedly needs this for FIONBIO definition */
145 #include <sys/filio.h>
149 * INADDR_BROADCAST is identical to INADDR_NONE which is not defined
150 * on all systems. INADDR_BROADCAST should be fine to indicate an error.
153 #define INADDR_NONE INADDR_BROADCAST
156 #if defined(__VISAGECPP__) || defined(__WATCOMC__)
158 #define MASK_SIGNAL() {
159 #define UNMASK_SIGNAL() }
162 extern "C" { typedef void (*wxSigHandler
)(int); }
164 #define MASK_SIGNAL() \
166 wxSigHandler old_handler = signal(SIGPIPE, SIG_IGN);
168 #define UNMASK_SIGNAL() \
169 signal(SIGPIPE, old_handler); \
174 /* If a SIGPIPE is issued by a socket call on a remotely closed socket,
175 the program will "crash" unless it explicitly handles the SIGPIPE.
176 By using MSG_NOSIGNAL, the SIGPIPE is suppressed. Later, we will
177 use SO_NOSIGPIPE (if available), the BSD equivalent. */
179 # define GSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL
180 #else /* MSG_NOSIGNAL not available (FreeBSD including OS X) */
181 # define GSOCKET_MSG_NOSIGNAL 0
182 #endif /* MSG_NOSIGNAL */
184 #ifndef __GSOCKET_STANDALONE__
185 # include "wx/unix/gsockunx.h"
186 # include "wx/unix/private.h"
187 # include "wx/gsocket.h"
188 #if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME))
189 # include "wx/thread.h"
192 # include "gsockunx.h"
193 # include "gsocket.h"
197 #endif /* __GSOCKET_STANDALONE__ */
199 #if defined(HAVE_GETHOSTBYNAME)
200 static struct hostent
* deepCopyHostent(struct hostent
*h
,
201 const struct hostent
*he
,
202 char *buffer
, int size
, int *err
)
204 /* copy old structure */
205 memcpy(h
, he
, sizeof(struct hostent
));
208 int len
= strlen(h
->h_name
);
214 memcpy(buffer
, h
->h_name
, len
);
218 /* track position in the buffer */
221 /* reuse len to store address length */
224 /* ensure pointer alignment */
225 unsigned int misalign
= sizeof(char *) - pos%sizeof
(char *);
226 if(misalign
< sizeof(char *))
229 /* leave space for pointer list */
230 char **p
= h
->h_addr_list
, **q
;
231 char **h_addr_list
= (char **)(buffer
+ pos
);
233 pos
+= sizeof(char *);
235 /* copy addresses and fill new pointer list */
236 for (p
= h
->h_addr_list
, q
= h_addr_list
; *p
!= 0; p
++, q
++)
238 if (size
< pos
+ len
)
243 memcpy(buffer
+ pos
, *p
, len
); /* copy content */
244 *q
= buffer
+ pos
; /* set copied pointer to copied content */
247 *++q
= 0; /* null terminate the pointer list */
248 h
->h_addr_list
= h_addr_list
; /* copy pointer to pointers */
250 /* ensure word alignment of pointers */
251 misalign
= sizeof(char *) - pos%sizeof
(char *);
252 if(misalign
< sizeof(char *))
255 /* leave space for pointer list */
257 char **h_aliases
= (char **)(buffer
+ pos
);
259 pos
+= sizeof(char *);
261 /* copy aliases and fill new pointer list */
262 for (p
= h
->h_aliases
, q
= h_aliases
; *p
!= 0; p
++, q
++)
265 if (size
<= pos
+ len
)
270 memcpy(buffer
+ pos
, *p
, len
); /* copy content */
271 buffer
[pos
+ len
] = '\0';
272 *q
= buffer
+ pos
; /* set copied pointer to copied content */
275 *++q
= 0; /* null terminate the pointer list */
276 h
->h_aliases
= h_aliases
; /* copy pointer to pointers */
282 #if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS
283 static wxMutex nameLock
;
285 struct hostent
* wxGethostbyname_r(const char *hostname
, struct hostent
*h
,
286 void *buffer
, int size
, int *err
)
289 struct hostent
*he
= NULL
;
291 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
292 if (gethostbyname_r(hostname
, h
, (char*)buffer
, size
, &he
, err
))
294 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
295 he
= gethostbyname_r(hostname
, h
, (char*)buffer
, size
, err
);
296 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
297 if (gethostbyname_r(hostname
, h
, (struct hostent_data
*) buffer
))
304 #elif defined(HAVE_GETHOSTBYNAME)
306 wxMutexLocker
locker(nameLock
);
308 he
= gethostbyname(hostname
);
312 he
= deepCopyHostent(h
, he
, (char*)buffer
, size
, err
);
317 #if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS
318 static wxMutex addrLock
;
320 struct hostent
* wxGethostbyaddr_r(const char *addr_buf
, int buf_size
,
321 int proto
, struct hostent
*h
,
322 void *buffer
, int size
, int *err
)
324 struct hostent
*he
= NULL
;
326 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
327 if (gethostbyaddr_r(addr_buf
, buf_size
, proto
, h
,
328 (char*)buffer
, size
, &he
, err
))
330 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
331 he
= gethostbyaddr_r(addr_buf
, buf_size
, proto
, h
, (char*)buffer
, size
, err
);
332 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
333 if (gethostbyaddr_r(addr_buf
, buf_size
, proto
, h
,
334 (struct hostent_data
*) buffer
))
341 #elif defined(HAVE_GETHOSTBYNAME)
343 wxMutexLocker
locker(addrLock
);
345 he
= gethostbyaddr(addr_buf
, buf_size
, proto
);
349 he
= deepCopyHostent(h
, he
, (char*)buffer
, size
, err
);
354 #if defined(HAVE_GETSERVBYNAME)
355 static struct servent
* deepCopyServent(struct servent
*s
,
356 const struct servent
*se
,
357 char *buffer
, int size
)
359 /* copy plain old structure */
360 memcpy(s
, se
, sizeof(struct servent
));
363 int len
= strlen(s
->s_name
);
368 memcpy(buffer
, s
->s_name
, len
);
372 /* track position in the buffer */
376 len
= strlen(s
->s_proto
);
377 if (pos
+ len
>= size
)
381 memcpy(buffer
+ pos
, s
->s_proto
, len
);
382 buffer
[pos
+ len
] = '\0';
383 s
->s_proto
= buffer
+ pos
;
385 /* track position in the buffer */
388 /* ensure pointer alignment */
389 unsigned int misalign
= sizeof(char *) - pos%sizeof
(char *);
390 if(misalign
< sizeof(char *))
393 /* leave space for pointer list */
394 char **p
= s
->s_aliases
, **q
;
395 char **s_aliases
= (char **)(buffer
+ pos
);
397 pos
+= sizeof(char *);
399 /* copy addresses and fill new pointer list */
400 for (p
= s
->s_aliases
, q
= s_aliases
; *p
!= 0; p
++, q
++){
402 if (size
<= pos
+ len
)
406 memcpy(buffer
+ pos
, *p
, len
); /* copy content */
407 buffer
[pos
+ len
] = '\0';
408 *q
= buffer
+ pos
; /* set copied pointer to copied content */
411 *++q
= 0; /* null terminate the pointer list */
412 s
->s_aliases
= s_aliases
; /* copy pointer to pointers */
417 #if defined(HAVE_GETSERVBYNAME) && wxUSE_THREADS
418 static wxMutex servLock
;
420 struct servent
*wxGetservbyname_r(const char *port
, const char *protocol
,
421 struct servent
*serv
, void *buffer
, int size
)
423 struct servent
*se
= NULL
;
424 #if defined(HAVE_FUNC_GETSERVBYNAME_R_6)
425 if (getservbyname_r(port
, protocol
, serv
, (char*)buffer
, size
, &se
))
427 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_5)
428 se
= getservbyname_r(port
, protocol
, serv
, (char*)buffer
, size
);
429 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_4)
430 if (getservbyname_r(port
, protocol
, serv
, (struct servent_data
*) buffer
))
434 #elif defined(HAVE_GETSERVBYNAME)
436 wxMutexLocker
locker(servLock
);
438 se
= getservbyname(port
, protocol
);
440 se
= deepCopyServent(serv
, se
, (char*)buffer
, size
);
445 /* debugging helpers */
446 #ifdef __GSOCKET_DEBUG__
447 # define GSocket_Debug(args) printf args
449 # define GSocket_Debug(args)
450 #endif /* __GSOCKET_DEBUG__ */
452 /* Table of GUI-related functions. We must call them indirectly because
453 * of wxBase and GUI separation: */
455 static GSocketGUIFunctionsTable
*gs_gui_functions
;
457 class GSocketGUIFunctionsTableNull
: public GSocketGUIFunctionsTable
460 virtual bool OnInit();
461 virtual void OnExit();
462 virtual bool CanUseEventLoop();
463 virtual bool Init_Socket(GSocket
*socket
);
464 virtual void Destroy_Socket(GSocket
*socket
);
465 virtual void Install_Callback(GSocket
*socket
, GSocketEvent event
);
466 virtual void Uninstall_Callback(GSocket
*socket
, GSocketEvent event
);
467 virtual void Enable_Events(GSocket
*socket
);
468 virtual void Disable_Events(GSocket
*socket
);
471 bool GSocketGUIFunctionsTableNull::OnInit()
473 void GSocketGUIFunctionsTableNull::OnExit()
475 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
477 bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket
*WXUNUSED(socket
))
479 void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket
*WXUNUSED(socket
))
481 void GSocketGUIFunctionsTableNull::Install_Callback(GSocket
*WXUNUSED(socket
), GSocketEvent
WXUNUSED(event
))
483 void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket
*WXUNUSED(socket
), GSocketEvent
WXUNUSED(event
))
485 void GSocketGUIFunctionsTableNull::Enable_Events(GSocket
*WXUNUSED(socket
))
487 void GSocketGUIFunctionsTableNull::Disable_Events(GSocket
*WXUNUSED(socket
))
489 /* Global initialisers */
491 void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable
*guifunc
)
493 gs_gui_functions
= guifunc
;
496 int GSocket_Init(void)
498 if (!gs_gui_functions
)
500 static GSocketGUIFunctionsTableNull table
;
501 gs_gui_functions
= &table
;
503 if ( !gs_gui_functions
->OnInit() )
508 void GSocket_Cleanup(void)
510 if (gs_gui_functions
)
512 gs_gui_functions
->OnExit();
516 /* Constructors / Destructors for GSocket */
522 m_fd
= INVALID_SOCKET
;
523 for (i
=0;i
<GSOCK_MAX_EVENT
;i
++)
530 m_error
= GSOCK_NOERROR
;
533 m_gui_dependent
= NULL
;
534 m_non_blocking
= false;
538 m_timeout
= 10*60*1000;
539 /* 10 minutes * 60 sec * 1000 millisec */
540 m_establishing
= false;
542 assert(gs_gui_functions
);
543 /* Per-socket GUI-specific initialization */
544 m_ok
= gs_gui_functions
->Init_Socket(this);
547 void GSocket::Close()
549 gs_gui_functions
->Disable_Events(this);
550 /* gsockosx.c calls CFSocketInvalidate which closes the socket for us */
551 #if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)))
554 m_fd
= INVALID_SOCKET
;
561 /* Check that the socket is really shutdowned */
562 if (m_fd
!= INVALID_SOCKET
)
565 /* Per-socket GUI-specific cleanup */
566 gs_gui_functions
->Destroy_Socket(this);
568 /* Destroy private addresses */
570 GAddress_destroy(m_local
);
573 GAddress_destroy(m_peer
);
577 * Disallow further read/write operations on this socket, close
578 * the fd and disable all callbacks.
580 void GSocket::Shutdown()
586 /* Don't allow events to fire after socket has been closed */
587 gs_gui_functions
->Disable_Events(this);
589 /* If socket has been created, shutdown it */
590 if (m_fd
!= INVALID_SOCKET
)
596 /* Disable GUI callbacks */
597 for (evt
= 0; evt
< GSOCK_MAX_EVENT
; evt
++)
598 m_cbacks
[evt
] = NULL
;
600 m_detected
= GSOCK_LOST_FLAG
;
603 /* Address handling */
609 * Set or get the local or peer address for this socket. The 'set'
610 * functions return GSOCK_NOERROR on success, an error code otherwise.
611 * The 'get' functions return a pointer to a GAddress object on success,
612 * or NULL otherwise, in which case they set the error code of the
613 * corresponding GSocket.
616 * GSOCK_INVSOCK - the socket is not valid.
617 * GSOCK_INVADDR - the address is not valid.
619 GSocketError
GSocket::SetLocal(GAddress
*address
)
623 /* the socket must be initialized, or it must be a server */
624 if ((m_fd
!= INVALID_SOCKET
&& !m_server
))
626 m_error
= GSOCK_INVSOCK
;
627 return GSOCK_INVSOCK
;
631 if (address
== NULL
|| address
->m_family
== GSOCK_NOFAMILY
)
633 m_error
= GSOCK_INVADDR
;
634 return GSOCK_INVADDR
;
638 GAddress_destroy(m_local
);
640 m_local
= GAddress_copy(address
);
642 return GSOCK_NOERROR
;
645 GSocketError
GSocket::SetPeer(GAddress
*address
)
650 if (address
== NULL
|| address
->m_family
== GSOCK_NOFAMILY
)
652 m_error
= GSOCK_INVADDR
;
653 return GSOCK_INVADDR
;
657 GAddress_destroy(m_peer
);
659 m_peer
= GAddress_copy(address
);
661 return GSOCK_NOERROR
;
664 GAddress
*GSocket::GetLocal()
667 struct sockaddr addr
;
668 WX_SOCKLEN_T size
= sizeof(addr
);
673 /* try to get it from the m_local var first */
675 return GAddress_copy(m_local
);
677 /* else, if the socket is initialized, try getsockname */
678 if (m_fd
== INVALID_SOCKET
)
680 m_error
= GSOCK_INVSOCK
;
684 if (getsockname(m_fd
, &addr
, (WX_SOCKLEN_T
*) &size
) < 0)
686 m_error
= GSOCK_IOERR
;
690 /* got a valid address from getsockname, create a GAddress object */
691 address
= GAddress_new();
694 m_error
= GSOCK_MEMERR
;
698 err
= _GAddress_translate_from(address
, &addr
, size
);
699 if (err
!= GSOCK_NOERROR
)
701 GAddress_destroy(address
);
709 GAddress
*GSocket::GetPeer()
713 /* try to get it from the m_peer var */
715 return GAddress_copy(m_peer
);
720 /* Server specific parts */
722 /* GSocket_SetServer:
723 * Sets up this socket as a server. The local address must have been
724 * set with GSocket_SetLocal() before GSocket_SetServer() is called.
725 * Returns GSOCK_NOERROR on success, one of the following otherwise:
728 * GSOCK_INVSOCK - the socket is in use.
729 * GSOCK_INVADDR - the local address has not been set.
730 * GSOCK_IOERR - low-level error.
732 GSocketError
GSocket::SetServer()
738 /* must not be in use */
739 if (m_fd
!= INVALID_SOCKET
)
741 m_error
= GSOCK_INVSOCK
;
742 return GSOCK_INVSOCK
;
745 /* the local addr must have been set */
748 m_error
= GSOCK_INVADDR
;
749 return GSOCK_INVADDR
;
752 /* Initialize all fields */
756 /* Create the socket */
757 m_fd
= socket(m_local
->m_realfamily
, SOCK_STREAM
, 0);
759 if (m_fd
== INVALID_SOCKET
)
761 m_error
= GSOCK_IOERR
;
765 /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
767 setsockopt(m_fd
, SOL_SOCKET
, SO_NOSIGPIPE
, (const char*)&arg
, sizeof(arg
));
770 ioctl(m_fd
, FIONBIO
, &arg
);
771 gs_gui_functions
->Enable_Events(this);
773 /* allow a socket to re-bind if the socket is in the TIME_WAIT
774 state after being previously closed.
778 setsockopt(m_fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char*)&arg
, sizeof(arg
));
780 setsockopt(m_fd
, SOL_SOCKET
, SO_REUSEPORT
, (const char*)&arg
, sizeof(arg
));
784 /* Bind to the local address,
785 * retrieve the actual address bound,
786 * and listen up to 5 connections.
788 if ((bind(m_fd
, m_local
->m_addr
, m_local
->m_len
) != 0) ||
791 (WX_SOCKLEN_T
*) &m_local
->m_len
) != 0) ||
792 (listen(m_fd
, 5) != 0))
795 m_error
= GSOCK_IOERR
;
799 return GSOCK_NOERROR
;
802 /* GSocket_WaitConnection:
803 * Waits for an incoming client connection. Returns a pointer to
804 * a GSocket object, or NULL if there was an error, in which case
805 * the last error field will be updated for the calling GSocket.
807 * Error codes (set in the calling GSocket)
808 * GSOCK_INVSOCK - the socket is not valid or not a server.
809 * GSOCK_TIMEDOUT - timeout, no incoming connections.
810 * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
811 * GSOCK_MEMERR - couldn't allocate memory.
812 * GSOCK_IOERR - low-level error.
814 GSocket
*GSocket::WaitConnection()
816 struct sockaddr from
;
817 WX_SOCKLEN_T fromlen
= sizeof(from
);
824 /* If the socket has already been created, we exit immediately */
825 if (m_fd
== INVALID_SOCKET
|| !m_server
)
827 m_error
= GSOCK_INVSOCK
;
831 /* Create a GSocket object for the new connection */
832 connection
= GSocket_new();
836 m_error
= GSOCK_MEMERR
;
840 /* Wait for a connection (with timeout) */
841 if (Input_Timeout() == GSOCK_TIMEDOUT
)
844 /* m_error set by _GSocket_Input_Timeout */
848 connection
->m_fd
= accept(m_fd
, &from
, (WX_SOCKLEN_T
*) &fromlen
);
850 /* Reenable CONNECTION events */
851 Enable(GSOCK_CONNECTION
);
853 if (connection
->m_fd
== INVALID_SOCKET
)
855 if (errno
== EWOULDBLOCK
)
856 m_error
= GSOCK_WOULDBLOCK
;
858 m_error
= GSOCK_IOERR
;
864 /* Initialize all fields */
865 connection
->m_server
= false;
866 connection
->m_stream
= true;
868 /* Setup the peer address field */
869 connection
->m_peer
= GAddress_new();
870 if (!connection
->m_peer
)
873 m_error
= GSOCK_MEMERR
;
877 err
= _GAddress_translate_from(connection
->m_peer
, &from
, fromlen
);
878 if (err
!= GSOCK_NOERROR
)
885 #if defined(__EMX__) || defined(__VISAGECPP__)
886 ioctl(connection
->m_fd
, FIONBIO
, (char*)&arg
, sizeof(arg
));
888 ioctl(connection
->m_fd
, FIONBIO
, &arg
);
890 gs_gui_functions
->Enable_Events(connection
);
895 bool GSocket::SetReusable()
897 /* socket must not be null, and must not be in use/already bound */
898 if (this && m_fd
== INVALID_SOCKET
)
908 bool GSocket::SetBroadcast()
910 /* socket must not be in use/already bound */
911 if (m_fd
== INVALID_SOCKET
) {
918 bool GSocket::DontDoBind()
920 /* socket must not be in use/already bound */
921 if (m_fd
== INVALID_SOCKET
) {
928 /* Client specific parts */
931 * For stream (connection oriented) sockets, GSocket_Connect() tries
932 * to establish a client connection to a server using the peer address
933 * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
934 * connection has been successfully established, or one of the error
935 * codes listed below. Note that for nonblocking sockets, a return
936 * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
937 * request can be completed later; you should use GSocket_Select()
938 * to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
939 * corresponding asynchronous events.
941 * For datagram (non connection oriented) sockets, GSocket_Connect()
942 * just sets the peer address established with GSocket_SetPeer() as
943 * default destination.
946 * GSOCK_INVSOCK - the socket is in use or not valid.
947 * GSOCK_INVADDR - the peer address has not been established.
948 * GSOCK_TIMEDOUT - timeout, the connection failed.
949 * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
950 * GSOCK_MEMERR - couldn't allocate memory.
951 * GSOCK_IOERR - low-level error.
953 GSocketError
GSocket::Connect(GSocketStream stream
)
960 /* Enable CONNECTION events (needed for nonblocking connections) */
961 Enable(GSOCK_CONNECTION
);
963 if (m_fd
!= INVALID_SOCKET
)
965 m_error
= GSOCK_INVSOCK
;
966 return GSOCK_INVSOCK
;
971 m_error
= GSOCK_INVADDR
;
972 return GSOCK_INVADDR
;
975 /* Streamed or dgram socket? */
976 m_stream
= (stream
== GSOCK_STREAMED
);
978 m_establishing
= false;
980 /* Create the socket */
981 m_fd
= socket(m_peer
->m_realfamily
,
982 m_stream
? SOCK_STREAM
: SOCK_DGRAM
, 0);
984 if (m_fd
== INVALID_SOCKET
)
986 m_error
= GSOCK_IOERR
;
990 /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
992 setsockopt(m_fd
, SOL_SOCKET
, SO_NOSIGPIPE
, (const char*)&arg
, sizeof(arg
));
995 #if defined(__EMX__) || defined(__VISAGECPP__)
996 ioctl(m_fd
, FIONBIO
, (char*)&arg
, sizeof(arg
));
998 ioctl(m_fd
, FIONBIO
, &arg
);
1001 // If the reuse flag is set, use the applicable socket reuse flags(s)
1004 setsockopt(m_fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char*)&arg
, sizeof(arg
));
1006 setsockopt(m_fd
, SOL_SOCKET
, SO_REUSEPORT
, (const char*)&arg
, sizeof(arg
));
1010 // If a local address has been set, then we need to bind to it before calling connect
1011 if (m_local
&& m_local
->m_addr
)
1013 bind(m_fd
, m_local
->m_addr
, m_local
->m_len
);
1016 /* Connect it to the peer address, with a timeout (see below) */
1017 ret
= connect(m_fd
, m_peer
->m_addr
, m_peer
->m_len
);
1019 /* We only call Enable_Events if we know we aren't shutting down the socket.
1020 * NB: Enable_Events needs to be called whether the socket is blocking or
1021 * non-blocking, it just shouldn't be called prior to knowing there is a
1022 * connection _if_ blocking sockets are being used.
1023 * If connect above returns 0, we are already connected and need to make the
1024 * call to Enable_Events now.
1027 if (m_non_blocking
|| ret
== 0)
1028 gs_gui_functions
->Enable_Events(this);
1034 /* If connect failed with EINPROGRESS and the GSocket object
1035 * is in blocking mode, we select() for the specified timeout
1036 * checking for writability to see if the connection request
1039 if ((err
== EINPROGRESS
) && (!m_non_blocking
))
1041 if (Output_Timeout() == GSOCK_TIMEDOUT
)
1044 /* m_error is set in _GSocket_Output_Timeout */
1045 return GSOCK_TIMEDOUT
;
1050 SOCKOPTLEN_T len
= sizeof(error
);
1052 getsockopt(m_fd
, SOL_SOCKET
, SO_ERROR
, (char*) &error
, &len
);
1054 gs_gui_functions
->Enable_Events(this);
1057 return GSOCK_NOERROR
;
1061 /* If connect failed with EINPROGRESS and the GSocket object
1062 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
1063 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
1064 * this way if the connection completes, a GSOCK_CONNECTION
1065 * event will be generated, if enabled.
1067 if ((err
== EINPROGRESS
) && (m_non_blocking
))
1069 m_establishing
= true;
1070 m_error
= GSOCK_WOULDBLOCK
;
1071 return GSOCK_WOULDBLOCK
;
1074 /* If connect failed with an error other than EINPROGRESS,
1075 * then the call to GSocket_Connect has failed.
1078 m_error
= GSOCK_IOERR
;
1083 return GSOCK_NOERROR
;
1086 /* Datagram sockets */
1088 /* GSocket_SetNonOriented:
1089 * Sets up this socket as a non-connection oriented (datagram) socket.
1090 * Before using this function, the local address must have been set
1091 * with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
1092 * on success, or one of the following otherwise.
1095 * GSOCK_INVSOCK - the socket is in use.
1096 * GSOCK_INVADDR - the local address has not been set.
1097 * GSOCK_IOERR - low-level error.
1099 GSocketError
GSocket::SetNonOriented()
1105 if (m_fd
!= INVALID_SOCKET
)
1107 m_error
= GSOCK_INVSOCK
;
1108 return GSOCK_INVSOCK
;
1113 m_error
= GSOCK_INVADDR
;
1114 return GSOCK_INVADDR
;
1117 /* Initialize all fields */
1121 /* Create the socket */
1122 m_fd
= socket(m_local
->m_realfamily
, SOCK_DGRAM
, 0);
1124 if (m_fd
== INVALID_SOCKET
)
1126 m_error
= GSOCK_IOERR
;
1129 #if defined(__EMX__) || defined(__VISAGECPP__)
1130 ioctl(m_fd
, FIONBIO
, (char*)&arg
, sizeof(arg
));
1132 ioctl(m_fd
, FIONBIO
, &arg
);
1134 gs_gui_functions
->Enable_Events(this);
1138 setsockopt(m_fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char*)&arg
, sizeof(arg
));
1140 setsockopt(m_fd
, SOL_SOCKET
, SO_REUSEPORT
, (const char*)&arg
, sizeof(arg
));
1146 setsockopt(m_fd
, SOL_SOCKET
, SO_BROADCAST
, (const char*)&arg
, sizeof(arg
));
1150 /* Bind to the local address,
1151 * and retrieve the actual address bound.
1153 if ((bind(m_fd
, m_local
->m_addr
, m_local
->m_len
) != 0) ||
1156 (WX_SOCKLEN_T
*) &m_local
->m_len
) != 0))
1159 m_error
= GSOCK_IOERR
;
1163 return GSOCK_NOERROR
;
1168 /* Like recv(), send(), ... */
1169 int GSocket::Read(char *buffer
, int size
)
1175 if (m_fd
== INVALID_SOCKET
|| m_server
)
1177 m_error
= GSOCK_INVSOCK
;
1181 /* Disable events during query of socket status */
1182 Disable(GSOCK_INPUT
);
1184 /* If the socket is blocking, wait for data (with a timeout) */
1185 if (Input_Timeout() == GSOCK_TIMEDOUT
) {
1186 m_error
= GSOCK_TIMEDOUT
;
1187 /* Don't return here immediately, otherwise socket events would not be
1195 ret
= Recv_Stream(buffer
, size
);
1197 ret
= Recv_Dgram(buffer
, size
);
1199 /* If recv returned zero, then the connection has been gracefully closed.
1200 * Otherwise, recv has returned an error (-1), in which case we have lost the
1201 * socket only if errno does _not_ indicate that there may be more data to read.
1205 /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */
1206 m_detected
= GSOCK_LOST_FLAG
;
1212 if ((errno
== EWOULDBLOCK
) || (errno
== EAGAIN
))
1213 m_error
= GSOCK_WOULDBLOCK
;
1215 m_error
= GSOCK_IOERR
;
1219 /* Enable events again now that we are done processing */
1220 Enable(GSOCK_INPUT
);
1225 int GSocket::Write(const char *buffer
, int size
)
1231 GSocket_Debug(( "GSocket_Write #1, size %d\n", size
));
1233 if (m_fd
== INVALID_SOCKET
|| m_server
)
1235 m_error
= GSOCK_INVSOCK
;
1239 GSocket_Debug(( "GSocket_Write #2, size %d\n", size
));
1241 /* If the socket is blocking, wait for writability (with a timeout) */
1242 if (Output_Timeout() == GSOCK_TIMEDOUT
)
1245 GSocket_Debug(( "GSocket_Write #3, size %d\n", size
));
1247 /* Write the data */
1249 ret
= Send_Stream(buffer
, size
);
1251 ret
= Send_Dgram(buffer
, size
);
1253 GSocket_Debug(( "GSocket_Write #4, size %d\n", size
));
1257 if ((errno
== EWOULDBLOCK
) || (errno
== EAGAIN
))
1259 m_error
= GSOCK_WOULDBLOCK
;
1260 GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
1264 m_error
= GSOCK_IOERR
;
1265 GSocket_Debug(( "GSocket_Write error IOERR\n" ));
1268 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
1269 * in MSW). Once the first OUTPUT event is received, users can assume
1270 * that the socket is writable until a read operation fails. Only then
1271 * will further OUTPUT events be posted.
1273 Enable(GSOCK_OUTPUT
);
1278 GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size
, ret
));
1284 * Polls the socket to determine its status. This function will
1285 * check for the events specified in the 'flags' parameter, and
1286 * it will return a mask indicating which operations can be
1287 * performed. This function won't block, regardless of the
1288 * mode (blocking | nonblocking) of the socket.
1290 GSocketEventFlags
GSocket::Select(GSocketEventFlags flags
)
1292 if (!gs_gui_functions
->CanUseEventLoop())
1295 GSocketEventFlags result
= 0;
1304 return (GSOCK_LOST_FLAG
& flags
);
1306 /* Do not use a static struct, Linux can garble it */
1307 tv
.tv_sec
= m_timeout
/ 1000;
1308 tv
.tv_usec
= (m_timeout
% 1000) * 1000;
1310 wxFD_ZERO(&readfds
);
1311 wxFD_ZERO(&writefds
);
1312 wxFD_ZERO(&exceptfds
);
1313 wxFD_SET(m_fd
, &readfds
);
1314 if (flags
& GSOCK_OUTPUT_FLAG
|| flags
& GSOCK_CONNECTION_FLAG
)
1315 wxFD_SET(m_fd
, &writefds
);
1316 wxFD_SET(m_fd
, &exceptfds
);
1318 /* Check 'sticky' CONNECTION flag first */
1319 result
|= (GSOCK_CONNECTION_FLAG
& m_detected
);
1321 /* If we have already detected a LOST event, then don't try
1322 * to do any further processing.
1324 if ((m_detected
& GSOCK_LOST_FLAG
) != 0)
1326 m_establishing
= false;
1328 return (GSOCK_LOST_FLAG
& flags
);
1331 /* Try select now */
1332 if (select(m_fd
+ 1, &readfds
, &writefds
, &exceptfds
, &tv
) <= 0)
1334 /* What to do here? */
1335 return (result
& flags
);
1338 /* Check for exceptions and errors */
1339 if (wxFD_ISSET(m_fd
, &exceptfds
))
1341 m_establishing
= false;
1342 m_detected
= GSOCK_LOST_FLAG
;
1344 /* LOST event: Abort any further processing */
1345 return (GSOCK_LOST_FLAG
& flags
);
1348 /* Check for readability */
1349 if (wxFD_ISSET(m_fd
, &readfds
))
1351 result
|= GSOCK_INPUT_FLAG
;
1353 if (m_server
&& m_stream
)
1355 /* This is a TCP server socket that detected a connection.
1356 While the INPUT_FLAG is also set, it doesn't matter on
1357 this kind of sockets, as we can only Accept() from them. */
1358 result
|= GSOCK_CONNECTION_FLAG
;
1359 m_detected
|= GSOCK_CONNECTION_FLAG
;
1363 /* Check for writability */
1364 if (wxFD_ISSET(m_fd
, &writefds
))
1366 if (m_establishing
&& !m_server
)
1369 SOCKOPTLEN_T len
= sizeof(error
);
1371 m_establishing
= false;
1373 getsockopt(m_fd
, SOL_SOCKET
, SO_ERROR
, (char*)&error
, &len
);
1377 m_detected
= GSOCK_LOST_FLAG
;
1379 /* LOST event: Abort any further processing */
1380 return (GSOCK_LOST_FLAG
& flags
);
1384 result
|= GSOCK_CONNECTION_FLAG
;
1385 m_detected
|= GSOCK_CONNECTION_FLAG
;
1390 result
|= GSOCK_OUTPUT_FLAG
;
1394 return (result
& flags
);
1400 return flags
& m_detected
;
1406 /* GSocket_SetNonBlocking:
1407 * Sets the socket to non-blocking mode. All IO calls will return
1410 void GSocket::SetNonBlocking(bool non_block
)
1414 GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block
) );
1416 m_non_blocking
= non_block
;
1419 /* GSocket_SetTimeout:
1420 * Sets the timeout for blocking calls. Time is expressed in
1423 void GSocket::SetTimeout(unsigned long millisec
)
1427 m_timeout
= millisec
;
1430 /* GSocket_GetError:
1431 * Returns the last error occurred for this socket. Note that successful
1432 * operations do not clear this back to GSOCK_NOERROR, so use it only
1435 GSocketError WXDLLIMPEXP_NET
GSocket::GetError()
1445 * There is data to be read in the input buffer. If, after a read
1446 * operation, there is still data available, the callback function will
1449 * The socket is available for writing. That is, the next write call
1450 * won't block. This event is generated only once, when the connection is
1451 * first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1452 * when the output buffer empties again. This means that the app should
1453 * assume that it can write since the first OUTPUT event, and no more
1454 * OUTPUT events will be generated unless an error occurs.
1456 * Connection successfully established, for client sockets, or incoming
1457 * client connection, for server sockets. Wait for this event (also watch
1458 * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1460 * The connection is lost (or a connection request failed); this could
1461 * be due to a failure, or due to the peer closing it gracefully.
1464 /* GSocket_SetCallback:
1465 * Enables the callbacks specified by 'flags'. Note that 'flags'
1466 * may be a combination of flags OR'ed toghether, so the same
1467 * callback function can be made to accept different events.
1468 * The callback function must have the following prototype:
1470 * void function(GSocket *socket, GSocketEvent event, char *cdata)
1472 void GSocket::SetCallback(GSocketEventFlags flags
,
1473 GSocketCallback callback
, char *cdata
)
1479 for (count
= 0; count
< GSOCK_MAX_EVENT
; count
++)
1481 if ((flags
& (1 << count
)) != 0)
1483 m_cbacks
[count
] = callback
;
1484 m_data
[count
] = cdata
;
1489 /* GSocket_UnsetCallback:
1490 * Disables all callbacks specified by 'flags', which may be a
1491 * combination of flags OR'ed toghether.
1493 void GSocket::UnsetCallback(GSocketEventFlags flags
)
1499 for (count
= 0; count
< GSOCK_MAX_EVENT
; count
++)
1501 if ((flags
& (1 << count
)) != 0)
1503 m_cbacks
[count
] = NULL
;
1504 m_data
[count
] = NULL
;
1509 GSocketError
GSocket::GetSockOpt(int level
, int optname
,
1510 void *optval
, int *optlen
)
1512 if (getsockopt(m_fd
, level
, optname
, (char*)optval
, (SOCKOPTLEN_T
*)optlen
) == 0)
1513 return GSOCK_NOERROR
;
1515 return GSOCK_OPTERR
;
1518 GSocketError
GSocket::SetSockOpt(int level
, int optname
,
1519 const void *optval
, int optlen
)
1521 if (setsockopt(m_fd
, level
, optname
, (const char*)optval
, optlen
) == 0)
1522 return GSOCK_NOERROR
;
1524 return GSOCK_OPTERR
;
1527 #define CALL_CALLBACK(socket, event) { \
1528 socket->Disable(event); \
1529 if (socket->m_cbacks[event]) \
1530 socket->m_cbacks[event](socket, event, socket->m_data[event]); \
1534 void GSocket::Enable(GSocketEvent event
)
1536 m_detected
&= ~(1 << event
);
1537 gs_gui_functions
->Install_Callback(this, event
);
1540 void GSocket::Disable(GSocketEvent event
)
1542 m_detected
|= (1 << event
);
1543 gs_gui_functions
->Uninstall_Callback(this, event
);
1546 /* _GSocket_Input_Timeout:
1547 * For blocking sockets, wait until data is available or
1548 * until timeout ellapses.
1550 GSocketError
GSocket::Input_Timeout()
1556 /* Linux select() will overwrite the struct on return */
1557 tv
.tv_sec
= (m_timeout
/ 1000);
1558 tv
.tv_usec
= (m_timeout
% 1000) * 1000;
1560 if (!m_non_blocking
)
1562 wxFD_ZERO(&readfds
);
1563 wxFD_SET(m_fd
, &readfds
);
1564 ret
= select(m_fd
+ 1, &readfds
, NULL
, NULL
, &tv
);
1567 GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1568 m_error
= GSOCK_TIMEDOUT
;
1569 return GSOCK_TIMEDOUT
;
1574 GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1575 if (errno
== EBADF
) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1576 if (errno
== EINTR
) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1577 if (errno
== EINVAL
) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1578 if (errno
== ENOMEM
) { GSocket_Debug(( "Not enough memory\n" )); }
1579 m_error
= GSOCK_TIMEDOUT
;
1580 return GSOCK_TIMEDOUT
;
1584 return GSOCK_NOERROR
;
1587 /* _GSocket_Output_Timeout:
1588 * For blocking sockets, wait until data can be sent without
1589 * blocking or until timeout ellapses.
1591 GSocketError
GSocket::Output_Timeout()
1597 /* Linux select() will overwrite the struct on return */
1598 tv
.tv_sec
= (m_timeout
/ 1000);
1599 tv
.tv_usec
= (m_timeout
% 1000) * 1000;
1601 GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking
) );
1603 if (!m_non_blocking
)
1605 wxFD_ZERO(&writefds
);
1606 wxFD_SET(m_fd
, &writefds
);
1607 ret
= select(m_fd
+ 1, NULL
, &writefds
, NULL
, &tv
);
1610 GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1611 m_error
= GSOCK_TIMEDOUT
;
1612 return GSOCK_TIMEDOUT
;
1617 GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1618 if (errno
== EBADF
) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1619 if (errno
== EINTR
) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1620 if (errno
== EINVAL
) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1621 if (errno
== ENOMEM
) { GSocket_Debug(( "Not enough memory\n" )); }
1622 m_error
= GSOCK_TIMEDOUT
;
1623 return GSOCK_TIMEDOUT
;
1626 if ( ! wxFD_ISSET(m_fd
, &writefds
) )
1628 GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1632 GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1637 GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1640 return GSOCK_NOERROR
;
1643 int GSocket::Recv_Stream(char *buffer
, int size
)
1648 ret
= recv(m_fd
, buffer
, size
, GSOCKET_MSG_NOSIGNAL
);
1650 while (ret
== -1 && errno
== EINTR
); /* Loop until not interrupted */
1655 int GSocket::Recv_Dgram(char *buffer
, int size
)
1657 struct sockaddr from
;
1658 WX_SOCKLEN_T fromlen
= sizeof(from
);
1662 fromlen
= sizeof(from
);
1666 ret
= recvfrom(m_fd
, buffer
, size
, 0, &from
, (WX_SOCKLEN_T
*) &fromlen
);
1668 while (ret
== -1 && errno
== EINTR
); /* Loop until not interrupted */
1673 /* Translate a system address into a GSocket address */
1676 m_peer
= GAddress_new();
1679 m_error
= GSOCK_MEMERR
;
1684 err
= _GAddress_translate_from(m_peer
, &from
, fromlen
);
1685 if (err
!= GSOCK_NOERROR
)
1687 GAddress_destroy(m_peer
);
1696 int GSocket::Send_Stream(const char *buffer
, int size
)
1704 ret
= send(m_fd
, (char *)buffer
, size
, GSOCKET_MSG_NOSIGNAL
);
1706 while (ret
== -1 && errno
== EINTR
); /* Loop until not interrupted */
1713 int GSocket::Send_Dgram(const char *buffer
, int size
)
1715 struct sockaddr
*addr
;
1721 m_error
= GSOCK_INVADDR
;
1725 err
= _GAddress_translate_to(m_peer
, &addr
, &len
);
1726 if (err
!= GSOCK_NOERROR
)
1736 ret
= sendto(m_fd
, (char *)buffer
, size
, 0, addr
, len
);
1738 while (ret
== -1 && errno
== EINTR
); /* Loop until not interrupted */
1742 /* Frees memory allocated from _GAddress_translate_to */
1748 void GSocket::Detected_Read()
1752 /* Safeguard against straggling call to Detected_Read */
1753 if (m_fd
== INVALID_SOCKET
)
1758 /* If we have already detected a LOST event, then don't try
1759 * to do any further processing.
1761 if ((m_detected
& GSOCK_LOST_FLAG
) != 0)
1763 m_establishing
= false;
1765 CALL_CALLBACK(this, GSOCK_LOST
);
1770 int num
= recv(m_fd
, &c
, 1, MSG_PEEK
| GSOCKET_MSG_NOSIGNAL
);
1774 CALL_CALLBACK(this, GSOCK_INPUT
);
1778 if (m_server
&& m_stream
)
1780 CALL_CALLBACK(this, GSOCK_CONNECTION
);
1784 /* graceful shutdown */
1785 CALL_CALLBACK(this, GSOCK_LOST
);
1790 /* Do not throw a lost event in cases where the socket isn't really lost */
1791 if ((errno
== EWOULDBLOCK
) || (errno
== EAGAIN
) || (errno
== EINTR
))
1793 CALL_CALLBACK(this, GSOCK_INPUT
);
1797 CALL_CALLBACK(this, GSOCK_LOST
);
1804 void GSocket::Detected_Write()
1806 /* If we have already detected a LOST event, then don't try
1807 * to do any further processing.
1809 if ((m_detected
& GSOCK_LOST_FLAG
) != 0)
1811 m_establishing
= false;
1813 CALL_CALLBACK(this, GSOCK_LOST
);
1818 if (m_establishing
&& !m_server
)
1821 SOCKOPTLEN_T len
= sizeof(error
);
1823 m_establishing
= false;
1825 getsockopt(m_fd
, SOL_SOCKET
, SO_ERROR
, (char*)&error
, &len
);
1829 CALL_CALLBACK(this, GSOCK_LOST
);
1834 CALL_CALLBACK(this, GSOCK_CONNECTION
);
1835 /* We have to fire this event by hand because CONNECTION (for clients)
1836 * and OUTPUT are internally the same and we just disabled CONNECTION
1837 * events with the above macro.
1839 CALL_CALLBACK(this, GSOCK_OUTPUT
);
1844 CALL_CALLBACK(this, GSOCK_OUTPUT
);
1848 /* Compatibility functions for GSocket */
1849 GSocket
*GSocket_new(void)
1851 GSocket
*newsocket
= new GSocket();
1852 if (newsocket
->IsOk())
1861 * -------------------------------------------------------------------------
1863 * -------------------------------------------------------------------------
1866 /* CHECK_ADDRESS verifies that the current address family is either
1867 * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1868 * initalizes it to be a GSOCK_*family*. In other cases, it returns
1869 * an appropiate error code.
1871 * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1873 #define CHECK_ADDRESS(address, family) \
1875 if (address->m_family == GSOCK_NOFAMILY) \
1876 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1877 return address->m_error; \
1878 if (address->m_family != GSOCK_##family) \
1880 address->m_error = GSOCK_INVADDR; \
1881 return GSOCK_INVADDR; \
1885 #define CHECK_ADDRESS_RETVAL(address, family, retval) \
1887 if (address->m_family == GSOCK_NOFAMILY) \
1888 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1890 if (address->m_family != GSOCK_##family) \
1892 address->m_error = GSOCK_INVADDR; \
1898 GAddress
*GAddress_new(void)
1902 if ((address
= (GAddress
*) malloc(sizeof(GAddress
))) == NULL
)
1905 address
->m_family
= GSOCK_NOFAMILY
;
1906 address
->m_addr
= NULL
;
1912 GAddress
*GAddress_copy(GAddress
*address
)
1916 assert(address
!= NULL
);
1918 if ((addr2
= (GAddress
*) malloc(sizeof(GAddress
))) == NULL
)
1921 memcpy(addr2
, address
, sizeof(GAddress
));
1923 if (address
->m_addr
&& address
->m_len
> 0)
1925 addr2
->m_addr
= (struct sockaddr
*)malloc(addr2
->m_len
);
1926 if (addr2
->m_addr
== NULL
)
1931 memcpy(addr2
->m_addr
, address
->m_addr
, addr2
->m_len
);
1937 void GAddress_destroy(GAddress
*address
)
1939 assert(address
!= NULL
);
1941 if (address
->m_addr
)
1942 free(address
->m_addr
);
1947 void GAddress_SetFamily(GAddress
*address
, GAddressType type
)
1949 assert(address
!= NULL
);
1951 address
->m_family
= type
;
1954 GAddressType
GAddress_GetFamily(GAddress
*address
)
1956 assert(address
!= NULL
);
1958 return address
->m_family
;
1961 GSocketError
_GAddress_translate_from(GAddress
*address
,
1962 struct sockaddr
*addr
, int len
)
1964 address
->m_realfamily
= addr
->sa_family
;
1965 switch (addr
->sa_family
)
1968 address
->m_family
= GSOCK_INET
;
1971 address
->m_family
= GSOCK_UNIX
;
1975 address
->m_family
= GSOCK_INET6
;
1980 address
->m_error
= GSOCK_INVOP
;
1985 if (address
->m_addr
)
1986 free(address
->m_addr
);
1988 address
->m_len
= len
;
1989 address
->m_addr
= (struct sockaddr
*)malloc(len
);
1991 if (address
->m_addr
== NULL
)
1993 address
->m_error
= GSOCK_MEMERR
;
1994 return GSOCK_MEMERR
;
1997 memcpy(address
->m_addr
, addr
, len
);
1999 return GSOCK_NOERROR
;
2002 GSocketError
_GAddress_translate_to(GAddress
*address
,
2003 struct sockaddr
**addr
, int *len
)
2005 if (!address
->m_addr
)
2007 address
->m_error
= GSOCK_INVADDR
;
2008 return GSOCK_INVADDR
;
2011 *len
= address
->m_len
;
2012 *addr
= (struct sockaddr
*)malloc(address
->m_len
);
2015 address
->m_error
= GSOCK_MEMERR
;
2016 return GSOCK_MEMERR
;
2019 memcpy(*addr
, address
->m_addr
, address
->m_len
);
2020 return GSOCK_NOERROR
;
2024 * -------------------------------------------------------------------------
2025 * Internet address family
2026 * -------------------------------------------------------------------------
2029 GSocketError
_GAddress_Init_INET(GAddress
*address
)
2031 address
->m_len
= sizeof(struct sockaddr_in
);
2032 address
->m_addr
= (struct sockaddr
*) malloc(address
->m_len
);
2033 if (address
->m_addr
== NULL
)
2035 address
->m_error
= GSOCK_MEMERR
;
2036 return GSOCK_MEMERR
;
2039 address
->m_family
= GSOCK_INET
;
2040 address
->m_realfamily
= PF_INET
;
2041 ((struct sockaddr_in
*)address
->m_addr
)->sin_family
= AF_INET
;
2042 ((struct sockaddr_in
*)address
->m_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
2044 return GSOCK_NOERROR
;
2047 GSocketError
GAddress_INET_SetHostName(GAddress
*address
, const char *hostname
)
2050 struct in_addr
*addr
;
2052 assert(address
!= NULL
);
2054 CHECK_ADDRESS(address
, INET
);
2056 addr
= &(((struct sockaddr_in
*)address
->m_addr
)->sin_addr
);
2058 /* If it is a numeric host name, convert it now */
2059 #if defined(HAVE_INET_ATON)
2060 if (inet_aton(hostname
, addr
) == 0)
2062 #elif defined(HAVE_INET_ADDR)
2063 if ( (addr
->s_addr
= inet_addr(hostname
)) == (unsigned)-1 )
2066 /* Use gethostbyname by default */
2068 int val
= 1; /* VA doesn't like constants in conditional expressions */
2073 struct in_addr
*array_addr
;
2075 /* It is a real name, we solve it */
2077 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
2078 struct hostent_data buffer
;
2083 he
= wxGethostbyname_r(hostname
, &h
, (void*)&buffer
, sizeof(buffer
), &err
);
2086 /* Reset to invalid address */
2087 addr
->s_addr
= INADDR_NONE
;
2088 address
->m_error
= GSOCK_NOHOST
;
2089 return GSOCK_NOHOST
;
2092 array_addr
= (struct in_addr
*) *(he
->h_addr_list
);
2093 addr
->s_addr
= array_addr
[0].s_addr
;
2096 return GSOCK_NOERROR
;
2100 GSocketError
GAddress_INET_SetBroadcastAddress(GAddress
*address
)
2102 return GAddress_INET_SetHostAddress(address
, INADDR_BROADCAST
);
2105 GSocketError
GAddress_INET_SetAnyAddress(GAddress
*address
)
2107 return GAddress_INET_SetHostAddress(address
, INADDR_ANY
);
2110 GSocketError
GAddress_INET_SetHostAddress(GAddress
*address
,
2111 unsigned long hostaddr
)
2113 struct in_addr
*addr
;
2115 assert(address
!= NULL
);
2117 CHECK_ADDRESS(address
, INET
);
2119 addr
= &(((struct sockaddr_in
*)address
->m_addr
)->sin_addr
);
2120 addr
->s_addr
= htonl(hostaddr
);
2122 return GSOCK_NOERROR
;
2125 GSocketError
GAddress_INET_SetPortName(GAddress
*address
, const char *port
,
2126 const char *protocol
)
2129 struct sockaddr_in
*addr
;
2131 assert(address
!= NULL
);
2132 CHECK_ADDRESS(address
, INET
);
2136 address
->m_error
= GSOCK_INVPORT
;
2137 return GSOCK_INVPORT
;
2140 #if defined(HAVE_FUNC_GETSERVBYNAME_R_4)
2141 struct servent_data buffer
;
2145 struct servent serv
;
2146 se
= wxGetservbyname_r(port
, protocol
, &serv
,
2147 (void*)&buffer
, sizeof(buffer
));
2150 /* the cast to int suppresses compiler warnings about subscript having the
2152 if (isdigit((int)port
[0]))
2156 port_int
= atoi(port
);
2157 addr
= (struct sockaddr_in
*)address
->m_addr
;
2158 addr
->sin_port
= htons(port_int
);
2159 return GSOCK_NOERROR
;
2162 address
->m_error
= GSOCK_INVPORT
;
2163 return GSOCK_INVPORT
;
2166 addr
= (struct sockaddr_in
*)address
->m_addr
;
2167 addr
->sin_port
= se
->s_port
;
2169 return GSOCK_NOERROR
;
2172 GSocketError
GAddress_INET_SetPort(GAddress
*address
, unsigned short port
)
2174 struct sockaddr_in
*addr
;
2176 assert(address
!= NULL
);
2177 CHECK_ADDRESS(address
, INET
);
2179 addr
= (struct sockaddr_in
*)address
->m_addr
;
2180 addr
->sin_port
= htons(port
);
2182 return GSOCK_NOERROR
;
2185 GSocketError
GAddress_INET_GetHostName(GAddress
*address
, char *hostname
, size_t sbuf
)
2189 struct sockaddr_in
*addr
;
2191 assert(address
!= NULL
);
2192 CHECK_ADDRESS(address
, INET
);
2194 addr
= (struct sockaddr_in
*)address
->m_addr
;
2195 addr_buf
= (char *)&(addr
->sin_addr
);
2197 struct hostent temphost
;
2198 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
2199 struct hostent_data buffer
;
2204 he
= wxGethostbyaddr_r(addr_buf
, sizeof(addr
->sin_addr
), AF_INET
, &temphost
,
2205 (void*)&buffer
, sizeof(buffer
), &err
);
2208 address
->m_error
= GSOCK_NOHOST
;
2209 return GSOCK_NOHOST
;
2212 strncpy(hostname
, he
->h_name
, sbuf
);
2214 return GSOCK_NOERROR
;
2217 unsigned long GAddress_INET_GetHostAddress(GAddress
*address
)
2219 struct sockaddr_in
*addr
;
2221 assert(address
!= NULL
);
2222 CHECK_ADDRESS_RETVAL(address
, INET
, 0);
2224 addr
= (struct sockaddr_in
*)address
->m_addr
;
2226 return ntohl(addr
->sin_addr
.s_addr
);
2229 unsigned short GAddress_INET_GetPort(GAddress
*address
)
2231 struct sockaddr_in
*addr
;
2233 assert(address
!= NULL
);
2234 CHECK_ADDRESS_RETVAL(address
, INET
, 0);
2236 addr
= (struct sockaddr_in
*)address
->m_addr
;
2237 return ntohs(addr
->sin_port
);
2241 * -------------------------------------------------------------------------
2242 * Unix address family
2243 * -------------------------------------------------------------------------
2246 #ifndef __VISAGECPP__
2247 GSocketError
_GAddress_Init_UNIX(GAddress
*address
)
2249 address
->m_len
= sizeof(struct sockaddr_un
);
2250 address
->m_addr
= (struct sockaddr
*)malloc(address
->m_len
);
2251 if (address
->m_addr
== NULL
)
2253 address
->m_error
= GSOCK_MEMERR
;
2254 return GSOCK_MEMERR
;
2257 address
->m_family
= GSOCK_UNIX
;
2258 address
->m_realfamily
= PF_UNIX
;
2259 ((struct sockaddr_un
*)address
->m_addr
)->sun_family
= AF_UNIX
;
2260 ((struct sockaddr_un
*)address
->m_addr
)->sun_path
[0] = 0;
2262 return GSOCK_NOERROR
;
2265 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
2267 GSocketError
GAddress_UNIX_SetPath(GAddress
*address
, const char *path
)
2269 struct sockaddr_un
*addr
;
2271 assert(address
!= NULL
);
2273 CHECK_ADDRESS(address
, UNIX
);
2275 addr
= ((struct sockaddr_un
*)address
->m_addr
);
2276 strncpy(addr
->sun_path
, path
, UNIX_SOCK_PATHLEN
);
2277 addr
->sun_path
[UNIX_SOCK_PATHLEN
- 1] = '\0';
2279 return GSOCK_NOERROR
;
2282 GSocketError
GAddress_UNIX_GetPath(GAddress
*address
, char *path
, size_t sbuf
)
2284 struct sockaddr_un
*addr
;
2286 assert(address
!= NULL
);
2287 CHECK_ADDRESS(address
, UNIX
);
2289 addr
= (struct sockaddr_un
*)address
->m_addr
;
2291 strncpy(path
, addr
->sun_path
, sbuf
);
2293 return GSOCK_NOERROR
;
2295 #endif /* !defined(__VISAGECPP__) */
2296 #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */