private void AttachToExistingJVM(JavaVMInitArgs jvmInitArgs)
{
int virtualMachines;
IntPtr javaVM;
int result = JNINativeImports.JNI_GetCreatedJavaVMs(out javaVM, 1, out virtualMachines);
if (result != JNIConstants.JNI_OK)
{
throw new InvalidOperationException($"Error when creating Java Virtual Machine. [JNI_GetCreatedJavaVMs -> Return code: { result }].");
}
if (virtualMachines > 0)
{
this.JavaEnvironment.VirtualMachine = new JavaVM(javaVM);
JavaEnvironment env;
result = this.JavaEnvironment.VirtualMachine.AttachCurrentThread(out env, jvmInitArgs);
this.JavaEnvironment = env;
if (result != JNIConstants.JNI_OK)
{
throw new InvalidOperationException($"Error when creating Java Virtual Machine. [AttachCurrentThread -> Return code: { result }].");
}
}
}
public static JavaVMInitArgs create(int version)
{
global::System.IntPtr cPtr = JNIPINVOKE.JavaVMInitArgs_create__SWIG_0(version);
JavaVMInitArgs ret = (cPtr == global::System.IntPtr.Zero) ? null : new JavaVMInitArgs(cPtr, false);
return(ret);
}
public static JNetVirtualMachine Initialize(JNetConfiguration configuration)
{
configuration = configuration ?? new JNetConfiguration();
lock (instanceSync)
{
var options = configuration.BuildOptions();
JVMLib.Load(configuration);
JavaVMInitArgs vm_args = new JavaVMInitArgs();
vm_args.SetOptions(options.ToArray());
vm_args.version = (int)configuration.JNIVersion;
vm_args.ignoreUnrecognized = true; // invalid options make the JVM init fail
var p_vmArgs = Marshal.AllocCoTaskMem(Marshal.SizeOf <JavaVMInitArgs>());
Marshal.StructureToPtr(vm_args, p_vmArgs, false);
JavaVM *vm;
JNIEnv *env;
var ret = JVMLib.JNI_CreateJavaVM(&vm, (void **)&env, (void *)p_vmArgs);
vm_args.ReleaseOptions();
Marshal.FreeCoTaskMem(p_vmArgs);
JNIResultException.Check(ret);
return(Boot(configuration.Bootstrap, vm, env));
}
}
public void TestMethod1()
{
Setup();
// NO FUNCIONA... ?????
JavaVMOption options = new JavaVMOption();
//options.optionString = $@"-Djava.class.path={jdkPath}";
options.optionString = "";
JavaVMInitArgs vm_args = JavaVMInitArgs.create(JNI.JNI_VERSION_1_8, 1);
vm_args.set(0, options);
int flags;
Ref_JavaVM refJavaVM = new Ref_JavaVM();
Ref_JNIEnv refJNIEnv = new Ref_JNIEnv();
flags = JavaVM.CreateJavaVM(refJavaVM, refJNIEnv, vm_args);
if (flags == JNI.JNI_ERR)
{
String msg = "Error creando la maquina virtual";
Debug.WriteLine(msg);
throw new Exception(msg);
}
JNIEnv jniEnv = refJNIEnv.getValue();
JClass clazz = jniEnv.FindClass("java/lang/Object");
Debug.WriteLine("Class " + clazz);
}
/// <summary>
/// Loads Java Environment and Virtual Machine.
/// </summary>
/// <param name="path"> On Windows: Path to jvm.dll file. </param>
/// <param name="parameters"> Optional arguments for virtual machine. </param>
/// <param name="jniVersion"> Correct JNI version. See: <see cref="JNIConstants"/>. </param>
/// <param name="attachToExistingJVM"></param>
public void Load(string path, IDictionary <string, string> parameters = null, int jniVersion = JNIConstants.JNI_VERSION_1_8, bool attachToExistingJVM = false)
{
if (string.IsNullOrEmpty(path) ||
!File.Exists(path))
{
throw new ArgumentException("You must specify the correct location of JVM library.", "path");
}
// Set the working directory to directory with JVM library.
Directory.SetCurrentDirectory(Path.GetDirectoryName(path));
var jvmInitArgs = new JavaVMInitArgs
{
version = jniVersion,
ignoreUnrecognized = JavaConverter.ToByte(true)
};
if (parameters != null &&
parameters.Count > 0)
{
jvmInitArgs.nOptions = parameters.Count;
var options = new List <JavaVMOption>();
foreach (var kvp in parameters)
{
options.Add(new JavaVMOption
{
optionString = Marshal.StringToHGlobalAnsi($"{ kvp.Key }={ kvp.Value }")
});
}
JavaVMOption[] parsedOptions = options.ToArray();
fixed(JavaVMOption *a = &parsedOptions[0])
{
jvmInitArgs.options = a;
}
}
if (!attachToExistingJVM)
{
IntPtr environment;
IntPtr javaVM;
int result = JNINativeImports.JNI_CreateJavaVM(out javaVM, out environment, &jvmInitArgs);
if (result != JNIConstants.JNI_OK)
{
throw new InvalidOperationException($"Error when creating Java Virtual Machine. [JNI_CreateJavaVM -> Return code: { result }].");
}
this.JavaEnvironment = new JavaEnvironment(environment);
this.JavaEnvironment.VirtualMachine = new JavaVM(javaVM);
}
else
{
this.AttachToExistingJVM(jvmInitArgs);
}
this.Gateway = new GatewayManager(this);
}
static void CreateJavaVM(out IntPtr jvm, out IntPtr jnienv)
{
var args = new JavaVMInitArgs()
{
version = JniVersion.v1_6,
nOptions = 0,
ignoreUnrecognized = (byte)1,
};
int r = JNI_CreateJavaVM(out jvm, out jnienv, ref args);
if (r != 0)
{
throw new InvalidOperationException("JNI_CreateJavaVM returned: " + r);
}
}
internal int AttachCurrentThread(out JavaEnvironment env, JavaVMInitArgs?args = null)
{
IntPtr envPointer;
IntPtr result;
if (args.HasValue)
{
JavaVMInitArgs initArgs = args.Value;
result = this.JVM.AttachCurrentThread(out envPointer, &initArgs);
}
else
{
result = this.JVM.AttachCurrentThread(out envPointer, null);
}
env = new JavaEnvironment(envPointer);
return(result.ToInt32());
}
public void TestMethod1()
{
Setup();
es.jni.JavaVMOption options = new JavaVMOption();
//options.optionString = $@"-Djava.class.path={jdkPath}";
options.optionString = "";
JavaVMInitArgs vm_args = JavaVMInitArgs.create(JNI.JNI_VERSION_1_8, 1);
vm_args.set(0, options);
int flags;
Ref_JavaVM refJavaVM = new Ref_JavaVM();
Ref_JNIEnv refJNIEnv = new Ref_JNIEnv();
flags = JavaVM.CreateJavaVM(refJavaVM, refJNIEnv, vm_args);
if (flags == JNI.JNI_ERR)
{
String msg = "Error creando la maquina virtual";
Debug.WriteLine(msg);
throw new Exception(msg);
}
JavaVM javaVM = refJavaVM.getValue();
JNIEnv jniEnv = refJNIEnv.getValue();
JClass jclazz = jniEnv.FindClass("java/lang/Object");
Debug.WriteLine("jclazz " + jclazz);
GC(jniEnv);
JMethodID jinit = jniEnv.GetMethodID(jclazz, "<init>", "()V");
JObject jinstance = jniEnv.NewObject(jclazz, jinit, new JValue[0]);
JObject jref = jniEnv.NewGlobalRef(jinstance);
Test(jniEnv, jclazz);
jniEnv.DeleteLocalRef(jclazz);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(JavaVMInitArgs obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
static extern int JNI_CreateJavaVM(out IntPtr javavm, out IntPtr jnienv, ref JavaVMInitArgs args);
public static extern int JNI_CreateJavaVM(ref IntPtr vm, ref IntPtr env, ref JavaVMInitArgs args);
/// <summary>
/// Sets up all required JVM initialization arguments.
/// </summary>
/// <returns>A filled JavaVMInitArgs that can be used to create a JVM.</returns>
private JavaVMInitArgs CreateInitializationArguments()
{
Logger.Log(Resources.LogCreateInitializationArguments);
JavaVMInitArgs args = new JavaVMInitArgs();
args.Version = (int)JNIVersion.JNI_VERSION_1_4;
args.IgnoreUnrecognized = 0x01;
args.OptionCount = 0;
//// TODO: set OptionCount and Options!
//// args.Options = 0;
return args;
}
/// <summary>
/// Creates a JVM.
/// </summary>
/// <param name="initArgs">Initialization arguments for the JVM.</param>
private unsafe void CreateJavaVirtualMachine(JavaVMInitArgs initArgs)
{
Logger.Log(Resources.LogCreateJavaVirtualMachine);
IntPtr env;
IntPtr jvm;
JniResult result = this.createJavaVm(out jvm, out env, &initArgs);
if (result != JniResult.Ok)
throw new MajalaException(string.Format(CultureInfo.CurrentCulture, Resources.ErrorCreatingJVM, result));
this.env = new JniEnv(env);
this.jvm = new JavaVM(jvm);
}
/// <summary>
/// Create the Java VM and wrap it.
/// </summary>
/// <param name="jvmDllPath">(Optional) Path to jvm.dll where we'll load the JNI library. If not provided we'll try to infer its location from the Java install path.</param>
/// <param name="attemptVmReuse">
/// This is an annoying workaround to a fundamental JNI problem: you can't host a JVM within the process again once you've hosted it once
/// (ever, even if you destroy the first one). So if this flag is <c>true</c>, we'll attempt to find an existing JVM in the process and use that
/// if available, and we won't destroy the JVM on dispose so subsequent constructions of this object will succeed.
/// The downside of reuse of course is that if we're reusing it then we won't be able to construct it with fresh arguments.
/// </param>
internal JniWrapper(string jvmDllPath, bool attemptVmReuse, IEnumerable <JavaOption> options)
{
_currentThreadEnv = new ThreadLocal <IntPtr>(() =>
{
IntPtr ret;
unsafe
{
if (_vm.GetDelegate <GetEnv>()(_vmP, (IntPtr)(&ret), _jniVersion) == -2)
{
_vm.GetDelegate <AttachCurrentThread>()(_vmP, (IntPtr)(&ret), IntPtr.Zero);
}
return(ret);
}
});
if (String.IsNullOrEmpty(jvmDllPath))
{
string javaHome = GetJavaInstallationPath();
_vmDll = Path.Combine(javaHome, "bin", "server", "jvm.dll");
}
else
{
_vmDll = jvmDllPath;
}
if (!File.Exists(_vmDll))
{
throw new InvalidOperationException("Couldn't find the runtime library for Java at: " + _vmDll);
}
IntPtr envP;
IntPtr vmP;
_vmDllModule = LoadLibrary(_vmDll);
if (_vmDllModule == IntPtr.Zero)
{
throw new Win32Exception();
}
if (attemptVmReuse)
{
_vmReuse = true;
int numVms;
unsafe
{
ThrowOnBadResult(GetDelegateFromJni <GetCreatedJavaVMs>("JNI_GetCreatedJavaVMs")(&vmP, 1, out numVms), "GetCreatedJavaVMs");
if (numVms >= 1)
{
_vmP = vmP;
_vm = (JavaVM)Marshal.PtrToStructure(vmP, typeof(JavaVM));
ThrowOnBadResult(_vm.GetDelegate <AttachCurrentThread>()(_vmP, (IntPtr)(&envP), IntPtr.Zero), "AttachCurrentThread");
_envP = envP;
_env = (JniEnv)Marshal.PtrToStructure(envP, typeof(JniEnv));
return;
}
}
}
JavaVMInitArgs vmArgs = new JavaVMInitArgs();
GetDelegateFromJni <GetDefaultJavaVMInitArgs>("JNI_GetDefaultJavaVMInitArgs")(ref vmArgs);
vmArgs.Version = _jniVersion;
vmArgs._nOptions = options.Count();
vmArgs._options = Marshal.AllocHGlobal(vmArgs._nOptions * Marshal.SizeOf(typeof(JavaVMOption)));
IntPtr vmArgsP = Marshal.AllocHGlobal(Marshal.SizeOf(vmArgs));
try
{
int optionsLocation = 0;
foreach (JavaOption currentOption in options)
{
Marshal.StructureToPtr(currentOption.ActualOption, vmArgs._options + optionsLocation * Marshal.SizeOf(typeof(JavaVMOption)), false);
optionsLocation++;
}
Marshal.StructureToPtr(vmArgs, vmArgsP, false);
unsafe
{
ThrowOnBadResult(GetDelegateFromJni <CreateJavaVM>("JNI_CreateJavaVM")(&vmP, &envP, vmArgsP), "CreateJavaVM");
_vm = (JavaVM)Marshal.PtrToStructure(vmP, typeof(JavaVM));
_env = (JniEnv)Marshal.PtrToStructure(envP, typeof(JniEnv));
_envP = envP;
_vmP = vmP;
}
}
finally
{
Marshal.DestroyStructure(vmArgsP, typeof(JavaVMInitArgs));
Marshal.FreeHGlobal(vmArgsP);
Marshal.FreeHGlobal(vmArgs._options);
}
}
public static int CreateJavaVM(Ref_JavaVM refvm, Ref_JNIEnv refenv, JavaVMInitArgs args)
{
int ret = JNIPINVOKE.JavaVM_CreateJavaVM(Ref_JavaVM.getCPtr(refvm), Ref_JNIEnv.getCPtr(refenv), JavaVMInitArgs.getCPtr(args));
return(ret);
}
public static int GetDefaultJavaVMInitArgs(JavaVMInitArgs args)
{
int ret = JNIPINVOKE.JavaVM_GetDefaultJavaVMInitArgs(JavaVMInitArgs.getCPtr(args));
return(ret);
}
public static void Attach(int pid, string path, string arguments = "")
{
IntPtr vm = IntPtr.Zero, env = IntPtr.Zero;
JavaVMInitArgs args = new JavaVMInitArgs();
args.version = 0x00010008;
args.nOptions = 0;
int result = JNI_CreateJavaVM(ref vm, ref env, ref args);
Console.WriteLine("result " + result);
IntPtr real = Marshal.ReadIntPtr(env);
IntPtr function = Marshal.ReadIntPtr(real, 668);
IntPtr functionL = Marshal.ReadIntPtr(real, 656);
IntPtr realVmStruct = Marshal.ReadIntPtr(vm);
StringDelegate newStringUTF = Marshal.GetDelegateForFunctionPointer <StringDelegate>(function);
GetStringLength stringLen = Marshal.GetDelegateForFunctionPointer <GetStringLength>(functionL);
ExceptionCheck checkException = Marshal.GetDelegateForFunctionPointer <ExceptionCheck>(Marshal.ReadIntPtr(real, 912));
ExceptionDescribe printException = Marshal.GetDelegateForFunctionPointer <ExceptionDescribe>(Marshal.ReadIntPtr(real, 64));
NewObjectArray newObjectArray = Marshal.GetDelegateForFunctionPointer <NewObjectArray>(Marshal.ReadIntPtr(real, 688));
FindClass findClass = Marshal.GetDelegateForFunctionPointer <FindClass>(Marshal.ReadIntPtr(real, 24));
SetArray setArray = Marshal.GetDelegateForFunctionPointer <SetArray>(Marshal.ReadIntPtr(real, 696));
DestroyJavaVM destroyVM = Marshal.GetDelegateForFunctionPointer <DestroyJavaVM>(Marshal.ReadIntPtr(realVmStruct, 12));
//attach api start
Java_sun_tools_attach_WindowsVirtualMachine_init(env, IntPtr.Zero);
IntPtr stub = Java_sun_tools_attach_WindowsVirtualMachine_generateStub(env, IntPtr.Zero);
long process = Java_sun_tools_attach_WindowsVirtualMachine_openProcess(env, IntPtr.Zero, pid);
Console.WriteLine("exception " + checkException(env));
IntPtr cmd = newStringUTF(env, "load");
IntPtr pipeName = newStringUTF(env, "\\\\.\\pipe\\javatool22");
IntPtr pathJStr = newStringUTF(env, path);
IntPtr unknownBoolean = newStringUTF(env, "true");
IntPtr argumentsJ = newStringUTF(env, arguments);
Console.WriteLine("exception " + checkException(env));
IntPtr clazz = findClass(env, "java/lang/String");
IntPtr array = newObjectArray(env, 3, clazz, IntPtr.Zero);
setArray(env, array, 0, pathJStr);
setArray(env, array, 1, unknownBoolean);
setArray(env, array, 2, argumentsJ);
Java_sun_tools_attach_WindowsVirtualMachine_enqueue(env, IntPtr.Zero,
process, stub, cmd, pipeName, array);
Console.WriteLine("exception " + checkException(env));
printException(env);
/*
*
* var pipe = new NamedPipeServerStream("javatool22");
* pipe.WaitForConnection();
* BinaryReader reader = new BinaryReader(pipe);
* char callback = reader.ReadChar();
*
*
* Console.WriteLine("pipe result " + callback);
*/
Java_sun_tools_attach_WindowsVirtualMachine_closeProcess(env, IntPtr.Zero, process);
int rr = destroyVM(vm);
Console.WriteLine("destroyed vm: " + result);
}
