void CContentWindowContainer::DataReceived(const isab::DataGuiMess* aMess, const char *aUrl) { list<class CResolveItem*>::iterator it = iReqList.begin(); if (iBrCtlInterface) { class CResolveItem* item = NULL; while (it != iReqList.end()) { item = *it; HBufC* url = WFTextUtil::AllocLC(aUrl); if (!url->Find(item->getUrl())) { CleanupStack::PopAndDestroy(url); iReqList.erase(it); DataReceived(item->getLinkContent(), aMess, aUrl); delete item; return; } CleanupStack::PopAndDestroy(url); it++; } } class CResolveItem* item; while (it != iReqList.end()) { item = *it; it++; iReqList.pop_front(); delete item; } }
int WSocket::ReceiveBuffer() { unsigned int num_read; unsigned int num_to_read; while(m_num_read<m_read_data_buf_len) { // Read the data in 4K at a time to avoid the NOBUFS error if((m_read_data_buf_len-m_num_read)>4096) { num_to_read=4096; } else { num_to_read=m_read_data_buf_len-m_num_read; } num_read=Receive(p_read_data_buf+m_num_read,num_to_read); if(num_read==SOCKET_ERROR) { int error_code=GetLastError(); // The assumption is that not all the data was sent if we get a WSAEWOULDBLOCK, and that a later // OnReceive will pick the rest of it up when it is sent. if(error_code==WSAEWOULDBLOCK) { return 0; } else { return error_code; } } if(num_read==0) // assume that this is crap { return SOCKET_ERROR; } m_num_read+=num_read; } DataReceived(m_num_read); return 0; }
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QMainWindow::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: on_clearButton_clicked(); break; case 1: on_getLastTempButton_clicked(); break; case 2: on_getTempButton_clicked(); break; case 3: on_getTempAllButton_clicked(); break; case 4: DataReceived((*reinterpret_cast< QString(*)>(_a[1]))); break; case 5: ConnectError(); break; case 6: timerEvent((*reinterpret_cast< QTimerEvent*(*)>(_a[1]))); break; default: ; } _id -= 8; } return _id; }
void TCPPort::OnRead(const boost::system::error_code &ec, size_t nbytes) { if (ec == boost::asio::error::operation_aborted) /* this object has already been deleted; bail out quickly without touching anything */ return; if (ec) { connection.close(); AsyncAccept(); StateChanged(); Error(ec.message().c_str()); return; } DataReceived(input, nbytes); AsyncRead(); }
MainWindow::MainWindow(QWidget *parent, Qt::WFlags flags) : QMainWindow(parent, flags) { ui.setupUi(this); cntPkt = cntErr = cntWtf = 0; QObject::connect(ui.portOpenButton, SIGNAL(clicked()),this, SLOT(openPort())); QObject::connect(ui.portCloseButton, SIGNAL(clicked()),this, SLOT(closePort())); QObject::connect(ui.nodeSettingsSetButton, SIGNAL(clicked()),this, SLOT(nodeUpdateSettings())); QObject::connect(&port, SIGNAL(DataReceived(quint64)),this, SLOT(DataInput(quint64))); QObject::connect(&timer, SIGNAL(timeout()),this, SLOT(timeout())); QStringList ports = port.EnumeratePorts(); ports.sort(); ui.portSelectCombo->insertItems(0, ports); nodeUpdateSettings(); //timer.setInterval(1);//in fact it should be ~230usec //port.SetReadTimeout(1);//and still to much }
void TCPClientPort::OnRead(const boost::system::error_code &ec, size_t nbytes) { if (ec == boost::asio::error::operation_aborted) /* this object has already been deleted; bail out quickly without touching anything */ return; if (ec) { socket.close(); state = PortState::FAILED; StateChanged(); Error(ec.message().c_str()); return; } DataReceived(input, nbytes); socket.async_receive(boost::asio::buffer(input, sizeof(input)), std::bind(&TCPClientPort::OnRead, this, std::placeholders::_1, std::placeholders::_2)); }
void ServerNetwork::readyRead() { QTcpSocket *socket = static_cast<QTcpSocket*>(sender()); u32 clientId = clientManager->GetClient(socket); QByteArray *buffer = buffers.value(socket); qint32 size = socket->bytesAvailable(); while (socket->bytesAvailable() > 0) { buffer->append(socket->readAll()); while ((size == 0 && buffer->size() >= 4) || (size > 0 && buffer->size() >= size)) { if (size == 0 && buffer->size() >= 4) { size = ArrayToInt(buffer->mid(0, 4)); buffer->remove(0, 4); } if (size > 0 && buffer->size() >= size) { QByteArray data = buffer->mid(0, size); buffer->remove(0, size); size = 0; emit DataReceived(data, clientId); } } } }
void CEMSocket::OnReceive(int nErrorCode) { // the 2 meg size was taken from another place static char GlobalReadBuffer[2000000]; // Check for an error code if (nErrorCode != 0) { OnError(nErrorCode); return; } // Check current connection state if (byConnected == ES_DISCONNECTED) { TRACE("->%s: the sock is disconnected\n",__FUNCTION__); return; } else { byConnected = ES_CONNECTED; // ES_DISCONNECTED, ES_NOTCONNECTED, ES_CONNECTED } // CPU load improvement if (downloadLimitEnable == true && downloadLimit == 0) { #ifdef _DEBUG_CPU TRACE("->%s: CPU load improvement\n",__FUNCTION__); #endif pendingOnReceive = true; //Receive(GlobalReadBuffer + pendingHeaderSize, 0); return; } // Remark: an overflow can not occur here uint32 readMax = sizeof(GlobalReadBuffer) - pendingHeaderSize; if (downloadLimitEnable == true && readMax > downloadLimit) { readMax = downloadLimit; } // We attempt to read up to 2 megs at a time (minus whatever is in our internal read buffer) uint32 ret = Receive(GlobalReadBuffer + pendingHeaderSize, readMax); GlobalReadBuffer[pendingHeaderSize+ret] = 0; if (ret == SOCKET_ERROR || byConnected == ES_DISCONNECTED) { return; } // Bandwidth control if (downloadLimitEnable == true) { // Update limit downloadLimit -= GetRealReceivedBytes(); } // CPU load improvement // Detect if the socket's buffer is empty (or the size did match...) pendingOnReceive = m_bFullReceive; if (ret == 0) return; // Copy back the partial header into the global read buffer for processing if (pendingHeaderSize > 0) { memcpy(GlobalReadBuffer, pendingHeader, pendingHeaderSize); ret += pendingHeaderSize; pendingHeaderSize = 0; } if (IsRawDataMode()) { DataReceived((BYTE*)GlobalReadBuffer, ret); return; } char *rptr = GlobalReadBuffer; // floating index initialized with begin of buffer const char *rend = GlobalReadBuffer + ret; // end of buffer // Loop, processing packets until we run out of them while ((rend - rptr >= PACKET_HEADER_SIZE) || ((pendingPacket != NULL) && (rend - rptr > 0))) { // Two possibilities here: // // 1. There is no pending incoming packet // 2. There is already a partial pending incoming packet // // It's important to remember that emule exchange two kinds of packet // - The control packet // - The data packet for the transport of the block // // The biggest part of the traffic is done with the data packets. // The default size of one block is 10240 bytes (or less if compressed), but the // maximal size for one packet on the network is 1300 bytes. It's the reason // why most of the Blocks are splitted before to be sent. // // Conclusion: When the download limit is disabled, this method can be at least // called 8 times (10240/1300) by the lower layer before a splitted packet is // rebuild and transferred to the above layer for processing. // // The purpose of this algorithm is to limit the amount of data exchanged between buffers if (pendingPacket == NULL) { pendingPacket = new Packet(rptr); // Create new packet container. rptr += 6; // Only the header is initialized so far // Bugfix We still need to check for a valid protocol // Remark: the default eMule v0.26b had removed this test...... switch (pendingPacket->prot) { case OP_EDONKEYPROT: case OP_PACKEDPROT: case OP_EMULEPROT: break; default: EMTrace("CEMSocket::OnReceive ERROR Wrong header"); delete pendingPacket; pendingPacket = NULL; OnError(ERR_WRONGHEADER); return; } // Security: Check for buffer overflow (2MB) if (pendingPacket->size > sizeof(GlobalReadBuffer)) { delete pendingPacket; pendingPacket = NULL; OnError(ERR_TOOBIG); return; } // Init data buffer pendingPacket->pBuffer = new char[pendingPacket->size + 1]; pendingPacketSize = 0; } // Bytes ready to be copied into packet's internal buffer ASSERT(rptr <= rend); uint32 toCopy = ((pendingPacket->size - pendingPacketSize) < (uint32)(rend - rptr)) ? (pendingPacket->size - pendingPacketSize) : (uint32)(rend - rptr); // Copy Bytes from Global buffer to packet's internal buffer memcpy(&pendingPacket->pBuffer[pendingPacketSize], rptr, toCopy); pendingPacketSize += toCopy; rptr += toCopy; // Check if packet is complet ASSERT(pendingPacket->size >= pendingPacketSize); if (pendingPacket->size == pendingPacketSize) { #ifdef EMSOCKET_DEBUG EMTrace("CEMSocket::PacketReceived on %d, opcode=%X, realSize=%d", (SOCKET)this, pendingPacket->opcode, pendingPacket->GetRealPacketSize()); #endif // Process packet bool bPacketResult = PacketReceived(pendingPacket); delete pendingPacket; pendingPacket = NULL; pendingPacketSize = 0; if (!bPacketResult) return; } } // Finally, if there is any data left over, save it for next time ASSERT(rptr <= rend); ASSERT(rend - rptr < PACKET_HEADER_SIZE); if (rptr != rend) { // Keep the partial head pendingHeaderSize = rend - rptr; memcpy(pendingHeader, rptr, pendingHeaderSize); } }
void SerialPort::Run() { assert(Thread::IsInside()); DWORD dwBytesTransferred; BYTE inbuf[1024]; // JMW added purging of port on open to prevent overflow Flush(); #ifndef _WIN32_WCE OverlappedEvent osStatus, osReader; if (!osStatus.Defined() || !osReader.Defined()) // error creating event; abort return; #endif // Specify a set of events to be monitored for the port. if (is_widcomm) SetRxTimeout(180); else { ::SetCommMask(hPort, EV_RXCHAR); SetRxTimeout(0); } while (!CheckStopped()) { #ifndef _WIN32_WCE WaitResult result = WaitDataPending(osStatus, INFINITE); switch (result) { case WaitResult::READY: break; case WaitResult::TIMEOUT: continue; case WaitResult::FAILED: case WaitResult::CANCELLED: ::Sleep(100); continue; } int nbytes = GetDataPending(); if (nbytes <= 0) { ::Sleep(100); continue; } // Start reading data if ((size_t)nbytes > sizeof(inbuf)) nbytes = sizeof(inbuf); if (!::ReadFile(hPort, inbuf, nbytes, &dwBytesTransferred, osReader.GetPointer())) { if (::GetLastError() != ERROR_IO_PENDING) { // Error in ReadFile() occured ::Sleep(100); continue; } if (osReader.Wait() != OverlappedEvent::FINISHED) { ::CancelIo(hPort); ::SetCommMask(hPort, 0); osReader.Wait(); continue; } if (!::GetOverlappedResult(hPort, osReader.GetPointer(), &dwBytesTransferred, FALSE)) continue; } #else if (is_widcomm) { /* WaitCommEvent() doesn't work with the Widcomm Bluetooth driver, it blocks for 11 seconds, regardless whether data is received. This workaround polls for input manually. Observed on an iPaq hx4700 with WM6. */ } else { // Wait for an event to occur for the port. DWORD dwCommModemStatus; if (!::WaitCommEvent(hPort, &dwCommModemStatus, 0)) { // error reading from port Sleep(100); continue; } if ((dwCommModemStatus & EV_RXCHAR) == 0) /* no data available */ continue; } // Read the data from the serial port. if (!ReadFile(hPort, inbuf, 1024, &dwBytesTransferred, NULL) || dwBytesTransferred == 0) { Sleep(100); continue; } #endif DataReceived(inbuf, dwBytesTransferred); } Flush(); }
int NetworkCommunication::LoadNetworkSettings(QString filename) { if(QFile(filename).exists()) { QSettings* settings; settings= new QSettings(filename,QSettings::IniFormat); if(telegramHandler != NULL) { delete telegramHandler; } if(telegramData != NULL) { delete telegramData; } if(telegramTrigger != NULL) { delete telegramTrigger; } if(telegramStatus != NULL) { delete telegramStatus; } if(!CheckIfSettingsExist(settings, "UDPport")) return(1); UDPport=settings->value("UDPport").toInt(); telegramHandler = new QCoDeSysNetVarUDP(QHostAddress::Any,UDPport); if(!CheckIfSettingsExist(settings, "VariableIndexIonCurrent")) return(1); variableIndexIonCurrent = settings->value("VariableIndexIonCurrent").toInt(); if(!CheckIfSettingsExist(settings, "VariableIndexMagneticField")) return(1); variableIndexMagneticField = settings->value("VariableIndexMagneticField").toInt(); if(!CheckIfSettingsExist(settings, "DataIonCurrentCoefA")) return(1); ionCurrentCoefA = settings->value("DataIonCurrentCoefA").toDouble(); if(!CheckIfSettingsExist(settings, "DataIonCurrentCoefB")) return(1); ionCurrentCoefB = settings->value("DataIonCurrentCoefB").toDouble(); if(!CheckIfSettingsExist(settings, "DataIonCurrentCoefC")) return(1); ionCurrentCoefC = settings->value("DataIonCurrentCoefC").toDouble(); if(!CheckIfSettingsExist(settings, "VariableIndexTriggerReceived")) return(1); variableIndexTriggerReceived = settings->value("VariableIndexTriggerReceived").toInt(); if(!CheckIfSettingsExist(settings, "VariableIndexScanCompleted")) return(1); variableIndexScanCompleted = settings->value("VariableIndexScanCompleted").toInt(); if(!CheckIfSettingsExist(settings, "DataMagneticFieldCoefA")) return(1); magneticFieldCoefA = settings->value("DataMagneticFieldCoefA").toDouble(); if(!CheckIfSettingsExist(settings, "DataMagneticFieldCoefB")) return(1); magneticFieldCoefB = settings->value("DataMagneticFieldCoefB").toDouble(); if(!CheckIfSettingsExist(settings, "DataMagneticFieldCoefC")) return(1); magneticFieldCoefC = settings->value("DataMagneticFieldCoefC").toDouble(); telegramData = new QCoDeSysNVT(0); if(!CheckIfSettingsExist(settings, "DataTelegramFormat")) return(1); telegramData->StringToVariableList(settings->value("DataTelegramFormat").toString()); if(!CheckIfSettingsExist(settings, "DataTelegramCobID")) return(1); telegramData->setCobId(settings->value("DataTelegramCobID").toInt()); telegramStatus = new QCoDeSysNVT(0); if(!CheckIfSettingsExist(settings, "StatusTelegramFormat")) return(1); telegramStatus->StringToVariableList(settings->value("StatusTelegramFormat").toString()); if(!CheckIfSettingsExist(settings, "StatusTelegramCobID")) return(1); telegramStatus->setCobId(settings->value("StatusTelegramCobID").toInt()); telegramTrigger = new QCoDeSysNVT(1); if(!CheckIfSettingsExist(settings, "TriggerTelegramFormat")) return(1); telegramTrigger->StringToVariableList(settings->value("TriggerTelegramFormat").toString()); if(!CheckIfSettingsExist(settings, "TriggerTelegramCobID")) return(1); telegramTrigger->setCobId(settings->value("TriggerTelegramCobID").toInt()); if(!CheckIfSettingsExist(settings, "TriggerTelegramValues")) return(1); telegramTrigger->StringToData(settings->value("TriggerTelegramValues").toString()); telegramTrigger->setPort(UDPport); telegramTrigger->setIP(QHostAddress::Broadcast); if(!CheckIfSettingsExist(settings, "VariableIndexScanFrom")) return(1); variableIndexScanFrom=settings->value("VariableIndexScanFrom").toInt(); if(!CheckIfSettingsExist(settings, "VariableIndexScanTo")) return(1); variableIndexScanTo=settings->value("VariableIndexScanTo").toInt(); if(!CheckIfSettingsExist(settings, "VariableIndexScanTime")) return(1); variableIndexScanTime=settings->value("VariableIndexScanTime").toInt(); if(!CheckIfSettingsExist(settings, "VariableIndexSolFrom")) return(1); variableIndexSolFrom=settings->value("VariableIndexSolFrom").toInt(); if(!CheckIfSettingsExist(settings, "VariableIndexSolTo")) return(1); variableIndexSolTo=settings->value("VariableIndexSolTo").toInt(); if(!CheckIfSettingsExist(settings, "TriggerTimeOut")) return(1); triggerTimeOut=settings->value("TriggerTimeOut").toInt(); if(!CheckIfSettingsExist(settings, "ScanTimeOut")) return(1); scanTimeOut=settings->value("ScanTimeOut").toInt(); if(!CheckIfSettingsExist(settings, "HeartBeatTimeInterval")) return(1); heartBeatTimeInterval=settings->value("HeartBeatTimeInterval").toInt(); connect(telegramData,SIGNAL(updated()),this,SLOT(DataReceived())); connect(telegramStatus,SIGNAL(updated()),this,SLOT(StatusReceived())); telegramHandler->telegrams.append(telegramStatus); telegramHandler->telegrams.append(telegramData); return(0); } else { qDebug() << "NetworkCommunication::LoadNetworkSettings: File " << filename << " does not exist!"; return(1); } }
void RoundTest_MultiRound(CreateSessionCallback callback, CreateGroupGenerator cgg) { Timer::GetInstance().UseVirtualTime(); int count = Random::GetInstance().GetInt(TEST_RANGE_MIN, TEST_RANGE_MAX); int leader = Random::GetInstance().GetInt(0, count); int sender0 = Random::GetInstance().GetInt(0, count); int sender1 = Random::GetInstance().GetInt(0, count); while(sender0 != sender1) { sender1 = Random::GetInstance().GetInt(0, count); } QVector<TestNode *> nodes; Group *group; ConstructOverlay(count, nodes, group); Id leader_id = nodes[leader]->cm.GetId(); Id session_id; CreateSessions(nodes, *group, leader_id, session_id, callback, cgg); Library *lib = CryptoFactory::GetInstance().GetLibrary(); QScopedPointer<Dissent::Utils::Random> rand(lib->GetRandomNumberGenerator()); QByteArray msg(512, 0); rand->GenerateBlock(msg); nodes[sender0]->session->Send(msg); SignalCounter sc; for(int idx = 0; idx < count; idx++) { QObject::connect(&nodes[idx]->sink, SIGNAL(DataReceived()), &sc, SLOT(Counter())); nodes[idx]->session->Start(); } TestNode::calledback = 0; qint64 next = Timer::GetInstance().VirtualRun(); while(next != -1 && sc.GetCount() < count && TestNode::calledback < count) { Time::GetInstance().IncrementVirtualClock(next); next = Timer::GetInstance().VirtualRun(); } sc.Reset(); for(int idx = 0; idx < count; idx++) { EXPECT_EQ(msg, nodes[idx]->sink.Last().first); } rand->GenerateBlock(msg); nodes[sender1]->session->Send(msg); TestNode::calledback = 0; next = Timer::GetInstance().VirtualRun(); while(next != -1 && sc.GetCount() < count && TestNode::calledback < count * 2) { Time::GetInstance().IncrementVirtualClock(next); next = Timer::GetInstance().VirtualRun(); } for(int idx = 0; idx < count; idx++) { EXPECT_EQ(msg, nodes[idx]->sink.Last().first); } CleanUp(nodes); delete group; }
void SerialPort::Run() { assert(Thread::IsInside()); DWORD dwBytesTransferred; BYTE inbuf[1024]; // JMW added purging of port on open to prevent overflow Flush(); OverlappedEvent osStatus, osReader; if (!osStatus.Defined() || !osReader.Defined()) // error creating event; abort return; // Specify a set of events to be monitored for the port. ::SetCommMask(hPort, EV_RXCHAR); SetRxTimeout(0); while (!CheckStopped()) { WaitResult result = WaitDataPending(osStatus, INFINITE); switch (result) { case WaitResult::READY: break; case WaitResult::TIMEOUT: continue; case WaitResult::FAILED: case WaitResult::CANCELLED: ::Sleep(100); continue; } int nbytes = GetDataPending(); if (nbytes <= 0) { ::Sleep(100); continue; } // Start reading data if ((size_t)nbytes > sizeof(inbuf)) nbytes = sizeof(inbuf); if (!::ReadFile(hPort, inbuf, nbytes, &dwBytesTransferred, osReader.GetPointer())) { if (::GetLastError() != ERROR_IO_PENDING) { // Error in ReadFile() occured ::Sleep(100); continue; } if (osReader.Wait() != OverlappedEvent::FINISHED) { ::CancelIo(hPort); ::SetCommMask(hPort, 0); osReader.Wait(); continue; } if (!::GetOverlappedResult(hPort, osReader.GetPointer(), &dwBytesTransferred, FALSE)) continue; } DataReceived(inbuf, dwBytesTransferred); } Flush(); }