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