reverseproxymethodhandler.java

这是linux下ssl vpn的实现程序

                request.getParameters().remove("launched");
                /**
                 * This code will automatically submit form parameters.
                 */
                method = new ReverseProxyProxiedMethod(webForward.getFormType(), request.getURIEncoded(), request.getParameters(),
                                session);

                if(((ReverseProxyWebForward)wf).getCharset()!=null && !((ReverseProxyWebForward)wf).getCharset().equals(""))
                    method.setCharsetEncoding(((ReverseProxyWebForward)wf).getCharset());
                
                StringTokenizer tokens = new StringTokenizer(webForward.getFormParameters(), "\n");
                int idx;
                String param;
                while (tokens.hasMoreTokens()) {
                    param = CoreUtil.doStandardReplacements(session, 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(request.getMethod(), request.getURIEncoded(), request.getParameters(),
                                session);
                if(((ReverseProxyWebForward)wf).getCharset()!=null && !((ReverseProxyWebForward)wf).getCharset().equals(""))
                    method.setCharsetEncoding(((ReverseProxyWebForward)wf).getCharset());
            }

            int contentLength = 0;
            String contentType = null;
            
            for (Enumeration e = request.getFieldNames(); e.hasMoreElements();) {
                header = (String) e.nextElement();

                // Skip the connection header as our client maintains its own
                // connections
                if (header.equalsIgnoreCase("Connection")) {
                    continue;
                }

                for (Enumeration j = request.getFieldValues(header); j.hasMoreElements();) {
                    String val = (String) j.nextElement();
                    method.getProxiedRequest().setHeaderField(header, val);
                    if (log.isInfoEnabled())
                    	log.info("HEADER: " + header + " " + val);
                    if (header.equalsIgnoreCase("content-length")) {
                        contentLength = Integer.parseInt(val);
                    } else if(header.equalsIgnoreCase("content-type")) {
                        contentType = val;
                    }
                    
                }
            }

            String thisHost = ContextHolder.getContext().getHostname();
            int thisPort = ContextHolder.getContext().getPort();

            // Check for a non default port (we dont care if we receive on 443
            // but
            // forward to 80 as this would not change the host header
            if (thisPort != 443 && thisPort != 80) {
                thisHost += ":" + thisPort;
            }

            method.getProxiedRequest().setHeaderField("X-Forwarded-Host", thisHost);
            method.getProxiedRequest().setHeaderField("X-Forwarded-For", request.getRemoteHost());
            method.getProxiedRequest().setHeaderField("X-Forwarded-Server", thisHost);
            method.getProxiedRequest().setHeaderField("X-Forwarded-Port", String.valueOf(thisPort));

            boolean hasProcessedContent = contentType!=null && request.getMethod().equals("POST") && contentType.equals("application/x-www-form-urlencoded");
            
            if (contentLength > 0 && !hasProcessedContent) {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                byte[] buf = new byte[4096];
                int read;
                while (contentLength > 0) {
                    read = request.getInputStream().read(buf, 0, contentLength < buf.length ? contentLength : buf.length);
                    if (read == -1) {
                        log.warn("HTTP content read returned unexpected EOF (" + contentLength + " more bytes expected.");
                        break;
                    }
                    out.write(buf, 0, read);
                    contentLength -= read;
                }

                method.setContent(out.toByteArray());
            }

            /**
             * Add any custom headers to the request
             */
            Map customHeaders = webForward.getCustomHeaders();

            for (Iterator it = customHeaders.entrySet().iterator(); it.hasNext();) {
                Map.Entry entry = (Map.Entry) it.next();
                header = (String) entry.getKey();
                Vector v = (Vector) entry.getValue();
                for (Iterator it2 = v.iterator(); it2.hasNext();) {
                    method.getProxiedRequest().setHeaderField(header, (String) it2.next());
                }
            }

            if (log.isDebugEnabled()) {
                log.debug("Connecting to " + hostname + ":" + connectPort + " (Secure = " + isSecure + ")");
            }

            clientResponse = client.execute(method);

            /**
             * Perform a check to see if we're connected to an IIS server and if
             * the backend server is insecure. If it is set the customer
             * Front-End-Https: on header.
             */
            String server = clientResponse.getHeaderField("Server");

            if (server != null && server.startsWith("Microsoft-IIS")) {
                if (!webForward.containsCustomHeader("Front-End-Https"))
                    webForward.setCustomHeader("Front-End-Https", "on");
            }

            /**
             * Filter out unsupported authentication methods because they dont
             * work through the reverse proxy - the best way to enable these
             * will be to allow credentials to be set on the reverse proxy web
             * forward.
             */
            String[] challenges = clientResponse.getHeaderFields("www-authenticate");

            if (challenges != null) {
                clientResponse.removeFields("www-authenticate");

                for (int i = 0; i < challenges.length; i++) {
                    if (challenges[i].toLowerCase().startsWith("basic") || challenges[i].toLowerCase().startsWith("digest")
                                    || challenges[i].toLowerCase().startsWith("ntlm")) {
                        clientResponse.setHeaderField("www-authenticate", challenges[i]);
                    }
                }
            }

            if (log.isInfoEnabled())
            	log.info("HTTP response is " + clientResponse.getStartLine());

            response.setStatus(clientResponse.getStatus());
            response.setReason(clientResponse.getReason());

            clientResponse.removeFields("Server");
            clientResponse.removeFields("Date");

            /**
             * Process redirect Location headers, the location may be a HTTP
             * resource which will require changing to HTTPS
             */
            if (clientResponse.getStatus() >= 300 && clientResponse.getStatus() < 400) {
                switch (clientResponse.getStatus()) {
                    case 300: // Multiple choices
                    case 301: // Moved permanentley
                    case 302: // Found
                    case 303: // See other
                    case 307: // Temporarily redirect
                        String[] locations = clientResponse.getHeaderFields("Location");
                        clientResponse.removeFields("Location");

                        for (int i = 0; i < locations.length; i++) {
                            // Check against the requests Host value and change
                            // the
                            // Location if required
                            if (locations[i].startsWith("http://" + request.getHost())) {
                                response.addField("Location", "https://" + locations[i].substring(7));
                            } else {
                                if (log.isInfoEnabled()) {
                                    log.info("Redirect location may result in reverse proxy error " + locations[i]);
                                }
                                response.addField("Location", locations[i]);
                            }
                        }
                        break;
                    case 304: // Not Modified
                        // Do nothing return as is
                        break;
                    case 305: // Use proxy
                        log.warn("Detected HTTP response 305 [Use proxy] this may break reverse proxy!");
                        break;
                    default:
                        log.error("Got unknown 3XX response code from server " + clientResponse.getStatus());
                }

            }

            for (Enumeration e = clientResponse.getHeaderFieldNames(); e.hasMoreElements();) {
                header = (String) e.nextElement();
                if (log.isDebugEnabled()) {
                    log.debug("Received header " + header);
                }
                String[] val = clientResponse.getHeaderFields(header);

                if (header.equalsIgnoreCase("Location")) {
                	if (log.isInfoEnabled())
                		log.info("Found possible redirect");
                }

                for (int i = 0; i < val.length; i++) {
                    if (log.isDebugEnabled()) {
                        log.debug("Adding value " + val[i] + " for " + header);
                    }
                    response.addField(header, val[i]);
                }
            }

            int read;
            byte[] buf = new byte[16384];
            while ((read = clientResponse.getInputStream().read(buf)) > -1) {
                response.getOutputStream().write(buf, 0, read);
            }

            return true;
        } catch (UnsupportedAuthenticationException ex) {
            log.error("?", ex);
        } catch (com.maverick.http.HttpException ex) {
            log.error("?", ex);
        } catch (EOFException e) {
            /*
             * This is probably just because the user clicked on a link before
             * the page had finished downloading.
             */
        	if (log.isDebugEnabled())
        		log.debug("Received EOF in reverse proxy request [THIS IS PROBABLY NOT FATAL]", e);
        } catch (IOException ex) {
            log.error("?", ex);
        } catch (AuthenticationCancelledException ex) {
            log.error("?", ex);
        }
        return false;

    }

}