org.eclipse.mylyn.commons.repositories.http.core/src/org/eclipse/mylyn/commons/repositories/http/core/HttpUtil.java - mylyn/org.eclipse.mylyn.commons - Git at Google

 /*******************************************************************************
  * Copyright (c) 2011, 2014 Tasktop Technologies and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Tasktop Technologies - initial API and implementation
  *******************************************************************************/

 package org.eclipse.mylyn.commons.repositories.http.core;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InterruptedIOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Proxy;
 import java.net.URI;
 import java.net.UnknownHostException;
 import java.util.Locale;

 import org.apache.http.HttpEntity;
 import org.apache.http.HttpHost;
 import org.apache.http.HttpRequest;
 import org.apache.http.HttpResponse;
 import org.apache.http.auth.AuthScope;
 import org.apache.http.auth.Credentials;
 import org.apache.http.auth.NTCredentials;
 import org.apache.http.auth.UsernamePasswordCredentials;
 import org.apache.http.client.methods.HttpRequestBase;
 import org.apache.http.client.methods.HttpUriRequest;
 import org.apache.http.client.params.AuthPolicy;
 import org.apache.http.client.params.ClientPNames;
 import org.apache.http.client.params.CookiePolicy;
 import org.apache.http.client.params.HttpClientParams;
 import org.apache.http.conn.params.ConnRoutePNames;
 import org.apache.http.conn.scheme.Scheme;
 import org.apache.http.conn.scheme.SchemeRegistry;
 import org.apache.http.conn.scheme.SchemeSocketFactory;
 import org.apache.http.impl.EnglishReasonPhraseCatalog;
 import org.apache.http.impl.client.AbstractHttpClient;
 import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
 import org.apache.http.params.HttpConnectionParams;
 import org.apache.http.params.HttpProtocolParams;
 import org.apache.http.protocol.HttpContext;
 import org.apache.http.util.EntityUtils;
 import org.eclipse.core.net.proxy.IProxyData;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.mylyn.commons.core.CoreUtil;
 import org.eclipse.mylyn.commons.core.StatusHandler;
 import org.eclipse.mylyn.commons.core.net.AuthenticatedProxy;
 import org.eclipse.mylyn.commons.core.net.NetUtil;
 import org.eclipse.mylyn.commons.core.operations.CancellableOperationMonitorThread;
 import org.eclipse.mylyn.commons.core.operations.ICancellableOperation;
 import org.eclipse.mylyn.commons.core.operations.IOperationMonitor;
 import org.eclipse.mylyn.commons.core.operations.OperationUtil;
 import org.eclipse.mylyn.commons.repositories.core.RepositoryLocation;
 import org.eclipse.mylyn.commons.repositories.core.auth.AuthenticationType;
 import org.eclipse.mylyn.commons.repositories.core.auth.UserCredentials;
 import org.eclipse.mylyn.internal.commons.repositories.http.core.IdleConnectionMonitorThread;
 import org.eclipse.mylyn.internal.commons.repositories.http.core.PollingProtocolSocketFactory;
 import org.eclipse.mylyn.internal.commons.repositories.http.core.PollingSslProtocolSocketFactory;

 /**
  * @author Steffen Pingel
  * @author Shawn Minto
  * @author Christian Janz
  * @noinstantiate This class is not intended to be instantiated by clients.
  */
 public class HttpUtil {

 	static {
 		CoreUtil.initializeLoggingSettings();
 	}

 	@SuppressWarnings("unused")
 	private static final int BUFFER_SIZE = 4096;

 	@SuppressWarnings("unused")
 	private static final long CLOSE_TIMEOUT = -1;

 	/**
 	 * @see IdleConnectionMonitorThread
 	 */
 	private static final int CONNECTION_TIMEOUT_INTERVAL = 1 * 30 * 1000;

 	private static final int CONNNECT_TIMEOUT = 60 * 1000;

 	private static final int HTTP_PORT = 80;

 	private static final int HTTPS_PORT = 443;

 	private static final int POLL_INTERVAL = 500;

 	private static final int SOCKET_TIMEOUT = 3 * 60 * 1000;

 	@SuppressWarnings("unused")
 	private static final int POLL_ATTEMPTS = SOCKET_TIMEOUT / POLL_INTERVAL;

 	private static SchemeSocketFactory socketFactory = new PollingProtocolSocketFactory();

 	private static SchemeSocketFactory sslSocketFactory = new PollingSslProtocolSocketFactory();

 	static final String ID_PLUGIN = "org.eclipse.mylyn.commons.repositories.http"; //$NON-NLS-1$

 	private static ThreadSafeClientConnManager connectionManager;

 	static final String CONTEXT_KEY_MONITOR_THREAD = CancellableOperationMonitorThread.class.getName();

 	public static void configureClient(AbstractHttpClient client, String userAgent) {
 		HttpClientParams.setCookiePolicy(client.getParams(), CookiePolicy.BEST_MATCH);

 		if (userAgent != null) {
 			HttpProtocolParams.setUserAgent(client.getParams(), userAgent);
 		}
 		HttpProtocolParams.setUseExpectContinue(client.getParams(), true);
 		client.getParams().setBooleanParameter(ClientPNames.ALLOW_CIRCULAR_REDIRECTS, true);

 		HttpConnectionParams.setConnectionTimeout(client.getParams(), CONNNECT_TIMEOUT);
 		HttpConnectionParams.setSoTimeout(client.getParams(), SOCKET_TIMEOUT);

 		//AuthParams.setCredentialCharset(client.getParams(), "UTF-8");
 	}

 	public static void configureAuthentication(AbstractHttpClient client, RepositoryLocation location) {
 		UserCredentials credentials = location.getCredentials(AuthenticationType.HTTP);
 		if (credentials != null) {
 			configureAuthentication(client, location, credentials);
 		}
 	}

 	public static void configureAuthentication(AbstractHttpClient client, RepositoryLocation location,
 			UserCredentials credentials) {
 		Assert.isNotNull(client);
 		Assert.isNotNull(location);
 		Assert.isNotNull(credentials);
 		String url = location.getUrl();
 		Assert.isNotNull(url, "The location url must not be null"); //$NON-NLS-1$

 		String host = NetUtil.getHost(url);
 		int port = NetUtil.getPort(url);

 		NTCredentials ntlmCredentials = getNtCredentials(credentials, ""); //$NON-NLS-1$
 		if (ntlmCredentials != null) {
 			AuthScope authScopeNtlm = new AuthScope(host, port, AuthScope.ANY_REALM, AuthPolicy.NTLM);
 			client.getCredentialsProvider().setCredentials(authScopeNtlm, ntlmCredentials);
 		}

 		UsernamePasswordCredentials usernamePasswordCredentials = getUserNamePasswordCredentials(credentials);
 		AuthScope authScopeAny = new AuthScope(host, port, AuthScope.ANY_REALM);
 		client.getCredentialsProvider().setCredentials(authScopeAny, usernamePasswordCredentials);
 	}

 	public static HttpHost createHost(HttpRequestBase method) {
 		URI uri = method.getURI();
 		return new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());
 	}

 	public static HttpResponse execute(final AbstractHttpClient client, final HttpContext context,
 			final HttpRequestBase method, IProgressMonitor monitor) throws IOException {
 		return execute(client, createHost(method), context, method, monitor);
 	}

 	public static HttpResponse execute(final AbstractHttpClient client, final HttpHost host, final HttpContext context,
 			final HttpRequestBase method, final IProgressMonitor progress) throws IOException {
 		Assert.isNotNull(client);
 		Assert.isNotNull(method);

 		final IOperationMonitor monitor = OperationUtil.convert(progress);
 		ICancellableOperation operation = new ICancellableOperation() {
 			@Override
 			public void abort() {
 				method.abort();
 			}

 			@Override
 			public boolean isCanceled() {
 				return monitor.isCanceled();
 			}
 		};

 		CancellableOperationMonitorThread thread = null;
 		if (context != null) {
 			thread = (CancellableOperationMonitorThread) context.getAttribute(CONTEXT_KEY_MONITOR_THREAD);
 		}
 		if (thread != null) {
 			thread.addOperation(operation);
 		}
 		try {
 			return client.execute(host, method, context);
 		} catch (InterruptedIOException e) {
 			if (monitor.isCanceled()) {
 				throw new OperationCanceledException();
 			}
 			throw e;
 		} finally {
 			if (thread != null) {
 				thread.removeOperation(operation);
 			}
 		}
 	}

 	public static NTCredentials getNtCredentials(UserCredentials credentials, String workstation) {
 		String username = credentials.getUserName();
 		int i = username.indexOf("\\"); //$NON-NLS-1$
 		if (i > 0 && i < username.length() - 1) {
 //			try {
 //				InetAddress localHost = InetAddress.getLocalHost();
 //				if (localHost != null) {
 //					hostName = localHost.getHostName();
 //				}
 //			} catch (UnknownHostException e) {
 //				StatusHandler.log(new Status(IStatus.ERROR, ID_PLUGIN,
 //						"Unable to get hostname.  Defaulting to servers host.", e));
 //			}
 			return new NTCredentials(username.substring(i + 1), credentials.getPassword(), workstation,
 					username.substring(0, i));
 		}
 		return null;
 	}

 	public static UsernamePasswordCredentials getUserNamePasswordCredentials(UserCredentials credentials) {
 		return new UsernamePasswordCredentials(credentials.getUserName(), credentials.getPassword());
 	}

 	public static InputStream getResponseBodyAsStream(HttpEntity entity, IProgressMonitor monitor) throws IOException {
 		monitor = OperationUtil.convert(monitor);
 		return entity.getContent();
 //		return new PollingInputStream(new TimeoutInputStream(entity.getContent(), BUFFER_SIZE, POLL_INTERVAL,
 //				CLOSE_TIMEOUT), POLL_ATTEMPTS, monitor);
 	}

 	public static SchemeRegistry getSchemeRegistry() {
 		SchemeRegistry schemeRegistry = new SchemeRegistry();
 		schemeRegistry.register(new Scheme("http", HTTP_PORT, socketFactory)); //$NON-NLS-1$
 		schemeRegistry.register(new Scheme("https", HTTPS_PORT, sslSocketFactory)); //$NON-NLS-1$
 		return schemeRegistry;
 	}

 	public static void configureProxy(AbstractHttpClient client, RepositoryLocation location) {
 		Assert.isNotNull(client);
 		Assert.isNotNull(location);
 		String url = location.getUrl();
 		Assert.isNotNull(url, "The location url must not be null"); //$NON-NLS-1$

 		String host = NetUtil.getHost(url);
 		Proxy proxy;
 		if (NetUtil.isUrlHttps(url)) {
 			proxy = location.getProxyForHost(host, IProxyData.HTTPS_PROXY_TYPE);
 		} else {
 			proxy = location.getProxyForHost(host, IProxyData.HTTP_PROXY_TYPE);
 		}

 		if (proxy != null && !Proxy.NO_PROXY.equals(proxy)) {
 			InetSocketAddress address = (InetSocketAddress) proxy.address();

 			client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,
 					new HttpHost(address.getHostName(), address.getPort()));

 			if (proxy instanceof AuthenticatedProxy) {
 				AuthenticatedProxy authProxy = (AuthenticatedProxy) proxy;
 				Credentials credentials = getCredentials(authProxy.getUserName(), authProxy.getPassword(),
 						address.getAddress(), false);
 				if (credentials instanceof NTCredentials) {
 					AuthScope proxyAuthScopeNTLM = new AuthScope(address.getHostName(), address.getPort(),
 							AuthScope.ANY_REALM, AuthPolicy.NTLM);
 					client.getCredentialsProvider().setCredentials(proxyAuthScopeNTLM, credentials);

 					AuthScope proxyAuthScopeAny = new AuthScope(address.getHostName(), address.getPort(),
 							AuthScope.ANY_REALM);
 					Credentials usernamePasswordCredentials = getCredentials(authProxy.getUserName(),
 							authProxy.getPassword(), address.getAddress(), true);
 					client.getCredentialsProvider().setCredentials(proxyAuthScopeAny, usernamePasswordCredentials);

 				} else {
 					AuthScope proxyAuthScope = new AuthScope(address.getHostName(), address.getPort(),
 							AuthScope.ANY_REALM);
 					client.getCredentialsProvider().setCredentials(proxyAuthScope, credentials);
 				}
 			}
 		} else {
 			client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, null);
 		}
 	}

 	static Credentials getCredentials(final String username, final String password, final InetAddress address,
 			boolean forceUserNamePassword) {
 		int i = username.indexOf("\\"); //$NON-NLS-1$
 		if (i > 0 && i < username.length() - 1 && address != null && !forceUserNamePassword) {
 			String hostName = address.getHostName();
 			try {
 				InetAddress localHost = InetAddress.getLocalHost();
 				if (localHost != null) {
 					hostName = localHost.getHostName();
 				}
 			} catch (UnknownHostException e) {
 				StatusHandler.log(new Status(IStatus.ERROR, ID_PLUGIN,
 						"Unable to get hostname.  Defaulting to servers host.", e)); //$NON-NLS-1$
 			}
 			if (hostName == null) {
 				hostName = address.getHostName();
 			}
 			return new NTCredentials(username.substring(i + 1), password, hostName, username.substring(0, i));
 		} else {
 			return new UsernamePasswordCredentials(username, password);
 		}
 	}

 	public static synchronized ThreadSafeClientConnManager getConnectionManager() {
 		if (connectionManager == null) {
 			connectionManager = new ThreadSafeClientConnManager(HttpUtil.getSchemeRegistry());
 			if (CoreUtil.TEST_MODE) {
 				connectionManager.setDefaultMaxPerRoute(2);
 			} else {
 				connectionManager.setDefaultMaxPerRoute(NetUtil.getMaxHttpConnectionsPerHost());
 				connectionManager.setMaxTotal(NetUtil.getMaxHttpConnections());
 			}

 			IdleConnectionMonitorThread thread = new IdleConnectionMonitorThread(CONNECTION_TIMEOUT_INTERVAL);
 			thread.setTimeout(CONNNECT_TIMEOUT);
 			thread.addConnectionManager(connectionManager);
 			thread.start();
 		}
 		return connectionManager;
 	}

 	public static String getStatusText(int statusCode) {
 		return EnglishReasonPhraseCatalog.INSTANCE.getReason(statusCode, Locale.getDefault());
 	}

 	public static void release(HttpRequest request, HttpResponse response, IProgressMonitor monitor) {
 		Assert.isNotNull(request);
 		Assert.isNotNull(response);
 		if (monitor != null && monitor.isCanceled() && request instanceof HttpUriRequest) {
 			// force a connection close on cancel to avoid blocking to do reading the remainder of the response
 			try {
 				((HttpUriRequest) request).abort();
 			} catch (UnsupportedOperationException e) {
 				// fall back to standard close
 				consume(request, response);
 			}
 		} else {
 			consume(request, response);
 		}
 	}

 	private static void consume(HttpRequest request, HttpResponse response) {
 		try {
 			EntityUtils.consume(response.getEntity());
 		} catch (IOException e) {
 			// if construction of the stream fails the connection has to be aborted to be released
 			try {
 				((HttpUriRequest) request).abort();
 			} catch (UnsupportedOperationException e2) {
 			}
 		} catch (NullPointerException e2) {
 			// XXX work-around for bug 368830
 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2011, 2014 Tasktop Technologies and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Tasktop Technologies - initial API and implementation
	*******************************************************************************/

	package org.eclipse.mylyn.commons.repositories.http.core;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InterruptedIOException;
	import java.net.InetAddress;
	import java.net.InetSocketAddress;
	import java.net.Proxy;
	import java.net.URI;
	import java.net.UnknownHostException;
	import java.util.Locale;

	import org.apache.http.HttpEntity;
	import org.apache.http.HttpHost;
	import org.apache.http.HttpRequest;
	import org.apache.http.HttpResponse;
	import org.apache.http.auth.AuthScope;
	import org.apache.http.auth.Credentials;
	import org.apache.http.auth.NTCredentials;
	import org.apache.http.auth.UsernamePasswordCredentials;
	import org.apache.http.client.methods.HttpRequestBase;
	import org.apache.http.client.methods.HttpUriRequest;
	import org.apache.http.client.params.AuthPolicy;
	import org.apache.http.client.params.ClientPNames;
	import org.apache.http.client.params.CookiePolicy;
	import org.apache.http.client.params.HttpClientParams;
	import org.apache.http.conn.params.ConnRoutePNames;
	import org.apache.http.conn.scheme.Scheme;
	import org.apache.http.conn.scheme.SchemeRegistry;
	import org.apache.http.conn.scheme.SchemeSocketFactory;
	import org.apache.http.impl.EnglishReasonPhraseCatalog;
	import org.apache.http.impl.client.AbstractHttpClient;
	import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
	import org.apache.http.params.HttpConnectionParams;
	import org.apache.http.params.HttpProtocolParams;
	import org.apache.http.protocol.HttpContext;
	import org.apache.http.util.EntityUtils;
	import org.eclipse.core.net.proxy.IProxyData;
	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.OperationCanceledException;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.mylyn.commons.core.CoreUtil;
	import org.eclipse.mylyn.commons.core.StatusHandler;
	import org.eclipse.mylyn.commons.core.net.AuthenticatedProxy;
	import org.eclipse.mylyn.commons.core.net.NetUtil;
	import org.eclipse.mylyn.commons.core.operations.CancellableOperationMonitorThread;
	import org.eclipse.mylyn.commons.core.operations.ICancellableOperation;
	import org.eclipse.mylyn.commons.core.operations.IOperationMonitor;
	import org.eclipse.mylyn.commons.core.operations.OperationUtil;
	import org.eclipse.mylyn.commons.repositories.core.RepositoryLocation;
	import org.eclipse.mylyn.commons.repositories.core.auth.AuthenticationType;
	import org.eclipse.mylyn.commons.repositories.core.auth.UserCredentials;
	import org.eclipse.mylyn.internal.commons.repositories.http.core.IdleConnectionMonitorThread;
	import org.eclipse.mylyn.internal.commons.repositories.http.core.PollingProtocolSocketFactory;
	import org.eclipse.mylyn.internal.commons.repositories.http.core.PollingSslProtocolSocketFactory;

	/**
	* @author Steffen Pingel
	* @author Shawn Minto
	* @author Christian Janz
	* @noinstantiate This class is not intended to be instantiated by clients.
	*/
	public class HttpUtil {

	static {
	CoreUtil.initializeLoggingSettings();
	}

	@SuppressWarnings("unused")
	private static final int BUFFER_SIZE = 4096;

	@SuppressWarnings("unused")
	private static final long CLOSE_TIMEOUT = -1;

	/**
	* @see IdleConnectionMonitorThread
	*/
	private static final int CONNECTION_TIMEOUT_INTERVAL = 1 * 30 * 1000;

	private static final int CONNNECT_TIMEOUT = 60 * 1000;

	private static final int HTTP_PORT = 80;

	private static final int HTTPS_PORT = 443;

	private static final int POLL_INTERVAL = 500;

	private static final int SOCKET_TIMEOUT = 3 * 60 * 1000;

	@SuppressWarnings("unused")
	private static final int POLL_ATTEMPTS = SOCKET_TIMEOUT / POLL_INTERVAL;

	private static SchemeSocketFactory socketFactory = new PollingProtocolSocketFactory();

	private static SchemeSocketFactory sslSocketFactory = new PollingSslProtocolSocketFactory();

	static final String ID_PLUGIN = "org.eclipse.mylyn.commons.repositories.http"; //$NON-NLS-1$

	private static ThreadSafeClientConnManager connectionManager;

	static final String CONTEXT_KEY_MONITOR_THREAD = CancellableOperationMonitorThread.class.getName();

	public static void configureClient(AbstractHttpClient client, String userAgent) {
	HttpClientParams.setCookiePolicy(client.getParams(), CookiePolicy.BEST_MATCH);

	if (userAgent != null) {
	HttpProtocolParams.setUserAgent(client.getParams(), userAgent);
	}
	HttpProtocolParams.setUseExpectContinue(client.getParams(), true);
	client.getParams().setBooleanParameter(ClientPNames.ALLOW_CIRCULAR_REDIRECTS, true);

	HttpConnectionParams.setConnectionTimeout(client.getParams(), CONNNECT_TIMEOUT);
	HttpConnectionParams.setSoTimeout(client.getParams(), SOCKET_TIMEOUT);

	//AuthParams.setCredentialCharset(client.getParams(), "UTF-8");
	}

	public static void configureAuthentication(AbstractHttpClient client, RepositoryLocation location) {
	UserCredentials credentials = location.getCredentials(AuthenticationType.HTTP);
	if (credentials != null) {
	configureAuthentication(client, location, credentials);
	}
	}

	public static void configureAuthentication(AbstractHttpClient client, RepositoryLocation location,
	UserCredentials credentials) {
	Assert.isNotNull(client);
	Assert.isNotNull(location);
	Assert.isNotNull(credentials);
	String url = location.getUrl();
	Assert.isNotNull(url, "The location url must not be null"); //$NON-NLS-1$

	String host = NetUtil.getHost(url);
	int port = NetUtil.getPort(url);

	NTCredentials ntlmCredentials = getNtCredentials(credentials, ""); //$NON-NLS-1$
	if (ntlmCredentials != null) {
	AuthScope authScopeNtlm = new AuthScope(host, port, AuthScope.ANY_REALM, AuthPolicy.NTLM);
	client.getCredentialsProvider().setCredentials(authScopeNtlm, ntlmCredentials);
	}

	UsernamePasswordCredentials usernamePasswordCredentials = getUserNamePasswordCredentials(credentials);
	AuthScope authScopeAny = new AuthScope(host, port, AuthScope.ANY_REALM);
	client.getCredentialsProvider().setCredentials(authScopeAny, usernamePasswordCredentials);
	}

	public static HttpHost createHost(HttpRequestBase method) {
	URI uri = method.getURI();
	return new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());
	}

	public static HttpResponse execute(final AbstractHttpClient client, final HttpContext context,
	final HttpRequestBase method, IProgressMonitor monitor) throws IOException {
	return execute(client, createHost(method), context, method, monitor);
	}

	public static HttpResponse execute(final AbstractHttpClient client, final HttpHost host, final HttpContext context,
	final HttpRequestBase method, final IProgressMonitor progress) throws IOException {
	Assert.isNotNull(client);
	Assert.isNotNull(method);

	final IOperationMonitor monitor = OperationUtil.convert(progress);
	ICancellableOperation operation = new ICancellableOperation() {
	@Override
	public void abort() {
	method.abort();
	}

	@Override
	public boolean isCanceled() {
	return monitor.isCanceled();
	}
	};

	CancellableOperationMonitorThread thread = null;
	if (context != null) {
	thread = (CancellableOperationMonitorThread) context.getAttribute(CONTEXT_KEY_MONITOR_THREAD);
	}
	if (thread != null) {
	thread.addOperation(operation);
	}
	try {
	return client.execute(host, method, context);
	} catch (InterruptedIOException e) {
	if (monitor.isCanceled()) {
	throw new OperationCanceledException();
	}
	throw e;
	} finally {
	if (thread != null) {
	thread.removeOperation(operation);
	}
	}
	}

	public static NTCredentials getNtCredentials(UserCredentials credentials, String workstation) {
	String username = credentials.getUserName();
	int i = username.indexOf("\\"); //$NON-NLS-1$
	if (i > 0 && i < username.length() - 1) {
	// try {
	// InetAddress localHost = InetAddress.getLocalHost();
	// if (localHost != null) {
	// hostName = localHost.getHostName();
	// }
	// } catch (UnknownHostException e) {
	// StatusHandler.log(new Status(IStatus.ERROR, ID_PLUGIN,
	// "Unable to get hostname. Defaulting to servers host.", e));
	// }
	return new NTCredentials(username.substring(i + 1), credentials.getPassword(), workstation,
	username.substring(0, i));
	}
	return null;
	}

	public static UsernamePasswordCredentials getUserNamePasswordCredentials(UserCredentials credentials) {
	return new UsernamePasswordCredentials(credentials.getUserName(), credentials.getPassword());
	}

	public static InputStream getResponseBodyAsStream(HttpEntity entity, IProgressMonitor monitor) throws IOException {
	monitor = OperationUtil.convert(monitor);
	return entity.getContent();
	// return new PollingInputStream(new TimeoutInputStream(entity.getContent(), BUFFER_SIZE, POLL_INTERVAL,
	// CLOSE_TIMEOUT), POLL_ATTEMPTS, monitor);
	}

	public static SchemeRegistry getSchemeRegistry() {
	SchemeRegistry schemeRegistry = new SchemeRegistry();
	schemeRegistry.register(new Scheme("http", HTTP_PORT, socketFactory)); //$NON-NLS-1$
	schemeRegistry.register(new Scheme("https", HTTPS_PORT, sslSocketFactory)); //$NON-NLS-1$
	return schemeRegistry;
	}

	public static void configureProxy(AbstractHttpClient client, RepositoryLocation location) {
	Assert.isNotNull(client);
	Assert.isNotNull(location);
	String url = location.getUrl();
	Assert.isNotNull(url, "The location url must not be null"); //$NON-NLS-1$

	String host = NetUtil.getHost(url);
	Proxy proxy;
	if (NetUtil.isUrlHttps(url)) {
	proxy = location.getProxyForHost(host, IProxyData.HTTPS_PROXY_TYPE);
	} else {
	proxy = location.getProxyForHost(host, IProxyData.HTTP_PROXY_TYPE);
	}

	if (proxy != null && !Proxy.NO_PROXY.equals(proxy)) {
	InetSocketAddress address = (InetSocketAddress) proxy.address();

	client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,
	new HttpHost(address.getHostName(), address.getPort()));

	if (proxy instanceof AuthenticatedProxy) {
	AuthenticatedProxy authProxy = (AuthenticatedProxy) proxy;
	Credentials credentials = getCredentials(authProxy.getUserName(), authProxy.getPassword(),
	address.getAddress(), false);
	if (credentials instanceof NTCredentials) {
	AuthScope proxyAuthScopeNTLM = new AuthScope(address.getHostName(), address.getPort(),
	AuthScope.ANY_REALM, AuthPolicy.NTLM);
	client.getCredentialsProvider().setCredentials(proxyAuthScopeNTLM, credentials);

	AuthScope proxyAuthScopeAny = new AuthScope(address.getHostName(), address.getPort(),
	AuthScope.ANY_REALM);
	Credentials usernamePasswordCredentials = getCredentials(authProxy.getUserName(),
	authProxy.getPassword(), address.getAddress(), true);
	client.getCredentialsProvider().setCredentials(proxyAuthScopeAny, usernamePasswordCredentials);

	} else {
	AuthScope proxyAuthScope = new AuthScope(address.getHostName(), address.getPort(),
	AuthScope.ANY_REALM);
	client.getCredentialsProvider().setCredentials(proxyAuthScope, credentials);
	}
	}
	} else {
	client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, null);
	}
	}

	static Credentials getCredentials(final String username, final String password, final InetAddress address,
	boolean forceUserNamePassword) {
	int i = username.indexOf("\\"); //$NON-NLS-1$
	if (i > 0 && i < username.length() - 1 && address != null && !forceUserNamePassword) {
	String hostName = address.getHostName();
	try {
	InetAddress localHost = InetAddress.getLocalHost();
	if (localHost != null) {
	hostName = localHost.getHostName();
	}
	} catch (UnknownHostException e) {
	StatusHandler.log(new Status(IStatus.ERROR, ID_PLUGIN,
	"Unable to get hostname. Defaulting to servers host.", e)); //$NON-NLS-1$
	}
	if (hostName == null) {
	hostName = address.getHostName();
	}
	return new NTCredentials(username.substring(i + 1), password, hostName, username.substring(0, i));
	} else {
	return new UsernamePasswordCredentials(username, password);
	}
	}

	public static synchronized ThreadSafeClientConnManager getConnectionManager() {
	if (connectionManager == null) {
	connectionManager = new ThreadSafeClientConnManager(HttpUtil.getSchemeRegistry());
	if (CoreUtil.TEST_MODE) {
	connectionManager.setDefaultMaxPerRoute(2);
	} else {
	connectionManager.setDefaultMaxPerRoute(NetUtil.getMaxHttpConnectionsPerHost());
	connectionManager.setMaxTotal(NetUtil.getMaxHttpConnections());
	}

	IdleConnectionMonitorThread thread = new IdleConnectionMonitorThread(CONNECTION_TIMEOUT_INTERVAL);
	thread.setTimeout(CONNNECT_TIMEOUT);
	thread.addConnectionManager(connectionManager);
	thread.start();
	}
	return connectionManager;
	}

	public static String getStatusText(int statusCode) {
	return EnglishReasonPhraseCatalog.INSTANCE.getReason(statusCode, Locale.getDefault());
	}

	public static void release(HttpRequest request, HttpResponse response, IProgressMonitor monitor) {
	Assert.isNotNull(request);
	Assert.isNotNull(response);
	if (monitor != null && monitor.isCanceled() && request instanceof HttpUriRequest) {
	// force a connection close on cancel to avoid blocking to do reading the remainder of the response
	try {
	((HttpUriRequest) request).abort();
	} catch (UnsupportedOperationException e) {
	// fall back to standard close
	consume(request, response);
	}
	} else {
	consume(request, response);
	}
	}

	private static void consume(HttpRequest request, HttpResponse response) {
	try {
	EntityUtils.consume(response.getEntity());
	} catch (IOException e) {
	// if construction of the stream fails the connection has to be aborted to be released
	try {
	((HttpUriRequest) request).abort();
	} catch (UnsupportedOperationException e2) {
	}
	} catch (NullPointerException e2) {
	// XXX work-around for bug 368830
	}
	}

	}