]> git.saurik.com Git - wxWidgets.git/blob - src/unix/gsocket.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
compilation fix for !wxUSE_THREADS
[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 #if defined(__WATCOMC__)
16 #include "wx/wxprec.h"
17 #include <errno.h>
18 #include <nerrno.h>
19 #endif
20
21 #ifndef __GSOCKET_STANDALONE__
22 #include "wx/defs.h"
23 #include "wx/private/gsocketiohandler.h"
24 #include "wx/thread.h" // for wxThread::IsMain() used in assert
25 #endif
26
27 #if defined(__VISAGECPP__)
28 #define BSD_SELECT /* use Berkeley Sockets select */
29 #endif
30
31 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
32
33 #include <assert.h>
34 #include <sys/types.h>
35 #ifdef __VISAGECPP__
36 #include <string.h>
37 #include <sys/time.h>
38 #include <types.h>
39 #include <netinet/in.h>
40 #endif
41 #include <netdb.h>
42 #include <sys/ioctl.h>
43
44 #ifdef HAVE_SYS_SELECT_H
45 # include <sys/select.h>
46 #endif
47
48 #ifdef __VMS__
49 #include <socket.h>
50 struct sockaddr_un
51 {
52 u_char sun_len; /* sockaddr len including null */
53 u_char sun_family; /* AF_UNIX */
54 char sun_path[108]; /* path name (gag) */
55 };
56 #else
57 #include <sys/socket.h>
58 #include <sys/un.h>
59 #endif
60
61 #ifndef __VISAGECPP__
62 #include <sys/time.h>
63 #include <netinet/in.h>
64 #include <arpa/inet.h>
65 #include <errno.h>
66 #include <string.h>
67 #include <unistd.h>
68 #else
69 #include <nerrno.h>
70 # if __IBMCPP__ < 400
71 #include <machine/endian.h>
72 #include <socket.h>
73 #include <ioctl.h>
74 #include <select.h>
75 #include <unistd.h>
76
77 #define EBADF SOCEBADF
78
79 # ifdef min
80 # undef min
81 # endif
82 # else
83 #include <sys/socket.h>
84 #include <sys/ioctl.h>
85 #include <sys/select.h>
86
87 #define close(a) soclose(a)
88 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
89 int _System bsdselect(int,
90 struct fd_set *,
91 struct fd_set *,
92 struct fd_set *,
93 struct timeval *);
94 int _System soclose(int);
95 # endif
96 #endif
97 #ifdef __EMX__
98 #include <sys/select.h>
99 #endif
100
101 #include <stdio.h>
102 #include <stdlib.h>
103 #include <stddef.h>
104 #include <ctype.h>
105 #ifdef sun
106 # include <sys/filio.h>
107 #endif
108 #ifdef sgi
109 # include <bstring.h>
110 #endif
111 #ifdef _AIX
112 # include <strings.h>
113 #endif
114 #include <signal.h>
115
116 #ifndef WX_SOCKLEN_T
117
118 #ifdef VMS
119 # define WX_SOCKLEN_T unsigned int
120 #else
121 # ifdef __GLIBC__
122 # if __GLIBC__ == 2
123 # define WX_SOCKLEN_T socklen_t
124 # endif
125 # elif defined(__WXMAC__)
126 # define WX_SOCKLEN_T socklen_t
127 # else
128 # define WX_SOCKLEN_T int
129 # endif
130 #endif
131
132 #endif /* SOCKLEN_T */
133
134 #ifndef SOCKOPTLEN_T
135 #define SOCKOPTLEN_T WX_SOCKLEN_T
136 #endif
137
138 /*
139 * MSW defines this, Unices don't.
140 */
141 #ifndef INVALID_SOCKET
142 #define INVALID_SOCKET -1
143 #endif
144
145 /* UnixWare reportedly needs this for FIONBIO definition */
146 #ifdef __UNIXWARE__
147 #include <sys/filio.h>
148 #endif
149
150 /*
151 * INADDR_BROADCAST is identical to INADDR_NONE which is not defined
152 * on all systems. INADDR_BROADCAST should be fine to indicate an error.
153 */
154 #ifndef INADDR_NONE
155 #define INADDR_NONE INADDR_BROADCAST
156 #endif
157
158 #if defined(__VISAGECPP__) || defined(__WATCOMC__)
159
160 #define MASK_SIGNAL() {
161 #define UNMASK_SIGNAL() }
162
163 #else
164 extern "C" { typedef void (*wxSigHandler)(int); }
165
166 #define MASK_SIGNAL() \
167 { \
168 wxSigHandler old_handler = signal(SIGPIPE, SIG_IGN);
169
170 #define UNMASK_SIGNAL() \
171 signal(SIGPIPE, old_handler); \
172 }
173
174 #endif
175
176 /* If a SIGPIPE is issued by a socket call on a remotely closed socket,
177 the program will "crash" unless it explicitly handles the SIGPIPE.
178 By using MSG_NOSIGNAL, the SIGPIPE is suppressed. Later, we will
179 use SO_NOSIGPIPE (if available), the BSD equivalent. */
180 #ifdef MSG_NOSIGNAL
181 # define GSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL
182 #else /* MSG_NOSIGNAL not available (FreeBSD including OS X) */
183 # define GSOCKET_MSG_NOSIGNAL 0
184 #endif /* MSG_NOSIGNAL */
185
186 #ifndef __GSOCKET_STANDALONE__
187 # include "wx/unix/gsockunx.h"
188 # include "wx/unix/private.h"
189 # include "wx/gsocket.h"
190 #if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME))
191 # include "wx/thread.h"
192 #endif
193 #else
194 # include "gsockunx.h"
195 # include "gsocket.h"
196 # ifndef WXUNUSED
197 # define WXUNUSED(x)
198 # endif
199 #endif /* __GSOCKET_STANDALONE__ */
200
201 #if defined(HAVE_GETHOSTBYNAME)
202 static struct hostent * deepCopyHostent(struct hostent *h,
203 const struct hostent *he,
204 char *buffer, int size, int *err)
205 {
206 /* copy old structure */
207 memcpy(h, he, sizeof(struct hostent));
208
209 /* copy name */
210 int len = strlen(h->h_name);
211 if (len > size)
212 {
213 *err = ENOMEM;
214 return NULL;
215 }
216 memcpy(buffer, h->h_name, len);
217 buffer[len] = '\0';
218 h->h_name = buffer;
219
220 /* track position in the buffer */
221 int pos = len + 1;
222
223 /* reuse len to store address length */
224 len = h->h_length;
225
226 /* ensure pointer alignment */
227 unsigned int misalign = sizeof(char *) - pos%sizeof(char *);
228 if(misalign < sizeof(char *))
229 pos += misalign;
230
231 /* leave space for pointer list */
232 char **p = h->h_addr_list, **q;
233 char **h_addr_list = (char **)(buffer + pos);
234 while(*(p++) != 0)
235 pos += sizeof(char *);
236
237 /* copy addresses and fill new pointer list */
238 for (p = h->h_addr_list, q = h_addr_list; *p != 0; p++, q++)
239 {
240 if (size < pos + len)
241 {
242 *err = ENOMEM;
243 return NULL;
244 }
245 memcpy(buffer + pos, *p, len); /* copy content */
246 *q = buffer + pos; /* set copied pointer to copied content */
247 pos += len;
248 }
249 *++q = 0; /* null terminate the pointer list */
250 h->h_addr_list = h_addr_list; /* copy pointer to pointers */
251
252 /* ensure word alignment of pointers */
253 misalign = sizeof(char *) - pos%sizeof(char *);
254 if(misalign < sizeof(char *))
255 pos += misalign;
256
257 /* leave space for pointer list */
258 p = h->h_aliases;
259 char **h_aliases = (char **)(buffer + pos);
260 while(*(p++) != 0)
261 pos += sizeof(char *);
262
263 /* copy aliases and fill new pointer list */
264 for (p = h->h_aliases, q = h_aliases; *p != 0; p++, q++)
265 {
266 len = strlen(*p);
267 if (size <= pos + len)
268 {
269 *err = ENOMEM;
270 return NULL;
271 }
272 memcpy(buffer + pos, *p, len); /* copy content */
273 buffer[pos + len] = '\0';
274 *q = buffer + pos; /* set copied pointer to copied content */
275 pos += len + 1;
276 }
277 *++q = 0; /* null terminate the pointer list */
278 h->h_aliases = h_aliases; /* copy pointer to pointers */
279
280 return h;
281 }
282 #endif
283
284 #if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS
285 static wxMutex nameLock;
286 #endif
287 struct hostent * wxGethostbyname_r(const char *hostname, struct hostent *h,
288 void *buffer, int size, int *err)
289
290 {
291 struct hostent *he = NULL;
292 *err = 0;
293 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
294 if (gethostbyname_r(hostname, h, (char*)buffer, size, &he, err))
295 he = NULL;
296 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
297 he = gethostbyname_r(hostname, h, (char*)buffer, size, err);
298 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
299 if (gethostbyname_r(hostname, h, (struct hostent_data*) buffer))
300 {
301 he = NULL;
302 *err = h_errno;
303 }
304 else
305 he = h;
306 #elif defined(HAVE_GETHOSTBYNAME)
307 #if wxUSE_THREADS
308 wxMutexLocker locker(nameLock);
309 #endif
310 he = gethostbyname(hostname);
311 if (!he)
312 *err = h_errno;
313 else
314 he = deepCopyHostent(h, he, (char*)buffer, size, err);
315 #endif
316 return he;
317 }
318
319 #if defined(HAVE_GETHOSTBYNAME) && wxUSE_THREADS
320 static wxMutex addrLock;
321 #endif
322 struct hostent * wxGethostbyaddr_r(const char *addr_buf, int buf_size,
323 int proto, struct hostent *h,
324 void *buffer, int size, int *err)
325 {
326 struct hostent *he = NULL;
327 *err = 0;
328 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
329 if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
330 (char*)buffer, size, &he, err))
331 he = NULL;
332 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
333 he = gethostbyaddr_r(addr_buf, buf_size, proto, h, (char*)buffer, size, err);
334 #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
335 if (gethostbyaddr_r(addr_buf, buf_size, proto, h,
336 (struct hostent_data*) buffer))
337 {
338 he = NULL;
339 *err = h_errno;
340 }
341 else
342 he = h;
343 #elif defined(HAVE_GETHOSTBYNAME)
344 #if wxUSE_THREADS
345 wxMutexLocker locker(addrLock);
346 #endif
347 he = gethostbyaddr(addr_buf, buf_size, proto);
348 if (!he)
349 *err = h_errno;
350 else
351 he = deepCopyHostent(h, he, (char*)buffer, size, err);
352 #endif
353 return he;
354 }
355
356 #if defined(HAVE_GETSERVBYNAME)
357 static struct servent * deepCopyServent(struct servent *s,
358 const struct servent *se,
359 char *buffer, int size)
360 {
361 /* copy plain old structure */
362 memcpy(s, se, sizeof(struct servent));
363
364 /* copy name */
365 int len = strlen(s->s_name);
366 if (len >= size)
367 {
368 return NULL;
369 }
370 memcpy(buffer, s->s_name, len);
371 buffer[len] = '\0';
372 s->s_name = buffer;
373
374 /* track position in the buffer */
375 int pos = len + 1;
376
377 /* copy protocol */
378 len = strlen(s->s_proto);
379 if (pos + len >= size)
380 {
381 return NULL;
382 }
383 memcpy(buffer + pos, s->s_proto, len);
384 buffer[pos + len] = '\0';
385 s->s_proto = buffer + pos;
386
387 /* track position in the buffer */
388 pos += len + 1;
389
390 /* ensure pointer alignment */
391 unsigned int misalign = sizeof(char *) - pos%sizeof(char *);
392 if(misalign < sizeof(char *))
393 pos += misalign;
394
395 /* leave space for pointer list */
396 char **p = s->s_aliases, **q;
397 char **s_aliases = (char **)(buffer + pos);
398 while(*(p++) != 0)
399 pos += sizeof(char *);
400
401 /* copy addresses and fill new pointer list */
402 for (p = s->s_aliases, q = s_aliases; *p != 0; p++, q++){
403 len = strlen(*p);
404 if (size <= pos + len)
405 {
406 return NULL;
407 }
408 memcpy(buffer + pos, *p, len); /* copy content */
409 buffer[pos + len] = '\0';
410 *q = buffer + pos; /* set copied pointer to copied content */
411 pos += len + 1;
412 }
413 *++q = 0; /* null terminate the pointer list */
414 s->s_aliases = s_aliases; /* copy pointer to pointers */
415 return s;
416 }
417 #endif
418
419 #if defined(HAVE_GETSERVBYNAME) && wxUSE_THREADS
420 static wxMutex servLock;
421 #endif
422 struct servent *wxGetservbyname_r(const char *port, const char *protocol,
423 struct servent *serv, void *buffer, int size)
424 {
425 struct servent *se = NULL;
426 #if defined(HAVE_FUNC_GETSERVBYNAME_R_6)
427 if (getservbyname_r(port, protocol, serv, (char*)buffer, size, &se))
428 se = NULL;
429 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_5)
430 se = getservbyname_r(port, protocol, serv, (char*)buffer, size);
431 #elif defined(HAVE_FUNC_GETSERVBYNAME_R_4)
432 if (getservbyname_r(port, protocol, serv, (struct servent_data*) buffer))
433 se = NULL;
434 else
435 se = serv;
436 #elif defined(HAVE_GETSERVBYNAME)
437 #if wxUSE_THREADS
438 wxMutexLocker locker(servLock);
439 #endif
440 se = getservbyname(port, protocol);
441 if (se)
442 se = deepCopyServent(serv, se, (char*)buffer, size);
443 #endif
444 return se;
445 }
446
447 /* debugging helpers */
448 #ifdef __GSOCKET_DEBUG__
449 # define GSocket_Debug(args) printf args
450 #else
451 # define GSocket_Debug(args)
452 #endif /* __GSOCKET_DEBUG__ */
453
454 #if wxUSE_IPV6
455 typedef struct sockaddr_storage wxSockAddr;
456 #else
457 typedef struct sockaddr wxSockAddr;
458 #endif
459
460 /* Table of GUI-related functions. We must call them indirectly because
461 * of wxBase and GUI separation: */
462
463 bool GSocket_Init()
464 {
465 GSocketManager * const manager = GSocketManager::Get();
466 return manager && manager->OnInit();
467 }
468
469 void GSocket_Cleanup()
470 {
471 GSocketManager * const manager = GSocketManager::Get();
472 if ( manager )
473 manager->OnExit();
474 }
475
476 /* Constructors / Destructors for GSocket */
477
478 GSocket::GSocket()
479 {
480 int i;
481
482 m_fd = INVALID_SOCKET;
483 m_handler = NULL;
484
485 for (i=0;i<GSOCK_MAX_EVENT;i++)
486 {
487 m_cbacks[i] = NULL;
488 }
489 m_detected = 0;
490 m_local = NULL;
491 m_peer = NULL;
492 m_error = GSOCK_NOERROR;
493 m_server = false;
494 m_stream = true;
495 m_gui_dependent = NULL;
496 m_non_blocking = false;
497 m_reusable = false;
498 m_broadcast = false;
499 m_dobind = true;
500 m_timeout = 10*60*1000;
501 /* 10 minutes * 60 sec * 1000 millisec */
502 m_establishing = false;
503 m_use_events = false;
504 m_initialRecvBufferSize = -1;
505 m_initialSendBufferSize = -1;
506
507 m_ok = GSocketManager::Get()->Init_Socket(this);
508 }
509
510 void GSocket::Close()
511 {
512 if (m_use_events)
513 DisableEvents();
514
515 /* When running on OS X, the gsockosx implementation of GSocketGUIFunctionsTable
516 will close the socket during Disable_Events. However, it will only do this
517 if it is being used. That is, it won't do it in a console program. To
518 ensure we get the right behavior, we have gsockosx set m_fd = INVALID_SOCKET
519 if it has closed the socket which indicates to us (at runtime, instead of
520 at compile time as this had been before) that the socket has already
521 been closed.
522 */
523 if(m_fd != INVALID_SOCKET)
524 close(m_fd);
525 m_fd = INVALID_SOCKET;
526 }
527
528 GSocket::~GSocket()
529 {
530 assert(this);
531
532 /* Check that the socket is really shutdowned */
533 if (m_fd != INVALID_SOCKET)
534 Shutdown();
535
536 GSocketManager::Get()->Destroy_Socket(this);
537
538 delete m_handler;
539
540 /* Destroy private addresses */
541 if (m_local)
542 GAddress_destroy(m_local);
543
544 if (m_peer)
545 GAddress_destroy(m_peer);
546
547 }
548
549 /* GSocket_Shutdown:
550 * Disallow further read/write operations on this socket, close
551 * the fd and disable all callbacks.
552 */
553 void GSocket::Shutdown()
554 {
555 int evt;
556
557 assert(this);
558
559 /* Don't allow events to fire after socket has been closed */
560 if (m_use_events)
561 DisableEvents();
562
563 /* If socket has been created, shutdown it */
564 if (m_fd != INVALID_SOCKET)
565 {
566 shutdown(m_fd, 1);
567 Close();
568 }
569
570 /* Disable GUI callbacks */
571 for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
572 m_cbacks[evt] = NULL;
573
574 m_detected = GSOCK_LOST_FLAG;
575 }
576
577 /* Address handling */
578
579 /* GSocket_SetLocal:
580 * GSocket_GetLocal:
581 * GSocket_SetPeer:
582 * GSocket_GetPeer:
583 * Set or get the local or peer address for this socket. The 'set'
584 * functions return GSOCK_NOERROR on success, an error code otherwise.
585 * The 'get' functions return a pointer to a GAddress object on success,
586 * or NULL otherwise, in which case they set the error code of the
587 * corresponding GSocket.
588 *
589 * Error codes:
590 * GSOCK_INVSOCK - the socket is not valid.
591 * GSOCK_INVADDR - the address is not valid.
592 */
593 GSocketError GSocket::SetLocal(GAddress *address)
594 {
595 assert(this);
596
597 /* the socket must be initialized, or it must be a server */
598 if ((m_fd != INVALID_SOCKET && !m_server))
599 {
600 m_error = GSOCK_INVSOCK;
601 return GSOCK_INVSOCK;
602 }
603
604 /* check address */
605 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
606 {
607 m_error = GSOCK_INVADDR;
608 return GSOCK_INVADDR;
609 }
610
611 if (m_local)
612 GAddress_destroy(m_local);
613
614 m_local = GAddress_copy(address);
615
616 return GSOCK_NOERROR;
617 }
618
619 GSocketError GSocket::SetPeer(GAddress *address)
620 {
621 assert(this);
622
623 /* check address */
624 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
625 {
626 m_error = GSOCK_INVADDR;
627 return GSOCK_INVADDR;
628 }
629
630 if (m_peer)
631 GAddress_destroy(m_peer);
632
633 m_peer = GAddress_copy(address);
634
635 return GSOCK_NOERROR;
636 }
637
638 GAddress *GSocket::GetLocal()
639 {
640 GAddress *address;
641 wxSockAddr addr;
642 WX_SOCKLEN_T size = sizeof(addr);
643 GSocketError err;
644
645 assert(this);
646
647 /* try to get it from the m_local var first */
648 if (m_local)
649 return GAddress_copy(m_local);
650
651 /* else, if the socket is initialized, try getsockname */
652 if (m_fd == INVALID_SOCKET)
653 {
654 m_error = GSOCK_INVSOCK;
655 return NULL;
656 }
657
658 if (getsockname(m_fd, (sockaddr*)&addr, (WX_SOCKLEN_T *) &size) < 0)
659 {
660 m_error = GSOCK_IOERR;
661 return NULL;
662 }
663
664 /* got a valid address from getsockname, create a GAddress object */
665 address = GAddress_new();
666 if (address == NULL)
667 {
668 m_error = GSOCK_MEMERR;
669 return NULL;
670 }
671
672 err = _GAddress_translate_from(address, (sockaddr*)&addr, size);
673 if (err != GSOCK_NOERROR)
674 {
675 GAddress_destroy(address);
676 m_error = err;
677 return NULL;
678 }
679
680 return address;
681 }
682
683 GAddress *GSocket::GetPeer()
684 {
685 assert(this);
686
687 /* try to get it from the m_peer var */
688 if (m_peer)
689 return GAddress_copy(m_peer);
690
691 return NULL;
692 }
693
694 /* Server specific parts */
695
696 /* GSocket_SetServer:
697 * Sets up this socket as a server. The local address must have been
698 * set with GSocket_SetLocal() before GSocket_SetServer() is called.
699 * Returns GSOCK_NOERROR on success, one of the following otherwise:
700 *
701 * Error codes:
702 * GSOCK_INVSOCK - the socket is in use.
703 * GSOCK_INVADDR - the local address has not been set.
704 * GSOCK_IOERR - low-level error.
705 */
706 GSocketError GSocket::SetServer()
707 {
708 int arg = 1;
709
710 assert(this);
711
712 /* must not be in use */
713 if (m_fd != INVALID_SOCKET)
714 {
715 m_error = GSOCK_INVSOCK;
716 return GSOCK_INVSOCK;
717 }
718
719 /* the local addr must have been set */
720 if (!m_local)
721 {
722 m_error = GSOCK_INVADDR;
723 return GSOCK_INVADDR;
724 }
725
726 /* Initialize all fields */
727 m_stream = true;
728 m_server = true;
729
730 /* Create the socket */
731 m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
732
733 if (m_fd == INVALID_SOCKET)
734 {
735 m_error = GSOCK_IOERR;
736 return GSOCK_IOERR;
737 }
738
739 /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
740 #ifdef SO_NOSIGPIPE
741 setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));
742 #endif
743
744 ioctl(m_fd, FIONBIO, &arg);
745 if (m_use_events)
746 EnableEvents();
747
748 /* allow a socket to re-bind if the socket is in the TIME_WAIT
749 state after being previously closed.
750 */
751 if (m_reusable)
752 {
753 setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
754 #ifdef SO_REUSEPORT
755 setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
756 #endif
757 }
758
759 /* Bind to the local address,
760 * retrieve the actual address bound,
761 * and listen up to 5 connections.
762 */
763 if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
764 (getsockname(m_fd,
765 m_local->m_addr,
766 (WX_SOCKLEN_T *) &m_local->m_len) != 0) ||
767 (listen(m_fd, 5) != 0))
768 {
769 Close();
770 m_error = GSOCK_IOERR;
771 return GSOCK_IOERR;
772 }
773
774 return GSOCK_NOERROR;
775 }
776
777 /* GSocket_WaitConnection:
778 * Waits for an incoming client connection. Returns a pointer to
779 * a GSocket object, or NULL if there was an error, in which case
780 * the last error field will be updated for the calling GSocket.
781 *
782 * Error codes (set in the calling GSocket)
783 * GSOCK_INVSOCK - the socket is not valid or not a server.
784 * GSOCK_TIMEDOUT - timeout, no incoming connections.
785 * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
786 * GSOCK_MEMERR - couldn't allocate memory.
787 * GSOCK_IOERR - low-level error.
788 */
789 GSocket *GSocket::WaitConnection()
790 {
791 wxSockAddr from;
792 WX_SOCKLEN_T fromlen = sizeof(from);
793 GSocket *connection;
794 GSocketError err;
795 int arg = 1;
796
797 assert(this);
798
799 /* If the socket has already been created, we exit immediately */
800 if (m_fd == INVALID_SOCKET || !m_server)
801 {
802 m_error = GSOCK_INVSOCK;
803 return NULL;
804 }
805
806 /* Create a GSocket object for the new connection */
807 connection = GSocket_new();
808
809 if (!connection)
810 {
811 m_error = GSOCK_MEMERR;
812 return NULL;
813 }
814
815 /* Wait for a connection (with timeout) */
816 if (Input_Timeout() == GSOCK_TIMEDOUT)
817 {
818 delete connection;
819 /* m_error set by _GSocket_Input_Timeout */
820 return NULL;
821 }
822
823 connection->m_fd = accept(m_fd, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);
824
825 /* Reenable CONNECTION events */
826 Enable(GSOCK_CONNECTION);
827
828 if (connection->m_fd == INVALID_SOCKET)
829 {
830 if (errno == EWOULDBLOCK)
831 m_error = GSOCK_WOULDBLOCK;
832 else
833 m_error = GSOCK_IOERR;
834
835 delete connection;
836 return NULL;
837 }
838
839 /* Initialize all fields */
840 connection->m_server = false;
841 connection->m_stream = true;
842
843 /* Setup the peer address field */
844 connection->m_peer = GAddress_new();
845 if (!connection->m_peer)
846 {
847 delete connection;
848 m_error = GSOCK_MEMERR;
849 return NULL;
850 }
851
852 err = _GAddress_translate_from(connection->m_peer, (sockaddr*)&from, fromlen);
853 if (err != GSOCK_NOERROR)
854 {
855 delete connection;
856 m_error = err;
857 return NULL;
858 }
859
860 #if defined(__EMX__) || defined(__VISAGECPP__)
861 ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
862 #else
863 ioctl(connection->m_fd, FIONBIO, &arg);
864 #endif
865 if (m_use_events)
866 connection->Notify(true);
867
868 return connection;
869 }
870
871 void GSocket::Notify(bool flag)
872 {
873 if (flag == m_use_events)
874 return;
875 #if wxUSE_THREADS
876 // it is not safe to attach or detach i/o descriptor in child thread
877 wxASSERT_MSG( wxThread::IsMain(), "should be called in main thread only" );
878 #endif
879 m_use_events = flag;
880 EnableEvents(flag);
881 }
882
883 void GSocket::EnableEvents(bool flag)
884 {
885 if (flag)
886 GSocketManager::Get()->Enable_Events(this);
887 else
888 GSocketManager::Get()->Disable_Events(this);
889 }
890
891 bool GSocket::SetReusable()
892 {
893 /* socket must not be null, and must not be in use/already bound */
894 if (this && m_fd == INVALID_SOCKET)
895 {
896 m_reusable = true;
897
898 return true;
899 }
900
901 return false;
902 }
903
904 bool GSocket::SetBroadcast()
905 {
906 /* socket must not be in use/already bound */
907 if (m_fd == INVALID_SOCKET) {
908 m_broadcast = true;
909 return true;
910 }
911 return false;
912 }
913
914 bool GSocket::DontDoBind()
915 {
916 /* socket must not be in use/already bound */
917 if (m_fd == INVALID_SOCKET) {
918 m_dobind = false;
919 return true;
920 }
921 return false;
922 }
923
924 /* Client specific parts */
925
926 /* GSocket_Connect:
927 * For stream (connection oriented) sockets, GSocket_Connect() tries
928 * to establish a client connection to a server using the peer address
929 * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
930 * connection has been successfully established, or one of the error
931 * codes listed below. Note that for nonblocking sockets, a return
932 * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
933 * request can be completed later; you should use GSocket_Select()
934 * to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
935 * corresponding asynchronous events.
936 *
937 * For datagram (non connection oriented) sockets, GSocket_Connect()
938 * just sets the peer address established with GSocket_SetPeer() as
939 * default destination.
940 *
941 * Error codes:
942 * GSOCK_INVSOCK - the socket is in use or not valid.
943 * GSOCK_INVADDR - the peer address has not been established.
944 * GSOCK_TIMEDOUT - timeout, the connection failed.
945 * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
946 * GSOCK_MEMERR - couldn't allocate memory.
947 * GSOCK_IOERR - low-level error.
948 */
949 GSocketError GSocket::Connect(GSocketStream stream)
950 {
951 int err, ret;
952 int arg = 1;
953
954 assert(this);
955
956 /* Enable CONNECTION events (needed for nonblocking connections) */
957 Enable(GSOCK_CONNECTION);
958
959 if (m_fd != INVALID_SOCKET)
960 {
961 m_error = GSOCK_INVSOCK;
962 return GSOCK_INVSOCK;
963 }
964
965 if (!m_peer)
966 {
967 m_error = GSOCK_INVADDR;
968 return GSOCK_INVADDR;
969 }
970
971 /* Streamed or dgram socket? */
972 m_stream = (stream == GSOCK_STREAMED);
973 m_server = false;
974 m_establishing = false;
975
976 /* Create the socket */
977 m_fd = socket(m_peer->m_realfamily,
978 m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
979
980 if (m_fd == INVALID_SOCKET)
981 {
982 m_error = GSOCK_IOERR;
983 return GSOCK_IOERR;
984 }
985
986 /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
987 #ifdef SO_NOSIGPIPE
988 setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(arg));
989 #endif
990
991 #if defined(__EMX__) || defined(__VISAGECPP__)
992 ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
993 #else
994 ioctl(m_fd, FIONBIO, &arg);
995 #endif
996
997 // If the reuse flag is set, use the applicable socket reuse flags(s)
998 if (m_reusable)
999 {
1000 setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
1001 #ifdef SO_REUSEPORT
1002 setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
1003 #endif
1004 }
1005
1006 if (m_initialRecvBufferSize >= 0)
1007 setsockopt(m_fd, SOL_SOCKET, SO_RCVBUF, (const char*)&m_initialRecvBufferSize, sizeof(m_initialRecvBufferSize));
1008 if (m_initialSendBufferSize >= 0)
1009 setsockopt(m_fd, SOL_SOCKET, SO_SNDBUF, (const char*)&m_initialSendBufferSize, sizeof(m_initialSendBufferSize));
1010
1011 // If a local address has been set, then we need to bind to it before calling connect
1012 if (m_local && m_local->m_addr)
1013 {
1014 bind(m_fd, m_local->m_addr, m_local->m_len);
1015 }
1016
1017 /* Connect it to the peer address, with a timeout (see below) */
1018 ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
1019
1020 /* We only call Enable_Events if we know we aren't shutting down the socket.
1021 * NB: Enable_Events needs to be called whether the socket is blocking or
1022 * non-blocking, it just shouldn't be called prior to knowing there is a
1023 * connection _if_ blocking sockets are being used.
1024 * If connect above returns 0, we are already connected and need to make the
1025 * call to Enable_Events now.
1026 */
1027
1028 if (m_use_events && (m_non_blocking || ret == 0))
1029 EnableEvents();
1030
1031 if (ret == -1)
1032 {
1033 err = errno;
1034
1035 /* If connect failed with EINPROGRESS and the GSocket object
1036 * is in blocking mode, we select() for the specified timeout
1037 * checking for writability to see if the connection request
1038 * completes.
1039 */
1040 if ((err == EINPROGRESS) && (!m_non_blocking))
1041 {
1042 if (Output_Timeout() == GSOCK_TIMEDOUT)
1043 {
1044 Close();
1045 /* m_error is set in _GSocket_Output_Timeout */
1046 return GSOCK_TIMEDOUT;
1047 }
1048 else
1049 {
1050 int error;
1051 SOCKOPTLEN_T len = sizeof(error);
1052
1053 getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
1054 if (m_use_events)
1055 EnableEvents();
1056
1057 if (!error)
1058 return GSOCK_NOERROR;
1059 }
1060 }
1061
1062 /* If connect failed with EINPROGRESS and the GSocket object
1063 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
1064 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
1065 * this way if the connection completes, a GSOCK_CONNECTION
1066 * event will be generated, if enabled.
1067 */
1068 if ((err == EINPROGRESS) && (m_non_blocking))
1069 {
1070 m_establishing = true;
1071 m_error = GSOCK_WOULDBLOCK;
1072 return GSOCK_WOULDBLOCK;
1073 }
1074
1075 /* If connect failed with an error other than EINPROGRESS,
1076 * then the call to GSocket_Connect has failed.
1077 */
1078 Close();
1079 m_error = GSOCK_IOERR;
1080
1081 return GSOCK_IOERR;
1082 }
1083
1084 return GSOCK_NOERROR;
1085 }
1086
1087 /* Datagram sockets */
1088
1089 /* GSocket_SetNonOriented:
1090 * Sets up this socket as a non-connection oriented (datagram) socket.
1091 * Before using this function, the local address must have been set
1092 * with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
1093 * on success, or one of the following otherwise.
1094 *
1095 * Error codes:
1096 * GSOCK_INVSOCK - the socket is in use.
1097 * GSOCK_INVADDR - the local address has not been set.
1098 * GSOCK_IOERR - low-level error.
1099 */
1100 GSocketError GSocket::SetNonOriented()
1101 {
1102 int arg = 1;
1103
1104 assert(this);
1105
1106 if (m_fd != INVALID_SOCKET)
1107 {
1108 m_error = GSOCK_INVSOCK;
1109 return GSOCK_INVSOCK;
1110 }
1111
1112 if (!m_local)
1113 {
1114 m_error = GSOCK_INVADDR;
1115 return GSOCK_INVADDR;
1116 }
1117
1118 /* Initialize all fields */
1119 m_stream = false;
1120 m_server = false;
1121
1122 /* Create the socket */
1123 m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
1124
1125 if (m_fd == INVALID_SOCKET)
1126 {
1127 m_error = GSOCK_IOERR;
1128 return GSOCK_IOERR;
1129 }
1130 #if defined(__EMX__) || defined(__VISAGECPP__)
1131 ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
1132 #else
1133 ioctl(m_fd, FIONBIO, &arg);
1134 #endif
1135 if (m_use_events)
1136 EnableEvents();
1137
1138 if (m_reusable)
1139 {
1140 setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
1141 #ifdef SO_REUSEPORT
1142 setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT, (const char*)&arg, sizeof(arg));
1143 #endif
1144 }
1145
1146 if (m_broadcast)
1147 {
1148 setsockopt(m_fd, SOL_SOCKET, SO_BROADCAST, (const char*)&arg, sizeof(arg));
1149 }
1150 if (m_dobind)
1151 {
1152 /* Bind to the local address,
1153 * and retrieve the actual address bound.
1154 */
1155 if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
1156 (getsockname(m_fd,
1157 m_local->m_addr,
1158 (WX_SOCKLEN_T *) &m_local->m_len) != 0))
1159 {
1160 Close();
1161 m_error = GSOCK_IOERR;
1162 return GSOCK_IOERR;
1163 }
1164 }
1165 return GSOCK_NOERROR;
1166 }
1167
1168 /* Generic IO */
1169
1170 /* Like recv(), send(), ... */
1171 int GSocket::Read(char *buffer, int size)
1172 {
1173 int ret;
1174
1175 assert(this);
1176
1177 if (m_fd == INVALID_SOCKET || m_server)
1178 {
1179 m_error = GSOCK_INVSOCK;
1180 return -1;
1181 }
1182
1183 /* Disable events during query of socket status */
1184 Disable(GSOCK_INPUT);
1185
1186 /* If the socket is blocking, wait for data (with a timeout) */
1187 if (Input_Timeout() == GSOCK_TIMEDOUT) {
1188 m_error = GSOCK_TIMEDOUT;
1189 /* Don't return here immediately, otherwise socket events would not be
1190 * re-enabled! */
1191 ret = -1;
1192 }
1193 else
1194 {
1195 /* Read the data */
1196 if (m_stream)
1197 ret = Recv_Stream(buffer, size);
1198 else
1199 ret = Recv_Dgram(buffer, size);
1200
1201 /* If recv returned zero, then the connection has been gracefully closed.
1202 * Otherwise, recv has returned an error (-1), in which case we have lost the
1203 * socket only if errno does _not_ indicate that there may be more data to read.
1204 */
1205 if (ret == 0)
1206 {
1207 /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */
1208 if (m_use_events)
1209 {
1210 m_detected = GSOCK_LOST_FLAG;
1211 Detected_Read();
1212 return 0;
1213 }
1214 }
1215 else if (ret == -1)
1216 {
1217 if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1218 m_error = GSOCK_WOULDBLOCK;
1219 else
1220 m_error = GSOCK_IOERR;
1221 }
1222 }
1223
1224 /* Enable events again now that we are done processing */
1225 Enable(GSOCK_INPUT);
1226
1227 return ret;
1228 }
1229
1230 int GSocket::Write(const char *buffer, int size)
1231 {
1232 int ret;
1233
1234 assert(this);
1235
1236 GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
1237
1238 if (m_fd == INVALID_SOCKET || m_server)
1239 {
1240 m_error = GSOCK_INVSOCK;
1241 return -1;
1242 }
1243
1244 GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
1245
1246 /* If the socket is blocking, wait for writability (with a timeout) */
1247 if (Output_Timeout() == GSOCK_TIMEDOUT)
1248 return -1;
1249
1250 GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
1251
1252 /* Write the data */
1253 if (m_stream)
1254 ret = Send_Stream(buffer, size);
1255 else
1256 ret = Send_Dgram(buffer, size);
1257
1258 GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
1259
1260 if (ret == -1)
1261 {
1262 if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
1263 {
1264 m_error = GSOCK_WOULDBLOCK;
1265 GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
1266 }
1267 else
1268 {
1269 m_error = GSOCK_IOERR;
1270 GSocket_Debug(( "GSocket_Write error IOERR\n" ));
1271 }
1272
1273 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
1274 * in MSW). Once the first OUTPUT event is received, users can assume
1275 * that the socket is writable until a read operation fails. Only then
1276 * will further OUTPUT events be posted.
1277 */
1278 Enable(GSOCK_OUTPUT);
1279
1280 return -1;
1281 }
1282
1283 GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
1284
1285 return ret;
1286 }
1287
1288 /* GSocket_Select:
1289 * Polls the socket to determine its status. This function will
1290 * check for the events specified in the 'flags' parameter, and
1291 * it will return a mask indicating which operations can be
1292 * performed. This function won't block, regardless of the
1293 * mode (blocking | nonblocking) of the socket.
1294 */
1295 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
1296 {
1297 assert(this);
1298
1299 return flags & m_detected;
1300 }
1301
1302 /* Flags */
1303
1304 /* GSocket_SetNonBlocking:
1305 * Sets the socket to non-blocking mode. All IO calls will return
1306 * immediately.
1307 */
1308 void GSocket::SetNonBlocking(bool non_block)
1309 {
1310 assert(this);
1311
1312 GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1313
1314 m_non_blocking = non_block;
1315 }
1316
1317 /* GSocket_SetTimeout:
1318 * Sets the timeout for blocking calls. Time is expressed in
1319 * milliseconds.
1320 */
1321 void GSocket::SetTimeout(unsigned long millisec)
1322 {
1323 assert(this);
1324
1325 m_timeout = millisec;
1326 }
1327
1328 /* GSocket_GetError:
1329 * Returns the last error occurred for this socket. Note that successful
1330 * operations do not clear this back to GSOCK_NOERROR, so use it only
1331 * after an error.
1332 */
1333 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
1334 {
1335 assert(this);
1336
1337 return m_error;
1338 }
1339
1340 /* Callbacks */
1341
1342 /* GSOCK_INPUT:
1343 * There is data to be read in the input buffer. If, after a read
1344 * operation, there is still data available, the callback function will
1345 * be called again.
1346 * GSOCK_OUTPUT:
1347 * The socket is available for writing. That is, the next write call
1348 * won't block. This event is generated only once, when the connection is
1349 * first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1350 * when the output buffer empties again. This means that the app should
1351 * assume that it can write since the first OUTPUT event, and no more
1352 * OUTPUT events will be generated unless an error occurs.
1353 * GSOCK_CONNECTION:
1354 * Connection successfully established, for client sockets, or incoming
1355 * client connection, for server sockets. Wait for this event (also watch
1356 * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1357 * GSOCK_LOST:
1358 * The connection is lost (or a connection request failed); this could
1359 * be due to a failure, or due to the peer closing it gracefully.
1360 */
1361
1362 /* GSocket_SetCallback:
1363 * Enables the callbacks specified by 'flags'. Note that 'flags'
1364 * may be a combination of flags OR'ed toghether, so the same
1365 * callback function can be made to accept different events.
1366 * The callback function must have the following prototype:
1367 *
1368 * void function(GSocket *socket, GSocketEvent event, char *cdata)
1369 */
1370 void GSocket::SetCallback(GSocketEventFlags flags,
1371 GSocketCallback callback, char *cdata)
1372 {
1373 int count;
1374
1375 assert(this);
1376
1377 for (count = 0; count < GSOCK_MAX_EVENT; count++)
1378 {
1379 if ((flags & (1 << count)) != 0)
1380 {
1381 m_cbacks[count] = callback;
1382 m_data[count] = cdata;
1383 }
1384 }
1385 }
1386
1387 /* GSocket_UnsetCallback:
1388 * Disables all callbacks specified by 'flags', which may be a
1389 * combination of flags OR'ed toghether.
1390 */
1391 void GSocket::UnsetCallback(GSocketEventFlags flags)
1392 {
1393 int count;
1394
1395 assert(this);
1396
1397 for (count = 0; count < GSOCK_MAX_EVENT; count++)
1398 {
1399 if ((flags & (1 << count)) != 0)
1400 {
1401 m_cbacks[count] = NULL;
1402 m_data[count] = NULL;
1403 }
1404 }
1405 }
1406
1407 GSocketError GSocket::GetSockOpt(int level, int optname,
1408 void *optval, int *optlen)
1409 {
1410 if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
1411 return GSOCK_NOERROR;
1412
1413 return GSOCK_OPTERR;
1414 }
1415
1416 GSocketError GSocket::SetSockOpt(int level, int optname,
1417 const void *optval, int optlen)
1418 {
1419 if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
1420 return GSOCK_NOERROR;
1421
1422 return GSOCK_OPTERR;
1423 }
1424
1425 #define CALL_CALLBACK(socket, event) { \
1426 socket->Disable(event); \
1427 if (socket->m_cbacks[event]) \
1428 socket->m_cbacks[event](socket, event, socket->m_data[event]); \
1429 }
1430
1431
1432 void GSocket::Enable(GSocketEvent event)
1433 {
1434 if (m_use_events)
1435 {
1436 m_detected &= ~(1 << event);
1437 GSocketManager::Get()->Install_Callback(this, event);
1438 }
1439 }
1440
1441 void GSocket::Disable(GSocketEvent event)
1442 {
1443 if (m_use_events)
1444 {
1445 m_detected |= (1 << event);
1446 GSocketManager::Get()->Uninstall_Callback(this, event);
1447 }
1448 }
1449
1450 /* _GSocket_Input_Timeout:
1451 * For blocking sockets, wait until data is available or
1452 * until timeout ellapses.
1453 */
1454 GSocketError GSocket::Input_Timeout()
1455 {
1456 struct timeval tv;
1457 fd_set readfds;
1458 int ret;
1459
1460 /* Linux select() will overwrite the struct on return */
1461 tv.tv_sec = (m_timeout / 1000);
1462 tv.tv_usec = (m_timeout % 1000) * 1000;
1463
1464 if (!m_non_blocking)
1465 {
1466 wxFD_ZERO(&readfds);
1467 wxFD_SET(m_fd, &readfds);
1468 ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
1469 if (ret == 0)
1470 {
1471 GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1472 m_error = GSOCK_TIMEDOUT;
1473 return GSOCK_TIMEDOUT;
1474 }
1475
1476 if (ret == -1)
1477 {
1478 GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1479 if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1480 if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1481 if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1482 if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1483 m_error = GSOCK_TIMEDOUT;
1484 return GSOCK_TIMEDOUT;
1485 }
1486 }
1487
1488 return GSOCK_NOERROR;
1489 }
1490
1491 /* _GSocket_Output_Timeout:
1492 * For blocking sockets, wait until data can be sent without
1493 * blocking or until timeout ellapses.
1494 */
1495 GSocketError GSocket::Output_Timeout()
1496 {
1497 struct timeval tv;
1498 fd_set writefds;
1499 int ret;
1500
1501 /* Linux select() will overwrite the struct on return */
1502 tv.tv_sec = (m_timeout / 1000);
1503 tv.tv_usec = (m_timeout % 1000) * 1000;
1504
1505 GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
1506
1507 if (!m_non_blocking)
1508 {
1509 wxFD_ZERO(&writefds);
1510 wxFD_SET(m_fd, &writefds);
1511 ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
1512 if (ret == 0)
1513 {
1514 GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1515 m_error = GSOCK_TIMEDOUT;
1516 return GSOCK_TIMEDOUT;
1517 }
1518
1519 if (ret == -1)
1520 {
1521 GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1522 if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1523 if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1524 if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1525 if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1526 m_error = GSOCK_TIMEDOUT;
1527 return GSOCK_TIMEDOUT;
1528 }
1529
1530 if ( ! wxFD_ISSET(m_fd, &writefds) )
1531 {
1532 GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1533 }
1534 else
1535 {
1536 GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1537 }
1538 }
1539 else
1540 {
1541 GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1542 }
1543
1544 return GSOCK_NOERROR;
1545 }
1546
1547 int GSocket::Recv_Stream(char *buffer, int size)
1548 {
1549 int ret;
1550 do
1551 {
1552 ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
1553 }
1554 while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1555
1556 return ret;
1557 }
1558
1559 int GSocket::Recv_Dgram(char *buffer, int size)
1560 {
1561 wxSockAddr from;
1562 WX_SOCKLEN_T fromlen = sizeof(from);
1563 int ret;
1564 GSocketError err;
1565
1566 fromlen = sizeof(from);
1567
1568 do
1569 {
1570 ret = recvfrom(m_fd, buffer, size, 0, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);
1571 }
1572 while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1573
1574 if (ret == -1)
1575 return -1;
1576
1577 /* Translate a system address into a GSocket address */
1578 if (!m_peer)
1579 {
1580 m_peer = GAddress_new();
1581 if (!m_peer)
1582 {
1583 m_error = GSOCK_MEMERR;
1584 return -1;
1585 }
1586 }
1587
1588 err = _GAddress_translate_from(m_peer, (sockaddr*)&from, fromlen);
1589 if (err != GSOCK_NOERROR)
1590 {
1591 GAddress_destroy(m_peer);
1592 m_peer = NULL;
1593 m_error = err;
1594 return -1;
1595 }
1596
1597 return ret;
1598 }
1599
1600 int GSocket::Send_Stream(const char *buffer, int size)
1601 {
1602 int ret;
1603
1604 MASK_SIGNAL();
1605
1606 do
1607 {
1608 ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
1609 }
1610 while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1611
1612 UNMASK_SIGNAL();
1613
1614 return ret;
1615 }
1616
1617 int GSocket::Send_Dgram(const char *buffer, int size)
1618 {
1619 struct sockaddr *addr;
1620 int len, ret;
1621 GSocketError err;
1622
1623 if (!m_peer)
1624 {
1625 m_error = GSOCK_INVADDR;
1626 return -1;
1627 }
1628
1629 err = _GAddress_translate_to(m_peer, &addr, &len);
1630 if (err != GSOCK_NOERROR)
1631 {
1632 m_error = err;
1633 return -1;
1634 }
1635
1636 MASK_SIGNAL();
1637
1638 do
1639 {
1640 ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
1641 }
1642 while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1643
1644 UNMASK_SIGNAL();
1645
1646 /* Frees memory allocated from _GAddress_translate_to */
1647 free(addr);
1648
1649 return ret;
1650 }
1651
1652 void GSocket::Detected_Read()
1653 {
1654 char c;
1655
1656 /* Safeguard against straggling call to Detected_Read */
1657 if (m_fd == INVALID_SOCKET)
1658 {
1659 return;
1660 }
1661
1662 /* If we have already detected a LOST event, then don't try
1663 * to do any further processing.
1664 */
1665 if ((m_detected & GSOCK_LOST_FLAG) != 0)
1666 {
1667 m_establishing = false;
1668
1669 CALL_CALLBACK(this, GSOCK_LOST);
1670 Shutdown();
1671 return;
1672 }
1673
1674 int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1675
1676 if (num > 0)
1677 {
1678 CALL_CALLBACK(this, GSOCK_INPUT);
1679 }
1680 else
1681 {
1682 if (m_server && m_stream)
1683 {
1684 CALL_CALLBACK(this, GSOCK_CONNECTION);
1685 }
1686 else if (num == 0)
1687 {
1688 /* graceful shutdown */
1689 CALL_CALLBACK(this, GSOCK_LOST);
1690 Shutdown();
1691 }
1692 else
1693 {
1694 /* Do not throw a lost event in cases where the socket isn't really lost */
1695 if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
1696 {
1697 CALL_CALLBACK(this, GSOCK_INPUT);
1698 }
1699 else
1700 {
1701 CALL_CALLBACK(this, GSOCK_LOST);
1702 Shutdown();
1703 }
1704 }
1705 }
1706 }
1707
1708 void GSocket::Detected_Write()
1709 {
1710 /* If we have already detected a LOST event, then don't try
1711 * to do any further processing.
1712 */
1713 if ((m_detected & GSOCK_LOST_FLAG) != 0)
1714 {
1715 m_establishing = false;
1716
1717 CALL_CALLBACK(this, GSOCK_LOST);
1718 Shutdown();
1719 return;
1720 }
1721
1722 if (m_establishing && !m_server)
1723 {
1724 int error;
1725 SOCKOPTLEN_T len = sizeof(error);
1726
1727 m_establishing = false;
1728
1729 getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1730
1731 if (error)
1732 {
1733 CALL_CALLBACK(this, GSOCK_LOST);
1734 Shutdown();
1735 }
1736 else
1737 {
1738 CALL_CALLBACK(this, GSOCK_CONNECTION);
1739 /* We have to fire this event by hand because CONNECTION (for clients)
1740 * and OUTPUT are internally the same and we just disabled CONNECTION
1741 * events with the above macro.
1742 */
1743 CALL_CALLBACK(this, GSOCK_OUTPUT);
1744 }
1745 }
1746 else
1747 {
1748 CALL_CALLBACK(this, GSOCK_OUTPUT);
1749 }
1750 }
1751
1752 /* Compatibility functions for GSocket */
1753 GSocket *GSocket_new(void)
1754 {
1755 GSocket *newsocket = new GSocket();
1756 if (newsocket->IsOk())
1757 return newsocket;
1758
1759 delete newsocket;
1760
1761 return NULL;
1762 }
1763
1764 /*
1765 * -------------------------------------------------------------------------
1766 * GAddress
1767 * -------------------------------------------------------------------------
1768 */
1769
1770 /* CHECK_ADDRESS verifies that the current address family is either
1771 * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1772 * initalizes it to be a GSOCK_*family*. In other cases, it returns
1773 * an appropiate error code.
1774 *
1775 * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1776 */
1777 #define CHECK_ADDRESS(address, family) \
1778 { \
1779 if (address->m_family == GSOCK_NOFAMILY) \
1780 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1781 return address->m_error; \
1782 if (address->m_family != GSOCK_##family) \
1783 { \
1784 address->m_error = GSOCK_INVADDR; \
1785 return GSOCK_INVADDR; \
1786 } \
1787 }
1788
1789 #define CHECK_ADDRESS_RETVAL(address, family, retval) \
1790 { \
1791 if (address->m_family == GSOCK_NOFAMILY) \
1792 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1793 return retval; \
1794 if (address->m_family != GSOCK_##family) \
1795 { \
1796 address->m_error = GSOCK_INVADDR; \
1797 return retval; \
1798 } \
1799 }
1800
1801
1802 GAddress *GAddress_new(void)
1803 {
1804 GAddress *address;
1805
1806 if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1807 return NULL;
1808
1809 address->m_family = GSOCK_NOFAMILY;
1810 address->m_addr = NULL;
1811 address->m_len = 0;
1812
1813 return address;
1814 }
1815
1816 GAddress *GAddress_copy(GAddress *address)
1817 {
1818 GAddress *addr2;
1819
1820 assert(address != NULL);
1821
1822 if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1823 return NULL;
1824
1825 memcpy(addr2, address, sizeof(GAddress));
1826
1827 if (address->m_addr && address->m_len > 0)
1828 {
1829 addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1830 if (addr2->m_addr == NULL)
1831 {
1832 free(addr2);
1833 return NULL;
1834 }
1835 memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1836 }
1837
1838 return addr2;
1839 }
1840
1841 void GAddress_destroy(GAddress *address)
1842 {
1843 assert(address != NULL);
1844
1845 if (address->m_addr)
1846 free(address->m_addr);
1847
1848 free(address);
1849 }
1850
1851 void GAddress_SetFamily(GAddress *address, GAddressType type)
1852 {
1853 assert(address != NULL);
1854
1855 address->m_family = type;
1856 }
1857
1858 GAddressType GAddress_GetFamily(GAddress *address)
1859 {
1860 assert(address != NULL);
1861
1862 return address->m_family;
1863 }
1864
1865 GSocketError _GAddress_translate_from(GAddress *address,
1866 struct sockaddr *addr, int len)
1867 {
1868 address->m_realfamily = addr->sa_family;
1869 switch (addr->sa_family)
1870 {
1871 case AF_INET:
1872 address->m_family = GSOCK_INET;
1873 break;
1874 case AF_UNIX:
1875 address->m_family = GSOCK_UNIX;
1876 break;
1877 #if wxUSE_IPV6
1878 case AF_INET6:
1879 address->m_family = GSOCK_INET6;
1880 break;
1881 #endif // wxUSE_IPV6
1882 default:
1883 {
1884 address->m_error = GSOCK_INVOP;
1885 return GSOCK_INVOP;
1886 }
1887 }
1888
1889 if (address->m_addr)
1890 free(address->m_addr);
1891
1892 address->m_len = len;
1893 address->m_addr = (struct sockaddr *)malloc(len);
1894
1895 if (address->m_addr == NULL)
1896 {
1897 address->m_error = GSOCK_MEMERR;
1898 return GSOCK_MEMERR;
1899 }
1900
1901 memcpy(address->m_addr, addr, len);
1902
1903 return GSOCK_NOERROR;
1904 }
1905
1906 GSocketError _GAddress_translate_to(GAddress *address,
1907 struct sockaddr **addr, int *len)
1908 {
1909 if (!address->m_addr)
1910 {
1911 address->m_error = GSOCK_INVADDR;
1912 return GSOCK_INVADDR;
1913 }
1914
1915 *len = address->m_len;
1916 *addr = (struct sockaddr *)malloc(address->m_len);
1917 if (*addr == NULL)
1918 {
1919 address->m_error = GSOCK_MEMERR;
1920 return GSOCK_MEMERR;
1921 }
1922
1923 memcpy(*addr, address->m_addr, address->m_len);
1924 return GSOCK_NOERROR;
1925 }
1926
1927 /*
1928 * -------------------------------------------------------------------------
1929 * Internet address family
1930 * -------------------------------------------------------------------------
1931 */
1932
1933 GSocketError _GAddress_Init_INET(GAddress *address)
1934 {
1935 address->m_len = sizeof(struct sockaddr_in);
1936 address->m_addr = (struct sockaddr *) malloc(address->m_len);
1937 if (address->m_addr == NULL)
1938 {
1939 address->m_error = GSOCK_MEMERR;
1940 return GSOCK_MEMERR;
1941 }
1942
1943 address->m_family = GSOCK_INET;
1944 address->m_realfamily = PF_INET;
1945 ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1946 ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1947
1948 return GSOCK_NOERROR;
1949 }
1950
1951 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1952 {
1953 struct hostent *he;
1954 struct in_addr *addr;
1955
1956 assert(address != NULL);
1957
1958 CHECK_ADDRESS(address, INET);
1959
1960 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1961
1962 /* If it is a numeric host name, convert it now */
1963 #if defined(HAVE_INET_ATON)
1964 if (inet_aton(hostname, addr) == 0)
1965 {
1966 #elif defined(HAVE_INET_ADDR)
1967 if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
1968 {
1969 #else
1970 /* Use gethostbyname by default */
1971 #ifndef __WXMAC__
1972 int val = 1; /* VA doesn't like constants in conditional expressions */
1973 if (val)
1974 #endif
1975 {
1976 #endif
1977 struct in_addr *array_addr;
1978
1979 /* It is a real name, we solve it */
1980 struct hostent h;
1981 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
1982 struct hostent_data buffer;
1983 #else
1984 char buffer[1024];
1985 #endif
1986 int err;
1987 he = wxGethostbyname_r(hostname, &h, (void*)&buffer, sizeof(buffer), &err);
1988 if (he == NULL)
1989 {
1990 /* Reset to invalid address */
1991 addr->s_addr = INADDR_NONE;
1992 address->m_error = GSOCK_NOHOST;
1993 return GSOCK_NOHOST;
1994 }
1995
1996 array_addr = (struct in_addr *) *(he->h_addr_list);
1997 addr->s_addr = array_addr[0].s_addr;
1998 }
1999
2000 return GSOCK_NOERROR;
2001 }
2002
2003
2004 GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
2005 {
2006 return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
2007 }
2008
2009 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
2010 {
2011 return GAddress_INET_SetHostAddress(address, INADDR_ANY);
2012 }
2013
2014 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
2015 unsigned long hostaddr)
2016 {
2017 struct in_addr *addr;
2018
2019 assert(address != NULL);
2020
2021 CHECK_ADDRESS(address, INET);
2022
2023 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
2024 addr->s_addr = htonl(hostaddr);
2025
2026 return GSOCK_NOERROR;
2027 }
2028
2029 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
2030 const char *protocol)
2031 {
2032 struct servent *se;
2033 struct sockaddr_in *addr;
2034
2035 assert(address != NULL);
2036 CHECK_ADDRESS(address, INET);
2037
2038 if (!port)
2039 {
2040 address->m_error = GSOCK_INVPORT;
2041 return GSOCK_INVPORT;
2042 }
2043
2044 #if defined(HAVE_FUNC_GETSERVBYNAME_R_4)
2045 struct servent_data buffer;
2046 #else
2047 char buffer[1024];
2048 #endif
2049 struct servent serv;
2050 se = wxGetservbyname_r(port, protocol, &serv,
2051 (void*)&buffer, sizeof(buffer));
2052 if (!se)
2053 {
2054 /* the cast to int suppresses compiler warnings about subscript having the
2055 type char */
2056 if (isdigit((int)port[0]))
2057 {
2058 int port_int;
2059
2060 port_int = atoi(port);
2061 addr = (struct sockaddr_in *)address->m_addr;
2062 addr->sin_port = htons(port_int);
2063 return GSOCK_NOERROR;
2064 }
2065
2066 address->m_error = GSOCK_INVPORT;
2067 return GSOCK_INVPORT;
2068 }
2069
2070 addr = (struct sockaddr_in *)address->m_addr;
2071 addr->sin_port = se->s_port;
2072
2073 return GSOCK_NOERROR;
2074 }
2075
2076 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
2077 {
2078 struct sockaddr_in *addr;
2079
2080 assert(address != NULL);
2081 CHECK_ADDRESS(address, INET);
2082
2083 addr = (struct sockaddr_in *)address->m_addr;
2084 addr->sin_port = htons(port);
2085
2086 return GSOCK_NOERROR;
2087 }
2088
2089 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
2090 {
2091 struct hostent *he;
2092 char *addr_buf;
2093 struct sockaddr_in *addr;
2094
2095 assert(address != NULL);
2096 CHECK_ADDRESS(address, INET);
2097
2098 addr = (struct sockaddr_in *)address->m_addr;
2099 addr_buf = (char *)&(addr->sin_addr);
2100
2101 struct hostent temphost;
2102 #if defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
2103 struct hostent_data buffer;
2104 #else
2105 char buffer[1024];
2106 #endif
2107 int err;
2108 he = wxGethostbyaddr_r(addr_buf, sizeof(addr->sin_addr), AF_INET, &temphost,
2109 (void*)&buffer, sizeof(buffer), &err);
2110 if (he == NULL)
2111 {
2112 address->m_error = GSOCK_NOHOST;
2113 return GSOCK_NOHOST;
2114 }
2115
2116 strncpy(hostname, he->h_name, sbuf);
2117
2118 return GSOCK_NOERROR;
2119 }
2120
2121 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
2122 {
2123 struct sockaddr_in *addr;
2124
2125 assert(address != NULL);
2126 CHECK_ADDRESS_RETVAL(address, INET, 0);
2127
2128 addr = (struct sockaddr_in *)address->m_addr;
2129
2130 return ntohl(addr->sin_addr.s_addr);
2131 }
2132
2133 unsigned short GAddress_INET_GetPort(GAddress *address)
2134 {
2135 struct sockaddr_in *addr;
2136
2137 assert(address != NULL);
2138 CHECK_ADDRESS_RETVAL(address, INET, 0);
2139
2140 addr = (struct sockaddr_in *)address->m_addr;
2141 return ntohs(addr->sin_port);
2142 }
2143
2144 #if wxUSE_IPV6
2145 /*
2146 * -------------------------------------------------------------------------
2147 * Internet IPv6 address family
2148 * -------------------------------------------------------------------------
2149 */
2150
2151 GSocketError _GAddress_Init_INET6(GAddress *address)
2152 {
2153 struct in6_addr any_address = IN6ADDR_ANY_INIT;
2154 address->m_len = sizeof(struct sockaddr_in6);
2155 address->m_addr = (struct sockaddr *) malloc(address->m_len);
2156 if (address->m_addr == NULL)
2157 {
2158 address->m_error = GSOCK_MEMERR;
2159 return GSOCK_MEMERR;
2160 }
2161 memset(address->m_addr,0,address->m_len);
2162
2163 address->m_family = GSOCK_INET6;
2164 address->m_realfamily = AF_INET6;
2165 ((struct sockaddr_in6 *)address->m_addr)->sin6_family = AF_INET6;
2166 ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = any_address;
2167
2168 return GSOCK_NOERROR;
2169 }
2170
2171 GSocketError GAddress_INET6_SetHostName(GAddress *address, const char *hostname)
2172 {
2173 assert(address != NULL);
2174 CHECK_ADDRESS(address, INET6);
2175
2176 addrinfo hints;
2177 memset( & hints, 0, sizeof( hints ) );
2178 hints.ai_family = AF_INET6;
2179 addrinfo * info = 0;
2180 if ( getaddrinfo( hostname, "0", & hints, & info ) || ! info )
2181 {
2182 address->m_error = GSOCK_NOHOST;
2183 return GSOCK_NOHOST;
2184 }
2185
2186 memcpy( address->m_addr, info->ai_addr, info->ai_addrlen );
2187 freeaddrinfo( info );
2188 return GSOCK_NOERROR;
2189 }
2190
2191 GSocketError GAddress_INET6_SetAnyAddress(GAddress *address)
2192 {
2193 assert(address != NULL);
2194
2195 CHECK_ADDRESS(address, INET6);
2196
2197 struct in6_addr addr;
2198 memset( & addr, 0, sizeof( addr ) );
2199 return GAddress_INET6_SetHostAddress(address, addr);
2200 }
2201 GSocketError GAddress_INET6_SetHostAddress(GAddress *address,
2202 struct in6_addr hostaddr)
2203 {
2204 assert(address != NULL);
2205
2206 CHECK_ADDRESS(address, INET6);
2207
2208 ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = hostaddr;
2209
2210 return GSOCK_NOERROR;
2211 }
2212
2213 GSocketError GAddress_INET6_SetPortName(GAddress *address, const char *port,
2214 const char *protocol)
2215 {
2216 struct servent *se;
2217 struct sockaddr_in6 *addr;
2218
2219 assert(address != NULL);
2220 CHECK_ADDRESS(address, INET6);
2221
2222 if (!port)
2223 {
2224 address->m_error = GSOCK_INVPORT;
2225 return GSOCK_INVPORT;
2226 }
2227
2228 se = getservbyname(port, protocol);
2229 if (!se)
2230 {
2231 if (isdigit(port[0]))
2232 {
2233 int port_int;
2234
2235 port_int = atoi(port);
2236 addr = (struct sockaddr_in6 *)address->m_addr;
2237 addr->sin6_port = htons((u_short) port_int);
2238 return GSOCK_NOERROR;
2239 }
2240
2241 address->m_error = GSOCK_INVPORT;
2242 return GSOCK_INVPORT;
2243 }
2244
2245 addr = (struct sockaddr_in6 *)address->m_addr;
2246 addr->sin6_port = se->s_port;
2247
2248 return GSOCK_NOERROR;
2249 }
2250
2251 GSocketError GAddress_INET6_SetPort(GAddress *address, unsigned short port)
2252 {
2253 struct sockaddr_in6 *addr;
2254
2255 assert(address != NULL);
2256 CHECK_ADDRESS(address, INET6);
2257
2258 addr = (struct sockaddr_in6 *)address->m_addr;
2259 addr->sin6_port = htons(port);
2260
2261 return GSOCK_NOERROR;
2262 }
2263
2264 GSocketError GAddress_INET6_GetHostName(GAddress *address, char *hostname, size_t sbuf)
2265 {
2266 struct hostent *he;
2267 char *addr_buf;
2268 struct sockaddr_in6 *addr;
2269
2270 assert(address != NULL);
2271 CHECK_ADDRESS(address, INET6);
2272
2273 addr = (struct sockaddr_in6 *)address->m_addr;
2274 addr_buf = (char *)&(addr->sin6_addr);
2275
2276 he = gethostbyaddr(addr_buf, sizeof(addr->sin6_addr), AF_INET6);
2277 if (he == NULL)
2278 {
2279 address->m_error = GSOCK_NOHOST;
2280 return GSOCK_NOHOST;
2281 }
2282
2283 strncpy(hostname, he->h_name, sbuf);
2284
2285 return GSOCK_NOERROR;
2286 }
2287
2288 GSocketError GAddress_INET6_GetHostAddress(GAddress *address,struct in6_addr *hostaddr)
2289 {
2290 assert(address != NULL);
2291 assert(hostaddr != NULL);
2292 CHECK_ADDRESS_RETVAL(address, INET6, GSOCK_INVADDR);
2293 *hostaddr = ( (struct sockaddr_in6 *)address->m_addr )->sin6_addr;
2294 return GSOCK_NOERROR;
2295 }
2296
2297 unsigned short GAddress_INET6_GetPort(GAddress *address)
2298 {
2299 assert(address != NULL);
2300 CHECK_ADDRESS_RETVAL(address, INET6, 0);
2301
2302 return ntohs( ((struct sockaddr_in6 *)address->m_addr)->sin6_port );
2303 }
2304
2305 #endif // wxUSE_IPV6
2306
2307 /*
2308 * -------------------------------------------------------------------------
2309 * Unix address family
2310 * -------------------------------------------------------------------------
2311 */
2312
2313 #ifndef __VISAGECPP__
2314 GSocketError _GAddress_Init_UNIX(GAddress *address)
2315 {
2316 address->m_len = sizeof(struct sockaddr_un);
2317 address->m_addr = (struct sockaddr *)malloc(address->m_len);
2318 if (address->m_addr == NULL)
2319 {
2320 address->m_error = GSOCK_MEMERR;
2321 return GSOCK_MEMERR;
2322 }
2323
2324 address->m_family = GSOCK_UNIX;
2325 address->m_realfamily = PF_UNIX;
2326 ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
2327 ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
2328
2329 return GSOCK_NOERROR;
2330 }
2331
2332 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
2333
2334 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
2335 {
2336 struct sockaddr_un *addr;
2337
2338 assert(address != NULL);
2339
2340 CHECK_ADDRESS(address, UNIX);
2341
2342 addr = ((struct sockaddr_un *)address->m_addr);
2343 strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
2344 addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
2345
2346 return GSOCK_NOERROR;
2347 }
2348
2349 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
2350 {
2351 struct sockaddr_un *addr;
2352
2353 assert(address != NULL);
2354 CHECK_ADDRESS(address, UNIX);
2355
2356 addr = (struct sockaddr_un *)address->m_addr;
2357
2358 strncpy(path, addr->sun_path, sbuf);
2359
2360 return GSOCK_NOERROR;
2361 }
2362 #endif /* !defined(__VISAGECPP__) */
2363 #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
wxWidgets (Impactor)