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.

Using POSIX MQ from Java - Introduction

All this is taking place on Linux Mint but should work on any other Linux. JDK is Oracle JDK, I am doing Android programming and it requires Oracle JDK, OpenJDK should do fine but path will differ. Goal of this introduction is to create new message queue and to close it - nothing else.
As usually in JNI workflow we write Java code:

public class PosixMQ { public native long mq_open(String name, int flags); public native int mq_close(long desc); public static void main(String[] args) { PosixMQ pmq = new PosixMQ(); long desc = pmq.mq_open("/JNIMQ_1",64); if(desc!=-1L){ System.out.println("We have MQ open."); System.out.println("Close returned " + pmq.mq_close(desc)); }else{ System.out.println("Open failed."); } } static { System.loadLibrary("PosixMQ"); } }

Idea about storing pointer to data structure into long is from jtux project, otherwise it should be message queue descriptor or (mqd_t)-1 in case of failure. Queue name must start with slash and 64 is O_CREAT | O_RDONLY we want queue to be created and to be read only for us. Now we compile PosixMQ.java and we run javah on class to get header for C implementation. On my box it looks like this:

/usr/lib/jvm/java-7-oracle/bin/javah -jni PosixMQ

Interesting part of PosixMQ.h looks like this:

/* * Class: PosixMQ * Method: mq_open * Signature: (Ljava/lang/String;I)J */ JNIEXPORT jlong JNICALL Java_PosixMQ_mq_1open (JNIEnv *, jobject, jstring, jint); /* * Class: PosixMQ * Method: mq_close * Signature: (J)I */ JNIEXPORT jint JNICALL Java_PosixMQ_mq_1close (JNIEnv *, jobject, jlong);

Finally we write trivial C implementation, being careful to include all required imports:

#include "PosixMQ.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 jlong JNICALL Java_PosixMQ_mq_1open (JNIEnv *env, jobject obj, jstring name, jint flags){ struct mq_attr attr; attr.mq_flags = 0; attr.mq_maxmsg = 10; attr.mq_msgsize = 1024; attr.mq_curmsgs = 0; const char *str = (*env)->GetStringUTFChars(env, name, 0); mqd_t desc; desc = mq_open(str, flags, 0644, &attr); (*env)->ReleaseStringUTFChars(env, name, str); return (intptr_t)desc; } JNIEXPORT jint JNICALL Java_PosixMQ_mq_1close (JNIEnv *env, jobject obj, jlong desc){ return mq_close((mqd_t)(intptr_t)desc); }

I was too lazy to pass attributes around, it should be done at later stage. Permissions are also conveniently hardcoded, though passing octal through parameter list is not difficult. To compile this I used:

gcc -I/usr/lib/jvm/java-7-oracle/include -I/usr/lib/jvm/java-7-oracle/include/linux -o libPosixMQ.so -shared -fPIC PosixMQ.c -lrt

Switch -fPIC will not be required on 32 bit Linux and -lrt instruction to link against the real-time is required everywhere. To run it we do:

java -Djava.library.path=. PosixMQ

in directory where are binaries and we see:

We have MQ open.
Close returned 0

Not very impressive but again very simple. Maybe next time we send and receive some messages, who knows.