Using POSIX MQ from Java - another part

In introduction we managed to create our message queue and to close it. Only thing which is unclear is where is it? Message queue is maintained by kernel and it is created in virtual file system. If we execute in terminal:

cat /proc/filesystems

we will see entry:

nodev    mqueue

If we want to take a closer look at our JNIMQ_1 we will have to mount mqueue. It is nicely described in man pages, just look for mq_overview entry. For lazy people here are commands for mounting message queue, you must do that as root:

# mkdir /dev/mqueue
# mount -t mqueue none /dev/mqueue

After this we should exit root level. Again using man pages we find out that second line is standard form for mount and looks like this mount -t type device dir. Once mounted we can use our standard set of tools for examining file content on Linux, for example:

ls -l /dev/mqueue
cat /dev/mqueue/JNIMQ_1

Now we can go on sending and receiving messages. If we do not specify time-out, those messages and queues will be persisted until system reboots.
Since we have functional message queue, we can nicely start chat. For that reason we will send some messages. We already have queue from last time and we will not create it:

public class SendMessage{ public native int send(String name, int flags, String text); public static void main(String[] args) { int status = new SendMessage().send("/JNIMQ_1",1,"Hello World!"); if(status!=-1) System.out.println("Message dispatched."); else System.out.println("Sending message failed."); } static { System.loadLibrary("SendMessage"); } }

That flags = 1 is open in write only mode. Boring part with javah we are skipping and here is implementation:

#include "SendMessage.h" #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <sys/stat.h> #include <sys/types.h> #include <mqueue.h> JNIEXPORT jint JNICALL Java_SendMessage_send (JNIEnv *env, jobject obj, jstring name, jint flags, jstring text){ mqd_t mq; const char *cstr = (*env)->GetStringUTFChars(env, name, 0); mq = mq_open(cstr, flags); if((mqd_t)-1 == mq){ (*env)->ReleaseStringUTFChars(env, name, cstr); perror("mq_open"); return -1; } const char *ctxt = (*env)->GetStringUTFChars(env, text, 0); int res = mq_send(mq, ctxt, strlen(ctxt)+1, 0); if(res==-1){ perror("mq_send"); return -1; } if((mqd_t)-1 == mq_close(mq)){ perror("mq_close"); return -1; } (*env)->ReleaseStringUTFChars(env, name, cstr); (*env)->ReleaseStringUTFChars(env, text, ctxt); return 0; }

We compile it as described in previous blog entry and send some messages. If we cat /dev/mqueue/JNIMQ_1 we will see that it is growing.
Receiving is equally simple, here is the Java code:

public class GetMessage{ public native String getMessage(String name, int flags, int priority); public static void main(String[] args) { System.out.println(new GetMessage().getMessage("/JNIMQ_1",0,0)); } static { System.loadLibrary("GetMessage"); } }

We want queue opened as read only and we want messages with priority 0. After applying javac and javah we write implementation:

#include "GetMessage.h" #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <sys/stat.h> #include <sys/types.h> #include <mqueue.h> JNIEXPORT jstring JNICALL Java_GetMessage_getMessage (JNIEnv *env, jobject obj, jstring name, jint flags, jint priority){ unsigned int up = priority; char ret[1025]; const char *cstr = (*env)->GetStringUTFChars(env, name, 0); mqd_t mq; mq = mq_open(cstr, flags); if((mqd_t)-1 == mq){ (*env)->ReleaseStringUTFChars(env, name, cstr); perror("mq_open"); return (*env)->NewStringUTF(env,"dud"); } ssize_t bytes_read = mq_receive(mq, ret, 1024, &up); if(bytes_read==-1){ perror("mq_receive"); return (*env)->NewStringUTF(env,"dud"); } ret[bytes_read] = '\0'; if((mqd_t)-1 == mq_close(mq)){ perror("mq_close"); return (*env)->NewStringUTF(env,"dud"); } (*env)->ReleaseStringUTFChars(env, name, cstr); return (*env)->NewStringUTF(env,ret); }

This 1024 should be retrieved from mq attributes, but I am lazy to do that and I still remember how it was created.
In this two examples I deviated from passing mq descriptor to Java, that is what jtux does. Not sure what is more expensive, crossing managed-native border or opening file, so do not ask.