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