/**
* Callback that should be invoked when the data is received
*/
void CNaviReceiverProfileImpl::onBufferReceived(const tChannelId channel, CBuffer const& buffer)
{
LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__);
UInt8 *incomingData = buffer.getBuffer();
int read_size = buffer.getSize();
std::string json((char*)incomingData, read_size);
LOG4CPLUS_TRACE(msLogger, "got string:");
LOG4CPLUS_TRACE(msLogger, json);
Json::Value root; // will contain the root value after parsing.
Json::Reader reader;
bool parsingSuccessful = reader.parse(json.c_str(), root);
if (parsingSuccessful) {
std::deque<std::string> tracks;
Json::Value list=root["play"];
Json::Value::UInt index=0;
LOG4CPLUS_TRACE(msLogger, "tracks to play:");
for(index=0;index<list.size();index++){
LOG4CPLUS_TRACE(msLogger, list[index].asString());
tracks.push_back(list[index].asString());
}
mpAppCallbacks->playTracks(tracks);
} else {
LOG4CPLUS_ERROR(msLogger, "Failed to parse tracklist!");
}
}
void CSelection::GetCaretRect( CEditView *pView, int nBuffCol, int nRow, RECT &rcCaret )
{
ASSERT( pView );
RECT rcView;
pView->GetRect( &rcView );
CBuffer *pBuffer = m_pCtrl->GetBuffer();
int nLastLine = pBuffer->GetLineCount() - 1;
int nViewCol = nBuffCol;
nRow = min( nLastLine, nRow );
if ( nRow < 0 )
{
nRow = 0;
}
else
{
nViewCol = pBuffer->ConvertBufferColToViewCol( nRow, nBuffCol );
}
rcCaret.left = rcView.left + pView->GetLeftMargin( TRUE, TRUE ) + ( ( nViewCol - pView->GetLeftIndex() ) * pView->GetCharWidth() );
rcCaret.right = rcCaret.left + m_cxCaretIns;
rcCaret.top = rcView.top + ( ( nRow - pView->GetTopIndex() ) * pView->GetLineHeight() );
rcCaret.bottom = rcCaret.top + m_cyCaret;
}
void Init(HWND hWnd)
{
// Set our global window handle to our main window
g_hWnd = hWnd;
// Create our double buffering our window
g_Buffer.CreateDoubleBuffering(hWnd);
// This is where we create the image of our character
HBITMAP hPlayerImage = g_Buffer.LoadABitmap((LPSTR)kPlayerImage);
// Initialize our player with it's image and position
g_Player.Init(hPlayerImage, kPlayerStartX, kPlayerStartY);
// Init, load and draw the first map file
g_Map.Load(kStartMap);
g_Map.SetDrawFlag(true);
// Here we load then play the starting background music
if(!g_Music.Init("techno.mod"))
exit(0);
g_Music.PlaySong();
// we need to seed our random number generator (rand()) for moving npcs.
srand(GetTickCount());
// Set the backbuffer to black first (This clears the backbuffer)
g_Buffer.ClearScreen(BLACK_BRUSH);
}
CBuffer *CBuffer::Allocator::Allocate()
{
CCriticalSection::Owner lock( m_criticalSection );
CBuffer *pBuffer = 0;
if ( !m_freeList.Empty() )
{
pBuffer = m_freeList.PopNode();
pBuffer->AddRef();
}
else
{
pBuffer = new( m_bufferSize )CBuffer( *this, m_bufferSize );
if ( !pBuffer )
{
throw CException( _T("CBuffer::Allocator::Allocate()"), _T("Out of memory") );
}
OnBufferCreated();
}
m_activeList.PushNode( pBuffer );
OnBufferAllocated();
return pBuffer;
}
HRESULT read(void *data, UInt32 size, UInt32 *processedSize)
{
Lock lock(m_mutex);
if (m_read_size==m_total_size)
{
*processedSize = 0;
m_sealed=true;
return S_OK;
}
while (m_buffer.size()==0)
m_buffer_not_empty.wait(lock);
try
{
*processedSize = m_buffer.read(data, size);
m_read_size += *processedSize;
//printf("CBuffer[%p]: %u bytes read\n", this, *processedSize);
}
catch(...)
{
assert(false);
}
m_buffer_not_full.notify_all();
lock.unlock();
//if (m_read_size==m_total_size)
// finalize();
return S_OK;
}
void wait_for_write()
{
Lock lock(m_mutex);
size_t old_size=m_buffer.size();
while (old_size==m_buffer.size())
m_buffer_not_empty.wait(lock);
}
void CMySocket::newdata()
{
CBuffer buffer;
CClientMsg climsg;
buffer.AddDataSize( GetData( buffer.GetDataEnd(), 255 ) );
if ( buffer.DataSize() == -1 )
return;
int nParseErr;
while(climsg.ParseData( &buffer, nParseErr ))
{
TVecChar vecMsg;
climsg.GetData( CClientMsg::etpCommand, &vecMsg );
if ( (climsg.GetTo() == 1 || climsg.GetTo() == 2) && ( int ) vecMsg[ 0 ] == 0 )
std::cout << "ok" << std::endl;
else
{
std::cout << "message from " << ( int ) climsg.GetTo() << " CMD: " << ( int ) climsg.GetCommand() << " ARG: ";
for ( TVecChar::const_iterator i = vecMsg.begin(); i != vecMsg.end(); ++i )
std::cout << (int) *i << " ";
std::cout << std::endl;
//sockclose();
}
if ( m_bAutoMode )
sendMsgFromList();
}
}
// If file was downloaded with a resource, validate checksum
void CScriptFile::DoResourceFileCheck ( void )
{
if ( !m_pFile || m_bDoneResourceFileCheck )
return;
m_bDoneResourceFileCheck = true;
if ( g_pClientGame->GetResourceManager()->IsResourceFile( m_strFilename ) )
{
// Remember current position and seek to the end
long lCurrentPos = m_pFile->FTell ();
m_pFile->FSeek ( 0, SEEK_END );
// Retrieve size of file
long lSize = m_pFile->FTell ();
// Read data
CBuffer buffer;
buffer.SetSize( lSize );
m_pFile->FSeek ( 0, SEEK_SET );
m_pFile->FRead ( buffer.GetData(), buffer.GetSize() );
// Seek back to where the pointer was
m_pFile->FSeek ( lCurrentPos, SEEK_SET );
// Check file content
g_pClientGame->GetResourceManager()->ValidateResourceFile( m_strFilename, buffer );
}
}
void CNiThread::SendData(CBuffer& bufDataSnd,const CString& strClientAddr)
{
if(bufDataSnd.GetDataLen()<=0 || strClientAddr.GetLength()<=0)
return;
NI_TASK_PARAM_TYPE* pNiTask = new NI_TASK_PARAM_TYPE;
if(pNiTask != NULL)
{
//pNiTask->pSendData = &bufDataSnd;
pNiTask->pSendData = new CBuffer();
if(pNiTask->pSendData!=NULL)
{
//加装数据包头
if(pNiTask->pSendData->Alloc(bufDataSnd.GetDataLen()+PACKAGE_HEAD_LEN))
{
//填写数据包头部
DWORD* pPackageEntityLen = (DWORD*)pNiTask->pSendData->GetBufP();
*pPackageEntityLen=bufDataSnd.GetDataLen();
pNiTask->pSendData->SetDataLen(PACKAGE_HEAD_LEN);
pNiTask->pSendData->AppendData(bufDataSnd);
//memcpy(pNiTask->pSendData,bufDataSnd.GetBufP(),bufDataSnd.GetDataLen());
//pNiTask->pSendData->SetDataLen(bufDataSnd.GetDataLen()+PACKAGE_HEAD_LEN);
}
}
//填写发送地址
pNiTask->strClientAddr = strClientAddr;
//提交发送任务
CommitNiTask(NITASK_SEND,pNiTask);
}
}
void CQuery::SendBuffer(CClient* pClient, const CBuffer& Buffer) {
if (m_pNetwork && m_pNetwork->IsUserAttached()) {
// Based on CChan::SendBuffer()
if (!Buffer.IsEmpty()) {
MCString msParams;
msParams["target"] = m_pNetwork->GetIRCNick().GetNick();
const vector<CClient*> & vClients = m_pNetwork->GetClients();
for (size_t uClient = 0; uClient < vClients.size(); ++uClient) {
CClient * pUseClient = (pClient ? pClient : vClients[uClient]);
size_t uSize = Buffer.Size();
for (size_t uIdx = 0; uIdx < uSize; uIdx++) {
CString sLine = Buffer.GetLine(uIdx, *pUseClient, msParams);
bool bContinue = false;
NETWORKMODULECALL(OnPrivBufferPlayLine(*pUseClient, sLine), m_pNetwork->GetUser(), m_pNetwork, NULL, &bContinue);
if (bContinue) continue;
m_pNetwork->PutUser(sLine, pUseClient);
}
if (pClient)
break;
}
}
}
}
int CAppCtrl::RecvData(unsigned int uiDPKey, CBuffer& stBuff)
{
//找到key对应的管道
PCShmQ pstShm = GetShm(uiDPKey);
if(pstShm == NULL)
{
SL_ERROR("shm %u fand fails!", uiDPKey);
return -1;
}
else if(!pstShm->HasCode())
{
//管道里没有数据
return 0;
}
m_Stat.Put(app_stat_recvpkg);
stBuff.Clear();
int iCodeLen = 0;
//从管道里取出一个code
int iRet = pstShm->GetOneCode(stBuff.GetFreeBuf(), stBuff.GetFreeLen(), iCodeLen);
if(iRet || iCodeLen < (int)sizeof(CNetHead))
{
SL_ERROR("get one code but data fails (ret: %d, clen:%d)",iRet, iCodeLen);
return -2;
}
stBuff.Append(iCodeLen);
return iCodeLen;
}
void DecodeAsterix::GetPacket(CBuffer& rBuffer)
{
index = rBuffer.GetIndex();
rBuffer.ReadU8(&cat);
qDebug () << QString("CAT : %1").arg(cat);
if (cat == 4) { // Category - 004
cat004.Clear();
cat004.BufferPrint(rBuffer, index, rBuffer.GetIndex(), "000");
cat004.GetPacket(rBuffer);
}else if(cat == 62) { // Category - 062 System track
cat062.Clear();
cat062.BufferPrint(rBuffer, index, rBuffer.GetIndex(), "000");
cat062.GetPacket(rBuffer);
//qDebug() << cat062.toString();
}else if(cat == 21) { // Category - 021 ADSB
cat021.Clear();
cat021.BufferPrint(rBuffer, index, rBuffer.GetIndex(), "000");
cat021.GetPacket(rBuffer);
//qDebug() << cat021.toString();
}else {
qDebug() << "Not found category...";
}
}
int CCircuitry::RecordWith(int nChan, BYTE* pBuffer, DWORD dwStopOffset)
{
if ( ! m_pChain || ! m_pChain->IsConnected() ) return -1;
if ( m_pRecIoOver->Offset >= MAX_RECLST ) return -1;
if ( ! HasOverlappedIoCompleted(m_pRecIoOver) ) return -1;
CBuffer* pOutput = m_pChain->m_pOutput;
if ( dwStopOffset ) pOutput->Add( pBuffer, dwStopOffset + 1 );
Neighbour.m_pWakeup.SetEvent();
if ( int nResult = SsmRecordMemBlock(nChan, 6, pBuffer, TEMP_BUFFER, OnRecMemBlockDone, m_pRecIoOver) )
{
#ifdef _DEBUG
CHAR sError[1024];
SsmGetLastErrMsg( sError );
theApp.Message( MSG_ERROR, sError );
#endif
return nResult;
}
m_pRecIoOver->Offset++;
ResetEvent( m_pRecIoOver->hEvent );
//TRACE("%i-> RecordWith in [%i]\n", GetTickCount(), m_pRecIoOver->Offset);
return 0;
}
void* CResox::InShellJob(void* pvThis) throw()
{
CResox* pResox = (CResox*) pvThis;
int nread;
try
{
CBuffer DataBuffer;
while(true)
{
pResox->XEPssh.ReceiveData(&DataBuffer);
nread = write(pResox->tun_fd, DataBuffer.GetBuffer(), DataBuffer.GetBufferSize());
if(nread < 0) {
perror("Write to interface");
close(pResox->tun_fd);
exit(1);
}
}
}
catch(exception& e)
{
pResox->ThreadOutShellJob.Stop();
pResox->XEPssh.Disconnect();
return NULL;
}
}
void wait_for_read()
{
Lock lock(m_mutex);
size_t old_size=m_buffer.size();
while (old_size==m_buffer.size())
m_buffer_not_full.wait(lock);
}
bool ZLibUtils::Uncompress(CBuffer& pSrc)
{
QMutexLocker l(&ZLibUtils::m_oMutex);
for(ulong nSize = qMax(pSrc.size() * 6u, 1024u); ; nSize *= 2)
{
ZLibUtils::m_oCompressBuffer.resize(nSize);
ulong nCompress = ZLibUtils::m_oCompressBuffer.size();
int nRet = ::uncompress((Bytef*)ZLibUtils::m_oCompressBuffer.data(), &nCompress, (Bytef*)pSrc.data(), pSrc.size());
if(nRet == Z_OK)
{
ZLibUtils::m_oCompressBuffer.resize(nCompress);
pSrc.clear();
pSrc.append(ZLibUtils::m_oCompressBuffer);
break;
}
if(nRet != Z_BUF_ERROR)
{
return false;
}
}
return true;
}
bool ZLibUtils::Compress(CBuffer& pSrc, bool bIfSmaller)
{
QMutexLocker l(&ZLibUtils::m_oMutex);
if(bIfSmaller && pSrc.size() < 64)
{
return false;
}
ulong nCompress = qMax(ZLibUtils::m_oCompressBuffer.size(), pSrc.size() * 2);
ZLibUtils::m_oCompressBuffer.resize(nCompress);
int nRet = ::compress((Bytef*)ZLibUtils::m_oCompressBuffer.data(), &nCompress, (const Bytef*)pSrc.data(), pSrc.size());
if(nRet != Z_OK)
{
Q_ASSERT(nRet != Z_BUF_ERROR);
return false;
}
ZLibUtils::m_oCompressBuffer.resize(nCompress);
if(bIfSmaller && ZLibUtils::m_oCompressBuffer.size() > pSrc.size())
{
return false;
}
pSrc.clear();
pSrc.append(ZLibUtils::m_oCompressBuffer);
return true;
}
bool PmpIpcProtocol::findProfilesResponse(const std::list<iviLink::Profile::Uid> & profiles,
iviLink::Ipc::DirectionID const& dirId)
{
LOG4CPLUS_TRACE_METHOD(msLogger, __PRETTY_FUNCTION__ );
CBuffer writeBuf = mWriteBufMgr.getBuffer();
ProfileManager::Ipc::PmMessage* req = reinterpret_cast<ProfileManager::Ipc::PmMessage*>(writeBuf.get());
req->header.type = ProfileManager::Ipc::PMP_PMAL_FIND_PROFILES;
iviLink::Ipc::Helpers::CBufferWriter writer(req->data, writeBuf.getSize() - sizeof(req->header));
BaseError err = writer.write(profiles.begin(), profiles.end());
if (!err.isNoError())
{
LOG4CPLUS_ERROR(msLogger, static_cast<std::string>(err));
return false;
}
req->header.size = writer.getUsedSize();
iviLink::Ipc::MsgID id = mMsgIdGen.getNext();
UInt32 const reqSize = sizeof(ProfileManager::Ipc::PmMessage) + req->header.size;
err = mIpc->asyncRequest(id, writeBuf.get(), reqSize, &dirId);
if (!err.isNoError())
{
LOG4CPLUS_ERROR(msLogger, static_cast<std::string>(err));
return false;
}
return true;
}
int CUdpSocket::Send(const CBuffer &Buffer, const CIp &Ip)
{
CIp temp(Ip);
return (int)::sendto(m_Socket,
(void *)Buffer.data(), Buffer.size(),
0, (struct sockaddr *)temp.GetSockAddr(), sizeof(struct sockaddr_in));
}
BOOL CHostBrowser::LoadDC(LPCTSTR pszFile, CQueryHit*& pHits)
{
CFile pFile;
if ( ! pFile.Open( pszFile, CFile::modeRead | CFile::shareDenyWrite ) )
return FALSE; // File open error
UINT nInSize = (UINT)pFile.GetLength();
if ( ! nInSize )
return FALSE; // Empty file
CBuffer pBuffer;
if ( ! pBuffer.EnsureBuffer( nInSize ) )
return FALSE; // Out of memory
if ( pFile.Read( pBuffer.GetData(), nInSize ) != nInSize )
return FALSE; // File read error
pBuffer.m_nLength = nInSize;
if ( ! pBuffer.UnBZip() )
return FALSE; // Decompression error
augment::auto_ptr< CXMLElement > pXML ( CXMLElement::FromString( pBuffer.ReadString( pBuffer.m_nLength, CP_UTF8 ), TRUE ) );
if ( ! pXML.get() )
return FALSE; // XML decoding error
// <FileListing Version="1" CID="SKCB4ZF4PZUDF7RKQ5LX6SVAARQER7QEVELZ2TY" Base="/" Generator="DC++ 0.762">
if ( ! pXML->IsNamed( L"FileListing" ) )
return FALSE; // Invalid XML file format
// CString strTitle = pXML->GetAttributeValue( L"CID" );
return LoadDCDirectory( pXML.get(), pHits );
}
int CPollTask::Run()
{
if (NULL == m_lpQQUser || NULL == m_lpQQProtocol || NULL == m_lpRecvMsgTask)
{
m_bStop = FALSE;
return 0;
}
while (1)
{
if (m_bStop)
break;
CBuffer * lpMsgData = new CBuffer;
if (NULL == lpMsgData)
continue;
BOOL bRet = m_lpQQProtocol->Poll(m_HttpClient, WEBQQ_CLIENT_ID,
m_lpQQUser->m_LoginResult2.m_strPSessionId.c_str(), lpMsgData);
if (!bRet || lpMsgData->GetData() == NULL || lpMsgData->GetSize() <= 0)
{
delete lpMsgData;
::OutputDebugStringA("poll message error!\r\n");
continue;
}
m_lpRecvMsgTask->AddMsgData(lpMsgData);
}
m_bStop = FALSE;
return 0;
}
bool CNetDelegate::runRead()
{
int nRet = m_oSocket.ccRead(m_pReadBuffer, SOCKET_READ_BUFFER_SIZE);
if( nRet == eSocketIoError || nRet == eSocketIoClosed )
{
unregisterScheduler();
m_oSocket.ccClose();
m_eStatus = eSocketIoClosed;
onDisconnected();
return true;
}
else
{
#if 1
CCLOG("CCSOCKET READ %d", nRet);
#endif
m_oReadBuffer.writeData(m_pReadBuffer, (unsigned int)nRet);
#if USING_PACKAGE_HEAD_LENGTH
while( m_oReadBuffer.isReadable(sizeof(int)) )
{
m_oReadBuffer.moveReaderIndexToFront();
int n_head_len = m_oReadBuffer.readInt();
if( n_head_len <= 0 )
{
CCLOGERROR("invalidate head length");
m_oReadBuffer.moveLeft(sizeof(int));
}
int n_content_len = (int)m_oReadBuffer.length();
if( n_content_len - (int)(sizeof(int)) >= n_head_len )
{
m_oReadBuffer.moveLeft(sizeof(unsigned int));
CBuffer* pData = m_oReadBuffer.readData(n_head_len);
m_oReadBuffer.moveLeft(n_head_len);
m_oReadBuffer.moveReaderIndexToFront();
m_oReadBuffer.moveWriterIndexToBack();
onMessageReceived(*pData);
#if USING_LUA
executeOnMessageReceivedScriptHandler(pData);
#endif
}else{
break;
}
}
#else
CBuffer* pData = (CBuffer*) m_oReadBuffer.copy();
pData->autorelease();
m_oReadBuffer.clear();
onMessageReceived(*pData);
#if USING_LUA
executeOnMessageReceivedScripHandler(pData);
#endif
#endif
}
return false;
}
//------------------------------------------------------------------------------
void CBOMRecognizerFilter::AcknowledgeBOM( unsigned long ulBOMBytes )
{
CBuffer* pBuffer = GetSourceBuffer();
if( pBuffer )
{
pBuffer->ReadAcknowledge( ulBOMBytes );
}
}
bool CBuffer::operator ==(const CBuffer &Buffer) const
{
if ( size() == Buffer.size() )
{
return (::memcmp((const char *)data(), (const char *)Buffer.data(), size()) == 0);
}
return false;
}
//************************************
// Method: Copy
// FullName: CBuffer::Copy
// Access: public
// Returns: void
// Qualifier: Copy from one buffer object to another
// Parameter: CBuffer & buffer
//************************************
void CBuffer::Copy(CBuffer& buffer){
int nReSize = buffer.GetMemSize();
int nSize = buffer.GetBufferLen();
ClearBuffer();
ReAllocateBuffer(nReSize);
m_pPtr = m_pBase + nSize;
CopyMemory(m_pBase,buffer.GetBuffer(),buffer.GetBufferLen());
}
inline const void* CNetDDEPacket::DataBuffer() const
{
ASSERT(m_oBuffer.Buffer() != NULL);
const byte* pBuffer = static_cast<const byte*>(m_oBuffer.Buffer());
return pBuffer + sizeof(Header);
}
//------------------------------------------------------------------------------
void CBOMRecognizerFilter::RejectBOM( unsigned long ulBOMBytes )
{
CBuffer* pBuffer = GetSourceBuffer();
if( pBuffer )
{
pBuffer->ReadReject( ulBOMBytes );
}
}
inline CNetDDEPacket::CNetDDEPacket(uint nDataType, const CBuffer& oBuffer)
{
uint nPacketID = ASYNC_PACKET_ID;
if ((nDataType & PACKET_SYNC_MASK) == SYNC_PACKET)
nPacketID = GeneratePktID();
Create(nDataType, nPacketID, oBuffer.Buffer(), oBuffer.Size());
}
int CSocket::sendMessage(CBuffer& pSource, char* pIp, int pPort)
{
if(udp)
return sendBuffer(pSource, pIp, pPort);
CBuffer sendBuff;
sendBuff.writeuShort(pSource.length());
sendBuff.writeBuffer(pSource);
return sendBuffer(sendBuff);
}
void CQuery::SendBuffer(CClient* pClient, const CBuffer& Buffer) {
if (m_pNetwork && m_pNetwork->IsUserAttached()) {
// Based on CChan::SendBuffer()
if (!Buffer.IsEmpty()) {
const vector<CClient*> & vClients = m_pNetwork->GetClients();
for (CClient* pEachClient : vClients) {
CClient * pUseClient = (pClient ? pClient : pEachClient);
MCString msParams;
msParams["target"] = pUseClient->GetNick();
bool bWasPlaybackActive = pUseClient->IsPlaybackActive();
pUseClient->SetPlaybackActive(true);
bool bBatch = pUseClient->HasBatch();
CString sBatchName = m_sName.MD5();
if (bBatch) {
m_pNetwork->PutUser(":znc.in BATCH +" + sBatchName + " znc.in/playback " + m_sName, pUseClient);
}
size_t uSize = Buffer.Size();
for (size_t uIdx = 0; uIdx < uSize; uIdx++) {
const CBufLine& BufLine = Buffer.GetBufLine(uIdx);
if (!pUseClient->HasEchoMessage() && !pUseClient->HasSelfMessage()) {
CNick Sender(BufLine.GetFormat().Token(0));
if (Sender.NickEquals(pUseClient->GetNick())) {
continue;
}
}
CString sLine = BufLine.GetLine(*pUseClient, msParams);
if (bBatch) {
MCString msBatchTags = CUtils::GetMessageTags(sLine);
msBatchTags["batch"] = sBatchName;
CUtils::SetMessageTags(sLine, msBatchTags);
}
bool bContinue = false;
NETWORKMODULECALL(OnPrivBufferPlayLine2(*pUseClient, sLine, BufLine.GetTime()), m_pNetwork->GetUser(), m_pNetwork, nullptr, &bContinue);
if (bContinue) continue;
m_pNetwork->PutUser(sLine, pUseClient);
}
if (bBatch) {
m_pNetwork->PutUser(":znc.in BATCH -" + sBatchName, pUseClient);
}
pUseClient->SetPlaybackActive(bWasPlaybackActive);
if (pClient)
break;
}
}
}
}
