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


e9a222b142ad3735b4a7388d97a494f1b4e09cda
[wxWidgets.git] / src / common / socket.cpp
1 ////////////////////////////////////////////////////////////////////////////////
2 // Name: socket.cpp
3 // Purpose: Socket handler classes
4 // Authors: Guilhem Lavaux (completely rewritten from a basic API of Andrew
5 // Davidson(1995) in wxWeb)
6 // Created: April 1997
7 // Updated: March 1998
8 // Copyright: (C) 1998, 1997, Guilhem Lavaux
9 // RCS_ID: $Id$
10 // License: see wxWindows license
11 ////////////////////////////////////////////////////////////////////////////////
12 #ifdef __GNUG__
13 #pragma implementation "socket.h"
14 #endif
15
16 #ifdef __MWERKS__
17 typedef int socklen_t ;
18 #endif
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 /////////////////////////////////////////////////////////////////////////////
28 // wxWindows headers
29 /////////////////////////////////////////////////////////////////////////////
30 #include <wx/defs.h>
31 #include <wx/object.h>
32 #include <wx/string.h>
33 #include <wx/timer.h>
34 #include <wx/utils.h>
35
36 // Not enough OS behaviour defined for wxStubs
37 #ifndef __WXSTUBS__
38
39 #include <stdlib.h>
40 #include <string.h>
41 #include <ctype.h>
42
43 /////////////////////////////////////////////////////////////////////////////
44 // System specific headers
45 /////////////////////////////////////////////////////////////////////////////
46 #ifdef __WXMAC__
47 // in order to avoid problems with our c library and double definitions
48 #define close closesocket
49 #define ioctl ioctlsocket
50
51 #include <wx/mac/macsock.h>
52 extern GUSISpinFn GUSISpin;
53 #define PROCESS_EVENTS() wxMacProcessEvents()
54 const short kwxMacNetEventsMax = 1000 ;
55 short wxMacNetEventsTop = 0 ;
56 short wxMacNetEventsBottom = 0 ;
57 short wxMacNetEventsEvents[kwxMacNetEventsMax] ;
58 void *wxMacNetEventsReferences[kwxMacNetEventsMax] ;
59
60 #define FD_READ 1
61 #define FD_WRITE 2
62 #define FD_CLOSE 4
63 #define FD_ACCEPT 8
64 #define FD_CONNECT 16
65 #define FD_READY 32
66
67 extern "C" void wxMacSocketHandlerProc( void *refcon , short event ) ; // adds events
68 extern "C" void wxMacSocketOnRequestProc( void *refcon , short event ) ; // consumes them
69 extern "C" void GUSISetReference( short sock , short eventmask , void * data ) ;
70 void wxMacProcessEvents() ;
71 #endif
72
73 #if defined(__WINDOWS__)
74 #include <winsock.h>
75 #endif // __WINDOWS__
76
77 #if defined(__UNIX__)
78
79 #ifdef VMS
80 #include <socket.h>
81 #else
82 #include <sys/socket.h>
83 #endif
84 #include <sys/ioctl.h>
85
86 #include <sys/time.h>
87 #include <unistd.h>
88
89 #ifdef sun
90 #include <sys/filio.h>
91 #endif
92
93 #endif // __UNIX__
94
95 #include <signal.h>
96 #include <errno.h>
97
98 #ifdef __VISUALC__
99 #include <io.h>
100 #endif
101
102 #if defined(__WXMOTIF__) || defined(__WXXT__)
103 #include <X11/Intrinsic.h>
104
105 /////////////////////////////
106 // Needs internal variables
107 /////////////////////////////
108 #ifdef __WXXT__
109 #define Uses_XtIntrinsic
110 #endif
111
112 #endif
113
114 #if defined(__WXGTK__)
115 #include <gtk/gtk.h>
116 #endif
117
118 /////////////////////////////////////////////////////////////////////////////
119 // wxSocket headers
120 /////////////////////////////////////////////////////////////////////////////
121 #include "wx/module.h"
122 #define WXSOCK_INTERNAL
123 #include "wx/sckaddr.h"
124 #include "wx/socket.h"
125
126 /////////////////////////////////////////////////////////////////////////////
127 // Some patch ///// BEGIN
128 /////////////////////////////////////////////////////////////////////////////
129 #ifdef __WINDOWS__
130 #define close closesocket
131 #define ioctl ioctlsocket
132 #ifdef errno
133 #undef errno
134 #endif
135 #define errno WSAGetLastError()
136 #ifdef EWOULDBLOCK
137 #undef EWOULDBLOCK
138 #endif
139 #define EWOULDBLOCK WSAEWOULDBLOCK
140 #define ETIMEDOUT WSAETIMEDOUT
141 #undef EINTR
142 #define EINTR WSAEINTR
143 #endif
144
145 #ifndef __WINDOWS__
146 #define INVALID_SOCKET -1
147 #endif
148
149 #ifdef __WXMOTIF__
150 #define wxAPP_CONTEXT ((XtAppContext)wxTheApp->GetAppContext())
151 #endif
152
153 #ifdef __WINDOWS__
154 // This is an MS TCP/IP routine and is not needed here. Some WinSock
155 // implementations (such as PC-NFS) will require you to include this
156 // or a similar routine (see appendix in WinSock doc or help file).
157
158 #if defined( NEED_WSAFDIsSet ) || defined( __VISUALC__ )
159 int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *set)
160 {
161 int i = set->fd_count;
162
163 while (i--)
164 {
165 if (set->fd_array[i] == fd)
166 return 1;
167 }
168
169 return 0;
170 }
171 #endif
172 #endif
173
174 #if defined(__WINDOWS__)
175 #define PROCESS_EVENTS() wxYield()
176 #elif defined(__WXXT__) || defined(__WXMOTIF__)
177 #define PROCESS_EVENTS() XtAppProcessEvent(wxAPP_CONTEXT, XtIMAll)
178 #elif defined(__WXGTK__)
179 #define PROCESS_EVENTS() gtk_main_iteration()
180 #endif
181
182 /////////////////////////////////////////////////////////////////////////////
183 // Some patch ///// END
184 /////////////////////////////////////////////////////////////////////////////
185
186 #ifdef GetClassInfo
187 #undef GetClassInfo
188 #endif
189
190 // --------------------------------------------------------------
191 // Module
192 // --------------------------------------------------------------
193 class wxSocketModule: public wxModule
194 {
195 DECLARE_DYNAMIC_CLASS(wxSocketModule)
196 public:
197 wxSocketModule() {}
198 bool OnInit();
199 void OnExit();
200 };
201
202 // --------------------------------------------------------------
203 // ClassInfos
204 // --------------------------------------------------------------
205 #if !USE_SHARED_LIBRARY
206 IMPLEMENT_CLASS(wxSocketBase, wxObject)
207 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
208 IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
209 IMPLEMENT_CLASS(wxSocketHandler, wxObject)
210 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
211 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
212 #endif
213
214 class wxSockWakeUp : public wxTimer
215 {
216 public:
217 int *my_id;
218 int n_val;
219 wxSocketBase *sock;
220
221 wxSockWakeUp(wxSocketBase *_sock, int *id, int new_val)
222 {
223 my_id = id; n_val = new_val;
224 sock = _sock;
225 }
226 virtual void Notify()
227 {
228 *my_id = n_val;
229 if (sock) sock->Notify(FALSE);
230 }
231 };
232
233 /// Socket request
234 class SockRequest : public wxObject
235 {
236 public:
237 char *buffer;
238 size_t size, nbytes;
239 bool done;
240 int error;
241 wxSockWakeUp *auto_wakeup;
242 wxSocketBase::wxRequestNotify type;
243 };
244
245
246 /////////////////////////////////////////////////////////////////////////////
247 // Some internal define
248 /////////////////////////////////////////////////////////////////////////////
249
250 // --------------------------------------------------------------
251 // --------- wxSocketBase CONSTRUCTOR ---------------------------
252 // --------------------------------------------------------------
253 wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags,
254 wxSocketBase::wxSockType _type) :
255 wxEvtHandler(),
256 m_flags(_flags), m_type(_type), m_connected(FALSE), m_connecting(FALSE),
257 m_fd(INVALID_SOCKET), m_waitflags(0), m_cbk(0), m_cdata(0), m_id(-1),
258 m_handler(0),
259 m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)),
260 m_cbkon(FALSE),
261 m_unread(NULL), m_unrd_size(0),
262 m_processing(FALSE),
263 m_timeout(3600), m_wantbuf(0)
264 {
265 m_internal = new wxSockInternal;
266 #if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__)
267 m_internal->sock_inputid = 0;
268 m_internal->sock_outputid = 0;
269 m_internal->sock_exceptid = 0;
270 #endif
271 #ifdef __WINDOWS__
272 m_internal->my_msg = 0;
273 #endif
274 }
275
276 wxSocketBase::wxSocketBase() :
277 wxEvtHandler(),
278 m_flags(WAITALL), m_type(SOCK_UNINIT), m_connected(FALSE),
279 m_connecting(FALSE), m_fd(INVALID_SOCKET), m_waitflags(0),
280 m_cbk(0), m_cdata(0),
281 m_id(-1), m_handler(0),
282 m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)),
283 m_cbkon(FALSE),
284 m_unread(NULL), m_unrd_size(0),
285 m_processing(FALSE),
286 m_timeout(3600), m_wantbuf(0)
287 {
288 m_internal = new wxSockInternal;
289 #if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__)
290 m_internal->sock_inputid = 0;
291 m_internal->sock_outputid = 0;
292 m_internal->sock_exceptid = 0;
293 #endif
294 #ifdef __WINDOWS__
295 m_internal->my_msg = 0;
296 #endif
297 }
298
299 // --------------------------------------------------------------
300 // wxSocketBase
301 // --------------------------------------------------------------
302
303 wxSocketBase::~wxSocketBase()
304 {
305 DestroyCallbacks();
306 Close();
307
308 if (m_unread)
309 free(m_unread);
310 if (m_handler)
311 {
312 #ifdef __WINDOWS__
313 if (m_internal->my_msg)
314 m_handler->DestroyMessage(m_internal->my_msg);
315 #endif
316 m_handler->UnRegister(this);
317 }
318 m_states.DeleteContents(TRUE);
319
320 delete m_internal;
321 }
322
323 bool wxSocketBase::Close()
324 {
325 if (m_fd != INVALID_SOCKET)
326 {
327 for (int i=0;i<3;i++)
328 {
329 wxNode *n, *node = req_list[i].First();
330
331 while (node)
332 {
333 SockRequest *req = (SockRequest *)node->Data();
334 req->done = TRUE;
335
336 n = node->Next();
337 delete node;
338 node = n;
339 }
340 }
341
342 DestroyCallbacks();
343 shutdown(m_fd, 2);
344 close(m_fd);
345 m_fd = INVALID_SOCKET;
346 m_connected = FALSE;
347 }
348
349 return TRUE;
350 }
351
352 // --------------------------------------------------------------
353 // wxSocketBase base IO function
354 // --------------------------------------------------------------
355
356 wxSocketBase& wxSocketBase::Read(char* buffer, size_t nbytes)
357 {
358 size_t count;
359
360 count = GetPushback(buffer, nbytes, FALSE);
361 nbytes -= count;
362 buffer += count;
363
364 // If we have got the whole needed buffer or if we don't want to
365 // wait then it returns immediately.
366 if (!nbytes || (m_lcount && !(m_flags & WAITALL)) )
367 return *this;
368
369 m_lcount = 0;
370 WantBuffer(buffer, nbytes, EVT_READ);
371 m_lcount += count;
372
373 return *this;
374 }
375
376 wxSocketBase& wxSocketBase::Peek(char* buffer, size_t nbytes)
377 {
378 size_t count;
379
380 count = GetPushback(buffer, nbytes, TRUE);
381 if (nbytes-count == 0)
382 {
383 m_lcount = nbytes;
384 return *this;
385 }
386 buffer += count;
387 nbytes -= count;
388
389 m_lcount = 0;
390 WantBuffer(buffer, nbytes, EVT_PEEK);
391 m_lcount += count;
392
393 return *this;
394 }
395
396 wxSocketBase& wxSocketBase::Write(const char *buffer, size_t nbytes)
397 {
398 WantBuffer((char *)buffer, nbytes, EVT_WRITE);
399 return *this;
400 }
401
402 wxSocketBase& wxSocketBase::ReadMsg(char* buffer, size_t nbytes)
403 {
404 SockMsg msg;
405 size_t len, len2, sig;
406
407 Read((char *)&msg, sizeof(msg));
408 if (m_lcount != sizeof(msg))
409 return *this;
410
411 sig = msg.sig[0] & 0xff;
412 sig |= (size_t)(msg.sig[1] & 0xff) << 8;
413 sig |= (size_t)(msg.sig[2] & 0xff) << 16;
414 sig |= (size_t)(msg.sig[3] & 0xff) << 24;
415
416 if (sig != 0xfeeddead)
417 return *this;
418 len = msg.len[0] & 0xff;
419 len |= (size_t)(msg.len[1] & 0xff) << 8;
420 len |= (size_t)(msg.len[2] & 0xff) << 16;
421 len |= (size_t)(msg.len[3] & 0xff) << 24;
422 len2 = len;
423 if (len > nbytes)
424 len = nbytes;
425 else
426 len2 = 0;
427
428 if (Read(buffer, len).LastCount() != len)
429 return *this;
430 if (len2 && (Read(NULL, len2).LastCount() != len2))
431 return *this;
432 if (Read((char *)&msg, sizeof(msg)).LastCount() != sizeof(msg))
433 return *this;
434
435 sig = msg.sig[0] & 0xff;
436 sig |= (size_t)(msg.sig[1] & 0xff) << 8;
437 sig |= (size_t)(msg.sig[2] & 0xff) << 16;
438 sig |= (size_t)(msg.sig[3] & 0xff) << 24;
439 // ERROR
440 if (sig != 0xdeadfeed)
441 return *this;
442
443 return *this;
444 }
445
446 wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes)
447 {
448 SockMsg msg;
449
450 // warning about 'cast truncates constant value'
451 #ifdef __VISUALC__
452 #pragma warning(disable: 4310)
453 #endif // __VISUALC__
454
455 msg.sig[0] = (char) 0xad;
456 msg.sig[1] = (char) 0xde;
457 msg.sig[2] = (char) 0xed;
458 msg.sig[3] = (char) 0xfe;
459
460 msg.len[0] = (char) nbytes & 0xff;
461 msg.len[1] = (char) (nbytes >> 8) & 0xff;
462 msg.len[2] = (char) (nbytes >> 16) & 0xff;
463 msg.len[3] = (char) (nbytes >> 24) & 0xff;
464
465 if (Write((char *)&msg, sizeof(msg)).LastCount() < sizeof(msg))
466 return *this;
467 if (Write(buffer, nbytes).LastCount() < nbytes)
468 return *this;
469
470 msg.sig[0] = (char) 0xed;
471 msg.sig[1] = (char) 0xfe;
472 msg.sig[2] = (char) 0xad;
473 msg.sig[3] = (char) 0xde;
474 msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
475 Write((char *)&msg, sizeof(msg));
476
477 return *this;
478
479 #ifdef __VISUALC__
480 #pragma warning(default: 4310)
481 #endif // __VISUALC__
482 }
483
484 wxSocketBase& wxSocketBase::Unread(const char *buffer, size_t nbytes)
485 {
486 CreatePushbackAfter(buffer, nbytes);
487 return *this;
488 }
489
490 bool wxSocketBase::IsData() const
491 {
492 struct timeval tv;
493 fd_set sock_set;
494
495 if (m_fd < 0)
496 return FALSE;
497 if (m_unrd_size > 0)
498 return TRUE;
499
500 tv.tv_sec = 0;
501 tv.tv_usec = 0;
502 FD_ZERO(&sock_set);
503 FD_SET(m_fd, &sock_set);
504 select(FD_SETSIZE, &sock_set, NULL, NULL, &tv);
505 return (FD_ISSET(m_fd, &sock_set) != 0);
506 }
507
508 // ---------------------------------------------------------------------
509 // --------- wxSocketBase Discard(): deletes all byte in the input queue
510 // ---------------------------------------------------------------------
511 void wxSocketBase::Discard()
512 {
513 #define MAX_BUFSIZE (10*1024)
514 char *my_data = new char[MAX_BUFSIZE];
515 size_t recv_size = MAX_BUFSIZE;
516
517 SaveState();
518 SetFlags((wxSockFlags)(NOWAIT | SPEED));
519
520 while (recv_size == MAX_BUFSIZE)
521 {
522 recv_size = Read(my_data, MAX_BUFSIZE).LastCount();
523 }
524
525 RestoreState();
526 delete [] my_data;
527
528 #undef MAX_BUFSIZE
529 }
530
531 // If what? Who seems to need unsigned int?
532 // BTW uint isn't even defined on wxMSW for VC++ for some reason. Even if it
533 // were, getpeername/getsockname don't take unsigned int*, they take int*.
534 //
535 // Under glibc 2.0.7, socketbits.h declares socklen_t to be unsigned int
536 // and it uses *socklen_t as the 3rd parameter. Robert.
537
538 // JACS - How can we detect this?
539 // Meanwhile, if your compiler complains about socklen_t,
540 // switch lines below.
541
542 #if wxHAVE_GLIBC2
543 # define wxSOCKET_INT socklen_t
544 #else
545 # define wxSOCKET_INT int
546 #endif
547
548 // --------------------------------------------------------------
549 // wxSocketBase socket info functions
550 // --------------------------------------------------------------
551
552 bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
553 {
554 struct sockaddr my_addr;
555 wxSOCKET_INT len_addr = sizeof(my_addr);
556
557 if (m_fd < 0)
558 return FALSE;
559
560 if (getpeername(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0)
561 return FALSE;
562
563 addr_man.Disassemble(&my_addr, len_addr);
564 return TRUE;
565 }
566
567 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
568 {
569 struct sockaddr my_addr;
570 wxSOCKET_INT len_addr = sizeof(my_addr);
571
572 if (m_fd < 0)
573 return FALSE;
574
575 if (getsockname(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0)
576
577 return FALSE;
578
579 addr_man.Disassemble(&my_addr, len_addr);
580 return TRUE;
581 }
582
583 // --------------------------------------------------------------
584 // wxSocketBase wait functions
585 // --------------------------------------------------------------
586
587 void wxSocketBase::SaveState()
588 {
589 wxSockState *state = new wxSockState;
590
591 state->cbk_on = m_cbkon;
592 state->cbk_set= m_neededreq;
593 state->cbk = m_cbk;
594 state->cdata = m_cdata;
595 state->flags = m_flags;
596 state->notif = m_notifyme;
597
598 m_states.Append(state);
599 }
600
601 void wxSocketBase::RestoreState()
602 {
603 wxNode *node;
604
605 node = m_states.Last();
606 if (!node)
607 return;
608
609 wxSockState *state = (wxSockState *)node->Data();
610
611 SetFlags(state->flags);
612 m_neededreq = state->cbk_set;
613 m_cbk = state->cbk;
614 m_cdata = state->cdata;
615 m_notifyme = state->notif;
616 if (state->cbk_on)
617 SetupCallbacks();
618 else
619 DestroyCallbacks();
620
621 delete node;
622 delete state;
623 }
624
625 // --------------------------------------------------------------
626 // --------- wxSocketBase wait functions ------------------------
627 // --------------------------------------------------------------
628
629 bool wxSocketBase::_Wait(long seconds, long microseconds, int type)
630 {
631 if ((!m_connected && !m_connecting) || m_fd < 0)
632 return FALSE;
633
634 wxSockWakeUp wakeup(this, &m_waitflags, 0);
635
636 SaveState();
637 SetNotify((wxRequestNotify)type);
638 SetupCallbacks();
639
640 if (seconds != -1)
641 wakeup.Start((int)(seconds*1000 + (microseconds / 1000)), TRUE);
642
643 m_waitflags = 0x80 | type;
644 while (m_waitflags & 0x80)
645 PROCESS_EVENTS();
646
647 RestoreState();
648
649 if (m_waitflags & 0x40)
650 {
651 m_waitflags = 0;
652 return TRUE;
653 }
654 m_waitflags = 0;
655
656 return FALSE;
657 }
658
659 bool wxSocketBase::Wait(long seconds, long microseconds)
660 {
661 return _Wait(seconds, microseconds, REQ_ACCEPT | REQ_CONNECT |
662 REQ_READ | REQ_WRITE | REQ_LOST);
663 }
664
665 bool wxSocketBase::WaitForRead(long seconds, long microseconds)
666 {
667 return _Wait(seconds, microseconds, REQ_READ | REQ_LOST);
668 }
669
670 bool wxSocketBase::WaitForWrite(long seconds, long microseconds)
671 {
672 return _Wait(seconds, microseconds, REQ_WRITE);
673 }
674
675 bool wxSocketBase::WaitForLost(long seconds, long microseconds)
676 {
677 return _Wait(seconds, microseconds, REQ_LOST);
678 }
679
680 // --------------------------------------------------------------
681 // --------- wxSocketBase callback management -------------------
682 // --------------------------------------------------------------
683
684 #if defined(__WXMOTIF__) || defined(__WXXT__) || defined(__WXGTK__)
685 #if defined(__WXMOTIF__) || defined(__WXXT__)
686 static void wx_socket_read(XtPointer client, int *fid,
687 XtInputId *WXUNUSED(id))
688 #define fd *fid
689 #else
690 static void wx_socket_read(gpointer client, gint fd,
691 GdkInputCondition WXUNUSED(cond))
692 #define fd fd
693 #endif
694 {
695 wxSocketBase *sock = (wxSocketBase *)client;
696 char c;
697 int i;
698
699 i = recv(fd, &c, 1, MSG_PEEK);
700
701 if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT))
702 {
703 sock->OnRequest(wxSocketBase::EVT_ACCEPT);
704 return;
705 }
706
707 if (i != 0)
708 {
709 if (!(sock->NeededReq() & wxSocketBase::REQ_READ))
710 {
711 return;
712 }
713
714 sock->OnRequest(wxSocketBase::EVT_READ);
715 }
716 else
717 {
718 if (!(sock->NeededReq() & wxSocketBase::REQ_LOST))
719 {
720 sock->Close();
721 return;
722 }
723
724 sock->OnRequest(wxSocketBase::EVT_LOST);
725 }
726 }
727 #undef fd
728
729 #if defined(__WXMOTIF__) || defined(__WXXT__)
730 static void wx_socket_write(XtPointer client, int *WXUNUSED(fid),
731 XtInputId *WXUNUSED(id))
732 #else
733 static void wx_socket_write(gpointer client, gint WXUNUSED(fd),
734 GdkInputCondition WXUNUSED(cond))
735 #endif
736 {
737 wxSocketBase *sock = (wxSocketBase *)client;
738
739 if (!sock->IsConnected())
740 sock->OnRequest(wxSocketBase::EVT_CONNECT);
741 else
742 sock->OnRequest(wxSocketBase::EVT_WRITE);
743 }
744 #endif
745
746 #ifdef wx_xview
747 Notify_value wx_sock_read_xview (Notify_client client, int fd)
748 {
749 wxSocketBase *sock = (wxSocketBase *)client;
750 char c;
751 int i;
752
753 i = recv(fd, &c, 1, MSG_PEEK);
754
755 if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT))
756 {
757 sock->OnRequest(wxSocketBase::EVT_ACCEPT);
758 return;
759 }
760
761 /* Bytes arrived */
762 if (i != 0)
763 {
764 if (!(sock->NeededReq() & wxSocketBase::REQ_READ))
765 return (Notify_value) FALSE;
766
767 sock->OnRequest(wxSocketBase::EVT_READ);
768 }
769 else
770 {
771 if (!(sock->NeededReq() & wxSocketBase::REQ_LOST))
772 return;
773
774 sock->OnRequest(wxSocketBase::EVT_LOST);
775 }
776
777 return (Notify_value) FALSE;
778 }
779
780 Notify_value wx_sock_write_xview (Notify_client client, int fd)
781 {
782 wxSocketBase *sock = (wxSocketBase *)client;
783
784 if (!sock->IsConnected())
785 sock->OnRequest(wxSocketBase::EVT_CONNECT);
786 else
787 sock->OnRequest(wxSocketBase::EVT_WRITE);
788
789 return (Notify_value) TRUE;
790 }
791 #endif
792
793 wxSocketBase::wxRequestNotify wxSocketBase::EventToNotify(wxRequestEvent evt)
794 {
795 switch (evt)
796 {
797 case EVT_READ:
798 return REQ_READ;
799 case EVT_PEEK:
800 return REQ_PEEK;
801 case EVT_WRITE:
802 return REQ_WRITE;
803 case EVT_LOST:
804 return REQ_LOST;
805 case EVT_ACCEPT:
806 return REQ_ACCEPT;
807 case EVT_CONNECT:
808 return REQ_CONNECT;
809 }
810 return 0;
811 }
812
813 void wxSocketBase::SetFlags(wxSockFlags _flags)
814 {
815 m_flags = _flags;
816 if (_flags & SPEED)
817 {
818 unsigned long flag = 0;
819 ioctl(m_fd, FIONBIO, &flag);
820
821 // SPEED and WAITALL are antagonists.
822 m_flags = (wxSockFlags)(m_flags & ~WAITALL);
823
824 Notify(FALSE);
825 }
826 else
827 {
828 unsigned long flag = 1;
829 ioctl(m_fd, FIONBIO, &flag);
830 }
831 }
832
833 void wxSocketBase::SetNotify(wxRequestNotify flags)
834 {
835 wxRequestNotify old_needed_req = m_neededreq;
836 if (flags & REQ_ACCEPT)
837 {
838 /* Check if server */
839 if (!(GetClassInfo()->IsKindOf(CLASSINFO(wxSocketServer))))
840 flags &= ~REQ_ACCEPT;
841 }
842 m_neededreq = flags;
843
844 /*
845 if (m_cbkon && old_needed_req != flags) seems to be wrong, Robert Roebling
846 SetupCallbacks();
847 */
848
849 if (old_needed_req != flags)
850 SetupCallbacks();
851 }
852
853 void wxSocketBase::SetupCallbacks()
854 {
855 if (m_fd == INVALID_SOCKET || !m_handler || (m_flags & SPEED))
856 return;
857
858 #if defined(__WXMOTIF__) || defined(__WXXT__)
859 if (m_neededreq & (REQ_ACCEPT | REQ_READ | REQ_LOST))
860 {
861 if (m_internal->sock_inputid <= 0)
862 {
863 m_internal->sock_inputid = XtAppAddInput (wxAPP_CONTEXT, m_fd,
864 (XtPointer *) XtInputReadMask,
865 (XtInputCallbackProc) wx_socket_read,
866 (XtPointer) this);
867 }
868 }
869 else
870 {
871 if (m_internal->sock_inputid > 0)
872 {
873 XtRemoveInput(m_internal->sock_inputid);
874 m_internal->sock_inputid = 0;
875 }
876 }
877
878 if (m_neededreq & (REQ_CONNECT | REQ_WRITE))
879 {
880 if (m_internal->sock_outputid <= 0)
881 {
882 m_internal->sock_outputid = XtAppAddInput (wxAPP_CONTEXT, m_fd,
883 (XtPointer *) XtInputWriteMask,
884 (XtInputCallbackProc) wx_socket_write,
885 (XtPointer) this);
886 }
887 }
888 else
889 {
890 if (m_internal->sock_outputid > 0)
891 {
892 XtRemoveInput(m_internal->sock_outputid);
893 m_internal->sock_outputid = 0;
894 }
895 }
896 #endif
897
898
899 #ifdef __WXGTK__
900 if (m_neededreq & (REQ_ACCEPT | REQ_READ | REQ_LOST))
901 {
902 if (m_internal->sock_inputid <= 0)
903 {
904 m_internal->sock_inputid = gdk_input_add(m_fd, GDK_INPUT_READ,
905 wx_socket_read, (gpointer)this);
906 }
907 }
908 else
909 {
910 if (m_internal->sock_inputid > 0)
911 {
912 /*
913 gdk_input_remove(m_internal->sock_inputid);
914 m_internal->sock_inputid = 0;
915 */
916 }
917 }
918
919 if (m_neededreq & (REQ_CONNECT | REQ_WRITE))
920 {
921 if (m_internal->sock_outputid <= 0)
922 {
923 m_internal->sock_outputid = gdk_input_add(m_fd, GDK_INPUT_WRITE,
924 wx_socket_write, (gpointer)this);
925 }
926 }
927 else
928 {
929 if (m_internal->sock_outputid > 0)
930 {
931 /*
932 gdk_input_remove(m_internal->sock_outputid);
933 m_internal->sock_outputid = 0;
934 */
935 }
936 }
937 #endif
938
939
940 #ifdef __WXMSW__
941 WORD mask = 0;
942
943 if (m_neededreq & REQ_READ)
944 mask |= FD_READ;
945 if (m_neededreq & REQ_WRITE)
946 mask |= FD_WRITE;
947 if (m_neededreq & REQ_LOST)
948 mask |= FD_CLOSE;
949 if (m_neededreq & REQ_ACCEPT)
950 mask |= FD_ACCEPT;
951 if (m_neededreq & REQ_CONNECT)
952 mask |= FD_CONNECT;
953
954 if (!m_internal->my_msg)
955 m_internal->my_msg = m_handler->NewMessage(this);
956 WSAAsyncSelect(m_fd, m_handler->GetHWND(), m_internal->my_msg, mask);
957 #endif
958 #ifdef __WXMAC__
959 short mask = 0;
960
961 if (m_neededreq & REQ_READ)
962 mask |= FD_READ;
963 if (m_neededreq & REQ_WRITE)
964 mask |= FD_WRITE;
965 if (m_neededreq & REQ_LOST)
966 mask |= FD_CLOSE;
967 if (m_neededreq & REQ_ACCEPT)
968 mask |= FD_ACCEPT;
969 if (m_neededreq & REQ_CONNECT)
970 mask |= FD_CONNECT;
971
972 GUSISetReference( m_fd ,mask, this ) ;
973 unsigned long flag = 1;
974 ioctl(m_fd, FIONBIO, &flag);
975 #endif
976 m_cbkon = TRUE;
977 m_processing = FALSE;
978 }
979
980 void wxSocketBase::DestroyCallbacks()
981 {
982 if (!m_cbkon || !m_handler)
983 return;
984
985 m_cbkon = FALSE;
986 m_processing = FALSE;
987 #if defined(__WXMOTIF__) || defined(__WXXT__)
988 if (m_internal->sock_inputid > 0)
989 XtRemoveInput(m_internal->sock_inputid);
990 m_internal->sock_inputid = 0;
991 if (m_internal->sock_outputid > 0)
992 XtRemoveInput(m_internal->sock_outputid);
993 m_internal->sock_outputid = 0;
994 #endif
995 #ifdef __WXGTK__
996 if (m_internal->sock_inputid > 0)
997 gdk_input_remove(m_internal->sock_inputid);
998 m_internal->sock_inputid = 0;
999 if (m_internal->sock_outputid > 0)
1000 gdk_input_remove(m_internal->sock_outputid);
1001 m_internal->sock_outputid = 0;
1002 #endif
1003 #ifdef __WINDOWS__
1004 WSAAsyncSelect(m_fd, m_handler->GetHWND(), 0, 0);
1005 #endif
1006 #ifdef __WXMAC__
1007 GUSISetReference( m_fd , 0 , 0 ) ;
1008 int bottom = wxMacNetEventsBottom ;
1009 while ( wxMacNetEventsTop != bottom )
1010 {
1011 // set all events that reference this socket to nil
1012 if ( wxMacNetEventsReferences[bottom] == (void*) this )
1013 wxMacNetEventsReferences[bottom] = NULL ;
1014 bottom++ ;
1015 if ( bottom == kwxMacNetEventsMax )
1016 bottom = 0 ;
1017 }
1018 SetFlags( m_flags ) ;
1019 #endif
1020 }
1021
1022 void wxSocketBase::Notify(bool notify)
1023 {
1024 if (m_notifyme == notify)
1025 return;
1026 if (notify)
1027 SetupCallbacks();
1028 else
1029 DestroyCallbacks();
1030 m_notifyme = notify;
1031 }
1032
1033 void wxSocketBase::OnRequest(wxRequestEvent req_evt)
1034 {
1035 wxRequestNotify req_notif = EventToNotify(req_evt);
1036
1037 // Mask the current event
1038 SetNotify(m_neededreq & ~req_notif);
1039
1040 if (req_evt <= EVT_WRITE && DoRequests(req_evt))
1041 return;
1042
1043 if (m_waitflags & 0xF0)
1044 {
1045 // Wake up
1046 if ((m_waitflags & 0x0F) == req_evt)
1047 {
1048 m_waitflags = 0x80;
1049 #ifndef __WXGTK__
1050 DestroyCallbacks();
1051 #endif
1052 }
1053 return;
1054 }
1055
1056 if (req_evt == EVT_LOST)
1057 {
1058 m_connected = FALSE;
1059 Close();
1060 }
1061 if (m_notifyme)
1062 OldOnNotify(req_evt);
1063
1064 // Unmask
1065 SetNotify(m_neededreq | req_notif);
1066 }
1067
1068 wxSocketEvent::wxSocketEvent(int id)
1069 : wxEvent(id)
1070 {
1071 wxEventType type = (wxEventType)wxEVT_SOCKET;
1072
1073 SetEventType(type);
1074 }
1075
1076 void wxSocketBase::OldOnNotify(wxRequestEvent evt)
1077 {
1078 wxSocketEvent event(m_id);
1079
1080 event.SetEventObject(this);
1081 event.m_skevt = evt;
1082 ProcessEvent(event);
1083
1084 if (m_cbk)
1085 m_cbk(*this, evt, m_cdata);
1086 }
1087
1088 // --------------------------------------------------------------
1089 // --------- wxSocketBase functions [Callback, CallbackData] ----
1090 // --------------------------------------------------------------
1091
1092 wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSocketBase::wxSockCbk _cbk)
1093 {
1094 wxSockCbk old_cbk = m_cbk;
1095
1096 m_cbk = _cbk;
1097 return old_cbk;
1098 }
1099
1100 char *wxSocketBase::CallbackData(char *cdata_)
1101 {
1102 char *old_cdata = m_cdata;
1103
1104 m_cdata = cdata_;
1105 return old_cdata;
1106 }
1107
1108 void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id)
1109 {
1110 SetNextHandler(&h_evt);
1111 m_id = id;
1112 }
1113
1114 // --------------------------------------------------------------
1115 // --------- wxSocketBase pushback library ----------------------
1116 // --------------------------------------------------------------
1117
1118 void wxSocketBase::CreatePushbackAfter(const char *buffer, size_t size)
1119 {
1120 char *curr_pos;
1121
1122 m_unread = (char *) realloc(m_unread, m_unrd_size+size);
1123 curr_pos = m_unread + m_unrd_size;
1124
1125 memcpy(curr_pos, buffer, size);
1126 m_unrd_size += size;
1127 }
1128
1129 void wxSocketBase::CreatePushbackBefore(const char *buffer, size_t size)
1130 {
1131 char *curr_pos, *new_buf;
1132
1133 new_buf = (char *) malloc(m_unrd_size+size);
1134 curr_pos = new_buf + size;
1135
1136 memcpy(new_buf, buffer, size);
1137 if (m_unrd_size != 0) {
1138 memcpy(curr_pos, m_unread, m_unrd_size);
1139 free(m_unread);
1140 }
1141 m_unread = new_buf;
1142 m_unrd_size += size;
1143 }
1144
1145 size_t wxSocketBase::GetPushback(char *buffer, size_t size, bool peek)
1146 {
1147 if (!m_unrd_size)
1148 return 0;
1149
1150 if (size > m_unrd_size)
1151 size = m_unrd_size;
1152 memcpy(buffer, m_unread, size);
1153
1154 if (!peek) {
1155 m_unrd_size -= size;
1156 if (m_unrd_size == 0) {
1157 free(m_unread);
1158 m_unread = NULL;
1159 }
1160 }
1161
1162 return size;
1163 }
1164
1165 // --------------------------------------------------------------
1166 // --------- wxSocketBase "multi-thread" core -------------------
1167 // --------------------------------------------------------------
1168
1169 bool wxSocketBase::DoRequests(wxRequestEvent req_flag)
1170 {
1171 wxNode *node = req_list[req_flag].First();
1172 size_t len;
1173 int ret;
1174
1175 if (!node)
1176 return FALSE;
1177
1178 SockRequest *req = (SockRequest *)node->Data();
1179
1180 delete node;
1181
1182 switch (req->type)
1183 {
1184 case EVT_READ:
1185 case EVT_PEEK:
1186 ret = recv(m_fd, req->buffer, req->size,
1187 (req->type == EVT_PEEK) ? MSG_PEEK : 0);
1188 if (ret < 0)
1189 {
1190 req->error = errno;
1191 req->done = TRUE;
1192 break;
1193 }
1194 len = ret;
1195 if ((len < req->size) && (m_flags & WAITALL))
1196 {
1197 req->size -= len;
1198 req->nbytes += len;
1199 req->buffer += len;
1200 req->auto_wakeup->Start(m_timeout*1000, TRUE);
1201 req_list[req_flag].Insert(req);
1202 break;
1203 }
1204 req->done = TRUE;
1205 req->nbytes += len;
1206 #ifndef __WXGTK__
1207 DestroyCallbacks();
1208 #endif
1209 break;
1210 case EVT_WRITE:
1211 ret = send(m_fd, req->buffer, req->size, 0);
1212 if (ret < 0)
1213 {
1214 req->error = errno;
1215 req->done = TRUE;
1216 break;
1217 }
1218 len = ret;
1219 if ((len < req->size) && (m_flags & WAITALL))
1220 {
1221 req->size -= len;
1222 req->nbytes += len;
1223 req->buffer += len;
1224 req->auto_wakeup->Start(m_timeout*1000, TRUE);
1225 req_list[req_flag].Insert(req);
1226 break;
1227 }
1228 req->done = TRUE;
1229 req->nbytes += len;
1230 #ifndef __WXGTK__
1231 DestroyCallbacks();
1232 #endif
1233 break;
1234 default:
1235 return FALSE;
1236 }
1237 return TRUE;
1238 }
1239
1240 void wxSocketBase::WantSpeedBuffer(char *buffer, size_t nbytes,
1241 wxRequestEvent evt)
1242 {
1243 int ret = 0;
1244
1245 switch (evt)
1246 {
1247 case EVT_PEEK:
1248 case EVT_READ:
1249 ret = recv(m_fd, buffer, nbytes,
1250 (evt == EVT_PEEK) ? MSG_PEEK : 0);
1251 break;
1252 case EVT_WRITE:
1253 ret = send(m_fd, buffer, nbytes, 0);
1254 break;
1255 }
1256 if (ret < 0)
1257 {
1258 m_lcount = 0;
1259 m_error = errno;
1260 }
1261 else
1262 {
1263 m_lcount = ret;
1264 m_error = 0;
1265 }
1266 }
1267
1268 void wxSocketBase::WantBuffer(char *buffer, size_t nbytes,
1269 wxRequestEvent evt)
1270 {
1271 bool buf_timed_out;
1272
1273 if (m_fd == INVALID_SOCKET || !m_handler || !m_connected)
1274 return;
1275
1276 if (m_flags & SPEED)
1277 {
1278 WantSpeedBuffer(buffer, nbytes, evt);
1279 return;
1280 }
1281
1282 SockRequest *buf = new SockRequest;
1283 wxSockWakeUp s_wake(NULL, (int *)&buf_timed_out, (int)TRUE);
1284
1285 m_wantbuf++;
1286 req_list[evt].Append(buf);
1287
1288 SaveState();
1289 SetNotify(REQ_LOST | EventToNotify(evt));
1290 SetupCallbacks();
1291 buf->buffer = buffer;
1292 buf->size = nbytes;
1293 buf->done = FALSE;
1294 buf->type = evt;
1295 buf->nbytes = 0;
1296 buf->auto_wakeup = &s_wake;
1297 buf->error = 0;
1298 buf_timed_out = FALSE;
1299
1300 s_wake.Start(m_timeout*1000, TRUE);
1301 if (m_flags & NOWAIT)
1302 {
1303 DoRequests(evt);
1304 }
1305 else
1306 {
1307 while (!buf->done && !buf_timed_out)
1308 PROCESS_EVENTS();
1309 }
1310 m_wantbuf--;
1311 m_lcount = buf->nbytes;
1312 if (buf_timed_out)
1313 m_error = ETIMEDOUT;
1314 else
1315 m_error = buf->error;
1316
1317 delete buf;
1318 RestoreState();
1319 }
1320
1321 // --------------------------------------------------------------
1322 // wxSocketServer
1323 // --------------------------------------------------------------
1324
1325 wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
1326 wxSockFlags flags) :
1327 wxSocketBase(flags, SOCK_SERVER)
1328 {
1329 m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
1330
1331 if (m_fd == INVALID_SOCKET)
1332 return;
1333
1334 int flag = 1;
1335 setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&flag, sizeof(int));
1336
1337 struct sockaddr *myaddr;
1338 size_t len;
1339
1340 addr_man.Build(myaddr, len);
1341 if (bind(m_fd, myaddr, addr_man.SockAddrLen()) < 0)
1342 return;
1343
1344 if (listen(m_fd, 5) < 0) {
1345 m_fd = INVALID_SOCKET;
1346 return;
1347 }
1348 }
1349
1350 // --------------------------------------------------------------
1351 // wxSocketServer Accept
1352 // --------------------------------------------------------------
1353
1354 bool wxSocketServer::AcceptWith(wxSocketBase& sock)
1355 {
1356 int fd2;
1357
1358 if ((fd2 = accept(m_fd, 0, 0)) < 0)
1359 return FALSE;
1360
1361 struct linger linger;
1362 linger.l_onoff = 0;
1363 linger.l_linger = 1;
1364
1365 setsockopt(fd2, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
1366
1367 int flag = 0;
1368 setsockopt(fd2, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
1369
1370 if (!(sock.m_flags & SPEED))
1371 {
1372 unsigned long flag2 = 1;
1373 ioctl(fd2, FIONBIO, &flag2);
1374 }
1375
1376 sock.m_type = SOCK_INTERNAL;
1377 sock.m_fd = fd2;
1378 sock.m_connected = TRUE;
1379
1380 return TRUE;
1381 }
1382
1383 wxSocketBase *wxSocketServer::Accept()
1384 {
1385 wxSocketBase* sock = new wxSocketBase();
1386
1387 sock->SetFlags((wxSockFlags)m_flags);
1388
1389 if (!AcceptWith(*sock))
1390 return NULL;
1391
1392 if (m_handler)
1393 m_handler->Register(sock);
1394
1395 return sock;
1396 }
1397
1398 // --------------------------------------------------------------
1399 // wxSocketServer callbacks
1400 // --------------------------------------------------------------
1401
1402 void wxSocketServer::OnRequest(wxRequestEvent evt)
1403 {
1404 if (evt == EVT_ACCEPT)
1405 {
1406 OldOnNotify(EVT_ACCEPT);
1407 }
1408 }
1409
1410 // --------------------------------------------------------------
1411 // wxSocketClient
1412 // --------------------------------------------------------------
1413
1414 // --------- wxSocketClient CONSTRUCTOR -------------------------
1415 // --------------------------------------------------------------
1416 wxSocketClient::wxSocketClient(wxSockFlags _flags) :
1417 wxSocketBase(_flags, SOCK_CLIENT)
1418 {
1419 }
1420
1421 // --------------------------------------------------------------
1422 // --------- wxSocketClient DESTRUCTOR --------------------------
1423 // --------------------------------------------------------------
1424 wxSocketClient::~wxSocketClient()
1425 {
1426 }
1427
1428 // --------------------------------------------------------------
1429 // --------- wxSocketClient Connect functions -------------------
1430 // --------------------------------------------------------------
1431 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) )
1432 {
1433 struct linger linger;
1434
1435 if (IsConnected())
1436 Close();
1437
1438 m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
1439
1440 if (m_fd < 0)
1441 return FALSE;
1442
1443 m_connected = FALSE;
1444
1445 linger.l_onoff = 1;
1446 linger.l_linger = 5;
1447 setsockopt(m_fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
1448
1449 // Stay in touch with the state of things...
1450
1451 unsigned long flag = 1;
1452 setsockopt(m_fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
1453
1454 // Disable the nagle algorithm, which delays sends till the
1455 // buffer is full (or a certain time period has passed?)...
1456
1457 #if defined(__WINDOWS__) || (defined(IPPROTO_TCP) && defined(TCP_NODELAY))
1458 flag = 1;
1459 setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int));
1460 #endif
1461
1462 struct sockaddr *remote;
1463 size_t len;
1464
1465 addr_man.Build(remote, len);
1466
1467 if (connect(m_fd, remote, len) != 0)
1468 return FALSE;
1469
1470 if (!(m_flags & SPEED))
1471 {
1472 flag = 1;
1473 ioctl(m_fd, FIONBIO, &flag);
1474 }
1475
1476 Notify(TRUE);
1477
1478 m_connected = TRUE;
1479 return TRUE;
1480 }
1481
1482 bool wxSocketClient::WaitOnConnect(long seconds, long microseconds)
1483 {
1484 int ret = _Wait(seconds, microseconds, REQ_CONNECT | REQ_LOST);
1485
1486 if (ret)
1487 m_connected = TRUE;
1488
1489 return m_connected;
1490 }
1491
1492 void wxSocketClient::OnRequest(wxRequestEvent evt)
1493 {
1494 if (evt == EVT_CONNECT)
1495 {
1496 if (m_connected)
1497 {
1498 #ifndef __WXGTK__
1499 SetNotify(m_neededreq & ~REQ_CONNECT);
1500 #endif
1501 return;
1502 }
1503 m_waitflags = 0x40;
1504 m_connected = TRUE;
1505 OldOnNotify(EVT_CONNECT);
1506 #ifndef __WXGTK__
1507 DestroyCallbacks();
1508 #endif
1509 return;
1510 }
1511 wxSocketBase::OnRequest(evt);
1512 }
1513
1514 /////////////////////////////////////////////////////////////////
1515 // wxSocketHandler ///////////////////////////////////////////////
1516 /////////////////////////////////////////////////////////////////
1517
1518 wxSocketHandler *wxSocketHandler::master = NULL;
1519 #if defined(__WINDOWS__)
1520 static int win_initialized = 0;
1521 #endif
1522
1523 // --------------------------------------------------------------
1524 // --------- wxSocketHandler CONSTRUCTOR ------------------------
1525 // --------------------------------------------------------------
1526 #ifdef __WXMAC__
1527
1528 extern "C" int updatestatus(int s) ;
1529
1530 void wxMacSocketOnRequestProc( void *refcon , short event )
1531 {
1532 if ( refcon )
1533 {
1534 wxSocketBase *sock = (wxSocketBase *) refcon ;
1535
1536 wxSocketBase::wxRequestEvent sk_req;
1537
1538 int canRead ;
1539 int canWrite ;
1540 int exception ;
1541
1542 switch (event) {
1543 case FD_READ:
1544 sk_req = wxSocketBase::EVT_READ;
1545 sock->OnRequest(sk_req);
1546 break;
1547 case FD_WRITE:
1548 sk_req = wxSocketBase::EVT_WRITE;
1549 sock->OnRequest(sk_req);
1550 break;
1551 case FD_CLOSE:
1552 sk_req = wxSocketBase::EVT_LOST;
1553 sock->OnRequest(sk_req);
1554 break;
1555 case FD_ACCEPT:
1556 sk_req = wxSocketBase::EVT_ACCEPT;
1557 sock->OnRequest(sk_req);
1558 break;
1559 case FD_CONNECT:
1560 sk_req = wxSocketBase::EVT_CONNECT;
1561 sock->OnRequest(sk_req);
1562 break;
1563 case FD_READY :
1564 break ;
1565 }
1566 updatestatus ( sock->m_fd ) ;
1567 }
1568 }
1569
1570 void wxMacSocketHandlerProc( void *refcon , short event )
1571 {
1572 wxMacNetEventsReferences[wxMacNetEventsTop] = refcon ;
1573 wxMacNetEventsEvents[wxMacNetEventsTop] = event ;
1574
1575 // clumsy construct in order to never have a incorrect wxMacNetEventsTop (above limits)
1576
1577 if ( wxMacNetEventsTop + 1 == kwxMacNetEventsMax )
1578 wxMacNetEventsTop = 0 ;
1579 else
1580 wxMacNetEventsTop++ ;
1581 }
1582
1583 #endif
1584 #ifdef __WINDOWS__
1585
1586 extern char wxPanelClassName[];
1587
1588 LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd, UINT message,
1589 WPARAM wParam, LPARAM lParam)
1590 {
1591 if(message==WM_DESTROY)
1592 {
1593 ::SetWindowLong(hWnd, GWL_WNDPROC, (LONG) DefWindowProc);
1594 return DefWindowProc(hWnd, message, wParam, lParam);
1595 }
1596 wxSocketHandler *h_sock = (wxSocketHandler *)GetWindowLong(hWnd, GWL_USERDATA);
1597 wxNode *node = h_sock->smsg_list->Find(message);
1598 wxSocketBase *sock;
1599 wxSocketBase::wxRequestEvent sk_req;
1600 UINT event = WSAGETSELECTEVENT(lParam);
1601
1602 if (!node)
1603 return DefWindowProc(hWnd, message, wParam, lParam);
1604
1605 sock = (wxSocketBase *)node->Data();
1606
1607 switch (event) {
1608 case FD_READ:
1609 sk_req = wxSocketBase::EVT_READ;
1610 break;
1611 case FD_WRITE:
1612 sk_req = wxSocketBase::EVT_WRITE;
1613 break;
1614 case FD_CLOSE:
1615 sk_req = wxSocketBase::EVT_LOST;
1616 break;
1617 case FD_ACCEPT:
1618 sk_req = wxSocketBase::EVT_ACCEPT;
1619 break;
1620 case FD_CONNECT:
1621 sk_req = wxSocketBase::EVT_CONNECT;
1622 break;
1623
1624 default:
1625 wxFAIL_MSG("invalid socket event");
1626 return (LRESULT)0;
1627 }
1628
1629 sock->OnRequest(sk_req);
1630
1631 return (LRESULT)0;
1632 }
1633
1634 FARPROC wxSocketSubClassProc = NULL;
1635
1636 #endif
1637
1638 wxSocketHandler::wxSocketHandler()
1639 {
1640 #if defined(__WINDOWS__)
1641 if (!win_initialized)
1642 {
1643 WSADATA wsaData;
1644
1645 WSAStartup((1 << 8) | 1, &wsaData);
1646 win_initialized = 1;
1647 }
1648 internal = new wxSockHandlerInternal;
1649 internal->sockWin = ::CreateWindow(wxPanelClassName, NULL, 0,
1650 0, 0, 0, 0, NULL, (HMENU) NULL,
1651 wxhInstance, 0);
1652
1653 // Subclass the window
1654 if (!wxSocketSubClassProc)
1655 wxSocketSubClassProc = MakeProcInstance((FARPROC) wxSocketHandlerWndProc, wxhInstance);
1656 ::SetWindowLong(internal->sockWin, GWL_WNDPROC, (LONG) wxSocketSubClassProc);
1657 ::SetWindowLong(internal->sockWin, GWL_USERDATA, (LONG) this);
1658
1659 internal->firstAvailableMsg = 5000;
1660 smsg_list = new wxList(wxKEY_INTEGER);
1661 #endif
1662
1663 socks = new wxList;
1664
1665 #ifndef __WINDOWS__
1666 signal(SIGPIPE, SIG_IGN);
1667 #endif
1668 }
1669
1670 // --------------------------------------------------------------
1671 // --------- wxSocketHandler DESTRUCTOR -------------------------
1672 // --------------------------------------------------------------
1673 wxSocketHandler::~wxSocketHandler()
1674 {
1675 wxNode *next_node, *node = socks->First();
1676
1677 while (node)
1678 {
1679 wxSocketBase* sock = (wxSocketBase*)node->Data();
1680
1681 delete sock;
1682 next_node = node->Next();
1683 delete node;
1684 node = next_node;
1685 }
1686
1687 delete socks;
1688
1689 #ifdef __WINDOWS__
1690 delete smsg_list;
1691
1692 ::DestroyWindow(internal->sockWin);
1693 WSACleanup();
1694 win_initialized = 0;
1695
1696 delete internal;
1697 #endif
1698 }
1699
1700 // --------------------------------------------------------------
1701 // --------- wxSocketHandler registering functions --------------
1702 // --------------------------------------------------------------
1703
1704 void wxSocketHandler::Register(wxSocketBase* sock)
1705 {
1706 wxNode *node;
1707
1708 for (node = socks->First(); node != NULL; node = node->Next())
1709 {
1710 wxSocketBase* s = (wxSocketBase*)node->Data();
1711
1712 if (s == sock)
1713 return;
1714 }
1715
1716 if (sock)
1717 {
1718 socks->Append(sock);
1719 sock->SetHandler(this);
1720 sock->SetupCallbacks();
1721 }
1722 }
1723
1724 void wxSocketHandler::UnRegister(wxSocketBase* sock)
1725 {
1726 wxNode *node;
1727
1728 for (node = socks->First(); node; node = node->Next())
1729 {
1730 wxSocketBase* s = (wxSocketBase*)node->Data();
1731
1732 if (s == sock)
1733 {
1734 delete node;
1735 sock->DestroyCallbacks();
1736 sock->SetHandler(NULL);
1737 return;
1738 }
1739 }
1740 }
1741
1742 unsigned long wxSocketHandler::Count() const
1743 {
1744 return socks->Number();
1745 }
1746
1747 // --------------------------------------------------------------
1748 // --------- wxSocketHandler "big" wait functions ---------------
1749 // --------------------------------------------------------------
1750 void handler_cbk(wxSocketBase& sock,
1751 wxSocketBase::wxRequestEvent WXUNUSED(flags),
1752 char *cdata)
1753 {
1754 int *a_wait = (int *)cdata;
1755
1756 (*a_wait)++;
1757 sock.Notify(FALSE);
1758 }
1759
1760 int wxSocketHandler::Wait(long seconds, long microseconds)
1761 {
1762 int i;
1763 int on_wait;
1764 wxSockWakeUp s_wake(NULL, &on_wait, -2);
1765 wxNode *node;
1766
1767 for (node = socks->First(), i=0; node; node = node->Next(), i++)
1768 {
1769 wxSocketBase *sock = (wxSocketBase *)node->Data();
1770
1771 sock->SaveState();
1772
1773 sock->SetupCallbacks();
1774
1775 sock->Callback(handler_cbk);
1776 sock->CallbackData((char *)&on_wait);
1777 }
1778 on_wait = 0;
1779 if (seconds != -1)
1780 s_wake.Start((seconds*1000) + (microseconds/1000), TRUE);
1781
1782 while (!on_wait)
1783 PROCESS_EVENTS();
1784
1785 for (node = socks->First(), i=0; node; node = node->Next(), i++)
1786 {
1787 wxSocketBase *sock = (wxSocketBase *)node->Data();
1788
1789 sock->RestoreState();
1790 }
1791
1792 if (on_wait == -2)
1793 return 0;
1794
1795 return on_wait;
1796 }
1797
1798 void wxSocketHandler::YieldSock()
1799 {
1800 wxNode *node;
1801
1802 for (node = socks->First(); node; node = node->Next() )
1803 {
1804 wxSocketBase *sock = (wxSocketBase *)node->Data();
1805
1806 sock->SaveState();
1807
1808 sock->SetFlags(wxSocketBase::SPEED);
1809 if (sock->IsData())
1810 sock->DoRequests(wxSocketBase::EVT_READ);
1811 sock->DoRequests(wxSocketBase::EVT_WRITE);
1812
1813 sock->RestoreState();
1814 }
1815 }
1816
1817 // --------------------------------------------------------------
1818 // --------- wxSocketHandler: create and register the socket ----
1819 // --------------------------------------------------------------
1820 wxSocketServer *wxSocketHandler::CreateServer(wxSockAddress& addr,
1821 wxSocketBase::wxSockFlags flags)
1822 {
1823 wxSocketServer *serv = new wxSocketServer(addr, flags);
1824
1825 Register(serv);
1826 return serv;
1827 }
1828
1829 wxSocketClient *wxSocketHandler::CreateClient(wxSocketBase::wxSockFlags flags)
1830 {
1831 wxSocketClient *client = new wxSocketClient(flags);
1832
1833 Register(client);
1834 return client;
1835 }
1836
1837 #ifdef __WINDOWS__
1838 // --------------------------------------------------------------
1839 // --------- wxSocketHandler: Windows specific methods ----------
1840 // --------------------------------------------------------------
1841
1842 UINT wxSocketHandler::NewMessage(wxSocketBase *sock)
1843 {
1844 internal->firstAvailableMsg++;
1845 smsg_list->Append(internal->firstAvailableMsg, sock);
1846 return internal->firstAvailableMsg;
1847 }
1848
1849 void wxSocketHandler::DestroyMessage(UINT msg)
1850 {
1851 wxNode *node = smsg_list->Find(msg);
1852 delete node;
1853 }
1854
1855 HWND wxSocketHandler::GetHWND() const
1856 {
1857 return internal->sockWin;
1858 }
1859
1860 #endif
1861
1862 bool wxSocketModule::OnInit()
1863 {
1864 wxSocketHandler::master = new wxSocketHandler();
1865 return TRUE;
1866 }
1867
1868 void wxSocketModule::OnExit()
1869 {
1870 delete wxSocketHandler::master;
1871 wxSocketHandler::master = NULL;
1872 }
1873
1874 #ifdef __WXMAC__
1875 void wxMacProcessSocketEvents() ;
1876 void wxMacProcessEvents()
1877 {
1878 wxMacProcessSocketEvents() ;
1879 (*GUSISpin)(SP_MISC, 0) ;
1880 }
1881
1882 void wxMacProcessSocketEvents()
1883 {
1884 while ( wxMacNetEventsTop != wxMacNetEventsBottom )
1885 {
1886 // consume event at wxMacNetEventsBottom
1887 wxMacSocketOnRequestProc(wxMacNetEventsReferences[wxMacNetEventsBottom] , wxMacNetEventsEvents[wxMacNetEventsBottom] ) ;
1888 wxMacNetEventsBottom++ ;
1889 if ( wxMacNetEventsBottom == kwxMacNetEventsMax )
1890 wxMacNetEventsBottom = 0 ;
1891 }
1892 }
1893 #endif
1894
1895 #endif
1896 // __WXSTUBS__
wxWidgets (Impactor)