src/jdk.net/share/classes/jdk/net/ExtendedSocketOptions.java

*** 66,89 ****
       */
      public static final SocketOption<SocketFlow> SO_FLOW_SLA = new
          ExtSocketOption<SocketFlow>("SO_FLOW_SLA", SocketFlow.class);
  
  
      private static final PlatformSocketOptions platformSocketOptions =
              PlatformSocketOptions.get();
  
      private static final boolean flowSupported =
              platformSocketOptions.flowSupported();
  
      private static final Set<SocketOption<?>> extendedOptions = options();
  
      static Set<SocketOption<?>> options() {
!         if (flowSupported)
              return Set.of(SO_FLOW_SLA);
!         else
              return Collections.<SocketOption<?>>emptySet();
      }
  
      static {
          // Registers the extended socket options with the base module.
          sun.net.ext.ExtendedSocketOptions.register(
                  new sun.net.ext.ExtendedSocketOptions(extendedOptions) {
--- 66,124 ----
       */
      public static final SocketOption<SocketFlow> SO_FLOW_SLA = new
          ExtSocketOption<SocketFlow>("SO_FLOW_SLA", SocketFlow.class);
  
  
+     /**
+      * TCP_QUICKACK.
+      *
+      * This socket option usually enable TCP_QUICKACK mode if set or disable
+      * TCP_QUICKACK mode if cleared.
+      *
+      * The value of this socket option is a {@code Boolean} that represents
+      * whether the option is enabled or disabled. The socket option is specific
+      * to stream-oriented sockets using the TCP/IP protocol.
+      *
+      * The exact semantics of this socket option are socket type and system
+      * dependent.
+      *
+      * When TCP_QUICKACK is enabled, acks are sent immediately, rather than
+      * delayed if needed in accordance to normal TCP operation.This flag is not
+      * permanent, it only enables a switch to or from TCP_QUICKACK mode.
+      *
+      * Subsequent operation of the TCP protocol will once again enter/leave
+      * TCP_QUICKACK mode depending on internal protocol processing and factors
+      * such as delayed ack timeouts occurring and data transfer.
+      *
+      * @since 18.3
+      */
+     public static final SocketOption<Boolean> TCP_QUICKACK
+             = new ExtSocketOption<Boolean>("TCP_QUICKACK", Boolean.class);
+     
      private static final PlatformSocketOptions platformSocketOptions =
              PlatformSocketOptions.get();
  
      private static final boolean flowSupported =
              platformSocketOptions.flowSupported();
+     private static final boolean quickAckSupported =
+             platformSocketOptions.quickAckSupported();
  
      private static final Set<SocketOption<?>> extendedOptions = options();
  
      static Set<SocketOption<?>> options() {
!         if (flowSupported) {
!             if (quickAckSupported) {
!                 return Set.of(SO_FLOW_SLA, TCP_QUICKACK);
!             } else {
                  return Set.of(SO_FLOW_SLA);
!             }
!         } else if (quickAckSupported) {
!             return Set.of(TCP_QUICKACK);
!         } else {
              return Collections.<SocketOption<?>>emptySet();
          }
+     }
  
      static {
          // Registers the extended socket options with the base module.
          sun.net.ext.ExtendedSocketOptions.register(
                  new sun.net.ext.ExtendedSocketOptions(extendedOptions) {
*** 103,112 ****
--- 138,149 ----
  
                  if (option == SO_FLOW_SLA) {
                      assert flowSupported;
                      SocketFlow flow = checkValueType(value, option.type());
                      setFlowOption(fd, flow);
+                 } else if (option == TCP_QUICKACK) {
+                     setQuickAckOption(fd, (boolean) value);
                  } else {
                      throw new InternalError("Unexpected option " + option);
                  }
              }
  
*** 125,134 ****
--- 162,173 ----
                  if (option == SO_FLOW_SLA) {
                      assert flowSupported;
                      SocketFlow flow = SocketFlow.create();
                      getFlowOption(fd, flow);
                      return flow;
+                 } else if (option == TCP_QUICKACK) {
+                     return getQuickAckOption(fd);
                  } else {
                      throw new InternalError("Unexpected option " + option);
                  }
              }
          });
*** 154,169 ****
                                                           f.bandwidth());
          f.status(status);  // augment the given flow with the status
      }
  
      private static void getFlowOption(FileDescriptor fd, SocketFlow f)
!         throws SocketException
!     {
          int status = platformSocketOptions.getFlowOption(fdAccess.get(fd), f);
          f.status(status);  // augment the given flow with the status
      }
  
      static class PlatformSocketOptions {
  
          protected PlatformSocketOptions() {}
  
          @SuppressWarnings("unchecked")
--- 193,217 ----
                                                           f.bandwidth());
          f.status(status);  // augment the given flow with the status
      }
  
      private static void getFlowOption(FileDescriptor fd, SocketFlow f)
!             throws SocketException {
          int status = platformSocketOptions.getFlowOption(fdAccess.get(fd), f);
          f.status(status);  // augment the given flow with the status
      }
  
+     private static void setQuickAckOption(FileDescriptor fd, boolean enable)
+             throws SocketException {
+         platformSocketOptions.setQuickAck(fdAccess.get(fd), enable == true ? 1 : 0);
+     }
+ 
+     private static Object getQuickAckOption(FileDescriptor fd)
+             throws SocketException {
+         return platformSocketOptions.getQuickAck(fdAccess.get(fd));
+     }
+     
      static class PlatformSocketOptions {
  
          protected PlatformSocketOptions() {}
  
          @SuppressWarnings("unchecked")
*** 182,195 ****
                      new PrivilegedAction<String>() {
                          public String run() {
                              return System.getProperty("os.name");
                          }
                      });
!             if ("SunOS".equals(osname))
                  return newInstance("jdk.net.SolarisSocketOptions");
              return new PlatformSocketOptions();
          }
  
          private static final PlatformSocketOptions instance = create();
  
          static PlatformSocketOptions get() {
              return instance;
--- 230,247 ----
                      new PrivilegedAction<String>() {
                          public String run() {
                              return System.getProperty("os.name");
                          }
                      });
!             if ("SunOS".equals(osname)) {
                  return newInstance("jdk.net.SolarisSocketOptions");
+             } else if ("Linux".equals(osname)) {
+                 return newInstance("jdk.net.LinuxSocketOptions");
+             } else {
                  return new PlatformSocketOptions();
              }
+         }
  
          private static final PlatformSocketOptions instance = create();
  
          static PlatformSocketOptions get() {
              return instance;
*** 206,212 ****
--- 258,276 ----
          }
  
          boolean flowSupported() {
              return false;
          }
+         
+         void setQuickAck(int fd, int on) throws SocketException {
+             throw new UnsupportedOperationException("unsupported TCP_QUICKACK option");
+         }
+ 
+         boolean getQuickAck(int fd) throws SocketException {
+             throw new UnsupportedOperationException("unsupported TCP_QUICKACK option");
+         }
+ 
+         boolean quickAckSupported() {
+             return false;
+         }
      }
  }