| /* |
| * Copyright (c) 2004, 2012, 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 sun.security.ssl; |
| |
| import java.nio.*; |
| |
| /* |
| * A multi-purpose class which handles all of the SSLEngine arguments. |
| * It validates arguments, checks for RO conditions, does space |
| * calculations, performs scatter/gather, etc. |
| * |
| * @author Brad R. Wetmore |
| */ |
| class EngineArgs { |
| |
| /* |
| * Keep track of the input parameters. |
| */ |
| ByteBuffer netData; |
| ByteBuffer [] appData; |
| |
| private int offset; // offset/len for the appData array. |
| private int len; |
| |
| /* |
| * The initial pos/limit conditions. This is useful because we can |
| * quickly calculate the amount consumed/produced in successful |
| * operations, or easily return the buffers to their pre-error |
| * conditions. |
| */ |
| private int netPos; |
| private int netLim; |
| |
| private int [] appPoss; |
| private int [] appLims; |
| |
| /* |
| * Sum total of the space remaining in all of the appData buffers |
| */ |
| private int appRemaining = 0; |
| |
| private boolean wrapMethod; |
| |
| /* |
| * Called by the SSLEngine.wrap() method. |
| */ |
| EngineArgs(ByteBuffer [] appData, int offset, int len, |
| ByteBuffer netData) { |
| this.wrapMethod = true; |
| init(netData, appData, offset, len); |
| } |
| |
| /* |
| * Called by the SSLEngine.unwrap() method. |
| */ |
| EngineArgs(ByteBuffer netData, ByteBuffer [] appData, int offset, |
| int len) { |
| this.wrapMethod = false; |
| init(netData, appData, offset, len); |
| } |
| |
| /* |
| * The main initialization method for the arguments. Most |
| * of them are pretty obvious as to what they do. |
| * |
| * Since we're already iterating over appData array for validity |
| * checking, we also keep track of how much remainging space is |
| * available. Info is used in both unwrap (to see if there is |
| * enough space available in the destination), and in wrap (to |
| * determine how much more we can copy into the outgoing data |
| * buffer. |
| */ |
| private void init(ByteBuffer netData, ByteBuffer [] appData, |
| int offset, int len) { |
| |
| if ((netData == null) || (appData == null)) { |
| throw new IllegalArgumentException("src/dst is null"); |
| } |
| |
| if ((offset < 0) || (len < 0) || (offset > appData.length - len)) { |
| throw new IndexOutOfBoundsException(); |
| } |
| |
| if (wrapMethod && netData.isReadOnly()) { |
| throw new ReadOnlyBufferException(); |
| } |
| |
| netPos = netData.position(); |
| netLim = netData.limit(); |
| |
| appPoss = new int [appData.length]; |
| appLims = new int [appData.length]; |
| |
| for (int i = offset; i < offset + len; i++) { |
| if (appData[i] == null) { |
| throw new IllegalArgumentException( |
| "appData[" + i + "] == null"); |
| } |
| |
| /* |
| * If we're unwrapping, then check to make sure our |
| * destination bufffers are writable. |
| */ |
| if (!wrapMethod && appData[i].isReadOnly()) { |
| throw new ReadOnlyBufferException(); |
| } |
| |
| appRemaining += appData[i].remaining(); |
| |
| appPoss[i] = appData[i].position(); |
| appLims[i] = appData[i].limit(); |
| } |
| |
| /* |
| * Ok, looks like we have a good set of args, let's |
| * store the rest of this stuff. |
| */ |
| this.netData = netData; |
| this.appData = appData; |
| this.offset = offset; |
| this.len = len; |
| } |
| |
| /* |
| * Given spaceLeft bytes to transfer, gather up that much data |
| * from the appData buffers (starting at offset in the array), |
| * and transfer it into the netData buffer. |
| * |
| * The user has already ensured there is enough room. |
| */ |
| void gather(int spaceLeft) { |
| for (int i = offset; (i < (offset + len)) && (spaceLeft > 0); i++) { |
| int amount = Math.min(appData[i].remaining(), spaceLeft); |
| appData[i].limit(appData[i].position() + amount); |
| netData.put(appData[i]); |
| appRemaining -= amount; |
| spaceLeft -= amount; |
| } |
| } |
| |
| /* |
| * Using the supplied buffer, scatter the data into the appData buffers |
| * (starting at offset in the array). |
| * |
| * The user has already ensured there is enough room. |
| */ |
| void scatter(ByteBuffer readyData) { |
| int amountLeft = readyData.remaining(); |
| |
| for (int i = offset; (i < (offset + len)) && (amountLeft > 0); |
| i++) { |
| int amount = Math.min(appData[i].remaining(), amountLeft); |
| readyData.limit(readyData.position() + amount); |
| appData[i].put(readyData); |
| amountLeft -= amount; |
| } |
| assert(readyData.remaining() == 0); |
| } |
| |
| int getAppRemaining() { |
| return appRemaining; |
| } |
| |
| /* |
| * Calculate the bytesConsumed/byteProduced. Aren't you glad |
| * we saved this off earlier? |
| */ |
| int deltaNet() { |
| return (netData.position() - netPos); |
| } |
| |
| /* |
| * Calculate the bytesConsumed/byteProduced. Aren't you glad |
| * we saved this off earlier? |
| */ |
| int deltaApp() { |
| int sum = 0; // Only calculating 2^14 here, don't need a long. |
| |
| for (int i = offset; i < offset + len; i++) { |
| sum += appData[i].position() - appPoss[i]; |
| } |
| |
| return sum; |
| } |
| |
| /* |
| * In the case of Exception, we want to reset the positions |
| * to appear as though no data has been consumed or produced. |
| * |
| * Currently, this method is only called as we are preparing to |
| * fail out, and thus we don't need to actually recalculate |
| * appRemaining. If that assumption changes, that variable should |
| * be updated here. |
| */ |
| void resetPos() { |
| netData.position(netPos); |
| for (int i = offset; i < offset + len; i++) { |
| // See comment above about recalculating appRemaining. |
| appData[i].position(appPoss[i]); |
| } |
| } |
| |
| /* |
| * We are doing lots of ByteBuffer manipulations, in which case |
| * we need to make sure that the limits get set back correctly. |
| * This is one of the last things to get done before returning to |
| * the user. |
| */ |
| void resetLim() { |
| netData.limit(netLim); |
| for (int i = offset; i < offset + len; i++) { |
| appData[i].limit(appLims[i]); |
| } |
| } |
| } |