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


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