/**
* \brief 发送原始指令数据，不做封包动作
* \param pstrCmd 待发送的内容
* \param nCmdLen 待发送内容的大小
* \param buffer 是否需要缓冲
* \return 发送是否成功
*/
bool zSocket::sendCmdNoPack(const void *pstrCmd, const int nCmdLen, const bool buffer)
{
//Zebra::logger->trace("zSocket::sendCmdNoPack");
if (NULL == pstrCmd || nCmdLen <= 0)
return false;
bool retval = true;
if (buffer)
{
mutex.lock();
_snd_queue.put((unsigned char *)pstrCmd, nCmdLen);
_current_cmd = nCmdLen;
mutex.unlock();
}
else
{
if (need_enc())
{
t_StackCmdQueue _raw_queue;
_raw_queue.put((unsigned char *)pstrCmd, nCmdLen);
packetPackEnc(_raw_queue, _raw_queue.rd_size());
mutex.lock();
retval = sendRawDataIM(_raw_queue.rd_buf(), _raw_queue.rd_size());
mutex.unlock();
}
else
{
mutex.lock();
retval = sendRawDataIM(pstrCmd, nCmdLen);
mutex.unlock();
}
}
return retval;
}
/**
* \brief 发送指令
* \param pstrCmd 待发送的内容
* \param nCmdLen 待发送内容的大小
* \param buffer 是否需要缓冲
* \return 发送是否成功
*/
bool CSocket::sendCmd(const void *pstrCmd,const int nCmdLen,const bool buffer)
{
//Zebra::logger->debug("CSocket::sendCmd");
if (NULL == pstrCmd || nCmdLen <= 0)
return false;
bool retval = true;
// Zebra::logger->debug("期望目标：%s : %u", getIP(), getPort());
// Zebra::logger->debug16("希望发送：", (BYTE*)pstrCmd, nCmdLen);
if (buffer)
{
// 直接把数据加密压缩封包后放到发送缓冲_enc_queue
t_StackCmdQueue _raw_queue;
packetAppend(pstrCmd,nCmdLen,_raw_queue);
mutex.lock();
_enc_queue.put(_raw_queue.rd_buf(),_raw_queue.rd_size());
mutex.unlock();
}
else
{
t_StackCmdQueue _raw_queue;
packetAppend(pstrCmd,nCmdLen,_raw_queue);
mutex.lock();
retval = sendRawDataIM(_raw_queue.rd_buf(),_raw_queue.rd_size());
mutex.unlock();
}
return retval;
}
/**
* \brief 发送指令
* \param pstrCmd 待发送的内容
* \param nCmdLen 待发送内容的大小
* \param buffer 是否需要缓冲
* \return 发送是否成功
*/
bool zSocket::sendCmd(const void *pstrCmd, const int nCmdLen, const bool buffer)
{
//Zebra::logger->trace("zSocket::sendCmd");
if (NULL == pstrCmd || nCmdLen <= 0)
return false;
bool retval = true;
if (buffer)
{
t_StackCmdQueue _raw_queue;
packetAppendNoEnc(pstrCmd, nCmdLen, _raw_queue);
mutex.lock();
_snd_queue.put(_raw_queue.rd_buf(), _raw_queue.rd_size());
_current_cmd = _raw_queue.rd_size();
mutex.unlock();
}
else
{
t_StackCmdQueue _raw_queue;
packetAppend(pstrCmd, nCmdLen, _raw_queue);
mutex.lock();
retval = sendRawDataIM(_raw_queue.rd_buf(), _raw_queue.rd_size());
mutex.unlock();
}
return retval;
}
void Socket::forceSync()
{
CheckConditonVoid(m_sendQueue.rdReady());
m_mutex.lock();
sendRawDataIM(m_sendQueue.rdBuffer(),m_sendQueue.rdSize());
m_currentCmd = m_sendQueue.rdSize();
m_sendQueue.reset();
m_mutex.unlock();
return;
#if 0
DWORD size = 0,offset = 0;
m_mutex.lock();
if(m_bufferQueue.rdReady())
{
BUFFER_CMD(Cmd::DataSendCmd,send,s_maxDataSize + 4);
bcopy(m_bufferQueue.rdBuffer(),send->data,m_bufferQueue.rdSize());
send->dwSize = m_bufferQueue.rdSize();
m_bufferQueue.reset();
m_mutex.unlock();
StackCmdQueue rawQueue;
if(*(DWORD*)send->data + sizeof(s_packHeadLen) < send->datasize())
{
packetAppendNoEnc(send,send->allsize(),rawQueue);
m_mutex.lock();
m_sendQueue.put(rawQueue.rdBuffer(),rawQueue.rdSize());
m_currentCmd = rawQueue.rdSize();
}
else
{
m_mutex.lock();
m_sendQueue.put((const BYTE*)send->data,send->datasize());
m_currentCmd = send->datasize();
offset = m_encQueue.rdSize();
m_encQueue.put(m_sendQueue.rdBuffer(),size);
m_sendQueue.rdFlip(size);
m_currentCmd = 0;
}
}
m_mutex.unlock();
if(m_encQueue.rdReady())
{
sendRawDataIM(m_encQueue.rdBuffer(),m_encQueue.rdSize());
m_encQueue.reset();
}
#endif
}
void CSocket::force_sync()
{
//Zebra::logger->debug("CSocket::force_sync");
if (_enc_queue.rd_ready())
{
mutex.lock();
sendRawDataIM(_enc_queue.rd_buf(),_enc_queue.rd_size());
_enc_queue.reset();
mutex.unlock();
}
}
void zSocket::force_sync()
{
//Zebra::logger->trace("zSocket::force_sync");
if(need_enc())
{
unsigned int nSize = 0, current_cmd = 0, offset = 0;
mutex.lock();
if (_snd_queue.rd_ready())
{
nSize = _snd_queue.rd_size();
current_cmd = _current_cmd;
offset = _enc_queue.rd_size();
_enc_queue.put(_snd_queue.rd_buf(), nSize);
_snd_queue.rd_flip(nSize);
_current_cmd = 0;
}
mutex.unlock();
if (nSize)
packetPackEnc(_enc_queue, current_cmd, offset);
if (_enc_queue.rd_ready())
{
sendRawDataIM(_enc_queue.rd_buf(), _enc_queue.rd_size());
_enc_queue.reset();
}
}
else
{
mutex.lock();
if (_snd_queue.rd_ready())
{
_enc_queue.put(_snd_queue.rd_buf(), _snd_queue.rd_size());
_snd_queue.rd_flip(_snd_queue.rd_size());
}
mutex.unlock();
if (_enc_queue.rd_ready())
{
sendRawDataIM(_enc_queue.rd_buf(), _enc_queue.rd_size());
_enc_queue.reset();
}
}
}
bool Socket::sendCmdNoPack(const void *cmd,const DWORD cmdLen,const bool buffer)
{
LogCheckCondition(cmd && cmdLen,false,"套接字发送数据非法");
bool retval = false;
if(buffer)
{
m_mutex.lock();
m_sendQueue.put((BYTE*)cmd,cmdLen);
m_currentCmd = cmdLen;
m_mutex.unlock();
}
else
{
m_mutex.lock();
retval = sendRawDataIM(cmd,cmdLen);
m_mutex.unlock();
}
return retval;
}
/**
* \brief 发送原始指令数据,不做封包动作 [ranqd] 用于原始数据的转发
* \param pstrCmd 待发送的内容
* \param nCmdLen 待发送内容的大小
* \param buffer 是否需要缓冲
* \return 发送是否成功
*/
bool CSocket::sendCmdNoPack(const void *pstrCmd,const int nCmdLen,const bool buffer)
{
//Zebra::logger->debug("CSocket::sendCmdNoPack");
if (NULL == pstrCmd || nCmdLen <= 0)
return false;
bool retval = true;
t_StackCmdQueue _raw_queue;
_raw_queue.put((BYTE*)pstrCmd,nCmdLen);
if (buffer)
{
/*if( need_enc() )
{
packetPackEnc( _raw_queue,_raw_queue.rd_size() );
}*/
PACK_HEAD head;
head.Len = _raw_queue.rd_size();
mutex.lock();
_enc_queue.put((BYTE*)&head, sizeof(head)); // NoPack也要封包头
_enc_queue.put( _raw_queue.rd_buf(),_raw_queue.rd_size() );
mutex.unlock();
}
else
{
/*if ( need_enc() )
{
packetPackEnc( _raw_queue,_raw_queue.rd_size() );
mutex.lock();
retval = sendRawDataIM( _raw_queue.rd_buf(),_raw_queue.rd_size() );
mutex.unlock();
}
else*/
{
mutex.lock();
retval = sendRawDataIM( _raw_queue.rd_buf(),_raw_queue.rd_size() );
mutex.unlock();
}
}
return retval;
}
bool Socket::sendCmd(const void *cmd,const DWORD cmdLen,const bool buffer)
{
LogCheckCondition(cmd && cmdLen,false,"套接字发送失败参数不合法");
bool retval = true;
StackCmdQueue rawQueue;
if(buffer)
{
packetAppendNoEnc(cmd,cmdLen,rawQueue);
m_mutex.lock();
m_sendQueue.put(rawQueue.rdBuffer(),rawQueue.rdSize());
m_currentCmd = rawQueue.rdSize();
m_mutex.unlock();
}
else
{
packetAppend(cmd,cmdLen,rawQueue);
m_mutex.lock();
retval = sendRawDataIM(rawQueue.rdBuffer(),rawQueue.rdSize());
m_currentCmd = rawQueue.rdSize();
m_mutex.unlock();
}
return retval;
}
bool Socket::sync()
{
CheckConditonReturn(m_sendQueue.rdReady(),true);
m_mutex.lock();
bool ret = sendRawDataIM(m_sendQueue.rdBuffer(),m_sendQueue.rdSize());
m_currentCmd = m_sendQueue.rdSize();
m_sendQueue.reset();
m_mutex.unlock();
return ret;
#if 0
DWORD size = 0,offset = 0;
m_mutex.lock();
if(m_bufferQueue.rdReady())
{
BUFFER_CMD(Cmd::DataSendCmd,send,s_maxDataSize + 4);
bcopy(m_bufferQueue.rdBuffer(),send->data,m_bufferQueue.rdSize());
send->dwSize = m_bufferQueue.rdSize();
m_bufferQueue.reset();
StackCmdQueue rawQueue;
m_mutex.unlock();
if(*(DWORD*)send->data + sizeof(s_packHeadLen) < send->datasize())
{
packetAppendNoEnc(send,send->allsize(),rawQueue);
m_mutex.lock();
m_sendQueue.put(rawQueue.rdBuffer(),rawQueue.rdSize());
m_currentCmd = rawQueue.rdSize();
}
else
{
m_mutex.lock();
m_sendQueue.put((const BYTE*)send->data,send->datasize());
m_currentCmd = send->datasize();
}
if(m_sendQueue.rdReady())
{
size = m_sendQueue.rdSize();
m_currentCmd = size;
offset = m_encQueue.rdSize();
//暂时加密buffer还没用到
m_encQueue.put(m_sendQueue.rdBuffer(),size);
m_sendQueue.rdFlip(size);
m_currentCmd = 0;
}
}
m_mutex.unlock();
if(m_encQueue.rdReady())
{
SWORD retcode = sendRawDataNoPoll(m_encQueue.rdBuffer(),m_encQueue.rdSize());
if(retcode > 0)
{
m_encQueue.rdFlip(retcode);
}
else if(retcode == -1)
{
return false;
}
}
return true;
#endif
}
