]>
git.saurik.com Git - wxWidgets.git/blob - src/unix/gsocket.c
1 /* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket) for WX
4 * Purpose: GSocket main Unix file
6 * -------------------------------------------------------------------------
14 #include <sys/ioctl.h>
15 #include <sys/types.h>
19 #include <sys/socket.h>
23 #include <netinet/in.h>
24 #include <arpa/inet.h>
36 # include <sys/filio.h>
45 #include "wx/gsocket.h"
46 #include "wx/unix/gsockunx.h"
52 # define SOCKLEN_T socklen_t
55 # define SOCKLEN_T int
60 #define MASK_SIGNAL() \
62 void (*old_handler)(int); \
64 old_handler = signal(SIGPIPE, SIG_IGN);
66 #define UNMASK_SIGNAL() \
67 signal(SIGPIPE, old_handler); \
71 /* Global initialisers */
78 void GSocket_Cleanup()
82 /* Constructors / Destructors */
84 GSocket
*GSocket_new()
89 socket
= (GSocket
*)malloc(sizeof(GSocket
));
95 for (i
=0;i
<GSOCK_MAX_EVENT
;i
++)
97 socket
->m_cbacks
[i
] = NULL
;
99 socket
->m_detected
= 0;
100 socket
->m_local
= NULL
;
101 socket
->m_peer
= NULL
;
102 socket
->m_error
= GSOCK_NOERROR
;
103 socket
->m_server
= FALSE
;
104 socket
->m_stream
= TRUE
;
105 socket
->m_gui_dependent
= NULL
;
106 socket
->m_non_blocking
= FALSE
;
107 socket
->m_timeout
= 10*60*1000;
108 /* 10 minutes * 60 sec * 1000 millisec */
109 socket
->m_establishing
= FALSE
;
111 /* We initialize the GUI specific entries here */
112 _GSocket_GUI_Init(socket
);
117 void GSocket_destroy(GSocket
*socket
)
119 assert(socket
!= NULL
);
121 /* First, we check that the socket is really shutdowned */
122 if (socket
->m_fd
!= -1)
123 GSocket_Shutdown(socket
);
125 /* We destroy GUI specific variables */
126 _GSocket_GUI_Destroy(socket
);
128 /* We destroy private addresses */
130 GAddress_destroy(socket
->m_local
);
133 GAddress_destroy(socket
->m_peer
);
135 /* We destroy socket itself */
139 void GSocket_Shutdown(GSocket
*socket
)
143 assert(socket
!= NULL
);
145 /* If socket has been created, we shutdown it */
146 if (socket
->m_fd
!= -1)
148 shutdown(socket
->m_fd
, 2);
153 /* We also disable GUI callbacks */
154 for (evt
= 0; evt
< GSOCK_MAX_EVENT
; evt
++)
155 socket
->m_cbacks
[evt
] = NULL
;
157 socket
->m_detected
= 0;
158 _GSocket_Disable_Events(socket
);
161 /* Address handling */
163 GSocketError
GSocket_SetLocal(GSocket
*socket
, GAddress
*address
)
165 assert(socket
!= NULL
);
167 if ((socket
->m_fd
!= -1 && !socket
->m_server
)) {
168 socket
->m_error
= GSOCK_INVSOCK
;
169 return GSOCK_INVSOCK
;
172 if (address
== NULL
|| address
->m_family
== GSOCK_NOFAMILY
) {
173 socket
->m_error
= GSOCK_INVADDR
;
174 return GSOCK_INVADDR
;
178 GAddress_destroy(socket
->m_local
);
180 socket
->m_local
= GAddress_copy(address
);
182 return GSOCK_NOERROR
;
185 GSocketError
GSocket_SetPeer(GSocket
*socket
, GAddress
*address
)
187 assert(socket
!= NULL
);
189 if (address
== NULL
|| address
->m_family
== GSOCK_NOFAMILY
) {
190 socket
->m_error
= GSOCK_INVADDR
;
191 return GSOCK_INVADDR
;
195 GAddress_destroy(socket
->m_peer
);
197 socket
->m_peer
= GAddress_copy(address
);
199 return GSOCK_NOERROR
;
202 GAddress
*GSocket_GetLocal(GSocket
*socket
)
205 struct sockaddr addr
;
209 assert(socket
!= NULL
);
212 return GAddress_copy(socket
->m_local
);
214 if (socket
->m_fd
== -1) {
215 socket
->m_error
= GSOCK_INVSOCK
;
221 if (getsockname(socket
->m_fd
, &addr
, &size
) < 0) {
222 socket
->m_error
= GSOCK_IOERR
;
226 address
= GAddress_new();
227 if (address
== NULL
) {
228 socket
->m_error
= GSOCK_MEMERR
;
231 socket
->m_error
= _GAddress_translate_from(address
, &addr
, size
);
232 if (socket
->m_error
!= GSOCK_NOERROR
) {
233 GAddress_destroy(address
);
240 GAddress
*GSocket_GetPeer(GSocket
*socket
)
242 assert(socket
!= NULL
);
245 return GAddress_copy(socket
->m_peer
);
250 /* Server specific parts */
252 /* GSocket_SetServer:
253 * Sets up the socket as a server. It uses the "Local" field of GSocket.
254 * "Local" must be set by GSocket_SetLocal() before GSocket_SetServer()
255 * is called. Possible error codes are: GSOCK_INVSOCK if socket has not
256 * been initialized, GSOCK_INVADDR if the local address has not been
257 * defined and GSOCK_IOERR for other internal errors.
259 GSocketError
GSocket_SetServer(GSocket
*sck
)
266 if (sck
->m_fd
!= -1) {
267 sck
->m_error
= GSOCK_INVSOCK
;
268 return GSOCK_INVSOCK
;
272 sck
->m_error
= GSOCK_INVADDR
;
273 return GSOCK_INVADDR
;
276 /* We always have a stream here */
277 sck
->m_stream
= TRUE
;
278 sck
->m_server
= TRUE
;
280 /* Create the socket */
281 sck
->m_fd
= socket(sck
->m_local
->m_realfamily
, SOCK_STREAM
, 0);
283 if (sck
->m_fd
== -1) {
284 sck
->m_error
= GSOCK_IOERR
;
288 ioctl(sck
->m_fd
, FIONBIO
, &arg
);
289 _GSocket_Enable_Events(sck
);
291 /* Bind the socket to the LOCAL address */
292 if (bind(sck
->m_fd
, sck
->m_local
->m_addr
, sck
->m_local
->m_len
) < 0) {
295 sck
->m_error
= GSOCK_IOERR
;
299 /* Enable listening up to 5 connections */
300 if (listen(sck
->m_fd
, 5) < 0) {
303 sck
->m_error
= GSOCK_IOERR
;
307 return GSOCK_NOERROR
;
310 /* GSocket_WaitConnection:
311 * Waits for an incoming client connection.
313 GSocket
*GSocket_WaitConnection(GSocket
*socket
)
318 assert(socket
!= NULL
);
320 /* Reenable CONNECTION events */
321 _GSocket_Enable(socket
, GSOCK_CONNECTION
);
323 /* If the socket has already been created, we exit immediately */
324 if (socket
->m_fd
== -1 || !socket
->m_server
)
326 socket
->m_error
= GSOCK_INVSOCK
;
330 /* Create a GSocket object for the new connection */
331 connection
= GSocket_new();
334 connection
->m_error
= GSOCK_MEMERR
;
338 /* Accept the incoming connection */
339 if (_GSocket_Input_Timeout(socket
) == GSOCK_TIMEDOUT
)
341 GSocket_destroy(connection
);
342 /* socket->m_error set by _GSocket_Input_Timeout */
346 connection
->m_fd
= accept(socket
->m_fd
, NULL
, NULL
);
348 if (connection
->m_fd
== -1)
350 if (errno
== EWOULDBLOCK
)
351 socket
->m_error
= GSOCK_WOULDBLOCK
;
353 socket
->m_error
= GSOCK_IOERR
;
355 GSocket_destroy(connection
);
359 /* Initialize all fields */
360 connection
->m_server
= FALSE
;
361 connection
->m_stream
= TRUE
;
362 connection
->m_oriented
= TRUE
;
364 ioctl(connection
->m_fd
, FIONBIO
, &arg
);
365 _GSocket_Enable_Events(connection
);
370 /* Non oriented connections */
372 GSocketError
GSocket_SetNonOriented(GSocket
*sck
)
378 if (sck
->m_fd
!= -1) {
379 sck
->m_error
= GSOCK_INVSOCK
;
380 return GSOCK_INVSOCK
;
384 sck
->m_error
= GSOCK_INVADDR
;
385 return GSOCK_INVADDR
;
388 sck
->m_stream
= FALSE
;
389 sck
->m_server
= FALSE
;
390 sck
->m_oriented
= FALSE
;
392 /* Create the socket */
393 sck
->m_fd
= socket(sck
->m_local
->m_realfamily
, SOCK_DGRAM
, 0);
396 sck
->m_error
= GSOCK_IOERR
;
400 ioctl(sck
->m_fd
, FIONBIO
, &arg
);
401 _GSocket_Enable_Events(sck
);
403 /* Bind it to the LOCAL address */
404 if (bind(sck
->m_fd
, sck
->m_local
->m_addr
, sck
->m_local
->m_len
) < 0) {
407 sck
->m_error
= GSOCK_IOERR
;
411 return GSOCK_NOERROR
;
414 /* Client specific parts */
417 * Establishes a client connection to a server using the "Peer"
418 * field of GSocket. "Peer" must be set by GSocket_SetPeer() before
419 * GSocket_Connect() is called. Possible error codes are GSOCK_INVSOCK,
420 * GSOCK_INVADDR, GSOCK_TIMEDOUT, GSOCK_WOULDBLOCK and GSOCK_IOERR.
421 * If a socket is nonblocking and Connect() returns GSOCK_WOULDBLOCK,
422 * the connection request can be completed later. Use GSocket_Select()
423 * to check or wait for a GSOCK_CONNECTION event.
425 GSocketError
GSocket_Connect(GSocket
*sck
, GSocketStream stream
)
432 /* Enable CONNECTION events (needed for nonblocking connections) */
433 _GSocket_Enable(sck
, GSOCK_CONNECTION
);
437 sck
->m_error
= GSOCK_INVSOCK
;
438 return GSOCK_INVSOCK
;
443 sck
->m_error
= GSOCK_INVADDR
;
444 return GSOCK_INVADDR
;
447 /* Test whether we want the socket to be a stream (e.g. TCP) */
448 sck
->m_stream
= (stream
== GSOCK_STREAMED
);
449 sck
->m_oriented
= TRUE
;
450 sck
->m_server
= FALSE
;
451 sck
->m_establishing
= FALSE
;
458 /* Create the socket */
459 sck
->m_fd
= socket(sck
->m_peer
->m_realfamily
, type
, 0);
461 if (sck
->m_fd
== -1) {
462 sck
->m_error
= GSOCK_IOERR
;
466 ioctl(sck
->m_fd
, FIONBIO
, &arg
);
467 _GSocket_Enable_Events(sck
);
469 /* Connect it to the PEER address */
470 ret
= connect(sck
->m_fd
, sck
->m_peer
->m_addr
, sck
->m_peer
->m_len
);
476 /* If connect failed with EINPROGRESS and the GSocket object
477 * is in blocking mode, we select() for the specified timeout
478 * checking for writability to see if the connection request
481 if ((err
== EINPROGRESS
) && (!sck
->m_non_blocking
))
483 if (_GSocket_Output_Timeout(sck
) == GSOCK_TIMEDOUT
)
487 /* sck->m_error is set in _GSocket_Output_Timeout */
488 fprintf(stderr
, "Blocking connect timeouts\n");
489 return GSOCK_TIMEDOUT
;
493 fprintf(stderr
, "Blocking connect OK\n");
494 return GSOCK_NOERROR
;
498 /* If connect failed with EINPROGRESS and the GSocket object
499 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
500 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
501 * this way if the connection completes, a GSOCK_CONNECTION
502 * event will be generated, if enabled.
504 if ((err
== EINPROGRESS
) && (sck
->m_non_blocking
))
506 sck
->m_error
= GSOCK_WOULDBLOCK
;
507 sck
->m_establishing
= TRUE
;
508 fprintf(stderr
, "Nonblocking connect in progress\n");
510 return GSOCK_WOULDBLOCK
;
513 /* If connect failed with an error other than EINPROGRESS,
514 * then the call to GSocket_Connect has failed.
518 sck
->m_error
= GSOCK_IOERR
;
520 fprintf(stderr
, "Connect failed (generic err)\n");
524 fprintf(stderr
, "Connect OK\n");
525 return GSOCK_NOERROR
;
530 /* Like recv(), send(), ... */
531 int GSocket_Read(GSocket
*socket
, char *buffer
, int size
)
535 assert(socket
!= NULL
);
537 /* Reenable INPUT events */
538 _GSocket_Enable(socket
, GSOCK_INPUT
);
540 if (socket
->m_fd
== -1 || socket
->m_server
)
542 socket
->m_error
= GSOCK_INVSOCK
;
546 if (_GSocket_Input_Timeout(socket
) == GSOCK_TIMEDOUT
)
549 if (socket
->m_stream
)
550 ret
= _GSocket_Recv_Stream(socket
, buffer
, size
);
552 ret
= _GSocket_Recv_Dgram(socket
, buffer
, size
);
556 if (errno
== EWOULDBLOCK
)
557 socket
->m_error
= GSOCK_WOULDBLOCK
;
559 socket
->m_error
= GSOCK_IOERR
;
565 int GSocket_Write(GSocket
*socket
, const char *buffer
,
570 assert(socket
!= NULL
);
572 if (socket
->m_fd
== -1 || socket
->m_server
)
574 socket
->m_error
= GSOCK_INVSOCK
;
578 if (_GSocket_Output_Timeout(socket
) == GSOCK_TIMEDOUT
)
581 if (socket
->m_stream
)
582 ret
= _GSocket_Send_Stream(socket
, buffer
, size
);
584 ret
= _GSocket_Send_Dgram(socket
, buffer
, size
);
588 if (errno
== EWOULDBLOCK
)
589 socket
->m_error
= GSOCK_WOULDBLOCK
;
591 socket
->m_error
= GSOCK_IOERR
;
593 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
594 * in MSW). Once the first OUTPUT event is received, users can assume
595 * that the socket is writable until a read operation fails. Only then
596 * will further OUTPUT events be posted.
598 _GSocket_Enable(socket
, GSOCK_OUTPUT
);
605 * Polls the socket to determine its status. This function will
606 * check for the events specified in the 'flags' parameter, and
607 * it will return a mask indicating which operations can be
608 * performed. This function won't block, regardless of the
609 * mode (blocking|nonblocking) of the socket.
611 GSocketEventFlags
GSocket_Select(GSocket
*socket
, GSocketEventFlags flags
)
613 assert(socket
!= NULL
);
615 return (flags
& socket
->m_detected
);
620 /* GSocket_SetNonBlocking:
621 * Sets the socket to non-blocking mode. This is useful if
622 * we don't want to wait.
624 void GSocket_SetNonBlocking(GSocket
*socket
, bool non_block
)
626 assert(socket
!= NULL
);
628 socket
->m_non_blocking
= non_block
;
631 /* GSocket_SetTimeout:
632 * Sets the timeout for blocking calls. Time is
633 * expressed in milliseconds.
635 void GSocket_SetTimeout(GSocket
*socket
, unsigned long millisec
)
637 assert(socket
!= NULL
);
639 socket
->m_timeout
= millisec
;
643 * Returns the last error occured for this socket.
645 GSocketError
GSocket_GetError(GSocket
*socket
)
647 assert(socket
!= NULL
);
649 return socket
->m_error
;
654 /* Only one callback is possible for each event (INPUT, OUTPUT, CONNECTION
655 * and LOST). The callbacks are called in the following situations:
657 * INPUT: There is at least one byte in the input buffer
658 * OUTPUT: The system is sure that the next write call will not block
659 * CONNECTION: Two cases are possible:
660 * Client socket -> the connection is established
661 * Server socket -> a client requests a connection
662 * LOST: The connection is lost
664 * An event is generated only once and its state is reseted when the
665 * relative IO call is requested.
666 * For example: INPUT -> GSocket_Read()
667 * CONNECTION -> GSocket_Accept()
670 /* GSocket_SetCallback:
671 * Enables the callbacks specified by 'flags'. Note that 'flags'
672 * may be a combination of flags OR'ed toghether, so the same
673 * callback function can be made to accept different events.
674 * The callback function must have the following prototype:
676 * void function(GSocket *socket, GSocketEvent event, char *cdata)
678 void GSocket_SetCallback(GSocket
*socket
, GSocketEventFlags flags
,
679 GSocketCallback callback
, char *cdata
)
683 assert(socket
!= NULL
);
685 for (count
= 0; count
< GSOCK_MAX_EVENT
; count
++)
687 if ((flags
& (1 << count
)) != 0)
689 socket
->m_cbacks
[count
] = callback
;
690 socket
->m_data
[count
] = cdata
;
695 /* GSocket_UnsetCallback:
696 * Disables all callbacks specified by 'flags', which may be a
697 * combination of flags OR'ed toghether.
699 void GSocket_UnsetCallback(GSocket
*socket
, GSocketEventFlags flags
)
703 assert(socket
!= NULL
);
705 for (count
= 0; count
< GSOCK_MAX_EVENT
; count
++)
707 if ((flags
& (1 << count
)) != 0)
709 socket
->m_cbacks
[count
] = NULL
;
710 socket
->m_data
[count
] = NULL
;
715 #define CALL_CALLBACK(socket, event) { \
716 _GSocket_Disable(socket, event); \
717 if (socket->m_cbacks[event]) \
718 socket->m_cbacks[event](socket, event, socket->m_data[event]); \
722 void _GSocket_Enable(GSocket
*socket
, GSocketEvent event
)
724 socket
->m_detected
&= ~(1 << event
);
725 _GSocket_Install_Callback(socket
, event
);
728 void _GSocket_Disable(GSocket
*socket
, GSocketEvent event
)
730 socket
->m_detected
|= (1 << event
);
731 _GSocket_Uninstall_Callback(socket
, event
);
734 /* _GSocket_Input_Timeout:
735 * For blocking sockets, wait until data is available or
736 * until timeout ellapses.
738 GSocketError
_GSocket_Input_Timeout(GSocket
*socket
)
743 /* Linux select() will overwrite the struct on return */
744 tv
.tv_sec
= (socket
->m_timeout
/ 1000);
745 tv
.tv_usec
= (socket
->m_timeout
% 1000) * 1000;
747 if (!socket
->m_non_blocking
)
750 FD_SET(socket
->m_fd
, &readfds
);
751 if (select(socket
->m_fd
+ 1, &readfds
, NULL
, NULL
, &tv
) == 0)
753 socket
->m_error
= GSOCK_TIMEDOUT
;
754 return GSOCK_TIMEDOUT
;
757 return GSOCK_NOERROR
;
760 /* _GSocket_Output_Timeout:
761 * For blocking sockets, wait until data can be sent without
762 * blocking or until timeout ellapses.
764 GSocketError
_GSocket_Output_Timeout(GSocket
*socket
)
769 /* Linux select() will overwrite the struct on return */
770 tv
.tv_sec
= (socket
->m_timeout
/ 1000);
771 tv
.tv_usec
= (socket
->m_timeout
% 1000) * 1000;
773 if (!socket
->m_non_blocking
)
776 FD_SET(socket
->m_fd
, &writefds
);
777 if (select(socket
->m_fd
+ 1, NULL
, &writefds
, NULL
, &tv
) == 0)
779 socket
->m_error
= GSOCK_TIMEDOUT
;
780 return GSOCK_TIMEDOUT
;
783 return GSOCK_NOERROR
;
786 int _GSocket_Recv_Stream(GSocket
*socket
, char *buffer
, int size
)
791 ret
= recv(socket
->m_fd
, buffer
, size
, 0);
797 int _GSocket_Recv_Dgram(GSocket
*socket
, char *buffer
, int size
)
799 struct sockaddr from
;
804 fromlen
= sizeof(from
);
807 ret
= recvfrom(socket
->m_fd
, buffer
, size
, 0, &from
, &fromlen
);
813 /* Translate a system address into a GSocket address */
816 socket
->m_peer
= GAddress_new();
819 socket
->m_error
= GSOCK_MEMERR
;
823 err
= _GAddress_translate_from(socket
->m_peer
, &from
, fromlen
);
824 if (err
!= GSOCK_NOERROR
)
826 GAddress_destroy(socket
->m_peer
);
827 socket
->m_peer
= NULL
;
828 socket
->m_error
= err
;
835 int _GSocket_Send_Stream(GSocket
*socket
, const char *buffer
, int size
)
841 ret
= send(socket
->m_fd
, buffer
, size
, 0);
847 int _GSocket_Send_Dgram(GSocket
*socket
, const char *buffer
, int size
)
849 struct sockaddr
*addr
;
853 if (!socket
->m_peer
) {
854 socket
->m_error
= GSOCK_INVADDR
;
858 err
= _GAddress_translate_to(socket
->m_peer
, &addr
, &len
);
859 if (err
!= GSOCK_NOERROR
) {
860 socket
->m_error
= err
;
865 ret
= sendto(socket
->m_fd
, buffer
, size
, 0, addr
, len
);
868 /* Frees memory allocated from _GAddress_translate_to */
874 void _GSocket_Detected_Read(GSocket
*socket
)
879 if (socket
->m_stream
)
881 ret
= recv(socket
->m_fd
, &c
, 1, MSG_PEEK
);
883 if (ret
< 0 && socket
->m_server
)
885 CALL_CALLBACK(socket
, GSOCK_CONNECTION
);
891 CALL_CALLBACK(socket
, GSOCK_INPUT
);
895 CALL_CALLBACK(socket
, GSOCK_LOST
);
900 void _GSocket_Detected_Write(GSocket
*socket
)
902 if (socket
->m_establishing
&& !socket
->m_server
)
906 socket
->m_establishing
= FALSE
;
909 getsockopt(socket
->m_fd
, SOL_SOCKET
, SO_ERROR
, (void*) &error
, &len
);
913 CALL_CALLBACK(socket
, GSOCK_LOST
);
917 CALL_CALLBACK(socket
, GSOCK_CONNECTION
);
918 /* We have to fire this event by hand because CONNECTION (for clients)
919 * and OUTPUT are internally the same and we just disabled CONNECTION
920 * events with the above macro.
922 CALL_CALLBACK(socket
, GSOCK_OUTPUT
);
927 CALL_CALLBACK(socket
, GSOCK_OUTPUT
);
932 * -------------------------------------------------------------------------
934 * -------------------------------------------------------------------------
937 /* CHECK_ADDRESS verifies that the current family is either GSOCK_NOFAMILY or
938 * GSOCK_*family*. In case it is GSOCK_NOFAMILY, it initializes address to be
939 * a GSOCK_*family*. In other cases, it returns GSOCK_INVADDR.
941 #define CHECK_ADDRESS(address, family, retval) \
943 if (address->m_family == GSOCK_NOFAMILY) \
944 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) {\
945 return address->m_error; \
947 if (address->m_family != GSOCK_##family) {\
948 address->m_error = GSOCK_INVADDR; \
953 GAddress
*GAddress_new()
957 address
= (GAddress
*)malloc(sizeof(GAddress
));
962 address
->m_family
= GSOCK_NOFAMILY
;
963 address
->m_addr
= NULL
;
969 GAddress
*GAddress_copy(GAddress
*address
)
973 assert(address
!= NULL
);
975 addr2
= (GAddress
*)malloc(sizeof(GAddress
));
980 memcpy(addr2
, address
, sizeof(GAddress
));
982 if (address
->m_addr
) {
983 addr2
->m_addr
= (struct sockaddr
*)malloc(addr2
->m_len
);
984 if (addr2
->m_addr
== NULL
) {
988 memcpy(addr2
->m_addr
, address
->m_addr
, addr2
->m_len
);
994 void GAddress_destroy(GAddress
*address
)
996 assert(address
!= NULL
);
1001 void GAddress_SetFamily(GAddress
*address
, GAddressType type
)
1003 assert(address
!= NULL
);
1005 address
->m_family
= type
;
1008 GAddressType
GAddress_GetFamily(GAddress
*address
)
1010 assert(address
!= NULL
);
1012 return address
->m_family
;
1015 GSocketError
_GAddress_translate_from(GAddress
*address
, struct sockaddr
*addr
, int len
){
1016 address
->m_realfamily
= addr
->sa_family
;
1017 switch (addr
->sa_family
) {
1019 address
->m_family
= GSOCK_INET
;
1022 address
->m_family
= GSOCK_UNIX
;
1026 address
->m_family
= GSOCK_INET6
;
1031 address
->m_error
= GSOCK_INVOP
;
1036 if (address
->m_addr
)
1037 free(address
->m_addr
);
1039 address
->m_len
= len
;
1040 address
->m_addr
= (struct sockaddr
*)malloc(len
);
1041 if (address
->m_addr
== NULL
) {
1042 address
->m_error
= GSOCK_MEMERR
;
1043 return GSOCK_MEMERR
;
1045 memcpy(address
->m_addr
, addr
, len
);
1047 return GSOCK_NOERROR
;
1050 GSocketError
_GAddress_translate_to(GAddress
*address
,
1051 struct sockaddr
**addr
, int *len
)
1053 if (!address
->m_addr
) {
1054 address
->m_error
= GSOCK_INVADDR
;
1055 return GSOCK_INVADDR
;
1058 *len
= address
->m_len
;
1059 *addr
= (struct sockaddr
*)malloc(address
->m_len
);
1060 if (*addr
== NULL
) {
1061 address
->m_error
= GSOCK_MEMERR
;
1062 return GSOCK_MEMERR
;
1065 memcpy(*addr
, address
->m_addr
, address
->m_len
);
1066 return GSOCK_NOERROR
;
1070 * -------------------------------------------------------------------------
1071 * Internet address family
1072 * -------------------------------------------------------------------------
1075 GSocketError
_GAddress_Init_INET(GAddress
*address
)
1077 address
->m_addr
= (struct sockaddr
*)malloc(sizeof(struct sockaddr_in
));
1078 if (address
->m_addr
== NULL
) {
1079 address
->m_error
= GSOCK_MEMERR
;
1080 return GSOCK_MEMERR
;
1083 address
->m_len
= sizeof(struct sockaddr_in
);
1085 address
->m_family
= GSOCK_INET
;
1086 address
->m_realfamily
= PF_INET
;
1087 ((struct sockaddr_in
*)address
->m_addr
)->sin_family
= AF_INET
;
1088 ((struct sockaddr_in
*)address
->m_addr
)->sin_addr
.s_addr
= INADDR_ANY
;
1090 return GSOCK_NOERROR
;
1093 GSocketError
GAddress_INET_SetHostName(GAddress
*address
, const char *hostname
)
1096 struct in_addr
*addr
;
1098 assert(address
!= NULL
);
1100 CHECK_ADDRESS(address
, INET
, GSOCK_INVADDR
);
1102 addr
= &(((struct sockaddr_in
*)address
->m_addr
)->sin_addr
);
1104 /* If it is a numeric host name, convert it now */
1105 #if defined(HAVE_INET_ATON)
1106 if (inet_aton(hostname
, addr
) == 0) {
1107 #elif defined(HAVE_INET_ADDR)
1108 /* Fix from Guillermo Rodriguez Garcia <guille@iies.es> */
1109 if ( (addr
->s_addr
= inet_addr(hostname
)) == -1 ) {
1111 /* Use gethostbyname by default */
1114 struct in_addr
*array_addr
;
1116 /* It is a real name, we solve it */
1117 if ((he
= gethostbyname(hostname
)) == NULL
) {
1118 address
->m_error
= GSOCK_NOHOST
;
1119 return GSOCK_NOHOST
;
1121 array_addr
= (struct in_addr
*) *(he
->h_addr_list
);
1122 addr
->s_addr
= array_addr
[0].s_addr
;
1124 return GSOCK_NOERROR
;
1127 GSocketError
GAddress_INET_SetHostAddress(GAddress
*address
,
1128 unsigned long hostaddr
)
1130 struct in_addr
*addr
;
1132 assert(address
!= NULL
);
1134 CHECK_ADDRESS(address
, INET
, GSOCK_INVADDR
);
1136 addr
= &(((struct sockaddr_in
*)address
->m_addr
)->sin_addr
);
1137 addr
->s_addr
= hostaddr
;
1139 return GSOCK_NOERROR
;
1142 GSocketError
GAddress_INET_SetPortName(GAddress
*address
, const char *port
,
1143 const char *protocol
)
1146 struct sockaddr_in
*addr
;
1148 assert(address
!= NULL
);
1149 CHECK_ADDRESS(address
, INET
, GSOCK_INVADDR
);
1152 address
->m_error
= GSOCK_INVPORT
;
1153 return GSOCK_INVPORT
;
1156 se
= getservbyname(port
, protocol
);
1158 if (isdigit(port
[0])) {
1161 port_int
= atoi(port
);
1162 addr
= (struct sockaddr_in
*)address
->m_addr
;
1163 addr
->sin_port
= htons(port_int
);
1164 return GSOCK_NOERROR
;
1167 address
->m_error
= GSOCK_INVPORT
;
1168 return GSOCK_INVPORT
;
1171 addr
= (struct sockaddr_in
*)address
->m_addr
;
1172 addr
->sin_port
= se
->s_port
;
1174 return GSOCK_NOERROR
;
1177 GSocketError
GAddress_INET_SetPort(GAddress
*address
, unsigned short port
)
1179 struct sockaddr_in
*addr
;
1181 assert(address
!= NULL
);
1182 CHECK_ADDRESS(address
, INET
, GSOCK_INVADDR
);
1184 addr
= (struct sockaddr_in
*)address
->m_addr
;
1185 addr
->sin_port
= htons(port
);
1187 return GSOCK_NOERROR
;
1190 GSocketError
GAddress_INET_GetHostName(GAddress
*address
, char *hostname
, size_t sbuf
)
1194 struct sockaddr_in
*addr
;
1196 assert(address
!= NULL
);
1197 CHECK_ADDRESS(address
, INET
, GSOCK_INVADDR
);
1199 addr
= (struct sockaddr_in
*)address
->m_addr
;
1200 addr_buf
= (char *)&(addr
->sin_addr
);
1202 he
= gethostbyaddr(addr_buf
, sizeof(addr
->sin_addr
), AF_INET
);
1204 address
->m_error
= GSOCK_NOHOST
;
1205 return GSOCK_NOHOST
;
1208 strncpy(hostname
, he
->h_name
, sbuf
);
1210 return GSOCK_NOERROR
;
1213 unsigned long GAddress_INET_GetHostAddress(GAddress
*address
)
1215 struct sockaddr_in
*addr
;
1217 assert(address
!= NULL
);
1218 CHECK_ADDRESS(address
, INET
, 0);
1220 addr
= (struct sockaddr_in
*)address
->m_addr
;
1222 return addr
->sin_addr
.s_addr
;
1225 unsigned short GAddress_INET_GetPort(GAddress
*address
)
1227 struct sockaddr_in
*addr
;
1229 assert(address
!= NULL
);
1230 CHECK_ADDRESS(address
, INET
, 0);
1232 addr
= (struct sockaddr_in
*)address
->m_addr
;
1233 return ntohs(addr
->sin_port
);
1237 * -------------------------------------------------------------------------
1238 * Unix address family
1239 * -------------------------------------------------------------------------
1242 GSocketError
_GAddress_Init_UNIX(GAddress
*address
)
1244 address
->m_addr
= (struct sockaddr
*)malloc(address
->m_len
);
1245 if (address
->m_addr
== NULL
) {
1246 address
->m_error
= GSOCK_MEMERR
;
1247 return GSOCK_MEMERR
;
1250 address
->m_len
= sizeof(struct sockaddr_un
);
1251 address
->m_family
= GSOCK_UNIX
;
1252 address
->m_realfamily
= PF_UNIX
;
1253 ((struct sockaddr_un
*)address
->m_addr
)->sun_family
= AF_UNIX
;
1254 ((struct sockaddr_un
*)address
->m_addr
)->sun_path
[0] = 0;
1259 GSocketError
GAddress_UNIX_SetPath(GAddress
*address
, const char *path
)
1261 struct sockaddr_un
*addr
;
1263 assert(address
!= NULL
);
1265 CHECK_ADDRESS(address
, UNIX
, GSOCK_INVADDR
);
1267 addr
= ((struct sockaddr_un
*)address
->m_addr
);
1268 memcpy(addr
->sun_path
, path
, strlen(path
));
1270 return GSOCK_NOERROR
;
1273 GSocketError
GAddress_UNIX_GetPath(GAddress
*address
, char *path
, size_t sbuf
)
1275 struct sockaddr_un
*addr
;
1277 assert(address
!= NULL
);
1278 CHECK_ADDRESS(address
, UNIX
, GSOCK_INVADDR
);
1280 addr
= (struct sockaddr_un
*)address
->m_addr
;
1282 strncpy(path
, addr
->sun_path
, sbuf
);
1284 return GSOCK_NOERROR
;