1 /* 2 * Copyright (c) 2004, 2012, 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 sun.security.ssl; 27 28 import java.nio.*; 29 30 /* 31 * A multi-purpose class which handles all of the SSLEngine arguments. 32 * It validates arguments, checks for RO conditions, does space 33 * calculations, performs scatter/gather, etc. 34 * 35 * @author Brad R. Wetmore 36 */ 37 class EngineArgs { 38 39 /* 40 * Keep track of the input parameters. 41 */ 42 ByteBuffer netData; 43 ByteBuffer [] appData; 44 45 private int offset; // offset/len for the appData array. 46 private int len; 47 48 /* 49 * The initial pos/limit conditions. This is useful because we can 50 * quickly calculate the amount consumed/produced in successful 51 * operations, or easily return the buffers to their pre-error 52 * conditions. 53 */ 54 private int netPos; 55 private int netLim; 56 57 private int [] appPoss; 58 private int [] appLims; 59 60 /* 61 * Sum total of the space remaining in all of the appData buffers 62 */ 63 private int appRemaining = 0; 64 65 private boolean wrapMethod; 66 67 /* 68 * Called by the SSLEngine.wrap() method. 69 */ 70 EngineArgs(ByteBuffer [] appData, int offset, int len, 71 ByteBuffer netData) { 72 this.wrapMethod = true; 73 init(netData, appData, offset, len); 74 } 75 76 /* 77 * Called by the SSLEngine.unwrap() method. 78 */ 79 EngineArgs(ByteBuffer netData, ByteBuffer [] appData, int offset, 80 int len) { 81 this.wrapMethod = false; 82 init(netData, appData, offset, len); 83 } 84 85 /* 86 * The main initialization method for the arguments. Most 87 * of them are pretty obvious as to what they do. 88 * 89 * Since we're already iterating over appData array for validity 90 * checking, we also keep track of how much remainging space is 91 * available. Info is used in both unwrap (to see if there is 92 * enough space available in the destination), and in wrap (to 93 * determine how much more we can copy into the outgoing data 94 * buffer. 95 */ 96 private void init(ByteBuffer netData, ByteBuffer [] appData, 97 int offset, int len) { 98 99 if ((netData == null) || (appData == null)) { 100 throw new IllegalArgumentException("src/dst is null"); 101 } 102 103 if ((offset < 0) || (len < 0) || (offset > appData.length - len)) { 104 throw new IndexOutOfBoundsException(); 105 } 106 107 if (wrapMethod && netData.isReadOnly()) { 108 throw new ReadOnlyBufferException(); 109 } 110 111 netPos = netData.position(); 112 netLim = netData.limit(); 113 114 appPoss = new int [appData.length]; 115 appLims = new int [appData.length]; 116 117 for (int i = offset; i < offset + len; i++) { 118 if (appData[i] == null) { 119 throw new IllegalArgumentException( 120 "appData[" + i + "] == null"); 121 } 122 123 /* 124 * If we're unwrapping, then check to make sure our 125 * destination bufffers are writable. 126 */ 127 if (!wrapMethod && appData[i].isReadOnly()) { 128 throw new ReadOnlyBufferException(); 129 } 130 131 appRemaining += appData[i].remaining(); 132 133 appPoss[i] = appData[i].position(); 134 appLims[i] = appData[i].limit(); 135 } 136 137 /* 138 * Ok, looks like we have a good set of args, let's 139 * store the rest of this stuff. 140 */ 141 this.netData = netData; 142 this.appData = appData; 143 this.offset = offset; 144 this.len = len; 145 } 146 147 /* 148 * Given spaceLeft bytes to transfer, gather up that much data 149 * from the appData buffers (starting at offset in the array), 150 * and transfer it into the netData buffer. 151 * 152 * The user has already ensured there is enough room. 153 */ 154 void gather(int spaceLeft) { 155 for (int i = offset; (i < (offset + len)) && (spaceLeft > 0); i++) { 156 int amount = Math.min(appData[i].remaining(), spaceLeft); 157 appData[i].limit(appData[i].position() + amount); 158 netData.put(appData[i]); 159 appRemaining -= amount; 160 spaceLeft -= amount; 161 } 162 } 163 164 /* 165 * Using the supplied buffer, scatter the data into the appData buffers 166 * (starting at offset in the array). 167 * 168 * The user has already ensured there is enough room. 169 */ 170 void scatter(ByteBuffer readyData) { 171 int amountLeft = readyData.remaining(); 172 173 for (int i = offset; (i < (offset + len)) && (amountLeft > 0); 174 i++) { 175 int amount = Math.min(appData[i].remaining(), amountLeft); 176 readyData.limit(readyData.position() + amount); 177 appData[i].put(readyData); 178 amountLeft -= amount; 179 } 180 assert(readyData.remaining() == 0); 181 } 182 183 int getAppRemaining() { 184 return appRemaining; 185 } 186 187 /* 188 * Calculate the bytesConsumed/byteProduced. Aren't you glad 189 * we saved this off earlier? 190 */ 191 int deltaNet() { 192 return (netData.position() - netPos); 193 } 194 195 /* 196 * Calculate the bytesConsumed/byteProduced. Aren't you glad 197 * we saved this off earlier? 198 */ 199 int deltaApp() { 200 int sum = 0; // Only calculating 2^14 here, don't need a long. 201 202 for (int i = offset; i < offset + len; i++) { 203 sum += appData[i].position() - appPoss[i]; 204 } 205 206 return sum; 207 } 208 209 /* 210 * In the case of Exception, we want to reset the positions 211 * to appear as though no data has been consumed or produced. 212 * 213 * Currently, this method is only called as we are preparing to 214 * fail out, and thus we don't need to actually recalculate 215 * appRemaining. If that assumption changes, that variable should 216 * be updated here. 217 */ 218 void resetPos() { 219 netData.position(netPos); 220 for (int i = offset; i < offset + len; i++) { 221 // See comment above about recalculating appRemaining. 222 appData[i].position(appPoss[i]); 223 } 224 } 225 226 /* 227 * We are doing lots of ByteBuffer manipulations, in which case 228 * we need to make sure that the limits get set back correctly. 229 * This is one of the last things to get done before returning to 230 * the user. 231 */ 232 void resetLim() { 233 netData.limit(netLim); 234 for (int i = offset; i < offset + len; i++) { 235 appData[i].limit(appLims[i]); 236 } 237 } 238 } 239
