@Override public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) { try { for (String subprotocol : req.getSubProtocols()) { if ("xmpp".equals(subprotocol)) { resp.setAcceptedSubProtocol(subprotocol); return new XmppWebSocket(); } } } catch (Exception e) { Log.warn(MessageFormat.format("Unable to load websocket factory: {0} ({1})", e.getClass().getName(), e.getMessage())); } Log.warn("Failed to create websocket for {}:{} make a request at {}", req.getRemoteAddress(), req.getRemotePort(), req.getRequestPath() ); return null; } });
@Override public void start() { if (!isRunning()) { this.running = true; try { if (this.factory == null) { this.factory = new WebSocketServerFactory(this.servletContext, this.policy); } this.factory.setCreator((request, response) -> { WebSocketHandlerContainer container = containerHolder.get(); Assert.state(container != null, "Expected WebSocketHandlerContainer"); response.setAcceptedSubProtocol(container.getSelectedProtocol()); response.setExtensions(container.getExtensionConfigs()); return container.getHandler(); }); this.factory.start(); } catch (Throwable ex) { throw new IllegalStateException("Unable to start Jetty WebSocketServerFactory", ex); } } }
resp.sendForbidden("Origin mismatch"); if (StringUtil.isNotBlank(subprotocol)) resp.setAcceptedSubProtocol(subprotocol); resp.setExtensions(configs);
response.setHeader("Sec-WebSocket-Version", supportedVersions); response.sendError(HttpStatus.BAD_REQUEST_400, "Unsupported websocket version specification"); return false; if (response.isExtensionsNegotiated()) extensionStack.negotiate(response.getExtensions()); session.setUpgradeRequest(request); response.setExtensions(extensionStack.getNegotiatedExtensions()); session.setUpgradeResponse(response); wsConnection.addListener(session); response.setHeader("Server", HttpConfiguration.SERVER_VERSION); LOG.debug("Websocket upgrade {} {} {} {}", request.getRequestURI(), version, response.getAcceptedSubProtocol(), wsConnection);
response.sendError(404, "invalid path"); return null; response.sendError(404, "invalid path"); return null; + "(expected '" + serverId + "', received '" + ids[0] + "')."); response.sendError(404, "server ID mismatch"); return null; response.sendError(500, "no videobridge"); return null; response.sendError(403, authFailed); return null; response.sendError(403, authFailed); return null; if (!endpoint.acceptWebSocket(pwd)) response.sendError(403, authFailed); return null;
ServletUpgradeResponse sockresp = new ServletUpgradeResponse(response); if (sockresp.isCommitted()) sockresp.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, "Endpoint Creation Failed"); return false;
@Override public void configure(WebSocketServletFactory factory) { factory.setCreator((req, resp) -> { // remove all compressions extensions that might be requested by the browser... resp.setExtensions(Collections.<ExtensionConfig>emptyList()); return new EventSocket(events); }); } }
@Override public void doHandshakeResponse(ServletUpgradeRequest request, ServletUpgradeResponse response) throws IOException { String key = request.getHeader("Sec-WebSocket-Key"); if (key == null) { throw new IllegalStateException("Missing request header 'Sec-WebSocket-Key'"); } // build response response.setHeader("Upgrade","WebSocket"); response.addHeader("Connection","Upgrade"); response.addHeader("Sec-WebSocket-Accept",AcceptHash.hashKey(key)); request.complete(); response.setStatusCode(HttpServletResponse.SC_SWITCHING_PROTOCOLS); response.complete(); } }
public void sendError(int statusCode, String message) throws IOException { setSuccess(false); HttpServletResponse r = response; complete(); r.sendError(statusCode, message); r.flushBuffer(); }
private static Object sendForbiddenAsResponse(ServletUpgradeResponse resp) { try { resp.sendForbidden("You are not authorized to open a web socket."); } catch (IOException ignored) { } return null; }
private void sendError(int statusCode, String message, ServletUpgradeResponse resp) { try { resp.sendError(statusCode, message); } catch (IOException e) { log.error("sendError ['{}', '{}'] -> error", statusCode, message, e); throw new RuntimeException(e); } } }
@Override public void sendForbidden(String message) throws IOException { setSuccess(false); HttpServletResponse r = response; complete(); r.sendError(HttpServletResponse.SC_FORBIDDEN, message); r.flushBuffer(); }
@Override public Object createWebSocket(ServletUpgradeRequest request, ServletUpgradeResponse response) { try { Optional<WebSocketAuthenticator> authenticator = Optional.ofNullable(environment.getAuthenticator()); Object authenticated = null; if (authenticator.isPresent()) { AuthenticationResult authenticationResult = authenticator.get().authenticate(request); if (!authenticationResult.getUser().isPresent() && authenticationResult.isRequired()) { response.sendForbidden("Unauthorized"); return null; } else { authenticated = authenticationResult.getUser().orElse(null); } } return new WebSocketResourceProvider(this.environment.getJerseyServletContainer(), this.environment.getRequestLog(), authenticated, this.environment.getMessageFactory(), Optional.ofNullable(this.environment.getConnectListener()), this.environment.getIdleTimeoutMillis()); } catch (AuthenticationException | IOException e) { logger.warn("Authentication failure", e); return null; } }
@Override public void start() { synchronized (this.lifecycleMonitor) { ServletContext servletContext = this.servletContext; if (!isRunning() && servletContext != null) { this.running = true; try { this.factory = (this.webSocketPolicy != null ? new WebSocketServerFactory(servletContext, this.webSocketPolicy) : new WebSocketServerFactory(servletContext)); this.factory.setCreator((request, response) -> { WebSocketHandlerContainer container = adapterHolder.get(); String protocol = container.getProtocol(); if (protocol != null) { response.setAcceptedSubProtocol(protocol); } return container.getAdapter(); }); this.factory.start(); } catch (Throwable ex) { throw new IllegalStateException("Unable to start WebSocketServerFactory", ex); } } } }
@Override public void start() { if (!isRunning()) { this.running = true; try { if (this.factory == null) { this.factory = new WebSocketServerFactory(servletContext, this.policy); } this.factory.setCreator((request, response) -> { WebSocketHandlerContainer container = containerHolder.get(); Assert.state(container != null, "Expected WebSocketHandlerContainer"); response.setAcceptedSubProtocol(container.getSelectedProtocol()); response.setExtensions(container.getExtensionConfigs()); return container.getHandler(); }); this.factory.start(); } catch (Throwable ex) { throw new IllegalStateException("Unable to start Jetty WebSocketServerFactory", ex); } } }
private Object createWebSocketAdapter(ServletUpgradeRequest request, ServletUpgradeResponse response) { GenericRequestHandler handler = (GenericRequestHandler)request.getServletAttribute( GenericRequestHandler.class.getName()); request.setServletAttribute(GenericRequestHandler.class.getName(), null); Object result = handler.createWebSocketAdapter(request, response); if ( null == result ) { // Avoid 503 response. try { response.sendError(404, "Not Found"); } catch ( IOException ex ) { throw new UncheckedIOException(ex); } } return result; } }
@Override public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) { // Borrow WebSocket sub-protocols as input for channels and filters, // which are at position 0 and 1 in the sub-protocols array MetricWebSocket socket = new MetricWebSocket(req.getSubProtocols().get(0), req.getSubProtocols().get(1), wsConnectionManager); resp.setAcceptedSubProtocol(req.getSubProtocols().get(0)); return socket; }
@Override public void start() { if (!isRunning()) { this.running = true; try { if (this.factory == null) { this.factory = new WebSocketServerFactory(this.servletContext, this.policy); } this.factory.setCreator((request, response) -> { WebSocketHandlerContainer container = containerHolder.get(); Assert.state(container != null, "Expected WebSocketHandlerContainer"); response.setAcceptedSubProtocol(container.getSelectedProtocol()); response.setExtensions(container.getExtensionConfigs()); return container.getHandler(); }); this.factory.start(); } catch (Throwable ex) { throw new IllegalStateException("Unable to start Jetty WebSocketServerFactory", ex); } } }
request.getRemotePort(), authRole, topic, e.getMessage()); try { response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Failed to authenticate"); } catch (IOException e1) { log.warn("[{}:{}] Failed to send error: {}", request.getRemoteAddr(), request.getRemotePort(), log.warn("[{}:{}] WebSocket Client [{}] is not authorized on topic {}", request.getRemoteAddr(), request.getRemotePort(), authRole, topic); response.sendError(HttpServletResponse.SC_FORBIDDEN, "Not authorized"); return false; request.getRemoteAddr(), request.getRemotePort(), authRole, topic, e.getMessage()); try { response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Server error"); } catch (IOException e1) { log.warn("[{}:{}] Failed to send error: {}", request.getRemoteAddr(), request.getRemotePort(),
@Override public void configure(final WebSocketServletFactory factory) { factory.setCreator((req, resp) -> { resp.setAcceptedSubProtocol(AMQP_WEBSOCKET_SUBPROTOCOL); return new AmqpWebSocket(); }); }