quickserver/src/main/org/quickserver/net/client/BlockingClient.java - backupdr - Git at Google

 /*
  * This file is part of the QuickServer library
  * Copyright (C) QuickServer.org
  *
  * Use, modification, copying and distribution of this software is subject to
  * the terms and conditions of the GNU Lesser General Public License.
  * You should have received a copy of the GNU LGP License along with this
  * library; if not, you can download a copy from <http://www.quickserver.org/>.
  *
  * For questions, suggestions, bug-reports, enhancement-requests etc.
  * visit http://www.quickserver.org
  *
  */

 package org.quickserver.net.client;

 import java.io.*;
 import java.net.*;
 import java.security.KeyStore;
 import java.security.SecureRandom;
 import java.util.logging.*;
 import javax.net.ssl.KeyManager;
 import javax.net.ssl.KeyManagerFactory;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLSocketFactory;
 import javax.net.ssl.TrustManager;

 /**
  * Blocking Client socket.
  * @author Akshathkumar Shetty
  * @since 1.4.7
  */
 public class BlockingClient implements ClientService {
 	private static final Logger logger = Logger.getLogger(BlockingClient.class.getName());
 	private static String charset = "ISO-8859-1";
 	private static boolean debug = false;
 	private static final int _CR = 13;
 	private static final int _LF = 10;

         private static String providerForSSLContext;

 	public static boolean isDebug() {
 		return debug;
 	}

 	public static void setDebug(boolean aDebug) {
 		debug = aDebug;
 	}

     /**
      * @return the providerForSSLContext
      */
     public static String getProviderForSSLContext() {
         return providerForSSLContext;
     }

     /**
      * @param aProviderForSSLContext the providerForSSLContext to set
      */
     public static void setProviderForSSLContext(String aProviderForSSLContext) {
         providerForSSLContext = aProviderForSSLContext;
     }

 	private String host = "localhost";
 	private int port = 0;

 	private Socket socket;

 	private boolean secure;
 	private boolean useDummyTrustManager;
 	private TrustManager[] trustManager;
 	private SSLContext sslContext;
 	private SSLSocketFactory sslSocketFactory;
 	private InputStream clientAuthKeystoreInputStream;
 	private char[] clientAuthKeystorePassword;
 	private char[] clientAuthKeyPassword;

 	private OutputStream out;
 	private BufferedOutputStream b_out;
 	private ObjectOutputStream o_out;

 	private InputStream in;
 	private BufferedInputStream b_in;
 	private BufferedReader br;
 	private ObjectInputStream o_in;


 	public void setCharset(String c) {
 		charset = c;
 	}
 	public String getCharset() {
 		return charset;
 	}

 	public int getMode() {
 		return ClientService.BLOCKING;
 	}

 	public void connect(String host, int port) throws Exception {
 		this.host = host;
 		this.port = port;

 		if(isDebug()) logger.finest("Connecting to "+host+":"+port);

 		if(isSecure()) {
 			makeSSLSocketFactory();
 			socket = getSslSocketFactory().createSocket(host, port);
 		} else {
 			socket = new Socket(host, port);
 		}

 		in = socket.getInputStream();
 		out = socket.getOutputStream();
 		if(isDebug()) logger.fine("Connected");
 	}

 	public boolean isConnected() {
 		if(socket==null) return false;
 		return socket.isConnected();
 	}

 	public void close() throws IOException {
 		if(isDebug()) logger.fine("Closing");

 		if(out!=null) {
 			if(isDebug()) logger.finest("Closing output streams");
 			try {
 				out.flush();
 			} catch(IOException ioe) {
 				logger.log(Level.FINEST, "Flushing output streams failed: {0}", ioe);
 			}
 			/*
 			if(socket!=null && isSecure()==false) {
 				socket.shutdownOutput();
 			}
 			 */

 			try {
 				if(o_out != null) {
 					o_out.close();
 				}
 			} catch(IOException ioe) {
 				logger.log(Level.FINEST, "o_out stream close failed: {0}", ioe);
 			}

 			try {
 				if(b_out != null) {
 					b_out.close();
 				}
 			} catch(IOException ioe) {
 				logger.log(Level.FINEST, "b_out stream close failed: {0}", ioe);
 			}

 			try {
 				out.close();
 			} catch(IOException ioe) {
 				logger.log(Level.FINEST, "out stream close failed: {0}", ioe);
 			}
 		}

 		if(in!=null) {
 			if(isDebug()) logger.finest("Closing input streams");
 			/*
 			if(socket!=null && isSecure()==false) {
 				socket.shutdownInput();
 			}
 			 */

 			if(o_in != null) {
 				try {
 					o_in.close();
 				} catch(IOException ioe) {
 					logger.log(Level.FINEST, "o_in stream close failed: {0}", ioe);
 				}
 			}
 			if(b_in != null) {
 				try {
 					b_in.close();
 				} catch(IOException ioe) {
 					logger.log(Level.FINEST, "b_in stream close failed: {0}", ioe);
 				}
 			}
 			if(br != null) {
 				try {
 					br.close();
 				} catch(IOException ioe) {
 					logger.log(Level.FINEST, "b_in stream close failed: {0}", ioe);
 				}
 			}
 			try {
 				in.close();
 			} catch(IOException ioe) {
 				logger.log(Level.FINEST, "in stream close failed: {0}", ioe);
 			}
 		}

 		if(socket!=null) {
 			socket.close();
 			socket = null;
 		}
 	}

 	public void sendByte(int data) throws IOException {
 		if(isDebug()) logger.fine("Sending byte");
 		checkBufferedOutputStream();
 		b_out.write(data);
 		b_out.flush();
 	}

 	public void sendBytes(byte[] data) throws IOException {
 		if(isDebug()) logger.log(Level.FINE, "Sending bytes: {0}", data.length);
 		checkBufferedOutputStream();
 		b_out.write(data);
 		b_out.flush();
 	}

 	public void sendBytes(String data, String _charset) throws IOException {
 		if(isDebug()) logger.log(Level.FINE, "Sending: {0}", data);
 		checkBufferedOutputStream();
 		if(_charset==null) _charset = charset;
 		byte d[] = data.getBytes(_charset);
 		b_out.write(d, 0 , d.length);
 		b_out.flush();
 	}

 	public void sendLine(String data, String _charset) throws IOException {
 		if(isDebug()) logger.log(Level.FINE, "Sending: {0}", data);
 		checkBufferedOutputStream();
 		if(_charset==null) _charset = charset;
 		byte d[] = data.getBytes(_charset);
 		b_out.write(d, 0 , d.length);
 		d = "\r\n".getBytes(_charset);
 		b_out.write(d, 0 , d.length);
 		b_out.flush();
 	}

 	public void sendObject(Object data) throws IOException {
 		checkObjectOutputStream();
 		o_out.writeObject(data);
 		o_out.flush();
 	}

 	public int readByte() throws IOException {
 		checkBufferedInputStream();
 		return b_in.read();
 	}

 	public byte[] readBytes() throws IOException {
 		checkBufferedInputStream();
 		return readInputStream(b_in);
 	}

 	public byte[] readBytes(int countToRead) throws IOException {
 		checkBufferedInputStream();
 		return readInputStream(b_in, countToRead);
 	}

 	public String readBytes(String _charset) throws IOException {
 		byte data[] = readBytes();
 		if(data==null) return null;
 		if(_charset==null) _charset = charset;
 		return new String(data, _charset);
 	}

 	public String readBytes(String _charset, int countToRead) throws IOException {
 		byte data[] = readInputStream(b_in, countToRead);
 		if(data==null) return null;
 		if(_charset==null) _charset = charset;
 		return new String(data, _charset);
 	}

 	public String readLine() throws IOException {
 		checkBufferedReader();
 		return br.readLine();
 	}

 	 public String readCRLFLine() throws IOException {
 		checkBufferedInputStream();

 		StringBuilder sb = new StringBuilder();
 		int _ch = -1;
 		do {
 			_ch = b_in.read();
 			if(_ch==-1) {
 				return null;
 			}
 			if(_ch==_CR) {
 				_ch = b_in.read();
 				if(_ch==_LF) {
 					break;
 				} else {
 					sb.append((char) _CR);
 					sb.append((char) _ch);
 				}
 			} else {
 				sb.append((char) _ch);
 			}
 		} while(true);

 		return(new String(sb));
    }

 	public Object readObject() throws IOException, ClassNotFoundException {
 		checkObjectInputStream();
 		return o_in.readObject();
 	}

 	public Socket getSocket() {
 		return socket;
 	}

 	private void checkObjectOutputStream() throws IOException {
 		if(o_out==null) {
 			b_out = null;
 			o_out = new ObjectOutputStream(out);
 			o_out.flush();
 		}
 	}
 	private void checkBufferedOutputStream() throws IOException {
 		if(b_out==null) {
 			o_out = null;
 			b_out = new BufferedOutputStream(out);
 		}
 	}

 	private void checkBufferedInputStream() throws IOException {
 		if(b_in==null) {
 			br = null;
 			o_in = null;
 			b_in = new BufferedInputStream(in);
 		}
 	}
 	private void checkBufferedReader() throws IOException {
 		if(br==null) {
 			b_in = null;
 			o_in = null;
 			br = new BufferedReader(new InputStreamReader(in, charset));
 		}
 	}
 	private void checkObjectInputStream() throws IOException {
 		if(o_in==null) {
 			b_in = null;
 			br = null;
 			o_in = new ObjectInputStream(in);
 		}
 	}

 	public static byte[] readInputStream(InputStream _in, int countToRead)
 			throws IOException {
 		byte data[] = new byte[countToRead];
 		if(_in==null) {
 			throw new IOException("InputStream can't be null!");
 		}

 		int count = 0;
 		int dataRead = 0;
 		int dataLeftToRead = countToRead - dataRead;

 		while(true) {
 			count = _in.read(data, dataRead, dataLeftToRead);
 			if(count==-1) {
 				if(dataRead==countToRead) {
 					break;
 				} else {
 					throw new IOException("we have eof!");
 				}
 			} else {
 				dataRead = dataRead + count;
 				dataLeftToRead = countToRead - dataRead;
 			}

 			if(dataRead>=countToRead) {
 				break;
 			}
 		}//while
 		return data;
 	}

 	public static byte[] readInputStream(InputStream _in) throws IOException {
 		byte data[] = null;
 		if(_in==null)
 			throw new IOException("InputStream can't be null!");

 		int s = _in.read();
 		if(s==-1) {
 			return null; //Connection lost
 		}
 		int alength = _in.available();
 		if(alength > 0) {
 			data = new byte[alength+1];
 			data[0] = (byte) s;
 			int len = _in.read(data, 1, alength);
 			if(len < alength) {
 				data = copyOf(data, len+1);
 			}
 		} else {
 			data = new byte[1];
 			data[0] = (byte) s;
 		}
 		return data;
 	}

 	private static byte[] copyOf(byte data[], int len) {
 		byte newdate[] = new byte[len];
 		System.arraycopy(data, 0, newdate, 0, len);
 		return newdate;
 	}

 	public boolean isSecure() {
 		return secure;
 	}

 	public void setSecure(boolean secure) {
 		this.secure = secure;
 	}

 	public boolean isUseDummyTrustManager() {
 		return useDummyTrustManager;
 	}

 	public void setUseDummyTrustManager(boolean useDummyTrustManager) {
 		this.useDummyTrustManager = useDummyTrustManager;
 	}

 	public TrustManager[] getTrustManager() {
 		return trustManager;
 	}

 	public void setTrustManager(TrustManager[] trustManager) {
 		this.trustManager = trustManager;
 	}

 	public SSLContext getSslContext() {
 		return sslContext;
 	}

 	public void setSslContext(SSLContext sslContext) {
 		this.sslContext = sslContext;
 	}

 	public SSLSocketFactory getSslSocketFactory() {
 		return sslSocketFactory;
 	}

 	public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
 		this.sslSocketFactory = sslSocketFactory;
 	}

 	public void makeSSLSocketFactory() throws Exception {
 		if(getSslContext()==null && getSslSocketFactory()==null) {
 			SSLContext context = null;

                         if(getProviderForSSLContext()!=null) {
                             context = SSLContext.getInstance("TLS", getProviderForSSLContext());
                         } else {
                             context = SSLContext.getInstance("TLS");
                         }

 			if(getTrustManager()==null && isUseDummyTrustManager()) {
 				setTrustManager(new TrustManager[]{DummyTrustManager.getInstance()});
 			}

 			KeyManager km[] = null;
 			if(getClientAuthKeystoreInputStream()!=null) {
 				KeyStore keyStore = KeyStore.getInstance("JKS");
 				keyStore.load(getClientAuthKeystoreInputStream(), getClientAuthKeystorePassword());
 				KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
 				kmf.init(keyStore, getClientAuthKeyPassword());
 				km = kmf.getKeyManagers();
 			} else {
 				km = new KeyManager[0];
 			}

 			context.init(km, getTrustManager(), new SecureRandom());
 			setSslContext(context);
 		}

 		if(getSslSocketFactory()==null) {
 			SSLSocketFactory factory = getSslContext().getSocketFactory();
 			setSslSocketFactory(factory);
 		}
 	}

 	public InputStream getClientAuthKeystoreInputStream() {
 		return clientAuthKeystoreInputStream;
 	}

 	public void setClientAuthKeystoreInputStream(InputStream clientAuthKeystoreInputStream) {
 		this.clientAuthKeystoreInputStream = clientAuthKeystoreInputStream;
 	}

 	public char[] getClientAuthKeystorePassword() {
 		return clientAuthKeystorePassword;
 	}

 	public void setClientAuthKeystorePassword(char clientAuthKeystorePassword[]) {
 		this.clientAuthKeystorePassword = clientAuthKeystorePassword;
 	}

 	public char[] getClientAuthKeyPassword() {
 		return clientAuthKeyPassword;
 	}

 	public void setClientAuthKeyPassword(char[] clientAuthKeyPassword) {
 		this.clientAuthKeyPassword = clientAuthKeyPassword;
 	}
 }
	/*
	* This file is part of the QuickServer library
	* Copyright (C) QuickServer.org
	*
	* Use, modification, copying and distribution of this software is subject to
	* the terms and conditions of the GNU Lesser General Public License.
	* You should have received a copy of the GNU LGP License along with this
	* library; if not, you can download a copy from <http://www.quickserver.org/>.
	*
	* For questions, suggestions, bug-reports, enhancement-requests etc.
	* visit http://www.quickserver.org
	*
	*/

	package org.quickserver.net.client;

	import java.io.*;
	import java.net.*;
	import java.security.KeyStore;
	import java.security.SecureRandom;
	import java.util.logging.*;
	import javax.net.ssl.KeyManager;
	import javax.net.ssl.KeyManagerFactory;
	import javax.net.ssl.SSLContext;
	import javax.net.ssl.SSLSocketFactory;
	import javax.net.ssl.TrustManager;

	/**
	* Blocking Client socket.
	* @author Akshathkumar Shetty
	* @since 1.4.7
	*/
	public class BlockingClient implements ClientService {
	private static final Logger logger = Logger.getLogger(BlockingClient.class.getName());
	private static String charset = "ISO-8859-1";
	private static boolean debug = false;
	private static final int _CR = 13;
	private static final int _LF = 10;

	private static String providerForSSLContext;

	public static boolean isDebug() {
	return debug;
	}

	public static void setDebug(boolean aDebug) {
	debug = aDebug;
	}

	/**
	* @return the providerForSSLContext
	*/
	public static String getProviderForSSLContext() {
	return providerForSSLContext;
	}

	/**
	* @param aProviderForSSLContext the providerForSSLContext to set
	*/
	public static void setProviderForSSLContext(String aProviderForSSLContext) {
	providerForSSLContext = aProviderForSSLContext;
	}

	private String host = "localhost";
	private int port = 0;

	private Socket socket;

	private boolean secure;
	private boolean useDummyTrustManager;
	private TrustManager[] trustManager;
	private SSLContext sslContext;
	private SSLSocketFactory sslSocketFactory;
	private InputStream clientAuthKeystoreInputStream;
	private char[] clientAuthKeystorePassword;
	private char[] clientAuthKeyPassword;

	private OutputStream out;
	private BufferedOutputStream b_out;
	private ObjectOutputStream o_out;

	private InputStream in;
	private BufferedInputStream b_in;
	private BufferedReader br;
	private ObjectInputStream o_in;


	public void setCharset(String c) {
	charset = c;
	}
	public String getCharset() {
	return charset;
	}

	public int getMode() {
	return ClientService.BLOCKING;
	}

	public void connect(String host, int port) throws Exception {
	this.host = host;
	this.port = port;

	if(isDebug()) logger.finest("Connecting to "+host+":"+port);

	if(isSecure()) {
	makeSSLSocketFactory();
	socket = getSslSocketFactory().createSocket(host, port);
	} else {
	socket = new Socket(host, port);
	}

	in = socket.getInputStream();
	out = socket.getOutputStream();
	if(isDebug()) logger.fine("Connected");
	}

	public boolean isConnected() {
	if(socket==null) return false;
	return socket.isConnected();
	}

	public void close() throws IOException {
	if(isDebug()) logger.fine("Closing");

	if(out!=null) {
	if(isDebug()) logger.finest("Closing output streams");
	try {
	out.flush();
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "Flushing output streams failed: {0}", ioe);
	}
	/*
	if(socket!=null && isSecure()==false) {
	socket.shutdownOutput();
	}
	*/

	try {
	if(o_out != null) {
	o_out.close();
	}
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "o_out stream close failed: {0}", ioe);
	}

	try {
	if(b_out != null) {
	b_out.close();
	}
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "b_out stream close failed: {0}", ioe);
	}

	try {
	out.close();
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "out stream close failed: {0}", ioe);
	}
	}

	if(in!=null) {
	if(isDebug()) logger.finest("Closing input streams");
	/*
	if(socket!=null && isSecure()==false) {
	socket.shutdownInput();
	}
	*/

	if(o_in != null) {
	try {
	o_in.close();
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "o_in stream close failed: {0}", ioe);
	}
	}
	if(b_in != null) {
	try {
	b_in.close();
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "b_in stream close failed: {0}", ioe);
	}
	}
	if(br != null) {
	try {
	br.close();
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "b_in stream close failed: {0}", ioe);
	}
	}
	try {
	in.close();
	} catch(IOException ioe) {
	logger.log(Level.FINEST, "in stream close failed: {0}", ioe);
	}
	}

	if(socket!=null) {
	socket.close();
	socket = null;
	}
	}

	public void sendByte(int data) throws IOException {
	if(isDebug()) logger.fine("Sending byte");
	checkBufferedOutputStream();
	b_out.write(data);
	b_out.flush();
	}

	public void sendBytes(byte[] data) throws IOException {
	if(isDebug()) logger.log(Level.FINE, "Sending bytes: {0}", data.length);
	checkBufferedOutputStream();
	b_out.write(data);
	b_out.flush();
	}

	public void sendBytes(String data, String _charset) throws IOException {
	if(isDebug()) logger.log(Level.FINE, "Sending: {0}", data);
	checkBufferedOutputStream();
	if(_charset==null) _charset = charset;
	byte d[] = data.getBytes(_charset);
	b_out.write(d, 0 , d.length);
	b_out.flush();
	}

	public void sendLine(String data, String _charset) throws IOException {
	if(isDebug()) logger.log(Level.FINE, "Sending: {0}", data);
	checkBufferedOutputStream();
	if(_charset==null) _charset = charset;
	byte d[] = data.getBytes(_charset);
	b_out.write(d, 0 , d.length);
	d = "\r\n".getBytes(_charset);
	b_out.write(d, 0 , d.length);
	b_out.flush();
	}

	public void sendObject(Object data) throws IOException {
	checkObjectOutputStream();
	o_out.writeObject(data);
	o_out.flush();
	}

	public int readByte() throws IOException {
	checkBufferedInputStream();
	return b_in.read();
	}

	public byte[] readBytes() throws IOException {
	checkBufferedInputStream();
	return readInputStream(b_in);
	}

	public byte[] readBytes(int countToRead) throws IOException {
	checkBufferedInputStream();
	return readInputStream(b_in, countToRead);
	}

	public String readBytes(String _charset) throws IOException {
	byte data[] = readBytes();
	if(data==null) return null;
	if(_charset==null) _charset = charset;
	return new String(data, _charset);
	}

	public String readBytes(String _charset, int countToRead) throws IOException {
	byte data[] = readInputStream(b_in, countToRead);
	if(data==null) return null;
	if(_charset==null) _charset = charset;
	return new String(data, _charset);
	}

	public String readLine() throws IOException {
	checkBufferedReader();
	return br.readLine();
	}

	public String readCRLFLine() throws IOException {
	checkBufferedInputStream();

	StringBuilder sb = new StringBuilder();
	int _ch = -1;
	do {
	_ch = b_in.read();
	if(_ch==-1) {
	return null;
	}
	if(_ch==_CR) {
	_ch = b_in.read();
	if(_ch==_LF) {
	break;
	} else {
	sb.append((char) _CR);
	sb.append((char) _ch);
	}
	} else {
	sb.append((char) _ch);
	}
	} while(true);

	return(new String(sb));
	}

	public Object readObject() throws IOException, ClassNotFoundException {
	checkObjectInputStream();
	return o_in.readObject();
	}

	public Socket getSocket() {
	return socket;
	}

	private void checkObjectOutputStream() throws IOException {
	if(o_out==null) {
	b_out = null;
	o_out = new ObjectOutputStream(out);
	o_out.flush();
	}
	}
	private void checkBufferedOutputStream() throws IOException {
	if(b_out==null) {
	o_out = null;
	b_out = new BufferedOutputStream(out);
	}
	}

	private void checkBufferedInputStream() throws IOException {
	if(b_in==null) {
	br = null;
	o_in = null;
	b_in = new BufferedInputStream(in);
	}
	}
	private void checkBufferedReader() throws IOException {
	if(br==null) {
	b_in = null;
	o_in = null;
	br = new BufferedReader(new InputStreamReader(in, charset));
	}
	}
	private void checkObjectInputStream() throws IOException {
	if(o_in==null) {
	b_in = null;
	br = null;
	o_in = new ObjectInputStream(in);
	}
	}

	public static byte[] readInputStream(InputStream _in, int countToRead)
	throws IOException {
	byte data[] = new byte[countToRead];
	if(_in==null) {
	throw new IOException("InputStream can't be null!");
	}

	int count = 0;
	int dataRead = 0;
	int dataLeftToRead = countToRead - dataRead;

	while(true) {
	count = _in.read(data, dataRead, dataLeftToRead);
	if(count==-1) {
	if(dataRead==countToRead) {
	break;
	} else {
	throw new IOException("we have eof!");
	}
	} else {
	dataRead = dataRead + count;
	dataLeftToRead = countToRead - dataRead;
	}

	if(dataRead>=countToRead) {
	break;
	}
	}//while
	return data;
	}

	public static byte[] readInputStream(InputStream _in) throws IOException {
	byte data[] = null;
	if(_in==null)
	throw new IOException("InputStream can't be null!");

	int s = _in.read();
	if(s==-1) {
	return null; //Connection lost
	}
	int alength = _in.available();
	if(alength > 0) {
	data = new byte[alength+1];
	data[0] = (byte) s;
	int len = _in.read(data, 1, alength);
	if(len < alength) {
	data = copyOf(data, len+1);
	}
	} else {
	data = new byte[1];
	data[0] = (byte) s;
	}
	return data;
	}

	private static byte[] copyOf(byte data[], int len) {
	byte newdate[] = new byte[len];
	System.arraycopy(data, 0, newdate, 0, len);
	return newdate;
	}

	public boolean isSecure() {
	return secure;
	}

	public void setSecure(boolean secure) {
	this.secure = secure;
	}

	public boolean isUseDummyTrustManager() {
	return useDummyTrustManager;
	}

	public void setUseDummyTrustManager(boolean useDummyTrustManager) {
	this.useDummyTrustManager = useDummyTrustManager;
	}

	public TrustManager[] getTrustManager() {
	return trustManager;
	}

	public void setTrustManager(TrustManager[] trustManager) {
	this.trustManager = trustManager;
	}

	public SSLContext getSslContext() {
	return sslContext;
	}

	public void setSslContext(SSLContext sslContext) {
	this.sslContext = sslContext;
	}

	public SSLSocketFactory getSslSocketFactory() {
	return sslSocketFactory;
	}

	public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
	this.sslSocketFactory = sslSocketFactory;
	}

	public void makeSSLSocketFactory() throws Exception {
	if(getSslContext()==null && getSslSocketFactory()==null) {
	SSLContext context = null;

	if(getProviderForSSLContext()!=null) {
	context = SSLContext.getInstance("TLS", getProviderForSSLContext());
	} else {
	context = SSLContext.getInstance("TLS");
	}

	if(getTrustManager()==null && isUseDummyTrustManager()) {
	setTrustManager(new TrustManager[]{DummyTrustManager.getInstance()});
	}

	KeyManager km[] = null;
	if(getClientAuthKeystoreInputStream()!=null) {
	KeyStore keyStore = KeyStore.getInstance("JKS");
	keyStore.load(getClientAuthKeystoreInputStream(), getClientAuthKeystorePassword());
	KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
	kmf.init(keyStore, getClientAuthKeyPassword());
	km = kmf.getKeyManagers();
	} else {
	km = new KeyManager[0];
	}

	context.init(km, getTrustManager(), new SecureRandom());
	setSslContext(context);
	}

	if(getSslSocketFactory()==null) {
	SSLSocketFactory factory = getSslContext().getSocketFactory();
	setSslSocketFactory(factory);
	}
	}

	public InputStream getClientAuthKeystoreInputStream() {
	return clientAuthKeystoreInputStream;
	}

	public void setClientAuthKeystoreInputStream(InputStream clientAuthKeystoreInputStream) {
	this.clientAuthKeystoreInputStream = clientAuthKeystoreInputStream;
	}

	public char[] getClientAuthKeystorePassword() {
	return clientAuthKeystorePassword;
	}

	public void setClientAuthKeystorePassword(char clientAuthKeystorePassword[]) {
	this.clientAuthKeystorePassword = clientAuthKeystorePassword;
	}

	public char[] getClientAuthKeyPassword() {
	return clientAuthKeyPassword;
	}

	public void setClientAuthKeyPassword(char[] clientAuthKeyPassword) {
	this.clientAuthKeyPassword = clientAuthKeyPassword;
	}
	}