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


b5f1c91debe49f6e4d1e3c8e13f06d3110764d49
[wxWidgets.git] / src / msw / sockmsw.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/sockmsw.cpp
3 // Purpose: MSW-specific socket code
4 // Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia
5 // Created: April 1997
6 // Copyright: (C) 1999-1997, Guilhem Lavaux
7 // (C) 1999-2000, Guillermo Rodriguez Garcia
8 // (C) 2008 Vadim Zeitlin
9 // RCS_ID: $Id$
10 // License: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #if wxUSE_SOCKETS
22
23 /* including rasasync.h (included from windows.h itself included from
24 * wx/setup.h and/or winsock.h results in this warning for
25 * RPCNOTIFICATION_ROUTINE
26 */
27 #ifdef _MSC_VER
28 # pragma warning(disable:4115) /* named type definition in parentheses */
29 #endif
30
31 #include "wx/private/socket.h"
32 #include "wx/msw/private.h" // for wxGetInstance()
33 #include "wx/apptrait.h"
34 #include "wx/thread.h"
35 #include "wx/dynlib.h"
36
37 #ifdef __WXWINCE__
38 /*
39 * As WSAAsyncSelect is not present on WinCE, it now uses WSACreateEvent,
40 * WSAEventSelect, WSAWaitForMultipleEvents and WSAEnumNetworkEvents. When
41 * enabling eventhandling for a socket a new thread it created that keeps track
42 * of the events and posts a messageto the hidden window to use the standard
43 * message loop.
44 */
45 #include "wx/msw/wince/net.h"
46 #include "wx/hashmap.h"
47 WX_DECLARE_HASH_MAP(int,bool,wxIntegerHash,wxIntegerEqual,SocketHash);
48
49 #ifndef isdigit
50 #define isdigit(x) (x > 47 && x < 58)
51 #endif
52 #include "wx/msw/wince/net.h"
53
54 #endif // __WXWINCE__
55
56 #ifdef _MSC_VER
57 # pragma warning(default:4115) /* named type definition in parentheses */
58 #endif
59
60 #define CLASSNAME TEXT("_wxSocket_Internal_Window_Class")
61
62 /* implemented in utils.cpp */
63 extern "C" WXDLLIMPEXP_BASE HWND
64 wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc);
65
66 /* Maximum number of different wxSocket objects at a given time.
67 * This value can be modified at will, but it CANNOT be greater
68 * than (0x7FFF - WM_USER + 1)
69 */
70 #define MAXSOCKETS 1024
71
72 #if (MAXSOCKETS > (0x7FFF - WM_USER + 1))
73 #error "MAXSOCKETS is too big!"
74 #endif
75
76 #ifndef __WXWINCE__
77 typedef int (PASCAL *WSAAsyncSelect_t)(SOCKET,HWND,u_int,long);
78 #else
79 /* Typedef the needed function prototypes and the WSANETWORKEVENTS structure
80 */
81 typedef struct _WSANETWORKEVENTS {
82 long lNetworkEvents;
83 int iErrorCode[10];
84 } WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
85 typedef HANDLE (PASCAL *WSACreateEvent_t)();
86 typedef int (PASCAL *WSAEventSelect_t)(SOCKET,HANDLE,long);
87 typedef int (PASCAL *WSAWaitForMultipleEvents_t)(long,HANDLE,BOOL,long,BOOL);
88 typedef int (PASCAL *WSAEnumNetworkEvents_t)(SOCKET,HANDLE,LPWSANETWORKEVENTS);
89 #endif //__WXWINCE__
90
91 LRESULT CALLBACK wxSocket_Internal_WinProc(HWND, UINT, WPARAM, LPARAM);
92
93 /* Global variables */
94
95 static HWND hWin;
96 wxCRIT_SECT_DECLARE_MEMBER(gs_critical);
97 static wxSocketImplMSW *socketList[MAXSOCKETS];
98 static int firstAvailable;
99
100 #ifndef __WXWINCE__
101 static WSAAsyncSelect_t gs_WSAAsyncSelect = NULL;
102 #else
103 static SocketHash socketHash;
104 static unsigned int currSocket;
105 HANDLE hThread[MAXSOCKETS];
106 static WSACreateEvent_t gs_WSACreateEvent = NULL;
107 static WSAEventSelect_t gs_WSAEventSelect = NULL;
108 static WSAWaitForMultipleEvents_t gs_WSAWaitForMultipleEvents = NULL;
109 static WSAEnumNetworkEvents_t gs_WSAEnumNetworkEvents = NULL;
110 /* This structure will be used to pass data on to the thread that handles socket events.
111 */
112 typedef struct thread_data{
113 HWND hEvtWin;
114 unsigned long msgnumber;
115 unsigned long fd;
116 unsigned long lEvent;
117 }thread_data;
118 #endif
119
120 #ifdef __WXWINCE__
121 /* This thread handles socket events on WinCE using WSAEventSelect() as
122 * WSAAsyncSelect is not supported. When an event occurs for the socket, it is
123 * checked what kind of event happend and the correct message gets posted so
124 * that the hidden window can handle it as it would in other MSW builds.
125 */
126 DWORD WINAPI SocketThread(LPVOID data)
127 {
128 WSANETWORKEVENTS NetworkEvents;
129 thread_data* d = (thread_data *)data;
130
131 HANDLE NetworkEvent = gs_WSACreateEvent();
132 gs_WSAEventSelect(d->fd, NetworkEvent, d->lEvent);
133
134 while(socketHash[d->fd] == true)
135 {
136 if ((gs_WSAWaitForMultipleEvents(1, &NetworkEvent, FALSE,INFINITE, FALSE)) == WAIT_FAILED)
137 {
138 printf("WSAWaitForMultipleEvents failed with error %d\n", WSAGetLastError());
139 return 0;
140 }
141 if (gs_WSAEnumNetworkEvents(d->fd ,NetworkEvent, &NetworkEvents) == SOCKET_ERROR)
142 {
143 printf("WSAEnumNetworkEvents failed with error %d\n", WSAGetLastError());
144 return 0;
145 }
146
147 long flags = NetworkEvents.lNetworkEvents;
148 if (flags & FD_READ)
149 ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_READ);
150 if (flags & FD_WRITE)
151 ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_WRITE);
152 if (flags & FD_OOB)
153 ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_OOB);
154 if (flags & FD_ACCEPT)
155 ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_ACCEPT);
156 if (flags & FD_CONNECT)
157 ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CONNECT);
158 if (flags & FD_CLOSE)
159 ::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CLOSE);
160
161 }
162 gs_WSAEventSelect(d->fd, NetworkEvent, 0);
163 ExitThread(0);
164 return 0;
165 }
166 #endif
167
168 // ----------------------------------------------------------------------------
169 // MSW implementation of wxSocketManager
170 // ----------------------------------------------------------------------------
171
172 class wxSocketMSWManager : public wxSocketManager
173 {
174 public:
175 virtual bool OnInit();
176 virtual void OnExit();
177
178 virtual wxSocketImpl *CreateSocket(wxSocketBase& wxsocket)
179 {
180 return new wxSocketImplMSW(wxsocket);
181 }
182 virtual void Install_Callback(wxSocketImpl *socket, wxSocketNotify event);
183 virtual void Uninstall_Callback(wxSocketImpl *socket, wxSocketNotify event);
184
185 private:
186 static wxDynamicLibrary gs_wsock32dll;
187 };
188
189 wxDynamicLibrary wxSocketMSWManager::gs_wsock32dll;
190
191 bool wxSocketMSWManager::OnInit()
192 {
193 static LPCTSTR pclassname = NULL;
194 int i;
195
196 /* Create internal window for event notifications */
197 hWin = wxCreateHiddenWindow(&pclassname, CLASSNAME, wxSocket_Internal_WinProc);
198 if (!hWin)
199 return false;
200
201 /* Initialize socket list */
202 for (i = 0; i < MAXSOCKETS; i++)
203 {
204 socketList[i] = NULL;
205 }
206 firstAvailable = 0;
207
208 // we don't link with wsock32.dll (or ws2 in CE case) statically to avoid
209 // dependencies on it for all the application using wx even if they don't use
210 // sockets
211 #ifdef __WXWINCE__
212 #define WINSOCK_DLL_NAME _T("ws2.dll")
213 #else
214 #define WINSOCK_DLL_NAME _T("wsock32.dll")
215 #endif
216
217 gs_wsock32dll.Load(WINSOCK_DLL_NAME, wxDL_VERBATIM | wxDL_QUIET);
218 if ( !gs_wsock32dll.IsLoaded() )
219 return false;
220
221 #ifndef __WXWINCE__
222 wxDL_INIT_FUNC(gs_, WSAAsyncSelect, gs_wsock32dll);
223 if ( !gs_WSAAsyncSelect )
224 return false;
225 #else
226 wxDL_INIT_FUNC(gs_, WSAEventSelect, gs_wsock32dll);
227 if ( !gs_WSAEventSelect )
228 return false;
229
230 wxDL_INIT_FUNC(gs_, WSACreateEvent, gs_wsock32dll);
231 if ( !gs_WSACreateEvent )
232 return false;
233
234 wxDL_INIT_FUNC(gs_, WSAWaitForMultipleEvents, gs_wsock32dll);
235 if ( !gs_WSAWaitForMultipleEvents )
236 return false;
237
238 wxDL_INIT_FUNC(gs_, WSAEnumNetworkEvents, gs_wsock32dll);
239 if ( !gs_WSAEnumNetworkEvents )
240 return false;
241
242 currSocket = 0;
243 #endif // !__WXWINCE__/__WXWINCE__
244
245 // finally initialize WinSock
246 WSADATA wsaData;
247 return WSAStartup((1 << 8) | 1, &wsaData) == 0;
248 }
249
250 void wxSocketMSWManager::OnExit()
251 {
252 #ifdef __WXWINCE__
253 /* Delete the threads here */
254 for(unsigned int i=0; i < currSocket; i++)
255 CloseHandle(hThread[i]);
256 #endif
257 /* Destroy internal window */
258 DestroyWindow(hWin);
259 UnregisterClass(CLASSNAME, wxGetInstance());
260
261 WSACleanup();
262
263 gs_wsock32dll.Unload();
264 }
265
266 /* Per-socket GUI initialization / cleanup */
267
268 wxSocketImplMSW::wxSocketImplMSW(wxSocketBase& wxsocket)
269 : wxSocketImpl(wxsocket)
270 {
271 /* Allocate a new message number for this socket */
272 wxCRIT_SECT_LOCKER(lock, gs_critical);
273
274 int i = firstAvailable;
275 while (socketList[i] != NULL)
276 {
277 i = (i + 1) % MAXSOCKETS;
278
279 if (i == firstAvailable) /* abort! */
280 {
281 m_msgnumber = 0; // invalid
282 return;
283 }
284 }
285 socketList[i] = this;
286 firstAvailable = (i + 1) % MAXSOCKETS;
287 m_msgnumber = (i + WM_USER);
288 }
289
290 wxSocketImplMSW::~wxSocketImplMSW()
291 {
292 /* Remove the socket from the list */
293 wxCRIT_SECT_LOCKER(lock, gs_critical);
294
295 if ( m_msgnumber )
296 {
297 // we need to remove any pending messages for this socket to avoid having
298 // them sent to a new socket which could reuse the same message number as
299 // soon as we destroy this one
300 MSG msg;
301 while ( ::PeekMessage(&msg, hWin, m_msgnumber, m_msgnumber, PM_REMOVE) )
302 ;
303
304 socketList[m_msgnumber - WM_USER] = NULL;
305 }
306 //else: the socket has never been created successfully
307 }
308
309 /* Windows proc for asynchronous event handling */
310
311 LRESULT CALLBACK wxSocket_Internal_WinProc(HWND hWnd,
312 UINT uMsg,
313 WPARAM wParam,
314 LPARAM lParam)
315 {
316 if ( uMsg < WM_USER || uMsg > (WM_USER + MAXSOCKETS - 1))
317 return DefWindowProc(hWnd, uMsg, wParam, lParam);
318
319 wxSocketImplMSW *socket;
320 wxSocketNotify event;
321 {
322 wxCRIT_SECT_LOCKER(lock, gs_critical);
323
324 socket = socketList[(uMsg - WM_USER)];
325 event = (wxSocketNotify) -1;
326
327 /* Check that the socket still exists (it has not been
328 * destroyed) and for safety, check that the m_fd field
329 * is what we expect it to be.
330 */
331 if ((socket != NULL) && ((WPARAM)socket->m_fd == wParam))
332 {
333 switch WSAGETSELECTEVENT(lParam)
334 {
335 case FD_READ: event = wxSOCKET_INPUT; break;
336 case FD_WRITE: event = wxSOCKET_OUTPUT; break;
337 case FD_ACCEPT: event = wxSOCKET_CONNECTION; break;
338 case FD_CONNECT:
339 {
340 if (WSAGETSELECTERROR(lParam) != 0)
341 event = wxSOCKET_LOST;
342 else
343 event = wxSOCKET_CONNECTION;
344 break;
345 }
346 case FD_CLOSE: event = wxSOCKET_LOST; break;
347 }
348
349 if (event != -1)
350 {
351 if (event == wxSOCKET_LOST)
352 socket->m_detected = wxSOCKET_LOST_FLAG;
353 else
354 socket->m_detected |= (1 << event);
355 }
356 }
357 } // unlock gs_critical
358
359 if ( socket )
360 socket->NotifyOnStateChange(event);
361
362 return (LRESULT) 0;
363 }
364
365 /*
366 * Enable all event notifications; we need to be notified of all
367 * events for internal processing, but we will only notify users
368 * when an appropriate callback function has been installed.
369 */
370 void wxSocketMSWManager::Install_Callback(wxSocketImpl *socket_,
371 wxSocketNotify WXUNUSED(event))
372 {
373 wxSocketImplMSW * const socket = static_cast<wxSocketImplMSW *>(socket_);
374
375 if (socket->m_fd != INVALID_SOCKET)
376 {
377 /* We could probably just subscribe to all events regardless
378 * of the socket type, but MS recommends to do it this way.
379 */
380 long lEvent = socket->m_server?
381 FD_ACCEPT : (FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE);
382 #ifndef __WXWINCE__
383 gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, lEvent);
384 #else
385 /*
386 * WinCE creates a thread for socket event handling.
387 * All needed parameters get passed through the thread_data structure.
388 */
389
390 thread_data* d = new thread_data;
391 d->lEvent = lEvent;
392 d->hEvtWin = hWin;
393 d->msgnumber = socket->m_msgnumber;
394 d->fd = socket->m_fd;
395 socketHash[socket->m_fd] = true;
396 hThread[currSocket++] = CreateThread(NULL, 0, &SocketThread,(LPVOID)d, 0, NULL);
397 #endif
398 }
399 }
400
401 /*
402 * Disable event notifications (used when shutting down the socket)
403 */
404 void wxSocketMSWManager::Uninstall_Callback(wxSocketImpl *socket_,
405 wxSocketNotify WXUNUSED(event))
406 {
407 wxSocketImplMSW * const socket = static_cast<wxSocketImplMSW *>(socket_);
408
409 if (socket->m_fd != INVALID_SOCKET)
410 {
411 #ifndef __WXWINCE__
412 gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, 0);
413 #else
414 //Destroy the thread
415 socketHash[socket->m_fd] = false;
416 #endif
417 }
418 }
419
420 // set the wxBase variable to point to our wxSocketManager implementation
421 //
422 // see comments in wx/apptrait.h for the explanation of why do we do it
423 // like this
424 static struct ManagerSetter
425 {
426 ManagerSetter()
427 {
428 static wxSocketMSWManager s_manager;
429 wxAppTraits::SetDefaultSocketManager(&s_manager);
430 }
431 } gs_managerSetter;
432
433 // ============================================================================
434 // wxSocketImpl implementation
435 // ============================================================================
436
437 /* static */
438 wxSocketImpl *wxSocketImpl::Create(wxSocketBase& wxsocket)
439 {
440 return new wxSocketImplMSW(wxsocket);
441 }
442
443 void wxSocketImplMSW::DoClose()
444 {
445 wxSocketManager::Get()->
446 Uninstall_Callback(this, wxSOCKET_MAX_EVENT /* unused anyhow */);
447
448 closesocket(m_fd);
449 }
450
451 wxSocketError wxSocketImplMSW::GetLastError() const
452 {
453 switch ( WSAGetLastError() )
454 {
455 case 0:
456 return wxSOCKET_NOERROR;
457
458 case WSAENOTSOCK:
459 return wxSOCKET_INVSOCK;
460
461 case WSAEWOULDBLOCK:
462 return wxSOCKET_WOULDBLOCK;
463
464 default:
465 return wxSOCKET_IOERR;
466 }
467 }
468
469 /* Generic IO */
470
471 /* Like recv(), send(), ... */
472 int wxSocketImplMSW::Read(void *buffer, int size)
473 {
474 int ret;
475
476 /* Reenable INPUT events */
477 m_detected &= ~wxSOCKET_INPUT_FLAG;
478
479 if (m_fd == INVALID_SOCKET || m_server)
480 {
481 m_error = wxSOCKET_INVSOCK;
482 return -1;
483 }
484
485 /* Read the data */
486 if (m_stream)
487 ret = Recv_Stream(buffer, size);
488 else
489 ret = Recv_Dgram(buffer, size);
490
491 if (ret == SOCKET_ERROR)
492 {
493 if (WSAGetLastError() != WSAEWOULDBLOCK)
494 m_error = wxSOCKET_IOERR;
495 else
496 m_error = wxSOCKET_WOULDBLOCK;
497 return -1;
498 }
499
500 return ret;
501 }
502
503 int wxSocketImplMSW::Write(const void *buffer, int size)
504 {
505 int ret;
506
507 if (m_fd == INVALID_SOCKET || m_server)
508 {
509 m_error = wxSOCKET_INVSOCK;
510 return -1;
511 }
512
513 /* Write the data */
514 if (m_stream)
515 ret = Send_Stream(buffer, size);
516 else
517 ret = Send_Dgram(buffer, size);
518
519 if (ret == SOCKET_ERROR)
520 {
521 if (WSAGetLastError() != WSAEWOULDBLOCK)
522 m_error = wxSOCKET_IOERR;
523 else
524 m_error = wxSOCKET_WOULDBLOCK;
525
526 /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
527 * does). Once the first OUTPUT event is received, users can assume
528 * that the socket is writable until a read operation fails. Only then
529 * will further OUTPUT events be posted.
530 */
531 m_detected &= ~wxSOCKET_OUTPUT_FLAG;
532 return -1;
533 }
534
535 return ret;
536 }
537
538 /* Internals (IO) */
539
540 /*
541 * For blocking sockets, wait until the connection is
542 * established or fails, or until timeout ellapses.
543 */
544 wxSocketError wxSocketImplMSW::Connect_Timeout()
545 {
546 fd_set writefds;
547 fd_set exceptfds;
548
549 FD_ZERO(&writefds);
550 FD_ZERO(&exceptfds);
551 FD_SET(m_fd, &writefds);
552 FD_SET(m_fd, &exceptfds);
553 if (select(0, NULL, &writefds, &exceptfds, &m_timeout) == 0)
554 {
555 m_error = wxSOCKET_TIMEDOUT;
556 return wxSOCKET_TIMEDOUT;
557 }
558 if (!FD_ISSET(m_fd, &writefds))
559 {
560 m_error = wxSOCKET_IOERR;
561 return wxSOCKET_IOERR;
562 }
563
564 return wxSOCKET_NOERROR;
565 }
566
567 int wxSocketImplMSW::Recv_Stream(void *buffer, int size)
568 {
569 return recv(m_fd, static_cast<char *>(buffer), size, 0);
570 }
571
572 int wxSocketImplMSW::Recv_Dgram(void *buffer, int size)
573 {
574 wxSockAddr from;
575 WX_SOCKLEN_T fromlen = sizeof(from);
576 int ret;
577 wxSocketError err;
578
579 ret = recvfrom(m_fd, static_cast<char *>(buffer),
580 size, 0, &from, &fromlen);
581
582 if (ret == SOCKET_ERROR)
583 return SOCKET_ERROR;
584
585 /* Translate a system address into a wxSocketImpl address */
586 if (!m_peer)
587 {
588 m_peer = GAddress_new();
589 if (!m_peer)
590 {
591 m_error = wxSOCKET_MEMERR;
592 return -1;
593 }
594 }
595 err = _GAddress_translate_from(m_peer, (sockaddr*)&from, fromlen);
596 if (err != wxSOCKET_NOERROR)
597 {
598 GAddress_destroy(m_peer);
599 m_peer = NULL;
600 m_error = err;
601 return -1;
602 }
603
604 return ret;
605 }
606
607 int wxSocketImplMSW::Send_Stream(const void *buffer, int size)
608 {
609 return send(m_fd, static_cast<const char *>(buffer), size, 0);
610 }
611
612 int wxSocketImplMSW::Send_Dgram(const void *buffer, int size)
613 {
614 struct sockaddr *addr;
615 int len, ret;
616 wxSocketError err;
617
618 if (!m_peer)
619 {
620 m_error = wxSOCKET_INVADDR;
621 return -1;
622 }
623
624 err = _GAddress_translate_to(m_peer, &addr, &len);
625 if (err != wxSOCKET_NOERROR)
626 {
627 m_error = err;
628 return -1;
629 }
630
631 ret = sendto(m_fd, static_cast<const char *>(buffer), size, 0, addr, len);
632
633 /* Frees memory allocated by _GAddress_translate_to */
634 free(addr);
635
636 return ret;
637 }
638
639 /*
640 * -------------------------------------------------------------------------
641 * GAddress
642 * -------------------------------------------------------------------------
643 */
644
645 /* CHECK_ADDRESS verifies that the current address family is either
646 * wxSOCKET_NOFAMILY or wxSOCKET_*family*, and if it is wxSOCKET_NOFAMILY, it
647 * initalizes it to be a wxSOCKET_*family*. In other cases, it returns
648 * an appropiate error code.
649 *
650 * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
651 */
652 #define CHECK_ADDRESS(address, family) \
653 { \
654 if (address->m_family == wxSOCKET_NOFAMILY) \
655 if (_GAddress_Init_##family(address) != wxSOCKET_NOERROR) \
656 return address->m_error; \
657 if (address->m_family != wxSOCKET_##family) \
658 { \
659 address->m_error = wxSOCKET_INVADDR; \
660 return wxSOCKET_INVADDR; \
661 } \
662 }
663
664 #define CHECK_ADDRESS_RETVAL(address, family, retval) \
665 { \
666 if (address->m_family == wxSOCKET_NOFAMILY) \
667 if (_GAddress_Init_##family(address) != wxSOCKET_NOERROR) \
668 return retval; \
669 if (address->m_family != wxSOCKET_##family) \
670 { \
671 address->m_error = wxSOCKET_INVADDR; \
672 return retval; \
673 } \
674 }
675
676
677 GAddress *GAddress_new()
678 {
679 GAddress *address;
680
681 if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
682 return NULL;
683
684 address->m_family = wxSOCKET_NOFAMILY;
685 address->m_addr = NULL;
686 address->m_len = 0;
687
688 return address;
689 }
690
691 GAddress *GAddress_copy(GAddress *address)
692 {
693 GAddress *addr2;
694
695 if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
696 return NULL;
697
698 memcpy(addr2, address, sizeof(GAddress));
699
700 if (address->m_addr)
701 {
702 addr2->m_addr = (struct sockaddr *) malloc(addr2->m_len);
703 if (addr2->m_addr == NULL)
704 {
705 free(addr2);
706 return NULL;
707 }
708 memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
709 }
710
711 return addr2;
712 }
713
714 void GAddress_destroy(GAddress *address)
715 {
716 if (address->m_addr)
717 free(address->m_addr);
718
719 free(address);
720 }
721
722 void GAddress_SetFamily(GAddress *address, GAddressType type)
723 {
724 address->m_family = type;
725 }
726
727 GAddressType GAddress_GetFamily(GAddress *address)
728 {
729 return address->m_family;
730 }
731
732 wxSocketError _GAddress_translate_from(GAddress *address,
733 struct sockaddr *addr, int len)
734 {
735 address->m_realfamily = addr->sa_family;
736 switch (addr->sa_family)
737 {
738 case AF_INET:
739 address->m_family = wxSOCKET_INET;
740 break;
741 case AF_UNIX:
742 address->m_family = wxSOCKET_UNIX;
743 break;
744 #if wxUSE_IPV6
745 case AF_INET6:
746 address->m_family = wxSOCKET_INET6;
747 break;
748 #endif
749 default:
750 {
751 address->m_error = wxSOCKET_INVOP;
752 return wxSOCKET_INVOP;
753 }
754 }
755
756 if (address->m_addr)
757 free(address->m_addr);
758
759 address->m_len = len;
760 address->m_addr = (struct sockaddr *) malloc(len);
761
762 if (address->m_addr == NULL)
763 {
764 address->m_error = wxSOCKET_MEMERR;
765 return wxSOCKET_MEMERR;
766 }
767 memcpy(address->m_addr, addr, len);
768
769 return wxSOCKET_NOERROR;
770 }
771
772 wxSocketError _GAddress_translate_to(GAddress *address,
773 struct sockaddr **addr, int *len)
774 {
775 if (!address->m_addr)
776 {
777 address->m_error = wxSOCKET_INVADDR;
778 return wxSOCKET_INVADDR;
779 }
780
781 *len = address->m_len;
782 *addr = (struct sockaddr *) malloc(address->m_len);
783 if (*addr == NULL)
784 {
785 address->m_error = wxSOCKET_MEMERR;
786 return wxSOCKET_MEMERR;
787 }
788
789 memcpy(*addr, address->m_addr, address->m_len);
790 return wxSOCKET_NOERROR;
791 }
792
793 /*
794 * -------------------------------------------------------------------------
795 * Internet address family
796 * -------------------------------------------------------------------------
797 */
798
799 wxSocketError _GAddress_Init_INET(GAddress *address)
800 {
801 address->m_len = sizeof(struct sockaddr_in);
802 address->m_addr = (struct sockaddr *) malloc(address->m_len);
803 if (address->m_addr == NULL)
804 {
805 address->m_error = wxSOCKET_MEMERR;
806 return wxSOCKET_MEMERR;
807 }
808
809 address->m_family = wxSOCKET_INET;
810 address->m_realfamily = AF_INET;
811 ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
812 ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
813
814 return wxSOCKET_NOERROR;
815 }
816
817 wxSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
818 {
819 struct hostent *he;
820 struct in_addr *addr;
821
822 CHECK_ADDRESS(address, INET);
823
824 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
825
826 addr->s_addr = inet_addr(hostname);
827
828 /* If it is a numeric host name, convert it now */
829 if (addr->s_addr == INADDR_NONE)
830 {
831 struct in_addr *array_addr;
832
833 /* It is a real name, we solve it */
834 if ((he = gethostbyname(hostname)) == NULL)
835 {
836 /* addr->s_addr = INADDR_NONE just done by inet_addr() above */
837 address->m_error = wxSOCKET_NOHOST;
838 return wxSOCKET_NOHOST;
839 }
840 array_addr = (struct in_addr *) *(he->h_addr_list);
841 addr->s_addr = array_addr[0].s_addr;
842 }
843 return wxSOCKET_NOERROR;
844 }
845
846 wxSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
847 {
848 return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
849 }
850
851 wxSocketError GAddress_INET_SetAnyAddress(GAddress *address)
852 {
853 return GAddress_INET_SetHostAddress(address, INADDR_ANY);
854 }
855
856 wxSocketError GAddress_INET_SetHostAddress(GAddress *address,
857 unsigned long hostaddr)
858 {
859 struct in_addr *addr;
860
861 CHECK_ADDRESS(address, INET);
862
863 addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
864 addr->s_addr = htonl(hostaddr);
865
866 return wxSOCKET_NOERROR;
867 }
868
869 wxSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
870 const char *protocol)
871 {
872 struct servent *se;
873 struct sockaddr_in *addr;
874
875 CHECK_ADDRESS(address, INET);
876
877 if (!port)
878 {
879 address->m_error = wxSOCKET_INVPORT;
880 return wxSOCKET_INVPORT;
881 }
882
883 se = getservbyname(port, protocol);
884 if (!se)
885 {
886 if (isdigit(port[0]))
887 {
888 int port_int;
889
890 port_int = atoi(port);
891 addr = (struct sockaddr_in *)address->m_addr;
892 addr->sin_port = htons((u_short) port_int);
893 return wxSOCKET_NOERROR;
894 }
895
896 address->m_error = wxSOCKET_INVPORT;
897 return wxSOCKET_INVPORT;
898 }
899
900 addr = (struct sockaddr_in *)address->m_addr;
901 addr->sin_port = se->s_port;
902
903 return wxSOCKET_NOERROR;
904 }
905
906 wxSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
907 {
908 struct sockaddr_in *addr;
909
910 CHECK_ADDRESS(address, INET);
911
912 addr = (struct sockaddr_in *)address->m_addr;
913 addr->sin_port = htons(port);
914
915 return wxSOCKET_NOERROR;
916 }
917
918 wxSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
919 {
920 struct hostent *he;
921 char *addr_buf;
922 struct sockaddr_in *addr;
923
924 CHECK_ADDRESS(address, INET);
925
926 addr = (struct sockaddr_in *)address->m_addr;
927 addr_buf = (char *)&(addr->sin_addr);
928
929 he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
930 if (he == NULL)
931 {
932 address->m_error = wxSOCKET_NOHOST;
933 return wxSOCKET_NOHOST;
934 }
935
936 strncpy(hostname, he->h_name, sbuf);
937
938 return wxSOCKET_NOERROR;
939 }
940
941 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
942 {
943 struct sockaddr_in *addr;
944
945 CHECK_ADDRESS_RETVAL(address, INET, 0);
946
947 addr = (struct sockaddr_in *)address->m_addr;
948
949 return ntohl(addr->sin_addr.s_addr);
950 }
951
952 unsigned short GAddress_INET_GetPort(GAddress *address)
953 {
954 struct sockaddr_in *addr;
955
956 CHECK_ADDRESS_RETVAL(address, INET, 0);
957
958 addr = (struct sockaddr_in *)address->m_addr;
959 return ntohs(addr->sin_port);
960 }
961
962
963 #if wxUSE_IPV6
964 /*
965 * -------------------------------------------------------------------------
966 * Internet IPv6 address family
967 * -------------------------------------------------------------------------
968 */
969 #include "ws2tcpip.h"
970
971 #ifdef __VISUALC__
972 #pragma comment(lib,"ws2_32")
973 #endif // __VISUALC__
974
975 wxSocketError _GAddress_Init_INET6(GAddress *address)
976 {
977 struct in6_addr any_address = IN6ADDR_ANY_INIT;
978 address->m_len = sizeof(struct sockaddr_in6);
979 address->m_addr = (struct sockaddr *) malloc(address->m_len);
980 if (address->m_addr == NULL)
981 {
982 address->m_error = wxSOCKET_MEMERR;
983 return wxSOCKET_MEMERR;
984 }
985 memset(address->m_addr,0,address->m_len);
986
987 address->m_family = wxSOCKET_INET6;
988 address->m_realfamily = AF_INET6;
989 ((struct sockaddr_in6 *)address->m_addr)->sin6_family = AF_INET6;
990 ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = any_address;
991
992 return wxSOCKET_NOERROR;
993 }
994
995 wxSocketError GAddress_INET6_SetHostName(GAddress *address, const char *hostname)
996 {
997 CHECK_ADDRESS(address, INET6);
998
999 addrinfo hints;
1000 memset( & hints, 0, sizeof( hints ) );
1001 hints.ai_family = AF_INET6;
1002 addrinfo * info = 0;
1003 if ( getaddrinfo( hostname, "0", & hints, & info ) || ! info )
1004 {
1005 address->m_error = wxSOCKET_NOHOST;
1006 return wxSOCKET_NOHOST;
1007 }
1008
1009 memcpy( address->m_addr, info->ai_addr, info->ai_addrlen );
1010 freeaddrinfo( info );
1011 return wxSOCKET_NOERROR;
1012 }
1013
1014 wxSocketError GAddress_INET6_SetAnyAddress(GAddress *address)
1015 {
1016 CHECK_ADDRESS(address, INET6);
1017
1018 struct in6_addr addr;
1019 memset( & addr, 0, sizeof( addr ) );
1020 return GAddress_INET6_SetHostAddress(address, addr);
1021 }
1022 wxSocketError GAddress_INET6_SetHostAddress(GAddress *address,
1023 struct in6_addr hostaddr)
1024 {
1025 CHECK_ADDRESS(address, INET6);
1026
1027 ((struct sockaddr_in6 *)address->m_addr)->sin6_addr = hostaddr;
1028
1029 return wxSOCKET_NOERROR;
1030 }
1031
1032 wxSocketError GAddress_INET6_SetPortName(GAddress *address, const char *port,
1033 const char *protocol)
1034 {
1035 struct servent *se;
1036 struct sockaddr_in6 *addr;
1037
1038 CHECK_ADDRESS(address, INET6);
1039
1040 if (!port)
1041 {
1042 address->m_error = wxSOCKET_INVPORT;
1043 return wxSOCKET_INVPORT;
1044 }
1045
1046 se = getservbyname(port, protocol);
1047 if (!se)
1048 {
1049 if (isdigit((unsigned char) port[0]))
1050 {
1051 int port_int;
1052
1053 port_int = atoi(port);
1054 addr = (struct sockaddr_in6 *)address->m_addr;
1055 addr->sin6_port = htons((u_short) port_int);
1056 return wxSOCKET_NOERROR;
1057 }
1058
1059 address->m_error = wxSOCKET_INVPORT;
1060 return wxSOCKET_INVPORT;
1061 }
1062
1063 addr = (struct sockaddr_in6 *)address->m_addr;
1064 addr->sin6_port = se->s_port;
1065
1066 return wxSOCKET_NOERROR;
1067 }
1068
1069 wxSocketError GAddress_INET6_SetPort(GAddress *address, unsigned short port)
1070 {
1071 struct sockaddr_in6 *addr;
1072
1073 CHECK_ADDRESS(address, INET6);
1074
1075 addr = (struct sockaddr_in6 *)address->m_addr;
1076 addr->sin6_port = htons(port);
1077
1078 return wxSOCKET_NOERROR;
1079 }
1080
1081 wxSocketError GAddress_INET6_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1082 {
1083 struct hostent *he;
1084 char *addr_buf;
1085 struct sockaddr_in6 *addr;
1086
1087 CHECK_ADDRESS(address, INET6);
1088
1089 addr = (struct sockaddr_in6 *)address->m_addr;
1090 addr_buf = (char *)&(addr->sin6_addr);
1091
1092 he = gethostbyaddr(addr_buf, sizeof(addr->sin6_addr), AF_INET6);
1093 if (he == NULL)
1094 {
1095 address->m_error = wxSOCKET_NOHOST;
1096 return wxSOCKET_NOHOST;
1097 }
1098
1099 strncpy(hostname, he->h_name, sbuf);
1100
1101 return wxSOCKET_NOERROR;
1102 }
1103
1104 wxSocketError GAddress_INET6_GetHostAddress(GAddress *address,struct in6_addr *hostaddr)
1105 {
1106 CHECK_ADDRESS_RETVAL(address, INET6, wxSOCKET_INVADDR);
1107 *hostaddr = ( (struct sockaddr_in6 *)address->m_addr )->sin6_addr;
1108 return wxSOCKET_NOERROR;
1109 }
1110
1111 unsigned short GAddress_INET6_GetPort(GAddress *address)
1112 {
1113 CHECK_ADDRESS_RETVAL(address, INET6, 0);
1114
1115 return ntohs( ((struct sockaddr_in6 *)address->m_addr)->sin6_port );
1116 }
1117
1118 #endif // wxUSE_IPV6
1119
1120 /*
1121 * -------------------------------------------------------------------------
1122 * Unix address family
1123 * -------------------------------------------------------------------------
1124 */
1125
1126 wxSocketError _GAddress_Init_UNIX(GAddress *address)
1127 {
1128 address->m_error = wxSOCKET_INVADDR;
1129 return wxSOCKET_INVADDR;
1130 }
1131
1132 wxSocketError GAddress_UNIX_SetPath(GAddress *address, const char *WXUNUSED(path))
1133 {
1134 address->m_error = wxSOCKET_INVADDR;
1135 return wxSOCKET_INVADDR;
1136 }
1137
1138 wxSocketError GAddress_UNIX_GetPath(GAddress *address, char *WXUNUSED(path), size_t WXUNUSED(sbuf))
1139 {
1140 address->m_error = wxSOCKET_INVADDR;
1141 return wxSOCKET_INVADDR;
1142 }
1143
1144 #endif // wxUSE_SOCKETS
wxWidgets (Impactor)