Question

A program written in C++ reads from a network socket and then writes to local socket. It uses a separate thread for the “read”.

When a message is read, it is put into a char * queue (using mutex from the boost libraries to make it thread-safe).

Meanwhile the queue is checked to see if it is empty, if it isn’t, then the first message is popped from the queue (again using mutex) and written to the local socket as a char *.

My issue is: when a message of 4 bytes is pushed onto the queue, the queue saves it without issue, however when writing the message back out again, it has increased the message to eight bytes! The “new” four bytes are zero.

---

Example A

Message in: {4,0,0,0}
Saved to queue as; <4>, <0>, <0>, <0>
Read from queue as:  <4>, <0>, <0>, <0>, <0>, <0>, <0>, <0>

---

Example B

Message in: {4,0,0,0,8,0,0,0}
Saved to queue as; <4>, <0>, <0>, <0>, <8>, <0>, <0>, <0>
Read from queue as:  <4>, <0>, <0>, <0>, <8>, <0>, <0>, <0>

---

Any ideas as to the reason for this? Can the queue class only cope with a minimum number of chars? (Wouldn’t have thought so as there’s the “empty” method).
(This isn’t a major issue, as I never talk in less than eight bytes; I just want to know in case it comes up and attacks me later on in life.)

I did a bit of digging around online and through the documentation and found the odd referece to a buffer, but that seems to be more to do with using the queue as a buffer, rather than it having one…

Other information;

OS: RedHat

IDE: Eclipse

---

Code: Queue

//Thread-safe call to save the message to the queue
void MessageQueue::SaveToQueue(char* Data)
{
// Lock the mutex to prevent any other threads accessing this member (released when method exits).
boost::mutex::scoped_lock l(m_Msg);

//int i = 0;
//while (i < sizeof(Data))//iLength)
//{
//  unsigned int ByteVaule = Data[i];//pBuffer[i];//ByteValue = int(pBuffer[i]);//unsigned int(pBuffer[i]);
//  cout << "Buffer in Queue" << i << ": " << ByteVaule << endl;
//  i++;
//}

MsgQ.push(Data);
}

//Thread-safe call to get the message from the queue
char* MessageQueue::GetFromQueue()
{
// Lock the mutex to prevent any other threads accessing this member (released when method exits).
boost::mutex::scoped_lock l(m_Msg);
char* message = MsgQ.front();
MsgQ.pop();
return message;
}

//Thread-safe call to check if the queue is empty
bool MessageQueue::IsEmpty()
{
// Lock the mutex to prevent any other threads accessing this member (released when method exits).
boost::mutex::scoped_lock l(m_Msg);
return MsgQ.empty();
}

---

Code: Manager
int iStatus = 0;

//Start class to store message queue
MessageQueue* pQueue = new MessageQueue();

// Current hard coded value for the write scoket location
// TODO: change this to reading from enviroment variable
string WritePath = "DefaultSocket";

ReadSocket* pRead = new ReadSocket();
WriteSocket* pWrite = new WriteSocket();
cout << "Creating read socket" << endl;
iStatus = pRead->CreateSocket(pQueue);
cout << "Creating write socket." << endl;
iStatus = pWrite->CreateSocket(WritePath);

//while is running, check the message container and process it as needed
while (pRead->IsRunning())
{
    while (!(pQueue->IsEmpty()))
    {
        char* Msg = pQueue->GetFromQueue();

        iStatus = pWrite->WriteToSocket(Msg);
        // TODO: catch on failure
    }
    //sleep(1);
}
//Destroy sockets as program is closing
pWrite->~WriteSocket();
pRead->~ReadSocket();

// TODO: add exception?
//Token return
return iStatus;

---

To save making this too long and complex the read and write sockets are the same as in

http://www.linuxhowtos.org/C_C++/socket.htm

The read char* is saved to the queue using the

SaveToQueue()

method and taken from the queue using the

GetFromQueue

method.

Answer 1

std::queue has no such limitation. What you are seeing must be the result of problems in your code. (You say yourself, that you never take in less than 8 bytes?!)

Edit: What seems odd in the code samples is memory management (explicit calls to destructors, instead of delete; the memory of the char* -s doesn’t seem to be released – how is it allocated?).