Inter process communication using Message Queues (mq) -2

In the previous post we saw the various functions available for creation of message queues.

Now let us look at an example for creating and communication using message queues.

The first step is to create a message queue using mq_open

mqd_t q2; q2 = mq_open("/test_q",O_CREAT,0666,NULL);

Note that the name of the message queue begins with a "/" which is mandatory.

The flag O_CREAT signifies that the queues is being created new, and we are not opening a previously existing queue.

0666 gives read and write permissions to every one

We are creating the queue with default attributes hence leaving the last argument as NULL.

If a process wants to recieve data from the queue, it will need a buffer into which the data will have to be placed, hence we create a buffer for 10 characters as follows.

char *buf; buf = malloc(10*sizeof(char));

To recieve data from the queue we need to make use of the function mq_receive, which requires the attribute, "message size", of the queue to be passed to it.

To get the message size of the queue we created we need to make use of the function mq_getattr as follows.

struct mq_attr *attr1; attr1 = malloc(sizeof(struct mq_attr)); mq_getattr(q2, attr1);

We allocate memory for the structure and then pass the queue descriptor and the structure pointer to mq_getattr, which fills the strucutre with the relevant data.

Now we can get the message size from the structure by accessing the mq_msgsize field, i.e. attr1->mq_msgsize.

Now we can call mq_recevie to get data from the queue .

mq_receive(q2,buf,attr1->mq_msgsize,NULL); q2: Queue descriptor buf: Buffer to recieve data mq_msgsize: Size of the messages on the queue. We are not looking into the priority of the message as of now hence we can leave the last argument as null.

The full code would look as follows.

recieve.c #include "fcntl.h" /* For O_* constants */ #include "sys/stat.h" /* For mode constants */ #include "mqueue.h" #include <stdio.h> main() { mqd_t q2; char *buf; struct mq_attr *attr1; attr1 = malloc(sizeof(struct mq_attr)); q2 = mq_open("/test_q",O_CREAT,0666,NULL); if(q2 == -1) { printf("Error"); } printf("q = %d\n",q2); buf = malloc(10*sizeof(char)); mq_getattr(q2, attr1); mq_receive(q2,buf,attr1->mq_msgsize,NULL); printf("\n Message = %s\n",buf); }

Now we need a process to send the messages into the queue.

To send messages we again need to open the queue, but no create it. Hence the call to mq_open would be

mqd_t q1; q1 = mq_open("/test_q",O_RDWR);

Note that the name of the queue, test_q, is same as the one we used while creation making sure that we are sending and receiving on the same queue.

Let us create a buffer having data that has to be sent.

char *buf = "hello" ;

To send data we make use of the function mq_send.

mq_send(q1,buf,strlen(buf),1); q1: Queue descriptor buf: Buffer containing the data to be sent. strlen(buf) : lengt of data to be sent 1: Priority of the message being sent.

The full code will look as follows

send.c #include "fcntl.h" /* For O_* constants */ #include "sys/stat.h" /* For mode constants */ #include "mqueue.h" #include <stdio.h> main() { mqd_t q1; char *buf="hello"; q1 = mq_open("/test_q",O_RDWR); if(q1 == -1) { printf("Error"); } mq_send(q1,buf,strlen(buf),1); }

To see the queue in operation, open a terminal and compile the above two programs.

Note that for compiling these we need to pass the option "-lrt" to the compiler.

cc -lrt recieve.c -o recieve cc -lrt send.c -o send

Open two terminals and go the directory where the above executable were created.

In the first terminal execute the recieve program

./recieve

The terminal should go into a wait state, waiting for a message. (It is a blocking receive)

Open the second terminal and execute the send program

./send

As soon as the send program is executed, the terminal waiting in the receive program will recieve the message, and print the same before exiting.

Thus the two processes could communicate with each other using the message queues.

In the future posts we will see how can the message priority be used.