Add cherrypicks from latest dev for websocket

mondain · mondain · commit d6fe74e1a121 · 2025-09-18T08:58:56.000-07:00
diff --git a/server/src/main/java/org/red5/net/websocket/server/DefaultWebSocketEndpoint.java b/server/src/main/java/org/red5/net/websocket/server/DefaultWebSocketEndpoint.java
@@ -40,6 +40,8 @@ public class DefaultWebSocketEndpoint extends Endpoint {
     private final boolean isDebug = log.isDebugEnabled(), isTrace = log.isTraceEnabled();
 
     /**
+     * {@inheritDoc}
+     *
      * TODO: Currently, Tomcat uses an Endpoint instance once - however the java doc of endpoint says: "Each instance
      * of a websocket endpoint is guaranteed not to be called by more than one thread at a time per active connection."
      * This could mean that after calling onClose(), the instance could be reused for another connection so onOpen()
@@ -58,7 +60,8 @@ public void onOpen(Session session, EndpointConfig config) {
         // get ws scope from user props
         WebSocketScope scope = (WebSocketScope) userProps.get(WSConstants.WS_SCOPE);
         if (isDebug) {
-            log.debug("onOpen - session: {} props: {} scope: {}", session.getId(), userProps, scope);
+            log.debug("onOpen - session: {} props: {} scope: {}", session.getId(), scope);
+            log.trace("onOpen - props: {} ", userProps);
         }
         // get ws connection from session user props
         WebSocketConnection conn = (WebSocketConnection) userProps.get(WSConstants.WS_CONNECTION);
@@ -70,6 +73,7 @@ public void onOpen(Session session, EndpointConfig config) {
         session.addMessageHandler(new WholePongHandler(conn));
     }
 
+    /** {@inheritDoc} */
     @Override
     public void onClose(Session session, CloseReason closeReason) {
         final String sessionId = session.getId();
@@ -79,7 +83,8 @@ public void onClose(Session session, CloseReason closeReason) {
         // get ws scope from user props
         WebSocketScope scope = (WebSocketScope) userProps.get(WSConstants.WS_SCOPE);
         if (isDebug) {
-            log.debug("onClose - session: {} props: {} scope: {}", session.getId(), userProps, scope);
+            log.debug("onClose - session: {} scope: {}", session.getId(), scope);
+            log.trace("onClose - props: {} ", userProps);
         }
         WebSocketConnection conn = null;
         // getting the sessions user properties on a closed connection will throw an exception when it checks state
@@ -106,6 +111,7 @@ public void onClose(Session session, CloseReason closeReason) {
         }
     }
 
+    /** {@inheritDoc} */
     @Override
     public void onError(Session session, Throwable t) {
         log.debug("onError: {}", t.toString(), t);
diff --git a/server/src/main/java/org/red5/net/websocket/server/DefaultWsServerContainer.java b/server/src/main/java/org/red5/net/websocket/server/DefaultWsServerContainer.java
@@ -40,9 +40,11 @@
  * Provides a per class loader (i.e. per web application) instance of a ServerContainer. Web application wide defaults may be configured by setting the
  * following servlet context initialization parameters to the desired values.
  * <ul>
- * <li>{@link Constants#BINARY_BUFFER_SIZE_SERVLET_CONTEXT_INIT_PARAM}</li>
- * <li>{@link Constants#TEXT_BUFFER_SIZE_SERVLET_CONTEXT_INIT_PARAM}</li>
+ * <li>{@link org.apache.tomcat.websocket.server.Constants#BINARY_BUFFER_SIZE_SERVLET_CONTEXT_INIT_PARAM}</li>
+ * <li>{@link org.apache.tomcat.websocket.server.Constants#TEXT_BUFFER_SIZE_SERVLET_CONTEXT_INIT_PARAM}</li>
  * </ul>
+ *
+ * @author mondain
  */
 public class DefaultWsServerContainer extends WsWebSocketContainer implements ServerContainer {
 
@@ -66,6 +68,11 @@ public class DefaultWsServerContainer extends WsWebSocketContainer implements Se
 
     private volatile CopyOnWriteArraySet<String> registeredEndpointPaths = new CopyOnWriteArraySet<>();
 
+    /**
+     * <p>Constructor for DefaultWsServerContainer.</p>
+     *
+     * @param servletContext a {@link jakarta.servlet.ServletContext} object
+     */
     public DefaultWsServerContainer(ServletContext servletContext) {
         log.debug("ctor - context: {}", servletContext);
         this.servletContext = servletContext;
@@ -82,13 +89,14 @@ public DefaultWsServerContainer(ServletContext servletContext) {
     }
 
     /**
-     * Published the provided endpoint implementation at the specified path with the specified configuration. {@link #org.apache.tomcat.websocket.server.WsServerContainer(ServletContext)}
-     * must be called before calling this method.
+     * {@inheritDoc}
+     *
+     * Published the provided endpoint implementation at the specified path with the specified configuration.
      *
-     * @param sec
-     *            The configuration to use when creating endpoint instances
-     * @throws DeploymentException
-     *             if the endpoint cannot be published as requested
+     * @see org.apache.tomcat.websocket.server.WsServerContainer#addEndpoint(ServerEndpointConfig)
+     * @param sec a {@link jakarta.websocket.server.ServerEndpointConfig} object
+     * @throws jakarta.websocket.DeploymentException if any.
+     * @throws java.lang.IllegalStateException if the container is not started
      */
     @Override
     public void addEndpoint(ServerEndpointConfig sec) throws DeploymentException {
@@ -133,10 +141,9 @@ public void addEndpoint(ServerEndpointConfig sec) throws DeploymentException {
     }
 
     /**
-     * Provides the equivalent of {@link #addEndpoint(ServerEndpointConfig)} for publishing plain old java objects (POJOs) that have been annotated as WebSocket endpoints.
+     * {@inheritDoc}
      *
-     * @param pojo
-     *            The annotated POJO
+     * Provides the equivalent of {@link #addEndpoint(ServerEndpointConfig)} for publishing plain old java objects (POJOs) that have been annotated as WebSocket endpoints.
      */
     @Override
     public void addEndpoint(Class<?> pojo) throws DeploymentException {
@@ -168,35 +175,37 @@ boolean areEndpointsRegistered() {
     }
 
     /**
+     * {@inheritDoc}
+     *
      * Until the WebSocket specification provides such a mechanism, this Tomcat proprietary method is provided to enable applications to programmatically
      * determine whether or not to upgrade an individual request to WebSocket.
      * <p>
      * Note: This method is not used by Tomcat but is used directly by third-party code and must not be removed.
-     *
-     * @param request
-     *            The request object to be upgraded
-     * @param response
-     *            The response object to be populated with the result of the upgrade
-     * @param sec
-     *            The server endpoint to use to process the upgrade request
-     * @param pathParams
-     *            The path parameters associated with the upgrade request
-     *
-     * @throws DeploymentException
-     *             If an error prevents the upgrade from taking place
-     * @throws IOException
-     *             If an I/O error occurs during the upgrade process
      */
     @Override
     public void upgradeHttpToWebSocket(Object request, Object response, ServerEndpointConfig sec, Map<String, String> pathParams) throws IOException, DeploymentException {
-        log.debug("doUpgrade");
+        log.debug("upgradeHttpToWebSocket");
+        HttpServletResponse resp = (HttpServletResponse) response;
         try {
-            UpgradeUtil.doUpgrade(this, (HttpServletRequest) request, (HttpServletResponse) response, sec, pathParams);
+            UpgradeUtil.doUpgrade(this, (HttpServletRequest) request, resp, sec, pathParams);
         } catch (ServletException e) {
             throw new DeploymentException("Servlet exeception, upgrade failed", e);
         }
+        // did the upgrade fail? check the header set by the upgrade process
+        if ("true".equals(resp.getHeader("websocket.preinit"))) {
+            // Upgrade successful
+            log.debug("Upgrade to WebSocket pre-init successful");
+        } else {
+            throw new DeploymentException("WebSocket upgrade failed");
+        }
     }
 
+    /**
+     * <p>findMapping.</p>
+     *
+     * @param path a {@link java.lang.String} object
+     * @return a {@link org.red5.net.websocket.server.WsMappingResult} object
+     */
     public WsMappingResult findMapping(String path) {
         log.debug("findMapping: {}", path);
         // Prevent registering additional endpoints once the first attempt has been made to use one
@@ -242,10 +251,16 @@ public WsMappingResult findMapping(String path) {
         return new WsMappingResult(sec, pathParams);
     }
 
+    /**
+     * <p>Getter for the field <code>registeredEndpointPaths</code>.</p>
+     *
+     * @return a {@link java.util.Set} object
+     */
     public Set<String> getRegisteredEndpointPaths() {
         return Collections.unmodifiableSet(registeredEndpointPaths);
     }
 
+    /** {@inheritDoc} */
     @Override
     public void backgroundProcess() {
         // some comments say 1s others say 10s
@@ -313,6 +328,11 @@ private void unregisterAuthenticatedSession(WsSession wsSession, String httpSess
         }
     }
 
+    /**
+     * <p>closeAuthenticatedSession.</p>
+     *
+     * @param httpSessionId a {@link java.lang.String} object
+     */
     public void closeAuthenticatedSession(String httpSessionId) {
         Set<WsSession> wsSessions = authenticatedSessions.remove(httpSessionId);
         if (wsSessions != null && !wsSessions.isEmpty()) {
diff --git a/server/src/main/java/org/red5/net/websocket/server/UpgradeUtil.java b/server/src/main/java/org/red5/net/websocket/server/UpgradeUtil.java
@@ -32,6 +32,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+/**
+ * <p>UpgradeUtil class.</p>
+ *
+ * @author mondain
+ */
 public class UpgradeUtil {
 
     private static final Logger log = LoggerFactory.getLogger(UpgradeUtil.class);
@@ -40,6 +45,8 @@ public class UpgradeUtil {
 
     private static final byte[] WS_ACCEPT = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11".getBytes(StandardCharsets.ISO_8859_1);
 
+    public static boolean wsAllowCompression = true;
+
     private UpgradeUtil() {
         // Utility class. Hide default constructor.
     }
@@ -68,6 +75,17 @@ public static boolean isWebSocketUpgradeRequest(ServletRequest request, ServletR
         return ((request instanceof HttpServletRequest) && (response instanceof HttpServletResponse) && Constants.UPGRADE_HEADER_VALUE.equalsIgnoreCase(((HttpServletRequest) request).getHeader(Constants.UPGRADE_HEADER_NAME)));
     }
 
+    /**
+     * <p>doUpgrade.</p>
+     *
+     * @param sc a {@link org.red5.net.websocket.server.DefaultWsServerContainer} object
+     * @param req a {@link jakarta.servlet.http.HttpServletRequest} object
+     * @param resp a {@link jakarta.servlet.http.HttpServletResponse} object
+     * @param sec a {@link jakarta.websocket.server.ServerEndpointConfig} object
+     * @param pathParams a {@link java.util.Map} object
+     * @throws jakarta.servlet.ServletException if any.
+     * @throws java.io.IOException if any.
+     */
     public static void doUpgrade(DefaultWsServerContainer sc, HttpServletRequest req, HttpServletResponse resp, ServerEndpointConfig sec, Map<String, String> pathParams) throws ServletException, IOException {
         log.debug("doUpgrade - sc: {} sec: {} params: {}", sc, sec, pathParams);
         // Validate the rest of the headers and reject the request if that validation fails
@@ -105,12 +123,12 @@ public static void doUpgrade(DefaultWsServerContainer sc, HttpServletRequest req
         }
         // Negotiation phase 1. By default this simply filters out the extensions that the server does not support but applications could
         // use a custom configurator to do more than this.
-        List<Extension> installedExtensions = null;
-        if (sec.getExtensions().size() == 0) {
-            installedExtensions = Constants.INSTALLED_EXTENSIONS;
-        } else {
-            installedExtensions = new ArrayList<>();
+        List<Extension> installedExtensions = new ArrayList<>();
+        if (sec.getExtensions().size() > 0) {
             installedExtensions.addAll(sec.getExtensions());
+        }
+        // Enable permessage-deflate negotiation.
+        if (wsAllowCompression) {
             installedExtensions.addAll(Constants.INSTALLED_EXTENSIONS);
         }
         List<Extension> negotiatedExtensionsPhase1 = sec.getConfigurator().getNegotiatedExtensions(installedExtensions, extensionsRequested);
@@ -185,7 +203,7 @@ public static void doUpgrade(DefaultWsServerContainer sc, HttpServletRequest req
         log.debug("About to upgrade http session: {} qs: {}", wsRequest.getHttpSession(), wsRequest.getQueryString());
         WsHttpUpgradeHandler wsHandler = req.upgrade(WsHttpUpgradeHandler.class);
         wsHandler.preInit(ep, perSessionServerEndpointConfig, sc, wsRequest, negotiatedExtensionsPhase2, subProtocol, transformation, pathParams, req.isSecure());
-        log.debug("preinit completed");
+        resp.setHeader("websocket.preinit", "true");
     }
 
     private static List<Transformation> createTransformations(List<Extension> negotiatedExtensions) {
diff --git a/server/src/main/java/org/red5/net/websocket/server/WsHttpUpgradeHandler.java b/server/src/main/java/org/red5/net/websocket/server/WsHttpUpgradeHandler.java
