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