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