]> git.saurik.com Git - wxWidgets.git/blob - src/os2/gsocket.c
Committing in .
[wxWidgets.git] / src / os2 / gsocket.c
1 /* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket) for WX
3 * Name: gsocket.c
4 * Purpose: GSocket main Unix-style file
5 * CVSID: $Id$
6 * -------------------------------------------------------------------------
7 */
8
9 #include "wx/setup.h"
10 #ifndef __EMX__
11 /* I don't see, why this include is needed, but it seems to be necessary
12 sometimes. For EMX, including C++ headers into plain C source breaks
13 compilation, so don't do it there. */
14 #include "wx/defs.h"
15 #endif
16
17 #if wxUSE_SOCKETS
18
19 #define BSD_SELECT /* use Berkley Sockets select */
20
21 #include <assert.h>
22 #include <sys\types.h>
23 #ifdef __EMX__
24 #include <sys/time.h>
25 #include <netinet/in.h>
26 #include <arpa/inet.h>
27 #include <netdb.h>
28 #include <errno.h>
29 #define HAVE_INET_ADDR
30 #else
31 #include <utils.h>
32 #include <sys\time.h>
33 #include <in.h>
34 #include <netdb.h>
35 #include <nerrno.h>
36 #endif
37 #if defined(__VISAGECPP__) && __IBMCPP__ < 400
38 #include <socket.h>
39 #include <ioctl.h>
40 #include <select.h>
41 #else
42 #include <sys\socket.h>
43 #include <sys\ioctl.h>
44 #include <sys\select.h>
45 #ifdef __EMX__
46 #define soclose(a) close(a)
47 #else
48 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
49 int _System bsdselect(int,
50 struct fd_set *,
51 struct fd_set *,
52 struct fd_set *,
53 struct timeval *);
54 int _System soclose(int);
55 #endif
56 #endif
57
58 #include <string.h>
59 #include <stdio.h>
60 #include <stdlib.h>
61 #include <stddef.h>
62 #include <ctype.h>
63
64 #include <signal.h>
65
66 #include "wx/gsocket.h"
67 #include "wx/os2/gsockos2.h"
68
69 #ifndef SOCKLEN_T
70
71 #ifdef __GLIBC__
72 # if __GLIBC__ == 2
73 # define SOCKLEN_T socklen_t
74 # endif
75 #else
76 # define SOCKLEN_T int
77 #endif
78
79 #endif
80
81 /* Global initialisers */
82
83 int GSocket_Init()
84 {
85 return 1;
86 }
87
88 void GSocket_Cleanup()
89 {
90 }
91
92 /* Constructors / Destructors */
93
94 GSocket *GSocket_new()
95 {
96 int i;
97 GSocket *socket;
98
99 socket = (GSocket *)malloc(sizeof(GSocket));
100
101 if (socket == NULL)
102 return NULL;
103
104 socket->m_fd = -1;
105 for (i=0;i<GSOCK_MAX_EVENT;i++)
106 {
107 socket->m_cbacks[i] = NULL;
108 }
109 socket->m_detected = 0;
110 socket->m_local = NULL;
111 socket->m_peer = NULL;
112 socket->m_error = GSOCK_NOERROR;
113 socket->m_server = 0;
114 socket->m_stream = 1;
115 socket->m_gui_dependent = NULL;
116 socket->m_non_blocking = 0;
117 socket->m_timeout = 10*60*1000;
118 /* 10 minutes * 60 sec * 1000 millisec */
119 socket->m_establishing = 0;
120
121 return socket;
122 }
123
124 void GSocket_destroy(GSocket *socket)
125 {
126 assert(socket != NULL);
127
128 /* First, we check that the socket is really shutdowned */
129 if (socket->m_fd != -1)
130 GSocket_Shutdown(socket);
131
132 /* We destroy private addresses */
133 if (socket->m_local)
134 GAddress_destroy(socket->m_local);
135
136 if (socket->m_peer)
137 GAddress_destroy(socket->m_peer);
138
139 /* We destroy socket itself */
140 free(socket);
141 }
142
143 void GSocket_Shutdown(GSocket *socket)
144 {
145 int evt;
146
147 assert(socket != NULL);
148
149 /* If socket has been created, we shutdown it */
150 if (socket->m_fd != -1)
151 {
152 shutdown(socket->m_fd, 2);
153 soclose(socket->m_fd);
154 socket->m_fd = -1;
155 }
156
157 /* We also disable GUI callbacks */
158 for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
159 socket->m_cbacks[evt] = NULL;
160
161 socket->m_detected = 0;
162 (socket);
163 }
164
165 /* Address handling */
166
167 GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address)
168 {
169 assert(socket != NULL);
170
171 if ((socket->m_fd != -1 && !socket->m_server)) {
172 socket->m_error = GSOCK_INVSOCK;
173 return GSOCK_INVSOCK;
174 }
175
176 if (address == NULL || address->m_family == GSOCK_NOFAMILY) {
177 socket->m_error = GSOCK_INVADDR;
178 return GSOCK_INVADDR;
179 }
180
181 if (socket->m_local)
182 GAddress_destroy(socket->m_local);
183
184 socket->m_local = GAddress_copy(address);
185
186 return GSOCK_NOERROR;
187 }
188
189 GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address)
190 {
191 assert(socket != NULL);
192
193 if (address == NULL || address->m_family == GSOCK_NOFAMILY) {
194 socket->m_error = GSOCK_INVADDR;
195 return GSOCK_INVADDR;
196 }
197
198 if (socket->m_peer)
199 GAddress_destroy(socket->m_peer);
200
201 socket->m_peer = GAddress_copy(address);
202
203 return GSOCK_NOERROR;
204 }
205
206 GAddress *GSocket_GetLocal(GSocket *socket)
207 {
208 GAddress *address;
209 struct sockaddr addr;
210 SOCKLEN_T size;
211 GSocketError err;
212
213 assert(socket != NULL);
214
215 if (socket->m_local)
216 return GAddress_copy(socket->m_local);
217
218 if (socket->m_fd == -1) {
219 socket->m_error = GSOCK_INVSOCK;
220 return NULL;
221 }
222
223 size = sizeof(addr);
224
225 if (getsockname(socket->m_fd, &addr, &size) < 0) {
226 socket->m_error = GSOCK_IOERR;
227 return NULL;
228 }
229
230 address = GAddress_new();
231 if (address == NULL) {
232 socket->m_error = GSOCK_MEMERR;
233 return NULL;
234 }
235 socket->m_error = _GAddress_translate_from(address, &addr, size);
236 if (socket->m_error != GSOCK_NOERROR) {
237 GAddress_destroy(address);
238 return NULL;
239 }
240
241 return address;
242 }
243
244 GAddress *GSocket_GetPeer(GSocket *socket)
245 {
246 assert(socket != NULL);
247
248 if (socket->m_peer)
249 return GAddress_copy(socket->m_peer);
250
251 return NULL;
252 }
253
254 /* Server specific parts */
255
256 /* GSocket_SetServer:
257 * Sets up the socket as a server. It uses the "Local" field of GSocket.
258 * "Local" must be set by GSocket_SetLocal() before GSocket_SetServer()
259 * is called. Possible error codes are: GSOCK_INVSOCK if socket has not
260 * been initialized, GSOCK_INVADDR if the local address has not been
261 * defined and GSOCK_IOERR for other internal errors.
262 */
263 GSocketError GSocket_SetServer(GSocket *sck)
264 {
265 int type;
266 int arg = 1;
267
268 assert(sck != NULL);
269
270 if (sck->m_fd != -1) {
271 sck->m_error = GSOCK_INVSOCK;
272 return GSOCK_INVSOCK;
273 }
274
275 if (!sck->m_local) {
276 sck->m_error = GSOCK_INVADDR;
277 return GSOCK_INVADDR;
278 }
279
280 /* We always have a stream here */
281 sck->m_stream = 1;
282 sck->m_server = 1;
283
284 /* Create the socket */
285 sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_STREAM, 0);
286
287 if (sck->m_fd == -1) {
288 sck->m_error = GSOCK_IOERR;
289 return GSOCK_IOERR;
290 }
291
292 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(int));
293
294 /* Bind the socket to the LOCAL address */
295 if (bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) < 0) {
296 soclose(sck->m_fd);
297 sck->m_fd = -1;
298 sck->m_error = GSOCK_IOERR;
299 return GSOCK_IOERR;
300 }
301
302 /* Enable listening up to 5 connections */
303 if (listen(sck->m_fd, 5) < 0) {
304 soclose(sck->m_fd);
305 sck->m_fd = -1;
306 sck->m_error = GSOCK_IOERR;
307 return GSOCK_IOERR;
308 }
309
310 return GSOCK_NOERROR;
311 }
312
313 /* GSocket_WaitConnection:
314 * Waits for an incoming client connection.
315 */
316 GSocket *GSocket_WaitConnection(GSocket *socket)
317 {
318 GSocket *connection;
319 int arg = 1;
320
321 assert(socket != NULL);
322
323 /* Reenable CONNECTION events */
324 _GSocket_Enable(socket, GSOCK_CONNECTION);
325
326 /* If the socket has already been created, we exit immediately */
327 if (socket->m_fd == -1 || !socket->m_server)
328 {
329 socket->m_error = GSOCK_INVSOCK;
330 return NULL;
331 }
332
333 /* Create a GSocket object for the new connection */
334 connection = GSocket_new();
335 if (!connection)
336 {
337 connection->m_error = GSOCK_MEMERR;
338 return NULL;
339 }
340
341 /* Accept the incoming connection */
342 if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT)
343 {
344 GSocket_destroy(connection);
345 /* socket->m_error set by _GSocket_Input_Timeout */
346 return NULL;
347 }
348
349 connection->m_fd = accept(socket->m_fd, NULL, NULL);
350
351 if (connection->m_fd == -1)
352 {
353 if (errno == EWOULDBLOCK)
354 socket->m_error = GSOCK_WOULDBLOCK;
355 else
356 socket->m_error = GSOCK_IOERR;
357
358 GSocket_destroy(connection);
359 return NULL;
360 }
361
362 /* Initialize all fields */
363 connection->m_server = 0;
364 connection->m_stream = 1;
365 connection->m_oriented = 1;
366
367 ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(int));
368 return connection;
369 }
370
371 /* Non oriented connections */
372
373 GSocketError GSocket_SetNonOriented(GSocket *sck)
374 {
375 int arg = 1;
376
377 assert(sck != NULL);
378
379 if (sck->m_fd != -1) {
380 sck->m_error = GSOCK_INVSOCK;
381 return GSOCK_INVSOCK;
382 }
383
384 if (!sck->m_local) {
385 sck->m_error = GSOCK_INVADDR;
386 return GSOCK_INVADDR;
387 }
388
389 sck->m_stream = 0;
390 sck->m_server = 0;
391 sck->m_oriented = 0;
392
393 /* Create the socket */
394 sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0);
395
396 if (sck->m_fd < 0) {
397 sck->m_error = GSOCK_IOERR;
398 return GSOCK_IOERR;
399 }
400
401 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(int));
402
403 /* Bind it to the LOCAL address */
404 if (bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) < 0) {
405 soclose(sck->m_fd);
406 sck->m_fd = -1;
407 sck->m_error = GSOCK_IOERR;
408 return GSOCK_IOERR;
409 }
410
411 return GSOCK_NOERROR;
412 }
413
414 /* Client specific parts */
415
416 /* GSocket_Connect:
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.
424 */
425 GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream)
426 {
427 int type, err, ret;
428 int arg = 1;
429
430 assert(sck != NULL);
431
432 /* Enable CONNECTION events (needed for nonblocking connections) */
433 _GSocket_Enable(sck, GSOCK_CONNECTION);
434
435 if (sck->m_fd != -1)
436 {
437 sck->m_error = GSOCK_INVSOCK;
438 return GSOCK_INVSOCK;
439 }
440
441 if (!sck->m_peer)
442 {
443 sck->m_error = GSOCK_INVADDR;
444 return GSOCK_INVADDR;
445 }
446
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 = 1;
450 sck->m_server = 0;
451 sck->m_establishing = 0;
452
453 if (sck->m_stream)
454 type = SOCK_STREAM;
455 else
456 type = SOCK_DGRAM;
457
458 /* Create the socket */
459 sck->m_fd = socket(sck->m_peer->m_realfamily, type, 0);
460
461 if (sck->m_fd == -1) {
462 sck->m_error = GSOCK_IOERR;
463 return GSOCK_IOERR;
464 }
465
466 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(int));
467
468 /* Connect it to the PEER address */
469 ret = connect(sck->m_fd, sck->m_peer->m_addr, sck->m_peer->m_len);
470
471 if (ret == -1)
472 {
473 err = errno;
474
475 /* If connect failed with EINPROGRESS and the GSocket object
476 * is in blocking mode, we select() for the specified timeout
477 * checking for writability to see if the connection request
478 * completes.
479 */
480 if ((err == EINPROGRESS) && (!sck->m_non_blocking))
481 {
482 if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT)
483 {
484 soclose(sck->m_fd);
485 sck->m_fd = -1;
486 /* sck->m_error is set in _GSocket_Output_Timeout */
487 fprintf(stderr, "Blocking connect timeouts\n");
488 return GSOCK_TIMEDOUT;
489 }
490 else
491 {
492 fprintf(stderr, "Blocking connect OK\n");
493 return GSOCK_NOERROR;
494 }
495 }
496
497 /* If connect failed with EINPROGRESS and the GSocket object
498 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
499 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
500 * this way if the connection completes, a GSOCK_CONNECTION
501 * event will be generated, if enabled.
502 */
503 if ((err == EINPROGRESS) && (sck->m_non_blocking))
504 {
505 sck->m_error = GSOCK_WOULDBLOCK;
506 sck->m_establishing = 1;
507 fprintf(stderr, "Nonblocking connect in progress\n");
508
509 return GSOCK_WOULDBLOCK;
510 }
511
512 /* If connect failed with an error other than EINPROGRESS,
513 * then the call to GSocket_Connect has failed.
514 */
515 soclose(sck->m_fd);
516 sck->m_fd = -1;
517 sck->m_error = GSOCK_IOERR;
518
519 fprintf(stderr, "Connect failed (generic err)\n");
520 return GSOCK_IOERR;
521 }
522
523 fprintf(stderr, "Connect OK\n");
524 return GSOCK_NOERROR;
525 }
526
527 /* Generic IO */
528
529 /* Like recv(), send(), ... */
530 int GSocket_Read(GSocket *socket, char *buffer, int size)
531 {
532 int ret;
533
534 assert(socket != NULL);
535
536 /* Reenable INPUT events */
537 _GSocket_Enable(socket, GSOCK_INPUT);
538
539 if (socket->m_fd == -1 || socket->m_server)
540 {
541 socket->m_error = GSOCK_INVSOCK;
542 return -1;
543 }
544
545 if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT)
546 return -1;
547
548 if (socket->m_stream)
549 ret = _GSocket_Recv_Stream(socket, buffer, size);
550 else
551 ret = _GSocket_Recv_Dgram(socket, buffer, size);
552
553 if (ret == -1)
554 {
555 if (errno == EWOULDBLOCK)
556 socket->m_error = GSOCK_WOULDBLOCK;
557 else
558 socket->m_error = GSOCK_IOERR;
559 }
560
561 return ret;
562 }
563
564 int GSocket_Write(GSocket *socket, const char *buffer,
565 int size)
566 {
567 int ret;
568
569 assert(socket != NULL);
570
571 if (socket->m_fd == -1 || socket->m_server)
572 {
573 socket->m_error = GSOCK_INVSOCK;
574 return -1;
575 }
576
577 if (_GSocket_Output_Timeout(socket) == GSOCK_TIMEDOUT)
578 return -1;
579
580 if (socket->m_stream)
581 ret = _GSocket_Send_Stream(socket, buffer, size);
582 else
583 ret = _GSocket_Send_Dgram(socket, buffer, size);
584
585 if (ret == -1)
586 {
587 if (errno == EWOULDBLOCK)
588 socket->m_error = GSOCK_WOULDBLOCK;
589 else
590 socket->m_error = GSOCK_IOERR;
591
592 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
593 * in MSW). Once the first OUTPUT event is received, users can assume
594 * that the socket is writable until a read operation fails. Only then
595 * will further OUTPUT events be posted.
596 */
597 _GSocket_Enable(socket, GSOCK_OUTPUT);
598 }
599
600 return ret;
601 }
602
603 /* GSocket_Select:
604 * Polls the socket to determine its status. This function will
605 * check for the events specified in the 'flags' parameter, and
606 * it will return a mask indicating which operations can be
607 * performed. This function won't block, regardless of the
608 * mode (blocking|nonblocking) of the socket.
609 */
610 GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
611 {
612 assert(socket != NULL);
613
614 return (flags & socket->m_detected);
615 }
616
617 /* Flags */
618
619 /* GSocket_SetNonBlocking:
620 * Sets the socket to non-blocking mode. This is useful if
621 * we don't want to wait.
622 */
623 void GSocket_SetNonBlocking(GSocket *socket, int non_block)
624 {
625 assert(socket != NULL);
626
627 socket->m_non_blocking = non_block;
628 }
629
630 /* GSocket_SetTimeout:
631 * Sets the timeout for blocking calls. Time is
632 * expressed in milliseconds.
633 */
634 void GSocket_SetTimeout(GSocket *socket, unsigned long millisec)
635 {
636 assert(socket != NULL);
637
638 socket->m_timeout = millisec;
639 }
640
641 /* GSocket_GetError:
642 * Returns the last error occured for this socket.
643 */
644 GSocketError GSocket_GetError(GSocket *socket)
645 {
646 assert(socket != NULL);
647
648 return socket->m_error;
649 }
650
651 /* Callbacks */
652
653 /* Only one callback is possible for each event (INPUT, OUTPUT, CONNECTION
654 * and LOST). The callbacks are called in the following situations:
655 *
656 * INPUT: There is at least one byte in the input buffer
657 * OUTPUT: The system is sure that the next write call will not block
658 * CONNECTION: Two cases are possible:
659 * Client socket -> the connection is established
660 * Server socket -> a client requests a connection
661 * LOST: The connection is lost
662 *
663 * An event is generated only once and its state is reseted when the
664 * relative IO call is requested.
665 * For example: INPUT -> GSocket_Read()
666 * CONNECTION -> GSocket_Accept()
667 */
668
669 /* GSocket_SetCallback:
670 * Enables the callbacks specified by 'flags'. Note that 'flags'
671 * may be a combination of flags OR'ed toghether, so the same
672 * callback function can be made to accept different events.
673 * The callback function must have the following prototype:
674 *
675 * void function(GSocket *socket, GSocketEvent event, char *cdata)
676 */
677 void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags,
678 GSocketCallback callback, char *cdata)
679 {
680 int count;
681
682 assert(socket != NULL);
683
684 for (count = 0; count < GSOCK_MAX_EVENT; count++)
685 {
686 if ((flags & (1 << count)) != 0)
687 {
688 socket->m_cbacks[count] = callback;
689 socket->m_data[count] = cdata;
690 }
691 }
692 }
693
694 /* GSocket_UnsetCallback:
695 * Disables all callbacks specified by 'flags', which may be a
696 * combination of flags OR'ed toghether.
697 */
698 void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags)
699 {
700 int count;
701
702 assert(socket != NULL);
703
704 for (count = 0; count < GSOCK_MAX_EVENT; count++)
705 {
706 if ((flags & (1 << count)) != 0)
707 {
708 socket->m_cbacks[count] = NULL;
709 socket->m_data[count] = NULL;
710 }
711 }
712 }
713
714 #define CALL_CALLBACK(socket, event) { \
715 _GSocket_Disable(socket, event); \
716 if (socket->m_cbacks[event]) \
717 socket->m_cbacks[event](socket, event, socket->m_data[event]); \
718 }
719
720
721 void _GSocket_Enable(GSocket *socket, GSocketEvent event)
722 {
723 socket->m_detected &= ~(1 << event);
724 (socket, event);
725 }
726
727 void _GSocket_Disable(GSocket *socket, GSocketEvent event)
728 {
729 socket->m_detected |= (1 << event);
730 }
731
732 /* _GSocket_Input_Timeout:
733 * For blocking sockets, wait until data is available or
734 * until timeout ellapses.
735 */
736 GSocketError _GSocket_Input_Timeout(GSocket *socket)
737 {
738 struct timeval tv;
739 fd_set readfds;
740
741 tv.tv_sec = (socket->m_timeout / 1000);
742 tv.tv_usec = (socket->m_timeout % 1000) * 1000;
743
744 if (!socket->m_non_blocking)
745 {
746 FD_ZERO(&readfds);
747 FD_SET(socket->m_fd, &readfds);
748 if (select(socket->m_fd + 1, &readfds, NULL, NULL, &tv) == 0)
749 {
750 socket->m_error = GSOCK_TIMEDOUT;
751 return GSOCK_TIMEDOUT;
752 }
753 }
754 return GSOCK_NOERROR;
755 }
756
757 /* _GSocket_Output_Timeout:
758 * For blocking sockets, wait until data can be sent without
759 * blocking or until timeout ellapses.
760 */
761 GSocketError _GSocket_Output_Timeout(GSocket *socket)
762 {
763 struct timeval tv;
764 fd_set writefds;
765
766 tv.tv_sec = (socket->m_timeout / 1000);
767 tv.tv_usec = (socket->m_timeout % 1000) * 1000;
768
769 if (!socket->m_non_blocking)
770 {
771 FD_ZERO(&writefds);
772 FD_SET(socket->m_fd, &writefds);
773 if (select(socket->m_fd + 1, NULL, &writefds, NULL, &tv) == 0)
774 {
775 socket->m_error = GSOCK_TIMEDOUT;
776 return GSOCK_TIMEDOUT;
777 }
778 }
779 return GSOCK_NOERROR;
780 }
781
782 int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size)
783 {
784 int ret;
785
786 ret = recv(socket->m_fd, buffer, size, 0);
787
788 return ret;
789 }
790
791 int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size)
792 {
793 struct sockaddr from;
794 SOCKLEN_T fromlen;
795 int ret;
796 GSocketError err;
797
798 fromlen = sizeof(from);
799
800 ret = recvfrom(socket->m_fd, buffer, size, 0, &from, &fromlen);
801
802 if (ret == -1)
803 return -1;
804
805 /* Translate a system address into a GSocket address */
806 if (!socket->m_peer)
807 {
808 socket->m_peer = GAddress_new();
809 if (!socket->m_peer)
810 {
811 socket->m_error = GSOCK_MEMERR;
812 return -1;
813 }
814 }
815 err = _GAddress_translate_from(socket->m_peer, &from, fromlen);
816 if (err != GSOCK_NOERROR)
817 {
818 GAddress_destroy(socket->m_peer);
819 socket->m_peer = NULL;
820 socket->m_error = err;
821 return -1;
822 }
823
824 return ret;
825 }
826
827 int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size)
828 {
829 int ret;
830 GSocketError err;
831
832 ret = send(socket->m_fd, (char*)buffer, size, 0);
833
834 return ret;
835 }
836
837 int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size)
838 {
839 struct sockaddr *addr;
840 int len, ret;
841 GSocketError err;
842
843 if (!socket->m_peer) {
844 socket->m_error = GSOCK_INVADDR;
845 return -1;
846 }
847
848 err = _GAddress_translate_to(socket->m_peer, &addr, &len);
849 if (err != GSOCK_NOERROR) {
850 socket->m_error = err;
851 return -1;
852 }
853
854 ret = sendto(socket->m_fd, (char*)buffer, size, 0, addr, len);
855
856 /* Frees memory allocated from _GAddress_translate_to */
857 free(addr);
858
859 return ret;
860 }
861
862 void _GSocket_Detected_Read(GSocket *socket)
863 {
864 char c;
865 int ret;
866
867 if (socket->m_stream)
868 {
869 ret = recv(socket->m_fd, &c, 1, MSG_PEEK);
870
871 if (ret < 0 && socket->m_server)
872 {
873 CALL_CALLBACK(socket, GSOCK_CONNECTION);
874 return;
875 }
876
877 if (ret > 0)
878 {
879 CALL_CALLBACK(socket, GSOCK_INPUT);
880 }
881 else
882 {
883 CALL_CALLBACK(socket, GSOCK_LOST);
884 }
885 }
886 }
887
888 void _GSocket_Detected_Write(GSocket *socket)
889 {
890 if (socket->m_establishing && !socket->m_server)
891 {
892 int error, len;
893
894 socket->m_establishing = 0;
895
896 len = sizeof(error);
897 getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
898
899 if (error)
900 {
901 CALL_CALLBACK(socket, GSOCK_LOST);
902 }
903 else
904 {
905 CALL_CALLBACK(socket, GSOCK_CONNECTION);
906 /* We have to fire this event by hand because CONNECTION (for clients)
907 * and OUTPUT are internally the same and we just disabled CONNECTION
908 * events with the above macro.
909 */
910 CALL_CALLBACK(socket, GSOCK_OUTPUT);
911 }
912 }
913 else
914 {
915 CALL_CALLBACK(socket, GSOCK_OUTPUT);
916 }
917 }
918
919 /*
920 * -------------------------------------------------------------------------
921 * GAddress
922 * -------------------------------------------------------------------------
923 */
924
925 /* CHECK_ADDRESS verifies that the current family is either GSOCK_NOFAMILY or
926 * GSOCK_*family*. In case it is GSOCK_NOFAMILY, it initializes address to be
927 * a GSOCK_*family*. In other cases, it returns GSOCK_INVADDR.
928 */
929 #define CHECK_ADDRESS(address, family, retval) \
930 { \
931 if (address->m_family == GSOCK_NOFAMILY) \
932 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) {\
933 return address->m_error; \
934 }\
935 if (address->m_family != GSOCK_##family) {\
936 address->m_error = GSOCK_INVADDR; \
937 return retval; \
938 } \
939 }
940
941 GAddress *GAddress_new()
942 {
943 GAddress *address;
944
945 address = (GAddress *)malloc(sizeof(GAddress));
946
947 if (address == NULL)
948 return NULL;
949
950 address->m_family = GSOCK_NOFAMILY;
951 address->m_addr = NULL;
952 address->m_len = 0;
953
954 return address;
955 }
956
957 GAddress *GAddress_copy(GAddress *address)
958 {
959 GAddress *addr2;
960
961 assert(address != NULL);
962
963 addr2 = (GAddress *)malloc(sizeof(GAddress));
964
965 if (addr2 == NULL)
966 return NULL;
967
968 memcpy(addr2, address, sizeof(GAddress));
969
970 if (address->m_addr) {
971 addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
972 if (addr2->m_addr == NULL) {
973 free(addr2);
974 return NULL;
975 }
976 memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
977 }
978
979 return addr2;
980 }
981
982 void GAddress_destroy(GAddress *address)
983 {
984 assert(address != NULL);
985
986 free(address);
987 }
988
989 void GAddress_SetFamily(GAddress *address, GAddressType type)
990 {
991 assert(address != NULL);
992
993 address->m_family = type;
994 }
995
996 GAddressType GAddress_GetFamily(GAddress *address)
997 {
998 assert(address != NULL);
999
1000 return address->m_family;
1001 }
1002
1003 GSocketError _GAddress_translate_from(GAddress *address, struct sockaddr *addr, int len){
1004 address->m_realfamily = addr->sa_family;
1005 switch (addr->sa_family) {
1006 case AF_INET:
1007 address->m_family = GSOCK_INET;
1008 break;
1009 case AF_UNIX:
1010 address->m_family = GSOCK_UNIX;
1011 break;
1012 #ifdef AF_INET6
1013 case AF_INET6:
1014 address->m_family = GSOCK_INET6;
1015 break;
1016 #endif
1017 default:
1018 {
1019 address->m_error = GSOCK_INVOP;
1020 return GSOCK_INVOP;
1021 }
1022 }
1023
1024 if (address->m_addr)
1025 free(address->m_addr);
1026
1027 address->m_len = len;
1028 address->m_addr = (struct sockaddr *)malloc(len);
1029 if (address->m_addr == NULL) {
1030 address->m_error = GSOCK_MEMERR;
1031 return GSOCK_MEMERR;
1032 }
1033 memcpy(address->m_addr, addr, len);
1034
1035 return GSOCK_NOERROR;
1036 }
1037
1038 GSocketError _GAddress_translate_to(GAddress *address,
1039 struct sockaddr **addr, int *len)
1040 {
1041 if (!address->m_addr) {
1042 address->m_error = GSOCK_INVADDR;
1043 return GSOCK_INVADDR;
1044 }
1045
1046 *len = address->m_len;
1047 *addr = (struct sockaddr *)malloc(address->m_len);
1048 if (*addr == NULL) {
1049 address->m_error = GSOCK_MEMERR;
1050 return GSOCK_MEMERR;
1051 }
1052
1053 memcpy(*addr, address->m_addr, address->m_len);
1054 return GSOCK_NOERROR;
1055 }
1056
1057 /*
1058 * -------------------------------------------------------------------------
1059 * Internet address family
1060 * -------------------------------------------------------------------------
1061 */
1062
1063 GSocketError _GAddress_Init_INET(GAddress *address)
1064 {
1065 address->m_addr = (struct sockaddr *)malloc(sizeof(struct sockaddr_in));
1066 if (address->m_addr == NULL) {
1067 address->m_error = GSOCK_MEMERR;
1068 return GSOCK_MEMERR;
1069 }
1070
1071 address->m_len = sizeof(struct sockaddr_in);
1072
1073 address->m_family = GSOCK_INET;
1074 address->m_realfamily = PF_INET;
1075 ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1076 ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1077
1078 return GSOCK_NOERROR;
1079 }
1080
1081 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1082 {
1083 struct hostent *he;
1084 struct in_addr *addr;
1085
1086 assert(address != NULL);
1087
1088 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1089
1090 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1091
1092 /* If it is a numeric host name, convert it now */
1093 #if defined(HAVE_INET_ATON)
1094 if (inet_aton(hostname, addr) == 0) {
1095 #elif defined(HAVE_INET_ADDR)
1096 /* Fix from Guillermo Rodriguez Garcia <guille@iies.es> */
1097 if ( (addr->s_addr = inet_addr(hostname)) == -1 ) {
1098 #endif
1099 struct in_addr *array_addr;
1100
1101 /* It is a real name, we solve it */
1102 he = gethostbyname((char*)hostname);
1103 if (he == NULL) {
1104 address->m_error = GSOCK_NOHOST;
1105 return GSOCK_NOHOST;
1106 }
1107 array_addr = (struct in_addr *) *(he->h_addr_list);
1108 addr->s_addr = array_addr[0].s_addr;
1109 #if defined(HAVE_INET_ATON)
1110 }
1111 #elif defined(HAVE_INET_ADDR)
1112 }
1113 #endif
1114 return GSOCK_NOERROR;
1115 }
1116
1117 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1118 {
1119 return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1120 }
1121
1122 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1123 unsigned long hostaddr)
1124 {
1125 struct in_addr *addr;
1126
1127 assert(address != NULL);
1128
1129 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1130
1131 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1132 addr->s_addr = hostaddr;
1133
1134 return GSOCK_NOERROR;
1135 }
1136
1137 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1138 const char *protocol)
1139 {
1140 struct servent *se;
1141 struct sockaddr_in *addr;
1142
1143 assert(address != NULL);
1144 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1145
1146 if (!port) {
1147 address->m_error = GSOCK_INVPORT;
1148 return GSOCK_INVPORT;
1149 }
1150
1151 se = getservbyname((char*)port, (char*)protocol);
1152 if (!se) {
1153 if (isdigit(port[0])) {
1154 int port_int;
1155
1156 port_int = atoi(port);
1157 addr = (struct sockaddr_in *)address->m_addr;
1158 addr->sin_port = htons(port_int);
1159 return GSOCK_NOERROR;
1160 }
1161
1162 address->m_error = GSOCK_INVPORT;
1163 return GSOCK_INVPORT;
1164 }
1165
1166 addr = (struct sockaddr_in *)address->m_addr;
1167 addr->sin_port = se->s_port;
1168
1169 return GSOCK_NOERROR;
1170 }
1171
1172 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1173 {
1174 struct sockaddr_in *addr;
1175
1176 assert(address != NULL);
1177 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1178
1179 addr = (struct sockaddr_in *)address->m_addr;
1180 addr->sin_port = htons(port);
1181
1182 return GSOCK_NOERROR;
1183 }
1184
1185 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1186 {
1187 struct hostent *he;
1188 char *addr_buf;
1189 struct sockaddr_in *addr;
1190
1191 assert(address != NULL);
1192 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1193
1194 addr = (struct sockaddr_in *)address->m_addr;
1195 addr_buf = (char *)&(addr->sin_addr);
1196
1197 he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1198 if (he == NULL) {
1199 address->m_error = GSOCK_NOHOST;
1200 return GSOCK_NOHOST;
1201 }
1202
1203 strncpy(hostname, he->h_name, sbuf);
1204
1205 return GSOCK_NOERROR;
1206 }
1207
1208 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1209 {
1210 struct sockaddr_in *addr;
1211
1212 assert(address != NULL);
1213 CHECK_ADDRESS(address, INET, 0);
1214
1215 addr = (struct sockaddr_in *)address->m_addr;
1216
1217 return addr->sin_addr.s_addr;
1218 }
1219
1220 unsigned short GAddress_INET_GetPort(GAddress *address)
1221 {
1222 struct sockaddr_in *addr;
1223
1224 assert(address != NULL);
1225 CHECK_ADDRESS(address, INET, 0);
1226
1227 addr = (struct sockaddr_in *)address->m_addr;
1228 return ntohs(addr->sin_port);
1229 }
1230
1231 /*
1232 * -------------------------------------------------------------------------
1233 * Unix address family
1234 * -------------------------------------------------------------------------
1235 */
1236
1237 GSocketError _GAddress_Init_UNIX(GAddress *address)
1238 {
1239 assert (address != NULL);
1240 address->m_error = GSOCK_INVADDR;
1241 return GSOCK_INVADDR;
1242 }
1243
1244 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1245 {
1246 assert (address != NULL);
1247 address->m_error = GSOCK_INVADDR;
1248 return GSOCK_INVADDR;
1249 }
1250
1251 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1252 {
1253 assert (address != NULL);
1254 address->m_error = GSOCK_INVADDR;
1255 return GSOCK_INVADDR;
1256 }
1257
1258 #endif
1259 /* wxUSE_SOCKETS */