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