mirror of
https://github.com/yacy/yacy_search_server.git
synced 2024-09-21 00:00:13 +02:00
be28af50f5
git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@5058 6c8d7289-2bf4-0310-a012-ef5d649a1542
318 lines
10 KiB
Java
318 lines
10 KiB
Java
//httpRemoteProxyConfig.java
|
|
//-----------------------
|
|
//part of the AnomicHTTPD caching proxy
|
|
//(C) by Michael Peter Christen; mc@yacy.net
|
|
//first published on http://www.anomic.de
|
|
//Frankfurt, Germany, 2004
|
|
//
|
|
//this file was contributed by Martin Thelian
|
|
//$LastChangedDate$
|
|
//$LastChangedBy$
|
|
//$LastChangedRevision$
|
|
//
|
|
//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.
|
|
//
|
|
//You should have received a copy of the GNU General Public License
|
|
//along with this program; if not, write to the Free Software
|
|
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
//You must compile this file with
|
|
//javac -classpath .:../Classes Settings_p.java
|
|
//if the shell's current path is HTROOT
|
|
|
|
package de.anomic.http;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
|
|
import de.anomic.plasma.plasmaSwitchboard;
|
|
|
|
public final class httpRemoteProxyConfig {
|
|
|
|
/*
|
|
* Remote Proxy configuration
|
|
*/
|
|
private boolean remoteProxyUse;
|
|
private boolean remoteProxyUse4Yacy;
|
|
private boolean remoteProxyUse4SSL;
|
|
|
|
private String remoteProxyHost;
|
|
private int remoteProxyPort;
|
|
private String remoteProxyUser;
|
|
private String remoteProxyPwd;
|
|
|
|
private String[] remoteProxyNoProxyPatterns = null;
|
|
|
|
private final Set<String> remoteProxyAllowProxySet = new HashSet<String>();
|
|
private final Set<String> remoteProxyDisallowProxySet = new HashSet<String>();
|
|
|
|
/**
|
|
* *The* remote Proxy configuration
|
|
*/
|
|
private static httpRemoteProxyConfig remoteProxyConfig = null;
|
|
|
|
/**
|
|
* @param remoteProxyConfig the remoteProxyConfig to set
|
|
*/
|
|
public static synchronized void setRemoteProxyConfig(final httpRemoteProxyConfig remoteProxyConfig) {
|
|
httpRemoteProxyConfig.remoteProxyConfig = remoteProxyConfig;
|
|
}
|
|
|
|
/**
|
|
* @return the remoteProxyConfig
|
|
*/
|
|
public static synchronized httpRemoteProxyConfig getRemoteProxyConfig() {
|
|
return remoteProxyConfig;
|
|
}
|
|
|
|
/**
|
|
* creates a new remoteProxyConfig for given proxy
|
|
*
|
|
* @param proxyHostName
|
|
* @param proxyHostPort
|
|
* @return
|
|
*/
|
|
public static httpRemoteProxyConfig createRemoteProxyConfig(
|
|
final String proxyHostName,
|
|
final int proxyHostPort
|
|
) {
|
|
final httpRemoteProxyConfig newConfig = new httpRemoteProxyConfig();
|
|
|
|
newConfig.remoteProxyUse = true;
|
|
newConfig.remoteProxyUse4SSL = true;
|
|
newConfig.remoteProxyUse4Yacy = true;
|
|
newConfig.remoteProxyPort = proxyHostPort;
|
|
newConfig.remoteProxyHost = proxyHostName;
|
|
if ((newConfig.remoteProxyHost == null) || (newConfig.remoteProxyHost.length() == 0)) {
|
|
newConfig.remoteProxyUse = false;
|
|
}
|
|
|
|
return newConfig;
|
|
}
|
|
|
|
/**
|
|
* initializes the global remoteProxyConfig with values from plasmaSwitchboard (config)
|
|
*
|
|
* @param sb
|
|
* @return
|
|
*/
|
|
public static void init(final plasmaSwitchboard sb) {
|
|
// reading the proxy host name
|
|
final String proxyHostName = sb.getConfig("remoteProxyHost", "").trim();
|
|
// reading the proxy host port
|
|
int proxyHostPort;
|
|
try {
|
|
proxyHostPort = Integer.parseInt(sb.getConfig("remoteProxyPort", "3128"));
|
|
} catch (final NumberFormatException e) {
|
|
proxyHostPort = 3128;
|
|
}
|
|
// create new config
|
|
final httpRemoteProxyConfig newConfig = createRemoteProxyConfig(proxyHostName, proxyHostPort);
|
|
|
|
// determining if remote proxy usage is enabled
|
|
newConfig.remoteProxyUse = newConfig.remoteProxyUse && sb.getConfigBool("remoteProxyUse", false);
|
|
|
|
// determining if remote proxy should be used for yacy -> yacy communication
|
|
newConfig.remoteProxyUse4Yacy = sb.getConfig("remoteProxyUse4Yacy", "true").equalsIgnoreCase("true");
|
|
|
|
// determining if remote proxy should be used for ssl connections
|
|
newConfig.remoteProxyUse4SSL = sb.getConfig("remoteProxyUse4SSL", "true").equalsIgnoreCase("true");
|
|
|
|
newConfig.remoteProxyUser = sb.getConfig("remoteProxyUser", "").trim();
|
|
newConfig.remoteProxyPwd = sb.getConfig("remoteProxyPwd", "").trim();
|
|
|
|
// determining addresses for which the remote proxy should not be used
|
|
final String remoteProxyNoProxy = sb.getConfig("remoteProxyNoProxy","").trim();
|
|
newConfig.remoteProxyNoProxyPatterns = remoteProxyNoProxy.split(",");
|
|
// trim split entries
|
|
int i = 0;
|
|
for(final String pattern: newConfig.remoteProxyNoProxyPatterns) {
|
|
newConfig.remoteProxyNoProxyPatterns[i] = pattern.trim();
|
|
i++;
|
|
}
|
|
|
|
setRemoteProxyConfig(newConfig);
|
|
sb.getLog().logConfig("Remote proxy configuration:\n" + getRemoteProxyConfig().toString());
|
|
}
|
|
|
|
public boolean useProxy() {
|
|
return this.remoteProxyUse;
|
|
}
|
|
|
|
public boolean useProxy4Yacy() {
|
|
return this.remoteProxyUse4Yacy;
|
|
}
|
|
|
|
public boolean useProxy4SSL() {
|
|
return this.remoteProxyUse4SSL;
|
|
}
|
|
|
|
public String getProxyHost() {
|
|
return this.remoteProxyHost;
|
|
}
|
|
|
|
public int getProxyPort() {
|
|
return this.remoteProxyPort;
|
|
}
|
|
|
|
public String getProxyUser() {
|
|
return this.remoteProxyUser;
|
|
}
|
|
|
|
public String getProxyPwd() {
|
|
return this.remoteProxyPwd;
|
|
}
|
|
|
|
/**
|
|
* checks if server matches the noProxyPattern and caches result as (Dis-)AllowedHost
|
|
*
|
|
* @param server
|
|
* @return
|
|
*/
|
|
public boolean matchesProxyNoProxyPatterns(final String server) {
|
|
boolean noProxy = false;
|
|
for (final String pattern :remoteProxyNoProxyPatterns) {
|
|
if (server.matches(pattern)) {
|
|
noProxy = true;
|
|
break;
|
|
}
|
|
}
|
|
// set either remoteProxyAllowProxySet or remoteProxyDisallowProxySet accordingly
|
|
if(noProxy) {
|
|
addDisallowedHost(server);
|
|
} else {
|
|
addAllowedHost(server);
|
|
}
|
|
return noProxy;
|
|
}
|
|
|
|
public String toString() {
|
|
final StringBuilder toStrBuf = new StringBuilder(50);
|
|
|
|
toStrBuf
|
|
.append("Status: ").append(this.remoteProxyUse?"ON":"OFF").append(" | ")
|
|
.append("Host: ");
|
|
if ((this.remoteProxyUser != null) && (this.remoteProxyUser.length() > 0)) {
|
|
toStrBuf.append(this.remoteProxyUser)
|
|
.append("@");
|
|
}
|
|
toStrBuf
|
|
.append((this.remoteProxyHost==null)?"unknown":this.remoteProxyHost).append(":").append(this.remoteProxyPort).append(" | ")
|
|
.append("Usage: HTTP");
|
|
if (this.remoteProxyUse4Yacy) toStrBuf.append(" YACY");
|
|
if (this.remoteProxyUse4SSL) toStrBuf.append(" SSL");
|
|
toStrBuf.append(" | ")
|
|
.append("No Proxy for: ")
|
|
.append(Arrays.toString(this.remoteProxyNoProxyPatterns));
|
|
|
|
|
|
return toStrBuf.toString();
|
|
}
|
|
|
|
/**
|
|
* @param host
|
|
* @return
|
|
*/
|
|
public boolean isHostAllowedToUseProxy(final String host) {
|
|
return remoteProxyAllowProxySet.contains(host);
|
|
}
|
|
|
|
/**
|
|
* @param host
|
|
* @return
|
|
*/
|
|
public boolean isHostNotAllowedToUseProxy(final String host) {
|
|
return remoteProxyDisallowProxySet.contains(host);
|
|
}
|
|
|
|
/**
|
|
* @param host
|
|
*/
|
|
public void addAllowedHost(final String host) {
|
|
remoteProxyAllowProxySet.add(host);
|
|
}
|
|
|
|
/**
|
|
* @param host
|
|
*/
|
|
public void addDisallowedHost(final String host) {
|
|
remoteProxyDisallowProxySet.add(host);
|
|
}
|
|
|
|
/**
|
|
* checks if proxy-config is allowed and not denied
|
|
*
|
|
* @param server
|
|
* @param remProxyConfig
|
|
* @return proxy which should be used or null if no proxy should be used for server
|
|
*/
|
|
public boolean useForHost(final String server) {
|
|
// possible remote proxy
|
|
// check no-proxy rule
|
|
boolean useProxy;
|
|
if (useProxy()) {
|
|
useProxy = true;
|
|
if (!isHostAllowedToUseProxy(server)) {
|
|
if (isHostNotAllowedToUseProxy(server)) {
|
|
useProxy = false;
|
|
} else {
|
|
// analyse remoteProxyNoProxy;
|
|
if(matchesProxyNoProxyPatterns(server)) {
|
|
useProxy = false;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// not enabled
|
|
useProxy = false;
|
|
}
|
|
|
|
return useProxy;
|
|
}
|
|
|
|
/**
|
|
* checks if proxy-config exists for server (is allowed and not denied)
|
|
*
|
|
* @param server
|
|
* @return proxy which should be used or null if no proxy should be used
|
|
*/
|
|
public static httpRemoteProxyConfig getProxyConfigForHost(final String server) {
|
|
final httpRemoteProxyConfig proxyConfig = getRemoteProxyConfig();
|
|
if(proxyConfig == null || !proxyConfig.useForHost(server)) {
|
|
return null;
|
|
}
|
|
return proxyConfig;
|
|
}
|
|
|
|
/**
|
|
* gets proxy config for full adress (without protocol) ie. "localhost:8080/path/file.html"
|
|
*
|
|
* @param address full address with host and optionally port or path <host>:<port>/<path>
|
|
* @return null if no proxy should be used
|
|
*/
|
|
public static httpRemoteProxyConfig getProxyConfigForURI(final String address) {
|
|
// host goes to port
|
|
int p = address.indexOf(":");
|
|
if (p < 0) {
|
|
// no port, so host goes to path
|
|
p = address.indexOf("/");
|
|
}
|
|
// host should have minimum 1 character ;)
|
|
if(p > 0) {
|
|
final String server = address.substring(0, p);
|
|
return getProxyConfigForHost(server);
|
|
}
|
|
// check if full address is in allow/deny-list
|
|
return getProxyConfigForHost(address);
|
|
}
|
|
}
|