]> git.saurik.com Git - wxWidgets.git/blob - src/common/socket.cpp
added vendor display name (for consistency with app display name &c) (patch 1831303)
[wxWidgets.git] / src / common / socket.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/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: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ==========================================================================
13 // Declarations
14 // ==========================================================================
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 #include "wx/socket.h"
26
27 #ifndef WX_PRECOMP
28 #include "wx/object.h"
29 #include "wx/string.h"
30 #include "wx/intl.h"
31 #include "wx/log.h"
32 #include "wx/event.h"
33 #include "wx/app.h"
34 #include "wx/utils.h"
35 #include "wx/timer.h"
36 #include "wx/module.h"
37 #endif
38
39 #include "wx/apptrait.h"
40
41 #include "wx/sckaddr.h"
42 #include "wx/stopwatch.h"
43
44 // DLL options compatibility check:
45 #include "wx/build.h"
46 WX_CHECK_BUILD_OPTIONS("wxNet")
47
48 // --------------------------------------------------------------------------
49 // macros and constants
50 // --------------------------------------------------------------------------
51
52 // discard buffer
53 #define MAX_DISCARD_SIZE (10 * 1024)
54
55 // what to do within waits: we have 2 cases: from the main thread itself we
56 // have to call wxYield() to let the events (including the GUI events and the
57 // low-level (not wxWidgets) events from GSocket) be processed. From another
58 // thread it is enough to just call wxThread::Yield() which will give away the
59 // rest of our time slice: the explanation is that the events will be processed
60 // by the main thread anyhow, without calling wxYield(), but we don't want to
61 // eat the CPU time uselessly while sitting in the loop waiting for the data
62 #if wxUSE_THREADS
63 #define PROCESS_EVENTS() \
64 { \
65 if ( wxThread::IsMain() ) \
66 wxYield(); \
67 else \
68 wxThread::Yield(); \
69 }
70 #else // !wxUSE_THREADS
71 #define PROCESS_EVENTS() wxYield()
72 #endif // wxUSE_THREADS/!wxUSE_THREADS
73
74 #define wxTRACE_Socket _T("wxSocket")
75
76 // --------------------------------------------------------------------------
77 // wxWin macros
78 // --------------------------------------------------------------------------
79
80 IMPLEMENT_CLASS(wxSocketBase, wxObject)
81 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
82 IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
83 IMPLEMENT_CLASS(wxDatagramSocket, wxSocketBase)
84 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
85
86 // --------------------------------------------------------------------------
87 // private classes
88 // --------------------------------------------------------------------------
89
90 class wxSocketState : public wxObject
91 {
92 public:
93 wxSocketFlags m_flags;
94 wxSocketEventFlags m_eventmask;
95 bool m_notify;
96 void *m_clientData;
97
98 public:
99 wxSocketState() : wxObject() {}
100
101 DECLARE_NO_COPY_CLASS(wxSocketState)
102 };
103
104 // ==========================================================================
105 // wxSocketBase
106 // ==========================================================================
107
108 // --------------------------------------------------------------------------
109 // Initialization and shutdown
110 // --------------------------------------------------------------------------
111
112 // FIXME-MT: all this is MT-unsafe, of course, we should protect all accesses
113 // to m_countInit with a crit section
114 size_t wxSocketBase::m_countInit = 0;
115
116 bool wxSocketBase::IsInitialized()
117 {
118 return m_countInit > 0;
119 }
120
121 bool wxSocketBase::Initialize()
122 {
123 if ( !m_countInit++ )
124 {
125 /*
126 Details: Initialize() creates a hidden window as a sink for socket
127 events, such as 'read completed'. wxMSW has only one message loop
128 for the main thread. If Initialize is called in a secondary thread,
129 the socket window will be created for the secondary thread, but
130 since there is no message loop on this thread, it will never
131 receive events and all socket operations will time out.
132 BTW, the main thread must not be stopped using sleep or block
133 on a semaphore (a bad idea in any case) or socket operations
134 will time out.
135
136 On the Mac side, Initialize() stores a pointer to the CFRunLoop for
137 the main thread. Because secondary threads do not have run loops,
138 adding event notifications to the "Current" loop would have no
139 effect at all, events would never fire.
140 */
141 wxASSERT_MSG( wxIsMainThread(),
142 wxT("Call wxSocketBase::Initialize() from the main thread first!"));
143
144 wxAppTraits *traits = wxAppConsole::GetInstance() ?
145 wxAppConsole::GetInstance()->GetTraits() : NULL;
146 GSocketGUIFunctionsTable *functions =
147 traits ? traits->GetSocketGUIFunctionsTable() : NULL;
148 GSocket_SetGUIFunctions(functions);
149
150 if ( !GSocket_Init() )
151 {
152 m_countInit--;
153
154 return false;
155 }
156 }
157
158 return true;
159 }
160
161 void wxSocketBase::Shutdown()
162 {
163 // we should be initialized
164 wxASSERT_MSG( m_countInit, _T("extra call to Shutdown()") );
165 if ( --m_countInit == 0 )
166 {
167 GSocket_Cleanup();
168 }
169 }
170
171 // --------------------------------------------------------------------------
172 // Ctor and dtor
173 // --------------------------------------------------------------------------
174
175 void wxSocketBase::Init()
176 {
177 m_socket = NULL;
178 m_type = wxSOCKET_UNINIT;
179
180 // state
181 m_flags = 0;
182 m_connected =
183 m_establishing =
184 m_reading =
185 m_writing =
186 m_error = false;
187 m_lcount = 0;
188 m_timeout = 600;
189 m_beingDeleted = false;
190
191 // pushback buffer
192 m_unread = NULL;
193 m_unrd_size = 0;
194 m_unrd_cur = 0;
195
196 // events
197 m_id = wxID_ANY;
198 m_handler = NULL;
199 m_clientData = NULL;
200 m_notify = false;
201 m_eventmask = 0;
202
203 if ( !IsInitialized() )
204 {
205 // this Initialize() will be undone by wxSocketModule::OnExit(), all the
206 // other calls to it should be matched by a call to Shutdown()
207 Initialize();
208 }
209 }
210
211 wxSocketBase::wxSocketBase()
212 {
213 Init();
214 }
215
216 wxSocketBase::wxSocketBase(wxSocketFlags flags, wxSocketType type)
217 {
218 Init();
219
220 m_flags = flags;
221 m_type = type;
222 }
223
224 wxSocketBase::~wxSocketBase()
225 {
226 // Just in case the app called Destroy() *and* then deleted
227 // the socket immediately: don't leave dangling pointers.
228 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
229 if ( traits )
230 traits->RemoveFromPendingDelete(this);
231
232 // Shutdown and close the socket
233 if (!m_beingDeleted)
234 Close();
235
236 // Destroy the GSocket object
237 if (m_socket)
238 delete m_socket;
239
240 // Free the pushback buffer
241 if (m_unread)
242 free(m_unread);
243 }
244
245 bool wxSocketBase::Destroy()
246 {
247 // Delayed destruction: the socket will be deleted during the next
248 // idle loop iteration. This ensures that all pending events have
249 // been processed.
250 m_beingDeleted = true;
251
252 // Shutdown and close the socket
253 Close();
254
255 // Supress events from now on
256 Notify(false);
257
258 // schedule this object for deletion
259 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
260 if ( traits )
261 {
262 // let the traits object decide what to do with us
263 traits->ScheduleForDestroy(this);
264 }
265 else // no app or no traits
266 {
267 // in wxBase we might have no app object at all, don't leak memory
268 delete this;
269 }
270
271 return true;
272 }
273
274 // --------------------------------------------------------------------------
275 // Basic IO calls
276 // --------------------------------------------------------------------------
277
278 // The following IO operations update m_error and m_lcount:
279 // {Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard}
280 //
281 // TODO: Should Connect, Accept and AcceptWith update m_error?
282
283 bool wxSocketBase::Close()
284 {
285 // Interrupt pending waits
286 InterruptWait();
287
288 if (m_socket)
289 {
290 // Disable callbacks
291 m_socket->UnsetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
292 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG);
293
294 // Shutdown the connection
295 m_socket->Shutdown();
296 }
297
298 m_connected = false;
299 m_establishing = false;
300 return true;
301 }
302
303 wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
304 {
305 // Mask read events
306 m_reading = true;
307
308 m_lcount = _Read(buffer, nbytes);
309
310 // If in wxSOCKET_WAITALL mode, all bytes should have been read.
311 if (m_flags & wxSOCKET_WAITALL)
312 m_error = (m_lcount != nbytes);
313 else
314 m_error = (m_lcount == 0);
315
316 // Allow read events from now on
317 m_reading = false;
318
319 return *this;
320 }
321
322 wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
323 {
324 int total;
325
326 // Try the pushback buffer first
327 total = GetPushback(buffer, nbytes, false);
328 nbytes -= total;
329 buffer = (char *)buffer + total;
330
331 // Return now in one of the following cases:
332 // - the socket is invalid,
333 // - we got all the data
334 if ( !m_socket ||
335 !nbytes )
336 return total;
337
338 // Possible combinations (they are checked in this order)
339 // wxSOCKET_NOWAIT
340 // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK)
341 // wxSOCKET_BLOCK
342 // wxSOCKET_NONE
343 //
344 int ret;
345 if (m_flags & wxSOCKET_NOWAIT)
346 {
347 m_socket->SetNonBlocking(1);
348 ret = m_socket->Read((char *)buffer, nbytes);
349 m_socket->SetNonBlocking(0);
350
351 if (ret > 0)
352 total += ret;
353 }
354 else
355 {
356 bool more = true;
357
358 while (more)
359 {
360 if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() )
361 break;
362
363 ret = m_socket->Read((char *)buffer, nbytes);
364
365 if (ret > 0)
366 {
367 total += ret;
368 nbytes -= ret;
369 buffer = (char *)buffer + ret;
370 }
371
372 // If we got here and wxSOCKET_WAITALL is not set, we can leave
373 // now. Otherwise, wait until we recv all the data or until there
374 // is an error.
375 //
376 more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));
377 }
378 }
379
380 return total;
381 }
382
383 wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
384 {
385 wxUint32 len, len2, sig, total;
386 bool error;
387 int old_flags;
388 struct
389 {
390 unsigned char sig[4];
391 unsigned char len[4];
392 } msg;
393
394 // Mask read events
395 m_reading = true;
396
397 total = 0;
398 error = true;
399 old_flags = m_flags;
400 SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
401
402 if (_Read(&msg, sizeof(msg)) != sizeof(msg))
403 goto exit;
404
405 sig = (wxUint32)msg.sig[0];
406 sig |= (wxUint32)(msg.sig[1] << 8);
407 sig |= (wxUint32)(msg.sig[2] << 16);
408 sig |= (wxUint32)(msg.sig[3] << 24);
409
410 if (sig != 0xfeeddead)
411 {
412 wxLogWarning(_("wxSocket: invalid signature in ReadMsg."));
413 goto exit;
414 }
415
416 len = (wxUint32)msg.len[0];
417 len |= (wxUint32)(msg.len[1] << 8);
418 len |= (wxUint32)(msg.len[2] << 16);
419 len |= (wxUint32)(msg.len[3] << 24);
420
421 if (len > nbytes)
422 {
423 len2 = len - nbytes;
424 len = nbytes;
425 }
426 else
427 len2 = 0;
428
429 // Don't attemp to read if the msg was zero bytes long.
430 if (len)
431 {
432 total = _Read(buffer, len);
433
434 if (total != len)
435 goto exit;
436 }
437 if (len2)
438 {
439 char *discard_buffer = new char[MAX_DISCARD_SIZE];
440 long discard_len;
441
442 // NOTE: discarded bytes don't add to m_lcount.
443 do
444 {
445 discard_len = ((len2 > MAX_DISCARD_SIZE)? MAX_DISCARD_SIZE : len2);
446 discard_len = _Read(discard_buffer, (wxUint32)discard_len);
447 len2 -= (wxUint32)discard_len;
448 }
449 while ((discard_len > 0) && len2);
450
451 delete [] discard_buffer;
452
453 if (len2 != 0)
454 goto exit;
455 }
456 if (_Read(&msg, sizeof(msg)) != sizeof(msg))
457 goto exit;
458
459 sig = (wxUint32)msg.sig[0];
460 sig |= (wxUint32)(msg.sig[1] << 8);
461 sig |= (wxUint32)(msg.sig[2] << 16);
462 sig |= (wxUint32)(msg.sig[3] << 24);
463
464 if (sig != 0xdeadfeed)
465 {
466 wxLogWarning(_("wxSocket: invalid signature in ReadMsg."));
467 goto exit;
468 }
469
470 // everything was OK
471 error = false;
472
473 exit:
474 m_error = error;
475 m_lcount = total;
476 m_reading = false;
477 SetFlags(old_flags);
478
479 return *this;
480 }
481
482 wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
483 {
484 // Mask read events
485 m_reading = true;
486
487 m_lcount = _Read(buffer, nbytes);
488 Pushback(buffer, m_lcount);
489
490 // If in wxSOCKET_WAITALL mode, all bytes should have been read.
491 if (m_flags & wxSOCKET_WAITALL)
492 m_error = (m_lcount != nbytes);
493 else
494 m_error = (m_lcount == 0);
495
496 // Allow read events again
497 m_reading = false;
498
499 return *this;
500 }
501
502 wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes)
503 {
504 // Mask write events
505 m_writing = true;
506
507 m_lcount = _Write(buffer, nbytes);
508
509 // If in wxSOCKET_WAITALL mode, all bytes should have been written.
510 if (m_flags & wxSOCKET_WAITALL)
511 m_error = (m_lcount != nbytes);
512 else
513 m_error = (m_lcount == 0);
514
515 // Allow write events again
516 m_writing = false;
517
518 return *this;
519 }
520
521 wxUint32 wxSocketBase::_Write(const void *buffer, wxUint32 nbytes)
522 {
523 wxUint32 total = 0;
524
525 // If the socket is invalid or parameters are ill, return immediately
526 if (!m_socket || !buffer || !nbytes)
527 return 0;
528
529 // Possible combinations (they are checked in this order)
530 // wxSOCKET_NOWAIT
531 // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK)
532 // wxSOCKET_BLOCK
533 // wxSOCKET_NONE
534 //
535 int ret;
536 if (m_flags & wxSOCKET_NOWAIT)
537 {
538 m_socket->SetNonBlocking(1);
539 ret = m_socket->Write((const char *)buffer, nbytes);
540 m_socket->SetNonBlocking(0);
541
542 if (ret > 0)
543 total = ret;
544 }
545 else
546 {
547 bool more = true;
548
549 while (more)
550 {
551 if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForWrite() )
552 break;
553
554 ret = m_socket->Write((const char *)buffer, nbytes);
555
556 if (ret > 0)
557 {
558 total += ret;
559 nbytes -= ret;
560 buffer = (const char *)buffer + ret;
561 }
562
563 // If we got here and wxSOCKET_WAITALL is not set, we can leave
564 // now. Otherwise, wait until we send all the data or until there
565 // is an error.
566 //
567 more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));
568 }
569 }
570
571 return total;
572 }
573
574 wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes)
575 {
576 wxUint32 total;
577 bool error;
578 struct
579 {
580 unsigned char sig[4];
581 unsigned char len[4];
582 } msg;
583
584 // Mask write events
585 m_writing = true;
586
587 error = true;
588 total = 0;
589 SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
590
591 msg.sig[0] = (unsigned char) 0xad;
592 msg.sig[1] = (unsigned char) 0xde;
593 msg.sig[2] = (unsigned char) 0xed;
594 msg.sig[3] = (unsigned char) 0xfe;
595
596 msg.len[0] = (unsigned char) (nbytes & 0xff);
597 msg.len[1] = (unsigned char) ((nbytes >> 8) & 0xff);
598 msg.len[2] = (unsigned char) ((nbytes >> 16) & 0xff);
599 msg.len[3] = (unsigned char) ((nbytes >> 24) & 0xff);
600
601 if (_Write(&msg, sizeof(msg)) < sizeof(msg))
602 goto exit;
603
604 total = _Write(buffer, nbytes);
605
606 if (total < nbytes)
607 goto exit;
608
609 msg.sig[0] = (unsigned char) 0xed;
610 msg.sig[1] = (unsigned char) 0xfe;
611 msg.sig[2] = (unsigned char) 0xad;
612 msg.sig[3] = (unsigned char) 0xde;
613 msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
614
615 if ((_Write(&msg, sizeof(msg))) < sizeof(msg))
616 goto exit;
617
618 // everything was OK
619 error = false;
620
621 exit:
622 m_error = error;
623 m_lcount = total;
624 m_writing = false;
625
626 return *this;
627 }
628
629 wxSocketBase& wxSocketBase::Unread(const void *buffer, wxUint32 nbytes)
630 {
631 if (nbytes != 0)
632 Pushback(buffer, nbytes);
633
634 m_error = false;
635 m_lcount = nbytes;
636
637 return *this;
638 }
639
640 wxSocketBase& wxSocketBase::Discard()
641 {
642 char *buffer = new char[MAX_DISCARD_SIZE];
643 wxUint32 ret;
644 wxUint32 total = 0;
645
646 // Mask read events
647 m_reading = true;
648
649 SetFlags(wxSOCKET_NOWAIT);
650
651 do
652 {
653 ret = _Read(buffer, MAX_DISCARD_SIZE);
654 total += ret;
655 }
656 while (ret == MAX_DISCARD_SIZE);
657
658 delete[] buffer;
659 m_lcount = total;
660 m_error = false;
661
662 // Allow read events again
663 m_reading = false;
664
665 return *this;
666 }
667
668 // --------------------------------------------------------------------------
669 // Wait functions
670 // --------------------------------------------------------------------------
671
672 // All Wait functions poll the socket using GSocket_Select() to
673 // check for the specified combination of conditions, until one
674 // of these conditions become true, an error occurs, or the
675 // timeout elapses. The polling loop calls PROCESS_EVENTS(), so
676 // this won't block the GUI.
677
678 bool wxSocketBase::_Wait(long seconds,
679 long milliseconds,
680 wxSocketEventFlags flags)
681 {
682 GSocketEventFlags result;
683 long timeout; // in ms
684
685 // Set this to true to interrupt ongoing waits
686 m_interrupt = false;
687
688 // Check for valid socket
689 if (!m_socket)
690 return false;
691
692 // Check for valid timeout value.
693 if (seconds != -1)
694 timeout = seconds * 1000 + milliseconds;
695 else
696 timeout = m_timeout * 1000;
697
698 bool has_event_loop = wxTheApp->GetTraits() ? (wxTheApp->GetTraits()->GetSocketGUIFunctionsTable() ? true : false) : false;
699
700 // Wait in an active polling loop.
701 //
702 // NOTE: We duplicate some of the code in OnRequest, but this doesn't
703 // hurt. It has to be here because the (GSocket) event might arrive
704 // a bit delayed, and it has to be in OnRequest as well because we
705 // don't know whether the Wait functions are being used.
706 //
707 // Do this at least once (important if timeout == 0, when
708 // we are just polling). Also, if just polling, do not yield.
709
710 const wxMilliClock_t time_limit = wxGetLocalTimeMillis() + timeout;
711 bool done = false;
712 bool valid_result = false;
713
714 if (!has_event_loop)
715 {
716 // This is used to avoid a busy loop on wxBase - having a select
717 // timeout of 50 ms per iteration should be enough.
718 if (timeout > 50)
719 m_socket->SetTimeout(50);
720 else
721 m_socket->SetTimeout(timeout);
722 }
723
724 while (!done)
725 {
726 result = m_socket->Select(flags | GSOCK_LOST_FLAG);
727
728 // Incoming connection (server) or connection established (client)
729 if (result & GSOCK_CONNECTION_FLAG)
730 {
731 m_connected = true;
732 m_establishing = false;
733 valid_result = true;
734 break;
735 }
736
737 // Data available or output buffer ready
738 if ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG))
739 {
740 valid_result = true;
741 break;
742 }
743
744 // Connection lost
745 if (result & GSOCK_LOST_FLAG)
746 {
747 m_connected = false;
748 m_establishing = false;
749 valid_result = ((flags & GSOCK_LOST_FLAG) != 0);
750 break;
751 }
752
753 // Wait more?
754 long time_left = wxMilliClockToLong(time_limit - wxGetLocalTimeMillis());
755 if ((!timeout) || (time_left <= 0) || (m_interrupt))
756 done = true;
757 else
758 {
759 if (has_event_loop)
760 {
761 PROCESS_EVENTS();
762 }
763 else
764 {
765 // If there's less than 50 ms left, just call select with that timeout.
766 if (time_left < 50)
767 m_socket->SetTimeout(time_left);
768 }
769 }
770 }
771
772 // Set timeout back to original value (we overwrote it for polling)
773 if (!has_event_loop)
774 m_socket->SetTimeout(m_timeout*1000);
775
776 return valid_result;
777 }
778
779 bool wxSocketBase::Wait(long seconds, long milliseconds)
780 {
781 return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
782 GSOCK_OUTPUT_FLAG |
783 GSOCK_CONNECTION_FLAG |
784 GSOCK_LOST_FLAG);
785 }
786
787 bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
788 {
789 // Check pushback buffer before entering _Wait
790 if (m_unread)
791 return true;
792
793 // Note that GSOCK_INPUT_LOST has to be explicitly passed to
794 // _Wait because of the semantics of WaitForRead: a return
795 // value of true means that a GSocket_Read call will return
796 // immediately, not that there is actually data to read.
797
798 return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
799 GSOCK_LOST_FLAG);
800 }
801
802
803 bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
804 {
805 return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
806 }
807
808 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
809 {
810 return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG);
811 }
812
813 // --------------------------------------------------------------------------
814 // Miscellaneous
815 // --------------------------------------------------------------------------
816
817 //
818 // Get local or peer address
819 //
820
821 bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
822 {
823 GAddress *peer;
824
825 if (!m_socket)
826 return false;
827
828 peer = m_socket->GetPeer();
829
830 // copying a null address would just trigger an assert anyway
831
832 if (!peer)
833 return false;
834
835 addr_man.SetAddress(peer);
836 GAddress_destroy(peer);
837
838 return true;
839 }
840
841 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
842 {
843 GAddress *local;
844
845 if (!m_socket)
846 return false;
847
848 local = m_socket->GetLocal();
849 addr_man.SetAddress(local);
850 GAddress_destroy(local);
851
852 return true;
853 }
854
855 //
856 // Save and restore socket state
857 //
858
859 void wxSocketBase::SaveState()
860 {
861 wxSocketState *state;
862
863 state = new wxSocketState();
864
865 state->m_flags = m_flags;
866 state->m_notify = m_notify;
867 state->m_eventmask = m_eventmask;
868 state->m_clientData = m_clientData;
869
870 m_states.Append(state);
871 }
872
873 void wxSocketBase::RestoreState()
874 {
875 wxList::compatibility_iterator node;
876 wxSocketState *state;
877
878 node = m_states.GetLast();
879 if (!node)
880 return;
881
882 state = (wxSocketState *)node->GetData();
883
884 m_flags = state->m_flags;
885 m_notify = state->m_notify;
886 m_eventmask = state->m_eventmask;
887 m_clientData = state->m_clientData;
888
889 m_states.Erase(node);
890 delete state;
891 }
892
893 //
894 // Timeout and flags
895 //
896
897 void wxSocketBase::SetTimeout(long seconds)
898 {
899 m_timeout = seconds;
900
901 if (m_socket)
902 m_socket->SetTimeout(m_timeout * 1000);
903 }
904
905 void wxSocketBase::SetFlags(wxSocketFlags flags)
906 {
907 m_flags = flags;
908 }
909
910
911 // --------------------------------------------------------------------------
912 // Event handling
913 // --------------------------------------------------------------------------
914
915 // A note on how events are processed, which is probably the most
916 // difficult thing to get working right while keeping the same API
917 // and functionality for all platforms.
918 //
919 // When GSocket detects an event, it calls wx_socket_callback, which in
920 // turn just calls wxSocketBase::OnRequest in the corresponding wxSocket
921 // object. OnRequest does some housekeeping, and if the event is to be
922 // propagated to the user, it creates a new wxSocketEvent object and
923 // posts it. The event is not processed immediately, but delayed with
924 // AddPendingEvent instead. This is necessary in order to decouple the
925 // event processing from wx_socket_callback; otherwise, subsequent IO
926 // calls made from the user event handler would fail, as gtk callbacks
927 // are not reentrant.
928 //
929 // Note that, unlike events, user callbacks (now deprecated) are _not_
930 // decoupled from wx_socket_callback and thus they suffer from a variety
931 // of problems. Avoid them where possible and use events instead.
932
933 extern "C"
934 void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
935 GSocketEvent notification,
936 char *cdata)
937 {
938 wxSocketBase *sckobj = (wxSocketBase *)cdata;
939
940 sckobj->OnRequest((wxSocketNotify) notification);
941 }
942
943 void wxSocketBase::OnRequest(wxSocketNotify notification)
944 {
945 // NOTE: We duplicate some of the code in _Wait, but this doesn't
946 // hurt. It has to be here because the (GSocket) event might arrive
947 // a bit delayed, and it has to be in _Wait as well because we don't
948 // know whether the Wait functions are being used.
949
950 switch(notification)
951 {
952 case wxSOCKET_CONNECTION:
953 m_establishing = false;
954 m_connected = true;
955 break;
956
957 // If we are in the middle of a R/W operation, do not
958 // propagate events to users. Also, filter 'late' events
959 // which are no longer valid.
960
961 case wxSOCKET_INPUT:
962 if (m_reading || !m_socket->Select(GSOCK_INPUT_FLAG))
963 return;
964 break;
965
966 case wxSOCKET_OUTPUT:
967 if (m_writing || !m_socket->Select(GSOCK_OUTPUT_FLAG))
968 return;
969 break;
970
971 case wxSOCKET_LOST:
972 m_connected = false;
973 m_establishing = false;
974 break;
975
976 default:
977 break;
978 }
979
980 // Schedule the event
981
982 wxSocketEventFlags flag = 0;
983 wxUnusedVar(flag);
984 switch (notification)
985 {
986 case GSOCK_INPUT: flag = GSOCK_INPUT_FLAG; break;
987 case GSOCK_OUTPUT: flag = GSOCK_OUTPUT_FLAG; break;
988 case GSOCK_CONNECTION: flag = GSOCK_CONNECTION_FLAG; break;
989 case GSOCK_LOST: flag = GSOCK_LOST_FLAG; break;
990 default:
991 wxLogWarning(_("wxSocket: unknown event!."));
992 return;
993 }
994
995 if (((m_eventmask & flag) == flag) && m_notify)
996 {
997 if (m_handler)
998 {
999 wxSocketEvent event(m_id);
1000 event.m_event = notification;
1001 event.m_clientData = m_clientData;
1002 event.SetEventObject(this);
1003
1004 m_handler->AddPendingEvent(event);
1005 }
1006 }
1007 }
1008
1009 void wxSocketBase::Notify(bool notify)
1010 {
1011 m_notify = notify;
1012 }
1013
1014 void wxSocketBase::SetNotify(wxSocketEventFlags flags)
1015 {
1016 m_eventmask = flags;
1017 }
1018
1019 void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id)
1020 {
1021 m_handler = &handler;
1022 m_id = id;
1023 }
1024
1025 // --------------------------------------------------------------------------
1026 // Pushback buffer
1027 // --------------------------------------------------------------------------
1028
1029 void wxSocketBase::Pushback(const void *buffer, wxUint32 size)
1030 {
1031 if (!size) return;
1032
1033 if (m_unread == NULL)
1034 m_unread = malloc(size);
1035 else
1036 {
1037 void *tmp;
1038
1039 tmp = malloc(m_unrd_size + size);
1040 memcpy((char *)tmp + size, m_unread, m_unrd_size);
1041 free(m_unread);
1042
1043 m_unread = tmp;
1044 }
1045
1046 m_unrd_size += size;
1047
1048 memcpy(m_unread, buffer, size);
1049 }
1050
1051 wxUint32 wxSocketBase::GetPushback(void *buffer, wxUint32 size, bool peek)
1052 {
1053 if (!m_unrd_size)
1054 return 0;
1055
1056 if (size > (m_unrd_size-m_unrd_cur))
1057 size = m_unrd_size-m_unrd_cur;
1058
1059 memcpy(buffer, (char *)m_unread + m_unrd_cur, size);
1060
1061 if (!peek)
1062 {
1063 m_unrd_cur += size;
1064 if (m_unrd_size == m_unrd_cur)
1065 {
1066 free(m_unread);
1067 m_unread = NULL;
1068 m_unrd_size = 0;
1069 m_unrd_cur = 0;
1070 }
1071 }
1072
1073 return size;
1074 }
1075
1076
1077 // ==========================================================================
1078 // wxSocketServer
1079 // ==========================================================================
1080
1081 // --------------------------------------------------------------------------
1082 // Ctor
1083 // --------------------------------------------------------------------------
1084
1085 wxSocketServer::wxSocketServer(const wxSockAddress& addr_man,
1086 wxSocketFlags flags)
1087 : wxSocketBase(flags, wxSOCKET_SERVER)
1088 {
1089 wxLogTrace( wxTRACE_Socket, _T("Opening wxSocketServer") );
1090
1091 m_socket = GSocket_new();
1092
1093 if (!m_socket)
1094 {
1095 wxLogTrace( wxTRACE_Socket, _T("*** GSocket_new failed") );
1096 return;
1097 }
1098
1099 // Setup the socket as server
1100
1101 m_socket->SetLocal(addr_man.GetAddress());
1102
1103 if (GetFlags() & wxSOCKET_REUSEADDR) {
1104 m_socket->SetReusable();
1105 }
1106 if (GetFlags() & wxSOCKET_BROADCAST) {
1107 m_socket->SetBroadcast();
1108 }
1109 if (GetFlags() & wxSOCKET_NOBIND) {
1110 m_socket->DontDoBind();
1111 }
1112
1113 if (m_socket->SetServer() != GSOCK_NOERROR)
1114 {
1115 delete m_socket;
1116 m_socket = NULL;
1117
1118 wxLogTrace( wxTRACE_Socket, _T("*** GSocket_SetServer failed") );
1119 return;
1120 }
1121
1122 m_socket->SetTimeout(m_timeout * 1000);
1123 m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1124 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1125 wx_socket_callback, (char *)this);
1126 }
1127
1128 // --------------------------------------------------------------------------
1129 // Accept
1130 // --------------------------------------------------------------------------
1131
1132 bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait)
1133 {
1134 GSocket *child_socket;
1135
1136 if (!m_socket)
1137 return false;
1138
1139 // If wait == false, then the call should be nonblocking.
1140 // When we are finished, we put the socket to blocking mode
1141 // again.
1142
1143 if (!wait)
1144 m_socket->SetNonBlocking(1);
1145
1146 child_socket = m_socket->WaitConnection();
1147
1148 if (!wait)
1149 m_socket->SetNonBlocking(0);
1150
1151 if (!child_socket)
1152 return false;
1153
1154 sock.m_type = wxSOCKET_BASE;
1155 sock.m_socket = child_socket;
1156 sock.m_connected = true;
1157
1158 sock.m_socket->SetTimeout(sock.m_timeout * 1000);
1159 sock.m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1160 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1161 wx_socket_callback, (char *)&sock);
1162
1163 return true;
1164 }
1165
1166 wxSocketBase *wxSocketServer::Accept(bool wait)
1167 {
1168 wxSocketBase* sock = new wxSocketBase();
1169
1170 sock->SetFlags(m_flags);
1171
1172 if (!AcceptWith(*sock, wait))
1173 {
1174 sock->Destroy();
1175 sock = NULL;
1176 }
1177
1178 return sock;
1179 }
1180
1181 bool wxSocketServer::WaitForAccept(long seconds, long milliseconds)
1182 {
1183 return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
1184 }
1185
1186 bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen)
1187 {
1188 wxASSERT_MSG( m_socket, _T("Socket not initialised") );
1189
1190 if (m_socket->GetSockOpt(level, optname, optval, optlen)
1191 != GSOCK_NOERROR)
1192 {
1193 return false;
1194 }
1195 return true;
1196 }
1197
1198 bool wxSocketBase::SetOption(int level, int optname, const void *optval,
1199 int optlen)
1200 {
1201 wxASSERT_MSG( m_socket, _T("Socket not initialised") );
1202
1203 if (m_socket->SetSockOpt(level, optname, optval, optlen)
1204 != GSOCK_NOERROR)
1205 {
1206 return false;
1207 }
1208 return true;
1209 }
1210
1211 bool wxSocketBase::SetLocal(wxIPV4address& local)
1212 {
1213 GAddress* la = local.GetAddress();
1214
1215 // If the address is valid, save it for use when we call Connect
1216 if (la && la->m_addr)
1217 {
1218 m_localAddress = local;
1219
1220 return true;
1221 }
1222
1223 return false;
1224 }
1225
1226 // ==========================================================================
1227 // wxSocketClient
1228 // ==========================================================================
1229
1230 // --------------------------------------------------------------------------
1231 // Ctor and dtor
1232 // --------------------------------------------------------------------------
1233
1234 wxSocketClient::wxSocketClient(wxSocketFlags flags)
1235 : wxSocketBase(flags, wxSOCKET_CLIENT)
1236 {
1237 }
1238
1239 wxSocketClient::~wxSocketClient()
1240 {
1241 }
1242
1243 // --------------------------------------------------------------------------
1244 // Connect
1245 // --------------------------------------------------------------------------
1246
1247 bool wxSocketClient::DoConnect(wxSockAddress& addr_man, wxSockAddress* local, bool wait)
1248 {
1249 GSocketError err;
1250
1251 if (m_socket)
1252 {
1253 // Shutdown and destroy the socket
1254 Close();
1255 delete m_socket;
1256 }
1257
1258 m_socket = GSocket_new();
1259 m_connected = false;
1260 m_establishing = false;
1261
1262 if (!m_socket)
1263 return false;
1264
1265 m_socket->SetTimeout(m_timeout * 1000);
1266 m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1267 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1268 wx_socket_callback, (char *)this);
1269
1270 // If wait == false, then the call should be nonblocking.
1271 // When we are finished, we put the socket to blocking mode
1272 // again.
1273
1274 if (!wait)
1275 m_socket->SetNonBlocking(1);
1276
1277 // Reuse makes sense for clients too, if we are trying to rebind to the same port
1278 if (GetFlags() & wxSOCKET_REUSEADDR)
1279 {
1280 m_socket->SetReusable();
1281 }
1282 if (GetFlags() & wxSOCKET_BROADCAST)
1283 {
1284 m_socket->SetBroadcast();
1285 }
1286 if (GetFlags() & wxSOCKET_NOBIND)
1287 {
1288 m_socket->DontDoBind();
1289 }
1290
1291 // If no local address was passed and one has been set, use the one that was Set
1292 if (!local && m_localAddress.GetAddress())
1293 {
1294 local = &m_localAddress;
1295 }
1296
1297 // Bind to the local IP address and port, when provided
1298 if (local)
1299 {
1300 GAddress* la = local->GetAddress();
1301
1302 if (la && la->m_addr)
1303 m_socket->SetLocal(la);
1304 }
1305
1306 m_socket->SetPeer(addr_man.GetAddress());
1307 err = m_socket->Connect(GSOCK_STREAMED);
1308
1309 if (!wait)
1310 m_socket->SetNonBlocking(0);
1311
1312 if (err != GSOCK_NOERROR)
1313 {
1314 if (err == GSOCK_WOULDBLOCK)
1315 m_establishing = true;
1316
1317 return false;
1318 }
1319
1320 m_connected = true;
1321 return true;
1322 }
1323
1324 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
1325 {
1326 return (DoConnect(addr_man, NULL, wait));
1327 }
1328
1329 bool wxSocketClient::Connect(wxSockAddress& addr_man, wxSockAddress& local, bool wait)
1330 {
1331 return (DoConnect(addr_man, &local, wait));
1332 }
1333
1334 bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
1335 {
1336 if (m_connected) // Already connected
1337 return true;
1338
1339 if (!m_establishing || !m_socket) // No connection in progress
1340 return false;
1341
1342 return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG |
1343 GSOCK_LOST_FLAG);
1344 }
1345
1346 // ==========================================================================
1347 // wxDatagramSocket
1348 // ==========================================================================
1349
1350 /* NOTE: experimental stuff - might change */
1351
1352 wxDatagramSocket::wxDatagramSocket( const wxSockAddress& addr,
1353 wxSocketFlags flags )
1354 : wxSocketBase( flags, wxSOCKET_DATAGRAM )
1355 {
1356 // Create the socket
1357 m_socket = GSocket_new();
1358
1359 if (!m_socket)
1360 {
1361 wxFAIL_MSG( _T("datagram socket not new'd") );
1362 return;
1363 }
1364 // Setup the socket as non connection oriented
1365 m_socket->SetLocal(addr.GetAddress());
1366 if (flags & wxSOCKET_REUSEADDR)
1367 {
1368 m_socket->SetReusable();
1369 }
1370 if (GetFlags() & wxSOCKET_BROADCAST)
1371 {
1372 m_socket->SetBroadcast();
1373 }
1374 if (GetFlags() & wxSOCKET_NOBIND)
1375 {
1376 m_socket->DontDoBind();
1377 }
1378 if ( m_socket->SetNonOriented() != GSOCK_NOERROR )
1379 {
1380 delete m_socket;
1381 m_socket = NULL;
1382 return;
1383 }
1384
1385 // Initialize all stuff
1386 m_connected = false;
1387 m_establishing = false;
1388 m_socket->SetTimeout( m_timeout );
1389 m_socket->SetCallback( GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1390 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1391 wx_socket_callback, (char*)this );
1392 }
1393
1394 wxDatagramSocket& wxDatagramSocket::RecvFrom( wxSockAddress& addr,
1395 void* buf,
1396 wxUint32 nBytes )
1397 {
1398 Read(buf, nBytes);
1399 GetPeer(addr);
1400 return (*this);
1401 }
1402
1403 wxDatagramSocket& wxDatagramSocket::SendTo( const wxSockAddress& addr,
1404 const void* buf,
1405 wxUint32 nBytes )
1406 {
1407 wxASSERT_MSG( m_socket, _T("Socket not initialised") );
1408
1409 m_socket->SetPeer(addr.GetAddress());
1410 Write(buf, nBytes);
1411 return (*this);
1412 }
1413
1414 // ==========================================================================
1415 // wxSocketModule
1416 // ==========================================================================
1417
1418 class wxSocketModule : public wxModule
1419 {
1420 public:
1421 virtual bool OnInit()
1422 {
1423 // wxSocketBase will call GSocket_Init() itself when/if needed
1424 return true;
1425 }
1426
1427 virtual void OnExit()
1428 {
1429 if ( wxSocketBase::IsInitialized() )
1430 wxSocketBase::Shutdown();
1431 }
1432
1433 private:
1434 DECLARE_DYNAMIC_CLASS(wxSocketModule)
1435 };
1436
1437 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
1438
1439 #endif
1440 // wxUSE_SOCKETS