]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/mac/carbon/cfsocket.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 licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #include "wx/wxprec.h" | |
13 | ||
14 | #ifdef __BORLANDC__ | |
15 | #pragma hdrstop | |
16 | #endif | |
17 | ||
18 | #if wxUSE_SOCKETS | |
19 | ||
20 | #include "wx/socket.h" | |
21 | ||
22 | #ifndef WX_PRECOMP | |
23 | #include "wx/object.h" | |
24 | #include "wx/string.h" | |
25 | #include "wx/intl.h" | |
26 | #include "wx/log.h" | |
27 | #include "wx/event.h" | |
28 | #include "wx/app.h" | |
29 | #include "wx/utils.h" | |
30 | #include "wx/timer.h" | |
31 | #include "wx/module.h" | |
32 | #endif | |
33 | ||
34 | #include "wx/apptrait.h" | |
35 | ||
36 | #include "wx/sckaddr.h" | |
37 | #include "wx/mac/carbon/private.h" | |
38 | ||
39 | #include <sys/socket.h> | |
40 | #include <netinet/in.h> | |
41 | #include <arpa/inet.h> | |
42 | #include <netdb.h> | |
43 | ||
44 | #define HAVE_INET_ATON | |
45 | ||
46 | // DLL options compatibility check: | |
47 | #include "wx/build.h" | |
48 | ||
49 | WX_CHECK_BUILD_OPTIONS("wxNet") | |
50 | ||
51 | ||
52 | // discard buffer | |
53 | #define MAX_DISCARD_SIZE (10 * 1024) | |
54 | ||
55 | #ifndef INVALID_SOCKET | |
56 | #define INVALID_SOCKET -1 | |
57 | #endif | |
58 | ||
59 | // what to do within waits: we have 2 cases: from the main thread itself we | |
60 | // have to call wxYield() to let the events (including the GUI events and the | |
61 | // low-level (not wxWidgets) events from GSocket) be processed. From another | |
62 | // thread it is enough to just call wxThread::Yield() which will give away the | |
63 | // rest of our time slice: the explanation is that the events will be processed | |
64 | // by the main thread anyhow, without calling wxYield(), but we don't want to | |
65 | // eat the CPU time uselessly while sitting in the loop waiting for the data | |
66 | #if wxUSE_THREADS | |
67 | #define PROCESS_EVENTS() \ | |
68 | { \ | |
69 | if ( wxThread::IsMain() ) \ | |
70 | wxYield(); \ | |
71 | else \ | |
72 | wxThread::Yield(); \ | |
73 | } | |
74 | #else // !wxUSE_THREADS | |
75 | #define PROCESS_EVENTS() wxYield() | |
76 | #endif // wxUSE_THREADS/!wxUSE_THREADS | |
77 | ||
78 | #define wxTRACE_Socket _T("wxSocket") | |
79 | ||
80 | ||
81 | IMPLEMENT_CLASS(wxSocketBase, wxObject) | |
82 | IMPLEMENT_CLASS(wxSocketServer, wxSocketBase) | |
83 | IMPLEMENT_CLASS(wxSocketClient, wxSocketBase) | |
84 | IMPLEMENT_CLASS(wxDatagramSocket, wxSocketBase) | |
85 | IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent) | |
86 | ||
87 | // -------------------------------------------------------------------------- | |
88 | // private classes | |
89 | // -------------------------------------------------------------------------- | |
90 | ||
91 | class wxSocketState : public wxObject | |
92 | { | |
93 | public: | |
94 | wxSocketFlags m_flags; | |
95 | wxSocketEventFlags m_eventmask; | |
96 | bool m_notify; | |
97 | void *m_clientData; | |
98 | ||
99 | public: | |
100 | wxSocketState() : wxObject() {} | |
101 | ||
102 | DECLARE_NO_COPY_CLASS(wxSocketState) | |
103 | }; | |
104 | ||
105 | struct _GSocket | |
106 | { | |
107 | CFSocketNativeHandle m_fd; | |
108 | GAddress *m_local; | |
109 | GAddress *m_peer; | |
110 | GSocketError m_error; | |
111 | ||
112 | int m_non_blocking; | |
113 | int m_server; | |
114 | int m_stream; | |
115 | int m_oriented; | |
116 | int m_establishing; | |
117 | unsigned long m_timeout; | |
118 | ||
119 | // Callbacks | |
120 | GSocketEventFlags m_detected; | |
121 | GSocketCallback m_cbacks[GSOCK_MAX_EVENT]; | |
122 | char *m_data[GSOCK_MAX_EVENT]; | |
123 | ||
124 | CFSocketRef m_cfSocket; | |
125 | CFRunLoopSourceRef m_runLoopSource; | |
126 | CFReadStreamRef m_readStream ; | |
127 | CFWriteStreamRef m_writeStream ; | |
128 | }; | |
129 | ||
130 | struct _GAddress | |
131 | { | |
132 | struct sockaddr *m_addr; | |
133 | size_t m_len; | |
134 | ||
135 | GAddressType m_family; | |
136 | int m_realfamily; | |
137 | ||
138 | GSocketError m_error; | |
139 | int somethingElse ; | |
140 | }; | |
141 | ||
142 | void wxMacCFSocketCallback(CFSocketRef s, CFSocketCallBackType callbackType, | |
143 | CFDataRef address, const void* data, void* info) ; | |
144 | void _GSocket_Enable(GSocket *socket, GSocketEvent event) ; | |
145 | void _GSocket_Disable(GSocket *socket, GSocketEvent event) ; | |
146 | ||
147 | // ========================================================================== | |
148 | // wxSocketBase | |
149 | // ========================================================================== | |
150 | ||
151 | // -------------------------------------------------------------------------- | |
152 | // Initialization and shutdown | |
153 | // -------------------------------------------------------------------------- | |
154 | ||
155 | // FIXME-MT: all this is MT-unsafe, of course, we should protect all accesses | |
156 | // to m_countInit with a crit section | |
157 | size_t wxSocketBase::m_countInit = 0; | |
158 | ||
159 | bool wxSocketBase::IsInitialized() | |
160 | { | |
161 | return m_countInit > 0; | |
162 | } | |
163 | ||
164 | bool wxSocketBase::Initialize() | |
165 | { | |
166 | if ( !m_countInit++ ) | |
167 | { | |
168 | #if 0 | |
169 | wxAppTraits *traits = wxAppConsole::GetInstance() ? | |
170 | wxAppConsole::GetInstance()->GetTraits() : NULL; | |
171 | GSocketGUIFunctionsTable *functions = | |
172 | traits ? traits->GetSocketGUIFunctionsTable() : NULL; | |
173 | GSocket_SetGUIFunctions(functions); | |
174 | ||
175 | if ( !GSocket_Init() ) | |
176 | { | |
177 | m_countInit--; | |
178 | ||
179 | return false; | |
180 | } | |
181 | #endif | |
182 | } | |
183 | ||
184 | return true; | |
185 | } | |
186 | ||
187 | void wxSocketBase::Shutdown() | |
188 | { | |
189 | // we should be initialized | |
190 | wxASSERT_MSG( m_countInit, wxT("extra call to Shutdown()") ); | |
191 | if ( !--m_countInit ) | |
192 | { | |
193 | #if 0 | |
194 | GSocket_Cleanup(); | |
195 | #endif | |
196 | } | |
197 | } | |
198 | ||
199 | // -------------------------------------------------------------------------- | |
200 | // Ctor and dtor | |
201 | // -------------------------------------------------------------------------- | |
202 | ||
203 | void wxSocketBase::Init() | |
204 | { | |
205 | m_socket = NULL; | |
206 | m_type = wxSOCKET_UNINIT; | |
207 | ||
208 | // state | |
209 | m_flags = 0; | |
210 | m_connected = | |
211 | m_establishing = | |
212 | m_reading = | |
213 | m_writing = | |
214 | m_error = false; | |
215 | m_lcount = 0; | |
216 | m_timeout = 600; | |
217 | m_beingDeleted = false; | |
218 | ||
219 | // pushback buffer | |
220 | m_unread = NULL; | |
221 | m_unrd_size = 0; | |
222 | m_unrd_cur = 0; | |
223 | ||
224 | // events | |
225 | m_id = -1; | |
226 | m_handler = NULL; | |
227 | m_clientData = NULL; | |
228 | m_notify = false; | |
229 | m_eventmask = 0; | |
230 | ||
231 | if ( !IsInitialized() ) | |
232 | { | |
233 | // this Initialize() will be undone by wxSocketModule::OnExit(), all the | |
234 | // other calls to it should be matched by a call to Shutdown() | |
235 | Initialize(); | |
236 | } | |
237 | } | |
238 | ||
239 | wxSocketBase::wxSocketBase() | |
240 | { | |
241 | Init(); | |
242 | } | |
243 | ||
244 | wxSocketBase::wxSocketBase( wxSocketFlags flags, wxSocketType type) | |
245 | { | |
246 | Init(); | |
247 | ||
248 | m_flags = flags; | |
249 | m_type = type; | |
250 | } | |
251 | ||
252 | wxSocketBase::~wxSocketBase() | |
253 | { | |
254 | // Just in case the app called Destroy() *and* then deleted | |
255 | // the socket immediately: don't leave dangling pointers. | |
256 | wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; | |
257 | if ( traits ) | |
258 | traits->RemoveFromPendingDelete(this); | |
259 | ||
260 | // Shutdown and close the socket | |
261 | if (!m_beingDeleted) | |
262 | Close(); | |
263 | ||
264 | // Destroy the GSocket object | |
265 | if (m_socket) | |
266 | { | |
267 | GSocket_destroy(m_socket); | |
268 | } | |
269 | ||
270 | // Free the pushback buffer | |
271 | if (m_unread) | |
272 | free(m_unread); | |
273 | } | |
274 | ||
275 | bool wxSocketBase::Destroy() | |
276 | { | |
277 | // Delayed destruction: the socket will be deleted during the next | |
278 | // idle loop iteration. This ensures that all pending events have | |
279 | // been processed. | |
280 | m_beingDeleted = true; | |
281 | ||
282 | // Shutdown and close the socket | |
283 | Close(); | |
284 | ||
285 | // Supress events from now on | |
286 | Notify(false); | |
287 | ||
288 | // schedule this object for deletion | |
289 | wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; | |
290 | if ( traits ) | |
291 | { | |
292 | // let the traits object decide what to do with us | |
293 | traits->ScheduleForDestroy(this); | |
294 | } | |
295 | else // no app or no traits | |
296 | { | |
297 | // in wxBase we might have no app object at all, don't leak memory | |
298 | delete this; | |
299 | } | |
300 | ||
301 | return true; | |
302 | } | |
303 | ||
304 | // -------------------------------------------------------------------------- | |
305 | // Basic IO calls | |
306 | // -------------------------------------------------------------------------- | |
307 | ||
308 | // The following IO operations update m_error and m_lcount: | |
309 | // {Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard} | |
310 | // | |
311 | // TODO: Should Connect, Accept and AcceptWith update m_error? | |
312 | ||
313 | bool wxSocketBase::Close() | |
314 | { | |
315 | // Interrupt pending waits | |
316 | InterruptWait(); | |
317 | ||
318 | if (m_socket) | |
319 | GSocket_Shutdown(m_socket); | |
320 | ||
321 | m_connected = false; | |
322 | m_establishing = false; | |
323 | ||
324 | return true; | |
325 | } | |
326 | ||
327 | wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes) | |
328 | { | |
329 | // Mask read events | |
330 | m_reading = true; | |
331 | ||
332 | m_lcount = _Read(buffer, nbytes); | |
333 | ||
334 | // If in wxSOCKET_WAITALL mode, all bytes should have been read. | |
335 | if (m_flags & wxSOCKET_WAITALL) | |
336 | m_error = (m_lcount != nbytes); | |
337 | else | |
338 | m_error = (m_lcount == 0); | |
339 | ||
340 | // Allow read events from now on | |
341 | m_reading = false; | |
342 | ||
343 | return *this; | |
344 | } | |
345 | ||
346 | wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes) | |
347 | { | |
348 | int total = 0; | |
349 | ||
350 | // Try the pushback buffer first | |
351 | total = GetPushback(buffer, nbytes, false); | |
352 | nbytes -= total; | |
353 | buffer = (char *)buffer + total; | |
354 | ||
355 | // Return now in one of the following cases: | |
356 | // - the socket is invalid, | |
357 | // - we got all the data, | |
358 | // - we got *some* data and we are not using wxSOCKET_WAITALL. | |
359 | if ( !m_socket || | |
360 | !nbytes || | |
361 | ((total != 0) && !(m_flags & wxSOCKET_WAITALL)) ) | |
362 | return total; | |
363 | ||
364 | // Possible combinations (they are checked in this order) | |
365 | // wxSOCKET_NOWAIT | |
366 | // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK) | |
367 | // wxSOCKET_BLOCK | |
368 | // wxSOCKET_NONE | |
369 | // | |
370 | ||
371 | int ret; | |
372 | if (m_flags & wxSOCKET_NOWAIT) | |
373 | { | |
374 | GSocket_SetNonBlocking(m_socket, 1); | |
375 | ret = GSocket_Read(m_socket, (char *)buffer, nbytes); | |
376 | GSocket_SetNonBlocking(m_socket, 0); | |
377 | ||
378 | if (ret > 0) | |
379 | total += ret; | |
380 | } | |
381 | else | |
382 | { | |
383 | bool more = true; | |
384 | ||
385 | while (more) | |
386 | { | |
387 | if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() ) | |
388 | break; | |
389 | ||
390 | ret = GSocket_Read(m_socket, (char *)buffer, nbytes); | |
391 | ||
392 | if (ret > 0) | |
393 | { | |
394 | total += ret; | |
395 | nbytes -= ret; | |
396 | buffer = (char *)buffer + ret; | |
397 | } | |
398 | ||
399 | // If we got here and wxSOCKET_WAITALL is not set, we can leave | |
400 | // now. Otherwise, wait until we recv all the data or until there | |
401 | // is an error. | |
402 | // | |
403 | more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL)); | |
404 | } | |
405 | } | |
406 | ||
407 | return total; | |
408 | } | |
409 | ||
410 | wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes) | |
411 | { | |
412 | wxUint32 len, len2, sig, total; | |
413 | bool error; | |
414 | int old_flags; | |
415 | struct | |
416 | { | |
417 | unsigned char sig[4]; | |
418 | unsigned char len[4]; | |
419 | } | |
420 | msg; | |
421 | ||
422 | // Mask read events | |
423 | m_reading = true; | |
424 | ||
425 | total = 0; | |
426 | error = true; | |
427 | old_flags = m_flags; | |
428 | SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL); | |
429 | ||
430 | if (_Read(&msg, sizeof(msg)) != sizeof(msg)) | |
431 | goto exit; | |
432 | ||
433 | sig = (wxUint32)msg.sig[0]; | |
434 | sig |= (wxUint32)(msg.sig[1] << 8); | |
435 | sig |= (wxUint32)(msg.sig[2] << 16); | |
436 | sig |= (wxUint32)(msg.sig[3] << 24); | |
437 | ||
438 | if (sig != 0xfeeddead) | |
439 | { | |
440 | wxLogWarning( wxT("wxSocket: invalid signature in ReadMsg.") ); | |
441 | goto exit; | |
442 | } | |
443 | ||
444 | len = (wxUint32)msg.len[0]; | |
445 | len |= (wxUint32)(msg.len[1] << 8); | |
446 | len |= (wxUint32)(msg.len[2] << 16); | |
447 | len |= (wxUint32)(msg.len[3] << 24); | |
448 | ||
449 | if (len > nbytes) | |
450 | { | |
451 | len2 = len - nbytes; | |
452 | len = nbytes; | |
453 | } | |
454 | else | |
455 | len2 = 0; | |
456 | ||
457 | // Don't attemp to read if the msg was zero bytes long. | |
458 | if (len) | |
459 | { | |
460 | total = _Read(buffer, len); | |
461 | ||
462 | if (total != len) | |
463 | goto exit; | |
464 | } | |
465 | if (len2) | |
466 | { | |
467 | char *discard_buffer = new char[MAX_DISCARD_SIZE]; | |
468 | long discard_len; | |
469 | ||
470 | // NOTE: discarded bytes don't add to m_lcount. | |
471 | do | |
472 | { | |
473 | discard_len = ((len2 > MAX_DISCARD_SIZE)? MAX_DISCARD_SIZE : len2); | |
474 | discard_len = _Read(discard_buffer, (wxUint32)discard_len); | |
475 | len2 -= (wxUint32)discard_len; | |
476 | } | |
477 | while ((discard_len > 0) && len2); | |
478 | ||
479 | delete [] discard_buffer; | |
480 | ||
481 | if (len2 != 0) | |
482 | goto exit; | |
483 | } | |
484 | if (_Read(&msg, sizeof(msg)) != sizeof(msg)) | |
485 | goto exit; | |
486 | ||
487 | sig = (wxUint32)msg.sig[0]; | |
488 | sig |= (wxUint32)(msg.sig[1] << 8); | |
489 | sig |= (wxUint32)(msg.sig[2] << 16); | |
490 | sig |= (wxUint32)(msg.sig[3] << 24); | |
491 | ||
492 | if (sig != 0xdeadfeed) | |
493 | { | |
494 | wxLogWarning( wxT("wxSocket: invalid signature in ReadMsg.") ); | |
495 | goto exit; | |
496 | } | |
497 | ||
498 | // everything was OK | |
499 | error = false; | |
500 | ||
501 | exit: | |
502 | m_error = error; | |
503 | m_lcount = total; | |
504 | m_reading = false; | |
505 | SetFlags(old_flags); | |
506 | ||
507 | return *this; | |
508 | } | |
509 | ||
510 | wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes) | |
511 | { | |
512 | // Mask read events | |
513 | m_reading = true; | |
514 | ||
515 | m_lcount = _Read(buffer, nbytes); | |
516 | Pushback(buffer, m_lcount); | |
517 | ||
518 | // If in wxSOCKET_WAITALL mode, all bytes should have been read. | |
519 | if (m_flags & wxSOCKET_WAITALL) | |
520 | m_error = (m_lcount != nbytes); | |
521 | else | |
522 | m_error = (m_lcount == 0); | |
523 | ||
524 | // Allow read events again | |
525 | m_reading = false; | |
526 | ||
527 | return *this; | |
528 | } | |
529 | ||
530 | wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes) | |
531 | { | |
532 | // Mask write events | |
533 | m_writing = true; | |
534 | ||
535 | m_lcount = _Write(buffer, nbytes); | |
536 | ||
537 | // If in wxSOCKET_WAITALL mode, all bytes should have been written. | |
538 | if (m_flags & wxSOCKET_WAITALL) | |
539 | m_error = (m_lcount != nbytes); | |
540 | else | |
541 | m_error = (m_lcount == 0); | |
542 | ||
543 | // Allow write events again | |
544 | m_writing = false; | |
545 | ||
546 | return *this; | |
547 | } | |
548 | ||
549 | wxUint32 wxSocketBase::_Write(const void *buffer, wxUint32 nbytes) | |
550 | { | |
551 | wxUint32 total = 0; | |
552 | ||
553 | // If the socket is invalid or parameters are ill, return immediately | |
554 | if (!m_socket || !buffer || !nbytes) | |
555 | return 0; | |
556 | ||
557 | // Possible combinations (they are checked in this order) | |
558 | // wxSOCKET_NOWAIT | |
559 | // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK) | |
560 | // wxSOCKET_BLOCK | |
561 | // wxSOCKET_NONE | |
562 | // | |
563 | int ret; | |
564 | if (m_flags & wxSOCKET_NOWAIT) | |
565 | { | |
566 | GSocket_SetNonBlocking(m_socket, 1); | |
567 | ret = GSocket_Write(m_socket, (const char *)buffer, nbytes); | |
568 | GSocket_SetNonBlocking(m_socket, 0); | |
569 | ||
570 | if (ret > 0) | |
571 | total = ret; | |
572 | } | |
573 | else | |
574 | { | |
575 | bool more = true; | |
576 | ||
577 | while (more) | |
578 | { | |
579 | if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForWrite() ) | |
580 | break; | |
581 | ||
582 | ret = GSocket_Write(m_socket, (const char *)buffer, nbytes); | |
583 | ||
584 | if (ret > 0) | |
585 | { | |
586 | total += ret; | |
587 | nbytes -= ret; | |
588 | buffer = (const char *)buffer + ret; | |
589 | } | |
590 | ||
591 | // If we got here and wxSOCKET_WAITALL is not set, we can leave | |
592 | // now. Otherwise, wait until we send all the data or until there | |
593 | // is an error. | |
594 | // | |
595 | more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL)); | |
596 | } | |
597 | } | |
598 | ||
599 | return total; | |
600 | } | |
601 | ||
602 | wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes) | |
603 | { | |
604 | wxUint32 total; | |
605 | bool error; | |
606 | struct | |
607 | { | |
608 | unsigned char sig[4]; | |
609 | unsigned char len[4]; | |
610 | } | |
611 | msg; | |
612 | ||
613 | // Mask write events | |
614 | m_writing = true; | |
615 | ||
616 | error = true; | |
617 | total = 0; | |
618 | SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL); | |
619 | ||
620 | msg.sig[0] = (unsigned char) 0xad; | |
621 | msg.sig[1] = (unsigned char) 0xde; | |
622 | msg.sig[2] = (unsigned char) 0xed; | |
623 | msg.sig[3] = (unsigned char) 0xfe; | |
624 | ||
625 | msg.len[0] = (unsigned char) (nbytes & 0xff); | |
626 | msg.len[1] = (unsigned char) ((nbytes >> 8) & 0xff); | |
627 | msg.len[2] = (unsigned char) ((nbytes >> 16) & 0xff); | |
628 | msg.len[3] = (unsigned char) ((nbytes >> 24) & 0xff); | |
629 | ||
630 | if (_Write(&msg, sizeof(msg)) < sizeof(msg)) | |
631 | goto exit; | |
632 | ||
633 | total = _Write(buffer, nbytes); | |
634 | ||
635 | if (total < nbytes) | |
636 | goto exit; | |
637 | ||
638 | msg.sig[0] = (unsigned char) 0xed; | |
639 | msg.sig[1] = (unsigned char) 0xfe; | |
640 | msg.sig[2] = (unsigned char) 0xad; | |
641 | msg.sig[3] = (unsigned char) 0xde; | |
642 | msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0; | |
643 | ||
644 | if ((_Write(&msg, sizeof(msg))) < sizeof(msg)) | |
645 | goto exit; | |
646 | ||
647 | // everything was OK | |
648 | error = false; | |
649 | ||
650 | exit: | |
651 | m_error = error; | |
652 | m_lcount = total; | |
653 | m_writing = false; | |
654 | ||
655 | return *this; | |
656 | } | |
657 | ||
658 | wxSocketBase& wxSocketBase::Unread(const void *buffer, wxUint32 nbytes) | |
659 | { | |
660 | if (nbytes != 0) | |
661 | Pushback(buffer, nbytes); | |
662 | ||
663 | m_error = false; | |
664 | m_lcount = nbytes; | |
665 | ||
666 | return *this; | |
667 | } | |
668 | ||
669 | wxSocketBase& wxSocketBase::Discard() | |
670 | { | |
671 | char *buffer = new char[MAX_DISCARD_SIZE]; | |
672 | wxUint32 ret; | |
673 | wxUint32 total = 0; | |
674 | ||
675 | // Mask read events | |
676 | m_reading = true; | |
677 | ||
678 | SetFlags(wxSOCKET_NOWAIT); | |
679 | ||
680 | do | |
681 | { | |
682 | ret = _Read(buffer, MAX_DISCARD_SIZE); | |
683 | total += ret; | |
684 | } | |
685 | while (ret == MAX_DISCARD_SIZE); | |
686 | ||
687 | delete[] buffer; | |
688 | m_lcount = total; | |
689 | m_error = false; | |
690 | ||
691 | // Allow read events again | |
692 | m_reading = false; | |
693 | ||
694 | return *this; | |
695 | } | |
696 | ||
697 | // -------------------------------------------------------------------------- | |
698 | // Wait functions | |
699 | // -------------------------------------------------------------------------- | |
700 | ||
701 | // All Wait functions poll the socket using GSocket_Select() to | |
702 | // check for the specified combination of conditions, until one | |
703 | // of these conditions become true, an error occurs, or the | |
704 | // timeout elapses. The polling loop calls PROCESS_EVENTS(), so | |
705 | // this won't block the GUI. | |
706 | ||
707 | bool wxSocketBase::_Wait(long seconds, | |
708 | long milliseconds, | |
709 | wxSocketEventFlags flags) | |
710 | { | |
711 | GSocketEventFlags result; | |
712 | long timeout; | |
713 | ||
714 | // Set this to true to interrupt ongoing waits | |
715 | m_interrupt = false; | |
716 | ||
717 | // Check for valid socket | |
718 | if (!m_socket) | |
719 | return false; | |
720 | ||
721 | // Check for valid timeout value. | |
722 | if (seconds != -1) | |
723 | timeout = seconds * 1000 + milliseconds; | |
724 | else | |
725 | timeout = m_timeout * 1000; | |
726 | ||
727 | #if !defined(wxUSE_GUI) || !wxUSE_GUI | |
728 | GSocket_SetTimeout(m_socket, timeout); | |
729 | #endif | |
730 | ||
731 | // Wait in an active polling loop. | |
732 | // | |
733 | // NOTE: We duplicate some of the code in OnRequest, but this doesn't | |
734 | // hurt. It has to be here because the (GSocket) event might arrive | |
735 | // a bit delayed, and it has to be in OnRequest as well because we | |
736 | // don't know whether the Wait functions are being used. | |
737 | // | |
738 | // Do this at least once (important if timeout == 0, when | |
739 | // we are just polling). Also, if just polling, do not yield. | |
740 | ||
741 | wxStopWatch chrono; | |
742 | bool done = false; | |
743 | ||
744 | while (!done) | |
745 | { | |
746 | result = GSocket_Select(m_socket, flags | GSOCK_LOST_FLAG); | |
747 | ||
748 | // Incoming connection (server) or connection established (client) | |
749 | if (result & GSOCK_CONNECTION_FLAG) | |
750 | { | |
751 | m_connected = true; | |
752 | m_establishing = false; | |
753 | ||
754 | return true; | |
755 | } | |
756 | ||
757 | // Data available or output buffer ready | |
758 | if ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG)) | |
759 | { | |
760 | return true; | |
761 | } | |
762 | ||
763 | // Connection lost | |
764 | if (result & GSOCK_LOST_FLAG) | |
765 | { | |
766 | m_connected = false; | |
767 | m_establishing = false; | |
768 | ||
769 | return (flags & GSOCK_LOST_FLAG) != 0; | |
770 | } | |
771 | ||
772 | // Wait more? | |
773 | if ((!timeout) || (chrono.Time() > timeout) || (m_interrupt)) | |
774 | done = true; | |
775 | else | |
776 | PROCESS_EVENTS(); | |
777 | } | |
778 | ||
779 | return false; | |
780 | } | |
781 | ||
782 | bool wxSocketBase::Wait(long seconds, long milliseconds) | |
783 | { | |
784 | return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG | | |
785 | GSOCK_OUTPUT_FLAG | | |
786 | GSOCK_CONNECTION_FLAG | | |
787 | GSOCK_LOST_FLAG); | |
788 | } | |
789 | ||
790 | bool wxSocketBase::WaitForRead(long seconds, long milliseconds) | |
791 | { | |
792 | // Check pushback buffer before entering _Wait | |
793 | if (m_unread) | |
794 | return true; | |
795 | ||
796 | // Note that GSOCK_INPUT_LOST has to be explicitly passed to | |
797 | // _Wait becuase of the semantics of WaitForRead: a return | |
798 | // value of true means that a GSocket_Read call will return | |
799 | // immediately, not that there is actually data to read. | |
800 | ||
801 | return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG); | |
802 | } | |
803 | ||
804 | bool wxSocketBase::WaitForWrite(long seconds, long milliseconds) | |
805 | { | |
806 | return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG); | |
807 | } | |
808 | ||
809 | bool wxSocketBase::WaitForLost(long seconds, long milliseconds) | |
810 | { | |
811 | return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG); | |
812 | } | |
813 | ||
814 | // -------------------------------------------------------------------------- | |
815 | // Miscellaneous | |
816 | // -------------------------------------------------------------------------- | |
817 | ||
818 | // | |
819 | // Get local or peer address | |
820 | // | |
821 | ||
822 | bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const | |
823 | { | |
824 | GAddress *peer; | |
825 | ||
826 | if (!m_socket) | |
827 | return false; | |
828 | ||
829 | peer = GSocket_GetPeer(m_socket); | |
830 | ||
831 | // copying a null address would just trigger an assert anyway | |
832 | ||
833 | if (!peer) | |
834 | return false; | |
835 | ||
836 | addr_man.SetAddress(peer); | |
837 | GAddress_destroy(peer); | |
838 | ||
839 | return true; | |
840 | } | |
841 | ||
842 | bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const | |
843 | { | |
844 | #if 0 | |
845 | GAddress *local; | |
846 | ||
847 | if (!m_socket) | |
848 | return false; | |
849 | ||
850 | local = GSocket_GetLocal(m_socket); | |
851 | addr_man.SetAddress(local); | |
852 | GAddress_destroy(local); | |
853 | #endif | |
854 | ||
855 | return true; | |
856 | } | |
857 | ||
858 | // | |
859 | // Save and restore socket state | |
860 | // | |
861 | ||
862 | void wxSocketBase::SaveState() | |
863 | { | |
864 | wxSocketState *state; | |
865 | ||
866 | state = new wxSocketState(); | |
867 | ||
868 | state->m_flags = m_flags; | |
869 | state->m_notify = m_notify; | |
870 | state->m_eventmask = m_eventmask; | |
871 | state->m_clientData = m_clientData; | |
872 | ||
873 | m_states.Append(state); | |
874 | } | |
875 | ||
876 | void wxSocketBase::RestoreState() | |
877 | { | |
878 | wxList::compatibility_iterator node; | |
879 | wxSocketState *state; | |
880 | ||
881 | node = m_states.GetLast(); | |
882 | if (!node) | |
883 | return; | |
884 | ||
885 | state = (wxSocketState *)node->GetData(); | |
886 | ||
887 | m_flags = state->m_flags; | |
888 | m_notify = state->m_notify; | |
889 | m_eventmask = state->m_eventmask; | |
890 | m_clientData = state->m_clientData; | |
891 | ||
892 | m_states.Erase(node); | |
893 | delete state; | |
894 | } | |
895 | ||
896 | // | |
897 | // Timeout and flags | |
898 | // | |
899 | ||
900 | void wxSocketBase::SetTimeout(long seconds) | |
901 | { | |
902 | m_timeout = seconds; | |
903 | ||
904 | #if 0 | |
905 | if (m_socket) | |
906 | GSocket_SetTimeout(m_socket, m_timeout * 1000); | |
907 | #endif | |
908 | } | |
909 | ||
910 | void wxSocketBase::SetFlags(wxSocketFlags flags) | |
911 | { | |
912 | m_flags = flags; | |
913 | } | |
914 | ||
915 | ||
916 | // -------------------------------------------------------------------------- | |
917 | // Event handling | |
918 | // -------------------------------------------------------------------------- | |
919 | ||
920 | // A note on how events are processed, which is probably the most | |
921 | // difficult thing to get working right while keeping the same API | |
922 | // and functionality for all platforms. | |
923 | // | |
924 | // When GSocket detects an event, it calls wx_socket_callback, which in | |
925 | // turn just calls wxSocketBase::OnRequest in the corresponding wxSocket | |
926 | // object. OnRequest does some housekeeping, and if the event is to be | |
927 | // propagated to the user, it creates a new wxSocketEvent object and | |
928 | // posts it. The event is not processed immediately, but delayed with | |
929 | // AddPendingEvent instead. This is necessary in order to decouple the | |
930 | // event processing from wx_socket_callback; otherwise, subsequent IO | |
931 | // calls made from the user event handler would fail, as gtk callbacks | |
932 | // are not reentrant. | |
933 | // | |
934 | // Note that, unlike events, user callbacks (now deprecated) are _not_ | |
935 | // decoupled from wx_socket_callback and thus they suffer from a variety | |
936 | // of problems. Avoid them where possible and use events instead. | |
937 | ||
938 | extern "C" | |
939 | void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket), | |
940 | GSocketEvent notification, | |
941 | char *cdata) | |
942 | { | |
943 | wxSocketBase *sckobj = (wxSocketBase *)cdata; | |
944 | ||
945 | sckobj->OnRequest((wxSocketNotify) notification); | |
946 | } | |
947 | ||
948 | void wxSocketBase::OnRequest(wxSocketNotify notification) | |
949 | { | |
950 | // NOTE: We duplicate some of the code in _Wait, but this doesn't | |
951 | // hurt. It has to be here because the (GSocket) event might arrive | |
952 | // a bit delayed, and it has to be in _Wait as well because we don't | |
953 | // know whether the Wait functions are being used. | |
954 | ||
955 | switch (notification) | |
956 | { | |
957 | case wxSOCKET_CONNECTION: | |
958 | m_establishing = false; | |
959 | m_connected = true; | |
960 | break; | |
961 | ||
962 | // If we are in the middle of a R/W operation, do not | |
963 | // propagate events to users. Also, filter 'late' events | |
964 | // which are no longer valid. | |
965 | ||
966 | case wxSOCKET_INPUT: | |
967 | if (m_reading || !GSocket_Select(m_socket, GSOCK_INPUT_FLAG)) | |
968 | return; | |
969 | break; | |
970 | ||
971 | case wxSOCKET_OUTPUT: | |
972 | if (m_writing || !GSocket_Select(m_socket, GSOCK_OUTPUT_FLAG)) | |
973 | return; | |
974 | break; | |
975 | ||
976 | case wxSOCKET_LOST: | |
977 | m_connected = false; | |
978 | m_establishing = false; | |
979 | break; | |
980 | ||
981 | default: | |
982 | break; | |
983 | } | |
984 | ||
985 | // Schedule the event | |
986 | ||
987 | wxSocketEventFlags flag = 0; | |
988 | wxUnusedVar(flag); | |
989 | switch (notification) | |
990 | { | |
991 | case GSOCK_INPUT: | |
992 | flag = GSOCK_INPUT_FLAG; | |
993 | break; | |
994 | ||
995 | case GSOCK_OUTPUT: | |
996 | flag = GSOCK_OUTPUT_FLAG; | |
997 | break; | |
998 | ||
999 | case GSOCK_CONNECTION: | |
1000 | flag = GSOCK_CONNECTION_FLAG; | |
1001 | break; | |
1002 | ||
1003 | case GSOCK_LOST: | |
1004 | flag = GSOCK_LOST_FLAG; | |
1005 | break; | |
1006 | ||
1007 | default: | |
1008 | wxLogWarning( wxT("wxSocket: unknown event!") ); | |
1009 | return; | |
1010 | } | |
1011 | ||
1012 | if (((m_eventmask & flag) == flag) && m_notify) | |
1013 | { | |
1014 | if (m_handler) | |
1015 | { | |
1016 | wxSocketEvent event(m_id); | |
1017 | event.m_event = notification; | |
1018 | event.m_clientData = m_clientData; | |
1019 | event.SetEventObject(this); | |
1020 | ||
1021 | m_handler->AddPendingEvent(event); | |
1022 | } | |
1023 | } | |
1024 | } | |
1025 | ||
1026 | void wxSocketBase::Notify(bool notify) | |
1027 | { | |
1028 | m_notify = notify; | |
1029 | } | |
1030 | ||
1031 | void wxSocketBase::SetNotify(wxSocketEventFlags flags) | |
1032 | { | |
1033 | m_eventmask = flags; | |
1034 | } | |
1035 | ||
1036 | void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id) | |
1037 | { | |
1038 | m_handler = &handler; | |
1039 | m_id = id; | |
1040 | } | |
1041 | ||
1042 | // -------------------------------------------------------------------------- | |
1043 | // Pushback buffer | |
1044 | // -------------------------------------------------------------------------- | |
1045 | ||
1046 | void wxSocketBase::Pushback(const void *buffer, wxUint32 size) | |
1047 | { | |
1048 | if (!size) | |
1049 | return; | |
1050 | ||
1051 | if (m_unread == NULL) | |
1052 | m_unread = malloc(size); | |
1053 | else | |
1054 | { | |
1055 | void *tmp; | |
1056 | ||
1057 | tmp = malloc(m_unrd_size + size); | |
1058 | memcpy((char *)tmp + size, m_unread, m_unrd_size); | |
1059 | free(m_unread); | |
1060 | ||
1061 | m_unread = tmp; | |
1062 | } | |
1063 | ||
1064 | m_unrd_size += size; | |
1065 | ||
1066 | memcpy(m_unread, buffer, size); | |
1067 | } | |
1068 | ||
1069 | wxUint32 wxSocketBase::GetPushback(void *buffer, wxUint32 size, bool peek) | |
1070 | { | |
1071 | if (!m_unrd_size) | |
1072 | return 0; | |
1073 | ||
1074 | if (size > (m_unrd_size-m_unrd_cur)) | |
1075 | size = m_unrd_size-m_unrd_cur; | |
1076 | ||
1077 | memcpy(buffer, (char *)m_unread + m_unrd_cur, size); | |
1078 | ||
1079 | if (!peek) | |
1080 | { | |
1081 | m_unrd_cur += size; | |
1082 | if (m_unrd_size == m_unrd_cur) | |
1083 | { | |
1084 | free(m_unread); | |
1085 | m_unread = NULL; | |
1086 | m_unrd_size = 0; | |
1087 | m_unrd_cur = 0; | |
1088 | } | |
1089 | } | |
1090 | ||
1091 | return size; | |
1092 | } | |
1093 | ||
1094 | ||
1095 | // ========================================================================== | |
1096 | // wxSocketServer | |
1097 | // ========================================================================== | |
1098 | ||
1099 | // -------------------------------------------------------------------------- | |
1100 | // Ctor | |
1101 | // -------------------------------------------------------------------------- | |
1102 | ||
1103 | wxSocketServer::wxSocketServer(wxSockAddress& addr_man, | |
1104 | wxSocketFlags flags) | |
1105 | : wxSocketBase(flags, wxSOCKET_SERVER) | |
1106 | { | |
1107 | wxLogTrace( wxTRACE_Socket, wxT("Opening wxSocketServer") ); | |
1108 | ||
1109 | m_socket = GSocket_new(); | |
1110 | ||
1111 | if (!m_socket) | |
1112 | { | |
1113 | wxLogTrace( wxTRACE_Socket, wxT("*** GSocket_new failed") ); | |
1114 | return; | |
1115 | } | |
1116 | ||
1117 | // Setup the socket as server | |
1118 | ||
1119 | #if 0 | |
1120 | GSocket_SetLocal(m_socket, addr_man.GetAddress()); | |
1121 | if (GSocket_SetServer(m_socket) != GSOCK_NOERROR) | |
1122 | { | |
1123 | GSocket_destroy(m_socket); | |
1124 | m_socket = NULL; | |
1125 | ||
1126 | wxLogTrace( wxTRACE_Socket, wxT("*** GSocket_SetServer failed") ); | |
1127 | return; | |
1128 | } | |
1129 | ||
1130 | GSocket_SetTimeout(m_socket, m_timeout * 1000); | |
1131 | GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | | |
1132 | GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG, | |
1133 | wx_socket_callback, (char *)this); | |
1134 | #endif | |
1135 | } | |
1136 | ||
1137 | // -------------------------------------------------------------------------- | |
1138 | // Accept | |
1139 | // -------------------------------------------------------------------------- | |
1140 | ||
1141 | bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait) | |
1142 | { | |
1143 | GSocket *child_socket; | |
1144 | ||
1145 | if (!m_socket) | |
1146 | return false; | |
1147 | ||
1148 | // If wait == false, then the call should be nonblocking. | |
1149 | // When we are finished, we put the socket to blocking mode | |
1150 | // again. | |
1151 | ||
1152 | #if 0 | |
1153 | if (!wait) | |
1154 | GSocket_SetNonBlocking(m_socket, 1); | |
1155 | ||
1156 | child_socket = GSocket_WaitConnection(m_socket); | |
1157 | ||
1158 | if (!wait) | |
1159 | GSocket_SetNonBlocking(m_socket, 0); | |
1160 | ||
1161 | if (!child_socket) | |
1162 | return false; | |
1163 | ||
1164 | sock.m_type = wxSOCKET_BASE; | |
1165 | sock.m_socket = child_socket; | |
1166 | sock.m_connected = true; | |
1167 | ||
1168 | GSocket_SetTimeout(sock.m_socket, sock.m_timeout * 1000); | |
1169 | GSocket_SetCallback(sock.m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | | |
1170 | GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG, | |
1171 | wx_socket_callback, (char *)&sock); | |
1172 | #endif | |
1173 | ||
1174 | return true; | |
1175 | } | |
1176 | ||
1177 | wxSocketBase *wxSocketServer::Accept(bool wait) | |
1178 | { | |
1179 | wxSocketBase* sock = new wxSocketBase(); | |
1180 | ||
1181 | sock->SetFlags(m_flags); | |
1182 | ||
1183 | if (!AcceptWith(*sock, wait)) | |
1184 | { | |
1185 | sock->Destroy(); | |
1186 | sock = NULL; | |
1187 | } | |
1188 | ||
1189 | return sock; | |
1190 | } | |
1191 | ||
1192 | bool wxSocketServer::WaitForAccept(long seconds, long milliseconds) | |
1193 | { | |
1194 | return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG); | |
1195 | } | |
1196 | ||
1197 | // ========================================================================== | |
1198 | // wxSocketClient | |
1199 | // ========================================================================== | |
1200 | ||
1201 | // -------------------------------------------------------------------------- | |
1202 | // Ctor and dtor | |
1203 | // -------------------------------------------------------------------------- | |
1204 | ||
1205 | wxSocketClient::wxSocketClient(wxSocketFlags flags) | |
1206 | : wxSocketBase(flags, wxSOCKET_CLIENT) | |
1207 | { | |
1208 | } | |
1209 | ||
1210 | wxSocketClient::~wxSocketClient() | |
1211 | { | |
1212 | } | |
1213 | ||
1214 | // -------------------------------------------------------------------------- | |
1215 | // Connect | |
1216 | // -------------------------------------------------------------------------- | |
1217 | ||
1218 | bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait) | |
1219 | { | |
1220 | GSocketError err; | |
1221 | ||
1222 | if (m_socket) | |
1223 | { | |
1224 | // Shutdown and destroy the socket | |
1225 | Close(); | |
1226 | GSocket_destroy(m_socket); | |
1227 | } | |
1228 | ||
1229 | m_socket = GSocket_new(); | |
1230 | m_connected = false; | |
1231 | m_establishing = false; | |
1232 | ||
1233 | if (!m_socket) | |
1234 | return false; | |
1235 | ||
1236 | GSocket_SetTimeout(m_socket, m_timeout * 1000); | |
1237 | GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | | |
1238 | GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG, | |
1239 | wx_socket_callback, (char *)this); | |
1240 | ||
1241 | // If wait == false, then the call should be nonblocking. | |
1242 | // When we are finished, we put the socket to blocking mode | |
1243 | // again. | |
1244 | ||
1245 | if (!wait) | |
1246 | GSocket_SetNonBlocking(m_socket, 1); | |
1247 | ||
1248 | GSocket_SetPeer(m_socket, addr_man.GetAddress()); | |
1249 | err = GSocket_Connect(m_socket, GSOCK_STREAMED); | |
1250 | ||
1251 | if (!wait) | |
1252 | GSocket_SetNonBlocking(m_socket, 0); | |
1253 | ||
1254 | if (err != GSOCK_NOERROR) | |
1255 | { | |
1256 | if (err == GSOCK_WOULDBLOCK) | |
1257 | m_establishing = true; | |
1258 | ||
1259 | return false; | |
1260 | } | |
1261 | ||
1262 | m_connected = true; | |
1263 | return true; | |
1264 | } | |
1265 | ||
1266 | bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds) | |
1267 | { | |
1268 | if (m_connected) // Already connected | |
1269 | return true; | |
1270 | ||
1271 | if (!m_establishing || !m_socket) // No connection in progress | |
1272 | return false; | |
1273 | ||
1274 | return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG | GSOCK_LOST_FLAG); | |
1275 | } | |
1276 | ||
1277 | // ========================================================================== | |
1278 | // wxDatagramSocket | |
1279 | // ========================================================================== | |
1280 | ||
1281 | /* NOTE: experimental stuff - might change */ | |
1282 | ||
1283 | wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr, | |
1284 | wxSocketFlags flags ) | |
1285 | : wxSocketBase( flags, wxSOCKET_DATAGRAM ) | |
1286 | { | |
1287 | #if 0 | |
1288 | // Create the socket | |
1289 | m_socket = GSocket_new(); | |
1290 | ||
1291 | if (!m_socket) | |
1292 | return; | |
1293 | ||
1294 | // Setup the socket as non connection oriented | |
1295 | GSocket_SetLocal(m_socket, addr.GetAddress()); | |
1296 | if( GSocket_SetNonOriented(m_socket) != GSOCK_NOERROR ) | |
1297 | { | |
1298 | GSocket_destroy(m_socket); | |
1299 | m_socket = NULL; | |
1300 | return; | |
1301 | } | |
1302 | ||
1303 | // Initialize all stuff | |
1304 | m_connected = false; | |
1305 | m_establishing = false; | |
1306 | GSocket_SetTimeout( m_socket, m_timeout ); | |
1307 | GSocket_SetCallback( m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG | | |
1308 | GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG, | |
1309 | wx_socket_callback, (char*)this ); | |
1310 | #endif | |
1311 | } | |
1312 | ||
1313 | wxDatagramSocket& wxDatagramSocket::RecvFrom( wxSockAddress& addr, | |
1314 | void* buf, | |
1315 | wxUint32 nBytes ) | |
1316 | { | |
1317 | Read(buf, nBytes); | |
1318 | GetPeer(addr); | |
1319 | return (*this); | |
1320 | } | |
1321 | ||
1322 | wxDatagramSocket& wxDatagramSocket::SendTo( wxSockAddress& addr, | |
1323 | const void* buf, | |
1324 | wxUint32 nBytes ) | |
1325 | { | |
1326 | GSocket_SetPeer(m_socket, addr.GetAddress()); | |
1327 | Write(buf, nBytes); | |
1328 | return (*this); | |
1329 | } | |
1330 | ||
1331 | /* | |
1332 | * ------------------------------------------------------------------------- | |
1333 | * GAddress | |
1334 | * ------------------------------------------------------------------------- | |
1335 | */ | |
1336 | ||
1337 | /* CHECK_ADDRESS verifies that the current address family is either | |
1338 | * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it | |
1339 | * initalizes it to be a GSOCK_*family*. In other cases, it returns | |
1340 | * an appropiate error code. | |
1341 | * | |
1342 | * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error. | |
1343 | */ | |
1344 | #define CHECK_ADDRESS(address, family) \ | |
1345 | { \ | |
1346 | if (address->m_family == GSOCK_NOFAMILY) \ | |
1347 | if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \ | |
1348 | return address->m_error; \ | |
1349 | if (address->m_family != GSOCK_##family) \ | |
1350 | { \ | |
1351 | address->m_error = GSOCK_INVADDR; \ | |
1352 | return GSOCK_INVADDR; \ | |
1353 | } \ | |
1354 | } | |
1355 | ||
1356 | #define CHECK_ADDRESS_RETVAL(address, family, retval) \ | |
1357 | { \ | |
1358 | if (address->m_family == GSOCK_NOFAMILY) \ | |
1359 | if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \ | |
1360 | return retval; \ | |
1361 | if (address->m_family != GSOCK_##family) \ | |
1362 | { \ | |
1363 | address->m_error = GSOCK_INVADDR; \ | |
1364 | return retval; \ | |
1365 | } \ | |
1366 | } | |
1367 | ||
1368 | ||
1369 | GAddress *GAddress_new(void) | |
1370 | { | |
1371 | GAddress *address; | |
1372 | ||
1373 | if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL) | |
1374 | return NULL; | |
1375 | ||
1376 | address->m_family = GSOCK_NOFAMILY; | |
1377 | address->m_addr = NULL; | |
1378 | address->m_len = 0; | |
1379 | ||
1380 | return address; | |
1381 | } | |
1382 | ||
1383 | GAddress *GAddress_copy(GAddress *address) | |
1384 | { | |
1385 | GAddress *addr2; | |
1386 | ||
1387 | assert(address != NULL); | |
1388 | ||
1389 | if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL) | |
1390 | return NULL; | |
1391 | ||
1392 | memcpy(addr2, address, sizeof(GAddress)); | |
1393 | ||
1394 | if (address->m_addr && address->m_len > 0) | |
1395 | { | |
1396 | addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len); | |
1397 | if (addr2->m_addr == NULL) | |
1398 | { | |
1399 | free(addr2); | |
1400 | return NULL; | |
1401 | } | |
1402 | ||
1403 | memcpy(addr2->m_addr, address->m_addr, addr2->m_len); | |
1404 | } | |
1405 | ||
1406 | return addr2; | |
1407 | } | |
1408 | ||
1409 | void GAddress_destroy(GAddress *address) | |
1410 | { | |
1411 | assert( address != NULL ); | |
1412 | ||
1413 | if (address->m_addr) | |
1414 | free(address->m_addr); | |
1415 | ||
1416 | free(address); | |
1417 | } | |
1418 | ||
1419 | void GAddress_SetFamily(GAddress *address, GAddressType type) | |
1420 | { | |
1421 | assert(address != NULL); | |
1422 | ||
1423 | address->m_family = type; | |
1424 | } | |
1425 | ||
1426 | GAddressType GAddress_GetFamily(GAddress *address) | |
1427 | { | |
1428 | assert( address != NULL ); | |
1429 | ||
1430 | return address->m_family; | |
1431 | } | |
1432 | ||
1433 | GSocketError _GAddress_translate_from(GAddress *address, | |
1434 | struct sockaddr *addr, int len) | |
1435 | { | |
1436 | address->m_realfamily = addr->sa_family; | |
1437 | switch (addr->sa_family) | |
1438 | { | |
1439 | case AF_INET: | |
1440 | address->m_family = GSOCK_INET; | |
1441 | break; | |
1442 | ||
1443 | case AF_UNIX: | |
1444 | address->m_family = GSOCK_UNIX; | |
1445 | break; | |
1446 | ||
1447 | #ifdef AF_INET6 | |
1448 | case AF_INET6: | |
1449 | address->m_family = GSOCK_INET6; | |
1450 | break; | |
1451 | #endif | |
1452 | ||
1453 | default: | |
1454 | { | |
1455 | address->m_error = GSOCK_INVOP; | |
1456 | return GSOCK_INVOP; | |
1457 | } | |
1458 | } | |
1459 | ||
1460 | if (address->m_addr) | |
1461 | free(address->m_addr); | |
1462 | ||
1463 | address->m_len = len; | |
1464 | address->m_addr = (struct sockaddr *)malloc(len); | |
1465 | ||
1466 | if (address->m_addr == NULL) | |
1467 | { | |
1468 | address->m_error = GSOCK_MEMERR; | |
1469 | return GSOCK_MEMERR; | |
1470 | } | |
1471 | ||
1472 | memcpy(address->m_addr, addr, len); | |
1473 | ||
1474 | return GSOCK_NOERROR; | |
1475 | } | |
1476 | ||
1477 | GSocketError _GAddress_translate_to(GAddress *address, | |
1478 | struct sockaddr **addr, int *len) | |
1479 | { | |
1480 | if (!address->m_addr) | |
1481 | { | |
1482 | address->m_error = GSOCK_INVADDR; | |
1483 | return GSOCK_INVADDR; | |
1484 | } | |
1485 | ||
1486 | *len = address->m_len; | |
1487 | *addr = (struct sockaddr *)malloc(address->m_len); | |
1488 | if (*addr == NULL) | |
1489 | { | |
1490 | address->m_error = GSOCK_MEMERR; | |
1491 | return GSOCK_MEMERR; | |
1492 | } | |
1493 | ||
1494 | memcpy(*addr, address->m_addr, address->m_len); | |
1495 | return GSOCK_NOERROR; | |
1496 | } | |
1497 | ||
1498 | /* | |
1499 | * ------------------------------------------------------------------------- | |
1500 | * Internet address family | |
1501 | * ------------------------------------------------------------------------- | |
1502 | */ | |
1503 | ||
1504 | GSocketError _GAddress_Init_INET(GAddress *address) | |
1505 | { | |
1506 | address->m_len = sizeof(struct sockaddr_in); | |
1507 | address->m_addr = (struct sockaddr *) malloc(address->m_len); | |
1508 | if (address->m_addr == NULL) | |
1509 | { | |
1510 | address->m_error = GSOCK_MEMERR; | |
1511 | return GSOCK_MEMERR; | |
1512 | } | |
1513 | ||
1514 | memset( address->m_addr , 0 , address->m_len ) ; | |
1515 | address->m_family = GSOCK_INET; | |
1516 | address->m_realfamily = PF_INET; | |
1517 | ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET; | |
1518 | ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY; | |
1519 | ||
1520 | return GSOCK_NOERROR; | |
1521 | } | |
1522 | ||
1523 | GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname) | |
1524 | { | |
1525 | struct hostent *he; | |
1526 | struct in_addr *addr; | |
1527 | ||
1528 | assert( address != NULL ); | |
1529 | CHECK_ADDRESS( address, INET ); | |
1530 | ||
1531 | addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr); | |
1532 | ||
1533 | // If it is a numeric host name, convert it now | |
1534 | #if defined(HAVE_INET_ATON) | |
1535 | if (inet_aton(hostname, addr) == 0) | |
1536 | { | |
1537 | #elif defined(HAVE_INET_ADDR) | |
1538 | if ( (addr->s_addr = inet_addr(hostname)) == -1 ) | |
1539 | { | |
1540 | #else | |
1541 | // Use gethostbyname by default | |
1542 | #ifndef __WXMAC__ | |
1543 | int val = 1; // VA doesn't like constants in conditional expressions | |
1544 | if (val) | |
1545 | #endif | |
1546 | { | |
1547 | #endif | |
1548 | struct in_addr *array_addr; | |
1549 | ||
1550 | // It is a real name, we solve it | |
1551 | if ((he = gethostbyname(hostname)) == NULL) | |
1552 | { | |
1553 | // Reset to invalid address | |
1554 | addr->s_addr = INADDR_NONE; | |
1555 | address->m_error = GSOCK_NOHOST; | |
1556 | return GSOCK_NOHOST; | |
1557 | } | |
1558 | array_addr = (struct in_addr *) *(he->h_addr_list); | |
1559 | addr->s_addr = array_addr[0].s_addr; | |
1560 | } | |
1561 | ||
1562 | return GSOCK_NOERROR; | |
1563 | } | |
1564 | ||
1565 | GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address) | |
1566 | { | |
1567 | return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST); | |
1568 | } | |
1569 | ||
1570 | GSocketError GAddress_INET_SetAnyAddress(GAddress *address) | |
1571 | { | |
1572 | return GAddress_INET_SetHostAddress(address, INADDR_ANY); | |
1573 | } | |
1574 | ||
1575 | GSocketError GAddress_INET_SetHostAddress(GAddress *address, | |
1576 | unsigned long hostaddr) | |
1577 | { | |
1578 | struct in_addr *addr; | |
1579 | ||
1580 | assert( address != NULL ); | |
1581 | CHECK_ADDRESS( address, INET ); | |
1582 | ||
1583 | addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr); | |
1584 | addr->s_addr = htonl(hostaddr) ; | |
1585 | ||
1586 | return GSOCK_NOERROR; | |
1587 | } | |
1588 | ||
1589 | GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port, | |
1590 | const char *protocol) | |
1591 | { | |
1592 | struct servent *se; | |
1593 | struct sockaddr_in *addr; | |
1594 | ||
1595 | assert( address != NULL ); | |
1596 | CHECK_ADDRESS( address, INET ); | |
1597 | ||
1598 | if (!port) | |
1599 | { | |
1600 | address->m_error = GSOCK_INVPORT; | |
1601 | return GSOCK_INVPORT; | |
1602 | } | |
1603 | ||
1604 | se = getservbyname(port, protocol); | |
1605 | if (!se) | |
1606 | { | |
1607 | // the cast to int suppresses compiler warnings | |
1608 | // about subscript having the type char | |
1609 | if (isdigit((int)port[0])) | |
1610 | { | |
1611 | int port_int; | |
1612 | ||
1613 | port_int = atoi(port); | |
1614 | addr = (struct sockaddr_in *)address->m_addr; | |
1615 | addr->sin_port = htons(port_int); | |
1616 | return GSOCK_NOERROR; | |
1617 | } | |
1618 | ||
1619 | address->m_error = GSOCK_INVPORT; | |
1620 | return GSOCK_INVPORT; | |
1621 | } | |
1622 | ||
1623 | addr = (struct sockaddr_in *)address->m_addr; | |
1624 | addr->sin_port = se->s_port; | |
1625 | ||
1626 | return GSOCK_NOERROR; | |
1627 | } | |
1628 | ||
1629 | GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port) | |
1630 | { | |
1631 | struct sockaddr_in *addr; | |
1632 | ||
1633 | assert( address != NULL ); | |
1634 | CHECK_ADDRESS( address, INET ); | |
1635 | ||
1636 | addr = (struct sockaddr_in *)address->m_addr; | |
1637 | addr->sin_port = htons(port); | |
1638 | ||
1639 | return GSOCK_NOERROR; | |
1640 | } | |
1641 | ||
1642 | GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf) | |
1643 | { | |
1644 | struct hostent *he; | |
1645 | char *addr_buf; | |
1646 | struct sockaddr_in *addr; | |
1647 | ||
1648 | assert( address != NULL ); | |
1649 | CHECK_ADDRESS( address, INET ); | |
1650 | ||
1651 | addr = (struct sockaddr_in *)address->m_addr; | |
1652 | addr_buf = (char *)&(addr->sin_addr); | |
1653 | ||
1654 | he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET); | |
1655 | if (he == NULL) | |
1656 | { | |
1657 | address->m_error = GSOCK_NOHOST; | |
1658 | return GSOCK_NOHOST; | |
1659 | } | |
1660 | ||
1661 | strncpy(hostname, he->h_name, sbuf); | |
1662 | ||
1663 | return GSOCK_NOERROR; | |
1664 | } | |
1665 | ||
1666 | unsigned long GAddress_INET_GetHostAddress(GAddress *address) | |
1667 | { | |
1668 | struct sockaddr_in *addr; | |
1669 | ||
1670 | assert( address != NULL ); | |
1671 | CHECK_ADDRESS_RETVAL( address, INET, 0 ); | |
1672 | ||
1673 | addr = (struct sockaddr_in *)address->m_addr; | |
1674 | ||
1675 | return ntohl(addr->sin_addr.s_addr) ; | |
1676 | } | |
1677 | ||
1678 | unsigned short GAddress_INET_GetPort(GAddress *address) | |
1679 | { | |
1680 | struct sockaddr_in *addr; | |
1681 | ||
1682 | assert( address != NULL ); | |
1683 | CHECK_ADDRESS_RETVAL( address, INET, 0 ); | |
1684 | ||
1685 | addr = (struct sockaddr_in *)address->m_addr; | |
1686 | ||
1687 | return ntohs(addr->sin_port); | |
1688 | } | |
1689 | ||
1690 | /* | |
1691 | * ------------------------------------------------------------------------- | |
1692 | * Unix address family | |
1693 | * ------------------------------------------------------------------------- | |
1694 | */ | |
1695 | ||
1696 | GSocketError _GAddress_Init_UNIX(GAddress *address) | |
1697 | { | |
1698 | address->m_len = sizeof(struct sockaddr_un); | |
1699 | address->m_addr = (struct sockaddr *)malloc(address->m_len); | |
1700 | if (address->m_addr == NULL) | |
1701 | { | |
1702 | address->m_error = GSOCK_MEMERR; | |
1703 | return GSOCK_MEMERR; | |
1704 | } | |
1705 | ||
1706 | address->m_family = GSOCK_UNIX; | |
1707 | address->m_realfamily = PF_UNIX; | |
1708 | ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX; | |
1709 | ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0; | |
1710 | ||
1711 | return GSOCK_NOERROR; | |
1712 | } | |
1713 | ||
1714 | #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0])) | |
1715 | ||
1716 | GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path) | |
1717 | { | |
1718 | struct sockaddr_un *addr; | |
1719 | ||
1720 | assert( address != NULL ); | |
1721 | CHECK_ADDRESS( address, UNIX ); | |
1722 | ||
1723 | addr = ((struct sockaddr_un *)address->m_addr); | |
1724 | strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN); | |
1725 | addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0'; | |
1726 | ||
1727 | return GSOCK_NOERROR; | |
1728 | } | |
1729 | ||
1730 | GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf) | |
1731 | { | |
1732 | struct sockaddr_un *addr; | |
1733 | ||
1734 | assert( address != NULL ); | |
1735 | CHECK_ADDRESS( address, UNIX ); | |
1736 | ||
1737 | addr = (struct sockaddr_un *)address->m_addr; | |
1738 | ||
1739 | strncpy(path, addr->sun_path, sbuf); | |
1740 | ||
1741 | return GSOCK_NOERROR; | |
1742 | } | |
1743 | ||
1744 | /* Address handling */ | |
1745 | ||
1746 | /* GSocket_SetLocal: | |
1747 | * GSocket_GetLocal: | |
1748 | * GSocket_SetPeer: | |
1749 | * GSocket_GetPeer: | |
1750 | * Set or get the local or peer address for this socket. The 'set' | |
1751 | * functions return GSOCK_NOERROR on success, an error code otherwise. | |
1752 | * The 'get' functions return a pointer to a GAddress object on success, | |
1753 | * or NULL otherwise, in which case they set the error code of the | |
1754 | * corresponding GSocket. | |
1755 | * | |
1756 | * Error codes: | |
1757 | * GSOCK_INVSOCK - the socket is not valid. | |
1758 | * GSOCK_INVADDR - the address is not valid. | |
1759 | */ | |
1760 | ||
1761 | GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address) | |
1762 | { | |
1763 | assert( socket != NULL ); | |
1764 | ||
1765 | // the socket must be initialized, or it must be a server | |
1766 | if ((socket->m_fd != INVALID_SOCKET && !socket->m_server)) | |
1767 | { | |
1768 | socket->m_error = GSOCK_INVSOCK; | |
1769 | return GSOCK_INVSOCK; | |
1770 | } | |
1771 | ||
1772 | // check address | |
1773 | if (address == NULL || address->m_family == GSOCK_NOFAMILY) | |
1774 | { | |
1775 | socket->m_error = GSOCK_INVADDR; | |
1776 | return GSOCK_INVADDR; | |
1777 | } | |
1778 | ||
1779 | if (socket->m_local) | |
1780 | GAddress_destroy(socket->m_local); | |
1781 | ||
1782 | socket->m_local = GAddress_copy(address); | |
1783 | ||
1784 | return GSOCK_NOERROR; | |
1785 | } | |
1786 | ||
1787 | GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address) | |
1788 | { | |
1789 | assert(socket != NULL); | |
1790 | ||
1791 | // check address | |
1792 | if (address == NULL || address->m_family == GSOCK_NOFAMILY) | |
1793 | { | |
1794 | socket->m_error = GSOCK_INVADDR; | |
1795 | return GSOCK_INVADDR; | |
1796 | } | |
1797 | ||
1798 | if (socket->m_peer) | |
1799 | GAddress_destroy(socket->m_peer); | |
1800 | ||
1801 | socket->m_peer = GAddress_copy(address); | |
1802 | ||
1803 | return GSOCK_NOERROR; | |
1804 | } | |
1805 | ||
1806 | GAddress *GSocket_GetLocal(GSocket *socket) | |
1807 | { | |
1808 | GAddress *address; | |
1809 | struct sockaddr addr; | |
1810 | socklen_t size = sizeof(addr); | |
1811 | GSocketError err; | |
1812 | ||
1813 | assert( socket != NULL ); | |
1814 | ||
1815 | // try to get it from the m_local var first | |
1816 | if (socket->m_local) | |
1817 | return GAddress_copy(socket->m_local); | |
1818 | ||
1819 | // else, if the socket is initialized, try getsockname | |
1820 | if (socket->m_fd == INVALID_SOCKET) | |
1821 | { | |
1822 | socket->m_error = GSOCK_INVSOCK; | |
1823 | return NULL; | |
1824 | } | |
1825 | ||
1826 | if (getsockname(socket->m_fd, &addr, (socklen_t *) &size) < 0) | |
1827 | { | |
1828 | socket->m_error = GSOCK_IOERR; | |
1829 | return NULL; | |
1830 | } | |
1831 | ||
1832 | // got a valid address from getsockname, create a GAddress object | |
1833 | address = GAddress_new(); | |
1834 | if (address == NULL) | |
1835 | { | |
1836 | socket->m_error = GSOCK_MEMERR; | |
1837 | return NULL; | |
1838 | } | |
1839 | ||
1840 | err = _GAddress_translate_from(address, &addr, size); | |
1841 | if (err != GSOCK_NOERROR) | |
1842 | { | |
1843 | GAddress_destroy(address); | |
1844 | socket->m_error = err; | |
1845 | return NULL; | |
1846 | } | |
1847 | ||
1848 | return address; | |
1849 | } | |
1850 | ||
1851 | GAddress *GSocket_GetPeer(GSocket *socket) | |
1852 | { | |
1853 | assert(socket != NULL); | |
1854 | ||
1855 | // try to get it from the m_peer var | |
1856 | if (socket->m_peer) | |
1857 | return GAddress_copy(socket->m_peer); | |
1858 | ||
1859 | return NULL; | |
1860 | } | |
1861 | ||
1862 | ||
1863 | GSocket *GSocket_new(void) | |
1864 | { | |
1865 | GSocket *socket; | |
1866 | socket = (GSocket *)malloc(sizeof(GSocket)); | |
1867 | ||
1868 | if (socket == NULL) | |
1869 | return NULL; | |
1870 | ||
1871 | socket->m_fd = INVALID_SOCKET; | |
1872 | ||
1873 | for (int i=0;i<GSOCK_MAX_EVENT;i++) | |
1874 | { | |
1875 | socket->m_cbacks[i] = NULL; | |
1876 | } | |
1877 | ||
1878 | socket->m_detected = 0; | |
1879 | ||
1880 | socket->m_local = NULL; | |
1881 | socket->m_peer = NULL; | |
1882 | socket->m_error = GSOCK_NOERROR; | |
1883 | ||
1884 | socket->m_non_blocking = false ; | |
1885 | socket->m_stream = true; | |
1886 | // socket->m_oriented = true; | |
1887 | socket->m_server = false; | |
1888 | socket->m_establishing = false; | |
1889 | socket->m_timeout = 10 * 60 * 1000; | |
1890 | // 10 minutes * 60 sec * 1000 millisec | |
1891 | ||
1892 | socket->m_cfSocket = NULL ; | |
1893 | socket->m_runLoopSource = NULL ; | |
1894 | socket->m_readStream = NULL; | |
1895 | socket->m_writeStream = NULL; | |
1896 | ||
1897 | return socket ; | |
1898 | } | |
1899 | ||
1900 | void GSocket_close(GSocket *socket) | |
1901 | { | |
1902 | if ( socket->m_cfSocket != NULL ) | |
1903 | { | |
1904 | if ( socket->m_readStream ) | |
1905 | { | |
1906 | CFReadStreamClose(socket->m_readStream); | |
1907 | CFRelease( socket->m_readStream ) ; | |
1908 | socket->m_readStream = NULL ; | |
1909 | } | |
1910 | ||
1911 | if ( socket->m_writeStream ) | |
1912 | { | |
1913 | CFWriteStreamClose(socket->m_writeStream); | |
1914 | CFRelease( socket->m_writeStream ) ; | |
1915 | socket->m_writeStream = NULL ; | |
1916 | } | |
1917 | ||
1918 | CFSocketInvalidate( socket->m_cfSocket ) ; | |
1919 | CFRelease( socket->m_cfSocket ) ; | |
1920 | socket->m_cfSocket = NULL ; | |
1921 | socket->m_fd = INVALID_SOCKET ; | |
1922 | } | |
1923 | } | |
1924 | ||
1925 | void GSocket_Shutdown(GSocket *socket) | |
1926 | { | |
1927 | GSocket_close( socket ); | |
1928 | ||
1929 | // Disable GUI callbacks | |
1930 | for (int evt = 0; evt < GSOCK_MAX_EVENT; evt++) | |
1931 | socket->m_cbacks[evt] = NULL; | |
1932 | ||
1933 | socket->m_detected = GSOCK_LOST_FLAG; | |
1934 | } | |
1935 | ||
1936 | void GSocket_destroy(GSocket *socket) | |
1937 | { | |
1938 | assert( socket != NULL ); | |
1939 | ||
1940 | // Check that the socket is really shut down | |
1941 | if (socket->m_fd != INVALID_SOCKET) | |
1942 | GSocket_Shutdown(socket); | |
1943 | ||
1944 | // Destroy private addresses | |
1945 | if (socket->m_local) | |
1946 | GAddress_destroy(socket->m_local); | |
1947 | ||
1948 | if (socket->m_peer) | |
1949 | GAddress_destroy(socket->m_peer); | |
1950 | ||
1951 | // Destroy the socket itself | |
1952 | free(socket); | |
1953 | } | |
1954 | ||
1955 | GSocketError GSocket_Connect(GSocket *socket, GSocketStream stream) | |
1956 | { | |
1957 | assert( socket != NULL ); | |
1958 | ||
1959 | if (socket->m_fd != INVALID_SOCKET) | |
1960 | { | |
1961 | socket->m_error = GSOCK_INVSOCK; | |
1962 | return GSOCK_INVSOCK; | |
1963 | } | |
1964 | ||
1965 | if (!socket->m_peer) | |
1966 | { | |
1967 | socket->m_error = GSOCK_INVADDR; | |
1968 | return GSOCK_INVADDR; | |
1969 | } | |
1970 | ||
1971 | // Streamed or dgram socket? | |
1972 | socket->m_stream = (stream == GSOCK_STREAMED); | |
1973 | socket->m_oriented = true; | |
1974 | socket->m_server = false; | |
1975 | socket->m_establishing = false; | |
1976 | ||
1977 | GSocketError returnErr = GSOCK_NOERROR ; | |
1978 | CFSocketError err ; | |
1979 | ||
1980 | CFAllocatorRef alloc = kCFAllocatorDefault ; | |
1981 | CFSocketContext ctx ; | |
1982 | memset( &ctx , 0 , sizeof( ctx ) ) ; | |
1983 | ctx.info = socket ; | |
1984 | socket->m_cfSocket = CFSocketCreate( alloc , socket->m_peer->m_realfamily , | |
1985 | stream == GSOCK_STREAMED ? SOCK_STREAM : SOCK_DGRAM , 0 , | |
1986 | kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack , wxMacCFSocketCallback , &ctx ) ; | |
1987 | _GSocket_Enable(socket, GSOCK_CONNECTION); | |
1988 | ||
1989 | socket->m_fd = CFSocketGetNative( socket->m_cfSocket ) ; | |
1990 | ||
1991 | CFStreamCreatePairWithSocket ( alloc , socket->m_fd , &socket->m_readStream , &socket->m_writeStream ); | |
1992 | if ((socket->m_readStream == NULL) || (socket->m_writeStream == NULL)) | |
1993 | { | |
1994 | GSocket_close(socket); | |
1995 | socket->m_error = GSOCK_IOERR; | |
1996 | return GSOCK_IOERR; | |
1997 | } | |
1998 | ||
1999 | if ( !CFReadStreamOpen( socket->m_readStream ) || !CFWriteStreamOpen( socket->m_writeStream ) ) | |
2000 | { | |
2001 | GSocket_close(socket); | |
2002 | socket->m_error = GSOCK_IOERR; | |
2003 | return GSOCK_IOERR; | |
2004 | } | |
2005 | ||
2006 | CFRunLoopSourceRef rls = CFSocketCreateRunLoopSource(alloc , socket->m_cfSocket , 0); | |
2007 | CFRunLoopAddSource(CFRunLoopGetCurrent() , rls, kCFRunLoopCommonModes); | |
2008 | CFRelease(rls); | |
2009 | ||
2010 | CFDataRef address = CFDataCreateWithBytesNoCopy(alloc, (const UInt8*) socket->m_peer->m_addr, socket->m_peer->m_len , kCFAllocatorNull); | |
2011 | if ( !address ) | |
2012 | return GSOCK_MEMERR ; | |
2013 | ||
2014 | err = CFSocketConnectToAddress( socket->m_cfSocket , address, socket->m_non_blocking ? -1 : socket->m_timeout / 1000 ) ; | |
2015 | CFRelease(address); | |
2016 | ||
2017 | if (err != kCFSocketSuccess) | |
2018 | { | |
2019 | if ( err == kCFSocketTimeout ) | |
2020 | { | |
2021 | GSocket_close(socket); | |
2022 | socket->m_error = GSOCK_TIMEDOUT ; | |
2023 | return GSOCK_TIMEDOUT ; | |
2024 | } | |
2025 | ||
2026 | // we don't know whether a connect in progress will be issued like this | |
2027 | if ( err != kCFSocketTimeout && socket->m_non_blocking ) | |
2028 | { | |
2029 | socket->m_establishing = true; | |
2030 | socket->m_error = GSOCK_WOULDBLOCK; | |
2031 | return GSOCK_WOULDBLOCK; | |
2032 | } | |
2033 | ||
2034 | GSocket_close(socket); | |
2035 | socket->m_error = GSOCK_IOERR; | |
2036 | return GSOCK_IOERR; | |
2037 | } | |
2038 | ||
2039 | return GSOCK_NOERROR; | |
2040 | } | |
2041 | ||
2042 | /* Flags */ | |
2043 | ||
2044 | /* GSocket_SetNonBlocking: | |
2045 | * Sets the socket to non-blocking mode. | |
2046 | * All IO calls will return immediately. | |
2047 | */ | |
2048 | void GSocket_SetNonBlocking(GSocket *socket, int non_block) | |
2049 | { | |
2050 | assert( socket != NULL ); | |
2051 | ||
2052 | // GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) ); | |
2053 | ||
2054 | socket->m_non_blocking = non_block; | |
2055 | } | |
2056 | ||
2057 | /* | |
2058 | * GSocket_SetTimeout: | |
2059 | * Sets the timeout for blocking calls. Time is expressed in | |
2060 | * milliseconds. | |
2061 | */ | |
2062 | void GSocket_SetTimeout(GSocket *socket, unsigned long millisec) | |
2063 | { | |
2064 | assert( socket != NULL ); | |
2065 | ||
2066 | socket->m_timeout = millisec; | |
2067 | } | |
2068 | ||
2069 | /* GSocket_GetError: | |
2070 | * Returns the last error which occurred for this socket. Note that successful | |
2071 | * operations do not clear this back to GSOCK_NOERROR, so use it only | |
2072 | * after an error. | |
2073 | */ | |
2074 | GSocketError GSocket_GetError(GSocket *socket) | |
2075 | { | |
2076 | assert( socket != NULL ); | |
2077 | ||
2078 | return socket->m_error; | |
2079 | } | |
2080 | ||
2081 | /* Callbacks */ | |
2082 | ||
2083 | /* GSOCK_INPUT: | |
2084 | * There is data to be read in the input buffer. If, after a read | |
2085 | * operation, there is still data available, the callback function will | |
2086 | * be called again. | |
2087 | * GSOCK_OUTPUT: | |
2088 | * The socket is available for writing. That is, the next write call | |
2089 | * won't block. This event is generated only once, when the connection is | |
2090 | * first established, and then only if a call failed with GSOCK_WOULDBLOCK, | |
2091 | * when the output buffer empties again. This means that the app should | |
2092 | * assume that it can write since the first OUTPUT event, and no more | |
2093 | * OUTPUT events will be generated unless an error occurs. | |
2094 | * GSOCK_CONNECTION: | |
2095 | * Connection successfully established, for client sockets, or incoming | |
2096 | * client connection, for server sockets. Wait for this event (also watch | |
2097 | * out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call. | |
2098 | * GSOCK_LOST: | |
2099 | * The connection is lost (or a connection request failed); this could | |
2100 | * be due to a failure, or due to the peer closing it gracefully. | |
2101 | */ | |
2102 | ||
2103 | /* GSocket_SetCallback: | |
2104 | * Enables the callbacks specified by 'flags'. Note that 'flags' | |
2105 | * may be a combination of flags OR'ed toghether, so the same | |
2106 | * callback function can be made to accept different events. | |
2107 | * The callback function must have the following prototype: | |
2108 | * | |
2109 | * void function(GSocket *socket, GSocketEvent event, char *cdata) | |
2110 | */ | |
2111 | void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags, | |
2112 | GSocketCallback callback, char *cdata) | |
2113 | { | |
2114 | int count; | |
2115 | ||
2116 | assert( socket != NULL ); | |
2117 | ||
2118 | for (count = 0; count < GSOCK_MAX_EVENT; count++) | |
2119 | { | |
2120 | if ((flags & (1 << count)) != 0) | |
2121 | { | |
2122 | socket->m_cbacks[count] = callback; | |
2123 | socket->m_data[count] = cdata; | |
2124 | } | |
2125 | } | |
2126 | } | |
2127 | ||
2128 | /* GSocket_UnsetCallback: | |
2129 | * Disables all callbacks specified by 'flags', which may be a | |
2130 | * combination of flags OR'ed toghether. | |
2131 | */ | |
2132 | void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags) | |
2133 | { | |
2134 | int count; | |
2135 | ||
2136 | assert(socket != NULL); | |
2137 | ||
2138 | for (count = 0; count < GSOCK_MAX_EVENT; count++) | |
2139 | { | |
2140 | if ((flags & (1 << count)) != 0) | |
2141 | { | |
2142 | socket->m_cbacks[count] = NULL; | |
2143 | socket->m_data[count] = NULL; | |
2144 | } | |
2145 | } | |
2146 | } | |
2147 | ||
2148 | ||
2149 | #define CALL_CALLBACK(socket, event) { \ | |
2150 | _GSocket_Disable(socket, event); \ | |
2151 | if (socket->m_cbacks[event]) \ | |
2152 | socket->m_cbacks[event](socket, event, socket->m_data[event]); \ | |
2153 | } | |
2154 | ||
2155 | void _GSocket_Install_Callback(GSocket *socket, GSocketEvent event) | |
2156 | { | |
2157 | int c; | |
2158 | switch (event) | |
2159 | { | |
2160 | case GSOCK_CONNECTION: | |
2161 | if (socket->m_server) | |
2162 | c = kCFSocketReadCallBack; | |
2163 | else | |
2164 | c = kCFSocketConnectCallBack; | |
2165 | break; | |
2166 | ||
2167 | case GSOCK_LOST: | |
2168 | case GSOCK_INPUT: | |
2169 | c = kCFSocketReadCallBack; | |
2170 | break; | |
2171 | ||
2172 | case GSOCK_OUTPUT: | |
2173 | c = kCFSocketWriteCallBack; | |
2174 | break; | |
2175 | ||
2176 | default: | |
2177 | c = 0; | |
2178 | } | |
2179 | ||
2180 | CFSocketEnableCallBacks(socket->m_cfSocket, c); | |
2181 | } | |
2182 | ||
2183 | void _GSocket_Uninstall_Callback(GSocket *socket, GSocketEvent event) | |
2184 | { | |
2185 | int c; | |
2186 | switch (event) | |
2187 | { | |
2188 | case GSOCK_CONNECTION: | |
2189 | if (socket->m_server) | |
2190 | c = kCFSocketReadCallBack; | |
2191 | else | |
2192 | c = kCFSocketConnectCallBack; | |
2193 | break; | |
2194 | ||
2195 | case GSOCK_LOST: | |
2196 | case GSOCK_INPUT: | |
2197 | c = kCFSocketReadCallBack; | |
2198 | break; | |
2199 | ||
2200 | case GSOCK_OUTPUT: | |
2201 | c = kCFSocketWriteCallBack; | |
2202 | break; | |
2203 | ||
2204 | default: | |
2205 | c = 0; | |
2206 | break; | |
2207 | } | |
2208 | ||
2209 | CFSocketDisableCallBacks(socket->m_cfSocket, c); | |
2210 | } | |
2211 | ||
2212 | void _GSocket_Enable(GSocket *socket, GSocketEvent event) | |
2213 | { | |
2214 | socket->m_detected &= ~(1 << event); | |
2215 | _GSocket_Install_Callback(socket, event); | |
2216 | } | |
2217 | ||
2218 | void _GSocket_Disable(GSocket *socket, GSocketEvent event) | |
2219 | { | |
2220 | socket->m_detected |= (1 << event); | |
2221 | _GSocket_Uninstall_Callback(socket, event); | |
2222 | } | |
2223 | ||
2224 | void wxMacCFSocketCallback(CFSocketRef s, CFSocketCallBackType callbackType, | |
2225 | CFDataRef address, const void* data, void* info) | |
2226 | { | |
2227 | GSocket* socket = (GSocket*)info; | |
2228 | ||
2229 | switch (callbackType) | |
2230 | { | |
2231 | case kCFSocketConnectCallBack: | |
2232 | if ( data ) | |
2233 | { | |
2234 | SInt32 error = *((SInt32*)data) ; | |
2235 | CALL_CALLBACK( socket , GSOCK_LOST ) ; | |
2236 | GSocket_Shutdown(socket); | |
2237 | } | |
2238 | else | |
2239 | { | |
2240 | CALL_CALLBACK( socket , GSOCK_CONNECTION ) ; | |
2241 | } | |
2242 | break; | |
2243 | ||
2244 | case kCFSocketReadCallBack: | |
2245 | CALL_CALLBACK( socket , GSOCK_INPUT ) ; | |
2246 | break; | |
2247 | ||
2248 | case kCFSocketWriteCallBack: | |
2249 | CALL_CALLBACK( socket , GSOCK_OUTPUT ) ; | |
2250 | break; | |
2251 | ||
2252 | default: | |
2253 | break; // We shouldn't get here. | |
2254 | } | |
2255 | } | |
2256 | ||
2257 | int GSocket_Read(GSocket *socket, char *buffer, int size) | |
2258 | { | |
2259 | int ret = 0 ; | |
2260 | ||
2261 | assert(socket != NULL); | |
2262 | // if ( !CFReadStreamHasBytesAvailable() ) | |
2263 | ret = CFReadStreamRead( socket->m_readStream , (UInt8*) buffer , size ) ; | |
2264 | ||
2265 | return ret; | |
2266 | } | |
2267 | ||
2268 | int GSocket_Write(GSocket *socket, const char *buffer, int size) | |
2269 | { | |
2270 | int ret; | |
2271 | ||
2272 | assert(socket != NULL); | |
2273 | ret = CFWriteStreamWrite( socket->m_writeStream , (UInt8*) buffer , size ) ; | |
2274 | ||
2275 | return ret; | |
2276 | } | |
2277 | ||
2278 | GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags) | |
2279 | { | |
2280 | assert( socket != NULL ); | |
2281 | ||
2282 | return flags & socket->m_detected; | |
2283 | } | |
2284 | ||
2285 | // ========================================================================== | |
2286 | // wxSocketModule | |
2287 | // ========================================================================== | |
2288 | ||
2289 | class wxSocketModule : public wxModule | |
2290 | { | |
2291 | public: | |
2292 | virtual bool OnInit() | |
2293 | { | |
2294 | // wxSocketBase will call GSocket_Init() itself when/if needed | |
2295 | return true; | |
2296 | } | |
2297 | ||
2298 | virtual void OnExit() | |
2299 | { | |
2300 | if ( wxSocketBase::IsInitialized() ) | |
2301 | wxSocketBase::Shutdown(); | |
2302 | } | |
2303 | ||
2304 | private: | |
2305 | DECLARE_DYNAMIC_CLASS(wxSocketModule) | |
2306 | }; | |
2307 | ||
2308 | IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule) | |
2309 | ||
2310 | #endif | |
2311 | // wxUSE_SOCKETS |