]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/socket.cpp
Don't emit bogus size events if a child window
[wxWidgets.git] / src / common / socket.cpp
index bbbdc01e59faf100ce37ac5b2633c413e33cfd25..11d97cccc433cba57f797ac6e210cf7ed3179f2e 100644 (file)
@@ -1,45 +1,45 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:       socket.cpp
+// Name:       src/common/socket.cpp
 // Purpose:    Socket handler classes
 // Authors:    Guilhem Lavaux, Guillermo Rodriguez Garcia
 // Created:    April 1997
 // Copyright:  (C) 1999-1997, Guilhem Lavaux
 //             (C) 2000-1999, Guillermo Rodriguez Garcia
 // RCS_ID:     $Id$
-// License:    see wxWindows licence
+// License:    wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // ==========================================================================
 // Declarations
 // ==========================================================================
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "socket.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #if wxUSE_SOCKETS
 
-#include "wx/app.h"
+#include "wx/socket.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/object.h"
+    #include "wx/string.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/event.h"
+    #include "wx/app.h"
+    #include "wx/utils.h"
+    #include "wx/timer.h"
+#endif
+
 #include "wx/apptrait.h"
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
-#include "wx/timer.h"
-#include "wx/utils.h"
 #include "wx/module.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include "wx/event.h"
 
 #include "wx/sckaddr.h"
-#include "wx/socket.h"
+#include "wx/datetime.h"
 
 // DLL options compatibility check:
 #include "wx/build.h"
@@ -98,7 +98,7 @@ public:
 public:
   wxSocketState() : wxObject() {}
 
-    DECLARE_NO_COPY_CLASS(wxSocketState)
+  DECLARE_NO_COPY_CLASS(wxSocketState)
 };
 
 // ==========================================================================
@@ -122,14 +122,6 @@ bool wxSocketBase::Initialize()
 {
     if ( !m_countInit++ )
     {
-#ifdef __WXMSW__
-        /*
-            The following asserting might be neccessary for linux as well,
-            but I cannot verify this.
-        */
-        wxASSERT(wxThread::IsMain(), 
-            wxT("To use sockets in a secondary thread, ")
-            wxT("call wxSocketBase::Initialize() from the main thread."));
         /*
             Details: Initialize() creates a hidden window as a sink for socket
             events, such as 'read completed'. wxMSW has only one message loop
@@ -138,32 +130,39 @@ bool wxSocketBase::Initialize()
             since there is no message loop on this thread, it will never
             receive events and all socket operations will time out.
             BTW, the main thread must not be stopped using sleep or block
-            on a semaphore (a bad idea in any case) or socket operations 
+            on a semaphore (a bad idea in any case) or socket operations
             will time out.
+
+            On the Mac side, Initialize() stores a pointer to the CFRunLoop for
+            the main thread. Because secondary threads do not have run loops,
+            adding event notifications to the "Current" loop would have no
+            effect at all, events would never fire.
         */
-#endif
+        wxASSERT_MSG( wxIsMainThread(),
+            wxT("Call wxSocketBase::Initialize() from the main thread first!"));
+
         wxAppTraits *traits = wxAppConsole::GetInstance() ?
                               wxAppConsole::GetInstance()->GetTraits() : NULL;
-        GSocketGUIFunctionsTable *functions = 
+        GSocketGUIFunctionsTable *functions =
             traits ? traits->GetSocketGUIFunctionsTable() : NULL;
         GSocket_SetGUIFunctions(functions);
-        
+
         if ( !GSocket_Init() )
         {
             m_countInit--;
 
-            return FALSE;
+            return false;
         }
     }
 
-    return TRUE;
+    return true;
 }
 
 void wxSocketBase::Shutdown()
 {
     // we should be initialized
     wxASSERT_MSG( m_countInit, _T("extra call to Shutdown()") );
-    if ( !--m_countInit )
+    if ( --m_countInit == 0 )
     {
         GSocket_Cleanup();
     }
@@ -184,10 +183,10 @@ void wxSocketBase::Init()
   m_establishing =
   m_reading      =
   m_writing      =
-  m_error        = FALSE;
+  m_error        = false;
   m_lcount       = 0;
   m_timeout      = 600;
-  m_beingDeleted = FALSE;
+  m_beingDeleted = false;
 
   // pushback buffer
   m_unread       = NULL;
@@ -195,10 +194,10 @@ void wxSocketBase::Init()
   m_unrd_cur     = 0;
 
   // events
-  m_id           = -1;
+  m_id           = wxID_ANY;
   m_handler      = NULL;
   m_clientData   = NULL;
-  m_notify       = FALSE;
+  m_notify       = false;
   m_eventmask    = 0;
 
   if ( !IsInitialized() )
@@ -236,7 +235,7 @@ wxSocketBase::~wxSocketBase()
 
   // Destroy the GSocket object
   if (m_socket)
-    GSocket_destroy(m_socket);
+    delete m_socket;
 
   // Free the pushback buffer
   if (m_unread)
@@ -248,13 +247,13 @@ bool wxSocketBase::Destroy()
   // Delayed destruction: the socket will be deleted during the next
   // idle loop iteration. This ensures that all pending events have
   // been processed.
-  m_beingDeleted = TRUE;
+  m_beingDeleted = true;
 
   // Shutdown and close the socket
   Close();
 
   // Supress events from now on
-  Notify(FALSE);
+  Notify(false);
 
   // schedule this object for deletion
   wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
@@ -269,7 +268,7 @@ bool wxSocketBase::Destroy()
       delete this;
   }
 
-  return TRUE;
+  return true;
 }
 
 // --------------------------------------------------------------------------
@@ -289,22 +288,22 @@ bool wxSocketBase::Close()
   if (m_socket)
   {
     // Disable callbacks
-    GSocket_UnsetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+    m_socket->UnsetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
                                     GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG);
 
     // Shutdown the connection
-    GSocket_Shutdown(m_socket);
+    m_socket->Shutdown();
   }
 
-  m_connected = FALSE;
-  m_establishing = FALSE;
-  return TRUE;
+  m_connected = false;
+  m_establishing = false;
+  return true;
 }
 
 wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
 {
   // Mask read events
-  m_reading = TRUE;
+  m_reading = true;
 
   m_lcount = _Read(buffer, nbytes);
 
@@ -315,7 +314,7 @@ wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes)
     m_error = (m_lcount == 0);
 
   // Allow read events from now on
-  m_reading = FALSE;
+  m_reading = false;
 
   return *this;
 }
@@ -325,17 +324,15 @@ wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
   int total;
 
   // Try the pushback buffer first
-  total = GetPushback(buffer, nbytes, FALSE);
+  total = GetPushback(buffer, nbytes, false);
   nbytes -= total;
   buffer  = (char *)buffer + total;
 
   // Return now in one of the following cases:
   // - the socket is invalid,
-  // - we got all the data,
-  // - we got *some* data and we are not using wxSOCKET_WAITALL.
+  // - we got all the data
   if ( !m_socket ||
-       !nbytes ||
-       ((total != 0) && !(m_flags & wxSOCKET_WAITALL)) )
+       !nbytes )
     return total;
 
   // Possible combinations (they are checked in this order)
@@ -347,23 +344,23 @@ wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
   int ret;
   if (m_flags & wxSOCKET_NOWAIT)
   {
-    GSocket_SetNonBlocking(m_socket, 1);
-    ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
-    GSocket_SetNonBlocking(m_socket, 0);
+    m_socket->SetNonBlocking(1);
+    ret = m_socket->Read((char *)buffer, nbytes);
+    m_socket->SetNonBlocking(0);
 
     if (ret > 0)
       total += ret;
   }
   else
   {
-    bool more = TRUE;
+    bool more = true;
 
     while (more)
     {
       if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() )
         break;
 
-      ret = GSocket_Read(m_socket, (char *)buffer, nbytes);
+      ret = m_socket->Read((char *)buffer, nbytes);
 
       if (ret > 0)
       {
@@ -395,10 +392,10 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
   } msg;
 
   // Mask read events
-  m_reading = TRUE;
+  m_reading = true;
 
   total = 0;
-  error = TRUE;
+  error = true;
   old_flags = m_flags;
   SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
 
@@ -471,12 +468,12 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
   }
 
   // everything was OK
-  error = FALSE;
+  error = false;
 
 exit:
   m_error = error;
   m_lcount = total;
-  m_reading = FALSE;
+  m_reading = false;
   SetFlags(old_flags);
 
   return *this;
@@ -485,7 +482,7 @@ exit:
 wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
 {
   // Mask read events
-  m_reading = TRUE;
+  m_reading = true;
 
   m_lcount = _Read(buffer, nbytes);
   Pushback(buffer, m_lcount);
@@ -497,7 +494,7 @@ wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
     m_error = (m_lcount == 0);
 
   // Allow read events again
-  m_reading = FALSE;
+  m_reading = false;
 
   return *this;
 }
@@ -505,7 +502,7 @@ wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes)
 wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes)
 {
   // Mask write events
-  m_writing = TRUE;
+  m_writing = true;
 
   m_lcount = _Write(buffer, nbytes);
 
@@ -516,7 +513,7 @@ wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes)
     m_error = (m_lcount == 0);
 
   // Allow write events again
-  m_writing = FALSE;
+  m_writing = false;
 
   return *this;
 }
@@ -538,23 +535,23 @@ wxUint32 wxSocketBase::_Write(const void *buffer, wxUint32 nbytes)
   int ret;
   if (m_flags & wxSOCKET_NOWAIT)
   {
-    GSocket_SetNonBlocking(m_socket, 1);
-    ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
-    GSocket_SetNonBlocking(m_socket, 0);
+    m_socket->SetNonBlocking(1);
+    ret = m_socket->Write((const char *)buffer, nbytes);
+    m_socket->SetNonBlocking(0);
 
     if (ret > 0)
       total = ret;
   }
   else
   {
-    bool more = TRUE;
+    bool more = true;
 
     while (more)
     {
       if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForWrite() )
         break;
 
-      ret = GSocket_Write(m_socket, (const char *)buffer, nbytes);
+      ret = m_socket->Write((const char *)buffer, nbytes);
 
       if (ret > 0)
       {
@@ -585,9 +582,9 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes)
   } msg;
 
   // Mask write events
-  m_writing = TRUE;
+  m_writing = true;
 
-  error = TRUE;
+  error = true;
   total = 0;
   SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
 
@@ -619,12 +616,12 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes)
     goto exit;
 
   // everything was OK
-  error = FALSE;
+  error = false;
 
 exit:
   m_error = error;
   m_lcount = total;
-  m_writing = FALSE;
+  m_writing = false;
 
   return *this;
 }
@@ -634,7 +631,7 @@ wxSocketBase& wxSocketBase::Unread(const void *buffer, wxUint32 nbytes)
   if (nbytes != 0)
     Pushback(buffer, nbytes);
 
-  m_error = FALSE;
+  m_error = false;
   m_lcount = nbytes;
 
   return *this;
@@ -647,7 +644,7 @@ wxSocketBase& wxSocketBase::Discard()
   wxUint32 total = 0;
 
   // Mask read events
-  m_reading = TRUE;
+  m_reading = true;
 
   SetFlags(wxSOCKET_NOWAIT);
 
@@ -660,10 +657,10 @@ wxSocketBase& wxSocketBase::Discard()
 
   delete[] buffer;
   m_lcount = total;
-  m_error  = FALSE;
+  m_error  = false;
 
   // Allow read events again
-  m_reading = FALSE;
+  m_reading = false;
 
   return *this;
 }
@@ -685,12 +682,12 @@ bool wxSocketBase::_Wait(long seconds,
   GSocketEventFlags result;
   long timeout;
 
-  // Set this to TRUE to interrupt ongoing waits
-  m_interrupt = FALSE;
+  // Set this to true to interrupt ongoing waits
+  m_interrupt = false;
 
   // Check for valid socket
   if (!m_socket)
-    return FALSE;
+    return false;
 
   // Check for valid timeout value.
   if (seconds != -1)
@@ -698,9 +695,7 @@ bool wxSocketBase::_Wait(long seconds,
   else
     timeout = m_timeout * 1000;
 
-#if !defined(wxUSE_GUI) || !wxUSE_GUI
-  GSocket_SetTimeout(m_socket, timeout);
-#endif 
+  bool has_event_loop = wxTheApp->GetTraits() ? (wxTheApp->GetTraits()->GetSocketGUIFunctionsTable() ? true : false) : false;
 
   // Wait in an active polling loop.
   //
@@ -712,62 +707,94 @@ bool wxSocketBase::_Wait(long seconds,
   // Do this at least once (important if timeout == 0, when
   // we are just polling). Also, if just polling, do not yield.
 
-  wxStopWatch chrono;
-  bool done = FALSE;
+  wxDateTime current_time = wxDateTime::UNow();
+  unsigned int time_limit = (current_time.GetTicks() * 1000) + current_time.GetMillisecond() + timeout;
+  bool done = false;
+  bool valid_result = false;
+
+  if (!has_event_loop)
+  {
+    // This is used to avoid a busy loop on wxBase - having a select
+    // timeout of 50 ms per iteration should be enough.
+    if (timeout > 50)
+      m_socket->SetTimeout(50);
+    else
+      m_socket->SetTimeout(timeout);
+  }
 
   while (!done)
   {
-    result = GSocket_Select(m_socket, flags | GSOCK_LOST_FLAG);
+    result = m_socket->Select(flags | GSOCK_LOST_FLAG);
 
     // Incoming connection (server) or connection established (client)
     if (result & GSOCK_CONNECTION_FLAG)
     {
-      m_connected = TRUE;
-      m_establishing = FALSE;
-      return TRUE;
+      m_connected = true;
+      m_establishing = false;
+      valid_result = true;
+      break;
     }
 
     // Data available or output buffer ready
     if ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG))
     {
-      return TRUE;
+      valid_result = true;
+      break;
     }
 
     // Connection lost
     if (result & GSOCK_LOST_FLAG)
     {
-      m_connected = FALSE;
-      m_establishing = FALSE;
-      return (flags & GSOCK_LOST_FLAG) != 0;
+      m_connected = false;
+      m_establishing = false;
+      valid_result = ((flags & GSOCK_LOST_FLAG) != 0);
+      break;
     }
 
     // Wait more?
-    if ((!timeout) || (chrono.Time() > timeout) || (m_interrupt))
-      done = TRUE;
+    current_time = wxDateTime::UNow();
+    int time_left = time_limit - ((current_time.GetTicks() * 1000) + current_time.GetMillisecond());
+    if ((!timeout) || (time_left <= 0) || (m_interrupt))
+      done = true;
     else
-      PROCESS_EVENTS();
+    {
+      if (has_event_loop)
+      {
+          PROCESS_EVENTS();
+      }
+      else
+      {
+        // If there's less than 50 ms left, just call select with that timeout.
+        if (time_left < 50)
+          m_socket->SetTimeout(time_left);
+      }
+    }
   }
 
-  return FALSE;
+  // Set timeout back to original value (we overwrote it for polling)
+  if (!has_event_loop)
+    m_socket->SetTimeout(m_timeout*1000);
+
+  return valid_result;
 }
 
 bool wxSocketBase::Wait(long seconds, long milliseconds)
 {
-  return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
-                                      GSOCK_OUTPUT_FLAG |
-                                      GSOCK_CONNECTION_FLAG |
-                                      GSOCK_LOST_FLAG);
+    return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
+                                        GSOCK_OUTPUT_FLAG |
+                                        GSOCK_CONNECTION_FLAG |
+                                        GSOCK_LOST_FLAG);
 }
 
 bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
 {
   // Check pushback buffer before entering _Wait
   if (m_unread)
-    return TRUE;
+    return true;
 
   // Note that GSOCK_INPUT_LOST has to be explicitly passed to
-  // _Wait becuase of the semantics of WaitForRead: a return
-  // value of TRUE means that a GSocket_Read call will return
+  // _Wait because of the semantics of WaitForRead: a return
+  // value of true means that a GSocket_Read call will return
   // immediately, not that there is actually data to read.
 
   return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG |
@@ -777,12 +804,12 @@ bool wxSocketBase::WaitForRead(long seconds, long milliseconds)
 
 bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
 {
-  return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
+    return _Wait(seconds, milliseconds, GSOCK_OUTPUT_FLAG);
 }
 
 bool wxSocketBase::WaitForLost(long seconds, long milliseconds)
 {
-  return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG);
+    return _Wait(seconds, milliseconds, GSOCK_LOST_FLAG);
 }
 
 // --------------------------------------------------------------------------
@@ -798,33 +825,33 @@ bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
   GAddress *peer;
 
   if (!m_socket)
-    return FALSE;
+    return false;
 
-  peer = GSocket_GetPeer(m_socket);
+  peer = m_socket->GetPeer();
 
     // copying a null address would just trigger an assert anyway
 
   if (!peer)
-    return FALSE;
+    return false;
 
   addr_man.SetAddress(peer);
   GAddress_destroy(peer);
 
-  return TRUE;
+  return true;
 }
 
 bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
 {
-  GAddress *local;
+    GAddress *local;
 
-  if (!m_socket)
-    return FALSE;
+    if (!m_socket)
+        return false;
 
-  local = GSocket_GetLocal(m_socket);
-  addr_man.SetAddress(local);
-  GAddress_destroy(local);
+    local = m_socket->GetLocal();
+    addr_man.SetAddress(local);
+    GAddress_destroy(local);
 
-  return TRUE;
+    return true;
 }
 
 //
@@ -833,36 +860,36 @@ bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
 
 void wxSocketBase::SaveState()
 {
-  wxSocketState *state;
+    wxSocketState *state;
 
-  state = new wxSocketState();
+    state = new wxSocketState();
 
-  state->m_flags      = m_flags;
-  state->m_notify     = m_notify;
-  state->m_eventmask  = m_eventmask;
-  state->m_clientData = m_clientData;
+    state->m_flags      = m_flags;
+    state->m_notify     = m_notify;
+    state->m_eventmask  = m_eventmask;
+    state->m_clientData = m_clientData;
 
-  m_states.Append(state);
+    m_states.Append(state);
 }
 
 void wxSocketBase::RestoreState()
 {
-  wxList::compatibility_iterator node;
-  wxSocketState *state;
-
-  node = m_states.GetLast();
-  if (!node)
-    return;
-
-  state = (wxSocketState *)node->GetData();
-
-  m_flags      = state->m_flags;
-  m_notify     = state->m_notify;
-  m_eventmask  = state->m_eventmask;
-  m_clientData = state->m_clientData;
-  
-  m_states.Erase(node);
-  delete state;
+    wxList::compatibility_iterator node;
+    wxSocketState *state;
+
+    node = m_states.GetLast();
+    if (!node)
+        return;
+
+    state = (wxSocketState *)node->GetData();
+
+    m_flags      = state->m_flags;
+    m_notify     = state->m_notify;
+    m_eventmask  = state->m_eventmask;
+    m_clientData = state->m_clientData;
+
+    m_states.Erase(node);
+    delete state;
 }
 
 //
@@ -871,15 +898,15 @@ void wxSocketBase::RestoreState()
 
 void wxSocketBase::SetTimeout(long seconds)
 {
-  m_timeout = seconds;
+    m_timeout = seconds;
 
-  if (m_socket)
-    GSocket_SetTimeout(m_socket, m_timeout * 1000);
+    if (m_socket)
+        m_socket->SetTimeout(m_timeout * 1000);
 }
 
 void wxSocketBase::SetFlags(wxSocketFlags flags)
 {
-  m_flags = flags;
+    m_flags = flags;
 }
 
 
@@ -910,9 +937,9 @@ void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
                                     GSocketEvent notification,
                                     char *cdata)
 {
-  wxSocketBase *sckobj = (wxSocketBase *)cdata;
+    wxSocketBase *sckobj = (wxSocketBase *)cdata;
 
-  sckobj->OnRequest((wxSocketNotify) notification);
+    sckobj->OnRequest((wxSocketNotify) notification);
 }
 
 void wxSocketBase::OnRequest(wxSocketNotify notification)
@@ -925,8 +952,8 @@ void wxSocketBase::OnRequest(wxSocketNotify notification)
   switch(notification)
   {
     case wxSOCKET_CONNECTION:
-      m_establishing = FALSE;
-      m_connected = TRUE;
+      m_establishing = false;
+      m_connected = true;
       break;
 
     // If we are in the middle of a R/W operation, do not
@@ -934,18 +961,18 @@ void wxSocketBase::OnRequest(wxSocketNotify notification)
     // which are no longer valid.
 
     case wxSOCKET_INPUT:
-      if (m_reading || !GSocket_Select(m_socket, GSOCK_INPUT_FLAG))
+      if (m_reading || !m_socket->Select(GSOCK_INPUT_FLAG))
         return;
       break;
 
     case wxSOCKET_OUTPUT:
-      if (m_writing || !GSocket_Select(m_socket, GSOCK_OUTPUT_FLAG))
+      if (m_writing || !m_socket->Select(GSOCK_OUTPUT_FLAG))
         return;
       break;
 
     case wxSOCKET_LOST:
-      m_connected = FALSE;
-      m_establishing = FALSE;
+      m_connected = false;
+      m_establishing = false;
       break;
 
     default:
@@ -983,18 +1010,18 @@ void wxSocketBase::OnRequest(wxSocketNotify notification)
 
 void wxSocketBase::Notify(bool notify)
 {
-  m_notify = notify;
+    m_notify = notify;
 }
 
 void wxSocketBase::SetNotify(wxSocketEventFlags flags)
 {
-  m_eventmask = flags;
+    m_eventmask = flags;
 }
 
 void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id)
 {
-  m_handler = &handler;
-  m_id      = id;
+    m_handler = &handler;
+    m_id      = id;
 }
 
 // --------------------------------------------------------------------------
@@ -1057,7 +1084,7 @@ wxUint32 wxSocketBase::GetPushback(void *buffer, wxUint32 size, bool peek)
 // Ctor
 // --------------------------------------------------------------------------
 
-wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
+wxSocketServer::wxSocketServer(const wxSockAddress& addr_man,
                                wxSocketFlags flags)
               : wxSocketBase(flags, wxSOCKET_SERVER)
 {
@@ -1073,18 +1100,23 @@ wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
 
         // Setup the socket as server
 
-    GSocket_SetLocal(m_socket, addr_man.GetAddress());
-    if (GSocket_SetServer(m_socket) != GSOCK_NOERROR)
+    m_socket->SetLocal(addr_man.GetAddress());
+
+    if (GetFlags() & wxSOCKET_REUSEADDR) {
+        m_socket->SetReusable();
+    }
+
+    if (m_socket->SetServer() != GSOCK_NOERROR)
     {
-        GSocket_destroy(m_socket);
+        delete m_socket;
         m_socket = NULL;
 
         wxLogTrace( wxTRACE_Socket, _T("*** GSocket_SetServer failed") );
         return;
     }
 
-    GSocket_SetTimeout(m_socket, m_timeout * 1000);
-    GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+    m_socket->SetTimeout(m_timeout * 1000);
+    m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
                                   GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
                                   wx_socket_callback, (char *)this);
 }
@@ -1098,33 +1130,33 @@ bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait)
   GSocket *child_socket;
 
   if (!m_socket)
-    return FALSE;
+    return false;
 
-  // If wait == FALSE, then the call should be nonblocking.
+  // If wait == false, then the call should be nonblocking.
   // When we are finished, we put the socket to blocking mode
   // again.
 
   if (!wait)
-    GSocket_SetNonBlocking(m_socket, 1);
+    m_socket->SetNonBlocking(1);
 
-  child_socket = GSocket_WaitConnection(m_socket);
+  child_socket = m_socket->WaitConnection();
 
   if (!wait)
-    GSocket_SetNonBlocking(m_socket, 0);
+    m_socket->SetNonBlocking(0);
 
   if (!child_socket)
-    return FALSE;
+    return false;
 
   sock.m_type = wxSOCKET_BASE;
   sock.m_socket = child_socket;
-  sock.m_connected = TRUE;
+  sock.m_connected = true;
 
-  GSocket_SetTimeout(sock.m_socket, sock.m_timeout * 1000);
-  GSocket_SetCallback(sock.m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+  sock.m_socket->SetTimeout(sock.m_timeout * 1000);
+  sock.m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
                                      GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
                                      wx_socket_callback, (char *)&sock);
 
-  return TRUE;
+  return true;
 }
 
 wxSocketBase *wxSocketServer::Accept(bool wait)
@@ -1144,28 +1176,47 @@ wxSocketBase *wxSocketServer::Accept(bool wait)
 
 bool wxSocketServer::WaitForAccept(long seconds, long milliseconds)
 {
-  return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
+    return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG);
 }
 
 bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen)
 {
-    if (GSocket_GetSockOpt(m_socket, level, optname, optval, optlen) 
+    wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+    if (m_socket->GetSockOpt(level, optname, optval, optlen)
         != GSOCK_NOERROR)
     {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 
-bool wxSocketBase::SetOption(int level, int optname, const void *optval, 
+bool wxSocketBase::SetOption(int level, int optname, const void *optval,
                               int optlen)
 {
-    if (GSocket_SetSockOpt(m_socket, level, optname, optval, optlen) 
+    wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+    if (m_socket->SetSockOpt(level, optname, optval, optlen)
         != GSOCK_NOERROR)
     {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
+}
+
+bool wxSocketBase::SetLocal(wxIPV4address& local)
+{
+  GAddress* la = local.GetAddress();
+
+  // If the address is valid, save it for use when we call Connect
+  if (la && la->m_addr)
+  {
+    m_localAddress = local;
+
+    return true;
+  }
+
+  return false;
 }
 
 // ==========================================================================
@@ -1189,7 +1240,7 @@ wxSocketClient::~wxSocketClient()
 // Connect
 // --------------------------------------------------------------------------
 
-bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
+bool wxSocketClient::DoConnect(wxSockAddress& addr_man, wxSockAddress* local, bool wait)
 {
   GSocketError err;
 
@@ -1197,56 +1248,87 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
   {
     // Shutdown and destroy the socket
     Close();
-    GSocket_destroy(m_socket);
+    delete m_socket;
   }
 
   m_socket = GSocket_new();
-  m_connected = FALSE;
-  m_establishing = FALSE;
+  m_connected = false;
+  m_establishing = false;
 
   if (!m_socket)
-    return FALSE;
+    return false;
 
-  GSocket_SetTimeout(m_socket, m_timeout * 1000);
-  GSocket_SetCallback(m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+  m_socket->SetTimeout(m_timeout * 1000);
+  m_socket->SetCallback(GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
                                 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
                                 wx_socket_callback, (char *)this);
 
-  // If wait == FALSE, then the call should be nonblocking.
+  // If wait == false, then the call should be nonblocking.
   // When we are finished, we put the socket to blocking mode
   // again.
 
   if (!wait)
-    GSocket_SetNonBlocking(m_socket, 1);
+    m_socket->SetNonBlocking(1);
+
+  // Reuse makes sense for clients too, if we are trying to rebind to the same port
+  if (GetFlags() & wxSOCKET_REUSEADDR)
+  {
+    m_socket->SetReusable();
+  }
+
+  // If no local address was passed and one has been set, use the one that was Set
+  if (!local && m_localAddress.GetAddress())
+  {
+    local = &m_localAddress;
+  }
 
-  GSocket_SetPeer(m_socket, addr_man.GetAddress());
-  err = GSocket_Connect(m_socket, GSOCK_STREAMED);
+  // Bind to the local IP address and port, when provided
+  if (local)
+  {
+    GAddress* la = local->GetAddress();
+
+    if (la && la->m_addr)
+      m_socket->SetLocal(la);
+  }
+
+  m_socket->SetPeer(addr_man.GetAddress());
+  err = m_socket->Connect(GSOCK_STREAMED);
 
   if (!wait)
-    GSocket_SetNonBlocking(m_socket, 0);
+    m_socket->SetNonBlocking(0);
 
   if (err != GSOCK_NOERROR)
   {
     if (err == GSOCK_WOULDBLOCK)
-      m_establishing = TRUE;
+      m_establishing = true;
 
-    return FALSE;
+    return false;
   }
 
-  m_connected = TRUE;
-  return TRUE;
+  m_connected = true;
+  return true;
+}
+
+bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
+{
+    return (DoConnect(addr_man, NULL, wait));
+}
+
+bool wxSocketClient::Connect(wxSockAddress& addr_man, wxSockAddress& local, bool wait)
+{
+    return (DoConnect(addr_man, &local, wait));
 }
 
 bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
 {
-  if (m_connected)                      // Already connected
-    return TRUE;
+    if (m_connected)                      // Already connected
+        return true;
 
-  if (!m_establishing || !m_socket)     // No connection in progress
-    return FALSE;
+    if (!m_establishing || !m_socket)     // No connection in progress
+        return false;
 
-  return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG |
-                                      GSOCK_LOST_FLAG);
+    return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG |
+                                        GSOCK_LOST_FLAG);
 }
 
 // ==========================================================================
@@ -1255,36 +1337,34 @@ bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds)
 
 /* NOTE: experimental stuff - might change */
 
-wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr,
+wxDatagramSocket::wxDatagramSocket( const wxSockAddress& addr,
                                     wxSocketFlags flags )
                 : wxSocketBase( flags, wxSOCKET_DATAGRAM )
 {
-  // Create the socket
-  m_socket = GSocket_new();
-
-  if(!m_socket)
-  {
-    wxASSERT_MSG( 0, _T("datagram socket not new'd") );
-    return;
-  }
-  // Setup the socket as non connection oriented
-  GSocket_Unstreamed(m_socket);
-  GSocket_SetLocal(m_socket, addr.GetAddress());
-  if( GSocket_SetNonOriented(m_socket) != GSOCK_NOERROR )
-  {
-    GSocket_destroy(m_socket);
-    m_socket = NULL;
-    return;
-  }
+    // Create the socket
+    m_socket = GSocket_new();
 
-  // Initialize all stuff
-  m_connected = FALSE;
-  m_establishing = FALSE;
-  GSocket_SetTimeout( m_socket, m_timeout );
-  GSocket_SetCallback( m_socket, GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
-                                 GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
-                                 wx_socket_callback, (char*)this );
+    if(!m_socket)
+    {
+        wxFAIL_MSG( _T("datagram socket not new'd") );
+        return;
+    }
+    // Setup the socket as non connection oriented
+    m_socket->SetLocal(addr.GetAddress());
+    if( m_socket->SetNonOriented() != GSOCK_NOERROR )
+    {
+        delete m_socket;
+        m_socket = NULL;
+        return;
+    }
 
+    // Initialize all stuff
+    m_connected = false;
+    m_establishing = false;
+    m_socket->SetTimeout( m_timeout );
+    m_socket->SetCallback( GSOCK_INPUT_FLAG | GSOCK_OUTPUT_FLAG |
+                           GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
+                           wx_socket_callback, (char*)this );
 }
 
 wxDatagramSocket& wxDatagramSocket::RecvFrom( wxSockAddress& addr,
@@ -1296,11 +1376,13 @@ wxDatagramSocket& wxDatagramSocket::RecvFrom( wxSockAddress& addr,
     return (*this);
 }
 
-wxDatagramSocket& wxDatagramSocket::SendTo( wxSockAddress& addr,
+wxDatagramSocket& wxDatagramSocket::SendTo( const wxSockAddress& addr,
                                             const void* buf,
                                             wxUint32 nBytes )
 {
-    GSocket_SetPeer(m_socket, addr.GetAddress());
+    wxASSERT_MSG( m_socket, _T("Socket not initialised") );
+
+    m_socket->SetPeer(addr.GetAddress());
     Write(buf, nBytes);
     return (*this);
 }
@@ -1315,7 +1397,7 @@ public:
     virtual bool OnInit()
     {
         // wxSocketBase will call GSocket_Init() itself when/if needed
-        return TRUE;
+        return true;
     }
 
     virtual void OnExit()
@@ -1332,5 +1414,3 @@ IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
 
 #endif
   // wxUSE_SOCKETS
-
-// vi:sts=4:sw=4:et