airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From lah...@apache.org
Subject [04/13] airavata git commit: Fixed the disribution and tested the SSH protocol communication to different machines. AIRAVATA-1585 AIRAVATA-1595
Date Wed, 25 Feb 2015 06:09:45 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/9a6eaaae/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/CircularByteBuffer.java
----------------------------------------------------------------------
diff --git a/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/CircularByteBuffer.java b/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/CircularByteBuffer.java
index 8d4d339..47a946f 100644
--- a/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/CircularByteBuffer.java
+++ b/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/CircularByteBuffer.java
@@ -1,824 +1,824 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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 edu.illinois.ncsa.BCGSS;
-/*
- * Circular Byte Buffer
- * Copyright (C) 2002 Stephen Ostermiller
- * http://ostermiller.org/contact.pl?regarding=Java+Utilities
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 for more details.
- *
- * See COPYING.TXT for details.
- */
-
-
-import java.io.*;
-import java.nio.*;
-
-/**
- * Implements the Circular Buffer producer/consumer model for bytes.
- * More information about this class is available from <a target="_top" href=
- * "http://ostermiller.org/utils/CircularByteBuffer.html">ostermiller.org</a>.
- * <p>
- * Using this class is a simpler alternative to using a PipedInputStream
- * and a PipedOutputStream. PipedInputStreams and PipedOutputStreams don't support the
- * mark operation, don't allow you to control buffer sizes that they use,
- * and have a more complicated API that requires instantiating two
- * classes and connecting them.
- * <p>
- * This class is thread safe.
- *
- */
-public class CircularByteBuffer {
-
-	/**
-	 * The default size for a circular byte buffer.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	private final static int DEFAULT_SIZE = 1024;
-
-	/**
-	 * A buffer that will grow as things are added.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public final static int INFINITE_SIZE = -1;
-
-	/**
-	 * The circular buffer.
-	 * <p>
-	 * The actual capacity of the buffer is one less than the actual length
-	 * of the buffer so that an empty and a full buffer can be
-	 * distinguished.  An empty buffer will have the markPostion and the
-	 * writePosition equal to each other.  A full buffer will have
-	 * the writePosition one less than the markPostion.
-	 * <p>
-	 * There are three important indexes into the buffer:
-	 * The readPosition, the writePosition, and the markPosition.
-	 * If the InputStream has never been marked, the readPosition and
-	 * the markPosition should always be the same.  The bytes
-	 * available to be read go from the readPosition to the writePosition,
-	 * wrapping around the end of the buffer.  The space available for writing
-	 * goes from the write position to one less than the markPosition,
-	 * wrapping around the end of the buffer.  The bytes that have
-	 * been saved to support a reset() of the InputStream go from markPosition
-	 * to readPosition, wrapping around the end of the buffer.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected byte[] buffer;
-	/**
-	 * Index of the first byte available to be read.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected volatile int readPosition = 0;
-	/**
-	 * Index of the first byte available to be written.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected volatile int writePosition = 0;
-	/**
-	 * Index of the first saved byte. (To support stream marking.)
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected volatile int markPosition = 0;
-	/**
-	 * Number of bytes that have to be saved
-	 * to support mark() and reset() on the InputStream.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected volatile int markSize = 0;
-	/**
-	 * If this buffer is infinite (should resize itself when full)
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected volatile boolean infinite = false;
-	/**
-	 * True if a write to a full buffer should block until the buffer
-	 * has room, false if the write method should throw an IOException
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected boolean blockingWrite = true;
-	/**
-	 * The InputStream that can empty this buffer.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected InputStream in = new CircularByteBufferInputStream();
-	/**
-	 * true if the close() method has been called on the InputStream
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected boolean inputStreamClosed = false;
-	/**
-	 * The OutputStream that can fill this buffer.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected OutputStream out = new CircularByteBufferOutputStream();
-	/**
-	 * true if the close() method has been called on the OutputStream
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected boolean outputStreamClosed = false;
-
-	/**
-	 * Make this buffer ready for reuse.  The contents of the buffer
-	 * will be cleared and the streams associated with this buffer
-	 * will be reopened if they had been closed.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public void clear(){
-		synchronized (this){
-			readPosition = 0;
-			writePosition = 0;
-			markPosition = 0;
-			outputStreamClosed = false;
-			inputStreamClosed = false;
-		}
-	}
-
-	/**
-	 * Retrieve a OutputStream that can be used to fill
-	 * this buffer.
-	 * <p>
-	 * Write methods may throw a BufferOverflowException if
-	 * the buffer is not large enough.  A large enough buffer
-	 * size must be chosen so that this does not happen or
-	 * the caller must be prepared to catch the exception and
-	 * try again once part of the buffer has been consumed.
-	 *
-	 *
-	 * @return the producer for this buffer.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public OutputStream getOutputStream(){
-		return out;
-	}
-
-	/**
-	 * Retrieve a InputStream that can be used to empty
-	 * this buffer.
-	 * <p>
-	 * This InputStream supports marks at the expense
-	 * of the buffer size.
-	 *
-	 * @return the consumer for this buffer.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public InputStream getInputStream(){
-		return in;
-	}
-
-	/**
-	 * Get number of bytes that are available to be read.
-	 * <p>
-	 * Note that the number of bytes available plus
-	 * the number of bytes free may not add up to the
-	 * capacity of this buffer, as the buffer may reserve some
-	 * space for other purposes.
-	 *
-	 * @return the size in bytes of this buffer
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public int getAvailable(){
-		synchronized (this){
-			return available();
-		}
-	}
-
-	/**
-	 * Get the number of bytes this buffer has free for
-	 * writing.
-	 * <p>
-	 * Note that the number of bytes available plus
-	 * the number of bytes free may not add up to the
-	 * capacity of this buffer, as the buffer may reserve some
-	 * space for other purposes.
-	 *
-	 * @return the available space in bytes of this buffer
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public int getSpaceLeft(){
-		synchronized (this){
-			return spaceLeft();
-		}
-	}
-
-	/**
-	 * Get the capacity of this buffer.
-	 * <p>
-	 * Note that the number of bytes available plus
-	 * the number of bytes free may not add up to the
-	 * capacity of this buffer, as the buffer may reserve some
-	 * space for other purposes.
-	 *
-	 * @return the size in bytes of this buffer
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public int getSize(){
-		synchronized (this){
-			return buffer.length;
-		}
-	}
-
-	/**
-	 * double the size of the buffer
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	private void resize(){
-		byte[] newBuffer = new byte[buffer.length * 2];
-		int marked = marked();
-		int available = available();
-		if (markPosition <= writePosition){
-			// any space between the mark and
-			// the first write needs to be saved.
-			// In this case it is all in one piece.
-			int length = writePosition - markPosition;
-			System.arraycopy(buffer, markPosition, newBuffer, 0, length);
-		} else {
-			int length1 = buffer.length - markPosition;
-			System.arraycopy(buffer, markPosition, newBuffer, 0, length1);
-			int length2 = writePosition;
-			System.arraycopy(buffer, 0, newBuffer, length1, length2);
-		}
-		buffer = newBuffer;
-		markPosition = 0;
-		readPosition = marked;
-		writePosition = marked + available;
-	}
-
-	/**
-	 * Space available in the buffer which can be written.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	private int spaceLeft(){
-		if (writePosition < markPosition){
-			// any space between the first write and
-			// the mark except one byte is available.
-			// In this case it is all in one piece.
-			return (markPosition - writePosition - 1);
-		}
-		// space at the beginning and end.
-		return ((buffer.length - 1) - (writePosition - markPosition));
-	}
-
-	/**
-	 * Bytes available for reading.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	private int available(){
-		if (readPosition <= writePosition){
-			// any space between the first read and
-			// the first write is available.  In this case i
-			// is all in one piece.
-			return (writePosition - readPosition);
-		}
-		// space at the beginning and end.
-		return (buffer.length - (readPosition - writePosition));
-	}
-
-	/**
-	 * Bytes saved for supporting marks.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	private int marked(){
-		if (markPosition <= readPosition){
-			// any space between the markPosition and
-			// the first write is marked.  In this case i
-			// is all in one piece.
-			return (readPosition - markPosition);
-		}
-		// space at the beginning and end.
-		return (buffer.length - (markPosition - readPosition));
-	}
-
-	/**
-	 * If we have passed the markSize reset the
-	 * mark so that the space can be used.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	private void ensureMark(){
-		if (marked() >= markSize){
-			markPosition = readPosition;
-			markSize = 0;
-		}
-	}
-
-	/**
-	 * Create a new buffer with a default capacity.
-	 * Writing to a full buffer will block until space
-	 * is available rather than throw an exception.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public CircularByteBuffer(){
-		this (DEFAULT_SIZE, true);
-	}
-
-	/**
-	 * Create a new buffer with given capacity.
-	 * Writing to a full buffer will block until space
-	 * is available rather than throw an exception.
-	 * <p>
-	 * Note that the buffer may reserve some bytes for
-	 * special purposes and capacity number of bytes may
-	 * not be able to be written to the buffer.
-	 * <p>
-	 * Note that if the buffer is of INFINITE_SIZE it will
-	 * neither block or throw exceptions, but rather grow
-	 * without bound.
-	 *
-	 * @param size desired capacity of the buffer in bytes or CircularByteBuffer.INFINITE_SIZE.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public CircularByteBuffer(int size){
-		this (size, true);
-	}
-
-	/**
-	 * Create a new buffer with a default capacity and
-	 * given blocking behavior.
-	 *
-	 * @param blockingWrite true writing to a full buffer should block
-	 *        until space is available, false if an exception should
-	 *        be thrown instead.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public CircularByteBuffer(boolean blockingWrite){
-		this (DEFAULT_SIZE, blockingWrite);
-	}
-
-	/**
-	 * Create a new buffer with the given capacity and
-	 * blocking behavior.
-	 * <p>
-	 * Note that the buffer may reserve some bytes for
-	 * special purposes and capacity number of bytes may
-	 * not be able to be written to the buffer.
-	 * <p>
-	 * Note that if the buffer is of INFINITE_SIZE it will
-	 * neither block or throw exceptions, but rather grow
-	 * without bound.
-	 *
-	 * @param size desired capacity of the buffer in bytes or CircularByteBuffer.INFINITE_SIZE.
-	 * @param blockingWrite true writing to a full buffer should block
-	 *        until space is available, false if an exception should
-	 *        be thrown instead.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	public CircularByteBuffer(int size, boolean blockingWrite){
-		if (size == INFINITE_SIZE){
-			buffer = new byte[DEFAULT_SIZE];
-			infinite = true;
-		} else {
-			buffer = new byte[size];
-			infinite = false;
-		}
-		this.blockingWrite = blockingWrite;
-	}
-
-	/**
-	 * Class for reading from a circular byte buffer.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected class CircularByteBufferInputStream extends InputStream {
-
-		/**
-		 * Returns the number of bytes that can be read (or skipped over) from this
-		 * input stream without blocking by the next caller of a method for this input
-		 * stream. The next caller might be the same thread or or another thread.
-		 *
-		 * @return the number of bytes that can be read from this input stream without blocking.
-		 * @throws IOException if the stream is closed.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public int available() throws IOException {
-			synchronized (CircularByteBuffer.this){
-				if (inputStreamClosed) throw new IOException("InputStream has been closed, it is not ready.");
-				return (CircularByteBuffer.this.available());
-			}
-		}
-
-		/**
-		 * Close the stream. Once a stream has been closed, further read(), available(),
-		 * mark(), or reset() invocations will throw an IOException. Closing a
-		 * previously-closed stream, however, has no effect.
-		 *
-		 * @throws IOException never.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void close() throws IOException {
-			synchronized (CircularByteBuffer.this){
-				inputStreamClosed = true;
-			}
-		}
-
-		/**
-		 * Mark the present position in the stream. Subsequent calls to reset() will
-		 * attempt to reposition the stream to this point.
-		 * <p>
-		 * The readAheadLimit must be less than the size of circular buffer, otherwise
-		 * this method has no effect.
-		 *
-		 * @param readAheadLimit Limit on the number of bytes that may be read while
-		 *    still preserving the mark. After reading this many bytes, attempting to
-		 *    reset the stream will fail.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void mark(int readAheadLimit) {
-			synchronized (CircularByteBuffer.this){
-				//if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot mark a closed InputStream.");
-				if (buffer.length - 1 > readAheadLimit) {
-					markSize = readAheadLimit;
-					markPosition = readPosition;
-				}
-			}
-		}
-
-		/**
-		 * Tell whether this stream supports the mark() operation.
-		 *
-		 * @return true, mark is supported.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public boolean markSupported() {
-			return true;
-		}
-
-		/**
-		 * Read a single byte.
-		 * This method will block until a byte is available, an I/O error occurs,
-		 * or the end of the stream is reached.
-		 *
-		 * @return The byte read, as an integer in the range 0 to 255 (0x00-0xff),
-		 *     or -1 if the end of the stream has been reached
-		 * @throws IOException if the stream is closed.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public int read() throws IOException {
-			while (true){
-				synchronized (CircularByteBuffer.this){
-					if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot read from a closed InputStream.");
-					int available = CircularByteBuffer.this.available();
-					if (available > 0){
-						int result = buffer[readPosition] & 0xff;
-						readPosition++;
-						if (readPosition == buffer.length){
-							readPosition = 0;
-						}
-						ensureMark();
-						return result;
-					} else if (outputStreamClosed){
-						return -1;
-					}
-				}
-				try {
-					Thread.sleep(100);
-				} catch(Exception x){
-					throw new IOException("Blocking read operation interrupted.");
-				}
-			}
-		}
-
-		/**
-		 * Read bytes into an array.
-		 * This method will block until some input is available,
-		 * an I/O error occurs, or the end of the stream is reached.
-		 *
-		 * @param cbuf Destination buffer.
-		 * @return The number of bytes read, or -1 if the end of
-		 *   the stream has been reached
-		 * @throws IOException if the stream is closed.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public int read(byte[] cbuf) throws IOException {
-			return read(cbuf, 0, cbuf.length);
-		}
-
-		/**
-		 * Read bytes into a portion of an array.
-		 * This method will block until some input is available,
-		 * an I/O error occurs, or the end of the stream is reached.
-		 *
-		 * @param cbuf Destination buffer.
-		 * @param off Offset at which to start storing bytes.
-		 * @param len Maximum number of bytes to read.
-		 * @return The number of bytes read, or -1 if the end of
-		 *   the stream has been reached
-		 * @throws IOException if the stream is closed.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public int read(byte[] cbuf, int off, int len) throws IOException {
-			while (true){
-				synchronized (CircularByteBuffer.this){
-					if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot read from a closed InputStream.");
-					int available = CircularByteBuffer.this.available();
-					if (available > 0){
-						int length = Math.min(len, available);
-						int firstLen = Math.min(length, buffer.length - readPosition);
-						int secondLen = length - firstLen;
-						System.arraycopy(buffer, readPosition, cbuf, off, firstLen);
-						if (secondLen > 0){
-							System.arraycopy(buffer, 0, cbuf, off+firstLen,  secondLen);
-							readPosition = secondLen;
-						} else {
-							readPosition += length;
-						}
-						if (readPosition == buffer.length) {
-							readPosition = 0;
-						}
-						ensureMark();
-						return length;
-					} else if (outputStreamClosed){
-						return -1;
-					}
-				}
-				try {
-					Thread.sleep(100);
-				} catch(Exception x){
-					throw new IOException("Blocking read operation interrupted.");
-				}
-			}
-		}
-
-		/**
-		 * Reset the stream.
-		 * If the stream has been marked, then attempt to reposition i
-		 * at the mark. If the stream has not been marked, or more bytes
-		 * than the readAheadLimit have been read, this method has no effect.
-		 *
-		 * @throws IOException if the stream is closed.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void reset() throws IOException {
-			synchronized (CircularByteBuffer.this){
-				if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot reset a closed InputStream.");
-				readPosition = markPosition;
-			}
-		}
-
-		/**
-		 * Skip bytes.
-		 * This method will block until some bytes are available,
-		 * an I/O error occurs, or the end of the stream is reached.
-		 *
-		 * @param n The number of bytes to skip
-		 * @return The number of bytes actually skipped
-		 * @throws IllegalArgumentException if n is negative.
-		 * @throws IOException if the stream is closed.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public long skip(long n) throws IOException, IllegalArgumentException {
-			while (true){
-				synchronized (CircularByteBuffer.this){
-					if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot skip bytes on a closed InputStream.");
-					int available = CircularByteBuffer.this.available();
-					if (available > 0){
-						int length = Math.min((int)n, available);
-						int firstLen = Math.min(length, buffer.length - readPosition);
-						int secondLen = length - firstLen;
-						if (secondLen > 0){
-							readPosition = secondLen;
-						} else {
-							readPosition += length;
-						}
-						if (readPosition == buffer.length) {
-							readPosition = 0;
-						}
-						ensureMark();
-						return length;
-					} else if (outputStreamClosed){
-						return 0;
-					}
-				}
-				try {
-					Thread.sleep(100);
-				} catch(Exception x){
-					throw new IOException("Blocking read operation interrupted.");
-				}
-			}
-		}
-	}
-
-	/**
-	 * Class for writing to a circular byte buffer.
-	 * If the buffer is full, the writes will either block
-	 * until there is some space available or throw an IOException
-	 * based on the CircularByteBuffer's preference.
-	 *
-	 * @since ostermillerutils 1.00.00
-	 */
-	protected class CircularByteBufferOutputStream extends OutputStream {
-
-		/**
-		 * Close the stream, flushing it first.
-		 * This will cause the InputStream associated with this circular buffer
-		 * to read its last bytes once it empties the buffer.
-		 * Once a stream has been closed, further write() or flush() invocations
-		 * will cause an IOException to be thrown. Closing a previously-closed stream,
-		 * however, has no effect.
-		 *
-		 * @throws IOException never.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void close() throws IOException {
-			synchronized (CircularByteBuffer.this){
-				if (!outputStreamClosed){
-					flush();
-				}
-				outputStreamClosed = true;
-			}
-		}
-
-		/**
-		 * Flush the stream.
-		 *
-		 * @throws IOException if the stream is closed.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void flush() throws IOException {
-			if (outputStreamClosed) throw new IOException("OutputStream has been closed; cannot flush a closed OutputStream.");
-			if (inputStreamClosed) throw new IOException("Buffer closed by inputStream; cannot flush.");
-			// this method needs to do nothing
-		}
-
-		/**
-		 * Write an array of bytes.
-		 * If the buffer allows blocking writes, this method will block until
-		 * all the data has been written rather than throw an IOException.
-		 *
-		 * @param cbuf Array of bytes to be written
-		 * @throws BufferOverflowException if buffer does not allow blocking writes
-		 *   and the buffer is full.  If the exception is thrown, no data
-		 *   will have been written since the buffer was set to be non-blocking.
-		 * @throws IOException if the stream is closed, or the write is interrupted.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void write(byte[] cbuf) throws IOException {
-			write(cbuf, 0, cbuf.length);
-		}
-
-		/**
-		 * Write a portion of an array of bytes.
-		 * If the buffer allows blocking writes, this method will block until
-		 * all the data has been written rather than throw an IOException.
-		 *
-		 * @param cbuf Array of bytes
-		 * @param off Offset from which to start writing bytes
-		 * @param len - Number of bytes to write
-		 * @throws BufferOverflowException if buffer does not allow blocking writes
-		 *   and the buffer is full.  If the exception is thrown, no data
-		 *   will have been written since the buffer was set to be non-blocking.
-		 * @throws IOException if the stream is closed, or the write is interrupted.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void write(byte[] cbuf, int off, int len) throws IOException {
-			while (len > 0){
-				synchronized (CircularByteBuffer.this){
-					if (outputStreamClosed) throw new IOException("OutputStream has been closed; cannot write to a closed OutputStream.");
-					if (inputStreamClosed) throw new IOException("Buffer closed by InputStream; cannot write to a closed buffer.");
-					int spaceLeft = spaceLeft();
-					while (infinite && spaceLeft < len){
-						resize();
-						spaceLeft = spaceLeft();
-					}
-					if (!blockingWrite && spaceLeft < len) throw new BufferOverflowException();
-					int realLen = Math.min(len, spaceLeft);
-					int firstLen = Math.min(realLen, buffer.length - writePosition);
-					int secondLen = Math.min(realLen - firstLen, buffer.length - markPosition - 1);
-					int written = firstLen + secondLen;
-					if (firstLen > 0){
-						System.arraycopy(cbuf, off, buffer, writePosition, firstLen);
-					}
-					if (secondLen > 0){
-						System.arraycopy(cbuf, off+firstLen, buffer, 0, secondLen);
-						writePosition = secondLen;
-					} else {
-						writePosition += written;
-					}
-					if (writePosition == buffer.length) {
-						writePosition = 0;
-					}
-					off += written;
-					len -= written;
-				}
-				if (len > 0){
-					try {
-						Thread.sleep(100);
-					} catch(Exception x){
-						throw new IOException("Waiting for available space in buffer interrupted.");
-					}
-				}
-			}
-		}
-
-		/**
-		 * Write a single byte.
-		 * The byte to be written is contained in the 8 low-order bits of the
-		 * given integer value; the 24 high-order bits are ignored.
-		 * If the buffer allows blocking writes, this method will block until
-		 * all the data has been written rather than throw an IOException.
-		 *
-		 * @param c number of bytes to be written
-		 * @throws BufferOverflowException if buffer does not allow blocking writes
-		 *   and the buffer is full.
-		 * @throws IOException if the stream is closed, or the write is interrupted.
-		 *
-		 * @since ostermillerutils 1.00.00
-		 */
-		@Override public void write(int c) throws IOException {
-			boolean written = false;
-			while (!written){
-				synchronized (CircularByteBuffer.this){
-					if (outputStreamClosed) throw new IOException("OutputStream has been closed; cannot write to a closed OutputStream.");
-					if (inputStreamClosed) throw new IOException("Buffer closed by InputStream; cannot write to a closed buffer.");
-					int spaceLeft = spaceLeft();
-					while (infinite && spaceLeft < 1){
-						resize();
-						spaceLeft = spaceLeft();
-					}
-					if (!blockingWrite && spaceLeft < 1) throw new BufferOverflowException();
-					if (spaceLeft > 0){
-						buffer[writePosition] = (byte)(c & 0xff);
-						writePosition++;
-						if (writePosition == buffer.length) {
-							writePosition = 0;
-						}
-						written = true;
-					}
-				}
-				if (!written){
-					try {
-						Thread.sleep(100);
-					} catch(Exception x){
-						throw new IOException("Waiting for available space in buffer interrupted.");
-					}
-				}
-			}
-		}
-	}
-}
+///*
+// *
+// * Licensed to the Apache Software Foundation (ASF) under one
+// * or more contributor license agreements.  See the NOTICE file
+// * distributed with this work for additional information
+// * regarding copyright ownership.  The ASF licenses this file
+// * to you 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 edu.illinois.ncsa.BCGSS;
+///*
+// * Circular Byte Buffer
+// * Copyright (C) 2002 Stephen Ostermiller
+// * http://ostermiller.org/contact.pl?regarding=Java+Utilities
+// *
+// * This program is free software; you can redistribute it and/or modify
+// * it under the terms of the GNU General Public License as published by
+// * the Free Software Foundation; either version 2 of the License, or
+// * (at your option) any later version.
+// *
+// * This program 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 for more details.
+// *
+// * See COPYING.TXT for details.
+// */
+//
+//
+//import java.io.*;
+//import java.nio.*;
+//
+///**
+// * Implements the Circular Buffer producer/consumer model for bytes.
+// * More information about this class is available from <a target="_top" href=
+// * "http://ostermiller.org/utils/CircularByteBuffer.html">ostermiller.org</a>.
+// * <p>
+// * Using this class is a simpler alternative to using a PipedInputStream
+// * and a PipedOutputStream. PipedInputStreams and PipedOutputStreams don't support the
+// * mark operation, don't allow you to control buffer sizes that they use,
+// * and have a more complicated API that requires instantiating two
+// * classes and connecting them.
+// * <p>
+// * This class is thread safe.
+// *
+// */
+//public class CircularByteBuffer {
+//
+//	/**
+//	 * The default size for a circular byte buffer.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	private final static int DEFAULT_SIZE = 1024;
+//
+//	/**
+//	 * A buffer that will grow as things are added.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public final static int INFINITE_SIZE = -1;
+//
+//	/**
+//	 * The circular buffer.
+//	 * <p>
+//	 * The actual capacity of the buffer is one less than the actual length
+//	 * of the buffer so that an empty and a full buffer can be
+//	 * distinguished.  An empty buffer will have the markPostion and the
+//	 * writePosition equal to each other.  A full buffer will have
+//	 * the writePosition one less than the markPostion.
+//	 * <p>
+//	 * There are three important indexes into the buffer:
+//	 * The readPosition, the writePosition, and the markPosition.
+//	 * If the InputStream has never been marked, the readPosition and
+//	 * the markPosition should always be the same.  The bytes
+//	 * available to be read go from the readPosition to the writePosition,
+//	 * wrapping around the end of the buffer.  The space available for writing
+//	 * goes from the write position to one less than the markPosition,
+//	 * wrapping around the end of the buffer.  The bytes that have
+//	 * been saved to support a reset() of the InputStream go from markPosition
+//	 * to readPosition, wrapping around the end of the buffer.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected byte[] buffer;
+//	/**
+//	 * Index of the first byte available to be read.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected volatile int readPosition = 0;
+//	/**
+//	 * Index of the first byte available to be written.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected volatile int writePosition = 0;
+//	/**
+//	 * Index of the first saved byte. (To support stream marking.)
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected volatile int markPosition = 0;
+//	/**
+//	 * Number of bytes that have to be saved
+//	 * to support mark() and reset() on the InputStream.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected volatile int markSize = 0;
+//	/**
+//	 * If this buffer is infinite (should resize itself when full)
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected volatile boolean infinite = false;
+//	/**
+//	 * True if a write to a full buffer should block until the buffer
+//	 * has room, false if the write method should throw an IOException
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected boolean blockingWrite = true;
+//	/**
+//	 * The InputStream that can empty this buffer.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected InputStream in = new CircularByteBufferInputStream();
+//	/**
+//	 * true if the close() method has been called on the InputStream
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected boolean inputStreamClosed = false;
+//	/**
+//	 * The OutputStream that can fill this buffer.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected OutputStream out = new CircularByteBufferOutputStream();
+//	/**
+//	 * true if the close() method has been called on the OutputStream
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected boolean outputStreamClosed = false;
+//
+//	/**
+//	 * Make this buffer ready for reuse.  The contents of the buffer
+//	 * will be cleared and the streams associated with this buffer
+//	 * will be reopened if they had been closed.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public void clear(){
+//		synchronized (this){
+//			readPosition = 0;
+//			writePosition = 0;
+//			markPosition = 0;
+//			outputStreamClosed = false;
+//			inputStreamClosed = false;
+//		}
+//	}
+//
+//	/**
+//	 * Retrieve a OutputStream that can be used to fill
+//	 * this buffer.
+//	 * <p>
+//	 * Write methods may throw a BufferOverflowException if
+//	 * the buffer is not large enough.  A large enough buffer
+//	 * size must be chosen so that this does not happen or
+//	 * the caller must be prepared to catch the exception and
+//	 * try again once part of the buffer has been consumed.
+//	 *
+//	 *
+//	 * @return the producer for this buffer.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public OutputStream getOutputStream(){
+//		return out;
+//	}
+//
+//	/**
+//	 * Retrieve a InputStream that can be used to empty
+//	 * this buffer.
+//	 * <p>
+//	 * This InputStream supports marks at the expense
+//	 * of the buffer size.
+//	 *
+//	 * @return the consumer for this buffer.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public InputStream getInputStream(){
+//		return in;
+//	}
+//
+//	/**
+//	 * Get number of bytes that are available to be read.
+//	 * <p>
+//	 * Note that the number of bytes available plus
+//	 * the number of bytes free may not add up to the
+//	 * capacity of this buffer, as the buffer may reserve some
+//	 * space for other purposes.
+//	 *
+//	 * @return the size in bytes of this buffer
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public int getAvailable(){
+//		synchronized (this){
+//			return available();
+//		}
+//	}
+//
+//	/**
+//	 * Get the number of bytes this buffer has free for
+//	 * writing.
+//	 * <p>
+//	 * Note that the number of bytes available plus
+//	 * the number of bytes free may not add up to the
+//	 * capacity of this buffer, as the buffer may reserve some
+//	 * space for other purposes.
+//	 *
+//	 * @return the available space in bytes of this buffer
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public int getSpaceLeft(){
+//		synchronized (this){
+//			return spaceLeft();
+//		}
+//	}
+//
+//	/**
+//	 * Get the capacity of this buffer.
+//	 * <p>
+//	 * Note that the number of bytes available plus
+//	 * the number of bytes free may not add up to the
+//	 * capacity of this buffer, as the buffer may reserve some
+//	 * space for other purposes.
+//	 *
+//	 * @return the size in bytes of this buffer
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public int getSize(){
+//		synchronized (this){
+//			return buffer.length;
+//		}
+//	}
+//
+//	/**
+//	 * double the size of the buffer
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	private void resize(){
+//		byte[] newBuffer = new byte[buffer.length * 2];
+//		int marked = marked();
+//		int available = available();
+//		if (markPosition <= writePosition){
+//			// any space between the mark and
+//			// the first write needs to be saved.
+//			// In this case it is all in one piece.
+//			int length = writePosition - markPosition;
+//			System.arraycopy(buffer, markPosition, newBuffer, 0, length);
+//		} else {
+//			int length1 = buffer.length - markPosition;
+//			System.arraycopy(buffer, markPosition, newBuffer, 0, length1);
+//			int length2 = writePosition;
+//			System.arraycopy(buffer, 0, newBuffer, length1, length2);
+//		}
+//		buffer = newBuffer;
+//		markPosition = 0;
+//		readPosition = marked;
+//		writePosition = marked + available;
+//	}
+//
+//	/**
+//	 * Space available in the buffer which can be written.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	private int spaceLeft(){
+//		if (writePosition < markPosition){
+//			// any space between the first write and
+//			// the mark except one byte is available.
+//			// In this case it is all in one piece.
+//			return (markPosition - writePosition - 1);
+//		}
+//		// space at the beginning and end.
+//		return ((buffer.length - 1) - (writePosition - markPosition));
+//	}
+//
+//	/**
+//	 * Bytes available for reading.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	private int available(){
+//		if (readPosition <= writePosition){
+//			// any space between the first read and
+//			// the first write is available.  In this case i
+//			// is all in one piece.
+//			return (writePosition - readPosition);
+//		}
+//		// space at the beginning and end.
+//		return (buffer.length - (readPosition - writePosition));
+//	}
+//
+//	/**
+//	 * Bytes saved for supporting marks.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	private int marked(){
+//		if (markPosition <= readPosition){
+//			// any space between the markPosition and
+//			// the first write is marked.  In this case i
+//			// is all in one piece.
+//			return (readPosition - markPosition);
+//		}
+//		// space at the beginning and end.
+//		return (buffer.length - (markPosition - readPosition));
+//	}
+//
+//	/**
+//	 * If we have passed the markSize reset the
+//	 * mark so that the space can be used.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	private void ensureMark(){
+//		if (marked() >= markSize){
+//			markPosition = readPosition;
+//			markSize = 0;
+//		}
+//	}
+//
+//	/**
+//	 * Create a new buffer with a default capacity.
+//	 * Writing to a full buffer will block until space
+//	 * is available rather than throw an exception.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public CircularByteBuffer(){
+//		this (DEFAULT_SIZE, true);
+//	}
+//
+//	/**
+//	 * Create a new buffer with given capacity.
+//	 * Writing to a full buffer will block until space
+//	 * is available rather than throw an exception.
+//	 * <p>
+//	 * Note that the buffer may reserve some bytes for
+//	 * special purposes and capacity number of bytes may
+//	 * not be able to be written to the buffer.
+//	 * <p>
+//	 * Note that if the buffer is of INFINITE_SIZE it will
+//	 * neither block or throw exceptions, but rather grow
+//	 * without bound.
+//	 *
+//	 * @param size desired capacity of the buffer in bytes or CircularByteBuffer.INFINITE_SIZE.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public CircularByteBuffer(int size){
+//		this (size, true);
+//	}
+//
+//	/**
+//	 * Create a new buffer with a default capacity and
+//	 * given blocking behavior.
+//	 *
+//	 * @param blockingWrite true writing to a full buffer should block
+//	 *        until space is available, false if an exception should
+//	 *        be thrown instead.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public CircularByteBuffer(boolean blockingWrite){
+//		this (DEFAULT_SIZE, blockingWrite);
+//	}
+//
+//	/**
+//	 * Create a new buffer with the given capacity and
+//	 * blocking behavior.
+//	 * <p>
+//	 * Note that the buffer may reserve some bytes for
+//	 * special purposes and capacity number of bytes may
+//	 * not be able to be written to the buffer.
+//	 * <p>
+//	 * Note that if the buffer is of INFINITE_SIZE it will
+//	 * neither block or throw exceptions, but rather grow
+//	 * without bound.
+//	 *
+//	 * @param size desired capacity of the buffer in bytes or CircularByteBuffer.INFINITE_SIZE.
+//	 * @param blockingWrite true writing to a full buffer should block
+//	 *        until space is available, false if an exception should
+//	 *        be thrown instead.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	public CircularByteBuffer(int size, boolean blockingWrite){
+//		if (size == INFINITE_SIZE){
+//			buffer = new byte[DEFAULT_SIZE];
+//			infinite = true;
+//		} else {
+//			buffer = new byte[size];
+//			infinite = false;
+//		}
+//		this.blockingWrite = blockingWrite;
+//	}
+//
+//	/**
+//	 * Class for reading from a circular byte buffer.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected class CircularByteBufferInputStream extends InputStream {
+//
+//		/**
+//		 * Returns the number of bytes that can be read (or skipped over) from this
+//		 * input stream without blocking by the next caller of a method for this input
+//		 * stream. The next caller might be the same thread or or another thread.
+//		 *
+//		 * @return the number of bytes that can be read from this input stream without blocking.
+//		 * @throws IOException if the stream is closed.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public int available() throws IOException {
+//			synchronized (CircularByteBuffer.this){
+//				if (inputStreamClosed) throw new IOException("InputStream has been closed, it is not ready.");
+//				return (CircularByteBuffer.this.available());
+//			}
+//		}
+//
+//		/**
+//		 * Close the stream. Once a stream has been closed, further read(), available(),
+//		 * mark(), or reset() invocations will throw an IOException. Closing a
+//		 * previously-closed stream, however, has no effect.
+//		 *
+//		 * @throws IOException never.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void close() throws IOException {
+//			synchronized (CircularByteBuffer.this){
+//				inputStreamClosed = true;
+//			}
+//		}
+//
+//		/**
+//		 * Mark the present position in the stream. Subsequent calls to reset() will
+//		 * attempt to reposition the stream to this point.
+//		 * <p>
+//		 * The readAheadLimit must be less than the size of circular buffer, otherwise
+//		 * this method has no effect.
+//		 *
+//		 * @param readAheadLimit Limit on the number of bytes that may be read while
+//		 *    still preserving the mark. After reading this many bytes, attempting to
+//		 *    reset the stream will fail.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void mark(int readAheadLimit) {
+//			synchronized (CircularByteBuffer.this){
+//				//if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot mark a closed InputStream.");
+//				if (buffer.length - 1 > readAheadLimit) {
+//					markSize = readAheadLimit;
+//					markPosition = readPosition;
+//				}
+//			}
+//		}
+//
+//		/**
+//		 * Tell whether this stream supports the mark() operation.
+//		 *
+//		 * @return true, mark is supported.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public boolean markSupported() {
+//			return true;
+//		}
+//
+//		/**
+//		 * Read a single byte.
+//		 * This method will block until a byte is available, an I/O error occurs,
+//		 * or the end of the stream is reached.
+//		 *
+//		 * @return The byte read, as an integer in the range 0 to 255 (0x00-0xff),
+//		 *     or -1 if the end of the stream has been reached
+//		 * @throws IOException if the stream is closed.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public int read() throws IOException {
+//			while (true){
+//				synchronized (CircularByteBuffer.this){
+//					if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot read from a closed InputStream.");
+//					int available = CircularByteBuffer.this.available();
+//					if (available > 0){
+//						int result = buffer[readPosition] & 0xff;
+//						readPosition++;
+//						if (readPosition == buffer.length){
+//							readPosition = 0;
+//						}
+//						ensureMark();
+//						return result;
+//					} else if (outputStreamClosed){
+//						return -1;
+//					}
+//				}
+//				try {
+//					Thread.sleep(100);
+//				} catch(Exception x){
+//					throw new IOException("Blocking read operation interrupted.");
+//				}
+//			}
+//		}
+//
+//		/**
+//		 * Read bytes into an array.
+//		 * This method will block until some input is available,
+//		 * an I/O error occurs, or the end of the stream is reached.
+//		 *
+//		 * @param cbuf Destination buffer.
+//		 * @return The number of bytes read, or -1 if the end of
+//		 *   the stream has been reached
+//		 * @throws IOException if the stream is closed.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public int read(byte[] cbuf) throws IOException {
+//			return read(cbuf, 0, cbuf.length);
+//		}
+//
+//		/**
+//		 * Read bytes into a portion of an array.
+//		 * This method will block until some input is available,
+//		 * an I/O error occurs, or the end of the stream is reached.
+//		 *
+//		 * @param cbuf Destination buffer.
+//		 * @param off Offset at which to start storing bytes.
+//		 * @param len Maximum number of bytes to read.
+//		 * @return The number of bytes read, or -1 if the end of
+//		 *   the stream has been reached
+//		 * @throws IOException if the stream is closed.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public int read(byte[] cbuf, int off, int len) throws IOException {
+//			while (true){
+//				synchronized (CircularByteBuffer.this){
+//					if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot read from a closed InputStream.");
+//					int available = CircularByteBuffer.this.available();
+//					if (available > 0){
+//						int length = Math.min(len, available);
+//						int firstLen = Math.min(length, buffer.length - readPosition);
+//						int secondLen = length - firstLen;
+//						System.arraycopy(buffer, readPosition, cbuf, off, firstLen);
+//						if (secondLen > 0){
+//							System.arraycopy(buffer, 0, cbuf, off+firstLen,  secondLen);
+//							readPosition = secondLen;
+//						} else {
+//							readPosition += length;
+//						}
+//						if (readPosition == buffer.length) {
+//							readPosition = 0;
+//						}
+//						ensureMark();
+//						return length;
+//					} else if (outputStreamClosed){
+//						return -1;
+//					}
+//				}
+//				try {
+//					Thread.sleep(100);
+//				} catch(Exception x){
+//					throw new IOException("Blocking read operation interrupted.");
+//				}
+//			}
+//		}
+//
+//		/**
+//		 * Reset the stream.
+//		 * If the stream has been marked, then attempt to reposition i
+//		 * at the mark. If the stream has not been marked, or more bytes
+//		 * than the readAheadLimit have been read, this method has no effect.
+//		 *
+//		 * @throws IOException if the stream is closed.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void reset() throws IOException {
+//			synchronized (CircularByteBuffer.this){
+//				if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot reset a closed InputStream.");
+//				readPosition = markPosition;
+//			}
+//		}
+//
+//		/**
+//		 * Skip bytes.
+//		 * This method will block until some bytes are available,
+//		 * an I/O error occurs, or the end of the stream is reached.
+//		 *
+//		 * @param n The number of bytes to skip
+//		 * @return The number of bytes actually skipped
+//		 * @throws IllegalArgumentException if n is negative.
+//		 * @throws IOException if the stream is closed.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public long skip(long n) throws IOException, IllegalArgumentException {
+//			while (true){
+//				synchronized (CircularByteBuffer.this){
+//					if (inputStreamClosed) throw new IOException("InputStream has been closed; cannot skip bytes on a closed InputStream.");
+//					int available = CircularByteBuffer.this.available();
+//					if (available > 0){
+//						int length = Math.min((int)n, available);
+//						int firstLen = Math.min(length, buffer.length - readPosition);
+//						int secondLen = length - firstLen;
+//						if (secondLen > 0){
+//							readPosition = secondLen;
+//						} else {
+//							readPosition += length;
+//						}
+//						if (readPosition == buffer.length) {
+//							readPosition = 0;
+//						}
+//						ensureMark();
+//						return length;
+//					} else if (outputStreamClosed){
+//						return 0;
+//					}
+//				}
+//				try {
+//					Thread.sleep(100);
+//				} catch(Exception x){
+//					throw new IOException("Blocking read operation interrupted.");
+//				}
+//			}
+//		}
+//	}
+//
+//	/**
+//	 * Class for writing to a circular byte buffer.
+//	 * If the buffer is full, the writes will either block
+//	 * until there is some space available or throw an IOException
+//	 * based on the CircularByteBuffer's preference.
+//	 *
+//	 * @since ostermillerutils 1.00.00
+//	 */
+//	protected class CircularByteBufferOutputStream extends OutputStream {
+//
+//		/**
+//		 * Close the stream, flushing it first.
+//		 * This will cause the InputStream associated with this circular buffer
+//		 * to read its last bytes once it empties the buffer.
+//		 * Once a stream has been closed, further write() or flush() invocations
+//		 * will cause an IOException to be thrown. Closing a previously-closed stream,
+//		 * however, has no effect.
+//		 *
+//		 * @throws IOException never.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void close() throws IOException {
+//			synchronized (CircularByteBuffer.this){
+//				if (!outputStreamClosed){
+//					flush();
+//				}
+//				outputStreamClosed = true;
+//			}
+//		}
+//
+//		/**
+//		 * Flush the stream.
+//		 *
+//		 * @throws IOException if the stream is closed.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void flush() throws IOException {
+//			if (outputStreamClosed) throw new IOException("OutputStream has been closed; cannot flush a closed OutputStream.");
+//			if (inputStreamClosed) throw new IOException("Buffer closed by inputStream; cannot flush.");
+//			// this method needs to do nothing
+//		}
+//
+//		/**
+//		 * Write an array of bytes.
+//		 * If the buffer allows blocking writes, this method will block until
+//		 * all the data has been written rather than throw an IOException.
+//		 *
+//		 * @param cbuf Array of bytes to be written
+//		 * @throws BufferOverflowException if buffer does not allow blocking writes
+//		 *   and the buffer is full.  If the exception is thrown, no data
+//		 *   will have been written since the buffer was set to be non-blocking.
+//		 * @throws IOException if the stream is closed, or the write is interrupted.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void write(byte[] cbuf) throws IOException {
+//			write(cbuf, 0, cbuf.length);
+//		}
+//
+//		/**
+//		 * Write a portion of an array of bytes.
+//		 * If the buffer allows blocking writes, this method will block until
+//		 * all the data has been written rather than throw an IOException.
+//		 *
+//		 * @param cbuf Array of bytes
+//		 * @param off Offset from which to start writing bytes
+//		 * @param len - Number of bytes to write
+//		 * @throws BufferOverflowException if buffer does not allow blocking writes
+//		 *   and the buffer is full.  If the exception is thrown, no data
+//		 *   will have been written since the buffer was set to be non-blocking.
+//		 * @throws IOException if the stream is closed, or the write is interrupted.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void write(byte[] cbuf, int off, int len) throws IOException {
+//			while (len > 0){
+//				synchronized (CircularByteBuffer.this){
+//					if (outputStreamClosed) throw new IOException("OutputStream has been closed; cannot write to a closed OutputStream.");
+//					if (inputStreamClosed) throw new IOException("Buffer closed by InputStream; cannot write to a closed buffer.");
+//					int spaceLeft = spaceLeft();
+//					while (infinite && spaceLeft < len){
+//						resize();
+//						spaceLeft = spaceLeft();
+//					}
+//					if (!blockingWrite && spaceLeft < len) throw new BufferOverflowException();
+//					int realLen = Math.min(len, spaceLeft);
+//					int firstLen = Math.min(realLen, buffer.length - writePosition);
+//					int secondLen = Math.min(realLen - firstLen, buffer.length - markPosition - 1);
+//					int written = firstLen + secondLen;
+//					if (firstLen > 0){
+//						System.arraycopy(cbuf, off, buffer, writePosition, firstLen);
+//					}
+//					if (secondLen > 0){
+//						System.arraycopy(cbuf, off+firstLen, buffer, 0, secondLen);
+//						writePosition = secondLen;
+//					} else {
+//						writePosition += written;
+//					}
+//					if (writePosition == buffer.length) {
+//						writePosition = 0;
+//					}
+//					off += written;
+//					len -= written;
+//				}
+//				if (len > 0){
+//					try {
+//						Thread.sleep(100);
+//					} catch(Exception x){
+//						throw new IOException("Waiting for available space in buffer interrupted.");
+//					}
+//				}
+//			}
+//		}
+//
+//		/**
+//		 * Write a single byte.
+//		 * The byte to be written is contained in the 8 low-order bits of the
+//		 * given integer value; the 24 high-order bits are ignored.
+//		 * If the buffer allows blocking writes, this method will block until
+//		 * all the data has been written rather than throw an IOException.
+//		 *
+//		 * @param c number of bytes to be written
+//		 * @throws BufferOverflowException if buffer does not allow blocking writes
+//		 *   and the buffer is full.
+//		 * @throws IOException if the stream is closed, or the write is interrupted.
+//		 *
+//		 * @since ostermillerutils 1.00.00
+//		 */
+//		@Override public void write(int c) throws IOException {
+//			boolean written = false;
+//			while (!written){
+//				synchronized (CircularByteBuffer.this){
+//					if (outputStreamClosed) throw new IOException("OutputStream has been closed; cannot write to a closed OutputStream.");
+//					if (inputStreamClosed) throw new IOException("Buffer closed by InputStream; cannot write to a closed buffer.");
+//					int spaceLeft = spaceLeft();
+//					while (infinite && spaceLeft < 1){
+//						resize();
+//						spaceLeft = spaceLeft();
+//					}
+//					if (!blockingWrite && spaceLeft < 1) throw new BufferOverflowException();
+//					if (spaceLeft > 0){
+//						buffer[writePosition] = (byte)(c & 0xff);
+//						writePosition++;
+//						if (writePosition == buffer.length) {
+//							writePosition = 0;
+//						}
+//						written = true;
+//					}
+//				}
+//				if (!written){
+//					try {
+//						Thread.sleep(100);
+//					} catch(Exception x){
+//						throw new IOException("Waiting for available space in buffer interrupted.");
+//					}
+//				}
+//			}
+//		}
+//	}
+//}

http://git-wip-us.apache.org/repos/asf/airavata/blob/9a6eaaae/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsCipherFactory.java
----------------------------------------------------------------------
diff --git a/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsCipherFactory.java b/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsCipherFactory.java
index 6db1c3f..18d282a 100644
--- a/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsCipherFactory.java
+++ b/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsCipherFactory.java
@@ -1,63 +1,63 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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 edu.illinois.ncsa.BCGSS;
-
-import edu.illinois.ncsa.bouncycastle.crypto.Digest;
-import edu.illinois.ncsa.bouncycastle.crypto.tls.AlertDescription;
-import edu.illinois.ncsa.bouncycastle.crypto.tls.DefaultTlsCipherFactory;
-import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsBlockCipher;
-import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsCipher;
-import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsClientContext;
-import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsFatalAlert;
-
-import java.io.IOException;
-
-public class GlobusTlsCipherFactory extends DefaultTlsCipherFactory {
-    protected TlsBlockCipher tlsBlockCipher;
-    protected Digest digest;
-
-    public TlsBlockCipher getTlsBlockCipher() {
-        return tlsBlockCipher;
-    }
-
-    public Digest getDigest() {
-        return digest;
-    }
-
-    public TlsCipher createCipher(TlsClientContext context,
-                                     int encAlg, int digestAlg)
-            throws IOException {
-        TlsCipher cipher = super.createCipher(context, encAlg, digestAlg);
-        if (cipher instanceof TlsBlockCipher) {
-            tlsBlockCipher = (TlsBlockCipher) cipher;
-        } else {
-            throw new TlsFatalAlert(AlertDescription.internal_error);
-        }
-
-        return cipher;
-    }
-
-    protected Digest createDigest(int digestAlgorithm) throws IOException {
-        digest = super.createDigest(digestAlgorithm);
-        return digest;
-    }
-}
+///*
+// *
+// * Licensed to the Apache Software Foundation (ASF) under one
+// * or more contributor license agreements.  See the NOTICE file
+// * distributed with this work for additional information
+// * regarding copyright ownership.  The ASF licenses this file
+// * to you 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 edu.illinois.ncsa.BCGSS;
+//
+//import edu.illinois.ncsa.bouncycastle.crypto.Digest;
+//import edu.illinois.ncsa.bouncycastle.crypto.tls.AlertDescription;
+//import edu.illinois.ncsa.bouncycastle.crypto.tls.DefaultTlsCipherFactory;
+//import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsBlockCipher;
+//import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsCipher;
+//import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsClientContext;
+//import edu.illinois.ncsa.bouncycastle.crypto.tls.TlsFatalAlert;
+//
+//import java.io.IOException;
+//
+//public class GlobusTlsCipherFactory extends DefaultTlsCipherFactory {
+//    protected TlsBlockCipher tlsBlockCipher;
+//    protected Digest digest;
+//
+//    public TlsBlockCipher getTlsBlockCipher() {
+//        return tlsBlockCipher;
+//    }
+//
+//    public Digest getDigest() {
+//        return digest;
+//    }
+//
+//    public TlsCipher createCipher(TlsClientContext context,
+//                                     int encAlg, int digestAlg)
+//            throws IOException {
+//        TlsCipher cipher = super.createCipher(context, encAlg, digestAlg);
+//        if (cipher instanceof TlsBlockCipher) {
+//            tlsBlockCipher = (TlsBlockCipher) cipher;
+//        } else {
+//            throw new TlsFatalAlert(AlertDescription.internal_error);
+//        }
+//
+//        return cipher;
+//    }
+//
+//    protected Digest createDigest(int digestAlgorithm) throws IOException {
+//        digest = super.createDigest(digestAlgorithm);
+//        return digest;
+//    }
+//}

http://git-wip-us.apache.org/repos/asf/airavata/blob/9a6eaaae/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsClient.java
----------------------------------------------------------------------
diff --git a/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsClient.java b/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsClient.java
index 0da3bca..0b91af8 100644
--- a/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsClient.java
+++ b/tools/gsissh/src/main/java/edu/illinois/ncsa/BCGSS/GlobusTlsClient.java
@@ -1,247 +1,247 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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 edu.illinois.ncsa.BCGSS;
-
-import edu.illinois.ncsa.bouncycastle.crypto.tls.*;
-import edu.illinois.ncsa.bouncycastle.asn1.*;
-import edu.illinois.ncsa.bouncycastle.asn1.x509.*;
-import org.globus.common.CoGProperties;
-import org.globus.gsi.CredentialException;
-import org.globus.gsi.X509Credential;
-import org.globus.gsi.X509ProxyCertPathParameters;
-import org.globus.gsi.provider.GlobusProvider;
-import org.globus.gsi.provider.KeyStoreParametersFactory;
-import org.globus.gsi.stores.ResourceCertStoreParameters;
-import org.globus.gsi.stores.ResourceSigningPolicyStore;
-import org.globus.gsi.stores.ResourceSigningPolicyStoreParameters;
-import org.globus.gsi.trustmanager.X509ProxyCertPathValidator;
-import org.globus.gsi.util.CertificateUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.crypto.Cipher;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.security.KeyStore;
-import java.security.PrivateKey;
-import java.security.cert.CertStore;
-import java.security.cert.CertificateException;
-import java.security.cert.CertificateFactory;
-import java.security.cert.X509Certificate;
-
-public class GlobusTlsClient extends DefaultTlsClient
-{
-    private Certificate clientCert = new Certificate(new X509CertificateStructure[0]);
-    private PrivateKey clientPrivateKey = null;
-    private X509Certificate[] peerCerts = null;
-    private static final Logger logger = LoggerFactory.getLogger(GlobusTlsClient.class);
-
-    public X509Certificate[] getPeerCerts() {
-        return peerCerts;
-    }
-
-    public GlobusTlsClient(X509Credential cred, GlobusTlsCipherFactory factory)
-            throws IOException, CertificateException, CredentialException {
-        super(factory);
-        if (cred == null) {
-            throw new IllegalArgumentException("'cred' cannot be null");
-        }
-
-        clientCert = new Certificate(
-                X509CertArrayToStructArray(cred.getCertificateChain()));
-        clientPrivateKey = cred.getPrivateKey();
-
-        if (clientCert.getCerts().length == 0) {
-            throw new IllegalArgumentException(
-                    "'cred' contains no certificates");
-        }
-
-        if (clientPrivateKey == null) {
-            throw new IllegalArgumentException("'clientPrivateKey' cannot be null");
-        }
-    }
-
-    public TlsAuthentication getAuthentication() throws IOException {
-        return new GlobusTlsAuth();
-    }
-
-    public int[] getCipherSuites() {
-        return new int[] {
-                CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA,
-                CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA,
-                CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
-        };
-    }
-
-    public class GlobusTlsAuth implements TlsAuthentication {
-
-        /**
-         * Validates the server's certificate
-         * @param certificate received from server
-         * @throws IOException
-         */
-        public void notifyServerCertificate(Certificate certificate)
-                throws IOException {
-            try {
-            peerCerts = X509CertStructArrayToCertArray(certificate.getCerts());
-
-            String caCertsLocation =
-                    "file:" + CoGProperties.getDefault().getCaCertLocations();
-            String crlPattern = caCertsLocation + "/*.r*";
-            String sigPolPattern = caCertsLocation + "/*.signing_policy";
-
-            KeyStore keyStore = KeyStore.getInstance(
-                    GlobusProvider.KEYSTORE_TYPE, GlobusProvider.PROVIDER_NAME);
-            CertStore crlStore = CertStore.getInstance(
-                    GlobusProvider.CERTSTORE_TYPE,
-                    new ResourceCertStoreParameters(null, crlPattern));
-            ResourceSigningPolicyStore sigPolStore =
-                    new ResourceSigningPolicyStore(
-                            new ResourceSigningPolicyStoreParameters(
-                                    sigPolPattern));
-            keyStore.load(
-                    KeyStoreParametersFactory.createTrustStoreParameters(
-                            caCertsLocation));
-            X509ProxyCertPathParameters parameters =
-                    new X509ProxyCertPathParameters(keyStore, crlStore,
-                            sigPolStore, false);
-            X509ProxyCertPathValidator validator =
-                    new X509ProxyCertPathValidator();
-            if (validator.engineValidate(CertificateUtil.getCertPath(peerCerts),
-                    parameters) == null) {
-                throw new Exception("X509ProxyCertPathValidator did not return a result");
-            }
-            } catch (Exception e) {
-                logger.error(e.getMessage(), e);
-                throw new TlsFatalAlert(AlertDescription.user_canceled);
-            }
-        }
-
-        /**
-         * Returns an object representing the client's credentials
-         * @param request
-         * @return the client's credentials
-         * @throws IOException
-         */
-        public TlsCredentials getClientCredentials(CertificateRequest request)
-                throws IOException {
-            return new GlobusTlsCred();
-        }
-    }
-
-    public class GlobusTlsCred implements TlsSignerCredentials {
-        /**
-         * Encrypts a hash with the client's private key, producing a signature
-         * @param md5andsha1 the hash to encrypt
-         * @return an array of bytes containing the signature
-         * @throws IOException
-         */
-        public byte[] generateCertificateSignature(byte[] md5andsha1)
-                throws IOException {
-            // encrypt the input hash with the private key to produce signature
-            try {
-                Cipher cipher = Cipher.getInstance(clientPrivateKey.getAlgorithm());
-                cipher.init(Cipher.ENCRYPT_MODE, clientPrivateKey);
-                return cipher.doFinal(md5andsha1);
-            } catch (Exception e) {
-                logger.error(e.getMessage(), e);
-                throw new IOException(e);
-            }
-        }
-
-        public Certificate getCertificate() {
-            return clientCert;
-        }
-    }
-
-       /**
-     *
-     * @param struct
-     * @return
-     * @throws CertificateException
-     * @throws IOException
-     */
-    public static X509Certificate X509CertStructToCert(
-            X509CertificateStructure struct) throws CertificateException,
-            IOException {
-        CertificateFactory cf = CertificateFactory.getInstance("X.509");
-        InputStream is = new ByteArrayInputStream(struct.getEncoded());
-        X509Certificate cert = (X509Certificate) cf.generateCertificate(is);
-        is.close();
-        return cert;
-    }
-
-    /**
-     *
-     * @param structs
-     * @return
-     * @throws java.io.IOException
-     * @throws java.security.cert.CertificateException
-     */
-    public static X509Certificate[] X509CertStructArrayToCertArray(
-            X509CertificateStructure[] structs) throws IOException,
-            CertificateException {
-        X509Certificate[] certChain = new X509Certificate[structs.length];
-
-        for (int i = 0; i < structs.length; ++i) {
-            certChain[i] = X509CertStructToCert(structs[i]);
-        }
-
-        return certChain;
-    }
-
-    /**
-     *
-     * @param c
-     * @return
-     * @throws CertificateException
-     * @throws IOException
-     */
-    public static X509CertificateStructure X509CertToStruct(X509Certificate c)
-            throws CertificateException, IOException {
-        ASN1InputStream is = new ASN1InputStream(c.getEncoded());
-        DERObject o = is.readObject();
-        return X509CertificateStructure.getInstance(o);
-    }
-
-
-    /**
-     *
-     * @param certs
-     * @return
-     * @throws CertificateException
-     * @throws IOException
-     */
-    public static X509CertificateStructure[] X509CertArrayToStructArray(
-            X509Certificate[] certs) throws CertificateException, IOException {
-        X509CertificateStructure[] structs =
-                new X509CertificateStructure[certs.length];
-
-        for (int i = 0; i < certs.length; ++i) {
-            structs[i] = X509CertToStruct(certs[i]);
-        }
-
-        return structs;
-    }
-}
-
+///*
+// *
+// * Licensed to the Apache Software Foundation (ASF) under one
+// * or more contributor license agreements.  See the NOTICE file
+// * distributed with this work for additional information
+// * regarding copyright ownership.  The ASF licenses this file
+// * to you 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 edu.illinois.ncsa.BCGSS;
+//
+////import edu.illinois.ncsa.bouncycastle.crypto.tls.*;
+////import edu.illinois.ncsa.bouncycastle.asn1.*;
+////import edu.illinois.ncsa.bouncycastle.asn1.x509.*;
+//import org.globus.common.CoGProperties;
+//import org.globus.gsi.CredentialException;
+//import org.globus.gsi.X509Credential;
+//import org.globus.gsi.X509ProxyCertPathParameters;
+//import org.globus.gsi.provider.GlobusProvider;
+//import org.globus.gsi.provider.KeyStoreParametersFactory;
+//import org.globus.gsi.stores.ResourceCertStoreParameters;
+//import org.globus.gsi.stores.ResourceSigningPolicyStore;
+//import org.globus.gsi.stores.ResourceSigningPolicyStoreParameters;
+//import org.globus.gsi.trustmanager.X509ProxyCertPathValidator;
+//import org.globus.gsi.util.CertificateUtil;
+//import org.slf4j.Logger;
+//import org.slf4j.LoggerFactory;
+//
+//import javax.crypto.Cipher;
+//import java.io.ByteArrayInputStream;
+//import java.io.IOException;
+//import java.io.InputStream;
+//import java.security.KeyStore;
+//import java.security.PrivateKey;
+//import java.security.cert.CertStore;
+//import java.security.cert.CertificateException;
+//import java.security.cert.CertificateFactory;
+//import java.security.cert.X509Certificate;
+//
+//public class GlobusTlsClient extends DefaultTlsClient
+//{
+//    private Certificate clientCert = new Certificate(new X509CertificateStructure[0]);
+//    private PrivateKey clientPrivateKey = null;
+//    private X509Certificate[] peerCerts = null;
+//    private static final Logger logger = LoggerFactory.getLogger(GlobusTlsClient.class);
+//
+//    public X509Certificate[] getPeerCerts() {
+//        return peerCerts;
+//    }
+//
+//    public GlobusTlsClient(X509Credential cred, GlobusTlsCipherFactory factory)
+//            throws IOException, CertificateException, CredentialException {
+//        super(factory);
+//        if (cred == null) {
+//            throw new IllegalArgumentException("'cred' cannot be null");
+//        }
+//
+//        clientCert = new Certificate(
+//                X509CertArrayToStructArray(cred.getCertificateChain()));
+//        clientPrivateKey = cred.getPrivateKey();
+//
+//        if (clientCert.getCerts().length == 0) {
+//            throw new IllegalArgumentException(
+//                    "'cred' contains no certificates");
+//        }
+//
+//        if (clientPrivateKey == null) {
+//            throw new IllegalArgumentException("'clientPrivateKey' cannot be null");
+//        }
+//    }
+//
+//    public TlsAuthentication getAuthentication() throws IOException {
+//        return new GlobusTlsAuth();
+//    }
+//
+//    public int[] getCipherSuites() {
+//        return new int[] {
+//                CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA,
+//                CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA,
+//                CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+//        };
+//    }
+//
+//    public class GlobusTlsAuth implements TlsAuthentication {
+//
+//        /**
+//         * Validates the server's certificate
+//         * @param certificate received from server
+//         * @throws IOException
+//         */
+//        public void notifyServerCertificate(Certificate certificate)
+//                throws IOException {
+//            try {
+//            peerCerts = X509CertStructArrayToCertArray(certificate.getCerts());
+//
+//            String caCertsLocation =
+//                    "file:" + CoGProperties.getDefault().getCaCertLocations();
+//            String crlPattern = caCertsLocation + "/*.r*";
+//            String sigPolPattern = caCertsLocation + "/*.signing_policy";
+//
+//            KeyStore keyStore = KeyStore.getInstance(
+//                    GlobusProvider.KEYSTORE_TYPE, GlobusProvider.PROVIDER_NAME);
+//            CertStore crlStore = CertStore.getInstance(
+//                    GlobusProvider.CERTSTORE_TYPE,
+//                    new ResourceCertStoreParameters(null, crlPattern));
+//            ResourceSigningPolicyStore sigPolStore =
+//                    new ResourceSigningPolicyStore(
+//                            new ResourceSigningPolicyStoreParameters(
+//                                    sigPolPattern));
+//            keyStore.load(
+//                    KeyStoreParametersFactory.createTrustStoreParameters(
+//                            caCertsLocation));
+//            X509ProxyCertPathParameters parameters =
+//                    new X509ProxyCertPathParameters(keyStore, crlStore,
+//                            sigPolStore, false);
+//            X509ProxyCertPathValidator validator =
+//                    new X509ProxyCertPathValidator();
+//            if (validator.engineValidate(CertificateUtil.getCertPath(peerCerts),
+//                    parameters) == null) {
+//                throw new Exception("X509ProxyCertPathValidator did not return a result");
+//            }
+//            } catch (Exception e) {
+//                logger.error(e.getMessage(), e);
+//                throw new TlsFatalAlert(AlertDescription.user_canceled);
+//            }
+//        }
+//
+//        /**
+//         * Returns an object representing the client's credentials
+//         * @param request
+//         * @return the client's credentials
+//         * @throws IOException
+//         */
+//        public TlsCredentials getClientCredentials(CertificateRequest request)
+//                throws IOException {
+//            return new GlobusTlsCred();
+//        }
+//    }
+//
+//    public class GlobusTlsCred implements TlsSignerCredentials {
+//        /**
+//         * Encrypts a hash with the client's private key, producing a signature
+//         * @param md5andsha1 the hash to encrypt
+//         * @return an array of bytes containing the signature
+//         * @throws IOException
+//         */
+//        public byte[] generateCertificateSignature(byte[] md5andsha1)
+//                throws IOException {
+//            // encrypt the input hash with the private key to produce signature
+//            try {
+//                Cipher cipher = Cipher.getInstance(clientPrivateKey.getAlgorithm());
+//                cipher.init(Cipher.ENCRYPT_MODE, clientPrivateKey);
+//                return cipher.doFinal(md5andsha1);
+//            } catch (Exception e) {
+//                logger.error(e.getMessage(), e);
+//                throw new IOException(e);
+//            }
+//        }
+//
+//        public Certificate getCertificate() {
+//            return clientCert;
+//        }
+//    }
+//
+//       /**
+//     *
+//     * @param struct
+//     * @return
+//     * @throws CertificateException
+//     * @throws IOException
+//     */
+//    public static X509Certificate X509CertStructToCert(
+//            X509CertificateStructure struct) throws CertificateException,
+//            IOException {
+//        CertificateFactory cf = CertificateFactory.getInstance("X.509");
+//        InputStream is = new ByteArrayInputStream(struct.getEncoded());
+//        X509Certificate cert = (X509Certificate) cf.generateCertificate(is);
+//        is.close();
+//        return cert;
+//    }
+//
+//    /**
+//     *
+//     * @param structs
+//     * @return
+//     * @throws java.io.IOException
+//     * @throws java.security.cert.CertificateException
+//     */
+//    public static X509Certificate[] X509CertStructArrayToCertArray(
+//            X509CertificateStructure[] structs) throws IOException,
+//            CertificateException {
+//        X509Certificate[] certChain = new X509Certificate[structs.length];
+//
+//        for (int i = 0; i < structs.length; ++i) {
+//            certChain[i] = X509CertStructToCert(structs[i]);
+//        }
+//
+//        return certChain;
+//    }
+//
+//    /**
+//     *
+//     * @param c
+//     * @return
+//     * @throws CertificateException
+//     * @throws IOException
+//     */
+//    public static X509CertificateStructure X509CertToStruct(X509Certificate c)
+//            throws CertificateException, IOException {
+//        ASN1InputStream is = new ASN1InputStream(c.getEncoded());
+//        DERObject o = is.readObject();
+//        return X509CertificateStructure.getInstance(o);
+//    }
+//
+//
+//    /**
+//     *
+//     * @param certs
+//     * @return
+//     * @throws CertificateException
+//     * @throws IOException
+//     */
+//    public static X509CertificateStructure[] X509CertArrayToStructArray(
+//            X509Certificate[] certs) throws CertificateException, IOException {
+//        X509CertificateStructure[] structs =
+//                new X509CertificateStructure[certs.length];
+//
+//        for (int i = 0; i < certs.length; ++i) {
+//            structs[i] = X509CertToStruct(certs[i]);
+//        }
+//
+//        return structs;
+//    }
+//}
+//


Mime
View raw message