///////////////////////////////////////////////////////////////////////////////
-// 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
// --------- SocketWaiter ---------------------------------------
// --------------------------------------------------------------
+#if wxUSE_THREADS
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())
{
}
int ret;
char c;
+ m_internal->AcquireFD();
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) {
// 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);
- else {
+ } else {
m_socket->OnRequest(wxSocketBase::EVT_LOST);
+ m_internal->ReleaseData(); // In that case, we mustn't forget to unlock the mutex.
Exit(NULL);
}
}
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();
- 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))
if (FD_ISSET(m_fd, &sockwr_set))
ProcessWriteEvent();
+ m_internal->ReleaseData();
+
#if wxUSE_THREADS
#ifdef Yield
#undef Yield
#endif
#endif
- if (ret == 0)
- // If nothing happened, we wait for 100 ms.
- wxUsleep(10);
+ // We wait for 100 ms to prevent the CPU from burning.
+ wxUsleep(100);
// Check whether we should exit.
- if (TestDestroy()) {
+ if (TestDestroy())
return NULL;
- }
}
return NULL;
}
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())
{
}
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_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();
- 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);
req->size -= len;
req->io_nbytes += len;
req->buffer += len;
+
+ if (len == 0)
+ m_internal->EndRequest(req);
return;
}
// The End.
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();
{
SockRequest *req;
+ m_internal->m_request_locker.Lock();
while (1) {
// Wait for a new request or a destroy message.
req = m_internal->WaitForReq();
m_internal->m_end_requester.Lock();
- if (TestDestroy() || req == NULL) {
+ if (req == NULL) {
m_internal->m_invalid_requester = TRUE;
m_internal->m_end_requester.Unlock();
+ m_internal->m_request_locker.Unlock();
return NULL;
}
m_internal->m_end_requester.Unlock();
}
return NULL;
}
+#endif
// --------------------------------------------------------------
// --------- wxSocketInternal -----------------------------------
m_thread_requester = NULL;
m_thread_waiter = NULL;
m_invalid_requester = TRUE;
- m_request_locker.Lock();
}
wxSocketInternal::~wxSocketInternal()
wxASSERT(m_thread_requester == NULL);
StopWaiter();
wxASSERT(m_thread_waiter == NULL);
- m_request_locker.Unlock();
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
SockRequest *wxSocketInternal::WaitForReq()
{
+#if wxUSE_THREADS
wxNode *node;
+ // First try.
node = m_requests.First();
if (node == NULL) {
- m_socket_cond.Wait(m_request_locker, 1, 0);
+ 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();
+#else
+ return NULL;
+#endif
}
// ----------------------------------------------------------------------
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()
{
+#if wxUSE_THREADS
m_fd_locker.Lock();
+#endif
}
void wxSocketInternal::ReleaseFD()
{
+#if wxUSE_THREADS
m_fd_locker.Unlock();
+#endif
}
void wxSocketInternal::ResumeRequester()
{
+#if wxUSE_THREADS
wxThreadError err;
- wxASSERT(m_thread_requester == NULL);
+ wxASSERT(m_invalid_requester);
m_end_requester.Lock();
- if (m_invalid_requester) {
+
+ if (m_thread_requester != NULL) {
+ m_thread_requester->Delete(); // We must join it.
delete m_thread_requester;
+ }
- m_thread_requester = new SocketRequester(m_socket, this);
- m_thread_requester->m_fd = m_socket->m_fd;
+ m_invalid_requester = FALSE;
- err = m_thread_requester->Create();
- wxASSERT(err == wxTHREAD_NO_ERROR);
+ m_end_requester.Unlock();
- err = m_thread_requester->Run();
- wxASSERT(err == wxTHREAD_NO_ERROR);
+ m_thread_requester = new SocketRequester(m_socket, this);
- m_invalid_requester = FALSE;
- }
- m_end_requester.Unlock();
+ err = m_thread_requester->Create();
+ wxASSERT(err == wxTHREAD_NO_ERROR);
+
+ 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::StopRequester()
{
+#if wxUSE_THREADS
+ m_end_requester.Lock();
if (m_invalid_requester) {
- delete m_thread_requester;
- m_thread_requester = NULL;
- m_invalid_requester = FALSE;
+ 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();
wxASSERT(m_thread_requester != NULL);
- m_socket_locker.Lock();
+ m_request_locker.Lock();
// Send a signal to the requester.
- if (m_requests.Number() == 0)
- m_socket_cond.Signal();
+ m_socket_cond.Signal();
- m_socket_locker.Unlock();
+ 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::ResumeWaiter()
{
+#if wxUSE_THREADS
wxThreadError err;
if (m_thread_waiter != NULL)
return;
m_thread_waiter = new SocketWaiter(m_socket, this);
- m_thread_waiter->m_fd = m_socket->m_fd;
+
+ 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::StopWaiter()
{
+#if wxUSE_THREADS
if (m_thread_waiter == NULL)
return;
delete m_thread_waiter;
m_thread_waiter = NULL;
+#endif
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
void wxSocketInternal::QueueRequest(SockRequest *request, bool async)
{
+ if (m_invalid_requester)
+ ResumeRequester();
+
+#if wxUSE_THREADS
if (async) {
- if (m_thread_requester == NULL)
- ResumeRequester();
m_request_locker.Lock();
request->done = FALSE;
}
} else {
m_request_locker.Lock();
+#endif
if ((request->type & wxSocketBase::REQ_WAIT) != 0) {
m_thread_requester->ProcessWaitEvent(request);
}
}
request->done = TRUE;
+#if wxUSE_THREADS
m_request_locker.Unlock();
}
+#endif
}
void wxSocketInternal::WaitForEnd(SockRequest *request)
{
+#if wxUSE_THREADS
// TODOTODO
+#endif
}
#endif
projects / wxWidgets.git / blobdiff