/*
* 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 org.apache.axis2.transport.http.impl.httpclient3;
import java.net.URL;
import java.util.StringTokenizer;
import javax.xml.namespace.QName;
import org.apache.axiom.om.OMElement;
import org.apache.axis2.AxisFault;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.transport.http.HTTPConstants;
import org.apache.axis2.transport.http.HTTPTransportConstants;
import org.apache.axis2.transport.http.HttpTransportProperties;
import org.apache.commons.httpclient.Credentials;
import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpState;
import org.apache.commons.httpclient.NTCredentials;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* @deprecated use {@link HTTPProxyConfigurator}
*/
@Deprecated
public class HTTPProxcyConfigurator {
private static Log log = LogFactory.getLog(HTTPProxcyConfigurator.class);
/**
* Configure HTTP Proxy settings of commons-httpclient HostConfiguration.
* Proxy settings can be get from axis2.xml, Java proxy settings or can be
* override through property in message context.
* <p/>
* HTTP Proxy setting element format: <parameter name="Proxy">
* <Configuration> <ProxyHost>example.org</ProxyHost>
* <ProxyPort>3128</ProxyPort> <ProxyUser>EXAMPLE/John</ProxyUser>
* <ProxyPassword>password</ProxyPassword> <Configuration> <parameter>
*
* @param messageContext
* in message context for
* @param httpClient
* commons-httpclient instance
* @param config
* commons-httpclient HostConfiguration
* @throws AxisFault
* if Proxy settings are invalid
*/
public static void configure(MessageContext messageContext, HttpClient httpClient,
HostConfiguration config) throws AxisFault {
Credentials proxyCredentials = null;
String proxyHost = null;
String nonProxyHosts = null;
Integer proxyPort = -1;
String proxyUser = null;
String proxyPassword = null;
// Getting configuration values from Axis2.xml
Parameter proxySettingsFromAxisConfig = messageContext.getConfigurationContext()
.getAxisConfiguration().getParameter(HTTPTransportConstants.ATTR_PROXY);
if (proxySettingsFromAxisConfig != null) {
OMElement proxyConfiguration = getProxyConfigurationElement(proxySettingsFromAxisConfig);
proxyHost = getProxyHost(proxyConfiguration);
proxyPort = getProxyPort(proxyConfiguration);
proxyUser = getProxyUser(proxyConfiguration);
proxyPassword = getProxyPassword(proxyConfiguration);
if (proxyUser != null) {
if (proxyPassword == null) {
proxyPassword = "";
}
int proxyUserDomainIndex = proxyUser.indexOf("\\");
if (proxyUserDomainIndex > 0) {
String domain = proxyUser.substring(0, proxyUserDomainIndex);
if (proxyUser.length() > proxyUserDomainIndex + 1) {
String user = proxyUser.substring(proxyUserDomainIndex + 1);
proxyCredentials = new NTCredentials(user, proxyPassword, proxyHost, domain);
}
}
proxyCredentials = new UsernamePasswordCredentials(proxyUser, proxyPassword);
}
}
// If there is runtime proxy settings, these settings will override
// settings from axis2.xml
HttpTransportProperties.ProxyProperties proxyProperties = (HttpTransportProperties.ProxyProperties) messageContext
.getProperty(HTTPConstants.PROXY);
if (proxyProperties != null) {
String proxyHostProp = proxyProperties.getProxyHostName();
if (proxyHostProp == null || proxyHostProp.length() <= 0) {
throw new AxisFault("HTTP Proxy host is not available. Host is a MUST parameter");
} else {
proxyHost = proxyHostProp;
}
proxyPort = proxyProperties.getProxyPort();
// Overriding credentials
String userName = proxyProperties.getUserName();
String password = proxyProperties.getPassWord();
String domain = proxyProperties.getDomain();
if (userName != null && password != null && domain != null) {
proxyCredentials = new NTCredentials(userName, password, proxyHost, domain);
} else if (userName != null && domain == null) {
proxyCredentials = new UsernamePasswordCredentials(userName, password);
}
}
// Overriding proxy settings if proxy is available from JVM settings
String host = System.getProperty(HTTPTransportConstants.HTTP_PROXY_HOST);
if (host != null) {
proxyHost = host;
}
String port = System.getProperty(HTTPTransportConstants.HTTP_PROXY_PORT);
if (port != null) {
proxyPort = Integer.parseInt(port);
}
if (proxyCredentials != null) {
httpClient.getParams().setAuthenticationPreemptive(true);
HttpState cachedHttpState = (HttpState) messageContext
.getProperty(HTTPConstants.CACHED_HTTP_STATE);
if (cachedHttpState != null) {
httpClient.setState(cachedHttpState);
}
httpClient.getState().setProxyCredentials(AuthScope.ANY, proxyCredentials);
}
config.setProxy(proxyHost, proxyPort);
}
private static OMElement getProxyConfigurationElement(Parameter proxySettingsFromAxisConfig)
throws AxisFault {
OMElement proxyConfigurationElement = proxySettingsFromAxisConfig.getParameterElement()
.getFirstElement();
if (proxyConfigurationElement == null) {
log.error(HTTPTransportConstants.PROXY_CONFIGURATION_NOT_FOUND);
throw new AxisFault(HTTPTransportConstants.PROXY_CONFIGURATION_NOT_FOUND);
}
return proxyConfigurationElement;
}
private static String getProxyHost(OMElement proxyConfiguration) throws AxisFault {
OMElement proxyHostElement = proxyConfiguration.getFirstChildWithName(new QName(
HTTPTransportConstants.PROXY_HOST_ELEMENT));
if (proxyHostElement == null) {
log.error(HTTPTransportConstants.PROXY_HOST_ELEMENT_NOT_FOUND);
throw new AxisFault(HTTPTransportConstants.PROXY_HOST_ELEMENT_NOT_FOUND);
}
String proxyHost = proxyHostElement.getText();
if (proxyHost == null) {
log.error(HTTPTransportConstants.PROXY_HOST_ELEMENT_WITH_EMPTY_VALUE);
throw new AxisFault(HTTPTransportConstants.PROXY_HOST_ELEMENT_WITH_EMPTY_VALUE);
}
return proxyHost;
}
private static Integer getProxyPort(OMElement proxyConfiguration) throws AxisFault {
OMElement proxyPortElement = proxyConfiguration.getFirstChildWithName(new QName(
HTTPTransportConstants.PROXY_PORT_ELEMENT));
if (proxyPortElement == null) {
log.error(HTTPTransportConstants.PROXY_PORT_ELEMENT_NOT_FOUND);
throw new AxisFault(HTTPTransportConstants.PROXY_PORT_ELEMENT_NOT_FOUND);
}
String proxyPort = proxyPortElement.getText();
if (proxyPort == null) {
log.error(HTTPTransportConstants.PROXY_PORT_ELEMENT_WITH_EMPTY_VALUE);
throw new AxisFault(HTTPTransportConstants.PROXY_PORT_ELEMENT_WITH_EMPTY_VALUE);
}
return Integer.parseInt(proxyPort);
}
private static String getProxyUser(OMElement proxyConfiguration) {
OMElement proxyUserElement = proxyConfiguration.getFirstChildWithName(new QName(
HTTPTransportConstants.PROXY_USER_ELEMENT));
if (proxyUserElement == null) {
return null;
}
String proxyUser = proxyUserElement.getText();
if (proxyUser == null) {
log.warn("Empty user name element in HTTP Proxy settings.");
return null;
}
return proxyUser;
}
private static String getProxyPassword(OMElement proxyConfiguration) {
OMElement proxyPasswordElement = proxyConfiguration.getFirstChildWithName(new QName(
HTTPTransportConstants.PROXY_PASSWORD_ELEMENT));
if (proxyPasswordElement == null) {
return null;
}
String proxyUser = proxyPasswordElement.getText();
if (proxyUser == null) {
log.warn("Empty user name element in HTTP Proxy settings.");
return null;
}
return proxyUser;
}
/**
* Check whether http proxy is configured or active. This is not a deep
* check.
*
* @param messageContext
* in message context
* @param targetURL
* URL of the edpoint which we are sending the request
* @return true if proxy is enabled, false otherwise
*/
public static boolean isProxyEnabled(MessageContext messageContext, URL targetURL) {
boolean proxyEnabled = false;
Parameter param = messageContext.getConfigurationContext().getAxisConfiguration()
.getParameter(HTTPTransportConstants.ATTR_PROXY);
// If configuration is over ridden
Object obj = messageContext.getProperty(HTTPConstants.PROXY);
// From Java Networking Properties
String sp = System.getProperty(HTTPTransportConstants.HTTP_PROXY_HOST);
if (param != null || obj != null || sp != null) {
proxyEnabled = true;
}
boolean isNonProxyHost = validateNonProxyHosts(targetURL.getHost());
return proxyEnabled && !isNonProxyHost;
}
/**
* Validates for names that shouldn't be listered as proxies. The
* http.nonProxyHosts can be set to specify the hosts which should be
* connected to directly (not through the proxy server). The value of the
* http.nonProxyHosts property can be a list of hosts, each separated by a
* |; it can also take a regular expression for matches; for example:
* *.sfbay.sun.com would match any fully qualified hostname in the sfbay
* domain.
* <p/>
* For more information refer to :
* http://java.sun.com/features/2002/11/hilevel_network.html
* <p/>
* false : validation fail : User can use the proxy true : validation pass ;
* User can't use the proxy
*
* @return boolean
*/
private static boolean validateNonProxyHosts(String host) {
// From system property http.nonProxyHosts
String nonProxyHosts = System.getProperty(HTTPTransportConstants.HTTP_NON_PROXY_HOSTS);
return isHostInNonProxyList(host, nonProxyHosts);
}
/**
* Check if the specified host is in the list of non proxy hosts.
*
* @param host
* host name
* @param nonProxyHosts
* string containing the list of non proxy hosts
* @return true/false
*/
public static boolean isHostInNonProxyList(String host, String nonProxyHosts) {
if ((nonProxyHosts == null) || (host == null)) {
return false;
}
/*
* The http.nonProxyHosts system property is a list enclosed in double
* quotes with items separated by a vertical bar.
*/
StringTokenizer tokenizer = new StringTokenizer(nonProxyHosts, "|\"");
while (tokenizer.hasMoreTokens()) {
String pattern = tokenizer.nextToken();
if (match(pattern, host, false)) {
return true;
}
}
return false;
}
/**
* Matches a string against a pattern. The pattern contains two special
* characters: '*' which means zero or more characters,
*
* @param pattern
* the (non-null) pattern to match against
* @param str
* the (non-null) string that must be matched against the pattern
* @param isCaseSensitive
* @return <code>true</code> when the string matches against the pattern,
* <code>false</code> otherwise.
*/
private static boolean match(String pattern, String str, boolean isCaseSensitive) {
char[] patArr = pattern.toCharArray();
char[] strArr = str.toCharArray();
int patIdxStart = 0;
int patIdxEnd = patArr.length - 1;
int strIdxStart = 0;
int strIdxEnd = strArr.length - 1;
char ch;
boolean containsStar = false;
for (int i = 0; i < patArr.length; i++) {
if (patArr[i] == '*') {
containsStar = true;
break;
}
}
if (!containsStar) {
// No '*'s, so we make a shortcut
if (patIdxEnd != strIdxEnd) {
return false; // Pattern and string do not have the same size
}
for (int i = 0; i <= patIdxEnd; i++) {
ch = patArr[i];
if (isCaseSensitive && (ch != strArr[i])) {
return false; // Character mismatch
}
if (!isCaseSensitive
&& (Character.toUpperCase(ch) != Character.toUpperCase(strArr[i]))) {
return false; // Character mismatch
}
}
return true; // String matches against pattern
}
if (patIdxEnd == 0) {
return true; // Pattern contains only '*', which matches anything
}
// Process characters before first star
while ((ch = patArr[patIdxStart]) != '*' && (strIdxStart <= strIdxEnd)) {
if (isCaseSensitive && (ch != strArr[strIdxStart])) {
return false; // Character mismatch
}
if (!isCaseSensitive
&& (Character.toUpperCase(ch) != Character.toUpperCase(strArr[strIdxStart]))) {
return false; // Character mismatch
}
patIdxStart++;
strIdxStart++;
}
if (strIdxStart > strIdxEnd) {
// All characters in the string are used. Check if only '*'s are
// left in the pattern. If so, we succeeded. Otherwise failure.
for (int i = patIdxStart; i <= patIdxEnd; i++) {
if (patArr[i] != '*') {
return false;
}
}
return true;
}
// Process characters after last star
while ((ch = patArr[patIdxEnd]) != '*' && (strIdxStart <= strIdxEnd)) {
if (isCaseSensitive && (ch != strArr[strIdxEnd])) {
return false; // Character mismatch
}
if (!isCaseSensitive
&& (Character.toUpperCase(ch) != Character.toUpperCase(strArr[strIdxEnd]))) {
return false; // Character mismatch
}
patIdxEnd--;
strIdxEnd--;
}
if (strIdxStart > strIdxEnd) {
// All characters in the string are used. Check if only '*'s are
// left in the pattern. If so, we succeeded. Otherwise failure.
for (int i = patIdxStart; i <= patIdxEnd; i++) {
if (patArr[i] != '*') {
return false;
}
}
return true;
}
// process pattern between stars. padIdxStart and patIdxEnd point
// always to a '*'.
while ((patIdxStart != patIdxEnd) && (strIdxStart <= strIdxEnd)) {
int patIdxTmp = -1;
for (int i = patIdxStart + 1; i <= patIdxEnd; i++) {
if (patArr[i] == '*') {
patIdxTmp = i;
break;
}
}
if (patIdxTmp == patIdxStart + 1) {
// Two stars next to each other, skip the first one.
patIdxStart++;
continue;
}
// Find the pattern between padIdxStart & padIdxTmp in str between
// strIdxStart & strIdxEnd
int patLength = (patIdxTmp - patIdxStart - 1);
int strLength = (strIdxEnd - strIdxStart + 1);
int foundIdx = -1;
strLoop: for (int i = 0; i <= strLength - patLength; i++) {
for (int j = 0; j < patLength; j++) {
ch = patArr[patIdxStart + j + 1];
if (isCaseSensitive && (ch != strArr[strIdxStart + i + j])) {
continue strLoop;
}
if (!isCaseSensitive
&& (Character.toUpperCase(ch) != Character
.toUpperCase(strArr[strIdxStart + i + j]))) {
continue strLoop;
}
}
foundIdx = strIdxStart + i;
break;
}
if (foundIdx == -1) {
return false;
}
patIdxStart = patIdxTmp;
strIdxStart = foundIdx + patLength;
}
// All characters in the string are used. Check if only '*'s are left
// in the pattern. If so, we succeeded. Otherwise failure.
for (int i = patIdxStart; i <= patIdxEnd; i++) {
if (patArr[i] != '*') {
return false;
}
}
return true;
}
}