MirrorMirror
/
Signal-Server
mirror of https://github.com/signalapp/Signal-Server.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add websocket-resources as a module

This commit is contained in:
Moxie Marlinspike 2019-04-30 23:58:27 -07:00
parent 66917cd2c0
commit 9220f4d829
38 changed files with 9206 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
pom.xml
View File

@ -10,19 +10,21 @@
<modules>
<module>redis-dispatch</module>
<module>websocket-resources</module>
<module>service</module>
</modules>
<groupId>org.whispersystems.textsecure</groupId>
<artifactId>TextSecureServer</artifactId>
<version>2.52</version>
<properties>
<dropwizard.version>1.3.9</dropwizard.version>
<jackson.api.version>2.9.8</jackson.api.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<TextSecureServer.version>2.52</TextSecureServer.version>
</properties>
<groupId>org.whispersystems.textsecure</groupId>
<artifactId>TextSecureServer</artifactId>
<version>1.0</version>
<dependencies>
<dependency>
<groupId>io.dropwizard</groupId>
@ -62,6 +64,11 @@
</dependency>
<dependency>
<groupId>io.dropwizard</groupId>
<artifactId>dropwizard-servlets</artifactId>
<version>${dropwizard.version}</version>
</dependency>
<dependency>
<groupId>io.dropwizard</groupId>
<artifactId>dropwizard-testing</artifactId>

5
redis-dispatch/pom.xml
View File

@ -5,13 +5,12 @@
<parent>
<artifactId>TextSecureServer</artifactId>
<groupId>org.whispersystems.textsecure</groupId>
<version>2.49</version>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.whispersystems.textsecure</groupId>
<artifactId>redis-dispatch</artifactId>
<version>2.49</version>
<version>${TextSecureServer.version}</version>
</project>

28
service/pom.xml
View File

@ -5,13 +5,12 @@
<parent>
<artifactId>TextSecureServer</artifactId>
<groupId>org.whispersystems.textsecure</groupId>
<version>2.49</version>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.whispersystems.textsecure</groupId>
<artifactId>service</artifactId>
<version>2.49</version>
<version>${TextSecureServer.version}</version>
<properties>
<resilience4j.version>0.14.1</resilience4j.version>
@ -22,8 +21,14 @@
<dependency>
<groupId>org.whispersystems.textsecure</groupId>
<artifactId>redis-dispatch</artifactId>
<version>2.49</version>
<version>${TextSecureServer.version}</version>
</dependency>
<dependency>
<groupId>org.whispersystems.textsecure</groupId>
<artifactId>websocket-resources</artifactId>
<version>${TextSecureServer.version}</version>
</dependency>
<dependency>
<groupId>org.bouncycastle</groupId>
@ -65,11 +70,6 @@
<artifactId>aws-java-sdk-sqs</artifactId>
<version>1.11.362</version>
</dependency>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>2.6.1</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
@ -78,22 +78,12 @@
<type>jar</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.twilio.sdk</groupId>
<artifactId>twilio-java-sdk</artifactId>
<version>4.4.4</version>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>9.4-1201-jdbc41</version>
</dependency>
<dependency>
<groupId>org.whispersystems</groupId>
<artifactId>websocket-resources</artifactId>
<version>0.5.10</version>
</dependency>
<dependency>
<groupId>org.whispersystems</groupId>
<artifactId>curve25519-java</artifactId>

28
websocket-resources/pom.xml Normal file
View File

@ -0,0 +1,28 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>TextSecureServer</artifactId>
<groupId>org.whispersystems.textsecure</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>websocket-resources</artifactId>
<version>${TextSecureServer.version}</version>
<dependencies>
<dependency>
<groupId>org.eclipse.jetty.websocket</groupId>
<artifactId>websocket-server</artifactId>
<version>9.4.14.v20181114</version>
</dependency>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>2.6.1</version>
</dependency>
</dependencies>
</project>

106
websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketClient.java Normal file
View File

@ -0,0 +1,106 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.WebSocketException;
import org.eclipse.jetty.websocket.api.WriteCallback;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.whispersystems.websocket.messages.WebSocketMessage;
import org.whispersystems.websocket.messages.WebSocketMessageFactory;
import org.whispersystems.websocket.messages.WebSocketResponseMessage;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.security.SecureRandom;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public class WebSocketClient {
private static final Logger logger = LoggerFactory.getLogger(WebSocketClient.class);
private final Session session;
private final RemoteEndpoint remoteEndpoint;
private final WebSocketMessageFactory messageFactory;
private final Map<Long, SettableFuture<WebSocketResponseMessage>> pendingRequestMapper;
public WebSocketClient(Session session, RemoteEndpoint remoteEndpoint,
WebSocketMessageFactory messageFactory,
Map<Long, SettableFuture<WebSocketResponseMessage>> pendingRequestMapper)
{
this.session = session;
this.remoteEndpoint = remoteEndpoint;
this.messageFactory = messageFactory;
this.pendingRequestMapper = pendingRequestMapper;
}
public ListenableFuture<WebSocketResponseMessage> sendRequest(String verb, String path,
List<String> headers,
Optional<byte[]> body)
{
final long requestId = generateRequestId();
final SettableFuture<WebSocketResponseMessage> future = SettableFuture.create();
pendingRequestMapper.put(requestId, future);
WebSocketMessage requestMessage = messageFactory.createRequest(Optional.of(requestId), verb, path, headers, body);
try {
remoteEndpoint.sendBytes(ByteBuffer.wrap(requestMessage.toByteArray()), new WriteCallback() {
@Override
public void writeFailed(Throwable x) {
logger.debug("Write failed", x);
pendingRequestMapper.remove(requestId);
future.setException(x);
}
@Override
public void writeSuccess() {}
});
} catch (WebSocketException e) {
logger.debug("Write", e);
pendingRequestMapper.remove(requestId);
future.setException(e);
}
return future;
}
public void close(int code, String message) {
session.close(code, message);
}
public void hardDisconnectQuietly() {
try {
session.disconnect();
} catch (IOException e) {
// quietly we said
}
}
private long generateRequestId() {
return Math.abs(new SecureRandom().nextLong());
}
}

210
websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProvider.java Normal file
View File

@ -0,0 +1,210 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.SettableFuture;
import org.eclipse.jetty.server.RequestLog;
import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.WebSocketListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.whispersystems.websocket.messages.InvalidMessageException;
import org.whispersystems.websocket.messages.WebSocketMessage;
import org.whispersystems.websocket.messages.WebSocketMessageFactory;
import org.whispersystems.websocket.messages.WebSocketRequestMessage;
import org.whispersystems.websocket.messages.WebSocketResponseMessage;
import org.whispersystems.websocket.servlet.LoggableRequest;
import org.whispersystems.websocket.servlet.LoggableResponse;
import org.whispersystems.websocket.servlet.NullServletResponse;
import org.whispersystems.websocket.servlet.WebSocketServletRequest;
import org.whispersystems.websocket.servlet.WebSocketServletResponse;
import org.whispersystems.websocket.session.WebSocketSessionContext;
import org.whispersystems.websocket.setup.WebSocketConnectListener;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.core.Response;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public class WebSocketResourceProvider implements WebSocketListener {
private static final Logger logger = LoggerFactory.getLogger(WebSocketResourceProvider.class);
private final Map<Long, SettableFuture<WebSocketResponseMessage>> requestMap = new ConcurrentHashMap<>();
private final Object authenticated;
private final WebSocketMessageFactory messageFactory;
private final Optional<WebSocketConnectListener> connectListener;
private final HttpServlet servlet;
private final RequestLog requestLog;
private final long idleTimeoutMillis;
private Session session;
private RemoteEndpoint remoteEndpoint;
private WebSocketSessionContext context;
public WebSocketResourceProvider(HttpServlet servlet,
RequestLog requestLog,
Object authenticated,
WebSocketMessageFactory messageFactory,
Optional<WebSocketConnectListener> connectListener,
long idleTimeoutMillis)
{
this.servlet = servlet;
this.requestLog = requestLog;
this.authenticated = authenticated;
this.messageFactory = messageFactory;
this.connectListener = connectListener;
this.idleTimeoutMillis = idleTimeoutMillis;
}
@Override
public void onWebSocketConnect(Session session) {
this.session = session;
this.remoteEndpoint = session.getRemote();
this.context = new WebSocketSessionContext(new WebSocketClient(session, remoteEndpoint, messageFactory, requestMap));
this.context.setAuthenticated(authenticated);
this.session.setIdleTimeout(idleTimeoutMillis);
if (connectListener.isPresent()) {
connectListener.get().onWebSocketConnect(this.context);
}
}
@Override
public void onWebSocketError(Throwable cause) {
logger.debug("onWebSocketError", cause);
close(session, 1011, "Server error");
}
@Override
public void onWebSocketBinary(byte[] payload, int offset, int length) {
try {
WebSocketMessage webSocketMessage = messageFactory.parseMessage(payload, offset, length);
switch (webSocketMessage.getType()) {
case REQUEST_MESSAGE:
handleRequest(webSocketMessage.getRequestMessage());
break;
case RESPONSE_MESSAGE:
handleResponse(webSocketMessage.getResponseMessage());
break;
default:
close(session, 1018, "Badly formatted");
break;
}
} catch (InvalidMessageException e) {
logger.debug("Parsing", e);
close(session, 1018, "Badly formatted");
}
}
@Override
public void onWebSocketClose(int statusCode, String reason) {
if (context != null) {
context.notifyClosed(statusCode, reason);
for (long requestId : requestMap.keySet()) {
SettableFuture outstandingRequest = requestMap.remove(requestId);
if (outstandingRequest != null) {
outstandingRequest.setException(new IOException("Connection closed!"));
}
}
}
}
@Override
public void onWebSocketText(String message) {
logger.debug("onWebSocketText!");
}
private void handleRequest(WebSocketRequestMessage requestMessage) {
try {
HttpServletRequest servletRequest = createRequest(requestMessage, context);
HttpServletResponse servletResponse = createResponse(requestMessage);
servlet.service(servletRequest, servletResponse);
servletResponse.flushBuffer();
requestLog.log(new LoggableRequest(servletRequest), new LoggableResponse(servletResponse));
} catch (IOException | ServletException e) {
logger.warn("Servlet Error: " + requestMessage.getVerb() + " " + requestMessage.getPath() + "\n" + requestMessage.getBody(), e);
sendErrorResponse(requestMessage, Response.status(500).build());
}
}
private void handleResponse(WebSocketResponseMessage responseMessage) {
SettableFuture<WebSocketResponseMessage> future = requestMap.remove(responseMessage.getRequestId());
if (future != null) {
future.set(responseMessage);
}
}
private void close(Session session, int status, String message) {
session.close(status, message);
}
private HttpServletRequest createRequest(WebSocketRequestMessage message,
WebSocketSessionContext context)
{
return new WebSocketServletRequest(context, message, servlet.getServletContext());
}
private HttpServletResponse createResponse(WebSocketRequestMessage message) {
if (message.hasRequestId()) {
return new WebSocketServletResponse(remoteEndpoint, message.getRequestId(), messageFactory);
} else {
return new NullServletResponse();
}
}
private void sendErrorResponse(WebSocketRequestMessage requestMessage, Response error) {
if (requestMessage.hasRequestId()) {
List<String> headers = new LinkedList<>();
for (String key : error.getStringHeaders().keySet()) {
headers.add(key + ":" + error.getStringHeaders().getFirst(key));
}
WebSocketMessage response = messageFactory.createResponse(requestMessage.getRequestId(),
error.getStatus(),
"Error response",
headers,
Optional.<byte[]>empty());
remoteEndpoint.sendBytesByFuture(ByteBuffer.wrap(response.toByteArray()));
}
}
@VisibleForTesting
WebSocketSessionContext getContext() {
return context;
}
}

468
websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProviderFactory.java Normal file
View File

@ -0,0 +1,468 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.util.AttributesMap;
import org.eclipse.jetty.websocket.servlet.ServletUpgradeRequest;
import org.eclipse.jetty.websocket.servlet.ServletUpgradeResponse;
import org.eclipse.jetty.websocket.servlet.WebSocketCreator;
import org.eclipse.jetty.websocket.servlet.WebSocketServlet;
import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.whispersystems.websocket.auth.AuthenticationException;
import org.whispersystems.websocket.auth.WebSocketAuthenticator;
import org.whispersystems.websocket.auth.WebSocketAuthenticator.AuthenticationResult;
import org.whispersystems.websocket.auth.internal.WebSocketAuthValueFactoryProvider;
import org.whispersystems.websocket.session.WebSocketSessionContextValueFactoryProvider;
import org.whispersystems.websocket.setup.WebSocketEnvironment;
import javax.servlet.Filter;
import javax.servlet.FilterRegistration;
import javax.servlet.RequestDispatcher;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import javax.servlet.SessionCookieConfig;
import javax.servlet.SessionTrackingMode;
import javax.servlet.descriptor.JspConfigDescriptor;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.AccessController;
import java.util.Collections;
import java.util.Enumeration;
import java.util.EventListener;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import io.dropwizard.jersey.jackson.JacksonMessageBodyProvider;
public class WebSocketResourceProviderFactory extends WebSocketServlet implements WebSocketCreator {
private static final Logger logger = LoggerFactory.getLogger(WebSocketResourceProviderFactory.class);
private final WebSocketEnvironment environment;
public WebSocketResourceProviderFactory(WebSocketEnvironment environment)
throws ServletException
{
this.environment = environment;
environment.jersey().register(new WebSocketSessionContextValueFactoryProvider.Binder());
environment.jersey().register(new WebSocketAuthValueFactoryProvider.Binder());
environment.jersey().register(new JacksonMessageBodyProvider(environment.getObjectMapper()));
}
public void start() throws ServletException {
this.environment.getJerseyServletContainer().init(new WServletConfig());
}
@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 configure(WebSocketServletFactory factory) {
factory.setCreator(this);
}
private static class WServletConfig implements ServletConfig {
private final ServletContext context = new NoContext();
@Override
public String getServletName() {
return "WebSocketResourceServlet";
}
@Override
public ServletContext getServletContext() {
return context;
}
@Override
public String getInitParameter(String name) {
return null;
}
@Override
public Enumeration<String> getInitParameterNames() {
return new Enumeration<String>() {
@Override
public boolean hasMoreElements() {
return false;
}
@Override
public String nextElement() {
return null;
}
};
}
}
public static class NoContext extends AttributesMap implements ServletContext
{
private int effectiveMajorVersion = 3;
private int effectiveMinorVersion = 0;
@Override
public ServletContext getContext(String uripath)
{
return null;
}
@Override
public int getMajorVersion()
{
return 3;
}
@Override
public String getMimeType(String file)
{
return null;
}
@Override
public int getMinorVersion()
{
return 0;
}
@Override
public RequestDispatcher getNamedDispatcher(String name)
{
return null;
}
@Override
public RequestDispatcher getRequestDispatcher(String uriInContext)
{
return null;
}
@Override
public String getRealPath(String path)
{
return null;
}
@Override
public URL getResource(String path) throws MalformedURLException
{
return null;
}
@Override
public InputStream getResourceAsStream(String path)
{
return null;
}
@Override
public Set<String> getResourcePaths(String path)
{
return null;
}
@Override
public String getServerInfo()
{
return "websocketresources/" + Server.getVersion();
}
@Override
@Deprecated
public Servlet getServlet(String name) throws ServletException
{
return null;
}
@SuppressWarnings("unchecked")
@Override
@Deprecated
public Enumeration<String> getServletNames()
{
return Collections.enumeration(Collections.EMPTY_LIST);
}
@SuppressWarnings("unchecked")
@Override
@Deprecated
public Enumeration<Servlet> getServlets()
{
return Collections.enumeration(Collections.EMPTY_LIST);
}
@Override
public void log(Exception exception, String msg)
{
logger.warn(msg,exception);
}
@Override
public void log(String msg)
{
logger.info(msg);
}
@Override
public void log(String message, Throwable throwable)
{
logger.warn(message,throwable);
}
@Override
public String getInitParameter(String name)
{
return null;
}
@SuppressWarnings("unchecked")
@Override
public Enumeration<String> getInitParameterNames()
{
return Collections.enumeration(Collections.EMPTY_LIST);
}
@Override
public String getServletContextName()
{
return "No Context";
}
@Override
public String getContextPath()
{
return null;
}
@Override
public boolean setInitParameter(String name, String value)
{
return false;
}
@Override
public FilterRegistration.Dynamic addFilter(String filterName, Class<? extends Filter> filterClass)
{
return null;
}
@Override
public FilterRegistration.Dynamic addFilter(String filterName, Filter filter)
{
return null;
}
@Override
public FilterRegistration.Dynamic addFilter(String filterName, String className)
{
return null;
}
@Override
public javax.servlet.ServletRegistration.Dynamic addServlet(String servletName, Class<? extends Servlet> servletClass)
{
return null;
}
@Override
public javax.servlet.ServletRegistration.Dynamic addServlet(String servletName, Servlet servlet)
{
return null;
}
@Override
public javax.servlet.ServletRegistration.Dynamic addServlet(String servletName, String className)
{
return null;
}
@Override
public <T extends Filter> T createFilter(Class<T> c) throws ServletException
{
return null;
}
@Override
public <T extends Servlet> T createServlet(Class<T> c) throws ServletException
{
return null;
}
@Override
public Set<SessionTrackingMode> getDefaultSessionTrackingModes()
{
return null;
}
@Override
public Set<SessionTrackingMode> getEffectiveSessionTrackingModes()
{
return null;
}
@Override
public FilterRegistration getFilterRegistration(String filterName)
{
return null;
}
@Override
public Map<String, ? extends FilterRegistration> getFilterRegistrations()
{
return null;
}
@Override
public ServletRegistration getServletRegistration(String servletName)
{
return null;
}
@Override
public Map<String, ? extends ServletRegistration> getServletRegistrations()
{
return null;
}
@Override
public SessionCookieConfig getSessionCookieConfig()
{
return null;
}
@Override
public void setSessionTrackingModes(Set<SessionTrackingMode> sessionTrackingModes)
{
}
@Override
public void addListener(String className)
{
}
@Override
public <T extends EventListener> void addListener(T t)
{
}
@Override
public void addListener(Class<? extends EventListener> listenerClass)
{
}
@Override
public <T extends EventListener> T createListener(Class<T> clazz) throws ServletException
{
try
{
return clazz.newInstance();
}
catch (InstantiationException e)
{
throw new ServletException(e);
}
catch (IllegalAccessException e)
{
throw new ServletException(e);
}
}
@Override
public ClassLoader getClassLoader()
{
AccessController.checkPermission(new RuntimePermission("getClassLoader"));
return WebSocketResourceProviderFactory.class.getClassLoader();
}
@Override
public int getEffectiveMajorVersion()
{
return effectiveMajorVersion;
}
@Override
public int getEffectiveMinorVersion()
{
return effectiveMinorVersion;
}
public void setEffectiveMajorVersion (int v)
{
this.effectiveMajorVersion = v;
}
public void setEffectiveMinorVersion (int v)
{
this.effectiveMinorVersion = v;
}
@Override
public JspConfigDescriptor getJspConfigDescriptor()
{
return null;
}
@Override
public void declareRoles(String... roleNames)
{
}
@Override
public String getVirtualServerName() {
return null;
}
}
}

29
websocket-resources/src/main/java/org/whispersystems/websocket/auth/AuthenticationException.java Normal file
View File

@ -0,0 +1,29 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.auth;
public class AuthenticationException extends Exception {
public AuthenticationException(String s) {
super(s);
}
public AuthenticationException(Exception e) {
super(e);
}
}

45
websocket-resources/src/main/java/org/whispersystems/websocket/auth/WebSocketAuthenticator.java Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.auth;
import org.eclipse.jetty.server.Authentication;
import org.eclipse.jetty.websocket.api.UpgradeRequest;
import java.util.Optional;
public interface WebSocketAuthenticator<T> {
AuthenticationResult<T> authenticate(UpgradeRequest request) throws AuthenticationException;
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public class AuthenticationResult<T> {
private final Optional<T> user;
private final boolean required;
public AuthenticationResult(Optional<T> user, boolean required) {
this.user = user;
this.required = required;
}
public Optional<T> getUser() {
return user;
}
public boolean isRequired() {
return required;
}
}
}

120
websocket-resources/src/main/java/org/whispersystems/websocket/auth/internal/WebSocketAuthValueFactoryProvider.java Normal file
View File

@ -0,0 +1,120 @@
package org.whispersystems.websocket.auth.internal;
import org.glassfish.hk2.api.InjectionResolver;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.api.TypeLiteral;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.server.internal.inject.AbstractContainerRequestValueFactory;
import org.glassfish.jersey.server.internal.inject.AbstractValueFactoryProvider;
import org.glassfish.jersey.server.internal.inject.MultivaluedParameterExtractorProvider;
import org.glassfish.jersey.server.internal.inject.ParamInjectionResolver;
import org.glassfish.jersey.server.model.Parameter;
import org.glassfish.jersey.server.spi.internal.ValueFactoryProvider;
import org.whispersystems.websocket.servlet.WebSocketServletRequest;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.ws.rs.WebApplicationException;
import java.security.Principal;
import java.util.Optional;
import io.dropwizard.auth.Auth;
@Singleton
public class WebSocketAuthValueFactoryProvider extends AbstractValueFactoryProvider {
@Inject
public WebSocketAuthValueFactoryProvider(MultivaluedParameterExtractorProvider mpep,
ServiceLocator injector)
{
super(mpep, injector, Parameter.Source.UNKNOWN);
}
@Override
public AbstractContainerRequestValueFactory<?> createValueFactory(final Parameter parameter) {
if (parameter.getAnnotation(Auth.class) == null) {
return null;
}
if (parameter.getRawType() == Optional.class) {
return new OptionalContainerRequestValueFactory(parameter);
} else {
return new StandardContainerRequestValueFactory(parameter);
}
}
private static class OptionalContainerRequestValueFactory extends AbstractContainerRequestValueFactory {
private final Parameter parameter;
private OptionalContainerRequestValueFactory(Parameter parameter) {
this.parameter = parameter;
}
@Override
public Object provide() {
Principal principal = getContainerRequest().getSecurityContext().getUserPrincipal();
if (principal != null && !(principal instanceof WebSocketServletRequest.ContextPrincipal)) {
throw new IllegalArgumentException("Can't inject non-ContextPrincipal into request");
}
if (principal == null) return Optional.empty();
else return Optional.ofNullable(((WebSocketServletRequest.ContextPrincipal)principal).getContext().getAuthenticated());
}
}
private static class StandardContainerRequestValueFactory extends AbstractContainerRequestValueFactory {
private final Parameter parameter;
private StandardContainerRequestValueFactory(Parameter parameter) {
this.parameter = parameter;
}
@Override
public Object provide() {
Principal principal = getContainerRequest().getSecurityContext().getUserPrincipal();
if (principal == null) {
throw new IllegalStateException("Cannot inject a custom principal into unauthenticated request");
}
if (!(principal instanceof WebSocketServletRequest.ContextPrincipal)) {
throw new IllegalArgumentException("Cannot inject a non-WebSocket AuthPrincipal into request");
}
Object authenticated = ((WebSocketServletRequest.ContextPrincipal)principal).getContext().getAuthenticated();
if (authenticated == null) {
throw new WebApplicationException("Authenticated resource", 401);
}
if (!parameter.getRawType().isAssignableFrom(authenticated.getClass())) {
throw new IllegalArgumentException("Authenticated principal is of the wrong type: " + authenticated.getClass() + " looking for: " + parameter.getRawType());
}
return parameter.getRawType().cast(authenticated);
}
}
@Singleton
private static class AuthInjectionResolver extends ParamInjectionResolver<Auth> {
public AuthInjectionResolver() {
super(WebSocketAuthValueFactoryProvider.class);
}
}
public static class Binder extends AbstractBinder {
public Binder() {
}
@Override
protected void configure() {
bind(WebSocketAuthValueFactoryProvider.class).to(ValueFactoryProvider.class).in(Singleton.class);
bind(AuthInjectionResolver.class).to(new TypeLiteral<InjectionResolver<Auth>>() {
}).in(Singleton.class);
}
}
}

21
websocket-resources/src/main/java/org/whispersystems/websocket/configuration/WebSocketConfiguration.java Normal file
View File

@ -0,0 +1,21 @@
package org.whispersystems.websocket.configuration;
import com.fasterxml.jackson.annotation.JsonProperty;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import io.dropwizard.request.logging.LogbackAccessRequestLogFactory;
import io.dropwizard.request.logging.RequestLogFactory;
public class WebSocketConfiguration {
@Valid
@NotNull
@JsonProperty
private RequestLogFactory requestLog = new LogbackAccessRequestLogFactory();
public RequestLogFactory getRequestLog() {
return requestLog;
}
}

27
websocket-resources/src/main/java/org/whispersystems/websocket/messages/InvalidMessageException.java Normal file
View File

@ -0,0 +1,27 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages;
public class InvalidMessageException extends Exception {
public InvalidMessageException(String s) {
super(s);
}
public InvalidMessageException(Exception e) {
super(e);
}
}

32
websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessage.java Normal file
View File

@ -0,0 +1,32 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages;
public interface WebSocketMessage {
public enum Type {
UNKNOWN_MESSAGE,
REQUEST_MESSAGE,
RESPONSE_MESSAGE
}
public Type getType();
public WebSocketRequestMessage getRequestMessage();
public WebSocketResponseMessage getResponseMessage();
public byte[] toByteArray();
}

38
websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessageFactory.java Normal file
View File

@ -0,0 +1,38 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages;
import java.util.List;
import java.util.Optional;
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public interface WebSocketMessageFactory {
public WebSocketMessage parseMessage(byte[] serialized, int offset, int len)
throws InvalidMessageException;
public WebSocketMessage createRequest(Optional<Long> requestId,
String verb, String path,
List<String> headers,
Optional<byte[]> body);
public WebSocketMessage createResponse(long requestId, int status, String message,
List<String> headers,
Optional<byte[]> body);
}

33
websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketRequestMessage.java Normal file
View File

@ -0,0 +1,33 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages;
import java.util.Map;
import java.util.Optional;
public interface WebSocketRequestMessage {
public String getVerb();
public String getPath();
public Map<String,String> getHeaders();
public Optional<byte[]> getBody();
public long getRequestId();
public boolean hasRequestId();
}

29
websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketResponseMessage.java Normal file
View File

@ -0,0 +1,29 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages;
import java.util.Map;
import java.util.Optional;
public interface WebSocketResponseMessage {
public long getRequestId();
public int getStatus();
public String getMessage();
public Map<String,String> getHeaders();
public Optional<byte[]> getBody();
}

81
websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessage.java Normal file
View File

@ -0,0 +1,81 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages.protobuf;
import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import org.whispersystems.websocket.messages.InvalidMessageException;
import org.whispersystems.websocket.messages.WebSocketMessage;
import org.whispersystems.websocket.messages.WebSocketRequestMessage;
import org.whispersystems.websocket.messages.WebSocketResponseMessage;
public class ProtobufWebSocketMessage implements WebSocketMessage {
private final SubProtocol.WebSocketMessage message;
ProtobufWebSocketMessage(byte[] buffer, int offset, int length) throws InvalidMessageException {
try {
this.message = SubProtocol.WebSocketMessage.parseFrom(ByteString.copyFrom(buffer, offset, length));
if (getType() == Type.REQUEST_MESSAGE) {
if (!message.getRequest().hasVerb() || !message.getRequest().hasPath()) {
throw new InvalidMessageException("Missing required request attributes!");
}
} else if (getType() == Type.RESPONSE_MESSAGE) {
if (!message.getResponse().hasId() || !message.getResponse().hasStatus() || !message.getResponse().hasMessage()) {
throw new InvalidMessageException("Missing required response attributes!");
}
}
} catch (InvalidProtocolBufferException e) {
throw new InvalidMessageException(e);
}
}
ProtobufWebSocketMessage(SubProtocol.WebSocketMessage message) {
this.message = message;
}
@Override
public Type getType() {
if (message.getType().getNumber() == SubProtocol.WebSocketMessage.Type.REQUEST_VALUE &&
message.hasRequest())
{
return Type.REQUEST_MESSAGE;
} else if (message.getType().getNumber() == SubProtocol.WebSocketMessage.Type.RESPONSE_VALUE &&
message.hasResponse())
{
return Type.RESPONSE_MESSAGE;
} else {
return Type.UNKNOWN_MESSAGE;
}
}
@Override
public WebSocketRequestMessage getRequestMessage() {
return new ProtobufWebSocketRequestMessage(message.getRequest());
}
@Override
public WebSocketResponseMessage getResponseMessage() {
return new ProtobufWebSocketResponseMessage(message.getResponse());
}
@Override
public byte[] toByteArray() {
return message.toByteArray();
}
}

93
websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessageFactory.java Normal file
View File

@ -0,0 +1,93 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages.protobuf;
import com.google.protobuf.ByteString;
import org.whispersystems.websocket.messages.InvalidMessageException;
import org.whispersystems.websocket.messages.WebSocketMessage;
import org.whispersystems.websocket.messages.WebSocketMessageFactory;
import java.util.List;
import java.util.Optional;
public class ProtobufWebSocketMessageFactory implements WebSocketMessageFactory {
@Override
public WebSocketMessage parseMessage(byte[] serialized, int offset, int len)
throws InvalidMessageException
{
return new ProtobufWebSocketMessage(serialized, offset, len);
}
@Override
public WebSocketMessage createRequest(Optional<Long> requestId,
String verb, String path,
List<String> headers,
Optional<byte[]> body)
{
SubProtocol.WebSocketRequestMessage.Builder requestMessage =
SubProtocol.WebSocketRequestMessage.newBuilder()
.setVerb(verb)
.setPath(path);
if (requestId.isPresent()) {
requestMessage.setId(requestId.get());
}
if (body.isPresent()) {
requestMessage.setBody(ByteString.copyFrom(body.get()));
}
if (headers != null) {
requestMessage.addAllHeaders(headers);
}
SubProtocol.WebSocketMessage message
= SubProtocol.WebSocketMessage.newBuilder()
.setType(SubProtocol.WebSocketMessage.Type.REQUEST)
.setRequest(requestMessage)
.build();
return new ProtobufWebSocketMessage(message);
}
@Override
public WebSocketMessage createResponse(long requestId, int status, String messageString, List<String> headers, Optional<byte[]> body) {
SubProtocol.WebSocketResponseMessage.Builder responseMessage =
SubProtocol.WebSocketResponseMessage.newBuilder()
.setId(requestId)
.setStatus(status)
.setMessage(messageString);
if (body.isPresent()) {
responseMessage.setBody(ByteString.copyFrom(body.get()));
}
if (headers != null) {
responseMessage.addAllHeaders(headers);
}
SubProtocol.WebSocketMessage message =
SubProtocol.WebSocketMessage.newBuilder()
.setType(SubProtocol.WebSocketMessage.Type.RESPONSE)
.setResponse(responseMessage)
.build();
return new ProtobufWebSocketMessage(message);
}
}

76
websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketRequestMessage.java Normal file
View File

@ -0,0 +1,76 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages.protobuf;
import org.whispersystems.websocket.messages.WebSocketRequestMessage;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public class ProtobufWebSocketRequestMessage implements WebSocketRequestMessage {
private final SubProtocol.WebSocketRequestMessage message;
ProtobufWebSocketRequestMessage(SubProtocol.WebSocketRequestMessage message) {
this.message = message;
}
@Override
public String getVerb() {
return message.getVerb();
}
@Override
public String getPath() {
return message.getPath();
}
@Override
public Optional<byte[]> getBody() {
if (message.hasBody()) {
return Optional.of(message.getBody().toByteArray());
} else {
return Optional.empty();
}
}
@Override
public long getRequestId() {
return message.getId();
}
@Override
public boolean hasRequestId() {
return message.hasId();
}
@Override
public Map<String, String> getHeaders() {
Map<String, String> results = new HashMap<>();
for (String header : message.getHeadersList()) {
String[] tokenized = header.split(":");
if (tokenized.length == 2 && tokenized[0] != null && tokenized[1] != null) {
results.put(tokenized[0].trim().toLowerCase(), tokenized[1].trim());
}
}
return results;
}
}

71
websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketResponseMessage.java Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.messages.protobuf;
import org.whispersystems.websocket.messages.WebSocketResponseMessage;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public class ProtobufWebSocketResponseMessage implements WebSocketResponseMessage {
private final SubProtocol.WebSocketResponseMessage message;
public ProtobufWebSocketResponseMessage(SubProtocol.WebSocketResponseMessage message) {
this.message = message;
}
@Override
public long getRequestId() {
return message.getId();
}
@Override
public int getStatus() {
return message.getStatus();
}
@Override
public String getMessage() {
return message.getMessage();
}
@Override
public Optional<byte[]> getBody() {
if (message.hasBody()) {
return Optional.of(message.getBody().toByteArray());
} else {
return Optional.empty();
}
}
@Override
public Map<String, String> getHeaders() {
Map<String, String> results = new HashMap<>();
for (String header : message.getHeadersList()) {
String[] tokenized = header.split(":");
if (tokenized.length == 2 && tokenized[0] != null && tokenized[1] != null) {
results.put(tokenized[0].trim().toLowerCase(), tokenized[1].trim());
}
}
return results;
}
}

2841
websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/SubProtocol.java Normal file
View File

File diff suppressed because it is too large Load Diff

66
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletInputStream.java Normal file
View File

@ -0,0 +1,66 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.servlet;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
public class BufferingServletInputStream extends ServletInputStream {
private final ByteArrayInputStream buffer;
public BufferingServletInputStream(byte[] body) {
this.buffer = new ByteArrayInputStream(body);
}
@Override
public int read(byte[] buf, int offset, int length) {
return buffer.read(buf, offset, length);
}
@Override
public int read(byte[] buf) {
return read(buf, 0, buf.length);
}
@Override
public int read() throws IOException {
return buffer.read();
}
@Override
public int available() {
return buffer.available();
}
@Override
public boolean isFinished() {
return available() > 0;
}
@Override
public boolean isReady() {
return true;
}
@Override
public void setReadListener(ReadListener readListener) {
}
}

66
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletOutputStream.java Normal file
View File

@ -0,0 +1,66 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.servlet;
import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class BufferingServletOutputStream extends ServletOutputStream {
private final ByteArrayOutputStream buffer;
public BufferingServletOutputStream(ByteArrayOutputStream buffer) {
this.buffer = buffer;
}
@Override
public void write(byte[] buf, int offset, int length) {
buffer.write(buf, offset, length);
}
@Override
public void write(byte[] buf) {
write(buf, 0, buf.length);
}
@Override
public void write(int b) throws IOException {
buffer.write(b);
}
@Override
public void flush() {
}
@Override
public void close() {
}
@Override
public boolean isReady() {
return true;
}
@Override
public void setWriteListener(WriteListener writeListener) {
}
}

629
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableRequest.java Normal file
View File

@ -0,0 +1,629 @@
package org.whispersystems.websocket.servlet;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpURI;
import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.server.Authentication;
import org.eclipse.jetty.server.HttpChannel;
import org.eclipse.jetty.server.HttpChannelState;
import org.eclipse.jetty.server.HttpInput;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.server.UserIdentity;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.util.Attributes;
import javax.servlet.AsyncContext;
import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.http.Part;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.security.Principal;
import java.util.Collection;
import java.util.Enumeration;
import java.util.EventListener;
import java.util.Locale;
import java.util.Map;
public class LoggableRequest extends Request {
private final HttpServletRequest request;
public LoggableRequest(HttpServletRequest request) {
super(null, null);
this.request = request;
}
@Override
public HttpFields getHttpFields() {
throw new AssertionError();
}
@Override
public HttpInput getHttpInput() {
throw new AssertionError();
}
@Override
public void addEventListener(EventListener listener) {
throw new AssertionError();
}
@Override
public AsyncContext getAsyncContext() {
throw new AssertionError();
}
@Override
public HttpChannelState getHttpChannelState() {
throw new AssertionError();
}
@Override
public Object getAttribute(String name) {
return request.getAttribute(name);
}
@Override
public Enumeration<String> getAttributeNames() {
return request.getAttributeNames();
}
@Override
public Attributes getAttributes() {
throw new AssertionError();
}
@Override
public Authentication getAuthentication() {
return null;
}
@Override
public String getAuthType() {
return request.getAuthType();
}
@Override
public String getCharacterEncoding() {
return request.getCharacterEncoding();
}
@Override
public HttpChannel getHttpChannel() {
throw new AssertionError();
}
@Override
public int getContentLength() {
return request.getContentLength();
}
@Override
public String getContentType() {
return request.getContentType();
}
@Override
public ContextHandler.Context getContext() {
throw new AssertionError();
}
@Override
public String getContextPath() {
return request.getContextPath();
}
@Override
public Cookie[] getCookies() {
return request.getCookies();
}
@Override
public long getDateHeader(String name) {
return request.getDateHeader(name);
}
@Override
public DispatcherType getDispatcherType() {
return request.getDispatcherType();
}
@Override
public String getHeader(String name) {
return request.getHeader(name);
}
@Override
public Enumeration<String> getHeaderNames() {
return request.getHeaderNames();
}
@Override
public Enumeration<String> getHeaders(String name) {
return request.getHeaders(name);
}
@Override
public int getInputState() {
throw new AssertionError();
}
@Override
public ServletInputStream getInputStream() throws IOException {
return request.getInputStream();
}
@Override
public int getIntHeader(String name) {
return request.getIntHeader(name);
}
@Override
public Locale getLocale() {
return request.getLocale();
}
@Override
public Enumeration<Locale> getLocales() {
return request.getLocales();
}
@Override
public String getLocalAddr() {
return request.getLocalAddr();
}
@Override
public String getLocalName() {
return request.getLocalName();
}
@Override
public int getLocalPort() {
return request.getLocalPort();
}
@Override
public String getMethod() {
return request.getMethod();
}
@Override
public String getParameter(String name) {
return request.getParameter(name);
}
@Override
public Map<String, String[]> getParameterMap() {
return request.getParameterMap();
}
@Override
public Enumeration<String> getParameterNames() {
return request.getParameterNames();
}
@Override
public String[] getParameterValues(String name) {
return request.getParameterValues(name);
}
@Override
public String getPathInfo() {
return request.getPathInfo();
}
@Override
public String getPathTranslated() {
return request.getPathTranslated();
}
@Override
public String getProtocol() {
return request.getProtocol();
}
@Override
public HttpVersion getHttpVersion() {
throw new AssertionError();
}
@Override
public String getQueryEncoding() {
throw new AssertionError();
}
@Override
public String getQueryString() {
return request.getQueryString();
}
@Override
public BufferedReader getReader() throws IOException {
throw new AssertionError();
}
@Override
public String getRealPath(String path) {
return request.getRealPath(path);
}
@Override
public String getRemoteAddr() {
return request.getRemoteAddr();
}
@Override
public String getRemoteHost() {
return request.getRemoteHost();
}
@Override
public int getRemotePort() {
return request.getRemotePort();
}
@Override
public String getRemoteUser() {
return request.getRemoteUser();
}
@Override
public RequestDispatcher getRequestDispatcher(String path) {
return request.getRequestDispatcher(path);
}
@Override
public String getRequestedSessionId() {
return request.getRequestedSessionId();
}
@Override
public String getRequestURI() {
return request.getRequestURI();
}
@Override
public StringBuffer getRequestURL() {
return request.getRequestURL();
}
@Override
public Response getResponse() {
throw new AssertionError();
}
@Override
public StringBuilder getRootURL() {
throw new AssertionError();
}
@Override
public String getScheme() {
return request.getScheme();
}
@Override
public String getServerName() {
return request.getServerName();
}
@Override
public int getServerPort() {
return request.getServerPort();
}
@Override
public ServletContext getServletContext() {
return request.getServletContext();
}
@Override
public String getServletName() {
throw new AssertionError();
}
@Override
public String getServletPath() {
return request.getServletPath();
}
@Override
public ServletResponse getServletResponse() {
throw new AssertionError();
}
@Override
public String changeSessionId() {
throw new AssertionError();
}
@Override
public HttpSession getSession() {
return request.getSession();
}
@Override
public HttpSession getSession(boolean create) {
return request.getSession(create);
}
@Override
public long getTimeStamp() {
return System.currentTimeMillis();
}
@Override
public HttpURI getHttpURI() {
return new HttpURI(getRequestURI());
}
@Override
public UserIdentity getUserIdentity() {
throw new AssertionError();
}
@Override
public UserIdentity getResolvedUserIdentity() {
throw new AssertionError();
}
@Override
public UserIdentity.Scope getUserIdentityScope() {
throw new AssertionError();
}
@Override
public Principal getUserPrincipal() {
throw new AssertionError();
}
@Override
public boolean isHandled() {
throw new AssertionError();
}
@Override
public boolean isAsyncStarted() {
return request.isAsyncStarted();
}
@Override
public boolean isAsyncSupported() {
return request.isAsyncSupported();
}
@Override
public boolean isRequestedSessionIdFromCookie() {
return request.isRequestedSessionIdFromCookie();
}
@Override
public boolean isRequestedSessionIdFromUrl() {
return request.isRequestedSessionIdFromUrl();
}
@Override
public boolean isRequestedSessionIdFromURL() {
return request.isRequestedSessionIdFromURL();
}
@Override
public boolean isRequestedSessionIdValid() {
return request.isRequestedSessionIdValid();
}
@Override
public boolean isSecure() {
return request.isSecure();
}
@Override
public void setSecure(boolean secure) {
throw new AssertionError();
}
@Override
public boolean isUserInRole(String role) {
return request.isUserInRole(role);
}
@Override
public void removeAttribute(String name) {
request.removeAttribute(name);
}
@Override
public void removeEventListener(EventListener listener) {
throw new AssertionError();
}
@Override
public void setAsyncSupported(boolean supported, String source) {
throw new AssertionError();
}
@Override
public void setAttribute(String name, Object value) {
throw new AssertionError();
}
@Override
public void setAttributes(Attributes attributes) {
throw new AssertionError();
}
@Override
public void setAuthentication(Authentication authentication) {
throw new AssertionError();
}
@Override
public void setCharacterEncoding(String encoding) throws UnsupportedEncodingException {
throw new AssertionError();
}
@Override
public void setCharacterEncodingUnchecked(String encoding) {
throw new AssertionError();
}
@Override
public void setContentType(String contentType) {
throw new AssertionError();
}
@Override
public void setContext(ContextHandler.Context context) {
throw new AssertionError();
}
@Override
public boolean takeNewContext() {
throw new AssertionError();
}
@Override
public void setContextPath(String contextPath) {
throw new AssertionError();
}
@Override
public void setCookies(Cookie[] cookies) {
throw new AssertionError();
}
@Override
public void setDispatcherType(DispatcherType type) {
throw new AssertionError();
}
@Override
public void setHandled(boolean h) {
throw new AssertionError();
}
@Override
public boolean isHead() {
throw new AssertionError();
}
@Override
public void setPathInfo(String pathInfo) {
throw new AssertionError();
}
@Override
public void setHttpVersion(HttpVersion version) {
throw new AssertionError();
}
@Override
public void setQueryEncoding(String queryEncoding) {
throw new AssertionError();
}
@Override
public void setQueryString(String queryString) {
throw new AssertionError();
}
@Override
public void setRemoteAddr(InetSocketAddress addr) {
throw new AssertionError();
}
@Override
public void setRequestedSessionId(String requestedSessionId) {
throw new AssertionError();
}
@Override
public void setRequestedSessionIdFromCookie(boolean requestedSessionIdCookie) {
throw new AssertionError();
}
@Override
public void setScheme(String scheme) {
throw new AssertionError();
}
@Override
public void setServletPath(String servletPath) {
throw new AssertionError();
}
@Override
public void setSession(HttpSession session) {
throw new AssertionError();
}
@Override
public void setTimeStamp(long ts) {
throw new AssertionError();
}
@Override
public void setHttpURI(HttpURI uri) {
throw new AssertionError();
}
@Override
public void setUserIdentityScope(UserIdentity.Scope scope) {
throw new AssertionError();
}
@Override
public AsyncContext startAsync() throws IllegalStateException {
throw new AssertionError();
}
@Override
public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
throw new AssertionError();
}
@Override
public String toString() {
return request.toString();
}
@Override
public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
throw new AssertionError();
}
@Override
public Part getPart(String name) throws IOException, ServletException {
return request.getPart(name);
}
@Override
public Collection<Part> getParts() throws IOException, ServletException {
return request.getParts();
}
@Override
public void login(String username, String password) throws ServletException {
throw new AssertionError();
}
@Override
public void logout() throws ServletException {
throw new AssertionError();
}
}

449
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableResponse.java Normal file
View File

@ -0,0 +1,449 @@
package org.whispersystems.websocket.servlet;
import org.eclipse.jetty.http.HttpContent;
import org.eclipse.jetty.http.HttpCookie;
import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpHeader;
import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.http.MetaData;
import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.HttpChannel;
import org.eclipse.jetty.server.HttpConfiguration;
import org.eclipse.jetty.server.HttpOutput;
import org.eclipse.jetty.server.HttpTransport;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.util.Callback;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ReadPendingException;
import java.nio.channels.WritePendingException;
import java.util.Collection;
import java.util.Locale;
public class LoggableResponse extends Response {
private final HttpServletResponse response;
public LoggableResponse(HttpServletResponse response) {
super(null, null);
this.response = response;
}
@Override
public void putHeaders(HttpContent httpContent, long contentLength, boolean etag) {
throw new AssertionError();
}
@Override
public HttpOutput getHttpOutput() {
throw new AssertionError();
}
@Override
public boolean isIncluding() {
throw new AssertionError();
}
@Override
public void include() {
throw new AssertionError();
}
@Override
public void included() {
throw new AssertionError();
}
@Override
public void addCookie(HttpCookie cookie) {
throw new AssertionError();
}
@Override
public void addCookie(Cookie cookie) {
throw new AssertionError();
}
@Override
public boolean containsHeader(String name) {
return response.containsHeader(name);
}
@Override
public String encodeURL(String url) {
return response.encodeURL(url);
}
@Override
public String encodeRedirectURL(String url) {
return response.encodeRedirectURL(url);
}
@Override
public String encodeUrl(String url) {
return response.encodeUrl(url);
}
@Override
public String encodeRedirectUrl(String url) {
return response.encodeRedirectUrl(url);
}
@Override
public void sendError(int sc) throws IOException {
throw new AssertionError();
}
@Override
public void sendError(int code, String message) throws IOException {
throw new AssertionError();
}
@Override
public void sendProcessing() throws IOException {
throw new AssertionError();
}
@Override
public void sendRedirect(String location) throws IOException {
throw new AssertionError();
}
@Override
public void setDateHeader(String name, long date) {
throw new AssertionError();
}
@Override
public void addDateHeader(String name, long date) {
throw new AssertionError();
}
@Override
public void setHeader(HttpHeader name, String value) {
throw new AssertionError();
}
@Override
public void setHeader(String name, String value) {
throw new AssertionError();
}
@Override
public Collection<String> getHeaderNames() {
return response.getHeaderNames();
}
@Override
public String getHeader(String name) {
return response.getHeader(name);
}
@Override
public Collection<String> getHeaders(String name) {
return response.getHeaders(name);
}
@Override
public void addHeader(String name, String value) {
throw new AssertionError();
}
@Override
public void setIntHeader(String name, int value) {
throw new AssertionError();
}
@Override
public void addIntHeader(String name, int value) {
throw new AssertionError();
}
@Override
public void setStatus(int sc) {
throw new AssertionError();
}
@Override
public void setStatus(int sc, String sm) {
throw new AssertionError();
}
@Override
public void setStatusWithReason(int sc, String sm) {
throw new AssertionError();
}
@Override
public String getCharacterEncoding() {
return response.getCharacterEncoding();
}
@Override
public String getContentType() {
return response.getContentType();
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
throw new AssertionError();
}
@Override
public boolean isWriting() {
throw new AssertionError();
}
@Override
public PrintWriter getWriter() throws IOException {
throw new AssertionError();
}
@Override
public void setContentLength(int len) {
throw new AssertionError();
}
@Override
public boolean isAllContentWritten(long written) {
throw new AssertionError();
}
@Override
public void closeOutput() throws IOException {
throw new AssertionError();
}
@Override
public long getLongContentLength() {
return response.getBufferSize();
}
@Override
public void setLongContentLength(long len) {
throw new AssertionError();
}
@Override
public void setCharacterEncoding(String encoding) {
throw new AssertionError();
}
@Override
public void setContentType(String contentType) {
throw new AssertionError();
}
@Override
public void setBufferSize(int size) {
throw new AssertionError();
}
@Override
public int getBufferSize() {
return response.getBufferSize();
}
@Override
public void flushBuffer() throws IOException {
throw new AssertionError();
}
@Override
public void reset() {
throw new AssertionError();
}
@Override
public void reset(boolean preserveCookies) {
throw new AssertionError();
}
@Override
public void resetForForward() {
throw new AssertionError();
}
@Override
public void resetBuffer() {
throw new AssertionError();
}
@Override
public boolean isCommitted() {
throw new AssertionError();
}
@Override
public void setLocale(Locale locale) {
throw new AssertionError();
}
@Override
public Locale getLocale() {
return response.getLocale();
}
@Override
public int getStatus() {
return response.getStatus();
}
@Override
public String getReason() {
throw new AssertionError();
}
@Override
public HttpFields getHttpFields() {
return new HttpFields();
}
@Override
public long getContentCount() {
return 0;
}
@Override
public String toString() {
return response.toString();
}
@Override
public MetaData.Response getCommittedMetaData() {
return new MetaData.Response(HttpVersion.HTTP_2, getStatus(), null);
}
@Override
public HttpChannel getHttpChannel()
{
return new HttpChannel(null, new HttpConfiguration(), new NullEndPoint(), null);
}
private static class NullEndPoint implements EndPoint {
@Override
public InetSocketAddress getLocalAddress() {
return null;
}
@Override
public InetSocketAddress getRemoteAddress() {
return null;
}
@Override
public boolean isOpen() {
return false;
}
@Override
public long getCreatedTimeStamp() {
return 0;
}
@Override
public void shutdownOutput() {
}
@Override
public boolean isOutputShutdown() {
return false;
}
@Override
public boolean isInputShutdown() {
return false;
}
@Override
public void close() {
}
@Override
public int fill(ByteBuffer buffer) throws IOException {
return 0;
}
@Override
public boolean flush(ByteBuffer... buffer) throws IOException {
return false;
}
@Override
public Object getTransport() {
return null;
}
@Override
public long getIdleTimeout() {
return 0;
}
@Override
public void setIdleTimeout(long idleTimeout) {
}
@Override
public void fillInterested(Callback callback) throws ReadPendingException {
}
@Override
public boolean tryFillInterested(Callback callback) {
return false;
}
@Override
public boolean isFillInterested() {
return false;
}
@Override
public void write(Callback callback, ByteBuffer... buffers) throws WritePendingException {
}
@Override
public Connection getConnection() {
return null;
}
@Override
public void setConnection(Connection connection) {
}
@Override
public void onOpen() {
}
@Override
public void onClose() {
}
@Override
public boolean isOptimizedForDirectBuffers() {
return false;
}
@Override
public void upgrade(Connection newConnection) {
}
}
}

42
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletOutputStream.java Normal file
View File

@ -0,0 +1,42 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.servlet;
import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import java.io.IOException;
public class NullServletOutputStream extends ServletOutputStream {
@Override
public void write(int b) throws IOException {}
@Override
public void write(byte[] buf) {}
@Override
public void write(byte[] buf, int offset, int len) {}
@Override
public boolean isReady() {
return false;
}
@Override
public void setWriteListener(WriteListener writeListener) {
}
}

171
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletResponse.java Normal file
View File

@ -0,0 +1,171 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.servlet;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.LinkedList;
import java.util.Locale;
public class NullServletResponse implements HttpServletResponse {
@Override
public void addCookie(Cookie cookie) {}
@Override
public boolean containsHeader(String name) {
return false;
}
@Override
public String encodeURL(String url) {
return url;
}
@Override
public String encodeRedirectURL(String url) {
return url;
}
@Override
public String encodeUrl(String url) {
return url;
}
@Override
public String encodeRedirectUrl(String url) {
return url;
}
@Override
public void sendError(int sc, String msg) throws IOException {}
@Override
public void sendError(int sc) throws IOException {}
@Override
public void sendRedirect(String location) throws IOException {}
@Override
public void setDateHeader(String name, long date) {}
@Override
public void addDateHeader(String name, long date) {}
@Override
public void setHeader(String name, String value) {}
@Override
public void addHeader(String name, String value) {}
@Override
public void setIntHeader(String name, int value) {}
@Override
public void addIntHeader(String name, int value) {}
@Override
public void setStatus(int sc) {}
@Override
public void setStatus(int sc, String sm) {}
@Override
public int getStatus() {
return 200;
}
@Override
public String getHeader(String name) {
return null;
}
@Override
public Collection<String> getHeaders(String name) {
return new LinkedList<>();
}
@Override
public Collection<String> getHeaderNames() {
return new LinkedList<>();
}
@Override
public String getCharacterEncoding() {
return "UTF-8";
}
@Override
public String getContentType() {
return null;
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
return new NullServletOutputStream();
}
@Override
public PrintWriter getWriter() throws IOException {
return new PrintWriter(new NullServletOutputStream());
}
@Override
public void setCharacterEncoding(String charset) {}
@Override
public void setContentLength(int len) {}
@Override
public void setContentLengthLong(long len) {}
@Override
public void setContentType(String type) {}
@Override
public void setBufferSize(int size) {}
@Override
public int getBufferSize() {
return 0;
}
@Override
public void flushBuffer() throws IOException {}
@Override
public void resetBuffer() {}
@Override
public boolean isCommitted() {
return true;
}
@Override
public void reset() {}
@Override
public void setLocale(Locale loc) {}
@Override
public Locale getLocale() {
return Locale.US;
}
}

506
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletRequest.java Normal file
View File

@ -0,0 +1,506 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.servlet;
import org.whispersystems.websocket.messages.WebSocketRequestMessage;
import org.whispersystems.websocket.session.WebSocketSessionContext;
import javax.servlet.AsyncContext;
import javax.servlet.DispatcherType;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpUpgradeHandler;
import javax.servlet.http.Part;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Map;
import java.util.Vector;
public class WebSocketServletRequest implements HttpServletRequest {
private final Map<String, String> headers = new HashMap<>();
private final Map<String, Object> attributes = new HashMap<>();
private final WebSocketRequestMessage requestMessage;
private final ServletInputStream inputStream;
private final ServletContext servletContext;
private final WebSocketSessionContext sessionContext;
public WebSocketServletRequest(WebSocketSessionContext sessionContext,
WebSocketRequestMessage requestMessage,
ServletContext servletContext)
{
this.requestMessage = requestMessage;
this.servletContext = servletContext;
this.sessionContext = sessionContext;
if (requestMessage.getBody().isPresent()) {
inputStream = new BufferingServletInputStream(requestMessage.getBody().get());
} else {
inputStream = new BufferingServletInputStream(new byte[0]);
}
headers.putAll(requestMessage.getHeaders());
}
@Override
public String getAuthType() {
return BASIC_AUTH;
}
@Override
public Cookie[] getCookies() {
return new Cookie[0];
}
@Override
public long getDateHeader(String name) {
return -1;
}
@Override
public String getHeader(String name) {
return headers.get(name.toLowerCase());
}
@Override
public Enumeration<String> getHeaders(String name) {
String header = this.headers.get(name.toLowerCase());
Vector<String> results = new Vector<>();
if (header != null) {
results.add(header);
}
return results.elements();
}
@Override
public Enumeration<String> getHeaderNames() {
return new Vector<>(headers.keySet()).elements();
}
@Override
public int getIntHeader(String name) {
return -1;
}
@Override
public String getMethod() {
return requestMessage.getVerb();
}
@Override
public String getPathInfo() {
return requestMessage.getPath();
}
@Override
public String getPathTranslated() {
return requestMessage.getPath();
}
@Override
public String getContextPath() {
return "";
}
@Override
public String getQueryString() {
if (requestMessage.getPath().contains("?")) {
return requestMessage.getPath().substring(requestMessage.getPath().indexOf("?") + 1);
}
return null;
}
@Override
public String getRemoteUser() {
return null;
}
@Override
public boolean isUserInRole(String role) {
return false;
}
@Override
public Principal getUserPrincipal() {
return new ContextPrincipal(sessionContext);
}
@Override
public String getRequestedSessionId() {
return null;
}
@Override
public String getRequestURI() {
if (requestMessage.getPath().contains("?")) {
return requestMessage.getPath().substring(0, requestMessage.getPath().indexOf("?"));
} else {
return requestMessage.getPath();
}
}
@Override
public StringBuffer getRequestURL() {
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("http://websocket");
stringBuffer.append(getRequestURI());
return stringBuffer;
}
@Override
public String getServletPath() {
return "";
}
@Override
public HttpSession getSession(boolean create) {
return null;
}
@Override
public HttpSession getSession() {
return null;
}
@Override
public String changeSessionId() {
return null;
}
@Override
public boolean isRequestedSessionIdValid() {
return false;
}
@Override
public boolean isRequestedSessionIdFromCookie() {
return false;
}
@Override
public boolean isRequestedSessionIdFromURL() {
return false;
}
@Override
public boolean isRequestedSessionIdFromUrl() {
return false;
}
@Override
public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
return false;
}
@Override
public void login(String username, String password) throws ServletException {
}
@Override
public void logout() throws ServletException {
}
@Override
public Collection<Part> getParts() throws IOException, ServletException {
return new LinkedList<>();
}
@Override
public Part getPart(String name) throws IOException, ServletException {
return null;
}
@Override
public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
return null;
}
@Override
public Object getAttribute(String name) {
return attributes.get(name);
}
@Override
public Enumeration<String> getAttributeNames() {
return new Vector<>(attributes.keySet()).elements();
}
@Override
public String getCharacterEncoding() {
return null;
}
@Override
public void setCharacterEncoding(String env) throws UnsupportedEncodingException {}
@Override
public int getContentLength() {
if (requestMessage.getBody().isPresent()) {
return requestMessage.getBody().get().length;
} else {
return 0;
}
}
@Override
public long getContentLengthLong() {
return getContentLength();
}
@Override
public String getContentType() {
if (requestMessage.getBody().isPresent()) {
return "application/json";
} else {
return null;
}
}
@Override
public ServletInputStream getInputStream() throws IOException {
return inputStream;
}
@Override
public String getParameter(String name) {
String[] result = getParameterMap().get(name);
if (result != null && result.length > 0) {
return result[0];
}
return null;
}
@Override
public Enumeration<String> getParameterNames() {
return new Vector<>(getParameterMap().keySet()).elements();
}
@Override
public String[] getParameterValues(String name) {
return getParameterMap().get(name);
}
@Override
public Map<String, String[]> getParameterMap() {
Map<String, String[]> parameterMap = new HashMap<>();
String queryParameters = getQueryString();
if (queryParameters == null) {
return parameterMap;
}
String[] tokens = queryParameters.split("&");
for (String token : tokens) {
String[] parts = token.split("=");
if (parts != null && parts.length > 1) {
parameterMap.put(parts[0], new String[] {parts[1]});
}
}
return parameterMap;
}
@Override
public String getProtocol() {
return "HTTP/1.0";
}
@Override
public String getScheme() {
return "http";
}
@Override
public String getServerName() {
return "websocket";
}
@Override
public int getServerPort() {
return 8080;
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(inputStream));
}
@Override
public String getRemoteAddr() {
return "127.0.0.1";
}
@Override
public String getRemoteHost() {
return "localhost";
}
@Override
public void setAttribute(String name, Object o) {
if (o != null) attributes.put(name, o);
else removeAttribute(name);
}
@Override
public void removeAttribute(String name) {
attributes.remove(name);
}
@Override
public Locale getLocale() {
return Locale.US;
}
@Override
public Enumeration<Locale> getLocales() {
Vector<Locale> results = new Vector<>();
results.add(getLocale());
return results.elements();
}
@Override
public boolean isSecure() {
return false;
}
@Override
public RequestDispatcher getRequestDispatcher(String path) {
return servletContext.getRequestDispatcher(path);
}
@Override
public String getRealPath(String path) {
return path;
}
@Override
public int getRemotePort() {
return 31337;
}
@Override
public String getLocalName() {
return "localhost";
}
@Override
public String getLocalAddr() {
return "127.0.0.1";
}
@Override
public int getLocalPort() {
return 8080;
}
@Override
public ServletContext getServletContext() {
return servletContext;
}
@Override
public AsyncContext startAsync() throws IllegalStateException {
throw new AssertionError("nyi");
}
@Override
public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
throw new AssertionError("nyi");
}
@Override
public boolean isAsyncStarted() {
return false;
}
@Override
public boolean isAsyncSupported() {
return false;
}
@Override
public AsyncContext getAsyncContext() {
return null;
}
@Override
public DispatcherType getDispatcherType() {
return DispatcherType.REQUEST;
}
public static class ContextPrincipal implements Principal {
private final WebSocketSessionContext context;
public ContextPrincipal(WebSocketSessionContext context) {
this.context = context;
}
@Override
public boolean equals(Object another) {
return another instanceof ContextPrincipal &&
context.equals(((ContextPrincipal) another).context);
}
@Override
public String toString() {
return super.toString();
}
@Override
public int hashCode() {
return context.hashCode();
}
@Override
public String getName() {
return "WebSocketSessionContext";
}
public WebSocketSessionContext getContext() {
return context;
}
}
}

270
websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletResponse.java Normal file
View File

@ -0,0 +1,270 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.servlet;
import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.whispersystems.websocket.messages.WebSocketMessageFactory;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Optional;
public class WebSocketServletResponse implements HttpServletResponse {
@SuppressWarnings("unused")
private static final Logger logger = LoggerFactory.getLogger(WebSocketServletResponse.class);
private final RemoteEndpoint endPoint;
private final long requestId;
private final WebSocketMessageFactory messageFactory;
private ResponseBuilder responseBuilder = new ResponseBuilder();
private ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
private ServletOutputStream servletOutputStream = new BufferingServletOutputStream(responseBody);
private boolean isCommitted = false;
public WebSocketServletResponse(RemoteEndpoint endPoint, long requestId,
WebSocketMessageFactory messageFactory)
{
this.endPoint = endPoint;
this.requestId = requestId;
this.messageFactory = messageFactory;
this.responseBuilder.setRequestId(requestId);
}
@Override
public void addCookie(Cookie cookie) {}
@Override
public boolean containsHeader(String name) {
return false;
}
@Override
public String encodeURL(String url) {
return url;
}
@Override
public String encodeRedirectURL(String url) {
return url;
}
@Override
public String encodeUrl(String url) {
return url;
}
@Override
public String encodeRedirectUrl(String url) {
return url;
}
@Override
public void sendError(int sc, String msg) throws IOException {
setStatus(sc, msg);
}
@Override
public void sendError(int sc) throws IOException {
setStatus(sc);
}
@Override
public void sendRedirect(String location) throws IOException {
throw new IOException("Not supported!");
}
@Override
public void setDateHeader(String name, long date) {}
@Override
public void addDateHeader(String name, long date) {}
@Override
public void setHeader(String name, String value) {}
@Override
public void addHeader(String name, String value) {}
@Override
public void setIntHeader(String name, int value) {}
@Override
public void addIntHeader(String name, int value) {}
@Override
public void setStatus(int sc) {
setStatus(sc, "");
}
@Override
public void setStatus(int sc, String sm) {
this.responseBuilder.setStatusCode(sc);
this.responseBuilder.setMessage(sm);
}
@Override
public int getStatus() {
return this.responseBuilder.getStatusCode();
}
@Override
public String getHeader(String name) {
return null;
}
@Override
public Collection<String> getHeaders(String name) {
return new LinkedList<>();
}
@Override
public Collection<String> getHeaderNames() {
return new LinkedList<>();
}
@Override
public String getCharacterEncoding() {
return "UTF-8";
}
@Override
public String getContentType() {
return null;
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
return servletOutputStream;
}
@Override
public PrintWriter getWriter() throws IOException {
return new PrintWriter(servletOutputStream);
}
@Override
public void setCharacterEncoding(String charset) {}
@Override
public void setContentLength(int len) {}
@Override
public void setContentLengthLong(long len) {}
@Override
public void setContentType(String type) {}
@Override
public void setBufferSize(int size) {}
@Override
public int getBufferSize() {
return 0;
}
@Override
public void flushBuffer() throws IOException {
if (!isCommitted) {
byte[] body = responseBody.toByteArray();
if (body.length <= 0) {
body = null;
}
byte[] response = messageFactory.createResponse(responseBuilder.getRequestId(),
responseBuilder.getStatusCode(),
responseBuilder.getMessage(),
new LinkedList<>(),
Optional.ofNullable(body))
.toByteArray();
endPoint.sendBytesByFuture(ByteBuffer.wrap(response));
isCommitted = true;
}
}
@Override
public void resetBuffer() {
if (isCommitted) throw new IllegalStateException("Buffer already flushed!");
responseBody.reset();
}
@Override
public boolean isCommitted() {
return isCommitted;
}
@Override
public void reset() {
if (isCommitted) throw new IllegalStateException("Buffer already flushed!");
responseBuilder = new ResponseBuilder();
responseBuilder.setRequestId(requestId);
resetBuffer();
}
@Override
public void setLocale(Locale loc) {}
@Override
public Locale getLocale() {
return Locale.US;
}
private static class ResponseBuilder {
private long requestId;
private int statusCode;
private String message = "";
public long getRequestId() {
return requestId;
}
public void setRequestId(long requestId) {
this.requestId = requestId;
}
public int getStatusCode() {
return statusCode;
}
public void setStatusCode(int statusCode) {
this.statusCode = statusCode;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
}

28
websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSession.java Normal file
View File

@ -0,0 +1,28 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.session;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
public @interface WebSocketSession {
}

75
websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContext.java Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.session;
import org.whispersystems.websocket.WebSocketClient;
import java.util.LinkedList;
import java.util.List;
public class WebSocketSessionContext {
private final List<WebSocketEventListener> closeListeners = new LinkedList<>();
private final WebSocketClient webSocketClient;
private Object authenticated;
private boolean closed;
public WebSocketSessionContext(WebSocketClient webSocketClient) {
this.webSocketClient = webSocketClient;
}
public void setAuthenticated(Object authenticated) {
this.authenticated = authenticated;
}
public <T> T getAuthenticated(Class<T> clazz) {
if (authenticated != null && clazz.equals(authenticated.getClass())) {
return clazz.cast(authenticated);
}
throw new IllegalArgumentException("No authenticated type for: " + clazz + ", we have: " + authenticated);
}
public Object getAuthenticated() {
return authenticated;
}
public synchronized void addListener(WebSocketEventListener listener) {
if (!closed) this.closeListeners.add(listener);
else listener.onWebSocketClose(this, 1000, "Closed");
}
public WebSocketClient getClient() {
return webSocketClient;
}
public synchronized void notifyClosed(int statusCode, String reason) {
for (WebSocketEventListener listener : closeListeners) {
listener.onWebSocketClose(this, statusCode, reason);
}
closed = true;
}
public interface WebSocketEventListener {
public void onWebSocketClose(WebSocketSessionContext context, int statusCode, String reason);
}
}

73
websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContextValueFactoryProvider.java Normal file
View File

@ -0,0 +1,73 @@
package org.whispersystems.websocket.session;
import org.glassfish.hk2.api.InjectionResolver;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.api.TypeLiteral;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.server.internal.inject.AbstractContainerRequestValueFactory;
import org.glassfish.jersey.server.internal.inject.AbstractValueFactoryProvider;
import org.glassfish.jersey.server.internal.inject.MultivaluedParameterExtractorProvider;
import org.glassfish.jersey.server.internal.inject.ParamInjectionResolver;
import org.glassfish.jersey.server.model.Parameter;
import org.glassfish.jersey.server.spi.internal.ValueFactoryProvider;
import org.whispersystems.websocket.servlet.WebSocketServletRequest;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.security.Principal;
@Singleton
public class WebSocketSessionContextValueFactoryProvider extends AbstractValueFactoryProvider {
@Inject
public WebSocketSessionContextValueFactoryProvider(MultivaluedParameterExtractorProvider mpep,
ServiceLocator injector)
{
super(mpep, injector, Parameter.Source.UNKNOWN);
}
@Override
public AbstractContainerRequestValueFactory<WebSocketSessionContext> createValueFactory(Parameter parameter) {
if (parameter.getAnnotation(WebSocketSession.class) == null) {
return null;
}
return new AbstractContainerRequestValueFactory<WebSocketSessionContext>() {
public WebSocketSessionContext provide() {
Principal principal = getContainerRequest().getSecurityContext().getUserPrincipal();
if (principal == null) {
throw new IllegalStateException("Cannot inject a custom principal into unauthenticated request");
}
if (!(principal instanceof WebSocketServletRequest.ContextPrincipal)) {
throw new IllegalArgumentException("Cannot inject a non-WebSocket AuthPrincipal into request");
}
return ((WebSocketServletRequest.ContextPrincipal)principal).getContext();
}
};
}
@Singleton
private static class WebSocketSessionInjectionResolver extends ParamInjectionResolver<WebSocketSession> {
public WebSocketSessionInjectionResolver() {
super(WebSocketSessionContextValueFactoryProvider.class);
}
}
public static class Binder extends AbstractBinder {
public Binder() {
}
@Override
protected void configure() {
bind(WebSocketSessionContextValueFactoryProvider.class).to(ValueFactoryProvider.class).in(Singleton.class);
bind(WebSocketSessionInjectionResolver.class).to(new TypeLiteral<InjectionResolver<WebSocketSession>>() {
}).in(Singleton.class);
}
}
}

23
websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketConnectListener.java Normal file
View File

@ -0,0 +1,23 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.setup;
import org.whispersystems.websocket.session.WebSocketSessionContext;
public interface WebSocketConnectListener {
public void onWebSocketConnect(WebSocketSessionContext context);
}

115
websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketEnvironment.java Normal file
View File

@ -0,0 +1,115 @@
/**
* Copyright (C) 2014 Open WhisperSystems
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.whispersystems.websocket.setup;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.eclipse.jetty.server.RequestLog;
import org.glassfish.jersey.servlet.ServletContainer;
import org.whispersystems.websocket.auth.WebSocketAuthenticator;
import org.whispersystems.websocket.configuration.WebSocketConfiguration;
import org.whispersystems.websocket.messages.WebSocketMessageFactory;
import org.whispersystems.websocket.messages.protobuf.ProtobufWebSocketMessageFactory;
import javax.servlet.http.HttpServlet;
import javax.validation.Validator;
import io.dropwizard.jersey.DropwizardResourceConfig;
import io.dropwizard.jersey.setup.JerseyContainerHolder;
import io.dropwizard.jersey.setup.JerseyEnvironment;
import io.dropwizard.setup.Environment;
public class WebSocketEnvironment {
private final JerseyContainerHolder jerseyServletContainer;
private final JerseyEnvironment jerseyEnvironment;
private final ObjectMapper objectMapper;
private final Validator validator;
private final RequestLog requestLog;
private final long idleTimeoutMillis;
private WebSocketAuthenticator authenticator;
private WebSocketMessageFactory messageFactory;
private WebSocketConnectListener connectListener;
public WebSocketEnvironment(Environment environment, WebSocketConfiguration configuration) {
this(environment, configuration, 60000);
}
public WebSocketEnvironment(Environment environment, WebSocketConfiguration configuration, long idleTimeoutMillis) {
this(environment, configuration.getRequestLog().build("websocket"), idleTimeoutMillis);
}
public WebSocketEnvironment(Environment environment, RequestLog requestLog, long idleTimeoutMillis) {
DropwizardResourceConfig jerseyConfig = new DropwizardResourceConfig(environment.metrics());
this.objectMapper = environment.getObjectMapper();
this.validator = environment.getValidator();
this.requestLog = requestLog;
this.jerseyServletContainer = new JerseyContainerHolder(new ServletContainer(jerseyConfig) );
this.jerseyEnvironment = new JerseyEnvironment(jerseyServletContainer, jerseyConfig);
this.messageFactory = new ProtobufWebSocketMessageFactory();
this.idleTimeoutMillis = idleTimeoutMillis;
}
public JerseyEnvironment jersey() {
return jerseyEnvironment;
}
public WebSocketAuthenticator getAuthenticator() {
return authenticator;
}
public void setAuthenticator(WebSocketAuthenticator authenticator) {
this.authenticator = authenticator;
}
public long getIdleTimeoutMillis() {
return idleTimeoutMillis;
}
public ObjectMapper getObjectMapper() {
return objectMapper;
}
public RequestLog getRequestLog() {
return requestLog;
}
public Validator getValidator() {
return validator;
}
public HttpServlet getJerseyServletContainer() {
return (HttpServlet)jerseyServletContainer.getContainer();
}
public WebSocketMessageFactory getMessageFactory() {
return messageFactory;
}
public void setMessageFactory(WebSocketMessageFactory messageFactory) {
this.messageFactory = messageFactory;
}
public WebSocketConnectListener getConnectListener() {
return connectListener;
}
public void setConnectListener(WebSocketConnectListener connectListener) {
this.connectListener = connectListener;
}
}

2096
websocket-resources/src/main/java/org/whispersystems/websocket/util/Base64.java Normal file
View File

File diff suppressed because it is too large Load Diff

64
websocket-resources/src/test/java/org/whispersystems/websocket/LoggableRequestResponseTest.java Normal file
View File

@ -0,0 +1,64 @@
package org.whispersystems.websocket;
import org.eclipse.jetty.server.AbstractNCSARequestLog;
import org.eclipse.jetty.server.NCSARequestLog;
import org.eclipse.jetty.server.RequestLog;
import org.eclipse.jetty.util.component.AbstractLifeCycle;
import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import org.junit.Test;
import org.whispersystems.websocket.messages.WebSocketMessageFactory;
import org.whispersystems.websocket.messages.WebSocketRequestMessage;
import org.whispersystems.websocket.servlet.LoggableRequest;
import org.whispersystems.websocket.servlet.LoggableResponse;
import org.whispersystems.websocket.servlet.WebSocketServletRequest;
import org.whispersystems.websocket.servlet.WebSocketServletResponse;
import org.whispersystems.websocket.session.WebSocketSessionContext;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Optional;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class LoggableRequestResponseTest {
@Test
public void testLogging() {
NCSARequestLog requestLog = new EnabledNCSARequestLog();
WebSocketClient webSocketClient = mock(WebSocketClient.class );
WebSocketRequestMessage requestMessage = mock(WebSocketRequestMessage.class);
ServletContext servletContext = mock(ServletContext.class );
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class );
WebSocketMessageFactory messageFactory = mock(WebSocketMessageFactory.class);
when(requestMessage.getVerb()).thenReturn("GET");
when(requestMessage.getBody()).thenReturn(Optional.empty());
when(requestMessage.getHeaders()).thenReturn(new HashMap<>());
when(requestMessage.getPath()).thenReturn("/api/v1/test");
when(requestMessage.getRequestId()).thenReturn(1L);
when(requestMessage.hasRequestId()).thenReturn(true);
WebSocketSessionContext sessionContext = new WebSocketSessionContext (webSocketClient );
HttpServletRequest servletRequest = new WebSocketServletRequest (sessionContext, requestMessage, servletContext);
HttpServletResponse servletResponse = new WebSocketServletResponse(remoteEndpoint, 1, messageFactory );
LoggableRequest loggableRequest = new LoggableRequest (servletRequest );
LoggableResponse loggableResponse = new LoggableResponse(servletResponse);
requestLog.log(loggableRequest, loggableResponse);
}
private class EnabledNCSARequestLog extends NCSARequestLog {
@Override
public boolean isEnabled() {
return true;
}
}
}

73
websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderFactoryTest.java Normal file
View File

@ -0,0 +1,73 @@
package org.whispersystems.websocket;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.servlet.ServletUpgradeRequest;
import org.eclipse.jetty.websocket.servlet.ServletUpgradeResponse;
import org.junit.Test;
import org.whispersystems.websocket.auth.AuthenticationException;
import org.whispersystems.websocket.auth.WebSocketAuthenticator;
import org.whispersystems.websocket.setup.WebSocketEnvironment;
import javax.servlet.ServletException;
import java.io.IOException;
import java.util.Optional;
import io.dropwizard.jersey.setup.JerseyEnvironment;
import static org.junit.Assert.*;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.*;
public class WebSocketResourceProviderFactoryTest {
@Test
public void testUnauthorized() throws ServletException, AuthenticationException, IOException {
JerseyEnvironment jerseyEnvironment = mock(JerseyEnvironment.class );
WebSocketEnvironment environment = mock(WebSocketEnvironment.class );
WebSocketAuthenticator authenticator = mock(WebSocketAuthenticator.class);
ServletUpgradeRequest request = mock(ServletUpgradeRequest.class );
ServletUpgradeResponse response = mock(ServletUpgradeResponse.class);
when(environment.getAuthenticator()).thenReturn(authenticator);
when(authenticator.authenticate(eq(request))).thenReturn(new WebSocketAuthenticator.AuthenticationResult<>(Optional.empty(), true));
when(environment.jersey()).thenReturn(jerseyEnvironment);
WebSocketResourceProviderFactory factory = new WebSocketResourceProviderFactory(environment);
Object connection = factory.createWebSocket(request, response);
assertNull(connection);
verify(response).sendForbidden(eq("Unauthorized"));
verify(authenticator).authenticate(eq(request));
}
@Test
public void testValidAuthorization() throws AuthenticationException, ServletException {
JerseyEnvironment jerseyEnvironment = mock(JerseyEnvironment.class );
WebSocketEnvironment environment = mock(WebSocketEnvironment.class );
WebSocketAuthenticator authenticator = mock(WebSocketAuthenticator.class);
ServletUpgradeRequest request = mock(ServletUpgradeRequest.class );
ServletUpgradeResponse response = mock(ServletUpgradeResponse.class);
Session session = mock(Session.class );
Account account = new Account();
when(environment.getAuthenticator()).thenReturn(authenticator);
when(authenticator.authenticate(eq(request))).thenReturn(new WebSocketAuthenticator.AuthenticationResult<>(Optional.of(account), true));
when(environment.jersey()).thenReturn(jerseyEnvironment);
WebSocketResourceProviderFactory factory = new WebSocketResourceProviderFactory(environment);
Object connection = factory.createWebSocket(request, response);
assertNotNull(connection);
verifyNoMoreInteractions(response);
verify(authenticator).authenticate(eq(request));
((WebSocketResourceProvider)connection).onWebSocketConnect(session);
assertNotNull(((WebSocketResourceProvider) connection).getContext().getAuthenticated());
assertEquals(((WebSocketResourceProvider)connection).getContext().getAuthenticated(), account);
}
private static class Account {}
}

90
websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderTest.java Normal file
View File

@ -0,0 +1,90 @@
package org.whispersystems.websocket;
import org.eclipse.jetty.server.RequestLog;
import org.eclipse.jetty.websocket.api.CloseStatus;
import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.UpgradeRequest;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.whispersystems.websocket.WebSocketResourceProvider;
import org.whispersystems.websocket.auth.AuthenticationException;
import org.whispersystems.websocket.auth.WebSocketAuthenticator;
import org.whispersystems.websocket.messages.protobuf.ProtobufWebSocketMessageFactory;
import org.whispersystems.websocket.setup.WebSocketConnectListener;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
public class WebSocketResourceProviderTest {
@Test
public void testOnConnect() throws AuthenticationException, IOException {
HttpServlet contextHandler = mock(HttpServlet.class);
WebSocketAuthenticator<String> authenticator = mock(WebSocketAuthenticator.class);
RequestLog requestLog = mock(RequestLog.class);
WebSocketResourceProvider provider = new WebSocketResourceProvider(contextHandler, requestLog,
null,
new ProtobufWebSocketMessageFactory(),
Optional.empty(),
30000);
Session session = mock(Session.class );
UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request);
when(authenticator.authenticate(request)).thenReturn(new WebSocketAuthenticator.AuthenticationResult<>(Optional.of("fooz"), true));
provider.onWebSocketConnect(session);
verify(session, never()).close(anyInt(), anyString());
verify(session, never()).close();
verify(session, never()).close(any(CloseStatus.class));
}
@Test
public void testRouteMessage() throws Exception {
HttpServlet servlet = mock(HttpServlet.class );
WebSocketAuthenticator<String> authenticator = mock(WebSocketAuthenticator.class);
RequestLog requestLog = mock(RequestLog.class );
WebSocketResourceProvider provider = new WebSocketResourceProvider(servlet, requestLog, Optional.of((WebSocketAuthenticator)authenticator), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class );
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint);
when(authenticator.authenticate(request)).thenReturn(new WebSocketAuthenticator.AuthenticationResult<>(Optional.of("foo"), true));
provider.onWebSocketConnect(session);
verify(session, never()).close(anyInt(), anyString());
verify(session, never()).close();
verify(session, never()).close(any(CloseStatus.class));
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/bar", new LinkedList<String>(), Optional.of("hello world!".getBytes())).toByteArray();
provider.onWebSocketBinary(message, 0, message.length);
ArgumentCaptor<HttpServletRequest> requestCaptor = ArgumentCaptor.forClass(HttpServletRequest.class);
verify(servlet).service(requestCaptor.capture(), any(HttpServletResponse.class));
HttpServletRequest bundledRequest = requestCaptor.getValue();
byte[] expected = new byte[bundledRequest.getInputStream().available()];
int read = bundledRequest.getInputStream().read(expected);
assertThat(read).isEqualTo(expected.length);
assertThat(new String(expected)).isEqualTo("hello world!");
}
}