[moira.git] / webmoira / moirai.c

/* $Header$ */
#include "mit_moira_MoiraConnectInternal.h"
#include <moira.h>
#include <mr_et.h>
#include <malloc.h>
#include <string.h>
#include <stdio.h>

static void throwMoiraException(JNIEnv *env, int code)
{
    char buffer[1024];
    jmethodID mid;
    jobject tothrow;
    jclass IOE;
    jstring jmess;

    IOE = (*env)->FindClass(env, "mit/moira/MoiraException");
    if (IOE == NULL) {
	fprintf(stderr, "moirai: No Class\n");
	goto die;
    }
    mid = (*env)->GetMethodID(env, IOE, "<init>", "(Ljava/lang/String;I)V");
    if (mid == NULL) {
	fprintf(stderr, "moirai: No Method\n");
	goto die;
    }
    sprintf(buffer, "%s", error_message(code));
    jmess = (*env)->NewStringUTF(env, buffer);
    if (jmess == NULL) {
	fprintf(stderr, "Cannot get new string\n");
	goto die;
    }
    tothrow = (*env)->NewObject(env, IOE, mid, jmess, (jint) code);
    if (tothrow == NULL) {
	fprintf(stderr, "moirai: No Throw\n");
	goto die;
    }
    (*env)->Throw(env, (jthrowable) tothrow);
    return;
 die:
    abort();
    return;
}

static void throwMoiraExceptionMess(JNIEnv *env, char *mess)
{
    jclass IOE = (*env)->FindClass(env, "mit/moira/MoiraException");
    if (IOE == NULL) abort();
    (*env)->ThrowNew(env, IOE, mess);
    return;
}

JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_connect(JNIEnv *env,
							 jclass Class, jstring server) {
    int status;
    char buffer[1024];
    const char *aserver = (*env)->GetStringUTFChars(env, server, 0);
    if (strlen(aserver) > sizeof(buffer)) abort();
    strcpy(buffer, aserver);
    (*env)->ReleaseStringUTFChars(env, server, aserver);
    status = mr_connect(buffer);
    if (status != MR_SUCCESS) throwMoiraException(env, status);
    status = mr_version(2);
    if (status != MR_SUCCESS) {
	if (status == MR_VERSION_LOW) return; /* This is OK */
	else {
	    mr_disconnect();
	    throwMoiraException(env, status);
	}
    }
    return;
}

JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_proxy(JNIEnv *env,
						       jclass Class,
						       jstring jUser) {
    int status;
    char buffer[1024];
    const char *user = (*env)->GetStringUTFChars(env, jUser, 0);
    if (strlen(user) > sizeof(buffer)) abort();
    strcpy(buffer, user);
    (*env)->ReleaseStringUTFChars(env, jUser, user);
    status = mr_proxy(buffer, "Java");
    if (status != MR_SUCCESS) throwMoiraException(env, status);
    return;
}


JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_auth(JNIEnv *env,
						      jclass Class) {
    int status;
    status = mr_krb5_auth("JavaInterface");
    if (status != MR_SUCCESS) throwMoiraException(env, status);
    return;
}

JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_disconnect
    (JNIEnv *env, jclass Class) {
    mr_disconnect();
    return;
}
	
typedef struct ArgBlock {
    int alloccount;
    int count;
    char **stringval;
} ArgBlock;

typedef struct ListBlock {
    int alloccount;
    int count;
    ArgBlock **Args;
} ListBlock;

static jobjectArray ArgBlockToJavaArray(JNIEnv *env, ArgBlock *argb);
static jobjectArray ListBlockToJavaArray(JNIEnv *env, ListBlock *lb);

extern int mr_query(char *name, int argc, char **argv,
		int (*proc)(int, char **, void *), void *hint);
static ListBlock *NewListBlock();
static ArgBlock *NewArgBlock();
static void FreeListBlock(ListBlock *);
static int StashResults(int argc, char **argv, void *callback);
static char **ConvertJavaArgs(JNIEnv *env, jobjectArray jargs);
static void FreeArgs(char **args);

JNIEXPORT jobjectArray JNICALL Java_mit_moira_MoiraConnectInternal_mr_1query
    (JNIEnv *env, jclass Class, jstring jcommand, jobjectArray jargs) {
    ListBlock *listblock = NewListBlock();
    jobjectArray retval;
    int status;
    const char *command;
    char icommand[1024];
    char **args = ConvertJavaArgs(env, jargs);
    if (args == NULL) return (NULL); /* It probably thru an exception */
    command = (*env)->GetStringUTFChars(env, jcommand, 0);
    strncpy(icommand, command, sizeof(icommand));

    status = mr_query(icommand, (*env)->GetArrayLength(env, jargs), args, 
			 StashResults, listblock);
    FreeArgs(args);			/* Don't need them anymore */
    if (status != MR_SUCCESS) {
	FreeListBlock(listblock);
	throwMoiraException(env, status);
	return (0);
    }
    /*    if (listblock->count == 0) { / * No such list or empty list * /
	FreeListBlock(listblock);
	throwMoiraExceptionMess(env, "No Such List or Empty List");
	return(0);
    } */

    if (listblock->count == 0) return (0);

    retval = ListBlockToJavaArray(env, listblock);
    FreeListBlock(listblock);
    return (retval);

}

static ArgBlock *NewArgBlock() {
    ArgBlock *argb = (ArgBlock *)malloc(sizeof(ArgBlock));
    argb->alloccount = 10;
    argb->stringval = (char **) malloc(10 * sizeof(char *));
    argb->count = 0;
    return (argb);
}

static void AddArg(ArgBlock *argb, char *arg) {
    int i;
    if (argb->alloccount <= (argb->count + 1)) {
	char **st = malloc((2 * argb->alloccount) * sizeof(char *));
	argb->alloccount *= 2;
	for (i = 0; i < argb->count; i++)
	    st[i] = argb->stringval[i];
	free(argb->stringval);
	argb->stringval = st;
    }
    argb->stringval[argb->count++] = arg;
}

static ListBlock *NewListBlock() {
    ListBlock *list = (ListBlock *)malloc(sizeof(ListBlock));
    list->alloccount = 10;
    list->Args = (ArgBlock **) malloc(10 * sizeof(ArgBlock *));
    list->count = 0;
    return (list);
}

static void FreeArgBlock(ArgBlock *argb) {
    int i;
    for (i = 0; i < argb->count; i++) free(argb->stringval[i]);
    free(argb->stringval);
    free(argb);
}

static void FreeListBlock(ListBlock *list) {
    int i;
    for (i = 0; i < list->count; i++) FreeArgBlock(list->Args[i]);
    free(list->Args);
    free(list);
}

static jobjectArray ArgBlockToJavaArray(JNIEnv *env, ArgBlock *argb) {
    jobjectArray retval;
    int i;
    retval = (*env)->NewObjectArray(env, argb->count,
				    (*env)->FindClass(env, "java/lang/String"),
				    NULL);
    for (i = 0; i < argb->count; i++) {
	(*env)->SetObjectArrayElement(env, retval, i,
				      (*env)->NewStringUTF(env, argb->stringval[i]));
    }
    return (retval);
}

static jobjectArray ListBlockToJavaArray(JNIEnv *env, ListBlock *lb) {
    jobjectArray retval;
    int i;
    retval = (*env)->NewObjectArray(env, lb->count,
				    (*env)->FindClass(env, "java/lang/Object"),
				    NULL);
    for (i = 0; i < lb->count; i++)
	(*env)->SetObjectArrayElement(env, retval, i,
				      ArgBlockToJavaArray(env, lb->Args[i]));
    return (retval);
}

static int StashResults(int argc, char **argv, void *callback) {
    ListBlock *list = (ListBlock *) callback;
    ArgBlock *argb;
    char *arg;
    int i;

    /* printf("DEBUG: StashResults argc = %d\n", argc);
     * for (i = 0; i < argc; i++)
     * printf("DEBUG: StashResults argv[%d] = %s\n", i, argv[i]);
     */

    while (list->alloccount <= (list->count + 1)) {
	ArgBlock **args = (ArgBlock **) malloc(list->alloccount * 2 * sizeof(char *));
	list->alloccount = list->alloccount * 2;
	for(i = 0; i < list->count; i++) {
	    args[i] = list->Args[i];
	}
	free(list->Args);
	list->Args = args;
    }

    argb = NewArgBlock();

    for (i = 0; i < argc; i++) {
	arg = (char *) malloc(strlen(argv[i]) + 1);
	strcpy(arg, argv[i]);
	AddArg(argb, arg);
    }
    list->Args[list->count++] = argb;
    return (0);
}

static char **ConvertJavaArgs(JNIEnv *env, jobjectArray jargs) {
    char **retval;
    int i, j;
    const char *iarg;
    int length = (*env)->GetArrayLength(env, jargs);
    if (length == 0) {		/* Does this happen in a non-error situation? */
	retval = (char **) malloc(sizeof (char *));
	retval[0] = NULL;
	return(retval);
    }
    retval = (char **) malloc((length + 1) * sizeof(char *));
    for (i = 0; i < length; i++) {
	jobject jarg = (*env)->GetObjectArrayElement(env, jargs, i);
	if ((*env)->ExceptionOccurred(env)) {
	    for (j = 0; j < i; j++) free(retval[j]);
	    free (retval);
	    return (NULL);
	}
	iarg = (*env)->GetStringUTFChars(env, jarg, 0);
	if ((*env)->ExceptionOccurred(env)) {
	    for (j = 0; j < i; j++) free(retval[j]);
	    free (retval);
	    return (NULL);
	}
	retval[i] = malloc(strlen(iarg) + 1);
	strcpy(retval[i], iarg);
	(*env)->ReleaseStringUTFChars(env, jarg, iarg);
    }
    retval[length] = NULL;
    return (retval);
}

static void FreeArgs(char **args) {
    int i;
    i = 0;
    while (args[i] != NULL) free(args[i++]);
    free(args);
}
Commit	Line	Data
c7f8876d	1	/* $Header$ */
bde1652c	2	#include "mit_moira_MoiraConnectInternal.h"
	3	#include <moira.h>
	4	#include <mr_et.h>
	5	#include <malloc.h>
	6	#include <string.h>
	7	#include <stdio.h>
	8
	9	static void throwMoiraException(JNIEnv *env, int code)
	10	{
	11	char buffer[1024];
	12	jmethodID mid;
	13	jobject tothrow;
	14	jclass IOE;
	15	jstring jmess;
	16
	17	IOE = (*env)->FindClass(env, "mit/moira/MoiraException");
	18	if (IOE == NULL) {
	19	fprintf(stderr, "moirai: No Class\n");
	20	goto die;
	21	}
	22	mid = (*env)->GetMethodID(env, IOE, "<init>", "(Ljava/lang/String;I)V");
	23	if (mid == NULL) {
	24	fprintf(stderr, "moirai: No Method\n");
	25	goto die;
	26	}
	27	sprintf(buffer, "%s", error_message(code));
	28	jmess = (*env)->NewStringUTF(env, buffer);
	29	if (jmess == NULL) {
	30	fprintf(stderr, "Cannot get new string\n");
	31	goto die;
	32	}
	33	tothrow = (*env)->NewObject(env, IOE, mid, jmess, (jint) code);
	34	if (tothrow == NULL) {
	35	fprintf(stderr, "moirai: No Throw\n");
	36	goto die;
	37	}
	38	(*env)->Throw(env, (jthrowable) tothrow);
	39	return;
	40	die:
	41	abort();
	42	return;
	43	}
	44
	45	static void throwMoiraExceptionMess(JNIEnv env, char mess)
	46	{
	47	jclass IOE = (*env)->FindClass(env, "mit/moira/MoiraException");
	48	if (IOE == NULL) abort();
	49	(*env)->ThrowNew(env, IOE, mess);
	50	return;
	51	}
	52
	53	JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_connect(JNIEnv *env,
	54	jclass Class, jstring server) {
	55	int status;
	56	char buffer[1024];
	57	const char aserver = (env)->GetStringUTFChars(env, server, 0);
	58	if (strlen(aserver) > sizeof(buffer)) abort();
	59	strcpy(buffer, aserver);
	60	(*env)->ReleaseStringUTFChars(env, server, aserver);
	61	status = mr_connect(buffer);
	62	if (status != MR_SUCCESS) throwMoiraException(env, status);
	63	status = mr_version(2);
	64	if (status != MR_SUCCESS) {
	65	if (status == MR_VERSION_LOW) return; /* This is OK */
66	else {
67	mr_disconnect();
68	throwMoiraException(env, status);
69	}
70	}
71	return;
72	}
73
74	JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_proxy(JNIEnv *env,
75	jclass Class,
76	jstring jUser) {
77	int status;
78	char buffer[1024];
79	const char user = (env)->GetStringUTFChars(env, jUser, 0);
80	if (strlen(user) > sizeof(buffer)) abort();
81	strcpy(buffer, user);
82	(*env)->ReleaseStringUTFChars(env, jUser, user);
83	status = mr_proxy(buffer, "Java");
84	if (status != MR_SUCCESS) throwMoiraException(env, status);
85	return;
86	}
87
88
89	JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_auth(JNIEnv *env,
90	jclass Class) {
91	int status;
991417e4	92	status = mr_krb5_auth("JavaInterface");
bde1652c	93	if (status != MR_SUCCESS) throwMoiraException(env, status);
	94	return;
	95	}
	96
	97	JNIEXPORT void JNICALL Java_mit_moira_MoiraConnectInternal_disconnect
	98	(JNIEnv *env, jclass Class) {
	99	mr_disconnect();
	100	return;
	101	}
	102
	103	typedef struct ArgBlock {
	104	int alloccount;
	105	int count;
	106	char **stringval;
	107	} ArgBlock;
	108
	109	typedef struct ListBlock {
	110	int alloccount;
	111	int count;
	112	ArgBlock **Args;
	113	} ListBlock;
	114
	115	static jobjectArray ArgBlockToJavaArray(JNIEnv env, ArgBlock argb);
	116	static jobjectArray ListBlockToJavaArray(JNIEnv env, ListBlock lb);
	117
	118	extern int mr_query(char name, int argc, char *argv,
	119	int (proc)(int, char , void ), void *hint);
	120	static ListBlock *NewListBlock();
	121	static ArgBlock *NewArgBlock();
	122	static void FreeListBlock(ListBlock *);
	123	static int StashResults(int argc, char *argv, void callback);
	124	static char *ConvertJavaArgs(JNIEnv env, jobjectArray jargs);
	125	static void FreeArgs(char **args);
	126
	127	JNIEXPORT jobjectArray JNICALL Java_mit_moira_MoiraConnectInternal_mr_1query
	128	(JNIEnv *env, jclass Class, jstring jcommand, jobjectArray jargs) {
	129	ListBlock *listblock = NewListBlock();
	130	jobjectArray retval;
	131	int status;
	132	const char *command;
	133	char icommand[1024];
	134	char **args = ConvertJavaArgs(env, jargs);
	135	if (args == NULL) return (NULL); /* It probably thru an exception */
	136	command = (*env)->GetStringUTFChars(env, jcommand, 0);
	137	strncpy(icommand, command, sizeof(icommand));
	138
	139	status = mr_query(icommand, (*env)->GetArrayLength(env, jargs), args,
	140	StashResults, listblock);
	141	FreeArgs(args); /* Don't need them anymore */
	142	if (status != MR_SUCCESS) {
	143	FreeListBlock(listblock);
	144	throwMoiraException(env, status);
	145	return (0);
	146	}
	147	/* if (listblock->count == 0) { / * No such list or empty list * /
	148	FreeListBlock(listblock);
	149	throwMoiraExceptionMess(env, "No Such List or Empty List");
	150	return(0);
	151	} */
	152
	153	if (listblock->count == 0) return (0);
	154
	155	retval = ListBlockToJavaArray(env, listblock);
	156	FreeListBlock(listblock);
157	return (retval);
158
159	}
160
161	static ArgBlock *NewArgBlock() {
162	ArgBlock argb = (ArgBlock )malloc(sizeof(ArgBlock));
163	argb->alloccount = 10;
164	argb->stringval = (char *) malloc(10 sizeof(char *));
165	argb->count = 0;
166	return (argb);
167	}
168
169	static void AddArg(ArgBlock argb, char arg) {
170	int i;
171	if (argb->alloccount <= (argb->count + 1)) {
172	char *st = malloc((2 argb->alloccount) * sizeof(char *));
173	argb->alloccount *= 2;
174	for (i = 0; i < argb->count; i++)
175	st[i] = argb->stringval[i];
176	free(argb->stringval);
177	argb->stringval = st;
178	}
179	argb->stringval[argb->count++] = arg;
180	}
181
182	static ListBlock *NewListBlock() {
183	ListBlock list = (ListBlock )malloc(sizeof(ListBlock));
184	list->alloccount = 10;
185	list->Args = (ArgBlock *) malloc(10 sizeof(ArgBlock *));
186	list->count = 0;
187	return (list);
188	}
189
190	static void FreeArgBlock(ArgBlock *argb) {
191	int i;
192	for (i = 0; i < argb->count; i++) free(argb->stringval[i]);
193	free(argb->stringval);
194	free(argb);
195	}
196
197	static void FreeListBlock(ListBlock *list) {
198	int i;
199	for (i = 0; i < list->count; i++) FreeArgBlock(list->Args[i]);
200	free(list->Args);
201	free(list);
202	}
203
204	static jobjectArray ArgBlockToJavaArray(JNIEnv env, ArgBlock argb) {
205	jobjectArray retval;
206	int i;
207	retval = (*env)->NewObjectArray(env, argb->count,
208	(*env)->FindClass(env, "java/lang/String"),
209	NULL);
210	for (i = 0; i < argb->count; i++) {
211	(*env)->SetObjectArrayElement(env, retval, i,
212	(*env)->NewStringUTF(env, argb->stringval[i]));
213	}
214	return (retval);
215	}
216
217	static jobjectArray ListBlockToJavaArray(JNIEnv env, ListBlock lb) {
218	jobjectArray retval;
219	int i;
220	retval = (*env)->NewObjectArray(env, lb->count,
221	(*env)->FindClass(env, "java/lang/Object"),
222	NULL);
223	for (i = 0; i < lb->count; i++)
224	(*env)->SetObjectArrayElement(env, retval, i,
225	ArgBlockToJavaArray(env, lb->Args[i]));
226	return (retval);
227	}
228
229	static int StashResults(int argc, char *argv, void callback) {
230	ListBlock list = (ListBlock ) callback;
231	ArgBlock *argb;
232	char *arg;
233	int i;
234
235	/* printf("DEBUG: StashResults argc = %d\n", argc);
236	* for (i = 0; i < argc; i++)
237	* printf("DEBUG: StashResults argv[%d] = %s\n", i, argv[i]);
238	*/
239
240	while (list->alloccount <= (list->count + 1)) {
241	ArgBlock args = (ArgBlock ) malloc(list->alloccount * 2 * sizeof(char *));
242	list->alloccount = list->alloccount * 2;
243	for(i = 0; i < list->count; i++) {
244	args[i] = list->Args[i];
245	}
246	free(list->Args);
247	list->Args = args;
248	}
249
250	argb = NewArgBlock();
251
252	for (i = 0; i < argc; i++) {
253	arg = (char *) malloc(strlen(argv[i]) + 1);
254	strcpy(arg, argv[i]);
255	AddArg(argb, arg);
256	}
257	list->Args[list->count++] = argb;
258	return (0);
259	}
260
261	static char *ConvertJavaArgs(JNIEnv env, jobjectArray jargs) {
262	char **retval;
263	int i, j;
264	const char *iarg;
265	int length = (*env)->GetArrayLength(env, jargs);
266	if (length == 0) { /* Does this happen in a non-error situation? */
267	retval = (char *) malloc(sizeof (char ));
268	retval[0] = NULL;
269	return(retval);
270	}
271	retval = (char *) malloc((length + 1) sizeof(char *));
272	for (i = 0; i < length; i++) {
273	jobject jarg = (*env)->GetObjectArrayElement(env, jargs, i);
274	if ((*env)->ExceptionOccurred(env)) {
275	for (j = 0; j < i; j++) free(retval[j]);
276	free (retval);
277	return (NULL);
278	}
279	iarg = (*env)->GetStringUTFChars(env, jarg, 0);
280	if ((*env)->ExceptionOccurred(env)) {
281	for (j = 0; j < i; j++) free(retval[j]);
282	free (retval);
283	return (NULL);
284	}
285	retval[i] = malloc(strlen(iarg) + 1);
286	strcpy(retval[i], iarg);
287	(*env)->ReleaseStringUTFChars(env, jarg, iarg);
288	}
289	retval[length] = NULL;
290	return (retval);
291	}
292
293	static void FreeArgs(char **args) {
294	int i;
295	i = 0;
296	while (args[i] != NULL) free(args[i++]);
297	free(args);
298	}
299