ElephantFilter.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.elephant.servlet.context;
 
import java.io.IOException;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.turro.config.Configurator;
import org.turro.string.Strings;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.direct.DirectContents;
import org.turro.elephant.servlet.crawler.CrawlerOptions;
import org.turro.file.Document;
import org.turro.http.HttpUtil;
import org.turro.http.activity.IActivityOptions;
import org.turro.http.activity.IPActivity;
import org.turro.util.Cached;
 
@WebFilter(filterName = "ContextFilter", urlPatterns = {"/*"})
public class ElephantFilter implements Filter {
 
  private FilterConfig filterConfig;
  private IPActivity ipActivity;
  
  @Override
  public void doFilter(ServletRequest request, ServletResponse response,
          FilterChain chain)
          throws IOException, ServletException {
    if(request instanceof HttpServletRequest httpRequest) {
      // Performance blocks
      if(ipActivity.isBlocked(request.getRemoteAddr(), httpRequest.getServletPath(), httpRequest.getHeader("User-Agent"))) {
        if(response instanceof HttpServletResponse httpResponse) {
          Document crawlers = Document.from(ElephantContext.getRealPath(CrawlerOptions.CRAWLERS_RESPONSE));
          httpResponse.setContentType("text/html");
          httpResponse.setCharacterEncoding(ElephantContext.getEncoding());
          httpResponse.setStatus(HttpServletResponse.SC_FORBIDDEN);
          httpResponse.getWriter().write(crawlers.content());
        }
        return; // blocked
      // Performance internal calls
      } else if(!pass(httpRequest.getServletPath())) {
        if(resource(httpRequest.getServletPath())) {
          RequestDispatcher rd = getServletContext().getNamedDispatcher("default");
          if(rd!= null) rd.forward(request, response);
          return; // resource
        }
        if(!checkSchemas(httpRequest, (HttpServletResponse) response)) {    
          return; // redirected
        }
        ElephantContext.initServerSchemas(httpRequest);
        if(!DirectContents.isDirectContent(httpRequest) && checkMobile(httpRequest)) {
          forwardMobile(httpRequest, response);
          return; // mobile context
        }
        ipActivity.check(request.getRemoteAddr(), httpRequest.getServletPath(), httpRequest.getHeader("User-Agent"));
      }
    }    
 
    chain.doFilter(request, response);
  }
 
  @Override
  public void init(FilterConfig filterConfig) throws ServletException { 
    this.filterConfig = filterConfig;
    this.ipActivity = IPActivity.instance(Cached.<IActivityOptions>instance(() -> CrawlerOptions.instance()));
  }
 
  @Override
  public void destroy() {
  }
 
  private ServletContext getServletContext() {
    return filterConfig.getServletContext();
  }
  
  private static final Set<String> PASS = Set.of("/zkau", "/tag_", "/ws_", "/up_");
  
  private boolean pass(String reqUri) {
    return PASS.stream().anyMatch(pass -> reqUri.equals(pass) || reqUri.startsWith(pass + "/"));
  }
  
  private boolean resource(String reqUri) {
    String req = HttpUtil.removeSession(reqUri);
    return !req.endsWith(".jsp") && req.matches(".*\\.[a-zA-Z0-9]{2,5}");
            /* && Document.from(getServletContext().getRealPath(reqUri)).exists()*/
  }
 
  private boolean checkSchemas(HttpServletRequest request, HttpServletResponse response) {
    String forcedDomain = ElephantContext.getSiteForcedDomain(),
           serverName = request.getServerName(),
           scheme = request.getScheme();      
    boolean changesDone = false;
    String url = request.getRequestURL().toString();
    if(forcedDomain != null && !forcedDomain.equals(serverName)) {
      url = url.replaceFirst(serverName, forcedDomain);
      changesDone = true;
    }
    if(ElephantContext.getUseSSL() && !"https".equals(scheme)) {
      url = url.replaceFirst("http\\:", "https:");
      changesDone = true;
    }
    if(changesDone) {
      String query = request.getQueryString();
      response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
      response.setHeader("Location", url + (Strings.isBlank(query) ? "" : "?" + query));
      response.setHeader( "Connection", "close" );
    }
    return !changesDone;
  }
 
  private boolean checkMobile(HttpServletRequest request) {
    String mobilePath = Configurator.instance().asString("Context.Mobile.Path");
    return !Strings.isBlank(mobilePath) && 
            request.getHeader("User-Agent").contains("Mobi") && // Set to ! to test
            !request.getServletPath().startsWith(mobilePath);
  }
 
  private void forwardMobile(HttpServletRequest request, ServletResponse response) throws ServletException, IOException {
    String mobilePath = Configurator.instance().asString("Context.Mobile.Path");
    ((HttpServletResponse) response).sendRedirect(request.getContextPath() + 
            mobilePath + HttpUtil.getServletQuery(request));
  }
 
}