Access violation reading location. Heap corruption. Boost thread - c++

Question

I'm trying to create an multithreaded graphical network application using boost, raknet and irrlicht.
I use one thread that receives messages and another thread to proccess the messages and all the graphical work.
this is the error screen I'm getting
First-chance exception at 0x77183c8d in
NetSystemForVideogamesServerTester.exe: 0xC0000005: Access violation reading location 0x0d99d472
this is the output window information
HEAP[NetSystemForVideogamesServerTester.exe]: HEAP: Free Heap block
da58d10 modified at da58fe0 after it was freed Windows has triggered a
breakpoint in NetSystemForVideogamesServerTester.exe.
This may be due to a corruption of the heap, which indicates a bug in
NetSystemForVideogamesServerTester.exe or any of the DLLs it has
loaded.
This may also be due to the user pressing F12 while
NetSystemForVideogamesServerTester.exe has focus.
The output window may have more diagnostic information.
this is when I launch the thread
void receive()
{
boost::thread(&IConnectionInstance::receiveInThread, this);
}
mutex declaration
boost::mutex mMessagesReceived;
this is the code from the receiving thread
void RakNetConnectionInstance::receiveInThread()
{
Packet* packet;
IMessage* message = NULL;
long time = 0;
while (true)
{
message = NULL;
packet = aPeer->Receive();
while (packet)
{
RakNet::BitStream* dataStream = new RakNet::BitStream(packet->data, packet->length, false);
dataStream->IgnoreBits(sizeof(unsigned char)*8);
switch (packet->data[0])
{
case ID_TIMESTAMP:
{
dataStream->Read(time);
int countMessagesAggregated = 0;
dataStream->Read(countMessagesAggregated);
unsigned char messageType = char();
IBitStream* bitStream = new RakNetBitStream(dataStream);
while(countMessagesAggregated > 0)
{
dataStream->Read(messageType);
switch ((EMESSAGE_TYPE)messageType)
{
case EACTOR_CONTENT_MESSAGE:
message = new CActorContentMessage(aUserDataFactory);
break;
case EWORLD_CONTENT_MESSAGE:
message = new CWorldClientContentMessage(aUserDataFactory);
break;
case EUSER_COMMAND_MESSAGE:
message = new CUserCommandMessage(aEventFactory);
break;
case EPREDICTION_MESSAGE:
message = new CPredictionMessage(aUserDataFactory);
break;
case EPREDICTION_RESPONSE_MESSAGE:
message = new CPredictionResponseMessage(aUserDataFactory);
break;
}
countMessagesAggregated --;
if (messageType >= EUSER_MESSAGE && aCustomReceiver)
{
aCustomReceiver->receiveCustomMessages();
}
if (message)
{
message->readFromBitStream(bitStream);
message->setTimeMS(time);
message->setIPAddress(packet->systemAddress.ToString(false));
message->setPort(packet->systemAddress.port);
mMessagesReceived.lock();
aMessagesReceivedQueue.push(message);
printf("adicionando mensaje a cola en lock\n");
mMessagesReceived.unlock();
message = NULL;
}
}
}
break;
}
if (message)
{
message->setTimeMS(time);
message->setIPAddress(packet->systemAddress.ToString(false));
message->setPort(packet->systemAddress.port);
mMessagesReceived.lock();
aMessagesReceivedQueue.push(message);
mMessagesReceived.unlock();
}
aPeer->DeallocatePacket(packet);
packet = aPeer->Receive();
}
if (RakNet::GetTimeMS() - aBeginTimeSearchServersActives > aWaitTimeServersActives && !aTimeOut)
{
boost::mutex::scoped_lock lock(mTimeOut);
aTimeOut = true;
}
}
}
here I attend the messages from queue in the proccessing thread
void CMessageManager::attendMessages()
{
std::queue<IMessage*> messages = aConnectionInstance->getMessagesReceivedFromQueue();
while(!messages.empty())
{
notifyMessage(messages.back());
aConnectionInstance->popMessageReceivedFromQueue();
messages.pop();
}
}
here I access the message queue
std::queue<IMessage*> RakNetConnectionInstance::getMessagesReceivedFromQueue()
{
boost::mutex::scoped_lock lock(mMessagesReceived);
std::queue<IMessage*> messages;
messages = aMessagesReceivedQueue;
return messages;
}
and finally here I delete the message from queue
void RakNetConnectionInstance::popMessageReceivedFromQueue()
{
boost::mutex::scoped_lock lock(mMessagesReceived);
if (!aMessagesReceivedQueue.empty())
{
aMessagesReceivedQueue.pop();
}
}
I'm new to c++ and multithreading, Please help me, What am I doing wrong?
Thanks in advance.

Answer 1

You don't remove the messages from the original queue, you just copy the pointers to a new queue. So the following happens:
You receive a message. A pointer to it goes on the queue.
You copy the queue, process the message, and delete it.
You receive another message.
You copy the queue. It still contains a pointer to the first message though.
You access the pointer to the first message that you deleted.
This code is broken because it copies the queue leaving the original unmodified:
std::queue<IMessage*> RakNetConnectionInstance::getMessagesReceivedFromQueue()
{
boost::mutex::scoped_lock lock(mMessagesReceived);
std::queue<IMessage*> messages;
messages = aMessagesReceivedQueue;
return messages;
}