fixed wrong assert

[wxWidgets.git] / src / common / sckint.cpp

diff --git a/src/common/sckint.cpp b/src/common/sckint.cpp
index d9a5a17580a785af72335d274b8331f9fd2a6a6f..6483df8ee864508b200fb6ec3dd2705a10c17611 100644 (file)
--- a/src/common/sckint.cpp
+++ b/src/common/sckint.cpp
@@ -1,10 +1,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:       socket.cpp
-// Purpose:    Socket handler classes
-// Authors:    Guilhem Lavaux (completely rewritten from a basic API of Andrew
-//             Davidson(1995) in wxWeb)
-// Created:    April 1997
-// Updated:    April 1999
+// Name:       sckint.cpp
+// Purpose:    Socket internal classes
+// Authors:    Guilhem Lavaux
+// Created:    April 1999
+// Updated:

 // Copyright:  (C) 1999, 1998, 1997, Guilhem Lavaux
 // RCS_ID:     $Id$
 // License:    see wxWindows license
 // Copyright:  (C) 1999, 1998, 1997, Guilhem Lavaux
 // RCS_ID:     $Id$
 // License:    see wxWindows license


@@ -23,11 +22,18 @@
 #if wxUSE_SOCKETS
 
 #define WXSOCK_INTERNAL
 #if wxUSE_SOCKETS
 
 #define WXSOCK_INTERNAL

-#include <wx/object.h>
-#include <wx/list.h>
-#include <wx/socket.h>
-#include <wx/thread.h>
-#include <wx/sckint.h>
+#include "wx/object.h"
+#include "wx/list.h"
+#include "wx/socket.h"
+#include "wx/thread.h"
+#include "wx/sckint.h"
+#include "wx/sckint.h"
+#include "wx/utils.h"
+
+// IRIX requires bstring.h be included to use select()
+#ifdef sgi
+    #include <bstring.h>
+#endif // IRIX

 
 #ifndef __WXSTUBS__
 
 
 #ifndef __WXSTUBS__
 


@@ -84,9 +90,11 @@
 // --------- SocketWaiter ---------------------------------------
 // --------------------------------------------------------------
 
 // --------- SocketWaiter ---------------------------------------
 // --------------------------------------------------------------
 

+#if wxUSE_THREADS

 SocketWaiter::SocketWaiter(wxSocketBase *socket,
                                 wxSocketInternal *internal)
 SocketWaiter::SocketWaiter(wxSocketBase *socket,
                                 wxSocketInternal *internal)

-  : m_socket(socket), m_internal(internal), m_fd(internal->GetFD())
+  : wxThread(), 
+    m_socket(socket), m_internal(internal), m_fd(internal->GetFD())

 {
 }
 
 {
 }
 


@@ -99,7 +107,9 @@ void SocketWaiter::ProcessReadEvent()
   int ret;
   char c;
 
   int ret;
   char c;
 

+  m_internal->AcquireFD();

   ret = recv(m_fd, &c, 1, MSG_PEEK);
   ret = recv(m_fd, &c, 1, MSG_PEEK);

+  m_internal->ReleaseFD();

   
   // We are a server => emit a EVT_ACCEPT event.
   if (ret == -1 && m_socket->GetType() == wxSocketBase::SOCK_SERVER) {
   
   // We are a server => emit a EVT_ACCEPT event.
   if (ret == -1 && m_socket->GetType() == wxSocketBase::SOCK_SERVER) {


@@ -109,10 +119,11 @@ void SocketWaiter::ProcessReadEvent()
   
   // Else, no error => there is something to be read else
   // we've lost the connection.
   
   // Else, no error => there is something to be read else
   // we've lost the connection.

-  if (ret > 0)
+  if (ret > 0) {

     m_socket->OnRequest(wxSocketBase::EVT_READ);
     m_socket->OnRequest(wxSocketBase::EVT_READ);

-  else {
+  } else {

     m_socket->OnRequest(wxSocketBase::EVT_LOST);
     m_socket->OnRequest(wxSocketBase::EVT_LOST);

+    m_internal->ReleaseData();  // In that case, we mustn't forget to unlock the mutex.

     Exit(NULL);
   }
 }
     Exit(NULL);
   }
 }


@@ -139,14 +150,16 @@ void *SocketWaiter::Entry()
 
     FD_ZERO(&sockrd_set);
     FD_ZERO(&sockwr_set);
 
     FD_ZERO(&sockrd_set);
     FD_ZERO(&sockwr_set);

-    
+
+    m_internal->AcquireData();
+

     if ((m_socket->NeededReq() & READ_MASK) != 0)
       FD_SET(m_fd, &sockrd_set);
     if ((m_socket->NeededReq() & WRITE_MASK) != 0)
       FD_SET(m_fd, &sockwr_set);
 
     m_internal->AcquireFD();
     if ((m_socket->NeededReq() & READ_MASK) != 0)
       FD_SET(m_fd, &sockrd_set);
     if ((m_socket->NeededReq() & WRITE_MASK) != 0)
       FD_SET(m_fd, &sockwr_set);
 
     m_internal->AcquireFD();

-    ret = select(FD_SETSIZE, &sockrd_set, &sockwr_set, NULL, &tv);
+    ret = select(m_fd+1, &sockrd_set, &sockwr_set, NULL, &tv);

     m_internal->ReleaseFD();
 
     if (FD_ISSET(m_fd, &sockrd_set))
     m_internal->ReleaseFD();
 
     if (FD_ISSET(m_fd, &sockrd_set))


@@ -155,16 +168,21 @@ void *SocketWaiter::Entry()
     if (FD_ISSET(m_fd, &sockwr_set))
       ProcessWriteEvent();
 
     if (FD_ISSET(m_fd, &sockwr_set))
       ProcessWriteEvent();
 

-    if (ret == 0)
-      // If nothing happened, we wait for 100 ms.
-      wxThread::Sleep(10);
-    else
-      wxThread::Yield();
+    m_internal->ReleaseData();
+
+#if wxUSE_THREADS
+#ifdef Yield
+#undef Yield
+#endif
+#endif
+
+   // We wait for 100 ms to prevent the CPU from burning.
+   wxUsleep(100);

 
     // Check whether we should exit.
     if (TestDestroy())
       return NULL;
 
     // Check whether we should exit.
     if (TestDestroy())
       return NULL;

- }
+  }

   return NULL;
 }
 
   return NULL;
 }
 


@@ -174,7 +192,11 @@ void *SocketWaiter::Entry()
 
 SocketRequester::SocketRequester(wxSocketBase *socket,
                                 wxSocketInternal *internal)
 
 SocketRequester::SocketRequester(wxSocketBase *socket,
                                 wxSocketInternal *internal)

-  : m_socket(socket), m_internal(internal), m_fd(internal->GetFD())
+  :
+#if wxUSE_THREADS
+    wxThread(),
+#endif
+    m_socket(socket), m_internal(internal), m_fd(internal->GetFD())

 {
 }
 
 {
 }
 


@@ -192,15 +214,15 @@ bool SocketRequester::WaitFor(wxSocketBase::wxRequestNotify req, int millisec)
   tv.tv_sec = millisec / 1000;
   tv.tv_usec = (millisec % 1000) * 1000;
 
   tv.tv_sec = millisec / 1000;
   tv.tv_usec = (millisec % 1000) * 1000;
 

-  if ((req & READ_MASK) != 0)  
-    FD_ZERO(&sockrd_set);
+  FD_ZERO(&sockrd_set);

   FD_ZERO(&sockwr_set);
   FD_ZERO(&sockwr_set);

-
-  FD_SET(m_fd, &sockrd_set);
-  FD_SET(m_fd, &sockwr_set);
+  if ((req & READ_MASK) != 0)  
+    FD_SET(m_fd, &sockrd_set);
+  if ((req & WRITE_MASK) != 0)
+    FD_SET(m_fd, &sockwr_set);

   
   m_internal->AcquireFD();
   
   m_internal->AcquireFD();

-  ret = select(FD_SETSIZE, &sockrd_set, &sockwr_set, NULL, &tv);
+  ret = select(m_fd+1, &sockrd_set, &sockwr_set, NULL, &tv);

   m_internal->ReleaseFD();
 
   return (ret != 0);
   m_internal->ReleaseFD();
 
   return (ret != 0);


@@ -235,6 +257,9 @@ void SocketRequester::ProcessReadEvent(SockRequest *req)
     req->size -= len;
     req->io_nbytes += len;
     req->buffer += len;
     req->size -= len;
     req->io_nbytes += len;
     req->buffer += len;

+
+    if (len == 0)
+      m_internal->EndRequest(req); 

     return;
   }
   // The End.
     return;
   }
   // The End.


@@ -247,6 +272,11 @@ void SocketRequester::ProcessWriteEvent(SockRequest *req)
   int ret;
   size_t len;
 
   int ret;
   size_t len;
 

+  if (!WaitFor(wxSocketBase::REQ_WRITE, req->timeout)) {
+    m_internal->EndRequest(req);
+    return;
+  }
+

   m_internal->AcquireFD();
   ret = send(m_fd, req->buffer, req->size, 0);
   m_internal->ReleaseFD();
   m_internal->AcquireFD();
   ret = send(m_fd, req->buffer, req->size, 0);
   m_internal->ReleaseFD();


@@ -281,11 +311,18 @@ void *SocketRequester::Entry()
 {
   SockRequest *req;
 
 {
   SockRequest *req;
 

+  m_internal->m_request_locker.Lock();

   while (1) {
     // Wait for a new request or a destroy message.
     req = m_internal->WaitForReq();
   while (1) {
     // Wait for a new request or a destroy message.
     req = m_internal->WaitForReq();

-    if (TestDestroy() || req == NULL)
+    m_internal->m_end_requester.Lock();
+    if (req == NULL) {
+      m_internal->m_invalid_requester = TRUE;
+      m_internal->m_end_requester.Unlock();
+      m_internal->m_request_locker.Unlock();

       return NULL;
       return NULL;

+    }
+    m_internal->m_end_requester.Unlock();

 
     if ((req->type & wxSocketBase::REQ_WAIT) != 0) {
       ProcessWaitEvent(req);
 
     if ((req->type & wxSocketBase::REQ_WAIT) != 0) {
       ProcessWaitEvent(req);


@@ -304,6 +341,7 @@ void *SocketRequester::Entry()
   }
   return NULL;
 }
   }
   return NULL;
 }

+#endif

 
 // --------------------------------------------------------------
 // --------- wxSocketInternal -----------------------------------
 
 // --------------------------------------------------------------
 // --------- wxSocketInternal -----------------------------------


@@ -312,17 +350,17 @@ void *SocketRequester::Entry()
 wxSocketInternal::wxSocketInternal(wxSocketBase *socket)
 {
   m_socket = socket;
 wxSocketInternal::wxSocketInternal(wxSocketBase *socket)
 {
   m_socket = socket;

-  m_thread_waiter = new SocketWaiter(socket, this);
-  m_thread_requester = new SocketRequester(socket, this);
-  m_request_locker.Lock();
+  m_thread_requester = NULL;
+  m_thread_waiter = NULL;
+  m_invalid_requester = TRUE;

 }
 
 wxSocketInternal::~wxSocketInternal()
 {
 }
 
 wxSocketInternal::~wxSocketInternal()
 {

-//  wxASSERT(!m_finalized); there is no m_finalized anywhere, RR
-  m_request_locker.Unlock();
-  delete m_thread_waiter;
-  delete m_thread_requester;
+  StopRequester();
+  wxASSERT(m_thread_requester == NULL);
+  StopWaiter();
+  wxASSERT(m_thread_waiter == NULL);

 }
 
 // ----------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------


@@ -331,18 +369,24 @@ wxSocketInternal::~wxSocketInternal()
 // ----------------------------------------------------------------------
 SockRequest *wxSocketInternal::WaitForReq()
 {
 // ----------------------------------------------------------------------
 SockRequest *wxSocketInternal::WaitForReq()
 {

+#if wxUSE_THREADS

   wxNode *node;
 
   wxNode *node;
 

+  // First try.

   node = m_requests.First();
   if (node == NULL) {
   node = m_requests.First();
   if (node == NULL) {

-    m_socket_cond.Wait(m_request_locker);
+    m_socket_cond.Wait(m_request_locker, 10, 0);

 
 

+    // Second try, if it is unsuccessul we give up.

     node = m_requests.First();
     if (node == NULL)
       return NULL;
   }
 
   return (SockRequest *)node->Data();
     node = m_requests.First();
     if (node == NULL)
       return NULL;
   }
 
   return (SockRequest *)node->Data();

+#else
+  return NULL;
+#endif

 }
 
 // ----------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------


@@ -359,88 +403,136 @@ void wxSocketInternal::EndRequest(SockRequest *req)
     delete node;
 }
 
     delete node;
 }
 

+void wxSocketInternal::AcquireData()
+{
+#if wxUSE_THREADS
+  m_socket_locker.Lock();
+#endif
+}
+
+void wxSocketInternal::ReleaseData()
+{
+#if wxUSE_THREADS
+  m_socket_locker.Unlock();
+#endif
+}
+

 void wxSocketInternal::AcquireFD()
 {
 void wxSocketInternal::AcquireFD()
 {

+#if wxUSE_THREADS

   m_fd_locker.Lock();
   m_fd_locker.Lock();

+#endif

 }
 
 void wxSocketInternal::ReleaseFD()
 {
 }
 
 void wxSocketInternal::ReleaseFD()
 {

+#if wxUSE_THREADS

   m_fd_locker.Unlock();
   m_fd_locker.Unlock();

+#endif

 }
 
 }
 

-// ----------------------------------------------------------------------
-// InitializeSocket: called by wxSocketBase to initialize the daemons with
-// a new file descriptor and to create them
-// ----------------------------------------------------------------------
-void wxSocketInternal::InitializeSocket()
+void wxSocketInternal::ResumeRequester()

 {
 {

-  wxASSERT( ((m_thread_waiter->IsAlive() && !m_thread_waiter->IsPaused()) ||
-            (m_thread_requester->IsAlive() && !m_thread_requester->IsPaused())));
+#if wxUSE_THREADS
+  wxThreadError err;

 
 

-  m_thread_waiter->m_fd = m_socket->m_fd;
-  m_thread_requester->m_fd = m_socket->m_fd;
+  wxASSERT(m_invalid_requester);

 
 

-  if (m_thread_waiter->IsPaused())
-    ResumeSocket();
-  else {
+  m_end_requester.Lock();

 
 

-    if (m_thread_waiter->Create() != wxTHREAD_NO_ERROR) {
-      // Something should be done here.
-      return;
-    }
-    
-    if (m_thread_requester->Create() != wxTHREAD_NO_ERROR) {
-      // Something should be done here.
-      return;
-    }
- 
-    m_thread_waiter->Run();
-    m_thread_requester->Run();
+  if (m_thread_requester != NULL) {
+    m_thread_requester->Delete(); // We must join it.
+    delete m_thread_requester;

   }
   }

-}

 
 

+  m_invalid_requester = FALSE;

 
 

-// ----------------------------------------------------------------------
-// InitializeSocket: called by wxSocketBase to destroy daemons
-// ----------------------------------------------------------------------
-void wxSocketInternal::FinalizeSocket()
-{
-  wxASSERT( (!m_thread_waiter->IsAlive() && !m_thread_requester->IsAlive()) );
+  m_end_requester.Unlock();

 
 

-  ResumeSocket();
+  m_thread_requester = new SocketRequester(m_socket, this);

 
 

-  m_thread_waiter->Delete();
-  m_socket_locker.Lock();
-  if (m_requests.Number() == 0)
-    m_socket_cond.Signal();
-  m_socket_locker.Unlock();
+  err = m_thread_requester->Create();
+  wxASSERT(err == wxTHREAD_NO_ERROR);

 
 

-  m_thread_requester->Delete();
+  err = m_thread_requester->Run();
+  wxASSERT(err == wxTHREAD_NO_ERROR);
+#else
+  if (!m_invalid_requester) 
+    return;
+  m_thread_requester = new SocketRequester(m_socket, this);
+  m_invalid_requester = FALSE;
+#endif

 }
 
 }
 

-void wxSocketInternal::PauseSocket()
+void wxSocketInternal::StopRequester()

 {
 {

-  if (m_thread_waiter != NULL && !m_thread_waiter->IsPaused())
-    m_thread_waiter->Pause();
-}
+#if wxUSE_THREADS
+  m_end_requester.Lock();
+  if (m_invalid_requester) {
+    m_end_requester.Unlock();
+    if (m_thread_requester) {
+      m_thread_requester->Delete();
+      delete m_thread_requester;
+      m_thread_requester = NULL;
+    }
+    m_invalid_requester = TRUE;
+    return;
+  }
+  m_end_requester.Unlock();

 
 

-void wxSocketInternal::ResumeSocket()
-{
-  if (m_thread_waiter != NULL && m_thread_waiter->IsPaused())
-    m_thread_waiter->Resume();
+  wxASSERT(m_thread_requester != NULL);
+
+  m_request_locker.Lock();
+
+  // Send a signal to the requester.
+  m_socket_cond.Signal();
+
+  m_request_locker.Unlock();
+
+  // Finish the destruction of the requester.
+  m_thread_requester->Delete();
+
+  delete m_thread_requester;
+  m_thread_requester = NULL;
+  m_invalid_requester = TRUE;
+#else
+  delete m_thread_requester;
+  m_thread_requester = NULL;
+  m_invalid_requester = TRUE;
+#endif

 }
 
 }
 

-void wxSocketInternal::EnableWaiter()
+void wxSocketInternal::ResumeWaiter()

 {
 {

-  if (m_thread_waiter != NULL && m_thread_waiter->IsPaused())
-    m_thread_waiter->Resume();
+#if wxUSE_THREADS
+  wxThreadError err;
+
+  if (m_thread_waiter != NULL)
+    return;
+
+  m_thread_waiter = new SocketWaiter(m_socket, this);
+
+  m_thread_waiter->SetPriority(WXTHREAD_MIN_PRIORITY);
+
+  err = m_thread_waiter->Create();
+  wxASSERT(err == wxTHREAD_NO_ERROR);
+
+  err = m_thread_waiter->Run();
+  wxASSERT(err == wxTHREAD_NO_ERROR);
+#endif

 }
 
 }
 

-void wxSocketInternal::DisableWaiter()
+void wxSocketInternal::StopWaiter()

 {
 {

-  if (m_thread_waiter != NULL && !m_thread_waiter->IsPaused())
-    m_thread_waiter->Pause();
+#if wxUSE_THREADS
+  if (m_thread_waiter == NULL)
+    return;
+
+  m_thread_waiter->Delete();
+
+  delete m_thread_waiter;
+  m_thread_waiter = NULL;
+#endif

 }
 
 // ----------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------


@@ -448,14 +540,19 @@ void wxSocketInternal::DisableWaiter()
 // ----------------------------------------------------------------------
 void wxSocketInternal::QueueRequest(SockRequest *request, bool async)
 {
 // ----------------------------------------------------------------------
 void wxSocketInternal::QueueRequest(SockRequest *request, bool async)
 {

+  if (m_invalid_requester)
+    ResumeRequester();
+
+#if wxUSE_THREADS

   if (async) {
   if (async) {

+

     m_request_locker.Lock();
     request->done = FALSE;
     m_requests.Append((wxObject *)request);
     m_request_locker.Lock();
     request->done = FALSE;
     m_requests.Append((wxObject *)request);

+    m_socket_cond.Signal();

     m_request_locker.Unlock();
     
     // Wake up
     m_request_locker.Unlock();
     
     // Wake up

-    m_socket_cond.Signal();

     
     if (request->wait) {
       if (wxThread::IsMain())
     
     if (request->wait) {
       if (wxThread::IsMain())


@@ -467,9 +564,9 @@ void wxSocketInternal::QueueRequest(SockRequest *request, bool async)
           wxThread::Yield();
         }
     }
           wxThread::Yield();
         }
     }

-

   } else {
     m_request_locker.Lock();
   } else {
     m_request_locker.Lock();

+#endif

 
     if ((request->type & wxSocketBase::REQ_WAIT) != 0) {
       m_thread_requester->ProcessWaitEvent(request);
 
     if ((request->type & wxSocketBase::REQ_WAIT) != 0) {
       m_thread_requester->ProcessWaitEvent(request);


@@ -488,13 +585,17 @@ void wxSocketInternal::QueueRequest(SockRequest *request, bool async)
       }
     }
     request->done = TRUE;
       }
     }
     request->done = TRUE;

+#if wxUSE_THREADS

     m_request_locker.Unlock();
   }
     m_request_locker.Unlock();
   }

+#endif

 }
 
 void wxSocketInternal::WaitForEnd(SockRequest *request)
 {
 }
 
 void wxSocketInternal::WaitForEnd(SockRequest *request)
 {

+#if wxUSE_THREADS

   // TODOTODO
   // TODOTODO

+#endif

 }
 
 #endif
 }
 
 #endif