2004-07-04 17:41:17 +02:00
|
|
|
|
2008-06-16 20:19:35 +02:00
|
|
|
#include "precompiled.h"
|
2003-11-25 03:11:50 +01:00
|
|
|
#include "Network.h"
|
|
|
|
#include "Serialization.h"
|
2006-06-02 05:56:24 +02:00
|
|
|
#include "ps/CLogger.h"
|
2005-02-21 18:13:31 +01:00
|
|
|
#include "NetLog.h"
|
2004-08-16 17:19:17 +02:00
|
|
|
|
2007-01-01 22:25:47 +01:00
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
DEFINE_ERROR(CONFLICTING_OP_IN_PROGRESS, "A conflicting operation is already in progress");
|
|
|
|
|
2004-08-16 17:19:17 +02:00
|
|
|
#define LOG_CAT_NET "net"
|
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
/**
|
|
|
|
* The SNetHeader will always be stored in host-order
|
|
|
|
*/
|
|
|
|
struct SNetHeader
|
|
|
|
{
|
|
|
|
u8 m_MsgType;
|
|
|
|
u16 m_MsgLength;
|
|
|
|
|
2004-03-08 03:06:06 +01:00
|
|
|
inline const u8 *Deserialize(const u8 *pos)
|
2003-11-25 03:11:50 +01:00
|
|
|
{
|
2003-11-30 17:54:11 +01:00
|
|
|
Deserialize_int_1(pos, m_MsgType);
|
|
|
|
Deserialize_int_2(pos, m_MsgLength);
|
|
|
|
return pos;
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
|
2004-03-08 03:06:06 +01:00
|
|
|
inline u8 *Serialize(u8 *pos) const
|
2003-11-25 03:11:50 +01:00
|
|
|
{
|
2003-11-30 17:54:11 +01:00
|
|
|
Serialize_int_1(pos, m_MsgType);
|
|
|
|
Serialize_int_2(pos, m_MsgLength);
|
2003-11-25 03:11:50 +01:00
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
#define HEADER_LENGTH 3
|
|
|
|
|
|
|
|
CMessagePipe::CMessagePipe()
|
|
|
|
{
|
|
|
|
m_Ends[0]=End(this, &m_Queues[0], &m_Queues[1]);
|
|
|
|
m_Ends[1]=End(this, &m_Queues[1], &m_Queues[0]);
|
|
|
|
// pthread_cond_init(&m_CondVar, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CMessagePipe::End::Push(CNetMessage *msg)
|
|
|
|
{
|
|
|
|
m_pOut->Lock();
|
|
|
|
m_pOut->push_back(msg);
|
|
|
|
m_pOut->Unlock();
|
|
|
|
/*pthread_mutex_lock(&m_pPipe->m_CondMutex);
|
|
|
|
pthread_cond_broadcast(&m_pPipe->m_CondVar);
|
|
|
|
pthread_mutex_unlock(&m_pPipe->m_CondMutex);*/
|
|
|
|
}
|
|
|
|
|
|
|
|
CNetMessage *CMessagePipe::End::TryPop()
|
|
|
|
{
|
|
|
|
CScopeLock lock(m_pIn->m_Mutex);
|
|
|
|
if (m_pIn->size())
|
|
|
|
{
|
|
|
|
CNetMessage *msg=m_pIn->front();
|
|
|
|
m_pIn->pop_front();
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*void CMessagePipe::End::WaitPop(CNetMessage *msg)
|
|
|
|
{
|
|
|
|
while (!TryPop(msg))
|
|
|
|
{
|
|
|
|
pthread_mutex_lock(&m_pPipe->m_CondMutex);
|
|
|
|
pthread_cond_wait(&m_pPipe->m_CondVar, &m_pPipe->m_CondMutex);
|
|
|
|
pthread_mutex_unlock(&m_pPipe->m_CondMutex);
|
|
|
|
}
|
|
|
|
}*/
|
|
|
|
|
2008-06-16 20:19:35 +02:00
|
|
|
/*CStr CErrorMessage::GetString() const
|
2004-03-08 03:06:06 +01:00
|
|
|
{
|
|
|
|
static const char* const states[]={
|
|
|
|
"SS_UNCONNECTED",
|
|
|
|
"SS_CONNECT_STARTED",
|
|
|
|
"SS_CONNECTED",
|
|
|
|
"SS_CLOSED_LOCALLY"
|
|
|
|
};
|
|
|
|
|
|
|
|
return CStr("NetErrorMessage: ")+
|
|
|
|
m_Error+", Socket State "+states[m_State];
|
|
|
|
}
|
|
|
|
|
|
|
|
CStr CConnectCompleteMessage::GetString() const
|
|
|
|
{
|
|
|
|
return CStr("ConnectCompleteMessage");
|
|
|
|
}
|
|
|
|
|
|
|
|
CStr CCloseRequestMessage::GetString() const
|
|
|
|
{
|
|
|
|
return CStr("CloseRequestMessage");
|
2008-06-16 20:19:35 +02:00
|
|
|
}*/
|
|
|
|
|
|
|
|
CStr CErrorMessage::ToString( void ) const
|
|
|
|
{
|
|
|
|
static const char* const states[]=
|
|
|
|
{
|
|
|
|
"SS_UNCONNECTED",
|
|
|
|
"SS_CONNECT_STARTED",
|
|
|
|
"SS_CONNECTED",
|
|
|
|
"SS_CLOSED_LOCALLY"
|
|
|
|
};
|
|
|
|
|
|
|
|
return CStr("NetErrorMessage: ")+
|
|
|
|
m_Error+", Socket State "+states[m_State];
|
|
|
|
}
|
|
|
|
|
|
|
|
CStr CConnectCompleteMessage::ToString( void ) const
|
|
|
|
{
|
|
|
|
return CStr( "ConnectCompleteMessage" );
|
|
|
|
}
|
|
|
|
|
|
|
|
CStr CCloseRequestMessage::ToString( void ) const
|
|
|
|
{
|
|
|
|
return CStr( "CloseRequestMessage" );
|
2004-03-08 03:06:06 +01:00
|
|
|
}
|
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
void CMessageSocket::Push(CNetMessage *msg)
|
|
|
|
{
|
2008-06-16 20:19:35 +02:00
|
|
|
NET_LOG2( "CMessageSocket::Push(): %s", msg->ToString().c_str() );
|
2004-08-16 17:19:17 +02:00
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
m_OutQ.Lock();
|
|
|
|
m_OutQ.push_back(msg);
|
|
|
|
m_OutQ.Unlock();
|
|
|
|
StartWriteNextMessage();
|
|
|
|
}
|
|
|
|
|
|
|
|
CNetMessage *CMessageSocket::TryPop()
|
|
|
|
{
|
|
|
|
CScopeLock lock(m_InQ.m_Mutex);
|
|
|
|
if (m_InQ.size())
|
|
|
|
{
|
|
|
|
CNetMessage *msg=m_InQ.front();
|
|
|
|
m_InQ.pop_front();
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CMessageSocket::StartWriteNextMessage()
|
|
|
|
{
|
|
|
|
m_OutQ.Lock();
|
|
|
|
if (!m_IsWriting && m_OutQ.size())
|
|
|
|
{
|
2004-03-08 03:06:06 +01:00
|
|
|
CNetMessage *pMsg=NULL;
|
|
|
|
while (pMsg == NULL)
|
|
|
|
{
|
|
|
|
// This may happen when the last message of the queue is an invalid
|
|
|
|
// message type (non-network or socket command)
|
|
|
|
if (m_OutQ.size() == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Pop next output message
|
|
|
|
pMsg=m_OutQ.front();
|
|
|
|
m_OutQ.pop_front();
|
|
|
|
m_IsWriting=true;
|
|
|
|
m_OutQ.Unlock();
|
|
|
|
|
|
|
|
if (pMsg->GetType() == NMT_CLOSE_REQUEST)
|
|
|
|
{
|
|
|
|
Close();
|
|
|
|
delete pMsg;
|
|
|
|
pMsg=NULL;
|
|
|
|
}
|
|
|
|
else if (pMsg->GetType() < 0)
|
|
|
|
{
|
2007-12-29 17:22:23 +01:00
|
|
|
LOG(CLogger::Warning, LOG_CAT_NET, "CMessageSocket::StartWriteNextMessage(): Non-network message");
|
2004-03-08 03:06:06 +01:00
|
|
|
delete pMsg;
|
|
|
|
pMsg=NULL;
|
|
|
|
}
|
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
|
|
|
|
// Prepare the header
|
|
|
|
SNetHeader hdr;
|
|
|
|
hdr.m_MsgType=pMsg->GetType();
|
had to remove uint and ulong from lib/types.h due to conflict with other library.
this snowballed into a massive search+destroy of the hodgepodge of
mostly equivalent types we had in use (int, uint, unsigned, unsigned
int, i32, u32, ulong, uintN).
it is more efficient to use 64-bit types in 64-bit mode, so the
preferred default is size_t (for anything remotely resembling a size or
index). tile coordinates are ssize_t to allow more efficient conversion
to/from floating point. flags are int because we almost never need more
than 15 distinct bits, bit test/set is not slower and int is fastest to
type. finally, some data that is pretty much directly passed to OpenGL
is now typed accordingly.
after several hours, the code now requires fewer casts and less
guesswork.
other changes:
- unit and player IDs now have an "invalid id" constant in the
respective class to avoid casting and -1
- fix some endian/64-bit bugs in the map (un)packing. added a
convenience function to write/read a size_t.
- ia32: change CPUID interface to allow passing in ecx (required for
cache topology detection, which I need at work). remove some unneeded
functions from asm, replace with intrinsics where possible.
This was SVN commit r5942.
2008-05-11 20:48:32 +02:00
|
|
|
hdr.m_MsgLength=(u16)pMsg->GetSerializedLength();
|
2003-11-25 03:11:50 +01:00
|
|
|
|
|
|
|
// Allocate buffer space
|
had to remove uint and ulong from lib/types.h due to conflict with other library.
this snowballed into a massive search+destroy of the hodgepodge of
mostly equivalent types we had in use (int, uint, unsigned, unsigned
int, i32, u32, ulong, uintN).
it is more efficient to use 64-bit types in 64-bit mode, so the
preferred default is size_t (for anything remotely resembling a size or
index). tile coordinates are ssize_t to allow more efficient conversion
to/from floating point. flags are int because we almost never need more
than 15 distinct bits, bit test/set is not slower and int is fastest to
type. finally, some data that is pretty much directly passed to OpenGL
is now typed accordingly.
after several hours, the code now requires fewer casts and less
guesswork.
other changes:
- unit and player IDs now have an "invalid id" constant in the
respective class to avoid casting and -1
- fix some endian/64-bit bugs in the map (un)packing. added a
convenience function to write/read a size_t.
- ia32: change CPUID interface to allow passing in ecx (required for
cache topology detection, which I need at work). remove some unneeded
functions from asm, replace with intrinsics where possible.
This was SVN commit r5942.
2008-05-11 20:48:32 +02:00
|
|
|
if ((size_t)(hdr.m_MsgLength+HEADER_LENGTH) > m_WrBufferSize)
|
2003-11-25 03:11:50 +01:00
|
|
|
{
|
2008-06-16 20:19:35 +02:00
|
|
|
//m_WrBufferSize = BUFFER_SIZE(hdr.m_MsgLength+HEADER_LENGTH);
|
|
|
|
m_WrBufferSize = ALIGN_BLOCK(hdr.m_MsgLength+HEADER_LENGTH);
|
2003-11-25 03:11:50 +01:00
|
|
|
if (m_pWrBuffer)
|
|
|
|
m_pWrBuffer=(u8 *)realloc(m_pWrBuffer, m_WrBufferSize);
|
|
|
|
else
|
|
|
|
m_pWrBuffer=(u8 *)malloc(m_WrBufferSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fill in buffer
|
|
|
|
u8 *pos=m_pWrBuffer;
|
|
|
|
pos=hdr.Serialize(pos);
|
|
|
|
pMsg->Serialize(pos);
|
|
|
|
|
|
|
|
// Deallocate message
|
|
|
|
delete pMsg;
|
|
|
|
|
|
|
|
// Start Write Operation
|
2005-01-17 05:52:02 +01:00
|
|
|
//printf("CMessageSocket::StartWriteNextMessage(): Writing an MT %d, length %u (%u)\n", hdr.m_MsgType, hdr.m_MsgLength+HEADER_LENGTH, hdr.m_MsgLength);
|
2003-11-25 03:11:50 +01:00
|
|
|
PS_RESULT res=Write(m_pWrBuffer, hdr.m_MsgLength+HEADER_LENGTH);
|
|
|
|
if (res != PS_OK)
|
2004-03-08 03:06:06 +01:00
|
|
|
{
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG2( "CMessageSocket::StartWriteNextMessage(): %s", res );
|
|
|
|
|
2004-03-08 03:06:06 +01:00
|
|
|
// Queue Error Message
|
|
|
|
m_InQ.Lock();
|
2008-06-16 20:19:35 +02:00
|
|
|
m_InQ.push_back(new CErrorMessage(res, GetState()));
|
2004-03-08 03:06:06 +01:00
|
|
|
m_InQ.Unlock();
|
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (m_IsWriting)
|
2007-10-13 17:17:50 +02:00
|
|
|
{
|
|
|
|
NET_LOG( "CMessageSocket::StartWriteNextMessage(): Already writing" );
|
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
else
|
2007-10-13 17:17:50 +02:00
|
|
|
{
|
2005-02-21 18:13:31 +01:00
|
|
|
NET_LOG("CMessageSocket::StartWriteNextMessage(): Nothing to write");
|
2007-10-13 17:17:50 +02:00
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
m_OutQ.Unlock();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CMessageSocket::WriteComplete(PS_RESULT ec)
|
|
|
|
{
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG2( "CMessageSocket::WriteComplete(): %s", ec );
|
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
if (ec == PS_OK)
|
|
|
|
{
|
|
|
|
if (m_IsWriting)
|
|
|
|
{
|
|
|
|
m_OutQ.Lock();
|
|
|
|
m_IsWriting=false;
|
|
|
|
m_OutQ.Unlock();
|
|
|
|
StartWriteNextMessage();
|
|
|
|
}
|
|
|
|
else
|
2007-10-13 17:17:50 +02:00
|
|
|
{
|
|
|
|
NET_LOG( "CMessageSocket::WriteComplete(): Was not writing" );
|
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Push an error message
|
2008-06-16 20:19:35 +02:00
|
|
|
m_InQ.push_back(new CErrorMessage(ec, GetState()));
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CMessageSocket::StartReadHeader()
|
|
|
|
{
|
|
|
|
if (m_RdBufferSize < HEADER_LENGTH)
|
|
|
|
{
|
2008-06-16 20:19:35 +02:00
|
|
|
//m_RdBufferSize=BUFFER_SIZE(HEADER_LENGTH);
|
|
|
|
m_RdBufferSize=ALIGN_BLOCK(HEADER_LENGTH);
|
2003-11-25 03:11:50 +01:00
|
|
|
if (m_pRdBuffer)
|
|
|
|
m_pRdBuffer=(u8 *)realloc(m_pRdBuffer, m_RdBufferSize);
|
|
|
|
else
|
|
|
|
m_pRdBuffer=(u8 *)malloc(m_RdBufferSize);
|
|
|
|
}
|
|
|
|
m_ReadingData=false;
|
2008-06-16 20:19:35 +02:00
|
|
|
printf("CMessageSocket::StartReadHeader(): Trying to read %u\n", HEADER_LENGTH);
|
2003-11-25 03:11:50 +01:00
|
|
|
PS_RESULT res=Read(m_pRdBuffer, HEADER_LENGTH);
|
|
|
|
if (res != PS_OK)
|
2004-03-08 03:06:06 +01:00
|
|
|
{
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG2( "CMessageSocket::StartReadHeader(): %s", res );
|
|
|
|
|
2004-03-08 03:06:06 +01:00
|
|
|
// Push an error message
|
|
|
|
CScopeLock scopeLock(m_InQ.m_Mutex);
|
2008-06-16 20:19:35 +02:00
|
|
|
m_InQ.push_back(new CErrorMessage(res, GetState()));
|
2004-03-08 03:06:06 +01:00
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void CMessageSocket::StartReadMessage()
|
|
|
|
{
|
|
|
|
SNetHeader hdr;
|
|
|
|
hdr.Deserialize(m_pRdBuffer);
|
2004-08-16 17:19:17 +02:00
|
|
|
|
had to remove uint and ulong from lib/types.h due to conflict with other library.
this snowballed into a massive search+destroy of the hodgepodge of
mostly equivalent types we had in use (int, uint, unsigned, unsigned
int, i32, u32, ulong, uintN).
it is more efficient to use 64-bit types in 64-bit mode, so the
preferred default is size_t (for anything remotely resembling a size or
index). tile coordinates are ssize_t to allow more efficient conversion
to/from floating point. flags are int because we almost never need more
than 15 distinct bits, bit test/set is not slower and int is fastest to
type. finally, some data that is pretty much directly passed to OpenGL
is now typed accordingly.
after several hours, the code now requires fewer casts and less
guesswork.
other changes:
- unit and player IDs now have an "invalid id" constant in the
respective class to avoid casting and -1
- fix some endian/64-bit bugs in the map (un)packing. added a
convenience function to write/read a size_t.
- ia32: change CPUID interface to allow passing in ecx (required for
cache topology detection, which I need at work). remove some unneeded
functions from asm, replace with intrinsics where possible.
This was SVN commit r5942.
2008-05-11 20:48:32 +02:00
|
|
|
size_t reqBufSize=HEADER_LENGTH+hdr.m_MsgLength;
|
2003-11-25 03:11:50 +01:00
|
|
|
if (m_RdBufferSize < reqBufSize)
|
|
|
|
{
|
2008-06-16 20:19:35 +02:00
|
|
|
//m_RdBufferSize=BUFFER_SIZE(reqBufSize);
|
|
|
|
m_RdBufferSize=ALIGN_BLOCK(reqBufSize);
|
2003-11-25 03:11:50 +01:00
|
|
|
if (m_pRdBuffer)
|
|
|
|
m_pRdBuffer=(u8 *)realloc(m_pRdBuffer, m_RdBufferSize);
|
|
|
|
else
|
|
|
|
m_pRdBuffer=(u8 *)malloc(m_RdBufferSize);
|
|
|
|
}
|
|
|
|
m_ReadingData=true;
|
2007-10-23 08:52:23 +02:00
|
|
|
|
2004-08-16 17:19:17 +02:00
|
|
|
if (hdr.m_MsgLength == 0)
|
2004-03-08 03:06:06 +01:00
|
|
|
{
|
2004-08-16 17:19:17 +02:00
|
|
|
ReadComplete(PS_OK);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PS_RESULT res=Read(m_pRdBuffer+HEADER_LENGTH, hdr.m_MsgLength);
|
|
|
|
if (res != PS_OK)
|
|
|
|
{
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG2( "CMessageSocket::StartReadMessage(): %s", res );
|
|
|
|
|
2004-08-16 17:19:17 +02:00
|
|
|
// Queue an error message
|
|
|
|
CScopeLock scopeLock(m_InQ);
|
2008-06-16 20:19:35 +02:00
|
|
|
m_InQ.push_back(new CErrorMessage(res, GetState()));
|
2004-08-16 17:19:17 +02:00
|
|
|
}
|
2004-03-08 03:06:06 +01:00
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void CMessageSocket::ReadComplete(PS_RESULT ec)
|
|
|
|
{
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG3( "CMessageSocket::ReadComplete(%s): %s", m_ReadingData ? "data":"header", ec );
|
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
// Check if we were reading header or message
|
|
|
|
// If header:
|
|
|
|
if (!m_ReadingData)
|
|
|
|
{
|
|
|
|
StartReadMessage();
|
|
|
|
}
|
|
|
|
// If data:
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SNetHeader hdr;
|
|
|
|
hdr.Deserialize(m_pRdBuffer);
|
2008-06-16 20:19:35 +02:00
|
|
|
//CNetMessage *pMsg=CNetMessage::DeserializeMessage((ENetMessageType)hdr.m_MsgType, m_pRdBuffer+HEADER_LENGTH, hdr.m_MsgLength);
|
|
|
|
CNetMessage *pMsg = CNetMessageFactory::CreateMessage( m_pRdBuffer+HEADER_LENGTH, hdr.m_MsgLength);
|
2003-11-25 03:11:50 +01:00
|
|
|
if (pMsg)
|
|
|
|
{
|
2004-08-16 17:19:17 +02:00
|
|
|
OnMessage(pMsg);
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
2005-01-17 05:52:02 +01:00
|
|
|
else
|
|
|
|
{
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG3( "CMessageSocket::ReadComplete(): Deserialization failed! (type %d, length %d)", hdr.m_MsgType, hdr.m_MsgLength );
|
|
|
|
NET_LOG( "Data: {" );
|
|
|
|
|
2005-01-17 05:52:02 +01:00
|
|
|
for (int i=HEADER_LENGTH;i<hdr.m_MsgLength+HEADER_LENGTH;i++)
|
|
|
|
{
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG3( "\t0x%x [%c]", m_pRdBuffer[i], isalnum(m_pRdBuffer[i])?m_pRdBuffer[i]:'.' );
|
2005-01-17 05:52:02 +01:00
|
|
|
}
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG( "};" );
|
2005-01-17 05:52:02 +01:00
|
|
|
}
|
2003-11-25 03:11:50 +01:00
|
|
|
StartReadHeader();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-16 17:19:17 +02:00
|
|
|
void CMessageSocket::OnMessage(CNetMessage *pMsg)
|
|
|
|
{
|
|
|
|
m_InQ.Lock();
|
|
|
|
m_InQ.push_back(pMsg);
|
2008-06-16 20:19:35 +02:00
|
|
|
NET_LOG2( "CMessageSocket::OnMessage(): %s", pMsg->ToString().c_str() );
|
2007-10-13 17:17:50 +02:00
|
|
|
NET_LOG2( "CMessageSocket::OnMessage(): Queue size now %u", m_InQ.size() );
|
2004-08-16 17:19:17 +02:00
|
|
|
m_InQ.Unlock();
|
|
|
|
}
|
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
void CMessageSocket::ConnectComplete(PS_RESULT ec)
|
|
|
|
{
|
2004-03-08 03:06:06 +01:00
|
|
|
if (ec == PS_OK)
|
|
|
|
{
|
|
|
|
StartReadHeader();
|
|
|
|
CScopeLock scopeLock(m_InQ);
|
|
|
|
m_InQ.push_back(new CConnectCompleteMessage());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CScopeLock scopeLock(m_InQ);
|
2008-06-16 20:19:35 +02:00
|
|
|
m_InQ.push_back(new CErrorMessage(ec, GetState()));
|
2004-03-08 03:06:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CMessageSocket::OnClose(PS_RESULT errorCode)
|
|
|
|
{
|
|
|
|
CScopeLock scopeLock(m_InQ.m_Mutex);
|
2008-06-16 20:19:35 +02:00
|
|
|
m_InQ.push_back(new CErrorMessage(errorCode, GetState()));
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
|
2003-11-30 17:54:11 +01:00
|
|
|
CMessageSocket::CMessageSocket(CSocketInternal *pInt):
|
|
|
|
CStreamSocket(pInt),
|
|
|
|
m_IsWriting(false),
|
|
|
|
m_pWrBuffer(NULL),
|
|
|
|
m_WrBufferSize(0),
|
|
|
|
m_ReadingData(false),
|
|
|
|
m_pRdBuffer(NULL),
|
|
|
|
m_RdBufferSize(0)
|
|
|
|
{
|
|
|
|
StartReadHeader();
|
|
|
|
}
|
|
|
|
|
|
|
|
CMessageSocket::CMessageSocket():
|
|
|
|
m_IsWriting(false),
|
|
|
|
m_pWrBuffer(NULL),
|
|
|
|
m_WrBufferSize(0),
|
|
|
|
m_ReadingData(false),
|
|
|
|
m_pRdBuffer(NULL),
|
|
|
|
m_RdBufferSize(0)
|
2004-03-08 03:06:06 +01:00
|
|
|
{
|
|
|
|
}
|
2003-11-30 17:54:11 +01:00
|
|
|
|
2003-11-25 03:11:50 +01:00
|
|
|
CMessageSocket::~CMessageSocket()
|
|
|
|
{
|
2004-03-08 03:06:06 +01:00
|
|
|
if (m_pRdBuffer)
|
|
|
|
free(m_pRdBuffer);
|
|
|
|
if (m_pWrBuffer)
|
|
|
|
free(m_pWrBuffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
PS_RESULT CMessageSocket::BeginConnect(const char *address, int port)
|
|
|
|
{
|
2005-02-21 18:13:31 +01:00
|
|
|
StartReadHeader();
|
2004-03-08 03:06:06 +01:00
|
|
|
return CStreamSocket::BeginConnect(address, port);
|
2003-11-25 03:11:50 +01:00
|
|
|
}
|
|
|
|
|
2003-11-30 17:54:11 +01:00
|
|
|
// End of Network.cpp
|