Hi netties,

posted this in a different group already, which seems to be
inappropriate.

I create a message queue with msgget(), sent a 5-byte message to it
with msgsnd() and try to receive the queue's content with msgrcv().
Everything seems to work fine, apart from the fact that I get back
only the last byte back from the original message (after sending the
message ipcs -qA shows clearly that there are 5 Bytes waiting in the
queue).


I am running Solaris 10 8/07 with gcc 3.4.3 as the compiler.


As being not such an experienced C-programmer it could be possible
hat
I am something doing wrong when fiddling around with structures,
pointers etc., but I cannot find it.


The source code (see below) was compiled in the following way:


gcc -fpic msgqueue_tst.c -o mgsqueue_tst


The output is:


Hi there, here is msgget!
msqid: 16777338
msgget: msgget succeeded (msqid: 16777338)
Hi there, here is msgsnd!
msgsnd: message was successfully placed into message queue 16777338.
Hi there, here is msgrcv!
msgflg: 3600
msgtyp: 0
msgrcv: message was successfully read from message queue 16777338.
We finally made it past the invocation ( msgactsz = 1, mtext: o )!


The source:


#include <stdio.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/msg.h>


int main() {


printf("Hi there, here is msgget!\n") ;


/* Parameters */
key_t key = 0 ;
int msgflg = 03600 ;


/* Return value */
int msqid ;


/* Create the message queue */
msqid = msgget( key, msgflg ) ;
printf( "msqid: %i\n", msqid) ;
if ( msqid == -1 )
{


printf("msgget: initializing message queue failed!\n") ;
perror("errno:") ;
return -1 ;


} else
{


printf("msgget: msgget succeeded (msqid: %i)\n", msqid) ;


}


printf("Hi there, here is msgsnd!\n") ;


/* Parameters */
size_t msgsz = 5 ;


struct message {


long mtype ;
const char *mpointer ;


} ;


struct message msg ;


msg.mtype = 0 ;
msg.mpointer = "hello" ;


if ( msgsnd( msqid, msg.mpointer, msgsz, msgflg ) == 0 ) {


printf("msgsnd: message was successfully placed into message
queue %i.\n", msqid) ;


} else
{


printf("msgsnd: sending message to message queue %i failed.
\n", msqid) ;
return -1 ;


}


printf("Hi there, here is msgrcv!\n") ;


/* Parameters */
int msgtyp = 0 ;


struct message_rcv {


long mtype ;
char messtxt[msgsz] ;


} *msg_rcv ;


msg_rcv = malloc( msgsz*sizeof(char) + sizeof(long) ) ;


/* Receive the message */


printf("msgflg: %5o\n", msgflg) ;
printf("msgtyp: %d\n", msgtyp) ;


long msgactsz ; // Actual number of bytes placed in the structure


if ( msgactsz = msgrcv( msqid, msg_rcv, msgsz, msgtyp,
IPC_NOWAIT ) != -1 ) {


printf("msgrcv: message was successfully read from message
queue
%i.\n", msqid) ;


} else
{


printf("msgrcv: receiving message from message queue %i
failed.
\n", msqid) ;
fprintf( stderr, "errno: %i\n", errno ) ;


return -1 ;


}


printf("We finally made it past the invocation ( msgactsz = %d,
mtext: %s )!\n", msgactsz, msg_rcv->messtxt ) ;


return 0 ;



}


Hope somebody can !

Cheers


Bernd

bernd wrote:
> Hi netties,
>
> posted this in a different group already, which seems to be
> inappropriate.
unfortunatly you're wrong here too as messages queue are not part of the C
standard, try comp.unix.programmer.

Bye, Jojo

On 27 May 2008 at 10:59, bernd wrote:
> I create a message queue with msgget(), sent a 5-byte message to it
> with msgsnd() and try to receive the queue's content with msgrcv().
> Everything seems to work fine, apart from the fact that I get back
> only the last byte back from the original message (after sending the
> message ipcs -qA shows clearly that there are 5 Bytes waiting in the
> queue).

First up, there are several minor problems with your code (a missing
header, wrong format specifier for printf, an assignment needing
parentheses to do what you want it to do...), all of which you can find
by turning up the warning level on gcc. Another fairly serious problem
is that you declare an array of length msgsz, where msgsz is a variable.
You can't do that, even with C99's VLAs, since your array is a member of
a structure.

For now, let's replace

> size_t msgsz = 5 ;

with
#define msgsz 6
which will also give us space for the null-terminator at the end of the
"hello" string.

As to your actual problem, it's in the sending stage.

> struct message {
> long mtype ;
> const char *mpointer ;
> } ;
> struct message msg ;
>
> msg.mtype = 0 ;
> msg.mpointer = "hello" ;
>
> if ( msgsnd( msqid, msg.mpointer, msgsz, msgflg ) == 0 ) {
[snip]

The first thing to note is that msg.mtype must be > 0.

The second thing is that the second argument to msgsnd needs to be a
pointer to a struct message: use &msg instead of msg.mpointer.

But the really slippery point is that this is one of those occasions
when arrays and pointers aren't interchangeable. Let's suppose for the
sake of argument that msg.mpointer is at address 0xDEADBEEF, and think
about what msgsnd is going to do when you pass it &msg. It will try to
read msgsz (i.e. 6) characters from memory locations 0xDEADBEEF,
0xDEADBEF0, ..., 0xDEADBEF4. That's unfortunate, because 0xDEADBEEF
through 0xDEADBEF2 (on a 32-bit system) contain a pointer to the string
literal "hello" in the data segment of your program, while the last two
bytes are garbage.

So you should change the sending code to look like this:

struct message {
long mtype ;
char mtext[msgsz];
} ;
struct message msg;

msg.mtype = 1;
strcpy(msg.mtext, "hello");

if ( msgsnd( msqid, &msg, msgsz, msgflg ) == 0 ) {
...