jna | definitive JNA reference ( including an overview and usage | Wrapper library

You are running the project via Java 1.8 and add the --add-opens option to the runner. However Java 1.8 does not support it.

So, the first option is to use Java 11 to run the project, as Java 11 can recognize this VM option.

Another solution is to find a place where --add-opens is added and remove it. Check Run configuration in IntelliJ IDEA (VM options field) and Maven/Gradle configuration files for argLine (Maven) and jvmArgs (Gradle)

Building an ARM-based image is not currently possible with mvn spring-boot:build-image, because the Cloud Native Buildpacks builders that Spring Boot integrates with do not support this. This is one of the possible items of focus on the Paketo buildpacks 2022 roadmap, which you can cast votes for.

CNB documents a work-around for this, but it's not simple to set up and run.

RUN mvn -f /home/path_to_app/pom.xml spring-boot:build-image -DskipTests

You would need Docker-in-Docker to make something like this work, since the CNB builder processes that would run inside the Docker container need to talk to the Docker daemon. Regardless, this would not allow you to build an ARM image for the reasons stated above.

Found a solution: Inside sbt 1.4.6 there is a JNA library version 5.5.0, which apparently does not have the necessary files for the arm64 architecture processor Raising the sbt version to 1.6.2 helped

You have an invalid handle, just not the one you think.

The problem is in your function mapping for SetWindowPos:

The first thing to check when you get Invalid Memory Access errors is your type mapping, which you correctly started with looking at the int return value. Turns out the String mapping for the other arguments, which works fine on *nix systems, needs a little special treatment on Windows.

By default Windows uses UTF 16 encoding, and JNA's default type mapping under-the-hood tries to convert Java String objects to UTF-16 encoded native strings (wchar*). This works fine for Windows API DLLs.

However, your custom DLL specified that the User Name and Password arguments should be in ASCIIZ format (null-terminated C strings).

You can force JNA to use an ASCII String type mapper by including W32APIOptions.ASCII_OPTIONS as a third argument when loading the DLL, e.g.,

You can just load the library by name in JNA as usual (version 5.6 or greater).

Based on the code you've provided, the problem is the same as other Callback-related questions here: you're losing the native allocation of TRANX due to Java's garbage collection.

A JNA Structure consists of two parts: a pointer (to data), and the data itself. You have not provided the native typedef for TRANX to confirm your JNA mapping, but an instantiated object will have an internal pointer reference, pointing to a 4-byte allocation of memory (the int unused).

You only show the callback code where TRANX is already an argument, meaning you've already instantiated it to pass to the callback.

If you allocated it yourself using new TRANX() or new TRANX(int unused), then JNA has

• allocated 4 bytes of native memory
• stored the pointer to it internally

In JNA, the native memory attached to a Structure is automatically freed as a part of the garbage collection process. This is a common problem with callbacks, as you generally don't control the timing of the callback return, so the following sequence occurs:

• You create the object in Java (allocating the native 4 bytes which the TRANX structure tracks the pointer to internally)
• You pass the TRANX object to the callback
• Immediately after passing the object, Java no longer has need for its own object; it is unreachable and thus eligible for garbage collection
• When GC occurs the native 4 bytes are freed as part of the process
• The TRANX object in the callback still has the pointer internally, but it now points to memory that is no longer allocated, resulting in the SIGSEGV (or Invalid Memory Access error, or strange symptoms if the memory is allocated by another thread, or other undefined behavior).

The solution to the problem is to track the memory associated with TRANX.

• If you are allocating it yourself, keep a reference to the TRANX object to prevent it from being unreachable.
  • This generally requires accessing the TRANX structure at some later point after you are sure the callback will have been processed
  • In JDK9+ a ReachabilityFence can be used for this.
  • In JDK8 you should manipulate the class in some way (e.g., read a value from it, or call toString on it, etc.).
• If you are using a native allocation and creating the pointer from the peer value returned from the native API, then read the API to determine when that memory is freed.

The WINAPI call you need is ReportEvent.

This is mapped in the user-contributed platform mappings in JNA in Advapi32.

The Advapi32Test class contains code demonstrating writing an event. I've excerpted portions of this test code below:

You need to take care of a few things here:

• You have already download the ChromeDriver and accessing it as: