proxiedrequestdispatcher.java

这是linux下ssl vpn的实现程序

/*
 *  SSL-Explorer
 *
 *  Copyright (C) 2003-2006 3SP LTD. All Rights Reserved
 *
 *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
			
package com.sslexplorer.replacementproxy;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import javax.servlet.http.HttpSession;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.transaction.util.FileHelper;

import com.maverick.http.HttpAuthenticatorFactory;
import com.maverick.http.HttpClient;
import com.maverick.http.HttpConnection;
import com.maverick.http.HttpResponse;
import com.maverick.http.PasswordCredentials;
import com.sslexplorer.boot.CaseInsensitiveMap;
import com.sslexplorer.boot.HttpConstants;
import com.sslexplorer.boot.Util;
import com.sslexplorer.core.CookieItem;
import com.sslexplorer.core.CookieMap;
import com.sslexplorer.core.CoreServlet;
import com.sslexplorer.core.CoreUtil;
import com.sslexplorer.reverseproxy.ReverseProxyProxiedMethod;
import com.sslexplorer.reverseproxy.SessionClients;
import com.sslexplorer.security.Constants;
import com.sslexplorer.security.User;

/**
 * @author Brett Smith <[e-mail]>
 */
public class ProxiedRequestDispatcher {
    final static Log log = LogFactory.getLog(ProxiedRequestDispatcher.class);
    static CaseInsensitiveMap ignoreHeaders = new CaseInsensitiveMap();


    final static String sessionIdCookieName = System.getProperty("sslexplorer.cookie", "JSESSIONID");

    static {

        ignoreHeaders.put(HttpConstants.HDR_PROXY_CONNECTION, Boolean.TRUE);
        ignoreHeaders.put(HttpConstants.HDR_ACCEPT_ENCODING, Boolean.TRUE);
        ignoreHeaders.put(HttpConstants.HDR_TRANSFER_ENCODING, Boolean.TRUE);
        ignoreHeaders.put(HttpConstants.HDR_TE, Boolean.TRUE);
        ignoreHeaders.put(HttpConstants.HDR_TRAILER, Boolean.TRUE);
        ignoreHeaders.put(HttpConstants.HDR_PROXY_AUTHORIZATION, Boolean.TRUE);
        ignoreHeaders.put(HttpConstants.HDR_PROXY_AUTHENTICATE, Boolean.TRUE);
        ignoreHeaders.put(HttpConstants.HDR_UPGRADE, Boolean.TRUE);

    }

    private RequestProcessor requestProcessor;
    private User user;
    //private boolean keepAlive;
    private HttpResponse serverResponse;
    //private InputStream serverIn;
    private int responseCode;
    private String responseMessage;
    private CookieMap cookieMap;
   // private URLConnection connection;
    private URL connectionURL;

    public ProxiedRequestDispatcher(RequestProcessor requestProcessor, User user, CookieMap cookieMap) {
        this.user = user;
        this.requestProcessor = requestProcessor;
        //keepAlive = requestProcessor.isKeepAlive();
        this.cookieMap = cookieMap;
    }

   // public boolean isKeepAlive() {
   //     return keepAlive;
  //  }
    public RequestProcessor getRequestProcessor() {
        return requestProcessor;
    }

    public boolean sendProxiedRequest() throws Exception {

        byte[] content = requestProcessor.getContent();
        OutputStream serverOut = null;
        HttpClient client;
        SessionClients clients = null;
        HttpSession session = requestProcessor.getSession();
        connectionURL = new URL(requestProcessor.getConnectionPath());

        // Manage the sessions clients
        synchronized(session) {
            clients =
                (SessionClients)session.getAttribute(Constants.HTTP_CLIENTS);
            if(clients == null) {
                clients = new SessionClients();
                session.setAttribute(Constants.HTTP_CLIENTS, clients);
            }
            cookieMap = (CookieMap) session.getAttribute(Constants.ATTR_COOKIE_MAP);
            if (cookieMap == null) {
                cookieMap = new CookieMap();
                session.setAttribute(Constants.ATTR_COOKIE_MAP, cookieMap);
            }
        }

        synchronized(clients) {
            String key = connectionURL.getHost()
                         + ":"
                         + (connectionURL.getPort() > 0 ? connectionURL.getPort() : connectionURL.getProtocol().equals("https") ? 443 : 80)
                         + ":"
                         + connectionURL.getProtocol().equals("https")
                         + ":"
                         + requestProcessor.getWebForward().getResourceId()
                         + Thread.currentThread().getName();
            client = (HttpClient) clients.get(key);

            if (client == null) {
                client = new HttpClient(connectionURL.getHost(),
                                        (connectionURL.getPort() > 0 ? connectionURL.getPort() : connectionURL.getProtocol().equals("https") ? 443 : 80),
                                        connectionURL.getProtocol().equals("https"));

                if(!requestProcessor.getWebForward().getPreferredAuthenticationScheme().equals(HttpAuthenticatorFactory.NONE)
                                && !requestProcessor.getWebForward().getAuthenticationUsername().equals("")
                                && !requestProcessor.getWebForward().getAuthenticationPassword().equals("")) {
                    PasswordCredentials pwd = new PasswordCredentials();
                    pwd.setUsername(CoreUtil.doStandardReplacements(requestProcessor.getSessionInfo(), requestProcessor.getWebForward().getAuthenticationUsername()));
                    pwd.setPassword(CoreUtil.doStandardReplacements(requestProcessor.getSessionInfo(), requestProcessor.getWebForward().getAuthenticationPassword()));
                    client.setCredentials(pwd);
                }

                // Set the preferred scheme
                client.setPreferredAuthentication(requestProcessor.getWebForward().getPreferredAuthenticationScheme());

                // If we're using basic authentication then preempt the 401 response
                client.setPreemtiveAuthentication(requestProcessor.getWebForward().getPreferredAuthenticationScheme().equalsIgnoreCase("BASIC"));
                clients.put(key, client);
            }
        }

        if (log.isDebugEnabled())
        	log.debug("Connecting to [" + requestProcessor.getConnectionPath() + "] ");

        ReverseProxyProxiedMethod method;
        
        if (!requestProcessor.getWebForward().getFormType().equals("NONE") 
                        && requestProcessor.getRequestParameters().containsKey("launched")) {

            requestProcessor.getRequestParameters().remove("launched");

            method = new ReverseProxyProxiedMethod(requestProcessor.getWebForward().getFormType(), 
                CoreUtil.doStandardReplacements(requestProcessor.getSessionInfo(), requestProcessor.getEncodedUri()),
                requestProcessor.getRequestParameters(),
                requestProcessor.getSessionInfo());

            StringTokenizer tokens = new StringTokenizer(requestProcessor.getWebForward().getFormParameters(), "\n");
            int idx;
            String param;
            while (tokens.hasMoreTokens()) {
                param = CoreUtil.doStandardReplacements(requestProcessor.getSessionInfo(), tokens.nextToken().trim());
                idx = param.indexOf('=');
                if (idx > -1) {
                    method.setParameter(param.substring(0, idx), param.substring(idx + 1));
                } else
                    method.setParameter(param, "");
            }
        } else {
            method = new ReverseProxyProxiedMethod(requestProcessor.getMethod(),
                CoreUtil.doStandardReplacements(requestProcessor.getSessionInfo(), requestProcessor.getEncodedUri()),
                requestProcessor.getRequestParameters(),
                requestProcessor.getSessionInfo());        }        
        




       int contentLength = 0;

       for (Enumeration e = requestProcessor.getHeaderNames(); e.hasMoreElements(); ) {

           String hdr = (String) e.nextElement();

           if (ignoreHeaders.containsKey(hdr)) {
        	   if (log.isDebugEnabled())
        		   log.debug("Ignoring " + hdr + " = " + requestProcessor.getHeader(hdr));
               continue;
           }

           // See if there any replacements for this header
           List replacements = CoreServlet.getServlet().getSystemDatabase().getReplacementsForContent(
                           user.getPrincipalName(), Replacement.REPLACEMENT_TYPE_SENT_HEADER, hdr,
                           connectionURL.toExternalForm());

           Enumeration vals = requestProcessor.getHeaders(hdr);
           while (vals.hasMoreElements()) {
               String val = (String) vals.nextElement();

               // Do the replacements
               for (Iterator i = replacements.iterator(); i.hasNext();) {
                   Replacement r = (Replacement) i.next();
                   val = val.replaceAll(r.getMatchPattern(), r.getReplacePattern());
               }

               if (val != null) {
                   if (hdr.equalsIgnoreCase(HttpConstants.HDR_HOST)) {
                       if (connectionURL.getPort() == -1) {