]> git.saurik.com Git - wxWidgets.git/blob - src/msw/gsocket.c
compilation fix for non-threaded compilation (threads are still broken
[wxWidgets.git] / src / msw / gsocket.c
1 /* -------------------------------------------------------------------------
2 * Project: GSocket (Generic Socket) for WX
3 * Name: gsocket.c
4 * Purpose: GSocket main MSW file
5 * CVSID: $Id$
6 * -------------------------------------------------------------------------
7 */
8
9 #ifndef __GSOCKET_STANDALONE__
10 #include "wx/setup.h"
11 #endif
12
13 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
14
15
16 #ifndef __GSOCKET_STANDALONE__
17
18 #include "wx/msw/gsockmsw.h"
19 #include "wx/gsocket.h"
20
21 #define INSTANCE wxGetInstance()
22
23 #else
24
25 #include "gsockmsw.h"
26 #include "gsocket.h"
27
28 /* If not using wxWindows, a global var called hInst must
29 * be available and it must containt the app's instance
30 * handle.
31 */
32 #define INSTANCE hInst
33
34 #endif /* __GSOCKET_STANDALONE__ */
35
36
37 #include <assert.h>
38 #include <string.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <stddef.h>
42 #include <ctype.h>
43 #include <winsock.h>
44
45 #define SOCKLEN_T int
46 #define CLASSNAME "_GSocket_Internal_Window_Class"
47 #define WINDOWNAME "_GSocket_Internal_Window_Name"
48
49 /* Maximum number of different GSocket objects at a given time.
50 * This value can be modified at will, but it CANNOT be greater
51 * than (0x7FFF - WM_USER + 1)
52 */
53 #define MAXSOCKETS 1024
54
55 #if (MAXSOCKETS > (0x7FFF - WM_USER + 1))
56 #error "MAXSOCKETS is too big!"
57 #endif
58
59
60 /* Global variables */
61
62 extern HINSTANCE INSTANCE;
63 static HWND hWin;
64 static CRITICAL_SECTION critical;
65 static GSocket* socketList[MAXSOCKETS];
66 static int firstAvailable;
67
68 /* Global initializers */
69
70 bool GSocket_Init()
71 {
72 WSADATA wsaData;
73 WNDCLASS winClass;
74 int i;
75
76 /* Create internal window for event notifications */
77 winClass.style = 0;
78 winClass.lpfnWndProc = _GSocket_Internal_WinProc;
79 winClass.cbClsExtra = 0;
80 winClass.cbWndExtra = 0;
81 winClass.hInstance = INSTANCE;
82 winClass.hIcon = (HICON) NULL;
83 winClass.hCursor = (HCURSOR) NULL;
84 winClass.hbrBackground = (HBRUSH) NULL;
85 winClass.lpszMenuName = (LPCTSTR) NULL;
86 winClass.lpszClassName = CLASSNAME;
87
88 RegisterClass(&winClass);
89 hWin = CreateWindow(CLASSNAME,
90 WINDOWNAME,
91 0, 0, 0, 0, 0,
92 (HWND) NULL, (HMENU) NULL, INSTANCE, (LPVOID) NULL);
93
94 if (!hWin) return FALSE;
95
96 /* Initialize socket list */
97 InitializeCriticalSection(&critical);
98
99 for (i = 0; i < MAXSOCKETS; i++)
100 {
101 socketList[i] = NULL;
102 }
103 firstAvailable = 0;
104
105 /* Initialize WinSocket */
106 return (WSAStartup((1 << 8) | 1, &wsaData) == 0);
107 }
108
109 void GSocket_Cleanup()
110 {
111 /* Destroy internal window */
112 DestroyWindow(hWin);
113 UnregisterClass(CLASSNAME, INSTANCE);
114
115 /* Delete critical section */
116 DeleteCriticalSection(&critical);
117
118 /* Cleanup WinSocket */
119 WSACleanup();
120 }
121
122 /* Constructors / Destructors */
123
124 GSocket *GSocket_new()
125 {
126 int i;
127 GSocket *socket;
128
129 if ((socket = (GSocket *) malloc(sizeof(GSocket))) == NULL)
130 return NULL;
131
132 socket->m_fd = INVALID_SOCKET;
133 for (i = 0; i < GSOCK_MAX_EVENT; i++)
134 {
135 socket->m_cbacks[i] = NULL;
136 }
137 socket->m_local = NULL;
138 socket->m_peer = NULL;
139 socket->m_error = GSOCK_NOERROR;
140 socket->m_server = FALSE;
141 socket->m_stream = TRUE;
142 socket->m_non_blocking = FALSE;
143 socket->m_timeout.tv_sec = 10 * 60; /* 10 minutes */
144 socket->m_timeout.tv_usec = 0;
145 socket->m_detected = 0;
146
147 /* Allocate a new message number for this socket */
148 EnterCriticalSection(&critical);
149
150 i = firstAvailable;
151 while (socketList[i] != NULL)
152 {
153 i = (i + 1) % MAXSOCKETS;
154
155 if (i == firstAvailable) /* abort! */
156 {
157 free(socket);
158 LeaveCriticalSection(&critical);
159 return NULL;
160 }
161 }
162 socketList[i] = socket;
163 firstAvailable = (i + 1) % MAXSOCKETS;
164 socket->m_msgnumber = (i + WM_USER);
165
166 LeaveCriticalSection(&critical);
167
168 return socket;
169 }
170
171 void GSocket_destroy(GSocket *socket)
172 {
173 assert(socket != NULL);
174
175 /* Remove the socket from the list */
176 EnterCriticalSection(&critical);
177 socketList[(socket->m_msgnumber - WM_USER)] = NULL;
178 LeaveCriticalSection(&critical);
179
180 /* Check that the socket is really shutdowned */
181 if (socket->m_fd != INVALID_SOCKET)
182 GSocket_Shutdown(socket);
183
184 /* Destroy private addresses */
185 if (socket->m_local)
186 GAddress_destroy(socket->m_local);
187
188 if (socket->m_peer)
189 GAddress_destroy(socket->m_peer);
190
191 /* Destroy socket itself */
192 free(socket);
193 }
194
195 void GSocket_Shutdown(GSocket *socket)
196 {
197 int evt;
198
199 assert(socket != NULL);
200
201 /* If socket has been created, shutdown it */
202 if (socket->m_fd != INVALID_SOCKET)
203 {
204 shutdown(socket->m_fd, 2);
205 closesocket(socket->m_fd);
206 socket->m_fd = INVALID_SOCKET;
207 }
208
209 /* Disable GUI callbacks */
210 for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
211 socket->m_cbacks[evt] = NULL;
212
213 socket->m_detected = 0;
214 _GSocket_Disable_Events(socket);
215 }
216
217 /* Address handling */
218
219 GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address)
220 {
221 assert(socket != NULL);
222
223 if (socket->m_fd != INVALID_SOCKET && !socket->m_server)
224 {
225 socket->m_error = GSOCK_INVSOCK;
226 return GSOCK_INVSOCK;
227 }
228
229 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
230 {
231 socket->m_error = GSOCK_INVADDR;
232 return GSOCK_INVADDR;
233 }
234
235 if (socket->m_local)
236 GAddress_destroy(socket->m_local);
237
238 socket->m_local = GAddress_copy(address);
239
240 return GSOCK_NOERROR;
241 }
242
243 GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address)
244 {
245 assert(socket != NULL);
246
247 if (address == NULL || address->m_family == GSOCK_NOFAMILY)
248 {
249 socket->m_error = GSOCK_INVADDR;
250 return GSOCK_INVADDR;
251 }
252
253 if (socket->m_peer)
254 GAddress_destroy(socket->m_peer);
255
256 socket->m_peer = GAddress_copy(address);
257
258 return GSOCK_NOERROR;
259 }
260
261 GAddress *GSocket_GetLocal(GSocket *socket)
262 {
263 GAddress *address;
264 struct sockaddr addr;
265 SOCKLEN_T size = sizeof(addr);
266 GSocketError err;
267
268 assert(socket != NULL);
269
270 if (socket->m_local)
271 return GAddress_copy(socket->m_local);
272
273 if (socket->m_fd == INVALID_SOCKET)
274 {
275 socket->m_error = GSOCK_INVSOCK;
276 return NULL;
277 }
278
279 size = sizeof(addr);
280
281 if (getsockname(socket->m_fd, &addr, &size) == SOCKET_ERROR)
282 {
283 socket->m_error = GSOCK_IOERR;
284 return NULL;
285 }
286
287 address = GAddress_new();
288 if (address == NULL)
289 {
290 socket->m_error = GSOCK_MEMERR;
291 return NULL;
292 }
293 err = _GAddress_translate_from(address, &addr, size);
294 if (err != GSOCK_NOERROR)
295 {
296 GAddress_destroy(address);
297 socket->m_error = err;
298 return NULL;
299 }
300
301 return address;
302 }
303
304 GAddress *GSocket_GetPeer(GSocket *socket)
305 {
306 assert(socket != NULL);
307
308 if (socket->m_peer)
309 return GAddress_copy(socket->m_peer);
310
311 return NULL;
312 }
313
314 /* Server specific parts */
315
316 /* GSocket_SetServer:
317 * Sets up the socket as a server. It uses the "Local" field of GSocket.
318 * "Local" must be set by GSocket_SetLocal() before GSocket_SetServer()
319 * is called. Possible error codes are: GSOCK_INVSOCK if socket has not
320 * been initialized, GSOCK_INVADDR if the local address has not been
321 * defined and GSOCK_IOERR for other internal errors.
322 */
323 GSocketError GSocket_SetServer(GSocket *sck)
324 {
325 u_long arg = 1;
326
327 assert(sck != NULL);
328
329 if (sck->m_fd != INVALID_SOCKET)
330 {
331 sck->m_error = GSOCK_INVSOCK;
332 return GSOCK_INVSOCK;
333 }
334
335 if (!sck->m_local)
336 {
337 sck->m_error = GSOCK_INVADDR;
338 return GSOCK_INVADDR;
339 }
340
341 /* Initialize all fields */
342 sck->m_server = TRUE;
343 sck->m_stream = TRUE;
344 sck->m_oriented = TRUE;
345
346 /* Create the socket */
347 sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_STREAM, 0);
348
349 if (sck->m_fd == INVALID_SOCKET)
350 {
351 sck->m_error = GSOCK_IOERR;
352 return GSOCK_IOERR;
353 }
354
355 ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg);
356 _GSocket_Enable_Events(sck);
357
358 /* Bind the socket to the LOCAL address */
359 if (bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0)
360 {
361 closesocket(sck->m_fd);
362 sck->m_fd = INVALID_SOCKET;
363 sck->m_error = GSOCK_IOERR;
364 return GSOCK_IOERR;
365 }
366
367 /* Enable listening up to 5 connections */
368 if (listen(sck->m_fd, 5) != 0)
369 {
370 closesocket(sck->m_fd);
371 sck->m_fd = INVALID_SOCKET;
372 sck->m_error = GSOCK_IOERR;
373 return GSOCK_IOERR;
374 }
375
376 return GSOCK_NOERROR;
377 }
378
379 /* GSocket_WaitConnection:
380 * Waits for an incoming client connection.
381 */
382 GSocket *GSocket_WaitConnection(GSocket *sck)
383 {
384 GSocket *connection;
385 struct sockaddr from;
386 SOCKLEN_T fromlen = sizeof(from);
387 GSocketError err;
388 u_long arg = 1;
389
390 assert(sck != NULL);
391
392 sck->m_detected &= ~GSOCK_CONNECTION_FLAG;
393
394 if (sck->m_fd == INVALID_SOCKET || !sck->m_server)
395 {
396 sck->m_error = GSOCK_INVSOCK;
397 return NULL;
398 }
399
400 /* Create a GSocket object for the new connection */
401 connection = GSocket_new();
402
403 if (!connection)
404 {
405 sck->m_error = GSOCK_MEMERR;
406 return NULL;
407 }
408
409 /* Wait for a connection (with timeout) */
410 if (_GSocket_Input_Timeout(sck) == GSOCK_TIMEDOUT)
411 {
412 GSocket_destroy(connection);
413 /* sck->m_error set by _GSocket_Input_Timeout */
414 return NULL;
415 }
416
417 connection->m_fd = accept(sck->m_fd, &from, &fromlen);
418
419 if (connection->m_fd == INVALID_SOCKET)
420 {
421 if (WSAGetLastError() == WSAEWOULDBLOCK)
422 sck->m_error = GSOCK_WOULDBLOCK;
423 else
424 sck->m_error = GSOCK_IOERR;
425
426 GSocket_destroy(connection);
427 return NULL;
428 }
429
430 /* Initialize all fields */
431 connection->m_server = FALSE;
432 connection->m_stream = TRUE;
433 connection->m_oriented = TRUE;
434
435 /* Setup the peer address field */
436 connection->m_peer = GAddress_new();
437 if (!connection->m_peer)
438 {
439 GSocket_destroy(connection);
440 sck->m_error = GSOCK_MEMERR;
441 return NULL;
442 }
443 err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
444 if (err != GSOCK_NOERROR)
445 {
446 GAddress_destroy(connection->m_peer);
447 GSocket_destroy(connection);
448 sck->m_error = err;
449 return NULL;
450 }
451
452 ioctlsocket(connection->m_fd, FIONBIO, (u_long FAR *) &arg);
453 _GSocket_Enable_Events(connection);
454
455 return connection;
456 }
457
458 /* Non oriented connections */
459
460 GSocketError GSocket_SetNonOriented(GSocket *sck)
461 {
462 u_long arg = 1;
463
464 assert(sck != NULL);
465
466 if (sck->m_fd != INVALID_SOCKET)
467 {
468 sck->m_error = GSOCK_INVSOCK;
469 return GSOCK_INVSOCK;
470 }
471
472 if (!sck->m_local)
473 {
474 sck->m_error = GSOCK_INVADDR;
475 return GSOCK_INVADDR;
476 }
477
478 /* Initialize all fields */
479 sck->m_stream = FALSE;
480 sck->m_server = FALSE;
481 sck->m_oriented = FALSE;
482
483 /* Create the socket */
484 sck->m_fd = socket(sck->m_local->m_realfamily, SOCK_DGRAM, 0);
485
486 if (sck->m_fd == INVALID_SOCKET)
487 {
488 sck->m_error = GSOCK_IOERR;
489 return GSOCK_IOERR;
490 }
491
492 ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg);
493 _GSocket_Enable_Events(sck);
494
495 /* Bind it to the LOCAL address */
496 if (bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0)
497 {
498 closesocket(sck->m_fd);
499 sck->m_fd = INVALID_SOCKET;
500 sck->m_error = GSOCK_IOERR;
501 return GSOCK_IOERR;
502 }
503
504 return GSOCK_NOERROR;
505 }
506
507 GSocketError GSocket_SetBroadcast(GSocket *sck)
508 {
509 BOOL b = TRUE;
510
511 assert(sck != NULL);
512
513 if (GSocket_SetNonOriented(sck) != GSOCK_NOERROR)
514 return sck->m_error;
515
516 setsockopt(sck->m_fd, SOL_SOCKET, SO_BROADCAST,
517 (const char FAR *) &b, sizeof(b));
518
519 return GSOCK_NOERROR;
520 }
521
522 /* Client specific parts */
523
524 /* GSocket_Connect:
525 * Establishes a client connection to a server using the "Peer"
526 * field of GSocket. "Peer" must be set by GSocket_SetPeer() before
527 * GSocket_Connect() is called. Possible error codes are GSOCK_INVSOCK,
528 * GSOCK_INVADDR, GSOCK_TIMEDOUT, GSOCK_WOULDBLOCK and GSOCK_IOERR.
529 * If a socket is nonblocking and Connect() returns GSOCK_WOULDBLOCK,
530 * the connection request can be completed later. Use GSocket_Select()
531 * to check or wait for a GSOCK_CONNECTION event.
532 */
533 GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream)
534 {
535 u_long arg = 1;
536 int type, ret, err;
537
538 assert(sck != NULL);
539
540 sck->m_detected &= ~GSOCK_CONNECTION_FLAG;
541
542 if (sck->m_fd != INVALID_SOCKET)
543 {
544 sck->m_error = GSOCK_INVSOCK;
545 return GSOCK_INVSOCK;
546 }
547
548 if (!sck->m_peer)
549 {
550 sck->m_error = GSOCK_INVADDR;
551 return GSOCK_INVADDR;
552 }
553
554 /* Test whether we want the socket to be a stream (e.g. TCP) */
555 sck->m_stream = (stream == GSOCK_STREAMED);
556 sck->m_oriented = TRUE;
557 sck->m_server = FALSE;
558
559 if (sck->m_stream)
560 type = SOCK_STREAM;
561 else
562 type = SOCK_DGRAM;
563
564 /* Create the socket */
565 sck->m_fd = socket(sck->m_peer->m_realfamily, type, 0);
566
567 if (sck->m_fd == INVALID_SOCKET)
568 {
569 sck->m_error = GSOCK_IOERR;
570 return GSOCK_IOERR;
571 }
572
573 ioctlsocket(sck->m_fd, FIONBIO, (u_long FAR *) &arg);
574 _GSocket_Enable_Events(sck);
575
576 /* Connect it to the PEER address, with a timeout (see below) */
577 ret = connect(sck->m_fd, sck->m_peer->m_addr, sck->m_peer->m_len);
578
579 if (ret == SOCKET_ERROR)
580 {
581 err = WSAGetLastError();
582
583 /* If connect failed with EWOULDBLOCK and the GSocket object
584 * is in blocking mode, we select() for the specified timeout
585 * checking for writability to see if the connection request
586 * completes.
587 */
588 if ((err == WSAEWOULDBLOCK) && (!sck->m_non_blocking))
589 {
590 if (_GSocket_Output_Timeout(sck) == GSOCK_TIMEDOUT)
591 {
592 closesocket(sck->m_fd);
593 sck->m_fd = INVALID_SOCKET;
594 /* sck->m_error is set in _GSocket_Output_Timeout */
595 return GSOCK_TIMEDOUT;
596 }
597 else
598 return GSOCK_NOERROR;
599 }
600
601 /* If connect failed with EWOULDBLOCK and the GSocket object
602 * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
603 * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
604 * this way if the connection completes, a GSOCK_CONNECTION
605 * event will be generated, if enabled.
606 */
607 if ((err == WSAEWOULDBLOCK) && (sck->m_non_blocking))
608 {
609 sck->m_error = GSOCK_WOULDBLOCK;
610 return GSOCK_WOULDBLOCK;
611 }
612
613 /* If connect failed with an error other than EWOULDBLOCK,
614 * then the call to GSocket_Connect has failed.
615 */
616 closesocket(sck->m_fd);
617 sck->m_fd = INVALID_SOCKET;
618 sck->m_error = GSOCK_IOERR;
619 return GSOCK_IOERR;
620 }
621
622 return GSOCK_NOERROR;
623 }
624
625 /* Generic IO */
626
627 /* Like recv(), send(), ... */
628 int GSocket_Read(GSocket *socket, char *buffer, int size)
629 {
630 int ret;
631
632 assert(socket != NULL);
633
634 socket->m_detected &= ~GSOCK_INPUT_FLAG;
635
636 if (socket->m_fd == INVALID_SOCKET || socket->m_server)
637 {
638 socket->m_error = GSOCK_INVSOCK;
639 return -1;
640 }
641
642 /* If the socket is blocking, wait for data (with a timeout) */
643 if (_GSocket_Input_Timeout(socket) == GSOCK_TIMEDOUT)
644 return -1;
645
646 /* Read the data */
647 if (socket->m_stream)
648 ret = _GSocket_Recv_Stream(socket, buffer, size);
649 else
650 ret = _GSocket_Recv_Dgram(socket, buffer, size);
651
652 if (ret == SOCKET_ERROR)
653 {
654 /* NOTE: Window sockets exhibit a very strange property;
655 * if the socket is in non-blocking mode (which is always
656 * the case here, no matter the setting of GSocket itself)
657 * a call to send() can fail with EWOULDBLOCK even when
658 * select() says that the socket is writable.
659 *
660 * This can break several things because, usually, if
661 * select() says that the socket is writable, it is
662 * assumed that send() won't fail. To avoid this, we
663 * return 0 instead of -1 for this special case.
664 *
665 * XXX - this comment seems not to belong here, and also
666 * the code is not consistent with the unix version of
667 * gsocket... what to do? (GRG)
668 */
669 if (WSAGetLastError() != WSAEWOULDBLOCK)
670 {
671 socket->m_error = GSOCK_IOERR;
672 return -1;
673 }
674 else
675 {
676 socket->m_error = GSOCK_WOULDBLOCK;
677 return 0;
678 }
679 }
680
681 return ret;
682 }
683
684 int GSocket_Write(GSocket *socket, const char *buffer, int size)
685 {
686 int ret;
687
688 assert(socket != NULL);
689
690 if (socket->m_fd == INVALID_SOCKET || socket->m_server)
691 {
692 socket->m_error = GSOCK_INVSOCK;
693 return -1;
694 }
695
696 /* If the socket is blocking, wait for writability (with a timeout) */
697 if (_GSocket_Output_Timeout(socket) == GSOCK_TIMEDOUT)
698 return -1;
699
700 /* Read the data */
701 if (socket->m_stream)
702 ret = _GSocket_Send_Stream(socket, buffer, size);
703 else
704 ret = _GSocket_Send_Dgram(socket, buffer, size);
705
706 if (ret == SOCKET_ERROR)
707 {
708 if (WSAGetLastError() != WSAEWOULDBLOCK)
709 socket->m_error = GSOCK_IOERR;
710 else
711 socket->m_error = GSOCK_WOULDBLOCK;
712
713 socket->m_detected &= ~GSOCK_OUTPUT_FLAG;
714 return -1;
715 }
716
717 return ret;
718 }
719
720 /* GSocket_Select:
721 * Polls the socket to determine its status. This function will
722 * check for the events specified in the 'flags' parameter, and
723 * it will return a mask indicating which operations can be
724 * performed. This function won't block, regardless of the
725 * mode (blocking|nonblocking) of the socket.
726 */
727 GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
728 {
729 assert(socket != NULL);
730
731 return (flags & socket->m_detected);
732 }
733
734 /* Flags */
735
736 /* GSocket_SetNonBlocking:
737 * Sets the socket to non-blocking mode. This is useful if
738 * we don't want to wait.
739 */
740 void GSocket_SetNonBlocking(GSocket *socket, bool non_block)
741 {
742 assert(socket != NULL);
743
744 socket->m_non_blocking = non_block;
745 }
746
747 /* GSocket_SetTimeout:
748 * Sets the timeout for blocking calls. Time is
749 * expressed in milliseconds.
750 */
751 void GSocket_SetTimeout(GSocket *socket, unsigned long millis)
752 {
753 assert(socket != NULL);
754
755 socket->m_timeout.tv_sec = (millis / 1000);
756 socket->m_timeout.tv_usec = (millis % 1000) * 1000;
757 }
758
759 /* GSocket_GetError:
760 * Returns the last error occured for this socket.
761 */
762 GSocketError GSocket_GetError(GSocket *socket)
763 {
764 assert(socket != NULL);
765
766 return socket->m_error;
767 }
768
769 /* Callbacks */
770
771 /* Only one callback is possible for each event (INPUT, OUTPUT, CONNECTION
772 * and LOST). The callbacks are called in the following situations:
773 *
774 * INPUT: There is at least one byte in the input buffer
775 * OUTPUT: The system is sure that the next write call will not block
776 * CONNECTION: Two cases are possible:
777 * Client socket -> the connection is established
778 * Server socket -> a client requests a connection
779 * LOST: The connection is lost
780 *
781 * An event is generated only once and its state is reseted when the
782 * relative IO call is requested.
783 * For example: INPUT -> GSocket_Read()
784 * CONNECTION -> GSocket_Accept()
785 */
786
787 /* GSocket_SetCallback:
788 * Enables the callbacks specified by 'flags'. Note that 'flags'
789 * may be a combination of flags OR'ed toghether, so the same
790 * callback function can be made to accept different events.
791 * The callback function must have the following prototype:
792 *
793 * void function(GSocket *socket, GSocketEvent event, char *cdata)
794 */
795 void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags,
796 GSocketCallback callback, char *cdata)
797 {
798 int count;
799
800 assert (socket != NULL);
801
802 for (count = 0; count < GSOCK_MAX_EVENT; count++)
803 {
804 if ((flags & (1 << count)) != 0)
805 {
806 socket->m_cbacks[count] = callback;
807 socket->m_data[count] = cdata;
808 }
809 }
810 }
811
812 /* GSocket_UnsetCallback:
813 * Disables all callbacks specified by 'flags', which may be a
814 * combination of flags OR'ed toghether.
815 */
816 void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags)
817 {
818 int count = 0;
819
820 assert(socket != NULL);
821
822 for (count = 0; count < GSOCK_MAX_EVENT; count++)
823 {
824 if ((flags & (1 << count)) != 0)
825 {
826 socket->m_cbacks[count] = NULL;
827 socket->m_data[count] = NULL;
828 }
829 }
830 }
831
832
833 /* Internals */
834
835 /* _GSocket_Enable_Events:
836 * We enable all event notifications here (we need to be notified
837 * of all events for internal processing) but we will only notify
838 * users when an appropiate callback function has been installed.
839 */
840 void _GSocket_Enable_Events(GSocket *socket)
841 {
842 assert (socket != NULL);
843
844 if (socket->m_fd != INVALID_SOCKET)
845 {
846 WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber,
847 FD_READ | FD_WRITE | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
848 }
849 }
850
851 /* _GSocket_Disable_Events:
852 * Disable event notifications (when shutdowning the socket)
853 */
854 void _GSocket_Disable_Events(GSocket *socket)
855 {
856 assert (socket != NULL);
857
858 if (socket->m_fd != INVALID_SOCKET)
859 {
860 WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, 0);
861 }
862 }
863
864
865 LRESULT CALLBACK _GSocket_Internal_WinProc(HWND hWnd,
866 UINT uMsg,
867 WPARAM wParam,
868 LPARAM lParam)
869 {
870 GSocket *socket;
871 GSocketEvent event;
872 GSocketCallback cback;
873 char *data;
874
875 if (uMsg >= WM_USER && uMsg <= (WM_USER + MAXSOCKETS - 1))
876 {
877 EnterCriticalSection(&critical);
878 socket = socketList[(uMsg - WM_USER)];
879 event = -1;
880 cback = NULL;
881 data = NULL;
882
883 /* Check that the socket still exists (it has not been
884 * destroyed) and for safety, check that the m_fd field
885 * is what we expect it to be.
886 */
887 if ((socket != NULL) && (socket->m_fd == wParam))
888 {
889 switch WSAGETSELECTEVENT(lParam)
890 {
891 case FD_READ: event = GSOCK_INPUT; break;
892 case FD_WRITE: event = GSOCK_OUTPUT; break;
893 case FD_ACCEPT: event = GSOCK_CONNECTION; break;
894 case FD_CONNECT:
895 {
896 if (WSAGETSELECTERROR(lParam) != 0)
897 event = GSOCK_LOST;
898 else
899 event = GSOCK_CONNECTION;
900 break;
901 }
902 case FD_CLOSE: event = GSOCK_LOST; break;
903 }
904
905 if (event != -1)
906 {
907 cback = socket->m_cbacks[event];
908 data = socket->m_data[event];
909
910 if (event == GSOCK_LOST)
911 socket->m_detected = GSOCK_LOST_FLAG;
912 else
913 socket->m_detected |= (1 << event);
914 }
915 }
916
917 /* OK, we can now leave the critical section because we have
918 * already obtained the callback address (we make no further
919 * accesses to socket->whatever)
920 */
921 LeaveCriticalSection(&critical);
922
923 if (cback != NULL)
924 (cback)(socket, event, data);
925
926 return (LRESULT) 0;
927 }
928 else
929 return DefWindowProc(hWnd, uMsg, wParam, lParam);
930 }
931
932
933 /* _GSocket_Input_Timeout:
934 * For blocking sockets, wait until data is available or
935 * until timeout ellapses.
936 */
937 GSocketError _GSocket_Input_Timeout(GSocket *socket)
938 {
939 fd_set readfds;
940
941 if (!socket->m_non_blocking)
942 {
943 FD_ZERO(&readfds);
944 FD_SET(socket->m_fd, &readfds);
945 if (select(0, &readfds, NULL, NULL, &socket->m_timeout) == 0)
946 {
947 socket->m_error = GSOCK_TIMEDOUT;
948 return GSOCK_TIMEDOUT;
949 }
950 }
951 return GSOCK_NOERROR;
952 }
953
954 /* _GSocket_Output_Timeout:
955 * For blocking sockets, wait until data can be sent without
956 * blocking or until timeout ellapses.
957 */
958 GSocketError _GSocket_Output_Timeout(GSocket *socket)
959 {
960 fd_set writefds;
961
962 if (!socket->m_non_blocking)
963 {
964 FD_ZERO(&writefds);
965 FD_SET(socket->m_fd, &writefds);
966 if (select(0, NULL, &writefds, NULL, &socket->m_timeout) == 0)
967 {
968 socket->m_error = GSOCK_TIMEDOUT;
969 return GSOCK_TIMEDOUT;
970 }
971 }
972 return GSOCK_NOERROR;
973 }
974
975 int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size)
976 {
977 return recv(socket->m_fd, buffer, size, 0);
978 }
979
980 int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size)
981 {
982 struct sockaddr from;
983 SOCKLEN_T fromlen = sizeof(from);
984 int ret;
985 GSocketError err;
986
987 ret = recvfrom(socket->m_fd, buffer, size, 0, &from, &fromlen);
988
989 if (ret == SOCKET_ERROR)
990 return SOCKET_ERROR;
991
992 /* Translate a system address into a GSocket address */
993 if (!socket->m_peer)
994 {
995 socket->m_peer = GAddress_new();
996 if (!socket->m_peer)
997 {
998 socket->m_error = GSOCK_MEMERR;
999 return -1;
1000 }
1001 }
1002 err = _GAddress_translate_from(socket->m_peer, &from, fromlen);
1003 if (err != GSOCK_NOERROR)
1004 {
1005 GAddress_destroy(socket->m_peer);
1006 socket->m_peer = NULL;
1007 socket->m_error = err;
1008 return -1;
1009 }
1010
1011 return ret;
1012 }
1013
1014 int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size)
1015 {
1016 return send(socket->m_fd, buffer, size, 0);
1017 }
1018
1019 int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size)
1020 {
1021 struct sockaddr *addr;
1022 int len, ret;
1023 GSocketError err;
1024
1025 if (!socket->m_peer)
1026 {
1027 socket->m_error = GSOCK_INVADDR;
1028 return -1;
1029 }
1030
1031 err = _GAddress_translate_to(socket->m_peer, &addr, &len);
1032 if (err != GSOCK_NOERROR)
1033 {
1034 socket->m_error = err;
1035 return -1;
1036 }
1037
1038 ret = sendto(socket->m_fd, buffer, size, 0, addr, len);
1039
1040 /* Frees memory allocated by _GAddress_translate_to */
1041 free(addr);
1042
1043 return ret;
1044 }
1045
1046
1047 /*
1048 * -------------------------------------------------------------------------
1049 * GAddress
1050 * -------------------------------------------------------------------------
1051 */
1052
1053 /* CHECK_ADDRESS verifies that the current family is either GSOCK_NOFAMILY
1054 * or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it initalizes address
1055 * to be a GSOCK_*family*. In other cases, it returns GSOCK_INVADDR.
1056 */
1057 #define CHECK_ADDRESS(address, family, retval) \
1058 { \
1059 if (address->m_family == GSOCK_NOFAMILY) \
1060 if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
1061 return address->m_error; \
1062 if (address->m_family != GSOCK_##family) \
1063 { \
1064 address->m_error = GSOCK_INVADDR; \
1065 return retval; \
1066 } \
1067 }
1068
1069 GAddress *GAddress_new()
1070 {
1071 GAddress *address;
1072
1073 if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1074 return NULL;
1075
1076 address->m_family = GSOCK_NOFAMILY;
1077 address->m_addr = NULL;
1078 address->m_len = 0;
1079
1080 return address;
1081 }
1082
1083 GAddress *GAddress_copy(GAddress *address)
1084 {
1085 GAddress *addr2;
1086
1087 assert(address != NULL);
1088
1089 if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1090 return NULL;
1091
1092 memcpy(addr2, address, sizeof(GAddress));
1093
1094 if (address->m_addr)
1095 {
1096 addr2->m_addr = (struct sockaddr *) malloc(addr2->m_len);
1097 if (addr2->m_addr == NULL)
1098 {
1099 free(addr2);
1100 return NULL;
1101 }
1102 memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1103 }
1104
1105 return addr2;
1106 }
1107
1108 void GAddress_destroy(GAddress *address)
1109 {
1110 assert(address != NULL);
1111
1112 free(address);
1113 }
1114
1115 void GAddress_SetFamily(GAddress *address, GAddressType type)
1116 {
1117 assert(address != NULL);
1118
1119 address->m_family = type;
1120 }
1121
1122 GAddressType GAddress_GetFamily(GAddress *address)
1123 {
1124 assert(address != NULL);
1125
1126 return address->m_family;
1127 }
1128
1129 GSocketError _GAddress_translate_from(GAddress *address,
1130 struct sockaddr *addr, int len)
1131 {
1132 address->m_realfamily = addr->sa_family;
1133 switch (addr->sa_family)
1134 {
1135 case AF_INET:
1136 address->m_family = GSOCK_INET;
1137 break;
1138 case AF_UNIX:
1139 address->m_family = GSOCK_UNIX;
1140 break;
1141 #ifdef AF_INET6
1142 case AF_INET6:
1143 address->m_family = GSOCK_INET6;
1144 break;
1145 #endif
1146 default:
1147 {
1148 address->m_error = GSOCK_INVOP;
1149 return GSOCK_INVOP;
1150 }
1151 }
1152
1153 if (address->m_addr)
1154 free(address->m_addr);
1155
1156 address->m_len = len;
1157 address->m_addr = (struct sockaddr *) malloc(len);
1158
1159 if (address->m_addr == NULL)
1160 {
1161 address->m_error = GSOCK_MEMERR;
1162 return GSOCK_MEMERR;
1163 }
1164 memcpy(address->m_addr, addr, len);
1165
1166 return GSOCK_NOERROR;
1167 }
1168
1169 GSocketError _GAddress_translate_to(GAddress *address,
1170 struct sockaddr **addr, int *len)
1171 {
1172 if (!address->m_addr)
1173 {
1174 address->m_error = GSOCK_INVADDR;
1175 return GSOCK_INVADDR;
1176 }
1177
1178 *len = address->m_len;
1179 *addr = (struct sockaddr *) malloc(address->m_len);
1180 if (*addr == NULL)
1181 {
1182 address->m_error = GSOCK_MEMERR;
1183 return GSOCK_MEMERR;
1184 }
1185
1186 memcpy(*addr, address->m_addr, address->m_len);
1187 return GSOCK_NOERROR;
1188 }
1189
1190 /*
1191 * -------------------------------------------------------------------------
1192 * Internet address family
1193 * -------------------------------------------------------------------------
1194 */
1195
1196 GSocketError _GAddress_Init_INET(GAddress *address)
1197 {
1198 address->m_len = sizeof(struct sockaddr_in);
1199 address->m_addr = (struct sockaddr *) malloc(address->m_len);
1200 if (address->m_addr == NULL)
1201 {
1202 address->m_error = GSOCK_MEMERR;
1203 return GSOCK_MEMERR;
1204 }
1205
1206 address->m_family = GSOCK_INET;
1207 address->m_realfamily = PF_INET;
1208 ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1209 ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_NONE;
1210
1211 return GSOCK_NOERROR;
1212 }
1213
1214 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1215 {
1216 struct hostent *he;
1217 struct in_addr *addr;
1218
1219 assert(address != NULL);
1220
1221 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1222
1223 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1224
1225 addr->s_addr = inet_addr(hostname);
1226
1227 /* If it is a numeric host name, convert it now */
1228 if (addr->s_addr == INADDR_NONE)
1229 {
1230 struct in_addr *array_addr;
1231
1232 /* It is a real name, we solve it */
1233 if ((he = gethostbyname(hostname)) == NULL)
1234 {
1235 address->m_error = GSOCK_NOHOST;
1236 return GSOCK_NOHOST;
1237 }
1238 array_addr = (struct in_addr *) *(he->h_addr_list);
1239 addr->s_addr = array_addr[0].s_addr;
1240 }
1241 return GSOCK_NOERROR;
1242 }
1243
1244 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1245 unsigned long hostaddr)
1246 {
1247 struct in_addr *addr;
1248
1249 assert(address != NULL);
1250
1251 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1252
1253 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1254 addr->s_addr = hostaddr;
1255
1256 return GSOCK_NOERROR;
1257 }
1258
1259 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1260 const char *protocol)
1261 {
1262 struct servent *se;
1263 struct sockaddr_in *addr;
1264
1265 assert(address != NULL);
1266 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1267
1268 if (!port)
1269 {
1270 address->m_error = GSOCK_INVPORT;
1271 return GSOCK_INVOP;
1272 }
1273
1274 se = getservbyname(port, protocol);
1275 if (!se)
1276 {
1277 if (isdigit(port[0]))
1278 {
1279 int port_int;
1280
1281 port_int = atoi(port);
1282 addr = (struct sockaddr_in *)address->m_addr;
1283 addr->sin_port = htons((u_short) port_int);
1284 return GSOCK_NOERROR;
1285 }
1286
1287 address->m_error = GSOCK_INVPORT;
1288 return GSOCK_INVPORT;
1289 }
1290
1291 addr = (struct sockaddr_in *)address->m_addr;
1292 addr->sin_port = se->s_port;
1293
1294 return GSOCK_NOERROR;
1295 }
1296
1297 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1298 {
1299 struct sockaddr_in *addr;
1300
1301 assert(address != NULL);
1302 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1303
1304 addr = (struct sockaddr_in *)address->m_addr;
1305 addr->sin_port = htons(port);
1306
1307 return GSOCK_NOERROR;
1308 }
1309
1310 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1311 {
1312 struct hostent *he;
1313 char *addr_buf;
1314 struct sockaddr_in *addr;
1315
1316 assert(address != NULL);
1317 CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
1318
1319 addr = (struct sockaddr_in *)address->m_addr;
1320 addr_buf = (char *)&(addr->sin_addr);
1321
1322 he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1323 if (he == NULL)
1324 {
1325 address->m_error = GSOCK_NOHOST;
1326 return GSOCK_NOHOST;
1327 }
1328
1329 strncpy(hostname, he->h_name, sbuf);
1330
1331 return GSOCK_NOERROR;
1332 }
1333
1334 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1335 {
1336 struct sockaddr_in *addr;
1337
1338 assert(address != NULL);
1339 CHECK_ADDRESS(address, INET, 0);
1340
1341 addr = (struct sockaddr_in *)address->m_addr;
1342
1343 return addr->sin_addr.s_addr;
1344 }
1345
1346 unsigned short GAddress_INET_GetPort(GAddress *address)
1347 {
1348 struct sockaddr_in *addr;
1349
1350 assert(address != NULL);
1351 CHECK_ADDRESS(address, INET, 0);
1352
1353 addr = (struct sockaddr_in *)address->m_addr;
1354 return ntohs(addr->sin_port);
1355 }
1356
1357 /*
1358 * -------------------------------------------------------------------------
1359 * Unix address family
1360 * -------------------------------------------------------------------------
1361 */
1362
1363 GSocketError _GAddress_Init_UNIX(GAddress *address)
1364 {
1365 assert (address != NULL);
1366 address->m_error = GSOCK_INVADDR;
1367 return GSOCK_INVADDR;
1368 }
1369
1370 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1371 {
1372 assert (address != NULL);
1373 address->m_error = GSOCK_INVADDR;
1374 return GSOCK_INVADDR;
1375 }
1376
1377 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1378 {
1379 assert (address != NULL);
1380 address->m_error = GSOCK_INVADDR;
1381 return GSOCK_INVADDR;
1382 }
1383
1384 #else /* !wxUSE_SOCKETS */
1385
1386 /*
1387 * translation unit shouldn't be empty, so include this typedef to make the
1388 * compiler (VC++ 6.0, for example) happy
1389 */
1390 typedef (*wxDummy)();
1391
1392 #endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
1393
1394 /* Diferencias con la version Unix:
1395 * - El descriptor es SOCKET y no int
1396 * - Constantes -1 pasan a INVALID_SOCKET
1397 * - Errores en muchas funciones pasan de -1 o <0 a SOCKET_ERROR
1398 * - ioctl y close pasan a ioctlsocket y closesocket
1399 * - inet_addr en lugar de inet_aton
1400 * - Codigo de inicializacion y terminacion para inicializar y
1401 * terminar WinSocket y para la ventana interna.
1402 * - SetTimeout, SetNonBlocking y la implementacion de los
1403 * timeouts eran bastante diferentes, pero ahora se han
1404 * hecho en la version Unix igual que en esta.
1405 */