src/common/socket.cpp

   1 ////////////////////////////////////////////////////////////////////////////////
   2 // Name:       socket.cpp
   3 // Purpose:    Socket handler classes
   4 // Authors:    Guilhem Lavaux (completely rewritten from a basic API of Andrew
   5 //             Davidson(1995) in wxWeb)
   6 // Created:    April 1997
   7 // Updated:    March 1998
   8 // Copyright:  (C) 1998, 1997, Guilhem Lavaux
   9 // RCS_ID:     $Id$
  10 // License:    see wxWindows license
  11 ////////////////////////////////////////////////////////////////////////////////
  12 #ifdef __GNUG__
  13 #pragma implementation "socket.h"
  14 // #pragma interface
  15 // #pragma implementation "socket.cpp"
  16 #endif
  17
  18 // For compilers that support precompilation, includes "wx.h".
  19 #include "wx/wxprec.h"
  20
  21 #ifdef __BORLANDC__
  22 #pragma hdrstop
  23 #endif
  24
  25 /////////////////////////////////////////////////////////////////////////////
  26 // wxWindows headers
  27 /////////////////////////////////////////////////////////////////////////////
  28 #include <wx/defs.h>
  29 #include <wx/object.h>
  30 #include <wx/string.h>
  31 #include <wx/timer.h>
  32 #include <wx/utils.h>
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <ctype.h>
  37
  38 /////////////////////////////////////////////////////////////////////////////
  39 // System specific headers
  40 /////////////////////////////////////////////////////////////////////////////
  41 #if defined(__WINDOWS__)
  42 #include <winsock.h>
  43 #endif // __WINDOWS__
  44
  45 #if defined(__UNIX__)
  46
  47 #ifdef VMS
  48 #include <socket.h>
  49 #else
  50 #include <sys/socket.h>
  51 #endif
  52 #include <sys/ioctl.h>
  53
  54 #include <sys/time.h>
  55 #include <unistd.h>
  56
  57 #ifdef sun
  58 #include <sys/filio.h>
  59 #endif
  60
  61 #endif // __UNIX__
  62
  63 #include <signal.h>
  64 #include <errno.h>
  65
  66 #ifdef _MSC_VER
  67 #include <io.h>
  68 #endif
  69
  70 #if defined(__WXMOTIF__) || defined(__WXXT__)
  71 #include <X11/Intrinsic.h>
  72
  73 /////////////////////////////
  74 // Needs internal variables
  75 /////////////////////////////
  76 #ifdef __WXXT__
  77 #define Uses_XtIntrinsic
  78 #endif
  79
  80 #endif
  81
  82 #if defined(__WXGTK__)
  83 #include <gtk/gtk.h>
  84 #endif
  85
  86 /////////////////////////////////////////////////////////////////////////////
  87 // wxSocket headers
  88 /////////////////////////////////////////////////////////////////////////////
  89 #define WXSOCK_INTERNAL
  90 #include "wx/sckaddr.h"
  91 #include "wx/socket.h"
  92
  93 /////////////////////////////////////////////////////////////////////////////
  94 // Some patch ///// BEGIN
  95 /////////////////////////////////////////////////////////////////////////////
  96 #ifdef __WINDOWS__
  97 #define close closesocket
  98 #define ioctl ioctlsocket
  99 #ifdef errno
 100 #undef errno
 101 #endif
 102 #define errno WSAGetLastError()
 103 #ifdef EWOULDBLOCK
 104 #undef EWOULDBLOCK
 105 #endif
 106 #define EWOULDBLOCK WSAEWOULDBLOCK
 107 #define ETIMEDOUT WSAETIMEDOUT
 108 #undef EINTR
 109 #define EINTR WSAEINTR
 110 #endif
 111
 112 #ifndef __WINDOWS__
 113 #define INVALID_SOCKET -1
 114 #endif
 115
 116 #ifdef __WXMOTIF__
 117 #define wxAPP_CONTEXT wxTheApp->appContext
 118 #endif
 119
 120 #ifdef __WINDOWS__
 121 // This is an MS TCP/IP routine and is not needed here. Some WinSock
 122 // implementations (such as PC-NFS) will require you to include this
 123 // or a similar routine (see appendix in WinSock doc or help file).
 124
 125 #if defined( NEED_WSAFDIsSet ) || defined( _MSC_VER )
 126 int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *set)
 127 {
 128         int i = set->fd_count;
 129
 130         while (i--)
 131         {
 132                 if (set->fd_array[i] == fd)
 133                         return 1;
 134         }
 135
 136         return 0;
 137 }
 138 #endif
 139 #endif
 140
 141 #if defined(__WINDOWS__)
 142 #define PROCESS_EVENTS() wxYield()
 143 #elif defined(__WXXT__) || defined(__WXMOTIF__)
 144 #define PROCESS_EVENTS() XtAppProcessEvent(wxAPP_CONTEXT, XtIMAll)
 145 #elif defined(__WXGTK__)
 146 #define PROCESS_EVENTS() gtk_main_iteration()
 147 #endif
 148
 149 /////////////////////////////////////////////////////////////////////////////
 150 // Some patch ///// END
 151 /////////////////////////////////////////////////////////////////////////////
 152
 153 // --------------------------------------------------------------
 154 // ClassInfos
 155 // --------------------------------------------------------------
 156 #if !USE_SHARED_LIBRARY
 157 IMPLEMENT_CLASS(wxSocketBase, wxObject)
 158 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
 159 IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
 160 IMPLEMENT_CLASS(wxSocketHandler, wxObject)
 161 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
 162 #endif
 163
 164 class wxSockWakeUp : public wxTimer {
 165 public:
 166   int *my_id;
 167   int n_val;
 168   wxSocketBase *sock;
 169
 170   wxSockWakeUp(wxSocketBase *_sock, int *id, int new_val) {
 171     my_id = id; n_val = new_val;
 172     sock = _sock;
 173   }
 174   virtual void Notify() {
 175     *my_id = n_val;
 176     if (sock) sock->Notify(FALSE);
 177   }
 178 };
 179
 180 /// Socket request
 181 class SockRequest : public wxObject {
 182 public:
 183   char *buffer;
 184   size_t size, nbytes;
 185   bool done;
 186   int error;
 187   wxSockWakeUp *auto_wakeup;
 188   wxSocketBase::wxRequestNotify type;
 189 };
 190
 191
 192 /////////////////////////////////////////////////////////////////////////////
 193 // Some internal define
 194 /////////////////////////////////////////////////////////////////////////////
 195
 196 // --------------------------------------------------------------
 197 // --------- wxSocketBase CONSTRUCTOR ---------------------------
 198 // --------------------------------------------------------------
 199 wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags,
 200                            wxSocketBase::wxSockType _type) :
 201   wxEvtHandler(),
 202   m_flags(_flags), m_type(_type), m_connected(FALSE), m_connecting(FALSE),
 203   m_fd(INVALID_SOCKET), m_waitflags(0), m_cbk(0), m_cdata(0), m_id(-1),
 204   m_handler(0),
 205   m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)),
 206   m_cbkon(FALSE),
 207   m_unread(NULL), m_unrd_size(0),
 208   m_processing(FALSE),
 209   m_timeout(3600), m_wantbuf(0)
 210 {
 211   m_internal = new wxSockInternal;
 212 #if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__)
 213   m_internal->sock_inputid = 0;
 214   m_internal->sock_outputid = 0;
 215   m_internal->sock_exceptid = 0;
 216 #endif
 217 #ifdef __WINDOWS__
 218   m_internal->my_msg = 0;
 219 #endif
 220 }
 221
 222 wxSocketBase::wxSocketBase() :
 223   wxEvtHandler(),
 224   m_flags(WAITALL), m_type(SOCK_UNINIT), m_connected(FALSE),
 225   m_connecting(FALSE), m_fd(INVALID_SOCKET), m_waitflags(0),
 226   m_cbk(0), m_cdata(0),
 227   m_id(-1), m_handler(0),
 228   m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)),
 229   m_cbkon(FALSE),
 230   m_unread(NULL), m_unrd_size(0),
 231   m_processing(FALSE),
 232   m_timeout(3600), m_wantbuf(0)
 233 {
 234   m_internal = new wxSockInternal;
 235 #if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__)
 236   m_internal->sock_inputid = 0;
 237   m_internal->sock_outputid = 0;
 238   m_internal->sock_exceptid = 0;
 239 #endif
 240 #ifdef __WINDOWS__
 241   m_internal->my_msg = 0;
 242 #endif
 243 }
 244
 245 // --------------------------------------------------------------
 246 // --------- wxSocketBase CONSTRUCTOR ---------------------------
 247 // --------------------------------------------------------------
 248 wxSocketBase::~wxSocketBase()
 249 {
 250   DestroyCallbacks();
 251   Close();
 252
 253   if (m_unread)
 254     free(m_unread);
 255   if (m_handler) {
 256 #ifdef __WINDOWS__
 257     if (m_internal->my_msg)
 258       m_handler->DestroyMessage(m_internal->my_msg);
 259 #endif
 260     m_handler->UnRegister(this);
 261   }
 262   m_states.DeleteContents(TRUE);
 263
 264   delete m_internal;
 265 }
 266
 267 bool wxSocketBase::Close()
 268 {
 269   if (m_fd != INVALID_SOCKET) {
 270     for (int i=0;i<3;i++) {
 271       wxNode *n, *node = req_list[i].First();
 272
 273       while (node) {
 274         SockRequest *req = (SockRequest *)node->Data();
 275         req->done = TRUE;
 276
 277         n = node->Next();
 278         delete node;
 279         node = n;
 280       }
 281     }
 282
 283     DestroyCallbacks();
 284     shutdown(m_fd, 2);
 285     close(m_fd);
 286     m_fd = INVALID_SOCKET;
 287     m_connected = FALSE;
 288   }
 289
 290   return TRUE;
 291 }
 292
 293 // --------------------------------------------------------------
 294 // --------- wxSocketBase base IO functions ---------------------
 295 // --------------------------------------------------------------
 296 wxSocketBase& wxSocketBase::Read(char* buffer, size_t nbytes)
 297 {
 298   m_lcount = GetPushback(buffer, nbytes, FALSE);
 299
 300   // If we have got the whole needed buffer or if we don't want to
 301   // wait then it returns immediately.
 302   if (!nbytes || (m_lcount && !(m_flags & WAITALL)) )
 303     return *this;
 304
 305   WantBuffer(buffer, nbytes, EVT_READ);
 306
 307   return *this;
 308 }
 309
 310 wxSocketBase& wxSocketBase::Peek(char* buffer, size_t nbytes)
 311 {
 312   size_t nbytes_old = nbytes;
 313
 314   nbytes -= GetPushback(buffer, nbytes, TRUE);
 315   if (!nbytes) {
 316     m_lcount = nbytes_old;
 317     return *this;
 318   }
 319
 320   WantBuffer(buffer, nbytes, EVT_PEEK);
 321
 322   return *this;
 323 }
 324
 325 wxSocketBase& wxSocketBase::Write(const char *buffer, size_t nbytes)
 326 {
 327   WantBuffer((char *)buffer, nbytes, EVT_WRITE);
 328   return *this;
 329 }
 330
 331 wxSocketBase& wxSocketBase::ReadMsg(char* buffer, size_t nbytes)
 332 {
 333   SockMsg msg;
 334   size_t len, len2, sig;
 335
 336   Read((char *)&msg, sizeof(msg));
 337   if (m_lcount != sizeof(msg))
 338     return *this;
 339
 340   sig = msg.sig[0] & 0xff;
 341   sig |= (size_t)(msg.sig[1] & 0xff) << 8;
 342   sig |= (size_t)(msg.sig[2] & 0xff) << 16;
 343   sig |= (size_t)(msg.sig[3] & 0xff) << 24;
 344
 345   if (sig != 0xfeeddead)
 346     return *this;
 347   len = msg.len[0] & 0xff;
 348   len |= (size_t)(msg.len[1] & 0xff) << 8;
 349   len |= (size_t)(msg.len[2] & 0xff) << 16;
 350   len |= (size_t)(msg.len[3] & 0xff) << 24;
 351   len2 = len;
 352   if (len > nbytes)
 353     len = nbytes;
 354   else
 355     len2 = 0;
 356
 357   if (Read(buffer, len).LastCount() != len)
 358     return *this;
 359   if (len2 && (Read(NULL, len2).LastCount() != len2))
 360     return *this;
 361   if (Read((char *)&msg, sizeof(msg)).LastCount() != sizeof(msg))
 362     return *this;
 363
 364   sig = msg.sig[0] & 0xff;
 365   sig |= (size_t)(msg.sig[1] & 0xff) << 8;
 366   sig |= (size_t)(msg.sig[2] & 0xff) << 16;
 367   sig |= (size_t)(msg.sig[3] & 0xff) << 24;
 368 // ERROR
 369   if (sig != 0xdeadfeed)
 370     return *this;
 371
 372   return *this;
 373 }
 374
 375 wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes)
 376 {
 377   SockMsg msg;
 378
 379   msg.sig[0] = (char) 0xad;
 380   msg.sig[1] = (char) 0xde;
 381   msg.sig[2] = (char) 0xed;
 382   msg.sig[3] = (char) 0xfe;
 383
 384   msg.len[0] = (char) nbytes & 0xff;
 385   msg.len[1] = (char) (nbytes >> 8) & 0xff;
 386   msg.len[2] = (char) (nbytes >> 16) & 0xff;
 387   msg.len[3] = (char) (nbytes >> 24) & 0xff;
 388
 389   if (Write((char *)&msg, sizeof(msg)).LastCount() < sizeof(msg))
 390     return *this;
 391   if (Write(buffer, nbytes).LastCount() < nbytes)
 392     return *this;
 393
 394   msg.sig[0] = (char) 0xed;
 395   msg.sig[1] = (char) 0xfe;
 396   msg.sig[2] = (char) 0xad;
 397   msg.sig[3] = (char) 0xde;
 398   msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
 399   Write((char *)&msg, sizeof(msg));
 400
 401   return *this;
 402 }
 403
 404 wxSocketBase& wxSocketBase::Unread(const char *buffer, size_t nbytes)
 405 {
 406   CreatePushbackAfter(buffer, nbytes);
 407   return *this;
 408 }
 409
 410 bool wxSocketBase::IsData() const
 411 {
 412   struct timeval tv;
 413   fd_set sock_set;
 414
 415   if (m_fd < 0)
 416     return FALSE;
 417   if (m_unrd_size > 0)
 418     return TRUE;
 419
 420   tv.tv_sec = 0;
 421   tv.tv_usec = 0;
 422   FD_ZERO(&sock_set);
 423   FD_SET(m_fd, &sock_set);
 424   select(FD_SETSIZE, &sock_set, NULL, NULL, &tv);
 425   return (FD_ISSET(m_fd, &sock_set) != 0);
 426 }
 427
 428 // ---------------------------------------------------------------------
 429 // --------- wxSocketBase Discard(): deletes all byte in the input queue
 430 // ---------------------------------------------------------------------
 431 void wxSocketBase::Discard()
 432 {
 433 #define MAX_BUFSIZE (10*1024)
 434   char *my_data = new char[MAX_BUFSIZE];
 435   size_t recv_size = MAX_BUFSIZE;
 436
 437   SaveState();
 438   SetFlags((wxSockFlags)(NOWAIT | SPEED));
 439
 440   while (recv_size == MAX_BUFSIZE) {
 441     recv_size = Read(my_data, MAX_BUFSIZE).LastCount();
 442   }
 443
 444   RestoreState();
 445   delete [] my_data;
 446
 447 #undef MAX_BUFSIZE
 448 }
 449
 450 // --------------------------------------------------------------
 451 // --------- wxSocketBase socket info functions -----------------
 452 // --------------------------------------------------------------
 453 bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
 454 {
 455   struct sockaddr my_addr;
 456   size_t len_addr = sizeof(my_addr);
 457
 458   if (m_fd < 0)
 459     return FALSE;
 460
 461   if (getpeername(m_fd, (struct sockaddr *)&my_addr, (int *)&len_addr) < 0)
 462     return FALSE;
 463
 464   addr_man.Disassemble(&my_addr, len_addr);
 465   return TRUE;
 466 }
 467
 468 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
 469 {
 470   struct sockaddr my_addr;
 471   size_t len_addr = sizeof(my_addr);
 472
 473   if (m_fd < 0)
 474     return FALSE;
 475
 476   if (getsockname(m_fd, (struct sockaddr *)&my_addr, (int *)&len_addr) < 0)
 477     return FALSE;
 478
 479   addr_man.Disassemble(&my_addr, len_addr);
 480   return TRUE;
 481 }
 482
 483 // --------------------------------------------------------------
 484 // --------- wxSocketBase wait functions ------------------------
 485 // --------------------------------------------------------------
 486 void wxSocketBase::SaveState()
 487 {
 488   wxSockState *state = new wxSockState;
 489
 490   state->cbk_on = m_cbkon;
 491   state->cbk_set= m_neededreq;
 492   state->cbk    = m_cbk;
 493   state->cdata  = m_cdata;
 494   state->flags  = m_flags;
 495   state->notif  = m_notifyme;
 496
 497   m_states.Append(state);
 498 }
 499
 500 void wxSocketBase::RestoreState()
 501 {
 502   wxNode *node;
 503
 504   node = m_states.Last();
 505   if (!node)
 506     return;
 507
 508   wxSockState *state = (wxSockState *)node->Data();
 509
 510   SetFlags(state->flags);
 511   m_neededreq = state->cbk_set;
 512   m_cbk       = state->cbk;
 513   m_cdata     = state->cdata;
 514   m_notifyme  = state->notif;
 515   if (state->cbk_on)
 516     SetupCallbacks();
 517   else
 518     DestroyCallbacks();
 519
 520   delete node;
 521   delete state;
 522 }
 523
 524 // --------------------------------------------------------------
 525 // --------- wxSocketBase wait functions ------------------------
 526 // --------------------------------------------------------------
 527 //
 528 bool wxSocketBase::_Wait(long seconds, long microseconds, int type)
 529 {
 530   if ((!m_connected && !m_connecting) || m_fd < 0)
 531     return FALSE;
 532
 533   wxSockWakeUp wakeup(this, &m_waitflags, 0);
 534
 535   SaveState();
 536   SetNotify((wxRequestNotify)type);
 537   SetupCallbacks();
 538
 539   if (seconds != -1)
 540     wakeup.Start((int)(seconds*1000 + (microseconds / 1000)), TRUE);
 541
 542   m_waitflags = 0x80 | type;
 543   while (m_waitflags & 0x80)
 544     PROCESS_EVENTS();
 545
 546   RestoreState();
 547
 548   if (m_waitflags & 0x40) {
 549     m_waitflags = 0;
 550     return TRUE;
 551   }
 552   m_waitflags = 0;
 553
 554   return FALSE;
 555 }
 556
 557 bool wxSocketBase::Wait(long seconds, long microseconds)
 558 {
 559   return _Wait(seconds, microseconds, REQ_ACCEPT | REQ_CONNECT |
 560                                       REQ_READ | REQ_WRITE | REQ_LOST);
 561 }
 562
 563 bool wxSocketBase::WaitForRead(long seconds, long microseconds)
 564 {
 565   return _Wait(seconds, microseconds, REQ_READ | REQ_LOST);
 566 }
 567
 568 bool wxSocketBase::WaitForWrite(long seconds, long microseconds)
 569 {
 570   return _Wait(seconds, microseconds, REQ_WRITE);
 571 }
 572
 573 bool wxSocketBase::WaitForLost(long seconds, long microseconds)
 574 {
 575   return _Wait(seconds, microseconds, REQ_LOST);
 576 }
 577
 578 // --------------------------------------------------------------
 579 // --------- wxSocketBase callback management -------------------
 580 // --------------------------------------------------------------
 581
 582 #if defined(__WXMOTIF__) || defined(__WXXT__) || defined(__WXGTK__)
 583 #if defined(__WXMOTIF__) || defined(__WXXT__)
 584 static void wx_socket_read(XtPointer client, int *fid,
 585                            XtInputId *WXUNUSED(id))
 586 #define fd *fid
 587 #else
 588 static void wx_socket_read(gpointer client, gint fd,
 589                            GdkInputCondition WXUNUSED(cond))
 590 #define fd fd
 591 #endif
 592 {
 593   wxSocketBase *sock = (wxSocketBase *)client;
 594   char c;
 595   int i;
 596
 597   i = recv(fd, &c, 1, MSG_PEEK);
 598
 599   if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT)) {
 600     sock->OnRequest(wxSocketBase::EVT_ACCEPT);
 601     return;
 602   }
 603
 604   if (i != 0) {
 605     if (!(sock->NeededReq() & wxSocketBase::REQ_READ))
 606       return;
 607
 608     sock->OnRequest(wxSocketBase::EVT_READ);
 609   } else {
 610     if (!(sock->NeededReq() & wxSocketBase::REQ_LOST)) {
 611       sock->Close();
 612       return;
 613     }
 614
 615     sock->OnRequest(wxSocketBase::EVT_LOST);
 616   }
 617 }
 618 #undef fd
 619
 620 #if defined(__WXMOTIF__) || defined(__WXXT__)
 621 static void wx_socket_write(XtPointer client, int *WXUNUSED(fid),
 622                             XtInputId *WXUNUSED(id))
 623 #else
 624 static void wx_socket_write(gpointer client, gint WXUNUSED(fd),
 625                             GdkInputCondition WXUNUSED(cond))
 626 #endif
 627 {
 628   wxSocketBase *sock = (wxSocketBase *)client;
 629
 630   if (!sock->IsConnected())
 631     sock->OnRequest(wxSocketBase::EVT_CONNECT);
 632   else
 633     sock->OnRequest(wxSocketBase::EVT_WRITE);
 634 }
 635 #endif
 636
 637 #ifdef wx_xview
 638 Notify_value wx_sock_read_xview (Notify_client client, int fd)
 639 {
 640   wxSocketBase *sock = (wxSocketBase *)client;
 641   char c;
 642   int i;
 643
 644   i = recv(fd, &c, 1, MSG_PEEK);
 645
 646   if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT)) {
 647     sock->OnRequest(wxSocketBase::EVT_ACCEPT);
 648     return;
 649   }
 650
 651   /* Bytes arrived */
 652   if (i != 0) {
 653     if (!(sock->NeededReq() & wxSocketBase::REQ_READ))
 654       return (Notify_value) FALSE;
 655
 656     sock->OnRequest(wxSocketBase::EVT_READ);
 657   } else {
 658     if (!(sock->NeededReq() & wxSocketBase::REQ_LOST))
 659       return;
 660
 661     sock->OnRequest(wxSocketBase::EVT_LOST);
 662   }
 663
 664   return (Notify_value) FALSE;
 665 }
 666
 667 Notify_value wx_sock_write_xview (Notify_client client, int fd)
 668 {
 669   wxSocketBase *sock = (wxSocketBase *)client;
 670
 671   if (!sock->IsConnected())
 672     sock->OnRequest(wxSocketBase::EVT_CONNECT);
 673   else
 674     sock->OnRequest(wxSocketBase::EVT_WRITE);
 675
 676   return (Notify_value) TRUE;
 677 }
 678 #endif
 679
 680 wxSocketBase::wxRequestNotify wxSocketBase::EventToNotify(wxRequestEvent evt)
 681 {
 682   switch (evt) {
 683   case EVT_READ:
 684     return REQ_READ;
 685   case EVT_PEEK:
 686     return REQ_PEEK;
 687   case EVT_WRITE:
 688     return REQ_WRITE;
 689   case EVT_LOST:
 690     return REQ_LOST;
 691   case EVT_ACCEPT:
 692     return REQ_ACCEPT;
 693   case EVT_CONNECT:
 694     return REQ_CONNECT;
 695   }
 696   return 0;
 697 }
 698
 699 void wxSocketBase::SetFlags(wxSockFlags _flags)
 700 {
 701   m_flags = _flags;
 702   if (_flags & SPEED) {
 703     unsigned long flag = 0;
 704     ioctl(m_fd, FIONBIO, &flag);
 705
 706     // SPEED and WAITALL are antagonists.
 707     m_flags = (wxSockFlags)(m_flags & ~WAITALL);
 708
 709     Notify(FALSE);
 710   } else {
 711     unsigned long flag = 1;
 712     ioctl(m_fd, FIONBIO, &flag);
 713   }
 714 }
 715
 716 void wxSocketBase::SetNotify(wxRequestNotify flags)
 717 {
 718   wxRequestNotify old_needed_req = m_neededreq;
 719   if (flags & REQ_ACCEPT) {
 720     /* Check if server */
 721     if (!(GetClassInfo()->IsKindOf(CLASSINFO(wxSocketServer))))
 722       flags &= ~REQ_ACCEPT;
 723   }
 724   m_neededreq = flags;
 725   if (m_cbkon && old_needed_req != flags)
 726     SetupCallbacks();
 727 }
 728
 729 void wxSocketBase::SetupCallbacks()
 730 {
 731   if (m_fd == INVALID_SOCKET || !m_handler || (m_flags & SPEED))
 732     return;
 733
 734 #if defined(__WXMOTIF__) || defined(__WXXT__) || defined(__WXGTK__)
 735   if (m_cbkon)
 736     DestroyCallbacks();
 737   if (m_neededreq & (REQ_ACCEPT | REQ_READ | REQ_LOST)) {
 738 #ifdef __WXGTK__
 739     m_internal->sock_inputid = gdk_input_add(m_fd, GDK_INPUT_READ,
 740                                            wx_socket_read, (gpointer)this);
 741 #else
 742     m_internal->sock_inputid = XtAppAddInput (wxAPP_CONTEXT, m_fd,
 743                                         (XtPointer *) XtInputReadMask,
 744                                         (XtInputCallbackProc) wx_socket_read,
 745                                         (XtPointer) this);
 746 #endif
 747   }
 748   if (m_neededreq & (REQ_CONNECT | REQ_WRITE)) {
 749 #ifdef __WXGTK__
 750     m_internal->sock_inputid = gdk_input_add(m_fd, GDK_INPUT_WRITE,
 751                                              wx_socket_write, (gpointer)this);
 752 #else
 753     m_internal->sock_outputid = XtAppAddInput (wxAPP_CONTEXT, m_fd,
 754                                         (XtPointer *) XtInputWriteMask,
 755                                         (XtInputCallbackProc) wx_socket_write,
 756                                         (XtPointer) this);
 757 #endif
 758   }
 759 #endif
 760 #ifdef __WINDOWS__
 761   WORD mask = 0;
 762
 763   if (m_neededreq & REQ_READ)
 764     mask |= FD_READ;
 765   if (m_neededreq & REQ_WRITE)
 766     mask |= FD_WRITE;
 767   if (m_neededreq & REQ_LOST)
 768     mask |= FD_CLOSE;
 769   if (m_neededreq & REQ_ACCEPT)
 770     mask |= FD_ACCEPT;
 771   if (m_neededreq & REQ_CONNECT)
 772     mask |= FD_CONNECT;
 773
 774   if (!m_internal->my_msg)
 775     m_internal->my_msg = m_handler->NewMessage(this);
 776   WSAAsyncSelect(m_fd, m_handler->GetHWND(), m_internal->my_msg, mask);
 777 #endif
 778   m_cbkon = TRUE;
 779   m_processing = FALSE;
 780 }
 781
 782 void wxSocketBase::DestroyCallbacks()
 783 {
 784   if (!m_cbkon || !m_handler)
 785     return;
 786   m_cbkon = FALSE;
 787   m_processing = FALSE;
 788 #if defined(__WXMOTIF__) || defined(__WXXT__)
 789   if (m_internal->sock_inputid > 0)
 790     XtRemoveInput(m_internal->sock_inputid);
 791   m_internal->sock_inputid = 0;
 792   if (m_internal->sock_outputid > 0)
 793     XtRemoveInput(m_internal->sock_outputid);
 794   m_internal->sock_outputid = 0;
 795 #endif
 796 #ifdef __WXGTK__
 797   if (m_internal->sock_inputid > 0)
 798     gdk_input_remove(m_internal->sock_inputid);
 799   m_internal->sock_inputid = 0;
 800   if (m_internal->sock_outputid > 0)
 801     gdk_input_remove(m_internal->sock_outputid);
 802   m_internal->sock_outputid = 0;
 803 #endif
 804 #ifdef __WINDOWS__
 805   WSAAsyncSelect(m_fd, m_handler->GetHWND(), 0, 0);
 806 #endif
 807 }
 808
 809 void wxSocketBase::Notify(bool notify)
 810 {
 811   if (m_notifyme == notify)
 812     return;
 813   if (notify)
 814     SetupCallbacks();
 815   else
 816     DestroyCallbacks();
 817   m_notifyme = notify;
 818 }
 819
 820 void wxSocketBase::OnRequest(wxRequestEvent req_evt)
 821 {
 822   wxRequestNotify req_notif = EventToNotify(req_evt);
 823
 824   // Mask the current event
 825   SetNotify(m_neededreq & ~req_notif);
 826
 827   if (req_evt <= EVT_WRITE && DoRequests(req_evt))
 828     return;
 829
 830   if (m_waitflags & 0xF0) {
 831     // Wake up
 832     if ((m_waitflags & 0x0F) == req_evt) {
 833       m_waitflags = 0x80;
 834 #ifndef __WXGTK__
 835       DestroyCallbacks();  // I disable it to prevent infinite loop on X11.
 836 #endif
 837     }
 838     return;
 839   }
 840
 841   if (req_evt == EVT_LOST) {
 842     m_connected = FALSE;
 843     Close();
 844   }
 845   if (m_notifyme)
 846     OldOnNotify(req_evt);
 847
 848   // Unmask
 849   SetNotify(m_neededreq | req_notif);
 850 }
 851
 852 wxSocketEvent::wxSocketEvent(int id)
 853   : wxEvent(id)
 854 {
 855   wxEventType type = (wxEventType)wxEVT_SOCKET;
 856
 857   SetEventType(type);
 858 }
 859
 860 void wxSocketBase::OldOnNotify(wxRequestEvent evt)
 861 {
 862   wxSocketEvent event(m_id);
 863
 864   event.SetEventObject(this);
 865   event.m_skevt = evt;
 866   ProcessEvent(event);
 867
 868   if (m_cbk)
 869     m_cbk(*this, evt, m_cdata);
 870 }
 871
 872 // --------------------------------------------------------------
 873 // --------- wxSocketBase functions [Callback, CallbackData] ----
 874 // --------------------------------------------------------------
 875 wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSocketBase::wxSockCbk _cbk)
 876 {
 877   wxSockCbk old_cbk = m_cbk;
 878
 879   m_cbk = _cbk;
 880   return old_cbk;
 881 }
 882
 883 char *wxSocketBase::CallbackData(char *cdata_)
 884 {
 885   char *old_cdata = m_cdata;
 886
 887   m_cdata = cdata_;
 888   return old_cdata;
 889 }
 890
 891 void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id)
 892 {
 893   SetNextHandler(&h_evt);
 894   m_id = id;
 895 }
 896
 897 // --------------------------------------------------------------
 898 // --------- wxSocketBase pushback library ----------------------
 899 // --------------------------------------------------------------
 900 void wxSocketBase::CreatePushbackAfter(const char *buffer, size_t size)
 901 {
 902   char *curr_pos;
 903
 904   m_unread = (char *) realloc(m_unread, m_unrd_size+size);
 905   curr_pos = m_unread + m_unrd_size;
 906
 907   memcpy(curr_pos, buffer, size);
 908   m_unrd_size += size;
 909 }
 910
 911 void wxSocketBase::CreatePushbackBefore(const char *buffer, size_t size)
 912 {
 913   char *curr_pos, *new_buf;
 914
 915   new_buf = (char *) malloc(m_unrd_size+size);
 916   curr_pos = new_buf + size;
 917
 918   memcpy(new_buf, buffer, size);
 919   memcpy(curr_pos, m_unread, m_unrd_size);
 920
 921   free(m_unread);
 922   m_unread = new_buf;
 923   m_unrd_size += size;
 924 }
 925
 926 size_t wxSocketBase::GetPushback(char *buffer, size_t size, bool peek)
 927 {
 928   if (!m_unrd_size)
 929     return 0;
 930
 931   if (size > m_unrd_size)
 932     size = m_unrd_size;
 933   memcpy(buffer, m_unread, size);
 934
 935   if (!peek) {
 936     m_unrd_size -= size;
 937     if (!m_unrd_size) {
 938       free(m_unread);
 939       m_unread = NULL;
 940     }
 941   }
 942
 943   return size;
 944 }
 945
 946 // --------------------------------------------------------------
 947 // --------- wxSocketBase "multi-thread" core -------------------
 948 // --------------------------------------------------------------
 949
 950 bool wxSocketBase::DoRequests(wxRequestEvent req_flag)
 951 {
 952   wxNode *node = req_list[req_flag].First();
 953   size_t len;
 954   int ret;
 955
 956   if (!node)
 957     return FALSE;
 958
 959   SockRequest *req = (SockRequest *)node->Data();
 960
 961   delete node;
 962
 963   switch (req->type) {
 964   case EVT_READ:
 965   case EVT_PEEK:
 966     ret = recv(m_fd, req->buffer, req->size,
 967                (req->type == EVT_PEEK) ? MSG_PEEK : 0);
 968     if (ret < 0) {
 969       req->error = errno;
 970       req->done = TRUE;
 971       break;
 972     }
 973     len = ret;
 974     if ((len < req->size) && (m_flags & WAITALL)) {
 975       req->size -= len;
 976       req->nbytes += len;
 977       req->buffer += len;
 978       req->auto_wakeup->Start(m_timeout*1000, TRUE);
 979       req_list[req_flag].Insert(req);
 980       break;
 981     }
 982     req->done = TRUE;
 983     req->nbytes += len;
 984 #ifndef __WXGTK__
 985     DestroyCallbacks();
 986 #endif
 987     break;
 988   case EVT_WRITE:
 989     ret = send(m_fd, req->buffer, req->size, 0);
 990     if (ret < 0) {
 991       req->error = errno;
 992       req->done = TRUE;
 993       break;
 994     }
 995     len = ret;
 996     if ((len < req->size) && (m_flags & WAITALL)) {
 997       req->size -= len;
 998       req->nbytes += len;
 999       req->buffer += len;
1000       req->auto_wakeup->Start(m_timeout*1000, TRUE);
1001       req_list[req_flag].Insert(req);
1002       break;
1003     }
1004     req->done = TRUE;
1005     req->nbytes += len;
1006 #ifndef __WXGTK__
1007     DestroyCallbacks();
1008 #endif
1009     break;
1010   default:
1011     return FALSE;
1012   }
1013   return TRUE;
1014 }
1015
1016 void wxSocketBase::WantSpeedBuffer(char *buffer, size_t nbytes,
1017                                    wxRequestEvent evt)
1018 {
1019   int ret = 0;
1020
1021   switch (evt) {
1022   case EVT_PEEK:
1023   case EVT_READ:
1024     ret = recv(m_fd, buffer, nbytes,
1025                (evt == EVT_PEEK) ? MSG_PEEK : 0);
1026     break;
1027   case EVT_WRITE:
1028     ret = send(m_fd, buffer, nbytes, 0);
1029     break;
1030   }
1031   if (ret < 0) {
1032     m_lcount = 0;
1033     m_error = errno;
1034   } else
1035     m_lcount = ret;
1036 }
1037
1038 void wxSocketBase::WantBuffer(char *buffer, size_t nbytes,
1039                               wxRequestEvent evt)
1040 {
1041   bool buf_timed_out;
1042
1043   if (m_fd == INVALID_SOCKET || !m_handler || !m_connected)
1044     return;
1045
1046   if (m_flags & SPEED) {
1047     WantSpeedBuffer(buffer, nbytes, evt);
1048     return;
1049   }
1050
1051   SockRequest *buf = new SockRequest;
1052   wxSockWakeUp s_wake(NULL, (int *)&buf_timed_out, (int)TRUE);
1053
1054   m_wantbuf++;
1055   req_list[evt].Append(buf);
1056
1057   SaveState();
1058   SetNotify(REQ_LOST | EventToNotify(evt));
1059   SetupCallbacks();
1060   buf->buffer = buffer;
1061   buf->size = nbytes;
1062   buf->done = FALSE;
1063   buf->type = evt;
1064   buf->nbytes = 0;
1065   buf->auto_wakeup = &s_wake;
1066   buf->error = 0;
1067   buf_timed_out = FALSE;
1068
1069   s_wake.Start(m_timeout*1000, TRUE);
1070   if (m_flags & NOWAIT) {
1071     DoRequests(evt);
1072   } else {
1073     while (!buf->done && !buf_timed_out)
1074       PROCESS_EVENTS();
1075   }
1076   m_wantbuf--;
1077   m_lcount = buf->nbytes;
1078   if (buf_timed_out)
1079     m_error = ETIMEDOUT;
1080   else
1081     m_error = buf->error;
1082
1083   delete buf;
1084   RestoreState();
1085 }
1086
1087 // --------------------------------------------------------------
1088 // wxSocketServer ///////////////////////////////////////////////
1089 // --------------------------------------------------------------
1090
1091 // --------------------------------------------------------------
1092 // --------- wxSocketServer CONSTRUCTOR -------------------------
1093 // --------------------------------------------------------------
1094 wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
1095                                wxSockFlags flags) :
1096   wxSocketBase(flags, SOCK_SERVER)
1097 {
1098   m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
1099
1100   if (m_fd == INVALID_SOCKET)
1101     return;
1102
1103   int flag = 1;
1104   setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&flag, sizeof(int));
1105
1106   struct sockaddr *myaddr;
1107   size_t len;
1108
1109   addr_man.Build(myaddr, len);
1110   if (bind(m_fd, myaddr, addr_man.SockAddrLen()) < 0)
1111     return;
1112
1113   if (listen(m_fd, 5) < 0) {
1114     m_fd = INVALID_SOCKET;
1115     return;
1116   }
1117 }
1118
1119 // --------------------------------------------------------------
1120 // --------- wxSocketServer Accept ------------------------------
1121 // --------------------------------------------------------------
1122 bool wxSocketServer::AcceptWith(wxSocketBase& sock)
1123 {
1124   int fd2;
1125
1126   if ((fd2 = accept(m_fd, 0, 0)) < 0)
1127     return FALSE;
1128
1129   struct linger linger;
1130   linger.l_onoff = 0;
1131   linger.l_linger = 1;
1132
1133   setsockopt(fd2, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
1134
1135   int flag = 0;
1136   setsockopt(fd2, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
1137
1138   if (!(sock.m_flags & SPEED)) {
1139     unsigned long flag2 = 1;
1140     ioctl(fd2, FIONBIO, &flag2);
1141   }
1142
1143   sock.m_type = SOCK_INTERNAL;
1144   sock.m_fd = fd2;
1145   sock.m_connected = TRUE;
1146
1147   return TRUE;
1148 }
1149
1150 wxSocketBase *wxSocketServer::Accept()
1151 {
1152   wxSocketBase* sock = new wxSocketBase();
1153
1154   sock->SetFlags((wxSockFlags)m_flags);
1155
1156   if (!AcceptWith(*sock))
1157     return NULL;
1158
1159   if (m_handler)
1160     m_handler->Register(sock);
1161
1162   return sock;
1163 }
1164
1165 // --------------------------------------------------------------
1166 // --------- wxSocketServer callbacks ---------------------------
1167 // --------------------------------------------------------------
1168 void wxSocketServer::OnRequest(wxRequestEvent evt)
1169 {
1170   if (evt == EVT_ACCEPT) {
1171     OldOnNotify(EVT_ACCEPT);
1172   }
1173 }
1174
1175 // --------------------------------------------------------------
1176 // wxSocketClient ///////////////////////////////////////////////
1177 // --------------------------------------------------------------
1178
1179 // --------- wxSocketClient CONSTRUCTOR -------------------------
1180 // --------------------------------------------------------------
1181 wxSocketClient::wxSocketClient(wxSockFlags _flags) :
1182         wxSocketBase(_flags, SOCK_CLIENT)
1183 {
1184 }
1185
1186 // --------------------------------------------------------------
1187 // --------- wxSocketClient DESTRUCTOR --------------------------
1188 // --------------------------------------------------------------
1189 wxSocketClient::~wxSocketClient()
1190 {
1191 }
1192
1193 // --------------------------------------------------------------
1194 // --------- wxSocketClient Connect functions -------------------
1195 // --------------------------------------------------------------
1196 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) )
1197 {
1198   struct linger linger;
1199
1200   if (IsConnected())
1201     Close();
1202
1203   m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
1204
1205   if (m_fd < 0)
1206     return FALSE;
1207
1208   m_connected = FALSE;
1209
1210   linger.l_onoff = 1;
1211   linger.l_linger = 5;
1212   setsockopt(m_fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
1213
1214   // Stay in touch with the state of things...
1215
1216   unsigned long flag = 1;
1217   setsockopt(m_fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
1218
1219   // Disable the nagle algorithm, which delays sends till the
1220   // buffer is full (or a certain time period has passed?)...
1221
1222 #if defined(__WINDOWS__) || (defined(IPPROTO_TCP) && defined(TCP_NODELAY))
1223   flag = 1;
1224   setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int));
1225 #endif
1226
1227   struct sockaddr *remote;
1228   size_t len;
1229
1230   addr_man.Build(remote, len);
1231
1232   if (connect(m_fd, remote, len) != 0)
1233     return FALSE;
1234
1235   if (!(m_flags & SPEED)) {
1236     flag = 1;
1237     ioctl(m_fd, FIONBIO, &flag);
1238   }
1239
1240   Notify(TRUE);
1241
1242   m_connected = TRUE;
1243   return TRUE;
1244 }
1245
1246 bool wxSocketClient::WaitOnConnect(long seconds)
1247 {
1248   int ret = _Wait(seconds, 0, REQ_CONNECT | REQ_LOST);
1249
1250   if (ret)
1251     m_connected = TRUE;
1252
1253   return m_connected;
1254 }
1255
1256 void wxSocketClient::OnRequest(wxRequestEvent evt)
1257 {
1258   if (evt == EVT_CONNECT) {
1259     if (m_connected) {
1260       SetNotify(m_neededreq & ~REQ_CONNECT);
1261       return;
1262     }
1263     m_waitflags = 0x40;
1264     m_connected = TRUE;
1265     OldOnNotify(EVT_CONNECT);
1266     DestroyCallbacks();
1267     return;
1268   }
1269   wxSocketBase::OnRequest(evt);
1270 }
1271
1272 /////////////////////////////////////////////////////////////////
1273 // wxSocketHandler ///////////////////////////////////////////////
1274 /////////////////////////////////////////////////////////////////
1275
1276 wxSocketHandler *wxSocketHandler::master = NULL;
1277 #if defined(__WINDOWS__)
1278 static int win_initialized = 0;
1279 #endif
1280
1281 // --------------------------------------------------------------
1282 // --------- wxSocketHandler CONSTRUCTOR ------------------------
1283 // --------------------------------------------------------------
1284 #ifdef __WINDOWS__
1285
1286 extern char wxPanelClassName[];
1287
1288 LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd, UINT message,
1289    WPARAM wParam, LPARAM lParam)
1290 {
1291   wxSocketHandler *h_sock = (wxSocketHandler *)GetWindowLong(hWnd, GWL_USERDATA);
1292   wxNode *node = h_sock->smsg_list->Find(message);
1293   wxSocketBase *sock;
1294   wxSocketBase::wxRequestEvent sk_req;
1295   UINT event = WSAGETSELECTEVENT(lParam);
1296
1297   if (!node)
1298     return DefWindowProc(hWnd, message, wParam, lParam);
1299
1300   sock = (wxSocketBase *)node->Data();
1301
1302   switch (event) {
1303   case FD_READ:
1304     sk_req = wxSocketBase::EVT_READ;
1305     break;
1306   case FD_WRITE:
1307     sk_req = wxSocketBase::EVT_WRITE;
1308     break;
1309   case FD_CLOSE:
1310     sk_req = wxSocketBase::EVT_LOST;
1311     break;
1312   case FD_ACCEPT:
1313     sk_req = wxSocketBase::EVT_ACCEPT;
1314     break;
1315   case FD_CONNECT:
1316     sk_req = wxSocketBase::EVT_CONNECT;
1317     break;
1318   }
1319   sock->OnRequest(sk_req);
1320
1321   return (LRESULT)0;
1322 }
1323
1324 FARPROC wxSocketSubClassProc = NULL;
1325
1326 #endif
1327
1328 wxSocketHandler::wxSocketHandler()
1329 {
1330 #if defined(__WINDOWS__)
1331   if (!win_initialized) {
1332     WSADATA wsaData;
1333
1334     WSAStartup((1 << 8) | 1, &wsaData);
1335     win_initialized = 1;
1336   }
1337   internal = new wxSockHandlerInternal;
1338   internal->sockWin = ::CreateWindow(wxPanelClassName, NULL, 0,
1339                 0, 0, 0, 0, NULL, (HMENU) NULL,
1340                 wxhInstance, 0);
1341
1342   // Subclass the window
1343   if (!wxSocketSubClassProc)
1344     wxSocketSubClassProc = MakeProcInstance((FARPROC) wxSocketHandlerWndProc, wxhInstance);
1345   ::SetWindowLong(internal->sockWin, GWL_WNDPROC, (LONG) wxSocketSubClassProc);
1346   ::SetWindowLong(internal->sockWin, GWL_USERDATA, (LONG) this);
1347
1348   internal->firstAvailableMsg = 5000;
1349   smsg_list = new wxList(wxKEY_INTEGER);
1350 #endif
1351
1352   socks = new wxList;
1353
1354 #ifndef __WINDOWS__
1355   signal(SIGPIPE, SIG_IGN);
1356 #endif
1357 }
1358
1359 // --------------------------------------------------------------
1360 // --------- wxSocketHandler DESTRUCTOR -------------------------
1361 // --------------------------------------------------------------
1362 wxSocketHandler::~wxSocketHandler()
1363 {
1364   wxNode *next_node, *node = socks->First();
1365
1366   while (node) {
1367     wxSocketBase* sock = (wxSocketBase*)node->Data();
1368
1369     delete sock;
1370     next_node = node->Next();
1371     delete node;
1372     node = next_node;
1373   }
1374
1375   delete socks;
1376
1377 #ifdef __WINDOWS__
1378   delete smsg_list;
1379
1380   ::DestroyWindow(internal->sockWin);
1381   WSACleanup();
1382   win_initialized = 0;
1383
1384   delete internal;
1385 #endif
1386 }
1387
1388 // --------------------------------------------------------------
1389 // --------- wxSocketHandler registering functions --------------
1390 // --------------------------------------------------------------
1391 void wxSocketHandler::Register(wxSocketBase* sock)
1392 {
1393   wxNode *node;
1394
1395   for (node = socks->First(); node != NULL; node = node->Next()) {
1396     wxSocketBase* s = (wxSocketBase*)node->Data();
1397
1398     if (s == sock)
1399       return;
1400   }
1401
1402   if (sock) {
1403     socks->Append(sock);
1404     sock->SetHandler(this);
1405     sock->SetupCallbacks();
1406   }
1407 }
1408
1409 void wxSocketHandler::UnRegister(wxSocketBase* sock)
1410 {
1411   wxNode *node;
1412
1413   for (node = socks->First(); node; node = node->Next()) {
1414     wxSocketBase* s = (wxSocketBase*)node->Data();
1415
1416     if (s == sock) {
1417       delete node;
1418       sock->DestroyCallbacks();
1419       sock->SetHandler(NULL);
1420       return;
1421     }
1422   }
1423 }
1424
1425 unsigned long wxSocketHandler::Count() const
1426 {
1427   return socks->Number();
1428 }
1429
1430 // --------------------------------------------------------------
1431 // --------- wxSocketHandler "big" wait functions ---------------
1432 // --------------------------------------------------------------
1433 void handler_cbk(wxSocketBase& sock,
1434                  wxSocketBase::wxRequestEvent WXUNUSED(flags),
1435                  char *cdata)
1436 {
1437   int *a_wait = (int *)cdata;
1438
1439   (*a_wait)++;
1440   sock.Notify(FALSE);
1441 }
1442
1443 int wxSocketHandler::Wait(long seconds, long microseconds)
1444 {
1445   int i;
1446   int on_wait;
1447   wxSockWakeUp s_wake(NULL, &on_wait, -2);
1448   wxNode *node;
1449
1450   for (node = socks->First(), i=0; node; node = node->Next(), i++) {
1451     wxSocketBase *sock = (wxSocketBase *)node->Data();
1452
1453     sock->SaveState();
1454
1455     sock->SetupCallbacks();
1456
1457     sock->Callback(handler_cbk);
1458     sock->CallbackData((char *)&on_wait);
1459   }
1460   on_wait = 0;
1461   if (seconds != -1)
1462     s_wake.Start((seconds*1000) + (microseconds/1000), TRUE);
1463
1464   while (!on_wait)
1465     PROCESS_EVENTS();
1466
1467   for (node = socks->First(), i=0; node; node = node->Next(), i++) {
1468     wxSocketBase *sock = (wxSocketBase *)node->Data();
1469
1470     sock->RestoreState();
1471   }
1472
1473   if (on_wait == -2)
1474     return 0;
1475
1476   return on_wait;
1477 }
1478
1479 void wxSocketHandler::YieldSock()
1480 {
1481   wxNode *node;
1482
1483   for (node = socks->First(); node; node = node->Next() ) {
1484     wxSocketBase *sock = (wxSocketBase *)node->Data();
1485
1486     sock->SaveState();
1487
1488     sock->SetFlags(wxSocketBase::SPEED);
1489     if (sock->IsData())
1490       sock->DoRequests(wxSocketBase::EVT_READ);
1491     sock->DoRequests(wxSocketBase::EVT_WRITE);
1492
1493     sock->RestoreState();
1494   }
1495 }
1496
1497 // --------------------------------------------------------------
1498 // --------- wxSocketHandler: create and register the socket ----
1499 // --------------------------------------------------------------
1500 wxSocketServer *wxSocketHandler::CreateServer(wxSockAddress& addr,
1501                                               wxSocketBase::wxSockFlags flags)
1502 {
1503   wxSocketServer *serv = new wxSocketServer(addr, flags);
1504
1505   Register(serv);
1506   return serv;
1507 }
1508
1509 wxSocketClient *wxSocketHandler::CreateClient(wxSocketBase::wxSockFlags flags)
1510 {
1511   wxSocketClient *client = new wxSocketClient(flags);
1512
1513   Register(client);
1514   return client;
1515 }
1516
1517 #ifdef __WINDOWS__
1518 // --------------------------------------------------------------
1519 // --------- wxSocketHandler: Windows specific methods ----------
1520 // --------------------------------------------------------------
1521 UINT wxSocketHandler::NewMessage(wxSocketBase *sock)
1522 {
1523   internal->firstAvailableMsg++;
1524   smsg_list->Append(internal->firstAvailableMsg, sock);
1525   return internal->firstAvailableMsg;
1526 }
1527
1528 void wxSocketHandler::DestroyMessage(UINT msg)
1529 {
1530   wxNode *node = smsg_list->Find(msg);
1531   delete node;
1532 }
1533
1534 HWND wxSocketHandler::GetHWND() const
1535 {
1536   return internal->sockWin;
1537 }
1538
1539 #endif