1 /* 2 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package java.net.http; 27 28 import java.io.IOException; 29 import java.nio.ByteBuffer; 30 import java.nio.channels.ByteChannel; 31 import java.nio.channels.GatheringByteChannel; 32 import java.nio.channels.SelectableChannel; 33 import java.nio.channels.SelectionKey; 34 import java.nio.channels.SocketChannel; 35 36 // 37 // Used to implement WebSocket. Each RawChannel corresponds to a TCP connection 38 // (SocketChannel) but is connected to a Selector and an ExecutorService for 39 // invoking the send and receive callbacks. Also includes SSL processing. 40 // 41 final class RawChannel implements ByteChannel, GatheringByteChannel { 42 43 private final HttpClientImpl client; 44 private final HttpConnection connection; 45 46 private interface RawEvent { 47 48 /** 49 * must return the selector interest op flags OR'd. 50 */ 51 int interestOps(); 52 53 /** 54 * called when event occurs. 55 */ 56 void handle(); 57 } 58 59 interface NonBlockingEvent extends RawEvent { 60 } 61 62 RawChannel(HttpClientImpl client, HttpConnection connection) 63 throws IOException { 64 this.client = client; 65 this.connection = connection; 66 SocketChannel chan = connection.channel(); 67 client.cancelRegistration(chan); 68 chan.configureBlocking(false); 69 } 70 71 SocketChannel socketChannel() { 72 return connection.channel(); 73 } 74 75 ByteBuffer getRemaining() { 76 return connection.getRemaining(); 77 } 78 79 private class RawAsyncEvent extends AsyncEvent { 80 81 private final RawEvent re; 82 83 RawAsyncEvent(RawEvent re) { 84 super(AsyncEvent.BLOCKING); // BLOCKING & !REPEATING 85 this.re = re; 86 } 87 88 RawAsyncEvent(RawEvent re, int flags) { 89 super(flags); 90 this.re = re; 91 } 92 93 @Override 94 public SelectableChannel channel() { 95 return connection.channel(); 96 } 97 98 // must return the selector interest op flags OR'd 99 @Override 100 public int interestOps() { 101 return re.interestOps(); 102 } 103 104 // called when event occurs 105 @Override 106 public void handle() { 107 re.handle(); 108 } 109 110 @Override 111 public void abort() { } 112 } 113 114 private class NonBlockingRawAsyncEvent extends RawAsyncEvent { 115 116 NonBlockingRawAsyncEvent(RawEvent re) { 117 super(re, 0); // !BLOCKING & !REPEATING 118 } 119 } 120 121 /* 122 * Register given event whose callback will be called once only. 123 * (i.e. register new event for each callback) 124 */ 125 public void registerEvent(RawEvent event) throws IOException { 126 if (!(event instanceof NonBlockingEvent)) { 127 throw new InternalError(); 128 } 129 if ((event.interestOps() & SelectionKey.OP_READ) != 0 130 && connection.buffer.hasRemaining()) { 131 // FIXME: a hack to deal with leftovers from previous reads into an 132 // internal buffer (works in conjunction with change in 133 // java.net.http.PlainHttpConnection.readImpl(java.nio.ByteBuffer) 134 connection.channel().configureBlocking(false); 135 event.handle(); 136 } else { 137 client.registerEvent(new NonBlockingRawAsyncEvent(event)); 138 } 139 } 140 141 @Override 142 public int read(ByteBuffer dst) throws IOException { 143 assert !connection.channel().isBlocking(); 144 return connection.read(dst); 145 } 146 147 @Override 148 public boolean isOpen() { 149 return connection.isOpen(); 150 } 151 152 @Override 153 public void close() throws IOException { 154 connection.close(); 155 } 156 157 @Override 158 public long write(ByteBuffer[] src) throws IOException { 159 return connection.write(src, 0, src.length); 160 } 161 162 @Override 163 public long write(ByteBuffer[] src, int offset, int len) 164 throws IOException { 165 return connection.write(src, offset, len); 166 } 167 168 @Override 169 public int write(ByteBuffer src) throws IOException { 170 return (int) connection.write(src); 171 } 172 }