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; } }