void Client::handleReceive()
{
boost::asio::async_read(
socket_,
boost::asio::buffer(receive_.getBody(), receive_.getLength()),
[this](boost::system::error_code ec, std::size_t)
{
if ( ! ec)
{
switch (receive_.getType())
{
case PacketType::STATE:
std::cout << "Received state packet" << std::endl;
break;
case PacketType::CALL:
handleCall();
break;
default:
std::cout << "Received unhandeled packet with type:" << receive_.getType() << std::endl;
break;
}
// Keep waiting for new stuff
doReceive();
}
else
{
socket_.close();
}
}
);
}
/* process a single workset item
*/
static inline rsRetVal
processWorksetItem(tcpsrv_t *pThis, nspoll_t *pPoll, int idx, void *pUsr)
{
tcps_sess_t *pNewSess = NULL;
DEFiRet;
DBGPRINTF("tcpsrv: processing item %d, pUsr %p, bAbortConn\n", idx, pUsr);
if(pUsr == pThis->ppLstn) {
DBGPRINTF("New connect on NSD %p.\n", pThis->ppLstn[idx]);
iRet = SessAccept(pThis, pThis->ppLstnPort[idx], &pNewSess, pThis->ppLstn[idx]);
if(iRet == RS_RET_OK) {
if(pPoll != NULL) {
CHKiRet(nspoll.Ctl(pPoll, pNewSess->pStrm, 0, pNewSess, NSDPOLL_IN, NSDPOLL_ADD));
}
DBGPRINTF("New session created with NSD %p.\n", pNewSess);
} else {
DBGPRINTF("tcpsrv: error %d during accept\n", iRet);
}
} else {
pNewSess = (tcps_sess_t*) pUsr;
doReceive(pThis, &pNewSess, pPoll);
if(pPoll == NULL && pNewSess == NULL) {
pThis->pSessions[idx] = NULL;
}
}
finalize_it:
RETiRet;
}
void
TCPSocket::onDataReady()
{
char buffer[4096];
int len;
do {
len = doReceive(buffer,sizeof(buffer));
if (len && observer)
observer->onDataReceived(this, buffer,len);
} while (len && observer);
}
void SFEQuery::mutateFrom(SFENoTypeQuery* notype)
{
_type = notype->type();
_outblock.append(notype->outblock());
_inblock.append(notype->inblock());
_in.skipRawData(sizeof(quint32)*2);
dump(_inblock);
doReceive();
}
int main(int argc, char** argv)
{
if (argc < 2) {
printf("Usage: %s <ipv6 addr>\n", argv[0]);
exit(1);
}
onms_socket sock = socket(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
if (sock == INVALID_SOCKET) {
perror("main: error creating socket");
exit(1);
}
doSend(sock, argv[1]);
doReceive(sock);
}
// Shift data into and out of JTAG chain.
// In pointer may be ZEROS (shift in zeros) or ONES (shift in ones).
// Out pointer may be NULL (not interested in data shifted out of the chain).
//
NeroStatus neroShift(
struct NeroHandle *handle, uint32 numBits, const uint8 *inData, uint8 *outData, bool isLast,
const char **error)
{
NeroStatus returnCode, nStatus;
uint32 numBytes;
uint16 chunkSize;
SendType sendType;
bool isResponseNeeded;
if ( inData == ZEROS ) {
sendType = SEND_ZEROS;
} else if ( inData == ONES ) {
sendType = SEND_ONES;
} else {
sendType = SEND_DATA;
}
if ( outData ) {
isResponseNeeded = true;
} else {
isResponseNeeded = false;
}
nStatus = beginShift(handle, numBits, sendType, isLast, isResponseNeeded, error);
CHECK_STATUS(nStatus, "neroShift()", NERO_BEGIN_SHIFT);
numBytes = bitsToBytes(numBits);
while ( numBytes ) {
chunkSize = (numBytes>=handle->endpointSize) ? handle->endpointSize : (uint16)numBytes;
if ( sendType == SEND_DATA ) {
nStatus = doSend(handle, inData, chunkSize, error);
CHECK_STATUS(nStatus, "neroShift()", NERO_SEND);
inData += chunkSize;
}
if ( isResponseNeeded ) {
nStatus = doReceive(handle, outData, chunkSize, error);
CHECK_STATUS(nStatus, "neroShift()", NERO_RECEIVE);
outData += chunkSize;
}
numBytes -= chunkSize;
}
return NERO_SUCCESS;
cleanup:
return returnCode;
}
void binary_recv(int sourceProcessID, const string& tag, vector<char>& data ) {
static vector<char> dataTmp;
static string tagReceived;
int size;
char cdataIn;
map< string, vector<char> >::iterator itr;
while (true) {
itr = _hash[_processID].find(tag);
if (itr != _hash[_processID].end()) { // Found?
data = _hash[_processID][tag];
_hash[_processID].erase(itr);
break;
} else {
doReceive(sourceProcessID, (int*) &size, sizeof(size));
char buffer[size+1];
doReceive(sourceProcessID, (char*) &buffer, size);
buffer[size] = 0;
tagReceived = buffer;
if (tagReceived == tag) {
doReceive(sourceProcessID, (int*) &size, sizeof(size));
data.resize(size);
for (int i=0; i<size; i++) {
doReceive(sourceProcessID, (char*) &cdataIn, sizeof(char));
data[i] = cdataIn;
}
break;
} else {
doReceive(sourceProcessID, (int*) &size, sizeof(size));
dataTmp.resize(size);
for (int i=0; i<size; i++) {
doReceive(sourceProcessID, (char*) &cdataIn, sizeof(char));
dataTmp[i] = cdataIn;
}
_hash[_processID][tagReceived] = dataTmp;
}
}
}
}
void Client::doConnect(tcp::resolver::iterator endpointIterator)
{
boost::asio::async_connect(
socket_,
endpointIterator,
[this](boost::system::error_code ec, tcp::resolver::iterator)
{
if ( ! ec)
{
std::cout << "Connected" << std::endl;
PacketRegister p;
p.global = true;
p.username.set(settings_.username);
p.password.set(settings_.password);
send(PacketCast p);
// Start our receiving cycle
doReceive();
}
}
);
}
// Core loop
void doLoop(void)
{
while (socketSend.isOk() && socketReceive.isOk())
{
// Modipulate: update
err = modipulate_global_update();
if (!MODIPULATE_OK(err))
{
std::cout << PFX_ERR << "Modipulate: " << modipulate_global_get_last_error_string() << "\n";
break;
}
// Wait a little bit for incoming messages.
if (socketReceive.receiveNextPacket(SLEEP_MS))
{
if (!doReceive())
{
return;
}
}
}
}
void SFEQuery::Receive(QTcpSocket &socket)
{
// QDataStream _in((QTcpSocket*)&socket);
_in.setVersion(QDataStream::Qt_4_7);
while(socket.bytesAvailable()<sizeof(quint32))
socket.waitForReadyRead(1000);
qDebug("reading %d",sizeof(quint32));
QByteArray ba = socket.read(sizeof(quint32));
_inblock.append(ba);
_in >> _size;
qDebug("cmd size: %d",_size);
quint32 left = _size- sizeof(quint32);
while(socket.bytesAvailable()<left){
qDebug("2 available: %d",(int)socket.bytesAvailable());
socket.waitForReadyRead(1000);
}
qDebug("reading: %d",left);
QByteArray ba2 = socket.read(left);
_inblock.append(ba2);
// _in.skipRawData(sizeof(quint32));
quint32 type;
_in >> type;
qDebug("got type: %d",type);
if (_type!=SFEQuery::NOTYPE_TYPE && type!=(quint32)_type)
qDebug("error type !=");
_type=(SFEQuery::QueryType)type;
doReceive();
}
void CDirectSerial::handleUpperEvent(Bit16u type) {
switch(type) {
case SERIAL_POLLING_EVENT: {
setEvent(SERIAL_POLLING_EVENT, 1.0f);
// update Modem input line states
switch(rx_state) {
case D_RX_IDLE:
if(CanReceiveByte()) {
if(doReceive()) {
// a byte was received
rx_state=D_RX_WAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
} // else still idle
} else {
#if SERIAL_DEBUG
if(!dbgmsg_poll_block) {
log_ser(dbg_aux,"Directserial: block on polling.");
dbgmsg_poll_block=true;
}
#endif
rx_state=D_RX_BLOCKED;
// have both delays (1ms + bytetime)
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
}
break;
case D_RX_BLOCKED:
// one timeout tick
if(!CanReceiveByte()) {
rx_retry++;
if(rx_retry>=rx_retry_max) {
// it has timed out:
rx_retry=0;
removeEvent(SERIAL_RX_EVENT);
if(doReceive()) {
// read away everything
// this will set overrun errors
while(doReceive());
rx_state=D_RX_WAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
} else {
// much trouble about nothing
rx_state=D_RX_IDLE;
}
} // else wait further
} else {
// good: we can receive again
#if SERIAL_DEBUG
dbgmsg_poll_block=false;
dbgmsg_rx_block=false;
#endif
removeEvent(SERIAL_RX_EVENT);
rx_retry=0;
if(doReceive()) {
rx_state=D_RX_FASTWAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.65f);
} else {
// much trouble about nothing
rx_state=D_RX_IDLE;
}
}
break;
case D_RX_WAIT:
case D_RX_FASTWAIT:
break;
}
updateMSR();
break;
}
case SERIAL_RX_EVENT: {
switch(rx_state) {
case D_RX_IDLE:
LOG_MSG("internal error in directserial");
break;
case D_RX_BLOCKED: // try to receive
case D_RX_WAIT:
case D_RX_FASTWAIT:
if(CanReceiveByte()) {
// just works or unblocked
rx_retry=0; // not waiting anymore
if(doReceive()) {
if(rx_state==D_RX_WAIT) setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
else {
// maybe unblocked
rx_state=D_RX_FASTWAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.65f);
}
} else {
// didn't receive anything
rx_state=D_RX_IDLE;
}
} else {
// blocking now or still blocked
#if SERIAL_DEBUG
if(rx_state==D_RX_BLOCKED) {
if(!dbgmsg_rx_block) {
log_ser(dbg_aux,"Directserial: rx still blocked (retry=%d)",rx_retry);
dbgmsg_rx_block=true;
}
}
else log_ser(dbg_aux,"Directserial: block on continued rx (retry=%d).",rx_retry);
#endif
setEvent(SERIAL_RX_EVENT, bytetime*0.65f);
rx_state=D_RX_BLOCKED;
}
break;
}
updateMSR();
break;
}
case SERIAL_TX_EVENT: {
// Maybe echo cirquit works a bit better this way
if(rx_state==D_RX_IDLE && CanReceiveByte()) {
if(doReceive()) {
// a byte was received
rx_state=D_RX_WAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
}
}
ByteTransmitted();
updateMSR();
break;
}
case SERIAL_THR_EVENT: {
ByteTransmitting();
setEvent(SERIAL_TX_EVENT,bytetime*1.1f);
break;
}
}
}
void CNullModem::handleUpperEvent(Bit16u type) {
switch(type) {
case SERIAL_POLLING_EVENT: {
// periodically check if new data arrived, disconnect
// if required. Add it back.
setEvent(SERIAL_POLLING_EVENT, 1.0f);
// update Modem input line states
updateMSR();
switch(rx_state) {
case N_RX_IDLE:
if (CanReceiveByte()) {
if (doReceive()) {
// a byte was received
rx_state=N_RX_WAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
} // else still idle
} else {
#if SERIAL_DEBUG
log_ser(dbg_aux,"Nullmodem: block on polling.");
#endif
rx_state=N_RX_BLOCKED;
// have both delays (1ms + bytetime)
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
}
break;
case N_RX_BLOCKED:
// one timeout tick
if (!CanReceiveByte()) {
rx_retry++;
if (rx_retry>=rx_retry_max) {
// it has timed out:
rx_retry=0;
removeEvent(SERIAL_RX_EVENT);
if (doReceive()) {
// read away everything
while(doReceive());
rx_state=N_RX_WAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
} else {
// much trouble about nothing
rx_state=N_RX_IDLE;
#if SERIAL_DEBUG
log_ser(dbg_aux,"Nullmodem: unblock due to no more data",rx_retry);
#endif
}
} // else wait further
} else {
// good: we can receive again
removeEvent(SERIAL_RX_EVENT);
rx_retry=0;
if (doReceive()) {
rx_state=N_RX_FASTWAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.65f);
} else {
// much trouble about nothing
rx_state=N_RX_IDLE;
}
}
break;
case N_RX_WAIT:
case N_RX_FASTWAIT:
break;
}
break;
}
case SERIAL_RX_EVENT: {
switch(rx_state) {
case N_RX_IDLE:
LOG_MSG("internal error in nullmodem");
break;
case N_RX_BLOCKED: // try to receive
case N_RX_WAIT:
case N_RX_FASTWAIT:
if (CanReceiveByte()) {
// just works or unblocked
if (doReceive()) {
rx_retry=0; // not waiting anymore
if (rx_state==N_RX_WAIT) setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
else {
// maybe unblocked
rx_state=N_RX_FASTWAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.65f);
}
} else {
// didn't receive anything
rx_retry=0;
rx_state=N_RX_IDLE;
}
} else {
// blocking now or still blocked
#if SERIAL_DEBUG
if (rx_state==N_RX_BLOCKED)
log_ser(dbg_aux,"Nullmodem: rx still blocked (retry=%d)",rx_retry);
else log_ser(dbg_aux,"Nullmodem: block on continued rx (retry=%d).",rx_retry);
#endif
setEvent(SERIAL_RX_EVENT, bytetime*0.65f);
rx_state=N_RX_BLOCKED;
}
break;
}
break;
}
case SERIAL_TX_EVENT: {
// Maybe echo cirquit works a bit better this way
if (rx_state==N_RX_IDLE && CanReceiveByte() && clientsocket) {
if (doReceive()) {
// a byte was received
rx_state=N_RX_WAIT;
setEvent(SERIAL_RX_EVENT, bytetime*0.9f);
}
}
ByteTransmitted();
break;
}
case SERIAL_THR_EVENT: {
ByteTransmitting();
// actually send it
setEvent(SERIAL_TX_EVENT,bytetime+0.01f);
break;
}
case SERIAL_SERVER_POLLING_EVENT: {
// As long as nothing is connected to our server poll the
// connection.
if (!ServerConnect()) {
// continue looking
setEvent(SERIAL_SERVER_POLLING_EVENT, 50);
}
break;
}
case SERIAL_TX_REDUCTION: {
// Flush the data in the transmitting buffer.
if (clientsocket) clientsocket->FlushBuffer();
tx_block=false;
break;
}
case SERIAL_NULLMODEM_DTR_EVENT: {
if ((!DTR_delta) && getDTR()) {
// DTR went positive. Try to connect.
if (ClientConnect(new TCPClientSocket((char*)hostnamebuffer,
(Bit16u)clientport)))
break; // no more DTR wait event when connected
}
DTR_delta = getDTR();
setEvent(SERIAL_NULLMODEM_DTR_EVENT,50);
break;
}
}
}
// Remove a message from the head of the queue
// Wait until either a message arrives or the timeout expires.
// The receiver is responsible for freeing the received message.
// Other than for messages sent from an ISR, the receiver is responsible
// for freeing the received message.
OsStatus OsMsgQShared::receive(OsMsg*& rpMsg, const OsTime& rTimeout)
{
return doReceive(rpMsg, rTimeout);
}
void IAdaptor::receiving( fwServices::ObjectMsg::csptr _msg) throw ( ::fwTools::Failed )
{
doReceive(_msg);
}
void IVtkAdaptorService::receiving(::fwServices::ObjectMsg::csptr msg) throw(fwTools::Failed)
{
doReceive(msg);
requestRender();
}
