WebSocketHandler wsHandler, Map<String, Object> attributes) throws HandshakeFailureException { WebSocketHttpHeaders headers = new WebSocketHttpHeaders(request.getHeaders()); if (logger.isTraceEnabled()) { logger.trace("Processing request " + request.getURI() + " with headers=" + headers); if (!"WebSocket".equalsIgnoreCase(headers.getUpgrade())) { handleInvalidUpgradeHeader(request, response); return false; if (!headers.getConnection().contains("Upgrade") && !headers.getConnection().contains("upgrade")) { handleInvalidConnectHeader(request, response); return false; return false; String wsKey = headers.getSecWebSocketKey(); if (wsKey == null) { if (logger.isErrorEnabled()) { String subProtocol = selectProtocol(headers.getSecWebSocketProtocol(), wsHandler); List<WebSocketExtension> requested = headers.getSecWebSocketExtensions(); List<WebSocketExtension> supported = this.requestUpgradeStrategy.getSupportedExtensions(request); List<WebSocketExtension> extensions = filterRequestedExtensions(request, requested, supported);
/** * Set the origin to use. */ public void setOrigin(@Nullable String origin) { this.headers.setOrigin(origin); }
/** * Set the sub-protocols to use. If configured, specified sub-protocols will be * requested in the handshake through the {@code Sec-WebSocket-Protocol} header. The * resulting WebSocket session will contain the protocol accepted by the server, if * any. */ public void setSubProtocols(List<String> protocols) { this.headers.setSecWebSocketProtocol(protocols); }
/** * Sets the (new) value of the {@code Sec-WebSocket-Protocol} header. * @param secWebSocketProtocols the value of the header */ public void setSecWebSocketProtocol(List<String> secWebSocketProtocols) { set(SEC_WEBSOCKET_PROTOCOL, toCommaDelimitedString(secWebSocketProtocols)); }
/** * Returns the value of the {@code Sec-WebSocket-Key} header. * @return the value of the header */ public List<String> getSecWebSocketProtocol() { List<String> values = get(SEC_WEBSOCKET_PROTOCOL); if (CollectionUtils.isEmpty(values)) { return Collections.emptyList(); } else if (values.size() == 1) { return getValuesAsList(SEC_WEBSOCKET_PROTOCOL); } else { return values; } }
@Test public void subProtocolCapableHandlerNoMatch() { given(this.upgradeStrategy.getSupportedVersions()).willReturn(new String[] {"13"}); this.servletRequest.setMethod("GET"); WebSocketHttpHeaders headers = new WebSocketHttpHeaders(this.request.getHeaders()); headers.setUpgrade("WebSocket"); headers.setConnection("Upgrade"); headers.setSecWebSocketVersion("13"); headers.setSecWebSocketKey("82/ZS2YHjEnUN97HLL8tbw=="); headers.setSecWebSocketProtocol("v10.stomp"); WebSocketHandler handler = new SubProtocolCapableHandler("v12.stomp", "v11.stomp"); Map<String, Object> attributes = Collections.<String, Object>emptyMap(); this.handshakeHandler.doHandshake(this.request, this.response, handler, attributes); verify(this.upgradeStrategy).upgrade(this.request, this.response, null, Collections.emptyList(), null, handler, attributes); }
@Test public void doHandshake() throws Exception { WebSocketHttpHeaders headers = new WebSocketHttpHeaders(); headers.setSecWebSocketProtocol(Arrays.asList("echo")); this.wsSession = this.client.doHandshake(new TextWebSocketHandler(), headers, new URI(this.wsUrl)).get(); assertEquals(this.wsUrl, this.wsSession.getUri().toString()); assertEquals("echo", this.wsSession.getAcceptedProtocol()); }
/** * Returns {@code WebSocketHttpHeaders} object that can only be read, not written to. */ public static WebSocketHttpHeaders readOnlyWebSocketHttpHeaders(WebSocketHttpHeaders headers) { return new WebSocketHttpHeaders(headers, true); }
@Override public final ListenableFuture<WebSocketSession> doHandshake(WebSocketHandler webSocketHandler, @Nullable WebSocketHttpHeaders headers, URI uri) { Assert.notNull(webSocketHandler, "WebSocketHandler must not be null"); assertUri(uri); if (logger.isDebugEnabled()) { logger.debug("Connecting to " + uri); } HttpHeaders headersToUse = new HttpHeaders(); if (headers != null) { headers.forEach((header, values) -> { if (values != null && !specialHeaders.contains(header.toLowerCase())) { headersToUse.put(header, values); } }); } List<String> subProtocols = (headers != null ? headers.getSecWebSocketProtocol() : Collections.emptyList()); List<WebSocketExtension> extensions = (headers != null ? headers.getSecWebSocketExtensions() : Collections.emptyList()); return doHandshakeInternal(webSocketHandler, headersToUse, uri, subProtocols, extensions, Collections.emptyMap()); }
@Test public void connectAndUseSubsetOfHandshakeHeadersForHttpRequests() throws Exception { ArgumentCaptor<HttpHeaders> headersCaptor = setupInfoRequest(false); this.xhrTransport.setStreamingDisabled(true); WebSocketHttpHeaders headers = new WebSocketHttpHeaders(); headers.set("foo", "bar"); headers.set("auth", "123"); this.sockJsClient.setHttpHeaderNames("auth"); this.sockJsClient.doHandshake(handler, headers, new URI(URL)).addCallback(this.connectCallback); assertEquals(1, headersCaptor.getValue().size()); assertEquals("123", headersCaptor.getValue().getFirst("auth")); assertEquals(1, this.xhrTransport.getRequest().getHttpRequestHeaders().size()); assertEquals("123", this.xhrTransport.getRequest().getHttpRequestHeaders().getFirst("auth")); }
@Test public void supportedExtensions() { WebSocketExtension extension1 = new WebSocketExtension("ext1"); WebSocketExtension extension2 = new WebSocketExtension("ext2"); given(this.upgradeStrategy.getSupportedVersions()).willReturn(new String[] {"13"}); given(this.upgradeStrategy.getSupportedExtensions(this.request)).willReturn(Collections.singletonList(extension1)); this.servletRequest.setMethod("GET"); WebSocketHttpHeaders headers = new WebSocketHttpHeaders(this.request.getHeaders()); headers.setUpgrade("WebSocket"); headers.setConnection("Upgrade"); headers.setSecWebSocketVersion("13"); headers.setSecWebSocketKey("82/ZS2YHjEnUN97HLL8tbw=="); headers.setSecWebSocketExtensions(Arrays.asList(extension1, extension2)); WebSocketHandler handler = new TextWebSocketHandler(); Map<String, Object> attributes = Collections.<String, Object>emptyMap(); this.handshakeHandler.doHandshake(this.request, this.response, handler, attributes); verify(this.upgradeStrategy).upgrade(this.request, this.response, null, Collections.singletonList(extension1), null, handler, attributes); }
/** * Sets the (new) value of the {@code Sec-WebSocket-Protocol} header. * @param secWebSocketProtocol the value of the header */ public void setSecWebSocketProtocol(String secWebSocketProtocol) { set(SEC_WEBSOCKET_PROTOCOL, secWebSocketProtocol); }
@Bean public StompSessionManager stompSessionManager(WebSocketStompClient stompClient) { WebSocketStompSessionManager webSocketStompSessionManager = new WebSocketStompSessionManager(stompClient, server().getWsBaseUrl() + "/ws"); webSocketStompSessionManager.setAutoReceipt(true); webSocketStompSessionManager.setRecoveryInterval(1000); WebSocketHttpHeaders handshakeHeaders = new WebSocketHttpHeaders(); handshakeHeaders.setOrigin("http://foo.com"); webSocketStompSessionManager.setHandshakeHeaders(handshakeHeaders); StompHeaders stompHeaders = new StompHeaders(); stompHeaders.setHeartbeat(new long[] { 10000, 10000 }); webSocketStompSessionManager.setConnectHeaders(stompHeaders); return webSocketStompSessionManager; }
@Test public void echoXhrWithHeaders() throws Exception { AbstractXhrTransport xhrTransport = createXhrTransport(); xhrTransport.setXhrStreamingDisabled(true); WebSocketHttpHeaders headers = new WebSocketHttpHeaders(); headers.add("auth", "123"); testEcho(10, xhrTransport, headers); for (Map.Entry<String, HttpHeaders> entry : this.testFilter.requests.entrySet()) { HttpHeaders httpHeaders = entry.getValue(); assertEquals("No auth header for: " + entry.getKey(), "123", httpHeaders.getFirst("auth")); } }
@Test public void handshakeHeaders() throws Exception { URI uri = new URI("ws://localhost/abc"); List<String> protocols = Collections.singletonList("abc"); this.headers.setSecWebSocketProtocol(protocols); this.headers.add("foo", "bar"); WebSocketSession session = this.wsClient.doHandshake(this.wsHandler, this.headers, uri).get(); assertEquals(1, session.getHandshakeHeaders().size()); assertEquals("bar", session.getHandshakeHeaders().getFirst("foo")); }
WebSocketHttpHeaders headers = TestUtils.getPropertyValue(this.clientWebSocketContainer, "headers", WebSocketHttpHeaders.class); assertEquals("FOO", headers.getOrigin()); assertEquals(Arrays.asList("BAR", "baz"), headers.get("FOO")); "connectionManager.autoStartup", Boolean.class)); assertTrue(TestUtils.getPropertyValue(this.simpleClientWebSocketContainer, "headers", WebSocketHttpHeaders.class).isEmpty());
@Test public void parseWebSocketExtensions() { List<String> extensions = new ArrayList<>(); extensions.add("x-foo-extension, x-bar-extension"); extensions.add("x-test-extension"); this.headers.put(WebSocketHttpHeaders.SEC_WEBSOCKET_EXTENSIONS, extensions); List<WebSocketExtension> parsedExtensions = this.headers.getSecWebSocketExtensions(); assertThat(parsedExtensions, Matchers.hasSize(3)); }
public void setHeaders(HttpHeaders headers) { this.headers.putAll(headers); }
/** * Return the configured origin. */ @Nullable public String getOrigin() { return this.headers.getOrigin(); }