/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/msw/gsocket.cpp
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/msw/gsocket.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 11 months ago) by william
File size: 37649 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
1 /* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket)
3 * Name: src/msw/gsocket.cpp
4 * Copyright: (c) Guilhem Lavaux
5 * Licence: wxWindows Licence
6 * Author: Guillermo Rodriguez Garcia <guille@iies.es>
7 * Purpose: GSocket main MSW file
8 * Licence: The wxWindows licence
9 * CVSID: $Id: gsocket.cpp 52492 2008-03-14 14:17:14Z JS $
10 * -------------------------------------------------------------------------
11 */
12
13 // For compilers that support precompilation, includes "wx.h".
14 #include "wx/wxprec.h"
15
16 #ifdef __BORLANDC__
17 #pragma hdrstop
18 #endif
19
20 #ifdef _MSC_VER
21 /* RPCNOTIFICATION_ROUTINE in rasasync.h (included from winsock.h),
22 * warning: conditional expression is constant.
23 */
24 # pragma warning(disable:4115)
25 /* FD_SET,
26 * warning: named type definition in parentheses.
27 */
28 # pragma warning(disable:4127)
29 /* GAddress_UNIX_GetPath,
30 * warning: unreferenced formal parameter.
31 */
32 # pragma warning(disable:4100)
33
34 #ifdef __WXWINCE__
35 /* windows.h results in tons of warnings at max warning level */
36 # ifdef _MSC_VER
37 # pragma warning(push, 1)
38 # endif
39 # include <windows.h>
40 # ifdef _MSC_VER
41 # pragma warning(pop)
42 # pragma warning(disable:4514)
43 # endif
44 #endif
45
46 #endif /* _MSC_VER */
47
48 #if defined(__CYGWIN__)
49 //CYGWIN gives annoying warning about runtime stuff if we don't do this
50 # define USE_SYS_TYPES_FD_SET
51 # include <sys/types.h>
52 #endif
53
54 #include <winsock.h>
55
56 #ifndef __GSOCKET_STANDALONE__
57 # include "wx/platform.h"
58 #endif
59
60 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
61
62 #ifndef __GSOCKET_STANDALONE__
63 # include "wx/msw/gsockmsw.h"
64 # include "wx/gsocket.h"
65 #else
66 # include "gsockmsw.h"
67 # include "gsocket.h"
68 #endif /* __GSOCKET_STANDALONE__ */
69
70 #ifndef __WXWINCE__
71 #include <assert.h>
72 #else
73 #define assert(x)
74 #ifndef isdigit
75 #define isdigit(x) (x > 47 && x < 58)
76 #endif
77 #include "wx/msw/wince/net.h"
78 #endif
79
80 #include <string.h>
81 #include <stdio.h>
82 #include <stdlib.h>
83 #include <stddef.h>
84 #include <ctype.h>
85
86 /* if we use configure for MSW WX_SOCKLEN_T will be already defined */
87 #ifndef WX_SOCKLEN_T
88 # define WX_SOCKLEN_T int
89 #endif
90
91 /* Table of GUI-related functions. We must call them indirectly because
92 * of wxBase and GUI separation: */
93
94 static GSocketGUIFunctionsTable *gs_gui_functions;
95
96 class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable
97 {
98 public:
99 virtual bool OnInit();
100 virtual void OnExit();
101 virtual bool CanUseEventLoop();
102 virtual bool Init_Socket(GSocket *socket);
103 virtual void Destroy_Socket(GSocket *socket);
104 virtual void Enable_Events(GSocket *socket);
105 virtual void Disable_Events(GSocket *socket);
106 };
107
108 bool GSocketGUIFunctionsTableNull::OnInit()
109 { return true; }
110 void GSocketGUIFunctionsTableNull::OnExit()
111 {}
112 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
113 { return false; }
114 bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))
115 { return true; }
116 void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket))
117 {}
118 void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket))
119 {}
120 void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket))
121 {}
122 /* Global initialisers */
123
124 void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc)
125 {
126 gs_gui_functions = guifunc;
127 }
128
129 int GSocket_Init(void)
130 {
131 WSADATA wsaData;
132
133 if (!gs_gui_functions)
134 {
135 static GSocketGUIFunctionsTableNull table;
136 gs_gui_functions = &table;
137 }
138 if ( !gs_gui_functions->OnInit() )
139 {
140 return 0;
141 }
142
143 /* Initialize WinSocket */
144 return (WSAStartup((1 << 8) | 1, &wsaData) == 0);
145 }
146
147 void GSocket_Cleanup(void)
148 {
149 if (gs_gui_functions)
150 {
151 gs_gui_functions->OnExit();
152 }
153
154 /* Cleanup WinSocket */
155 WSACleanup();
156 }
157
158 /* Constructors / Destructors for GSocket */
159
160 GSocket::GSocket()
161 {
162 int i;
163
164 m_fd = INVALID_SOCKET;
165 for (i = 0; i < GSOCK_MAX_EVENT; i++)
166 {
167 m_cbacks[i] = NULL;
168 }
169 m_detected = 0;
170 m_local = NULL;
171 m_peer = NULL;
172 m_error = GSOCK_NOERROR;
173 m_server = false;
174 m_stream = true;
175 m_non_blocking = false;
176 m_timeout.tv_sec = 10 * 60; /* 10 minutes */
177 m_timeout.tv_usec = 0;
178 m_establishing = false;
179 m_reusable = false;
180
181 assert(gs_gui_functions);
182 /* Per-socket GUI-specific initialization */
183 m_ok = gs_gui_functions->Init_Socket(this);
184 }
185
186 void GSocket::Close()
187 {
188 gs_gui_functions->Disable_Events(this);
189 closesocket(m_fd);
190 m_fd = INVALID_SOCKET;
191 }
192
193 GSocket::~GSocket()
194 {
195 assert(this);
196
197 /* Per-socket GUI-specific cleanup */
198 gs_gui_functions->Destroy_Socket(this);
199
200 /* Check that the socket is really shutdowned */
201 if (m_fd != INVALID_SOCKET)
202 Shutdown();
203
204 /* Destroy private addresses */
205 if (m_local)
206 GAddress_destroy(m_local);
207
208 if (m_peer)
209 GAddress_destroy(m_peer);
210 }
211
212 /* GSocket_Shutdown:
213 * Disallow further read/write operations on this socket, close
214 * the fd and disable all callbacks.
215 */
216 void GSocket::Shutdown()
217 {
218 int evt;
219
220 assert(this);
221
222 /* If socket has been created, shutdown it */
223 if (m_fd != INVALID_SOCKET)
224 {
225 shutdown(m_fd, 1 /* SD_SEND */);
226 Close();
227 }
228
229 /* Disable GUI callbacks */
230 for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
231 m_cbacks[evt] = NULL;
232
233 m_detected = GSOCK_LOST_FLAG;
234 }
235
236 /* Address handling */
237
238 /* GSocket_SetLocal:
239 * GSocket_GetLocal:
240 * GSocket_SetPeer:
241 * GSocket_GetPeer:
242 * Set or get the local or peer address for this socket. The 'set'
243 * functions return GSOCK_NOERROR on success, an error code otherwise.
244 * The 'get' functions return a pointer to a GAddress object on success,
245 * or NULL otherwise, in which case they set the error code of the
246 * corresponding GSocket.
247 *
248 * Error codes:
249 * GSOCK_INVSOCK - the socket is not valid.
250 * GSOCK_INVADDR - the address is not valid.
251 */
252 GSocketError GSocket::SetLocal(GAddress *address)
253 {
254 assert(this);
255
256 /* the socket must be initialized, or it must be a server */
257 if (m_fd != INVALID_SOCKET && !m_server)
258 {
259 m_error = GSOCK_INVSOCK;
260 return GSOCK_INVSOCK;
261 }
262
263 /* check address */
264 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
265 {
266 m_error = GSOCK_INVADDR;
267 return GSOCK_INVADDR;
268 }
269
270 if (m_local)
271 GAddress_destroy(m_local);
272
273 m_local = GAddress_copy(address);
274
275 return GSOCK_NOERROR;
276 }
277
278 GSocketError GSocket::SetPeer(GAddress *address)
279 {
280 assert(this);
281
282 /* check address */
283 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
284 {
285 m_error = GSOCK_INVADDR;
286 return GSOCK_INVADDR;
287 }
288
289 if (m_peer)
290 GAddress_destroy(m_peer);
291
292 m_peer = GAddress_copy(address);
293
294 return GSOCK_NOERROR;
295 }
296
297 GAddress *GSocket::GetLocal()
298 {
299 GAddress *address;
300 struct sockaddr addr;
301 WX_SOCKLEN_T size = sizeof(addr);
302 GSocketError err;
303
304 assert(this);
305
306 /* try to get it from the m_local var first */
307 if (m_local)
308 return GAddress_copy(m_local);
309
310 /* else, if the socket is initialized, try getsockname */
311 if (m_fd == INVALID_SOCKET)
312 {
313 m_error = GSOCK_INVSOCK;
314 return NULL;
315 }
316
317 if (getsockname(m_fd, &addr, &size) == SOCKET_ERROR)
318 {
319 m_error = GSOCK_IOERR;
320 return NULL;
321 }
322
323 /* got a valid address from getsockname, create a GAddress object */
324 if ((address = GAddress_new()) == NULL)
325 {
326 m_error = GSOCK_MEMERR;
327 return NULL;
328 }
329
330 if ((err = _GAddress_translate_from(address, &addr, size)) != GSOCK_NOERROR)
331 {
332 GAddress_destroy(address);
333 m_error = err;
334 return NULL;
335 }
336
337 return address;
338 }
339
340 GAddress *GSocket::GetPeer()
341 {
342 assert(this);
343
344 /* try to get it from the m_peer var */
345 if (m_peer)
346 return GAddress_copy(m_peer);
347
348 return NULL;
349 }
350
351 /* Server specific parts */
352
353 /* GSocket_SetServer:
354 * Sets up this socket as a server. The local address must have been
355 * set with GSocket_SetLocal() before GSocket_SetServer() is called.
356 * Returns GSOCK_NOERROR on success, one of the following otherwise:
357 *
358 * Error codes:
359 * GSOCK_INVSOCK - the socket is in use.
360 * GSOCK_INVADDR - the local address has not been set.
361 * GSOCK_IOERR - low-level error.
362 */
363 GSocketError GSocket::SetServer()
364 {
365 u_long arg = 1;
366
367 assert(this);
368
369 /* must not be in use */
370 if (m_fd != INVALID_SOCKET)
371 {
372 m_error = GSOCK_INVSOCK;
373 return GSOCK_INVSOCK;
374 }
375
376 /* the local addr must have been set */
377 if (!m_local)
378 {
379 m_error = GSOCK_INVADDR;
380 return GSOCK_INVADDR;
381 }
382
383 /* Initialize all fields */
384 m_server = true;
385 m_stream = true;
386
387 /* Create the socket */
388 m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
389
390 if (m_fd == INVALID_SOCKET)
391 {
392 m_error = GSOCK_IOERR;
393 return GSOCK_IOERR;
394 }
395
396 ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
397 gs_gui_functions->Enable_Events(this);
398
399 /* allow a socket to re-bind if the socket is in the TIME_WAIT
400 state after being previously closed.
401 */
402 if (m_reusable)
403 {
404 setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
405 }
406
407 /* Bind to the local address,
408 * retrieve the actual address bound,
409 * and listen up to 5 connections.
410 */
411 if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
412 (getsockname(m_fd,
413 m_local->m_addr,
414 (WX_SOCKLEN_T *)&m_local->m_len) != 0) ||
415 (listen(m_fd, 5) != 0))
416 {
417 Close();
418 m_error = GSOCK_IOERR;
419 return GSOCK_IOERR;
420 }
421
422 return GSOCK_NOERROR;
423 }
424
425 /* GSocket_WaitConnection:
426 * Waits for an incoming client connection. Returns a pointer to
427 * a GSocket object, or NULL if there was an error, in which case
428 * the last error field will be updated for the calling GSocket.
429 *
430 * Error codes (set in the calling GSocket)
431 * GSOCK_INVSOCK - the socket is not valid or not a server.
432 * GSOCK_TIMEDOUT - timeout, no incoming connections.
433 * GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
434 * GSOCK_MEMERR - couldn't allocate memory.
435 * GSOCK_IOERR - low-level error.
436 */
437 GSocket *GSocket::WaitConnection()
438 {
439 GSocket *connection;
440 struct sockaddr from;
441 WX_SOCKLEN_T fromlen = sizeof(from);
442 GSocketError err;
443 u_long arg = 1;
444
445 assert(this);
446
447 /* Reenable CONNECTION events */
448 m_detected &= ~GSOCK_CONNECTION_FLAG;
449
450 /* If the socket has already been created, we exit immediately */
451 if (m_fd == INVALID_SOCKET || !m_server)
452 {
453 m_error = GSOCK_INVSOCK;
454 return NULL;
455 }
456
457 /* Create a GSocket object for the new connection */
458 connection = GSocket_new();
459
460 if (!connection)
461 {
462 m_error = GSOCK_MEMERR;
463 return NULL;
464 }
465
466 /* Wait for a connection (with timeout) */
467 if (Input_Timeout() == GSOCK_TIMEDOUT)
468 {
469 delete connection;
470 /* m_error set by _GSocket_Input_Timeout */
471 return NULL;
472 }
473
474 connection->m_fd = accept(m_fd, &from, &fromlen);
475
476 if (connection->m_fd == INVALID_SOCKET)
477 {
478 if (WSAGetLastError() == WSAEWOULDBLOCK)
479 m_error = GSOCK_WOULDBLOCK;
480 else
481 m_error = GSOCK_IOERR;
482
483 delete connection;
484 return NULL;
485 }
486
487 /* Initialize all fields */
488 connection->m_server = false;
489 connection->m_stream = true;
490
491 /* Setup the peer address field */
492 connection->m_peer = GAddress_new();
493 if (!connection->m_peer)
494 {
495 delete connection;
496 m_error = GSOCK_MEMERR;
497 return NULL;
498 }
499 err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
500 if (err != GSOCK_NOERROR)
501 {
502 GAddress_destroy(connection->m_peer);
503 delete connection;
504 m_error = err;
505 return NULL;
506 }
507
508 ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg);
509 gs_gui_functions->Enable_Events(connection);
510
511 return connection;
512 }
513
514 /* GSocket_SetReusable:
515 * Simply sets the m_resuable flag on the socket. GSocket_SetServer will
516 * make the appropriate setsockopt() call.
517 * Implemented as a GSocket function because clients (ie, wxSocketServer)
518 * don't have access to the GSocket struct information.
519 * Returns true if the flag was set correctly, false if an error occurred
520 * (ie, if the parameter was NULL)
521 */
522 bool GSocket::SetReusable()
523 {
524 /* socket must not be null, and must not be in use/already bound */
525 if (this && m_fd == INVALID_SOCKET) {
526 m_reusable = true;
527 return true;
528 }
529 return false;
530 }
531
532 /* Client specific parts */
533
534 /* GSocket_Connect:
535 * For stream (connection oriented) sockets, GSocket_Connect() tries
536 * to establish a client connection to a server using the peer address
537 * as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
538 * connection has been successfully established, or one of the error
539 * codes listed below. Note that for nonblocking sockets, a return
540 * value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
541 * request can be completed later; you should use GSocket_Select()
542 * to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
543 * corresponding asynchronous events.
544 *
545 * For datagram (non connection oriented) sockets, GSocket_Connect()
546 * just sets the peer address established with GSocket_SetPeer() as
547 * default destination.
548 *
549 * Error codes:
550 * GSOCK_INVSOCK - the socket is in use or not valid.
551 * GSOCK_INVADDR - the peer address has not been established.
552 * GSOCK_TIMEDOUT - timeout, the connection failed.
553 * GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
554 * GSOCK_MEMERR - couldn't allocate memory.
555 * GSOCK_IOERR - low-level error.
556 */
557 GSocketError GSocket::Connect(GSocketStream stream)
558 {
559 int ret, err;
560 u_long arg = 1;
561
562 assert(this);
563
564 /* Enable CONNECTION events (needed for nonblocking connections) */
565 m_detected &= ~GSOCK_CONNECTION_FLAG;
566
567 if (m_fd != INVALID_SOCKET)
568 {
569 m_error = GSOCK_INVSOCK;
570 return GSOCK_INVSOCK;
571 }
572
573 if (!m_peer)
574 {
575 m_error = GSOCK_INVADDR;
576 return GSOCK_INVADDR;
577 }
578
579 /* Streamed or dgram socket? */
580 m_stream = (stream == GSOCK_STREAMED);
581 m_server = false;
582 m_establishing = false;
583
584 /* Create the socket */
585 m_fd = socket(m_peer->m_realfamily,
586 m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
587
588 if (m_fd == INVALID_SOCKET)
589 {
590 m_error = GSOCK_IOERR;
591 return GSOCK_IOERR;
592 }
593
594 ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
595 gs_gui_functions->Enable_Events(this);
596
597 // If the reuse flag is set, use the applicable socket reuse flag
598 if (m_reusable)
599 {
600 setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
601 }
602
603 // If a local address has been set, then we need to bind to it before calling connect
604 if (m_local && m_local->m_addr)
605 {
606 bind(m_fd, m_local->m_addr, m_local->m_len);
607 }
608
609 /* Connect it to the peer address, with a timeout (see below) */
610 ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
611
612 if (ret == SOCKET_ERROR)
613 {
614 err = WSAGetLastError();
615
616 /* If connect failed with EWOULDBLOCK and the GSocket object
617 * is in blocking mode, we select() for the specified timeout
618 * checking for writability to see if the connection request
619 * completes.
620 */
621 if ((err == WSAEWOULDBLOCK) && (!m_non_blocking))
622 {
623 err = Connect_Timeout();
624
625 if (err != GSOCK_NOERROR)
626 {
627 Close();
628 /* m_error is set in _GSocket_Connect_Timeout */
629 }
630
631 return (GSocketError) err;
632 }
633
634 /* If connect failed with EWOULDBLOCK and the GSocket object
635 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
636 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
637 * this way if the connection completes, a GSOCK_CONNECTION
638 * event will be generated, if enabled.
639 */
640 if ((err == WSAEWOULDBLOCK) && (m_non_blocking))
641 {
642 m_establishing = true;
643 m_error = GSOCK_WOULDBLOCK;
644 return GSOCK_WOULDBLOCK;
645 }
646
647 /* If connect failed with an error other than EWOULDBLOCK,
648 * then the call to GSocket_Connect() has failed.
649 */
650 Close();
651 m_error = GSOCK_IOERR;
652 return GSOCK_IOERR;
653 }
654
655 return GSOCK_NOERROR;
656 }
657
658 /* Datagram sockets */
659
660 /* GSocket_SetNonOriented:
661 * Sets up this socket as a non-connection oriented (datagram) socket.
662 * Before using this function, the local address must have been set
663 * with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
664 * on success, or one of the following otherwise.
665 *
666 * Error codes:
667 * GSOCK_INVSOCK - the socket is in use.
668 * GSOCK_INVADDR - the local address has not been set.
669 * GSOCK_IOERR - low-level error.
670 */
671 GSocketError GSocket::SetNonOriented()
672 {
673 u_long arg = 1;
674
675 assert(this);
676
677 if (m_fd != INVALID_SOCKET)
678 {
679 m_error = GSOCK_INVSOCK;
680 return GSOCK_INVSOCK;
681 }
682
683 if (!m_local)
684 {
685 m_error = GSOCK_INVADDR;
686 return GSOCK_INVADDR;
687 }
688
689 /* Initialize all fields */
690 m_stream = false;
691 m_server = false;
692
693 /* Create the socket */
694 m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
695
696 if (m_fd == INVALID_SOCKET)
697 {
698 m_error = GSOCK_IOERR;
699 return GSOCK_IOERR;
700 }
701
702 ioctlsocket(m_fd, FIONBIO, (u_long FAR *) &arg);
703 gs_gui_functions->Enable_Events(this);
704
705 if (m_reusable)
706 {
707 setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(arg));
708 }
709
710 /* Bind to the local address,
711 * and retrieve the actual address bound.
712 */
713 if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
714 (getsockname(m_fd,
715 m_local->m_addr,
716 (WX_SOCKLEN_T *)&m_local->m_len) != 0))
717 {
718 Close();
719 m_error = GSOCK_IOERR;
720 return GSOCK_IOERR;
721 }
722
723 return GSOCK_NOERROR;
724 }
725
726 /* Generic IO */
727
728 /* Like recv(), send(), ... */
729 int GSocket::Read(char *buffer, int size)
730 {
731 int ret;
732
733 assert(this);
734
735 /* Reenable INPUT events */
736 m_detected &= ~GSOCK_INPUT_FLAG;
737
738 if (m_fd == INVALID_SOCKET || m_server)
739 {
740 m_error = GSOCK_INVSOCK;
741 return -1;
742 }
743
744 /* If the socket is blocking, wait for data (with a timeout) */
745 if (Input_Timeout() == GSOCK_TIMEDOUT)
746 {
747 m_error = GSOCK_TIMEDOUT;
748 return -1;
749 }
750
751 /* Read the data */
752 if (m_stream)
753 ret = Recv_Stream(buffer, size);
754 else
755 ret = Recv_Dgram(buffer, size);
756
757 if (ret == SOCKET_ERROR)
758 {
759 if (WSAGetLastError() != WSAEWOULDBLOCK)
760 m_error = GSOCK_IOERR;
761 else
762 m_error = GSOCK_WOULDBLOCK;
763 return -1;
764 }
765
766 return ret;
767 }
768
769 int GSocket::Write(const char *buffer, int size)
770 {
771 int ret;
772
773 assert(this);
774
775 if (m_fd == INVALID_SOCKET || m_server)
776 {
777 m_error = GSOCK_INVSOCK;
778 return -1;
779 }
780
781 /* If the socket is blocking, wait for writability (with a timeout) */
782 if (Output_Timeout() == GSOCK_TIMEDOUT)
783 return -1;
784
785 /* Write the data */
786 if (m_stream)
787 ret = Send_Stream(buffer, size);
788 else
789 ret = Send_Dgram(buffer, size);
790
791 if (ret == SOCKET_ERROR)
792 {
793 if (WSAGetLastError() != WSAEWOULDBLOCK)
794 m_error = GSOCK_IOERR;
795 else
796 m_error = GSOCK_WOULDBLOCK;
797
798 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
799 * does). Once the first OUTPUT event is received, users can assume
800 * that the socket is writable until a read operation fails. Only then
801 * will further OUTPUT events be posted.
802 */
803 m_detected &= ~GSOCK_OUTPUT_FLAG;
804 return -1;
805 }
806
807 return ret;
808 }
809
810 /* GSocket_Select:
811 * Polls the socket to determine its status. This function will
812 * check for the events specified in the 'flags' parameter, and
813 * it will return a mask indicating which operations can be
814 * performed. This function won't block, regardless of the
815 * mode (blocking | nonblocking) of the socket.
816 */
817 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
818 {
819 if (!gs_gui_functions->CanUseEventLoop())
820 {
821 GSocketEventFlags result = 0;
822 fd_set readfds;
823 fd_set writefds;
824 fd_set exceptfds;
825
826 assert(this);
827
828 FD_ZERO(&readfds);
829 FD_ZERO(&writefds);
830 FD_ZERO(&exceptfds);
831 FD_SET(m_fd, &readfds);
832 if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
833 FD_SET(m_fd, &writefds);
834 FD_SET(m_fd, &exceptfds);
835
836 /* Check 'sticky' CONNECTION flag first */
837 result |= (GSOCK_CONNECTION_FLAG & m_detected);
838
839 /* If we have already detected a LOST event, then don't try
840 * to do any further processing.
841 */
842 if ((m_detected & GSOCK_LOST_FLAG) != 0)
843 {
844 m_establishing = false;
845
846 return (GSOCK_LOST_FLAG & flags);
847 }
848
849 /* Try select now */
850 if (select(m_fd + 1, &readfds, &writefds, &exceptfds,
851 &m_timeout) <= 0)
852 {
853 /* What to do here? */
854 return (result & flags);
855 }
856
857 /* Check for exceptions and errors */
858 if (FD_ISSET(m_fd, &exceptfds))
859 {
860 m_establishing = false;
861 m_detected = GSOCK_LOST_FLAG;
862
863 /* LOST event: Abort any further processing */
864 return (GSOCK_LOST_FLAG & flags);
865 }
866
867 /* Check for readability */
868 if (FD_ISSET(m_fd, &readfds))
869 {
870 result |= GSOCK_INPUT_FLAG;
871
872 if (m_server && m_stream)
873 {
874 /* This is a TCP server socket that detected a connection.
875 While the INPUT_FLAG is also set, it doesn't matter on
876 this kind of sockets, as we can only Accept() from them. */
877 result |= GSOCK_CONNECTION_FLAG;
878 m_detected |= GSOCK_CONNECTION_FLAG;
879 }
880 }
881
882 /* Check for writability */
883 if (FD_ISSET(m_fd, &writefds))
884 {
885 if (m_establishing && !m_server)
886 {
887 int error;
888 WX_SOCKLEN_T len = sizeof(error);
889
890 m_establishing = false;
891
892 getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
893
894 if (error)
895 {
896 m_detected = GSOCK_LOST_FLAG;
897
898 /* LOST event: Abort any further processing */
899 return (GSOCK_LOST_FLAG & flags);
900 }
901 else
902 {
903 result |= GSOCK_CONNECTION_FLAG;
904 m_detected |= GSOCK_CONNECTION_FLAG;
905 }
906 }
907 else
908 {
909 result |= GSOCK_OUTPUT_FLAG;
910 }
911 }
912
913 return (result & flags);
914 }
915 else /* USE_GUI() */
916 {
917 assert(this);
918 return flags & m_detected;
919 }
920 }
921
922 /* Attributes */
923
924 /* GSocket_SetNonBlocking:
925 * Sets the socket to non-blocking mode. All IO calls will return
926 * immediately.
927 */
928 void GSocket::SetNonBlocking(bool non_block)
929 {
930 assert(this);
931
932 m_non_blocking = non_block;
933 }
934
935 /* GSocket_SetTimeout:
936 * Sets the timeout for blocking calls. Time is expressed in
937 * milliseconds.
938 */
939 void GSocket::SetTimeout(unsigned long millis)
940 {
941 assert(this);
942
943 m_timeout.tv_sec = (millis / 1000);
944 m_timeout.tv_usec = (millis % 1000) * 1000;
945 }
946
947 /* GSocket_GetError:
948 * Returns the last error occurred for this socket. Note that successful
949 * operations do not clear this back to GSOCK_NOERROR, so use it only
950 * after an error.
951 */
952 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
953 {
954 assert(this);
955
956 return m_error;
957 }
958
959 /* Callbacks */
960
961 /* GSOCK_INPUT:
962 * There is data to be read in the input buffer. If, after a read
963 * operation, there is still data available, the callback function will
964 * be called again.
965 * GSOCK_OUTPUT:
966 * The socket is available for writing. That is, the next write call
967 * won't block. This event is generated only once, when the connection is
968 * first established, and then only if a call failed with GSOCK_WOULDBLOCK,
969 * when the output buffer empties again. This means that the app should
970 * assume that it can write since the first OUTPUT event, and no more
971 * OUTPUT events will be generated unless an error occurs.
972 * GSOCK_CONNECTION:
973 * Connection successfully established, for client sockets, or incoming
974 * client connection, for server sockets. Wait for this event (also watch
975 * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
976 * GSOCK_LOST:
977 * The connection is lost (or a connection request failed); this could
978 * be due to a failure, or due to the peer closing it gracefully.
979 */
980
981 /* GSocket_SetCallback:
982 * Enables the callbacks specified by 'flags'. Note that 'flags'
983 * may be a combination of flags OR'ed toghether, so the same
984 * callback function can be made to accept different events.
985 * The callback function must have the following prototype:
986 *
987 * void function(GSocket *socket, GSocketEvent event, char *cdata)
988 */
989 void GSocket::SetCallback(GSocketEventFlags flags,
990 GSocketCallback callback, char *cdata)
991 {
992 int count;
993
994 assert(this);
995
996 for (count = 0; count < GSOCK_MAX_EVENT; count++)
997 {
998 if ((flags & (1 << count)) != 0)
999 {
1000 m_cbacks[count] = callback;
1001 m_data[count] = cdata;
1002 }
1003 }
1004 }
1005
1006 /* GSocket_UnsetCallback:
1007 * Disables all callbacks specified by 'flags', which may be a
1008 * combination of flags OR'ed toghether.
1009 */
1010 void GSocket::UnsetCallback(GSocketEventFlags flags)
1011 {
1012 int count;
1013
1014 assert(this);
1015
1016 for (count = 0; count < GSOCK_MAX_EVENT; count++)
1017 {
1018 if ((flags & (1 << count)) != 0)
1019 {
1020 m_cbacks[count] = NULL;
1021 m_data[count] = NULL;
1022 }
1023 }
1024 }
1025
1026 GSocketError GSocket::GetSockOpt(int level, int optname,
1027 void *optval, int *optlen)
1028 {
1029 if (getsockopt(m_fd, level, optname, (char*)optval, optlen) == 0)
1030 {
1031 return GSOCK_NOERROR;
1032 }
1033 return GSOCK_OPTERR;
1034 }
1035
1036 GSocketError GSocket::SetSockOpt(int level, int optname,
1037 const void *optval, int optlen)
1038 {
1039 if (setsockopt(m_fd, level, optname, (char*)optval, optlen) == 0)
1040 {
1041 return GSOCK_NOERROR;
1042 }
1043 return GSOCK_OPTERR;
1044 }
1045
1046 /* Internals (IO) */
1047
1048 /* _GSocket_Input_Timeout:
1049 * For blocking sockets, wait until data is available or
1050 * until timeout ellapses.
1051 */
1052 GSocketError GSocket::Input_Timeout()
1053 {
1054 fd_set readfds;
1055
1056 if (!m_non_blocking)
1057 {
1058 FD_ZERO(&readfds);
1059 FD_SET(m_fd, &readfds);
1060 if (select(0, &readfds, NULL, NULL, &m_timeout) == 0)
1061 {
1062 m_error = GSOCK_TIMEDOUT;
1063 return GSOCK_TIMEDOUT;
1064 }
1065 }
1066 return GSOCK_NOERROR;
1067 }
1068
1069 /* _GSocket_Output_Timeout:
1070 * For blocking sockets, wait until data can be sent without
1071 * blocking or until timeout ellapses.
1072 */
1073 GSocketError GSocket::Output_Timeout()
1074 {
1075 fd_set writefds;
1076
1077 if (!m_non_blocking)
1078 {
1079 FD_ZERO(&writefds);
1080 FD_SET(m_fd, &writefds);
1081 if (select(0, NULL, &writefds, NULL, &m_timeout) == 0)
1082 {
1083 m_error = GSOCK_TIMEDOUT;
1084 return GSOCK_TIMEDOUT;
1085 }
1086 }
1087 return GSOCK_NOERROR;
1088 }
1089
1090 /* _GSocket_Connect_Timeout:
1091 * For blocking sockets, wait until the connection is
1092 * established or fails, or until timeout ellapses.
1093 */
1094 GSocketError GSocket::Connect_Timeout()
1095 {
1096 fd_set writefds;
1097 fd_set exceptfds;
1098
1099 FD_ZERO(&writefds);
1100 FD_ZERO(&exceptfds);
1101 FD_SET(m_fd, &writefds);
1102 FD_SET(m_fd, &exceptfds);
1103 if (select(0, NULL, &writefds, &exceptfds, &m_timeout) == 0)
1104 {
1105 m_error = GSOCK_TIMEDOUT;
1106 return GSOCK_TIMEDOUT;
1107 }
1108 if (!FD_ISSET(m_fd, &writefds))
1109 {
1110 m_error = GSOCK_IOERR;
1111 return GSOCK_IOERR;
1112 }
1113
1114 return GSOCK_NOERROR;
1115 }
1116
1117 int GSocket::Recv_Stream(char *buffer, int size)
1118 {
1119 return recv(m_fd, buffer, size, 0);
1120 }
1121
1122 int GSocket::Recv_Dgram(char *buffer, int size)
1123 {
1124 struct sockaddr from;
1125 WX_SOCKLEN_T fromlen = sizeof(from);
1126 int ret;
1127 GSocketError err;
1128
1129 ret = recvfrom(m_fd, buffer, size, 0, &from, &fromlen);
1130
1131 if (ret == SOCKET_ERROR)
1132 return SOCKET_ERROR;
1133
1134 /* Translate a system address into a GSocket address */
1135 if (!m_peer)
1136 {
1137 m_peer = GAddress_new();
1138 if (!m_peer)
1139 {
1140 m_error = GSOCK_MEMERR;
1141 return -1;
1142 }
1143 }
1144 err = _GAddress_translate_from(m_peer, &from, fromlen);
1145 if (err != GSOCK_NOERROR)
1146 {
1147 GAddress_destroy(m_peer);
1148 m_peer = NULL;
1149 m_error = err;
1150 return -1;
1151 }
1152
1153 return ret;
1154 }
1155
1156 int GSocket::Send_Stream(const char *buffer, int size)
1157 {
1158 return send(m_fd, buffer, size, 0);
1159 }
1160
1161 int GSocket::Send_Dgram(const char *buffer, int size)
1162 {
1163 struct sockaddr *addr;
1164 int len, ret;
1165 GSocketError err;
1166
1167 if (!m_peer)
1168 {
1169 m_error = GSOCK_INVADDR;
1170 return -1;
1171 }
1172
1173 err = _GAddress_translate_to(m_peer, &addr, &len);
1174 if (err != GSOCK_NOERROR)
1175 {
1176 m_error = err;
1177 return -1;
1178 }
1179
1180 ret = sendto(m_fd, buffer, size, 0, addr, len);
1181
1182 /* Frees memory allocated by _GAddress_translate_to */
1183 free(addr);
1184
1185 return ret;
1186 }
1187
1188 /* Compatibility functions for GSocket */
1189 GSocket *GSocket_new(void)
1190 {
1191 GSocket *newsocket = new GSocket();
1192 if(newsocket->IsOk())
1193 return newsocket;
1194 delete newsocket;
1195 return NULL;
1196 }
1197
1198
1199 /*
1200 * -------------------------------------------------------------------------
1201 * GAddress
1202 * -------------------------------------------------------------------------
1203 */
1204
1205 /* CHECK_ADDRESS verifies that the current address family is either
1206 * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1207 * initalizes it to be a GSOCK_*family*. In other cases, it returns
1208 * an appropiate error code.
1209 *
1210 * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1211 */
1212 #define CHECK_ADDRESS(address, family) \
1213 { \
1214 if (address->m_family == GSOCK_NOFAMILY) \
1215 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1216 return address->m_error; \
1217 if (address->m_family != GSOCK_##family) \
1218 { \
1219 address->m_error = GSOCK_INVADDR; \
1220 return GSOCK_INVADDR; \
1221 } \
1222 }
1223
1224 #define CHECK_ADDRESS_RETVAL(address, family, retval) \
1225 { \
1226 if (address->m_family == GSOCK_NOFAMILY) \
1227 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1228 return retval; \
1229 if (address->m_family != GSOCK_##family) \
1230 { \
1231 address->m_error = GSOCK_INVADDR; \
1232 return retval; \
1233 } \
1234 }
1235
1236
1237 GAddress *GAddress_new(void)
1238 {
1239 GAddress *address;
1240
1241 if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1242 return NULL;
1243
1244 address->m_family = GSOCK_NOFAMILY;
1245 address->m_addr = NULL;
1246 address->m_len = 0;
1247
1248 return address;
1249 }
1250
1251 GAddress *GAddress_copy(GAddress *address)
1252 {
1253 GAddress *addr2;
1254
1255 assert(address != NULL);
1256
1257 if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1258 return NULL;
1259
1260 memcpy(addr2, address, sizeof(GAddress));
1261
1262 if (address->m_addr)
1263 {
1264 addr2->m_addr = (struct sockaddr *) malloc(addr2->m_len);
1265 if (addr2->m_addr == NULL)
1266 {
1267 free(addr2);
1268 return NULL;
1269 }
1270 memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1271 }
1272
1273 return addr2;
1274 }
1275
1276 void GAddress_destroy(GAddress *address)
1277 {
1278 assert(address != NULL);
1279
1280 if (address->m_addr)
1281 free(address->m_addr);
1282
1283 free(address);
1284 }
1285
1286 void GAddress_SetFamily(GAddress *address, GAddressType type)
1287 {
1288 assert(address != NULL);
1289
1290 address->m_family = type;
1291 }
1292
1293 GAddressType GAddress_GetFamily(GAddress *address)
1294 {
1295 assert(address != NULL);
1296
1297 return address->m_family;
1298 }
1299
1300 GSocketError _GAddress_translate_from(GAddress *address,
1301 struct sockaddr *addr, int len)
1302 {
1303 address->m_realfamily = addr->sa_family;
1304 switch (addr->sa_family)
1305 {
1306 case AF_INET:
1307 address->m_family = GSOCK_INET;
1308 break;
1309 case AF_UNIX:
1310 address->m_family = GSOCK_UNIX;
1311 break;
1312 #ifdef AF_INET6
1313 case AF_INET6:
1314 address->m_family = GSOCK_INET6;
1315 break;
1316 #endif
1317 default:
1318 {
1319 address->m_error = GSOCK_INVOP;
1320 return GSOCK_INVOP;
1321 }
1322 }
1323
1324 if (address->m_addr)
1325 free(address->m_addr);
1326
1327 address->m_len = len;
1328 address->m_addr = (struct sockaddr *) malloc(len);
1329
1330 if (address->m_addr == NULL)
1331 {
1332 address->m_error = GSOCK_MEMERR;
1333 return GSOCK_MEMERR;
1334 }
1335 memcpy(address->m_addr, addr, len);
1336
1337 return GSOCK_NOERROR;
1338 }
1339
1340 GSocketError _GAddress_translate_to(GAddress *address,
1341 struct sockaddr **addr, int *len)
1342 {
1343 if (!address->m_addr)
1344 {
1345 address->m_error = GSOCK_INVADDR;
1346 return GSOCK_INVADDR;
1347 }
1348
1349 *len = address->m_len;
1350 *addr = (struct sockaddr *) malloc(address->m_len);
1351 if (*addr == NULL)
1352 {
1353 address->m_error = GSOCK_MEMERR;
1354 return GSOCK_MEMERR;
1355 }
1356
1357 memcpy(*addr, address->m_addr, address->m_len);
1358 return GSOCK_NOERROR;
1359 }
1360
1361 /*
1362 * -------------------------------------------------------------------------
1363 * Internet address family
1364 * -------------------------------------------------------------------------
1365 */
1366
1367 GSocketError _GAddress_Init_INET(GAddress *address)
1368 {
1369 address->m_len = sizeof(struct sockaddr_in);
1370 address->m_addr = (struct sockaddr *) malloc(address->m_len);
1371 if (address->m_addr == NULL)
1372 {
1373 address->m_error = GSOCK_MEMERR;
1374 return GSOCK_MEMERR;
1375 }
1376
1377 address->m_family = GSOCK_INET;
1378 address->m_realfamily = AF_INET;
1379 ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1380 ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1381
1382 return GSOCK_NOERROR;
1383 }
1384
1385 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1386 {
1387 struct hostent *he;
1388 struct in_addr *addr;
1389
1390 assert(address != NULL);
1391
1392 CHECK_ADDRESS(address, INET);
1393
1394 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1395
1396 addr->s_addr = inet_addr(hostname);
1397
1398 /* If it is a numeric host name, convert it now */
1399 if (addr->s_addr == INADDR_NONE)
1400 {
1401 struct in_addr *array_addr;
1402
1403 /* It is a real name, we solve it */
1404 if ((he = gethostbyname(hostname)) == NULL)
1405 {
1406 /* addr->s_addr = INADDR_NONE just done by inet_addr() above */
1407 address->m_error = GSOCK_NOHOST;
1408 return GSOCK_NOHOST;
1409 }
1410 array_addr = (struct in_addr *) *(he->h_addr_list);
1411 addr->s_addr = array_addr[0].s_addr;
1412 }
1413 return GSOCK_NOERROR;
1414 }
1415
1416 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1417 {
1418 return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1419 }
1420
1421 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1422 unsigned long hostaddr)
1423 {
1424 struct in_addr *addr;
1425
1426 assert(address != NULL);
1427
1428 CHECK_ADDRESS(address, INET);
1429
1430 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1431 addr->s_addr = htonl(hostaddr);
1432
1433 return GSOCK_NOERROR;
1434 }
1435
1436 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1437 const char *protocol)
1438 {
1439 struct servent *se;
1440 struct sockaddr_in *addr;
1441
1442 assert(address != NULL);
1443 CHECK_ADDRESS(address, INET);
1444
1445 if (!port)
1446 {
1447 address->m_error = GSOCK_INVPORT;
1448 return GSOCK_INVPORT;
1449 }
1450
1451 se = getservbyname(port, protocol);
1452 if (!se)
1453 {
1454 if (isdigit((unsigned char) port[0]))
1455 {
1456 int port_int;
1457
1458 port_int = atoi(port);
1459 addr = (struct sockaddr_in *)address->m_addr;
1460 addr->sin_port = htons((u_short) port_int);
1461 return GSOCK_NOERROR;
1462 }
1463
1464 address->m_error = GSOCK_INVPORT;
1465 return GSOCK_INVPORT;
1466 }
1467
1468 addr = (struct sockaddr_in *)address->m_addr;
1469 addr->sin_port = se->s_port;
1470
1471 return GSOCK_NOERROR;
1472 }
1473
1474 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1475 {
1476 struct sockaddr_in *addr;
1477
1478 assert(address != NULL);
1479 CHECK_ADDRESS(address, INET);
1480
1481 addr = (struct sockaddr_in *)address->m_addr;
1482 addr->sin_port = htons(port);
1483
1484 return GSOCK_NOERROR;
1485 }
1486
1487 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1488 {
1489 struct hostent *he;
1490 char *addr_buf;
1491 struct sockaddr_in *addr;
1492
1493 assert(address != NULL);
1494 CHECK_ADDRESS(address, INET);
1495
1496 addr = (struct sockaddr_in *)address->m_addr;
1497 addr_buf = (char *)&(addr->sin_addr);
1498
1499 he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1500 if (he == NULL)
1501 {
1502 address->m_error = GSOCK_NOHOST;
1503 return GSOCK_NOHOST;
1504 }
1505
1506 strncpy(hostname, he->h_name, sbuf);
1507
1508 return GSOCK_NOERROR;
1509 }
1510
1511 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1512 {
1513 struct sockaddr_in *addr;
1514
1515 assert(address != NULL);
1516 CHECK_ADDRESS_RETVAL(address, INET, 0);
1517
1518 addr = (struct sockaddr_in *)address->m_addr;
1519
1520 return ntohl(addr->sin_addr.s_addr);
1521 }
1522
1523 unsigned short GAddress_INET_GetPort(GAddress *address)
1524 {
1525 struct sockaddr_in *addr;
1526
1527 assert(address != NULL);
1528 CHECK_ADDRESS_RETVAL(address, INET, 0);
1529
1530 addr = (struct sockaddr_in *)address->m_addr;
1531 return ntohs(addr->sin_port);
1532 }
1533
1534 /*
1535 * -------------------------------------------------------------------------
1536 * Unix address family
1537 * -------------------------------------------------------------------------
1538 */
1539
1540 GSocketError _GAddress_Init_UNIX(GAddress *address)
1541 {
1542 assert (address != NULL);
1543 address->m_error = GSOCK_INVADDR;
1544 return GSOCK_INVADDR;
1545 }
1546
1547 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *WXUNUSED(path))
1548 {
1549 assert (address != NULL);
1550 address->m_error = GSOCK_INVADDR;
1551 return GSOCK_INVADDR;
1552 }
1553
1554 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *WXUNUSED(path), size_t WXUNUSED(sbuf))
1555 {
1556 assert (address != NULL);
1557 address->m_error = GSOCK_INVADDR;
1558 return GSOCK_INVADDR;
1559 }
1560
1561 #else /* !wxUSE_SOCKETS */
1562
1563 /*
1564 * Translation unit shouldn't be empty, so include this typedef to make the
1565 * compiler (VC++ 6.0, for example) happy
1566 */
1567 typedef void (*wxDummy)();
1568
1569 #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */

  ViewVC Help
Powered by ViewVC 1.1.22