src/mac/carbon/cfsocket.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:       src/mac/carbon/cfsocket.cpp
   3 // Purpose:    Socket handler classes
   4 // Authors:    Guilhem Lavaux, Guillermo Rodriguez Garcia
   5 // Created:    April 1997
   6 // Copyright:  (C) 1999-1997, Guilhem Lavaux
   7 //             (C) 2000-1999, Guillermo Rodriguez Garcia
   8 // RCS_ID:     $Id$
   9 // License:    see wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_SOCKETS
  19
  20 #include "wx/socket.h"
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/object.h"
  24     #include "wx/string.h"
  25     #include "wx/intl.h"
  26     #include "wx/log.h"
  27     #include "wx/event.h"
  28     #include "wx/app.h"
  29     #include "wx/utils.h"
  30     #include "wx/timer.h"
  31     #include "wx/module.h"
  32 #endif
  33
  34 #include "wx/apptrait.h"
  35
  36 #include "wx/sckaddr.h"
  37 #include "wx/mac/carbon/private.h"
  38
  39 #include <sys/socket.h>
  40 #include <netinet/in.h>
  41 #include <arpa/inet.h>
  42 #include <netdb.h>
  43
  44 #define HAVE_INET_ATON
  45
  46 // DLL options compatibility check:
  47 #include "wx/build.h"
  48
  49 WX_CHECK_BUILD_OPTIONS("wxNet")
  50
  51
  52 // discard buffer
  53 #define MAX_DISCARD_SIZE (10 * 1024)
  54
  55 #ifndef INVALID_SOCKET
  56 #define INVALID_SOCKET -1
  57 #endif
  58
  59 // what to do within waits: we have 2 cases: from the main thread itself we
  60 // have to call wxYield() to let the events (including the GUI events and the
  61 // low-level (not wxWidgets) events from GSocket) be processed. From another
  62 // thread it is enough to just call wxThread::Yield() which will give away the
  63 // rest of our time slice: the explanation is that the events will be processed
  64 // by the main thread anyhow, without calling wxYield(), but we don't want to
  65 // eat the CPU time uselessly while sitting in the loop waiting for the data
  66 #if wxUSE_THREADS
  67     #define PROCESS_EVENTS()        \
  68     {                               \
  69         if ( wxThread::IsMain() )   \
  70             wxYield();              \
  71         else                        \
  72             wxThread::Yield();      \
  73     }
  74 #else // !wxUSE_THREADS
  75     #define PROCESS_EVENTS() wxYield()
  76 #endif // wxUSE_THREADS/!wxUSE_THREADS
  77
  78 #define wxTRACE_Socket _T("wxSocket")
  79
  80
  81 IMPLEMENT_CLASS(wxSocketBase, wxObject)
  82 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
  83 IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
  84 IMPLEMENT_CLASS(wxDatagramSocket, wxSocketBase)
  85 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
  86
  87 // --------------------------------------------------------------------------
  88 // private classes
  89 // --------------------------------------------------------------------------
  90
  91 class wxSocketState : public wxObject
  92 {
  93 public:
  94   wxSocketFlags            m_flags;
  95   wxSocketEventFlags       m_eventmask;
  96   bool                     m_notify;
  97   void                    *m_clientData;
  98
  99 public:
 100   wxSocketState() : wxObject() {}
 101
 102     DECLARE_NO_COPY_CLASS(wxSocketState)
 103 };
 104
 105 struct _GSocket
 106 {
 107   CFSocketNativeHandle m_fd;
 108   GAddress *m_local;
 109   GAddress *m_peer;
 110   GSocketError m_error;
 111
 112   int m_non_blocking;
 113   int m_server;
 114   int m_stream;
 115   int m_oriented;
 116   int m_establishing;
 117   unsigned long m_timeout;
 118
 119   // Callbacks
 120   GSocketEventFlags m_detected;
 121   GSocketCallback m_cbacks[GSOCK_MAX_EVENT];
 122   char *m_data[GSOCK_MAX_EVENT];
 123
 124   CFSocketRef           m_cfSocket;
 125   CFRunLoopSourceRef    m_runLoopSource;
 126   CFReadStreamRef       m_readStream ;
 127   CFWriteStreamRef      m_writeStream ;
 128 };
 129
 130 struct _GAddress
 131 {
 132   struct sockaddr *m_addr;
 133   size_t m_len;
 134
 135   GAddressType m_family;
 136   int m_realfamily;
 137
 138   GSocketError m_error;
 139   int somethingElse ;
 140 };
 141
 142 void wxMacCFSocketCallback(CFSocketRef s, CFSocketCallBackType callbackType,
 143                          CFDataRef address, const void* data, void* info) ;
 144 void _GSocket_Enable(GSocket *socket, GSocketEvent event) ;
 145 void _GSocket_Disable(GSocket *socket, GSocketEvent event) ;
 146
 147 // ==========================================================================
 148 // wxSocketBase
 149 // ==========================================================================
 150
 151 // --------------------------------------------------------------------------
 152 // Initialization and shutdown
 153 // --------------------------------------------------------------------------
 154
 155 // FIXME-MT: all this is MT-unsafe, of course, we should protect all accesses
 156 //           to m_countInit with a crit section
 157 size_t wxSocketBase::m_countInit = 0;
 158
 159 bool wxSocketBase::IsInitialized()
 160 {
 161     return m_countInit > 0;
 162 }
 163
 164 bool wxSocketBase::Initialize()
 165 {
 166     if ( !m_countInit++ )
 167     {
 168 #if 0
 169         wxAppTraits *traits = wxAppConsole::GetInstance() ?
 170                               wxAppConsole::GetInstance()->GetTraits() : NULL;
 171         GSocketGUIFunctionsTable *functions =
 172             traits ? traits->GetSocketGUIFunctionsTable() : NULL;
 173         GSocket_SetGUIFunctions(functions);
 174
 175         if ( !GSocket_Init() )
 176         {
 177             m_countInit--;
 178
 179             return false;
 180         }
 181 #endif
 182     }
 183
 184     return true;
 185 }
 186
 187 void wxSocketBase::Shutdown()
 188 {
 189     // we should be initialized
 190     wxASSERT_MSG( m_countInit, wxT("extra call to Shutdown()") );
 191     if ( !--m_countInit )
 192     {
 193 #if 0
 194         GSocket_Cleanup();
 195 #endif
 196     }
 197 }
 198
 199 // --------------------------------------------------------------------------
 200 // Ctor and dtor
 201 // --------------------------------------------------------------------------
 202
 203 void wxSocketBase::Init()
 204 {
 205   m_socket       = NULL;
 206   m_type         = wxSOCKET_UNINIT;
 207
 208   // state
 209   m_flags        = 0;
 210   m_connected    =
 211   m_establishing =
 212   m_reading      =
 213   m_writing      =
 214   m_error        = false;
 215   m_lcount       = 0;
 216   m_timeout      = 600;
 217   m_beingDeleted = false;
 218
 219   // pushback buffer
 220   m_unread       = NULL;
 221   m_unrd_size    = 0;
 222   m_unrd_cur     = 0;
 223
 224   // events
 225   m_id           = -1;
 226   m_handler      = NULL;
 227   m_clientData   = NULL;
 228   m_notify       = false;
 229   m_eventmask    = 0;
 230
 231   if ( !IsInitialized() )
 232   {
 233       // this Initialize() will be undone by wxSocketModule::OnExit(), all the
 234       // other calls to it should be matched by a call to Shutdown()
 235       Initialize();
 236   }
 237 }
 238
 239 wxSocketBase::wxSocketBase()
 240 {
 241   Init();
 242 }
 243
 244 wxSocketBase::wxSocketBase( wxSocketFlags flags, wxSocketType type)
 245 {
 246   Init();
 247
 248   m_flags = flags;
 249   m_type  = type;
 250 }
 251
 252 wxSocketBase::~wxSocketBase()
 253 {
 254   // Just in case the app called Destroy() *and* then deleted
 255   // the socket immediately: don't leave dangling pointers.
 256   wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
 257   if ( traits )
 258       traits->RemoveFromPendingDelete(this);
 259
 260   // Shutdown and close the socket
 261   if (!m_beingDeleted)
 262     Close();
 263
 264   // Destroy the GSocket object
 265   if (m_socket)
 266   {
 267     GSocket_destroy(m_socket);
 268   }
 269
 270   // Free the pushback buffer
 271   if (m_unread)
 272     free(m_unread);
 273 }
 274
 275 bool wxSocketBase::Destroy()
 276 {
 277   // Delayed destruction: the socket will be deleted during the next
 278   // idle loop iteration. This ensures that all pending events have
 279   // been processed.
 280   m_beingDeleted = true;
 281
 282   // Shutdown and close the socket
 283   Close();
 284
 285   // Supress events from now on
 286   Notify(false);
 287
 288   // schedule this object for deletion
 289   wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
 290   if ( traits )
 291   {
 292       // let the traits object decide what to do with us
 293       traits->ScheduleForDestroy(this);
 294   }
 295   else // no app or no traits
 296   {
 297       // in wxBase we might have no app object at all, don't leak memory
 298       delete this;
 299   }
 300
 301   return true;
 302 }
 303
 304 // --------------------------------------------------------------------------
 305 // Basic IO calls
 306 // --------------------------------------------------------------------------
 307
 308 // The following IO operations update m_error and m_lcount:
 309 // {Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard}
 310 //
 311 // TODO: Should Connect, Accept and AcceptWith update m_error?
 312
 313 bool wxSocketBase::Close()
 314 {
 315   // Interrupt pending waits
 316   InterruptWait();
 317
 318   if (m_socket)
 319     GSocket_Shutdown(m_socket);
 320
 321   m_connected = false;
 322   m_establishing = false;
 323
 324   return true;
 325 }
 326
 327 wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
 328 {
 329   // Mask read events
 330   m_reading = true;
 331
 332   m_lcount = _Read(buffer, nbytes);
 333
 334   // If in wxSOCKET_WAITALL mode, all bytes should have been read.
 335   if (m_flags & wxSOCKET_WAITALL)
 336     m_error = (m_lcount != nbytes);
 337   else
 338     m_error = (m_lcount == 0);
 339
 340   // Allow read events from now on
 341   m_reading = false;
 342
 343   return *this;
 344 }
 345
 346 wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
 347 {
 348   int total = 0;
 349
 350   // Try the pushback buffer first
 351   total = GetPushback(buffer, nbytes, false);
 352   nbytes -= total;
 353   buffer  = (char *)buffer + total;
 354
 355   // Return now in one of the following cases:
 356   // - the socket is invalid,
 357   // - we got all the data,
 358   // - we got *some* data and we are not using wxSOCKET_WAITALL.
 359   if ( !m_socket ||
 360        !nbytes ||
 361        ((total != 0) && !(m_flags & wxSOCKET_WAITALL)) )
 362     return total;
 363
 364   // Possible combinations (they are checked in this order)
 365   // wxSOCKET_NOWAIT
 366   // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK)
 367   // wxSOCKET_BLOCK
 368   // wxSOCKET_NONE
 369   //
 370
 371   int ret;
 372   if (m_flags & wxSOCKET_NOWAIT)
 373   {
 374     GSocket_SetNonBlocking(m_socket, 1);
 375     ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
 376     GSocket_SetNonBlocking(m_socket, 0);
 377
 378     if (ret > 0)
 379       total += ret;
 380   }
 381   else
 382   {
 383     bool more = true;
 384
 385     while (more)
 386     {
 387       if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() )
 388         break;
 389
 390       ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
 391
 392       if (ret > 0)
 393       {
 394         total  += ret;
 395         nbytes -= ret;
 396         buffer  = (char *)buffer + ret;
 397       }
 398
 399       // If we got here and wxSOCKET_WAITALL is not set, we can leave
 400       // now. Otherwise, wait until we recv all the data or until there
 401       // is an error.
 402       //
 403       more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));
 404     }
 405   }
 406
 407   return total;
 408 }
 409
 410 wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
 411 {
 412   wxUint32 len, len2, sig, total;
 413   bool error;
 414   int old_flags;
 415   struct
 416   {
 417     unsigned char sig[4];
 418     unsigned char len[4];
 419   }
 420   msg;
 421
 422   // Mask read events
 423   m_reading = true;
 424
 425   total = 0;
 426   error = true;
 427   old_flags = m_flags;
 428   SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
 429
 430   if (_Read(&msg, sizeof(msg)) != sizeof(msg))
 431     goto exit;
 432
 433   sig = (wxUint32)msg.sig[0];
 434   sig |= (wxUint32)(msg.sig[1] << 8);
 435   sig |= (wxUint32)(msg.sig[2] << 16);
 436   sig |= (wxUint32)(msg.sig[3] << 24);
 437
 438   if (sig != 0xfeeddead)
 439   {
 440     wxLogWarning( wxT("wxSocket: invalid signature in ReadMsg.") );
 441     goto exit;
 442   }
 443
 444   len = (wxUint32)msg.len[0];
 445   len |= (wxUint32)(msg.len[1] << 8);
 446   len |= (wxUint32)(msg.len[2] << 16);
 447   len |= (wxUint32)(msg.len[3] << 24);
 448
 449   if (len > nbytes)
 450   {
 451     len2 = len - nbytes;
 452     len = nbytes;
 453   }
 454   else
 455     len2 = 0;
 456
 457   // Don't attemp to read if the msg was zero bytes long.
 458   if (len)
 459   {
 460     total = _Read(buffer, len);
 461
 462     if (total != len)
 463       goto exit;
 464   }
 465   if (len2)
 466   {
 467     char *discard_buffer = new char[MAX_DISCARD_SIZE];
 468     long discard_len;
 469
 470     // NOTE: discarded bytes don't add to m_lcount.
 471     do
 472     {
 473       discard_len = ((len2 > MAX_DISCARD_SIZE)? MAX_DISCARD_SIZE : len2);
 474       discard_len = _Read(discard_buffer, (wxUint32)discard_len);
 475       len2 -= (wxUint32)discard_len;
 476     }
 477     while ((discard_len > 0) && len2);
 478
 479     delete [] discard_buffer;
 480
 481     if (len2 != 0)
 482       goto exit;
 483   }
 484   if (_Read(&msg, sizeof(msg)) != sizeof(msg))
 485     goto exit;
 486
 487   sig = (wxUint32)msg.sig[0];
 488   sig |= (wxUint32)(msg.sig[1] << 8);
 489   sig |= (wxUint32)(msg.sig[2] << 16);
 490   sig |= (wxUint32)(msg.sig[3] << 24);
 491
 492   if (sig != 0xdeadfeed)
 493   {
 494     wxLogWarning( wxT("wxSocket: invalid signature in ReadMsg.") );
 495     goto exit;
 496   }
 497
 498   // everything was OK
 499   error = false;
 500
 501 exit:
 502   m_error = error;
 503   m_lcount = total;
 504   m_reading = false;
 505   SetFlags(old_flags);
 506
 507   return *this;
 508 }
 509
 510 wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
 511 {
 512   // Mask read events
 513   m_reading = true;
 514
 515   m_lcount = _Read(buffer, nbytes);
 516   Pushback(buffer, m_lcount);
 517
 518   // If in wxSOCKET_WAITALL mode, all bytes should have been read.
 519   if (m_flags & wxSOCKET_WAITALL)
 520     m_error = (m_lcount != nbytes);
 521   else
 522     m_error = (m_lcount == 0);
 523
 524   // Allow read events again
 525   m_reading = false;
 526
 527   return *this;
 528 }
 529
 530 wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes)
 531 {
 532   // Mask write events
 533   m_writing = true;
 534
 535   m_lcount = _Write(buffer, nbytes);
 536
 537   // If in wxSOCKET_WAITALL mode, all bytes should have been written.
 538   if (m_flags & wxSOCKET_WAITALL)
 539     m_error = (m_lcount != nbytes);
 540   else
 541     m_error = (m_lcount == 0);
 542
 543   // Allow write events again
 544   m_writing = false;
 545
 546   return *this;
 547 }
 548
 549 wxUint32 wxSocketBase::_Write(const void *buffer, wxUint32 nbytes)
 550 {
 551   wxUint32 total = 0;
 552
 553   // If the socket is invalid or parameters are ill, return immediately
 554   if (!m_socket || !buffer || !nbytes)
 555     return 0;
 556
 557   // Possible combinations (they are checked in this order)
 558   // wxSOCKET_NOWAIT
 559   // wxSOCKET_WAITALL (with or without wxSOCKET_BLOCK)
 560   // wxSOCKET_BLOCK
 561   // wxSOCKET_NONE
 562   //
 563   int ret;
 564   if (m_flags & wxSOCKET_NOWAIT)
 565   {
 566     GSocket_SetNonBlocking(m_socket, 1);
 567     ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
 568     GSocket_SetNonBlocking(m_socket, 0);
 569
 570     if (ret > 0)
 571       total = ret;
 572   }
 573   else
 574   {
 575     bool more = true;
 576
 577     while (more)
 578     {
 579       if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForWrite() )
 580         break;
 581
 582       ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
 583
 584       if (ret > 0)
 585       {
 586         total  += ret;
 587         nbytes -= ret;
 588         buffer  = (const char *)buffer + ret;
 589       }
 590
 591       // If we got here and wxSOCKET_WAITALL is not set, we can leave
 592       // now. Otherwise, wait until we send all the data or until there
 593       // is an error.
 594       //
 595       more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));
 596     }
 597   }
 598
 599   return total;
 600 }
 601
 602 wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes)
 603 {
 604   wxUint32 total;
 605   bool error;
 606   struct
 607   {
 608     unsigned char sig[4];
 609     unsigned char len[4];
 610   }
 611   msg;
 612
 613   // Mask write events
 614   m_writing = true;
 615
 616   error = true;
 617   total = 0;
 618   SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
 619
 620   msg.sig[0] = (unsigned char) 0xad;
 621   msg.sig[1] = (unsigned char) 0xde;
 622   msg.sig[2] = (unsigned char) 0xed;
 623   msg.sig[3] = (unsigned char) 0xfe;
 624
 625   msg.len[0] = (unsigned char) (nbytes & 0xff);
 626   msg.len[1] = (unsigned char) ((nbytes >> 8) & 0xff);
 627   msg.len[2] = (unsigned char) ((nbytes >> 16) & 0xff);
 628   msg.len[3] = (unsigned char) ((nbytes >> 24) & 0xff);
 629
 630   if (_Write(&msg, sizeof(msg)) < sizeof(msg))
 631     goto exit;
 632
 633   total = _Write(buffer, nbytes);
 634
 635   if (total < nbytes)
 636     goto exit;
 637
 638   msg.sig[0] = (unsigned char) 0xed;
 639   msg.sig[1] = (unsigned char) 0xfe;
 640   msg.sig[2] = (unsigned char) 0xad;
 641   msg.sig[3] = (unsigned char) 0xde;
 642   msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
 643
 644   if ((_Write(&msg, sizeof(msg))) < sizeof(msg))
 645     goto exit;
 646
 647   // everything was OK
 648   error = false;
 649
 650 exit:
 651   m_error = error;
 652   m_lcount = total;
 653   m_writing = false;
 654
 655   return *this;
 656 }
 657
 658 wxSocketBase& wxSocketBase::Unread(const void *buffer, wxUint32 nbytes)
 659 {
 660   if (nbytes != 0)
 661     Pushback(buffer, nbytes);
 662
 663   m_error = false;
 664   m_lcount = nbytes;
 665
 666   return *this;
 667 }
 668
 669 wxSocketBase& wxSocketBase::Discard()
 670 {
 671   char *buffer = new char[MAX_DISCARD_SIZE];
 672   wxUint32 ret;
 673   wxUint32 total = 0;
 674
 675   // Mask read events
 676   m_reading = true;
 677
 678   SetFlags(wxSOCKET_NOWAIT);
 679
 680   do
 681   {
 682     ret = _Read(buffer, MAX_DISCARD_SIZE);
 683     total += ret;
 684   }
 685   while (ret == MAX_DISCARD_SIZE);
 686
 687   delete[] buffer;
 688   m_lcount = total;
 689   m_error  = false;
 690
 691   // Allow read events again
 692   m_reading = false;
 693
 694   return *this;
 695 }
 696
 697 // --------------------------------------------------------------------------
 698 // Wait functions
 699 // --------------------------------------------------------------------------
 700
 701 // All Wait functions poll the socket using GSocket_Select() to
 702 // check for the specified combination of conditions, until one
 703 // of these conditions become true, an error occurs, or the
 704 // timeout elapses. The polling loop calls PROCESS_EVENTS(), so
 705 // this won't block the GUI.
 706
 707 bool wxSocketBase::_Wait(long seconds,
 708                          long milliseconds,
 709                          wxSocketEventFlags flags)
 710 {
 711   GSocketEventFlags result;
 712   long timeout;
 713
 714   // Set this to true to interrupt ongoing waits
 715   m_interrupt = false;
 716
 717   // Check for valid socket
 718   if (!m_socket)
 719     return false;
 720
 721   // Check for valid timeout value.
 722   if (seconds != -1)
 723     timeout = seconds * 1000 + milliseconds;
 724   else
 725     timeout = m_timeout * 1000;
 726
 727 #if !defined(wxUSE_GUI) || !wxUSE_GUI
 728   GSocket_SetTimeout(m_socket, timeout);
 729 #endif
 730
 731   // Wait in an active polling loop.
 732   //
 733   // NOTE: We duplicate some of the code in OnRequest, but this doesn't
 734   //   hurt. It has to be here because the (GSocket) event might arrive
 735   //   a bit delayed, and it has to be in OnRequest as well because we
 736   //   don't know whether the Wait functions are being used.
 737   //
 738   // Do this at least once (important if timeout == 0, when
 739   // we are just polling). Also, if just polling, do not yield.
 740
 741   wxStopWatch chrono;
 742   bool done = false;
 743
 744   while (!done)
 745   {
 746     result = GSocket_Select(m_socket, flags | GSOCK_LOST_FLAG);
 747
 748     // Incoming connection (server) or connection established (client)
 749     if (result & GSOCK_CONNECTION_FLAG)
 750     {
 751       m_connected = true;
 752       m_establishing = false;
 753
 754       return true;
 755     }
 756
 757     // Data available or output buffer ready
 758     if ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG))
 759     {
 760       return true;
 761     }
 762
 763     // Connection lost
 764     if (result & GSOCK_LOST_FLAG)
 765     {
 766       m_connected = false;
 767       m_establishing = false;
 768
 769       return (flags & GSOCK_LOST_FLAG) != 0;
 770     }
 771
 772     // Wait more?
 773     if ((!timeout) || (chrono.Time() > timeout) || (m_interrupt))
 774       done = true;
 775     else
 776       PROCESS_EVENTS();
 777   }
 778
 779   return false;
 780 }
 781
 782 bool wxSocketBase::Wait(long seconds, long milliseconds)
 783 {
 784   return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
 785                                       GSOCK_OUTPUT_FLAG |
 786                                       GSOCK_CONNECTION_FLAG |
 787                                       GSOCK_LOST_FLAG);
 788 }
 789
 790 bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
 791 {
 792   // Check pushback buffer before entering _Wait
 793   if (m_unread)
 794     return true;
 795
 796   // Note that GSOCK_INPUT_LOST has to be explicitly passed to
 797   // _Wait becuase of the semantics of WaitForRead: a return
 798   // value of true means that a GSocket_Read call will return
 799   // immediately, not that there is actually data to read.
 800
 801   return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG);
 802 }
 803
 804 bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
 805 {
 806   return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
 807 }
 808
 809 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 810 {
 811   return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG);
 812 }
 813
 814 // --------------------------------------------------------------------------
 815 // Miscellaneous
 816 // --------------------------------------------------------------------------
 817
 818 //
 819 // Get local or peer address
 820 //
 821
 822 bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
 823 {
 824   GAddress *peer;
 825
 826   if (!m_socket)
 827     return false;
 828
 829   peer = GSocket_GetPeer(m_socket);
 830
 831     // copying a null address would just trigger an assert anyway
 832
 833   if (!peer)
 834     return false;
 835
 836   addr_man.SetAddress(peer);
 837   GAddress_destroy(peer);
 838
 839   return true;
 840 }
 841
 842 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
 843 {
 844 #if 0
 845   GAddress *local;
 846
 847   if (!m_socket)
 848     return false;
 849
 850   local = GSocket_GetLocal(m_socket);
 851   addr_man.SetAddress(local);
 852   GAddress_destroy(local);
 853 #endif
 854
 855   return true;
 856 }
 857
 858 //
 859 // Save and restore socket state
 860 //
 861
 862 void wxSocketBase::SaveState()
 863 {
 864   wxSocketState *state;
 865
 866   state = new wxSocketState();
 867
 868   state->m_flags      = m_flags;
 869   state->m_notify     = m_notify;
 870   state->m_eventmask  = m_eventmask;
 871   state->m_clientData = m_clientData;
 872
 873   m_states.Append(state);
 874 }
 875
 876 void wxSocketBase::RestoreState()
 877 {
 878   wxList::compatibility_iterator node;
 879   wxSocketState *state;
 880
 881   node = m_states.GetLast();
 882   if (!node)
 883     return;
 884
 885   state = (wxSocketState *)node->GetData();
 886
 887   m_flags      = state->m_flags;
 888   m_notify     = state->m_notify;
 889   m_eventmask  = state->m_eventmask;
 890   m_clientData = state->m_clientData;
 891
 892   m_states.Erase(node);
 893   delete state;
 894 }
 895
 896 //
 897 // Timeout and flags
 898 //
 899
 900 void wxSocketBase::SetTimeout(long seconds)
 901 {
 902   m_timeout = seconds;
 903
 904 #if 0
 905   if (m_socket)
 906     GSocket_SetTimeout(m_socket, m_timeout * 1000);
 907 #endif
 908 }
 909
 910 void wxSocketBase::SetFlags(wxSocketFlags flags)
 911 {
 912   m_flags = flags;
 913 }
 914
 915
 916 // --------------------------------------------------------------------------
 917 // Event handling
 918 // --------------------------------------------------------------------------
 919
 920 // A note on how events are processed, which is probably the most
 921 // difficult thing to get working right while keeping the same API
 922 // and functionality for all platforms.
 923 //
 924 // When GSocket detects an event, it calls wx_socket_callback, which in
 925 // turn just calls wxSocketBase::OnRequest in the corresponding wxSocket
 926 // object. OnRequest does some housekeeping, and if the event is to be
 927 // propagated to the user, it creates a new wxSocketEvent object and
 928 // posts it. The event is not processed immediately, but delayed with
 929 // AddPendingEvent instead. This is necessary in order to decouple the
 930 // event processing from wx_socket_callback; otherwise, subsequent IO
 931 // calls made from the user event handler would fail, as gtk callbacks
 932 // are not reentrant.
 933 //
 934 // Note that, unlike events, user callbacks (now deprecated) are _not_
 935 // decoupled from wx_socket_callback and thus they suffer from a variety
 936 // of problems. Avoid them where possible and use events instead.
 937
 938 extern "C"
 939 void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
 940                                     GSocketEvent notification,
 941                                     char *cdata)
 942 {
 943   wxSocketBase *sckobj = (wxSocketBase *)cdata;
 944
 945   sckobj->OnRequest((wxSocketNotify) notification);
 946 }
 947
 948 void wxSocketBase::OnRequest(wxSocketNotify notification)
 949 {
 950   // NOTE: We duplicate some of the code in _Wait, but this doesn't
 951   // hurt. It has to be here because the (GSocket) event might arrive
 952   // a bit delayed, and it has to be in _Wait as well because we don't
 953   // know whether the Wait functions are being used.
 954
 955   switch (notification)
 956   {
 957     case wxSOCKET_CONNECTION:
 958       m_establishing = false;
 959       m_connected = true;
 960       break;
 961
 962     // If we are in the middle of a R/W operation, do not
 963     // propagate events to users. Also, filter 'late' events
 964     // which are no longer valid.
 965
 966     case wxSOCKET_INPUT:
 967       if (m_reading || !GSocket_Select(m_socket, GSOCK_INPUT_FLAG))
 968         return;
 969       break;
 970
 971     case wxSOCKET_OUTPUT:
 972       if (m_writing || !GSocket_Select(m_socket, GSOCK_OUTPUT_FLAG))
 973         return;
 974       break;
 975
 976     case wxSOCKET_LOST:
 977       m_connected = false;
 978       m_establishing = false;
 979       break;
 980
 981     default:
 982       break;
 983   }
 984
 985   // Schedule the event
 986
 987   wxSocketEventFlags flag = 0;
 988   wxUnusedVar(flag);
 989   switch (notification)
 990   {
 991     case GSOCK_INPUT:
 992       flag = GSOCK_INPUT_FLAG;
 993       break;
 994
 995     case GSOCK_OUTPUT:
 996       flag = GSOCK_OUTPUT_FLAG;
 997       break;
 998
 999     case GSOCK_CONNECTION:
1000       flag = GSOCK_CONNECTION_FLAG;
1001       break;
1002
1003     case GSOCK_LOST:
1004       flag = GSOCK_LOST_FLAG;
1005       break;
1006
1007     default:
1008       wxLogWarning( wxT("wxSocket: unknown event!") );
1009       return;
1010   }
1011
1012   if (((m_eventmask & flag) == flag) && m_notify)
1013   {
1014     if (m_handler)
1015     {
1016       wxSocketEvent event(m_id);
1017       event.m_event      = notification;
1018       event.m_clientData = m_clientData;
1019       event.SetEventObject(this);
1020
1021       m_handler->AddPendingEvent(event);
1022     }
1023   }
1024 }
1025
1026 void wxSocketBase::Notify(bool notify)
1027 {
1028   m_notify = notify;
1029 }
1030
1031 void wxSocketBase::SetNotify(wxSocketEventFlags flags)
1032 {
1033   m_eventmask = flags;
1034 }
1035
1036 void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id)
1037 {
1038   m_handler = &handler;
1039   m_id      = id;
1040 }
1041
1042 // --------------------------------------------------------------------------
1043 // Pushback buffer
1044 // --------------------------------------------------------------------------
1045
1046 void wxSocketBase::Pushback(const void *buffer, wxUint32 size)
1047 {
1048   if (!size)
1049     return;
1050
1051   if (m_unread == NULL)
1052     m_unread = malloc(size);
1053   else
1054   {
1055     void *tmp;
1056
1057     tmp = malloc(m_unrd_size + size);
1058     memcpy((char *)tmp + size, m_unread, m_unrd_size);
1059     free(m_unread);
1060
1061     m_unread = tmp;
1062   }
1063
1064   m_unrd_size += size;
1065
1066   memcpy(m_unread, buffer, size);
1067 }
1068
1069 wxUint32 wxSocketBase::GetPushback(void *buffer, wxUint32 size, bool peek)
1070 {
1071   if (!m_unrd_size)
1072     return 0;
1073
1074   if (size > (m_unrd_size-m_unrd_cur))
1075     size = m_unrd_size-m_unrd_cur;
1076
1077   memcpy(buffer, (char *)m_unread + m_unrd_cur, size);
1078
1079   if (!peek)
1080   {
1081     m_unrd_cur += size;
1082     if (m_unrd_size == m_unrd_cur)
1083     {
1084       free(m_unread);
1085       m_unread = NULL;
1086       m_unrd_size = 0;
1087       m_unrd_cur  = 0;
1088     }
1089   }
1090
1091   return size;
1092 }
1093
1094
1095 // ==========================================================================
1096 // wxSocketServer
1097 // ==========================================================================
1098
1099 // --------------------------------------------------------------------------
1100 // Ctor
1101 // --------------------------------------------------------------------------
1102
1103 wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
1104                                wxSocketFlags flags)
1105               : wxSocketBase(flags, wxSOCKET_SERVER)
1106 {
1107     wxLogTrace( wxTRACE_Socket, wxT("Opening wxSocketServer") );
1108
1109     m_socket = GSocket_new();
1110
1111     if (!m_socket)
1112     {
1113         wxLogTrace( wxTRACE_Socket, wxT("*** GSocket_new failed") );
1114         return;
1115     }
1116
1117     // Setup the socket as server
1118
1119 #if 0
1120     GSocket_SetLocal(m_socket, addr_man.GetAddress());
1121     if (GSocket_SetServer(m_socket) != GSOCK_NOERROR)
1122     {
1123         GSocket_destroy(m_socket);
1124         m_socket = NULL;
1125
1126         wxLogTrace( wxTRACE_Socket, wxT("*** GSocket_SetServer failed") );
1127         return;
1128     }
1129
1130     GSocket_SetTimeout(m_socket, m_timeout * 1000);
1131     GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1132                                   GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1133                                   wx_socket_callback, (char *)this);
1134 #endif
1135 }
1136
1137 // --------------------------------------------------------------------------
1138 // Accept
1139 // --------------------------------------------------------------------------
1140
1141 bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait)
1142 {
1143   GSocket *child_socket;
1144
1145   if (!m_socket)
1146     return false;
1147
1148   // If wait == false, then the call should be nonblocking.
1149   // When we are finished, we put the socket to blocking mode
1150   // again.
1151
1152 #if 0
1153   if (!wait)
1154     GSocket_SetNonBlocking(m_socket, 1);
1155
1156   child_socket = GSocket_WaitConnection(m_socket);
1157
1158   if (!wait)
1159     GSocket_SetNonBlocking(m_socket, 0);
1160
1161   if (!child_socket)
1162     return false;
1163
1164   sock.m_type = wxSOCKET_BASE;
1165   sock.m_socket = child_socket;
1166   sock.m_connected = true;
1167
1168   GSocket_SetTimeout(sock.m_socket, sock.m_timeout * 1000);
1169   GSocket_SetCallback(sock.m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1170                                      GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1171                                      wx_socket_callback, (char *)&sock);
1172 #endif
1173
1174   return true;
1175 }
1176
1177 wxSocketBase *wxSocketServer::Accept(bool wait)
1178 {
1179   wxSocketBase* sock = new wxSocketBase();
1180
1181   sock->SetFlags(m_flags);
1182
1183   if (!AcceptWith(*sock, wait))
1184   {
1185     sock->Destroy();
1186     sock = NULL;
1187   }
1188
1189   return sock;
1190 }
1191
1192 bool wxSocketServer::WaitForAccept(long seconds, long milliseconds)
1193 {
1194   return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
1195 }
1196
1197 // ==========================================================================
1198 // wxSocketClient
1199 // ==========================================================================
1200
1201 // --------------------------------------------------------------------------
1202 // Ctor and dtor
1203 // --------------------------------------------------------------------------
1204
1205 wxSocketClient::wxSocketClient(wxSocketFlags flags)
1206               : wxSocketBase(flags, wxSOCKET_CLIENT)
1207 {
1208 }
1209
1210 wxSocketClient::~wxSocketClient()
1211 {
1212 }
1213
1214 // --------------------------------------------------------------------------
1215 // Connect
1216 // --------------------------------------------------------------------------
1217
1218 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
1219 {
1220   GSocketError err;
1221
1222   if (m_socket)
1223   {
1224     // Shutdown and destroy the socket
1225     Close();
1226     GSocket_destroy(m_socket);
1227   }
1228
1229   m_socket = GSocket_new();
1230   m_connected = false;
1231   m_establishing = false;
1232
1233   if (!m_socket)
1234     return false;
1235
1236   GSocket_SetTimeout(m_socket, m_timeout * 1000);
1237   GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1238                                 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1239                                 wx_socket_callback, (char *)this);
1240
1241   // If wait == false, then the call should be nonblocking.
1242   // When we are finished, we put the socket to blocking mode
1243   // again.
1244
1245   if (!wait)
1246     GSocket_SetNonBlocking(m_socket, 1);
1247
1248   GSocket_SetPeer(m_socket, addr_man.GetAddress());
1249   err = GSocket_Connect(m_socket, GSOCK_STREAMED);
1250
1251   if (!wait)
1252     GSocket_SetNonBlocking(m_socket, 0);
1253
1254   if (err != GSOCK_NOERROR)
1255   {
1256     if (err == GSOCK_WOULDBLOCK)
1257       m_establishing = true;
1258
1259     return false;
1260   }
1261
1262   m_connected = true;
1263   return true;
1264 }
1265
1266 bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
1267 {
1268   if (m_connected)                      // Already connected
1269     return true;
1270
1271   if (!m_establishing || !m_socket)     // No connection in progress
1272     return false;
1273
1274   return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG | GSOCK_LOST_FLAG);
1275 }
1276
1277 // ==========================================================================
1278 // wxDatagramSocket
1279 // ==========================================================================
1280
1281 /* NOTE: experimental stuff - might change */
1282
1283 wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr,
1284                                     wxSocketFlags flags )
1285                 : wxSocketBase( flags, wxSOCKET_DATAGRAM )
1286 {
1287 #if 0
1288   // Create the socket
1289   m_socket = GSocket_new();
1290
1291   if (!m_socket)
1292     return;
1293
1294   // Setup the socket as non connection oriented
1295   GSocket_SetLocal(m_socket, addr.GetAddress());
1296   if( GSocket_SetNonOriented(m_socket) != GSOCK_NOERROR )
1297   {
1298     GSocket_destroy(m_socket);
1299     m_socket = NULL;
1300     return;
1301   }
1302
1303   // Initialize all stuff
1304   m_connected = false;
1305   m_establishing = false;
1306   GSocket_SetTimeout( m_socket, m_timeout );
1307   GSocket_SetCallback( m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
1308                                  GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
1309                                  wx_socket_callback, (char*)this );
1310 #endif
1311 }
1312
1313 wxDatagramSocket& wxDatagramSocket::RecvFrom( wxSockAddress& addr,
1314                                               void* buf,
1315                                               wxUint32 nBytes )
1316 {
1317     Read(buf, nBytes);
1318     GetPeer(addr);
1319     return (*this);
1320 }
1321
1322 wxDatagramSocket& wxDatagramSocket::SendTo( wxSockAddress& addr,
1323                                             const void* buf,
1324                                             wxUint32 nBytes )
1325 {
1326     GSocket_SetPeer(m_socket, addr.GetAddress());
1327     Write(buf, nBytes);
1328     return (*this);
1329 }
1330
1331 /*
1332  * -------------------------------------------------------------------------
1333  * GAddress
1334  * -------------------------------------------------------------------------
1335  */
1336
1337 /* CHECK_ADDRESS verifies that the current address family is either
1338  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1339  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1340  * an appropiate error code.
1341  *
1342  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1343  */
1344 #define CHECK_ADDRESS(address, family)                              \
1345 {                                                                   \
1346   if (address->m_family == GSOCK_NOFAMILY)                          \
1347     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1348       return address->m_error;                                      \
1349   if (address->m_family != GSOCK_##family)                          \
1350   {                                                                 \
1351     address->m_error = GSOCK_INVADDR;                               \
1352     return GSOCK_INVADDR;                                           \
1353   }                                                                 \
1354 }
1355
1356 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1357 {                                                                   \
1358   if (address->m_family == GSOCK_NOFAMILY)                          \
1359     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1360       return retval;                                                \
1361   if (address->m_family != GSOCK_##family)                          \
1362   {                                                                 \
1363     address->m_error = GSOCK_INVADDR;                               \
1364     return retval;                                                  \
1365   }                                                                 \
1366 }
1367
1368
1369 GAddress *GAddress_new(void)
1370 {
1371   GAddress *address;
1372
1373   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1374     return NULL;
1375
1376   address->m_family  = GSOCK_NOFAMILY;
1377   address->m_addr    = NULL;
1378   address->m_len     = 0;
1379
1380   return address;
1381 }
1382
1383 GAddress *GAddress_copy(GAddress *address)
1384 {
1385   GAddress *addr2;
1386
1387   assert(address != NULL);
1388
1389   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1390     return NULL;
1391
1392   memcpy(addr2, address, sizeof(GAddress));
1393
1394   if (address->m_addr && address->m_len > 0)
1395   {
1396     addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1397     if (addr2->m_addr == NULL)
1398     {
1399       free(addr2);
1400       return NULL;
1401     }
1402
1403     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1404   }
1405
1406   return addr2;
1407 }
1408
1409 void GAddress_destroy(GAddress *address)
1410 {
1411   assert( address != NULL );
1412
1413   if (address->m_addr)
1414     free(address->m_addr);
1415
1416   free(address);
1417 }
1418
1419 void GAddress_SetFamily(GAddress *address, GAddressType type)
1420 {
1421   assert(address != NULL);
1422
1423   address->m_family = type;
1424 }
1425
1426 GAddressType GAddress_GetFamily(GAddress *address)
1427 {
1428   assert( address != NULL );
1429
1430   return address->m_family;
1431 }
1432
1433 GSocketError _GAddress_translate_from(GAddress *address,
1434                                       struct sockaddr *addr, int len)
1435 {
1436   address->m_realfamily = addr->sa_family;
1437   switch (addr->sa_family)
1438   {
1439     case AF_INET:
1440       address->m_family = GSOCK_INET;
1441       break;
1442
1443     case AF_UNIX:
1444       address->m_family = GSOCK_UNIX;
1445       break;
1446
1447 #ifdef AF_INET6
1448     case AF_INET6:
1449       address->m_family = GSOCK_INET6;
1450       break;
1451 #endif
1452
1453     default:
1454     {
1455       address->m_error = GSOCK_INVOP;
1456       return GSOCK_INVOP;
1457     }
1458   }
1459
1460   if (address->m_addr)
1461     free(address->m_addr);
1462
1463   address->m_len  = len;
1464   address->m_addr = (struct sockaddr *)malloc(len);
1465
1466   if (address->m_addr == NULL)
1467   {
1468     address->m_error = GSOCK_MEMERR;
1469     return GSOCK_MEMERR;
1470   }
1471
1472   memcpy(address->m_addr, addr, len);
1473
1474   return GSOCK_NOERROR;
1475 }
1476
1477 GSocketError _GAddress_translate_to(GAddress *address,
1478                                     struct sockaddr **addr, int *len)
1479 {
1480   if (!address->m_addr)
1481   {
1482     address->m_error = GSOCK_INVADDR;
1483     return GSOCK_INVADDR;
1484   }
1485
1486   *len = address->m_len;
1487   *addr = (struct sockaddr *)malloc(address->m_len);
1488   if (*addr == NULL)
1489   {
1490     address->m_error = GSOCK_MEMERR;
1491     return GSOCK_MEMERR;
1492   }
1493
1494   memcpy(*addr, address->m_addr, address->m_len);
1495   return GSOCK_NOERROR;
1496 }
1497
1498 /*
1499  * -------------------------------------------------------------------------
1500  * Internet address family
1501  * -------------------------------------------------------------------------
1502  */
1503
1504 GSocketError _GAddress_Init_INET(GAddress *address)
1505 {
1506   address->m_len  = sizeof(struct sockaddr_in);
1507   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1508   if (address->m_addr == NULL)
1509   {
1510     address->m_error = GSOCK_MEMERR;
1511     return GSOCK_MEMERR;
1512   }
1513
1514   memset( address->m_addr , 0 , address->m_len ) ;
1515   address->m_family = GSOCK_INET;
1516   address->m_realfamily = PF_INET;
1517   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1518   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1519
1520   return GSOCK_NOERROR;
1521 }
1522
1523 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1524 {
1525   struct hostent *he;
1526   struct in_addr *addr;
1527
1528   assert( address != NULL );
1529   CHECK_ADDRESS( address, INET );
1530
1531   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1532
1533   // If it is a numeric host name, convert it now
1534 #if defined(HAVE_INET_ATON)
1535   if (inet_aton(hostname, addr) == 0)
1536   {
1537 #elif defined(HAVE_INET_ADDR)
1538   if ( (addr->s_addr = inet_addr(hostname)) == -1 )
1539   {
1540 #else
1541   // Use gethostbyname by default
1542 #ifndef __WXMAC__
1543   int val = 1;  // VA doesn't like constants in conditional expressions
1544   if (val)
1545 #endif
1546   {
1547 #endif
1548     struct in_addr *array_addr;
1549
1550     // It is a real name, we solve it
1551     if ((he = gethostbyname(hostname)) == NULL)
1552     {
1553       // Reset to invalid address
1554       addr->s_addr = INADDR_NONE;
1555       address->m_error = GSOCK_NOHOST;
1556       return GSOCK_NOHOST;
1557     }
1558     array_addr = (struct in_addr *) *(he->h_addr_list);
1559     addr->s_addr = array_addr[0].s_addr;
1560   }
1561
1562   return GSOCK_NOERROR;
1563 }
1564
1565 GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
1566 {
1567   return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
1568 }
1569
1570 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1571 {
1572   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1573 }
1574
1575 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1576                                           unsigned long hostaddr)
1577 {
1578   struct in_addr *addr;
1579
1580   assert( address != NULL );
1581   CHECK_ADDRESS( address, INET );
1582
1583   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1584   addr->s_addr = htonl(hostaddr) ;
1585
1586   return GSOCK_NOERROR;
1587 }
1588
1589 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1590                                        const char *protocol)
1591 {
1592   struct servent *se;
1593   struct sockaddr_in *addr;
1594
1595   assert( address != NULL );
1596   CHECK_ADDRESS( address, INET );
1597
1598   if (!port)
1599   {
1600     address->m_error = GSOCK_INVPORT;
1601     return GSOCK_INVPORT;
1602   }
1603
1604   se = getservbyname(port, protocol);
1605   if (!se)
1606   {
1607     // the cast to int suppresses compiler warnings
1608     // about subscript having the type char
1609     if (isdigit((int)port[0]))
1610     {
1611       int port_int;
1612
1613       port_int = atoi(port);
1614       addr = (struct sockaddr_in *)address->m_addr;
1615       addr->sin_port = htons(port_int);
1616       return GSOCK_NOERROR;
1617     }
1618
1619     address->m_error = GSOCK_INVPORT;
1620     return GSOCK_INVPORT;
1621   }
1622
1623   addr = (struct sockaddr_in *)address->m_addr;
1624   addr->sin_port = se->s_port;
1625
1626   return GSOCK_NOERROR;
1627 }
1628
1629 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1630 {
1631   struct sockaddr_in *addr;
1632
1633   assert( address != NULL );
1634   CHECK_ADDRESS( address, INET );
1635
1636   addr = (struct sockaddr_in *)address->m_addr;
1637   addr->sin_port = htons(port);
1638
1639   return GSOCK_NOERROR;
1640 }
1641
1642 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1643 {
1644   struct hostent *he;
1645   char *addr_buf;
1646   struct sockaddr_in *addr;
1647
1648   assert( address != NULL );
1649   CHECK_ADDRESS( address, INET );
1650
1651   addr = (struct sockaddr_in *)address->m_addr;
1652   addr_buf = (char *)&(addr->sin_addr);
1653
1654   he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1655   if (he == NULL)
1656   {
1657     address->m_error = GSOCK_NOHOST;
1658     return GSOCK_NOHOST;
1659   }
1660
1661   strncpy(hostname, he->h_name, sbuf);
1662
1663   return GSOCK_NOERROR;
1664 }
1665
1666 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1667 {
1668   struct sockaddr_in *addr;
1669
1670   assert( address != NULL );
1671   CHECK_ADDRESS_RETVAL( address, INET, 0 );
1672
1673   addr = (struct sockaddr_in *)address->m_addr;
1674
1675   return ntohl(addr->sin_addr.s_addr) ;
1676 }
1677
1678 unsigned short GAddress_INET_GetPort(GAddress *address)
1679 {
1680   struct sockaddr_in *addr;
1681
1682   assert( address != NULL );
1683   CHECK_ADDRESS_RETVAL( address, INET, 0 );
1684
1685   addr = (struct sockaddr_in *)address->m_addr;
1686
1687   return ntohs(addr->sin_port);
1688 }
1689
1690 /*
1691  * -------------------------------------------------------------------------
1692  * Unix address family
1693  * -------------------------------------------------------------------------
1694  */
1695
1696 GSocketError _GAddress_Init_UNIX(GAddress *address)
1697 {
1698   address->m_len  = sizeof(struct sockaddr_un);
1699   address->m_addr = (struct sockaddr *)malloc(address->m_len);
1700   if (address->m_addr == NULL)
1701   {
1702     address->m_error = GSOCK_MEMERR;
1703     return GSOCK_MEMERR;
1704   }
1705
1706   address->m_family = GSOCK_UNIX;
1707   address->m_realfamily = PF_UNIX;
1708   ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
1709   ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
1710
1711   return GSOCK_NOERROR;
1712 }
1713
1714 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
1715
1716 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1717 {
1718   struct sockaddr_un *addr;
1719
1720   assert( address != NULL );
1721   CHECK_ADDRESS( address, UNIX );
1722
1723   addr = ((struct sockaddr_un *)address->m_addr);
1724   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
1725   addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
1726
1727   return GSOCK_NOERROR;
1728 }
1729
1730 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1731 {
1732   struct sockaddr_un *addr;
1733
1734   assert( address != NULL );
1735   CHECK_ADDRESS( address, UNIX );
1736
1737   addr = (struct sockaddr_un *)address->m_addr;
1738
1739   strncpy(path, addr->sun_path, sbuf);
1740
1741   return GSOCK_NOERROR;
1742 }
1743
1744 /* Address handling */
1745
1746 /* GSocket_SetLocal:
1747  * GSocket_GetLocal:
1748  * GSocket_SetPeer:
1749  * GSocket_GetPeer:
1750  *  Set or get the local or peer address for this socket. The 'set'
1751  *  functions return GSOCK_NOERROR on success, an error code otherwise.
1752  *  The 'get' functions return a pointer to a GAddress object on success,
1753  *  or NULL otherwise, in which case they set the error code of the
1754  *  corresponding GSocket.
1755  *
1756  *  Error codes:
1757  *    GSOCK_INVSOCK - the socket is not valid.
1758  *    GSOCK_INVADDR - the address is not valid.
1759  */
1760
1761 GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address)
1762 {
1763   assert( socket != NULL );
1764
1765   // the socket must be initialized, or it must be a server
1766   if ((socket->m_fd != INVALID_SOCKET && !socket->m_server))
1767   {
1768     socket->m_error = GSOCK_INVSOCK;
1769     return GSOCK_INVSOCK;
1770   }
1771
1772   // check address
1773   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
1774   {
1775     socket->m_error = GSOCK_INVADDR;
1776     return GSOCK_INVADDR;
1777   }
1778
1779   if (socket->m_local)
1780     GAddress_destroy(socket->m_local);
1781
1782   socket->m_local = GAddress_copy(address);
1783
1784   return GSOCK_NOERROR;
1785 }
1786
1787 GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address)
1788 {
1789   assert(socket != NULL);
1790
1791   // check address
1792   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
1793   {
1794     socket->m_error = GSOCK_INVADDR;
1795     return GSOCK_INVADDR;
1796   }
1797
1798   if (socket->m_peer)
1799     GAddress_destroy(socket->m_peer);
1800
1801   socket->m_peer = GAddress_copy(address);
1802
1803   return GSOCK_NOERROR;
1804 }
1805
1806 GAddress *GSocket_GetLocal(GSocket *socket)
1807 {
1808   GAddress *address;
1809   struct sockaddr addr;
1810   socklen_t size = sizeof(addr);
1811   GSocketError err;
1812
1813   assert( socket != NULL );
1814
1815   // try to get it from the m_local var first
1816   if (socket->m_local)
1817     return GAddress_copy(socket->m_local);
1818
1819   // else, if the socket is initialized, try getsockname
1820   if (socket->m_fd == INVALID_SOCKET)
1821   {
1822     socket->m_error = GSOCK_INVSOCK;
1823     return NULL;
1824   }
1825
1826   if (getsockname(socket->m_fd, &addr, (socklen_t *) &size) < 0)
1827   {
1828     socket->m_error = GSOCK_IOERR;
1829     return NULL;
1830   }
1831
1832   // got a valid address from getsockname, create a GAddress object
1833   address = GAddress_new();
1834   if (address == NULL)
1835   {
1836     socket->m_error = GSOCK_MEMERR;
1837     return NULL;
1838   }
1839
1840   err = _GAddress_translate_from(address, &addr, size);
1841   if (err != GSOCK_NOERROR)
1842   {
1843     GAddress_destroy(address);
1844     socket->m_error = err;
1845     return NULL;
1846   }
1847
1848   return address;
1849 }
1850
1851 GAddress *GSocket_GetPeer(GSocket *socket)
1852 {
1853   assert(socket != NULL);
1854
1855   // try to get it from the m_peer var
1856   if (socket->m_peer)
1857     return GAddress_copy(socket->m_peer);
1858
1859   return NULL;
1860 }
1861
1862
1863 GSocket *GSocket_new(void)
1864 {
1865   GSocket *socket;
1866   socket = (GSocket *)malloc(sizeof(GSocket));
1867
1868   if (socket == NULL)
1869     return NULL;
1870
1871   socket->m_fd                  = INVALID_SOCKET;
1872
1873   for (int i=0;i<GSOCK_MAX_EVENT;i++)
1874   {
1875     socket->m_cbacks[i] = NULL;
1876   }
1877
1878   socket->m_detected            = 0;
1879
1880   socket->m_local               = NULL;
1881   socket->m_peer                = NULL;
1882   socket->m_error               = GSOCK_NOERROR;
1883
1884   socket->m_non_blocking        = false ;
1885   socket->m_stream              = true;
1886 //  socket->m_oriented            = true;
1887   socket->m_server              = false;
1888   socket->m_establishing        = false;
1889   socket->m_timeout             = 10 * 60 * 1000;
1890                                 // 10 minutes * 60 sec * 1000 millisec
1891
1892   socket->m_cfSocket            = NULL ;
1893   socket->m_runLoopSource       = NULL ;
1894   socket->m_readStream          = NULL;
1895   socket->m_writeStream         = NULL;
1896
1897   return socket ;
1898 }
1899
1900 void GSocket_close(GSocket *socket)
1901 {
1902     if ( socket->m_cfSocket != NULL )
1903     {
1904         if ( socket->m_readStream )
1905         {
1906             CFReadStreamClose(socket->m_readStream);
1907             CFRelease( socket->m_readStream ) ;
1908             socket->m_readStream = NULL ;
1909         }
1910
1911         if ( socket->m_writeStream )
1912         {
1913             CFWriteStreamClose(socket->m_writeStream);
1914             CFRelease( socket->m_writeStream ) ;
1915             socket->m_writeStream = NULL ;
1916         }
1917
1918         CFSocketInvalidate( socket->m_cfSocket ) ;
1919         CFRelease( socket->m_cfSocket ) ;
1920         socket->m_cfSocket = NULL ;
1921         socket->m_fd = INVALID_SOCKET ;
1922     }
1923 }
1924
1925 void GSocket_Shutdown(GSocket *socket)
1926 {
1927     GSocket_close( socket );
1928
1929     // Disable GUI callbacks
1930     for (int evt = 0; evt < GSOCK_MAX_EVENT; evt++)
1931         socket->m_cbacks[evt] = NULL;
1932
1933     socket->m_detected = GSOCK_LOST_FLAG;
1934 }
1935
1936 void GSocket_destroy(GSocket *socket)
1937 {
1938   assert( socket != NULL );
1939
1940   // Check that the socket is really shut down
1941   if (socket->m_fd != INVALID_SOCKET)
1942     GSocket_Shutdown(socket);
1943
1944   // Destroy private addresses
1945   if (socket->m_local)
1946     GAddress_destroy(socket->m_local);
1947
1948   if (socket->m_peer)
1949     GAddress_destroy(socket->m_peer);
1950
1951   // Destroy the socket itself
1952   free(socket);
1953 }
1954
1955 GSocketError GSocket_Connect(GSocket *socket, GSocketStream stream)
1956 {
1957   assert( socket != NULL );
1958
1959   if (socket->m_fd != INVALID_SOCKET)
1960   {
1961     socket->m_error = GSOCK_INVSOCK;
1962     return GSOCK_INVSOCK;
1963   }
1964
1965   if (!socket->m_peer)
1966   {
1967     socket->m_error = GSOCK_INVADDR;
1968     return GSOCK_INVADDR;
1969   }
1970
1971   // Streamed or dgram socket?
1972   socket->m_stream   = (stream == GSOCK_STREAMED);
1973   socket->m_oriented = true;
1974   socket->m_server = false;
1975   socket->m_establishing = false;
1976
1977   GSocketError returnErr = GSOCK_NOERROR ;
1978   CFSocketError err ;
1979
1980   CFAllocatorRef alloc = kCFAllocatorDefault ;
1981   CFSocketContext ctx ;
1982   memset( &ctx , 0 , sizeof( ctx ) ) ;
1983   ctx.info = socket ;
1984   socket->m_cfSocket = CFSocketCreate( alloc , socket->m_peer->m_realfamily ,
1985      stream == GSOCK_STREAMED ? SOCK_STREAM : SOCK_DGRAM , 0 ,
1986       kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack , wxMacCFSocketCallback , &ctx  ) ;
1987   _GSocket_Enable(socket, GSOCK_CONNECTION);
1988
1989   socket->m_fd = CFSocketGetNative( socket->m_cfSocket ) ;
1990
1991   CFStreamCreatePairWithSocket ( alloc , socket->m_fd , &socket->m_readStream , &socket->m_writeStream  );
1992   if ((socket->m_readStream == NULL) || (socket->m_writeStream == NULL))
1993   {
1994     GSocket_close(socket);
1995     socket->m_error = GSOCK_IOERR;
1996     return GSOCK_IOERR;
1997   }
1998
1999   if ( !CFReadStreamOpen( socket->m_readStream ) || !CFWriteStreamOpen( socket->m_writeStream ) )
2000   {
2001     GSocket_close(socket);
2002     socket->m_error = GSOCK_IOERR;
2003     return GSOCK_IOERR;
2004   }
2005
2006   CFRunLoopSourceRef rls = CFSocketCreateRunLoopSource(alloc , socket->m_cfSocket , 0);
2007   CFRunLoopAddSource(CFRunLoopGetCurrent() , rls, kCFRunLoopCommonModes);
2008   CFRelease(rls);
2009
2010   CFDataRef address = CFDataCreateWithBytesNoCopy(alloc, (const UInt8*) socket->m_peer->m_addr, socket->m_peer->m_len , kCFAllocatorNull);
2011   if ( !address )
2012     return GSOCK_MEMERR ;
2013
2014   err = CFSocketConnectToAddress( socket->m_cfSocket , address, socket->m_non_blocking ? -1 : socket->m_timeout / 1000  ) ;
2015   CFRelease(address);
2016
2017   if (err != kCFSocketSuccess)
2018   {
2019     if ( err == kCFSocketTimeout )
2020     {
2021       GSocket_close(socket);
2022       socket->m_error = GSOCK_TIMEDOUT ;
2023       return GSOCK_TIMEDOUT ;
2024     }
2025
2026     // we don't know whether a connect in progress will be issued like this
2027     if ( err != kCFSocketTimeout && socket->m_non_blocking )
2028     {
2029       socket->m_establishing = true;
2030       socket->m_error = GSOCK_WOULDBLOCK;
2031       return GSOCK_WOULDBLOCK;
2032     }
2033
2034     GSocket_close(socket);
2035     socket->m_error = GSOCK_IOERR;
2036     return GSOCK_IOERR;
2037   }
2038
2039   return GSOCK_NOERROR;
2040 }
2041
2042 /* Flags */
2043
2044 /* GSocket_SetNonBlocking:
2045  *  Sets the socket to non-blocking mode.
2046  *  All IO calls will return immediately.
2047  */
2048 void GSocket_SetNonBlocking(GSocket *socket, int non_block)
2049 {
2050   assert( socket != NULL );
2051
2052 //  GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
2053
2054   socket->m_non_blocking = non_block;
2055 }
2056
2057 /*
2058  *  GSocket_SetTimeout:
2059  *  Sets the timeout for blocking calls. Time is expressed in
2060  *  milliseconds.
2061  */
2062 void GSocket_SetTimeout(GSocket *socket, unsigned long millisec)
2063 {
2064   assert( socket != NULL );
2065
2066   socket->m_timeout = millisec;
2067 }
2068
2069 /* GSocket_GetError:
2070  *  Returns the last error which occurred for this socket. Note that successful
2071  *  operations do not clear this back to GSOCK_NOERROR, so use it only
2072  *  after an error.
2073  */
2074 GSocketError GSocket_GetError(GSocket *socket)
2075 {
2076   assert( socket != NULL );
2077
2078   return socket->m_error;
2079 }
2080
2081 /* Callbacks */
2082
2083 /* GSOCK_INPUT:
2084  *   There is data to be read in the input buffer. If, after a read
2085  *   operation, there is still data available, the callback function will
2086  *   be called again.
2087  * GSOCK_OUTPUT:
2088  *   The socket is available for writing. That is, the next write call
2089  *   won't block. This event is generated only once, when the connection is
2090  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
2091  *   when the output buffer empties again. This means that the app should
2092  *   assume that it can write since the first OUTPUT event, and no more
2093  *   OUTPUT events will be generated unless an error occurs.
2094  * GSOCK_CONNECTION:
2095  *   Connection successfully established, for client sockets, or incoming
2096  *   client connection, for server sockets. Wait for this event (also watch
2097  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
2098  * GSOCK_LOST:
2099  *   The connection is lost (or a connection request failed); this could
2100  *   be due to a failure, or due to the peer closing it gracefully.
2101  */
2102
2103 /* GSocket_SetCallback:
2104  *  Enables the callbacks specified by 'flags'. Note that 'flags'
2105  *  may be a combination of flags OR'ed toghether, so the same
2106  *  callback function can be made to accept different events.
2107  *  The callback function must have the following prototype:
2108  *
2109  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
2110  */
2111 void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags,
2112                          GSocketCallback callback, char *cdata)
2113 {
2114   int count;
2115
2116   assert( socket != NULL );
2117
2118   for (count = 0; count < GSOCK_MAX_EVENT; count++)
2119   {
2120     if ((flags & (1 << count)) != 0)
2121     {
2122       socket->m_cbacks[count] = callback;
2123       socket->m_data[count] = cdata;
2124     }
2125   }
2126 }
2127
2128 /* GSocket_UnsetCallback:
2129  *  Disables all callbacks specified by 'flags', which may be a
2130  *  combination of flags OR'ed toghether.
2131  */
2132 void GSocket_UnsetCallback(GSocket *socket, GSocketEventFlags flags)
2133 {
2134   int count;
2135
2136   assert(socket != NULL);
2137
2138   for (count = 0; count < GSOCK_MAX_EVENT; count++)
2139   {
2140     if ((flags & (1 << count)) != 0)
2141     {
2142       socket->m_cbacks[count] = NULL;
2143       socket->m_data[count] = NULL;
2144     }
2145   }
2146 }
2147
2148
2149 #define CALL_CALLBACK(socket, event) {                                  \
2150   _GSocket_Disable(socket, event);                                      \
2151   if (socket->m_cbacks[event])                                          \
2152     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
2153 }
2154
2155 void _GSocket_Install_Callback(GSocket *socket, GSocketEvent event)
2156 {
2157     int c;
2158     switch (event)
2159     {
2160      case GSOCK_CONNECTION:
2161          if (socket->m_server)
2162             c = kCFSocketReadCallBack;
2163          else
2164             c = kCFSocketConnectCallBack;
2165          break;
2166
2167      case GSOCK_LOST:
2168      case GSOCK_INPUT:
2169          c = kCFSocketReadCallBack;
2170          break;
2171
2172      case GSOCK_OUTPUT:
2173          c = kCFSocketWriteCallBack;
2174          break;
2175
2176      default:
2177          c = 0;
2178     }
2179
2180     CFSocketEnableCallBacks(socket->m_cfSocket, c);
2181 }
2182
2183 void _GSocket_Uninstall_Callback(GSocket *socket, GSocketEvent event)
2184 {
2185     int c;
2186     switch (event)
2187     {
2188      case GSOCK_CONNECTION:
2189          if (socket->m_server)
2190             c = kCFSocketReadCallBack;
2191          else
2192             c = kCFSocketConnectCallBack;
2193          break;
2194
2195      case GSOCK_LOST:
2196      case GSOCK_INPUT:
2197          c = kCFSocketReadCallBack;
2198          break;
2199
2200      case GSOCK_OUTPUT:
2201          c = kCFSocketWriteCallBack;
2202          break;
2203
2204      default:
2205          c = 0;
2206          break;
2207     }
2208
2209     CFSocketDisableCallBacks(socket->m_cfSocket, c);
2210 }
2211
2212 void _GSocket_Enable(GSocket *socket, GSocketEvent event)
2213 {
2214   socket->m_detected &= ~(1 << event);
2215   _GSocket_Install_Callback(socket, event);
2216 }
2217
2218 void _GSocket_Disable(GSocket *socket, GSocketEvent event)
2219 {
2220   socket->m_detected |= (1 << event);
2221   _GSocket_Uninstall_Callback(socket, event);
2222 }
2223
2224 void wxMacCFSocketCallback(CFSocketRef s, CFSocketCallBackType callbackType,
2225                          CFDataRef address, const void* data, void* info)
2226 {
2227   GSocket* socket = (GSocket*)info;
2228
2229   switch (callbackType)
2230   {
2231     case kCFSocketConnectCallBack:
2232       if ( data )
2233       {
2234         SInt32 error = *((SInt32*)data) ;
2235         CALL_CALLBACK( socket , GSOCK_LOST ) ;
2236         GSocket_Shutdown(socket);
2237       }
2238       else
2239       {
2240         CALL_CALLBACK( socket , GSOCK_CONNECTION ) ;
2241       }
2242       break;
2243
2244     case kCFSocketReadCallBack:
2245       CALL_CALLBACK( socket , GSOCK_INPUT ) ;
2246       break;
2247
2248     case kCFSocketWriteCallBack:
2249       CALL_CALLBACK( socket , GSOCK_OUTPUT ) ;
2250       break;
2251
2252     default:
2253       break;  // We shouldn't get here.
2254   }
2255 }
2256
2257 int GSocket_Read(GSocket *socket, char *buffer, int size)
2258 {
2259   int ret = 0 ;
2260
2261   assert(socket != NULL);
2262   // if ( !CFReadStreamHasBytesAvailable() )
2263   ret = CFReadStreamRead( socket->m_readStream , (UInt8*) buffer , size ) ;
2264
2265   return ret;
2266 }
2267
2268 int GSocket_Write(GSocket *socket, const char *buffer, int size)
2269 {
2270   int ret;
2271
2272   assert(socket != NULL);
2273   ret = CFWriteStreamWrite( socket->m_writeStream , (UInt8*) buffer , size ) ;
2274
2275   return ret;
2276 }
2277
2278 GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
2279 {
2280   assert( socket != NULL );
2281
2282   return flags & socket->m_detected;
2283 }
2284
2285 // ==========================================================================
2286 // wxSocketModule
2287 // ==========================================================================
2288
2289 class wxSocketModule : public wxModule
2290 {
2291 public:
2292     virtual bool OnInit()
2293     {
2294         // wxSocketBase will call GSocket_Init() itself when/if needed
2295         return true;
2296     }
2297
2298     virtual void OnExit()
2299     {
2300         if ( wxSocketBase::IsInitialized() )
2301             wxSocketBase::Shutdown();
2302     }
2303
2304 private:
2305     DECLARE_DYNAMIC_CLASS(wxSocketModule)
2306 };
2307
2308 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
2309
2310 #endif
2311   // wxUSE_SOCKETS