jdk/src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/internal/websocket/OutgoingMessage.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code 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 General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package jdk.incubator.http.internal.websocket;

 import jdk.incubator.http.internal.websocket.Frame.Opcode;

 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.CharsetEncoder;
 import java.nio.charset.CoderResult;
 import java.security.SecureRandom;

 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Objects.requireNonNull;
 import static jdk.incubator.http.internal.common.Utils.EMPTY_BYTEBUFFER;
 import static jdk.incubator.http.internal.websocket.Frame.MAX_HEADER_SIZE_BYTES;
 import static jdk.incubator.http.internal.websocket.Frame.Opcode.BINARY;
 import static jdk.incubator.http.internal.websocket.Frame.Opcode.CLOSE;
 import static jdk.incubator.http.internal.websocket.Frame.Opcode.CONTINUATION;
 import static jdk.incubator.http.internal.websocket.Frame.Opcode.PING;
 import static jdk.incubator.http.internal.websocket.Frame.Opcode.PONG;
 import static jdk.incubator.http.internal.websocket.Frame.Opcode.TEXT;

 /*
  * A stateful object that represents a WebSocket message being sent to the
  * channel.
  *
  * Data provided to the constructors is copied. Otherwise we would have to deal
  * with mutability, security, masking/unmasking, readonly status, etc. So
  * copying greatly simplifies the implementation.
  *
  * In the case of memory-sensitive environments an alternative implementation
  * could use an internal pool of buffers though at the cost of extra complexity
  * and possible performance degradation.
  */
 abstract class OutgoingMessage {

     private static final SecureRandom maskingKeys = new SecureRandom();

     protected ByteBuffer[] frame;
     protected int offset;

     /*
      * Performs contextualization. This method is not a part of the constructor
      * so it would be possible to defer the work it does until the most
      * convenient moment (up to the point where sentTo is invoked).
      */
     protected void contextualize(Context context) {
         if (context.isCloseSent()) {
             throw new IllegalStateException("Close sent");
         }
     }

     protected boolean sendTo(RawChannel channel) throws IOException {
         while ((offset = nextUnwrittenIndex()) != -1) {
             long n = channel.write(frame, offset, frame.length - offset);
             if (n == 0) {
                 return false;
             }
         }
         return true;
     }

     private int nextUnwrittenIndex() {
         for (int i = offset; i < frame.length; i++) {
             if (frame[i].hasRemaining()) {
                 return i;
             }
         }
         return -1;
     }

     static final class Text extends OutgoingMessage {

         private final ByteBuffer payload;
         private final boolean isLast;

         Text(CharSequence characters, boolean isLast) {
             CharsetEncoder encoder = UTF_8.newEncoder();
             try {
                 payload = encoder.encode(CharBuffer.wrap(characters));
             } catch (CharacterCodingException e) {
                 throw new IllegalArgumentException(
                         "Malformed UTF-8 text message");
             }
             this.isLast = isLast;
         }

         @Override
         protected void contextualize(Context context) {
             super.contextualize(context);
             if (context.isPreviousBinary() && !context.isPreviousLast()) {
                 throw new IllegalStateException("Unexpected text message");
             }
             frame = getDataMessageBuffers(
                     TEXT, context.isPreviousLast(), isLast, payload, payload);
             context.setPreviousBinary(false);
             context.setPreviousText(true);
             context.setPreviousLast(isLast);
         }
     }

     static final class Binary extends OutgoingMessage {

         private final ByteBuffer payload;
         private final boolean isLast;

         Binary(ByteBuffer payload, boolean isLast) {
             this.payload = requireNonNull(payload);
             this.isLast = isLast;
         }

         @Override
         protected void contextualize(Context context) {
             super.contextualize(context);
             if (context.isPreviousText() && !context.isPreviousLast()) {
                 throw new IllegalStateException("Unexpected binary message");
             }
             ByteBuffer newBuffer = ByteBuffer.allocate(payload.remaining());
             frame = getDataMessageBuffers(
                     BINARY, context.isPreviousLast(), isLast, payload, newBuffer);
             context.setPreviousText(false);
             context.setPreviousBinary(true);
             context.setPreviousLast(isLast);
         }
     }

     static final class Ping extends OutgoingMessage {

         Ping(ByteBuffer payload) {
             frame = getControlMessageBuffers(PING, payload);
         }
     }

     static final class Pong extends OutgoingMessage {

         Pong(ByteBuffer payload) {
             frame = getControlMessageBuffers(PONG, payload);
         }
     }

     static final class Close extends OutgoingMessage {

         Close() {
             frame = getControlMessageBuffers(CLOSE, EMPTY_BYTEBUFFER);
         }

         Close(int statusCode, CharSequence reason) {
             ByteBuffer payload = ByteBuffer.allocate(125)
                                            .putChar((char) statusCode);
             CoderResult result = UTF_8.newEncoder()
                                       .encode(CharBuffer.wrap(reason),
                                               payload,
                                               true);
             if (result.isOverflow()) {
                 throw new IllegalArgumentException("Long reason");
             } else if (result.isError()) {
                 try {
                     result.throwException();
                 } catch (CharacterCodingException e) {
                     throw new IllegalArgumentException(
                             "Malformed UTF-8 reason", e);
                 }
             }
             payload.flip();
             frame = getControlMessageBuffers(CLOSE, payload);
         }

         @Override
         protected void contextualize(Context context) {
             super.contextualize(context);
             context.setCloseSent();
         }
     }

     private static ByteBuffer[] getControlMessageBuffers(Opcode opcode,
                                                          ByteBuffer payload) {
         assert opcode.isControl() : opcode;
         int remaining = payload.remaining();
         if (remaining > 125) {
             throw new IllegalArgumentException
                     ("Long message: " + remaining);
         }
         ByteBuffer frame = ByteBuffer.allocate(MAX_HEADER_SIZE_BYTES + remaining);
         int mask = maskingKeys.nextInt();
         new Frame.HeaderWriter()
                 .fin(true)
                 .opcode(opcode)
                 .payloadLen(remaining)
                 .mask(mask)
                 .write(frame);
         Frame.Masker.transferMasking(payload, frame, mask);
         frame.flip();
         return new ByteBuffer[]{frame};
     }

     private static ByteBuffer[] getDataMessageBuffers(Opcode type,
                                                       boolean isPreviousLast,
                                                       boolean isLast,
                                                       ByteBuffer payloadSrc,
                                                       ByteBuffer payloadDst) {
         assert !type.isControl() && type != CONTINUATION : type;
         ByteBuffer header = ByteBuffer.allocate(MAX_HEADER_SIZE_BYTES);
         int mask = maskingKeys.nextInt();
         new Frame.HeaderWriter()
                 .fin(isLast)
                 .opcode(isPreviousLast ? type : CONTINUATION)
                 .payloadLen(payloadDst.remaining())
                 .mask(mask)
                 .write(header);
         header.flip();
         Frame.Masker.transferMasking(payloadSrc, payloadDst, mask);
         payloadDst.flip();
         return new ByteBuffer[]{header, payloadDst};
     }

     /*
      * An instance of this class is passed sequentially between messages, so
      * every message in a sequence can check the context it is in and update it
      * if necessary.
      */
     public static class Context {

         boolean previousLast = true;
         boolean previousBinary;
         boolean previousText;
         boolean closeSent;

         private boolean isPreviousText() {
             return this.previousText;
         }

         private void setPreviousText(boolean value) {
             this.previousText = value;
         }

         private boolean isPreviousBinary() {
             return this.previousBinary;
         }

         private void setPreviousBinary(boolean value) {
             this.previousBinary = value;
         }

         private boolean isPreviousLast() {
             return this.previousLast;
         }

         private void setPreviousLast(boolean value) {
             this.previousLast = value;
         }

         private boolean isCloseSent() {
             return closeSent;
         }

         private void setCloseSent() {
             closeSent = true;
         }
     }
 }
	/*
	* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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 General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package jdk.incubator.http.internal.websocket;

	import jdk.incubator.http.internal.websocket.Frame.Opcode;

	import java.io.IOException;
	import java.nio.ByteBuffer;
	import java.nio.CharBuffer;
	import java.nio.charset.CharacterCodingException;
	import java.nio.charset.CharsetEncoder;
	import java.nio.charset.CoderResult;
	import java.security.SecureRandom;

	import static java.nio.charset.StandardCharsets.UTF_8;
	import static java.util.Objects.requireNonNull;
	import static jdk.incubator.http.internal.common.Utils.EMPTY_BYTEBUFFER;
	import static jdk.incubator.http.internal.websocket.Frame.MAX_HEADER_SIZE_BYTES;
	import static jdk.incubator.http.internal.websocket.Frame.Opcode.BINARY;
	import static jdk.incubator.http.internal.websocket.Frame.Opcode.CLOSE;
	import static jdk.incubator.http.internal.websocket.Frame.Opcode.CONTINUATION;
	import static jdk.incubator.http.internal.websocket.Frame.Opcode.PING;
	import static jdk.incubator.http.internal.websocket.Frame.Opcode.PONG;
	import static jdk.incubator.http.internal.websocket.Frame.Opcode.TEXT;

	/*
	* A stateful object that represents a WebSocket message being sent to the
	* channel.
	*
	* Data provided to the constructors is copied. Otherwise we would have to deal
	* with mutability, security, masking/unmasking, readonly status, etc. So
	* copying greatly simplifies the implementation.
	*
	* In the case of memory-sensitive environments an alternative implementation
	* could use an internal pool of buffers though at the cost of extra complexity
	* and possible performance degradation.
	*/
	abstract class OutgoingMessage {

	private static final SecureRandom maskingKeys = new SecureRandom();

	protected ByteBuffer[] frame;
	protected int offset;

	/*
	* Performs contextualization. This method is not a part of the constructor
	* so it would be possible to defer the work it does until the most
	* convenient moment (up to the point where sentTo is invoked).
	*/
	protected void contextualize(Context context) {
	if (context.isCloseSent()) {
	throw new IllegalStateException("Close sent");
	}
	}

	protected boolean sendTo(RawChannel channel) throws IOException {
	while ((offset = nextUnwrittenIndex()) != -1) {
	long n = channel.write(frame, offset, frame.length - offset);
	if (n == 0) {
	return false;
	}
	}
	return true;
	}

	private int nextUnwrittenIndex() {
	for (int i = offset; i < frame.length; i++) {
	if (frame[i].hasRemaining()) {
	return i;
	}
	}
	return -1;
	}

	static final class Text extends OutgoingMessage {

	private final ByteBuffer payload;
	private final boolean isLast;

	Text(CharSequence characters, boolean isLast) {
	CharsetEncoder encoder = UTF_8.newEncoder();
	try {
	payload = encoder.encode(CharBuffer.wrap(characters));
	} catch (CharacterCodingException e) {
	throw new IllegalArgumentException(
	"Malformed UTF-8 text message");
	}
	this.isLast = isLast;
	}

	@Override
	protected void contextualize(Context context) {
	super.contextualize(context);
	if (context.isPreviousBinary() && !context.isPreviousLast()) {
	throw new IllegalStateException("Unexpected text message");
	}
	frame = getDataMessageBuffers(
	TEXT, context.isPreviousLast(), isLast, payload, payload);
	context.setPreviousBinary(false);
	context.setPreviousText(true);
	context.setPreviousLast(isLast);
	}
	}

	static final class Binary extends OutgoingMessage {

	private final ByteBuffer payload;
	private final boolean isLast;

	Binary(ByteBuffer payload, boolean isLast) {
	this.payload = requireNonNull(payload);
	this.isLast = isLast;
	}

	@Override
	protected void contextualize(Context context) {
	super.contextualize(context);
	if (context.isPreviousText() && !context.isPreviousLast()) {
	throw new IllegalStateException("Unexpected binary message");
	}
	ByteBuffer newBuffer = ByteBuffer.allocate(payload.remaining());
	frame = getDataMessageBuffers(
	BINARY, context.isPreviousLast(), isLast, payload, newBuffer);
	context.setPreviousText(false);
	context.setPreviousBinary(true);
	context.setPreviousLast(isLast);
	}
	}

	static final class Ping extends OutgoingMessage {

	Ping(ByteBuffer payload) {
	frame = getControlMessageBuffers(PING, payload);
	}
	}

	static final class Pong extends OutgoingMessage {

	Pong(ByteBuffer payload) {
	frame = getControlMessageBuffers(PONG, payload);
	}
	}

	static final class Close extends OutgoingMessage {

	Close() {
	frame = getControlMessageBuffers(CLOSE, EMPTY_BYTEBUFFER);
	}

	Close(int statusCode, CharSequence reason) {
	ByteBuffer payload = ByteBuffer.allocate(125)
	.putChar((char) statusCode);
	CoderResult result = UTF_8.newEncoder()
	.encode(CharBuffer.wrap(reason),
	payload,
	true);
	if (result.isOverflow()) {
	throw new IllegalArgumentException("Long reason");
	} else if (result.isError()) {
	try {
	result.throwException();
	} catch (CharacterCodingException e) {
	throw new IllegalArgumentException(
	"Malformed UTF-8 reason", e);
	}
	}
	payload.flip();
	frame = getControlMessageBuffers(CLOSE, payload);
	}

	@Override
	protected void contextualize(Context context) {
	super.contextualize(context);
	context.setCloseSent();
	}
	}

	private static ByteBuffer[] getControlMessageBuffers(Opcode opcode,
	ByteBuffer payload) {
	assert opcode.isControl() : opcode;
	int remaining = payload.remaining();
	if (remaining > 125) {
	throw new IllegalArgumentException
	("Long message: " + remaining);
	}
	ByteBuffer frame = ByteBuffer.allocate(MAX_HEADER_SIZE_BYTES + remaining);
	int mask = maskingKeys.nextInt();
	new Frame.HeaderWriter()
	.fin(true)
	.opcode(opcode)
	.payloadLen(remaining)
	.mask(mask)
	.write(frame);
	Frame.Masker.transferMasking(payload, frame, mask);
	frame.flip();
	return new ByteBuffer[]{frame};
	}

	private static ByteBuffer[] getDataMessageBuffers(Opcode type,
	boolean isPreviousLast,
	boolean isLast,
	ByteBuffer payloadSrc,
	ByteBuffer payloadDst) {
	assert !type.isControl() && type != CONTINUATION : type;
	ByteBuffer header = ByteBuffer.allocate(MAX_HEADER_SIZE_BYTES);
	int mask = maskingKeys.nextInt();
	new Frame.HeaderWriter()
	.fin(isLast)
	.opcode(isPreviousLast ? type : CONTINUATION)
	.payloadLen(payloadDst.remaining())
	.mask(mask)
	.write(header);
	header.flip();
	Frame.Masker.transferMasking(payloadSrc, payloadDst, mask);
	payloadDst.flip();
	return new ByteBuffer[]{header, payloadDst};
	}

	/*
	* An instance of this class is passed sequentially between messages, so
	* every message in a sequence can check the context it is in and update it
	* if necessary.
	*/
	public static class Context {

	boolean previousLast = true;
	boolean previousBinary;
	boolean previousText;
	boolean closeSent;

	private boolean isPreviousText() {
	return this.previousText;
	}

	private void setPreviousText(boolean value) {
	this.previousText = value;
	}

	private boolean isPreviousBinary() {
	return this.previousBinary;
	}

	private void setPreviousBinary(boolean value) {
	this.previousBinary = value;
	}

	private boolean isPreviousLast() {
	return this.previousLast;
	}

	private void setPreviousLast(boolean value) {
	this.previousLast = value;
	}

	private boolean isCloseSent() {
	return closeSent;
	}

	private void setCloseSent() {
	closeSent = true;
	}
	}
	}