[GR-70147] EspressoNoNative: Synchronize SocketOptions between host and guest

The guest encodes SocketOptions to ints in the platform-specific sun.nio.ch.SocketOptionRegistry.findOption. Those encodings are then provided to nativ get/set methods. 

In the substitutions of those methods in EspressoNoNative we have to decode the ints back to the original SocketOption. 

To ensure consistency between guest SocketOptions and host SocketOptions across platforms, we substitute findOption to use our
custom encoding.

Author: Elia Trachsel

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/descriptors/EspressoSymbols.java

@@ -183,9 +183,12 @@ public static void ensureInitialized() {
         public static final Symbol<Type> java_net_InetAddress_array = SYMBOLS.putType("[Ljava/net/InetAddress;");
         public static final Symbol<Type> sun_net_ConnectionResetException = SYMBOLS.putType("Lsun/net/ConnectionResetException;");
         public static final Symbol<Type> java_net_UnknownHostException = SYMBOLS.putType("Ljava/net/UnknownHostException;");
+        public static final Symbol<Type> java_net_SocketOption = SYMBOLS.putType("Ljava/net/SocketOption;");
         public static final Symbol<Type> sun_nio_ch_IOStatus = SYMBOLS.putType("Lsun/nio/ch/IOStatus;");
         public static final Symbol<Type> java_net_spi_InetAddressResolver$LookupPolicy = SYMBOLS.putType("Ljava/net/spi/InetAddressResolver$LookupPolicy;");
         public static final Symbol<Type> sun_nio_ch_Net = SYMBOLS.putType("Lsun/nio/ch/Net;");
+        public static final Symbol<Type> sun_nio_ch_OptionKey = SYMBOLS.putType("Lsun/nio/ch/OptionKey;");
+
         // libjava
         public static final Symbol<Type> java_lang_ProcessHandleImpl$Info = SYMBOLS.putType("Ljava/lang/ProcessHandleImpl$Info;");
         // libnio
@@ -1260,6 +1263,7 @@ public static class Signatures {
         public static final Symbol<Signature> _void_Exception = SYMBOLS.putSignature(Types._void, Types.java_lang_Exception);
         public static final Symbol<Signature> _void_String_String_String_int = SYMBOLS.putSignature(Types._void, Types.java_lang_String, Types.java_lang_String, Types.java_lang_String, Types._int);
         public static final Symbol<Signature> _void_int = SYMBOLS.putSignature(Types._void, Types._int);
+        public static final Symbol<Signature> _void_int_int = SYMBOLS.putSignature(Types._void, Types._int, Types._int);
         public static final Symbol<Signature> _void_boolean = SYMBOLS.putSignature(Types._void, Types._boolean);
         public static final Symbol<Signature> _void_long = SYMBOLS.putSignature(Types._void, Types._long);
         public static final Symbol<Signature> _void_long_int = SYMBOLS.putSignature(Types._void, Types._long, Types._int);

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/LibsMeta.java

@@ -185,6 +185,12 @@ public final class LibNetMeta {
         public final ObjectKlass java_net_InetSocketAddress;
         public final Method java_net_InetSocketAddress_init;
 
+        // Synchronize guest and host SocketOptions.
+        public final ObjectKlass sun_nio_ch_OptionKey;
+        public final Method sun_nio_ch_OptionKey_init;
+        public final ObjectKlass java_net_SocketOption;
+        public final Method java_net_SocketOption_name;
+
         // Checkstyle: resume field name check
 
         private LibNetMeta() {
@@ -221,6 +227,11 @@ private LibNetMeta() {
 
             java_net_InetSocketAddress = knownKlass(EspressoSymbols.Types.java_net_InetSocketAddress);
             java_net_InetSocketAddress_init = java_net_InetSocketAddress.lookupDeclaredMethod(EspressoSymbols.Names._init_, EspressoSymbols.Signatures.java_net_InetSocketAddress_init_signature);
+
+            sun_nio_ch_OptionKey = knownKlass(EspressoSymbols.Types.sun_nio_ch_OptionKey);
+            sun_nio_ch_OptionKey_init = sun_nio_ch_OptionKey.requireDeclaredMethod(EspressoSymbols.Names._init_, EspressoSymbols.Signatures._void_int_int);
+            java_net_SocketOption = knownKlass(EspressoSymbols.Types.java_net_SocketOption);
+            java_net_SocketOption_name = java_net_SocketOption.requireDeclaredMethod(EspressoSymbols.Names.name, EspressoSymbols.Signatures.String);
         }
     }
 

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/LibsState.java

@@ -29,12 +29,16 @@
 import java.net.Inet6Address;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
+import java.net.SocketOption;
+import java.net.StandardSocketOptions;
 import java.nio.channels.CancelledKeyException;
 import java.nio.channels.SelectableChannel;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
@@ -484,7 +488,7 @@ public void pollerCleanSelectionKey(int fdToClean) {
 
     /**
      * Only used for testing.
-     * 
+     *
      * @return true if there are no registrations for the TrufflePoller
      */
     public boolean noPollerRegisterations() {
@@ -637,4 +641,66 @@ private InetAddress getInetAddress(String hostName, int address, boolean preferI
             return guestInetAddr;
         }
     }
+
+    /**
+     * Class for synchronizing platform-specific socket options between the host and the guest.
+     */
+    public static final class SocketOptionSync {
+        /*
+         * The guest encodes SocketOptions to ints in the platform-specific
+         * sun.nio.ch.SocketOptionRegistry.findOption. Those encodings are then provided to native
+         * get/set methods. In the substitutions of those methods in EspressoNoNative we have to
+         * decode the ints back to the original SocketOption. To ensure consistency between guest
+         * SocketOptions and host SocketOptions across platforms, we substitute findOption to use our
+         * custom encoding defined by this class.
+         */
+
+        // Defines all supported StandardSocketOptions. ExtendedSocketOptions are currently disabled GR-78554.
+        private static final SocketOption<?>[] intToOption = {
+                        StandardSocketOptions.SO_BROADCAST,
+                        StandardSocketOptions.SO_KEEPALIVE,
+                        StandardSocketOptions.SO_SNDBUF,
+                        StandardSocketOptions.SO_RCVBUF,
+                        StandardSocketOptions.SO_REUSEADDR,
+                        StandardSocketOptions.SO_REUSEPORT,
+                        StandardSocketOptions.SO_LINGER,
+                        StandardSocketOptions.IP_TOS,
+                        StandardSocketOptions.TCP_NODELAY,
+                        StandardSocketOptions.IP_MULTICAST_IF,
+                        StandardSocketOptions.IP_MULTICAST_TTL,
+                        StandardSocketOptions.IP_MULTICAST_LOOP
+        };
+        private static final Map<String, Integer> optionNameToInt = createOptionNameToInt();
+
+        private static Map<String, Integer> createOptionNameToInt() {
+            Map<String, Integer> result = new HashMap<>(intToOption.length);
+            for (int i = 0; i < intToOption.length; i++) {
+                String name = intToOption[i].name();
+                if (result.put(name, i) != null) {
+                    throw new IllegalStateException("Duplicate SocketOption name: " + name);
+                }
+            }
+            return result;
+        }
+
+        /**
+         * Retrieve the int encoding associated with the given name of the SocketOption.
+         *
+         * @param name the name associated with the SocketOption
+         * @return the encoding or -1 if the option was not found
+         */
+        public static int getInt(String name) {
+            return name == null ? -1 : optionNameToInt.getOrDefault(name, -1);
+        }
+
+        /**
+         * Retrieve the SocketOption associated with the given encoding.
+         *
+         * @param code the encoded SocketOption
+         * @return the SocketOption
+         */
+        public static SocketOption<?> getOption(int code) {
+            return intToOption[code];
+        }
+    }
 }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/Target_jdk_net_ExtendedSocketOptions_PlatformSocketOptions.java

@@ -34,6 +34,7 @@ public final class Target_jdk_net_ExtendedSocketOptions_PlatformSocketOptions {
     @Substitution(languageFilter = EspressoLibsFilter.class)
     public static @JavaType(internalName = "Ljdk/net/ExtendedSocketOptions$PlatformSocketOptions;") StaticObject create(
                     @Inject LibsMeta libsMeta) {
+        // todo (GR-78554)
         // lazily initialize jdk/net
         libsMeta.initJdkNet();
         // create a nonPlatformSpecificOptions instance to return

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/libnio/impl/Target_sun_nio_ch_Net.java

@@ -32,7 +32,6 @@
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.net.SocketOption;
-import java.net.StandardSocketOptions;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 
@@ -260,14 +259,13 @@ public static int localPort(@JavaType(FileDescriptor.class) StaticObject fd, @In
     @SuppressWarnings("unchecked")
     @TruffleBoundary
     public static void setIntOption0(@JavaType(FileDescriptor.class) StaticObject fd, @SuppressWarnings("unused") boolean mayNeedConversion,
-                    int level, int opt, int arg, @SuppressWarnings("unused") boolean isIPv6,
-                    @Inject EspressoContext ctx, @Inject TruffleIO io, @Inject LibsState libsState) {
+                    int level, @SuppressWarnings("unused") int opt, int arg, @SuppressWarnings("unused") boolean isIPv6, @Inject TruffleIO io, @Inject LibsState libsState) {
         libsState.net.checkNetworkEnabled();
         // We set the option over the public NetworkChannel API, thus the low-level platform
         // specific arguments like mayNeedConversion and isIpv6 aren't needed
 
         // recover SocketOption and do Type-Conversion
-        SocketOption<?> socketOption = getSocketOption(level, opt, ctx);
+        SocketOption<?> socketOption = getSocketOption(level);
         Class<?> type = socketOption.type();
         if (type == Integer.class) {
             SocketOption<Integer> intSocketOption = (SocketOption<Integer>) socketOption;
@@ -286,14 +284,13 @@ public static void setIntOption0(@JavaType(FileDescriptor.class) StaticObject fd
     @SuppressWarnings("unchecked")
     @TruffleBoundary
     public static int getIntOption0(@JavaType(FileDescriptor.class) StaticObject fd, @SuppressWarnings("unused") boolean mayNeedConversion,
-                    int level, int opt,
-                    @Inject EspressoContext ctx, @Inject TruffleIO io, @Inject LibsState libsState) {
+                    int level, @SuppressWarnings("unused") int opt, @Inject TruffleIO io, @Inject LibsState libsState) {
         libsState.net.checkNetworkEnabled();
         // We get the option over the public NetworkChannel API, thus the low-level platform
         // mayNeedConversion and isIpv6 aren't needed
 
         // recover SocketOption and do Type-Conversion
-        SocketOption<?> socketOption = getSocketOption(level, opt, ctx);
+        SocketOption<?> socketOption = getSocketOption(level);
         Class<?> type = socketOption.type();
         if (type == Integer.class) {
             SocketOption<Integer> intSocketOption = (SocketOption<Integer>) socketOption;
@@ -378,64 +375,7 @@ private static int nativeToSelectorOps(int nativeOps, EspressoContext ctx) {
         return ops;
     }
 
-    private static SocketOption<?> getSocketOption(int level, int opt, EspressoContext ctx) {
-        // todo (GR-70147): synchronize between host and guest
-        // be aware of GR-71965
-        switch (level) {
-            case 0:
-                switch (opt) {
-                    case 1:
-                        return StandardSocketOptions.IP_TOS;
-                    case 32:
-                        return StandardSocketOptions.IP_MULTICAST_IF;
-                    case 33:
-                        return StandardSocketOptions.IP_MULTICAST_TTL;
-                    case 34:
-                        return StandardSocketOptions.IP_MULTICAST_LOOP;
-                }
-                break;
-            case 1:
-                switch (opt) {
-                    case 2:
-                        return StandardSocketOptions.SO_REUSEADDR;
-                    case 6:
-                        return StandardSocketOptions.SO_BROADCAST;
-                    case 7:
-                        return StandardSocketOptions.SO_SNDBUF;
-                    case 8:
-                        return StandardSocketOptions.SO_RCVBUF;
-                    case 9:
-                        return StandardSocketOptions.SO_KEEPALIVE;
-                    case 10:
-                        /*
-                         * Would be a ExtendedSocketOption.SO_OOBINLINE, however ExtendedOption are
-                         * package private so we cannot easily access them. For set and getOption of
-                         * Net, extended options aren't accessed over the native world anyway thus
-                         * we shouldn't reach here
-                         */
-                        throw JavaSubstitution.unimplemented();
-                    case 13:
-                        return StandardSocketOptions.SO_LINGER;
-                    case 15:
-                        return StandardSocketOptions.SO_REUSEPORT;
-                }
-                break;
-            case 41:
-                switch (opt) {
-                    case 17:
-                        return StandardSocketOptions.IP_MULTICAST_IF;
-                    case 18:
-                        return StandardSocketOptions.IP_MULTICAST_TTL;
-                    case 19:
-                        return StandardSocketOptions.IP_MULTICAST_LOOP;
-                    case 67:
-                        return StandardSocketOptions.IP_TOS;
-                }
-                break;
-        }
-        if (level == 6 && opt == 1) {
-            return StandardSocketOptions.TCP_NODELAY;
-        }
-        throw Throw.throwUnsupported("Unsupported SocketOption: level = " + level + ", opt = " + opt, ctx);
+    private static SocketOption<?> getSocketOption(int level) {
+        return LibsState.SocketOptionSync.getOption(level);
     }
 }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/libnio/impl/Target_sun_nio_ch_SocketOptionRegistry.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.espresso.libs.libnio.impl;
+
+import java.net.ProtocolFamily;
+import java.net.SocketOption;
+
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.espresso.libs.EspressoLibsFilter;
+import com.oracle.truffle.espresso.libs.LibsMeta;
+import com.oracle.truffle.espresso.libs.LibsState;
+import com.oracle.truffle.espresso.meta.Meta;
+import com.oracle.truffle.espresso.runtime.EspressoContext;
+import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
+import com.oracle.truffle.espresso.substitutions.EspressoSubstitutions;
+import com.oracle.truffle.espresso.substitutions.Inject;
+import com.oracle.truffle.espresso.substitutions.JavaSubstitution;
+import com.oracle.truffle.espresso.substitutions.JavaType;
+import com.oracle.truffle.espresso.substitutions.Substitution;
+
+@EspressoSubstitutions
+public final class Target_sun_nio_ch_SocketOptionRegistry {
+    /*
+     * As we just use the int level to encode SocketOptions we define here a dummy value as the
+     * (unused) name of the OptionKey.
+     */
+    private static final int OPTION_KEY_NAME = 0;
+
+    @TruffleBoundary
+    @Substitution(languageFilter = EspressoLibsFilter.class)
+    public static @JavaType(internalName = "Lsun/nio/ch/OptionKey;") StaticObject findOption(@JavaType(SocketOption.class) StaticObject name,
+                    @SuppressWarnings("unused") @JavaType(ProtocolFamily.class) StaticObject family,
+                    @Inject LibsMeta libsMeta,
+                    @Inject Meta meta,
+                    @Inject EspressoContext context) {
+        // First retrieve the name of the guest options.
+        Object result = libsMeta.net.java_net_SocketOption_name.invokeDirectInterface(name);
+        // Use the name to get the int encoding.
+        String optionName = meta.toHostString((StaticObject) result);
+        int level = LibsState.SocketOptionSync.getInt(optionName);
+        if (level == -1) {
+            throw JavaSubstitution.shouldNotReachHere();
+        }
+        return makeGuestOptionKey(level, libsMeta, context);
+    }
+
+    private static @JavaType(internalName = "Lsun/nio/ch/OptionKey;") StaticObject makeGuestOptionKey(int level, LibsMeta libsMeta, EspressoContext context) {
+        StaticObject guestObject = libsMeta.net.sun_nio_ch_OptionKey.allocateInstance(context);
+        libsMeta.net.sun_nio_ch_OptionKey_init.invokeDirectSpecial(guestObject, level, OPTION_KEY_NAME);
+        return guestObject;
+    }
+
+}