void CNetSock::SockBytesSend(qint64 nSend)
{
if (m_pMsgOut)
{
if (m_pMsgOut->OnBytesSend(nSend))
{
delete m_pMsgOut;
if (m_listOut.isEmpty())
{
m_pMsgOut = NULL;
return;
}
m_pMsgOut = m_listOut.takeFirst();
}
QByteArray* pArr=NULL;
if (m_pMsgOut->DataForSend(&pArr) && (pArr!=NULL))
{
if (write(*pArr) != pArr->size())
{
ForceClose(QString("Socket write error. %1").arg(errorString()));
}
}
else
{
ForceClose(QString("Msg [%1] convert for send error").arg(m_pMsgOut->MsgId()));
}
}
else
{
ForceClose("Bytes send call on empty outgoing msg");
}
}
void cceMaterialShaderEditorDialog::SetShader(cceMaterialShader *shader)
{
_shader = shader;
connect (_shader, SIGNAL(Removed()), this, SLOT(ForceClose()));
_proxyShader->SetCode(_shader->GetCode());
_proxyShader->UpdateBindings();
UpdateGUIFromShader();
}
// This may be called from an ISR, in which case we need to defer the close
bool FileStore::Close()
{
switch (usageMode)
{
case FileUseMode::free:
if (!inInterrupt())
{
INTERNAL_ERROR;
}
return false;
case FileUseMode::readOnly:
case FileUseMode::readWrite:
{
const irqflags_t flags = cpu_irq_save();
if (openCount > 1)
{
--openCount;
cpu_irq_restore(flags);
return true;
}
else if (inInterrupt())
{
closeRequested = true;
cpu_irq_restore(flags);
return true;
}
else
{
cpu_irq_restore(flags);
return ForceClose();
}
}
case FileUseMode::invalidated:
default:
{
const irqflags_t flags = cpu_irq_save();
if (openCount > 1)
{
--openCount;
}
else
{
usageMode = FileUseMode::free;
}
cpu_irq_restore(flags);
return true;
}
}
}
BOOL CMemoryMappedFileSharingTool<T>::CreateOrOpen(const wchar_t* obj_name)
{
ForceClose();
BOOL ok = TRUE;
do {
_obj_name = obj_name;
_handle = CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0, _data->size(), obj_name);
if (_handle == nullptr) { ok = FALSE; break; }
if (GetLastError() == ERROR_ALREADY_EXISTS) {
}
} while (0);
}
void CNetSock::SendMsg(CNetMsgBase* pMsg)
{
if (m_pMsgOut != NULL)
{
m_listOut.append(pMsg);
}
else
{
m_pMsgOut = pMsg;
QByteArray* pArr=NULL;
if (m_pMsgOut->DataForSend(&pArr) && (pArr!=NULL))
{
if (write(*pArr) != pArr->size())
{
ForceClose(QString("Socket write error. %1").arg(errorString()));
}
}
else
{
ForceClose(QString("Msg [%1] convert for send error").arg(m_pMsgOut->MsgId()));
}
}
}
// Invalidate the file if it uses the specified FATFS object
bool FileStore::Invalidate(const FATFS *fs, bool doClose)
{
if (file.obj.fs == fs)
{
if (doClose)
{
(void)ForceClose();
}
else
{
file.obj.fs = nullptr;
if (writeBuffer != nullptr)
{
reprap.GetPlatform().GetMassStorage()->ReleaseWriteBuffer(writeBuffer);
writeBuffer = nullptr;
}
}
usageMode = FileUseMode::invalidated;
return true;
}
return false;
}
void CNetSock::SockError(QAbstractSocket::SocketError err)
{
ForceClose(errorString());
}
void CNetSock::SockReadyRead()
{
quint32 nPos=0;
quint32 nLeftOver=m_arrLeftOver.size();
quint32 nLen=bytesAvailable()+nLeftOver;
if ((m_pMsgIn==NULL) && (nLen < CNetHeader::HEADER_SIZE))
{
return;
}
QByteArray data;
data.reserve(nLen);
if (nLeftOver)
{
data.append(m_arrLeftOver);
data.append(read((nLen-nLeftOver)));
m_arrLeftOver.clear();
}
else
{
data.append(read(nLen));
}
QBuffer buffer(&data);
buffer.open(QIODevice::ReadOnly);
while (nLen > buffer.pos())
{
if (m_pMsgIn==NULL)
{
if (nLen < CNetHeader::HEADER_SIZE)
{
quint32 nBuffLeft = nLen-buffer.pos();
m_arrLeftOver.resize(nBuffLeft);
m_arrLeftOver.append(buffer.read(nBuffLeft));
return;
}
else
{
m_pMsgIn = CNetMsgFactory::CreateMsg(buffer);
if (m_pMsgIn == NULL)
{
ForceClose("Invalid data received.");
return;
}
}
}
switch (m_pMsgIn->OnReceivedData(buffer,(nLen-buffer.pos())))
{
case 0:
{
m_pBridge->OnReceivedMsg(m_pMsgIn);
m_pMsgIn = NULL;
}
break;
case 1://not all data yet
{
Q_ASSERT(nLen==buffer.pos());
return;
}break;
default://error -1
{
ForceClose(QString("Invalid data received.%1").arg(m_pMsgIn->MsgId()));
}
}
}
}
void CSessionThread::ReceiverRun(void)
{
struct packet_s in_pkt;
if (m_stop||!m_open) { CloseSession(); return; }
++m_receiver_thread_instances;
CSingleLock GateKeeper(&m_ReceiverGateKeeper, TRUE);
//AddEvent(EVENT_SENT, 0, _T("Fila de entrada ativada"));
while (TRUE)
{
if (m_stop||!m_open) break;
int retcode = Receive(in_pkt);
if (!retcode)
{
if (!m_stop) ForceClose();
break;
}
WORD wType = ntohs(in_pkt.header.type);
/////////// DEBUG STUFF
/*
{
static WORD wPreviousType = 0;
if (wPreviousType != wType)
{
wPreviousType = wType;
AddEvent(EVENT_RECEIVED, 0, _T("[0x%04lx] Received"), (LONG)wType);
}
}
*/
if (wType == PKT_ABORT)
{
AddEvent(EVENT_RECEIVED, 0, _T("Sessão encerrada pelo servidor"));
SendABORTACK();
ForceClose();
break;
}
else if (wType == PKT_ABORT_ACK)
{
AddEvent(EVENT_RECEIVED, 0, _T("Fim de sessão confirmado"));
ForceClose();
break;
}
else if (wType == PKT_EOJ)
{
AddEvent(EVENT_RECEIVED, 0, _T("Fim da recepção"));
EnqueueTask(in_pkt);
break;
}
else if (wType == PKT_EOJ_ACK)
{
AddEvent(EVENT_RECEIVED, 0, _T("Fim da transmissão confirmado"));
CloseSession();
break;
}
else
{
EnqueueTask(in_pkt);
}
}
--m_receiver_thread_instances;
}
