| package gnu.javax.net.ssl.provider; | |
| import java.io.PrintWriter; | |
| import java.io.StringWriter; | |
| import java.nio.ByteBuffer; | |
| import java.nio.ByteOrder; | |
| import java.util.ConcurrentModificationException; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.ListIterator; | |
| import java.util.NoSuchElementException; | |
| /** | |
| * A list of extensions, that may appear in either the {@link ClientHello} or | |
| * {@link ServerHello}. The form of the extensions list is: | |
| * | |
| * <tt> Extension extensions_list<1..2^16-1></tt> | |
| * | |
| * @author csm | |
| */ | |
| public class ExtensionList implements Builder, Iterable<Extension> | |
| { | |
| private final ByteBuffer buffer; | |
| private int modCount; | |
| public ExtensionList (ByteBuffer buffer) | |
| { | |
| this.buffer = buffer.duplicate().order(ByteOrder.BIG_ENDIAN); | |
| modCount = 0; | |
| } | |
| public ExtensionList(List<Extension> extensions) | |
| { | |
| int length = 2; | |
| for (Extension extension : extensions) | |
| length += extension.length(); | |
| buffer = ByteBuffer.allocate(length); | |
| buffer.putShort((short) (length - 2)); | |
| for (Extension extension : extensions) | |
| buffer.put(extension.buffer()); | |
| buffer.rewind(); | |
| } | |
| public ByteBuffer buffer() | |
| { | |
| return (ByteBuffer) buffer.duplicate().limit(length()); | |
| } | |
| public Extension get (final int index) | |
| { | |
| int length = length (); | |
| int i; | |
| int n = 0; | |
| for (i = 2; i < length && n < index; ) | |
| { | |
| int l = buffer.getShort (i+2) & 0xFFFF; | |
| i += l + 4; | |
| n++; | |
| } | |
| if (n < index) | |
| throw new IndexOutOfBoundsException ("no elemenet at " + index); | |
| int el = buffer.getShort (i+2) & 0xFFFF; | |
| ByteBuffer b = (ByteBuffer) buffer.duplicate().position(i).limit(i+el+4); | |
| return new Extension(b.slice()); | |
| } | |
| /** | |
| * Returns the number of extensions this list contains. | |
| * | |
| * @return The number of extensions. | |
| */ | |
| public int size () | |
| { | |
| int length = length (); | |
| if (length == 0) | |
| return 0; | |
| int n = 0; | |
| for (int i = 2; i < length; ) | |
| { | |
| int len = buffer.getShort (i+2) & 0xFFFF; | |
| i += len + 4; | |
| n++; | |
| } | |
| return n; | |
| } | |
| /** | |
| * Returns the length of this extension list, in bytes. | |
| * | |
| * @return The length of this extension list, in bytes. | |
| */ | |
| public int length () | |
| { | |
| return (buffer.getShort (0) & 0xFFFF) + 2; | |
| } | |
| /** | |
| * Sets the extension at index <i>i</i> to <i>e</i>. Note that setting an | |
| * element at an index <b>may</b> invalidate any other elements that come | |
| * after element at index <i>i</i>. In other words, no attempt is made to | |
| * move existing elements in this list, and since extensions are variable | |
| * length, you can <em>not</em> guarantee that extensions later in the list | |
| * will still be valid. | |
| * | |
| * <p>Thus, elements of this list <b>must</b> be set in order of increasing | |
| * index. | |
| * | |
| * @param index The index to set the extension at. | |
| * @param e The extension. | |
| * @throws java.nio.BufferOverflowException If setting the extension overflows | |
| * the buffer. | |
| * @throws IllegalArgumentException If it isn't possible to find the given index | |
| * in the current list (say, if no element index - 1 is set), or if setting | |
| * the extension will overflow the current list length (given by {@link | |
| * #length()}). | |
| */ | |
| public void set (final int index, Extension e) | |
| { | |
| int length = length(); | |
| int n = 0; | |
| int i; | |
| for (i = 2; i < length && n < index; ) | |
| { | |
| int len = buffer.getShort(i+2) & 0xFFFF; | |
| i += len + 4; | |
| n++; | |
| } | |
| if (n < index) | |
| throw new IllegalArgumentException("nothing set at index " + (index-1) | |
| + " or insufficient space"); | |
| if (i + e.length() + 2 > length) | |
| throw new IllegalArgumentException("adding this element will exceed the " | |
| + "list length"); | |
| buffer.putShort(i, (short) e.type().getValue()); | |
| buffer.putShort(i+2, (short) e.length()); | |
| ((ByteBuffer) buffer.duplicate().position(i+4)).put (e.valueBuffer()); | |
| modCount++; | |
| } | |
| /** | |
| * Reserve space for an extension at index <i>i</i> in the list. In other | |
| * words, this does the job of {@link #set(int, Extension)}, but does not | |
| * copy the extension value to the underlying buffer. | |
| * | |
| * @param index The index of the extension to reserve space for. | |
| * @param t The type of the extension. | |
| * @param eLength The number of bytes to reserve for this extension. The total | |
| * number of bytes used by this method is this length, plus four. | |
| */ | |
| public void set (final int index, Extension.Type t, final int eLength) | |
| { | |
| int length = length (); | |
| int n = 0; | |
| int i; | |
| for (i = 2; i < length && n < index; ) | |
| { | |
| int len = buffer.getShort (i+2) & 0xFFFF; | |
| i += len + 4; | |
| n++; | |
| } | |
| if (n < index) | |
| throw new IllegalArgumentException ("nothing set at index " + (index-1) | |
| + " or insufficient space"); | |
| if (i + eLength + 2 > length) | |
| throw new IllegalArgumentException ("adding this element will exceed the " | |
| + "list length"); | |
| buffer.putShort(i, (short) t.getValue()); | |
| buffer.putShort(i+2, (short) eLength); | |
| modCount++; | |
| } | |
| /** | |
| * Set the total length of this list, in bytes. | |
| * | |
| * @param newLength The new list length. | |
| */ | |
| public void setLength (final int newLength) | |
| { | |
| if (newLength < 0 || newLength > 65535) | |
| throw new IllegalArgumentException ("invalid length"); | |
| buffer.putShort (0, (short) newLength); | |
| modCount++; | |
| } | |
| public Iterator<Extension> iterator() | |
| { | |
| return new ExtensionsIterator(); | |
| } | |
| public String toString() | |
| { | |
| return toString (null); | |
| } | |
| public String toString(final String prefix) | |
| { | |
| StringWriter str = new StringWriter(); | |
| PrintWriter out = new PrintWriter(str); | |
| if (prefix != null) out.print(prefix); | |
| out.println("ExtensionList {"); | |
| if (prefix != null) out.print(prefix); | |
| out.print(" length = "); | |
| out.print(length()); | |
| out.println(";"); | |
| String subprefix = " "; | |
| if (prefix != null) | |
| subprefix = prefix + subprefix; | |
| for (Extension e : this) | |
| out.println(e.toString(subprefix)); | |
| if (prefix != null) out.print(prefix); | |
| out.print("};"); | |
| return str.toString(); | |
| } | |
| /** | |
| * List iterator interface to an extensions list. | |
| * | |
| * @author csm@gnu.org | |
| */ | |
| public final class ExtensionsIterator implements ListIterator<Extension> | |
| { | |
| private final int modCount; | |
| private int index; | |
| private final int size; | |
| public ExtensionsIterator () | |
| { | |
| this.modCount = ExtensionList.this.modCount; | |
| index = 0; | |
| size = size (); | |
| } | |
| public boolean hasNext() | |
| { | |
| return index < size; | |
| } | |
| public boolean hasPrevious() | |
| { | |
| return index > 0; | |
| } | |
| public Extension next() throws NoSuchElementException | |
| { | |
| if (modCount != ExtensionList.this.modCount) | |
| throw new ConcurrentModificationException (); | |
| if (!hasNext ()) | |
| throw new NoSuchElementException (); | |
| return get (index++); | |
| } | |
| public Extension previous() throws NoSuchElementException | |
| { | |
| if (modCount != ExtensionList.this.modCount) | |
| throw new ConcurrentModificationException (); | |
| if (!hasPrevious ()) | |
| throw new NoSuchElementException (); | |
| return get (--index); | |
| } | |
| public int nextIndex() | |
| { | |
| if (hasNext ()) | |
| return index + 1; | |
| return index; | |
| } | |
| public int previousIndex() | |
| { | |
| if (hasPrevious ()) | |
| return index - 1; | |
| return -1; | |
| } | |
| public void add(Extension e) | |
| { | |
| throw new UnsupportedOperationException ("cannot add items to this iterator"); | |
| } | |
| public void remove() | |
| { | |
| throw new UnsupportedOperationException ("cannot remove items from this iterator"); | |
| } | |
| public void set(Extension e) | |
| { | |
| ExtensionList.this.set (index, e); | |
| } | |
| } | |
| } |