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