]>
git.saurik.com Git - wxWidgets.git/blob - src/msw/gsocket.cpp
1 /* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket)
4 * Author: Guillermo Rodriguez Garcia <guille@iies.es>
5 * Purpose: GSocket main MSW file
6 * Licence: The wxWindows licence
8 * -------------------------------------------------------------------------
12 * PLEASE don't put C++ comments here - this is a C source file.
16 /* RPCNOTIFICATION_ROUTINE in rasasync.h (included from winsock.h),
17 * warning: conditional expression is constant.
19 # pragma warning(disable:4115)
21 * warning: named type definition in parentheses.
23 # pragma warning(disable:4127)
24 /* GAddress_UNIX_GetPath,
25 * warning: unreferenced formal parameter.
27 # pragma warning(disable:4100)
30 /* windows.h results in tons of warnings at max warning level */
32 # pragma warning(push, 1)
37 # pragma warning(disable:4514)
45 #ifndef __GSOCKET_STANDALONE__
46 # include "wx/platform.h"
47 # include "wx/setup.h"
50 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
52 #ifndef __GSOCKET_STANDALONE__
53 # include "wx/msw/gsockmsw.h"
54 # include "wx/gsocket.h"
56 # include "gsockmsw.h"
58 #endif /* __GSOCKET_STANDALONE__ */
65 #define isdigit(x) (x > 47 && x < 58)
67 #include "wx/msw/wince/net.h"
76 /* if we use configure for MSW SOCKLEN_T will be already defined */
78 # define SOCKLEN_T int
81 /* Table of GUI-related functions. We must call them indirectly because
82 * of wxBase and GUI separation: */
84 static struct GSocketGUIFunctionsTable
*gs_gui_functions
;
86 #define USE_GUI() (gs_gui_functions != NULL)
88 /* Define macros to simplify indirection: */
89 #define _GSocket_GUI_Init() \
90 if (gs_gui_functions) gs_gui_functions->GUI_Init()
91 #define _GSocket_GUI_Cleanup() \
92 if (gs_gui_functions) gs_gui_functions->GUI_Cleanup()
93 #define _GSocket_GUI_Init_Socket(socket) \
94 (gs_gui_functions ? gs_gui_functions->GUI_Init_Socket(socket) : 1)
95 #define _GSocket_GUI_Destroy_Socket(socket) \
96 if (gs_gui_functions) gs_gui_functions->GUI_Destroy_Socket(socket)
97 #define _GSocket_Enable_Events(socket) \
98 if (gs_gui_functions) gs_gui_functions->Enable_Events(socket)
99 #define _GSocket_Disable_Events(socket) \
100 if (gs_gui_functions) gs_gui_functions->Disable_Events(socket)
101 #define _GSocket_Install_Callback(socket, event) \
102 if (gs_gui_functions) gs_gui_functions->Install_Callback(socket, event)
103 #define _GSocket_Uninstall_Callback(socket, event) \
104 if (gs_gui_functions) gs_gui_functions->Uninstall_Callback(socket, event)
106 /* Global initialisers */
108 void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable
*guifunc
)
110 gs_gui_functions
= guifunc
;
113 int GSocket_Init(void)
117 if (gs_gui_functions
)
119 if ( !gs_gui_functions
->GUI_Init() )
123 /* Initialize WinSocket */
124 return (WSAStartup((1 << 8) | 1, &wsaData
) == 0);
127 void GSocket_Cleanup(void)
129 if (gs_gui_functions
)
131 gs_gui_functions
->GUI_Cleanup();
134 /* Cleanup WinSocket */
138 /* Constructors / Destructors for GSocket */
140 GSocket
*GSocket_new(void)
145 if ((socket
= (GSocket
*) malloc(sizeof(GSocket
))) == NULL
)
148 socket
->m_fd
= INVALID_SOCKET
;
149 for (i
= 0; i
< GSOCK_MAX_EVENT
; i
++)
151 socket
->m_cbacks
[i
] = NULL
;
153 socket
->m_detected
= 0;
154 socket
->m_local
= NULL
;
155 socket
->m_peer
= NULL
;
156 socket
->m_error
= GSOCK_NOERROR
;
157 socket
->m_server
= FALSE
;
158 socket
->m_stream
= TRUE
;
159 socket
->m_non_blocking
= FALSE
;
160 socket
->m_timeout
.tv_sec
= 10 * 60; /* 10 minutes */
161 socket
->m_timeout
.tv_usec
= 0;
162 socket
->m_establishing
= FALSE
;
163 socket
->m_reusable
= FALSE
;
165 /* Per-socket GUI-specific initialization */
166 success
= _GSocket_GUI_Init_Socket(socket
);
176 void GSocket_close(GSocket
*socket
)
178 _GSocket_Disable_Events(socket
);
179 closesocket(socket
->m_fd
);
180 socket
->m_fd
= INVALID_SOCKET
;
183 void GSocket_destroy(GSocket
*socket
)
185 assert(socket
!= NULL
);
187 /* Per-socket GUI-specific cleanup */
188 _GSocket_GUI_Destroy_Socket(socket
);
190 /* Check that the socket is really shutdowned */
191 if (socket
->m_fd
!= INVALID_SOCKET
)
192 GSocket_Shutdown(socket
);
194 /* Destroy private addresses */
196 GAddress_destroy(socket
->m_local
);
199 GAddress_destroy(socket
->m_peer
);
201 /* Destroy the socket itself */
206 * Disallow further read/write operations on this socket, close
207 * the fd and disable all callbacks.
209 void GSocket_Shutdown(GSocket
*socket
)
213 assert(socket
!= NULL
);
215 /* If socket has been created, shutdown it */
216 if (socket
->m_fd
!= INVALID_SOCKET
)
218 shutdown(socket
->m_fd
, 2);
219 GSocket_close(socket
);
222 /* Disable GUI callbacks */
223 for (evt
= 0; evt
< GSOCK_MAX_EVENT
; evt
++)
224 socket
->m_cbacks
[evt
] = NULL
;
226 socket
->m_detected
= GSOCK_LOST_FLAG
;
229 /* Address handling */
235 * Set or get the local or peer address for this socket. The 'set'
236 * functions return GSOCK_NOERROR on success, an error code otherwise.
237 * The 'get' functions return a pointer to a GAddress object on success,
238 * or NULL otherwise, in which case they set the error code of the
239 * corresponding GSocket.
242 * GSOCK_INVSOCK - the socket is not valid.
243 * GSOCK_INVADDR - the address is not valid.
245 GSocketError
GSocket_SetLocal(GSocket
*socket
, GAddress
*address
)
247 assert(socket
!= NULL
);
249 /* the socket must be initialized, or it must be a server */
250 if (socket
->m_fd
!= INVALID_SOCKET
&& !socket
->m_server
)
252 socket
->m_error
= GSOCK_INVSOCK
;
253 return GSOCK_INVSOCK
;
257 if (address
== NULL
|| address
->m_family
== GSOCK_NOFAMILY
)
259 socket
->m_error
= GSOCK_INVADDR
;
260 return GSOCK_INVADDR
;
264 GAddress_destroy(socket
->m_local
);
266 socket
->m_local
= GAddress_copy(address
);
268 return GSOCK_NOERROR
;
271 GSocketError
GSocket_SetPeer(GSocket
*socket
, GAddress
*address
)
273 assert(socket
!= NULL
);
276 if (address
== NULL
|| address
->m_family
== GSOCK_NOFAMILY
)
278 socket
->m_error
= GSOCK_INVADDR
;
279 return GSOCK_INVADDR
;
283 GAddress_destroy(socket
->m_peer
);
285 socket
->m_peer
= GAddress_copy(address
);
287 return GSOCK_NOERROR
;
290 GAddress
*GSocket_GetLocal(GSocket
*socket
)
293 struct sockaddr addr
;
294 SOCKLEN_T size
= sizeof(addr
);
297 assert(socket
!= NULL
);
299 /* try to get it from the m_local var first */
301 return GAddress_copy(socket
->m_local
);
303 /* else, if the socket is initialized, try getsockname */
304 if (socket
->m_fd
== INVALID_SOCKET
)
306 socket
->m_error
= GSOCK_INVSOCK
;
310 if (getsockname(socket
->m_fd
, &addr
, &size
) == SOCKET_ERROR
)
312 socket
->m_error
= GSOCK_IOERR
;
316 /* got a valid address from getsockname, create a GAddress object */
317 if ((address
= GAddress_new()) == NULL
)
319 socket
->m_error
= GSOCK_MEMERR
;
323 if ((err
= _GAddress_translate_from(address
, &addr
, size
)) != GSOCK_NOERROR
)
325 GAddress_destroy(address
);
326 socket
->m_error
= err
;
333 GAddress
*GSocket_GetPeer(GSocket
*socket
)
335 assert(socket
!= NULL
);
337 /* try to get it from the m_peer var */
339 return GAddress_copy(socket
->m_peer
);
344 /* Server specific parts */
346 /* GSocket_SetServer:
347 * Sets up this socket as a server. The local address must have been
348 * set with GSocket_SetLocal() before GSocket_SetServer() is called.
349 * Returns GSOCK_NOERROR on success, one of the following otherwise:
352 * GSOCK_INVSOCK - the socket is in use.
353 * GSOCK_INVADDR - the local address has not been set.
354 * GSOCK_IOERR - low-level error.
356 GSocketError
GSocket_SetServer(GSocket
*sck
)
362 /* must not be in use */
363 if (sck
->m_fd
!= INVALID_SOCKET
)
365 sck
->m_error
= GSOCK_INVSOCK
;
366 return GSOCK_INVSOCK
;
369 /* the local addr must have been set */
372 sck
->m_error
= GSOCK_INVADDR
;
373 return GSOCK_INVADDR
;
376 /* Initialize all fields */
377 sck
->m_server
= TRUE
;
378 sck
->m_stream
= TRUE
;
380 /* Create the socket */
381 sck
->m_fd
= socket(sck
->m_local
->m_realfamily
, SOCK_STREAM
, 0);
383 if (sck
->m_fd
== INVALID_SOCKET
)
385 sck
->m_error
= GSOCK_IOERR
;
389 ioctlsocket(sck
->m_fd
, FIONBIO
, (u_long FAR
*) &arg
);
390 _GSocket_Enable_Events(sck
);
392 /* allow a socket to re-bind if the socket is in the TIME_WAIT
393 state after being previously closed.
395 if (sck
->m_reusable
) {
396 setsockopt(sck
->m_fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char*)&arg
, sizeof(u_long
));
399 /* Bind to the local address,
400 * retrieve the actual address bound,
401 * and listen up to 5 connections.
403 if ((bind(sck
->m_fd
, sck
->m_local
->m_addr
, sck
->m_local
->m_len
) != 0) ||
404 (getsockname(sck
->m_fd
,
405 sck
->m_local
->m_addr
,
406 (SOCKLEN_T
*)&sck
->m_local
->m_len
) != 0) ||
407 (listen(sck
->m_fd
, 5) != 0))
410 sck
->m_error
= GSOCK_IOERR
;
414 return GSOCK_NOERROR
;
417 /* GSocket_WaitConnection:
418 * Waits for an incoming client connection. Returns a pointer to
419 * a GSocket object, or NULL if there was an error, in which case
420 * the last error field will be updated for the calling GSocket.
422 * Error codes (set in the calling GSocket)
423 * GSOCK_INVSOCK - the socket is not valid or not a server.
424 * GSOCK_TIMEDOUT - timeout, no incoming connections.
425 * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
426 * GSOCK_MEMERR - couldn't allocate memory.
427 * GSOCK_IOERR - low-level error.
429 GSocket
*GSocket_WaitConnection(GSocket
*sck
)
432 struct sockaddr from
;
433 SOCKLEN_T fromlen
= sizeof(from
);
439 /* Reenable CONNECTION events */
440 sck
->m_detected
&= ~GSOCK_CONNECTION_FLAG
;
442 /* If the socket has already been created, we exit immediately */
443 if (sck
->m_fd
== INVALID_SOCKET
|| !sck
->m_server
)
445 sck
->m_error
= GSOCK_INVSOCK
;
449 /* Create a GSocket object for the new connection */
450 connection
= GSocket_new();
454 sck
->m_error
= GSOCK_MEMERR
;
458 /* Wait for a connection (with timeout) */
459 if (_GSocket_Input_Timeout(sck
) == GSOCK_TIMEDOUT
)
461 GSocket_destroy(connection
);
462 /* sck->m_error set by _GSocket_Input_Timeout */
466 connection
->m_fd
= accept(sck
->m_fd
, &from
, &fromlen
);
468 if (connection
->m_fd
== INVALID_SOCKET
)
470 if (WSAGetLastError() == WSAEWOULDBLOCK
)
471 sck
->m_error
= GSOCK_WOULDBLOCK
;
473 sck
->m_error
= GSOCK_IOERR
;
475 GSocket_destroy(connection
);
479 /* Initialize all fields */
480 connection
->m_server
= FALSE
;
481 connection
->m_stream
= TRUE
;
483 /* Setup the peer address field */
484 connection
->m_peer
= GAddress_new();
485 if (!connection
->m_peer
)
487 GSocket_destroy(connection
);
488 sck
->m_error
= GSOCK_MEMERR
;
491 err
= _GAddress_translate_from(connection
->m_peer
, &from
, fromlen
);
492 if (err
!= GSOCK_NOERROR
)
494 GAddress_destroy(connection
->m_peer
);
495 GSocket_destroy(connection
);
500 ioctlsocket(connection
->m_fd
, FIONBIO
, (u_long FAR
*) &arg
);
501 _GSocket_Enable_Events(connection
);
506 /* GSocket_SetReusable:
507 * Simply sets the m_resuable flag on the socket. GSocket_SetServer will
508 * make the appropriate setsockopt() call.
509 * Implemented as a GSocket function because clients (ie, wxSocketServer)
510 * don't have access to the GSocket struct information.
511 * Returns TRUE if the flag was set correctly, FALSE if an error occured
512 * (ie, if the parameter was NULL)
514 int GSocket_SetReusable(GSocket
*socket
)
516 /* socket must not be null, and must not be in use/already bound */
517 if (NULL
!= socket
&& socket
->m_fd
== INVALID_SOCKET
) {
518 socket
->m_reusable
= TRUE
;
524 /* Client specific parts */
527 * For stream (connection oriented) sockets, GSocket_Connect() tries
528 * to establish a client connection to a server using the peer address
529 * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
530 * connection has been succesfully established, or one of the error
531 * codes listed below. Note that for nonblocking sockets, a return
532 * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
533 * request can be completed later; you should use GSocket_Select()
534 * to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
535 * corresponding asynchronous events.
537 * For datagram (non connection oriented) sockets, GSocket_Connect()
538 * just sets the peer address established with GSocket_SetPeer() as
539 * default destination.
542 * GSOCK_INVSOCK - the socket is in use or not valid.
543 * GSOCK_INVADDR - the peer address has not been established.
544 * GSOCK_TIMEDOUT - timeout, the connection failed.
545 * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
546 * GSOCK_MEMERR - couldn't allocate memory.
547 * GSOCK_IOERR - low-level error.
549 GSocketError
GSocket_Connect(GSocket
*sck
, GSocketStream stream
)
556 /* Enable CONNECTION events (needed for nonblocking connections) */
557 sck
->m_detected
&= ~GSOCK_CONNECTION_FLAG
;
559 if (sck
->m_fd
!= INVALID_SOCKET
)
561 sck
->m_error
= GSOCK_INVSOCK
;
562 return GSOCK_INVSOCK
;
567 sck
->m_error
= GSOCK_INVADDR
;
568 return GSOCK_INVADDR
;
571 /* Streamed or dgram socket? */
572 sck
->m_stream
= (stream
== GSOCK_STREAMED
);
573 sck
->m_server
= FALSE
;
574 sck
->m_establishing
= FALSE
;
576 /* Create the socket */
577 sck
->m_fd
= socket(sck
->m_peer
->m_realfamily
,
578 sck
->m_stream
? SOCK_STREAM
: SOCK_DGRAM
, 0);
580 if (sck
->m_fd
== INVALID_SOCKET
)
582 sck
->m_error
= GSOCK_IOERR
;
586 ioctlsocket(sck
->m_fd
, FIONBIO
, (u_long FAR
*) &arg
);
587 _GSocket_Enable_Events(sck
);
589 /* Connect it to the peer address, with a timeout (see below) */
590 ret
= connect(sck
->m_fd
, sck
->m_peer
->m_addr
, sck
->m_peer
->m_len
);
592 if (ret
== SOCKET_ERROR
)
594 err
= WSAGetLastError();
596 /* If connect failed with EWOULDBLOCK and the GSocket object
597 * is in blocking mode, we select() for the specified timeout
598 * checking for writability to see if the connection request
601 if ((err
== WSAEWOULDBLOCK
) && (!sck
->m_non_blocking
))
603 err
= _GSocket_Connect_Timeout(sck
);
605 if (err
!= GSOCK_NOERROR
)
608 /* sck->m_error is set in _GSocket_Connect_Timeout */
611 return (GSocketError
) err
;
614 /* If connect failed with EWOULDBLOCK and the GSocket object
615 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
616 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
617 * this way if the connection completes, a GSOCK_CONNECTION
618 * event will be generated, if enabled.
620 if ((err
== WSAEWOULDBLOCK
) && (sck
->m_non_blocking
))
622 sck
->m_establishing
= TRUE
;
623 sck
->m_error
= GSOCK_WOULDBLOCK
;
624 return GSOCK_WOULDBLOCK
;
627 /* If connect failed with an error other than EWOULDBLOCK,
628 * then the call to GSocket_Connect() has failed.
631 sck
->m_error
= GSOCK_IOERR
;
635 return GSOCK_NOERROR
;
638 /* Datagram sockets */
640 /* GSocket_SetNonOriented:
641 * Sets up this socket as a non-connection oriented (datagram) socket.
642 * Before using this function, the local address must have been set
643 * with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
644 * on success, or one of the following otherwise.
647 * GSOCK_INVSOCK - the socket is in use.
648 * GSOCK_INVADDR - the local address has not been set.
649 * GSOCK_IOERR - low-level error.
651 GSocketError
GSocket_SetNonOriented(GSocket
*sck
)
657 if (sck
->m_fd
!= INVALID_SOCKET
)
659 sck
->m_error
= GSOCK_INVSOCK
;
660 return GSOCK_INVSOCK
;
665 sck
->m_error
= GSOCK_INVADDR
;
666 return GSOCK_INVADDR
;
669 /* Initialize all fields */
670 sck
->m_stream
= FALSE
;
671 sck
->m_server
= FALSE
;
673 /* Create the socket */
674 sck
->m_fd
= socket(sck
->m_local
->m_realfamily
, SOCK_DGRAM
, 0);
676 if (sck
->m_fd
== INVALID_SOCKET
)
678 sck
->m_error
= GSOCK_IOERR
;
682 ioctlsocket(sck
->m_fd
, FIONBIO
, (u_long FAR
*) &arg
);
683 _GSocket_Enable_Events(sck
);
685 /* Bind to the local address,
686 * and retrieve the actual address bound.
688 if ((bind(sck
->m_fd
, sck
->m_local
->m_addr
, sck
->m_local
->m_len
) != 0) ||
689 (getsockname(sck
->m_fd
,
690 sck
->m_local
->m_addr
,
691 (SOCKLEN_T
*)&sck
->m_local
->m_len
) != 0))
694 sck
->m_error
= GSOCK_IOERR
;
698 return GSOCK_NOERROR
;
703 /* Like recv(), send(), ... */
704 int GSocket_Read(GSocket
*socket
, char *buffer
, int size
)
708 assert(socket
!= NULL
);
710 /* Reenable INPUT events */
711 socket
->m_detected
&= ~GSOCK_INPUT_FLAG
;
713 if (socket
->m_fd
== INVALID_SOCKET
|| socket
->m_server
)
715 socket
->m_error
= GSOCK_INVSOCK
;
719 /* If the socket is blocking, wait for data (with a timeout) */
720 if (_GSocket_Input_Timeout(socket
) == GSOCK_TIMEDOUT
)
724 if (socket
->m_stream
)
725 ret
= _GSocket_Recv_Stream(socket
, buffer
, size
);
727 ret
= _GSocket_Recv_Dgram(socket
, buffer
, size
);
729 if (ret
== SOCKET_ERROR
)
731 if (WSAGetLastError() != WSAEWOULDBLOCK
)
732 socket
->m_error
= GSOCK_IOERR
;
734 socket
->m_error
= GSOCK_WOULDBLOCK
;
741 int GSocket_Write(GSocket
*socket
, const char *buffer
, int size
)
745 assert(socket
!= NULL
);
747 if (socket
->m_fd
== INVALID_SOCKET
|| socket
->m_server
)
749 socket
->m_error
= GSOCK_INVSOCK
;
753 /* If the socket is blocking, wait for writability (with a timeout) */
754 if (_GSocket_Output_Timeout(socket
) == GSOCK_TIMEDOUT
)
758 if (socket
->m_stream
)
759 ret
= _GSocket_Send_Stream(socket
, buffer
, size
);
761 ret
= _GSocket_Send_Dgram(socket
, buffer
, size
);
763 if (ret
== SOCKET_ERROR
)
765 if (WSAGetLastError() != WSAEWOULDBLOCK
)
766 socket
->m_error
= GSOCK_IOERR
;
768 socket
->m_error
= GSOCK_WOULDBLOCK
;
770 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
771 * does). Once the first OUTPUT event is received, users can assume
772 * that the socket is writable until a read operation fails. Only then
773 * will further OUTPUT events be posted.
775 socket
->m_detected
&= ~GSOCK_OUTPUT_FLAG
;
783 * Polls the socket to determine its status. This function will
784 * check for the events specified in the 'flags' parameter, and
785 * it will return a mask indicating which operations can be
786 * performed. This function won't block, regardless of the
787 * mode (blocking | nonblocking) of the socket.
789 GSocketEventFlags
GSocket_Select(GSocket
*socket
, GSocketEventFlags flags
)
793 GSocketEventFlags result
= 0;
798 assert(socket
!= NULL
);
803 FD_SET(socket
->m_fd
, &readfds
);
804 if (flags
& GSOCK_OUTPUT_FLAG
|| flags
& GSOCK_CONNECTION_FLAG
)
805 FD_SET(socket
->m_fd
, &writefds
);
806 FD_SET(socket
->m_fd
, &exceptfds
);
808 /* Check 'sticky' CONNECTION flag first */
809 result
|= (GSOCK_CONNECTION_FLAG
& socket
->m_detected
);
811 /* If we have already detected a LOST event, then don't try
812 * to do any further processing.
814 if ((socket
->m_detected
& GSOCK_LOST_FLAG
) != 0)
816 socket
->m_establishing
= FALSE
;
818 return (GSOCK_LOST_FLAG
& flags
);
822 if (select(socket
->m_fd
+ 1, &readfds
, &writefds
, &exceptfds
,
823 &socket
->m_timeout
) <= 0)
825 /* What to do here? */
826 return (result
& flags
);
829 /* Check for readability */
830 if (FD_ISSET(socket
->m_fd
, &readfds
))
834 if (!socket
->m_stream
|| recv(socket
->m_fd
, &c
, 1, MSG_PEEK
) > 0)
836 result
|= GSOCK_INPUT_FLAG
;
840 if (socket
->m_server
&& socket
->m_stream
)
842 result
|= GSOCK_CONNECTION_FLAG
;
843 socket
->m_detected
|= GSOCK_CONNECTION_FLAG
;
847 socket
->m_detected
= GSOCK_LOST_FLAG
;
848 socket
->m_establishing
= FALSE
;
850 /* LOST event: Abort any further processing */
851 return (GSOCK_LOST_FLAG
& flags
);
856 /* Check for writability */
857 if (FD_ISSET(socket
->m_fd
, &writefds
))
859 if (socket
->m_establishing
&& !socket
->m_server
)
862 SOCKLEN_T len
= sizeof(error
);
864 socket
->m_establishing
= FALSE
;
866 getsockopt(socket
->m_fd
, SOL_SOCKET
, SO_ERROR
, (char*)&error
, &len
);
870 socket
->m_detected
= GSOCK_LOST_FLAG
;
872 /* LOST event: Abort any further processing */
873 return (GSOCK_LOST_FLAG
& flags
);
877 result
|= GSOCK_CONNECTION_FLAG
;
878 socket
->m_detected
|= GSOCK_CONNECTION_FLAG
;
883 result
|= GSOCK_OUTPUT_FLAG
;
887 /* Check for exceptions and errors (is this useful in Unices?) */
888 if (FD_ISSET(socket
->m_fd
, &exceptfds
))
890 socket
->m_establishing
= FALSE
;
891 socket
->m_detected
= GSOCK_LOST_FLAG
;
893 /* LOST event: Abort any further processing */
894 return (GSOCK_LOST_FLAG
& flags
);
897 return (result
& flags
);
901 assert(socket
!= NULL
);
902 return flags
& socket
->m_detected
;
908 /* GSocket_SetNonBlocking:
909 * Sets the socket to non-blocking mode. All IO calls will return
912 void GSocket_SetNonBlocking(GSocket
*socket
, int non_block
)
914 assert(socket
!= NULL
);
916 socket
->m_non_blocking
= non_block
;
919 /* GSocket_SetTimeout:
920 * Sets the timeout for blocking calls. Time is expressed in
923 void GSocket_SetTimeout(GSocket
*socket
, unsigned long millis
)
925 assert(socket
!= NULL
);
927 socket
->m_timeout
.tv_sec
= (millis
/ 1000);
928 socket
->m_timeout
.tv_usec
= (millis
% 1000) * 1000;
932 * Returns the last error occured for this socket. Note that successful
933 * operations do not clear this back to GSOCK_NOERROR, so use it only
936 GSocketError
GSocket_GetError(GSocket
*socket
)
938 assert(socket
!= NULL
);
940 return socket
->m_error
;
946 * There is data to be read in the input buffer. If, after a read
947 * operation, there is still data available, the callback function will
950 * The socket is available for writing. That is, the next write call
951 * won't block. This event is generated only once, when the connection is
952 * first established, and then only if a call failed with GSOCK_WOULDBLOCK,
953 * when the output buffer empties again. This means that the app should
954 * assume that it can write since the first OUTPUT event, and no more
955 * OUTPUT events will be generated unless an error occurs.
957 * Connection succesfully established, for client sockets, or incoming
958 * client connection, for server sockets. Wait for this event (also watch
959 * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
961 * The connection is lost (or a connection request failed); this could
962 * be due to a failure, or due to the peer closing it gracefully.
965 /* GSocket_SetCallback:
966 * Enables the callbacks specified by 'flags'. Note that 'flags'
967 * may be a combination of flags OR'ed toghether, so the same
968 * callback function can be made to accept different events.
969 * The callback function must have the following prototype:
971 * void function(GSocket *socket, GSocketEvent event, char *cdata)
973 void GSocket_SetCallback(GSocket
*socket
, GSocketEventFlags flags
,
974 GSocketCallback callback
, char *cdata
)
978 assert(socket
!= NULL
);
980 for (count
= 0; count
< GSOCK_MAX_EVENT
; count
++)
982 if ((flags
& (1 << count
)) != 0)
984 socket
->m_cbacks
[count
] = callback
;
985 socket
->m_data
[count
] = cdata
;
990 /* GSocket_UnsetCallback:
991 * Disables all callbacks specified by 'flags', which may be a
992 * combination of flags OR'ed toghether.
994 void GSocket_UnsetCallback(GSocket
*socket
, GSocketEventFlags flags
)
998 assert(socket
!= NULL
);
1000 for (count
= 0; count
< GSOCK_MAX_EVENT
; count
++)
1002 if ((flags
& (1 << count
)) != 0)
1004 socket
->m_cbacks
[count
] = NULL
;
1005 socket
->m_data
[count
] = NULL
;
1010 GSocketError
GSocket_GetSockOpt(GSocket
*socket
, int level
, int optname
,
1011 void *optval
, int *optlen
)
1013 if (getsockopt(socket
->m_fd
, level
, optname
, (char*)optval
, optlen
) == 0)
1015 return GSOCK_NOERROR
;
1017 return GSOCK_OPTERR
;
1020 GSocketError
GSocket_SetSockOpt(GSocket
*socket
, int level
, int optname
,
1021 const void *optval
, int optlen
)
1023 if (setsockopt(socket
->m_fd
, level
, optname
, (char*)optval
, optlen
) == 0)
1025 return GSOCK_NOERROR
;
1027 return GSOCK_OPTERR
;
1030 /* Internals (IO) */
1032 /* _GSocket_Input_Timeout:
1033 * For blocking sockets, wait until data is available or
1034 * until timeout ellapses.
1036 GSocketError
_GSocket_Input_Timeout(GSocket
*socket
)
1040 if (!socket
->m_non_blocking
)
1043 FD_SET(socket
->m_fd
, &readfds
);
1044 if (select(0, &readfds
, NULL
, NULL
, &socket
->m_timeout
) == 0)
1046 socket
->m_error
= GSOCK_TIMEDOUT
;
1047 return GSOCK_TIMEDOUT
;
1050 return GSOCK_NOERROR
;
1053 /* _GSocket_Output_Timeout:
1054 * For blocking sockets, wait until data can be sent without
1055 * blocking or until timeout ellapses.
1057 GSocketError
_GSocket_Output_Timeout(GSocket
*socket
)
1061 if (!socket
->m_non_blocking
)
1064 FD_SET(socket
->m_fd
, &writefds
);
1065 if (select(0, NULL
, &writefds
, NULL
, &socket
->m_timeout
) == 0)
1067 socket
->m_error
= GSOCK_TIMEDOUT
;
1068 return GSOCK_TIMEDOUT
;
1071 return GSOCK_NOERROR
;
1074 /* _GSocket_Connect_Timeout:
1075 * For blocking sockets, wait until the connection is
1076 * established or fails, or until timeout ellapses.
1078 GSocketError
_GSocket_Connect_Timeout(GSocket
*socket
)
1084 FD_ZERO(&exceptfds
);
1085 FD_SET(socket
->m_fd
, &writefds
);
1086 FD_SET(socket
->m_fd
, &exceptfds
);
1087 if (select(0, NULL
, &writefds
, &exceptfds
, &socket
->m_timeout
) == 0)
1089 socket
->m_error
= GSOCK_TIMEDOUT
;
1090 return GSOCK_TIMEDOUT
;
1092 if (!FD_ISSET(socket
->m_fd
, &writefds
))
1094 socket
->m_error
= GSOCK_IOERR
;
1098 return GSOCK_NOERROR
;
1101 int _GSocket_Recv_Stream(GSocket
*socket
, char *buffer
, int size
)
1103 return recv(socket
->m_fd
, buffer
, size
, 0);
1106 int _GSocket_Recv_Dgram(GSocket
*socket
, char *buffer
, int size
)
1108 struct sockaddr from
;
1109 SOCKLEN_T fromlen
= sizeof(from
);
1113 ret
= recvfrom(socket
->m_fd
, buffer
, size
, 0, &from
, &fromlen
);
1115 if (ret
== SOCKET_ERROR
)
1116 return SOCKET_ERROR
;
1118 /* Translate a system address into a GSocket address */
1119 if (!socket
->m_peer
)
1121 socket
->m_peer
= GAddress_new();
1122 if (!socket
->m_peer
)
1124 socket
->m_error
= GSOCK_MEMERR
;
1128 err
= _GAddress_translate_from(socket
->m_peer
, &from
, fromlen
);
1129 if (err
!= GSOCK_NOERROR
)
1131 GAddress_destroy(socket
->m_peer
);
1132 socket
->m_peer
= NULL
;
1133 socket
->m_error
= err
;
1140 int _GSocket_Send_Stream(GSocket
*socket
, const char *buffer
, int size
)
1142 return send(socket
->m_fd
, buffer
, size
, 0);
1145 int _GSocket_Send_Dgram(GSocket
*socket
, const char *buffer
, int size
)
1147 struct sockaddr
*addr
;
1151 if (!socket
->m_peer
)
1153 socket
->m_error
= GSOCK_INVADDR
;
1157 err
= _GAddress_translate_to(socket
->m_peer
, &addr
, &len
);
1158 if (err
!= GSOCK_NOERROR
)
1160 socket
->m_error
= err
;
1164 ret
= sendto(socket
->m_fd
, buffer
, size
, 0, addr
, len
);
1166 /* Frees memory allocated by _GAddress_translate_to */
1174 * -------------------------------------------------------------------------
1176 * -------------------------------------------------------------------------
1179 /* CHECK_ADDRESS verifies that the current address family is either
1180 * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1181 * initalizes it to be a GSOCK_*family*. In other cases, it returns
1182 * an appropiate error code.
1184 * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1186 #define CHECK_ADDRESS(address, family) \
1188 if (address->m_family == GSOCK_NOFAMILY) \
1189 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1190 return address->m_error; \
1191 if (address->m_family != GSOCK_##family) \
1193 address->m_error = GSOCK_INVADDR; \
1194 return GSOCK_INVADDR; \
1198 #define CHECK_ADDRESS_RETVAL(address, family, retval) \
1200 if (address->m_family == GSOCK_NOFAMILY) \
1201 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1203 if (address->m_family != GSOCK_##family) \
1205 address->m_error = GSOCK_INVADDR; \
1211 GAddress
*GAddress_new(void)
1215 if ((address
= (GAddress
*) malloc(sizeof(GAddress
))) == NULL
)
1218 address
->m_family
= GSOCK_NOFAMILY
;
1219 address
->m_addr
= NULL
;
1225 GAddress
*GAddress_copy(GAddress
*address
)
1229 assert(address
!= NULL
);
1231 if ((addr2
= (GAddress
*) malloc(sizeof(GAddress
))) == NULL
)
1234 memcpy(addr2
, address
, sizeof(GAddress
));
1236 if (address
->m_addr
)
1238 addr2
->m_addr
= (struct sockaddr
*) malloc(addr2
->m_len
);
1239 if (addr2
->m_addr
== NULL
)
1244 memcpy(addr2
->m_addr
, address
->m_addr
, addr2
->m_len
);
1250 void GAddress_destroy(GAddress
*address
)
1252 assert(address
!= NULL
);
1254 if (address
->m_addr
)
1255 free(address
->m_addr
);
1260 void GAddress_SetFamily(GAddress
*address
, GAddressType type
)
1262 assert(address
!= NULL
);
1264 address
->m_family
= type
;
1267 GAddressType
GAddress_GetFamily(GAddress
*address
)
1269 assert(address
!= NULL
);
1271 return address
->m_family
;
1274 GSocketError
_GAddress_translate_from(GAddress
*address
,
1275 struct sockaddr
*addr
, int len
)
1277 address
->m_realfamily
= addr
->sa_family
;
1278 switch (addr
->sa_family
)
1281 address
->m_family
= GSOCK_INET
;
1284 address
->m_family
= GSOCK_UNIX
;
1288 address
->m_family
= GSOCK_INET6
;
1293 address
->m_error
= GSOCK_INVOP
;
1298 if (address
->m_addr
)
1299 free(address
->m_addr
);
1301 address
->m_len
= len
;
1302 address
->m_addr
= (struct sockaddr
*) malloc(len
);
1304 if (address
->m_addr
== NULL
)
1306 address
->m_error
= GSOCK_MEMERR
;
1307 return GSOCK_MEMERR
;
1309 memcpy(address
->m_addr
, addr
, len
);
1311 return GSOCK_NOERROR
;
1314 GSocketError
_GAddress_translate_to(GAddress
*address
,
1315 struct sockaddr
**addr
, int *len
)
1317 if (!address
->m_addr
)
1319 address
->m_error
= GSOCK_INVADDR
;
1320 return GSOCK_INVADDR
;
1323 *len
= address
->m_len
;
1324 *addr
= (struct sockaddr
*) malloc(address
->m_len
);
1327 address
->m_error
= GSOCK_MEMERR
;
1328 return GSOCK_MEMERR
;
1331 memcpy(*addr
, address
->m_addr
, address
->m_len
);
1332 return GSOCK_NOERROR
;
1336 * -------------------------------------------------------------------------
1337 * Internet address family
1338 * -------------------------------------------------------------------------
1341 GSocketError
_GAddress_Init_INET(GAddress
*address
)
1343 address
->m_len
= sizeof(struct sockaddr_in
);
1344 address
->m_addr
= (struct sockaddr
*) malloc(address
->m_len
);
1345 if (address
->m_addr
== NULL
)
1347 address
->m_error
= GSOCK_MEMERR
;
1348 return GSOCK_MEMERR
;
1351 address
->m_family
= GSOCK_INET
;
1352 address
->m_realfamily
= AF_INET
;
1353 ((struct sockaddr_in
*)address
->m_addr
)->sin_family
= AF_INET
;
1354 ((struct sockaddr_in
*)address
->m_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
1356 return GSOCK_NOERROR
;
1359 GSocketError
GAddress_INET_SetHostName(GAddress
*address
, const char *hostname
)
1362 struct in_addr
*addr
;
1364 assert(address
!= NULL
);
1366 CHECK_ADDRESS(address
, INET
);
1368 addr
= &(((struct sockaddr_in
*)address
->m_addr
)->sin_addr
);
1370 addr
->s_addr
= inet_addr(hostname
);
1372 /* If it is a numeric host name, convert it now */
1373 if (addr
->s_addr
== INADDR_NONE
)
1375 struct in_addr
*array_addr
;
1377 /* It is a real name, we solve it */
1378 if ((he
= gethostbyname(hostname
)) == NULL
)
1380 /* addr->s_addr = INADDR_NONE just done by inet_addr() above */
1381 address
->m_error
= GSOCK_NOHOST
;
1382 return GSOCK_NOHOST
;
1384 array_addr
= (struct in_addr
*) *(he
->h_addr_list
);
1385 addr
->s_addr
= array_addr
[0].s_addr
;
1387 return GSOCK_NOERROR
;
1390 GSocketError
GAddress_INET_SetAnyAddress(GAddress
*address
)
1392 return GAddress_INET_SetHostAddress(address
, INADDR_ANY
);
1395 GSocketError
GAddress_INET_SetHostAddress(GAddress
*address
,
1396 unsigned long hostaddr
)
1398 struct in_addr
*addr
;
1400 assert(address
!= NULL
);
1402 CHECK_ADDRESS(address
, INET
);
1404 addr
= &(((struct sockaddr_in
*)address
->m_addr
)->sin_addr
);
1405 addr
->s_addr
= htonl(hostaddr
);;
1407 return GSOCK_NOERROR
;
1410 GSocketError
GAddress_INET_SetPortName(GAddress
*address
, const char *port
,
1411 const char *protocol
)
1414 struct sockaddr_in
*addr
;
1416 assert(address
!= NULL
);
1417 CHECK_ADDRESS(address
, INET
);
1421 address
->m_error
= GSOCK_INVPORT
;
1422 return GSOCK_INVPORT
;
1425 se
= getservbyname(port
, protocol
);
1428 if (isdigit(port
[0]))
1432 port_int
= atoi(port
);
1433 addr
= (struct sockaddr_in
*)address
->m_addr
;
1434 addr
->sin_port
= htons((u_short
) port_int
);
1435 return GSOCK_NOERROR
;
1438 address
->m_error
= GSOCK_INVPORT
;
1439 return GSOCK_INVPORT
;
1442 addr
= (struct sockaddr_in
*)address
->m_addr
;
1443 addr
->sin_port
= se
->s_port
;
1445 return GSOCK_NOERROR
;
1448 GSocketError
GAddress_INET_SetPort(GAddress
*address
, unsigned short port
)
1450 struct sockaddr_in
*addr
;
1452 assert(address
!= NULL
);
1453 CHECK_ADDRESS(address
, INET
);
1455 addr
= (struct sockaddr_in
*)address
->m_addr
;
1456 addr
->sin_port
= htons(port
);
1458 return GSOCK_NOERROR
;
1461 GSocketError
GAddress_INET_GetHostName(GAddress
*address
, char *hostname
, size_t sbuf
)
1465 struct sockaddr_in
*addr
;
1467 assert(address
!= NULL
);
1468 CHECK_ADDRESS(address
, INET
);
1470 addr
= (struct sockaddr_in
*)address
->m_addr
;
1471 addr_buf
= (char *)&(addr
->sin_addr
);
1473 he
= gethostbyaddr(addr_buf
, sizeof(addr
->sin_addr
), AF_INET
);
1476 address
->m_error
= GSOCK_NOHOST
;
1477 return GSOCK_NOHOST
;
1480 strncpy(hostname
, he
->h_name
, sbuf
);
1482 return GSOCK_NOERROR
;
1485 unsigned long GAddress_INET_GetHostAddress(GAddress
*address
)
1487 struct sockaddr_in
*addr
;
1489 assert(address
!= NULL
);
1490 CHECK_ADDRESS_RETVAL(address
, INET
, 0);
1492 addr
= (struct sockaddr_in
*)address
->m_addr
;
1494 return ntohl(addr
->sin_addr
.s_addr
);
1497 unsigned short GAddress_INET_GetPort(GAddress
*address
)
1499 struct sockaddr_in
*addr
;
1501 assert(address
!= NULL
);
1502 CHECK_ADDRESS_RETVAL(address
, INET
, 0);
1504 addr
= (struct sockaddr_in
*)address
->m_addr
;
1505 return ntohs(addr
->sin_port
);
1509 * -------------------------------------------------------------------------
1510 * Unix address family
1511 * -------------------------------------------------------------------------
1514 GSocketError
_GAddress_Init_UNIX(GAddress
*address
)
1516 assert (address
!= NULL
);
1517 address
->m_error
= GSOCK_INVADDR
;
1518 return GSOCK_INVADDR
;
1521 GSocketError
GAddress_UNIX_SetPath(GAddress
*address
, const char *path
)
1523 #if defined(__BORLANDC__)
1524 /* prevents unused variable message in Borland */
1527 assert (address
!= NULL
);
1528 address
->m_error
= GSOCK_INVADDR
;
1529 return GSOCK_INVADDR
;
1532 GSocketError
GAddress_UNIX_GetPath(GAddress
*address
, char *path
, size_t sbuf
)
1534 #if defined(__BORLANDC__)
1535 /* prevents unused variable message in Borland */
1539 assert (address
!= NULL
);
1540 address
->m_error
= GSOCK_INVADDR
;
1541 return GSOCK_INVADDR
;
1544 #else /* !wxUSE_SOCKETS */
1547 * Translation unit shouldn't be empty, so include this typedef to make the
1548 * compiler (VC++ 6.0, for example) happy
1550 typedef void (*wxDummy
)();
1552 #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */