Example usage for org.apache.commons.httpclient URIException getMessage

List of usage examples for org.apache.commons.httpclient URIException getMessage

Introduction

In this page you can find the example usage for org.apache.commons.httpclient URIException getMessage.

Prototype

public String getMessage() 

Source Link

Document

Returns the detail message string of this throwable.

Usage

From source file:com.cyberway.issue.crawler.extractor.JerichoExtractorHTML.java

protected void processGeneralTag(CrawlURI curi, Element element, Attributes attributes) {
    Attribute attr;/* w  w  w  .ja  va 2 s .c o m*/
    String attrValue;
    List attrList;
    String elementName = element.getName();

    // Just in case it's an OBJECT or APPLET tag
    String codebase = null;
    ArrayList<String> resources = null;

    final boolean framesAsEmbeds = ((Boolean) getUncheckedAttribute(curi, ATTR_TREAT_FRAMES_AS_EMBED_LINKS))
            .booleanValue();

    final boolean ignoreFormActions = ((Boolean) getUncheckedAttribute(curi, ATTR_IGNORE_FORM_ACTION_URLS))
            .booleanValue();

    final boolean overlyEagerLinkDetection = ((Boolean) getUncheckedAttribute(curi, EXTRACT_VALUE_ATTRIBUTES))
            .booleanValue();

    // HREF
    if (((attr = attributes.get("href")) != null) && ((attrValue = attr.getValue()) != null)) {
        CharSequence context = Link.elementContext(elementName, attr.getKey());
        if ("link".equals(elementName)) {
            // <LINK> elements treated as embeds (css, ico, etc)
            processEmbed(curi, attrValue, context);
        } else {
            // other HREFs treated as links
            processLink(curi, attrValue, context);
        }
        if ("base".equals(elementName)) {
            try {
                curi.setBaseURI(attrValue);
            } catch (URIException e) {
                if (getController() != null) {
                    // Controller can be null: e.g. when running
                    // ExtractorTool.
                    getController().logUriError(e, curi.getUURI(), attrValue);
                } else {
                    logger.info("Failed set base uri: " + curi + ", " + attrValue + ": " + e.getMessage());
                }
            }
        }
    }
    // ACTION
    if (((attr = attributes.get("action")) != null) && ((attrValue = attr.getValue()) != null)) {
        if (!ignoreFormActions) {
            CharSequence context = Link.elementContext(elementName, attr.getKey());
            processLink(curi, attrValue, context);
        }
    }
    // ON_
    if ((attrList = findOnAttributes(attributes)).size() != 0) {
        for (Iterator attrIter = attrList.iterator(); attrIter.hasNext();) {
            attr = (Attribute) attrIter.next();
            CharSequence valueSegment = attr.getValueSegment();
            if (valueSegment != null)
                processScriptCode(curi, valueSegment);

        }
    }
    // SRC atc.
    if ((((attr = attributes.get("src")) != null) || ((attr = attributes.get("lowsrc")) != null)
            || ((attr = attributes.get("background")) != null) || ((attr = attributes.get("cite")) != null)
            || ((attr = attributes.get("longdesc")) != null) || ((attr = attributes.get("usemap")) != null)
            || ((attr = attributes.get("profile")) != null) || ((attr = attributes.get("datasrc")) != null))
            && ((attrValue = attr.getValue()) != null)) {

        final char hopType;
        CharSequence context = Link.elementContext(elementName, attr.getKey());

        if (!framesAsEmbeds && ("frame".equals(elementName) || "iframe".equals(elementName)))
            hopType = Link.NAVLINK_HOP;
        else
            hopType = Link.EMBED_HOP;

        processEmbed(curi, attrValue, context, hopType);
    }
    // CODEBASE
    if (((attr = attributes.get("codebase")) != null) && ((attrValue = attr.getValue()) != null)) {
        codebase = StringEscapeUtils.unescapeHtml(attrValue);
        CharSequence context = Link.elementContext(elementName, attr.getKey());
        processEmbed(curi, codebase, context);
    }
    // CLASSID DATA
    if ((((attr = attributes.get("classid")) != null) || ((attr = attributes.get("data")) != null))
            && ((attrValue = attr.getValue()) != null)) {
        if (resources == null)
            resources = new ArrayList<String>();
        resources.add(attrValue);
    }
    // ARCHIVE
    if (((attr = attributes.get("archive")) != null) && ((attrValue = attr.getValue()) != null)) {
        if (resources == null)
            resources = new ArrayList<String>();
        String[] multi = TextUtils.split(WHITESPACE, attrValue);
        for (int i = 0; i < multi.length; i++) {
            resources.add(multi[i]);
        }
    }
    // CODE
    if (((attr = attributes.get("code")) != null) && ((attrValue = attr.getValue()) != null)) {
        if (resources == null)
            resources = new ArrayList<String>();
        // If element is applet and code value does not end with
        // '.class' then append '.class' to the code value.
        if (APPLET.equals(elementName) && !attrValue.endsWith(CLASSEXT)) {
            resources.add(attrValue + CLASSEXT);
        } else {
            resources.add(attrValue);
        }
    }
    // VALUE
    if (((attr = attributes.get("value")) != null) && ((attrValue = attr.getValue()) != null)) {
        if (TextUtils.matches(LIKELY_URI_PATH, attrValue) && overlyEagerLinkDetection) {
            CharSequence context = Link.elementContext(elementName, attr.getKey());
            processLink(curi, attrValue, context);
        }

    }
    // STYLE
    if (((attr = attributes.get("style")) != null) && ((attrValue = attr.getValue()) != null)) {
        // STYLE inline attribute
        // then, parse for URIs
        this.numberOfLinksExtracted += ExtractorCSS.processStyleCode(curi, attrValue, getController());
    }

    // handle codebase/resources
    if (resources == null)
        return;

    Iterator<String> iter = resources.iterator();
    UURI codebaseURI = null;
    String res = null;
    try {
        if (codebase != null) {
            // TODO: Pass in the charset.
            codebaseURI = UURIFactory.getInstance(curi.getUURI(), codebase);
        }
        while (iter.hasNext()) {
            res = iter.next();
            res = StringEscapeUtils.unescapeHtml(res);
            if (codebaseURI != null) {
                res = codebaseURI.resolve(res).toString();
            }
            processEmbed(curi, res, element); // TODO: include attribute
                                              // too
        }
    } catch (URIException e) {
        curi.addLocalizedError(getName(), e, "BAD CODEBASE " + codebase);
    } catch (IllegalArgumentException e) {
        DevUtils.logger.log(Level.WARNING,
                "processGeneralTag()\n" + "codebase=" + codebase + " res=" + res + "\n" + DevUtils.extraInfo(),
                e);
    }
}

From source file:com.cyberway.issue.net.UURIFactoryTest.java

public final void testTooLongAfterEscaping() {
    StringBuffer buffer = new StringBuffer("http://www.archive.org/a/");
    // Append bunch of spaces.  When escaped, they'll triple in size.
    for (int i = 0; i < 1024; i++) {
        buffer.append(" ");
    }//from ww w. j av a2  s.  co m
    buffer.append("/index.html");
    String message = null;
    try {
        UURIFactory.getInstance(buffer.toString());
    } catch (URIException e) {
        message = e.getMessage();
    }
    assertTrue("Wrong or no exception: " + message,
            (message != null) && message.startsWith("Created (escaped) uuri >"));
}

From source file:de.juwimm.cms.http.HttpClientWrapper.java

/**
 * /* ww w .j  a v a 2 s.  co  m*/
 * @param testUrlString
 *                destination
 * @param userName
 *                for authentication at testUrlString NOT for proxy
 * @param password
 *                for authentication at testUrlString NOT for proxy
 * @throws HttpException
 */
public void testAndConfigureConnection(String testUrlString, String userName, String password)
        throws HttpException {
    URL testURL = null;
    try {
        testURL = new URL(testUrlString);
    } catch (MalformedURLException exe1) {
        throw new HttpException(
                HttpMessages.getString("HttpClientWrapper.testConnectionFailed", testUrlString, "\n"));
    }

    DlgUsernamePassword dlg = new DlgUsernamePassword();
    if ((getHttpProxyUser() == null || "".equalsIgnoreCase(getHttpProxyUser()))
            && getHttpProxyPassword() == null || "".equalsIgnoreCase(getHttpProxyPassword())) {
        dlg.getTxtUsername().setText(System.getProperty("user.name"));
    } else {
        dlg.getTxtUsername().setText(getHttpProxyUser());
    }
    dlg.getTxtPassword().setText(getHttpProxyPassword());
    // dlg.getTxtNTDomain().setText(httpProxyNTDomain);

    // try no auth, base auth, ntlm auth with user giving username and
    // password until successful
    while (true) {
        try {

            testAndConfigureConnectionTryInvoke(testURL, userName, password);
            // save password only if connect successful
            saveProperties(dlg.getCboSave().isSelected());
            break;
        } catch (URIException exe) {
            // http-Error-Code: 407 = Proxy Authentication Required
            if (exe.getReasonCode() == 407) {
                // ask user for user and password
                dlg.setVisible(true);
                if (dlg.isCanceled()) {
                    throw new HttpException(
                            HttpMessages.getString("HttpClientWrapper.noProxyWhereNeededExeption"));
                }
                setHttpProxyUser(dlg.getTxtUsername().getText());
                setHttpProxyPassword(String.copyValueOf(dlg.getTxtPassword().getPassword()));
                // httpProxyNTDomain = dlg.getTxtNTDomain().getText();
            } else {
                throw new HttpException(HttpMessages.getString("HttpClientWrapper.testConnectionFailed",
                        testURL.getHost(), exe.getMessage()));
            }
        }
    }
    log.debug("finished test");
}

From source file:com.cyberway.issue.crawler.extractor.ExtractorHTML.java

protected void processGeneralTag(CrawlURI curi, CharSequence element, CharSequence cs) {

    Matcher attr = TextUtils.getMatcher(EACH_ATTRIBUTE_EXTRACTOR, cs);

    // Just in case it's an OBJECT or APPLET tag
    String codebase = null;/*from   ww  w  . j a v a2s. co m*/
    ArrayList<String> resources = null;

    // Just in case it's a FORM
    CharSequence action = null;
    CharSequence actionContext = null;
    CharSequence method = null;

    final boolean framesAsEmbeds = ((Boolean) getUncheckedAttribute(curi, ATTR_TREAT_FRAMES_AS_EMBED_LINKS))
            .booleanValue();

    final boolean ignoreFormActions = ((Boolean) getUncheckedAttribute(curi, ATTR_IGNORE_FORM_ACTION_URLS))
            .booleanValue();

    final boolean extractValueAttributes = ((Boolean) getUncheckedAttribute(curi, EXTRACT_VALUE_ATTRIBUTES))
            .booleanValue();

    final String elementStr = element.toString();

    while (attr.find()) {
        int valueGroup = (attr.start(14) > -1) ? 14 : (attr.start(15) > -1) ? 15 : 16;
        int start = attr.start(valueGroup);
        int end = attr.end(valueGroup);
        assert start >= 0 : "Start is: " + start + ", " + curi;
        assert end >= 0 : "End is :" + end + ", " + curi;
        CharSequence value = cs.subSequence(start, end);
        value = TextUtils.unescapeHtml(value);
        if (attr.start(2) > -1) {
            // HREF
            CharSequence context = Link.elementContext(element, attr.group(2));
            if (elementStr.equalsIgnoreCase(LINK)) {
                // <LINK> elements treated as embeds (css, ico, etc)
                processEmbed(curi, value, context);
            } else {
                // other HREFs treated as links
                if (value.toString().indexOf("java") != -1)
                    System.out.println(value + "--------javascript--------");
                processLink(curi, value, context);
            }
            if (elementStr.equalsIgnoreCase(BASE)) {
                try {
                    curi.setBaseURI(value.toString());
                } catch (URIException e) {
                    if (getController() != null) {
                        // Controller can be null: e.g. when running
                        // ExtractorTool.
                        getController().logUriError(e, curi.getUURI(), value.toString());
                    } else {
                        logger.info("Failed set base uri: " + curi + ", " + value.toString() + ": "
                                + e.getMessage());
                    }
                }
            }
        } else if (attr.start(3) > -1) {
            // ACTION
            if (!ignoreFormActions) {
                action = value;
                actionContext = Link.elementContext(element, attr.group(3));
                // handling finished only at end (after METHOD also collected)
            }
        } else if (attr.start(4) > -1) {
            // ON____
            processScriptCode(curi, value); // TODO: context?
        } else if (attr.start(5) > -1) {
            // SRC etc.
            CharSequence context = Link.elementContext(element, attr.group(5));

            // true, if we expect another HTML page instead of an image etc.
            final char hopType;

            if (!framesAsEmbeds
                    && (elementStr.equalsIgnoreCase(FRAME) || elementStr.equalsIgnoreCase(IFRAME))) {
                hopType = Link.NAVLINK_HOP;
            } else {
                hopType = Link.EMBED_HOP;
            }
            processEmbed(curi, value, context, hopType);
        } else if (attr.start(6) > -1) {
            // CODEBASE
            codebase = (value instanceof String) ? (String) value : value.toString();
            CharSequence context = Link.elementContext(element, attr.group(6));
            processEmbed(curi, codebase, context);
        } else if (attr.start(7) > -1) {
            // CLASSID, DATA
            if (resources == null) {
                resources = new ArrayList<String>();
            }
            resources.add(value.toString());
        } else if (attr.start(8) > -1) {
            // ARCHIVE
            if (resources == null) {
                resources = new ArrayList<String>();
            }
            String[] multi = TextUtils.split(WHITESPACE, value);
            for (int i = 0; i < multi.length; i++) {
                resources.add(multi[i]);
            }
        } else if (attr.start(9) > -1) {
            // CODE
            if (resources == null) {
                resources = new ArrayList<String>();
            }
            // If element is applet and code value does not end with
            // '.class' then append '.class' to the code value.
            if (elementStr.equalsIgnoreCase(APPLET) && !value.toString().toLowerCase().endsWith(CLASSEXT)) {
                resources.add(value.toString() + CLASSEXT);
            } else {
                resources.add(value.toString());
            }
        } else if (attr.start(10) > -1) {
            // VALUE, with possibility of URI
            if (extractValueAttributes && TextUtils.matches(LIKELY_URI_PATH, value)) {
                CharSequence context = Link.elementContext(element, attr.group(10));
                processLink(curi, value, context);
            }

        } else if (attr.start(11) > -1) {
            // STYLE inline attribute
            // then, parse for URIs
            this.numberOfLinksExtracted += ExtractorCSS.processStyleCode(curi, value, getController());

        } else if (attr.start(12) > -1) {
            // METHOD
            method = value;
            // form processing finished at end (after ACTION also collected)
        } else if (attr.start(13) > -1) {
            // any other attribute
            // ignore for now
            // could probe for path- or script-looking strings, but
            // those should be vanishingly rare in other attributes,
            // and/or symptomatic of page bugs
        }
    }
    TextUtils.recycleMatcher(attr);

    // finish handling codebase/resources now that all available
    if (resources != null) {
        Iterator iter = resources.iterator();
        UURI codebaseURI = null;
        String res = null;
        try {
            if (codebase != null) {
                // TODO: Pass in the charset.
                codebaseURI = UURIFactory.getInstance(curi.getUURI(), codebase);
            }
            while (iter.hasNext()) {
                res = iter.next().toString();
                res = (String) TextUtils.unescapeHtml(res);
                if (codebaseURI != null) {
                    res = codebaseURI.resolve(res).toString();
                }
                processEmbed(curi, res, element); // TODO: include attribute too
            }
        } catch (URIException e) {
            curi.addLocalizedError(getName(), e, "BAD CODEBASE " + codebase);
        } catch (IllegalArgumentException e) {
            DevUtils.logger.log(Level.WARNING, "processGeneralTag()\n" + "codebase=" + codebase + " res=" + res
                    + "\n" + DevUtils.extraInfo(), e);
        }
    }

    // finish handling form action, now method is available
    if (action != null) {
        if (method == null || "GET".equalsIgnoreCase(method.toString())
                || !((Boolean) getUncheckedAttribute(curi, ATTR_EXTRACT_ONLY_FORM_GETS)).booleanValue()) {
            processLink(curi, action, actionContext);
        }
    }
}

From source file:com.cyberway.issue.crawler.framework.CrawlController.java

/**
 * Log a URIException from deep inside other components to the crawl's
 * shared log. /*from  ww  w  . ja v a 2  s . c  om*/
 * 
 * @param e URIException encountered
 * @param u CrawlURI where problem occurred
 * @param l String which could not be interpreted as URI without exception
 */
public void logUriError(URIException e, UURI u, CharSequence l) {
    if (e.getReasonCode() == UURIFactory.IGNORED_SCHEME) {
        // don't log those that are intentionally ignored
        return;
    }
    Object[] array = { u, l };
    uriErrors.log(Level.INFO, e.getMessage(), array);
}

From source file:davmail.http.SpNegoScheme.java

/**
 * Produces Negotiate authorization string for the given set of
 * {@link Credentials}./*w  w  w . j  a v a2  s. c  om*/
 *
 * @param credentials The set of credentials to be used for authentication
 * @param httpMethod  The method being authenticated
 * @return an Negotiate authorization string
 * @throws org.apache.commons.httpclient.auth.InvalidCredentialsException
 *                                 if authentication credentials
 *                                 are not valid or not applicable for this authentication scheme
 * @throws AuthenticationException if authorization string cannot
 *                                 be generated due to an authentication failure
 */
public String authenticate(Credentials credentials, HttpMethod httpMethod) throws AuthenticationException {
    if (this.state == UNINITIATED) {
        throw new IllegalStateException("Negotiate authentication process has not been initiated");
    }
    String host = null;
    try {
        host = httpMethod.getURI().getHost();
    } catch (URIException e) {
        // ignore
    }
    if (host == null) {
        Header header = httpMethod.getRequestHeader("Host");
        if (header != null) {
            host = header.getValue();
            if (host.indexOf(':') >= 0) {
                host = host.substring(0, host.indexOf(':'));
            }
        }
    }
    if (host == null) {
        throw new IllegalStateException("Negotiate authentication failed: empty host");
    }

    // no credentials needed
    String response;
    try {
        if (this.state == INITIATED || this.state == FAILED) {
            // send initial token to server
            response = EncodingUtil.getAsciiString(
                    Base64.encodeBase64(KerberosHelper.initSecurityContext("HTTP", host, new byte[0])));
            this.state = TYPE1_MSG_GENERATED;
        } else {
            // send challenge response
            response = EncodingUtil.getAsciiString(
                    Base64.encodeBase64(KerberosHelper.initSecurityContext("HTTP", host, serverToken)));
            this.state = TYPE3_MSG_GENERATED;
        }
    } catch (GSSException gsse) {
        state = FAILED;
        if (gsse.getMajor() == GSSException.DEFECTIVE_CREDENTIAL
                || gsse.getMajor() == GSSException.CREDENTIALS_EXPIRED)
            throw new InvalidCredentialsException(gsse.getMessage(), gsse);
        if (gsse.getMajor() == GSSException.NO_CRED)
            throw new CredentialsNotAvailableException(gsse.getMessage(), gsse);
        if (gsse.getMajor() == GSSException.DEFECTIVE_TOKEN || gsse.getMajor() == GSSException.DUPLICATE_TOKEN
                || gsse.getMajor() == GSSException.OLD_TOKEN)
            throw new AuthChallengeException(gsse.getMessage(), gsse);
        // other error
        throw new AuthenticationException(gsse.getMessage(), gsse);
    } catch (LoginException e) {
        state = FAILED;
        throw new InvalidCredentialsException(e.getMessage(), e);
    }
    return "Negotiate " + response;
}

From source file:davmail.exchange.dav.DavExchangeSession.java

protected void fixClientHost(HttpMethod method) {
    try {//from   w ww . ja va2 s  .  c  o  m
        // update client host, workaround for Exchange 2003 mailbox with an Exchange 2007 frontend
        URI currentUri = method.getURI();
        if (currentUri != null && currentUri.getHost() != null && currentUri.getScheme() != null) {
            httpClient.getHostConfiguration().setHost(currentUri.getHost(), currentUri.getPort(),
                    currentUri.getScheme());
        }
    } catch (URIException e) {
        LOGGER.warn("Unable to update http client host:" + e.getMessage(), e);
    }
}

From source file:com.zimbra.cs.account.ProvUtil.java

@Override
public void sendSoapMessage(PostMethod postMethod, Element envelope, HttpState httpState) {
    console.println("========== SOAP SEND ==========");

    if (debugLevel == SoapDebugLevel.high) {
        try {//from  w  w  w  .  j  a  v a2  s .c  om
            URI uri = postMethod.getURI();
            console.println(uri.toString());
        } catch (URIException e) {
            if (verboseMode) {
                e.printStackTrace(errConsole);
            } else {
                console.println("Unable to get request URL, error=" + e.getMessage());
            }
        }

        Header[] headers = postMethod.getRequestHeaders();
        for (Header header : headers) {
            console.println(header.toString().trim()); // trim the ending crlf
        }
        console.println();
    }

    sendStart = System.currentTimeMillis();

    console.println(envelope.prettyPrint());
    console.println("===============================");
}

From source file:com.twinsoft.convertigo.engine.servlets.ReverseProxyServlet.java

/**
 * Executes the {@link HttpMethod} passed in and sends the proxy response
 * back to the client via the given {@link HttpServletResponse}
 * /*  ww  w .  j a  va  2 s.  c om*/
 * @param httpMethodProxyRequest
 *            An object representing the proxy request to be made
 * @param httpServletResponse
 *            An object by which we can send the proxied response back to
 *            the client
 * @throws IOException
 *             Can be thrown by the {@link HttpClient}.executeMethod
 * @throws ServletException
 *             Can be thrown to indicate that another error has occurred
 * @throws EngineException
 */
private void doRequest(HttpMethodType httpMethodType, HttpServletRequest httpServletRequest,
        HttpServletResponse httpServletResponse) throws IOException, ServletException {
    try {
        Engine.logEngine.debug("(ReverseProxyServlet) Starting request handling");

        if (Boolean.parseBoolean(EnginePropertiesManager.getProperty(PropertyName.SSL_DEBUG))) {
            System.setProperty("javax.net.debug", "all");
            Engine.logEngine.trace("(ReverseProxyServlet) Enabling SSL debug mode");
        } else {
            System.setProperty("javax.net.debug", "");
            Engine.logEngine.debug("(ReverseProxyServlet) Disabling SSL debug mode");
        }

        String baseUrl;
        String projectName;
        String connectorName;
        String contextName;
        String extraPath;

        {
            String requestURI = httpServletRequest.getRequestURI();
            Engine.logEngine.trace("(ReverseProxyServlet) Requested URI : " + requestURI);
            Matcher m = reg_fields.matcher(requestURI);
            if (m.matches() && m.groupCount() >= 5) {
                baseUrl = m.group(1);
                projectName = m.group(2);
                connectorName = m.group(3);
                contextName = m.group(4);
                extraPath = m.group(5);
            } else {
                throw new MalformedURLException(
                        "The request doesn't contains needed fields : projectName, connectorName and contextName");
            }
        }

        String sessionID = httpServletRequest.getSession().getId();

        Engine.logEngine.debug("(ReverseProxyServlet) baseUrl : " + baseUrl + " ; projectName : " + projectName
                + " ; connectorName : " + connectorName + " ; contextName : " + contextName + " ; extraPath : "
                + extraPath + " ; sessionID : " + sessionID);

        Context context = Engine.theApp.contextManager.get(null, contextName, sessionID, null, projectName,
                connectorName, null);

        Project project = Engine.theApp.databaseObjectsManager.getProjectByName(projectName);
        context.projectName = projectName;
        context.project = project;

        ProxyHttpConnector proxyHttpConnector = (ProxyHttpConnector) project.getConnectorByName(connectorName);
        context.connector = proxyHttpConnector;
        context.connectorName = proxyHttpConnector.getName();

        HostConfiguration hostConfiguration = proxyHttpConnector.hostConfiguration;

        // Proxy configuration
        String proxyServer = Engine.theApp.proxyManager.getProxyServer();
        String proxyUser = Engine.theApp.proxyManager.getProxyUser();
        String proxyPassword = Engine.theApp.proxyManager.getProxyPassword();
        int proxyPort = Engine.theApp.proxyManager.getProxyPort();

        if (!proxyServer.equals("")) {
            hostConfiguration.setProxy(proxyServer, proxyPort);
            Engine.logEngine.debug("(ReverseProxyServlet) Using proxy: " + proxyServer + ":" + proxyPort);
        } else {
            // Remove old proxy configuration
            hostConfiguration.setProxyHost(null);
        }

        String targetHost = proxyHttpConnector.getServer();
        Engine.logEngine.debug("(ReverseProxyServlet) Target host: " + targetHost);
        int targetPort = proxyHttpConnector.getPort();
        Engine.logEngine.debug("(ReverseProxyServlet) Target port: " + targetPort);

        // Configuration SSL
        Engine.logEngine.debug("(ReverseProxyServlet) Https: " + proxyHttpConnector.isHttps());
        CertificateManager certificateManager = proxyHttpConnector.certificateManager;
        boolean trustAllServerCertificates = proxyHttpConnector.isTrustAllServerCertificates();

        if (proxyHttpConnector.isHttps()) {
            Engine.logEngine.debug("(ReverseProxyServlet) Setting up SSL properties");
            certificateManager.collectStoreInformation(context);

            Engine.logEngine.debug(
                    "(ReverseProxyServlet) CertificateManager has changed: " + certificateManager.hasChanged);
            if (certificateManager.hasChanged || (!targetHost.equalsIgnoreCase(hostConfiguration.getHost()))
                    || (hostConfiguration.getPort() != targetPort)) {
                Engine.logEngine
                        .debug("(ReverseProxyServlet) Using MySSLSocketFactory for creating the SSL socket");
                Protocol myhttps = new Protocol("https",
                        MySSLSocketFactory.getSSLSocketFactory(certificateManager.keyStore,
                                certificateManager.keyStorePassword, certificateManager.trustStore,
                                certificateManager.trustStorePassword, trustAllServerCertificates),
                        targetPort);

                hostConfiguration.setHost(targetHost, targetPort, myhttps);
            }

            Engine.logEngine.debug("(ReverseProxyServlet) Updated host configuration for SSL purposes");
        } else {
            hostConfiguration.setHost(targetHost, targetPort);
        }

        HttpMethod httpMethodProxyRequest;

        String targetPath = proxyHttpConnector.getBaseDir() + extraPath;

        // Handle the query string
        if (httpServletRequest.getQueryString() != null) {
            targetPath += "?" + httpServletRequest.getQueryString();
        }
        Engine.logEngine.debug("(ReverseProxyServlet) Target path: " + targetPath);

        Engine.logEngine.debug("(ReverseProxyServlet) Requested method: " + httpMethodType);

        if (httpMethodType == HttpMethodType.GET) {
            // Create a GET request
            httpMethodProxyRequest = new GetMethod();
        } else if (httpMethodType == HttpMethodType.POST) {
            // Create a standard POST request
            httpMethodProxyRequest = new PostMethod();
            ((PostMethod) httpMethodProxyRequest)
                    .setRequestEntity(new InputStreamRequestEntity(httpServletRequest.getInputStream()));
        } else {
            throw new IllegalArgumentException("Unknown HTTP method: " + httpMethodType);
        }

        String charset = httpMethodProxyRequest.getParams().getUriCharset();
        URI targetURI;
        try {
            targetURI = new URI(targetPath, true, charset);
        } catch (URIException e) {
            // Bugfix #1484
            String newTargetPath = "";
            for (String part : targetPath.split("&")) {
                if (!newTargetPath.equals("")) {
                    newTargetPath += "&";
                }
                String[] pair = part.split("=");
                try {
                    newTargetPath += URLDecoder.decode(pair[0], "UTF-8") + "="
                            + (pair.length > 1 ? URLEncoder.encode(URLDecoder.decode(pair[1], "UTF-8"), "UTF-8")
                                    : "");
                } catch (UnsupportedEncodingException ee) {
                    newTargetPath = targetPath;
                }
            }

            targetURI = new URI(newTargetPath, true, charset);
        }
        httpMethodProxyRequest.setURI(targetURI);

        // Tells the method to automatically handle authentication.
        httpMethodProxyRequest.setDoAuthentication(true);

        HttpState httpState = getHttpState(proxyHttpConnector, context);

        String basicUser = proxyHttpConnector.getAuthUser();
        String basicPassword = proxyHttpConnector.getAuthPassword();
        String givenBasicUser = proxyHttpConnector.getGivenAuthUser();
        String givenBasicPassword = proxyHttpConnector.getGivenAuthPassword();

        // Basic authentication configuration
        String realm = null;
        if (!basicUser.equals("") || (basicUser.equals("") && (givenBasicUser != null))) {
            String userName = ((givenBasicUser == null) ? basicUser : givenBasicUser);
            String userPassword = ((givenBasicPassword == null) ? basicPassword : givenBasicPassword);
            httpState.setCredentials(new AuthScope(targetHost, targetPort, realm),
                    new UsernamePasswordCredentials(userName, userPassword));
            Engine.logEngine.debug("(ReverseProxyServlet) Credentials: " + userName + ":******");
        }

        // Setting basic authentication for proxy
        if (!proxyServer.equals("") && !proxyUser.equals("")) {
            httpState.setProxyCredentials(new AuthScope(proxyServer, proxyPort),
                    new UsernamePasswordCredentials(proxyUser, proxyPassword));
            Engine.logEngine.debug("(ReverseProxyServlet) Proxy credentials: " + proxyUser + ":******");
        }

        // Forward the request headers
        setProxyRequestHeaders(httpServletRequest, httpMethodProxyRequest, proxyHttpConnector);

        // Use the CEMS HttpClient
        HttpClient httpClient = Engine.theApp.httpClient;
        httpMethodProxyRequest.setFollowRedirects(false);

        // Execute the request
        int intProxyResponseCode = httpClient.executeMethod(hostConfiguration, httpMethodProxyRequest,
                httpState);

        // Check if the proxy response is a redirect
        // The following code is adapted from
        // org.tigris.noodle.filters.CheckForRedirect
        // Hooray for open source software
        if (intProxyResponseCode >= HttpServletResponse.SC_MULTIPLE_CHOICES /* 300 */
                && intProxyResponseCode < HttpServletResponse.SC_NOT_MODIFIED /* 304 */) {
            String stringStatusCode = Integer.toString(intProxyResponseCode);
            String stringLocation = httpMethodProxyRequest.getResponseHeader(STRING_LOCATION_HEADER).getValue();
            if (stringLocation == null) {
                throw new ServletException("Received status code: " + stringStatusCode + " but no "
                        + STRING_LOCATION_HEADER + " header was found in the response");
            }
            // Modify the redirect to go to this proxy servlet rather that
            // the
            // proxied host
            String redirect = handleRedirect(stringLocation, baseUrl, proxyHttpConnector);
            httpServletResponse.sendRedirect(redirect);
            Engine.logEngine.debug("(ReverseProxyServlet) Send redirect (" + redirect + ")");
            return;
        } else if (intProxyResponseCode == HttpServletResponse.SC_NOT_MODIFIED) {
            // 304 needs special handling. See:
            // http://www.ics.uci.edu/pub/ietf/http/rfc1945.html#Code304
            // We get a 304 whenever passed an 'If-Modified-Since'
            // header and the data on disk has not changed; server
            // responds w/ a 304 saying I'm not going to send the
            // body because the file has not changed.
            httpServletResponse.setIntHeader(STRING_CONTENT_LENGTH_HEADER_NAME, 0);
            httpServletResponse.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            Engine.logEngine.debug("(ReverseProxyServlet) NOT MODIFIED (304)");
            return;
        }

        // Pass the response code back to the client
        httpServletResponse.setStatus(intProxyResponseCode);

        // Pass response headers back to the client
        Engine.logEngine.debug("(ReverseProxyServlet) Response headers back to the client:");
        Header[] headerArrayResponse = httpMethodProxyRequest.getResponseHeaders();
        for (Header header : headerArrayResponse) {
            String headerName = header.getName();
            String headerValue = header.getValue();
            if (!headerName.equalsIgnoreCase("Transfer-Encoding")
                    && !headerName.equalsIgnoreCase("Set-Cookie")) {
                httpServletResponse.setHeader(headerName, headerValue);
                Engine.logEngine.debug("   " + headerName + "=" + headerValue);
            }
        }

        String contentType = null;
        Header[] contentTypeHeaders = httpMethodProxyRequest.getResponseHeaders("Content-Type");
        for (Header contentTypeHeader : contentTypeHeaders) {
            contentType = contentTypeHeader.getValue();
            break;
        }

        String pageCharset = "UTF-8";
        if (contentType != null) {
            int iCharset = contentType.indexOf("charset=");
            if (iCharset != -1) {
                pageCharset = contentType.substring(iCharset + "charset=".length()).trim();
            }
            Engine.logEngine.debug("(ReverseProxyServlet) Using charset: " + pageCharset);
        }

        InputStream siteIn = httpMethodProxyRequest.getResponseBodyAsStream();

        // Handle gzipped content
        Header[] contentEncodingHeaders = httpMethodProxyRequest.getResponseHeaders("Content-Encoding");
        boolean bGZip = false, bDeflate = false;
        for (Header contentEncodingHeader : contentEncodingHeaders) {
            HeaderElement[] els = contentEncodingHeader.getElements();
            for (int j = 0; j < els.length; j++) {
                if ("gzip".equals(els[j].getName())) {
                    Engine.logBeans.debug("(ReverseProxyServlet) Decode GZip stream");
                    siteIn = new GZIPInputStream(siteIn);
                    bGZip = true;
                } else if ("deflate".equals(els[j].getName())) {
                    Engine.logBeans.debug("(ReverseProxyServlet) Decode Deflate stream");
                    siteIn = new InflaterInputStream(siteIn, new Inflater(true));
                    bDeflate = true;
                }
            }
        }

        byte[] bytesDataResult;

        ByteArrayOutputStream baos = new ByteArrayOutputStream(2048);

        // String resourceUrl = projectName + targetPath;

        String t = context.statistics.start(EngineStatistics.APPLY_USER_REQUEST);

        try {
            // Read either from the cache, either from the remote server
            // InputStream is = proxyCacheManager.getResource(resourceUrl);
            // if (is != null) {
            // Engine.logEngine.debug("(ReverseProxyServlet) Getting data from cache");
            // siteIn = is;
            // }
            int c = siteIn.read();
            while (c > -1) {
                baos.write(c);
                c = siteIn.read();
            }
            // if (is != null) is.close();
        } finally {
            context.statistics.stop(t, true);
        }

        bytesDataResult = baos.toByteArray();
        baos.close();
        Engine.logEngine.debug("(ReverseProxyServlet) Data retrieved!");

        // if (isDynamicContent(httpServletRequest.getPathInfo(),
        // proxyHttpConnector.getDynamicContentFiles())) {
        Engine.logEngine.debug("(ReverseProxyServlet) Dynamic content");

        bytesDataResult = handleStringReplacements(baseUrl, contentType, pageCharset, proxyHttpConnector,
                bytesDataResult);

        String billingClassName = context.getConnector().getBillingClassName();
        if (billingClassName != null) {
            try {
                Engine.logContext.debug("Billing class name required: " + billingClassName);
                AbstractBiller biller = (AbstractBiller) Class.forName(billingClassName).newInstance();
                Engine.logContext.debug("Executing the biller");
                biller.insertBilling(context);
            } catch (Throwable e) {
                Engine.logContext.warn("Unable to execute the biller (the billing is thus ignored): ["
                        + e.getClass().getName() + "] " + e.getMessage());
            }
        }
        // }
        // else {
        // Engine.logEngine.debug("(ReverseProxyServlet) Static content: " +
        // contentType);
        //            
        // // Determine if the resource has already been cached or not
        // CacheEntry cacheEntry =
        // proxyCacheManager.getCacheEntry(resourceUrl);
        // if (cacheEntry instanceof FileCacheEntry) {
        // FileCacheEntry fileCacheEntry = (FileCacheEntry) cacheEntry;
        // File file = new File(fileCacheEntry.fileName);
        // if (!file.exists())
        // proxyCacheManager.removeCacheEntry(cacheEntry);
        // cacheEntry = null;
        // }
        // if (cacheEntry == null) {
        // bytesDataResult = handleStringReplacements(contentType,
        // proxyHttpConnector, bytesDataResult);
        //
        // if (intProxyResponseCode == 200) {
        // Engine.logEngine.debug("(ReverseProxyServlet) Resource stored: "
        // + resourceUrl);
        // cacheEntry = proxyCacheManager.storeResponse(resourceUrl,
        // bytesDataResult);
        // cacheEntry.contentLength = bytesDataResult.length;
        // cacheEntry.contentType = contentType;
        // Engine.logEngine.debug("(ReverseProxyServlet) Cache entry: " +
        // cacheEntry);
        // }
        // }
        // }

        // Send the content to the client
        if (Engine.logEngine.isDebugEnabled() && MimeType.Html.is(contentType)) {
            Engine.logEngine.debug("Data proxied:\n" + new String(bytesDataResult, pageCharset));
        }

        if (bGZip || bDeflate) {
            baos = new ByteArrayOutputStream();
            OutputStream compressedOutputStream = bGZip ? new GZIPOutputStream(baos)
                    : new DeflaterOutputStream(baos,
                            new Deflater(Deflater.DEFAULT_COMPRESSION | Deflater.DEFAULT_STRATEGY, true));
            compressedOutputStream.write(bytesDataResult);
            compressedOutputStream.close();
            bytesDataResult = baos.toByteArray();
            baos.close();
        }

        httpServletResponse.setContentLength(bytesDataResult.length);
        OutputStream outputStreamClientResponse = httpServletResponse.getOutputStream();
        outputStreamClientResponse.write(bytesDataResult);

        Engine.logEngine.debug("(ReverseProxyServlet) End of document retransmission");
    } catch (Exception e) {
        Engine.logEngine.error("Error while trying to proxy page", e);
        throw new ServletException("Error while trying to proxy page", e);
    }
}

From source file:nl.basjes.parse.httpdlog.dissectors.HttpUriDissector.java

@Override
public void dissect(final Parsable<?> parsable, final String inputname) throws DissectionFailure {
    final ParsedField field = parsable.getParsableField(INPUT_TYPE, inputname);

    String uriString = field.getValue().getString();
    if (uriString == null || uriString.isEmpty()) {
        return; // Nothing to do here
    }//from   w ww  .ja v  a2  s  .co  m

    // First we cleanup the URI so we fail less often over 'garbage' URIs.
    // See: http://stackoverflow.com/questions/11038967/brackets-in-a-request-url-are-legal-but-not-in-a-uri-java
    try {
        uriString = URIUtil.encode(uriString, badUriChars, "UTF-8");
    } catch (URIException e) {
        throw new DissectionFailure(
                "Failed to parse URI >>" + field.getValue().getString() + "<< because of : " + e.getMessage());
    }

    // Before we hand it to the standard parser we hack it around a bit so we can parse
    // nasty edge cases that are illegal yet do occur in real clickstreams.
    // Also we force the query string to start with ?& so the returned query string starts with &
    // Which leads to more consistent output after parsing.
    int firstQuestionMark = uriString.indexOf('?');
    int firstAmpersand = uriString.indexOf('&');
    // Now we can have one of 3 situations:
    // 1) No query string
    // 2) Query string starts with a '?'
    //      (and optionally followed by one or more '&' or '?' )
    // 3) Query string starts with a '&'. This is invalid but does occur!
    // We may have ?x=x&y=y?z=z so we normalize it always
    // to:  ?&x=x&y=y&z=z
    if (firstAmpersand != -1 || firstQuestionMark != -1) {
        uriString = uriString.replaceAll("\\?", "&");
        uriString = uriString.replaceFirst("&", "?&");
    }

    // We find that people muck up the URL by putting % signs in the URLs that are NOT escape sequences
    // So any % that is not followed by a two 'hex' letters is fixed
    uriString = BAD_EXCAPE_PATTERN.matcher(uriString).replaceAll("%25$1");
    uriString = BAD_EXCAPE_PATTERN.matcher(uriString).replaceAll("%25$1");

    boolean isUrl = true;
    URI uri;
    try {
        if (uriString.charAt(0) == '/') {
            uri = URI.create("dummy-protocol://dummy.host.name" + uriString);
            isUrl = false; // I.e. we do not return the values we just faked.
        } else {
            uri = URI.create(uriString);
        }
    } catch (IllegalArgumentException e) {
        throw new DissectionFailure(
                "Failed to parse URI >>" + field.getValue().getString() + "<< because of : " + e.getMessage());
    }

    if (wantQuery || wantPath || wantRef) {
        if (wantQuery) {
            String query = uri.getRawQuery();
            if (query == null) {
                query = "";
            }
            parsable.addDissection(inputname, "HTTP.QUERYSTRING", "query", query);
        }
        if (wantPath) {
            parsable.addDissection(inputname, "HTTP.PATH", "path", uri.getPath());
        }
        if (wantRef) {
            parsable.addDissection(inputname, "HTTP.REF", "ref", uri.getFragment());
        }
    }

    if (isUrl) {
        if (wantProtocol) {
            parsable.addDissection(inputname, "HTTP.PROTOCOL", "protocol", uri.getScheme());
        }
        if (wantUserinfo) {
            parsable.addDissection(inputname, "HTTP.USERINFO", "userinfo", uri.getUserInfo());
        }
        if (wantHost) {
            parsable.addDissection(inputname, "HTTP.HOST", "host", uri.getHost());
        }
        if (wantPort) {
            if (uri.getPort() != -1) {
                parsable.addDissection(inputname, "HTTP.PORT", "port", uri.getPort());
            }
        }
    }
}