C++ Packet::Clear方法代码示例

void ClientTCP()
{
    TcpClient client;
    Packet data;
    data.SetByteOrder(CX_PACKET_BIG_ENDIAN);
    if(!client.InitializeSocket(HOSTNAME, PORT)) 
    {
        cout << "Unable to connect to host " << HOSTNAME << endl;
        return;
    }
    cout << "Initialized TCP Client Socket\n";
    char key = 0;
    while(key != 27) 
    {

        if((key = GetChar()) > 0) 
        {
            data.Clear();       //  Clear packet and encode data.
            data.Write(key);
            client.Send(data);  //  Send data (could send character array also if desired
            /* Alternative way to send:
               client.Send(&key, 1);    //  Send buffer/array.
            */
            data.Clear();
            if(client.Recv(data, 50, 0))
            {
                cout << *data.Ptr() << endl;
            }
            //cout << key;
        }
    }
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief If the IsLargeDataSet method returns true, then this method is used
///          to convert message payload data into a multi-packet stream
///          according to rules defined by the JAUS standards documents.
///
///   This method should only be overloaded if your message contains data
///   larger than Header::MaxSize - Header::MinSize (e.g. image data) and you wish
///   to optimize how data is written.  By default, this method calls the
///   WriteMessageBody method to generate a single large byte array, which is then
///   broken up into a Packet::List for the transport layer.
///
///   \param[out] stream Multi-packet stream containing serialized message 
///                      following rules of large data sets.
///   \param[out] streamHeaders Headers for packet in the stream.
///   \param[in] maxPayloadSize This is the maximum packet size including 
///                             payload, does not include transport, General
///                             Transport Header, or Message Code (USHORT).
///   \param[in] transportHeader Additional transport header data to precede
///                              the general transport header of each packet.
///   \param[in] startingSequenceNumber Sequence number to use for packets.
///   \param[in] broadcastFlags Values to use to signify if message should be
///                             sent using any broadcast options (e.g. 
///                             multicast). 0 = no options, 1 = local broadcast,
///                             2 = global broadcast.
///
///   \return FAILURE on error, otherwise number of packets written.
///
////////////////////////////////////////////////////////////////////////////////////
int Message::WriteLargeDataSet(Packet::List& stream,
                               Header::List& streamHeaders,
                               const UShort maxPayloadSize,
                               const Packet* transportHeader,
                               const UShort startingSequenceNumber,
                               const Byte broadcastFlags) const
{
    Header header;
    header.mDestinationID = mDestinationID;
    header.mSourceID = mSourceID;
    header.mPriorityFlag = mPriority;
    header.mBroadcastFlag = broadcastFlags;

    stream.clear();
    streamHeaders.clear();
    Packet* temp = ((Packet *)(&mStreamPayload));
    temp->Clear();
    if(IsLargeDataSet() && WriteMessageBody(*temp) >= 0)
    {
        LargeDataSet::CreateLargeDataSet(header, 
                                         mMessageCode, 
                                         *temp, 
                                         stream, 
                                         streamHeaders, 
                                         transportHeader, 
                                         maxPayloadSize,
                                         startingSequenceNumber);
        return (int)stream.size();
    }
    return FAILURE;
}

void MulticastClientUDP()
{
    UdpClient client;
    IP4Address::List hosts;
    client.GetHostAddresses(hosts);
    cout << "IP Address for Host Machine\n";
    for(int i = 0; i < (int)hosts.size(); i++ ) 
    {
        cout << hosts[i].mString << endl;
    }

    Packet data;
    data.SetByteOrder(CX_PACKET_BIG_ENDIAN);
    if(!client.InitializeMulticastSocket(MULTICAST_GROUP, PORT, 1)) 
    {
        cout << "Unable to connect to host " << HOSTNAME << endl;
        return;
    }
    cout << "Initialized UDP Client Socket on port " << PORT << endl;
    char key = 0;
    while(key != 27) 
    {
        if((key = GetChar()) > 0) 
        {
            data.Write(key);
            cout << key;
            client.Send(data);  //  Send data (could send character array also if desired
            data.Clear();       //  Clear packet and encode data.
            /*  Alternative way to send:
                client.Send(&key, 1);    //  Send buffer/array.
            */
        }
    }
}

Socket::Status TcpSocket::Receive(Packet& packet)
{
    // First clear the variables to fill
    packet.Clear();

    // We start by getting the size of the incoming packet
    Uint32 packetSize = 0;
    std::size_t received = 0;
    if (myPendingPacket.SizeReceived < sizeof(myPendingPacket.Size))
    {
        // Loop until we've received the entire size of the packet
        // (even a 4 bytes variable may be received in more than one call)
        while (myPendingPacket.SizeReceived < sizeof(myPendingPacket.Size))
        {
            char* data = reinterpret_cast<char*>(&myPendingPacket.Size) + myPendingPacket.SizeReceived;
            Status status = Receive(data, sizeof(myPendingPacket.Size) - myPendingPacket.SizeReceived, received);
            myPendingPacket.SizeReceived += received;

            if (status != Done)
                return status;
        }

        // The packet size has been fully received
        packetSize = ntohl(myPendingPacket.Size);
    }
    else
    {
        // The packet size has already been received in a previous call
        packetSize = ntohl(myPendingPacket.Size);
    }

    // Loop until we receive all the packet data
    char buffer[1024];
    while (myPendingPacket.Data.size() < packetSize)
    {
        // Receive a chunk of data
        std::size_t sizeToGet = std::min(static_cast<std::size_t>(packetSize - myPendingPacket.Data.size()), sizeof(buffer));
        Status status = Receive(buffer, sizeToGet, received);
        if (status != Done)
            return status;

        // Append it into the packet
        if (received > 0)
        {
            myPendingPacket.Data.resize(myPendingPacket.Data.size() + received);
            char* begin = &myPendingPacket.Data[0] + myPendingPacket.Data.size() - received;
            std::memcpy(begin, buffer, received);
        }
    }

    // We have received all the packet data: we can copy it to the user packet
    if (!myPendingPacket.Data.empty())
        packet.OnReceive(&myPendingPacket.Data[0], myPendingPacket.Data.size());

    // Clear the pending packet data
    myPendingPacket = PendingPacket();

    return Done;
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Reads a message out of the message box.
///
///   This method will read the first message that has not been read yet by this
///   instance of the MappedMessageBox.
///
///   \param[in] message Packet data to read from message box.
///
///   \return True on success, false on failure.
///
////////////////////////////////////////////////////////////////////////////////////
bool MappedMessageBox::ReadMessage(Packet& message) const
{
    bool result = false;
    message.Clear();
    if(mMessageBox.IsOpen())
    {
        Header header;
        if(mMessageBox.Lock() == 0)
        {
            return result;
        }
        header = ReadHeader();
        
        if(header.mCount > 0 && header.mStartBytePos < header.mEndBytePos)
        {
            // Advance to the position of the next message we want to read.
            unsigned int messageSize = 0;
            unsigned int messagePosition = header.mStartBytePos;
            
            // Read the message size in the box.
            mMessageBox->Read(messageSize, messagePosition); 
            
            if(messageSize + MessageHeaderSize + messagePosition <= header.mEndBytePos)
            {
                if(mMessageBox->Read(message, messageSize, messagePosition + MessageHeaderSize) == (int)messageSize)
                {
                     (*( (unsigned *)(&mMessagesRead) ))++;
                    // Advance the start byte position in the array.
                    header.mStartBytePos = messagePosition + MessageHeaderSize + messageSize;
                    // Decrease the number of messages in the box.
                    header.mCount--;
                    result = true;
                }
            }
            if(messageSize + MessageHeaderSize > mMessageBox->Length())
            {
                assert("Corrupted Shared Memory Message Box" && 0);
            }
        }
        // Reset position values.
        if(header.mCount == 0)
        {
            header.mStartBytePos = header.mEndBytePos = Header::Size;
        }
        // Update the read time (shows we are actively checking for messages).
        header.mReadTimeMs = GetTimeMs();
        // Save updated header data.
        WriteHeader(header);
        // Release critical section.
        mMessageBox.Unlock();
    }
        
    return result;
}

////////////////////////////////////////////////////////////
/// Receive a packet from the host (must be connected first).
/// This function will block if the socket is blocking
////////////////////////////////////////////////////////////
Socket::Status SocketTCP::Receive(Packet& PacketToReceive)
{
    // We start by getting the size of the incoming packet
    Uint32      PacketSize = 0;
    std::size_t Received   = 0;
    if (myPendingPacketSize < 0)
    {
        Socket::Status Status = Receive(reinterpret_cast<char*>(&PacketSize), sizeof(PacketSize), Received);
        if (Status != Socket::Done)
            return Status;

        PacketSize = ntohl(PacketSize);
    }
    else
    {
        // There is a pending packet : we already know its size
        PacketSize = myPendingPacketSize;
    }

    // Then loop until we receive all the packet data
    char Buffer[1024];
    while (myPendingPacket.size() < PacketSize)
    {
        // Receive a chunk of data
        std::size_t SizeToGet = std::min(static_cast<std::size_t>(PacketSize - myPendingPacket.size()), sizeof(Buffer));
        Socket::Status Status = Receive(Buffer, SizeToGet, Received);
        if (Status != Socket::Done)
        {
            // We must save the size of the pending packet until we can receive its content
            if (Status == Socket::NotReady)
                myPendingPacketSize = PacketSize;
            return Status;
        }

        // Append it into the packet
        if (Received > 0)
        {
            myPendingPacket.resize(myPendingPacket.size() + Received);
            char* Begin = &myPendingPacket[0] + myPendingPacket.size() - Received;
            memcpy(Begin, Buffer, Received);
        }
    }

    // We have received all the datas : we can copy it to the user packet, and clear our internal packet
    PacketToReceive.Clear();
    if (!myPendingPacket.empty())
        PacketToReceive.OnReceive(&myPendingPacket[0], myPendingPacket.size());
    myPendingPacket.clear();
    myPendingPacketSize = -1;

    return Socket::Done;
}

////////////////////////////////////////////////////////////
/// Receive a packet from the host (must be connected first).
/// This function will block if the socket is blocking
////////////////////////////////////////////////////////////
Socket::Status SocketTCP::Receive(Packet& PacketToReceive)
{
    // We start by getting the size of the incoming packet
    Uint32      PacketSize = 0;
    std::size_t Received   = 0;
    if (myPendingPacketSize < 0)
    {
        Socket::Status Status = Receive(reinterpret_cast<char*>(&PacketSize), sizeof(PacketSize), Received);
        if (Status != Socket::Done)
            return Status;

        PacketSize = ntohl(PacketSize);
    }
    else
    {
        // There is a pending packet : we already know its size
        PacketSize = myPendingPacketSize;
    }

    // Clear the user packet
    PacketToReceive.Clear();

    // Then loop until we receive all the packet data
    char Buffer[1024];
    while (myPendingPacket.GetDataSize() < PacketSize)
    {
        // Receive a chunk of data
        Uint32 SizeToGet = std::min(PacketSize - myPendingPacket.GetDataSize(), static_cast<Uint32>(sizeof(Buffer)));
        Socket::Status Status = Receive(Buffer, SizeToGet, Received);
        if (Status != Socket::Done)
        {
            // We must save the size of the pending packet until we can receive its content
            if (Status == Socket::NotReady)
                myPendingPacketSize = PacketSize;
            return Status;
        }

        // Append it into the packet
        myPendingPacket.Append(Buffer, Received);
    }

    // We have received all the datas : we can copy it to the user packet, and clear our internal packet
    PacketToReceive = myPendingPacket;
    myPendingPacket.Clear();
    myPendingPacketSize = -1;

    // Let the packet do custom stuff after data reception
    PacketToReceive.OnReceive();

    return Socket::Done;
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Thread used by the primary server (the active socket) to receive
///   UDP datagrams and share to clients.
///
////////////////////////////////////////////////////////////////////////////////////
void UdpSharedServer::UdpSocketThread(void* udpSharedServer)
{
    UdpSharedServer* server = (UdpSharedServer*)udpSharedServer;
    Packet udpMessage;
    IP4Address sourceAddress;
    unsigned short sourcePort = 0;
#ifdef WIN32
    unsigned int loopCounter = 0;
#endif

    while(server && 
          (server->mUdpSocketThread.QuitThreadFlag() == false ||
           server->mQuitServerFlag == false))
    {
        // Try and read a new incomming message.
        udpMessage.Clear(false);
        sourcePort = 0;
        if(server->mpSocket->Recv(udpMessage, 5000, 100, &sourceAddress, &sourcePort) > 0)
        {
            // Add the IP address to the end of the message for shared memory clients.
            udpMessage.Write(sourceAddress.mData, 4, udpMessage.Length());
            udpMessage.Write(sourcePort, udpMessage.Length());
            // Send to non-primary UdpSharedServer instances.
            server->mpMessageServer->SendToAllClients(udpMessage);
            // Now process the data internally.  This will add to the
            // queue of received messages, and generate callbacks.
            UdpSharedServer::ProcessUdpMessage(udpMessage, server);
        }
        server->mDelayMutex.Lock();
        if(server->mUpdateDelayMs == 0)
        {
#ifdef WIN32
            // Only sleep every N loops
            if( loopCounter++ == 250)
            {
                loopCounter = 0;
                SleepMs(1);
            }
#else
            usleep(500);
#endif
        }
        else
        {
            CxUtils::SleepMs(server->mUpdateDelayMs);
        }
        server->mDelayMutex.Unlock();
    }
    server->mConnectedFlag = false;
}

	void Connection::Update() {
		while (true) {
			this->RecvMutex.lock();
			if (this->ToRecv.Count == 0) {
				this->RecvMutex.unlock();
				break;
			}

			byte* buff = this->ToRecv.RemoveAt(0);
			this->RecvMutex.unlock();

			Packet p;
			p.InBuffer = buff + 4;
			p.InSize = *(int*)buff;

			int pid;
			switch (this->PIDType) {
				case ConnectionPacketIDType::Byte: pid = p.ReadByte(); break;
				case ConnectionPacketIDType::Short: pid = p.ReadShort(); break;
				case ConnectionPacketIDType::Int: pid = p.ReadInt(); break;
			}

			if (pid < this->CallbacksSize && pid >= 0 && this->Callbacks[pid] != nullptr) {
				bool ret = this->Callbacks[pid](this->m_pTag, p);
				if (!ret) {
					this->Disconnect();
					this->RecvMutex.lock();
					while (this->ToRecv.Count > 0) delete this->ToRecv.RemoveAt(this->ToRecv.Count - 1);
					this->RecvMutex.unlock();
				}

				if (p.InPos != p.InSize) {
					Utilities::Print("[col=%s]WARNING: Packet 0x%.4X(%d) was only read till %d, while the size is %d", Color::Orange.ToString().c_str(), pid, pid, p.InPos, p.InSize);
				}
			} else {
				Utilities::Print("[col=%s]Unknown packet: 0x%.4X(%d), size %d", Color::Red.ToString().c_str(), pid,  pid, p.InSize);
			}

			this->LastReceivedPacket = time(nullptr);

			p.InBuffer = nullptr;
			p.InSize = 0;
			p.Clear();

			delete[] buff;
		}
	}

////////////////////////////////////////////////////////////
/// Receive a packet.
/// This function will block if the socket is blocking
////////////////////////////////////////////////////////////
Socket::Status SocketUDP::Receive(Packet& PacketToReceive, IPAddress& Address, unsigned short& Port)
{
    // We start by getting the size of the incoming packet
    Uint32      PacketSize = 0;
    std::size_t Received   = 0;
    if (myPendingPacketSize < 0)
    {
        // Loop until we've received the entire size of the packet
        // (even a 4 bytes variable may be received in more than one call)
        while (myPendingHeaderSize < sizeof(myPendingHeader))
        {
            char* Data = reinterpret_cast<char*>(&myPendingHeader) + myPendingHeaderSize;
            Socket::Status Status = Receive(Data, sizeof(myPendingHeader) - myPendingHeaderSize, Received, Address, Port);
            myPendingHeaderSize += Received;

            if (Status != Socket::Done)
                return Status;
        }

        PacketSize = ntohl(myPendingHeader);
        myPendingHeaderSize = 0;
    }
    else
    {
        // There is a pending packet : we already know its size
        PacketSize = myPendingPacketSize;
    }

    // Use another address instance for receiving the packet data ;
    // chunks of data coming from a different sender will be discarded (and lost...)
    IPAddress Sender;
    unsigned short SenderPort;

    // Then loop until we receive all the packet data
    char Buffer[1024];
    while (myPendingPacket.size() < PacketSize)
    {
        // Receive a chunk of data
        std::size_t SizeToGet = std::min(static_cast<std::size_t>(PacketSize - myPendingPacket.size()), sizeof(Buffer));
        Socket::Status Status = Receive(Buffer, SizeToGet, Received, Sender, SenderPort);
        if (Status != Socket::Done)
        {
            // We must save the size of the pending packet until we can receive its content
            if (Status == Socket::NotReady)
                myPendingPacketSize = PacketSize;
            return Status;
        }

        // Append it into the packet
        if ((Sender == Address) && (SenderPort == Port) && (Received > 0))
        {
            myPendingPacket.resize(myPendingPacket.size() + Received);
            char* Begin = &myPendingPacket[0] + myPendingPacket.size() - Received;
            memcpy(Begin, Buffer, Received);
        }
    }

    // We have received all the datas : we can copy it to the user packet, and clear our internal packet
    PacketToReceive.Clear();
    if (!myPendingPacket.empty())
        PacketToReceive.OnReceive(&myPendingPacket[0], myPendingPacket.size());
    myPendingPacket.clear();
    myPendingPacketSize = -1;

    return Socket::Done;
}

void SceneryManager::SendPageRequest(const SceneryPageRequest& request, std::list<PacketManager::PACKET_PAIR>& outgoingPackets)
{
	TimeObject to("SceneryManager::SendPageRequest");

	STRINGLIST queryRows;
	Packet data;
	int wpos = 0;
	char idBuf[32];

	GetThread("SceneryManager::HandlePageRequests[page]");

	SceneryPage *page = GetOrCreatePage(request.zone, request.x, request.y);

	if(page == NULL)
	{
		g_Log.AddMessageFormat("[ERROR] SendPageRequest retrieved NULL page");
		
		wpos = PrepExt_QueryResponseNull(prepBuf, request.queryID);
		data.Assign(prepBuf, wpos);
		outgoingPackets.push_back(PacketManager::PACKET_PAIR(request.socket, data));

		ReleaseThread();
		return;
	}

	SceneryPage::SCENERY_IT it;
	for(it = page->mSceneryList.begin(); it != page->mSceneryList.end(); ++it)
	{
		//Build the list of scenery ID strings to form the response to the scenery.list query.
		//No need to save row data unless the query is required.
		if(request.skipQuery == false)
		{
			sprintf(idBuf, "%d", it->second.ID);
			queryRows.push_back(idBuf);
		}
		
		wpos += PrepExt_UpdateScenery(&prepBuf[wpos], &it->second);
		if(wpos > Global::MAX_SEND_CHUNK_SIZE)
		{
			data.Assign(prepBuf, wpos);
			outgoingPackets.push_back(PacketManager::PACKET_PAIR(request.socket, data));
			wpos = 0;
		}
	}
	if(wpos > 0)
	{
		data.Assign(prepBuf, wpos);
		outgoingPackets.push_back(PacketManager::PACKET_PAIR(request.socket, data));
	}

	//Done accessing the scenery data itself, no need to hold the thread any longer.
	//All the remaining stuff is using a resident list of query IDs to form into a response
	//packet.
	ReleaseThread();

	//Now build the query response if the client has requested it.
	if(request.skipQuery == true)
		return;

	//Reset the packet buffer and data.
	wpos = 0;
	data.Clear();

	//Get the size of the response
	int sizeReq = 6;  //Query ID (4 bytes) + row count (2 bytes)
	for(size_t s = 0; s < queryRows.size(); s++)
	{
		sizeReq++;  //1 string per row
		sizeReq += PutStringReq(queryRows[s].c_str());
	}

	wpos += PutByte(&prepBuf[wpos], 1);         //_handleQueryResultMsg
	wpos += PutShort(&prepBuf[wpos], sizeReq);  //Message size

	wpos += PutInteger(&prepBuf[wpos], request.queryID);
	wpos += PutShort(&prepBuf[wpos], queryRows.size());
	for(size_t s = 0; s < queryRows.size(); s++)
	{
		wpos += PutByte(&prepBuf[wpos], 1);
		wpos += PutStringUTF(&prepBuf[wpos], queryRows[s].c_str());
		if(wpos > Global::MAX_SEND_CHUNK_SIZE)
		{
			data.Append(prepBuf, wpos);
			wpos = 0;
		}
	}
	if(wpos > 0)
		data.Append(prepBuf, wpos);

	outgoingPackets.push_back(PacketManager::PACKET_PAIR(request.socket, data));
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Writes message contents to packet for the transport layer to
///          send.  Begins writing from current write position in packet.
///
///   Message contents are written to the packet following the JAUS standard.
///
///   \param[out] packet Packet to write header and payload data to.
///   \param[out] header Packet transport header data.
///   \param[in] transportHeader Optional parameter for transport header data to
///                              write before the general transport header.
///   \param[in] clearPacket If true, packet contents are cleared before
///                          writing takes place.
///   \param[in] startingSequenceNumber Sequence number to use for packets.
///   \param[in] broadcastFlag Values to use to signify if message should be
///                            sent using any broadcast options (e.g. 
///                            multicast). 0 = no options, 1 = local broadcast,
///                            2 = global broadcast.
///
///   \return FAILURE on error, otherwise number of bytes written.
///
////////////////////////////////////////////////////////////////////////////////////
int Message::Write(Packet& packet, 
                   Header& header,
                   const Packet* transportHeader, 
                   const bool clearPacket,
                   const UShort startingSequenceNumber,
                   const Byte broadcastFlag) const
{
    int total = 0;
    //  Build JAUS header data.
    header.mSourceID = mSourceID;
    header.mDestinationID = mDestinationID;
    header.mPriorityFlag = mPriority;
    header.mControlFlag = Header::DataControl::Single;
    header.mCompressionFlag = Header::Compression::None;
    header.mSequenceNumber = startingSequenceNumber;
    header.mBroadcastFlag = broadcastFlag;

    //  Clear out any previous message data.
    if(clearPacket)
    {
        packet.Clear();
        packet.Reserve(Header::MinSize + USHORT_SIZE + 1);
    }
    unsigned int writePos = packet.GetWritePos();
    
    if(transportHeader && transportHeader->Length() > 0)
    {
        writePos += (unsigned int)packet.Write(*transportHeader);
    }
    //  The first thing we must do is advance
    //  the write position to after the JAUS Header
    //  data.  The header is not written first because
    //  we do not know how large the message body will
    //  be yet.
    packet.SetLength(writePos + Header::PayloadOffset);
    packet.SetWritePos(writePos + Header::PayloadOffset);
    total += packet.Write(mMessageCode);
    int payloadSize = 0;
    if( (payloadSize = WriteMessageBody(packet)) >= 0)
    {
        total += payloadSize;
        // Check for large data set.
        if(total + Header::MinSize > Header::MaxPacketSize)
        {
            return FAILURE;
        }
        else
        {
            header.mSize = total + Header::MinSize;
            packet.SetWritePos(writePos);
            // Go back, and re-write the header since 
            // we now know the size of the message.
            if(header.Write(packet))
            {
                // Set the write position to the end of message we just wrote.
                packet.SetWritePos(writePos + header.mSize);
                //  Return the number of bytes written.
                if(transportHeader)
                {
                    return header.mSize + transportHeader->Length();
                }
                else
                {
                    return header.mSize;
                }
            }
        }
    }

    return FAILURE;
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Method for receiving UDP messages in a continuous loop.
///
////////////////////////////////////////////////////////////////////////////////////
void JUDP::ReceiveThread(void* args)
{
    JUDP* transport = (JUDP*)args;
    Packet udpMessage;
    CxUtils::IP4Address sourceAddress;
    unsigned short sourcePort = 0;
    long int timeoutMs = 100;
    
#ifdef WIN32
    int loopCounter = 0;
#endif

    udpMessage.Reserve(5000);
    Thread* thread = NULL;
    bool primary = false;
    
    if(transport->mPrimaryThreadCreatedFlag == false)
    {
        primary = true;
        transport->mPrimaryThreadCreatedFlag = true;
        thread = &transport->mPrimaryThread;
    }
    else
    {
        thread = &transport->mSecondaryThread;
    }

    while(transport && 
          thread->QuitThreadFlag() == false &&
          transport->mShutdownServiceFlag == false)
    {
        udpMessage.Clear(false);
        sourcePort = 0;
        if(primary)
        {
            if(transport->mInput.Recv(udpMessage, 
                                      5000, 
                                      timeoutMs, 
                                      &sourceAddress, 
                                      &sourcePort) > 0)
            {
                transport->ProcessUDP(udpMessage, sourceAddress, sourcePort);
            }
        }
        else
        {
            if(transport->mMulticast.GetSourcePort() > 0 &&
               transport->mMulticast.Recv(udpMessage, 
                                          5000, 
                                          timeoutMs, 
                                          &sourceAddress, 
                                          &sourcePort) > 0)
            {
                transport->ProcessUDP(udpMessage, sourceAddress, sourcePort);
            }
        }
        
        if(transport->mShutdownServiceFlag)
        {
            break;
        }

        if(transport->mDelayTimeMs == 0)
        {
#ifdef WIN32
            // Only sleep every N loops
            if( loopCounter++ == 250)
            {
                loopCounter = 0;
                CxUtils::SleepMs(1);
            }
#else
            usleep(500);
#endif
        }
        else
        {
            CxUtils::SleepMs(transport->mDelayTimeMs);
        }
    }
    
    //std::cout << "EXIT!\n";
}