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:    April 1999
   8 // Copyright:  (C) 1999 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 // IRIX requires bstring.h be included to use select()
  39 #ifdef sgi
  40     #include <bstring.h>
  41 #endif // IRIX
  42
  43 // Not enough OS behaviour defined for wxStubs
  44 #ifndef __WXSTUBS__
  45
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <ctype.h>
  49
  50 /////////////////////////////////////////////////////////////////////////////
  51 // System specific headers
  52 /////////////////////////////////////////////////////////////////////////////
  53 #ifdef __WXMAC__
  54 // in order to avoid problems with our c library and double definitions
  55 #define close closesocket
  56 #define ioctl ioctlsocket
  57
  58 #include <wx/mac/macsock.h>
  59
  60 #endif
  61
  62 #if defined(__WINDOWS__)
  63 #include <winsock.h>
  64 #endif // __WINDOWS__
  65
  66 #if defined(__UNIX__)
  67
  68 #ifdef VMS
  69 #include <socket.h>
  70 #else
  71 #include <sys/socket.h>
  72 #endif
  73 #include <sys/ioctl.h>
  74
  75 #include <sys/time.h>
  76 #include <unistd.h>
  77
  78 #ifdef sun
  79 #include <sys/filio.h>
  80 #endif
  81
  82 #endif // __UNIX__
  83
  84 #include <signal.h>
  85 #include <errno.h>
  86
  87 #ifdef __VISUALC__
  88 #include <io.h>
  89 #endif
  90
  91 /////////////////////////////////////////////////////////////////////////////
  92 // wxSocket headers
  93 /////////////////////////////////////////////////////////////////////////////
  94 #include <wx/module.h>
  95 #define WXSOCK_INTERNAL
  96 #include <wx/sckaddr.h>
  97 #include <wx/socket.h>
  98 #include <wx/sckint.h>
  99
 100 // ----------------------
 101 // Some patch ----- BEGIN
 102 // ----------------------
 103 #ifdef __WINDOWS__
 104 #define close closesocket
 105 #define ioctl ioctlsocket
 106 #ifdef errno
 107 #undef errno
 108 #endif
 109 #define errno WSAGetLastError()
 110 #ifdef EWOULDBLOCK
 111 #undef EWOULDBLOCK
 112 #endif
 113 #define EWOULDBLOCK WSAEWOULDBLOCK
 114 #define ETIMEDOUT WSAETIMEDOUT
 115 #undef EINTR
 116 #define EINTR WSAEINTR
 117 #endif
 118
 119 #ifndef __WINDOWS__
 120 #define INVALID_SOCKET -1
 121 #endif
 122
 123 #ifdef __WINDOWS__
 124 // This is an MS TCP/IP routine and is not needed here. Some WinSock
 125 // implementations (such as PC-NFS) will require you to include this
 126 // or a similar routine (see appendix in WinSock doc or help file).
 127
 128 #if defined( NEED_WSAFDIsSet ) || defined( __VISUALC__ )
 129 int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *set)
 130 {
 131   int i = set->fd_count;
 132
 133   while (i--)
 134   {
 135     if (set->fd_array[i] == fd)
 136       return 1;
 137   }
 138
 139   return 0;
 140 }
 141 #endif
 142 #endif
 143
 144 // -------------------
 145 // Some patch ---- END
 146 // -------------------
 147
 148 #ifdef GetClassInfo
 149 #undef GetClassInfo
 150 #endif
 151
 152 // --------------------------------------------------------------
 153 // Module
 154 // --------------------------------------------------------------
 155 class wxSocketModule: public wxModule
 156 {
 157   DECLARE_DYNAMIC_CLASS(wxSocketModule)
 158 public:
 159   wxSocketModule() {}
 160   bool OnInit();
 161   void OnExit();
 162 };
 163
 164 // --------------------------------------------------------------
 165 // ClassInfos
 166 // --------------------------------------------------------------
 167 #if !USE_SHARED_LIBRARY
 168 IMPLEMENT_CLASS(wxSocketBase, wxObject)
 169 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
 170 IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
 171 IMPLEMENT_CLASS(wxSocketHandler, wxObject)
 172 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
 173 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
 174 #endif
 175
 176 // --------------------------------------------------------------
 177 // --------- wxSocketBase CONSTRUCTOR ---------------------------
 178 // --------------------------------------------------------------
 179 wxSocketBase::wxSocketBase(wxSocketBase::wxSockFlags _flags,
 180          wxSocketBase::wxSockType _type) :
 181   wxEvtHandler(),
 182   m_flags(_flags), m_type(_type), m_connected(FALSE), m_connecting(FALSE),
 183   m_fd(INVALID_SOCKET), m_id(-1),
 184   m_handler(0),
 185   m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)),
 186   m_timeout(3600),
 187   m_unread(NULL), m_unrd_size(0),
 188   m_cbk(NULL), m_cdata(NULL),
 189   m_notify_state(FALSE)
 190 {
 191   m_internal = new wxSocketInternal(this);
 192 }
 193
 194 wxSocketBase::wxSocketBase() :
 195   wxEvtHandler(),
 196   m_flags(WAITALL), m_type(SOCK_UNINIT), m_connected(FALSE),
 197   m_connecting(FALSE), m_fd(INVALID_SOCKET),
 198   m_id(-1), m_handler(0),
 199   m_neededreq((wxRequestNotify)(REQ_READ | REQ_LOST)),
 200   m_timeout(3600),
 201   m_unread(NULL), m_unrd_size(0),
 202   m_cbk(NULL), m_cdata(NULL),
 203   m_notify_state(FALSE)
 204 {
 205   m_internal = new wxSocketInternal(this);
 206 }
 207
 208 // --------------------------------------------------------------
 209 // wxSocketBase
 210 // --------------------------------------------------------------
 211
 212 wxSocketBase::~wxSocketBase()
 213 {
 214   // First, close the file descriptor.
 215   Close();
 216
 217   if (m_unread)
 218     free(m_unread);
 219   // Unregister from the handler database.
 220   if (m_handler)
 221     m_handler->UnRegister(this);
 222
 223   // Destroy all saved states.
 224   m_states.DeleteContents(TRUE);
 225
 226   // Destroy the socket manager.
 227   delete m_internal;
 228 }
 229
 230 bool wxSocketBase::Close()
 231 {
 232   if (m_fd != INVALID_SOCKET)
 233   {
 234     if (m_notify_state == TRUE)
 235       Notify(FALSE);
 236
 237     // Shutdown the connection.
 238     shutdown(m_fd, 2);
 239     close(m_fd);
 240     m_fd = INVALID_SOCKET;
 241     m_connected = FALSE;
 242   }
 243
 244   return TRUE;
 245 }
 246
 247 // --------------------------------------------------------------
 248 // wxSocketBase base IO function
 249 // --------------------------------------------------------------
 250
 251 wxSocketBase& wxSocketBase::Read(char* buffer, size_t nbytes)
 252 {
 253   m_lcount = GetPushback(buffer, nbytes, FALSE);
 254   nbytes -= m_lcount;
 255   buffer += m_lcount;
 256
 257   // If we have got the whole needed buffer or if we don't want to
 258   // wait then it returns immediately.
 259   if (!nbytes || (m_lcount && !(m_flags & WAITALL)) ) {
 260     return *this;
 261   }
 262
 263   WantBuffer(buffer, nbytes, EVT_READ);
 264
 265   return *this;
 266 }
 267
 268 wxSocketBase& wxSocketBase::ReadMsg(char* buffer, size_t nbytes)
 269 {
 270   unsigned long len, len2, sig;
 271   struct {
 272     char sig[4];
 273     char len[4];
 274   } msg;
 275
 276   // sig should be an explicit 32-bit unsigned integer; I've seen
 277   // compilers in which size_t was actually a 16-bit unsigned integer
 278
 279   Read((char *)&msg, sizeof(msg));
 280   if (m_lcount != sizeof(msg))
 281     return *this;
 282
 283   sig = msg.sig[0] & 0xff;
 284   sig |= (size_t)(msg.sig[1] & 0xff) << 8;
 285   sig |= (size_t)(msg.sig[2] & 0xff) << 16;
 286   sig |= (size_t)(msg.sig[3] & 0xff) << 24;
 287
 288   if (sig != 0xfeeddead)
 289     return *this;
 290   len = msg.len[0] & 0xff;
 291   len |= (size_t)(msg.len[1] & 0xff) << 8;
 292   len |= (size_t)(msg.len[2] & 0xff) << 16;
 293   len |= (size_t)(msg.len[3] & 0xff) << 24;
 294
 295   // len2 is incorrectly computed in the original; this sequence is
 296   // the fix
 297   if (len > nbytes) {
 298     len2 = len - nbytes;
 299     len = nbytes;
 300   }
 301   else
 302     len2 = 0;
 303
 304   // the "len &&" in the following statement is necessary so that
 305   // we don't attempt to read (and possibly hang the system)
 306   // if the message was zero bytes long
 307   if (len && Read(buffer, len).LastCount() != len)
 308     return *this;
 309   if (len2 && (Read(NULL, len2).LastCount() != len2))
 310     return *this;
 311   if (Read((char *)&msg, sizeof(msg)).LastCount() != sizeof(msg))
 312     return *this;
 313
 314   sig = msg.sig[0] & 0xff;
 315   sig |= (size_t)(msg.sig[1] & 0xff) << 8;
 316   sig |= (size_t)(msg.sig[2] & 0xff) << 16;
 317   sig |= (size_t)(msg.sig[3] & 0xff) << 24;
 318 // ERROR
 319 // we return *this either way, so a smart optimizer will
 320 // optimize the following sequence out; I'm leaving it in anyway
 321   if (sig != 0xdeadfeed)
 322     return *this;
 323
 324   return *this;
 325 }
 326
 327 wxSocketBase& wxSocketBase::Peek(char* buffer, size_t nbytes)
 328 {
 329   m_lcount = GetPushback(buffer, nbytes, TRUE);
 330   if (nbytes-m_lcount == 0)
 331   {
 332     return *this;
 333   }
 334   buffer += m_lcount;
 335   nbytes -= m_lcount;
 336
 337   WantBuffer(buffer, nbytes, EVT_PEEK);
 338
 339   return *this;
 340 }
 341
 342 wxSocketBase& wxSocketBase::Write(const char *buffer, size_t nbytes)
 343 {
 344   m_lcount = 0;
 345   WantBuffer((char *)buffer, nbytes, EVT_WRITE);
 346   return *this;
 347 }
 348
 349 wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes)
 350 {
 351   struct {
 352     char sig[4];
 353     char len[4];
 354   } msg;
 355
 356   // warning about 'cast truncates constant value'
 357 #ifdef __VISUALC__
 358     #pragma warning(disable: 4310)
 359 #endif // __VISUALC__
 360
 361   msg.sig[0] = (char) 0xad;
 362   msg.sig[1] = (char) 0xde;
 363   msg.sig[2] = (char) 0xed;
 364   msg.sig[3] = (char) 0xfe;
 365
 366     msg.len[0] = (char) nbytes & 0xff;
 367   msg.len[1] = (char) (nbytes >> 8) & 0xff;
 368   msg.len[2] = (char) (nbytes >> 16) & 0xff;
 369   msg.len[3] = (char) (nbytes >> 24) & 0xff;
 370
 371   if (Write((char *)&msg, sizeof(msg)).LastCount() < sizeof(msg))
 372     return *this;
 373   if (Write(buffer, nbytes).LastCount() < nbytes)
 374     return *this;
 375
 376   msg.sig[0] = (char) 0xed;
 377   msg.sig[1] = (char) 0xfe;
 378   msg.sig[2] = (char) 0xad;
 379   msg.sig[3] = (char) 0xde;
 380   msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
 381   Write((char *)&msg, sizeof(msg));
 382
 383   return *this;
 384
 385 #ifdef __VISUALC__
 386     #pragma warning(default: 4310)
 387 #endif // __VISUALC__
 388 }
 389
 390 wxSocketBase& wxSocketBase::Unread(const char *buffer, size_t nbytes)
 391 {
 392   m_lcount = 0;
 393   if (nbytes != 0) {
 394     CreatePushbackAfter(buffer, nbytes);
 395     m_lcount = nbytes;
 396   }
 397   return *this;
 398 }
 399
 400 bool wxSocketBase::IsData() const
 401 {
 402   struct timeval tv;
 403   fd_set sock_set;
 404
 405   if (m_fd < 0)
 406     return FALSE;
 407   if (m_unrd_size > 0)
 408     return TRUE;
 409
 410   m_internal->AcquireFD();
 411
 412   tv.tv_sec = 0;
 413   tv.tv_usec = 0;
 414   FD_ZERO(&sock_set);
 415   FD_SET(m_fd, &sock_set);
 416   select(m_fd+1, &sock_set, NULL, NULL, &tv);
 417
 418   m_internal->ReleaseFD();
 419
 420   return (FD_ISSET(m_fd, &sock_set) != 0);
 421 }
 422
 423 // ---------------------------------------------------------------------
 424 // --------- wxSocketBase Discard(): deletes all byte in the input queue
 425 // ---------------------------------------------------------------------
 426 void wxSocketBase::Discard()
 427 {
 428 #define MAX_BUFSIZE (10*1024)
 429   char *my_data = new char[MAX_BUFSIZE];
 430   size_t recv_size = MAX_BUFSIZE;
 431
 432   SaveState();
 433   SetFlags((wxSockFlags)(NOWAIT | SPEED));
 434
 435   while (recv_size == MAX_BUFSIZE)
 436   {
 437     recv_size = Read(my_data, MAX_BUFSIZE).LastCount();
 438   }
 439
 440   RestoreState();
 441   delete [] my_data;
 442
 443 #undef MAX_BUFSIZE
 444 }
 445
 446 // If what? Who seems to need unsigned int?
 447 // BTW uint isn't even defined on wxMSW for VC++ for some reason. Even if it
 448 // were, getpeername/getsockname don't take unsigned int*, they take int*.
 449 //
 450 // Under glibc 2.0.7, socketbits.h declares socklen_t to be unsigned int
 451 // and it uses *socklen_t as the 3rd parameter. Robert.
 452
 453 // JACS - How can we detect this?
 454 // Meanwhile, if your compiler complains about socklen_t,
 455 // switch lines below.
 456
 457 #if wxHAVE_GLIBC2
 458 #   define wxSOCKET_INT socklen_t
 459 #else
 460 #   define wxSOCKET_INT int
 461 #endif
 462
 463 // --------------------------------------------------------------
 464 // wxSocketBase socket info functions
 465 // --------------------------------------------------------------
 466
 467 bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
 468 {
 469   struct sockaddr my_addr;
 470   wxSOCKET_INT len_addr = sizeof(my_addr);
 471
 472   if (m_fd < 0)
 473     return FALSE;
 474
 475   m_internal->AcquireFD();
 476
 477   if (getpeername(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0) {
 478     m_internal->ReleaseFD();
 479     return FALSE;
 480   }
 481
 482   m_internal->ReleaseFD();
 483   addr_man.Disassemble(&my_addr, len_addr);
 484   return TRUE;
 485 }
 486
 487 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
 488 {
 489   struct sockaddr my_addr;
 490   wxSOCKET_INT len_addr = sizeof(my_addr);
 491
 492   if (m_fd < 0)
 493     return FALSE;
 494
 495   m_internal->AcquireFD();
 496
 497   if (getsockname(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0) {
 498     m_internal->ReleaseFD();
 499     return FALSE;
 500   }
 501   m_internal->ReleaseFD();
 502
 503   addr_man.Disassemble(&my_addr, len_addr);
 504   return TRUE;
 505 }
 506
 507 // --------------------------------------------------------------
 508 // wxSocketBase wait functions
 509 // --------------------------------------------------------------
 510
 511 void wxSocketBase::SaveState()
 512 {
 513   SocketState *state = new SocketState;
 514
 515   state->notify_state     = m_notify_state;
 516   state->evt_notify_state = m_neededreq;
 517   state->socket_flags     = m_flags;
 518   state->c_callback       = m_cbk;
 519   state->c_callback_data  = m_cdata;
 520
 521   m_states.Append((wxObject *)state);
 522 }
 523
 524 void wxSocketBase::RestoreState()
 525 {
 526   wxNode *node;
 527   SocketState *state;
 528
 529   node = m_states.Last();
 530   if (!node)
 531     return;
 532
 533   state = (SocketState *)node->Data();
 534
 535   SetFlags(state->socket_flags);
 536   m_internal->AcquireData();
 537   m_neededreq = state->evt_notify_state;
 538   m_internal->ReleaseData();
 539   m_cbk       = state->c_callback;
 540   m_cdata     = state->c_callback_data;
 541   Notify(state->notify_state);
 542
 543   delete node;
 544   delete state;
 545 }
 546
 547 // --------------------------------------------------------------
 548 // --------- wxSocketBase callback functions --------------------
 549 // --------------------------------------------------------------
 550
 551 wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_)
 552 {
 553   wxSockCbk old_cbk = cbk_;
 554
 555   m_cbk = cbk_;
 556   return old_cbk;
 557 }
 558
 559 char *wxSocketBase::CallbackData(char *data)
 560 {
 561   char *old_data = m_cdata;
 562
 563   m_cdata = data;
 564   return old_data;
 565 }
 566
 567 // --------------------------------------------------------------
 568 // --------- wxSocketBase wait functions ------------------------
 569 // --------------------------------------------------------------
 570
 571 bool wxSocketBase::_Wait(long seconds, long milliseconds, int type)
 572 {
 573   SockRequest *req;
 574
 575   if ((!m_connected && !m_connecting) || m_fd < 0)
 576     return FALSE;
 577
 578   req = new SockRequest;
 579
 580   req->type = REQ_WAIT | type;
 581   req->timeout = seconds * 1000 + milliseconds;
 582   req->done = FALSE;
 583   req->buffer = NULL;
 584   req->size = 0;
 585   req->error = 0;
 586   req->wait = TRUE;
 587   m_internal->QueueRequest(req, TRUE);
 588
 589   return (req->io_nbytes != 0);
 590 }
 591
 592 bool wxSocketBase::Wait(long seconds, long milliseconds)
 593 {
 594   return _Wait(seconds, milliseconds, REQ_ACCEPT | REQ_CONNECT |
 595                                       REQ_READ | REQ_WRITE | REQ_LOST);
 596 }
 597
 598 bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
 599 {
 600   return _Wait(seconds, milliseconds, REQ_READ | REQ_LOST);
 601 }
 602
 603 bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
 604 {
 605   return _Wait(seconds, milliseconds, REQ_WRITE);
 606 }
 607
 608 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 609 {
 610   return _Wait(seconds, milliseconds, REQ_LOST);
 611 }
 612
 613 // --------------------------------------------------------------
 614 // --------- wxSocketBase callback management -------------------
 615 // --------------------------------------------------------------
 616
 617 wxSocketBase::wxRequestNotify wxSocketBase::EventToNotify(wxRequestEvent evt)
 618 {
 619   switch (evt)
 620   {
 621   case EVT_READ:
 622     return REQ_READ;
 623   case EVT_PEEK:
 624     return REQ_PEEK;
 625   case EVT_WRITE:
 626     return REQ_WRITE;
 627   case EVT_LOST:
 628     return REQ_LOST;
 629   case EVT_ACCEPT:
 630     return REQ_ACCEPT;
 631   case EVT_CONNECT:
 632     return REQ_CONNECT;
 633   }
 634   return 0;
 635 }
 636
 637 void wxSocketBase::SetFlags(wxSockFlags _flags)
 638 {
 639   m_flags = _flags;
 640   if (_flags & SPEED) {
 641     // SPEED and WAITALL are antagonists.
 642     m_flags = (wxSockFlags)(m_flags & ~WAITALL);
 643   }
 644 }
 645
 646 wxSocketBase::wxSockFlags wxSocketBase::GetFlags() const
 647 {
 648   return m_flags;
 649 }
 650
 651 void wxSocketBase::SetNotify(wxRequestNotify flags)
 652 {
 653   /* Check if server */
 654   if (m_type != SOCK_SERVER)
 655     flags &= ~REQ_ACCEPT;
 656
 657   m_internal->AcquireData();
 658   m_neededreq = flags;
 659   m_internal->ReleaseData();
 660   if (m_neededreq == 0)
 661     m_internal->StopWaiter();
 662   else
 663     Notify(m_notify_state);
 664 }
 665
 666 void wxSocketBase::Notify(bool notify)
 667 {
 668   m_notify_state = notify;
 669   if (m_fd == INVALID_SOCKET)
 670     return;
 671
 672   if (notify)
 673     m_internal->ResumeWaiter();
 674   else
 675     m_internal->StopWaiter();
 676 }
 677
 678 void wxSocketBase::OnRequest(wxRequestEvent req_evt)
 679 {
 680   wxSocketEvent event(m_id);
 681   wxRequestNotify notify = EventToNotify(req_evt);
 682
 683   if ((m_neededreq & notify) == notify) {
 684     event.m_socket = this;
 685     event.m_skevt = req_evt;
 686     ProcessEvent(event);
 687     // TODOTODO
 688     // OldOnNotify(req_evt);
 689
 690     // We disable the event reporting.
 691     m_neededreq &= ~notify;
 692   }
 693 }
 694
 695 wxSocketEvent::wxSocketEvent(int id)
 696   : wxEvent(id)
 697 {
 698   wxEventType type = (wxEventType)wxEVT_SOCKET;
 699
 700   SetEventType(type);
 701 }
 702
 703 void wxSocketEvent::CopyObject(wxObject& obj_d) const
 704 {
 705   wxSocketEvent *event = (wxSocketEvent *)&obj_d;
 706
 707   wxEvent::CopyObject(obj_d);
 708
 709   event->m_skevt = m_skevt;
 710   event->m_socket = m_socket;
 711 }
 712
 713 void wxSocketBase::OldOnNotify(wxRequestEvent evt)
 714 {
 715 }
 716
 717 // --------------------------------------------------------------
 718 // --------- wxSocketBase functions [Callback, CallbackData] ----
 719 // --------------------------------------------------------------
 720
 721 void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id)
 722 {
 723   SetNextHandler(&h_evt);
 724   m_id = id;
 725 }
 726
 727 // --------------------------------------------------------------
 728 // --------- wxSocketBase pushback library ----------------------
 729 // --------------------------------------------------------------
 730
 731 void wxSocketBase::CreatePushbackAfter(const char *buffer, size_t size)
 732 {
 733   char *curr_pos;
 734
 735   if (m_unread != NULL)
 736     m_unread = (char *) realloc(m_unread, m_unrd_size+size);
 737   else
 738     m_unread = (char *) malloc(size);
 739   curr_pos = m_unread + m_unrd_size;
 740
 741   memcpy(curr_pos, buffer, size);
 742   m_unrd_size += size;
 743 }
 744
 745 void wxSocketBase::CreatePushbackBefore(const char *buffer, size_t size)
 746 {
 747   char *curr_pos, *new_buf;
 748
 749   new_buf = (char *) malloc(m_unrd_size+size);
 750   curr_pos = new_buf + size;
 751
 752   memcpy(new_buf, buffer, size);
 753   if (m_unrd_size != 0) {
 754     memcpy(curr_pos, m_unread, m_unrd_size);
 755     free(m_unread);
 756   }
 757   m_unread = new_buf;
 758   m_unrd_size += size;
 759 }
 760
 761 size_t wxSocketBase::GetPushback(char *buffer, size_t size, bool peek)
 762 {
 763   if (!m_unrd_size)
 764     return 0;
 765
 766   if (size > m_unrd_size)
 767     size = m_unrd_size;
 768   memcpy(buffer, m_unread, size);
 769
 770   if (!peek) {
 771     m_unrd_size -= size;
 772     if (m_unrd_size == 0) {
 773       free(m_unread);
 774       m_unread = NULL;
 775     }
 776   }
 777
 778   return size;
 779 }
 780
 781 // --------------------------------------------------------------
 782 // --------- wxSocketBase buffer core requester -----------------
 783 // --------------------------------------------------------------
 784
 785 void wxSocketBase::WantBuffer(char *buffer, size_t nbytes,
 786             wxRequestEvent evt)
 787 {
 788   bool buf_timed_out;
 789
 790   if (m_fd == INVALID_SOCKET || !m_handler || !m_connected)
 791     return;
 792
 793   SockRequest *buf = new SockRequest;
 794
 795   SaveState();
 796   buf->buffer = buffer;
 797   buf->size = nbytes;
 798   buf->done = FALSE;
 799   buf->type = EventToNotify(evt);
 800   buf->io_nbytes = 0;
 801   buf->error = 0;
 802   buf->wait = TRUE;
 803   buf->timeout = 1000;
 804   buf_timed_out = FALSE;
 805
 806   if ((m_flags & SPEED) != 0)
 807     m_internal->QueueRequest(buf, FALSE);
 808   else
 809     if ((m_flags & NOWAIT) != 0)
 810       m_internal->QueueRequest(buf, TRUE);
 811     else
 812       m_internal->QueueRequest(buf, TRUE);
 813   m_lcount += buf->io_nbytes;
 814   if (buf_timed_out)
 815     m_error = ETIMEDOUT;
 816   else
 817     m_error = buf->error;
 818
 819   delete buf;
 820   RestoreState();
 821 }
 822
 823 // --------------------------------------------------------------
 824 // wxSocketServer
 825 // --------------------------------------------------------------
 826
 827 wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
 828              wxSockFlags flags) :
 829   wxSocketBase(flags, SOCK_SERVER)
 830 {
 831   m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
 832
 833   if (m_fd == INVALID_SOCKET)
 834     return;
 835
 836   int flag = 1;
 837   setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&flag, sizeof(int));
 838
 839   struct sockaddr *myaddr;
 840   size_t len;
 841
 842   addr_man.Build(myaddr, len);
 843   if (bind(m_fd, myaddr, addr_man.SockAddrLen()) < 0)
 844     return;
 845
 846   if (listen(m_fd, 5) < 0) {
 847     m_fd = INVALID_SOCKET;
 848     return;
 849   }
 850
 851   m_internal->SetFD(m_fd);
 852
 853   Notify(TRUE);
 854 }
 855
 856 // --------------------------------------------------------------
 857 // wxSocketServer Accept
 858 // --------------------------------------------------------------
 859
 860 bool wxSocketServer::AcceptWith(wxSocketBase& sock)
 861 {
 862   int fd2;
 863
 864   m_internal->AcquireFD();
 865   if ((fd2 = accept(m_fd, 0, 0)) < 0) {
 866     m_internal->ReleaseFD();
 867     return FALSE;
 868   }
 869   m_internal->ReleaseFD();
 870
 871   struct linger linger;
 872   linger.l_onoff = 0;
 873   linger.l_linger = 1;
 874
 875   setsockopt(fd2, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
 876
 877   int flag = 0;
 878   setsockopt(fd2, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
 879
 880   sock.m_type = SOCK_INTERNAL;
 881   sock.m_fd = fd2;
 882   sock.m_connected = TRUE;
 883
 884   sock.m_internal->SetFD(fd2);
 885
 886   sock.m_internal->ResumeWaiter();
 887
 888   return TRUE;
 889 }
 890
 891 wxSocketBase *wxSocketServer::Accept()
 892 {
 893   wxSocketBase* sock = new wxSocketBase();
 894
 895   sock->SetFlags((wxSockFlags)m_flags);
 896
 897   if (!AcceptWith(*sock))
 898     return NULL;
 899
 900   if (m_handler)
 901     m_handler->Register(sock);
 902
 903   return sock;
 904 }
 905
 906 // --------------------------------------------------------------
 907 // wxSocketClient
 908 // --------------------------------------------------------------
 909
 910 // --------- wxSocketClient CONSTRUCTOR -------------------------
 911 // --------------------------------------------------------------
 912 wxSocketClient::wxSocketClient(wxSockFlags _flags) :
 913   wxSocketBase(_flags, SOCK_CLIENT)
 914 {
 915 }
 916
 917 // --------------------------------------------------------------
 918 // --------- wxSocketClient DESTRUCTOR --------------------------
 919 // --------------------------------------------------------------
 920 wxSocketClient::~wxSocketClient()
 921 {
 922 }
 923
 924 // --------------------------------------------------------------
 925 // --------- wxSocketClient Connect functions -------------------
 926 // --------------------------------------------------------------
 927 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) )
 928 {
 929   struct linger linger;
 930
 931   if (IsConnected())
 932     Close();
 933
 934   // Initializes all socket stuff ...
 935   // --------------------------------
 936   m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
 937
 938   if (m_fd < 0)
 939     return FALSE;
 940
 941   m_connected = FALSE;
 942
 943   linger.l_onoff = 1;
 944   linger.l_linger = 5;
 945   setsockopt(m_fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
 946
 947   // Stay in touch with the state of things...
 948
 949   unsigned long flag = 1;
 950   setsockopt(m_fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
 951
 952   // Disable the nagle algorithm, which delays sends till the
 953   // buffer is full (or a certain time period has passed?)...
 954
 955 #if defined(__WINDOWS__) || (defined(IPPROTO_TCP) && defined(TCP_NODELAY))
 956   flag = 1;
 957   setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int));
 958 #endif
 959
 960   struct sockaddr *remote;
 961   size_t len;
 962
 963   addr_man.Build(remote, len);
 964
 965   if (connect(m_fd, remote, len) != 0)
 966     return FALSE;
 967
 968   m_internal->SetFD(m_fd);
 969
 970   // Enables bg events.
 971   // ------------------
 972   Notify(TRUE);
 973
 974   m_connected = TRUE;
 975   return TRUE;
 976 }
 977
 978 bool wxSocketClient::WaitOnConnect(long seconds, long microseconds)
 979 {
 980   int ret = _Wait(seconds, microseconds, REQ_CONNECT | REQ_LOST);
 981
 982   if (ret)
 983     m_connected = TRUE;
 984
 985   return m_connected;
 986 }
 987
 988 void wxSocketClient::OnRequest(wxRequestEvent evt)
 989 {
 990   if (evt == EVT_CONNECT)
 991   {
 992     if (m_connected)
 993     {
 994       m_neededreq &= ~REQ_CONNECT;
 995       return;
 996     }
 997     m_connected = TRUE;
 998     return;
 999   }
1000   wxSocketBase::OnRequest(evt);
1001 }
1002
1003 /////////////////////////////////////////////////////////////////
1004 // wxSocketHandler ///////////////////////////////////////////////
1005 /////////////////////////////////////////////////////////////////
1006
1007 wxSocketHandler *wxSocketHandler::master = NULL;
1008 #if defined(__WINDOWS__)
1009 static int win_initialized = 0;
1010 #endif
1011
1012 // --------------------------------------------------------------
1013 // --------- wxSocketHandler CONSTRUCTOR ------------------------
1014 // --------------------------------------------------------------
1015 wxSocketHandler::wxSocketHandler()
1016 {
1017 #if defined(__WINDOWS__)
1018   if (!win_initialized)
1019   {
1020     WSADATA wsaData;
1021
1022     WSAStartup((1 << 8) | 1, &wsaData);
1023     win_initialized = 1;
1024   }
1025 #endif
1026
1027   socks = new wxList;
1028
1029 #ifndef __WINDOWS__
1030   signal(SIGPIPE, SIG_IGN);
1031 #endif
1032 }
1033
1034 // --------------------------------------------------------------
1035 // --------- wxSocketHandler DESTRUCTOR -------------------------
1036 // --------------------------------------------------------------
1037 wxSocketHandler::~wxSocketHandler()
1038 {
1039   wxNode *next_node, *node = socks->First();
1040
1041   while (node)
1042   {
1043     wxSocketBase* sock = (wxSocketBase*)node->Data();
1044
1045     delete sock;
1046     next_node = node->Next();
1047     delete node;
1048     node = next_node;
1049   }
1050
1051   delete socks;
1052
1053 #ifdef __WINDOWS__
1054   WSACleanup();
1055   win_initialized = 0;
1056 #endif
1057 }
1058
1059 // --------------------------------------------------------------
1060 // --------- wxSocketHandler registering functions --------------
1061 // --------------------------------------------------------------
1062
1063 void wxSocketHandler::Register(wxSocketBase* sock)
1064 {
1065   wxNode *node;
1066
1067   for (node = socks->First(); node != NULL; node = node->Next())
1068   {
1069     wxSocketBase* s = (wxSocketBase*)node->Data();
1070
1071     if (s == sock)
1072       return;
1073   }
1074
1075   if (sock)
1076   {
1077     socks->Append(sock);
1078     sock->SetHandler(this);
1079   }
1080 }
1081
1082 void wxSocketHandler::UnRegister(wxSocketBase* sock)
1083 {
1084   wxNode *node;
1085
1086   for (node = socks->First(); node; node = node->Next())
1087   {
1088     wxSocketBase* s = (wxSocketBase*)node->Data();
1089
1090     if (s == sock)
1091     {
1092       delete node;
1093       sock->SetHandler(NULL);
1094       return;
1095     }
1096   }
1097 }
1098
1099 unsigned long wxSocketHandler::Count() const
1100 {
1101   return socks->Number();
1102 }
1103
1104 // --------------------------------------------------------------
1105 // --------- wxSocketHandler "big" wait functions ---------------
1106 // --------------------------------------------------------------
1107
1108 int wxSocketHandler::Wait(long seconds, long microseconds)
1109 {
1110   // TODO Needs the completely asynchronous notifier.
1111
1112   /*
1113   int i;
1114   int on_wait;
1115   wxNode *node;
1116   for (node = socks->First(), i=0; node; node = node->Next(), i++)
1117   {
1118     wxSocketBase *sock = (wxSocketBase *)node->Data();
1119
1120     sock->SaveState();
1121
1122     sock->SetupCallbacks();
1123
1124     sock->Callback(handler_cbk);
1125     sock->CallbackData((char *)&on_wait);
1126   }
1127   on_wait = 0;
1128   if (seconds != -1)
1129     s_wake.Start((seconds*1000) + (microseconds/1000), TRUE);
1130
1131   while (!on_wait)
1132     PROCESS_EVENTS();
1133
1134   for (node = socks->First(), i=0; node; node = node->Next(), i++)
1135   {
1136     wxSocketBase *sock = (wxSocketBase *)node->Data();
1137
1138     sock->RestoreState();
1139   }
1140
1141   if (on_wait == -2)
1142     return 0;
1143
1144   return on_wait;
1145   */
1146   return 0;
1147 }
1148
1149 void wxSocketHandler::YieldSock()
1150 {
1151   wxNode *node;
1152
1153   // Nothing to do anymore here except waiting for the queue emptying.
1154   for (node = socks->First(); node; node=node->Next()) {
1155     wxSocketBase *sock = (wxSocketBase *)node->Data();
1156
1157     sock->m_internal->WaitForEnd(NULL);
1158   }
1159 }
1160
1161 // --------------------------------------------------------------
1162 // --------- wxSocketHandler: create and register the socket ----
1163 // --------------------------------------------------------------
1164 wxSocketServer *wxSocketHandler::CreateServer(wxSockAddress& addr,
1165                 wxSocketBase::wxSockFlags flags)
1166 {
1167   wxSocketServer *serv = new wxSocketServer(addr, flags);
1168
1169   Register(serv);
1170   return serv;
1171 }
1172
1173 wxSocketClient *wxSocketHandler::CreateClient(wxSocketBase::wxSockFlags flags)
1174 {
1175   wxSocketClient *client = new wxSocketClient(flags);
1176
1177   Register(client);
1178   return client;
1179 }
1180
1181 bool wxSocketModule::OnInit()
1182 {
1183   wxSocketHandler::master = new wxSocketHandler();
1184   return TRUE;
1185 }
1186
1187 void wxSocketModule::OnExit()
1188 {
1189   delete wxSocketHandler::master;
1190   wxSocketHandler::master = NULL;
1191 }
1192
1193 #endif
1194   // __WXSTUBS__
1195
1196 #endif
1197   // wxUSE_SOCKETS