c++ msgsnd and msgrvc stuck in sleep - c++

Question

I have small C++ program where main process is "creating data" and sends them to the child (fork) process which should read that data. My problem is that in school my code works well, but on my own laptop both processes get stuck right after the program start. Specifically both of them are in Waiting Channel "do_msgrcv".
Here is my code:
#define VYROBA 1 // Manufacturer
#define PREPRAVA 2 // Transport
void manufacturer ( ) {
static int count = 0;
int rcv [ 2 ];
while ( 1 ) {
int snd [ 2 ] = { VYROBA, count };
int ret = msgsnd ( glb_msg_id, &snd, sizeof ( int ), 0 );
ret = msgrcv ( glb_msg_id, &rcv, sizeof ( int ), PREPRAVA, 0 );
printf ( "Got crate\n" );
}
}
void consumer ( ) {
static int count = 0;
int rcv [ 2 ];
while ( 1 ) {
int ret = msgrcv ( glb_msg_id, &rcv, sizeof ( int ), VYROBA, 0 );
usleep ( 500000 );
if ( ret < 0 ) {
printf ( "Can't read message.\n" );
}
printf ( "Got product: %d\r\n", rcv [ 1 ] );
fflush ( stdout );
rcv [ 1 ]++;
if ( rcv [ 1 ] == 10 ) {
int snd [ 2 ] = { PREPRAVA, rcv [ 1 ] };
ret = msgsnd ( glb_msg_id, &snd, sizeof ( int ), 0 );
} else {
ret = msgsnd ( glb_msg_id, &rcv, sizeof ( int ), 0 );
}
}
}
If it helps in school we have Ubuntu 12.04 and I'm using Ubuntu 16.04.
Thanks for any help.

Answer 1

You are using the system V message queue, which is supported by the linux kernel since version 2.6, so both Ubuntu versions you consider.
Now if you look at the manual, msgrcv() and msgsnd() use a message buffer, hwich should have the structure:
struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[1]; /* message data */
};
As soon as you start not using this structure but some manually managed buffer, you have the risk of getting non portable code (e.g. you have to ensure that the right sizes and padding, to take into consideration endianness, etc...). And this is certainly what happens here.
The message structure starts with a message type coded as long which you assume to be same as int (the first element of your array). But the C++ standard doesn't fix the size of int and long (only their minimum size): this size may vary between platforms, compilers and CPU architecture. For instance:
if at university you run Ubuntu 32 bits, int and long would both be 32 bits and have the same size. Your code works.
If you run Ubuntu 64 bits at home, your long would be 64 bits, whereas the int would still be 32 bits. So your buffers would be too short, causing msgsnd() and msgrcv() to overwlow the buffers. This would be undefined behaviour, not speaking of the fact that the message type would be corrupted.
I think that changing your code and use the right structure for the buffer should solve the problem.
Additional remark
By the way, your forking logic makes manufacturer() being executed twice: on the original process, but also on the forked ones once consumer finished !
if ( !fork ( ) ) {
consumer ( );
}
manufacturer ( );
Better use an else to make sure it's used only where it is supposed to be.