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