Migrate to JNA for Windows Named Pipes (#339)

Author: gesellix

build.gradle.kts

@@ -71,6 +71,7 @@ dependencies {
     isTransitive = true
   }
   implementation(libs.junixsocketCommon)
+  implementation(libs.bundles.jna)
 
   testImplementation("org.junit.jupiter:junit-jupiter-api:5.13.4")
   testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.13.4")

gradle/libs.versions.toml

@@ -1,4 +1,5 @@
 [versions]
+jna = "5.17.0"
 junixsocket = "2.10.1"
 junixsocketVersionrange = "[2.4,3)"
 kotlin = "2.2.0"
@@ -13,7 +14,8 @@ slf4j = "2.0.17"
 slf4jVersionrange = "[1.7,3)"
 
 [libraries]
-junit4 = { module = "junit:junit", version = "4.13.2" }
+jna = { module = "net.java.dev.jna:jna", version.ref = "jna" }
+jnaPlatform = { module = "net.java.dev.jna:jna-platform", version.ref = "jna" }
 junixsocketCore = { module = "com.kohlschutter.junixsocket:junixsocket-core", version.ref = "junixsocket" }
 junixsocketCommon = { module = "com.kohlschutter.junixsocket:junixsocket-common", version.ref = "junixsocket" }
 kotlin = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
@@ -28,5 +30,6 @@ slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 
 [bundles]
 kotlin = ["kotlin", "kotlinCommon", "kotlinJdk7", "kotlinJdk8"]
+jna = ["jna", "jnaPlatform"]
 junixsocket = ["junixsocketCore", "junixsocketCommon"]
 okio = ["okio", "okioJvm"]

src/main/java/de/gesellix/docker/client/filesocket/AsynchronousFileByteChannel.java

@@ -0,0 +1,43 @@
+package de.gesellix.docker.client.filesocket;
+
+import com.sun.jna.Library;
+import com.sun.jna.Native;
+import com.sun.jna.Pointer;
+import com.sun.jna.platform.win32.WinBase;
+import com.sun.jna.platform.win32.WinDef;
+import com.sun.jna.platform.win32.WinNT;
+import com.sun.jna.ptr.IntByReference;
+import com.sun.jna.win32.W32APIOptions;
+
+public interface ExtendedKernel32 extends Library {
+
+    ExtendedKernel32 INSTANCE = Native.load("kernel32", ExtendedKernel32.class, W32APIOptions.DEFAULT_OPTIONS);
+
+    boolean GetOverlappedResult(
+      WinNT.HANDLE hFile,
+      WinBase.OVERLAPPED lpOverlapped,
+      IntByReference lpNumberOfBytesTransferred,
+      boolean bWait
+    );
+
+    /**
+     * Cancels all pending I/O operations on the specified file handle.
+     *
+     * @param hFile        The handle to the file or I/O device.
+     * @param lpOverlapped Reserved; should be NULL.
+     * @return true if successful; false otherwise.
+     */
+    boolean CancelIoEx(
+      WinNT.HANDLE hFile,
+      Pointer lpOverlapped
+    );
+
+    WinDef.DWORD WaitForSingleObject(
+      WinNT.HANDLE hHandle,
+      int dwMilliseconds
+    );
+
+    boolean CloseHandle(
+      WinNT.HANDLE hObject
+    );
+}

src/main/java/de/gesellix/docker/client/filesocket/ExtendedKernel32.java

@@ -0,0 +1,68 @@
+package de.gesellix.docker.client.filesocket;
+
+import java.io.IOException;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.sun.jna.platform.win32.Kernel32;
+import com.sun.jna.platform.win32.WinError;
+import com.sun.jna.platform.win32.WinNT;
+import com.sun.jna.ptr.IntByReference;
+
+import okio.Buffer;
+import okio.Sink;
+import okio.Timeout;
+
+public class NamedPipeSink implements Sink {
+
+    private final WinNT.HANDLE handle;
+    private final int timeoutMillis;
+
+    public NamedPipeSink(WinNT.HANDLE handle, int timeoutMillis) {
+        this.handle = handle;
+        this.timeoutMillis = timeoutMillis;
+    }
+
+    @Override
+    public void write(@NotNull Buffer source, long byteCount) throws IOException {
+        if (byteCount == 0) {
+            return;
+        }
+        if (byteCount > Integer.MAX_VALUE) {
+            throw new IllegalArgumentException("Can only write max " + Integer.MAX_VALUE + " bytes");
+        }
+
+        byte[] data = source.readByteArray(byteCount);
+        IntByReference bytesWritten = new IntByReference();
+        //boolean ok = NamedPipeUtils.writeFromBuffer(handle, data, data.length, bytesWritten);
+        boolean ok = NamedPipeUtils.writeOverlapped(handle, data, data.length, bytesWritten, timeoutMillis);
+        if (!ok) {
+            int err = Kernel32.INSTANCE.GetLastError();
+            if (err == WinError.ERROR_OPERATION_ABORTED) {
+                // Expected when CancelIoEx() is called during close()
+                return;
+            }
+            throw new IOException("Failed to write to Named Pipe. WinError=" + err);
+        }
+
+        if (bytesWritten.getValue() <= 0) {
+            throw new IOException("No bytes written to Named Pipe");
+        }
+    }
+
+    @Override
+    public void flush() {
+        // No-op for Named Pipes
+    }
+
+    @NotNull
+    @Override
+    public Timeout timeout() {
+        return Timeout.NONE;
+    }
+
+    @Override
+    public void close() {
+        // No-op, handle closed by NamedPipeSocket
+    }
+}