]> git.saurik.com Git - wxWidgets.git/blob - src/unix/gsocket.c
projects / wxWidgets.git / blob
? search:


bc68887a40b925aaaeb2e78800ba625b780ca28b
[wxWidgets.git] / src / unix / gsocket.c
1 /* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket) for WX
3 * Name: gsocket.c
4 * Authors: Guilhem Lavaux,
5 * Guillermo Rodriguez Garcia <guille@iies.es> (maintainer)
6 * Purpose: GSocket main Unix and OS/2 file
7 * Licence: The wxWidgets licence
8 * CVSID: $Id$
9 * -------------------------------------------------------------------------
10 */
11
12 /*
13 * PLEASE don't put C++ comments here - this is a C source file.
14 */
15
16 #ifndef __GSOCKET_STANDALONE__
17 #include "wx/setup.h"
18 #endif
19
20 #if defined(__VISAGECPP__)
21 /* Seems to be needed by Visual Age C++, though I don't see how it manages
22 to not break on including a C++ header into a plain C source file */
23 #include "wx/defs.h"
24 #define BSD_SELECT /* use Berkley Sockets select */
25 #endif
26
27 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
28
29 #include <assert.h>
30 #include <sys/types.h>
31 #ifdef __VISAGECPP__
32 #include <string.h>
33 #include <sys/time.h>
34 #include <types.h>
35 #include <netinet/in.h>
36 #endif
37 #include <netdb.h>
38 #include <sys/ioctl.h>
39
40 #ifdef __VMS__
41 #include <socket.h>
42 struct sockaddr_un
43 {
44 u_char sun_len; /* sockaddr len including null */
45 u_char sun_family; /* AF_UNIX */
46 char sun_path[108]; /* path name (gag) */
47 };
48 #else
49 #include <sys/socket.h>
50 #include <sys/un.h>
51 #endif
52
53 #ifndef __VISAGECPP__
54 #include <sys/time.h>
55 #include <netinet/in.h>
56 #include <arpa/inet.h>
57 #include <errno.h>
58 #include <string.h>
59 #include <unistd.h>
60 #else
61 #include <nerrno.h>
62 # if __IBMCPP__ < 400
63 #include <machine/endian.h>
64 #include <socket.h>
65 #include <ioctl.h>
66 #include <select.h>
67 #include <unistd.h>
68
69 #define EBADF SOCEBADF
70
71 # ifdef min
72 # undef min
73 # endif
74 # else
75 #include <sys/socket.h>
76 #include <sys/ioctl.h>
77 #include <sys/select.h>
78
79 #define close(a) soclose(a)
80 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
81 int _System bsdselect(int,
82 struct fd_set *,
83 struct fd_set *,
84 struct fd_set *,
85 struct timeval *);
86 int _System soclose(int);
87 # endif
88 #endif
89 #include <stdio.h>
90 #include <stdlib.h>
91 #include <stddef.h>
92 #include <ctype.h>
93 #ifdef sun
94 # include <sys/filio.h>
95 #endif
96 #ifdef sgi
97 # include <bstring.h>
98 #endif
99 #include <signal.h>
100
101 #ifndef SOCKLEN_T
102
103 #ifdef VMS
104 # define SOCKLEN_T unsigned int
105 #else
106 # ifdef __GLIBC__
107 # if __GLIBC__ == 2
108 # define SOCKLEN_T socklen_t
109 # endif
110 # else
111 # define SOCKLEN_T int
112 # endif
113 #endif
114
115 #endif /* SOCKLEN_T */
116
117 /*
118 * MSW defines this, Unices don't.
119 */
120 #ifndef INVALID_SOCKET
121 #define INVALID_SOCKET -1
122 #endif
123
124 /* UnixWare reportedly needs this for FIONBIO definition */
125 #ifdef __UNIXWARE__
126 #include <sys/filio.h>
127 #endif
128
129 /*
130 * INADDR_BROADCAST is identical to INADDR_NONE which is not defined
131 * on all systems. INADDR_BROADCAST should be fine to indicate an error.
132 */
133 #ifndef INADDR_NONE
134 #define INADDR_NONE INADDR_BROADCAST
135 #endif
136
137 #define MASK_SIGNAL() \
138 { \
139 void (*old_handler)(int); \
140 \
141 old_handler = signal(SIGPIPE, SIG_IGN);
142
143 #define UNMASK_SIGNAL() \
144 signal(SIGPIPE, old_handler); \
145 }
146
147
148 #ifndef __GSOCKET_STANDALONE__
149 # include "wx/unix/gsockunx.h"
150 # include "wx/gsocket.h"
151 #else
152 # include "gsockunx.h"
153 # include "gsocket.h"
154 #endif /* __GSOCKET_STANDALONE__ */
155
156 /* debugging helpers */
157 #ifdef __GSOCKET_DEBUG__
158 # define GSocket_Debug(args) printf args
159 #else
160 # define GSocket_Debug(args)
161 #endif /* __GSOCKET_DEBUG__ */
162
163 /* Table of GUI-related functions. We must call them indirectly because
164 * of wxBase and GUI separation: */
165
166 static struct GSocketGUIFunctionsTable *gs_gui_functions;
167
168 #define USE_GUI() (gs_gui_functions != NULL)
169
170 /* Define macros to simplify indirection: */
171 #define _GSocket_GUI_Init() \
172 if (gs_gui_functions) gs_gui_functions->GUI_Init()
173 #define _GSocket_GUI_Cleanup() \
174 if (gs_gui_functions) gs_gui_functions->GUI_Cleanup()
175 #define _GSocket_GUI_Init_Socket(socket) \
176 (gs_gui_functions ? gs_gui_functions->GUI_Init_Socket(socket) : 1)
177 #define _GSocket_GUI_Destroy_Socket(socket) \
178 if (gs_gui_functions) gs_gui_functions->GUI_Destroy_Socket(socket)
179 #define _GSocket_Enable_Events(socket) \
180 if (gs_gui_functions) gs_gui_functions->Enable_Events(socket)
181 #define _GSocket_Disable_Events(socket) \
182 if (gs_gui_functions) gs_gui_functions->Disable_Events(socket)
183 #define _GSocket_Install_Callback(socket, event) \
184 if (gs_gui_functions) gs_gui_functions->Install_Callback(socket, event)
185 #define _GSocket_Uninstall_Callback(socket, event) \
186 if (gs_gui_functions) gs_gui_functions->Uninstall_Callback(socket, event)
187
188 static struct GSocketBaseFunctionsTable gs_base_functions =
189 {
190 _GSocket_Detected_Read,
191 _GSocket_Detected_Write
192 };
193
194 /* Global initialisers */
195
196 void GSocket_SetGUIFunctions(struct GSocketGUIFunctionsTable *guifunc)
197 {
198 gs_gui_functions = guifunc;
199 }
200
201 int GSocket_Init(void)
202 {
203 if (gs_gui_functions)
204 {
205 if ( !gs_gui_functions->GUI_Init() )
206 return 0;
207 }
208 return 1;
209 }
210
211 void GSocket_Cleanup(void)
212 {
213 if (gs_gui_functions)
214 {
215 gs_gui_functions->GUI_Cleanup();
216 }
217 }
218
219 /* Constructors / Destructors for GSocket */
220
221 GSocket *GSocket_new(void)
222 {
223 int i, success;
224 GSocket *socket;
225
226 socket = (GSocket *)malloc(sizeof(GSocket));
227
228 if (socket == NULL)
229 return NULL;
230
231 socket->m_fd = INVALID_SOCKET;
232 for (i=0;i<GSOCK_MAX_EVENT;i++)
233 {
234 socket->m_cbacks[i] = NULL;
235 }
236 socket->m_detected = 0;
237 socket->m_local = NULL;
238 socket->m_peer = NULL;
239 socket->m_error = GSOCK_NOERROR;
240 socket->m_server = FALSE;
241 socket->m_stream = TRUE;
242 socket->m_gui_dependent = NULL;
243 socket->m_non_blocking = FALSE;
244 socket->m_timeout = 10*60*1000;
245 /* 10 minutes * 60 sec * 1000 millisec */
246 socket->m_establishing = FALSE;
247
248 socket->m_functions = &gs_base_functions;
249
250 /* Per-socket GUI-specific initialization */
251 success = _GSocket_GUI_Init_Socket(socket);
252 if (!success)
253 {
254 free(socket);
255 return NULL;
256 }
257
258 return socket;
259 }
260
261 void GSocket_close(GSocket *socket)
262 {
263 _GSocket_Disable_Events(socket);
264 /* gsockosx.c calls CFSocketInvalidate which closes the socket for us */
265 #if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)))
266 close(socket->m_fd);
267 #endif
268 socket->m_fd = INVALID_SOCKET;
269 }
270
271 void GSocket_destroy(GSocket *socket)
272 {
273 assert(socket != NULL);
274
275 /* Check that the socket is really shutdowned */
276 if (socket->m_fd != INVALID_SOCKET)
277 GSocket_Shutdown(socket);
278
279 /* Per-socket GUI-specific cleanup */
280 _GSocket_GUI_Destroy_Socket(socket);
281
282 /* Destroy private addresses */
283 if (socket->m_local)
284 GAddress_destroy(socket->m_local);
285
286 if (socket->m_peer)
287 GAddress_destroy(socket->m_peer);
288
289 /* Destroy the socket itself */
290 free(socket);
291 }
292
293 /* GSocket_Shutdown:
294 * Disallow further read/write operations on this socket, close
295 * the fd and disable all callbacks.
296 */
297 void GSocket_Shutdown(GSocket *socket)
298 {
299 int evt;
300
301 assert(socket != NULL);
302
303 /* If socket has been created, shutdown it */
304 if (socket->m_fd != INVALID_SOCKET)
305 {
306 shutdown(socket->m_fd, 2);
307 GSocket_close(socket);
308 }
309
310 /* Disable GUI callbacks */
311 for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
312 socket->m_cbacks[evt] = NULL;
313
314 socket->m_detected = GSOCK_LOST_FLAG;
315 }
316
317 /* Address handling */
318
319 /* GSocket_SetLocal:
320 * GSocket_GetLocal:
321 * GSocket_SetPeer:
322 * GSocket_GetPeer:
323 * Set or get the local or peer address for this socket. The 'set'
324 * functions return GSOCK_NOERROR on success, an error code otherwise.
325 * The 'get' functions return a pointer to a GAddress object on success,
326 * or NULL otherwise, in which case they set the error code of the
327 * corresponding GSocket.
328 *
329 * Error codes:
330 * GSOCK_INVSOCK - the socket is not valid.
331 * GSOCK_INVADDR - the address is not valid.
332 */
333 GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address)
334 {
335 assert(socket != NULL);
336
337 /* the socket must be initialized, or it must be a server */
338 if ((socket->m_fd != INVALID_SOCKET && !socket->m_server))
339 {
340 socket->m_error = GSOCK_INVSOCK;
341 return GSOCK_INVSOCK;
342 }
343
344 /* check address */
345 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
346 {
347 socket->m_error = GSOCK_INVADDR;
348 return GSOCK_INVADDR;
349 }
350
351 if (socket->m_local)
352 GAddress_destroy(socket->m_local);
353
354 socket->m_local = GAddress_copy(address);
355
356 return GSOCK_NOERROR;
357 }
358
359 GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address)
360 {
361 assert(socket != NULL);
362
363 /* check address */
364 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
365 {
366 socket->m_error = GSOCK_INVADDR;
367 return GSOCK_INVADDR;
368 }
369
370 if (socket->m_peer)
371 GAddress_destroy(socket->m_peer);
372
373 socket->m_peer = GAddress_copy(address);
374
375 return GSOCK_NOERROR;
376 }
377
378 GAddress *GSocket_GetLocal(GSocket *socket)
379 {
380 GAddress *address;
381 struct sockaddr addr;
382 SOCKLEN_T size = sizeof(addr);
383 GSocketError err;
384
385 assert(socket != NULL);
386
387 /* try to get it from the m_local var first */
388 if (socket->m_local)
389 return GAddress_copy(socket->m_local);
390
391 /* else, if the socket is initialized, try getsockname */
392 if (socket->m_fd == INVALID_SOCKET)
393 {
394 socket->m_error = GSOCK_INVSOCK;
395 return NULL;
396 }
397
398 if (getsockname(socket->m_fd, &addr, (SOCKLEN_T *) &size) < 0)
399 {
400 socket->m_error = GSOCK_IOERR;
401 return NULL;
402 }
403
404 /* got a valid address from getsockname, create a GAddress object */
405 address = GAddress_new();
406 if (address == NULL)
407 {
408 socket->m_error = GSOCK_MEMERR;
409 return NULL;
410 }
411
412 err = _GAddress_translate_from(address, &addr, size);
413 if (err != GSOCK_NOERROR)
414 {
415 GAddress_destroy(address);
416 socket->m_error = err;
417 return NULL;
418 }
419
420 return address;
421 }
422
423 GAddress *GSocket_GetPeer(GSocket *socket)
424 {
425 assert(socket != NULL);
426
427 /* try to get it from the m_peer var */
428 if (socket->m_peer)
429 return GAddress_copy(socket->m_peer);
430
431 return NULL;
432 }
433
434 /* Server specific parts */
435
436 /* GSocket_SetServer:
437 * Sets up this socket as a server. The local address must have been
438 * set with GSocket_SetLocal() before GSocket_SetServer() is called.
439 * Returns GSOCK_NOERROR on success, one of the following otherwise:
440 *
441 * Error codes:
442 * GSOCK_INVSOCK - the socket is in use.
443 * GSOCK_INVADDR - the local address has not been set.
444 * GSOCK_IOERR - low-level error.
445 */
446 GSocketError GSocket_SetServer(GSocket *sck)
447 {
448 int arg = 1;
449
450 assert(sck != NULL);
451
452 /* must not be in use */
453 if (sck->m_fd != INVALID_SOCKET)
454 {
455 sck->m_error = GSOCK_INVSOCK;
456 return GSOCK_INVSOCK;
457 }
458
459 /* the local addr must have been set */
460 if (!sck->m_local)
461 {
462 sck->m_error = GSOCK_INVADDR;
463 return GSOCK_INVADDR;
464 }
465
466 /* Initialize all fields */
467 sck->m_stream = TRUE;
468 sck->m_server = TRUE;
469 sck->m_oriented = TRUE;
470
471 /* Create the socket */
472 sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_STREAM, 0);
473
474 if (sck->m_fd == INVALID_SOCKET)
475 {
476 sck->m_error = GSOCK_IOERR;
477 return GSOCK_IOERR;
478 }
479 #if defined(__EMX__) || defined(__VISAGECPP__)
480 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
481 #else
482 ioctl(sck->m_fd, FIONBIO, &arg);
483 #endif
484 _GSocket_Enable_Events(sck);
485
486 /* allow a socket to re-bind if the socket is in the TIME_WAIT
487 state after being previously closed.
488 */
489 setsockopt(sck->m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
490
491 /* Bind to the local address,
492 * retrieve the actual address bound,
493 * and listen up to 5 connections.
494 */
495 if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
496 (getsockname(sck->m_fd,
497 sck->m_local->m_addr,
498 (SOCKLEN_T *) &sck->m_local->m_len) != 0) ||
499 (listen(sck->m_fd, 5) != 0))
500 {
501 GSocket_close(sck);
502 sck->m_error = GSOCK_IOERR;
503 return GSOCK_IOERR;
504 }
505
506 return GSOCK_NOERROR;
507 }
508
509 /* GSocket_WaitConnection:
510 * Waits for an incoming client connection. Returns a pointer to
511 * a GSocket object, or NULL if there was an error, in which case
512 * the last error field will be updated for the calling GSocket.
513 *
514 * Error codes (set in the calling GSocket)
515 * GSOCK_INVSOCK - the socket is not valid or not a server.
516 * GSOCK_TIMEDOUT - timeout, no incoming connections.
517 * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
518 * GSOCK_MEMERR - couldn't allocate memory.
519 * GSOCK_IOERR - low-level error.
520 */
521 GSocket *GSocket_WaitConnection(GSocket *socket)
522 {
523 struct sockaddr from;
524 SOCKLEN_T fromlen = sizeof(from);
525 GSocket *connection;
526 GSocketError err;
527 int arg = 1;
528
529 assert(socket != NULL);
530
531 /* Reenable CONNECTION events */
532 _GSocket_Enable(socket, GSOCK_CONNECTION);
533
534 /* If the socket has already been created, we exit immediately */
535 if (socket->m_fd == INVALID_SOCKET || !socket->m_server)
536 {
537 socket->m_error = GSOCK_INVSOCK;
538 return NULL;
539 }
540
541 /* Create a GSocket object for the new connection */
542 connection = GSocket_new();
543
544 if (!connection)
545 {
546 socket->m_error = GSOCK_MEMERR;
547 return NULL;
548 }
549
550 /* Wait for a connection (with timeout) */
551 if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT)
552 {
553 GSocket_destroy(connection);
554 /* socket->m_error set by _GSocket_Input_Timeout */
555 return NULL;
556 }
557
558 connection->m_fd = accept(socket->m_fd, &from, (SOCKLEN_T *) &fromlen);
559
560 if (connection->m_fd == INVALID_SOCKET)
561 {
562 if (errno == EWOULDBLOCK)
563 socket->m_error = GSOCK_WOULDBLOCK;
564 else
565 socket->m_error = GSOCK_IOERR;
566
567 GSocket_destroy(connection);
568 return NULL;
569 }
570
571 /* Initialize all fields */
572 connection->m_server = FALSE;
573 connection->m_stream = TRUE;
574 connection->m_oriented = TRUE;
575
576 /* Setup the peer address field */
577 connection->m_peer = GAddress_new();
578 if (!connection->m_peer)
579 {
580 GSocket_destroy(connection);
581 socket->m_error = GSOCK_MEMERR;
582 return NULL;
583 }
584 err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
585 if (err != GSOCK_NOERROR)
586 {
587 GAddress_destroy(connection->m_peer);
588 GSocket_destroy(connection);
589 socket->m_error = err;
590 return NULL;
591 }
592 #if defined(__EMX__) || defined(__VISAGECPP__)
593 ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
594 #else
595 ioctl(connection->m_fd, FIONBIO, &arg);
596 #endif
597 _GSocket_Enable_Events(connection);
598
599 return connection;
600 }
601
602 /* Client specific parts */
603
604 /* GSocket_Connect:
605 * For stream (connection oriented) sockets, GSocket_Connect() tries
606 * to establish a client connection to a server using the peer address
607 * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
608 * connection has been succesfully established, or one of the error
609 * codes listed below. Note that for nonblocking sockets, a return
610 * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
611 * request can be completed later; you should use GSocket_Select()
612 * to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
613 * corresponding asynchronous events.
614 *
615 * For datagram (non connection oriented) sockets, GSocket_Connect()
616 * just sets the peer address established with GSocket_SetPeer() as
617 * default destination.
618 *
619 * Error codes:
620 * GSOCK_INVSOCK - the socket is in use or not valid.
621 * GSOCK_INVADDR - the peer address has not been established.
622 * GSOCK_TIMEDOUT - timeout, the connection failed.
623 * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
624 * GSOCK_MEMERR - couldn't allocate memory.
625 * GSOCK_IOERR - low-level error.
626 */
627 GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream)
628 {
629 int err, ret;
630 int arg = 1;
631
632 assert(sck != NULL);
633
634 /* Enable CONNECTION events (needed for nonblocking connections) */
635 _GSocket_Enable(sck, GSOCK_CONNECTION);
636
637 if (sck->m_fd != INVALID_SOCKET)
638 {
639 sck->m_error = GSOCK_INVSOCK;
640 return GSOCK_INVSOCK;
641 }
642
643 if (!sck->m_peer)
644 {
645 sck->m_error = GSOCK_INVADDR;
646 return GSOCK_INVADDR;
647 }
648
649 /* Streamed or dgram socket? */
650 sck->m_stream = (stream == GSOCK_STREAMED);
651 sck->m_oriented = TRUE;
652 sck->m_server = FALSE;
653 sck->m_establishing = FALSE;
654
655 /* Create the socket */
656 sck->m_fd = socket(sck->m_peer->m_realfamily,
657 sck->m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
658
659 if (sck->m_fd == INVALID_SOCKET)
660 {
661 sck->m_error = GSOCK_IOERR;
662 return GSOCK_IOERR;
663 }
664 #if defined(__EMX__) || defined(__VISAGECPP__)
665 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
666 #else
667 ioctl(sck->m_fd, FIONBIO, &arg);
668 #endif
669 _GSocket_Enable_Events(sck);
670
671 /* Connect it to the peer address, with a timeout (see below) */
672 ret = connect(sck->m_fd, sck->m_peer->m_addr, sck->m_peer->m_len);
673
674 if (ret == -1)
675 {
676 err = errno;
677
678 /* If connect failed with EINPROGRESS and the GSocket object
679 * is in blocking mode, we select() for the specified timeout
680 * checking for writability to see if the connection request
681 * completes.
682 */
683 if ((err == EINPROGRESS) && (!sck->m_non_blocking))
684 {
685 if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT)
686 {
687 GSocket_close(sck);
688 /* sck->m_error is set in _GSocket_Output_Timeout */
689 return GSOCK_TIMEDOUT;
690 }
691 else
692 {
693 int error;
694 SOCKLEN_T len = sizeof(error);
695
696 getsockopt(sck->m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len);
697
698 if (!error)
699 return GSOCK_NOERROR;
700 }
701 }
702
703 /* If connect failed with EINPROGRESS and the GSocket object
704 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
705 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
706 * this way if the connection completes, a GSOCK_CONNECTION
707 * event will be generated, if enabled.
708 */
709 if ((err == EINPROGRESS) && (sck->m_non_blocking))
710 {
711 sck->m_establishing = TRUE;
712 sck->m_error = GSOCK_WOULDBLOCK;
713 return GSOCK_WOULDBLOCK;
714 }
715
716 /* If connect failed with an error other than EINPROGRESS,
717 * then the call to GSocket_Connect has failed.
718 */
719 GSocket_close(sck);
720 sck->m_error = GSOCK_IOERR;
721 return GSOCK_IOERR;
722 }
723
724 return GSOCK_NOERROR;
725 }
726
727 /* Datagram sockets */
728
729 /* GSocket_SetNonOriented:
730 * Sets up this socket as a non-connection oriented (datagram) socket.
731 * Before using this function, the local address must have been set
732 * with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
733 * on success, or one of the following otherwise.
734 *
735 * Error codes:
736 * GSOCK_INVSOCK - the socket is in use.
737 * GSOCK_INVADDR - the local address has not been set.
738 * GSOCK_IOERR - low-level error.
739 */
740 GSocketError GSocket_SetNonOriented(GSocket *sck)
741 {
742 int arg = 1;
743
744 assert(sck != NULL);
745
746 if (sck->m_fd != INVALID_SOCKET)
747 {
748 sck->m_error = GSOCK_INVSOCK;
749 return GSOCK_INVSOCK;
750 }
751
752 if (!sck->m_local)
753 {
754 sck->m_error = GSOCK_INVADDR;
755 return GSOCK_INVADDR;
756 }
757
758 /* Initialize all fields */
759 sck->m_stream = FALSE;
760 sck->m_server = FALSE;
761 sck->m_oriented = FALSE;
762
763 /* Create the socket */
764 sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0);
765
766 if (sck->m_fd == INVALID_SOCKET)
767 {
768 sck->m_error = GSOCK_IOERR;
769 return GSOCK_IOERR;
770 }
771 #if defined(__EMX__) || defined(__VISAGECPP__)
772 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
773 #else
774 ioctl(sck->m_fd, FIONBIO, &arg);
775 #endif
776 _GSocket_Enable_Events(sck);
777
778 /* Bind to the local address,
779 * and retrieve the actual address bound.
780 */
781 if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
782 (getsockname(sck->m_fd,
783 sck->m_local->m_addr,
784 (SOCKLEN_T *) &sck->m_local->m_len) != 0))
785 {
786 GSocket_close(sck);
787 sck->m_error = GSOCK_IOERR;
788 return GSOCK_IOERR;
789 }
790
791 return GSOCK_NOERROR;
792 }
793
794 /* Generic IO */
795
796 /* Like recv(), send(), ... */
797 int GSocket_Read(GSocket *socket, char *buffer, int size)
798 {
799 int ret;
800
801 assert(socket != NULL);
802
803 if (socket->m_fd == INVALID_SOCKET || socket->m_server)
804 {
805 socket->m_error = GSOCK_INVSOCK;
806 return -1;
807 }
808
809 /* Disable events during query of socket status */
810 _GSocket_Disable(socket, GSOCK_INPUT);
811
812 /* If the socket is blocking, wait for data (with a timeout) */
813 if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT)
814 /* We no longer return here immediately, otherwise socket events would not be re-enabled! */
815 ret = -1;
816 else {
817 /* Read the data */
818 if (socket->m_stream)
819 ret = _GSocket_Recv_Stream(socket, buffer, size);
820 else
821 ret = _GSocket_Recv_Dgram(socket, buffer, size);
822 }
823
824 if (ret == -1)
825 {
826 if (errno == EWOULDBLOCK)
827 socket->m_error = GSOCK_WOULDBLOCK;
828 else
829 socket->m_error = GSOCK_IOERR;
830 }
831
832 /* Enable events again now that we are done processing */
833 _GSocket_Enable(socket, GSOCK_INPUT);
834
835 return ret;
836 }
837
838 int GSocket_Write(GSocket *socket, const char *buffer, int size)
839 {
840 int ret;
841
842 assert(socket != NULL);
843
844 GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
845
846 if (socket->m_fd == INVALID_SOCKET || socket->m_server)
847 {
848 socket->m_error = GSOCK_INVSOCK;
849 return -1;
850 }
851
852 GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
853
854 /* If the socket is blocking, wait for writability (with a timeout) */
855 if (_GSocket_Output_Timeout(socket) == GSOCK_TIMEDOUT)
856 return -1;
857
858 GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
859
860 /* Write the data */
861 if (socket->m_stream)
862 ret = _GSocket_Send_Stream(socket, buffer, size);
863 else
864 ret = _GSocket_Send_Dgram(socket, buffer, size);
865
866 GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
867
868 if (ret == -1)
869 {
870 if (errno == EWOULDBLOCK)
871 {
872 socket->m_error = GSOCK_WOULDBLOCK;
873 GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
874 }
875 else
876 {
877 socket->m_error = GSOCK_IOERR;
878 GSocket_Debug(( "GSocket_Write error IOERR\n" ));
879 }
880
881 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
882 * in MSW). Once the first OUTPUT event is received, users can assume
883 * that the socket is writable until a read operation fails. Only then
884 * will further OUTPUT events be posted.
885 */
886 _GSocket_Enable(socket, GSOCK_OUTPUT);
887 return -1;
888 }
889
890 GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
891
892 return ret;
893 }
894
895 /* GSocket_Select:
896 * Polls the socket to determine its status. This function will
897 * check for the events specified in the 'flags' parameter, and
898 * it will return a mask indicating which operations can be
899 * performed. This function won't block, regardless of the
900 * mode (blocking | nonblocking) of the socket.
901 */
902 GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
903 {
904 if (!USE_GUI())
905 {
906
907 GSocketEventFlags result = 0;
908 fd_set readfds;
909 fd_set writefds;
910 fd_set exceptfds;
911 struct timeval tv;
912
913 assert(socket != NULL);
914
915 /* Do not use a static struct, Linux can garble it */
916 tv.tv_sec = socket->m_timeout / 1000;
917 tv.tv_usec = (socket->m_timeout % 1000) / 1000;
918
919 FD_ZERO(&readfds);
920 FD_ZERO(&writefds);
921 FD_ZERO(&exceptfds);
922 FD_SET(socket->m_fd, &readfds);
923 if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
924 FD_SET(socket->m_fd, &writefds);
925 FD_SET(socket->m_fd, &exceptfds);
926
927 /* Check 'sticky' CONNECTION flag first */
928 result |= (GSOCK_CONNECTION_FLAG & socket->m_detected);
929
930 /* If we have already detected a LOST event, then don't try
931 * to do any further processing.
932 */
933 if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
934 {
935 socket->m_establishing = FALSE;
936
937 return (GSOCK_LOST_FLAG & flags);
938 }
939
940 /* Try select now */
941 if (select(socket->m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
942 {
943 /* What to do here? */
944 return (result & flags);
945 }
946
947 /* Check for readability */
948 if (FD_ISSET(socket->m_fd, &readfds))
949 {
950 char c;
951
952 if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0)
953 {
954 result |= GSOCK_INPUT_FLAG;
955 }
956 else
957 {
958 if (socket->m_server && socket->m_stream)
959 {
960 result |= GSOCK_CONNECTION_FLAG;
961 socket->m_detected |= GSOCK_CONNECTION_FLAG;
962 }
963 else
964 {
965 socket->m_detected = GSOCK_LOST_FLAG;
966 socket->m_establishing = FALSE;
967
968 /* LOST event: Abort any further processing */
969 return (GSOCK_LOST_FLAG & flags);
970 }
971 }
972 }
973
974 /* Check for writability */
975 if (FD_ISSET(socket->m_fd, &writefds))
976 {
977 if (socket->m_establishing && !socket->m_server)
978 {
979 int error;
980 SOCKLEN_T len = sizeof(error);
981
982 socket->m_establishing = FALSE;
983
984 getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
985
986 if (error)
987 {
988 socket->m_detected = GSOCK_LOST_FLAG;
989
990 /* LOST event: Abort any further processing */
991 return (GSOCK_LOST_FLAG & flags);
992 }
993 else
994 {
995 result |= GSOCK_CONNECTION_FLAG;
996 socket->m_detected |= GSOCK_CONNECTION_FLAG;
997 }
998 }
999 else
1000 {
1001 result |= GSOCK_OUTPUT_FLAG;
1002 }
1003 }
1004
1005 /* Check for exceptions and errors (is this useful in Unices?) */
1006 if (FD_ISSET(socket->m_fd, &exceptfds))
1007 {
1008 socket->m_establishing = FALSE;
1009 socket->m_detected = GSOCK_LOST_FLAG;
1010
1011 /* LOST event: Abort any further processing */
1012 return (GSOCK_LOST_FLAG & flags);
1013 }
1014
1015 return (result & flags);
1016
1017 }
1018 else
1019 {
1020
1021 assert(socket != NULL);
1022 return flags & socket->m_detected;
1023
1024 }
1025 }
1026
1027 /* Flags */
1028
1029 /* GSocket_SetNonBlocking:
1030 * Sets the socket to non-blocking mode. All IO calls will return
1031 * immediately.
1032 */
1033 void GSocket_SetNonBlocking(GSocket *socket, int non_block)
1034 {
1035 assert(socket != NULL);
1036
1037 GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1038
1039 socket->m_non_blocking = non_block;
1040 }
1041
1042 /* GSocket_SetTimeout:
1043 * Sets the timeout for blocking calls. Time is expressed in
1044 * milliseconds.
1045 */
1046 void GSocket_SetTimeout(GSocket *socket, unsigned long millisec)
1047 {
1048 assert(socket != NULL);
1049
1050 socket->m_timeout = millisec;
1051 }
1052
1053 /* GSocket_GetError:
1054 * Returns the last error occured for this socket. Note that successful
1055 * operations do not clear this back to GSOCK_NOERROR, so use it only
1056 * after an error.
1057 */
1058 GSocketError GSocket_GetError(GSocket *socket)
1059 {
1060 assert(socket != NULL);
1061
1062 return socket->m_error;
1063 }
1064
1065 /* Callbacks */
1066
1067 /* GSOCK_INPUT:
1068 * There is data to be read in the input buffer. If, after a read
1069 * operation, there is still data available, the callback function will
1070 * be called again.
1071 * GSOCK_OUTPUT:
1072 * The socket is available for writing. That is, the next write call
1073 * won't block. This event is generated only once, when the connection is
1074 * first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1075 * when the output buffer empties again. This means that the app should
1076 * assume that it can write since the first OUTPUT event, and no more
1077 * OUTPUT events will be generated unless an error occurs.
1078 * GSOCK_CONNECTION:
1079 * Connection succesfully established, for client sockets, or incoming
1080 * client connection, for server sockets. Wait for this event (also watch
1081 * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1082 * GSOCK_LOST:
1083 * The connection is lost (or a connection request failed); this could
1084 * be due to a failure, or due to the peer closing it gracefully.
1085 */
1086
1087 /* GSocket_SetCallback:
1088 * Enables the callbacks specified by 'flags'. Note that 'flags'
1089 * may be a combination of flags OR'ed toghether, so the same
1090 * callback function can be made to accept different events.
1091 * The callback function must have the following prototype:
1092 *
1093 * void function(GSocket *socket, GSocketEvent event, char *cdata)
1094 */
1095 void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags,
1096 GSocketCallback callback, char *cdata)
1097 {
1098 int count;
1099
1100 assert(socket != NULL);
1101
1102 for (count = 0; count < GSOCK_MAX_EVENT; count++)
1103 {
1104 if ((flags & (1 << count)) != 0)
1105 {
1106 socket->m_cbacks[count] = callback;
1107 socket->m_data[count] = cdata;
1108 }
1109 }
1110 }
1111
1112 /* GSocket_UnsetCallback:
1113 * Disables all callbacks specified by 'flags', which may be a
1114 * combination of flags OR'ed toghether.
1115 */
1116 void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags)
1117 {
1118 int count;
1119
1120 assert(socket != NULL);
1121
1122 for (count = 0; count < GSOCK_MAX_EVENT; count++)
1123 {
1124 if ((flags & (1 << count)) != 0)
1125 {
1126 socket->m_cbacks[count] = NULL;
1127 socket->m_data[count] = NULL;
1128 }
1129 }
1130 }
1131
1132 GSocketError GSocket_GetSockOpt(GSocket *socket, int level, int optname,
1133 void *optval, int *optlen)
1134 {
1135 if (getsockopt(socket->m_fd, level, optname, optval, optlen) == 0)
1136 {
1137 return GSOCK_NOERROR;
1138 }
1139 return GSOCK_OPTERR;
1140 }
1141
1142 GSocketError GSocket_SetSockOpt(GSocket *socket, int level, int optname,
1143 const void *optval, int optlen)
1144 {
1145 if (setsockopt(socket->m_fd, level, optname, optval, optlen) == 0)
1146 {
1147 return GSOCK_NOERROR;
1148 }
1149 return GSOCK_OPTERR;
1150 }
1151
1152 void GSocket_Streamed(GSocket *socket)
1153 {
1154 socket->m_stream = TRUE;
1155 }
1156
1157 void GSocket_Unstreamed(GSocket *socket)
1158 {
1159 socket->m_stream = FALSE;
1160 }
1161
1162 #define CALL_CALLBACK(socket, event) { \
1163 _GSocket_Disable(socket, event); \
1164 if (socket->m_cbacks[event]) \
1165 socket->m_cbacks[event](socket, event, socket->m_data[event]); \
1166 }
1167
1168
1169 void _GSocket_Enable(GSocket *socket, GSocketEvent event)
1170 {
1171 socket->m_detected &= ~(1 << event);
1172 _GSocket_Install_Callback(socket, event);
1173 }
1174
1175 void _GSocket_Disable(GSocket *socket, GSocketEvent event)
1176 {
1177 socket->m_detected |= (1 << event);
1178 _GSocket_Uninstall_Callback(socket, event);
1179 }
1180
1181 /* _GSocket_Input_Timeout:
1182 * For blocking sockets, wait until data is available or
1183 * until timeout ellapses.
1184 */
1185 GSocketError _GSocket_Input_Timeout(GSocket *socket)
1186 {
1187 struct timeval tv;
1188 fd_set readfds;
1189 int ret;
1190
1191 /* Linux select() will overwrite the struct on return */
1192 tv.tv_sec = (socket->m_timeout / 1000);
1193 tv.tv_usec = (socket->m_timeout % 1000) * 1000;
1194
1195 if (!socket->m_non_blocking)
1196 {
1197 FD_ZERO(&readfds);
1198 FD_SET(socket->m_fd, &readfds);
1199 ret = select(socket->m_fd + 1, &readfds, NULL, NULL, &tv);
1200 if (ret == 0)
1201 {
1202 GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1203 socket->m_error = GSOCK_TIMEDOUT;
1204 return GSOCK_TIMEDOUT;
1205 }
1206 if (ret == -1)
1207 {
1208 GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1209 if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1210 if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1211 if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1212 if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1213 socket->m_error = GSOCK_TIMEDOUT;
1214 return GSOCK_TIMEDOUT;
1215 }
1216 }
1217 return GSOCK_NOERROR;
1218 }
1219
1220 /* _GSocket_Output_Timeout:
1221 * For blocking sockets, wait until data can be sent without
1222 * blocking or until timeout ellapses.
1223 */
1224 GSocketError _GSocket_Output_Timeout(GSocket *socket)
1225 {
1226 struct timeval tv;
1227 fd_set writefds;
1228 int ret;
1229
1230 /* Linux select() will overwrite the struct on return */
1231 tv.tv_sec = (socket->m_timeout / 1000);
1232 tv.tv_usec = (socket->m_timeout % 1000) * 1000;
1233
1234 GSocket_Debug( ("m_non_blocking has: %d\n", (int)socket->m_non_blocking) );
1235
1236 if (!socket->m_non_blocking)
1237 {
1238 FD_ZERO(&writefds);
1239 FD_SET(socket->m_fd, &writefds);
1240 ret = select(socket->m_fd + 1, NULL, &writefds, NULL, &tv);
1241 if (ret == 0)
1242 {
1243 GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1244 socket->m_error = GSOCK_TIMEDOUT;
1245 return GSOCK_TIMEDOUT;
1246 }
1247 if (ret == -1)
1248 {
1249 GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1250 if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1251 if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1252 if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1253 if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1254 socket->m_error = GSOCK_TIMEDOUT;
1255 return GSOCK_TIMEDOUT;
1256 }
1257 if ( ! FD_ISSET(socket->m_fd, &writefds) ) {
1258 GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1259 }
1260 else {
1261 GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1262 }
1263 }
1264 else
1265 {
1266 GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1267 }
1268
1269 return GSOCK_NOERROR;
1270 }
1271
1272 int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size)
1273 {
1274 return recv(socket->m_fd, buffer, size, 0);
1275 }
1276
1277 int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size)
1278 {
1279 struct sockaddr from;
1280 SOCKLEN_T fromlen = sizeof(from);
1281 int ret;
1282 GSocketError err;
1283
1284 fromlen = sizeof(from);
1285
1286 ret = recvfrom(socket->m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen);
1287
1288 if (ret == -1)
1289 return -1;
1290
1291 /* Translate a system address into a GSocket address */
1292 if (!socket->m_peer)
1293 {
1294 socket->m_peer = GAddress_new();
1295 if (!socket->m_peer)
1296 {
1297 socket->m_error = GSOCK_MEMERR;
1298 return -1;
1299 }
1300 }
1301 err = _GAddress_translate_from(socket->m_peer, &from, fromlen);
1302 if (err != GSOCK_NOERROR)
1303 {
1304 GAddress_destroy(socket->m_peer);
1305 socket->m_peer = NULL;
1306 socket->m_error = err;
1307 return -1;
1308 }
1309
1310 return ret;
1311 }
1312
1313 int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size)
1314 {
1315 int ret;
1316
1317 #ifndef __VISAGECPP__
1318 MASK_SIGNAL();
1319 ret = send(socket->m_fd, buffer, size, 0);
1320 UNMASK_SIGNAL();
1321 #else
1322 ret = send(socket->m_fd, (char *)buffer, size, 0);
1323 #endif
1324
1325 return ret;
1326 }
1327
1328 int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size)
1329 {
1330 struct sockaddr *addr;
1331 int len, ret;
1332 GSocketError err;
1333
1334 if (!socket->m_peer)
1335 {
1336 socket->m_error = GSOCK_INVADDR;
1337 return -1;
1338 }
1339
1340 err = _GAddress_translate_to(socket->m_peer, &addr, &len);
1341 if (err != GSOCK_NOERROR)
1342 {
1343 socket->m_error = err;
1344 return -1;
1345 }
1346
1347 #ifndef __VISAGECPP__
1348 MASK_SIGNAL();
1349 ret = sendto(socket->m_fd, buffer, size, 0, addr, len);
1350 UNMASK_SIGNAL();
1351 #else
1352 ret = sendto(socket->m_fd, (char *)buffer, size, 0, addr, len);
1353 #endif
1354
1355 /* Frees memory allocated from _GAddress_translate_to */
1356 free(addr);
1357
1358 return ret;
1359 }
1360
1361 void _GSocket_Detected_Read(GSocket *socket)
1362 {
1363 char c;
1364
1365 /* If we have already detected a LOST event, then don't try
1366 * to do any further processing.
1367 */
1368 if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
1369 {
1370 socket->m_establishing = FALSE;
1371
1372 CALL_CALLBACK(socket, GSOCK_LOST);
1373 GSocket_Shutdown(socket);
1374 return;
1375 }
1376
1377 if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0)
1378 {
1379 CALL_CALLBACK(socket, GSOCK_INPUT);
1380 }
1381 else
1382 {
1383 if (socket->m_server && socket->m_stream)
1384 {
1385 CALL_CALLBACK(socket, GSOCK_CONNECTION);
1386 }
1387 else
1388 {
1389 CALL_CALLBACK(socket, GSOCK_LOST);
1390 GSocket_Shutdown(socket);
1391 }
1392 }
1393 }
1394
1395 void _GSocket_Detected_Write(GSocket *socket)
1396 {
1397 /* If we have already detected a LOST event, then don't try
1398 * to do any further processing.
1399 */
1400 if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
1401 {
1402 socket->m_establishing = FALSE;
1403
1404 CALL_CALLBACK(socket, GSOCK_LOST);
1405 GSocket_Shutdown(socket);
1406 return;
1407 }
1408
1409 if (socket->m_establishing && !socket->m_server)
1410 {
1411 int error;
1412 SOCKLEN_T len = sizeof(error);
1413
1414 socket->m_establishing = FALSE;
1415
1416 getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
1417
1418 if (error)
1419 {
1420 CALL_CALLBACK(socket, GSOCK_LOST);
1421 GSocket_Shutdown(socket);
1422 }
1423 else
1424 {
1425 CALL_CALLBACK(socket, GSOCK_CONNECTION);
1426 /* We have to fire this event by hand because CONNECTION (for clients)
1427 * and OUTPUT are internally the same and we just disabled CONNECTION
1428 * events with the above macro.
1429 */
1430 CALL_CALLBACK(socket, GSOCK_OUTPUT);
1431 }
1432 }
1433 else
1434 {
1435 CALL_CALLBACK(socket, GSOCK_OUTPUT);
1436 }
1437 }
1438
1439 /*
1440 * -------------------------------------------------------------------------
1441 * GAddress
1442 * -------------------------------------------------------------------------
1443 */
1444
1445 /* CHECK_ADDRESS verifies that the current address family is either
1446 * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1447 * initalizes it to be a GSOCK_*family*. In other cases, it returns
1448 * an appropiate error code.
1449 *
1450 * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1451 */
1452 #define CHECK_ADDRESS(address, family) \
1453 { \
1454 if (address->m_family == GSOCK_NOFAMILY) \
1455 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1456 return address->m_error; \
1457 if (address->m_family != GSOCK_##family) \
1458 { \
1459 address->m_error = GSOCK_INVADDR; \
1460 return GSOCK_INVADDR; \
1461 } \
1462 }
1463
1464 #define CHECK_ADDRESS_RETVAL(address, family, retval) \
1465 { \
1466 if (address->m_family == GSOCK_NOFAMILY) \
1467 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1468 return retval; \
1469 if (address->m_family != GSOCK_##family) \
1470 { \
1471 address->m_error = GSOCK_INVADDR; \
1472 return retval; \
1473 } \
1474 }
1475
1476
1477 GAddress *GAddress_new(void)
1478 {
1479 GAddress *address;
1480
1481 if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1482 return NULL;
1483
1484 address->m_family = GSOCK_NOFAMILY;
1485 address->m_addr = NULL;
1486 address->m_len = 0;
1487
1488 return address;
1489 }
1490
1491 GAddress *GAddress_copy(GAddress *address)
1492 {
1493 GAddress *addr2;
1494
1495 assert(address != NULL);
1496
1497 if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1498 return NULL;
1499
1500 memcpy(addr2, address, sizeof(GAddress));
1501
1502 if (address->m_addr && address->m_len > 0)
1503 {
1504 addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1505 if (addr2->m_addr == NULL)
1506 {
1507 free(addr2);
1508 return NULL;
1509 }
1510 memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1511 }
1512
1513 return addr2;
1514 }
1515
1516 void GAddress_destroy(GAddress *address)
1517 {
1518 assert(address != NULL);
1519
1520 if (address->m_addr)
1521 free(address->m_addr);
1522
1523 free(address);
1524 }
1525
1526 void GAddress_SetFamily(GAddress *address, GAddressType type)
1527 {
1528 assert(address != NULL);
1529
1530 address->m_family = type;
1531 }
1532
1533 GAddressType GAddress_GetFamily(GAddress *address)
1534 {
1535 assert(address != NULL);
1536
1537 return address->m_family;
1538 }
1539
1540 GSocketError _GAddress_translate_from(GAddress *address,
1541 struct sockaddr *addr, int len)
1542 {
1543 address->m_realfamily = addr->sa_family;
1544 switch (addr->sa_family)
1545 {
1546 case AF_INET:
1547 address->m_family = GSOCK_INET;
1548 break;
1549 case AF_UNIX:
1550 address->m_family = GSOCK_UNIX;
1551 break;
1552 #ifdef AF_INET6
1553 case AF_INET6:
1554 address->m_family = GSOCK_INET6;
1555 break;
1556 #endif
1557 default:
1558 {
1559 address->m_error = GSOCK_INVOP;
1560 return GSOCK_INVOP;
1561 }
1562 }
1563
1564 if (address->m_addr)
1565 free(address->m_addr);
1566
1567 address->m_len = len;
1568 address->m_addr = (struct sockaddr *)malloc(len);
1569
1570 if (address->m_addr == NULL)
1571 {
1572 address->m_error = GSOCK_MEMERR;
1573 return GSOCK_MEMERR;
1574 }
1575 memcpy(address->m_addr, addr, len);
1576
1577 return GSOCK_NOERROR;
1578 }
1579
1580 GSocketError _GAddress_translate_to(GAddress *address,
1581 struct sockaddr **addr, int *len)
1582 {
1583 if (!address->m_addr)
1584 {
1585 address->m_error = GSOCK_INVADDR;
1586 return GSOCK_INVADDR;
1587 }
1588
1589 *len = address->m_len;
1590 *addr = (struct sockaddr *)malloc(address->m_len);
1591 if (*addr == NULL)
1592 {
1593 address->m_error = GSOCK_MEMERR;
1594 return GSOCK_MEMERR;
1595 }
1596
1597 memcpy(*addr, address->m_addr, address->m_len);
1598 return GSOCK_NOERROR;
1599 }
1600
1601 /*
1602 * -------------------------------------------------------------------------
1603 * Internet address family
1604 * -------------------------------------------------------------------------
1605 */
1606
1607 GSocketError _GAddress_Init_INET(GAddress *address)
1608 {
1609 address->m_len = sizeof(struct sockaddr_in);
1610 address->m_addr = (struct sockaddr *) malloc(address->m_len);
1611 if (address->m_addr == NULL)
1612 {
1613 address->m_error = GSOCK_MEMERR;
1614 return GSOCK_MEMERR;
1615 }
1616
1617 address->m_family = GSOCK_INET;
1618 address->m_realfamily = PF_INET;
1619 ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1620 ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1621
1622 return GSOCK_NOERROR;
1623 }
1624
1625 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1626 {
1627 struct hostent *he;
1628 struct in_addr *addr;
1629
1630 assert(address != NULL);
1631
1632 CHECK_ADDRESS(address, INET);
1633
1634 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1635
1636 /* If it is a numeric host name, convert it now */
1637 #if defined(HAVE_INET_ATON)
1638 if (inet_aton(hostname, addr) == 0)
1639 {
1640 #elif defined(HAVE_INET_ADDR)
1641 if ( (addr->s_addr = inet_addr(hostname)) == -1 )
1642 {
1643 #else
1644 /* Use gethostbyname by default */
1645 #ifndef __WXMAC__
1646 int val = 1; /* VA doesn't like constants in conditional expressions */
1647 if (val)
1648 #endif
1649 {
1650 #endif
1651 struct in_addr *array_addr;
1652
1653 /* It is a real name, we solve it */
1654 if ((he = gethostbyname(hostname)) == NULL)
1655 {
1656 /* Reset to invalid address */
1657 addr->s_addr = INADDR_NONE;
1658 address->m_error = GSOCK_NOHOST;
1659 return GSOCK_NOHOST;
1660 }
1661 array_addr = (struct in_addr *) *(he->h_addr_list);
1662 addr->s_addr = array_addr[0].s_addr;
1663 }
1664 return GSOCK_NOERROR;
1665 }
1666
1667 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1668 {
1669 return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1670 }
1671
1672 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1673 unsigned long hostaddr)
1674 {
1675 struct in_addr *addr;
1676
1677 assert(address != NULL);
1678
1679 CHECK_ADDRESS(address, INET);
1680
1681 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1682 addr->s_addr = htonl(hostaddr);
1683
1684 return GSOCK_NOERROR;
1685 }
1686
1687 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1688 const char *protocol)
1689 {
1690 struct servent *se;
1691 struct sockaddr_in *addr;
1692
1693 assert(address != NULL);
1694 CHECK_ADDRESS(address, INET);
1695
1696 if (!port)
1697 {
1698 address->m_error = GSOCK_INVPORT;
1699 return GSOCK_INVPORT;
1700 }
1701
1702 se = getservbyname(port, protocol);
1703 if (!se)
1704 {
1705 /* the cast to int suppresses compiler warnings about subscript having the
1706 type char */
1707 if (isdigit((int)port[0]))
1708 {
1709 int port_int;
1710
1711 port_int = atoi(port);
1712 addr = (struct sockaddr_in *)address->m_addr;
1713 addr->sin_port = htons(port_int);
1714 return GSOCK_NOERROR;
1715 }
1716
1717 address->m_error = GSOCK_INVPORT;
1718 return GSOCK_INVPORT;
1719 }
1720
1721 addr = (struct sockaddr_in *)address->m_addr;
1722 addr->sin_port = se->s_port;
1723
1724 return GSOCK_NOERROR;
1725 }
1726
1727 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1728 {
1729 struct sockaddr_in *addr;
1730
1731 assert(address != NULL);
1732 CHECK_ADDRESS(address, INET);
1733
1734 addr = (struct sockaddr_in *)address->m_addr;
1735 addr->sin_port = htons(port);
1736
1737 return GSOCK_NOERROR;
1738 }
1739
1740 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1741 {
1742 struct hostent *he;
1743 char *addr_buf;
1744 struct sockaddr_in *addr;
1745
1746 assert(address != NULL);
1747 CHECK_ADDRESS(address, INET);
1748
1749 addr = (struct sockaddr_in *)address->m_addr;
1750 addr_buf = (char *)&(addr->sin_addr);
1751
1752 he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1753 if (he == NULL)
1754 {
1755 address->m_error = GSOCK_NOHOST;
1756 return GSOCK_NOHOST;
1757 }
1758
1759 strncpy(hostname, he->h_name, sbuf);
1760
1761 return GSOCK_NOERROR;
1762 }
1763
1764 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1765 {
1766 struct sockaddr_in *addr;
1767
1768 assert(address != NULL);
1769 CHECK_ADDRESS_RETVAL(address, INET, 0);
1770
1771 addr = (struct sockaddr_in *)address->m_addr;
1772
1773 return ntohl(addr->sin_addr.s_addr);
1774 }
1775
1776 unsigned short GAddress_INET_GetPort(GAddress *address)
1777 {
1778 struct sockaddr_in *addr;
1779
1780 assert(address != NULL);
1781 CHECK_ADDRESS_RETVAL(address, INET, 0);
1782
1783 addr = (struct sockaddr_in *)address->m_addr;
1784 return ntohs(addr->sin_port);
1785 }
1786
1787 /*
1788 * -------------------------------------------------------------------------
1789 * Unix address family
1790 * -------------------------------------------------------------------------
1791 */
1792
1793 #ifndef __VISAGECPP__
1794 GSocketError _GAddress_Init_UNIX(GAddress *address)
1795 {
1796 address->m_len = sizeof(struct sockaddr_un);
1797 address->m_addr = (struct sockaddr *)malloc(address->m_len);
1798 if (address->m_addr == NULL)
1799 {
1800 address->m_error = GSOCK_MEMERR;
1801 return GSOCK_MEMERR;
1802 }
1803
1804 address->m_family = GSOCK_UNIX;
1805 address->m_realfamily = PF_UNIX;
1806 ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
1807 ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
1808
1809 return GSOCK_NOERROR;
1810 }
1811
1812 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
1813
1814 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1815 {
1816 struct sockaddr_un *addr;
1817
1818 assert(address != NULL);
1819
1820 CHECK_ADDRESS(address, UNIX);
1821
1822 addr = ((struct sockaddr_un *)address->m_addr);
1823 strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
1824 addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
1825
1826 return GSOCK_NOERROR;
1827 }
1828
1829 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1830 {
1831 struct sockaddr_un *addr;
1832
1833 assert(address != NULL);
1834 CHECK_ADDRESS(address, UNIX);
1835
1836 addr = (struct sockaddr_un *)address->m_addr;
1837
1838 strncpy(path, addr->sun_path, sbuf);
1839
1840 return GSOCK_NOERROR;
1841 }
1842 #endif /* !defined(__VISAGECPP__) */
1843 #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
1844
wxWidgets (Impactor)