uint32 ReliableConduit::waitingMessageType() {
// The messageWaiting call is what actually receives the message.
if (messageWaiting()) {
return messageType;
} else {
return 0;
}
}
/**
* \brief add a message to the internal send queue, to be fetched by messageHub
*
*/
void eveMessageChannel::addMessage(eveMessage * message)
{
if (!message) return;
QWriteLocker locker(&sendLock);
sendMessageList.append(message);
emit messageWaiting(channelId);
}
bool ReliableConduit::messageWaiting() const {
ReliableConduit* me = const_cast<ReliableConduit*>(this);
switch (state) {
case HOLDING:
// We've already read the message and are waiting
// for a receive call.
return true;
case RECEIVING:
if (! ok()) {
return false;
}
// We're currently receiving the message. Read a little more.
me->receiveIntoBuffer();
if (messageSize == receiveBufferUsedSize) {
// We've read the whole mesage. Switch to holding state
// and return true.
me->state = HOLDING;
return true;
} else {
// There are more bytes left to read. We'll read them on
// the next call. Because the *entire* message is not ready,
// return false.
return false;
}
break;
case NO_MESSAGE:
if (Conduit::messageWaiting()) {
// Message incoming. Read the header.
me->state = RECEIVING;
me->receiveHeader();
// Loop back around now that we're in the receive state; we
// may be able to read the whole message before returning
// to the caller.
return messageWaiting();
} else {
// No message incoming.
return false;
}
}
debugAssertM(false, "Should not reach this point");
return false;
}
uint32 LightweightConduit::waitingMessageType() {
if (! messageWaiting()) {
return 0;
}
if (! alreadyReadMessage) {
messageBuffer.resize(8192);
SOCKADDR_IN remote_addr;
int iRemoteAddrLen = sizeof(sockaddr);
int ret = recvfrom(sock, (char*)messageBuffer.getCArray(),
messageBuffer.size(), 0, (struct sockaddr *) &remote_addr,
(socklen_t*)&iRemoteAddrLen);
if (ret == SOCKET_ERROR) {
if (nd->debugLog) {
nd->debugLog->println("Error: recvfrom failed in "
"LightweightConduit::waitingMessageType().");
nd->debugLog->println(socketErrorCode());
}
nd->closesocket(sock);
messageBuffer.resize(0);
messageSender = NetAddress();
messageType = 0;
return 0;
}
messageSender = NetAddress(remote_addr);
++mReceived;
bReceived += ret;
messageBuffer.resize(ret, DONT_SHRINK_UNDERLYING_ARRAY);
// The type is the first four bytes. It is little endian.
if (System::machineEndian() == G3D_LITTLE_ENDIAN) {
messageType = *((uint32*)messageBuffer.getCArray());
} else {
// Swap the byte order
for (int i = 0; i < 4; ++i) {
((char*)&messageType)[i] = messageBuffer[3 - i];
}
}
alreadyReadMessage = true;
}
return messageType;
}
/**
* \brief unregister if sendqueue is empty
* \return true if sendqueue is empty, else false
*/
bool eveMessageChannel::shutdownThreadIfQueueIsEmpty()
{
// if already successfully unregistered return true
if (unregistered) return true;
QWriteLocker locker(&sendLock);
if (sendMessageList.isEmpty()){
eveMessageHub::getmHub()->unregisterChannel(channelId);
unregistered = true;
QThread::currentThread()->quit();
return true;
}
else {
eveError::log(DEBUG, QString("eveMessageChannel: %1 more Messages before shutdown").arg(sendMessageList.size()));
emit messageWaiting(channelId);
return false;
}
}
