src/common/socket.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:       socket.cpp
   3 // Purpose:    Socket handler classes
   4 // Authors:    Guilhem Lavaux, Guillermo Rodriguez Garcia
   5 // Created:    April 1997
   6 // Updated:    September 1999
   7 // Copyright:  (C) 1999, 1998, 1997, Guilhem Lavaux
   8 //             (C) 1999, Guillermo Rodriguez Garcia
   9 // RCS_ID:     $Id$
  10 // License:    see wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  14 #pragma implementation "socket.h"
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #if wxUSE_SOCKETS
  25
  26 /////////////////////////////////////////////////////////////////////////////
  27 // wxWindows headers
  28 /////////////////////////////////////////////////////////////////////////////
  29 #include "wx/defs.h"
  30 #include "wx/object.h"
  31 #include "wx/string.h"
  32 #include "wx/timer.h"
  33 #include "wx/utils.h"
  34 #include "wx/module.h"
  35 #include "wx/log.h"
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <ctype.h>
  40
  41 /////////////////////////////////////////////////////////////////////////////
  42 // wxSocket headers
  43 /////////////////////////////////////////////////////////////////////////////
  44 #include "wx/sckaddr.h"
  45 #include "wx/socket.h"
  46
  47
  48 #if defined(__WXMSW__) || defined(__WXPM__) || defined(__WXMOTIF__) || defined(__WXMAC__)
  49     #define PROCESS_EVENTS() wxYield()
  50 #elif defined(__WXGTK__)
  51     #include <gtk/gtk.h>
  52     #define PROCESS_EVENTS() gtk_main_iteration()
  53 #endif
  54
  55
  56 // --------------------------------------------------------------
  57 // ClassInfos
  58 // --------------------------------------------------------------
  59 #if !USE_SHARED_LIBRARY
  60 IMPLEMENT_CLASS(wxSocketBase, wxObject)
  61 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
  62 IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
  63 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
  64 #endif
  65
  66 class wxSocketState : public wxObject
  67 {
  68 public:
  69   bool notify_state;
  70   GSocketEventFlags evt_notify_state;
  71   wxSockFlags socket_flags;
  72   wxSocketBase::wxSockCbk c_callback;
  73   char *c_callback_data;
  74
  75 public:
  76   wxSocketState() : wxObject() {}
  77 };
  78
  79 // --------------------------------------------------------------
  80 // wxSocketBase ctor and dtor
  81 // --------------------------------------------------------------
  82
  83 wxSocketBase::wxSocketBase(wxSockFlags _flags, wxSockType _type) :
  84   wxEvtHandler(),
  85   m_socket(NULL), m_id(-1),
  86   m_flags(_flags), m_type(_type),
  87   m_neededreq(0), m_notify_state(FALSE),
  88   m_connected(FALSE), m_establishing(FALSE),
  89   m_reading(FALSE), m_writing(FALSE),
  90   m_error(FALSE), m_lcount(0), m_timeout(600), m_states(),
  91   m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
  92   m_defering(NO_DEFER), m_defer_buffer(NULL), m_defer_timer(NULL),
  93   m_cbk(NULL), m_cdata(NULL)
  94 {
  95 }
  96
  97 wxSocketBase::wxSocketBase() :
  98   wxEvtHandler(),
  99   m_socket(NULL), m_id(-1),
 100   m_flags(NONE), m_type(SOCK_UNINIT),
 101   m_neededreq(0), m_notify_state(FALSE),
 102   m_connected(FALSE), m_establishing(FALSE),
 103   m_reading(FALSE), m_writing(FALSE),
 104   m_error(FALSE), m_lcount(0), m_timeout(600), m_states(),
 105   m_unread(NULL), m_unrd_size(0), m_unrd_cur(0),
 106   m_defering(NO_DEFER), m_defer_buffer(NULL), m_defer_timer(NULL),
 107   m_cbk(NULL), m_cdata(NULL)
 108 {
 109 }
 110
 111 wxSocketBase::~wxSocketBase()
 112 {
 113   if (m_unread)
 114     free(m_unread);
 115
 116   // Shutdown and close the socket
 117   Close();
 118
 119   // Destroy the GSocket object
 120   if (m_socket)
 121     GSocket_destroy(m_socket);
 122 }
 123
 124 bool wxSocketBase::Close()
 125 {
 126   if (m_socket)
 127   {
 128     // Disable callbacks
 129     GSocket_UnsetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
 130                                     GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG);
 131
 132     // Shutdown the connection
 133     GSocket_Shutdown(m_socket);
 134     m_connected = FALSE;
 135     m_establishing = FALSE;
 136   }
 137
 138   return TRUE;
 139 }
 140
 141 // --------------------------------------------------------------
 142 // wxSocketBase basic IO operations
 143 // --------------------------------------------------------------
 144
 145 // All IO operations {Read, Write, ReadMsg, WriteMsg, Peek,
 146 // Unread, Discard} update m_error and m_lcount.
 147 //
 148 // TODO: Should Connect, Accept and AcceptWith update m_error?
 149
 150 class _wxSocketInternalTimer: public wxTimer
 151 {
 152 public:
 153   int *m_state;
 154   unsigned long m_new_val;
 155
 156   void Notify()
 157   {
 158     *m_state = m_new_val;  // Change the value
 159   }
 160 };
 161
 162 wxUint32 wxSocketBase::DeferRead(char *buffer, wxUint32 nbytes)
 163 {
 164   // Timer for timeout
 165   _wxSocketInternalTimer timer;
 166
 167   //wxLogMessage("Entrando a DeferRead, nbytes = %d", nbytes);
 168   wxASSERT(m_defering == NO_DEFER);
 169
 170   // Set the defering mode to READ.
 171   m_defering = DEFER_READ;
 172
 173   // Set the current buffer.
 174   m_defer_buffer = buffer;
 175   m_defer_nbytes = nbytes;
 176   m_defer_timer  = &timer;
 177
 178   timer.m_state = (int *)&m_defer_buffer;
 179   timer.m_new_val = 0;
 180
 181   timer.Start(m_timeout * 1000, FALSE);
 182
 183   // If the socket is readable, call DoDefer for the first time
 184   if (GSocket_Select(m_socket, GSOCK_INPUT_FLAG))
 185   {
 186     //wxLogMessage("Llamando al primer DoDefer");
 187     DoDefer();
 188   }
 189
 190   // Wait for buffer completion.
 191   while (m_defer_buffer != NULL)
 192     PROCESS_EVENTS();
 193
 194   timer.Stop();
 195
 196   // Disable defering mode.
 197   m_defering = NO_DEFER;
 198   m_defer_timer = NULL;
 199
 200   // Return the number of bytes read from the socket.
 201   //wxLogMessage("Saliendo de DeferRead: total: %d bytes", nbytes - m_defer_nbytes);
 202   return nbytes-m_defer_nbytes;
 203 }
 204
 205 wxSocketBase& wxSocketBase::Read(char* buffer, wxUint32 nbytes)
 206 {
 207   // Mask read events
 208   m_reading = TRUE;
 209
 210   m_lcount = _Read(buffer, nbytes);
 211
 212   // If in WAITALL mode, all bytes should have been read.
 213   if (m_flags & WAITALL)
 214     m_error = (m_lcount != nbytes);
 215   else
 216     m_error = (m_lcount == 0);
 217
 218   // Trigger another read event if there is still data available.
 219   m_reading = FALSE;
 220   // TODO: TriggerRead
 221
 222   return *this;
 223 }
 224
 225 wxUint32 wxSocketBase::_Read(char* buffer, wxUint32 nbytes)
 226 {
 227   int total;
 228   int ret = 1;
 229
 230   // we try this even if the connection has already been closed.
 231   total = GetPushback(buffer, nbytes, FALSE);
 232   nbytes -= total;
 233   buffer += total;
 234
 235   // If the socket is not connected, or we have got the whole
 236   // needed buffer, return immedately
 237   if (!m_connected || !m_socket || !nbytes)
 238     return total;
 239
 240   // Possible combinations (they are checked in this order)
 241   // NOWAIT
 242   // SPEED | WAITALL
 243   // SPEED
 244   // WAITALL
 245   // NONE
 246   //
 247   if (m_flags & NOWAIT)                 // NOWAIT
 248   {
 249     GSocket_SetNonBlocking(m_socket, TRUE);
 250     ret = GSocket_Read(m_socket, buffer, nbytes);
 251     GSocket_SetNonBlocking(m_socket, FALSE);
 252
 253     if (ret > 0)
 254       total += ret;
 255   }
 256   else if ((m_flags & SPEED) && (m_flags & WAITALL))    // SPEED, WAITALL
 257   {
 258     while (ret > 0 && nbytes > 0)
 259     {
 260       ret = GSocket_Read(m_socket, buffer, nbytes);
 261       total += ret;
 262       buffer += ret;
 263       nbytes -= ret;
 264     }
 265     // In case the last call was an error ...
 266     if (ret < 0)
 267       total++;
 268   }
 269   else if (m_flags & SPEED)             // SPEED, !WAITALL
 270   {
 271     ret = GSocket_Read(m_socket, buffer, nbytes);
 272
 273     if (ret > 0)
 274       total += ret;
 275   }
 276   else                                  // NONE or WAITALL
 277   {
 278     ret = DeferRead(buffer, nbytes);
 279
 280     if (ret > 0)
 281       total += ret;
 282   }
 283
 284   return total;
 285 }
 286
 287 wxSocketBase& wxSocketBase::ReadMsg(char* buffer, wxUint32 nbytes)
 288 {
 289 #define MAX_DISCARD_SIZE (10 * 1024)
 290
 291   wxUint32 len, len2, sig, total;
 292   bool error;
 293   int old_flags;
 294   struct
 295   {
 296     unsigned char sig[4];
 297     unsigned char len[4];
 298   } msg;
 299
 300   // Mask read events
 301   m_reading = TRUE;
 302
 303   total = 0;
 304   error = TRUE;
 305   old_flags = m_flags;
 306   SetFlags((m_flags & SPEED) | WAITALL);
 307
 308   if (_Read((char *)&msg, sizeof(msg)) != sizeof(msg))
 309     goto exit;
 310
 311   sig = (wxUint32)msg.sig[0];
 312   sig |= (wxUint32)(msg.sig[1] << 8);
 313   sig |= (wxUint32)(msg.sig[2] << 16);
 314   sig |= (wxUint32)(msg.sig[3] << 24);
 315
 316   if (sig != 0xfeeddead)
 317   {
 318     wxLogMessage(wxT("Warning: invalid signature returned to ReadMsg"));
 319     goto exit;
 320   }
 321
 322   len = (wxUint32)msg.len[0];
 323   len |= (wxUint32)(msg.len[1] << 8);
 324   len |= (wxUint32)(msg.len[2] << 16);
 325   len |= (wxUint32)(msg.len[3] << 24);
 326
 327   //wxLogMessage("Readmsg: %d  %d  %d  %d -> len == %d",
 328   //  msg.len[0], msg.len[1], msg.len[2], msg.len[3], len);
 329
 330   if (len > nbytes)
 331   {
 332     len2 = len - nbytes;
 333     len = nbytes;
 334   }
 335   else
 336     len2 = 0;
 337
 338   // This check is necessary so that we don't attemp to read if
 339   // the msg was zero bytes long.
 340   if (len)
 341   {
 342     total = _Read(buffer, len);
 343
 344     if (total != len)
 345       goto exit;
 346   }
 347   if (len2)
 348   {
 349     char *discard_buffer = new char[MAX_DISCARD_SIZE];
 350     long discard_len;
 351
 352     // NOTE: discarded bytes don't add to m_lcount.
 353     do
 354     {
 355       discard_len = ((len2 > MAX_DISCARD_SIZE)? MAX_DISCARD_SIZE : len2);
 356       discard_len = _Read(discard_buffer, discard_len);
 357       len2 -= discard_len;
 358     }
 359     while ((discard_len > 0) && len2);
 360
 361     delete [] discard_buffer;
 362
 363     if (len2 != 0)
 364       goto exit;
 365   }
 366   if (_Read((char *)&msg, sizeof(msg)) != sizeof(msg))
 367     goto exit;
 368
 369   sig = (wxUint32)msg.sig[0];
 370   sig |= (wxUint32)(msg.sig[1] << 8);
 371   sig |= (wxUint32)(msg.sig[2] << 16);
 372   sig |= (wxUint32)(msg.sig[3] << 24);
 373
 374   if (sig != 0xdeadfeed)
 375   {
 376     //wxLogMessage(wxT("Warning: invalid signature returned to ReadMsg"));
 377     goto exit;
 378   }
 379
 380   // everything was OK
 381   error = FALSE;
 382
 383 exit:
 384   m_error = error;
 385   m_lcount = total;
 386   m_reading = FALSE;
 387   SetFlags(old_flags);
 388
 389   // TODO: TriggerRead
 390   return *this;
 391
 392 #undef MAX_DISCARD_SIZE
 393 }
 394
 395 wxSocketBase& wxSocketBase::Peek(char* buffer, wxUint32 nbytes)
 396 {
 397   // Mask read events
 398   m_reading = TRUE;
 399
 400   m_lcount = _Read(buffer, nbytes);
 401   Pushback(buffer, nbytes);
 402
 403   // If in WAITALL mode, all bytes should have been read.
 404   if (m_flags & WAITALL)
 405     m_error = (m_lcount != nbytes);
 406   else
 407     m_error = (m_lcount == 0);
 408
 409   // Trigger another read event if there is still data available.
 410   m_reading = FALSE;
 411
 412   // TODO: TriggerRead
 413   return *this;
 414 }
 415
 416 wxUint32 wxSocketBase::DeferWrite(const char *buffer, wxUint32 nbytes)
 417 {
 418   // Timer for timeout
 419   _wxSocketInternalTimer timer;
 420
 421   wxASSERT(m_defering == NO_DEFER);
 422   //wxLogMessage("Entrando a DeferWrite");
 423
 424   m_defering = DEFER_WRITE;
 425
 426   // Set the current buffer
 427   m_defer_buffer = (char *)buffer;
 428   m_defer_nbytes = nbytes;
 429   m_defer_timer  = &timer;
 430
 431   // Start timer
 432   timer.m_state   = (int *)&m_defer_buffer;
 433   timer.m_new_val = 0;
 434
 435   timer.Start(m_timeout * 1000, FALSE);
 436
 437   // If the socket is writable, call DoDefer for the first time
 438   if (GSocket_Select(m_socket, GSOCK_OUTPUT_FLAG))
 439   {
 440     //wxLogMessage("Llamando al primer DoDefer");
 441     DoDefer();
 442   }
 443
 444   // Wait for buffer completion.
 445   while (m_defer_buffer != NULL)
 446     PROCESS_EVENTS();
 447
 448   timer.Stop();
 449
 450   // Disable defering mode
 451   m_defer_timer = NULL;
 452   m_defering = NO_DEFER;
 453
 454   wxString s;
 455   s.Printf(wxT("Saliendo de DeferWrite: total %d bytes"), nbytes-m_defer_nbytes);
 456   //wxLogMessage(s);
 457
 458   return nbytes-m_defer_nbytes;
 459 }
 460
 461 wxSocketBase& wxSocketBase::Write(const char *buffer, wxUint32 nbytes)
 462 {
 463   // Mask write events
 464   m_writing = TRUE;
 465
 466   m_lcount = _Write(buffer, nbytes);
 467
 468   // If in WAITALL mode, all bytes should have been written.
 469   if (m_flags & WAITALL)
 470     m_error = (m_lcount != nbytes);
 471   else
 472     m_error = (m_lcount == 0);
 473
 474   // Trigger another write event if the socket is still writable
 475   m_writing = FALSE;
 476
 477   // TODO: TriggerWrite
 478   return *this;
 479 }
 480
 481 wxUint32 wxSocketBase::_Write(const char *buffer, wxUint32 nbytes)
 482 {
 483   wxUint32 total = 0;
 484   int ret = 1;
 485
 486   if (!m_connected || !m_socket)
 487     return 0;
 488
 489   // Possible combinations (they are checked in this order)
 490   // NOWAIT
 491   // SPEED | WAITALL
 492   // SPEED
 493   // WAITALL
 494   // NONE
 495   //
 496   if (m_flags & NOWAIT)                 // NOWAIT
 497   {
 498     GSocket_SetNonBlocking(m_socket, TRUE);
 499     ret = GSocket_Write(m_socket, buffer, nbytes);
 500     GSocket_SetNonBlocking(m_socket, FALSE);
 501
 502     if (ret > 0)
 503       total = ret;
 504   }
 505   else if ((m_flags & SPEED) && (m_flags & WAITALL))    // SPEED, WAITALL
 506   {
 507     while (ret > 0 && nbytes > 0)
 508     {
 509       ret = GSocket_Write(m_socket, buffer, nbytes);
 510       total += ret;
 511       buffer += ret;
 512       nbytes -= ret;
 513     }
 514     // In case the last call was an error ...
 515     if (ret < 0)
 516       total ++;
 517   }
 518   else if (m_flags & SPEED)             // SPEED, !WAITALL
 519   {
 520     ret = GSocket_Write(m_socket, buffer, nbytes);
 521
 522     if (ret > 0)
 523       total = ret;
 524   }
 525   else                                  // NONE or WAITALL
 526   {
 527     ret = DeferWrite(buffer, nbytes);
 528
 529     if (ret > 0)
 530       total = ret;
 531   }
 532
 533   return total;
 534 }
 535
 536 wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, wxUint32 nbytes)
 537 {
 538   wxUint32 total;
 539   bool error;
 540   int old_flags;
 541   struct {
 542     unsigned char sig[4];
 543     unsigned char len[4];
 544   } msg;
 545
 546   // Mask write events
 547   m_writing = TRUE;
 548
 549   error = TRUE;
 550   total = 0;
 551   old_flags = m_flags;
 552   SetFlags((m_flags & SPEED) | WAITALL);
 553
 554   // warning about 'cast truncates constant value'
 555 #ifdef __VISUALC__
 556 #  pragma warning(disable: 4310)
 557 #endif // __VISUALC__
 558
 559   msg.sig[0] = (unsigned char) 0xad;
 560   msg.sig[1] = (unsigned char) 0xde;
 561   msg.sig[2] = (unsigned char) 0xed;
 562   msg.sig[3] = (unsigned char) 0xfe;
 563
 564   msg.len[0] = (unsigned char) nbytes & 0xff;
 565   msg.len[1] = (unsigned char) (nbytes >> 8) & 0xff;
 566   msg.len[2] = (unsigned char) (nbytes >> 16) & 0xff;
 567   msg.len[3] = (unsigned char) (nbytes >> 24) & 0xff;
 568
 569   //wxLogMessage("Writemsg: %d  %d  %d  %d -> %d",
 570   //  nbytes & 0xff,
 571   //  (nbytes >> 8) & 0xff,
 572   //  (nbytes >> 16) & 0xff,
 573   //  (nbytes >> 24) & 0xff,
 574   //  nbytes
 575   //  );
 576
 577   if (_Write((char *)&msg, sizeof(msg)) < sizeof(msg))
 578     goto exit;
 579
 580   total = _Write(buffer, nbytes);
 581
 582   if (total < nbytes)
 583     goto exit;
 584
 585   msg.sig[0] = (unsigned char) 0xed;
 586   msg.sig[1] = (unsigned char) 0xfe;
 587   msg.sig[2] = (unsigned char) 0xad;
 588   msg.sig[3] = (unsigned char) 0xde;
 589   msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
 590
 591   if ((_Write((char *)&msg, sizeof(msg))) < sizeof(msg))
 592     goto exit;
 593
 594   // everything was OK
 595   error = FALSE;
 596
 597 exit:
 598   m_error = error;
 599   m_lcount = total;
 600   m_writing = FALSE;
 601
 602   // TODO: TriggerWrite
 603   return *this;
 604
 605 #ifdef __VISUALC__
 606 #  pragma warning(default: 4310)
 607 #endif // __VISUALC__
 608 }
 609
 610 wxSocketBase& wxSocketBase::Unread(const char *buffer, wxUint32 nbytes)
 611 {
 612   if (nbytes != 0)
 613     Pushback(buffer, nbytes);
 614
 615   m_error = FALSE;
 616   m_lcount = nbytes;
 617
 618   return *this;
 619 }
 620
 621 void wxSocketBase::DoDefer()
 622 {
 623   int ret;
 624
 625   if (!m_defer_buffer)
 626     return;
 627
 628   switch(m_defering)
 629   {
 630     case DEFER_READ:
 631       ret = GSocket_Read(m_socket, m_defer_buffer, m_defer_nbytes);
 632       break;
 633     case DEFER_WRITE:
 634       ret = GSocket_Write(m_socket, m_defer_buffer, m_defer_nbytes);
 635       break;
 636     default:
 637       ret = -1;
 638   }
 639
 640   if (ret >= 0)
 641     m_defer_nbytes -= ret;
 642
 643   // If we are waiting for all bytes to be acquired, keep the defering
 644   // mode enabled.
 645   if (!(m_flags & WAITALL) || !m_defer_nbytes || ret < 0)
 646   {
 647     m_defer_buffer = NULL;
 648   }
 649   else
 650   {
 651     m_defer_buffer += ret;
 652     m_defer_timer->Start(m_timeout * 1000, FALSE);
 653   }
 654
 655   //wxLogMessage("DoDefer ha transferido %d bytes", ret);
 656 }
 657
 658 wxSocketBase& wxSocketBase::Discard()
 659 {
 660 #define MAX_BUFSIZE (10*1024)
 661
 662   int old_flags;
 663   char *my_data = new char[MAX_BUFSIZE];
 664   wxUint32 recv_size = MAX_BUFSIZE;
 665   wxUint32 total = 0;
 666
 667   // Mask read events
 668   m_reading = TRUE;
 669
 670   old_flags = m_flags;
 671   SetFlags(NOWAIT);
 672
 673   while (recv_size == MAX_BUFSIZE)
 674   {
 675     recv_size = _Read(my_data, MAX_BUFSIZE);
 676     total += recv_size;
 677   }
 678
 679   delete [] my_data;
 680   m_lcount = total;
 681   m_error = FALSE;
 682
 683   // Trigger another read event if there is still data available.
 684   m_reading = FALSE;
 685
 686   // TODO: TriggerRead
 687   return *this;
 688
 689 #undef MAX_BUFSIZE
 690 }
 691
 692 // --------------------------------------------------------------
 693 // wxSocketBase get local or peer addresses
 694 // --------------------------------------------------------------
 695
 696 bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
 697 {
 698   GAddress *peer;
 699
 700   if (!m_socket)
 701     return FALSE;
 702
 703   peer = GSocket_GetPeer(m_socket);
 704   addr_man.SetAddress(peer);
 705   GAddress_destroy(peer);
 706
 707   return TRUE;
 708 }
 709
 710 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
 711 {
 712   GAddress *local;
 713
 714   if (!m_socket)
 715     return FALSE;
 716
 717   local = GSocket_GetLocal(m_socket);
 718   addr_man.SetAddress(local);
 719   GAddress_destroy(local);
 720
 721   return TRUE;
 722 }
 723
 724 // --------------------------------------------------------------
 725 // wxSocketBase save and restore socket state
 726 // --------------------------------------------------------------
 727
 728 void wxSocketBase::SaveState()
 729 {
 730   wxSocketState *state;
 731
 732   state = new wxSocketState();
 733
 734   state->notify_state     = m_notify_state;
 735   state->evt_notify_state = m_neededreq;
 736   state->socket_flags     = m_flags;
 737   state->c_callback       = m_cbk;
 738   state->c_callback_data  = m_cdata;
 739
 740   m_states.Append(state);
 741 }
 742
 743 void wxSocketBase::RestoreState()
 744 {
 745   wxNode *node;
 746   wxSocketState *state;
 747
 748   node = m_states.Last();
 749   if (!node)
 750     return;
 751
 752   state = (wxSocketState *)node->Data();
 753
 754   SetFlags(state->socket_flags);
 755   m_neededreq = state->evt_notify_state;
 756   m_cbk       = state->c_callback;
 757   m_cdata     = state->c_callback_data;
 758   Notify(state->notify_state);
 759
 760   delete node;
 761   delete state;
 762 }
 763
 764
 765 // --------------------------------------------------------------
 766 // wxSocketBase Wait functions
 767 // --------------------------------------------------------------
 768
 769 // GRG: I have completely rewritten this family of functions
 770 // so that they don't depend on event notifications; instead,
 771 // they poll the socket, using GSocket_Select(), to check for
 772 // the specified combination of event flags, until an event
 773 // occurs or until the timeout ellapses. The polling loop
 774 // calls PROCESS_EVENTS(), so this won't block the GUI.
 775
 776 bool wxSocketBase::_Wait(long seconds, long milliseconds, wxSocketEventFlags flags)
 777 {
 778   GSocketEventFlags result;
 779   _wxSocketInternalTimer timer;
 780   long timeout;
 781   int state = -1;
 782
 783   // Check for valid socket
 784   if (!m_socket)
 785     return FALSE;
 786
 787   // If it is not a server, it must be connected or establishing connection
 788   if ((m_type != SOCK_SERVER) && (!m_connected && !m_establishing))
 789     return FALSE;
 790
 791   // Check for valid timeout value
 792   if (seconds != -1)
 793     timeout = seconds * 1000 + milliseconds;
 794   else
 795     timeout = m_timeout * 1000;
 796
 797   // Activate timer
 798   if (timeout)
 799   {
 800     timer.m_state = &state;
 801     timer.m_new_val = 0;
 802     timer.Start(timeout, TRUE);
 803   }
 804
 805   // Active polling (without using events)
 806   //
 807   // NOTE: this duplicates some of the code in OnRequest (lost
 808   // connection and connection establishment handling) but this
 809   // doesn't hurt. It has to be here because the event might
 810   // be a bit delayed, and it has to be in OnRequest as well
 811   // because maybe the WaitXXX functions are not being used.
 812   //
 813   // Do this at least once (important if timeout == 0, when
 814   // we are just polling)
 815   do
 816   {
 817     result = GSocket_Select(m_socket, flags | GSOCK_LOST_FLAG);
 818
 819     // Connection lost
 820     if (result & GSOCK_LOST_FLAG)
 821     {
 822       timer.Stop();
 823       m_defer_buffer = NULL;
 824       Close();
 825       return TRUE;
 826     }
 827
 828     // Incoming connection (server) or connection established (client)
 829     if (result & GSOCK_CONNECTION_FLAG)
 830     {
 831       timer.Stop();
 832       m_connected = TRUE;
 833       m_establishing = FALSE;
 834       return TRUE;
 835     }
 836
 837     // If we are in the middle of a R/W operation, do not propagate
 838     // to users.
 839     if ( ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG))
 840          && (!m_writing) && (!m_reading) )
 841     {
 842 /* TODO: remove this
 843       if (m_defer_buffer == NULL)
 844 */
 845       {
 846         timer.Stop();
 847         return TRUE;
 848       }
 849     }
 850
 851     if (timeout != 0)
 852       PROCESS_EVENTS();
 853   }
 854   while ((state == -1) && timeout);
 855
 856   timer.Stop();
 857   return FALSE;
 858 }
 859
 860 bool wxSocketBase::Wait(long seconds, long milliseconds)
 861 {
 862   return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
 863                                       GSOCK_OUTPUT_FLAG |
 864                                       GSOCK_CONNECTION_FLAG |
 865                                       GSOCK_LOST_FLAG);
 866 }
 867
 868 bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
 869 {
 870   // Check pushback buffer
 871   if (m_unread)
 872     return TRUE;
 873
 874   return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG);
 875 }
 876
 877 bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
 878 {
 879   return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
 880 }
 881
 882 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 883 {
 884   return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG);
 885 }
 886
 887 void wxSocketBase::SetTimeout(long seconds)
 888 {
 889   m_timeout = seconds;
 890
 891   if (m_socket)
 892     GSocket_SetTimeout(m_socket, m_timeout);
 893 }
 894
 895 // --------------------------------------------------------------
 896 // wxSocketBase flags
 897 // --------------------------------------------------------------
 898
 899 void wxSocketBase::SetFlags(wxSockFlags _flags)
 900 {
 901   m_flags = _flags;
 902 }
 903
 904 // --------------------------------------------------------------
 905 // wxSocketBase callback management
 906 // --------------------------------------------------------------
 907
 908 wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSockCbk cbk_)
 909 {
 910   wxSockCbk old_cbk = cbk_;
 911
 912   m_cbk = cbk_;
 913   return old_cbk;
 914 }
 915
 916 char *wxSocketBase::CallbackData(char *data)
 917 {
 918   char *old_data = m_cdata;
 919
 920   m_cdata = data;
 921   return old_data;
 922 }
 923
 924 // --------------------------------------------------------------
 925 // wxSocketBase automatic notifier
 926 // --------------------------------------------------------------
 927
 928 // All events (INPUT, OUTPUT, CONNECTION, LOST) are now always
 929 // internally watched; but users will only be notified of those
 930 // events they are interested in.
 931
 932 static void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
 933                                            GSocketEvent event, char *cdata)
 934 {
 935   wxSocketBase *sckobj = (wxSocketBase *)cdata;
 936
 937   sckobj->OnRequest((wxSocketNotify)event);
 938 }
 939
 940 wxSocketEventFlags wxSocketBase::EventToNotify(wxSocketNotify evt)
 941 {
 942   switch (evt)
 943   {
 944     case GSOCK_INPUT:      return GSOCK_INPUT_FLAG;
 945     case GSOCK_OUTPUT:     return GSOCK_OUTPUT_FLAG;
 946     case GSOCK_CONNECTION: return GSOCK_CONNECTION_FLAG;
 947     case GSOCK_LOST:       return GSOCK_LOST_FLAG;
 948   }
 949   return 0;
 950 }
 951
 952 void wxSocketBase::SetNotify(wxSocketEventFlags flags)
 953 {
 954   m_neededreq = flags;
 955 }
 956
 957 void wxSocketBase::Notify(bool notify)
 958 {
 959   m_notify_state = notify;
 960 }
 961
 962 void wxSocketBase::OnRequest(wxSocketNotify req_evt)
 963 {
 964   wxSocketEvent event(m_id);
 965   wxSocketEventFlags flag = EventToNotify(req_evt);
 966
 967   // fprintf(stderr, "%s: Entering OnRequest (evt %d)\n", (m_type == SOCK_CLIENT)? "client" : "server", req_evt);
 968
 969   // NOTE: this duplicates some of the code in _Wait (lost
 970   // connection and connection establishment handling) but
 971   // this doesn't hurt. It has to be here because maybe the
 972   // WaitXXX are not being used, and it has to be in _Wait
 973   // as well because the event might be a bit delayed.
 974   //
 975   switch(req_evt)
 976   {
 977     case wxSOCKET_CONNECTION:
 978       m_establishing = FALSE;
 979       m_connected = TRUE;
 980       break;
 981     case wxSOCKET_LOST:
 982       m_defer_buffer = NULL;
 983       Close();
 984       break;
 985     case wxSOCKET_INPUT:
 986     case wxSOCKET_OUTPUT:
 987       if (m_defer_buffer)
 988       {
 989         // fprintf(stderr, "%s: Habia buffer, evt %d skipped\n", (m_type == SOCK_CLIENT)? "client" : "server", req_evt);
 990         DoDefer();
 991         // Do not notify to user
 992         return;
 993       }
 994       break;
 995   }
 996
 997   // If we are in the middle of a R/W operation, do not
 998   // propagate events to users.
 999   if (((req_evt == wxSOCKET_INPUT) && m_reading) ||
1000       ((req_evt == wxSOCKET_OUTPUT) && m_writing))
1001   {
1002     // fprintf(stderr, "%s: Swallowed evt %d\n", (m_type == SOCK_CLIENT)? "client" : "server", req_evt);
1003     return;
1004   }
1005
1006   if (((m_neededreq & flag) == flag) && m_notify_state)
1007   {
1008     // fprintf(stderr, "%s: Evt %d delivered\n", (m_type == SOCK_CLIENT)? "client" : "server", req_evt);
1009     event.m_socket = this;
1010     event.m_skevt  = req_evt;
1011     ProcessEvent(event);
1012     OldOnNotify(req_evt);
1013
1014     if (m_cbk)
1015       m_cbk(*this, req_evt, m_cdata);
1016   }
1017
1018   // fprintf(stderr, "%s: Exiting OnRequest (evt %d)\n", (m_type == SOCK_CLIENT)? "client" : "server", req_evt);
1019 }
1020
1021 void wxSocketBase::OldOnNotify(wxSocketNotify WXUNUSED(evt))
1022 {
1023 }
1024
1025 // --------------------------------------------------------------
1026 // wxSocketBase set event handler
1027 // --------------------------------------------------------------
1028
1029 void wxSocketBase::SetEventHandler(wxEvtHandler& h_evt, int id)
1030 {
1031   SetNextHandler(&h_evt);
1032   m_id = id;
1033 }
1034
1035 // --------------------------------------------------------------
1036 // wxSocketBase pushback
1037 // --------------------------------------------------------------
1038
1039 void wxSocketBase::Pushback(const char *buffer, wxUint32 size)
1040 {
1041   if (m_unread == NULL)
1042     m_unread = (char *)malloc(size);
1043   else {
1044     char *tmp;
1045
1046     tmp = (char *)malloc(m_unrd_size + size);
1047     memcpy(tmp+size, m_unread, m_unrd_size);
1048     free(m_unread);
1049
1050     m_unread = tmp;
1051   }
1052
1053   m_unrd_size += size;
1054
1055   memcpy(m_unread, buffer, size);
1056 }
1057
1058 wxUint32 wxSocketBase::GetPushback(char *buffer, wxUint32 size, bool peek)
1059 {
1060   if (!m_unrd_size)
1061     return 0;
1062
1063   if (size > (m_unrd_size-m_unrd_cur))
1064     size = m_unrd_size-m_unrd_cur;
1065
1066   memcpy(buffer, (m_unread+m_unrd_cur), size);
1067
1068   if (!peek) {
1069     m_unrd_cur += size;
1070     if (m_unrd_size == m_unrd_cur) {
1071       free(m_unread);
1072       m_unread = NULL;
1073       m_unrd_size = 0;
1074       m_unrd_cur  = 0;
1075     }
1076   }
1077
1078   return size;
1079 }
1080
1081 // --------------------------------------------------------------
1082 // wxSocketServer
1083 // --------------------------------------------------------------
1084
1085 // --------------------------------------------------------------
1086 // wxSocketServer ctor and dtor
1087 // --------------------------------------------------------------
1088
1089 wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
1090              wxSockFlags flags) :
1091   wxSocketBase(flags, SOCK_SERVER)
1092 {
1093   // Create the socket
1094   m_socket = GSocket_new();
1095
1096   if (!m_socket)
1097     return;
1098
1099   // Setup the socket as server
1100   GSocket_SetLocal(m_socket, addr_man.GetAddress());
1101   if (GSocket_SetServer(m_socket) != GSOCK_NOERROR)
1102   {
1103     GSocket_destroy(m_socket);
1104     m_socket = NULL;
1105     return;
1106   }
1107
1108   GSocket_SetTimeout(m_socket, m_timeout);
1109   GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1110                                 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1111                                 wx_socket_callback, (char *)this);
1112
1113 }
1114
1115 // --------------------------------------------------------------
1116 // wxSocketServer Accept
1117 // --------------------------------------------------------------
1118
1119 bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait)
1120 {
1121   GSocket *child_socket;
1122
1123   if (!m_socket)
1124     return FALSE;
1125
1126   // GRG: If wait == FALSE, then the call should be nonblocking.
1127   // When we are finished, we put the socket to blocking mode
1128   // again.
1129
1130   if (!wait)
1131     GSocket_SetNonBlocking(m_socket, TRUE);
1132
1133   child_socket = GSocket_WaitConnection(m_socket);
1134
1135   if (!wait)
1136     GSocket_SetNonBlocking(m_socket, FALSE);
1137
1138   // GRG: this was not being handled!
1139   if (child_socket == NULL)
1140     return FALSE;
1141
1142   sock.m_type = SOCK_INTERNAL;
1143   sock.m_socket = child_socket;
1144   sock.m_connected = TRUE;
1145
1146   GSocket_SetTimeout(sock.m_socket, sock.m_timeout);
1147   GSocket_SetCallback(sock.m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1148                                      GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1149                                      wx_socket_callback, (char *)&sock);
1150
1151   return TRUE;
1152 }
1153
1154 wxSocketBase *wxSocketServer::Accept(bool wait)
1155 {
1156   wxSocketBase* sock = new wxSocketBase();
1157
1158   sock->SetFlags((wxSockFlags)m_flags);
1159
1160   if (!AcceptWith(*sock, wait))
1161     return NULL;
1162
1163   return sock;
1164 }
1165
1166 bool wxSocketServer::WaitForAccept(long seconds, long milliseconds)
1167 {
1168   return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
1169 }
1170
1171 // --------------------------------------------------------------
1172 // wxSocketClient
1173 // --------------------------------------------------------------
1174
1175 // --------------------------------------------------------------
1176 // wxSocketClient ctor and dtor
1177 // --------------------------------------------------------------
1178
1179 wxSocketClient::wxSocketClient(wxSockFlags _flags) :
1180   wxSocketBase(_flags, SOCK_CLIENT)
1181 {
1182 }
1183
1184 wxSocketClient::~wxSocketClient()
1185 {
1186 }
1187
1188 // --------------------------------------------------------------
1189 // wxSocketClient Connect functions
1190 // --------------------------------------------------------------
1191 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
1192 {
1193   GSocketError err;
1194
1195   if (IsConnected())
1196     Close();
1197
1198   // This should never happen.
1199   if (m_socket)
1200     GSocket_destroy(m_socket);
1201
1202   // Initialize all socket stuff ...
1203   m_socket = GSocket_new();
1204   m_connected = FALSE;
1205   m_establishing = FALSE;
1206
1207   if (!m_socket)
1208     return FALSE;
1209
1210   GSocket_SetTimeout(m_socket, m_timeout);
1211   GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1212                                 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1213                                 wx_socket_callback, (char *)this);
1214
1215   // GRG: If wait == FALSE, then the call should be nonblocking.
1216   // When we are finished, we put the socket to blocking mode
1217   // again.
1218
1219   if (!wait)
1220     GSocket_SetNonBlocking(m_socket, TRUE);
1221
1222   GSocket_SetPeer(m_socket, addr_man.GetAddress());
1223   err = GSocket_Connect(m_socket, GSOCK_STREAMED);
1224
1225   if (!wait)
1226     GSocket_SetNonBlocking(m_socket, FALSE);
1227
1228   if (err != GSOCK_NOERROR)
1229   {
1230     if (err == GSOCK_WOULDBLOCK)
1231       m_establishing = TRUE;
1232
1233     return FALSE;
1234   }
1235
1236   m_connected = TRUE;
1237   return TRUE;
1238 }
1239
1240 bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
1241 {
1242   if (m_connected)                      // Already connected
1243     return TRUE;
1244
1245   if (!m_establishing || !m_socket)     // No connection in progress
1246     return FALSE;
1247
1248   return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
1249 }
1250
1251 // --------------------------------------------------------------
1252 // wxSocketEvent
1253 // --------------------------------------------------------------
1254
1255 wxSocketEvent::wxSocketEvent(int id)
1256   : wxEvent(id)
1257 {
1258   wxEventType type = (wxEventType)wxEVT_SOCKET;
1259
1260   SetEventType(type);
1261 }
1262
1263 void wxSocketEvent::CopyObject(wxObject& obj_d) const
1264 {
1265   wxSocketEvent *event = (wxSocketEvent *)&obj_d;
1266
1267   wxEvent::CopyObject(obj_d);
1268
1269   event->m_skevt = m_skevt;
1270   event->m_socket = m_socket;
1271 }
1272
1273 // --------------------------------------------------------------------------
1274 // wxSocketModule
1275 // --------------------------------------------------------------------------
1276 class WXDLLEXPORT wxSocketModule: public wxModule {
1277   DECLARE_DYNAMIC_CLASS(wxSocketModule)
1278  public:
1279   bool OnInit() {
1280     return GSocket_Init();
1281   }
1282   void OnExit() {
1283     GSocket_Cleanup();
1284   }
1285 };
1286
1287 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
1288
1289 #endif
1290   // wxUSE_SOCKETS