Java

/*
 ******************************************************************************
 *
 *    Name     : cpptojava.cpp
 *
 *    Function : Basic Console application to call a Java class.
 *
 *    Created  : 09 Jun 2022
 *
 ******************************************************************************
 */

#include <Windows.h>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <filesystem> // requires -std:c++17

#include "jni.h"

//
// Find the path to the jvm.dll given the base path to the Java runtime (or JDK if installed)
//
HMODULE LoadDll(
    const char* jrePath
)
{
    const char* pszjvmname = "bin\\server\\jvm.dll";   // Java VM name
    HMODULE hJVMDLL = 0;

    std::filesystem::path jvmpath(jrePath);
    jvmpath /= pszjvmname;
    if (!std::filesystem::exists(jvmpath))
    {
        std::cerr << "JVM library " << jvmpath << " not found." << std::endl;
        // throw an exception 
    }

    // load the Java VM DLL into our address space
    // NB filesystem::path is Unicode
    hJVMDLL = LoadLibraryW(reinterpret_cast<PCWSTR>(jvmpath.c_str()));
    if (hJVMDLL != NULL)
    {
        std::clog << "jvm.dll loaded from: " << jvmpath << std::endl;
    }
    return hJVMDLL; // a Windows HANDLE to the DLL
}


//
// A function to load the Java VM and initialise the JNI interface
// There are a number of diagnostic messages to show progress
//
JNIEnv* AttachJVM(
    const char* jrePath,
    JavaVM* jvm,
    std::string strcwd
)
{
    HMODULE     hJVMDLL = LoadDll(jrePath);
    if (hJVMDLL == 0)
    {
        return nullptr;
    }
    typedef jint(JNICALL* fpCJV)(JavaVM**, void**, void*);
    fpCJV JNI_CreateJavaVM = (fpCJV)::GetProcAddress(hJVMDLL, "JNI_CreateJavaVM");

    // tell the JVM where to find the class
    JavaVMOption    options[2];
    std::stringstream ssoptions;
    ssoptions << "-Djava.class.path=";
    ssoptions << strcwd;
    std::string stropts = ssoptions.str();
    options[0].optionString = const_cast<char*>(stropts.c_str());
    options[1].optionString = const_cast<char*>("-verbose:jni");   // print JNI-related messages

    JavaVMInitArgs  vm_args; // JDK/JRE 6 VM initialization arguments
    vm_args.version = JNI_VERSION_1_8;
    vm_args.nOptions = 1; // change to 2 for verbose output
    vm_args.ignoreUnrecognized = false;
    vm_args.options = options;
    for (int i = 0; i < vm_args.nOptions; ++i)
    {
        std::clog << "Options[" << i << "]: " << options[i].optionString << std::endl;
    }
    JNIEnv* env;            // pointer to native method interface
    jint res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
    if (res != 0)
    {
        std::cerr << "C++: JNI_CreateJavaVM returned: " << res << std::endl;
    }
    jint version = env->GetVersion();
    std::clog << "JVM Version: " << (version >> 16) << "." << (version & 0xffff) << std::endl;

    return env; // the pointer to the jvm dll
}


void CallClass(
    JNIEnv* jniEnv,
    const char* pszClassname,
    const char* pszMethodname,
    const char* pszSignature
)
{
    jclass jvmclass = jniEnv->FindClass(pszClassname);
    if (jvmclass != NULL)
    {
        std::cout << "C++: Found the class: " << pszClassname << std::endl;
        jmethodID jmid = jniEnv->GetStaticMethodID(jvmclass, pszMethodname, pszSignature);
        if (jmid != NULL)
        {
            std::cout << "C++: Found the method: " << pszMethodname << std::endl;
            jniEnv->CallStaticVoidMethod(jvmclass, jmid, NULL);
            std::cout << "C++: env->CallStaticVoidMethod complete" << std::endl;
        }
        else
        {
            std::cerr << "C++: Failed to find the method: " << pszMethodname << std::endl;
        }
    }
    else
    {
        std::cerr << "C++: Failed to find the class: " << pszClassname << std::endl;
    }
}


int main(
    int argc,
    const char** argv
)
{
    const char* jreDir = nullptr;

    // suppress debug messages
    std::clog.setstate(std::ios::badbit);
    for (argv++; argc > 1; ++argv, --argc)
    {
        if (*argv[0] == '-')
        {
            // handle any execution options ...
            if (strstr(*argv, "-d"))
                std::clog.clear();
        }
        else
        {
            jreDir = *argv;
        }
    }
    if (jreDir == nullptr)
    {
        std::cerr << "No root path provided for JVM." << std::endl;
        return 1;
    }
    JNIEnv* jniEnv = NULL;
    std::filesystem::path cwd = std::filesystem::current_path();
    JavaVM jvm;
    jniEnv = AttachJVM(jreDir, &jvm, cwd.string());
    if (jniEnv == NULL)
    {
        std::cerr << "C++: Failed to get Java environment" << std::endl;
        return 1;
    }
        CallClass(jniEnv, "CppToJava", "main", "([Ljava/lang/String;)V");

    // clean up
    jint jvmres = jvm.DestroyJavaVM(); // never returns ???
    std::clog << "C++: DestroyJavaVM and terminate: " << jvmres << std::endl;

}

#include <jni.h>
#include <string>
#include <iostream>
#include <chrono>
#include <thread>

JavaVM* jvm = nullptr;

std::string createVM(std::string location) {
	//Here what I need to add to load the dll from location + ThirdParty\Eclipse Adoptium\jre-17.0.7.7-hotspot\bin\server
	location.insert(0, "-Djava.class.path=");
	location.append("Data\\Java");
	JavaVMInitArgs vm_args;
	JavaVMOption* options = new JavaVMOption[1];
	options[0].optionString = &location[0];
	vm_args.version = JNI_VERSION_10;
	vm_args.nOptions = 1;
	vm_args.options = options;
	vm_args.ignoreUnrecognized = false;
	JNIEnv* env = nullptr;
	jint rc = JNI_OK;
	if (jvm == nullptr) {
		rc = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
	}
	else {
		rc = jvm->AttachCurrentThread((void**)&env, NULL);
	}
	delete[] options;
	if (rc != JNI_OK) {
		if (rc == JNI_EVERSION)
			return "JNI_EVERSION";
		else if (rc == JNI_ENOMEM)
			return "JNI_ENOMEM";
		else if (rc == JNI_EINVAL)
			return "JNI_EINVAL";
		else if (rc == JNI_EEXIST)
			return "JNI_EEXIST";
		else
			return "JNI_FATALERROR";
	}
	return "JNI_CREATED";
}

std::string createIdentification() {
	JNIEnv* env;
	jvm->AttachCurrentThread((void**)&env, NULL);
	jclass jClass = env->FindClass("JavaMethods");

	if (jClass == nullptr) {
		return "ClassNotFound cI";
	}
	else {
		jmethodID methodID = env->GetStaticMethodID(jClass, "createIdentification", "()Ljava/lang/String;");
		if (methodID == nullptr) {
			return "MethodNotFound cI";
		}
		else {
			jboolean isCopy;
			jstring jResult = (jstring)env->CallStaticObjectMethod(jClass, methodID);
			const char* string = env->GetStringUTFChars(jResult, &isCopy);
			std::string result = string;
			env->ReleaseStringUTFChars(jResult, string);

			return result;
		}
	}
}

int main() {
	//As an example I wrote a possible location
	std::cout << createVM("D:\\Program Files\\MyApp\\").c_str() << std::endl;
	std::cout << createIdentification().c_str();

	std::this_thread::sleep_for(std::chrono::milliseconds(2000));
	return 0;
}

System.out.println("Starting client");
Socket socket = new Socket("localhost", port);
System.out.println("Client sending data");
ObjectOutputStream dataOut = new ObjectOutputStream(socket.getOutputStream());
BufferedInputStream is = new BufferedInputStream(new FileInputStream(inFile));
byte[] buffer = new byte[8192];
int sizeRead = 0;
while ((sizeRead = is.read(buffer, 0, 8192)) >= 0) {
    printByte(buffer, "in"); //Function that writes to a file as strings the byte[], and after 8192 you can see it is the first byte[] each time, also it writes at the end of file
    dataOut.writeObject(true);
    dataOut.writeObject(buffer);
    dataOut.writeObject(sizeRead);
    dataOut.flush();
}
is.close();
System.out.println("Done sending file");
dataOut.writeObject(false);
socket.close();
System.out.println("Client closed");

System.out.println("Starting server");
ServerSocket server = new ServerSocket(port);
System.out.println("Server waiting");
Socket socket = server.accept();
System.out.println("Client connected");
ObjectInputStream dataIn = new ObjectInputStream(socket.getInputStream());
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(outFile));
Object auxKeepReading = dataIn.readObject();
if (auxKeepReading instanceof Boolean) {
    while ((boolean) auxKeepReading) {
        Object auxBuffer = dataIn.readObject();
        if (!(auxBuffer instanceof byte[])) {
            System.out.println("Broke byte");
            break;
        }
        Object auxSize = dataIn.readObject();
        if (!(auxSize instanceof Integer)) {
            System.out.println("Broke int");
            break;
        }
        printByte((byte[]) auxBuffer, "out"); //Same as on client but different file, it writes at the end of file each time
        bos.write((byte[]) auxBuffer, 0, (int) auxSize);

        auxKeepReading = dataIn.readObject();
        if (!(auxKeepReading instanceof Boolean)) {
            System.out.println("Broke boolean");
            break;
        }
    }
} else {
    System.out.println("Broke boolean");
}
bos.close();
socket.close();
server.close();
System.out.println("Server stopped");