diff --git a/pom.xml b/pom.xml
index 1dd8dcfa60a7a5a19edbafc030ba25cccd5f1e56..53b57445ccac186f32c4492125765c892710b962 100644
--- a/pom.xml
+++ b/pom.xml
@@ -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>
diff --git a/redis-dispatch/pom.xml b/redis-dispatch/pom.xml
index 55a86d2159cbfbe6364a43e66aeaf8acb7c38238..bfa6a160ecbee06ab84cdc1626a0ccbfa3405d93 100644
--- a/redis-dispatch/pom.xml
+++ b/redis-dispatch/pom.xml
@@ -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>
\ No newline at end of file
diff --git a/service/pom.xml b/service/pom.xml
index b126504366d7c9ceb8625e9da50f191c09505419..8ff3c60dd240d6d129041ea8e09c7f4a57a83253 100644
--- a/service/pom.xml
+++ b/service/pom.xml
@@ -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,9 +21,15 @@
<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>
<artifactId>bcprov-jdk16</artifactId>
@@ -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>
diff --git a/websocket-resources/pom.xml b/websocket-resources/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..db047fd3cf3fb1feac5d0289cbc841b783e21b0d
--- /dev/null
+++ b/websocket-resources/pom.xml
@@ -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>
\ No newline at end of file
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketClient.java b/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketClient.java
new file mode 100644
index 0000000000000000000000000000000000000000..36c299e59bcca13df27406863d45c382d535bc73
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketClient.java
@@ -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());
+ }
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProvider.java b/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e63470361a2a1c5984abb0053bf974563fc4fad
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProvider.java
@@ -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;
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProviderFactory.java b/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProviderFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..83086db235edb6c8573861ddf9fd36b884d23a80
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/WebSocketResourceProviderFactory.java
@@ -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;
+ }
+ }
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/auth/AuthenticationException.java b/websocket-resources/src/main/java/org/whispersystems/websocket/auth/AuthenticationException.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d75fd2d8f028e290c2aa8cf907c6750648178a0
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/auth/AuthenticationException.java
@@ -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);
+ }
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/auth/WebSocketAuthenticator.java b/websocket-resources/src/main/java/org/whispersystems/websocket/auth/WebSocketAuthenticator.java
new file mode 100644
index 0000000000000000000000000000000000000000..86ffcb611d5927b7ffe21bc2be35d34446049cfb
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/auth/WebSocketAuthenticator.java
@@ -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;
+ }
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/auth/internal/WebSocketAuthValueFactoryProvider.java b/websocket-resources/src/main/java/org/whispersystems/websocket/auth/internal/WebSocketAuthValueFactoryProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..104f89a8281492e2aa4114a4a95ea4ca843eb514
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/auth/internal/WebSocketAuthValueFactoryProvider.java
@@ -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);
+ }
+ }
+}
\ No newline at end of file
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/configuration/WebSocketConfiguration.java b/websocket-resources/src/main/java/org/whispersystems/websocket/configuration/WebSocketConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..05178ae5bbe16fcfa10265ec1140b4b1e399f360
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/configuration/WebSocketConfiguration.java
@@ -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;
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/InvalidMessageException.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/InvalidMessageException.java
new file mode 100644
index 0000000000000000000000000000000000000000..50d34a2e32e92d52b9a758ae431406890ec512b7
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/InvalidMessageException.java
@@ -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);
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessage.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessage.java
new file mode 100644
index 0000000000000000000000000000000000000000..91623c818749251b633027aa6711c83553d5df38
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessage.java
@@ -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();
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessageFactory.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessageFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee512fbe85979bbf7fade6aa1ddaa0c651d0fe1b
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketMessageFactory.java
@@ -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);
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketRequestMessage.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketRequestMessage.java
new file mode 100644
index 0000000000000000000000000000000000000000..5036d5abd6fd3745415955f498e71fde2bcfac8e
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketRequestMessage.java
@@ -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();
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketResponseMessage.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketResponseMessage.java
new file mode 100644
index 0000000000000000000000000000000000000000..55983eb0fd83c575d46743ae7dc6d2cba727c717
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/WebSocketResponseMessage.java
@@ -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();
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessage.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessage.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff3cf08c477f6a34efdb7f269082cce93ddc2e48
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessage.java
@@ -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();
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessageFactory.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessageFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..49e0ec92524c14d62acb13eb34c3ef515a525645
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketMessageFactory.java
@@ -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);
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketRequestMessage.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketRequestMessage.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e13b45b3a8564c5da1ee79a14e8c6564fe6463e
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketRequestMessage.java
@@ -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;
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketResponseMessage.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketResponseMessage.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c3bb2e644d669fca5d640b8345284853328dfb7
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/ProtobufWebSocketResponseMessage.java
@@ -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;
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/SubProtocol.java b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/SubProtocol.java
new file mode 100644
index 0000000000000000000000000000000000000000..f71d374eb1552d9c18702ca12ed4f192e139294c
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/messages/protobuf/SubProtocol.java
@@ -0,0 +1,2841 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: SubProtocol.proto
+
+package org.whispersystems.websocket.messages.protobuf;
+
+public final class SubProtocol {
+ private SubProtocol() {}
+ public static void registerAllExtensions(
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface WebSocketRequestMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional string verb = 1;
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ boolean hasVerb();
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ java.lang.String getVerb();
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ com.google.protobuf.ByteString
+ getVerbBytes();
+
+ // optional string path = 2;
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ boolean hasPath();
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ java.lang.String getPath();
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ com.google.protobuf.ByteString
+ getPathBytes();
+
+ // repeated string headers = 5;
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ java.util.List<java.lang.String>
+ getHeadersList();
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ int getHeadersCount();
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ java.lang.String getHeaders(int index);
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ com.google.protobuf.ByteString
+ getHeadersBytes(int index);
+
+ // optional bytes body = 3;
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ boolean hasBody();
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ com.google.protobuf.ByteString getBody();
+
+ // optional uint64 id = 4;
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ boolean hasId();
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ long getId();
+ }
+ /**
+ * Protobuf type {@code textsecure.WebSocketRequestMessage}
+ */
+ public static final class WebSocketRequestMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements WebSocketRequestMessageOrBuilder {
+ // Use WebSocketRequestMessage.newBuilder() to construct.
+ private WebSocketRequestMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private WebSocketRequestMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final WebSocketRequestMessage defaultInstance;
+ public static WebSocketRequestMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public WebSocketRequestMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private WebSocketRequestMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ bitField0_ |= 0x00000001;
+ verb_ = input.readBytes();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ path_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ body_ = input.readBytes();
+ break;
+ }
+ case 32: {
+ bitField0_ |= 0x00000008;
+ id_ = input.readUInt64();
+ break;
+ }
+ case 42: {
+ if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+ headers_ = new com.google.protobuf.LazyStringArrayList();
+ mutable_bitField0_ |= 0x00000004;
+ }
+ headers_.add(input.readBytes());
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+ headers_ = new com.google.protobuf.UnmodifiableLazyStringList(headers_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketRequestMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketRequestMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.class, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<WebSocketRequestMessage> PARSER =
+ new com.google.protobuf.AbstractParser<WebSocketRequestMessage>() {
+ public WebSocketRequestMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new WebSocketRequestMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<WebSocketRequestMessage> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional string verb = 1;
+ public static final int VERB_FIELD_NUMBER = 1;
+ private java.lang.Object verb_;
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public boolean hasVerb() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public java.lang.String getVerb() {
+ java.lang.Object ref = verb_;
+ if (ref instanceof java.lang.String) {
+ return (java.lang.String) ref;
+ } else {
+ com.google.protobuf.ByteString bs =
+ (com.google.protobuf.ByteString) ref;
+ java.lang.String s = bs.toStringUtf8();
+ if (bs.isValidUtf8()) {
+ verb_ = s;
+ }
+ return s;
+ }
+ }
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public com.google.protobuf.ByteString
+ getVerbBytes() {
+ java.lang.Object ref = verb_;
+ if (ref instanceof java.lang.String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ verb_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+
+ // optional string path = 2;
+ public static final int PATH_FIELD_NUMBER = 2;
+ private java.lang.Object path_;
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public boolean hasPath() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public java.lang.String getPath() {
+ java.lang.Object ref = path_;
+ if (ref instanceof java.lang.String) {
+ return (java.lang.String) ref;
+ } else {
+ com.google.protobuf.ByteString bs =
+ (com.google.protobuf.ByteString) ref;
+ java.lang.String s = bs.toStringUtf8();
+ if (bs.isValidUtf8()) {
+ path_ = s;
+ }
+ return s;
+ }
+ }
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public com.google.protobuf.ByteString
+ getPathBytes() {
+ java.lang.Object ref = path_;
+ if (ref instanceof java.lang.String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ path_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+
+ // repeated string headers = 5;
+ public static final int HEADERS_FIELD_NUMBER = 5;
+ private com.google.protobuf.LazyStringList headers_;
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.util.List<java.lang.String>
+ getHeadersList() {
+ return headers_;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public int getHeadersCount() {
+ return headers_.size();
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.lang.String getHeaders(int index) {
+ return headers_.get(index);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public com.google.protobuf.ByteString
+ getHeadersBytes(int index) {
+ return headers_.getByteString(index);
+ }
+
+ // optional bytes body = 3;
+ public static final int BODY_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString body_;
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ public boolean hasBody() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ public com.google.protobuf.ByteString getBody() {
+ return body_;
+ }
+
+ // optional uint64 id = 4;
+ public static final int ID_FIELD_NUMBER = 4;
+ private long id_;
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ public long getId() {
+ return id_;
+ }
+
+ private void initFields() {
+ verb_ = "";
+ path_ = "";
+ headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ body_ = com.google.protobuf.ByteString.EMPTY;
+ id_ = 0L;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeBytes(1, getVerbBytes());
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, getPathBytes());
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, body_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeUInt64(4, id_);
+ }
+ for (int i = 0; i < headers_.size(); i++) {
+ output.writeBytes(5, headers_.getByteString(i));
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, getVerbBytes());
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, getPathBytes());
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, body_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt64Size(4, id_);
+ }
+ {
+ int dataSize = 0;
+ for (int i = 0; i < headers_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+ .computeBytesSizeNoTag(headers_.getByteString(i));
+ }
+ size += dataSize;
+ size += 1 * getHeadersList().size();
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.WebSocketRequestMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketRequestMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketRequestMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.class, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ verb_ = "";
+ bitField0_ = (bitField0_ & ~0x00000001);
+ path_ = "";
+ bitField0_ = (bitField0_ & ~0x00000002);
+ headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ body_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ id_ = 0L;
+ bitField0_ = (bitField0_ & ~0x00000010);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketRequestMessage_descriptor;
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage getDefaultInstanceForType() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage build() {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage buildPartial() {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage result = new org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.verb_ = verb_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.path_ = path_;
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ headers_ = new com.google.protobuf.UnmodifiableLazyStringList(
+ headers_);
+ bitField0_ = (bitField0_ & ~0x00000004);
+ }
+ result.headers_ = headers_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.body_ = body_;
+ if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.id_ = id_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage) {
+ return mergeFrom((org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage other) {
+ if (other == org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.getDefaultInstance()) return this;
+ if (other.hasVerb()) {
+ bitField0_ |= 0x00000001;
+ verb_ = other.verb_;
+ onChanged();
+ }
+ if (other.hasPath()) {
+ bitField0_ |= 0x00000002;
+ path_ = other.path_;
+ onChanged();
+ }
+ if (!other.headers_.isEmpty()) {
+ if (headers_.isEmpty()) {
+ headers_ = other.headers_;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ } else {
+ ensureHeadersIsMutable();
+ headers_.addAll(other.headers_);
+ }
+ onChanged();
+ }
+ if (other.hasBody()) {
+ setBody(other.getBody());
+ }
+ if (other.hasId()) {
+ setId(other.getId());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional string verb = 1;
+ private java.lang.Object verb_ = "";
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public boolean hasVerb() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public java.lang.String getVerb() {
+ java.lang.Object ref = verb_;
+ if (!(ref instanceof java.lang.String)) {
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
+ verb_ = s;
+ return s;
+ } else {
+ return (java.lang.String) ref;
+ }
+ }
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public com.google.protobuf.ByteString
+ getVerbBytes() {
+ java.lang.Object ref = verb_;
+ if (ref instanceof String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ verb_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public Builder setVerb(
+ java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ verb_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public Builder clearVerb() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ verb_ = getDefaultInstance().getVerb();
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional string verb = 1;</code>
+ */
+ public Builder setVerbBytes(
+ com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ verb_ = value;
+ onChanged();
+ return this;
+ }
+
+ // optional string path = 2;
+ private java.lang.Object path_ = "";
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public boolean hasPath() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public java.lang.String getPath() {
+ java.lang.Object ref = path_;
+ if (!(ref instanceof java.lang.String)) {
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
+ path_ = s;
+ return s;
+ } else {
+ return (java.lang.String) ref;
+ }
+ }
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public com.google.protobuf.ByteString
+ getPathBytes() {
+ java.lang.Object ref = path_;
+ if (ref instanceof String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ path_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public Builder setPath(
+ java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ path_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public Builder clearPath() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ path_ = getDefaultInstance().getPath();
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional string path = 2;</code>
+ */
+ public Builder setPathBytes(
+ com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ path_ = value;
+ onChanged();
+ return this;
+ }
+
+ // repeated string headers = 5;
+ private com.google.protobuf.LazyStringList headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ private void ensureHeadersIsMutable() {
+ if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+ headers_ = new com.google.protobuf.LazyStringArrayList(headers_);
+ bitField0_ |= 0x00000004;
+ }
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.util.List<java.lang.String>
+ getHeadersList() {
+ return java.util.Collections.unmodifiableList(headers_);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public int getHeadersCount() {
+ return headers_.size();
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.lang.String getHeaders(int index) {
+ return headers_.get(index);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public com.google.protobuf.ByteString
+ getHeadersBytes(int index) {
+ return headers_.getByteString(index);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder setHeaders(
+ int index, java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureHeadersIsMutable();
+ headers_.set(index, value);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder addHeaders(
+ java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureHeadersIsMutable();
+ headers_.add(value);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder addAllHeaders(
+ java.lang.Iterable<java.lang.String> values) {
+ ensureHeadersIsMutable();
+ super.addAll(values, headers_);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder clearHeaders() {
+ headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder addHeadersBytes(
+ com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureHeadersIsMutable();
+ headers_.add(value);
+ onChanged();
+ return this;
+ }
+
+ // optional bytes body = 3;
+ private com.google.protobuf.ByteString body_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ public boolean hasBody() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ public com.google.protobuf.ByteString getBody() {
+ return body_;
+ }
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ public Builder setBody(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ body_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes body = 3;</code>
+ */
+ public Builder clearBody() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ body_ = getDefaultInstance().getBody();
+ onChanged();
+ return this;
+ }
+
+ // optional uint64 id = 4;
+ private long id_ ;
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ public long getId() {
+ return id_;
+ }
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ public Builder setId(long value) {
+ bitField0_ |= 0x00000010;
+ id_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint64 id = 4;</code>
+ */
+ public Builder clearId() {
+ bitField0_ = (bitField0_ & ~0x00000010);
+ id_ = 0L;
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.WebSocketRequestMessage)
+ }
+
+ static {
+ defaultInstance = new WebSocketRequestMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.WebSocketRequestMessage)
+ }
+
+ public interface WebSocketResponseMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint64 id = 1;
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ boolean hasId();
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ long getId();
+
+ // optional uint32 status = 2;
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ boolean hasStatus();
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ int getStatus();
+
+ // optional string message = 3;
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ boolean hasMessage();
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ java.lang.String getMessage();
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ com.google.protobuf.ByteString
+ getMessageBytes();
+
+ // repeated string headers = 5;
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ java.util.List<java.lang.String>
+ getHeadersList();
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ int getHeadersCount();
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ java.lang.String getHeaders(int index);
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ com.google.protobuf.ByteString
+ getHeadersBytes(int index);
+
+ // optional bytes body = 4;
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ boolean hasBody();
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ com.google.protobuf.ByteString getBody();
+ }
+ /**
+ * Protobuf type {@code textsecure.WebSocketResponseMessage}
+ */
+ public static final class WebSocketResponseMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements WebSocketResponseMessageOrBuilder {
+ // Use WebSocketResponseMessage.newBuilder() to construct.
+ private WebSocketResponseMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private WebSocketResponseMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final WebSocketResponseMessage defaultInstance;
+ public static WebSocketResponseMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public WebSocketResponseMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private WebSocketResponseMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ id_ = input.readUInt64();
+ break;
+ }
+ case 16: {
+ bitField0_ |= 0x00000002;
+ status_ = input.readUInt32();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ message_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ body_ = input.readBytes();
+ break;
+ }
+ case 42: {
+ if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+ headers_ = new com.google.protobuf.LazyStringArrayList();
+ mutable_bitField0_ |= 0x00000008;
+ }
+ headers_.add(input.readBytes());
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+ headers_ = new com.google.protobuf.UnmodifiableLazyStringList(headers_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketResponseMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketResponseMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.class, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<WebSocketResponseMessage> PARSER =
+ new com.google.protobuf.AbstractParser<WebSocketResponseMessage>() {
+ public WebSocketResponseMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new WebSocketResponseMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<WebSocketResponseMessage> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint64 id = 1;
+ public static final int ID_FIELD_NUMBER = 1;
+ private long id_;
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ public long getId() {
+ return id_;
+ }
+
+ // optional uint32 status = 2;
+ public static final int STATUS_FIELD_NUMBER = 2;
+ private int status_;
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ public boolean hasStatus() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ public int getStatus() {
+ return status_;
+ }
+
+ // optional string message = 3;
+ public static final int MESSAGE_FIELD_NUMBER = 3;
+ private java.lang.Object message_;
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public boolean hasMessage() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public java.lang.String getMessage() {
+ java.lang.Object ref = message_;
+ if (ref instanceof java.lang.String) {
+ return (java.lang.String) ref;
+ } else {
+ com.google.protobuf.ByteString bs =
+ (com.google.protobuf.ByteString) ref;
+ java.lang.String s = bs.toStringUtf8();
+ if (bs.isValidUtf8()) {
+ message_ = s;
+ }
+ return s;
+ }
+ }
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public com.google.protobuf.ByteString
+ getMessageBytes() {
+ java.lang.Object ref = message_;
+ if (ref instanceof java.lang.String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ message_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+
+ // repeated string headers = 5;
+ public static final int HEADERS_FIELD_NUMBER = 5;
+ private com.google.protobuf.LazyStringList headers_;
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.util.List<java.lang.String>
+ getHeadersList() {
+ return headers_;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public int getHeadersCount() {
+ return headers_.size();
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.lang.String getHeaders(int index) {
+ return headers_.get(index);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public com.google.protobuf.ByteString
+ getHeadersBytes(int index) {
+ return headers_.getByteString(index);
+ }
+
+ // optional bytes body = 4;
+ public static final int BODY_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString body_;
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ public boolean hasBody() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ public com.google.protobuf.ByteString getBody() {
+ return body_;
+ }
+
+ private void initFields() {
+ id_ = 0L;
+ status_ = 0;
+ message_ = "";
+ headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ body_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt64(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeUInt32(2, status_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, getMessageBytes());
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, body_);
+ }
+ for (int i = 0; i < headers_.size(); i++) {
+ output.writeBytes(5, headers_.getByteString(i));
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt64Size(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(2, status_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, getMessageBytes());
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, body_);
+ }
+ {
+ int dataSize = 0;
+ for (int i = 0; i < headers_.size(); i++) {
+ dataSize += com.google.protobuf.CodedOutputStream
+ .computeBytesSizeNoTag(headers_.getByteString(i));
+ }
+ size += dataSize;
+ size += 1 * getHeadersList().size();
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.WebSocketResponseMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketResponseMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketResponseMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.class, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ id_ = 0L;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ status_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ message_ = "";
+ bitField0_ = (bitField0_ & ~0x00000004);
+ headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ body_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000010);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketResponseMessage_descriptor;
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage getDefaultInstanceForType() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage build() {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage buildPartial() {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage result = new org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.id_ = id_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.status_ = status_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.message_ = message_;
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ headers_ = new com.google.protobuf.UnmodifiableLazyStringList(
+ headers_);
+ bitField0_ = (bitField0_ & ~0x00000008);
+ }
+ result.headers_ = headers_;
+ if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.body_ = body_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage) {
+ return mergeFrom((org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage other) {
+ if (other == org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.getDefaultInstance()) return this;
+ if (other.hasId()) {
+ setId(other.getId());
+ }
+ if (other.hasStatus()) {
+ setStatus(other.getStatus());
+ }
+ if (other.hasMessage()) {
+ bitField0_ |= 0x00000004;
+ message_ = other.message_;
+ onChanged();
+ }
+ if (!other.headers_.isEmpty()) {
+ if (headers_.isEmpty()) {
+ headers_ = other.headers_;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ } else {
+ ensureHeadersIsMutable();
+ headers_.addAll(other.headers_);
+ }
+ onChanged();
+ }
+ if (other.hasBody()) {
+ setBody(other.getBody());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint64 id = 1;
+ private long id_ ;
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ public long getId() {
+ return id_;
+ }
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ public Builder setId(long value) {
+ bitField0_ |= 0x00000001;
+ id_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint64 id = 1;</code>
+ */
+ public Builder clearId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ id_ = 0L;
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 status = 2;
+ private int status_ ;
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ public boolean hasStatus() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ public int getStatus() {
+ return status_;
+ }
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ public Builder setStatus(int value) {
+ bitField0_ |= 0x00000002;
+ status_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 status = 2;</code>
+ */
+ public Builder clearStatus() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ status_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional string message = 3;
+ private java.lang.Object message_ = "";
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public boolean hasMessage() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public java.lang.String getMessage() {
+ java.lang.Object ref = message_;
+ if (!(ref instanceof java.lang.String)) {
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
+ message_ = s;
+ return s;
+ } else {
+ return (java.lang.String) ref;
+ }
+ }
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public com.google.protobuf.ByteString
+ getMessageBytes() {
+ java.lang.Object ref = message_;
+ if (ref instanceof String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ message_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public Builder setMessage(
+ java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ message_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public Builder clearMessage() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ message_ = getDefaultInstance().getMessage();
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional string message = 3;</code>
+ */
+ public Builder setMessageBytes(
+ com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ message_ = value;
+ onChanged();
+ return this;
+ }
+
+ // repeated string headers = 5;
+ private com.google.protobuf.LazyStringList headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ private void ensureHeadersIsMutable() {
+ if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+ headers_ = new com.google.protobuf.LazyStringArrayList(headers_);
+ bitField0_ |= 0x00000008;
+ }
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.util.List<java.lang.String>
+ getHeadersList() {
+ return java.util.Collections.unmodifiableList(headers_);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public int getHeadersCount() {
+ return headers_.size();
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public java.lang.String getHeaders(int index) {
+ return headers_.get(index);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public com.google.protobuf.ByteString
+ getHeadersBytes(int index) {
+ return headers_.getByteString(index);
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder setHeaders(
+ int index, java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureHeadersIsMutable();
+ headers_.set(index, value);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder addHeaders(
+ java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureHeadersIsMutable();
+ headers_.add(value);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder addAllHeaders(
+ java.lang.Iterable<java.lang.String> values) {
+ ensureHeadersIsMutable();
+ super.addAll(values, headers_);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder clearHeaders() {
+ headers_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>repeated string headers = 5;</code>
+ */
+ public Builder addHeadersBytes(
+ com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureHeadersIsMutable();
+ headers_.add(value);
+ onChanged();
+ return this;
+ }
+
+ // optional bytes body = 4;
+ private com.google.protobuf.ByteString body_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ public boolean hasBody() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ public com.google.protobuf.ByteString getBody() {
+ return body_;
+ }
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ public Builder setBody(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000010;
+ body_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes body = 4;</code>
+ */
+ public Builder clearBody() {
+ bitField0_ = (bitField0_ & ~0x00000010);
+ body_ = getDefaultInstance().getBody();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.WebSocketResponseMessage)
+ }
+
+ static {
+ defaultInstance = new WebSocketResponseMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.WebSocketResponseMessage)
+ }
+
+ public interface WebSocketMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional .textsecure.WebSocketMessage.Type type = 1;
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ boolean hasType();
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type getType();
+
+ // optional .textsecure.WebSocketRequestMessage request = 2;
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ boolean hasRequest();
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage getRequest();
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessageOrBuilder getRequestOrBuilder();
+
+ // optional .textsecure.WebSocketResponseMessage response = 3;
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ boolean hasResponse();
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage getResponse();
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessageOrBuilder getResponseOrBuilder();
+ }
+ /**
+ * Protobuf type {@code textsecure.WebSocketMessage}
+ */
+ public static final class WebSocketMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements WebSocketMessageOrBuilder {
+ // Use WebSocketMessage.newBuilder() to construct.
+ private WebSocketMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private WebSocketMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final WebSocketMessage defaultInstance;
+ public static WebSocketMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public WebSocketMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private WebSocketMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ int rawValue = input.readEnum();
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type value = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type.valueOf(rawValue);
+ if (value == null) {
+ unknownFields.mergeVarintField(1, rawValue);
+ } else {
+ bitField0_ |= 0x00000001;
+ type_ = value;
+ }
+ break;
+ }
+ case 18: {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ subBuilder = request_.toBuilder();
+ }
+ request_ = input.readMessage(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(request_);
+ request_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000002;
+ break;
+ }
+ case 26: {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ subBuilder = response_.toBuilder();
+ }
+ response_ = input.readMessage(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(response_);
+ response_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000004;
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.class, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<WebSocketMessage> PARSER =
+ new com.google.protobuf.AbstractParser<WebSocketMessage>() {
+ public WebSocketMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new WebSocketMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<WebSocketMessage> getParserForType() {
+ return PARSER;
+ }
+
+ /**
+ * Protobuf enum {@code textsecure.WebSocketMessage.Type}
+ */
+ public enum Type
+ implements com.google.protobuf.ProtocolMessageEnum {
+ /**
+ * <code>UNKNOWN = 0;</code>
+ */
+ UNKNOWN(0, 0),
+ /**
+ * <code>REQUEST = 1;</code>
+ */
+ REQUEST(1, 1),
+ /**
+ * <code>RESPONSE = 2;</code>
+ */
+ RESPONSE(2, 2),
+ ;
+
+ /**
+ * <code>UNKNOWN = 0;</code>
+ */
+ public static final int UNKNOWN_VALUE = 0;
+ /**
+ * <code>REQUEST = 1;</code>
+ */
+ public static final int REQUEST_VALUE = 1;
+ /**
+ * <code>RESPONSE = 2;</code>
+ */
+ public static final int RESPONSE_VALUE = 2;
+
+
+ public final int getNumber() { return value; }
+
+ public static Type valueOf(int value) {
+ switch (value) {
+ case 0: return UNKNOWN;
+ case 1: return REQUEST;
+ case 2: return RESPONSE;
+ default: return null;
+ }
+ }
+
+ public static com.google.protobuf.Internal.EnumLiteMap<Type>
+ internalGetValueMap() {
+ return internalValueMap;
+ }
+ private static com.google.protobuf.Internal.EnumLiteMap<Type>
+ internalValueMap =
+ new com.google.protobuf.Internal.EnumLiteMap<Type>() {
+ public Type findValueByNumber(int number) {
+ return Type.valueOf(number);
+ }
+ };
+
+ public final com.google.protobuf.Descriptors.EnumValueDescriptor
+ getValueDescriptor() {
+ return getDescriptor().getValues().get(index);
+ }
+ public final com.google.protobuf.Descriptors.EnumDescriptor
+ getDescriptorForType() {
+ return getDescriptor();
+ }
+ public static final com.google.protobuf.Descriptors.EnumDescriptor
+ getDescriptor() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.getDescriptor().getEnumTypes().get(0);
+ }
+
+ private static final Type[] VALUES = values();
+
+ public static Type valueOf(
+ com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
+ if (desc.getType() != getDescriptor()) {
+ throw new java.lang.IllegalArgumentException(
+ "EnumValueDescriptor is not for this type.");
+ }
+ return VALUES[desc.getIndex()];
+ }
+
+ private final int index;
+ private final int value;
+
+ private Type(int index, int value) {
+ this.index = index;
+ this.value = value;
+ }
+
+ // @@protoc_insertion_point(enum_scope:textsecure.WebSocketMessage.Type)
+ }
+
+ private int bitField0_;
+ // optional .textsecure.WebSocketMessage.Type type = 1;
+ public static final int TYPE_FIELD_NUMBER = 1;
+ private org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type type_;
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ public boolean hasType() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type getType() {
+ return type_;
+ }
+
+ // optional .textsecure.WebSocketRequestMessage request = 2;
+ public static final int REQUEST_FIELD_NUMBER = 2;
+ private org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage request_;
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public boolean hasRequest() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage getRequest() {
+ return request_;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessageOrBuilder getRequestOrBuilder() {
+ return request_;
+ }
+
+ // optional .textsecure.WebSocketResponseMessage response = 3;
+ public static final int RESPONSE_FIELD_NUMBER = 3;
+ private org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage response_;
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public boolean hasResponse() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage getResponse() {
+ return response_;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessageOrBuilder getResponseOrBuilder() {
+ return response_;
+ }
+
+ private void initFields() {
+ type_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type.UNKNOWN;
+ request_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.getDefaultInstance();
+ response_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.getDefaultInstance();
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeEnum(1, type_.getNumber());
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeMessage(2, request_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeMessage(3, response_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeEnumSize(1, type_.getNumber());
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(2, request_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(3, response_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.WebSocketMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.class, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ getRequestFieldBuilder();
+ getResponseFieldBuilder();
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ type_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type.UNKNOWN;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ if (requestBuilder_ == null) {
+ request_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.getDefaultInstance();
+ } else {
+ requestBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000002);
+ if (responseBuilder_ == null) {
+ response_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.getDefaultInstance();
+ } else {
+ responseBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000004);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.internal_static_textsecure_WebSocketMessage_descriptor;
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage getDefaultInstanceForType() {
+ return org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage build() {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage buildPartial() {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage result = new org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.type_ = type_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ if (requestBuilder_ == null) {
+ result.request_ = request_;
+ } else {
+ result.request_ = requestBuilder_.build();
+ }
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ if (responseBuilder_ == null) {
+ result.response_ = response_;
+ } else {
+ result.response_ = responseBuilder_.build();
+ }
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage) {
+ return mergeFrom((org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage other) {
+ if (other == org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.getDefaultInstance()) return this;
+ if (other.hasType()) {
+ setType(other.getType());
+ }
+ if (other.hasRequest()) {
+ mergeRequest(other.getRequest());
+ }
+ if (other.hasResponse()) {
+ mergeResponse(other.getResponse());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional .textsecure.WebSocketMessage.Type type = 1;
+ private org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type type_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type.UNKNOWN;
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ public boolean hasType() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type getType() {
+ return type_;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ public Builder setType(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ type_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketMessage.Type type = 1;</code>
+ */
+ public Builder clearType() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ type_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketMessage.Type.UNKNOWN;
+ onChanged();
+ return this;
+ }
+
+ // optional .textsecure.WebSocketRequestMessage request = 2;
+ private org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage request_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessageOrBuilder> requestBuilder_;
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public boolean hasRequest() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage getRequest() {
+ if (requestBuilder_ == null) {
+ return request_;
+ } else {
+ return requestBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public Builder setRequest(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage value) {
+ if (requestBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ request_ = value;
+ onChanged();
+ } else {
+ requestBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000002;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public Builder setRequest(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder builderForValue) {
+ if (requestBuilder_ == null) {
+ request_ = builderForValue.build();
+ onChanged();
+ } else {
+ requestBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000002;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public Builder mergeRequest(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage value) {
+ if (requestBuilder_ == null) {
+ if (((bitField0_ & 0x00000002) == 0x00000002) &&
+ request_ != org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.getDefaultInstance()) {
+ request_ =
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.newBuilder(request_).mergeFrom(value).buildPartial();
+ } else {
+ request_ = value;
+ }
+ onChanged();
+ } else {
+ requestBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000002;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public Builder clearRequest() {
+ if (requestBuilder_ == null) {
+ request_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.getDefaultInstance();
+ onChanged();
+ } else {
+ requestBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000002);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder getRequestBuilder() {
+ bitField0_ |= 0x00000002;
+ onChanged();
+ return getRequestFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessageOrBuilder getRequestOrBuilder() {
+ if (requestBuilder_ != null) {
+ return requestBuilder_.getMessageOrBuilder();
+ } else {
+ return request_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.WebSocketRequestMessage request = 2;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessageOrBuilder>
+ getRequestFieldBuilder() {
+ if (requestBuilder_ == null) {
+ requestBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessage.Builder, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketRequestMessageOrBuilder>(
+ request_,
+ getParentForChildren(),
+ isClean());
+ request_ = null;
+ }
+ return requestBuilder_;
+ }
+
+ // optional .textsecure.WebSocketResponseMessage response = 3;
+ private org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage response_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessageOrBuilder> responseBuilder_;
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public boolean hasResponse() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage getResponse() {
+ if (responseBuilder_ == null) {
+ return response_;
+ } else {
+ return responseBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public Builder setResponse(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage value) {
+ if (responseBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ response_ = value;
+ onChanged();
+ } else {
+ responseBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public Builder setResponse(
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder builderForValue) {
+ if (responseBuilder_ == null) {
+ response_ = builderForValue.build();
+ onChanged();
+ } else {
+ responseBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public Builder mergeResponse(org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage value) {
+ if (responseBuilder_ == null) {
+ if (((bitField0_ & 0x00000004) == 0x00000004) &&
+ response_ != org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.getDefaultInstance()) {
+ response_ =
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.newBuilder(response_).mergeFrom(value).buildPartial();
+ } else {
+ response_ = value;
+ }
+ onChanged();
+ } else {
+ responseBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public Builder clearResponse() {
+ if (responseBuilder_ == null) {
+ response_ = org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.getDefaultInstance();
+ onChanged();
+ } else {
+ responseBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000004);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder getResponseBuilder() {
+ bitField0_ |= 0x00000004;
+ onChanged();
+ return getResponseFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ public org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessageOrBuilder getResponseOrBuilder() {
+ if (responseBuilder_ != null) {
+ return responseBuilder_.getMessageOrBuilder();
+ } else {
+ return response_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.WebSocketResponseMessage response = 3;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessageOrBuilder>
+ getResponseFieldBuilder() {
+ if (responseBuilder_ == null) {
+ responseBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessage.Builder, org.whispersystems.websocket.messages.protobuf.SubProtocol.WebSocketResponseMessageOrBuilder>(
+ response_,
+ getParentForChildren(),
+ isClean());
+ response_ = null;
+ }
+ return responseBuilder_;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.WebSocketMessage)
+ }
+
+ static {
+ defaultInstance = new WebSocketMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.WebSocketMessage)
+ }
+
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_WebSocketRequestMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_WebSocketRequestMessage_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_WebSocketResponseMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_WebSocketResponseMessage_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_WebSocketMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_WebSocketMessage_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
+ return descriptor;
+ }
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
+ static {
+ java.lang.String[] descriptorData = {
+ "\n\021SubProtocol.proto\022\ntextsecure\"`\n\027WebSo" +
+ "cketRequestMessage\022\014\n\004verb\030\001 \001(\t\022\014\n\004path" +
+ "\030\002 \001(\t\022\017\n\007headers\030\005 \003(\t\022\014\n\004body\030\003 \001(\014\022\n\n" +
+ "\002id\030\004 \001(\004\"f\n\030WebSocketResponseMessage\022\n\n" +
+ "\002id\030\001 \001(\004\022\016\n\006status\030\002 \001(\r\022\017\n\007message\030\003 \001" +
+ "(\t\022\017\n\007headers\030\005 \003(\t\022\014\n\004body\030\004 \001(\014\"\341\001\n\020We" +
+ "bSocketMessage\022/\n\004type\030\001 \001(\0162!.textsecur" +
+ "e.WebSocketMessage.Type\0224\n\007request\030\002 \001(\013" +
+ "2#.textsecure.WebSocketRequestMessage\0226\n" +
+ "\010response\030\003 \001(\0132$.textsecure.WebSocketRe",
+ "sponseMessage\".\n\004Type\022\013\n\007UNKNOWN\020\000\022\013\n\007RE" +
+ "QUEST\020\001\022\014\n\010RESPONSE\020\002B0\n.org.whispersyst" +
+ "ems.websocket.messages.protobuf"
+ };
+ com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_textsecure_WebSocketRequestMessage_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_textsecure_WebSocketRequestMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_WebSocketRequestMessage_descriptor,
+ new java.lang.String[] { "Verb", "Path", "Headers", "Body", "Id", });
+ internal_static_textsecure_WebSocketResponseMessage_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_textsecure_WebSocketResponseMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_WebSocketResponseMessage_descriptor,
+ new java.lang.String[] { "Id", "Status", "Message", "Headers", "Body", });
+ internal_static_textsecure_WebSocketMessage_descriptor =
+ getDescriptor().getMessageTypes().get(2);
+ internal_static_textsecure_WebSocketMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_WebSocketMessage_descriptor,
+ new java.lang.String[] { "Type", "Request", "Response", });
+ return null;
+ }
+ };
+ com.google.protobuf.Descriptors.FileDescriptor
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ }, assigner);
+ }
+
+ // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletInputStream.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletInputStream.java
new file mode 100644
index 0000000000000000000000000000000000000000..c35070857805bf23c3fc1ad838355fe87d721e63
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletInputStream.java
@@ -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) {
+
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletOutputStream.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletOutputStream.java
new file mode 100644
index 0000000000000000000000000000000000000000..4956da977c213c9db51b3feb4ab254f2169160ab
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/BufferingServletOutputStream.java
@@ -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) {
+
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableRequest.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5728b33884f73cf4ec10e4ed3c304cc4893b5ae6
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableRequest.java
@@ -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();
+ }
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableResponse.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..be1dbfb9a1ad8e1a63bb80d52a555b137a0d9de8
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/LoggableResponse.java
@@ -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) {
+
+ }
+ }
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletOutputStream.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletOutputStream.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e3a856cd2c8540e74fd28cb14caf433f5e951a8
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletOutputStream.java
@@ -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) {
+
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletResponse.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..6783d930764cd0e57337e8ae554c433a62438c90
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/NullServletResponse.java
@@ -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;
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletRequest.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletRequest.java
new file mode 100644
index 0000000000000000000000000000000000000000..014b514ac8eeb925d910b255d5804f51ac0c24f1
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletRequest.java
@@ -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;
+ }
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletResponse.java b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..6295bbfeae0ded9bf9fff67f4a5dd6cb018ede69
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/servlet/WebSocketServletResponse.java
@@ -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;
+ }
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSession.java b/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSession.java
new file mode 100644
index 0000000000000000000000000000000000000000..d0410f56d37d14c39fd8be7a3c7122bb846630c0
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSession.java
@@ -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 {
+}
+
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContext.java b/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContext.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fe00f153efea21640c0548bcd934bd2706ec9c4
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContext.java
@@ -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);
+ }
+
+
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContextValueFactoryProvider.java b/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContextValueFactoryProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..e451d20e784064c7428ab3231ac89cfc4e536ee0
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/session/WebSocketSessionContextValueFactoryProvider.java
@@ -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);
+ }
+ }
+}
\ No newline at end of file
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketConnectListener.java b/websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketConnectListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e4d82d6d633eb74c2a48f7aac93490ce0bb5683
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketConnectListener.java
@@ -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);
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketEnvironment.java b/websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketEnvironment.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ec1bacd56aa3f082598b5cbba5c894b81bce2c5
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/setup/WebSocketEnvironment.java
@@ -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;
+ }
+}
diff --git a/websocket-resources/src/main/java/org/whispersystems/websocket/util/Base64.java b/websocket-resources/src/main/java/org/whispersystems/websocket/util/Base64.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8170a9363a360422a318aca1849e016d8d382cb
--- /dev/null
+++ b/websocket-resources/src/main/java/org/whispersystems/websocket/util/Base64.java
@@ -0,0 +1,2096 @@
+package org.whispersystems.websocket.util;
+
+/**
+ * <p>Encodes and decodes to and from Base64 notation.</p>
+ * <p>Homepage: <a href="http://iharder.net/base64">http://iharder.net/base64</a>.</p>
+ *
+ * <p>Example:</p>
+ *
+ * <code>String encoded = Base64.encode( myByteArray );</code>
+ * <br />
+ * <code>byte[] myByteArray = Base64.decode( encoded );</code>
+ *
+ * <p>The <tt>options</tt> parameter, which appears in a few places, is used to pass
+ * several pieces of information to the encoder. In the "higher level" methods such as
+ * encodeBytes( bytes, options ) the options parameter can be used to indicate such
+ * things as first gzipping the bytes before encoding them, not inserting linefeeds,
+ * and encoding using the URL-safe and Ordered dialects.</p>
+ *
+ * <p>Note, according to <a href="http://www.faqs.org/rfcs/rfc3548.html">RFC3548</a>,
+ * Section 2.1, implementations should not add line feeds unless explicitly told
+ * to do so. I've got Base64 set to this behavior now, although earlier versions
+ * broke lines by default.</p>
+ *
+ * <p>The constants defined in Base64 can be OR-ed together to combine options, so you
+ * might make a call like this:</p>
+ *
+ * <code>String encoded = Base64.encodeBytes( mybytes, Base64.GZIP | Base64.DO_BREAK_LINES );</code>
+ * <p>to compress the data before encoding it and then making the output have newline characters.</p>
+ * <p>Also...</p>
+ * <code>String encoded = Base64.encodeBytes( crazyString.getBytes() );</code>
+ *
+ *
+ *
+ * <p>
+ * Change Log:
+ * </p>
+ * <ul>
+ * <li>v2.3.4 - Fixed bug when working with gzipped streams whereby flushing
+ * the Base64.OutputStream closed the Base64 encoding (by padding with equals
+ * signs) too soon. Also added an option to suppress the automatic decoding
+ * of gzipped streams. Also added experimental support for specifying a
+ * class loader when using the
+ * {@link #decodeToObject(String, int, ClassLoader)}
+ * method.</li>
+ * <li>v2.3.3 - Changed default char encoding to US-ASCII which reduces the internal Java
+ * footprint with its CharEncoders and so forth. Fixed some javadocs that were
+ * inconsistent. Removed imports and specified things like java.io.IOException
+ * explicitly inline.</li>
+ * <li>v2.3.2 - Reduced memory footprint! Finally refined the "guessing" of how big the
+ * final encoded data will be so that the code doesn't have to create two output
+ * arrays: an oversized initial one and then a final, exact-sized one. Big win
+ * when using the {@link #encodeBytesToBytes(byte[])} family of methods (and not
+ * using the gzip options which uses a different mechanism with streams and stuff).</li>
+ * <li>v2.3.1 - Added {@link #encodeBytesToBytes(byte[], int, int, int)} and some
+ * similar helper methods to be more efficient with memory by not returning a
+ * String but just a byte array.</li>
+ * <li>v2.3 - <strong>This is not a drop-in replacement!</strong> This is two years of comments
+ * and bug fixes queued up and finally executed. Thanks to everyone who sent
+ * me stuff, and I'm sorry I wasn't able to distribute your fixes to everyone else.
+ * Much bad coding was cleaned up including throwing exceptions where necessary
+ * instead of returning null values or something similar. Here are some changes
+ * that may affect you:
+ * <ul>
+ * <li><em>Does not break lines, by default.</em> This is to keep in compliance with
+ * <a href="http://www.faqs.org/rfcs/rfc3548.html">RFC3548</a>.</li>
+ * <li><em>Throws exceptions instead of returning null values.</em> Because some operations
+ * (especially those that may permit the GZIP option) use IO streams, there
+ * is a possiblity of an java.io.IOException being thrown. After some discussion and
+ * thought, I've changed the behavior of the methods to throw java.io.IOExceptions
+ * rather than return null if ever there's an error. I think this is more
+ * appropriate, though it will require some changes to your code. Sorry,
+ * it should have been done this way to begin with.</li>
+ * <li><em>Removed all references to System.out, System.err, and the like.</em>
+ * Shame on me. All I can say is sorry they were ever there.</li>
+ * <li><em>Throws NullPointerExceptions and IllegalArgumentExceptions</em> as needed
+ * such as when passed arrays are null or offsets are invalid.</li>
+ * <li>Cleaned up as much javadoc as I could to avoid any javadoc warnings.
+ * This was especially annoying before for people who were thorough in their
+ * own projects and then had gobs of javadoc warnings on this file.</li>
+ * </ul>
+ * <li>v2.2.1 - Fixed bug using URL_SAFE and ORDERED encodings. Fixed bug
+ * when using very small files (~< 40 bytes).</li>
+ * <li>v2.2 - Added some helper methods for encoding/decoding directly from
+ * one file to the next. Also added a main() method to support command line
+ * encoding/decoding from one file to the next. Also added these Base64 dialects:
+ * <ol>
+ * <li>The default is RFC3548 format.</li>
+ * <li>Calling Base64.setFormat(Base64.BASE64_FORMAT.URLSAFE_FORMAT) generates
+ * URL and file name friendly format as described in Section 4 of RFC3548.
+ * http://www.faqs.org/rfcs/rfc3548.html</li>
+ * <li>Calling Base64.setFormat(Base64.BASE64_FORMAT.ORDERED_FORMAT) generates
+ * URL and file name friendly format that preserves lexical ordering as described
+ * in http://www.faqs.org/qa/rfcc-1940.html</li>
+ * </ol>
+ * Special thanks to Jim Kellerman at <a href="http://www.powerset.com/">http://www.powerset.com/</a>
+ * for contributing the new Base64 dialects.
+ * </li>
+ *
+ * <li>v2.1 - Cleaned up javadoc comments and unused variables and methods. Added
+ * some convenience methods for reading and writing to and from files.</li>
+ * <li>v2.0.2 - Now specifies UTF-8 encoding in places where the code fails on systems
+ * with other encodings (like EBCDIC).</li>
+ * <li>v2.0.1 - Fixed an error when decoding a single byte, that is, when the
+ * encoded data was a single byte.</li>
+ * <li>v2.0 - I got rid of methods that used booleans to set options.
+ * Now everything is more consolidated and cleaner. The code now detects
+ * when data that's being decoded is gzip-compressed and will decompress it
+ * automatically. Generally things are cleaner. You'll probably have to
+ * change some method calls that you were making to support the new
+ * options format (<tt>int</tt>s that you "OR" together).</li>
+ * <li>v1.5.1 - Fixed bug when decompressing and decoding to a
+ * byte[] using <tt>decode( String s, boolean gzipCompressed )</tt>.
+ * Added the ability to "suspend" encoding in the Output Stream so
+ * you can turn on and off the encoding if you need to embed base64
+ * data in an otherwise "normal" stream (like an XML file).</li>
+ * <li>v1.5 - Output stream pases on flush() command but doesn't do anything itself.
+ * This helps when using GZIP streams.
+ * Added the ability to GZip-compress objects before encoding them.</li>
+ * <li>v1.4 - Added helper methods to read/write files.</li>
+ * <li>v1.3.6 - Fixed OutputStream.flush() so that 'position' is reset.</li>
+ * <li>v1.3.5 - Added flag to turn on and off line breaks. Fixed bug in input stream
+ * where last buffer being read, if not completely full, was not returned.</li>
+ * <li>v1.3.4 - Fixed when "improperly padded stream" error was thrown at the wrong time.</li>
+ * <li>v1.3.3 - Fixed I/O streams which were totally messed up.</li>
+ * </ul>
+ *
+ * <p>
+ * I am placing this code in the Public Domain. Do with it as you will.
+ * This software comes with no guarantees or warranties but with
+ * plenty of well-wishing instead!
+ * Please visit <a href="http://iharder.net/base64">http://iharder.net/base64</a>
+ * periodically to check for updates or to contribute improvements.
+ * </p>
+ *
+ * @author Robert Harder
+ * @author rob@iharder.net
+ * @version 2.3.3
+ */
+public class Base64
+{
+
+/* ******** P U B L I C F I E L D S ******** */
+
+
+ /** No options specified. Value is zero. */
+ public final static int NO_OPTIONS = 0;
+
+ /** Specify encoding in first bit. Value is one. */
+ public final static int ENCODE = 1;
+
+
+ /** Specify decoding in first bit. Value is zero. */
+ public final static int DECODE = 0;
+
+
+ /** Specify that data should be gzip-compressed in second bit. Value is two. */
+ public final static int GZIP = 2;
+
+ /** Specify that gzipped data should <em>not</em> be automatically gunzipped. */
+ public final static int DONT_GUNZIP = 4;
+
+
+ /** Do break lines when encoding. Value is 8. */
+ public final static int DO_BREAK_LINES = 8;
+
+ /**
+ * Encode using Base64-like encoding that is URL- and Filename-safe as described
+ * in Section 4 of RFC3548:
+ * <a href="http://www.faqs.org/rfcs/rfc3548.html">http://www.faqs.org/rfcs/rfc3548.html</a>.
+ * It is important to note that data encoded this way is <em>not</em> officially valid Base64,
+ * or at the very least should not be called Base64 without also specifying that is
+ * was encoded using the URL- and Filename-safe dialect.
+ */
+ public final static int URL_SAFE = 16;
+
+
+ /**
+ * Encode using the special "ordered" dialect of Base64 described here:
+ * <a href="http://www.faqs.org/qa/rfcc-1940.html">http://www.faqs.org/qa/rfcc-1940.html</a>.
+ */
+ public final static int ORDERED = 32;
+
+
+/* ******** P R I V A T E F I E L D S ******** */
+
+
+ /** Maximum line length (76) of Base64 output. */
+ private final static int MAX_LINE_LENGTH = 76;
+
+
+ /** The equals sign (=) as a byte. */
+ private final static byte EQUALS_SIGN = (byte)'=';
+
+
+ /** The new line character (\n) as a byte. */
+ private final static byte NEW_LINE = (byte)'\n';
+
+
+ /** Preferred encoding. */
+ private final static String PREFERRED_ENCODING = "US-ASCII";
+
+
+ private final static byte WHITE_SPACE_ENC = -5; // Indicates white space in encoding
+ private final static byte EQUALS_SIGN_ENC = -1; // Indicates equals sign in encoding
+
+
+/* ******** S T A N D A R D B A S E 6 4 A L P H A B E T ******** */
+
+ /** The 64 valid Base64 values. */
+ /* Host platform me be something funny like EBCDIC, so we hardcode these values. */
+ private final static byte[] _STANDARD_ALPHABET = {
+ (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
+ (byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
+ (byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
+ (byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
+ (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
+ (byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
+ (byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
+ (byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',
+ (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',
+ (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'+', (byte)'/'
+ };
+
+
+ /**
+ * Translates a Base64 value to either its 6-bit reconstruction value
+ * or a negative number indicating some other meaning.
+ **/
+ private final static byte[] _STANDARD_DECODABET = {
+ -9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 0 - 8
+ -5,-5, // Whitespace: Tab and Linefeed
+ -9,-9, // Decimal 11 - 12
+ -5, // Whitespace: Carriage Return
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 14 - 26
+ -9,-9,-9,-9,-9, // Decimal 27 - 31
+ -5, // Whitespace: Space
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 33 - 42
+ 62, // Plus sign at decimal 43
+ -9,-9,-9, // Decimal 44 - 46
+ 63, // Slash at decimal 47
+ 52,53,54,55,56,57,58,59,60,61, // Numbers zero through nine
+ -9,-9,-9, // Decimal 58 - 60
+ -1, // Equals sign at decimal 61
+ -9,-9,-9, // Decimal 62 - 64
+ 0,1,2,3,4,5,6,7,8,9,10,11,12,13, // Letters 'A' through 'N'
+ 14,15,16,17,18,19,20,21,22,23,24,25, // Letters 'O' through 'Z'
+ -9,-9,-9,-9,-9,-9, // Decimal 91 - 96
+ 26,27,28,29,30,31,32,33,34,35,36,37,38, // Letters 'a' through 'm'
+ 39,40,41,42,43,44,45,46,47,48,49,50,51, // Letters 'n' through 'z'
+ -9,-9,-9,-9 // Decimal 123 - 126
+ /*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 127 - 139
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 140 - 152
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 153 - 165
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 166 - 178
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 179 - 191
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 192 - 204
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 205 - 217
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 218 - 230
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 231 - 243
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9 // Decimal 244 - 255 */
+ };
+
+
+/* ******** U R L S A F E B A S E 6 4 A L P H A B E T ******** */
+
+ /**
+ * Used in the URL- and Filename-safe dialect described in Section 4 of RFC3548:
+ * <a href="http://www.faqs.org/rfcs/rfc3548.html">http://www.faqs.org/rfcs/rfc3548.html</a>.
+ * Notice that the last two bytes become "hyphen" and "underscore" instead of "plus" and "slash."
+ */
+ private final static byte[] _URL_SAFE_ALPHABET = {
+ (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
+ (byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
+ (byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
+ (byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
+ (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
+ (byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
+ (byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
+ (byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',
+ (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',
+ (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'-', (byte)'_'
+ };
+
+ /**
+ * Used in decoding URL- and Filename-safe dialects of Base64.
+ */
+ private final static byte[] _URL_SAFE_DECODABET = {
+ -9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 0 - 8
+ -5,-5, // Whitespace: Tab and Linefeed
+ -9,-9, // Decimal 11 - 12
+ -5, // Whitespace: Carriage Return
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 14 - 26
+ -9,-9,-9,-9,-9, // Decimal 27 - 31
+ -5, // Whitespace: Space
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 33 - 42
+ -9, // Plus sign at decimal 43
+ -9, // Decimal 44
+ 62, // Minus sign at decimal 45
+ -9, // Decimal 46
+ -9, // Slash at decimal 47
+ 52,53,54,55,56,57,58,59,60,61, // Numbers zero through nine
+ -9,-9,-9, // Decimal 58 - 60
+ -1, // Equals sign at decimal 61
+ -9,-9,-9, // Decimal 62 - 64
+ 0,1,2,3,4,5,6,7,8,9,10,11,12,13, // Letters 'A' through 'N'
+ 14,15,16,17,18,19,20,21,22,23,24,25, // Letters 'O' through 'Z'
+ -9,-9,-9,-9, // Decimal 91 - 94
+ 63, // Underscore at decimal 95
+ -9, // Decimal 96
+ 26,27,28,29,30,31,32,33,34,35,36,37,38, // Letters 'a' through 'm'
+ 39,40,41,42,43,44,45,46,47,48,49,50,51, // Letters 'n' through 'z'
+ -9,-9,-9,-9 // Decimal 123 - 126
+ /*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 127 - 139
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 140 - 152
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 153 - 165
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 166 - 178
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 179 - 191
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 192 - 204
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 205 - 217
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 218 - 230
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 231 - 243
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9 // Decimal 244 - 255 */
+ };
+
+
+
+/* ******** O R D E R E D B A S E 6 4 A L P H A B E T ******** */
+
+ /**
+ * I don't get the point of this technique, but someone requested it,
+ * and it is described here:
+ * <a href="http://www.faqs.org/qa/rfcc-1940.html">http://www.faqs.org/qa/rfcc-1940.html</a>.
+ */
+ private final static byte[] _ORDERED_ALPHABET = {
+ (byte)'-',
+ (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4',
+ (byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9',
+ (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
+ (byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
+ (byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
+ (byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
+ (byte)'_',
+ (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
+ (byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
+ (byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
+ (byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z'
+ };
+
+ /**
+ * Used in decoding the "ordered" dialect of Base64.
+ */
+ private final static byte[] _ORDERED_DECODABET = {
+ -9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 0 - 8
+ -5,-5, // Whitespace: Tab and Linefeed
+ -9,-9, // Decimal 11 - 12
+ -5, // Whitespace: Carriage Return
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 14 - 26
+ -9,-9,-9,-9,-9, // Decimal 27 - 31
+ -5, // Whitespace: Space
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 33 - 42
+ -9, // Plus sign at decimal 43
+ -9, // Decimal 44
+ 0, // Minus sign at decimal 45
+ -9, // Decimal 46
+ -9, // Slash at decimal 47
+ 1,2,3,4,5,6,7,8,9,10, // Numbers zero through nine
+ -9,-9,-9, // Decimal 58 - 60
+ -1, // Equals sign at decimal 61
+ -9,-9,-9, // Decimal 62 - 64
+ 11,12,13,14,15,16,17,18,19,20,21,22,23, // Letters 'A' through 'M'
+ 24,25,26,27,28,29,30,31,32,33,34,35,36, // Letters 'N' through 'Z'
+ -9,-9,-9,-9, // Decimal 91 - 94
+ 37, // Underscore at decimal 95
+ -9, // Decimal 96
+ 38,39,40,41,42,43,44,45,46,47,48,49,50, // Letters 'a' through 'm'
+ 51,52,53,54,55,56,57,58,59,60,61,62,63, // Letters 'n' through 'z'
+ -9,-9,-9,-9 // Decimal 123 - 126
+ /*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 127 - 139
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 140 - 152
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 153 - 165
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 166 - 178
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 179 - 191
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 192 - 204
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 205 - 217
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 218 - 230
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 231 - 243
+ -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9 // Decimal 244 - 255 */
+ };
+
+
+/* ******** D E T E R M I N E W H I C H A L H A B E T ******** */
+
+
+ /**
+ * Returns one of the _SOMETHING_ALPHABET byte arrays depending on
+ * the options specified.
+ * It's possible, though silly, to specify ORDERED <b>and</b> URLSAFE
+ * in which case one of them will be picked, though there is
+ * no guarantee as to which one will be picked.
+ */
+ private final static byte[] getAlphabet( int options ) {
+ if ((options & URL_SAFE) == URL_SAFE) {
+ return _URL_SAFE_ALPHABET;
+ } else if ((options & ORDERED) == ORDERED) {
+ return _ORDERED_ALPHABET;
+ } else {
+ return _STANDARD_ALPHABET;
+ }
+ } // end getAlphabet
+
+
+ /**
+ * Returns one of the _SOMETHING_DECODABET byte arrays depending on
+ * the options specified.
+ * It's possible, though silly, to specify ORDERED and URL_SAFE
+ * in which case one of them will be picked, though there is
+ * no guarantee as to which one will be picked.
+ */
+ private final static byte[] getDecodabet( int options ) {
+ if( (options & URL_SAFE) == URL_SAFE) {
+ return _URL_SAFE_DECODABET;
+ } else if ((options & ORDERED) == ORDERED) {
+ return _ORDERED_DECODABET;
+ } else {
+ return _STANDARD_DECODABET;
+ }
+ } // end getAlphabet
+
+
+
+ /** Defeats instantiation. */
+ private Base64(){}
+
+
+
+ public static int getEncodedLengthWithoutPadding(int unencodedLength) {
+ int remainderBytes = unencodedLength % 3;
+ int paddingBytes = 0;
+
+ if (remainderBytes != 0)
+ paddingBytes = 3 - remainderBytes;
+
+ return (((int)((unencodedLength+2)/3))*4) - paddingBytes;
+ }
+
+ public static int getEncodedBytesForTarget(int targetSize) {
+ return ((int)(targetSize * 3)) / 4;
+ }
+
+
+/* ******** E N C O D I N G M E T H O D S ******** */
+
+
+ /**
+ * Encodes up to the first three bytes of array <var>threeBytes</var>
+ * and returns a four-byte array in Base64 notation.
+ * The actual number of significant bytes in your array is
+ * given by <var>numSigBytes</var>.
+ * The array <var>threeBytes</var> needs only be as big as
+ * <var>numSigBytes</var>.
+ * Code can reuse a byte array by passing a four-byte array as <var>b4</var>.
+ *
+ * @param b4 A reusable byte array to reduce array instantiation
+ * @param threeBytes the array to convert
+ * @param numSigBytes the number of significant bytes in your array
+ * @return four byte array in Base64 notation.
+ * @since 1.5.1
+ */
+ private static byte[] encode3to4( byte[] b4, byte[] threeBytes, int numSigBytes, int options ) {
+ encode3to4( threeBytes, 0, numSigBytes, b4, 0, options );
+ return b4;
+ } // end encode3to4
+
+
+ /**
+ * <p>Encodes up to three bytes of the array <var>source</var>
+ * and writes the resulting four Base64 bytes to <var>destination</var>.
+ * The source and destination arrays can be manipulated
+ * anywhere along their length by specifying
+ * <var>srcOffset</var> and <var>destOffset</var>.
+ * This method does not check to make sure your arrays
+ * are large enough to accomodate <var>srcOffset</var> + 3 for
+ * the <var>source</var> array or <var>destOffset</var> + 4 for
+ * the <var>destination</var> array.
+ * The actual number of significant bytes in your array is
+ * given by <var>numSigBytes</var>.</p>
+ * <p>This is the lowest level of the encoding methods with
+ * all possible parameters.</p>
+ *
+ * @param source the array to convert
+ * @param srcOffset the index where conversion begins
+ * @param numSigBytes the number of significant bytes in your array
+ * @param destination the array to hold the conversion
+ * @param destOffset the index where output will be put
+ * @return the <var>destination</var> array
+ * @since 1.3
+ */
+ private static byte[] encode3to4(
+ byte[] source, int srcOffset, int numSigBytes,
+ byte[] destination, int destOffset, int options ) {
+
+ byte[] ALPHABET = getAlphabet( options );
+
+ // 1 2 3
+ // 01234567890123456789012345678901 Bit position
+ // --------000000001111111122222222 Array position from threeBytes
+ // --------| || || || | Six bit groups to index ALPHABET
+ // >>18 >>12 >> 6 >> 0 Right shift necessary
+ // 0x3f 0x3f 0x3f Additional AND
+
+ // Create buffer with zero-padding if there are only one or two
+ // significant bytes passed in the array.
+ // We have to shift left 24 in order to flush out the 1's that appear
+ // when Java treats a value as negative that is cast from a byte to an int.
+ int inBuff = ( numSigBytes > 0 ? ((source[ srcOffset ] << 24) >>> 8) : 0 )
+ | ( numSigBytes > 1 ? ((source[ srcOffset + 1 ] << 24) >>> 16) : 0 )
+ | ( numSigBytes > 2 ? ((source[ srcOffset + 2 ] << 24) >>> 24) : 0 );
+
+ switch( numSigBytes )
+ {
+ case 3:
+ destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];
+ destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];
+ destination[ destOffset + 2 ] = ALPHABET[ (inBuff >>> 6) & 0x3f ];
+ destination[ destOffset + 3 ] = ALPHABET[ (inBuff ) & 0x3f ];
+ return destination;
+
+ case 2:
+ destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];
+ destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];
+ destination[ destOffset + 2 ] = ALPHABET[ (inBuff >>> 6) & 0x3f ];
+ destination[ destOffset + 3 ] = EQUALS_SIGN;
+ return destination;
+
+ case 1:
+ destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];
+ destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];
+ destination[ destOffset + 2 ] = EQUALS_SIGN;
+ destination[ destOffset + 3 ] = EQUALS_SIGN;
+ return destination;
+
+ default:
+ return destination;
+ } // end switch
+ } // end encode3to4
+
+
+
+ /**
+ * Performs Base64 encoding on the <code>raw</code> ByteBuffer,
+ * writing it to the <code>encoded</code> ByteBuffer.
+ * This is an experimental feature. Currently it does not
+ * pass along any options (such as {@link #DO_BREAK_LINES}
+ * or {@link #GZIP}.
+ *
+ * @param raw input buffer
+ * @param encoded output buffer
+ * @since 2.3
+ */
+ public static void encode( java.nio.ByteBuffer raw, java.nio.ByteBuffer encoded ){
+ byte[] raw3 = new byte[3];
+ byte[] enc4 = new byte[4];
+
+ while( raw.hasRemaining() ){
+ int rem = Math.min(3,raw.remaining());
+ raw.get(raw3,0,rem);
+ Base64.encode3to4(enc4, raw3, rem, Base64.NO_OPTIONS );
+ encoded.put(enc4);
+ } // end input remaining
+ }
+
+
+ /**
+ * Performs Base64 encoding on the <code>raw</code> ByteBuffer,
+ * writing it to the <code>encoded</code> CharBuffer.
+ * This is an experimental feature. Currently it does not
+ * pass along any options (such as {@link #DO_BREAK_LINES}
+ * or {@link #GZIP}.
+ *
+ * @param raw input buffer
+ * @param encoded output buffer
+ * @since 2.3
+ */
+ public static void encode( java.nio.ByteBuffer raw, java.nio.CharBuffer encoded ){
+ byte[] raw3 = new byte[3];
+ byte[] enc4 = new byte[4];
+
+ while( raw.hasRemaining() ){
+ int rem = Math.min(3,raw.remaining());
+ raw.get(raw3,0,rem);
+ Base64.encode3to4(enc4, raw3, rem, Base64.NO_OPTIONS );
+ for( int i = 0; i < 4; i++ ){
+ encoded.put( (char)(enc4[i] & 0xFF) );
+ }
+ } // end input remaining
+ }
+
+
+
+
+ /**
+ * Serializes an object and returns the Base64-encoded
+ * version of that serialized object.
+ *
+ * <p>As of v 2.3, if the object
+ * cannot be serialized or there is another error,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned a null value, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ * The object is not GZip-compressed before being encoded.
+ *
+ * @param serializableObject The object to encode
+ * @return The Base64-encoded object
+ * @throws java.io.IOException if there is an error
+ * @throws NullPointerException if serializedObject is null
+ * @since 1.4
+ */
+ public static String encodeObject( java.io.Serializable serializableObject )
+ throws java.io.IOException {
+ return encodeObject( serializableObject, NO_OPTIONS );
+ } // end encodeObject
+
+
+
+ /**
+ * Serializes an object and returns the Base64-encoded
+ * version of that serialized object.
+ *
+ * <p>As of v 2.3, if the object
+ * cannot be serialized or there is another error,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned a null value, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ * The object is not GZip-compressed before being encoded.
+ * <p>
+ * Example options:<pre>
+ * GZIP: gzip-compresses object before encoding it.
+ * DO_BREAK_LINES: break lines at 76 characters
+ * </pre>
+ * <p>
+ * Example: <code>encodeObject( myObj, Base64.GZIP )</code> or
+ * <p>
+ * Example: <code>encodeObject( myObj, Base64.GZIP | Base64.DO_BREAK_LINES )</code>
+ *
+ * @param serializableObject The object to encode
+ * @param options Specified options
+ * @return The Base64-encoded object
+ * @see Base64#GZIP
+ * @see Base64#DO_BREAK_LINES
+ * @throws java.io.IOException if there is an error
+ * @since 2.0
+ */
+ public static String encodeObject( java.io.Serializable serializableObject, int options )
+ throws java.io.IOException {
+
+ if( serializableObject == null ){
+ throw new NullPointerException( "Cannot serialize a null object." );
+ } // end if: null
+
+ // Streams
+ java.io.ByteArrayOutputStream baos = null;
+ java.io.OutputStream b64os = null;
+ java.util.zip.GZIPOutputStream gzos = null;
+ java.io.ObjectOutputStream oos = null;
+
+
+ try {
+ // ObjectOutputStream -> (GZIP) -> Base64 -> ByteArrayOutputStream
+ baos = new java.io.ByteArrayOutputStream();
+ b64os = new Base64.OutputStream( baos, ENCODE | options );
+ if( (options & GZIP) != 0 ){
+ // Gzip
+ gzos = new java.util.zip.GZIPOutputStream(b64os);
+ oos = new java.io.ObjectOutputStream( gzos );
+ } else {
+ // Not gzipped
+ oos = new java.io.ObjectOutputStream( b64os );
+ }
+ oos.writeObject( serializableObject );
+ } // end try
+ catch( java.io.IOException e ) {
+ // Catch it and then throw it immediately so that
+ // the finally{} block is called for cleanup.
+ throw e;
+ } // end catch
+ finally {
+ try{ oos.close(); } catch( Exception e ){}
+ try{ gzos.close(); } catch( Exception e ){}
+ try{ b64os.close(); } catch( Exception e ){}
+ try{ baos.close(); } catch( Exception e ){}
+ } // end finally
+
+ // Return value according to relevant encoding.
+ try {
+ return new String( baos.toByteArray(), PREFERRED_ENCODING );
+ } // end try
+ catch (java.io.UnsupportedEncodingException uue){
+ // Fall back to some Java default
+ return new String( baos.toByteArray() );
+ } // end catch
+
+ } // end encode
+
+
+
+ /**
+ * Encodes a byte array into Base64 notation.
+ * Does not GZip-compress data.
+ *
+ * @param source The data to convert
+ * @return The data in Base64-encoded form
+ * @throws NullPointerException if source array is null
+ * @since 1.4
+ */
+ public static String encodeBytes( byte[] source ) {
+ // Since we're not going to have the GZIP encoding turned on,
+ // we're not going to have an java.io.IOException thrown, so
+ // we should not force the user to have to catch it.
+ String encoded = null;
+ try {
+ encoded = encodeBytes(source, 0, source.length, NO_OPTIONS);
+ } catch (java.io.IOException ex) {
+ assert false : ex.getMessage();
+ } // end catch
+ assert encoded != null;
+ return encoded;
+ } // end encodeBytes
+
+
+ public static String encodeBytesWithoutPadding(byte[] source, int offset, int length) {
+ String encoded = null;
+
+ try {
+ encoded = encodeBytes(source, offset, length, NO_OPTIONS);
+ } catch (java.io.IOException ex) {
+ assert false : ex.getMessage();
+ }
+
+ assert encoded != null;
+
+ if (encoded.charAt(encoded.length()-2) == '=') return encoded.substring(0, encoded.length()-2);
+ else if (encoded.charAt(encoded.length()-1) == '=') return encoded.substring(0, encoded.length()-1);
+ else return encoded;
+
+ }
+
+ public static String encodeBytesWithoutPadding(byte[] source) {
+ return encodeBytesWithoutPadding(source, 0, source.length);
+ }
+
+
+ /**
+ * Encodes a byte array into Base64 notation.
+ * <p>
+ * Example options:<pre>
+ * GZIP: gzip-compresses object before encoding it.
+ * DO_BREAK_LINES: break lines at 76 characters
+ * <i>Note: Technically, this makes your encoding non-compliant.</i>
+ * </pre>
+ * <p>
+ * Example: <code>encodeBytes( myData, Base64.GZIP )</code> or
+ * <p>
+ * Example: <code>encodeBytes( myData, Base64.GZIP | Base64.DO_BREAK_LINES )</code>
+ *
+ *
+ * <p>As of v 2.3, if there is an error with the GZIP stream,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned a null value, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ *
+ * @param source The data to convert
+ * @param options Specified options
+ * @return The Base64-encoded data as a String
+ * @see Base64#GZIP
+ * @see Base64#DO_BREAK_LINES
+ * @throws java.io.IOException if there is an error
+ * @throws NullPointerException if source array is null
+ * @since 2.0
+ */
+ public static String encodeBytes( byte[] source, int options ) throws java.io.IOException {
+ return encodeBytes( source, 0, source.length, options );
+ } // end encodeBytes
+
+
+ /**
+ * Encodes a byte array into Base64 notation.
+ * Does not GZip-compress data.
+ *
+ * <p>As of v 2.3, if there is an error,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned a null value, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ *
+ * @param source The data to convert
+ * @param off Offset in array where conversion should begin
+ * @param len Length of data to convert
+ * @return The Base64-encoded data as a String
+ * @throws NullPointerException if source array is null
+ * @throws IllegalArgumentException if source array, offset, or length are invalid
+ * @since 1.4
+ */
+ public static String encodeBytes( byte[] source, int off, int len ) {
+ // Since we're not going to have the GZIP encoding turned on,
+ // we're not going to have an java.io.IOException thrown, so
+ // we should not force the user to have to catch it.
+ String encoded = null;
+ try {
+ encoded = encodeBytes( source, off, len, NO_OPTIONS );
+ } catch (java.io.IOException ex) {
+ assert false : ex.getMessage();
+ } // end catch
+ assert encoded != null;
+ return encoded;
+ } // end encodeBytes
+
+
+
+ /**
+ * Encodes a byte array into Base64 notation.
+ * <p>
+ * Example options:<pre>
+ * GZIP: gzip-compresses object before encoding it.
+ * DO_BREAK_LINES: break lines at 76 characters
+ * <i>Note: Technically, this makes your encoding non-compliant.</i>
+ * </pre>
+ * <p>
+ * Example: <code>encodeBytes( myData, Base64.GZIP )</code> or
+ * <p>
+ * Example: <code>encodeBytes( myData, Base64.GZIP | Base64.DO_BREAK_LINES )</code>
+ *
+ *
+ * <p>As of v 2.3, if there is an error with the GZIP stream,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned a null value, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ *
+ * @param source The data to convert
+ * @param off Offset in array where conversion should begin
+ * @param len Length of data to convert
+ * @param options Specified options
+ * @return The Base64-encoded data as a String
+ * @see Base64#GZIP
+ * @see Base64#DO_BREAK_LINES
+ * @throws java.io.IOException if there is an error
+ * @throws NullPointerException if source array is null
+ * @throws IllegalArgumentException if source array, offset, or length are invalid
+ * @since 2.0
+ */
+ public static String encodeBytes( byte[] source, int off, int len, int options ) throws java.io.IOException {
+ byte[] encoded = encodeBytesToBytes( source, off, len, options );
+
+ // Return value according to relevant encoding.
+ try {
+ return new String( encoded, PREFERRED_ENCODING );
+ } // end try
+ catch (java.io.UnsupportedEncodingException uue) {
+ return new String( encoded );
+ } // end catch
+
+ } // end encodeBytes
+
+
+
+
+ /**
+ * Similar to {@link #encodeBytes(byte[])} but returns
+ * a byte array instead of instantiating a String. This is more efficient
+ * if you're working with I/O streams and have large data sets to encode.
+ *
+ *
+ * @param source The data to convert
+ * @return The Base64-encoded data as a byte[] (of ASCII characters)
+ * @throws NullPointerException if source array is null
+ * @since 2.3.1
+ */
+ public static byte[] encodeBytesToBytes( byte[] source ) {
+ byte[] encoded = null;
+ try {
+ encoded = encodeBytesToBytes( source, 0, source.length, Base64.NO_OPTIONS );
+ } catch( java.io.IOException ex ) {
+ assert false : "IOExceptions only come from GZipping, which is turned off: " + ex.getMessage();
+ }
+ return encoded;
+ }
+
+
+ /**
+ * Similar to {@link #encodeBytes(byte[], int, int, int)} but returns
+ * a byte array instead of instantiating a String. This is more efficient
+ * if you're working with I/O streams and have large data sets to encode.
+ *
+ *
+ * @param source The data to convert
+ * @param off Offset in array where conversion should begin
+ * @param len Length of data to convert
+ * @param options Specified options
+ * @return The Base64-encoded data as a String
+ * @see Base64#GZIP
+ * @see Base64#DO_BREAK_LINES
+ * @throws java.io.IOException if there is an error
+ * @throws NullPointerException if source array is null
+ * @throws IllegalArgumentException if source array, offset, or length are invalid
+ * @since 2.3.1
+ */
+ public static byte[] encodeBytesToBytes( byte[] source, int off, int len, int options ) throws java.io.IOException {
+
+ if( source == null ){
+ throw new NullPointerException( "Cannot serialize a null array." );
+ } // end if: null
+
+ if( off < 0 ){
+ throw new IllegalArgumentException( "Cannot have negative offset: " + off );
+ } // end if: off < 0
+
+ if( len < 0 ){
+ throw new IllegalArgumentException( "Cannot have length offset: " + len );
+ } // end if: len < 0
+
+ if( off + len > source.length ){
+ throw new IllegalArgumentException(
+ String.format( "Cannot have offset of %d and length of %d with array of length %d", off,len,source.length));
+ } // end if: off < 0
+
+
+
+ // Compress?
+ if( (options & GZIP) != 0 ) {
+ java.io.ByteArrayOutputStream baos = null;
+ java.util.zip.GZIPOutputStream gzos = null;
+ Base64.OutputStream b64os = null;
+
+ try {
+ // GZip -> Base64 -> ByteArray
+ baos = new java.io.ByteArrayOutputStream();
+ b64os = new Base64.OutputStream( baos, ENCODE | options );
+ gzos = new java.util.zip.GZIPOutputStream( b64os );
+
+ gzos.write( source, off, len );
+ gzos.close();
+ } // end try
+ catch( java.io.IOException e ) {
+ // Catch it and then throw it immediately so that
+ // the finally{} block is called for cleanup.
+ throw e;
+ } // end catch
+ finally {
+ try{ gzos.close(); } catch( Exception e ){}
+ try{ b64os.close(); } catch( Exception e ){}
+ try{ baos.close(); } catch( Exception e ){}
+ } // end finally
+
+ return baos.toByteArray();
+ } // end if: compress
+
+ // Else, don't compress. Better not to use streams at all then.
+ else {
+ boolean breakLines = (options & DO_BREAK_LINES) > 0;
+
+ //int len43 = len * 4 / 3;
+ //byte[] outBuff = new byte[ ( len43 ) // Main 4:3
+ // + ( (len % 3) > 0 ? 4 : 0 ) // Account for padding
+ // + (breakLines ? ( len43 / MAX_LINE_LENGTH ) : 0) ]; // New lines
+ // Try to determine more precisely how big the array needs to be.
+ // If we get it right, we don't have to do an array copy, and
+ // we save a bunch of memory.
+ int encLen = ( len / 3 ) * 4 + ( len % 3 > 0 ? 4 : 0 ); // Bytes needed for actual encoding
+ if( breakLines ){
+ encLen += encLen / MAX_LINE_LENGTH; // Plus extra newline characters
+ }
+ byte[] outBuff = new byte[ encLen ];
+
+
+ int d = 0;
+ int e = 0;
+ int len2 = len - 2;
+ int lineLength = 0;
+ for( ; d < len2; d+=3, e+=4 ) {
+ encode3to4( source, d+off, 3, outBuff, e, options );
+
+ lineLength += 4;
+ if( breakLines && lineLength >= MAX_LINE_LENGTH )
+ {
+ outBuff[e+4] = NEW_LINE;
+ e++;
+ lineLength = 0;
+ } // end if: end of line
+ } // en dfor: each piece of array
+
+ if( d < len ) {
+ encode3to4( source, d+off, len - d, outBuff, e, options );
+ e += 4;
+ } // end if: some padding needed
+
+
+ // Only resize array if we didn't guess it right.
+ if( e < outBuff.length - 1 ){
+ byte[] finalOut = new byte[e];
+ System.arraycopy(outBuff,0, finalOut,0,e);
+ //System.err.println("Having to resize array from " + outBuff.length + " to " + e );
+ return finalOut;
+ } else {
+ //System.err.println("No need to resize array.");
+ return outBuff;
+ }
+
+ } // end else: don't compress
+
+ } // end encodeBytesToBytes
+
+
+
+
+
+/* ******** D E C O D I N G M E T H O D S ******** */
+
+
+ /**
+ * Decodes four bytes from array <var>source</var>
+ * and writes the resulting bytes (up to three of them)
+ * to <var>destination</var>.
+ * The source and destination arrays can be manipulated
+ * anywhere along their length by specifying
+ * <var>srcOffset</var> and <var>destOffset</var>.
+ * This method does not check to make sure your arrays
+ * are large enough to accomodate <var>srcOffset</var> + 4 for
+ * the <var>source</var> array or <var>destOffset</var> + 3 for
+ * the <var>destination</var> array.
+ * This method returns the actual number of bytes that
+ * were converted from the Base64 encoding.
+ * <p>This is the lowest level of the decoding methods with
+ * all possible parameters.</p>
+ *
+ *
+ * @param source the array to convert
+ * @param srcOffset the index where conversion begins
+ * @param destination the array to hold the conversion
+ * @param destOffset the index where output will be put
+ * @param options alphabet type is pulled from this (standard, url-safe, ordered)
+ * @return the number of decoded bytes converted
+ * @throws NullPointerException if source or destination arrays are null
+ * @throws IllegalArgumentException if srcOffset or destOffset are invalid
+ * or there is not enough room in the array.
+ * @since 1.3
+ */
+ private static int decode4to3(
+ byte[] source, int srcOffset,
+ byte[] destination, int destOffset, int options ) {
+
+ // Lots of error checking and exception throwing
+ if( source == null ){
+ throw new NullPointerException( "Source array was null." );
+ } // end if
+ if( destination == null ){
+ throw new NullPointerException( "Destination array was null." );
+ } // end if
+ if( srcOffset < 0 || srcOffset + 3 >= source.length ){
+ throw new IllegalArgumentException( String.format(
+ "Source array with length %d cannot have offset of %d and still process four bytes.", source.length, srcOffset ) );
+ } // end if
+ if( destOffset < 0 || destOffset +2 >= destination.length ){
+ throw new IllegalArgumentException( String.format(
+ "Destination array with length %d cannot have offset of %d and still store three bytes.", destination.length, destOffset ) );
+ } // end if
+
+
+ byte[] DECODABET = getDecodabet( options );
+
+ // Example: Dk==
+ if( source[ srcOffset + 2] == EQUALS_SIGN ) {
+ // Two ways to do the same thing. Don't know which way I like best.
+ //int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 )
+ // | ( ( DECODABET[ source[ srcOffset + 1] ] << 24 ) >>> 12 );
+ int outBuff = ( ( DECODABET[ source[ srcOffset ] ] & 0xFF ) << 18 )
+ | ( ( DECODABET[ source[ srcOffset + 1] ] & 0xFF ) << 12 );
+
+ destination[ destOffset ] = (byte)( outBuff >>> 16 );
+ return 1;
+ }
+
+ // Example: DkL=
+ else if( source[ srcOffset + 3 ] == EQUALS_SIGN ) {
+ // Two ways to do the same thing. Don't know which way I like best.
+ //int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 )
+ // | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 )
+ // | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 );
+ int outBuff = ( ( DECODABET[ source[ srcOffset ] ] & 0xFF ) << 18 )
+ | ( ( DECODABET[ source[ srcOffset + 1 ] ] & 0xFF ) << 12 )
+ | ( ( DECODABET[ source[ srcOffset + 2 ] ] & 0xFF ) << 6 );
+
+ destination[ destOffset ] = (byte)( outBuff >>> 16 );
+ destination[ destOffset + 1 ] = (byte)( outBuff >>> 8 );
+ return 2;
+ }
+
+ // Example: DkLE
+ else {
+ // Two ways to do the same thing. Don't know which way I like best.
+ //int outBuff = ( ( DECODABET[ source[ srcOffset ] ] << 24 ) >>> 6 )
+ // | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 )
+ // | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 )
+ // | ( ( DECODABET[ source[ srcOffset + 3 ] ] << 24 ) >>> 24 );
+ int outBuff = ( ( DECODABET[ source[ srcOffset ] ] & 0xFF ) << 18 )
+ | ( ( DECODABET[ source[ srcOffset + 1 ] ] & 0xFF ) << 12 )
+ | ( ( DECODABET[ source[ srcOffset + 2 ] ] & 0xFF ) << 6)
+ | ( ( DECODABET[ source[ srcOffset + 3 ] ] & 0xFF ) );
+
+
+ destination[ destOffset ] = (byte)( outBuff >> 16 );
+ destination[ destOffset + 1 ] = (byte)( outBuff >> 8 );
+ destination[ destOffset + 2 ] = (byte)( outBuff );
+
+ return 3;
+ }
+ } // end decodeToBytes
+
+
+
+
+
+ /**
+ * Low-level access to decoding ASCII characters in
+ * the form of a byte array. <strong>Ignores GUNZIP option, if
+ * it's set.</strong> This is not generally a recommended method,
+ * although it is used internally as part of the decoding process.
+ * Special case: if len = 0, an empty array is returned. Still,
+ * if you need more speed and reduced memory footprint (and aren't
+ * gzipping), consider this method.
+ *
+ * @param source The Base64 encoded data
+ * @return decoded data
+ * @since 2.3.1
+ */
+ public static byte[] decode( byte[] source ){
+ byte[] decoded = null;
+ try {
+ decoded = decode( source, 0, source.length, Base64.NO_OPTIONS );
+ } catch( java.io.IOException ex ) {
+ assert false : "IOExceptions only come from GZipping, which is turned off: " + ex.getMessage();
+ }
+ return decoded;
+ }
+
+
+ /**
+ * Low-level access to decoding ASCII characters in
+ * the form of a byte array. <strong>Ignores GUNZIP option, if
+ * it's set.</strong> This is not generally a recommended method,
+ * although it is used internally as part of the decoding process.
+ * Special case: if len = 0, an empty array is returned. Still,
+ * if you need more speed and reduced memory footprint (and aren't
+ * gzipping), consider this method.
+ *
+ * @param source The Base64 encoded data
+ * @param off The offset of where to begin decoding
+ * @param len The length of characters to decode
+ * @param options Can specify options such as alphabet type to use
+ * @return decoded data
+ * @throws java.io.IOException If bogus characters exist in source data
+ * @since 1.3
+ */
+ public static byte[] decode( byte[] source, int off, int len, int options )
+ throws java.io.IOException {
+
+ // Lots of error checking and exception throwing
+ if( source == null ){
+ throw new NullPointerException( "Cannot decode null source array." );
+ } // end if
+ if( off < 0 || off + len > source.length ){
+ throw new IllegalArgumentException( String.format(
+ "Source array with length %d cannot have offset of %d and process %d bytes.", source.length, off, len ) );
+ } // end if
+
+ if( len == 0 ){
+ return new byte[0];
+ }else if( len < 4 ){
+ throw new IllegalArgumentException(
+ "Base64-encoded string must have at least four characters, but length specified was " + len );
+ } // end if
+
+ byte[] DECODABET = getDecodabet( options );
+
+ int len34 = len * 3 / 4; // Estimate on array size
+ byte[] outBuff = new byte[ len34 ]; // Upper limit on size of output
+ int outBuffPosn = 0; // Keep track of where we're writing
+
+ byte[] b4 = new byte[4]; // Four byte buffer from source, eliminating white space
+ int b4Posn = 0; // Keep track of four byte input buffer
+ int i = 0; // Source array counter
+ byte sbiCrop = 0; // Low seven bits (ASCII) of input
+ byte sbiDecode = 0; // Special value from DECODABET
+
+ for( i = off; i < off+len; i++ ) { // Loop through source
+
+ sbiCrop = (byte)(source[i] & 0x7f); // Only the low seven bits
+ sbiDecode = DECODABET[ sbiCrop ]; // Special value
+
+ // White space, Equals sign, or legit Base64 character
+ // Note the values such as -5 and -9 in the
+ // DECODABETs at the top of the file.
+ if( sbiDecode >= WHITE_SPACE_ENC ) {
+ if( sbiDecode >= EQUALS_SIGN_ENC ) {
+ b4[ b4Posn++ ] = sbiCrop; // Save non-whitespace
+ if( b4Posn > 3 ) { // Time to decode?
+ outBuffPosn += decode4to3( b4, 0, outBuff, outBuffPosn, options );
+ b4Posn = 0;
+
+ // If that was the equals sign, break out of 'for' loop
+ if( sbiCrop == EQUALS_SIGN ) {
+ break;
+ } // end if: equals sign
+ } // end if: quartet built
+ } // end if: equals sign or better
+ } // end if: white space, equals sign or better
+ else {
+ // There's a bad input character in the Base64 stream.
+ throw new java.io.IOException( String.format(
+ "Bad Base64 input character '%c' in array position %d", source[i], i ) );
+ } // end else:
+ } // each input character
+
+ byte[] out = new byte[ outBuffPosn ];
+ System.arraycopy( outBuff, 0, out, 0, outBuffPosn );
+ return out;
+ } // end decode
+
+
+
+
+ /**
+ * Decodes data from Base64 notation, automatically
+ * detecting gzip-compressed data and decompressing it.
+ *
+ * @param s the string to decode
+ * @return the decoded data
+ * @throws java.io.IOException If there is a problem
+ * @since 1.4
+ */
+ public static byte[] decode( String s ) throws java.io.IOException {
+ return decode( s, DONT_GUNZIP );
+ }
+
+
+ public static byte[] decodeWithoutPadding(String source) throws java.io.IOException {
+ int padding = source.length() % 4;
+
+ if (padding == 1) source = source + "=";
+ else if (padding == 2) source = source + "==";
+ else if (padding == 3) source = source + "=";
+
+ return decode(source);
+ }
+
+
+
+ /**
+ * Decodes data from Base64 notation, automatically
+ * detecting gzip-compressed data and decompressing it.
+ *
+ * @param s the string to decode
+ * @param options encode options such as URL_SAFE
+ * @return the decoded data
+ * @throws java.io.IOException if there is an error
+ * @throws NullPointerException if <tt>s</tt> is null
+ * @since 1.4
+ */
+ public static byte[] decode( String s, int options ) throws java.io.IOException {
+
+ if( s == null ){
+ throw new NullPointerException( "Input string was null." );
+ } // end if
+
+ byte[] bytes;
+ try {
+ bytes = s.getBytes( PREFERRED_ENCODING );
+ } // end try
+ catch( java.io.UnsupportedEncodingException uee ) {
+ bytes = s.getBytes();
+ } // end catch
+ //</change>
+
+ // Decode
+ bytes = decode( bytes, 0, bytes.length, options );
+
+ // Check to see if it's gzip-compressed
+ // GZIP Magic Two-Byte Number: 0x8b1f (35615)
+ boolean dontGunzip = (options & DONT_GUNZIP) != 0;
+ if( (bytes != null) && (bytes.length >= 4) && (!dontGunzip) ) {
+
+ int head = ((int)bytes[0] & 0xff) | ((bytes[1] << 8) & 0xff00);
+ if( java.util.zip.GZIPInputStream.GZIP_MAGIC == head ) {
+ java.io.ByteArrayInputStream bais = null;
+ java.util.zip.GZIPInputStream gzis = null;
+ java.io.ByteArrayOutputStream baos = null;
+ byte[] buffer = new byte[2048];
+ int length = 0;
+
+ try {
+ baos = new java.io.ByteArrayOutputStream();
+ bais = new java.io.ByteArrayInputStream( bytes );
+ gzis = new java.util.zip.GZIPInputStream( bais );
+
+ while( ( length = gzis.read( buffer ) ) >= 0 ) {
+ baos.write(buffer,0,length);
+ } // end while: reading input
+
+ // No error? Get new bytes.
+ bytes = baos.toByteArray();
+
+ } // end try
+ catch( java.io.IOException e ) {
+ e.printStackTrace();
+ // Just return originally-decoded bytes
+ } // end catch
+ finally {
+ try{ baos.close(); } catch( Exception e ){}
+ try{ gzis.close(); } catch( Exception e ){}
+ try{ bais.close(); } catch( Exception e ){}
+ } // end finally
+
+ } // end if: gzipped
+ } // end if: bytes.length >= 2
+
+ return bytes;
+ } // end decode
+
+
+
+ /**
+ * Attempts to decode Base64 data and deserialize a Java
+ * Object within. Returns <tt>null</tt> if there was an error.
+ *
+ * @param encodedObject The Base64 data to decode
+ * @return The decoded and deserialized object
+ * @throws NullPointerException if encodedObject is null
+ * @throws java.io.IOException if there is a general error
+ * @throws ClassNotFoundException if the decoded object is of a
+ * class that cannot be found by the JVM
+ * @since 1.5
+ */
+ public static Object decodeToObject( String encodedObject )
+ throws java.io.IOException, ClassNotFoundException {
+ return decodeToObject(encodedObject,NO_OPTIONS,null);
+ }
+
+
+ /**
+ * Attempts to decode Base64 data and deserialize a Java
+ * Object within. Returns <tt>null</tt> if there was an error.
+ * If <tt>loader</tt> is not null, it will be the class loader
+ * used when deserializing.
+ *
+ * @param encodedObject The Base64 data to decode
+ * @param options Various parameters related to decoding
+ * @param loader Optional class loader to use in deserializing classes.
+ * @return The decoded and deserialized object
+ * @throws NullPointerException if encodedObject is null
+ * @throws java.io.IOException if there is a general error
+ * @throws ClassNotFoundException if the decoded object is of a
+ * class that cannot be found by the JVM
+ * @since 2.3.4
+ */
+ public static Object decodeToObject(
+ String encodedObject, int options, final ClassLoader loader )
+ throws java.io.IOException, ClassNotFoundException {
+
+ // Decode and gunzip if necessary
+ byte[] objBytes = decode( encodedObject, options );
+
+ java.io.ByteArrayInputStream bais = null;
+ java.io.ObjectInputStream ois = null;
+ Object obj = null;
+
+ try {
+ bais = new java.io.ByteArrayInputStream( objBytes );
+
+ // If no custom class loader is provided, use Java's builtin OIS.
+ if( loader == null ){
+ ois = new java.io.ObjectInputStream( bais );
+ } // end if: no loader provided
+
+ // Else make a customized object input stream that uses
+ // the provided class loader.
+ else {
+ ois = new java.io.ObjectInputStream(bais){
+ @Override
+ public Class<?> resolveClass(java.io.ObjectStreamClass streamClass)
+ throws java.io.IOException, ClassNotFoundException {
+ Class c = Class.forName(streamClass.getName(), false, loader);
+ if( c == null ){
+ return super.resolveClass(streamClass);
+ } else {
+ return c; // Class loader knows of this class.
+ } // end else: not null
+ } // end resolveClass
+ }; // end ois
+ } // end else: no custom class loader
+
+ obj = ois.readObject();
+ } // end try
+ catch( java.io.IOException e ) {
+ throw e; // Catch and throw in order to execute finally{}
+ } // end catch
+ catch( ClassNotFoundException e ) {
+ throw e; // Catch and throw in order to execute finally{}
+ } // end catch
+ finally {
+ try{ bais.close(); } catch( Exception e ){}
+ try{ ois.close(); } catch( Exception e ){}
+ } // end finally
+
+ return obj;
+ } // end decodeObject
+
+
+
+ /**
+ * Convenience method for encoding data to a file.
+ *
+ * <p>As of v 2.3, if there is a error,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned false, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ * @param dataToEncode byte array of data to encode in base64 form
+ * @param filename Filename for saving encoded data
+ * @throws java.io.IOException if there is an error
+ * @throws NullPointerException if dataToEncode is null
+ * @since 2.1
+ */
+ public static void encodeToFile( byte[] dataToEncode, String filename )
+ throws java.io.IOException {
+
+ if( dataToEncode == null ){
+ throw new NullPointerException( "Data to encode was null." );
+ } // end iff
+
+ Base64.OutputStream bos = null;
+ try {
+ bos = new Base64.OutputStream(
+ new java.io.FileOutputStream( filename ), Base64.ENCODE );
+ bos.write( dataToEncode );
+ } // end try
+ catch( java.io.IOException e ) {
+ throw e; // Catch and throw to execute finally{} block
+ } // end catch: java.io.IOException
+ finally {
+ try{ bos.close(); } catch( Exception e ){}
+ } // end finally
+
+ } // end encodeToFile
+
+
+ /**
+ * Convenience method for decoding data to a file.
+ *
+ * <p>As of v 2.3, if there is a error,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned false, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ * @param dataToDecode Base64-encoded data as a string
+ * @param filename Filename for saving decoded data
+ * @throws java.io.IOException if there is an error
+ * @since 2.1
+ */
+ public static void decodeToFile( String dataToDecode, String filename )
+ throws java.io.IOException {
+
+ Base64.OutputStream bos = null;
+ try{
+ bos = new Base64.OutputStream(
+ new java.io.FileOutputStream( filename ), Base64.DECODE );
+ bos.write( dataToDecode.getBytes( PREFERRED_ENCODING ) );
+ } // end try
+ catch( java.io.IOException e ) {
+ throw e; // Catch and throw to execute finally{} block
+ } // end catch: java.io.IOException
+ finally {
+ try{ bos.close(); } catch( Exception e ){}
+ } // end finally
+
+ } // end decodeToFile
+
+
+
+
+ /**
+ * Convenience method for reading a base64-encoded
+ * file and decoding it.
+ *
+ * <p>As of v 2.3, if there is a error,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned false, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ * @param filename Filename for reading encoded data
+ * @return decoded byte array
+ * @throws java.io.IOException if there is an error
+ * @since 2.1
+ */
+ public static byte[] decodeFromFile( String filename )
+ throws java.io.IOException {
+
+ byte[] decodedData = null;
+ Base64.InputStream bis = null;
+ try
+ {
+ // Set up some useful variables
+ java.io.File file = new java.io.File( filename );
+ byte[] buffer = null;
+ int length = 0;
+ int numBytes = 0;
+
+ // Check for size of file
+ if( file.length() > Integer.MAX_VALUE )
+ {
+ throw new java.io.IOException( "File is too big for this convenience method (" + file.length() + " bytes)." );
+ } // end if: file too big for int index
+ buffer = new byte[ (int)file.length() ];
+
+ // Open a stream
+ bis = new Base64.InputStream(
+ new java.io.BufferedInputStream(
+ new java.io.FileInputStream( file ) ), Base64.DECODE );
+
+ // Read until done
+ while( ( numBytes = bis.read( buffer, length, 4096 ) ) >= 0 ) {
+ length += numBytes;
+ } // end while
+
+ // Save in a variable to return
+ decodedData = new byte[ length ];
+ System.arraycopy( buffer, 0, decodedData, 0, length );
+
+ } // end try
+ catch( java.io.IOException e ) {
+ throw e; // Catch and release to execute finally{}
+ } // end catch: java.io.IOException
+ finally {
+ try{ bis.close(); } catch( Exception e) {}
+ } // end finally
+
+ return decodedData;
+ } // end decodeFromFile
+
+
+
+ /**
+ * Convenience method for reading a binary file
+ * and base64-encoding it.
+ *
+ * <p>As of v 2.3, if there is a error,
+ * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>
+ * In earlier versions, it just returned false, but
+ * in retrospect that's a pretty poor way to handle it.</p>
+ *
+ * @param filename Filename for reading binary data
+ * @return base64-encoded string
+ * @throws java.io.IOException if there is an error
+ * @since 2.1
+ */
+ public static String encodeFromFile( String filename )
+ throws java.io.IOException {
+
+ String encodedData = null;
+ Base64.InputStream bis = null;
+ try
+ {
+ // Set up some useful variables
+ java.io.File file = new java.io.File( filename );
+ byte[] buffer = new byte[ Math.max((int)(file.length() * 1.4),40) ]; // Need max() for math on small files (v2.2.1)
+ int length = 0;
+ int numBytes = 0;
+
+ // Open a stream
+ bis = new Base64.InputStream(
+ new java.io.BufferedInputStream(
+ new java.io.FileInputStream( file ) ), Base64.ENCODE );
+
+ // Read until done
+ while( ( numBytes = bis.read( buffer, length, 4096 ) ) >= 0 ) {
+ length += numBytes;
+ } // end while
+
+ // Save in a variable to return
+ encodedData = new String( buffer, 0, length, Base64.PREFERRED_ENCODING );
+
+ } // end try
+ catch( java.io.IOException e ) {
+ throw e; // Catch and release to execute finally{}
+ } // end catch: java.io.IOException
+ finally {
+ try{ bis.close(); } catch( Exception e) {}
+ } // end finally
+
+ return encodedData;
+ } // end encodeFromFile
+
+ /**
+ * Reads <tt>infile</tt> and encodes it to <tt>outfile</tt>.
+ *
+ * @param infile Input file
+ * @param outfile Output file
+ * @throws java.io.IOException if there is an error
+ * @since 2.2
+ */
+ public static void encodeFileToFile( String infile, String outfile )
+ throws java.io.IOException {
+
+ String encoded = Base64.encodeFromFile( infile );
+ java.io.OutputStream out = null;
+ try{
+ out = new java.io.BufferedOutputStream(
+ new java.io.FileOutputStream( outfile ) );
+ out.write( encoded.getBytes("US-ASCII") ); // Strict, 7-bit output.
+ } // end try
+ catch( java.io.IOException e ) {
+ throw e; // Catch and release to execute finally{}
+ } // end catch
+ finally {
+ try { out.close(); }
+ catch( Exception ex ){}
+ } // end finally
+ } // end encodeFileToFile
+
+
+ /**
+ * Reads <tt>infile</tt> and decodes it to <tt>outfile</tt>.
+ *
+ * @param infile Input file
+ * @param outfile Output file
+ * @throws java.io.IOException if there is an error
+ * @since 2.2
+ */
+ public static void decodeFileToFile( String infile, String outfile )
+ throws java.io.IOException {
+
+ byte[] decoded = Base64.decodeFromFile( infile );
+ java.io.OutputStream out = null;
+ try{
+ out = new java.io.BufferedOutputStream(
+ new java.io.FileOutputStream( outfile ) );
+ out.write( decoded );
+ } // end try
+ catch( java.io.IOException e ) {
+ throw e; // Catch and release to execute finally{}
+ } // end catch
+ finally {
+ try { out.close(); }
+ catch( Exception ex ){}
+ } // end finally
+ } // end decodeFileToFile
+
+
+ /* ******** I N N E R C L A S S I N P U T S T R E A M ******** */
+
+
+
+ /**
+ * A {@link Base64.InputStream} will read data from another
+ * <tt>java.io.InputStream</tt>, given in the constructor,
+ * and encode/decode to/from Base64 notation on the fly.
+ *
+ * @see Base64
+ * @since 1.3
+ */
+ public static class InputStream extends java.io.FilterInputStream {
+
+ private boolean encode; // Encoding or decoding
+ private int position; // Current position in the buffer
+ private byte[] buffer; // Small buffer holding converted data
+ private int bufferLength; // Length of buffer (3 or 4)
+ private int numSigBytes; // Number of meaningful bytes in the buffer
+ private int lineLength;
+ private boolean breakLines; // Break lines at less than 80 characters
+ private int options; // Record options used to create the stream.
+ private byte[] decodabet; // Local copies to avoid extra method calls
+
+
+ /**
+ * Constructs a {@link Base64.InputStream} in DECODE mode.
+ *
+ * @param in the <tt>java.io.InputStream</tt> from which to read data.
+ * @since 1.3
+ */
+ public InputStream( java.io.InputStream in ) {
+ this( in, DECODE );
+ } // end constructor
+
+
+ /**
+ * Constructs a {@link Base64.InputStream} in
+ * either ENCODE or DECODE mode.
+ * <p>
+ * Valid options:<pre>
+ * ENCODE or DECODE: Encode or Decode as data is read.
+ * DO_BREAK_LINES: break lines at 76 characters
+ * (only meaningful when encoding)</i>
+ * </pre>
+ * <p>
+ * Example: <code>new Base64.InputStream( in, Base64.DECODE )</code>
+ *
+ *
+ * @param in the <tt>java.io.InputStream</tt> from which to read data.
+ * @param options Specified options
+ * @see Base64#ENCODE
+ * @see Base64#DECODE
+ * @see Base64#DO_BREAK_LINES
+ * @since 2.0
+ */
+ public InputStream( java.io.InputStream in, int options ) {
+
+ super( in );
+ this.options = options; // Record for later
+ this.breakLines = (options & DO_BREAK_LINES) > 0;
+ this.encode = (options & ENCODE) > 0;
+ this.bufferLength = encode ? 4 : 3;
+ this.buffer = new byte[ bufferLength ];
+ this.position = -1;
+ this.lineLength = 0;
+ this.decodabet = getDecodabet(options);
+ } // end constructor
+
+ /**
+ * Reads enough of the input stream to convert
+ * to/from Base64 and returns the next byte.
+ *
+ * @return next byte
+ * @since 1.3
+ */
+ @Override
+ public int read() throws java.io.IOException {
+
+ // Do we need to get data?
+ if( position < 0 ) {
+ if( encode ) {
+ byte[] b3 = new byte[3];
+ int numBinaryBytes = 0;
+ for( int i = 0; i < 3; i++ ) {
+ int b = in.read();
+
+ // If end of stream, b is -1.
+ if( b >= 0 ) {
+ b3[i] = (byte)b;
+ numBinaryBytes++;
+ } else {
+ break; // out of for loop
+ } // end else: end of stream
+
+ } // end for: each needed input byte
+
+ if( numBinaryBytes > 0 ) {
+ encode3to4( b3, 0, numBinaryBytes, buffer, 0, options );
+ position = 0;
+ numSigBytes = 4;
+ } // end if: got data
+ else {
+ return -1; // Must be end of stream
+ } // end else
+ } // end if: encoding
+
+ // Else decoding
+ else {
+ byte[] b4 = new byte[4];
+ int i = 0;
+ for( i = 0; i < 4; i++ ) {
+ // Read four "meaningful" bytes:
+ int b = 0;
+ do{ b = in.read(); }
+ while( b >= 0 && decodabet[ b & 0x7f ] <= WHITE_SPACE_ENC );
+
+ if( b < 0 ) {
+ break; // Reads a -1 if end of stream
+ } // end if: end of stream
+
+ b4[i] = (byte)b;
+ } // end for: each needed input byte
+
+ if( i == 4 ) {
+ numSigBytes = decode4to3( b4, 0, buffer, 0, options );
+ position = 0;
+ } // end if: got four characters
+ else if( i == 0 ){
+ return -1;
+ } // end else if: also padded correctly
+ else {
+ // Must have broken out from above.
+ throw new java.io.IOException( "Improperly padded Base64 input." );
+ } // end
+
+ } // end else: decode
+ } // end else: get data
+
+ // Got data?
+ if( position >= 0 ) {
+ // End of relevant data?
+ if( /*!encode &&*/ position >= numSigBytes ){
+ return -1;
+ } // end if: got data
+
+ if( encode && breakLines && lineLength >= MAX_LINE_LENGTH ) {
+ lineLength = 0;
+ return '\n';
+ } // end if
+ else {
+ lineLength++; // This isn't important when decoding
+ // but throwing an extra "if" seems
+ // just as wasteful.
+
+ int b = buffer[ position++ ];
+
+ if( position >= bufferLength ) {
+ position = -1;
+ } // end if: end
+
+ return b & 0xFF; // This is how you "cast" a byte that's
+ // intended to be unsigned.
+ } // end else
+ } // end if: position >= 0
+
+ // Else error
+ else {
+ throw new java.io.IOException( "Error in Base64 code reading stream." );
+ } // end else
+ } // end read
+
+
+ /**
+ * Calls {@link #read()} repeatedly until the end of stream
+ * is reached or <var>len</var> bytes are read.
+ * Returns number of bytes read into array or -1 if
+ * end of stream is encountered.
+ *
+ * @param dest array to hold values
+ * @param off offset for array
+ * @param len max number of bytes to read into array
+ * @return bytes read into array or -1 if end of stream is encountered.
+ * @since 1.3
+ */
+ @Override
+ public int read( byte[] dest, int off, int len )
+ throws java.io.IOException {
+ int i;
+ int b;
+ for( i = 0; i < len; i++ ) {
+ b = read();
+
+ if( b >= 0 ) {
+ dest[off + i] = (byte) b;
+ }
+ else if( i == 0 ) {
+ return -1;
+ }
+ else {
+ break; // Out of 'for' loop
+ } // Out of 'for' loop
+ } // end for: each byte read
+ return i;
+ } // end read
+
+ } // end inner class InputStream
+
+
+
+
+
+
+ /* ******** I N N E R C L A S S O U T P U T S T R E A M ******** */
+
+
+
+ /**
+ * A {@link Base64.OutputStream} will write data to another
+ * <tt>java.io.OutputStream</tt>, given in the constructor,
+ * and encode/decode to/from Base64 notation on the fly.
+ *
+ * @see Base64
+ * @since 1.3
+ */
+ public static class OutputStream extends java.io.FilterOutputStream {
+
+ private boolean encode;
+ private int position;
+ private byte[] buffer;
+ private int bufferLength;
+ private int lineLength;
+ private boolean breakLines;
+ private byte[] b4; // Scratch used in a few places
+ private boolean suspendEncoding;
+ private int options; // Record for later
+ private byte[] decodabet; // Local copies to avoid extra method calls
+
+ /**
+ * Constructs a {@link Base64.OutputStream} in ENCODE mode.
+ *
+ * @param out the <tt>java.io.OutputStream</tt> to which data will be written.
+ * @since 1.3
+ */
+ public OutputStream( java.io.OutputStream out ) {
+ this( out, ENCODE );
+ } // end constructor
+
+
+ /**
+ * Constructs a {@link Base64.OutputStream} in
+ * either ENCODE or DECODE mode.
+ * <p>
+ * Valid options:<pre>
+ * ENCODE or DECODE: Encode or Decode as data is read.
+ * DO_BREAK_LINES: don't break lines at 76 characters
+ * (only meaningful when encoding)</i>
+ * </pre>
+ * <p>
+ * Example: <code>new Base64.OutputStream( out, Base64.ENCODE )</code>
+ *
+ * @param out the <tt>java.io.OutputStream</tt> to which data will be written.
+ * @param options Specified options.
+ * @see Base64#ENCODE
+ * @see Base64#DECODE
+ * @see Base64#DO_BREAK_LINES
+ * @since 1.3
+ */
+ public OutputStream( java.io.OutputStream out, int options ) {
+ super( out );
+ this.breakLines = (options & DO_BREAK_LINES) != 0;
+ this.encode = (options & ENCODE) != 0;
+ this.bufferLength = encode ? 3 : 4;
+ this.buffer = new byte[ bufferLength ];
+ this.position = 0;
+ this.lineLength = 0;
+ this.suspendEncoding = false;
+ this.b4 = new byte[4];
+ this.options = options;
+ this.decodabet = getDecodabet(options);
+ } // end constructor
+
+
+ /**
+ * Writes the byte to the output stream after
+ * converting to/from Base64 notation.
+ * When encoding, bytes are buffered three
+ * at a time before the output stream actually
+ * gets a write() call.
+ * When decoding, bytes are buffered four
+ * at a time.
+ *
+ * @param theByte the byte to write
+ * @since 1.3
+ */
+ @Override
+ public void write(int theByte)
+ throws java.io.IOException {
+ // Encoding suspended?
+ if( suspendEncoding ) {
+ this.out.write( theByte );
+ return;
+ } // end if: supsended
+
+ // Encode?
+ if( encode ) {
+ buffer[ position++ ] = (byte)theByte;
+ if( position >= bufferLength ) { // Enough to encode.
+
+ this.out.write( encode3to4( b4, buffer, bufferLength, options ) );
+
+ lineLength += 4;
+ if( breakLines && lineLength >= MAX_LINE_LENGTH ) {
+ this.out.write( NEW_LINE );
+ lineLength = 0;
+ } // end if: end of line
+
+ position = 0;
+ } // end if: enough to output
+ } // end if: encoding
+
+ // Else, Decoding
+ else {
+ // Meaningful Base64 character?
+ if( decodabet[ theByte & 0x7f ] > WHITE_SPACE_ENC ) {
+ buffer[ position++ ] = (byte)theByte;
+ if( position >= bufferLength ) { // Enough to output.
+
+ int len = Base64.decode4to3( buffer, 0, b4, 0, options );
+ out.write( b4, 0, len );
+ position = 0;
+ } // end if: enough to output
+ } // end if: meaningful base64 character
+ else if( decodabet[ theByte & 0x7f ] != WHITE_SPACE_ENC ) {
+ throw new java.io.IOException( "Invalid character in Base64 data." );
+ } // end else: not white space either
+ } // end else: decoding
+ } // end write
+
+
+
+ /**
+ * Calls {@link #write(int)} repeatedly until <var>len</var>
+ * bytes are written.
+ *
+ * @param theBytes array from which to read bytes
+ * @param off offset for array
+ * @param len max number of bytes to read into array
+ * @since 1.3
+ */
+ @Override
+ public void write( byte[] theBytes, int off, int len )
+ throws java.io.IOException {
+ // Encoding suspended?
+ if( suspendEncoding ) {
+ this.out.write( theBytes, off, len );
+ return;
+ } // end if: supsended
+
+ for( int i = 0; i < len; i++ ) {
+ write( theBytes[ off + i ] );
+ } // end for: each byte written
+
+ } // end write
+
+
+
+ /**
+ * Method added by PHIL. [Thanks, PHIL. -Rob]
+ * This pads the buffer without closing the stream.
+ * @throws java.io.IOException if there's an error.
+ */
+ public void flushBase64() throws java.io.IOException {
+ if( position > 0 ) {
+ if( encode ) {
+ out.write( encode3to4( b4, buffer, position, options ) );
+ position = 0;
+ } // end if: encoding
+ else {
+ throw new java.io.IOException( "Base64 input not properly padded." );
+ } // end else: decoding
+ } // end if: buffer partially full
+
+ } // end flush
+
+
+ /**
+ * Flushes and closes (I think, in the superclass) the stream.
+ *
+ * @since 1.3
+ */
+ @Override
+ public void close() throws java.io.IOException {
+ // 1. Ensure that pending characters are written
+ flushBase64();
+
+ // 2. Actually close the stream
+ // Base class both flushes and closes.
+ super.close();
+
+ buffer = null;
+ out = null;
+ } // end close
+
+
+
+ /**
+ * Suspends encoding of the stream.
+ * May be helpful if you need to embed a piece of
+ * base64-encoded data in a stream.
+ *
+ * @throws java.io.IOException if there's an error flushing
+ * @since 1.5.1
+ */
+ public void suspendEncoding() throws java.io.IOException {
+ flushBase64();
+ this.suspendEncoding = true;
+ } // end suspendEncoding
+
+
+ /**
+ * Resumes encoding of the stream.
+ * May be helpful if you need to embed a piece of
+ * base64-encoded data in a stream.
+ *
+ * @since 1.5.1
+ */
+ public void resumeEncoding() {
+ this.suspendEncoding = false;
+ } // end resumeEncoding
+
+
+
+ } // end inner class OutputStream
+
+
+} // end class Base64
diff --git a/websocket-resources/src/test/java/org/whispersystems/websocket/LoggableRequestResponseTest.java b/websocket-resources/src/test/java/org/whispersystems/websocket/LoggableRequestResponseTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4faa1874bc88427aa3242c1741689b7ea00d8305
--- /dev/null
+++ b/websocket-resources/src/test/java/org/whispersystems/websocket/LoggableRequestResponseTest.java
@@ -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;
+ }
+ }
+
+}
diff --git a/websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderFactoryTest.java b/websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderFactoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..68a995c268d01f376ca7cddc7bc82fafb3c3772f
--- /dev/null
+++ b/websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderFactoryTest.java
@@ -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 {}
+
+
+}
diff --git a/websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderTest.java b/websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5745fc67bbe7fc1956bda0da9c17f40b977ab9e
--- /dev/null
+++ b/websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderTest.java
@@ -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!");
+ }
+
+}