mirror of
https://github.com/moparisthebest/davmail
synced 2024-12-13 11:12:22 -05:00
618cc4a3ea
git-svn-id: http://svn.code.sf.net/p/davmail/code/trunk@869 3d1905a2-6b24-0410-a738-b14d5a86fcbd
423 lines
12 KiB
C++
423 lines
12 KiB
C++
/*
|
|
JSmooth: a VM wrapper toolkit for Windows
|
|
Copyright (C) 2003-2007 Rodrigo Reyes <reyes@charabia.net>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with this library; if not, write to the Free
|
|
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
#include "SunJVMDLL.h"
|
|
|
|
#include "JClassProxy.h"
|
|
#include "JniSmooth.h"
|
|
|
|
SunJVMDLL::SunJVMDLL(const std::string& jvmdll, const Version& v)
|
|
{
|
|
m_dllpath = jvmdll;
|
|
m_version = v;
|
|
m_statusCode = SunJVMDLL::JVM_NOT_STARTED;
|
|
m_vmlib = NULL;
|
|
}
|
|
|
|
SunJVMDLL::~SunJVMDLL()
|
|
{
|
|
if (m_vmlib != NULL)
|
|
{
|
|
FreeLibrary(m_vmlib);
|
|
}
|
|
}
|
|
|
|
bool SunJVMDLL::run(const std::string& mainclass, bool waitDeath)
|
|
{
|
|
if (m_statusCode == SunJVMDLL::JVM_NOT_STARTED)
|
|
instanciate();
|
|
|
|
if (m_statusCode == SunJVMDLL::JVM_LOADED)
|
|
{
|
|
JClassProxy disp(this, mainclass);
|
|
jstring emptystr = newUTFString(std::string(""));
|
|
jobjectArray mainargs = newObjectArray(m_arguments.size(), "java.lang.String", emptystr);
|
|
for (int i =0; i<m_arguments.size(); i++)
|
|
{
|
|
env()->SetObjectArrayElement(mainargs, i, newUTFString(m_arguments[i]));
|
|
}
|
|
printf("arguments array = %d\n", mainargs);
|
|
jvalue ma[1];
|
|
ma[0].l = mainargs;
|
|
disp.invokeStatic(std::string("void main(java.lang.String[] args)"), ma);
|
|
if (waitDeath == true)
|
|
m_javavm->DestroyJavaVM();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void SunJVMDLL::join()
|
|
{
|
|
if (m_statusCode == SunJVMDLL::JVM_LOADED)
|
|
{
|
|
m_javavm->DestroyJavaVM();
|
|
}
|
|
}
|
|
|
|
bool SunJVMDLL::instanciate()
|
|
{
|
|
m_vmlib = LoadLibrary(m_dllpath.c_str());
|
|
if (m_vmlib == NULL)
|
|
{
|
|
m_statusCode = SunJVMDLL::JVM_DLL_CANT_LOAD;
|
|
return false;
|
|
}
|
|
CreateJavaVM_t CreateJavaVM = (CreateJavaVM_t)GetProcAddress(m_vmlib, "JNI_CreateJavaVM");
|
|
GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t)GetProcAddress(m_vmlib, "JNI_GetDefaultJavaVMInitArgs");
|
|
|
|
if ((CreateJavaVM == NULL) || (GetDefaultJavaVMInitArgs == NULL))
|
|
{
|
|
m_statusCode = SunJVMDLL::JVM_CANT_USE_VM;
|
|
return false;
|
|
}
|
|
|
|
DEBUG("VM Created successfully");
|
|
|
|
m_javavm = new JavaVM();
|
|
m_javaenv = new JNIEnv();
|
|
|
|
DEBUG("DLL Setup on " + m_version.toString());
|
|
bool res;
|
|
if ((m_version.getMajor() == 1) && (m_version.getMinor() == 1))
|
|
res = setupVM11DLL(CreateJavaVM, GetDefaultJavaVMInitArgs);
|
|
else
|
|
res = setupVM12DLL(CreateJavaVM, GetDefaultJavaVMInitArgs);
|
|
|
|
registerJniSmooth();
|
|
|
|
DEBUG("Result code on DLL: " + StringUtils::toString(res));
|
|
if (res)
|
|
{
|
|
m_statusCode = SunJVMDLL::JVM_LOADED;
|
|
return true;
|
|
}
|
|
|
|
m_statusCode = SunJVMDLL::JVM_CANT_USE_VM;
|
|
return false;
|
|
}
|
|
|
|
bool SunJVMDLL::setupVM12DLL(CreateJavaVM_t CreateJavaVM, GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs)
|
|
{
|
|
vector<string> jpropstrv;
|
|
for (int i=0; i<m_properties.size(); i++)
|
|
if(m_properties[i].getName()[0]=='-') {
|
|
jpropstrv.push_back( StringUtils::requoteForCommandLine(m_properties[i].getName()));
|
|
} else {
|
|
jpropstrv.push_back( StringUtils::requoteForCommandLine("-D" + m_properties[i].getName()) + "=" + StringUtils::requoteForCommandLine(m_properties[i].getValue()));
|
|
}
|
|
|
|
// DEBUG("MAXHEAP: " + StringUtils::toString(m_maxHeap));
|
|
// DEBUG("INITIALHEAP: " + StringUtils::toString(m_initialHeap));
|
|
|
|
if (m_maxHeap > 0)
|
|
{
|
|
jpropstrv.push_back("-Xmx" +StringUtils::toString(m_maxHeap));
|
|
}
|
|
|
|
if (m_initialHeap > 0)
|
|
{
|
|
jpropstrv.push_back("-Xms" + StringUtils::toString(m_initialHeap));
|
|
}
|
|
|
|
JavaVMInitArgs vm_args;
|
|
GetDefaultJavaVMInitArgs(&vm_args);
|
|
|
|
JavaVMOption options[1 + jpropstrv.size()];
|
|
std::string cpoption = "-Djava.class.path=" + StringUtils::join(m_pathElements, ";");
|
|
|
|
DEBUG("Classpath: " + cpoption);
|
|
options[0].optionString = (char*)cpoption.c_str();
|
|
vm_args.version = 0x00010002;
|
|
vm_args.version = JNI_VERSION_1_2;
|
|
vm_args.options = options;
|
|
vm_args.nOptions = 1 + jpropstrv.size();
|
|
|
|
for (int i=0; i<jpropstrv.size(); i++)
|
|
{
|
|
options[1 + i].optionString = (char*)jpropstrv[i].c_str();
|
|
DEBUG(string("Option added:") + options[1+i].optionString);
|
|
}
|
|
|
|
vm_args.ignoreUnrecognized = JNI_TRUE;
|
|
|
|
//
|
|
// Create the VM
|
|
if (CreateJavaVM( &m_javavm, &m_javaenv, &vm_args) != 0)
|
|
{
|
|
DEBUG("Can't create VM");
|
|
m_statusCode = SunJVMDLL::JVM_CANT_CREATE_VM;
|
|
return false;
|
|
}
|
|
|
|
DEBUG("VM 1.2+ Created successfully !!");
|
|
return true;
|
|
}
|
|
|
|
bool SunJVMDLL::setupVM11DLL(CreateJavaVM_t CreateJavaVM, GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs)
|
|
{
|
|
JDK1_1InitArgs vm_args;
|
|
vm_args.version = 0x00010001;
|
|
GetDefaultJavaVMInitArgs(&vm_args);
|
|
|
|
if (m_maxHeap > 0)
|
|
vm_args.maxHeapSize = m_maxHeap;
|
|
if (m_initialHeap > 0)
|
|
vm_args.minHeapSize = m_initialHeap;
|
|
|
|
//
|
|
// create the properties array
|
|
//
|
|
char const * props[m_properties.size()+1];
|
|
vector<string> jpropstrv;
|
|
|
|
for (int i=0; i<m_properties.size(); i++)
|
|
jpropstrv[i] = m_properties[i].getName() + "=" + m_properties[i].getValue();
|
|
|
|
for (int i=0; i<m_properties.size(); i++)
|
|
props[i] = jpropstrv[i].c_str();
|
|
props[m_properties.size()] = NULL;
|
|
|
|
vm_args.properties = (char**)props;
|
|
|
|
/* Append USER_CLASSPATH to the default system class path */
|
|
|
|
std::string classpath = vm_args.classpath;
|
|
classpath += StringUtils::join(m_pathElements, ";");
|
|
|
|
DEBUG("Classpath = " + classpath);
|
|
vm_args.classpath = (char*)classpath.c_str();
|
|
|
|
//
|
|
// Create the VM
|
|
if (CreateJavaVM( &m_javavm, &m_javaenv, &vm_args) != 0)
|
|
{
|
|
DEBUG("Can't create VM");
|
|
m_statusCode = SunJVMDLL::JVM_CANT_CREATE_VM;
|
|
return false;
|
|
}
|
|
DEBUG("VM 1.1 Created successfully !!");
|
|
return true;
|
|
}
|
|
|
|
|
|
jclass SunJVMDLL::findClass(const std::string& clazz)
|
|
{
|
|
std::string classname = StringUtils::replace(clazz,".", "/");
|
|
DEBUG("Looking up for class <" + classname + ">");
|
|
jclass cls = env()->FindClass(classname.c_str());
|
|
if (cls == 0)
|
|
DEBUG("Can't find class " + classname + " !");
|
|
return cls;
|
|
}
|
|
|
|
jmethodID SunJVMDLL::findMethod(jclass& cls, const std::string& methodname, const std::string& signature, bool isStatic)
|
|
{
|
|
std::string sig = StringUtils::replace(signature, ".", "/");
|
|
|
|
jmethodID mid;
|
|
if (isStatic)
|
|
mid = env()->GetStaticMethodID(cls, methodname.c_str(), sig.c_str());
|
|
else
|
|
mid = env()->GetMethodID(cls, methodname.c_str(), sig.c_str());
|
|
|
|
return mid;
|
|
}
|
|
|
|
JavaVM* SunJVMDLL::getJavaVM()
|
|
{
|
|
return m_javavm;
|
|
}
|
|
|
|
void SunJVMDLL::setIntField(jclass cls, jobject obj, const std::string& fieldName, int value)
|
|
{
|
|
jfieldID binding = env()->GetFieldID(cls, fieldName.c_str(), "I");
|
|
env()->SetIntField(obj, binding, (jint)value);
|
|
}
|
|
|
|
void SunJVMDLL::setLongField(jclass cls, jobject obj, const std::string& fieldName, jlong value)
|
|
{
|
|
jfieldID binding = env()->GetFieldID(cls, fieldName.c_str(), "J");
|
|
env()->SetLongField(obj, binding, (jlong)value);
|
|
}
|
|
|
|
void SunJVMDLL::setObjectField(jclass cls, jobject obj, const std::string& fieldName, const std::string& fieldclass, jobject value)
|
|
{
|
|
std::string fc = "L" + StringUtils::replace(fieldclass, "." , "/") + ";";
|
|
jfieldID binding = env()->GetFieldID(cls, fieldName.c_str(), fc.c_str());
|
|
env()->SetObjectField(obj, binding, value);
|
|
}
|
|
|
|
jstring SunJVMDLL::newUTFString(const std::string& str)
|
|
{
|
|
return env()->NewStringUTF(str.c_str());
|
|
}
|
|
|
|
jobject SunJVMDLL::newObject(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->NewObjectA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jobjectArray SunJVMDLL::newObjectArray(int size, jclass clazz, jobject initialValue)
|
|
{
|
|
return env()->NewObjectArray((jsize)size, clazz, initialValue);
|
|
}
|
|
|
|
jobjectArray SunJVMDLL::newObjectArray(int size, const std::string& classname, jobject initialValue)
|
|
{
|
|
jclass cls = findClass(classname);
|
|
return newObjectArray(size, cls, initialValue);
|
|
}
|
|
|
|
//
|
|
// Static method invocation
|
|
//
|
|
|
|
void SunJVMDLL::invokeVoidStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
env()->CallStaticVoidMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jboolean SunJVMDLL::invokeBooleanStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticBooleanMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jbyte SunJVMDLL::invokeByteStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticByteMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jchar SunJVMDLL::invokeCharStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticCharMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jshort SunJVMDLL::invokeShortStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticShortMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jint SunJVMDLL::invokeIntStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticIntMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jlong SunJVMDLL::invokeLongStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticLongMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jfloat SunJVMDLL::invokeFloatStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticFloatMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jdouble SunJVMDLL::invokeDoubleStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticDoubleMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
jobject SunJVMDLL::invokeObjectStatic(jclass clazz, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallStaticObjectMethodA(clazz, methodid, arguments);
|
|
}
|
|
|
|
|
|
//
|
|
// method invocation
|
|
//
|
|
|
|
void SunJVMDLL::invokeVoid(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
env()->CallVoidMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jboolean SunJVMDLL::invokeBoolean(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallBooleanMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jbyte SunJVMDLL::invokeByte(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallByteMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jchar SunJVMDLL::invokeChar(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallCharMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jshort SunJVMDLL::invokeShort(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallShortMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jint SunJVMDLL::invokeInt(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallIntMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jlong SunJVMDLL::invokeLong(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallLongMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jfloat SunJVMDLL::invokeFloat(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallFloatMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jdouble SunJVMDLL::invokeDouble(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallDoubleMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
jobject SunJVMDLL::invokeObject(jobject& obj, jmethodID& methodid, jvalue arguments[])
|
|
{
|
|
return env()->CallObjectMethodA(obj, methodid, arguments);
|
|
}
|
|
|
|
bool SunJVMDLL::registerMethod(const std::string& classname, const std::string& methodname, const std::string& signature,
|
|
void* fn)
|
|
{
|
|
jclass cc = this->findClass(classname);
|
|
if (cc == 0)
|
|
return false;
|
|
JNINativeMethod jnm;
|
|
jnm.name = (char*)methodname.c_str();
|
|
jnm.signature = (char*)signature.c_str();
|
|
jnm.fnPtr = fn;
|
|
|
|
int res = env()->RegisterNatives(cc, &jnm, 1);
|
|
if (res != 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool SunJVMDLL::registerJniSmooth()
|
|
{
|
|
registerNativeMethods(this);
|
|
return true;
|
|
}
|