Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed 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.catalina.filters;
 
 import static org.jboss.web.CatalinaMessages.MESSAGES;
 
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 

Servlet filter to integrate "X-Forwarded-For" and "X-Forwarded-Proto" HTTP headers.

Most of the design of this Servlet Filter is a port of mod_remoteip, this servlet filter replaces the apparent client remote IP address and hostname for the request with the IP address list presented by a proxy or a load balancer via a request headers (e.g. "X-Forwarded-For").

Another feature of this servlet filter is to replace the apparent scheme (http/https) and server port with the scheme presented by a proxy or a load balancer via a request header (e.g. "X-Forwarded-Proto").

This servlet filter proceeds as follows:

If the incoming request.getRemoteAddr() matches the servlet filter's list of internal proxies :

  • Loop on the comma delimited list of IPs and hostnames passed by the preceding load balancer or proxy in the given request's Http header named $remoteIPHeader (default value x-forwarded-for). Values are processed in right-to-left order.
  • For each ip/host of the list:
    • if it matches the internal proxies list, the ip/host is swallowed
    • if it matches the trusted proxies list, the ip/host is added to the created proxies header
    • otherwise, the ip/host is declared to be the remote ip and looping is stopped.
  • If the request http header named $protocolHeader (e.g. x-forwarded-for) equals to the value of protocolHeaderHttpsValue configuration parameter (default https) then request.isSecure = true, request.scheme = https and request.serverPort = 443. Note that 443 can be overwritten with the $httpsServerPort configuration parameter.

Configuration parameters:

XForwardedFilter propertyDescriptionEquivalent mod_remoteip directiveFormatDefault Value
remoteIPHeaderName of the Http Header read by this servlet filter that holds the list of traversed IP addresses starting from the requesting client RemoteIPHeaderCompliant http header namex-forwarded-for
internalProxiesList of internal proxies ip adress. If they appear in the remoteIpHeader value, they will be trusted and will not appear in the proxiesHeader valueRemoteIPInternalProxyComma delimited list of regular expressions (in the syntax supported by the java.util.regex.Pattern library)10\.\d{1,3}\.\d{1,3}\.\d{1,3}, 192\.168\.\d{1,3}\.\d{1,3}, 169\.254\.\d{1,3}\.\d{1,3}, 127\.\d{1,3}\.\d{1,3}\.\d{1,3}
By default, 10/8, 192.168/16, 169.254/16 and 127/8 are allowed ; 172.16/12 has not been enabled by default because it is complex to describe with regular expressions
proxiesHeaderName of the http header created by this servlet filter to hold the list of proxies that have been processed in the incoming remoteIPHeaderRemoteIPProxiesHeaderCompliant http header namex-forwarded-by
trustedProxiesList of trusted proxies ip adress. If they appear in the remoteIpHeader value, they will be trusted and will appear in the proxiesHeader valueRemoteIPTrustedProxyComma delimited list of regular expressions (in the syntax supported by the java.util.regex.Pattern library) 
protocolHeaderName of the http header read by this servlet filter that holds the flag that this requestN/ACompliant http header name like X-Forwarded-Proto, X-Forwarded-Ssl or Front-End-Httpsnull
protocolHeaderHttpsValueValue of the protocolHeader to indicate that it is an Https requestN/AString like https or ONhttps
httpServerPortValue returned by javax.servlet.ServletRequest.getServerPort() when the protocolHeader indicates http protocolN/Ainteger80
httpsServerPortValue returned by javax.servlet.ServletRequest.getServerPort() when the protocolHeader indicates https protocolN/Ainteger443

Regular expression vs. IP address blocks: mod_remoteip allows to use address blocks (e.g. 192.168/16) to configure RemoteIPInternalProxy and RemoteIPTrustedProxy ; as the JVM doesn't have a library similar to apr_ipsubnet_test, we rely on regular expressions.


Sample with internal proxies

XForwardedFilter configuration:

 <filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
    <init-param>
       <param-name>internalProxies</param-name><param-value>192\.168\.0\.10, 192\.168\.0\.11</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPHeader</param-name><param-value>x-forwarded-for</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPProxiesHeader</param-name><param-value>x-forwarded-by</param-value>
    </init-param>
    <init-param>
       <param-name>protocolHeader</param-name><param-value>x-forwarded-proto</param-value>
    </init-param>
 </filter>
 
 <filter-mapping>
    <filter-name>RemoteIpFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
 </filter-mapping>

Request values:

propertyValue Before RemoteIpFilterValue After RemoteIpFilter
request.remoteAddr192.168.0.10140.211.11.130
request.header['x-forwarded-for']140.211.11.130, 192.168.0.10null
request.header['x-forwarded-by']nullnull
request.header['x-forwarded-proto']httpshttps
request.schemehttphttps
request.securefalsetrue
request.serverPort80443
Note : x-forwarded-by header is null because only internal proxies as been traversed by the request. x-forwarded-by is null because all the proxies are trusted or internal.

Sample with trusted proxies

RemoteIpFilter configuration:

 <filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
    <init-param>
       <param-name>internalProxies</param-name><param-value>192\.168\.0\.10, 192\.168\.0\.11</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPHeader</param-name><param-value>x-forwarded-for</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPProxiesHeader</param-name><param-value>x-forwarded-by</param-value>
    </init-param>
    <init-param>
       <param-name>trustedProxies</param-name><param-value>proxy1, proxy2</param-value>
    </init-param>
 </filter>
 
 <filter-mapping>
    <filter-name>RemoteIpFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
 </filter-mapping>

Request values:

propertyValue Before RemoteIpFilterValue After RemoteIpFilter
request.remoteAddr192.168.0.10140.211.11.130
request.header['x-forwarded-for']140.211.11.130, proxy1, proxy2null
request.header['x-forwarded-by']nullproxy1, proxy2
Note : proxy1 and proxy2 are both trusted proxies that come in x-forwarded-for header, they both are migrated in x-forwarded-by header. x-forwarded-by is null because all the proxies are trusted or internal.

Sample with internal and trusted proxies

RemoteIpFilter configuration:

 <filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
    <init-param>
       <param-name>internalProxies</param-name><param-value>192\.168\.0\.10, 192\.168\.0\.11</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPHeader</param-name><param-value>x-forwarded-for</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPProxiesHeader</param-name><param-value>x-forwarded-by</param-value>
    </init-param>
    <init-param>
       <param-name>trustedProxies</param-name><param-value>proxy1, proxy2</param-value>
    </init-param>
 </filter>
 
 <filter-mapping>
    <filter-name>RemoteIpFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
 </filter-mapping>

Request values:

propertyValue Before RemoteIpFilterValue After RemoteIpFilter
request.remoteAddr192.168.0.10140.211.11.130
request.header['x-forwarded-for']140.211.11.130, proxy1, proxy2, 192.168.0.10null
request.header['x-forwarded-by']nullproxy1, proxy2
Note : proxy1 and proxy2 are both trusted proxies that come in x-forwarded-for header, they both are migrated in x-forwarded-by header. As 192.168.0.10 is an internal proxy, it does not appear in x-forwarded-by. x-forwarded-by is null because all the proxies are trusted or internal.

Sample with an untrusted proxy

RemoteIpFilter configuration:

 <filter>
    <filter-name>RemoteIpFilter</filter-name>
    <filter-class>org.apache.catalina.filters.RemoteIpFilter</filter-class>
    <init-param>
       <param-name>internalProxies</param-name><param-value>192\.168\.0\.10, 192\.168\.0\.11</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPHeader</param-name><param-value>x-forwarded-for</param-value>
    </init-param>
    <init-param>
       <param-name>remoteIPProxiesHeader</param-name><param-value>x-forwarded-by</param-value>
    </init-param>
    <init-param>
       <param-name>trustedProxies</param-name><param-value>proxy1, proxy2</param-value>
    </init-param>
 </filter>
 
 <filter-mapping>
    <filter-name>RemoteIpFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
 </filter-mapping>

Request values:

propertyValue Before RemoteIpFilterValue After RemoteIpFilter
request.remoteAddr192.168.0.10untrusted-proxy
request.header['x-forwarded-for']140.211.11.130, untrusted-proxy, proxy1140.211.11.130
request.header['x-forwarded-by']nullproxy1
Note : x-forwarded-by holds the trusted proxy proxy1. x-forwarded-by holds 140.211.11.130 because untrusted-proxy is not trusted and thus, we can not trust that untrusted-proxy is the actual remote ip. request.remoteAddr is untrusted-proxy that is an IP verified by proxy1.
public class RemoteIpFilter implements Filter {
    public static class XForwardedRequest extends HttpServletRequestWrapper {
        
        final static ThreadLocal<SimpleDateFormat[]> threadLocalDateFormats = new ThreadLocal<SimpleDateFormat[]>() {
            @Override
            protected SimpleDateFormat[] initialValue() {
                return new SimpleDateFormat[] {
                    new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz".),
                    new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss zzz".),
                    new SimpleDateFormat("EEE MMMM d HH:mm:ss yyyy".)
                };
                
            }
        };
        
        protected Map<StringList<String>> headers;
        
        protected String remoteAddr;
        
        protected String remoteHost;
        
        protected String scheme;
        
        protected boolean secure;
        
        protected int serverPort;
        
        public XForwardedRequest(HttpServletRequest request) {
            super(request);
            this. = request.getRemoteAddr();
            this. = request.getRemoteHost();
            this. = request.getScheme();
            this. = request.isSecure();
            this. = request.getServerPort();
            
             = new HashMap<StringList<String>>();
            for (Enumeration<StringheaderNames = request.getHeaderNames(); headerNames.hasMoreElements();) {
                String header = headerNames.nextElement();
                .put(header, Collections.list(request.getHeaders(header)));
            }
        }
        
        @Override
        public long getDateHeader(String name) {
            String value = getHeader(name);
            if (value == null) {
                return -1;
            }
            DateFormat[] dateFormats = .get();
            Date date = null;
            for (int i = 0; ((i < dateFormats.length) && (date == null)); i++) {
                DateFormat dateFormat = dateFormats[i];
                try {
                    date = dateFormat.parse(value);
                } catch (Exception ParseException) {
                    // Ignore
                }
            }
            if (date == null) {
                throw new IllegalArgumentException(value);
            }
            return date.getTime();
        }
        
        @Override
        public String getHeader(String name) {
            Map.Entry<StringList<String>> header = getHeaderEntry(name);
            if (header == null || header.getValue() == null || header.getValue().isEmpty()) {
                return null;
            }
            return header.getValue().get(0);
        }
        
        protected Map.Entry<StringList<String>> getHeaderEntry(String name) {
            for (Map.Entry<StringList<String>> entry : .entrySet()) {
                if (entry.getKey().equalsIgnoreCase(name)) {
                    return entry;
                }
            }
            return null;
        }
        
        @Override
        public Enumeration<StringgetHeaderNames() {
            return Collections.enumeration(.keySet());
        }
        
        @Override
        public Enumeration<StringgetHeaders(String name) {
            Map.Entry<StringList<String>> header = getHeaderEntry(name);
            if (header == null || header.getValue() == null) {
                return Collections.enumeration(Collections.<String>emptyList());
            }
            return Collections.enumeration(header.getValue());
        }
        
        @Override
        public int getIntHeader(String name) {
            String value = getHeader(name);
            if (value == null) {
                return -1;
            }
            return Integer.parseInt(value);
        }
        
        @Override
        public String getRemoteAddr() {
            return this.;
        }
        
        @Override
        public String getRemoteHost() {
            return this.;
        }
        
        @Override
        public String getScheme() {
            return ;
        }
        
        @Override
        public int getServerPort() {
            return ;
        }
        
        @Override
        public boolean isSecure() {
            return ;
        }
        
        public void removeHeader(String name) {
            Map.Entry<StringList<String>> header = getHeaderEntry(name);
            if (header != null) {
                .remove(header.getKey());
            }
        }
        
        public void setHeader(String nameString value) {
            List<Stringvalues = Arrays.asList(value);
            Map.Entry<StringList<String>> header = getHeaderEntry(name);
            if (header == null) {
                .put(namevalues);
            } else {
                header.setValue(values);
            }
            
        }
        
        public void setRemoteAddr(String remoteAddr) {
            this. = remoteAddr;
        }
        
        public void setRemoteHost(String remoteHost) {
            this. = remoteHost;
        }
        
        public void setScheme(String scheme) {
            this. = scheme;
        }
        
        public void setSecure(boolean secure) {
            this. = secure;
        }
        
        public void setServerPort(int serverPort) {
            this. = serverPort;
        }
    }
    
    
java.util.regex.Pattern for a comma delimited string that support whitespace characters
    private static final Pattern commaSeparatedValuesPattern = Pattern.compile("\\s*,\\s*");
    
    protected static final String HTTP_SERVER_PORT_PARAMETER = "httpServerPort";
    protected static final String HTTPS_SERVER_PORT_PARAMETER = "httpsServerPort";
    
    protected static final String INTERNAL_PROXIES_PARAMETER = "internalProxies";
    
    protected static final String PROTOCOL_HEADER_PARAMETER = "protocolHeader";
    
    protected static final String PROTOCOL_HEADER_HTTPS_VALUE_PARAMETER = "protocolHeaderHttpsValue";
    
    protected static final String PROXIES_HEADER_PARAMETER = "proxiesHeader";
    
    protected static final String REMOTE_IP_HEADER_PARAMETER = "remoteIPHeader";
    
    protected static final String TRUSTED_PROXIES_PARAMETER = "trustedProxies";
    
    
Convert a given comma delimited list of regular expressions into an array of compiled java.util.regex.Pattern

Returns:
array of patterns (not null)
    protected static Pattern[] commaDelimitedListToPatternArray(String commaDelimitedPatterns) {
        String[] patterns = commaDelimitedListToStringArray(commaDelimitedPatterns);
        List<PatternpatternsList = new ArrayList<Pattern>();
        for (String pattern : patterns) {
            try {
                patternsList.add(Pattern.compile(pattern));
            } catch (PatternSyntaxException e) {
                throw .remoteIpValvePatternError(patterne);
            }
        }
        return patternsList.toArray(new Pattern[0]);
    }
    
    
Convert a given comma delimited list of regular expressions into an array of String

Returns:
array of patterns (non null)
    protected static String[] commaDelimitedListToStringArray(String commaDelimitedStrings) {
        return (commaDelimitedStrings == null || commaDelimitedStrings.length() == 0) ? new String[0] : 
            .split(commaDelimitedStrings);
    }
    
    
Convert an array of strings in a comma delimited string
    protected static String listToCommaDelimitedString(List<StringstringList) {
        if (stringList == null) {
            return "";
        }
        StringBuilder result = new StringBuilder();
        for (Iterator<Stringit = stringList.iterator(); it.hasNext();) {
            Object element = it.next();
            if (element != null) {
                result.append(element);
                if (it.hasNext()) {
                    result.append(", ");
                }
            }
        }
        return result.toString();
    }
    
    
Return true if the given str matches at least one of the given patterns.
    protected static boolean matchesOne(String strPattern... patterns) {
        for (Pattern pattern : patterns) {
            if (pattern.matcher(str).matches()) {
                return true;
            }
        }
        return false;
    }
    
    
    private int httpServerPort = 80;

    
    private int httpsServerPort = 443;

    
    private Pattern[] internalProxies = new Pattern[] {
        Pattern.compile("10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"), Pattern.compile("192\\.168\\.\\d{1,3}\\.\\d{1,3}"),
        Pattern.compile("169\\.254\\.\\d{1,3}\\.\\d{1,3}"), Pattern.compile("127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}")
    };
    
    
    private String protocolHeader = null;
    
    private String protocolHeaderHttpsValue = "https";
    
    
    private String proxiesHeader = "X-Forwarded-By";
    
    
    private String remoteIPHeader = "X-Forwarded-For";
    
    
    private Pattern[] trustedProxies = new Pattern[0];
    
    public void destroy() {
        // NOOP
    }
    
    public void doFilter(HttpServletRequest requestHttpServletResponse responseFilterChain chainthrows IOExceptionServletException {
        
        if (matchesOne(request.getRemoteAddr(), )) {
            String remoteIp = null;
            // In java 6, proxiesHeaderValue should be declared as a java.util.Deque
            LinkedList<StringproxiesHeaderValue = new LinkedList<String>();
            
            String[] remoteIPHeaderValue = commaDelimitedListToStringArray(request.getHeader());
            int idx;
            // loop on remoteIPHeaderValue to find the first trusted remote ip and to build the proxies chain
            for (idx = remoteIPHeaderValue.length - 1; idx >= 0; idx--) {
                String currentRemoteIp = remoteIPHeaderValue[idx];
                remoteIp = currentRemoteIp;
                if (matchesOne(currentRemoteIp)) {
                    // do nothing, internalProxies IPs are not appended to the
                } else if (matchesOne(currentRemoteIp)) {
                    proxiesHeaderValue.addFirst(currentRemoteIp);
                } else {
                    idx--; // decrement idx because break statement doesn't do it
                    break;
                }
            }
            // continue to loop on remoteIPHeaderValue to build the new value of the remoteIPHeader
            LinkedList<StringnewRemoteIpHeaderValue = new LinkedList<String>();
            for (; idx >= 0; idx--) {
                String currentRemoteIp = remoteIPHeaderValue[idx];
                newRemoteIpHeaderValue.addFirst(currentRemoteIp);
            }
            
            XForwardedRequest xRequest = new XForwardedRequest(request);
            if (remoteIp != null) {
                
                xRequest.setRemoteAddr(remoteIp);
                xRequest.setRemoteHost(remoteIp);
                
                if (proxiesHeaderValue.size() == 0) {
                    xRequest.removeHeader();
                } else {
                    String commaDelimitedListOfProxies = listToCommaDelimitedString(proxiesHeaderValue);
                    xRequest.setHeader(commaDelimitedListOfProxies);
                }
                if (newRemoteIpHeaderValue.size() == 0) {
                    xRequest.removeHeader();
                } else {
                    String commaDelimitedRemoteIpHeaderValue = listToCommaDelimitedString(newRemoteIpHeaderValue);
                    xRequest.setHeader(commaDelimitedRemoteIpHeaderValue);
                }
            }
            
            if ( != null) {
                String protocolHeaderValue = request.getHeader();
                if (protocolHeaderValue == null) {
                    // don't modify the secure,scheme and serverPort attributes of the request
                } else if (.equalsIgnoreCase(protocolHeaderValue)) {
                    xRequest.setSecure(true);
                    xRequest.setScheme("https");
                    xRequest.setServerPort();
                } else {
                    xRequest.setSecure(false);
                    xRequest.setScheme("http");
                    xRequest.setServerPort();
                }
            }
            
           chain.doFilter(xRequestresponse);
        } else {
            chain.doFilter(requestresponse);
        }
        
    }
    
    
Wrap the incoming request in a RemoteIpFilter.XForwardedRequest if the http header x-forwareded-for is not empty.
    public void doFilter(ServletRequest requestServletResponse responseFilterChain chainthrows IOExceptionServletException {
        if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
            doFilter((HttpServletRequest)request, (HttpServletResponse)responsechain);
        } else {
            chain.doFilter(requestresponse);
        }
    }
    
    public int getHttpsServerPort() {
        return ;
    }
    
    public Pattern[] getInternalProxies() {
        return ;
    }
    
    public String getProtocolHeader() {
        return ;
    }
    
        return ;
    }
    
    public String getProxiesHeader() {
        return ;
    }
    
    public String getRemoteIPHeader() {
        return ;
    }
    
    public Pattern[] getTrustedProxies() {
        return ;
    }
    
    public void init(FilterConfig filterConfigthrows ServletException {
        if (filterConfig.getInitParameter() != null) {
            setInternalProxies(filterConfig.getInitParameter());
        }
        
        if (filterConfig.getInitParameter() != null) {
            setProtocolHeader(filterConfig.getInitParameter());
        }
        
        if (filterConfig.getInitParameter() != null) {
        }
        
        if (filterConfig.getInitParameter() != null) {
            setProxiesHeader(filterConfig.getInitParameter());
        }
        
        if (filterConfig.getInitParameter() != null) {
            setRemoteIPHeader(filterConfig.getInitParameter());
        }
        
        if (filterConfig.getInitParameter() != null) {
            setTrustedProxies(filterConfig.getInitParameter());
        }
        
        if (filterConfig.getInitParameter() != null) {
            try {
                setHttpServerPort(Integer.parseInt(filterConfig.getInitParameter()));
            } catch (NumberFormatException e) {
                throw .invalidHttpPortNumber(filterConfig.getInitParameter());
            }
        }
        
        if (filterConfig.getInitParameter() != null) {
            try {
                setHttpsServerPort(Integer.parseInt(filterConfig.getInitParameter()));
            } catch (NumberFormatException e) {
                throw .invalidHttpsPortNumber(filterConfig.getInitParameter());
            }
        }
    }
    
    

Server Port value if the protocolHeader indicates HTTP (i.e. protocolHeader is not null and has a value different of protocolHeaderHttpsValue).

Default value : 80

    public void setHttpServerPort(int httpServerPort) {
        this. = httpServerPort;
    }
    
    

Server Port value if the protocolHeader indicates HTTPS

Default value : 443

    public void setHttpsServerPort(int httpsServerPort) {
        this. = httpsServerPort;
    }
    
    

Comma delimited list of internal proxies. Can be expressed with regular expressions.

Default value : 10\.\d{1,3}\.\d{1,3}\.\d{1,3}, 192\.168\.\d{1,3}\.\d{1,3}, 127\.\d{1,3}\.\d{1,3}\.\d{1,3}

    public void setInternalProxies(String internalProxies) {
        this. = commaDelimitedListToPatternArray(internalProxies);
    }
    
    

Header that holds the incoming protocol, usally named X-Forwarded-Proto. If null, request.scheme and request.secure will not be modified.

Default value : null

    public void setProtocolHeader(String protocolHeader) {
        this. = protocolHeader;
    }
    
    

Case insensitive value of the protocol header to indicate that the incoming http request uses HTTPS.

Default value : https

    public void setProtocolHeaderHttpsValue(String protocolHeaderHttpsValue) {
        this. = protocolHeaderHttpsValue;
    }
    
    

The proxiesHeader directive specifies a header into which mod_remoteip will collect a list of all of the intermediate client IP addresses trusted to resolve the actual remote IP. Note that intermediate RemoteIPTrustedProxy addresses are recorded in this header, while any intermediate RemoteIPInternalProxy addresses are discarded.

Name of the http header that holds the list of trusted proxies that has been traversed by the http request.

The value of this header can be comma delimited.

Default value : X-Forwarded-By

    public void setProxiesHeader(String proxiesHeader) {
        this. = proxiesHeader;
    }
    
    

Name of the http header from which the remote ip is extracted.

The value of this header can be comma delimited.

Default value : X-Forwarded-For

    public void setRemoteIPHeader(String remoteIPHeader) {
        this. = remoteIPHeader;
    }
    
    

Comma delimited list of proxies that are trusted when they appear in the remoteIPHeader header. Can be expressed as a regular expression.

Default value : empty list, no external proxy is trusted.

    public void setTrustedProxies(String trustedProxies) {
        this. = commaDelimitedListToPatternArray(trustedProxies);
    }
New to GrepCode? Check out our FAQ X