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