/******************************************************************************\
* JniCript.c
* Project	: JniCript
* Version	: 1.0
* Date		: 25-09-1998
* Author	: Giuseppe Rizzo
* Purpose	: Cript_api dll (Cript_api.dll) encapsulation
* Called by	: gr.cript.jni.JniCript java class
\*****************************************************************************/
#include <stdio.h>
#include <windows.h>
#include "Cript_api.h"			// Cript dll (Cript_api.dll) interface
#include "gr_cript_jni_JniCript.h"	//gr.cript.jni.JniCript java class interface
#include "jToC_JNI.h"			// Java classes to C type conversion
#include "CToj_JNI.h"			// C types to java classes conversion

void init_class(JNIEnv* env);
void init_method(JNIEnv* env);

static jclass clasJDR = 0;
static jclass clasJVR = 0;
static jclass clasJB = 0;
static jclass clasJDn = 0;
static jclass clasJDnColl = 0;
static jclass clasStr = 0;
static int CLASS_OK = 0;
static jmethodID midJDn_initV = 0;
static jmethodID midJDn_setD = 0;
static jmethodID midJDn_setDir = 0;
static jmethodID midJDn_setUri = 0;
static jmethodID midJDn_setRC = 0;
static jmethodID midJDn_setRfc = 0;
static jmethodID midJB_initV = 0;
static jmethodID midJB_setBytes = 0;
static jmethodID midJDn_getD = 0;
static jmethodID midJDn_getDir = 0;
static jmethodID midJDn_getUri = 0;
static jmethodID midJDn_getRC = 0;
static jmethodID midJDn_getRfc = 0;
static jmethodID midJB_getBytes = 0;
static jmethodID midJB_length = 0;
static jmethodID midDR_setJB = 0;
static jmethodID midDR_setAlgorithm = 0;
static jmethodID midVR_setJB = 0;
static jmethodID midVR_addJDn = 0;
static jmethodID midVR_setAlgorithm = 0;
static jmethodID midJDnColl_getJDnArr = 0;
static jmethodID midJDnColl_length = 0;
static jmethodID midStr_getBytes = 0;
static jmethodID midStr_length = 0;
static int METHOD_OK = 0;

/************  METODI NATIVI DELLA CLASSE gr.cript.jni.JniCript *************/

/*
 * Class:     gr_cript_jni_JniCript
 * Method:    login
 * Signature: (Ljava/lang/String;Lgr/cript/JDn;)I
 */
JNIEXPORT jint JNICALL Java_gr_cript_jni_JniCript_login
(JNIEnv *env, jobject thisObj, jstring pwd, jobject dnOut) {
	BUFFER* password;
	DN dn_Out;
	int res;
	init_class(env);
	init_method(env);
	password = BUFFER_new();
	jstringToBUFFERPtr(env,pwd,password);
	res = login(&dn_Out,password);
	if (res == 0) DNPtrToJDn(env,&dn_Out,0,dnOut);
	BUFFER_free(password);
	return res;
}
/*
 * Class:     gr_cript_jni_JniCript
 * Method:    changePassword
 * Signature: (Ljava/lang/String;Ljava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_gr_cript_jni_JniCript_changePassword
(JNIEnv *env, jobject thisObj, jstring oldPwd, jstring newPwd){
	BUFFER *old_pwd,*new_pwd;
	int res;
	init_class(env);
	init_method(env);
	new_pwd = BUFFER_new();
	jstringToBUFFERPtr(env,newPwd,new_pwd);
	old_pwd = BUFFER_new();
	jstringToBUFFERPtr(env,oldPwd,old_pwd);
	res = changePassword(old_pwd,new_pwd);
	BUFFER_free(new_pwd);
	BUFFER_free(old_pwd);
	return res;
}
/*
 * Class:     gr_cript_jni_JniCript
 * Method:    sign
 * Signature: (ILjava/lang/String;Lgr/cript/JBuffer;Lgr/cript/JBuffer;)I
 */
JNIEXPORT jint JNICALL Java_gr_cript_jni_JniCript_sign
(JNIEnv *env, jobject thisObj, jint alg, jstring pwd, jobject inBuf, jobject outBuf) {
	BUFFER *in_buf,*password,*out_buf;
	int res;
	init_class(env);
	init_method(env);
	in_buf = BUFFER_new();
	JBufferToBUFFERPtr(env,inBuf,in_buf);
	password = BUFFER_new();
	jstringToBUFFERPtr(env,pwd,password);
	out_buf = BUFFER_new();
	out_buf->length = 0;
	res = sign(alg,password,in_buf,out_buf);
	if (res == 0) BUFFERPtrToJBuffer(env,out_buf,outBuf);
	BUFFER_free(in_buf);
	BUFFER_free(password);
	BUFFER_free(out_buf);
	return res;
}
/*
 * Class:     gr_cript_jni_JniCript
 * Method:    encrypt
 * Signature: (ILgr/cript/JDn;Lgr/cript/JBuffer;Lgr/cript/JBuffer;)I
 */
JNIEXPORT jint JNICALL Java_gr_cript_jni_JniCript_encrypt
(JNIEnv *env, jobject thisObj, jint alg, jobject dn, jobject inBuf, jobject outBuf) {
	DN dn_other;
	BUFFER* in_buf,*out_buf;
	int res;
	init_class(env);
	init_method(env);
	JDnToDNPtr(env,dn,&dn_other);
	in_buf = BUFFER_new();
	JBufferToBUFFERPtr(env,inBuf,in_buf);
	out_buf = BUFFER_new();
	out_buf->length = 0;
	res = encrypt(alg,&dn_other,in_buf,out_buf);
	if (res == 0) BUFFERPtrToJBuffer(env,out_buf,outBuf);
	BUFFER_free(out_buf);
	BUFFER_free(in_buf);
	return res;
}
/*
 * Class:     gr_cript_jni_JniCript
 * Method:    decrypt
 * Signature: (Ljava/lang/String;Lgr/cript/JBuffer;Lgr/cript/DecryptResult;)I
 */
JNIEXPORT jint JNICALL Java_gr_cript_jni_JniCript_decrypt
(JNIEnv *env, jobject thisObj, jstring pwd, jobject inBuf, jobject stateBuf) {
	BUFFER *in_buf,*out_buf,*pwd_usr;
	int alg,res;
	init_class(env);
	init_method(env);
	in_buf = BUFFER_new();
	JBufferToBUFFERPtr(env,inBuf,in_buf);
	pwd_usr = BUFFER_new();
	jstringToBUFFERPtr(env,pwd,pwd_usr);
	out_buf = BUFFER_new();
	res = decrypt(pwd_usr,in_buf,&alg,out_buf);
	if (res == 0)
		decodeResultToDecryptResult(env,out_buf,alg,stateBuf);
	BUFFER_free(out_buf);
	BUFFER_free(pwd_usr);
	BUFFER_free(in_buf);
	return res;
}
/*
 * Class:     gr_cript_jni_JniCript
 * Method:    verify
 * Signature: (Lgr/cript/JBuffer;Lgr/cript/VerifyResut;)I
 */
JNIEXPORT jint JNICALL Java_gr_cript_jni_JniCript_verify
(JNIEnv *env, jobject thisObj, jobject inBuf, jobject stateBuf) {
	int alg,res;
	SET_DN* signers;
	signers = (SET_DN*)malloc(sizeof(SET_DN));
	signers->length = 0;
	init_class(env);
	init_method(env);
	in_buf = BUFFER_new();
	JBufferToBUFFERPtr(env,inBuf,in_buf);
	out_buf = BUFFER_new();
	res = verify(in_buf,out_buf,&alg,signers);
	if (res == 0)
		decodeResultToVerifyResult(env,out_buf,alg,signers,stateBuf);
	BUFFER_free(out_buf);
	BUFFER_free(in_buf);
	free(signers);
	return res;
}
/************  FINE METODI NATIVI DELLA CLASSE gr.cript.jni.JniCript *************/

/********  Inizializzazione identificatori delle classi java utilizzate **********/

void init_class(JNIEnv *env) {
	if (CLASS_OK) return;
	CLASS_OK = 1;
	if (clasJDn == 0) {
		jclass cls = (*env)->FindClass(env,"gr/cript/JDn");
		clasJDn = (*env)->NewGlobalRef(env,cls);
		if (clasJDn == 0) {
			CLASS_OK = 0;
		}
	}
	if (clasJDnColl == 0) {
		jclass cls = (*env)->FindClass(env,"gr/cript/JDnCollection");
		clasJDnColl = (*env)->NewGlobalRef(env,cls);
		if (clasJDnColl == 0) {
			CLASS_OK = 0;
		}
	}
	if (clasJB == 0) {
		jclass cls = (*env)->FindClass(env,"gr/cript/JBuffer");
		clasJB = (*env)->NewGlobalRef(env,cls);
		if (clasJB == 0) {
			CLASS_OK = 0;
		}
	}
	if (clasJDR == 0) {
		jclass cls = (*env)->FindClass(env,"gr/cript/DecodeResult");
		clasJDR = (*env)->NewGlobalRef(env,cls);
		if (clasJDR == 0) {
			CLASS_OK = 0;
		}
	}
	if (clasJVR == 0) {
		jclass cls = (*env)->FindClass(env,"gr/cript/VerifyResult");
		clasJVR = (*env)->NewGlobalRef(env,cls);
		if (clasJVR == 0) {
			CLASS_OK = 0;
		}
	}
	if (clasStr == 0) {
		jclass cls = (*env)->FindClass(env,"java/lang/String");
		clasStr = (*env)->NewGlobalRef(env,cls);
		if (clasStr == 0) {
			CLASS_OK = 0;
		}
	}
}

/******  FINE Inizializzazione identificatori delle classi java utilizzate *******/

/***********  Inizializzazione identificatori dei metodi utilizzati **************/

void init_method(JNIEnv *env) {
	if (METHOD_OK) return;
	if (!CLASS_OK) {
		return;
	}
	METHOD_OK = 1;
	if (midJDn_initV == 0) {
		midJDn_initV = (*env)->GetMethodID(env,clasJDn,"<init>","()V");
		if (midJDn_initV == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_setD == 0) {
		midJDn_setD = (*env)->GetMethodID(env,clasJDn,"setDName","(Ljava/lang/String;)V");
		if (midJDn_setD == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_setRfc == 0) {
		midJDn_setRfc = (*env)->GetMethodID(env,clasJDn,"setRfc822Name","(Ljava/lang/String;)V");
		if (midJDn_setRfc == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_setUri == 0) {
		midJDn_setUri = (*env)->GetMethodID(env,clasJDn,"setUriName","(Ljava/lang/String;)V");
		if (midJDn_setUri == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_setDir == 0) {
		midJDn_setDir = (*env)->GetMethodID(env,clasJDn,"setDirName","(Ljava/lang/String;)V");
		if (midJDn_setDir == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_setRC == 0) {
		midJDn_setRC = (*env)->GetMethodID(env,clasJDn,"setRCode","(I)V");
		if (midJDn_setRC == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_getD == 0) {
		midJDn_getD = (*env)->GetMethodID(env,clasJDn,"getDName","()Ljava/lang/String;");
		if (midJDn_getD == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_getRfc == 0) {
		midJDn_getRfc = (*env)->GetMethodID(env,clasJDn,"getRfc822Name","()Ljava/lang/String;");
		if (midJDn_getRfc == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_getUri == 0) {
		midJDn_getUri = (*env)->GetMethodID(env,clasJDn,"getUriName","()Ljava/lang/String;");
		if (midJDn_getUri == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_getDir == 0) {
		midJDn_getDir = (*env)->GetMethodID(env,clasJDn,"getDirName","()Ljava/lang/String;");
		if (midJDn_getDir == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDn_getRC == 0) {
		midJDn_getRC = (*env)->GetMethodID(env,clasJDn,"getRCode","()I");
		if (midJDn_getRC == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDnColl_getJDnArr == 0) {
		midJDnColl_getJDnArr = (*env)->GetMethodID(env,clasJDnColl,"getJDnArray","()[Lgr/cript/JDn;");
		if (midJDnColl_getJDnArr == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJDnColl_length == 0) {
		midJDnColl_length = (*env)->GetMethodID(env,clasJDnColl,"length","()I");
		if (midJDnColl_length == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJB_initV == 0) {
		midJB_initV = (*env)->GetMethodID(env,clasJB,"<init>","()V");
		if (midJB_initV == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJB_setBytes == 0) {
		midJB_setBytes = (*env)->GetMethodID(env,clasJB,"setBytes","([B)V");
		if (midJB_setBytes == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJB_getBytes == 0) {
		midJB_getBytes = (*env)->GetMethodID(env,clasJB,"getBytes","()[B");
		if (midJB_getBytes == 0) {
			METHOD_OK = 0;
		}
	}
	if (midJB_length == 0) {
		midJB_length = (*env)->GetMethodID(env,clasJB,"length","()I");
		if (midJB_length == 0) {
			METHOD_OK = 0;
		}
	}
	if (midDR_setJB == 0) {
		midDR_setJB= (*env)->GetMethodID(env,clasJSB,"setJBuffer","(Lgr/cript/JBuffer;)V");
		if (midDR_setJB == 0) {
			METHOD_OK = 0;
		}
	}
	if (midDR_setAlg == 0) {
		midDR_setAlg = (*env)->GetMethodID(env,clasJSB,"setAlgorithm","(I)V");
		if (midDR_setAlg == 0) {
			METHOD_OK = 0;
		}
	}
	if (midVR_setJB == 0) {
		midVR_setJB= (*env)->GetMethodID(env,clasJSB,"setJBuffer","(Lgr/cript/JBuffer;)V");
		if (midVR_setJB == 0) {
			METHOD_OK = 0;
		}
	}
	if (midVR_setAlg == 0) {
		midVR_setAlg = (*env)->GetMethodID(env,clasJSB,"setAlgorithm","(I)V");
		if (midVR_setAlg == 0) {
			METHOD_OK = 0;
		}
	}
	if (midVR_addJDn == 0) {
		midVR_addJDn= (*env)->GetMethodID(env,clasJSB,"addJDn","(Lgr/cript/JDn;)V");
		if (midVR_addJDn == 0) {
			METHOD_OK = 0;
		}
	}
	if (midStr_getBytes == 0) {
		midStr_getBytes = (*env)->GetMethodID(env,clasStr,"getBytes","()[B");
		if (midStr_getBytes == 0) {
			METHOD_OK = 0;
		}
	}
	if (midStr_length == 0) {
		midStr_length = (*env)->GetMethodID(env,clasStr,"length","()I");
		if (midStr_length == 0) {
			METHOD_OK = 0;
		}
	}
}

/**********  FINE Inizializzazione identificatori dei metodi utilizzati ***********/



/*****************************************************************\
*
*	C To Java Conversion
*
\*****************************************************************/

void DNPtrToJDn(JNIEnv *env, DN* dn_usr, int r_code, jobject dn) {
	jstring jstr;
	jstr = CharPtrTojstring(env,dn_usr->DName);
	(*env)->CallVoidMethod(env,dn,midJDn_setD,jstr);
	jstr = CharPtrTojstring(env,dn_usr->rfc822Name);
	(*env)->CallVoidMethod(env,dn,midJDn_setRfc,jstr);
	jstr = CharPtrTojstring(env,dn_usr->URIName);
	(*env)->CallVoidMethod(env,dn,midJDn_setUri,jstr);
	jstr = CharPtrTojstring(env,dn_usr->DirName);
	(*env)->CallVoidMethod(env,dn,midJDn_setDir,jstr);
	(*env)->CallVoidMethod(env,dn,midJDn_setRC,r_code);
}
void BUFFERPtrToJBuffer(JNIEnv *env, BUFFER* out_buf,jobject outBuf) {
	int i;
	jbyteArray byteArr;
	jbyte* byteArrElems;
	jsize len;
	jboolean isCopy;
	len = out_buf->length;
	byteArr = (*env)->NewByteArray(env,len);
	byteArrElems = (*env)->GetByteArrayElements(env,byteArr,&isCopy);
	for(i=0;i<len;i++) {
		byteArrElems[i] = out_buf->value[i];
	}
	(*env)->CallVoidMethod(env,outBuf,midJB_setBytes,byteArr);
	if (isCopy==JNI_TRUE)
		(*env)->ReleaseByteArrayElements(env,byteArr,byteArrElems,0);
}
void decodeResultToDecryptResult(JNIEnv *env, BUFFER* res_buf, int alg, jobject jstateBuf) {
	int i;
	jobject buf;
	(*env)->CallVoidMethod(env,jstateBuf,midDR_setAlg,alg);
	buf = (*env)->NewObject(env,clasJB,midJB_initV);
	BUFFERPtrToJBuffer(env,res_buf,buf);
	(*env)->CallVoidMethod(env,jstateBuf,midDR_setJB,buf);
}
void decodeResultToVerifyResult(JNIEnv *env, BUFFER* res_buf, int alg, SET_DN* set_DN, jobject jstateBuf) {
	int i;
	jobject buf, dn;
	for(i=0;i<(int)(set_DN->length);i++) {
		dn = (*env)->NewObject(env,clasJDn,midJDn_initV);
		DNPtrToJDn(env,&(set_DN->DN[i].DN),set_DN->DN[i].r_code,dn);
		(*env)->CallVoidMethod(env,jstateBuf,midVR_addJDn,dn);
	}
	(*env)->CallVoidMethod(env,jstateBuf,midVR_setAlg,alg);
	buf = (*env)->NewObject(env,clasJB,midJB_initV);
	BUFFERPtrToJBuffer(env,res_buf,buf);
	(*env)->CallVoidMethod(env,jstateBuf,midVR_setJB,buf);
}
jstring CharPtrTojstring(JNIEnv *env, char* charPtr) {
	jstring ret;
	ret = (*env)->NewStringUTF(env,charPtr);
	return ret;
}

/*****************************************************************\
*
*	Java To C Conversion
*
\*****************************************************************/

void JBufferToBUFFERPtr(JNIEnv *env, jobject inBuf, BUFFER* in_buf) {
	jboolean isCopyjb_in;
	jbyteArray jbArr;
	jbyte* jb;
	jsize length_in;	
	length_in = (*env)->CallIntMethod(env,inBuf,midJB_length);
	jbArr = (jbyteArray)(*env)->CallObjectMethod(env,inBuf,midJB_getBytes);
	jb = (*env)->GetByteArrayElements(env,jbArr,&isCopyjb_in);
	BUFFER_set(in_buf,(unsigned char*) jb,length_in);
	if (isCopyjb_in == JNI_TRUE)
		(*env)->ReleaseByteArrayElements(env,jbArr,jb,0);
}

void jstringToBUFFERPtr(JNIEnv *env, jstring str, BUFFER* str_buf) {
	jsize length_str;
	jboolean isCopy_str;
	jbyte* jc;
	jbyteArray jcArr;
	length_str = (*env)->CallIntMethod(env,str,midStr_length);
	jcArr = (jbyteArray)(*env)->CallObjectMethod(env,str,midStr_getBytes);
	jc = (*env)->GetByteArrayElements(env,jcArr,&isCopy_str);
	BUFFER_set(str_buf,(unsigned char*)jc,length_str);
	if (isCopy_str == JNI_TRUE)
		(*env)->ReleaseByteArrayElements(env,jcArr,jc,0);
}
void JDnToDNPtr(JNIEnv *env, jobject dn, DN* dn_usr) {
	jstring jstr;
	jstr = (*env)->CallObjectMethod(env,dn,midJDn_getD);
	jstringToCharPtr(env,jstr,dn_usr->DName,sizeof(DN));
	jstr = (*env)->CallObjectMethod(env,dn,midJDn_getRfc);
	jstringToCharPtr(env,jstr,dn_usr->rfc822Name,sizeof(DN));
	jstr = (*env)->CallObjectMethod(env,dn,midJDn_getUri);
	jstringToCharPtr(env,jstr,dn_usr->URIName,sizeof(DN));
	jstr = (*env)->CallObjectMethod(env,dn,midJDn_getDir);
	jstringToCharPtr(env,jstr,dn_usr->DirName,sizeof(DN));
}
void JDnCollectionToSET_DNPtr(JNIEnv *env, jobject dnColl, SET_DN* set_DN) {
	int i;
	jint rCode,length;
	jobjectArray jDnArray;
	jDnArray = (*env)->CallObjectMethod(env,dnColl,midJDnColl_getJDnArr);
	length = (*env)->CallIntMethod(env,dnColl,midJDnColl_length);
	set_DN->length = length;
	for(i=0;i<length;i++) {
		jobject dn = (*env)->GetObjectArrayElement(env,jDnArray,i);
		JDnToDNPtr(env,dn,&(set_DN->DN[i].DN));
		rCode = (*env)->CallIntMethod(env,dn,midJDn_getRC);
		set_DN->DN[i].r_code = rCode;
	}
}
void jstringToDNPtr(JNIEnv *env, jstring jstr, DN* dn_usr) {
	jstringToCharPtr(env,jstr,*dn_usr,sizeof(DN));
}
void jstringToCharPtr(JNIEnv *env, jstring jstr, char* charPtr, int maxLen) {
	int i;
	jsize length;
	int len;
	jboolean isCopy;
	const char* str;
	length = (*env)->GetStringUTFLength(env,jstr);
	str = (*env)->GetStringUTFChars(env,jstr,&isCopy);
	if (length<maxLen)
		len = length;
	else len = maxLen - 1;
	for(i=0;i<len;i++)
		charPtr[i] = str[i];
	charPtr[len] = '\0';
	if (isCopy==JNI_TRUE)
		(*env)->ReleaseStringUTFChars(env,jstr,str);
}