]> git.saurik.com Git - wxWidgets.git/blobdiff - src/mac/carbon/cfsocket.cpp
Use IsOk() instead of Ok()
[wxWidgets.git] / src / mac / carbon / cfsocket.cpp
index 480bedab9a38677e2840a38e3c167c972b94b962..8a2383c7f5772a075bbf356a0cc7310a42f04f10 100644 (file)
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:       socket.cpp
+// Name:       src/mac/carbon/cfsocket.cpp
 // Purpose:    Socket handler classes
 // Authors:    Guilhem Lavaux, Guillermo Rodriguez Garcia
 // Created:    April 1997
@@ -9,37 +9,31 @@
 // License:    see 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"
+    #include "wx/module.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/mac/carbon/private.h"
 
 #include <sys/socket.h>
 
 // DLL options compatibility check:
 #include "wx/build.h"
+
 WX_CHECK_BUILD_OPTIONS("wxNet")
 
-// --------------------------------------------------------------------------
-// macros and constants
-// --------------------------------------------------------------------------
 
 // discard buffer
 #define MAX_DISCARD_SIZE (10 * 1024)
@@ -66,7 +58,7 @@ WX_CHECK_BUILD_OPTIONS("wxNet")
 
 // what to do within waits: we have 2 cases: from the main thread itself we
 // have to call wxYield() to let the events (including the GUI events and the
-// low-level (not wxWindows) events from GSocket) be processed. From another
+// low-level (not wxWidgets) events from GSocket) be processed. From another
 // thread it is enough to just call wxThread::Yield() which will give away the
 // rest of our time slice: the explanation is that the events will be processed
 // by the main thread anyhow, without calling wxYield(), but we don't want to
@@ -85,9 +77,6 @@ WX_CHECK_BUILD_OPTIONS("wxNet")
 
 #define wxTRACE_Socket _T("wxSocket")
 
-// --------------------------------------------------------------------------
-// wxWin macros
-// --------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxSocketBase, wxObject)
 IMPLEMENT_CLASS(wxSocketServer, wxSocketBase)
@@ -127,8 +116,7 @@ struct _GSocket
   int m_establishing;
   unsigned long m_timeout;
 
-
-  /* Callbacks */
+  // Callbacks
   GSocketEventFlags m_detected;
   GSocketCallback m_cbacks[GSOCK_MAX_EVENT];
   char *m_data[GSOCK_MAX_EVENT];
@@ -137,7 +125,7 @@ struct _GSocket
   CFRunLoopSourceRef    m_runLoopSource;
   CFReadStreamRef       m_readStream ;
   CFWriteStreamRef      m_writeStream ;
-} ;
+};
 
 struct _GAddress
 {
@@ -180,26 +168,26 @@ bool wxSocketBase::Initialize()
 #if 0
         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;
         }
 #endif
     }
 
-    return TRUE;
+    return true;
 }
 
 void wxSocketBase::Shutdown()
 {
     // we should be initialized
-    wxASSERT_MSG( m_countInit, _T("extra call to Shutdown()") );
+    wxASSERT_MSG( m_countInit, wxT("extra call to Shutdown()") );
     if ( !--m_countInit )
     {
 #if 0
@@ -223,10 +211,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;
@@ -237,7 +225,7 @@ void wxSocketBase::Init()
   m_id           = -1;
   m_handler      = NULL;
   m_clientData   = NULL;
-  m_notify       = FALSE;
+  m_notify       = false;
   m_eventmask    = 0;
 
   if ( !IsInitialized() )
@@ -253,7 +241,7 @@ wxSocketBase::wxSocketBase()
   Init();
 }
 
-wxSocketBase::wxSocketBase(wxSocketFlags flags, wxSocketType type)
+wxSocketBase::wxSocketBase( wxSocketFlags flags, wxSocketType type)
 {
   Init();
 
@@ -289,13 +277,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;
@@ -310,7 +298,7 @@ bool wxSocketBase::Destroy()
       delete this;
   }
 
-  return TRUE;
+  return true;
 }
 
 // --------------------------------------------------------------------------
@@ -328,19 +316,18 @@ bool wxSocketBase::Close()
   InterruptWait();
 
   if (m_socket)
-  {
     GSocket_Shutdown(m_socket);
-  }
 
-  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);
 
@@ -351,7 +338,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;
 }
@@ -361,7 +348,7 @@ wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
   int total = 0;
 
   // Try the pushback buffer first
-  total = GetPushback(buffer, nbytes, FALSE);
+  total = GetPushback(buffer, nbytes, false);
   nbytes -= total;
   buffer  = (char *)buffer + total;
 
@@ -393,7 +380,7 @@ wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
   }
   else
   {
-    bool more = TRUE;
+    bool more = true;
 
     while (more)
     {
@@ -429,13 +416,14 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
   {
     unsigned char sig[4];
     unsigned char len[4];
-  } msg;
+  }
+  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);
 
@@ -449,7 +437,7 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
 
   if (sig != 0xfeeddead)
   {
-    wxLogWarning(_("wxSocket: invalid signature in ReadMsg."));
+    wxLogWarning( wxT("wxSocket: invalid signature in ReadMsg.") );
     goto exit;
   }
 
@@ -503,17 +491,17 @@ wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes)
 
   if (sig != 0xdeadfeed)
   {
-    wxLogWarning(_("wxSocket: invalid signature in ReadMsg."));
+    wxLogWarning( wxT("wxSocket: invalid signature in ReadMsg.") );
     goto exit;
   }
 
   // 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;
@@ -522,7 +510,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);
@@ -534,7 +522,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;
 }
@@ -542,7 +530,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);
 
@@ -553,7 +541,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;
 }
@@ -584,7 +572,7 @@ wxUint32 wxSocketBase::_Write(const void *buffer, wxUint32 nbytes)
   }
   else
   {
-    bool more = TRUE;
+    bool more = true;
 
     while (more)
     {
@@ -619,12 +607,13 @@ wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes)
   {
     unsigned char sig[4];
     unsigned char len[4];
-  } msg;
+  }
+  msg;
 
   // Mask write events
-  m_writing = TRUE;
+  m_writing = true;
 
-  error = TRUE;
+  error = true;
   total = 0;
   SetFlags((m_flags & wxSOCKET_BLOCK) | wxSOCKET_WAITALL);
 
@@ -656,12 +645,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;
 }
@@ -671,7 +660,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;
@@ -684,7 +673,7 @@ wxSocketBase& wxSocketBase::Discard()
   wxUint32 total = 0;
 
   // Mask read events
-  m_reading = TRUE;
+  m_reading = true;
 
   SetFlags(wxSOCKET_NOWAIT);
 
@@ -697,10 +686,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;
 }
@@ -718,17 +707,16 @@ wxSocketBase& wxSocketBase::Discard()
 bool wxSocketBase::_Wait(long seconds,
                          long milliseconds,
                          wxSocketEventFlags flags)
-{  
-
+{
   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)
@@ -738,7 +726,7 @@ bool wxSocketBase::_Wait(long seconds,
 
 #if !defined(wxUSE_GUI) || !wxUSE_GUI
   GSocket_SetTimeout(m_socket, timeout);
-#endif 
+#endif
 
   // Wait in an active polling loop.
   //
@@ -751,7 +739,7 @@ bool wxSocketBase::_Wait(long seconds,
   // we are just polling). Also, if just polling, do not yield.
 
   wxStopWatch chrono;
-  bool done = FALSE;
+  bool done = false;
 
   while (!done)
   {
@@ -760,33 +748,35 @@ bool wxSocketBase::_Wait(long seconds,
     // 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;
+
+      return true;
     }
 
     // Data available or output buffer ready
     if ((result & GSOCK_INPUT_FLAG) || (result & GSOCK_OUTPUT_FLAG))
     {
-      return TRUE;
+      return true;
     }
 
     // Connection lost
     if (result & GSOCK_LOST_FLAG)
     {
-      m_connected = FALSE;
-      m_establishing = FALSE;
+      m_connected = false;
+      m_establishing = false;
+
       return (flags & GSOCK_LOST_FLAG) != 0;
     }
 
     // Wait more?
     if ((!timeout) || (chrono.Time() > timeout) || (m_interrupt))
-      done = TRUE;
+      done = true;
     else
       PROCESS_EVENTS();
   }
 
-  return FALSE;
+  return false;
 }
 
 bool wxSocketBase::Wait(long seconds, long milliseconds)
@@ -801,15 +791,14 @@ 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
+  // 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 |
-                                      GSOCK_LOST_FLAG);
+  return _Wait(seconds, milliseconds, GSOCK_INPUT_FLAG | GSOCK_LOST_FLAG);
 }
 
 bool wxSocketBase::WaitForWrite(long seconds, long milliseconds)
@@ -835,19 +824,19 @@ bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
   GAddress *peer;
 
   if (!m_socket)
-    return FALSE;
+    return false;
 
   peer = GSocket_GetPeer(m_socket);
 
     // 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
@@ -856,13 +845,14 @@ bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
   GAddress *local;
 
   if (!m_socket)
-    return FALSE;
+    return false;
 
   local = GSocket_GetLocal(m_socket);
   addr_man.SetAddress(local);
   GAddress_destroy(local);
 #endif
-  return TRUE;
+
+  return true;
 }
 
 //
@@ -898,7 +888,7 @@ void wxSocketBase::RestoreState()
   m_notify     = state->m_notify;
   m_eventmask  = state->m_eventmask;
   m_clientData = state->m_clientData;
-  
+
   m_states.Erase(node);
   delete state;
 }
@@ -958,15 +948,15 @@ void LINKAGEMODE wx_socket_callback(GSocket * WXUNUSED(socket),
 void wxSocketBase::OnRequest(wxSocketNotify notification)
 {
   // NOTE: We duplicate some of the code in _Wait, but this doesn't
-  //   hurt. It has to be here because the (GSocket) event might arrive
-  //   a bit delayed, and it has to be in _Wait as well because we don't
-  //   know whether the Wait functions are being used.
+  // hurt. It has to be here because the (GSocket) event might arrive
+  // a bit delayed, and it has to be in _Wait as well because we don't
+  // know whether the Wait functions are being used.
 
-  switch(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
@@ -984,8 +974,8 @@ void wxSocketBase::OnRequest(wxSocketNotify notification)
       break;
 
     case wxSOCKET_LOST:
-      m_connected = FALSE;
-      m_establishing = FALSE;
+      m_connected = false;
+      m_establishing = false;
       break;
 
     default:
@@ -998,12 +988,24 @@ void wxSocketBase::OnRequest(wxSocketNotify notification)
   wxUnusedVar(flag);
   switch (notification)
   {
-    case GSOCK_INPUT:      flag = GSOCK_INPUT_FLAG; break;
-    case GSOCK_OUTPUT:     flag = GSOCK_OUTPUT_FLAG; break;
-    case GSOCK_CONNECTION: flag = GSOCK_CONNECTION_FLAG; break;
-    case GSOCK_LOST:       flag = GSOCK_LOST_FLAG; break;
+    case GSOCK_INPUT:
+      flag = GSOCK_INPUT_FLAG;
+      break;
+
+    case GSOCK_OUTPUT:
+      flag = GSOCK_OUTPUT_FLAG;
+      break;
+
+    case GSOCK_CONNECTION:
+      flag = GSOCK_CONNECTION_FLAG;
+      break;
+
+    case GSOCK_LOST:
+      flag = GSOCK_LOST_FLAG;
+      break;
+
     default:
-      wxLogWarning(_("wxSocket: unknown event!."));
+      wxLogWarning( wxT("wxSocket: unknown event!") );
       return;
   }
 
@@ -1043,7 +1045,8 @@ void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id)
 
 void wxSocketBase::Pushback(const void *buffer, wxUint32 size)
 {
-  if (!size) return;
+  if (!size)
+    return;
 
   if (m_unread == NULL)
     m_unread = malloc(size);
@@ -1101,17 +1104,17 @@ wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
                                wxSocketFlags flags)
               : wxSocketBase(flags, wxSOCKET_SERVER)
 {
-    wxLogTrace( wxTRACE_Socket, _T("Opening wxSocketServer") );
+    wxLogTrace( wxTRACE_Socket, wxT("Opening wxSocketServer") );
 
     m_socket = GSocket_new();
 
     if (!m_socket)
     {
-        wxLogTrace( wxTRACE_Socket, _T("*** GSocket_new failed") );
+        wxLogTrace( wxTRACE_Socket, wxT("*** GSocket_new failed") );
         return;
     }
 
-        // Setup the socket as server
+    // Setup the socket as server
 
 #if 0
     GSocket_SetLocal(m_socket, addr_man.GetAddress());
@@ -1120,7 +1123,7 @@ wxSocketServer::wxSocketServer(wxSockAddress& addr_man,
         GSocket_destroy(m_socket);
         m_socket = NULL;
 
-        wxLogTrace( wxTRACE_Socket, _T("*** GSocket_SetServer failed") );
+        wxLogTrace( wxTRACE_Socket, wxT("*** GSocket_SetServer failed") );
         return;
     }
 
@@ -1140,9 +1143,9 @@ 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.
 
@@ -1156,18 +1159,19 @@ bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait)
     GSocket_SetNonBlocking(m_socket, 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 |
                                      GSOCK_LOST_FLAG | GSOCK_CONNECTION_FLAG,
                                      wx_socket_callback, (char *)&sock);
 #endif
-  return TRUE;
+
+  return true;
 }
 
 wxSocketBase *wxSocketServer::Accept(bool wait)
@@ -1213,7 +1217,7 @@ wxSocketClient::~wxSocketClient()
 
 bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
 {
-  GSocketError err ;
+  GSocketError err;
 
   if (m_socket)
   {
@@ -1223,18 +1227,18 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
   }
 
   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 |
                                 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.
 
@@ -1250,25 +1254,24 @@ bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
   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::WaitOnConnect(long seconds, long milliseconds)
 {
   if (m_connected)                      // Already connected
-    return TRUE;
+    return true;
 
   if (!m_establishing || !m_socket)     // No connection in progress
-    return FALSE;
+    return false;
 
-  return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG |
-                                      GSOCK_LOST_FLAG);
+  return _Wait(seconds, milliseconds, GSOCK_CONNECTION_FLAG | GSOCK_LOST_FLAG);
 }
 
 // ==========================================================================
@@ -1285,7 +1288,7 @@ wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr,
   // Create the socket
   m_socket = GSocket_new();
 
-  if(!m_socket)
+  if (!m_socket)
     return;
 
   // Setup the socket as non connection oriented
@@ -1298,8 +1301,8 @@ wxDatagramSocket::wxDatagramSocket( wxSockAddress& addr,
   }
 
   // Initialize all stuff
-  m_connected = FALSE;
-  m_establishing = FALSE;
+  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,
@@ -1396,6 +1399,7 @@ GAddress *GAddress_copy(GAddress *address)
       free(addr2);
       return NULL;
     }
+
     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
   }
 
@@ -1404,7 +1408,7 @@ GAddress *GAddress_copy(GAddress *address)
 
 void GAddress_destroy(GAddress *address)
 {
-  assert(address != NULL);
+  assert( address != NULL );
 
   if (address->m_addr)
     free(address->m_addr);
@@ -1421,7 +1425,7 @@ void GAddress_SetFamily(GAddress *address, GAddressType type)
 
 GAddressType GAddress_GetFamily(GAddress *address)
 {
-  assert(address != NULL);
+  assert( address != NULL );
 
   return address->m_family;
 }
@@ -1435,14 +1439,17 @@ GSocketError _GAddress_translate_from(GAddress *address,
     case AF_INET:
       address->m_family = GSOCK_INET;
       break;
+
     case AF_UNIX:
       address->m_family = GSOCK_UNIX;
       break;
+
 #ifdef AF_INET6
     case AF_INET6:
       address->m_family = GSOCK_INET6;
       break;
 #endif
+
     default:
     {
       address->m_error = GSOCK_INVOP;
@@ -1461,6 +1468,7 @@ GSocketError _GAddress_translate_from(GAddress *address,
     address->m_error = GSOCK_MEMERR;
     return GSOCK_MEMERR;
   }
+
   memcpy(address->m_addr, addr, len);
 
   return GSOCK_NOERROR;
@@ -1517,13 +1525,12 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   struct hostent *he;
   struct in_addr *addr;
 
-  assert(address != NULL);
-
-  CHECK_ADDRESS(address, INET);
+  assert( address != NULL );
+  CHECK_ADDRESS( address, INET );
 
   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
 
-  /* If it is a numeric host name, convert it now */
+  // If it is a numeric host name, convert it now
 #if defined(HAVE_INET_ATON)
   if (inet_aton(hostname, addr) == 0)
   {
@@ -1531,19 +1538,19 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
   if ( (addr->s_addr = inet_addr(hostname)) == -1 )
   {
 #else
-  /* Use gethostbyname by default */
+  // Use gethostbyname by default
 #ifndef __WXMAC__
-  int val = 1;  /* VA doesn't like constants in conditional expressions */
+  int val = 1;  // VA doesn't like constants in conditional expressions
   if (val)
 #endif
   {
 #endif
     struct in_addr *array_addr;
 
-    /* It is a real name, we solve it */
+    // It is a real name, we solve it
     if ((he = gethostbyname(hostname)) == NULL)
     {
-      /* Reset to invalid address */
+      // Reset to invalid address
       addr->s_addr = INADDR_NONE;
       address->m_error = GSOCK_NOHOST;
       return GSOCK_NOHOST;
@@ -1551,9 +1558,15 @@ GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
     array_addr = (struct in_addr *) *(he->h_addr_list);
     addr->s_addr = array_addr[0].s_addr;
   }
+
   return GSOCK_NOERROR;
 }
 
+GSocketError GAddress_INET_SetBroadcastAddress(GAddress *address)
+{
+  return GAddress_INET_SetHostAddress(address, INADDR_BROADCAST);
+}
+
 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
 {
   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
@@ -1564,9 +1577,8 @@ GSocketError GAddress_INET_SetHostAddress(GAddress *address,
 {
   struct in_addr *addr;
 
-  assert(address != NULL);
-
-  CHECK_ADDRESS(address, INET);
+  assert( address != NULL );
+  CHECK_ADDRESS( address, INET );
 
   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
   addr->s_addr = htonl(hostaddr) ;
@@ -1580,20 +1592,20 @@ GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
   struct servent *se;
   struct sockaddr_in *addr;
 
-  assert(address != NULL);
-  CHECK_ADDRESS(address, INET);
+  assert( address != NULL );
+  CHECK_ADDRESS( address, INET );
 
   if (!port)
   {
     address->m_error = GSOCK_INVPORT;
     return GSOCK_INVPORT;
   }
+
   se = getservbyname(port, protocol);
   if (!se)
   {
-    /* the cast to int suppresses compiler warnings about subscript having the
-       type char */
+    // the cast to int suppresses compiler warnings
+    // about subscript having the type char
     if (isdigit((int)port[0]))
     {
       int port_int;
@@ -1618,9 +1630,9 @@ GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL);
-  CHECK_ADDRESS(address, INET);
+  assert( address != NULL );
+  CHECK_ADDRESS( address, INET );
+
   addr = (struct sockaddr_in *)address->m_addr;
   addr->sin_port = htons(port);
 
@@ -1633,8 +1645,8 @@ GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t
   char *addr_buf;
   struct sockaddr_in *addr;
 
-  assert(address != NULL); 
-  CHECK_ADDRESS(address, INET);
+  assert( address != NULL );
+  CHECK_ADDRESS( address, INET );
 
   addr = (struct sockaddr_in *)address->m_addr;
   addr_buf = (char *)&(addr->sin_addr);
@@ -1655,8 +1667,8 @@ unsigned long GAddress_INET_GetHostAddress(GAddress *address)
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL); 
-  CHECK_ADDRESS_RETVAL(address, INET, 0); 
+  assert( address != NULL );
+  CHECK_ADDRESS_RETVAL( address, INET, 0 );
 
   addr = (struct sockaddr_in *)address->m_addr;
 
@@ -1667,10 +1679,11 @@ unsigned short GAddress_INET_GetPort(GAddress *address)
 {
   struct sockaddr_in *addr;
 
-  assert(address != NULL); 
-  CHECK_ADDRESS_RETVAL(address, INET, 0); 
+  assert( address != NULL );
+  CHECK_ADDRESS_RETVAL( address, INET, 0 );
 
   addr = (struct sockaddr_in *)address->m_addr;
+
   return ntohs(addr->sin_port);
 }
 
@@ -1704,9 +1717,8 @@ GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
 {
   struct sockaddr_un *addr;
 
-  assert(address != NULL); 
-
-  CHECK_ADDRESS(address, UNIX); 
+  assert( address != NULL );
+  CHECK_ADDRESS( address, UNIX );
 
   addr = ((struct sockaddr_un *)address->m_addr);
   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
@@ -1719,8 +1731,8 @@ GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
 {
   struct sockaddr_un *addr;
 
-  assert(address != NULL);
-  CHECK_ADDRESS(address, UNIX);
+  assert( address != NULL );
+  CHECK_ADDRESS( address, UNIX );
 
   addr = (struct sockaddr_un *)address->m_addr;
 
@@ -1745,19 +1757,19 @@ GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
  *    GSOCK_INVSOCK - the socket is not valid.
  *    GSOCK_INVADDR - the address is not valid.
  */
+
 GSocketError GSocket_SetLocal(GSocket *socket, GAddress *address)
 {
-  assert(socket != NULL);
+  assert( socket != NULL );
 
-  /* the socket must be initialized, or it must be a server */
+  // the socket must be initialized, or it must be a server
   if ((socket->m_fd != INVALID_SOCKET && !socket->m_server))
   {
     socket->m_error = GSOCK_INVSOCK;
     return GSOCK_INVSOCK;
   }
 
-  /* check address */
+  // check address
   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
   {
     socket->m_error = GSOCK_INVADDR;
@@ -1776,7 +1788,7 @@ GSocketError GSocket_SetPeer(GSocket *socket, GAddress *address)
 {
   assert(socket != NULL);
 
-  /* check address */
+  // check address
   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
   {
     socket->m_error = GSOCK_INVADDR;
@@ -1798,13 +1810,13 @@ GAddress *GSocket_GetLocal(GSocket *socket)
   socklen_t size = sizeof(addr);
   GSocketError err;
 
-  assert(socket != NULL);
+  assert( socket != NULL );
 
-  /* try to get it from the m_local var first */
+  // try to get it from the m_local var first
   if (socket->m_local)
     return GAddress_copy(socket->m_local);
 
-  /* else, if the socket is initialized, try getsockname */
+  // else, if the socket is initialized, try getsockname
   if (socket->m_fd == INVALID_SOCKET)
   {
     socket->m_error = GSOCK_INVSOCK;
@@ -1817,7 +1829,7 @@ GAddress *GSocket_GetLocal(GSocket *socket)
     return NULL;
   }
 
-  /* got a valid address from getsockname, create a GAddress object */
+  // got a valid address from getsockname, create a GAddress object
   address = GAddress_new();
   if (address == NULL)
   {
@@ -1840,17 +1852,13 @@ GAddress *GSocket_GetPeer(GSocket *socket)
 {
   assert(socket != NULL);
 
-  /* try to get it from the m_peer var */
+  // try to get it from the m_peer var
   if (socket->m_peer)
     return GAddress_copy(socket->m_peer);
 
   return NULL;
 }
 
-//
-//
-//
-
 
 GSocket *GSocket_new(void)
 {
@@ -1859,92 +1867,94 @@ GSocket *GSocket_new(void)
 
   if (socket == NULL)
     return NULL;
-    
+
   socket->m_fd                  = INVALID_SOCKET;
 
   for (int i=0;i<GSOCK_MAX_EVENT;i++)
   {
-    socket->m_cbacks[i]         = NULL;
+    socket->m_cbacks[i] = NULL;
   }
+
   socket->m_detected            = 0;
 
   socket->m_local               = NULL;
   socket->m_peer                = NULL;
   socket->m_error               = GSOCK_NOERROR;
 
-  socket->m_non_blocking        = FALSE ;
-  socket->m_stream              = TRUE;
-//  socket->m_oriented            = TRUE;
-  socket->m_server              = FALSE;
-  socket->m_establishing        = FALSE;
-  socket->m_timeout             = 10*60*1000;
-                                /* 10 minutes * 60 sec * 1000 millisec */
-  
+  socket->m_non_blocking        = false ;
+  socket->m_stream              = true;
+//  socket->m_oriented            = true;
+  socket->m_server              = false;
+  socket->m_establishing        = false;
+  socket->m_timeout             = 10 * 60 * 1000;
+                                // 10 minutes * 60 sec * 1000 millisec
+
   socket->m_cfSocket            = NULL ;
   socket->m_runLoopSource       = NULL ;
   socket->m_readStream          = NULL;
   socket->m_writeStream         = NULL;
-    
+
   return socket ;
 }
 
 void GSocket_close(GSocket *socket)
 {
-  if ( socket->m_cfSocket != NULL )
-  {
-    if ( socket->m_readStream )
-    {
-                 CFReadStreamClose(socket->m_readStream);
-      CFRelease( socket->m_readStream ) ;
-      socket->m_readStream = NULL ;
-    }
-    if ( socket->m_writeStream )
+    if ( socket->m_cfSocket != NULL )
     {
-                 CFWriteStreamClose(socket->m_writeStream);
-      CFRelease( socket->m_writeStream ) ;
-      socket->m_writeStream = NULL ;
-    }
+        if ( socket->m_readStream )
+        {
+            CFReadStreamClose(socket->m_readStream);
+            CFRelease( socket->m_readStream ) ;
+            socket->m_readStream = NULL ;
+        }
 
-    CFSocketInvalidate( socket->m_cfSocket ) ;
-    CFRelease( socket->m_cfSocket ) ;
-    socket->m_cfSocket = NULL ;
-    socket->m_fd = INVALID_SOCKET ;
-  }
+        if ( socket->m_writeStream )
+        {
+            CFWriteStreamClose(socket->m_writeStream);
+            CFRelease( socket->m_writeStream ) ;
+            socket->m_writeStream = NULL ;
+        }
+
+        CFSocketInvalidate( socket->m_cfSocket ) ;
+        CFRelease( socket->m_cfSocket ) ;
+        socket->m_cfSocket = NULL ;
+        socket->m_fd = INVALID_SOCKET ;
+    }
 }
 
 void GSocket_Shutdown(GSocket *socket)
 {
-  GSocket_close( socket ) ;
+    GSocket_close( socket );
 
-  /* Disable GUI callbacks */
-  for (int evt = 0; evt < GSOCK_MAX_EVENT; evt++)
-    socket->m_cbacks[evt] = NULL;
+    // Disable GUI callbacks
+    for (int evt = 0; evt < GSOCK_MAX_EVENT; evt++)
+        socket->m_cbacks[evt] = NULL;
 
-  socket->m_detected = GSOCK_LOST_FLAG;
+    socket->m_detected = GSOCK_LOST_FLAG;
 }
 
 void GSocket_destroy(GSocket *socket)
 {
-  assert(socket != NULL);
+  assert( socket != NULL );
 
-  /* Check that the socket is really shutdowned */
+  // Check that the socket is really shut down
   if (socket->m_fd != INVALID_SOCKET)
     GSocket_Shutdown(socket);
 
-  /* Destroy private addresses */
+  // Destroy private addresses
   if (socket->m_local)
     GAddress_destroy(socket->m_local);
 
   if (socket->m_peer)
     GAddress_destroy(socket->m_peer);
 
-  /* Destroy the socket itself */
+  // Destroy the socket itself
   free(socket);
 }
 
 GSocketError GSocket_Connect(GSocket *socket, GSocketStream stream)
 {
-  assert(socket != NULL);
+  assert( socket != NULL );
 
   if (socket->m_fd != INVALID_SOCKET)
   {
@@ -1958,68 +1968,69 @@ GSocketError GSocket_Connect(GSocket *socket, GSocketStream stream)
     return GSOCK_INVADDR;
   }
 
-  /* Streamed or dgram socket? */
+  // Streamed or dgram socket?
   socket->m_stream   = (stream == GSOCK_STREAMED);
-  socket->m_oriented = TRUE;
-  socket->m_server   = FALSE;
-  socket->m_establishing = FALSE;
+  socket->m_oriented = true;
+  socket->m_server = false;
+  socket->m_establishing = false;
 
   GSocketError returnErr = GSOCK_NOERROR ;
   CFSocketError err ;
-  
+
   CFAllocatorRef alloc = kCFAllocatorDefault ;
   CFSocketContext ctx ;
   memset( &ctx , 0 , sizeof( ctx ) ) ;
   ctx.info = socket ;
   socket->m_cfSocket = CFSocketCreate( alloc , socket->m_peer->m_realfamily ,
-     stream == GSOCK_STREAMED ? SOCK_STREAM : SOCK_DGRAM , 0 , 
+     stream == GSOCK_STREAMED ? SOCK_STREAM : SOCK_DGRAM , 0 ,
       kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack , wxMacCFSocketCallback , &ctx  ) ;
   _GSocket_Enable(socket, GSOCK_CONNECTION);
-     
-  socket->m_fd = CFSocketGetNative( socket->m_cfSocket ) ; 
 
-  CFStreamCreatePairWithSocket ( alloc , socket->m_fd , &socket->m_readStream , &socket->m_writeStream  ); 
-       if ((socket->m_readStream == NULL) || (socket->m_writeStream == NULL))
+  socket->m_fd = CFSocketGetNative( socket->m_cfSocket ) ;
+
+  CFStreamCreatePairWithSocket ( alloc , socket->m_fd , &socket->m_readStream , &socket->m_writeStream  );
+  if ((socket->m_readStream == NULL) || (socket->m_writeStream == NULL))
   {
     GSocket_close(socket);
     socket->m_error = GSOCK_IOERR;
     return GSOCK_IOERR;
   }
-    
+
   if ( !CFReadStreamOpen( socket->m_readStream ) || !CFWriteStreamOpen( socket->m_writeStream ) )
   {
     GSocket_close(socket);
     socket->m_error = GSOCK_IOERR;
     return GSOCK_IOERR;
   }
-  
+
   CFRunLoopSourceRef rls = CFSocketCreateRunLoopSource(alloc , socket->m_cfSocket , 0);
   CFRunLoopAddSource(CFRunLoopGetCurrent() , rls, kCFRunLoopCommonModes);
   CFRelease(rls);
-  
+
   CFDataRef address = CFDataCreateWithBytesNoCopy(alloc, (const UInt8*) socket->m_peer->m_addr, socket->m_peer->m_len , kCFAllocatorNull);
   if ( !address )
     return GSOCK_MEMERR ;
-    
+
   err = CFSocketConnectToAddress( socket->m_cfSocket , address, socket->m_non_blocking ? -1 : socket->m_timeout / 1000  ) ;
   CFRelease(address);
-  
+
   if (err != kCFSocketSuccess)
   {
     if ( err == kCFSocketTimeout )
-    {  
+    {
       GSocket_close(socket);
       socket->m_error = GSOCK_TIMEDOUT ;
       return GSOCK_TIMEDOUT ;
     }
+
     // we don't know whether a connect in progress will be issued like this
     if ( err != kCFSocketTimeout && socket->m_non_blocking )
     {
-      socket->m_establishing = TRUE;
+      socket->m_establishing = true;
       socket->m_error = GSOCK_WOULDBLOCK;
       return GSOCK_WOULDBLOCK;
     }
-    
+
     GSocket_close(socket);
     socket->m_error = GSOCK_IOERR;
     return GSOCK_IOERR;
@@ -2031,37 +2042,38 @@ GSocketError GSocket_Connect(GSocket *socket, GSocketStream stream)
 /* Flags */
 
 /* GSocket_SetNonBlocking:
- *  Sets the socket to non-blocking mode. All IO calls will return
- *  immediately.
+ *  Sets the socket to non-blocking mode.
+ *  All IO calls will return immediately.
  */
 void GSocket_SetNonBlocking(GSocket *socket, int non_block)
 {
-  assert(socket != NULL);
+  assert( socket != NULL );
 
 //  GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
 
   socket->m_non_blocking = non_block;
 }
 
-/* GSocket_SetTimeout:
+/*
+ *  GSocket_SetTimeout:
  *  Sets the timeout for blocking calls. Time is expressed in
  *  milliseconds.
  */
 void GSocket_SetTimeout(GSocket *socket, unsigned long millisec)
 {
-  assert(socket != NULL);
+  assert( socket != NULL );
 
   socket->m_timeout = millisec;
 }
 
 /* GSocket_GetError:
- *  Returns the last error occured for this socket. Note that successful
+ *  Returns the last error which occurred for this socket. Note that successful
  *  operations do not clear this back to GSOCK_NOERROR, so use it only
  *  after an error.
  */
 GSocketError GSocket_GetError(GSocket *socket)
 {
-  assert(socket != NULL);
+  assert( socket != NULL );
 
   return socket->m_error;
 }
@@ -2073,14 +2085,14 @@ GSocketError GSocket_GetError(GSocket *socket)
  *   operation, there is still data available, the callback function will
  *   be called again.
  * GSOCK_OUTPUT:
- *   The socket is available for writing. That is, the next write call 
+ *   The socket is available for writing. That is, the next write call
  *   won't block. This event is generated only once, when the connection is
  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
  *   when the output buffer empties again. This means that the app should
  *   assume that it can write since the first OUTPUT event, and no more
  *   OUTPUT events will be generated unless an error occurs.
  * GSOCK_CONNECTION:
- *   Connection succesfully established, for client sockets, or incoming
+ *   Connection successfully established, for client sockets, or incoming
  *   client connection, for server sockets. Wait for this event (also watch
  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
  * GSOCK_LOST:
@@ -2101,7 +2113,7 @@ void GSocket_SetCallback(GSocket *socket, GSocketEventFlags flags,
 {
   int count;
 
-  assert(socket != NULL);
+  assert( socket != NULL );
 
   for (count = 0; count < GSOCK_MAX_EVENT; count++)
   {
@@ -2146,21 +2158,25 @@ void _GSocket_Install_Callback(GSocket *socket, GSocketEvent event)
     switch (event)
     {
      case GSOCK_CONNECTION:
-         if(socket->m_server)
+         if (socket->m_server)
             c = kCFSocketReadCallBack;
          else
             c = kCFSocketConnectCallBack;
          break;
+
      case GSOCK_LOST:
      case GSOCK_INPUT:
          c = kCFSocketReadCallBack;
          break;
+
      case GSOCK_OUTPUT:
          c = kCFSocketWriteCallBack;
          break;
+
      default:
          c = 0;
     }
+
     CFSocketEnableCallBacks(socket->m_cfSocket, c);
 }
 
@@ -2170,21 +2186,26 @@ void _GSocket_Uninstall_Callback(GSocket *socket, GSocketEvent event)
     switch (event)
     {
      case GSOCK_CONNECTION:
-         if(socket->m_server)
+         if (socket->m_server)
             c = kCFSocketReadCallBack;
          else
             c = kCFSocketConnectCallBack;
          break;
+
      case GSOCK_LOST:
      case GSOCK_INPUT:
          c = kCFSocketReadCallBack;
          break;
+
      case GSOCK_OUTPUT:
          c = kCFSocketWriteCallBack;
          break;
+
      default:
          c = 0;
+         break;
     }
+
     CFSocketDisableCallBacks(socket->m_cfSocket, c);
 }
 
@@ -2219,14 +2240,17 @@ void wxMacCFSocketCallback(CFSocketRef s, CFSocketCallBackType callbackType,
         CALL_CALLBACK( socket , GSOCK_CONNECTION ) ;
       }
       break;
+
     case kCFSocketReadCallBack:
       CALL_CALLBACK( socket , GSOCK_INPUT ) ;
       break;
+
     case kCFSocketWriteCallBack:
       CALL_CALLBACK( socket , GSOCK_OUTPUT ) ;
       break;
+
     default:
-      break;  /* We shouldn't get here. */
+      break;  // We shouldn't get here.
   }
 }
 
@@ -2242,17 +2266,19 @@ int GSocket_Read(GSocket *socket, char *buffer, int size)
 }
 
 int GSocket_Write(GSocket *socket, const char *buffer, int size)
-{                        
+{
   int ret;
 
   assert(socket != NULL);
   ret = CFWriteStreamWrite( socket->m_writeStream , (UInt8*) buffer , size ) ;
+
   return ret;
 }
 
 GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
 {
-  assert(socket != NULL);
+  assert( socket != NULL );
+
   return flags & socket->m_detected;
 }
 
@@ -2266,7 +2292,7 @@ public:
     virtual bool OnInit()
     {
         // wxSocketBase will call GSocket_Init() itself when/if needed
-        return TRUE;
+        return true;
     }
 
     virtual void OnExit()
@@ -2283,4 +2309,3 @@ IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
 
 #endif
   // wxUSE_SOCKETS
-