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


3f1b7f4edd808680c315c9c9998a599059f8c501
[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 if (sck->m_reusable)
490 setsockopt(sck->m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
491
492 /* Bind to the local address,
493 * retrieve the actual address bound,
494 * and listen up to 5 connections.
495 */
496 if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
497 (getsockname(sck->m_fd,
498 sck->m_local->m_addr,
499 (SOCKLEN_T *) &sck->m_local->m_len) != 0) ||
500 (listen(sck->m_fd, 5) != 0))
501 {
502 GSocket_close(sck);
503 sck->m_error = GSOCK_IOERR;
504 return GSOCK_IOERR;
505 }
506
507 return GSOCK_NOERROR;
508 }
509
510 /* GSocket_WaitConnection:
511 * Waits for an incoming client connection. Returns a pointer to
512 * a GSocket object, or NULL if there was an error, in which case
513 * the last error field will be updated for the calling GSocket.
514 *
515 * Error codes (set in the calling GSocket)
516 * GSOCK_INVSOCK - the socket is not valid or not a server.
517 * GSOCK_TIMEDOUT - timeout, no incoming connections.
518 * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
519 * GSOCK_MEMERR - couldn't allocate memory.
520 * GSOCK_IOERR - low-level error.
521 */
522 GSocket *GSocket_WaitConnection(GSocket *socket)
523 {
524 struct sockaddr from;
525 SOCKLEN_T fromlen = sizeof(from);
526 GSocket *connection;
527 GSocketError err;
528 int arg = 1;
529
530 assert(socket != NULL);
531
532 /* Reenable CONNECTION events */
533 _GSocket_Enable(socket, GSOCK_CONNECTION);
534
535 /* If the socket has already been created, we exit immediately */
536 if (socket->m_fd == INVALID_SOCKET || !socket->m_server)
537 {
538 socket->m_error = GSOCK_INVSOCK;
539 return NULL;
540 }
541
542 /* Create a GSocket object for the new connection */
543 connection = GSocket_new();
544
545 if (!connection)
546 {
547 socket->m_error = GSOCK_MEMERR;
548 return NULL;
549 }
550
551 /* Wait for a connection (with timeout) */
552 if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT)
553 {
554 GSocket_destroy(connection);
555 /* socket->m_error set by _GSocket_Input_Timeout */
556 return NULL;
557 }
558
559 connection->m_fd = accept(socket->m_fd, &from, (SOCKLEN_T *) &fromlen);
560
561 if (connection->m_fd == INVALID_SOCKET)
562 {
563 if (errno == EWOULDBLOCK)
564 socket->m_error = GSOCK_WOULDBLOCK;
565 else
566 socket->m_error = GSOCK_IOERR;
567
568 GSocket_destroy(connection);
569 return NULL;
570 }
571
572 /* Initialize all fields */
573 connection->m_server = FALSE;
574 connection->m_stream = TRUE;
575 connection->m_oriented = TRUE;
576
577 /* Setup the peer address field */
578 connection->m_peer = GAddress_new();
579 if (!connection->m_peer)
580 {
581 GSocket_destroy(connection);
582 socket->m_error = GSOCK_MEMERR;
583 return NULL;
584 }
585 err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
586 if (err != GSOCK_NOERROR)
587 {
588 GAddress_destroy(connection->m_peer);
589 GSocket_destroy(connection);
590 socket->m_error = err;
591 return NULL;
592 }
593 #if defined(__EMX__) || defined(__VISAGECPP__)
594 ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
595 #else
596 ioctl(connection->m_fd, FIONBIO, &arg);
597 #endif
598 _GSocket_Enable_Events(connection);
599
600 return connection;
601 }
602
603 int GSocket_SetReusable(GSocket *socket)
604 {
605 /* socket must not be null, and must not be in use/already bound */
606 if (NULL != socket && socket->m_fd == INVALID_SOCKET) {
607 socket->m_reusable = TRUE;
608 return TRUE;
609 }
610 return FALSE;
611 }
612
613 /* Client specific parts */
614
615 /* GSocket_Connect:
616 * For stream (connection oriented) sockets, GSocket_Connect() tries
617 * to establish a client connection to a server using the peer address
618 * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
619 * connection has been succesfully established, or one of the error
620 * codes listed below. Note that for nonblocking sockets, a return
621 * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
622 * request can be completed later; you should use GSocket_Select()
623 * to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
624 * corresponding asynchronous events.
625 *
626 * For datagram (non connection oriented) sockets, GSocket_Connect()
627 * just sets the peer address established with GSocket_SetPeer() as
628 * default destination.
629 *
630 * Error codes:
631 * GSOCK_INVSOCK - the socket is in use or not valid.
632 * GSOCK_INVADDR - the peer address has not been established.
633 * GSOCK_TIMEDOUT - timeout, the connection failed.
634 * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
635 * GSOCK_MEMERR - couldn't allocate memory.
636 * GSOCK_IOERR - low-level error.
637 */
638 GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream)
639 {
640 int err, ret;
641 int arg = 1;
642
643 assert(sck != NULL);
644
645 /* Enable CONNECTION events (needed for nonblocking connections) */
646 _GSocket_Enable(sck, GSOCK_CONNECTION);
647
648 if (sck->m_fd != INVALID_SOCKET)
649 {
650 sck->m_error = GSOCK_INVSOCK;
651 return GSOCK_INVSOCK;
652 }
653
654 if (!sck->m_peer)
655 {
656 sck->m_error = GSOCK_INVADDR;
657 return GSOCK_INVADDR;
658 }
659
660 /* Streamed or dgram socket? */
661 sck->m_stream = (stream == GSOCK_STREAMED);
662 sck->m_oriented = TRUE;
663 sck->m_server = FALSE;
664 sck->m_establishing = FALSE;
665
666 /* Create the socket */
667 sck->m_fd = socket(sck->m_peer->m_realfamily,
668 sck->m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
669
670 if (sck->m_fd == INVALID_SOCKET)
671 {
672 sck->m_error = GSOCK_IOERR;
673 return GSOCK_IOERR;
674 }
675 #if defined(__EMX__) || defined(__VISAGECPP__)
676 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
677 #else
678 ioctl(sck->m_fd, FIONBIO, &arg);
679 #endif
680 _GSocket_Enable_Events(sck);
681
682 /* Connect it to the peer address, with a timeout (see below) */
683 ret = connect(sck->m_fd, sck->m_peer->m_addr, sck->m_peer->m_len);
684
685 if (ret == -1)
686 {
687 err = errno;
688
689 /* If connect failed with EINPROGRESS and the GSocket object
690 * is in blocking mode, we select() for the specified timeout
691 * checking for writability to see if the connection request
692 * completes.
693 */
694 if ((err == EINPROGRESS) && (!sck->m_non_blocking))
695 {
696 if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT)
697 {
698 GSocket_close(sck);
699 /* sck->m_error is set in _GSocket_Output_Timeout */
700 return GSOCK_TIMEDOUT;
701 }
702 else
703 {
704 int error;
705 SOCKLEN_T len = sizeof(error);
706
707 getsockopt(sck->m_fd, SOL_SOCKET, SO_ERROR, (void*) &error, &len);
708
709 if (!error)
710 return GSOCK_NOERROR;
711 }
712 }
713
714 /* If connect failed with EINPROGRESS and the GSocket object
715 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
716 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
717 * this way if the connection completes, a GSOCK_CONNECTION
718 * event will be generated, if enabled.
719 */
720 if ((err == EINPROGRESS) && (sck->m_non_blocking))
721 {
722 sck->m_establishing = TRUE;
723 sck->m_error = GSOCK_WOULDBLOCK;
724 return GSOCK_WOULDBLOCK;
725 }
726
727 /* If connect failed with an error other than EINPROGRESS,
728 * then the call to GSocket_Connect has failed.
729 */
730 GSocket_close(sck);
731 sck->m_error = GSOCK_IOERR;
732 return GSOCK_IOERR;
733 }
734
735 return GSOCK_NOERROR;
736 }
737
738 /* Datagram sockets */
739
740 /* GSocket_SetNonOriented:
741 * Sets up this socket as a non-connection oriented (datagram) socket.
742 * Before using this function, the local address must have been set
743 * with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
744 * on success, or one of the following otherwise.
745 *
746 * Error codes:
747 * GSOCK_INVSOCK - the socket is in use.
748 * GSOCK_INVADDR - the local address has not been set.
749 * GSOCK_IOERR - low-level error.
750 */
751 GSocketError GSocket_SetNonOriented(GSocket *sck)
752 {
753 int arg = 1;
754
755 assert(sck != NULL);
756
757 if (sck->m_fd != INVALID_SOCKET)
758 {
759 sck->m_error = GSOCK_INVSOCK;
760 return GSOCK_INVSOCK;
761 }
762
763 if (!sck->m_local)
764 {
765 sck->m_error = GSOCK_INVADDR;
766 return GSOCK_INVADDR;
767 }
768
769 /* Initialize all fields */
770 sck->m_stream = FALSE;
771 sck->m_server = FALSE;
772 sck->m_oriented = FALSE;
773
774 /* Create the socket */
775 sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0);
776
777 if (sck->m_fd == INVALID_SOCKET)
778 {
779 sck->m_error = GSOCK_IOERR;
780 return GSOCK_IOERR;
781 }
782 #if defined(__EMX__) || defined(__VISAGECPP__)
783 ioctl(sck->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
784 #else
785 ioctl(sck->m_fd, FIONBIO, &arg);
786 #endif
787 _GSocket_Enable_Events(sck);
788
789 /* Bind to the local address,
790 * and retrieve the actual address bound.
791 */
792 if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
793 (getsockname(sck->m_fd,
794 sck->m_local->m_addr,
795 (SOCKLEN_T *) &sck->m_local->m_len) != 0))
796 {
797 GSocket_close(sck);
798 sck->m_error = GSOCK_IOERR;
799 return GSOCK_IOERR;
800 }
801
802 return GSOCK_NOERROR;
803 }
804
805 /* Generic IO */
806
807 /* Like recv(), send(), ... */
808 int GSocket_Read(GSocket *socket, char *buffer, int size)
809 {
810 int ret;
811
812 assert(socket != NULL);
813
814 if (socket->m_fd == INVALID_SOCKET || socket->m_server)
815 {
816 socket->m_error = GSOCK_INVSOCK;
817 return -1;
818 }
819
820 /* Disable events during query of socket status */
821 _GSocket_Disable(socket, GSOCK_INPUT);
822
823 /* If the socket is blocking, wait for data (with a timeout) */
824 if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT)
825 /* We no longer return here immediately, otherwise socket events would not be re-enabled! */
826 ret = -1;
827 else {
828 /* Read the data */
829 if (socket->m_stream)
830 ret = _GSocket_Recv_Stream(socket, buffer, size);
831 else
832 ret = _GSocket_Recv_Dgram(socket, buffer, size);
833 }
834
835 if (ret == -1)
836 {
837 if (errno == EWOULDBLOCK)
838 socket->m_error = GSOCK_WOULDBLOCK;
839 else
840 socket->m_error = GSOCK_IOERR;
841 }
842
843 /* Enable events again now that we are done processing */
844 _GSocket_Enable(socket, GSOCK_INPUT);
845
846 return ret;
847 }
848
849 int GSocket_Write(GSocket *socket, const char *buffer, int size)
850 {
851 int ret;
852
853 assert(socket != NULL);
854
855 GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
856
857 if (socket->m_fd == INVALID_SOCKET || socket->m_server)
858 {
859 socket->m_error = GSOCK_INVSOCK;
860 return -1;
861 }
862
863 GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
864
865 /* If the socket is blocking, wait for writability (with a timeout) */
866 if (_GSocket_Output_Timeout(socket) == GSOCK_TIMEDOUT)
867 return -1;
868
869 GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
870
871 /* Write the data */
872 if (socket->m_stream)
873 ret = _GSocket_Send_Stream(socket, buffer, size);
874 else
875 ret = _GSocket_Send_Dgram(socket, buffer, size);
876
877 GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
878
879 if (ret == -1)
880 {
881 if (errno == EWOULDBLOCK)
882 {
883 socket->m_error = GSOCK_WOULDBLOCK;
884 GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
885 }
886 else
887 {
888 socket->m_error = GSOCK_IOERR;
889 GSocket_Debug(( "GSocket_Write error IOERR\n" ));
890 }
891
892 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
893 * in MSW). Once the first OUTPUT event is received, users can assume
894 * that the socket is writable until a read operation fails. Only then
895 * will further OUTPUT events be posted.
896 */
897 _GSocket_Enable(socket, GSOCK_OUTPUT);
898 return -1;
899 }
900
901 GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
902
903 return ret;
904 }
905
906 /* GSocket_Select:
907 * Polls the socket to determine its status. This function will
908 * check for the events specified in the 'flags' parameter, and
909 * it will return a mask indicating which operations can be
910 * performed. This function won't block, regardless of the
911 * mode (blocking | nonblocking) of the socket.
912 */
913 GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
914 {
915 if (!USE_GUI())
916 {
917
918 GSocketEventFlags result = 0;
919 fd_set readfds;
920 fd_set writefds;
921 fd_set exceptfds;
922 struct timeval tv;
923
924 assert(socket != NULL);
925
926 /* Do not use a static struct, Linux can garble it */
927 tv.tv_sec = socket->m_timeout / 1000;
928 tv.tv_usec = (socket->m_timeout % 1000) / 1000;
929
930 FD_ZERO(&readfds);
931 FD_ZERO(&writefds);
932 FD_ZERO(&exceptfds);
933 FD_SET(socket->m_fd, &readfds);
934 if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
935 FD_SET(socket->m_fd, &writefds);
936 FD_SET(socket->m_fd, &exceptfds);
937
938 /* Check 'sticky' CONNECTION flag first */
939 result |= (GSOCK_CONNECTION_FLAG & socket->m_detected);
940
941 /* If we have already detected a LOST event, then don't try
942 * to do any further processing.
943 */
944 if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
945 {
946 socket->m_establishing = FALSE;
947
948 return (GSOCK_LOST_FLAG & flags);
949 }
950
951 /* Try select now */
952 if (select(socket->m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
953 {
954 /* What to do here? */
955 return (result & flags);
956 }
957
958 /* Check for readability */
959 if (FD_ISSET(socket->m_fd, &readfds))
960 {
961 char c;
962
963 if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0)
964 {
965 result |= GSOCK_INPUT_FLAG;
966 }
967 else
968 {
969 if (socket->m_server && socket->m_stream)
970 {
971 result |= GSOCK_CONNECTION_FLAG;
972 socket->m_detected |= GSOCK_CONNECTION_FLAG;
973 }
974 else
975 {
976 socket->m_detected = GSOCK_LOST_FLAG;
977 socket->m_establishing = FALSE;
978
979 /* LOST event: Abort any further processing */
980 return (GSOCK_LOST_FLAG & flags);
981 }
982 }
983 }
984
985 /* Check for writability */
986 if (FD_ISSET(socket->m_fd, &writefds))
987 {
988 if (socket->m_establishing && !socket->m_server)
989 {
990 int error;
991 SOCKLEN_T len = sizeof(error);
992
993 socket->m_establishing = FALSE;
994
995 getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
996
997 if (error)
998 {
999 socket->m_detected = GSOCK_LOST_FLAG;
1000
1001 /* LOST event: Abort any further processing */
1002 return (GSOCK_LOST_FLAG & flags);
1003 }
1004 else
1005 {
1006 result |= GSOCK_CONNECTION_FLAG;
1007 socket->m_detected |= GSOCK_CONNECTION_FLAG;
1008 }
1009 }
1010 else
1011 {
1012 result |= GSOCK_OUTPUT_FLAG;
1013 }
1014 }
1015
1016 /* Check for exceptions and errors (is this useful in Unices?) */
1017 if (FD_ISSET(socket->m_fd, &exceptfds))
1018 {
1019 socket->m_establishing = FALSE;
1020 socket->m_detected = GSOCK_LOST_FLAG;
1021
1022 /* LOST event: Abort any further processing */
1023 return (GSOCK_LOST_FLAG & flags);
1024 }
1025
1026 return (result & flags);
1027
1028 }
1029 else
1030 {
1031
1032 assert(socket != NULL);
1033 return flags & socket->m_detected;
1034
1035 }
1036 }
1037
1038 /* Flags */
1039
1040 /* GSocket_SetNonBlocking:
1041 * Sets the socket to non-blocking mode. All IO calls will return
1042 * immediately.
1043 */
1044 void GSocket_SetNonBlocking(GSocket *socket, int non_block)
1045 {
1046 assert(socket != NULL);
1047
1048 GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1049
1050 socket->m_non_blocking = non_block;
1051 }
1052
1053 /* GSocket_SetTimeout:
1054 * Sets the timeout for blocking calls. Time is expressed in
1055 * milliseconds.
1056 */
1057 void GSocket_SetTimeout(GSocket *socket, unsigned long millisec)
1058 {
1059 assert(socket != NULL);
1060
1061 socket->m_timeout = millisec;
1062 }
1063
1064 /* GSocket_GetError:
1065 * Returns the last error occured for this socket. Note that successful
1066 * operations do not clear this back to GSOCK_NOERROR, so use it only
1067 * after an error.
1068 */
1069 GSocketError GSocket_GetError(GSocket *socket)
1070 {
1071 assert(socket != NULL);
1072
1073 return socket->m_error;
1074 }
1075
1076 /* Callbacks */
1077
1078 /* GSOCK_INPUT:
1079 * There is data to be read in the input buffer. If, after a read
1080 * operation, there is still data available, the callback function will
1081 * be called again.
1082 * GSOCK_OUTPUT:
1083 * The socket is available for writing. That is, the next write call
1084 * won't block. This event is generated only once, when the connection is
1085 * first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1086 * when the output buffer empties again. This means that the app should
1087 * assume that it can write since the first OUTPUT event, and no more
1088 * OUTPUT events will be generated unless an error occurs.
1089 * GSOCK_CONNECTION:
1090 * Connection succesfully established, for client sockets, or incoming
1091 * client connection, for server sockets. Wait for this event (also watch
1092 * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1093 * GSOCK_LOST:
1094 * The connection is lost (or a connection request failed); this could
1095 * be due to a failure, or due to the peer closing it gracefully.
1096 */
1097
1098 /* GSocket_SetCallback:
1099 * Enables the callbacks specified by 'flags'. Note that 'flags'
1100 * may be a combination of flags OR'ed toghether, so the same
1101 * callback function can be made to accept different events.
1102 * The callback function must have the following prototype:
1103 *
1104 * void function(GSocket *socket, GSocketEvent event, char *cdata)
1105 */
1106 void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags,
1107 GSocketCallback callback, char *cdata)
1108 {
1109 int count;
1110
1111 assert(socket != NULL);
1112
1113 for (count = 0; count < GSOCK_MAX_EVENT; count++)
1114 {
1115 if ((flags & (1 << count)) != 0)
1116 {
1117 socket->m_cbacks[count] = callback;
1118 socket->m_data[count] = cdata;
1119 }
1120 }
1121 }
1122
1123 /* GSocket_UnsetCallback:
1124 * Disables all callbacks specified by 'flags', which may be a
1125 * combination of flags OR'ed toghether.
1126 */
1127 void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags)
1128 {
1129 int count;
1130
1131 assert(socket != NULL);
1132
1133 for (count = 0; count < GSOCK_MAX_EVENT; count++)
1134 {
1135 if ((flags & (1 << count)) != 0)
1136 {
1137 socket->m_cbacks[count] = NULL;
1138 socket->m_data[count] = NULL;
1139 }
1140 }
1141 }
1142
1143 GSocketError GSocket_GetSockOpt(GSocket *socket, int level, int optname,
1144 void *optval, int *optlen)
1145 {
1146 if (getsockopt(socket->m_fd, level, optname, optval, optlen) == 0)
1147 {
1148 return GSOCK_NOERROR;
1149 }
1150 return GSOCK_OPTERR;
1151 }
1152
1153 GSocketError GSocket_SetSockOpt(GSocket *socket, int level, int optname,
1154 const void *optval, int optlen)
1155 {
1156 if (setsockopt(socket->m_fd, level, optname, optval, optlen) == 0)
1157 {
1158 return GSOCK_NOERROR;
1159 }
1160 return GSOCK_OPTERR;
1161 }
1162
1163 void GSocket_Streamed(GSocket *socket)
1164 {
1165 socket->m_stream = TRUE;
1166 }
1167
1168 void GSocket_Unstreamed(GSocket *socket)
1169 {
1170 socket->m_stream = FALSE;
1171 }
1172
1173 #define CALL_CALLBACK(socket, event) { \
1174 _GSocket_Disable(socket, event); \
1175 if (socket->m_cbacks[event]) \
1176 socket->m_cbacks[event](socket, event, socket->m_data[event]); \
1177 }
1178
1179
1180 void _GSocket_Enable(GSocket *socket, GSocketEvent event)
1181 {
1182 socket->m_detected &= ~(1 << event);
1183 _GSocket_Install_Callback(socket, event);
1184 }
1185
1186 void _GSocket_Disable(GSocket *socket, GSocketEvent event)
1187 {
1188 socket->m_detected |= (1 << event);
1189 _GSocket_Uninstall_Callback(socket, event);
1190 }
1191
1192 /* _GSocket_Input_Timeout:
1193 * For blocking sockets, wait until data is available or
1194 * until timeout ellapses.
1195 */
1196 GSocketError _GSocket_Input_Timeout(GSocket *socket)
1197 {
1198 struct timeval tv;
1199 fd_set readfds;
1200 int ret;
1201
1202 /* Linux select() will overwrite the struct on return */
1203 tv.tv_sec = (socket->m_timeout / 1000);
1204 tv.tv_usec = (socket->m_timeout % 1000) * 1000;
1205
1206 if (!socket->m_non_blocking)
1207 {
1208 FD_ZERO(&readfds);
1209 FD_SET(socket->m_fd, &readfds);
1210 ret = select(socket->m_fd + 1, &readfds, NULL, NULL, &tv);
1211 if (ret == 0)
1212 {
1213 GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1214 socket->m_error = GSOCK_TIMEDOUT;
1215 return GSOCK_TIMEDOUT;
1216 }
1217 if (ret == -1)
1218 {
1219 GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1220 if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1221 if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1222 if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1223 if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1224 socket->m_error = GSOCK_TIMEDOUT;
1225 return GSOCK_TIMEDOUT;
1226 }
1227 }
1228 return GSOCK_NOERROR;
1229 }
1230
1231 /* _GSocket_Output_Timeout:
1232 * For blocking sockets, wait until data can be sent without
1233 * blocking or until timeout ellapses.
1234 */
1235 GSocketError _GSocket_Output_Timeout(GSocket *socket)
1236 {
1237 struct timeval tv;
1238 fd_set writefds;
1239 int ret;
1240
1241 /* Linux select() will overwrite the struct on return */
1242 tv.tv_sec = (socket->m_timeout / 1000);
1243 tv.tv_usec = (socket->m_timeout % 1000) * 1000;
1244
1245 GSocket_Debug( ("m_non_blocking has: %d\n", (int)socket->m_non_blocking) );
1246
1247 if (!socket->m_non_blocking)
1248 {
1249 FD_ZERO(&writefds);
1250 FD_SET(socket->m_fd, &writefds);
1251 ret = select(socket->m_fd + 1, NULL, &writefds, NULL, &tv);
1252 if (ret == 0)
1253 {
1254 GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1255 socket->m_error = GSOCK_TIMEDOUT;
1256 return GSOCK_TIMEDOUT;
1257 }
1258 if (ret == -1)
1259 {
1260 GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1261 if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1262 if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1263 if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1264 if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1265 socket->m_error = GSOCK_TIMEDOUT;
1266 return GSOCK_TIMEDOUT;
1267 }
1268 if ( ! FD_ISSET(socket->m_fd, &writefds) ) {
1269 GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1270 }
1271 else {
1272 GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1273 }
1274 }
1275 else
1276 {
1277 GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1278 }
1279
1280 return GSOCK_NOERROR;
1281 }
1282
1283 int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size)
1284 {
1285 return recv(socket->m_fd, buffer, size, 0);
1286 }
1287
1288 int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size)
1289 {
1290 struct sockaddr from;
1291 SOCKLEN_T fromlen = sizeof(from);
1292 int ret;
1293 GSocketError err;
1294
1295 fromlen = sizeof(from);
1296
1297 ret = recvfrom(socket->m_fd, buffer, size, 0, &from, (SOCKLEN_T *) &fromlen);
1298
1299 if (ret == -1)
1300 return -1;
1301
1302 /* Translate a system address into a GSocket address */
1303 if (!socket->m_peer)
1304 {
1305 socket->m_peer = GAddress_new();
1306 if (!socket->m_peer)
1307 {
1308 socket->m_error = GSOCK_MEMERR;
1309 return -1;
1310 }
1311 }
1312 err = _GAddress_translate_from(socket->m_peer, &from, fromlen);
1313 if (err != GSOCK_NOERROR)
1314 {
1315 GAddress_destroy(socket->m_peer);
1316 socket->m_peer = NULL;
1317 socket->m_error = err;
1318 return -1;
1319 }
1320
1321 return ret;
1322 }
1323
1324 int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size)
1325 {
1326 int ret;
1327
1328 #ifndef __VISAGECPP__
1329 MASK_SIGNAL();
1330 ret = send(socket->m_fd, buffer, size, 0);
1331 UNMASK_SIGNAL();
1332 #else
1333 ret = send(socket->m_fd, (char *)buffer, size, 0);
1334 #endif
1335
1336 return ret;
1337 }
1338
1339 int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size)
1340 {
1341 struct sockaddr *addr;
1342 int len, ret;
1343 GSocketError err;
1344
1345 if (!socket->m_peer)
1346 {
1347 socket->m_error = GSOCK_INVADDR;
1348 return -1;
1349 }
1350
1351 err = _GAddress_translate_to(socket->m_peer, &addr, &len);
1352 if (err != GSOCK_NOERROR)
1353 {
1354 socket->m_error = err;
1355 return -1;
1356 }
1357
1358 #ifndef __VISAGECPP__
1359 MASK_SIGNAL();
1360 ret = sendto(socket->m_fd, buffer, size, 0, addr, len);
1361 UNMASK_SIGNAL();
1362 #else
1363 ret = sendto(socket->m_fd, (char *)buffer, size, 0, addr, len);
1364 #endif
1365
1366 /* Frees memory allocated from _GAddress_translate_to */
1367 free(addr);
1368
1369 return ret;
1370 }
1371
1372 void _GSocket_Detected_Read(GSocket *socket)
1373 {
1374 char c;
1375
1376 /* If we have already detected a LOST event, then don't try
1377 * to do any further processing.
1378 */
1379 if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
1380 {
1381 socket->m_establishing = FALSE;
1382
1383 CALL_CALLBACK(socket, GSOCK_LOST);
1384 GSocket_Shutdown(socket);
1385 return;
1386 }
1387
1388 if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0)
1389 {
1390 CALL_CALLBACK(socket, GSOCK_INPUT);
1391 }
1392 else
1393 {
1394 if (socket->m_server && socket->m_stream)
1395 {
1396 CALL_CALLBACK(socket, GSOCK_CONNECTION);
1397 }
1398 else
1399 {
1400 CALL_CALLBACK(socket, GSOCK_LOST);
1401 GSocket_Shutdown(socket);
1402 }
1403 }
1404 }
1405
1406 void _GSocket_Detected_Write(GSocket *socket)
1407 {
1408 /* If we have already detected a LOST event, then don't try
1409 * to do any further processing.
1410 */
1411 if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
1412 {
1413 socket->m_establishing = FALSE;
1414
1415 CALL_CALLBACK(socket, GSOCK_LOST);
1416 GSocket_Shutdown(socket);
1417 return;
1418 }
1419
1420 if (socket->m_establishing && !socket->m_server)
1421 {
1422 int error;
1423 SOCKLEN_T len = sizeof(error);
1424
1425 socket->m_establishing = FALSE;
1426
1427 getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
1428
1429 if (error)
1430 {
1431 CALL_CALLBACK(socket, GSOCK_LOST);
1432 GSocket_Shutdown(socket);
1433 }
1434 else
1435 {
1436 CALL_CALLBACK(socket, GSOCK_CONNECTION);
1437 /* We have to fire this event by hand because CONNECTION (for clients)
1438 * and OUTPUT are internally the same and we just disabled CONNECTION
1439 * events with the above macro.
1440 */
1441 CALL_CALLBACK(socket, GSOCK_OUTPUT);
1442 }
1443 }
1444 else
1445 {
1446 CALL_CALLBACK(socket, GSOCK_OUTPUT);
1447 }
1448 }
1449
1450 /*
1451 * -------------------------------------------------------------------------
1452 * GAddress
1453 * -------------------------------------------------------------------------
1454 */
1455
1456 /* CHECK_ADDRESS verifies that the current address family is either
1457 * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1458 * initalizes it to be a GSOCK_*family*. In other cases, it returns
1459 * an appropiate error code.
1460 *
1461 * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1462 */
1463 #define CHECK_ADDRESS(address, family) \
1464 { \
1465 if (address->m_family == GSOCK_NOFAMILY) \
1466 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1467 return address->m_error; \
1468 if (address->m_family != GSOCK_##family) \
1469 { \
1470 address->m_error = GSOCK_INVADDR; \
1471 return GSOCK_INVADDR; \
1472 } \
1473 }
1474
1475 #define CHECK_ADDRESS_RETVAL(address, family, retval) \
1476 { \
1477 if (address->m_family == GSOCK_NOFAMILY) \
1478 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1479 return retval; \
1480 if (address->m_family != GSOCK_##family) \
1481 { \
1482 address->m_error = GSOCK_INVADDR; \
1483 return retval; \
1484 } \
1485 }
1486
1487
1488 GAddress *GAddress_new(void)
1489 {
1490 GAddress *address;
1491
1492 if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1493 return NULL;
1494
1495 address->m_family = GSOCK_NOFAMILY;
1496 address->m_addr = NULL;
1497 address->m_len = 0;
1498
1499 return address;
1500 }
1501
1502 GAddress *GAddress_copy(GAddress *address)
1503 {
1504 GAddress *addr2;
1505
1506 assert(address != NULL);
1507
1508 if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1509 return NULL;
1510
1511 memcpy(addr2, address, sizeof(GAddress));
1512
1513 if (address->m_addr && address->m_len > 0)
1514 {
1515 addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1516 if (addr2->m_addr == NULL)
1517 {
1518 free(addr2);
1519 return NULL;
1520 }
1521 memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1522 }
1523
1524 return addr2;
1525 }
1526
1527 void GAddress_destroy(GAddress *address)
1528 {
1529 assert(address != NULL);
1530
1531 if (address->m_addr)
1532 free(address->m_addr);
1533
1534 free(address);
1535 }
1536
1537 void GAddress_SetFamily(GAddress *address, GAddressType type)
1538 {
1539 assert(address != NULL);
1540
1541 address->m_family = type;
1542 }
1543
1544 GAddressType GAddress_GetFamily(GAddress *address)
1545 {
1546 assert(address != NULL);
1547
1548 return address->m_family;
1549 }
1550
1551 GSocketError _GAddress_translate_from(GAddress *address,
1552 struct sockaddr *addr, int len)
1553 {
1554 address->m_realfamily = addr->sa_family;
1555 switch (addr->sa_family)
1556 {
1557 case AF_INET:
1558 address->m_family = GSOCK_INET;
1559 break;
1560 case AF_UNIX:
1561 address->m_family = GSOCK_UNIX;
1562 break;
1563 #ifdef AF_INET6
1564 case AF_INET6:
1565 address->m_family = GSOCK_INET6;
1566 break;
1567 #endif
1568 default:
1569 {
1570 address->m_error = GSOCK_INVOP;
1571 return GSOCK_INVOP;
1572 }
1573 }
1574
1575 if (address->m_addr)
1576 free(address->m_addr);
1577
1578 address->m_len = len;
1579 address->m_addr = (struct sockaddr *)malloc(len);
1580
1581 if (address->m_addr == NULL)
1582 {
1583 address->m_error = GSOCK_MEMERR;
1584 return GSOCK_MEMERR;
1585 }
1586 memcpy(address->m_addr, addr, len);
1587
1588 return GSOCK_NOERROR;
1589 }
1590
1591 GSocketError _GAddress_translate_to(GAddress *address,
1592 struct sockaddr **addr, int *len)
1593 {
1594 if (!address->m_addr)
1595 {
1596 address->m_error = GSOCK_INVADDR;
1597 return GSOCK_INVADDR;
1598 }
1599
1600 *len = address->m_len;
1601 *addr = (struct sockaddr *)malloc(address->m_len);
1602 if (*addr == NULL)
1603 {
1604 address->m_error = GSOCK_MEMERR;
1605 return GSOCK_MEMERR;
1606 }
1607
1608 memcpy(*addr, address->m_addr, address->m_len);
1609 return GSOCK_NOERROR;
1610 }
1611
1612 /*
1613 * -------------------------------------------------------------------------
1614 * Internet address family
1615 * -------------------------------------------------------------------------
1616 */
1617
1618 GSocketError _GAddress_Init_INET(GAddress *address)
1619 {
1620 address->m_len = sizeof(struct sockaddr_in);
1621 address->m_addr = (struct sockaddr *) malloc(address->m_len);
1622 if (address->m_addr == NULL)
1623 {
1624 address->m_error = GSOCK_MEMERR;
1625 return GSOCK_MEMERR;
1626 }
1627
1628 address->m_family = GSOCK_INET;
1629 address->m_realfamily = PF_INET;
1630 ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1631 ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1632
1633 return GSOCK_NOERROR;
1634 }
1635
1636 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1637 {
1638 struct hostent *he;
1639 struct in_addr *addr;
1640
1641 assert(address != NULL);
1642
1643 CHECK_ADDRESS(address, INET);
1644
1645 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1646
1647 /* If it is a numeric host name, convert it now */
1648 #if defined(HAVE_INET_ATON)
1649 if (inet_aton(hostname, addr) == 0)
1650 {
1651 #elif defined(HAVE_INET_ADDR)
1652 if ( (addr->s_addr = inet_addr(hostname)) == -1 )
1653 {
1654 #else
1655 /* Use gethostbyname by default */
1656 #ifndef __WXMAC__
1657 int val = 1; /* VA doesn't like constants in conditional expressions */
1658 if (val)
1659 #endif
1660 {
1661 #endif
1662 struct in_addr *array_addr;
1663
1664 /* It is a real name, we solve it */
1665 if ((he = gethostbyname(hostname)) == NULL)
1666 {
1667 /* Reset to invalid address */
1668 addr->s_addr = INADDR_NONE;
1669 address->m_error = GSOCK_NOHOST;
1670 return GSOCK_NOHOST;
1671 }
1672 array_addr = (struct in_addr *) *(he->h_addr_list);
1673 addr->s_addr = array_addr[0].s_addr;
1674 }
1675 return GSOCK_NOERROR;
1676 }
1677
1678 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1679 {
1680 return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1681 }
1682
1683 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1684 unsigned long hostaddr)
1685 {
1686 struct in_addr *addr;
1687
1688 assert(address != NULL);
1689
1690 CHECK_ADDRESS(address, INET);
1691
1692 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1693 addr->s_addr = htonl(hostaddr);
1694
1695 return GSOCK_NOERROR;
1696 }
1697
1698 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1699 const char *protocol)
1700 {
1701 struct servent *se;
1702 struct sockaddr_in *addr;
1703
1704 assert(address != NULL);
1705 CHECK_ADDRESS(address, INET);
1706
1707 if (!port)
1708 {
1709 address->m_error = GSOCK_INVPORT;
1710 return GSOCK_INVPORT;
1711 }
1712
1713 se = getservbyname(port, protocol);
1714 if (!se)
1715 {
1716 /* the cast to int suppresses compiler warnings about subscript having the
1717 type char */
1718 if (isdigit((int)port[0]))
1719 {
1720 int port_int;
1721
1722 port_int = atoi(port);
1723 addr = (struct sockaddr_in *)address->m_addr;
1724 addr->sin_port = htons(port_int);
1725 return GSOCK_NOERROR;
1726 }
1727
1728 address->m_error = GSOCK_INVPORT;
1729 return GSOCK_INVPORT;
1730 }
1731
1732 addr = (struct sockaddr_in *)address->m_addr;
1733 addr->sin_port = se->s_port;
1734
1735 return GSOCK_NOERROR;
1736 }
1737
1738 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1739 {
1740 struct sockaddr_in *addr;
1741
1742 assert(address != NULL);
1743 CHECK_ADDRESS(address, INET);
1744
1745 addr = (struct sockaddr_in *)address->m_addr;
1746 addr->sin_port = htons(port);
1747
1748 return GSOCK_NOERROR;
1749 }
1750
1751 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1752 {
1753 struct hostent *he;
1754 char *addr_buf;
1755 struct sockaddr_in *addr;
1756
1757 assert(address != NULL);
1758 CHECK_ADDRESS(address, INET);
1759
1760 addr = (struct sockaddr_in *)address->m_addr;
1761 addr_buf = (char *)&(addr->sin_addr);
1762
1763 he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1764 if (he == NULL)
1765 {
1766 address->m_error = GSOCK_NOHOST;
1767 return GSOCK_NOHOST;
1768 }
1769
1770 strncpy(hostname, he->h_name, sbuf);
1771
1772 return GSOCK_NOERROR;
1773 }
1774
1775 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1776 {
1777 struct sockaddr_in *addr;
1778
1779 assert(address != NULL);
1780 CHECK_ADDRESS_RETVAL(address, INET, 0);
1781
1782 addr = (struct sockaddr_in *)address->m_addr;
1783
1784 return ntohl(addr->sin_addr.s_addr);
1785 }
1786
1787 unsigned short GAddress_INET_GetPort(GAddress *address)
1788 {
1789 struct sockaddr_in *addr;
1790
1791 assert(address != NULL);
1792 CHECK_ADDRESS_RETVAL(address, INET, 0);
1793
1794 addr = (struct sockaddr_in *)address->m_addr;
1795 return ntohs(addr->sin_port);
1796 }
1797
1798 /*
1799 * -------------------------------------------------------------------------
1800 * Unix address family
1801 * -------------------------------------------------------------------------
1802 */
1803
1804 #ifndef __VISAGECPP__
1805 GSocketError _GAddress_Init_UNIX(GAddress *address)
1806 {
1807 address->m_len = sizeof(struct sockaddr_un);
1808 address->m_addr = (struct sockaddr *)malloc(address->m_len);
1809 if (address->m_addr == NULL)
1810 {
1811 address->m_error = GSOCK_MEMERR;
1812 return GSOCK_MEMERR;
1813 }
1814
1815 address->m_family = GSOCK_UNIX;
1816 address->m_realfamily = PF_UNIX;
1817 ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
1818 ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
1819
1820 return GSOCK_NOERROR;
1821 }
1822
1823 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
1824
1825 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1826 {
1827 struct sockaddr_un *addr;
1828
1829 assert(address != NULL);
1830
1831 CHECK_ADDRESS(address, UNIX);
1832
1833 addr = ((struct sockaddr_un *)address->m_addr);
1834 strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
1835 addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
1836
1837 return GSOCK_NOERROR;
1838 }
1839
1840 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1841 {
1842 struct sockaddr_un *addr;
1843
1844 assert(address != NULL);
1845 CHECK_ADDRESS(address, UNIX);
1846
1847 addr = (struct sockaddr_un *)address->m_addr;
1848
1849 strncpy(path, addr->sun_path, sbuf);
1850
1851 return GSOCK_NOERROR;
1852 }
1853 #endif /* !defined(__VISAGECPP__) */
1854 #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
1855
wxWidgets (Impactor)