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 #ifdef __WINDOWS__
 462   if (getpeername(m_fd, (struct sockaddr *)&my_addr, (int *)&len_addr) < 0)
 463 #else
 464   if (getpeername(m_fd, (struct sockaddr *)&my_addr, (unsigned int *)&len_addr) < 0)
 465 #endif
 466     return FALSE;
 467
 468   addr_man.Disassemble(&my_addr, len_addr);
 469   return TRUE;
 470 }
 471
 472 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
 473 {
 474   struct sockaddr my_addr;
 475   size_t len_addr = sizeof(my_addr);
 476
 477   if (m_fd < 0)
 478     return FALSE;
 479
 480 #ifdef __WINDOWS__
 481   if (getsockname(m_fd, (struct sockaddr *)&my_addr, (int *)&len_addr) < 0)
 482 #else
 483   if (getsockname(m_fd, (struct sockaddr *)&my_addr, (unsigned int *)&len_addr) < 0)
 484 #endif
 485     return FALSE;
 486
 487   addr_man.Disassemble(&my_addr, len_addr);
 488   return TRUE;
 489 }
 490
 491 // --------------------------------------------------------------
 492 // --------- wxSocketBase wait functions ------------------------
 493 // --------------------------------------------------------------
 494 void wxSocketBase::SaveState()
 495 {
 496   wxSockState *state = new wxSockState;
 497
 498   state->cbk_on = m_cbkon;
 499   state->cbk_set= m_neededreq;
 500   state->cbk    = m_cbk;
 501   state->cdata  = m_cdata;
 502   state->flags  = m_flags;
 503   state->notif  = m_notifyme;
 504
 505   m_states.Append(state);
 506 }
 507
 508 void wxSocketBase::RestoreState()
 509 {
 510   wxNode *node;
 511
 512   node = m_states.Last();
 513   if (!node)
 514     return;
 515
 516   wxSockState *state = (wxSockState *)node->Data();
 517
 518   SetFlags(state->flags);
 519   m_neededreq = state->cbk_set;
 520   m_cbk       = state->cbk;
 521   m_cdata     = state->cdata;
 522   m_notifyme  = state->notif;
 523   if (state->cbk_on)
 524     SetupCallbacks();
 525   else
 526     DestroyCallbacks();
 527
 528   delete node;
 529   delete state;
 530 }
 531
 532 // --------------------------------------------------------------
 533 // --------- wxSocketBase wait functions ------------------------
 534 // --------------------------------------------------------------
 535 //
 536 bool wxSocketBase::_Wait(long seconds, long microseconds, int type)
 537 {
 538   if ((!m_connected && !m_connecting) || m_fd < 0)
 539     return FALSE;
 540
 541   wxSockWakeUp wakeup(this, &m_waitflags, 0);
 542
 543   SaveState();
 544   SetNotify((wxRequestNotify)type);
 545   SetupCallbacks();
 546
 547   if (seconds != -1)
 548     wakeup.Start((int)(seconds*1000 + (microseconds / 1000)), TRUE);
 549
 550   m_waitflags = 0x80 | type;
 551   while (m_waitflags & 0x80)
 552     PROCESS_EVENTS();
 553
 554   RestoreState();
 555
 556   if (m_waitflags & 0x40) {
 557     m_waitflags = 0;
 558     return TRUE;
 559   }
 560   m_waitflags = 0;
 561
 562   return FALSE;
 563 }
 564
 565 bool wxSocketBase::Wait(long seconds, long microseconds)
 566 {
 567   return _Wait(seconds, microseconds, REQ_ACCEPT | REQ_CONNECT |
 568                                       REQ_READ | REQ_WRITE | REQ_LOST);
 569 }
 570
 571 bool wxSocketBase::WaitForRead(long seconds, long microseconds)
 572 {
 573   return _Wait(seconds, microseconds, REQ_READ | REQ_LOST);
 574 }
 575
 576 bool wxSocketBase::WaitForWrite(long seconds, long microseconds)
 577 {
 578   return _Wait(seconds, microseconds, REQ_WRITE);
 579 }
 580
 581 bool wxSocketBase::WaitForLost(long seconds, long microseconds)
 582 {
 583   return _Wait(seconds, microseconds, REQ_LOST);
 584 }
 585
 586 // --------------------------------------------------------------
 587 // --------- wxSocketBase callback management -------------------
 588 // --------------------------------------------------------------
 589
 590 #if defined(__WXMOTIF__) || defined(__WXXT__) || defined(__WXGTK__)
 591 #if defined(__WXMOTIF__) || defined(__WXXT__)
 592 static void wx_socket_read(XtPointer client, int *fid,
 593                            XtInputId *WXUNUSED(id))
 594 #define fd *fid
 595 #else
 596 static void wx_socket_read(gpointer client, gint fd,
 597                            GdkInputCondition WXUNUSED(cond))
 598 #define fd fd
 599 #endif
 600 {
 601   wxSocketBase *sock = (wxSocketBase *)client;
 602   char c;
 603   int i;
 604
 605   i = recv(fd, &c, 1, MSG_PEEK);
 606
 607   if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT)) {
 608     sock->OnRequest(wxSocketBase::EVT_ACCEPT);
 609     return;
 610   }
 611
 612   if (i != 0) {
 613     if (!(sock->NeededReq() & wxSocketBase::REQ_READ))
 614       return;
 615
 616     sock->OnRequest(wxSocketBase::EVT_READ);
 617   } else {
 618     if (!(sock->NeededReq() & wxSocketBase::REQ_LOST)) {
 619       sock->Close();
 620       return;
 621     }
 622
 623     sock->OnRequest(wxSocketBase::EVT_LOST);
 624   }
 625 }
 626 #undef fd
 627
 628 #if defined(__WXMOTIF__) || defined(__WXXT__)
 629 static void wx_socket_write(XtPointer client, int *WXUNUSED(fid),
 630                             XtInputId *WXUNUSED(id))
 631 #else
 632 static void wx_socket_write(gpointer client, gint WXUNUSED(fd),
 633                             GdkInputCondition WXUNUSED(cond))
 634 #endif
 635 {
 636   wxSocketBase *sock = (wxSocketBase *)client;
 637
 638   if (!sock->IsConnected())
 639     sock->OnRequest(wxSocketBase::EVT_CONNECT);
 640   else
 641     sock->OnRequest(wxSocketBase::EVT_WRITE);
 642 }
 643 #endif
 644
 645 #ifdef wx_xview
 646 Notify_value wx_sock_read_xview (Notify_client client, int fd)
 647 {
 648   wxSocketBase *sock = (wxSocketBase *)client;
 649   char c;
 650   int i;
 651
 652   i = recv(fd, &c, 1, MSG_PEEK);
 653
 654   if (i == -1 && (sock->NeededReq() & wxSocketBase::REQ_ACCEPT)) {
 655     sock->OnRequest(wxSocketBase::EVT_ACCEPT);
 656     return;
 657   }
 658
 659   /* Bytes arrived */
 660   if (i != 0) {
 661     if (!(sock->NeededReq() & wxSocketBase::REQ_READ))
 662       return (Notify_value) FALSE;
 663
 664     sock->OnRequest(wxSocketBase::EVT_READ);
 665   } else {
 666     if (!(sock->NeededReq() & wxSocketBase::REQ_LOST))
 667       return;
 668
 669     sock->OnRequest(wxSocketBase::EVT_LOST);
 670   }
 671
 672   return (Notify_value) FALSE;
 673 }
 674
 675 Notify_value wx_sock_write_xview (Notify_client client, int fd)
 676 {
 677   wxSocketBase *sock = (wxSocketBase *)client;
 678
 679   if (!sock->IsConnected())
 680     sock->OnRequest(wxSocketBase::EVT_CONNECT);
 681   else
 682     sock->OnRequest(wxSocketBase::EVT_WRITE);
 683
 684   return (Notify_value) TRUE;
 685 }
 686 #endif
 687
 688 wxSocketBase::wxRequestNotify wxSocketBase::EventToNotify(wxRequestEvent evt)
 689 {
 690   switch (evt) {
 691   case EVT_READ:
 692     return REQ_READ;
 693   case EVT_PEEK:
 694     return REQ_PEEK;
 695   case EVT_WRITE:
 696     return REQ_WRITE;
 697   case EVT_LOST:
 698     return REQ_LOST;
 699   case EVT_ACCEPT:
 700     return REQ_ACCEPT;
 701   case EVT_CONNECT:
 702     return REQ_CONNECT;
 703   }
 704   return 0;
 705 }
 706
 707 void wxSocketBase::SetFlags(wxSockFlags _flags)
 708 {
 709   m_flags = _flags;
 710   if (_flags & SPEED) {
 711     unsigned long flag = 0;
 712     ioctl(m_fd, FIONBIO, &flag);
 713
 714     // SPEED and WAITALL are antagonists.
 715     m_flags = (wxSockFlags)(m_flags & ~WAITALL);
 716
 717     Notify(FALSE);
 718   } else {
 719     unsigned long flag = 1;
 720     ioctl(m_fd, FIONBIO, &flag);
 721   }
 722 }
 723
 724 void wxSocketBase::SetNotify(wxRequestNotify flags)
 725 {
 726   wxRequestNotify old_needed_req = m_neededreq;
 727   if (flags & REQ_ACCEPT) {
 728     /* Check if server */
 729     if (!(GetClassInfo()->IsKindOf(CLASSINFO(wxSocketServer))))
 730       flags &= ~REQ_ACCEPT;
 731   }
 732   m_neededreq = flags;
 733   if (m_cbkon && old_needed_req != flags)
 734     SetupCallbacks();
 735 }
 736
 737 void wxSocketBase::SetupCallbacks()
 738 {
 739   if (m_fd == INVALID_SOCKET || !m_handler || (m_flags & SPEED))
 740     return;
 741
 742 #if defined(__WXMOTIF__) || defined(__WXXT__) || defined(__WXGTK__)
 743   if (m_cbkon)
 744     DestroyCallbacks();
 745   if (m_neededreq & (REQ_ACCEPT | REQ_READ | REQ_LOST)) {
 746 #ifdef __WXGTK__
 747     m_internal->sock_inputid = gdk_input_add(m_fd, GDK_INPUT_READ,
 748                                            wx_socket_read, (gpointer)this);
 749 #else
 750     m_internal->sock_inputid = XtAppAddInput (wxAPP_CONTEXT, m_fd,
 751                                         (XtPointer *) XtInputReadMask,
 752                                         (XtInputCallbackProc) wx_socket_read,
 753                                         (XtPointer) this);
 754 #endif
 755   }
 756   if (m_neededreq & (REQ_CONNECT | REQ_WRITE)) {
 757 #ifdef __WXGTK__
 758     m_internal->sock_inputid = gdk_input_add(m_fd, GDK_INPUT_WRITE,
 759                                              wx_socket_write, (gpointer)this);
 760 #else
 761     m_internal->sock_outputid = XtAppAddInput (wxAPP_CONTEXT, m_fd,
 762                                         (XtPointer *) XtInputWriteMask,
 763                                         (XtInputCallbackProc) wx_socket_write,
 764                                         (XtPointer) this);
 765 #endif
 766   }
 767 #endif
 768 #ifdef __WINDOWS__
 769   WORD mask = 0;
 770
 771   if (m_neededreq & REQ_READ)
 772     mask |= FD_READ;
 773   if (m_neededreq & REQ_WRITE)
 774     mask |= FD_WRITE;
 775   if (m_neededreq & REQ_LOST)
 776     mask |= FD_CLOSE;
 777   if (m_neededreq & REQ_ACCEPT)
 778     mask |= FD_ACCEPT;
 779   if (m_neededreq & REQ_CONNECT)
 780     mask |= FD_CONNECT;
 781
 782   if (!m_internal->my_msg)
 783     m_internal->my_msg = m_handler->NewMessage(this);
 784   WSAAsyncSelect(m_fd, m_handler->GetHWND(), m_internal->my_msg, mask);
 785 #endif
 786   m_cbkon = TRUE;
 787   m_processing = FALSE;
 788 }
 789
 790 void wxSocketBase::DestroyCallbacks()
 791 {
 792   if (!m_cbkon || !m_handler)
 793     return;
 794   m_cbkon = FALSE;
 795   m_processing = FALSE;
 796 #if defined(__WXMOTIF__) || defined(__WXXT__)
 797   if (m_internal->sock_inputid > 0)
 798     XtRemoveInput(m_internal->sock_inputid);
 799   m_internal->sock_inputid = 0;
 800   if (m_internal->sock_outputid > 0)
 801     XtRemoveInput(m_internal->sock_outputid);
 802   m_internal->sock_outputid = 0;
 803 #endif
 804 #ifdef __WXGTK__
 805   if (m_internal->sock_inputid > 0)
 806     gdk_input_remove(m_internal->sock_inputid);
 807   m_internal->sock_inputid = 0;
 808   if (m_internal->sock_outputid > 0)
 809     gdk_input_remove(m_internal->sock_outputid);
 810   m_internal->sock_outputid = 0;
 811 #endif
 812 #ifdef __WINDOWS__
 813   WSAAsyncSelect(m_fd, m_handler->GetHWND(), 0, 0);
 814 #endif
 815 }
 816
 817 void wxSocketBase::Notify(bool notify)
 818 {
 819   if (m_notifyme == notify)
 820     return;
 821   if (notify)
 822     SetupCallbacks();
 823   else
 824     DestroyCallbacks();
 825   m_notifyme = notify;
 826 }
 827
 828 void wxSocketBase::OnRequest(wxRequestEvent req_evt)
 829 {
 830   wxRequestNotify req_notif = EventToNotify(req_evt);
 831
 832   // Mask the current event
 833   SetNotify(m_neededreq & ~req_notif);
 834
 835   if (req_evt <= EVT_WRITE && DoRequests(req_evt))
 836     return;
 837
 838   if (m_waitflags & 0xF0) {
 839     // Wake up
 840     if ((m_waitflags & 0x0F) == req_evt) {
 841       m_waitflags = 0x80;
 842 #ifndef __WXGTK__
 843       DestroyCallbacks();  // I disable it to prevent infinite loop on X11.
 844 #endif
 845     }
 846     return;
 847   }
 848
 849   if (req_evt == EVT_LOST) {
 850     m_connected = FALSE;
 851     Close();
 852   }
 853   if (m_notifyme)
 854     OldOnNotify(req_evt);
 855
 856   // Unmask
 857   SetNotify(m_neededreq | req_notif);
 858 }
 859
 860 wxSocketEvent::wxSocketEvent(int id)
 861   : wxEvent(id)
 862 {
 863   wxEventType type = (wxEventType)wxEVT_SOCKET;
 864
 865   SetEventType(type);
 866 }
 867
 868 void wxSocketBase::OldOnNotify(wxRequestEvent evt)
 869 {
 870   wxSocketEvent event(m_id);
 871
 872   event.SetEventObject(this);
 873   event.m_skevt = evt;
 874   ProcessEvent(event);
 875
 876   if (m_cbk)
 877     m_cbk(*this, evt, m_cdata);
 878 }
 879
 880 // --------------------------------------------------------------
 881 // --------- wxSocketBase functions [Callback, CallbackData] ----
 882 // --------------------------------------------------------------
 883 wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSocketBase::wxSockCbk _cbk)
 884 {
 885   wxSockCbk old_cbk = m_cbk;
 886
 887   m_cbk = _cbk;
 888   return old_cbk;
 889 }
 890
 891 char *wxSocketBase::CallbackData(char *cdata_)
 892 {
 893   char *old_cdata = m_cdata;
 894
 895   m_cdata = cdata_;
 896   return old_cdata;
 897 }
 898
 899 void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id)
 900 {
 901   SetNextHandler(&h_evt);
 902   m_id = id;
 903 }
 904
 905 // --------------------------------------------------------------
 906 // --------- wxSocketBase pushback library ----------------------
 907 // --------------------------------------------------------------
 908 void wxSocketBase::CreatePushbackAfter(const char *buffer, size_t size)
 909 {
 910   char *curr_pos;
 911
 912   m_unread = (char *) realloc(m_unread, m_unrd_size+size);
 913   curr_pos = m_unread + m_unrd_size;
 914
 915   memcpy(curr_pos, buffer, size);
 916   m_unrd_size += size;
 917 }
 918
 919 void wxSocketBase::CreatePushbackBefore(const char *buffer, size_t size)
 920 {
 921   char *curr_pos, *new_buf;
 922
 923   new_buf = (char *) malloc(m_unrd_size+size);
 924   curr_pos = new_buf + size;
 925
 926   memcpy(new_buf, buffer, size);
 927   memcpy(curr_pos, m_unread, m_unrd_size);
 928
 929   free(m_unread);
 930   m_unread = new_buf;
 931   m_unrd_size += size;
 932 }
 933
 934 size_t wxSocketBase::GetPushback(char *buffer, size_t size, bool peek)
 935 {
 936   if (!m_unrd_size)
 937     return 0;
 938
 939   if (size > m_unrd_size)
 940     size = m_unrd_size;
 941   memcpy(buffer, m_unread, size);
 942
 943   if (!peek) {
 944     m_unrd_size -= size;
 945     if (!m_unrd_size) {
 946       free(m_unread);
 947       m_unread = NULL;
 948     }
 949   }
 950
 951   return size;
 952 }
 953
 954 // --------------------------------------------------------------
 955 // --------- wxSocketBase "multi-thread" core -------------------
 956 // --------------------------------------------------------------
 957
 958 bool wxSocketBase::DoRequests(wxRequestEvent req_flag)
 959 {
 960   wxNode *node = req_list[req_flag].First();
 961   size_t len;
 962   int ret;
 963
 964   if (!node)
 965     return FALSE;
 966
 967   SockRequest *req = (SockRequest *)node->Data();
 968
 969   delete node;
 970
 971   switch (req->type) {
 972   case EVT_READ:
 973   case EVT_PEEK:
 974     ret = recv(m_fd, req->buffer, req->size,
 975                (req->type == EVT_PEEK) ? MSG_PEEK : 0);
 976     if (ret < 0) {
 977       req->error = errno;
 978       req->done = TRUE;
 979       break;
 980     }
 981     len = ret;
 982     if ((len < req->size) && (m_flags & WAITALL)) {
 983       req->size -= len;
 984       req->nbytes += len;
 985       req->buffer += len;
 986       req->auto_wakeup->Start(m_timeout*1000, TRUE);
 987       req_list[req_flag].Insert(req);
 988       break;
 989     }
 990     req->done = TRUE;
 991     req->nbytes += len;
 992 #ifndef __WXGTK__
 993     DestroyCallbacks();
 994 #endif
 995     break;
 996   case EVT_WRITE:
 997     ret = send(m_fd, req->buffer, req->size, 0);
 998     if (ret < 0) {
 999       req->error = errno;
1000       req->done = TRUE;
1001       break;
1002     }
1003     len = ret;
1004     if ((len < req->size) && (m_flags & WAITALL)) {
1005       req->size -= len;
1006       req->nbytes += len;
1007       req->buffer += len;
1008       req->auto_wakeup->Start(m_timeout*1000, TRUE);
1009       req_list[req_flag].Insert(req);
1010       break;
1011     }
1012     req->done = TRUE;
1013     req->nbytes += len;
1014 #ifndef __WXGTK__
1015     DestroyCallbacks();
1016 #endif
1017     break;
1018   default:
1019     return FALSE;
1020   }
1021   return TRUE;
1022 }
1023
1024 void wxSocketBase::WantSpeedBuffer(char *buffer, size_t nbytes,
1025                                    wxRequestEvent evt)
1026 {
1027   int ret = 0;
1028
1029   switch (evt) {
1030   case EVT_PEEK:
1031   case EVT_READ:
1032     ret = recv(m_fd, buffer, nbytes,
1033                (evt == EVT_PEEK) ? MSG_PEEK : 0);
1034     break;
1035   case EVT_WRITE:
1036     ret = send(m_fd, buffer, nbytes, 0);
1037     break;
1038   }
1039   if (ret < 0) {
1040     m_lcount = 0;
1041     m_error = errno;
1042   } else
1043     m_lcount = ret;
1044 }
1045
1046 void wxSocketBase::WantBuffer(char *buffer, size_t nbytes,
1047                               wxRequestEvent evt)
1048 {
1049   bool buf_timed_out;
1050
1051   if (m_fd == INVALID_SOCKET || !m_handler || !m_connected)
1052     return;
1053
1054   if (m_flags & SPEED) {
1055     WantSpeedBuffer(buffer, nbytes, evt);
1056     return;
1057   }
1058
1059   SockRequest *buf = new SockRequest;
1060   wxSockWakeUp s_wake(NULL, (int *)&buf_timed_out, (int)TRUE);
1061
1062   m_wantbuf++;
1063   req_list[evt].Append(buf);
1064
1065   SaveState();
1066   SetNotify(REQ_LOST | EventToNotify(evt));
1067   SetupCallbacks();
1068   buf->buffer = buffer;
1069   buf->size = nbytes;
1070   buf->done = FALSE;
1071   buf->type = evt;
1072   buf->nbytes = 0;
1073   buf->auto_wakeup = &s_wake;
1074   buf->error = 0;
1075   buf_timed_out = FALSE;
1076
1077   s_wake.Start(m_timeout*1000, TRUE);
1078   if (m_flags & NOWAIT) {
1079     DoRequests(evt);
1080   } else {
1081     while (!buf->done && !buf_timed_out)
1082       PROCESS_EVENTS();
1083   }
1084   m_wantbuf--;
1085   m_lcount = buf->nbytes;
1086   if (buf_timed_out)
1087     m_error = ETIMEDOUT;
1088   else
1089     m_error = buf->error;
1090
1091   delete buf;
1092   RestoreState();
1093 }
1094
1095 // --------------------------------------------------------------
1096 // wxSocketServer ///////////////////////////////////////////////
1097 // --------------------------------------------------------------
1098
1099 // --------------------------------------------------------------
1100 // --------- wxSocketServer CONSTRUCTOR -------------------------
1101 // --------------------------------------------------------------
1102 wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
1103                                wxSockFlags flags) :
1104   wxSocketBase(flags, SOCK_SERVER)
1105 {
1106   m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
1107
1108   if (m_fd == INVALID_SOCKET)
1109     return;
1110
1111   int flag = 1;
1112   setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&flag, sizeof(int));
1113
1114   struct sockaddr *myaddr;
1115   size_t len;
1116
1117   addr_man.Build(myaddr, len);
1118   if (bind(m_fd, myaddr, addr_man.SockAddrLen()) < 0)
1119     return;
1120
1121   if (listen(m_fd, 5) < 0) {
1122     m_fd = INVALID_SOCKET;
1123     return;
1124   }
1125 }
1126
1127 // --------------------------------------------------------------
1128 // --------- wxSocketServer Accept ------------------------------
1129 // --------------------------------------------------------------
1130 bool wxSocketServer::AcceptWith(wxSocketBase& sock)
1131 {
1132   int fd2;
1133
1134   if ((fd2 = accept(m_fd, 0, 0)) < 0)
1135     return FALSE;
1136
1137   struct linger linger;
1138   linger.l_onoff = 0;
1139   linger.l_linger = 1;
1140
1141   setsockopt(fd2, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
1142
1143   int flag = 0;
1144   setsockopt(fd2, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
1145
1146   if (!(sock.m_flags & SPEED)) {
1147     unsigned long flag2 = 1;
1148     ioctl(fd2, FIONBIO, &flag2);
1149   }
1150
1151   sock.m_type = SOCK_INTERNAL;
1152   sock.m_fd = fd2;
1153   sock.m_connected = TRUE;
1154
1155   return TRUE;
1156 }
1157
1158 wxSocketBase *wxSocketServer::Accept()
1159 {
1160   wxSocketBase* sock = new wxSocketBase();
1161
1162   sock->SetFlags((wxSockFlags)m_flags);
1163
1164   if (!AcceptWith(*sock))
1165     return NULL;
1166
1167   if (m_handler)
1168     m_handler->Register(sock);
1169
1170   return sock;
1171 }
1172
1173 // --------------------------------------------------------------
1174 // --------- wxSocketServer callbacks ---------------------------
1175 // --------------------------------------------------------------
1176 void wxSocketServer::OnRequest(wxRequestEvent evt)
1177 {
1178   if (evt == EVT_ACCEPT) {
1179     OldOnNotify(EVT_ACCEPT);
1180   }
1181 }
1182
1183 // --------------------------------------------------------------
1184 // wxSocketClient ///////////////////////////////////////////////
1185 // --------------------------------------------------------------
1186
1187 // --------- wxSocketClient CONSTRUCTOR -------------------------
1188 // --------------------------------------------------------------
1189 wxSocketClient::wxSocketClient(wxSockFlags _flags) :
1190         wxSocketBase(_flags, SOCK_CLIENT)
1191 {
1192 }
1193
1194 // --------------------------------------------------------------
1195 // --------- wxSocketClient DESTRUCTOR --------------------------
1196 // --------------------------------------------------------------
1197 wxSocketClient::~wxSocketClient()
1198 {
1199 }
1200
1201 // --------------------------------------------------------------
1202 // --------- wxSocketClient Connect functions -------------------
1203 // --------------------------------------------------------------
1204 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) )
1205 {
1206   struct linger linger;
1207
1208   if (IsConnected())
1209     Close();
1210
1211   m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
1212
1213   if (m_fd < 0)
1214     return FALSE;
1215
1216   m_connected = FALSE;
1217
1218   linger.l_onoff = 1;
1219   linger.l_linger = 5;
1220   setsockopt(m_fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
1221
1222   // Stay in touch with the state of things...
1223
1224   unsigned long flag = 1;
1225   setsockopt(m_fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
1226
1227   // Disable the nagle algorithm, which delays sends till the
1228   // buffer is full (or a certain time period has passed?)...
1229
1230 #if defined(__WINDOWS__) || (defined(IPPROTO_TCP) && defined(TCP_NODELAY))
1231   flag = 1;
1232   setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int));
1233 #endif
1234
1235   struct sockaddr *remote;
1236   size_t len;
1237
1238   addr_man.Build(remote, len);
1239
1240   if (connect(m_fd, remote, len) != 0)
1241     return FALSE;
1242
1243   if (!(m_flags & SPEED)) {
1244     flag = 1;
1245     ioctl(m_fd, FIONBIO, &flag);
1246   }
1247
1248   Notify(TRUE);
1249
1250   m_connected = TRUE;
1251   return TRUE;
1252 }
1253
1254 bool wxSocketClient::WaitOnConnect(long seconds)
1255 {
1256   int ret = _Wait(seconds, 0, REQ_CONNECT | REQ_LOST);
1257
1258   if (ret)
1259     m_connected = TRUE;
1260
1261   return m_connected;
1262 }
1263
1264 void wxSocketClient::OnRequest(wxRequestEvent evt)
1265 {
1266   if (evt == EVT_CONNECT) {
1267     if (m_connected) {
1268       SetNotify(m_neededreq & ~REQ_CONNECT);
1269       return;
1270     }
1271     m_waitflags = 0x40;
1272     m_connected = TRUE;
1273     OldOnNotify(EVT_CONNECT);
1274     DestroyCallbacks();
1275     return;
1276   }
1277   wxSocketBase::OnRequest(evt);
1278 }
1279
1280 /////////////////////////////////////////////////////////////////
1281 // wxSocketHandler ///////////////////////////////////////////////
1282 /////////////////////////////////////////////////////////////////
1283
1284 wxSocketHandler *wxSocketHandler::master = NULL;
1285 #if defined(__WINDOWS__)
1286 static int win_initialized = 0;
1287 #endif
1288
1289 // --------------------------------------------------------------
1290 // --------- wxSocketHandler CONSTRUCTOR ------------------------
1291 // --------------------------------------------------------------
1292 #ifdef __WINDOWS__
1293
1294 extern char wxPanelClassName[];
1295
1296 LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd, UINT message,
1297    WPARAM wParam, LPARAM lParam)
1298 {
1299   wxSocketHandler *h_sock = (wxSocketHandler *)GetWindowLong(hWnd, GWL_USERDATA);
1300   wxNode *node = h_sock->smsg_list->Find(message);
1301   wxSocketBase *sock;
1302   wxSocketBase::wxRequestEvent sk_req;
1303   UINT event = WSAGETSELECTEVENT(lParam);
1304
1305   if (!node)
1306     return DefWindowProc(hWnd, message, wParam, lParam);
1307
1308   sock = (wxSocketBase *)node->Data();
1309
1310   switch (event) {
1311   case FD_READ:
1312     sk_req = wxSocketBase::EVT_READ;
1313     break;
1314   case FD_WRITE:
1315     sk_req = wxSocketBase::EVT_WRITE;
1316     break;
1317   case FD_CLOSE:
1318     sk_req = wxSocketBase::EVT_LOST;
1319     break;
1320   case FD_ACCEPT:
1321     sk_req = wxSocketBase::EVT_ACCEPT;
1322     break;
1323   case FD_CONNECT:
1324     sk_req = wxSocketBase::EVT_CONNECT;
1325     break;
1326   }
1327   sock->OnRequest(sk_req);
1328
1329   return (LRESULT)0;
1330 }
1331
1332 FARPROC wxSocketSubClassProc = NULL;
1333
1334 #endif
1335
1336 wxSocketHandler::wxSocketHandler()
1337 {
1338 #if defined(__WINDOWS__)
1339   if (!win_initialized) {
1340     WSADATA wsaData;
1341
1342     WSAStartup((1 << 8) | 1, &wsaData);
1343     win_initialized = 1;
1344   }
1345   internal = new wxSockHandlerInternal;
1346   internal->sockWin = ::CreateWindow(wxPanelClassName, NULL, 0,
1347                 0, 0, 0, 0, NULL, (HMENU) NULL,
1348                 wxhInstance, 0);
1349
1350   // Subclass the window
1351   if (!wxSocketSubClassProc)
1352     wxSocketSubClassProc = MakeProcInstance((FARPROC) wxSocketHandlerWndProc, wxhInstance);
1353   ::SetWindowLong(internal->sockWin, GWL_WNDPROC, (LONG) wxSocketSubClassProc);
1354   ::SetWindowLong(internal->sockWin, GWL_USERDATA, (LONG) this);
1355
1356   internal->firstAvailableMsg = 5000;
1357   smsg_list = new wxList(wxKEY_INTEGER);
1358 #endif
1359
1360   socks = new wxList;
1361
1362 #ifndef __WINDOWS__
1363   signal(SIGPIPE, SIG_IGN);
1364 #endif
1365 }
1366
1367 // --------------------------------------------------------------
1368 // --------- wxSocketHandler DESTRUCTOR -------------------------
1369 // --------------------------------------------------------------
1370 wxSocketHandler::~wxSocketHandler()
1371 {
1372   wxNode *next_node, *node = socks->First();
1373
1374   while (node) {
1375     wxSocketBase* sock = (wxSocketBase*)node->Data();
1376
1377     delete sock;
1378     next_node = node->Next();
1379     delete node;
1380     node = next_node;
1381   }
1382
1383   delete socks;
1384
1385 #ifdef __WINDOWS__
1386   delete smsg_list;
1387
1388   ::DestroyWindow(internal->sockWin);
1389   WSACleanup();
1390   win_initialized = 0;
1391
1392   delete internal;
1393 #endif
1394 }
1395
1396 // --------------------------------------------------------------
1397 // --------- wxSocketHandler registering functions --------------
1398 // --------------------------------------------------------------
1399 void wxSocketHandler::Register(wxSocketBase* sock)
1400 {
1401   wxNode *node;
1402
1403   for (node = socks->First(); node != NULL; node = node->Next()) {
1404     wxSocketBase* s = (wxSocketBase*)node->Data();
1405
1406     if (s == sock)
1407       return;
1408   }
1409
1410   if (sock) {
1411     socks->Append(sock);
1412     sock->SetHandler(this);
1413     sock->SetupCallbacks();
1414   }
1415 }
1416
1417 void wxSocketHandler::UnRegister(wxSocketBase* sock)
1418 {
1419   wxNode *node;
1420
1421   for (node = socks->First(); node; node = node->Next()) {
1422     wxSocketBase* s = (wxSocketBase*)node->Data();
1423
1424     if (s == sock) {
1425       delete node;
1426       sock->DestroyCallbacks();
1427       sock->SetHandler(NULL);
1428       return;
1429     }
1430   }
1431 }
1432
1433 unsigned long wxSocketHandler::Count() const
1434 {
1435   return socks->Number();
1436 }
1437
1438 // --------------------------------------------------------------
1439 // --------- wxSocketHandler "big" wait functions ---------------
1440 // --------------------------------------------------------------
1441 void handler_cbk(wxSocketBase& sock,
1442                  wxSocketBase::wxRequestEvent WXUNUSED(flags),
1443                  char *cdata)
1444 {
1445   int *a_wait = (int *)cdata;
1446
1447   (*a_wait)++;
1448   sock.Notify(FALSE);
1449 }
1450
1451 int wxSocketHandler::Wait(long seconds, long microseconds)
1452 {
1453   int i;
1454   int on_wait;
1455   wxSockWakeUp s_wake(NULL, &on_wait, -2);
1456   wxNode *node;
1457
1458   for (node = socks->First(), i=0; node; node = node->Next(), i++) {
1459     wxSocketBase *sock = (wxSocketBase *)node->Data();
1460
1461     sock->SaveState();
1462
1463     sock->SetupCallbacks();
1464
1465     sock->Callback(handler_cbk);
1466     sock->CallbackData((char *)&on_wait);
1467   }
1468   on_wait = 0;
1469   if (seconds != -1)
1470     s_wake.Start((seconds*1000) + (microseconds/1000), TRUE);
1471
1472   while (!on_wait)
1473     PROCESS_EVENTS();
1474
1475   for (node = socks->First(), i=0; node; node = node->Next(), i++) {
1476     wxSocketBase *sock = (wxSocketBase *)node->Data();
1477
1478     sock->RestoreState();
1479   }
1480
1481   if (on_wait == -2)
1482     return 0;
1483
1484   return on_wait;
1485 }
1486
1487 void wxSocketHandler::YieldSock()
1488 {
1489   wxNode *node;
1490
1491   for (node = socks->First(); node; node = node->Next() ) {
1492     wxSocketBase *sock = (wxSocketBase *)node->Data();
1493
1494     sock->SaveState();
1495
1496     sock->SetFlags(wxSocketBase::SPEED);
1497     if (sock->IsData())
1498       sock->DoRequests(wxSocketBase::EVT_READ);
1499     sock->DoRequests(wxSocketBase::EVT_WRITE);
1500
1501     sock->RestoreState();
1502   }
1503 }
1504
1505 // --------------------------------------------------------------
1506 // --------- wxSocketHandler: create and register the socket ----
1507 // --------------------------------------------------------------
1508 wxSocketServer *wxSocketHandler::CreateServer(wxSockAddress& addr,
1509                                               wxSocketBase::wxSockFlags flags)
1510 {
1511   wxSocketServer *serv = new wxSocketServer(addr, flags);
1512
1513   Register(serv);
1514   return serv;
1515 }
1516
1517 wxSocketClient *wxSocketHandler::CreateClient(wxSocketBase::wxSockFlags flags)
1518 {
1519   wxSocketClient *client = new wxSocketClient(flags);
1520
1521   Register(client);
1522   return client;
1523 }
1524
1525 #ifdef __WINDOWS__
1526 // --------------------------------------------------------------
1527 // --------- wxSocketHandler: Windows specific methods ----------
1528 // --------------------------------------------------------------
1529 UINT wxSocketHandler::NewMessage(wxSocketBase *sock)
1530 {
1531   internal->firstAvailableMsg++;
1532   smsg_list->Append(internal->firstAvailableMsg, sock);
1533   return internal->firstAvailableMsg;
1534 }
1535
1536 void wxSocketHandler::DestroyMessage(UINT msg)
1537 {
1538   wxNode *node = smsg_list->Find(msg);
1539   delete node;
1540 }
1541
1542 HWND wxSocketHandler::GetHWND() const
1543 {
1544   return internal->sockWin;
1545 }
1546
1547 #endif