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


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