Back to project page eu.marcelkloubert.simplemessenger.
The source code is released under:
GNU General Public License
If you think the Android project eu.marcelkloubert.simplemessenger listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (C) 2013 Square, Inc./*from ww w . j a v a 2s . c o m*/ * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.squareup.okhttp.internal.spdy; import com.squareup.okhttp.internal.Util; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.UnsupportedEncodingException; import java.util.Arrays; import java.util.List; /** * Read and write http/2 v06 frames. * http://tools.ietf.org/html/draft-ietf-httpbis-http2-06 */ final class Http20Draft06 implements Variant { private static final byte[] CONNECTION_HEADER; static { try { CONNECTION_HEADER = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".getBytes("UTF-8"); } catch (UnsupportedEncodingException e) { throw new AssertionError(); } } static final int TYPE_DATA = 0x0; static final int TYPE_HEADERS = 0x1; static final int TYPE_PRIORITY = 0x2; static final int TYPE_RST_STREAM = 0x3; static final int TYPE_SETTINGS = 0x4; static final int TYPE_PUSH_PROMISE = 0x5; static final int TYPE_PING = 0x6; static final int TYPE_GOAWAY = 0x7; static final int TYPE_WINDOW_UPDATE = 0x9; static final int TYPE_CONTINUATION = 0xa; static final int FLAG_END_STREAM = 0x1; /** Used for headers, push-promise and continuation. */ static final int FLAG_END_HEADERS = 0x4; static final int FLAG_PRIORITY = 0x8; static final int FLAG_PONG = 0x1; static final int FLAG_END_FLOW_CONTROL = 0x1; @Override public FrameReader newReader(InputStream in, boolean client) { return new Reader(in, client); } @Override public FrameWriter newWriter(OutputStream out, boolean client) { return new Writer(out, client); } static final class Reader implements FrameReader { private final DataInputStream in; private final boolean client; private final Hpack.Reader hpackReader; Reader(InputStream in, boolean client) { this.in = new DataInputStream(in); this.client = client; this.hpackReader = new Hpack.Reader(this.in, client); } @Override public void readConnectionHeader() throws IOException { if (client) return; // Nothing to read; servers don't send connection headers! byte[] connectionHeader = new byte[CONNECTION_HEADER.length]; in.readFully(connectionHeader); if (!Arrays.equals(connectionHeader, CONNECTION_HEADER)) { throw ioException("Expected a connection header but was " + Arrays.toString(connectionHeader)); } } @Override public boolean nextFrame(Handler handler) throws IOException { int w1; try { w1 = in.readInt(); } catch (IOException e) { return false; // This might be a normal socket close. } int w2 = in.readInt(); int length = (w1 & 0xffff0000) >> 16; int type = (w1 & 0xff00) >> 8; int flags = w1 & 0xff; // boolean r = (w2 & 0x80000000) != 0; // Reserved. int streamId = (w2 & 0x7fffffff); switch (type) { case TYPE_DATA: readData(handler, flags, length, streamId); return true; case TYPE_HEADERS: readHeaders(handler, flags, length, streamId); return true; case TYPE_PRIORITY: readPriority(handler, flags, length, streamId); return true; case TYPE_RST_STREAM: readRstStream(handler, flags, length, streamId); return true; case TYPE_SETTINGS: readSettings(handler, flags, length, streamId); return true; case TYPE_PUSH_PROMISE: readPushPromise(handler, flags, length, streamId); return true; case TYPE_PING: readPing(handler, flags, length, streamId); return true; case TYPE_GOAWAY: readGoAway(handler, flags, length, streamId); return true; case TYPE_WINDOW_UPDATE: readWindowUpdate(handler, flags, length, streamId); return true; } throw new UnsupportedOperationException("TODO"); } private void readHeaders(Handler handler, int flags, int length, int streamId) throws IOException { if (streamId == 0) throw ioException("TYPE_HEADERS streamId == 0"); boolean inFinished = (flags & FLAG_END_STREAM) != 0; while (true) { hpackReader.readHeaders(length); if ((flags & FLAG_END_HEADERS) != 0) { hpackReader.emitReferenceSet(); List<String> namesAndValues = hpackReader.getAndReset(); int priority = -1; // TODO: priority handler.headers(false, inFinished, streamId, -1, priority, namesAndValues, HeadersMode.HTTP_20_HEADERS); return; } // Read another continuation frame. int w1 = in.readInt(); int w2 = in.readInt(); length = (w1 & 0xffff0000) >> 16; int newType = (w1 & 0xff00) >> 8; flags = w1 & 0xff; // TODO: remove in draft 8: CONTINUATION no longer sets END_STREAM inFinished = (flags & FLAG_END_STREAM) != 0; // boolean u = (w2 & 0x80000000) != 0; // Unused. int newStreamId = (w2 & 0x7fffffff); if (newType != TYPE_CONTINUATION) { throw ioException("TYPE_CONTINUATION didn't have FLAG_END_HEADERS"); } if (newStreamId != streamId) throw ioException("TYPE_CONTINUATION streamId changed"); } } private void readData(Handler handler, int flags, int length, int streamId) throws IOException { boolean inFinished = (flags & FLAG_END_STREAM) != 0; handler.data(inFinished, streamId, in, length); } private void readPriority(Handler handler, int flags, int length, int streamId) throws IOException { if (length != 4) throw ioException("TYPE_PRIORITY length: %d != 4", length); if (streamId == 0) throw ioException("TYPE_PRIORITY streamId == 0"); int w1 = in.readInt(); // boolean r = (w1 & 0x80000000) != 0; // Reserved. int priority = (w1 & 0x7fffffff); handler.priority(streamId, priority); } private void readRstStream(Handler handler, int flags, int length, int streamId) throws IOException { if (length != 4) throw ioException("TYPE_RST_STREAM length: %d != 4", length); if (streamId == 0) throw ioException("TYPE_RST_STREAM streamId == 0"); int errorCodeInt = in.readInt(); ErrorCode errorCode = ErrorCode.fromHttp2(errorCodeInt); if (errorCode == null) { throw ioException("TYPE_RST_STREAM unexpected error code: %d", errorCodeInt); } handler.rstStream(streamId, errorCode); } private void readSettings(Handler handler, int flags, int length, int streamId) throws IOException { if (length % 8 != 0) throw ioException("TYPE_SETTINGS length %% 8 != 0: %s", length); if (streamId != 0) throw ioException("TYPE_SETTINGS streamId != 0"); Settings settings = new Settings(); for (int i = 0; i < length; i += 8) { int w1 = in.readInt(); int value = in.readInt(); // int r = (w1 & 0xff000000) >>> 24; // Reserved. int id = w1 & 0xffffff; settings.set(id, 0, value); } handler.settings(false, settings); } private void readPushPromise(Handler handler, int flags, int length, int streamId) { // TODO: } private void readPing(Handler handler, int flags, int length, int streamId) throws IOException { if (length != 8) throw ioException("TYPE_PING length != 8: %s", length); if (streamId != 0) throw ioException("TYPE_PING streamId != 0"); int payload1 = in.readInt(); int payload2 = in.readInt(); boolean reply = (flags & FLAG_PONG) != 0; handler.ping(reply, payload1, payload2); } private void readGoAway(Handler handler, int flags, int length, int streamId) throws IOException { if (length < 8) throw ioException("TYPE_GOAWAY length < 8: %s", length); int lastStreamId = in.readInt(); int errorCodeInt = in.readInt(); int opaqueDataLength = length - 8; ErrorCode errorCode = ErrorCode.fromHttp2(errorCodeInt); if (errorCode == null) { throw ioException("TYPE_RST_STREAM unexpected error code: %d", errorCodeInt); } if (Util.skipByReading(in, opaqueDataLength) != opaqueDataLength) { throw new IOException("TYPE_GOAWAY opaque data was truncated"); } handler.goAway(lastStreamId, errorCode); } private void readWindowUpdate(Handler handler, int flags, int length, int streamId) throws IOException { int w1 = in.readInt(); // boolean r = (w1 & 0x80000000) != 0; // Reserved. int windowSizeIncrement = (w1 & 0x7fffffff); boolean endFlowControl = (flags & FLAG_END_FLOW_CONTROL) != 0; handler.windowUpdate(streamId, windowSizeIncrement, endFlowControl); } private static IOException ioException(String message, Object... args) throws IOException { throw new IOException(String.format(message, args)); } @Override public void close() throws IOException { in.close(); } } static final class Writer implements FrameWriter { private final DataOutputStream out; private final boolean client; private final ByteArrayOutputStream hpackBuffer; private final Hpack.Writer hpackWriter; Writer(OutputStream out, boolean client) { this.out = new DataOutputStream(out); this.client = client; this.hpackBuffer = new ByteArrayOutputStream(); this.hpackWriter = new Hpack.Writer(hpackBuffer); } @Override public synchronized void flush() throws IOException { out.flush(); } @Override public synchronized void connectionHeader() throws IOException { if (!client) return; // Nothing to write; servers don't send connection headers! out.write(CONNECTION_HEADER); } @Override public synchronized void synStream(boolean outFinished, boolean inFinished, int streamId, int associatedStreamId, int priority, int slot, List<String> nameValueBlock) throws IOException { if (inFinished) throw new UnsupportedOperationException(); headers(outFinished, streamId, priority, nameValueBlock); } @Override public synchronized void synReply(boolean outFinished, int streamId, List<String> nameValueBlock) throws IOException { headers(outFinished, streamId, -1, nameValueBlock); } @Override public synchronized void headers(int streamId, List<String> nameValueBlock) throws IOException { headers(false, streamId, -1, nameValueBlock); } private void headers(boolean outFinished, int streamId, int priority, List<String> nameValueBlock) throws IOException { hpackBuffer.reset(); hpackWriter.writeHeaders(nameValueBlock); int type = TYPE_HEADERS; // TODO: implement CONTINUATION int length = hpackBuffer.size(); int flags = FLAG_END_HEADERS; if (outFinished) flags |= FLAG_END_STREAM; if (priority != -1) flags |= FLAG_PRIORITY; out.writeInt((length & 0xffff) << 16 | (type & 0xff) << 8 | (flags & 0xff)); out.writeInt(streamId & 0x7fffffff); if (priority != -1) out.writeInt(priority & 0x7fffffff); hpackBuffer.writeTo(out); } @Override public synchronized void rstStream(int streamId, ErrorCode errorCode) throws IOException { throw new UnsupportedOperationException("TODO"); } @Override public void data(boolean outFinished, int streamId, byte[] data) throws IOException { data(outFinished, streamId, data, 0, data.length); } @Override public synchronized void data(boolean outFinished, int streamId, byte[] data, int offset, int byteCount) throws IOException { int type = TYPE_DATA; int flags = 0; if (outFinished) flags |= FLAG_END_STREAM; out.writeInt((byteCount & 0xffff) << 16 | (type & 0xff) << 8 | (flags & 0xff)); out.writeInt(streamId & 0x7fffffff); out.write(data, offset, byteCount); } @Override public synchronized void settings(Settings settings) throws IOException { int type = TYPE_SETTINGS; int length = settings.size() * 8; int flags = 0; int streamId = 0; out.writeInt((length & 0xffff) << 16 | (type & 0xff) << 8 | (flags & 0xff)); out.writeInt(streamId & 0x7fffffff); for (int i = 0; i < Settings.COUNT; i++) { if (!settings.isSet(i)) continue; out.writeInt(i & 0xffffff); out.writeInt(settings.get(i)); } } @Override public synchronized void noop() throws IOException { throw new UnsupportedOperationException(); } @Override public synchronized void ping(boolean reply, int payload1, int payload2) throws IOException { // TODO } @Override public synchronized void goAway(int lastGoodStreamId, ErrorCode errorCode) throws IOException { // TODO } @Override public synchronized void windowUpdate(int streamId, int deltaWindowSize) throws IOException { // TODO } @Override public void close() throws IOException { out.close(); } } }