HTran | connection bouncer , a kind of proxy server | TCP library

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.