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


cc5c83e84f3c9fbfd56c8b6a9860ee6474fa56c2
[wxWidgets.git] / src / common / socket.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: socket.cpp
3 // Purpose: Socket handler classes
4 // Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia
5 // Created: April 1997
6 // Updated: July 1999
7 // Copyright: (C) 1999, 1998, 1997, Guilhem Lavaux
8 // RCS_ID: $Id$
9 // License: see wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "socket.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #if wxUSE_SOCKETS
24
25 /////////////////////////////////////////////////////////////////////////////
26 // wxWindows headers
27 /////////////////////////////////////////////////////////////////////////////
28 #include "wx/defs.h"
29 #include "wx/object.h"
30 #include "wx/string.h"
31 #include "wx/timer.h"
32 #include "wx/utils.h"
33 #include "wx/module.h"
34 #include "wx/log.h"
35
36 #include <stdlib.h>
37 #include <string.h>
38 #include <ctype.h>
39
40 /////////////////////////////////////////////////////////////////////////////
41 // wxSocket headers
42 /////////////////////////////////////////////////////////////////////////////
43 #include "wx/sckaddr.h"
44 #include "wx/socket.h"
45
46 // --------------------------------------------------------------
47 // ClassInfos
48 // --------------------------------------------------------------
49 #if !USE_SHARED_LIBRARY
50 IMPLEMENT_CLASS(wxSocketBase, wxObject)
51 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
52 IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
53 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
54 #endif
55
56 class wxSocketState : public wxObject
57 {
58 public:
59 bool notify_state;
60 GSocketEventFlags evt_notify_state;
61 wxSocketBase::wxSockFlags socket_flags;
62 wxSocketBase::wxSockCbk c_callback;
63 char *c_callback_data;
64
65 public:
66 wxSocketState() : wxObject() {}
67 };
68
69 // --------------------------------------------------------------
70 // wxSocketBase ctor and dtor
71 // --------------------------------------------------------------
72
73 wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags,
74 wxSocketBase::wxSockType _type) :
75 wxEvtHandler(),
76 m_socket(NULL), m_flags(_flags), m_type(_type),
77 m_neededreq(0),
78 m_lcount(0), m_timeout(600),
79 m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
80 m_cbk(NULL), m_cdata(NULL),
81 m_connected(FALSE), m_establishing(FALSE),
82 m_notify_state(FALSE), m_id(-1),
83 m_defering(NO_DEFER), m_error(FALSE),
84 m_states()
85 {
86 }
87
88 wxSocketBase::wxSocketBase() :
89 wxEvtHandler(),
90 m_socket(NULL), m_flags(WAITALL | SPEED), m_type(SOCK_UNINIT),
91 m_neededreq(0),
92 m_lcount(0), m_timeout(600),
93 m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
94 m_cbk(NULL), m_cdata(NULL),
95 m_connected(FALSE), m_establishing(FALSE),
96 m_notify_state(FALSE), m_id(-1),
97 m_defering(NO_DEFER), m_error(FALSE),
98 m_states()
99 {
100 }
101
102 wxSocketBase::~wxSocketBase()
103 {
104 if (m_unread)
105 free(m_unread);
106
107 // Shutdown and close the socket
108 Close();
109
110 // Destroy the GSocket object
111 if (m_socket)
112 GSocket_destroy(m_socket);
113 }
114
115 bool wxSocketBase::Close()
116 {
117 if (m_socket)
118 {
119 // Disable callbacks
120 GSocket_UnsetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
121 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG);
122
123 // Shutdown the connection
124 GSocket_Shutdown(m_socket);
125 m_connected = FALSE;
126 m_establishing = FALSE;
127 }
128
129 return TRUE;
130 }
131
132 // --------------------------------------------------------------
133 // wxSocketBase basic IO operations
134 // --------------------------------------------------------------
135
136 // GRG: I have made some changes to wxSocket internal event
137 // system; now, all events (INPUT, OUTPUT, CONNECTION, LOST)
138 // are always internally monitored; but users will only be
139 // notified of these events they are interested in. So we
140 // no longer have to change the event mask with SetNotify()
141 // in internal functions like DeferRead, DeferWrite, and
142 // the like. This solves a lot of problems.
143
144 // GRG: I added m_error handling to IO operations. Now,
145 // wxSocketBase::Error() correctly indicates if the last
146 // operation from {Read, Write, ReadMsg, WriteMsg, Peek,
147 // Unread, Discard} failed. Note that now, every function
148 // that updates m_lcount, also updates m_error. While I
149 // was at it, also fixed an UGLY bug in ReadMsg.
150
151 class _wxSocketInternalTimer: public wxTimer
152 {
153 public:
154 int *m_state;
155 unsigned long m_new_val;
156
157 void Notify()
158 {
159 *m_state = m_new_val; // Change the value
160 }
161 };
162
163 int wxSocketBase::DeferRead(char *buffer, wxUint32 nbytes)
164 {
165 // Timer for timeout
166 _wxSocketInternalTimer timer;
167
168 wxASSERT(m_defering == NO_DEFER);
169
170 // Set the defering mode to READ.
171 m_defering = DEFER_READ;
172
173 // Set the current buffer.
174 m_defer_buffer = buffer;
175 m_defer_nbytes = nbytes;
176 m_defer_timer = &timer;
177
178 timer.m_state = (int *)&m_defer_buffer;
179 timer.m_new_val = 0;
180
181 timer.Start(m_timeout * 1000, FALSE);
182
183 // If the socket is readable, call DoDefer for the first time
184 if (GSocket_Select(m_socket, GSOCK_INPUT_FLAG))
185 DoDefer();
186
187 // Wait for buffer completion.
188 while (m_defer_buffer != NULL)
189 wxYield();
190
191 timer.Stop();
192
193 // Disable defering mode.
194 m_defering = NO_DEFER;
195 m_defer_timer = NULL;
196
197 // Return the number of bytes read from the socket.
198 return nbytes-m_defer_nbytes;
199 }
200
201 wxSocketBase& wxSocketBase::Read(char* buffer, wxUint32 nbytes)
202 {
203 int ret = 1;
204
205 m_error = FALSE;
206
207 // we try this even if the connection has already been closed.
208 m_lcount = GetPushback(buffer, nbytes, FALSE);
209 nbytes -= m_lcount;
210 buffer += m_lcount;
211
212 if (!m_connected || !m_socket)
213 {
214 // if no data retrieved AND not connected, it is an error.
215 if (!m_lcount)
216 m_error = TRUE;
217
218 return *this;
219 }
220
221 // If we have got the whole needed buffer, return immediately
222 if (!nbytes)
223 {
224 return *this;
225 }
226
227 if (m_flags & SPEED & WAITALL) // SPEED && WAITALL
228 {
229 while (ret > 0 && nbytes > 0)
230 {
231 ret = GSocket_Read(m_socket, buffer, nbytes);
232 m_lcount += ret;
233 buffer += ret;
234 nbytes -= ret;
235 }
236 // In case the last call was an error ...
237 if (ret < 0)
238 m_lcount ++;
239 }
240 else if (m_flags & SPEED) // SPEED && !WAITALL
241 {
242 ret = GSocket_Read(m_socket, buffer, nbytes);
243
244 if (ret > 0)
245 m_lcount += ret;
246 }
247 else // !SPEED
248 {
249 ret = DeferRead(buffer, nbytes);
250
251 if (ret > 0)
252 m_lcount += ret;
253 }
254
255 // If we have read some data, then it is not an error, even
256 // when in WAITALL mode, the last low-level IO call might
257 // have failed.
258 if (!m_lcount)
259 m_error = TRUE;
260
261 return *this;
262 }
263
264 wxSocketBase& wxSocketBase::ReadMsg(char* buffer, wxUint32 nbytes)
265 {
266 #define MAX_BUFSIZE (10 * 1024)
267
268 int old_flags;
269 unsigned long len, len2, sig;
270 struct
271 {
272 char sig[4];
273 char len[4];
274 } msg;
275
276 // sig should be an explicit 32-bit unsigned integer; I've seen
277 // compilers in which wxUint32 was actually a 16-bit unsigned integer
278
279 old_flags = m_flags;
280 SetFlags(WAITALL | SPEED);
281
282 Read((char *)&msg, sizeof(msg));
283 if (m_lcount != sizeof(msg))
284 {
285 SetFlags(old_flags);
286 m_error = TRUE;
287 return *this;
288 }
289
290 sig = msg.sig[0] & 0xff;
291 sig |= (wxUint32)(msg.sig[1] & 0xff) << 8;
292 sig |= (wxUint32)(msg.sig[2] & 0xff) << 16;
293 sig |= (wxUint32)(msg.sig[3] & 0xff) << 24;
294
295 if (sig != 0xfeeddead)
296 {
297 wxLogDebug(_T("Warning: invalid signature returned to ReadMsg\n"));
298 SetFlags(old_flags);
299 m_error = TRUE;
300 return *this;
301 }
302
303 len = msg.len[0] & 0xff;
304 len |= (wxUint32)(msg.len[1] & 0xff) << 8;
305 len |= (wxUint32)(msg.len[2] & 0xff) << 16;
306 len |= (wxUint32)(msg.len[3] & 0xff) << 24;
307
308 if (len > nbytes)
309 {
310 len2 = len - nbytes;
311 len = nbytes;
312 }
313 else
314 len2 = 0;
315
316 // The "len &&" in the following statements is necessary so
317 // that we don't attempt to read (and possibly hang the system)
318 // if the message was zero bytes long
319 if (len && Read(buffer, len).LastCount() != len)
320 {
321 SetFlags(old_flags);
322 m_error = TRUE;
323 return *this;
324 }
325 if (len2)
326 {
327 char *discard_buffer = new char[MAX_BUFSIZE];
328 long discard_len;
329
330 do
331 {
332 discard_len = ((len2 > MAX_BUFSIZE)? MAX_BUFSIZE : len2);
333 discard_len = Read(discard_buffer, discard_len).LastCount();
334 len2 -= discard_len;
335 }
336 while ((discard_len > 0) && len2);
337
338 delete [] discard_buffer;
339
340 if (len2 != 0)
341 {
342 SetFlags(old_flags);
343 m_error = TRUE;
344 return *this;
345 }
346 }
347 if (Read((char *)&msg, sizeof(msg)).LastCount() != sizeof(msg))
348 {
349 SetFlags(old_flags);
350 m_error = TRUE;
351 return *this;
352 }
353
354 sig = msg.sig[0] & 0xff;
355 sig |= (wxUint32)(msg.sig[1] & 0xff) << 8;
356 sig |= (wxUint32)(msg.sig[2] & 0xff) << 16;
357 sig |= (wxUint32)(msg.sig[3] & 0xff) << 24;
358
359 if (sig != 0xdeadfeed)
360 {
361 m_error = TRUE;
362 wxLogDebug(_T("Warning: invalid signature returned to ReadMsg\n"));
363 }
364
365 SetFlags(old_flags);
366 return *this;
367
368 #undef MAX_BUFSIZE
369 }
370
371 wxSocketBase& wxSocketBase::Peek(char* buffer, wxUint32 nbytes)
372 {
373 Read(buffer, nbytes);
374 CreatePushbackAfter(buffer, nbytes);
375
376 return *this;
377 }
378
379 int wxSocketBase::DeferWrite(const char *buffer, wxUint32 nbytes)
380 {
381 // Timer for timeout
382 _wxSocketInternalTimer timer;
383
384 wxASSERT(m_defering == NO_DEFER);
385
386 m_defering = DEFER_WRITE;
387
388 // Set the current buffer
389 m_defer_buffer = (char *)buffer;
390 m_defer_nbytes = nbytes;
391 m_defer_timer = &timer;
392
393 // Start timer
394 timer.m_state = (int *)&m_defer_buffer;
395 timer.m_new_val = 0;
396
397 timer.Start(m_timeout * 1000, FALSE);
398
399 // If the socket is writable, call DoDefer for the first time
400 if (GSocket_Select(m_socket, GSOCK_OUTPUT_FLAG))
401 DoDefer();
402
403 // Wait for buffer completion.
404 while (m_defer_buffer != NULL)
405 wxYield();
406
407 // Stop timer
408 m_defer_timer = NULL;
409 timer.Stop();
410
411 m_defering = NO_DEFER;
412
413 return nbytes-m_defer_nbytes;
414 }
415
416 wxSocketBase& wxSocketBase::Write(const char *buffer, wxUint32 nbytes)
417 {
418 int ret = 1;
419
420 m_lcount = 0;
421 m_error = FALSE;
422
423 if (!m_connected || !m_socket)
424 {
425 m_error = TRUE;
426 return *this;
427 }
428
429 if (m_flags & SPEED & WAITALL) // SPEED && WAITALL
430 {
431 while (ret > 0 && nbytes > 0)
432 {
433 ret = GSocket_Write(m_socket, buffer, nbytes);
434 m_lcount += ret;
435 buffer += ret;
436 nbytes -= ret;
437 }
438 // In case the last call was an error ...
439 if (ret < 0)
440 m_lcount ++;
441 }
442 else if (m_flags & SPEED) // SPEED && !WAITALL
443 {
444 ret = GSocket_Write(m_socket, buffer, nbytes);
445
446 if (ret > 0)
447 m_lcount += ret;
448 }
449 else // !SPEED
450 {
451 ret = DeferWrite(buffer, nbytes);
452
453 if (ret > 0)
454 m_lcount += ret;
455 }
456
457 // If we have written some data, then it is not an error,
458 // even when in WAITALL mode, the last low-level IO call
459 // might have failed.
460 if (!m_lcount)
461 m_error = TRUE;
462
463 return *this;
464 }
465
466 wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, wxUint32 nbytes)
467 {
468 int old_flags;
469 struct {
470 char sig[4];
471 char len[4];
472 } msg;
473
474 // warning about 'cast truncates constant value'
475 #ifdef __VISUALC__
476 #pragma warning(disable: 4310)
477 #endif // __VISUALC__
478
479 msg.sig[0] = (char) 0xad;
480 msg.sig[1] = (char) 0xde;
481 msg.sig[2] = (char) 0xed;
482 msg.sig[3] = (char) 0xfe;
483
484 msg.len[0] = (char) nbytes & 0xff;
485 msg.len[1] = (char) (nbytes >> 8) & 0xff;
486 msg.len[2] = (char) (nbytes >> 16) & 0xff;
487 msg.len[3] = (char) (nbytes >> 24) & 0xff;
488
489 // GRG: We need WAITALL | SPEED
490 old_flags = m_flags;
491 SetFlags(WAITALL | SPEED);
492
493 if (Write((char *)&msg, sizeof(msg)).LastCount() < sizeof(msg))
494 {
495 SetFlags(old_flags);
496 m_error = TRUE;
497 return *this;
498 }
499 if (Write(buffer, nbytes).LastCount() < nbytes)
500 {
501 SetFlags(old_flags);
502 m_error = TRUE;
503 return *this;
504 }
505
506 msg.sig[0] = (char) 0xed;
507 msg.sig[1] = (char) 0xfe;
508 msg.sig[2] = (char) 0xad;
509 msg.sig[3] = (char) 0xde;
510 msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
511
512 if (Write((char *)&msg, sizeof(msg)).LastCount() < sizeof(msg))
513 m_error = TRUE;
514
515 SetFlags(old_flags);
516 return *this;
517
518 #ifdef __VISUALC__
519 #pragma warning(default: 4310)
520 #endif // __VISUALC__
521 }
522
523 wxSocketBase& wxSocketBase::Unread(const char *buffer, wxUint32 nbytes)
524 {
525 m_error = FALSE;
526 m_lcount = 0;
527
528 if (nbytes != 0)
529 {
530 CreatePushbackAfter(buffer, nbytes);
531 m_lcount = nbytes;
532 }
533 return *this;
534 }
535
536 bool wxSocketBase::IsData() const
537 {
538 if (!m_socket)
539 return FALSE;
540
541 return (GSocket_Select(m_socket, GSOCK_INPUT_FLAG));
542 }
543
544 // GRG: DoDefer() no longer needs to know which event occured,
545 // because this was only used to catch LOST events and set
546 // m_defer_buffer = NULL; this is done in OnRequest() now.
547
548 void wxSocketBase::DoDefer()
549 {
550 int ret;
551
552 if (!m_defer_buffer)
553 return;
554
555 switch (m_defering)
556 {
557 case DEFER_READ:
558 ret = GSocket_Read(m_socket, m_defer_buffer, m_defer_nbytes);
559 break;
560 case DEFER_WRITE:
561 ret = GSocket_Write(m_socket, m_defer_buffer, m_defer_nbytes);
562 break;
563 default:
564 ret = -1;
565 break;
566 }
567
568 if (ret >= 0)
569 m_defer_nbytes -= ret;
570
571 // If we are waiting for all bytes to be acquired, keep the defering
572 // mode enabled.
573 if ((m_flags & WAITALL) == 0 || m_defer_nbytes == 0 || ret < 0)
574 {
575 m_defer_buffer = NULL;
576 }
577 else
578 {
579 m_defer_buffer += ret;
580 m_defer_timer->Start(m_timeout * 1000, FALSE);
581 }
582 }
583
584 void wxSocketBase::Discard()
585 {
586 #define MAX_BUFSIZE (10*1024)
587
588 char *my_data = new char[MAX_BUFSIZE];
589 wxUint32 recv_size = MAX_BUFSIZE;
590 wxUint32 total = 0;
591
592 SaveState();
593 SetFlags(NOWAIT); // GRG: SPEED was not needed here!
594
595 while (recv_size == MAX_BUFSIZE)
596 {
597 recv_size = Read(my_data, MAX_BUFSIZE).LastCount();
598 total += recv_size;
599 }
600
601 RestoreState();
602 delete [] my_data;
603
604 m_lcount = total;
605 m_error = FALSE;
606
607 #undef MAX_BUFSIZE
608 }
609
610 // --------------------------------------------------------------
611 // wxSocketBase get local or peer addresses
612 // --------------------------------------------------------------
613
614 bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
615 {
616 GAddress *peer;
617
618 if (!m_socket)
619 return FALSE;
620
621 peer = GSocket_GetPeer(m_socket);
622 addr_man.SetAddress(peer);
623 GAddress_destroy(peer);
624
625 return TRUE;
626 }
627
628 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
629 {
630 GAddress *local;
631
632 if (!m_socket)
633 return FALSE;
634
635 local = GSocket_GetLocal(m_socket);
636 addr_man.SetAddress(local);
637 GAddress_destroy(local);
638
639 return TRUE;
640 }
641
642 // --------------------------------------------------------------
643 // wxSocketBase save and restore socket state
644 // --------------------------------------------------------------
645
646 void wxSocketBase::SaveState()
647 {
648 wxSocketState *state;
649
650 state = new wxSocketState();
651
652 state->notify_state = m_notify_state;
653 state->evt_notify_state = m_neededreq;
654 state->socket_flags = m_flags;
655 state->c_callback = m_cbk;
656 state->c_callback_data = m_cdata;
657
658 m_states.Append(state);
659 }
660
661 void wxSocketBase::RestoreState()
662 {
663 wxNode *node;
664 wxSocketState *state;
665
666 node = m_states.Last();
667 if (!node)
668 return;
669
670 state = (wxSocketState *)node->Data();
671
672 SetFlags(state->socket_flags);
673 m_neededreq = state->evt_notify_state;
674 m_cbk = state->c_callback;
675 m_cdata = state->c_callback_data;
676 Notify(state->notify_state);
677
678 delete node;
679 delete state;
680 }
681
682
683 // --------------------------------------------------------------
684 // wxSocketBase Wait functions
685 // --------------------------------------------------------------
686
687 // GRG: I have completely rewritten this family of functions
688 // so that they don't depend on event notifications; instead,
689 // they poll the socket, using GSocket_Select(), to check for
690 // the specified combination of event flags, until an event
691 // occurs or until the timeout ellapses. The polling loop
692 // calls wxYield(), so this won't block the GUI.
693
694 bool wxSocketBase::_Wait(long seconds, long milliseconds, wxSocketEventFlags flags)
695 {
696 GSocketEventFlags result;
697 _wxSocketInternalTimer timer;
698 long timeout;
699 int state = -1;
700
701 // Check for valid socket
702 if ((!m_connected && !m_establishing) || !m_socket)
703 return FALSE;
704
705 // Check for valid timeout value
706 if (seconds != -1)
707 timeout = seconds * 1000 + milliseconds;
708 else
709 timeout = m_timeout * 1000;
710
711 // Activate timer
712 timer.m_state = &state;
713 timer.m_new_val = 0;
714 timer.Start(timeout, TRUE);
715
716 // Active polling (without using events)
717 result = GSocket_Select(m_socket, flags);
718
719 while ((result == 0) && (state == -1))
720 {
721 wxYield();
722 result = GSocket_Select(m_socket, flags);
723 }
724
725 timer.Stop();
726
727 return (result != 0);
728 }
729
730 bool wxSocketBase::Wait(long seconds, long milliseconds)
731 {
732 return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
733 GSOCK_OUTPUT_FLAG |
734 GSOCK_CONNECTION_FLAG |
735 GSOCK_LOST_FLAG);
736 }
737
738 bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
739 {
740 return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG);
741 }
742
743 bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
744 {
745 return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG | GSOCK_LOST_FLAG);
746 }
747
748 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
749 {
750 return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG);
751 }
752
753 void wxSocketBase::SetTimeout(long seconds)
754 {
755 m_timeout = seconds;
756
757 if (m_socket)
758 GSocket_SetTimeout(m_socket, m_timeout);
759 }
760
761 // --------------------------------------------------------------
762 // wxSocketBase flags
763 // --------------------------------------------------------------
764
765 void wxSocketBase::SetFlags(wxSockFlags _flags)
766 {
767 m_flags = _flags;
768 }
769
770 wxSocketBase::wxSockFlags wxSocketBase::GetFlags() const
771 {
772 return m_flags;
773 }
774
775 // --------------------------------------------------------------
776 // wxSocketBase callback management
777 // --------------------------------------------------------------
778
779 wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_)
780 {
781 wxSockCbk old_cbk = cbk_;
782
783 m_cbk = cbk_;
784 return old_cbk;
785 }
786
787 char *wxSocketBase::CallbackData(char *data)
788 {
789 char *old_data = m_cdata;
790
791 m_cdata = data;
792 return old_data;
793 }
794
795 // --------------------------------------------------------------
796 // wxSocketBase automatic notifier
797 // --------------------------------------------------------------
798
799 static void LINKAGEMODE wx_socket_callback(GSocket *socket, GSocketEvent event, char *cdata)
800 {
801 wxSocketBase *sckobj = (wxSocketBase *)cdata;
802
803 sckobj->OnRequest((wxSocketNotify)event);
804 }
805
806 wxSocketEventFlags wxSocketBase::EventToNotify(wxSocketNotify evt)
807 {
808 switch (evt)
809 {
810 case GSOCK_INPUT: return GSOCK_INPUT_FLAG;
811 case GSOCK_OUTPUT: return GSOCK_OUTPUT_FLAG;
812 case GSOCK_CONNECTION: return GSOCK_CONNECTION_FLAG;
813 case GSOCK_LOST: return GSOCK_LOST_FLAG;
814 }
815 return 0;
816 }
817
818 void wxSocketBase::SetNotify(wxSocketEventFlags flags)
819 {
820 m_neededreq = flags;
821 }
822
823 void wxSocketBase::Notify(bool notify)
824 {
825 m_notify_state = notify;
826 }
827
828 void wxSocketBase::OnRequest(wxSocketNotify req_evt)
829 {
830 wxSocketEvent event(m_id);
831 wxSocketEventFlags flag = EventToNotify(req_evt);
832
833 switch(req_evt)
834 {
835 case wxSOCKET_CONNECTION:
836 m_establishing = FALSE;
837 m_connected = TRUE;
838 break;
839 case wxSOCKET_LOST:
840 m_defer_buffer = NULL;
841 Close();
842 break;
843 case wxSOCKET_INPUT:
844 case wxSOCKET_OUTPUT:
845 if (m_defer_buffer)
846 {
847 // GRG: DoDefer() no longer needs to know which
848 // event occured, because this was only used to
849 // catch LOST events and set m_defer_buffer to
850 // NULL, and this is done in OnRequest() now.
851 DoDefer();
852 // Do not notify to user
853 return;
854 }
855 break;
856 }
857
858 if (((m_neededreq & flag) == flag) && m_notify_state)
859 {
860 event.m_socket = this;
861 event.m_skevt = req_evt;
862 ProcessEvent(event);
863 OldOnNotify(req_evt);
864
865 if (m_cbk)
866 m_cbk(*this, req_evt, m_cdata);
867 }
868 }
869
870 void wxSocketBase::OldOnNotify(wxSocketNotify evt)
871 {
872 }
873
874 // --------------------------------------------------------------
875 // wxSocketBase set event handler
876 // --------------------------------------------------------------
877
878 void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id)
879 {
880 SetNextHandler(&h_evt);
881 m_id = id;
882 }
883
884 // --------------------------------------------------------------
885 // wxSocketBase pushback library
886 // --------------------------------------------------------------
887
888 void wxSocketBase::CreatePushbackAfter(const char *buffer, wxUint32 size)
889 {
890 char *curr_pos;
891
892 if (m_unread != NULL)
893 m_unread = (char *) realloc(m_unread, m_unrd_size+size);
894 else
895 m_unread = (char *) malloc(size);
896
897 curr_pos = m_unread + m_unrd_size;
898
899 memcpy(curr_pos, buffer, size);
900 m_unrd_size += size;
901 }
902
903 void wxSocketBase::CreatePushbackBefore(const char *buffer, wxUint32 size)
904 {
905 if (m_unread == NULL)
906 m_unread = (char *)malloc(size);
907 else {
908 char *tmp;
909
910 tmp = (char *)malloc(m_unrd_size + size);
911 memcpy(tmp+size, m_unread, m_unrd_size);
912 free(m_unread);
913
914 m_unread = tmp;
915 }
916
917 m_unrd_size += size;
918
919 memcpy(m_unread, buffer, size);
920 }
921
922 wxUint32 wxSocketBase::GetPushback(char *buffer, wxUint32 size, bool peek)
923 {
924 if (!m_unrd_size)
925 return 0;
926
927 if (size > (m_unrd_size-m_unrd_cur))
928 size = m_unrd_size-m_unrd_cur;
929 memcpy(buffer, (m_unread+m_unrd_cur), size);
930
931 if (!peek) {
932 m_unrd_cur += size;
933 if (m_unrd_size == m_unrd_cur) {
934 free(m_unread);
935 m_unread = NULL;
936 m_unrd_size = 0;
937 m_unrd_cur = 0;
938 }
939 }
940
941 return size;
942 }
943
944 // --------------------------------------------------------------
945 // wxSocketServer
946 // --------------------------------------------------------------
947
948 // --------------------------------------------------------------
949 // wxSocketServer ctor and dtor
950 // --------------------------------------------------------------
951
952 wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
953 wxSockFlags flags) :
954 wxSocketBase(flags, SOCK_SERVER)
955 {
956 // Create the socket
957 m_socket = GSocket_new();
958
959 if (!m_socket)
960 return;
961
962 // Setup the socket as server
963 GSocket_SetLocal(m_socket, addr_man.GetAddress());
964 if (GSocket_SetServer(m_socket) != GSOCK_NOERROR)
965 {
966 GSocket_destroy(m_socket);
967 m_socket = NULL;
968 return;
969 }
970
971 GSocket_SetTimeout(m_socket, m_timeout);
972 GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
973 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
974 wx_socket_callback, (char *)this);
975
976 }
977
978 // --------------------------------------------------------------
979 // wxSocketServer Accept
980 // --------------------------------------------------------------
981
982 bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait)
983 {
984 GSocket *child_socket;
985
986 if (!m_socket)
987 return FALSE;
988
989 // GRG: If wait == FALSE, then the call should be nonblocking.
990 // When we are finished, we put the socket to blocking mode
991 // again.
992
993 if (!wait)
994 GSocket_SetNonBlocking(m_socket, TRUE);
995
996 child_socket = GSocket_WaitConnection(m_socket);
997
998 if (!wait)
999 GSocket_SetNonBlocking(m_socket, FALSE);
1000
1001 // GRG: this was not being handled!
1002 if (child_socket == NULL)
1003 return FALSE;
1004
1005 sock.m_type = SOCK_INTERNAL;
1006 sock.m_socket = child_socket;
1007 sock.m_connected = TRUE;
1008
1009 GSocket_SetTimeout(sock.m_socket, sock.m_timeout);
1010 GSocket_SetCallback(sock.m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1011 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1012 wx_socket_callback, (char *)&sock);
1013
1014 return TRUE;
1015 }
1016
1017 wxSocketBase *wxSocketServer::Accept(bool wait)
1018 {
1019 wxSocketBase* sock = new wxSocketBase();
1020
1021 sock->SetFlags((wxSockFlags)m_flags);
1022
1023 if (!AcceptWith(*sock, wait))
1024 return NULL;
1025
1026 return sock;
1027 }
1028
1029 bool wxSocketServer::WaitForAccept(long seconds, long milliseconds)
1030 {
1031 return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG | GSOCK_LOST_FLAG);
1032 }
1033
1034 // --------------------------------------------------------------
1035 // wxSocketClient
1036 // --------------------------------------------------------------
1037
1038 // --------------------------------------------------------------
1039 // wxSocketClient ctor and dtor
1040 // --------------------------------------------------------------
1041
1042 wxSocketClient::wxSocketClient(wxSockFlags _flags) :
1043 wxSocketBase(_flags, SOCK_CLIENT)
1044 {
1045 }
1046
1047 wxSocketClient::~wxSocketClient()
1048 {
1049 }
1050
1051 // --------------------------------------------------------------
1052 // wxSocketClient Connect functions
1053 // --------------------------------------------------------------
1054 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
1055 {
1056 GSocketError err;
1057
1058 if (IsConnected())
1059 Close();
1060
1061 // This should never happen.
1062 if (m_socket)
1063 GSocket_destroy(m_socket);
1064
1065 // Initialize all socket stuff ...
1066 m_socket = GSocket_new();
1067 m_connected = FALSE;
1068 m_establishing = FALSE;
1069
1070 if (!m_socket)
1071 return FALSE;
1072
1073 GSocket_SetTimeout(m_socket, m_timeout);
1074
1075 // GRG: If wait == FALSE, then the call should be nonblocking.
1076 // When we are finished, we put the socket to blocking mode
1077 // again.
1078
1079 if (!wait)
1080 GSocket_SetNonBlocking(m_socket, TRUE);
1081
1082 GSocket_SetPeer(m_socket, addr_man.GetAddress());
1083 err = GSocket_Connect(m_socket, GSOCK_STREAMED);
1084 GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1085 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1086 wx_socket_callback, (char *)this);
1087
1088 if (!wait)
1089 GSocket_SetNonBlocking(m_socket, FALSE);
1090
1091 if (err != GSOCK_NOERROR)
1092 {
1093 if (err == GSOCK_WOULDBLOCK)
1094 m_establishing = TRUE;
1095
1096 return FALSE;
1097 }
1098
1099 m_connected = TRUE;
1100 return TRUE;
1101 }
1102
1103 bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
1104 {
1105 bool ret;
1106
1107 if (m_connected) // Already connected
1108 return TRUE;
1109
1110 if (!m_establishing || !m_socket) // No connection in progress
1111 return FALSE;
1112
1113 ret = _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG | GSOCK_LOST_FLAG);
1114
1115 // GRG: m_connected and m_establishing will be updated in
1116 // OnRequest(), but we do it here anyway because sometimes
1117 // the event might be a bit delayed, and if that happens,
1118 // when WaitOnConnect() returns, m_connected will still be
1119 // FALSE. We have to do it as well in OnRequest because
1120 // maybe WaitOnConnect() is not being used...
1121
1122 if (ret)
1123 {
1124 m_connected = GSocket_Select(m_socket, GSOCK_CONNECTION_FLAG);
1125 m_establishing = FALSE;
1126 }
1127
1128 return m_connected;
1129 }
1130
1131
1132 // --------------------------------------------------------------
1133 // wxSocketEvent
1134 // --------------------------------------------------------------
1135
1136 wxSocketEvent::wxSocketEvent(int id)
1137 : wxEvent(id)
1138 {
1139 wxEventType type = (wxEventType)wxEVT_SOCKET;
1140
1141 SetEventType(type);
1142 }
1143
1144 void wxSocketEvent::CopyObject(wxObject& obj_d) const
1145 {
1146 wxSocketEvent *event = (wxSocketEvent *)&obj_d;
1147
1148 wxEvent::CopyObject(obj_d);
1149
1150 event->m_skevt = m_skevt;
1151 event->m_socket = m_socket;
1152 }
1153
1154 // --------------------------------------------------------------------------
1155 // wxSocketModule
1156 // --------------------------------------------------------------------------
1157 class WXDLLEXPORT wxSocketModule: public wxModule {
1158 DECLARE_DYNAMIC_CLASS(wxSocketModule)
1159 public:
1160 bool OnInit() {
1161 return GSocket_Init();
1162 }
1163 void OnExit() {
1164 GSocket_Cleanup();
1165 }
1166 };
1167
1168 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
1169
1170 #endif
1171 // wxUSE_SOCKETS
wxWidgets (Impactor)