Examples with StringEntity org.openecard.apache.http.entity.StringEntity used on opensource projects

Example 1 with StringEntity

use of org.openecard.apache.http.entity.StringEntity in project open-ecard by ecsec.

the class HttpAppPluginActionHandler method addHTTPEntity.

private void addHTTPEntity(HttpResponse response, BindingResult bindingResult) {
    ResponseBody responseBody = bindingResult.getBody();
    if (responseBody != null && responseBody.hasValue()) {
        LOG.debug("BindingResult contains a body.");
        // determine content type
        ContentType ct = ContentType.create(responseBody.getMimeType(), Charset.forName("UTF-8"));
        StringEntity entity = new StringEntity(responseBody.getValue(), ct);
        response.setEntity(entity);
        // evaluate Base64 flag
        if (responseBody.isBase64()) {
            response.setHeader("Content-Transfer-Encoding", "Base64");
        }
    } else {
        LOG.debug("BindingResult contains no body.");
        if (bindingResult.getResultMessage() != null) {
            ContentType ct = ContentType.create("text/plain", Charset.forName("UTF-8"));
            StringEntity entity = new StringEntity(bindingResult.getResultMessage(), ct);
            response.setEntity(entity);
        }
    }
}

Example 2 with StringEntity

use of org.openecard.apache.http.entity.StringEntity in project open-ecard by ecsec.

the class PAOS method sendStartPAOS.

/**
 * Sends start PAOS and answers all successor messages to the server associated with this instance.
 * Messages are exchanged until the server replies with a {@code StartPAOSResponse} message.
 *
 * @param message The StartPAOS message which is sent in the first message.
 * @return The {@code StartPAOSResponse} message from the server.
 * @throws DispatcherException In case there errors with the message conversion or the dispatcher.
 * @throws PAOSException In case there were errors in the transport layer.
 * @throws PAOSConnectionException
 */
public StartPAOSResponse sendStartPAOS(StartPAOS message) throws DispatcherException, PAOSException, PAOSConnectionException {
    Object msg = message;
    StreamHttpClientConnection conn = null;
    HttpContext ctx = new BasicHttpContext();
    HttpRequestExecutor httpexecutor = new HttpRequestExecutor();
    DefaultConnectionReuseStrategy reuse = new DefaultConnectionReuseStrategy();
    boolean connectionDropped = false;
    ResponseBaseType lastResponse = null;
    try {
        // loop and send makes a computer happy
        while (true) {
            // set up connection to PAOS endpoint
            // if this one fails we may not continue
            conn = openHttpStream();
            boolean isReusable;
            // send as long as connection is valid
            try {
                do {
                    // save the last message we sent to the eID-Server.
                    if (msg instanceof ResponseBaseType) {
                        lastResponse = (ResponseBaseType) msg;
                    }
                    // prepare request
                    String resource = tlsHandler.getResource();
                    BasicHttpEntityEnclosingRequest req = new BasicHttpEntityEnclosingRequest("POST", resource);
                    HttpRequestHelper.setDefaultHeader(req, tlsHandler.getServerAddress());
                    req.setHeader(HEADER_KEY_PAOS, headerValuePaos);
                    req.setHeader("Accept", "text/xml, application/xml, application/vnd.paos+xml");
                    ContentType reqContentType = ContentType.create("application/vnd.paos+xml", "UTF-8");
                    HttpUtils.dumpHttpRequest(LOG, "before adding content", req);
                    String reqMsgStr = createPAOSResponse(msg);
                    StringEntity reqMsg = new StringEntity(reqMsgStr, reqContentType);
                    req.setEntity(reqMsg);
                    req.setHeader(reqMsg.getContentType());
                    req.setHeader("Content-Length", Long.toString(reqMsg.getContentLength()));
                    // send request and receive response
                    LOG.debug("Sending HTTP request.");
                    HttpResponse response = httpexecutor.execute(req, conn, ctx);
                    LOG.debug("HTTP response received.");
                    int statusCode = response.getStatusLine().getStatusCode();
                    try {
                        checkHTTPStatusCode(statusCode);
                    } catch (PAOSConnectionException ex) {
                        // response with error. So check the status of our last response to the eID-Server
                        if (lastResponse != null) {
                            WSHelper.checkResult(lastResponse);
                        }
                        throw ex;
                    }
                    conn.receiveResponseEntity(response);
                    HttpEntity entity = response.getEntity();
                    byte[] entityData = FileUtils.toByteArray(entity.getContent());
                    HttpUtils.dumpHttpResponse(LOG, response, entityData);
                    // consume entity
                    Object requestObj = processPAOSRequest(new ByteArrayInputStream(entityData));
                    // break when message is startpaosresponse
                    if (requestObj instanceof StartPAOSResponse) {
                        StartPAOSResponse startPAOSResponse = (StartPAOSResponse) requestObj;
                        // an ok.
                        if (lastResponse != null) {
                            WSHelper.checkResult(lastResponse);
                        }
                        WSHelper.checkResult(startPAOSResponse);
                        return startPAOSResponse;
                    }
                    // send via dispatcher
                    msg = dispatcher.deliver(requestObj);
                    // check if connection can be used one more time
                    isReusable = reuse.keepAlive(response, ctx);
                    connectionDropped = false;
                } while (isReusable);
            } catch (IOException ex) {
                if (!connectionDropped) {
                    connectionDropped = true;
                    LOG.warn("PAOS server closed the connection. Trying to connect again.");
                } else {
                    String errMsg = "Error in the link to the PAOS server.";
                    LOG.error(errMsg);
                    throw new PAOSException(DELIVERY_FAILED, ex);
                }
            }
        }
    } catch (HttpException ex) {
        throw new PAOSException(DELIVERY_FAILED, ex);
    } catch (SOAPException ex) {
        throw new PAOSException(SOAP_MESSAGE_FAILURE, ex);
    } catch (MarshallingTypeException ex) {
        throw new PAOSDispatcherException(MARSHALLING_ERROR, ex);
    } catch (InvocationTargetException ex) {
        throw new PAOSDispatcherException(DISPATCHER_ERROR, ex);
    } catch (TransformerException ex) {
        throw new DispatcherException(ex);
    } catch (WSException ex) {
        throw new PAOSException(ex);
    } finally {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (IOException ex) {
        // throw new PAOSException(ex);
        }
    }
}

Example 3 with StringEntity

use of org.openecard.apache.http.entity.StringEntity in project open-ecard by ecsec.

the class ErrorResponseInterceptor method process.

@Override
public void process(HttpResponse httpResponse, HttpContext httpContext) throws HttpException, IOException {
    StatusLine statusLine = httpResponse.getStatusLine();
    int statusCode = statusLine.getStatusCode();
    if (errorCodes.contains(statusCode)) {
        LOG.debug("HTTP response intercepted");
        Header contentType = httpResponse.getFirstHeader(HeaderTypes.CONTENT_TYPE.fieldName());
        if (contentType != null) {
            // Intercept response with the content type "text/plain"
            if (contentType.getValue().contains(MimeType.TEXT_PLAIN.getMimeType())) {
                // Remove old headers
                httpResponse.removeHeaders(HeaderTypes.CONTENT_TYPE.fieldName());
                httpResponse.removeHeaders(HeaderTypes.CONTENT_LENGTH.fieldName());
                // Read message body
                String content = readEntity(httpResponse.getEntity());
                // escape string to prevent script content to be injected into the template (XSS)
                content = HTMLUtils.escapeHtml(content);
                template.setProperty("%%%MESSAGE%%%", content);
            }
        } else {
            template.setProperty("%%%MESSAGE%%%", lang.translationForKey("http." + statusCode));
        }
        template.setProperty("%%%TITLE%%%", "Error");
        String reason = statusLine.getReasonPhrase();
        template.setProperty("%%%HEADLINE%%%", reason);
        // Add new content
        httpResponse.setEntity(new StringEntity(template.toString(), "UTF-8"));
        httpResponse.addHeader(HeaderTypes.CONTENT_TYPE.fieldName(), MimeType.TEXT_HTML.getMimeType() + "; charset=utf-8");
        httpResponse.addHeader(HeaderTypes.CONTENT_LENGTH.fieldName(), String.valueOf(template.getBytes().length));
    }
}

Example 4 with StringEntity

use of org.openecard.apache.http.entity.StringEntity in project open-ecard by ecsec.

the class ControlCommonHandler method handle.

/**
 * Handles a HTTP request.
 *
 * @param request HttpRequest
 * @param response HttpResponse
 * @param context HttpContext
 * @throws HttpException
 * @throws IOException
 */
@Override
public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException {
    _logger.debug("HTTP request: {}", request.toString());
    HttpResponse httpResponse = null;
    try {
        // Forward request parameters to response parameters
        response.setParams(request.getParams());
        httpResponse = handle(request);
    } catch (org.openecard.control.binding.http.HttpException e) {
        httpResponse = new Http11Response(HttpStatus.SC_BAD_REQUEST);
        httpResponse.setEntity(new StringEntity(e.getMessage(), "UTF-8"));
        if (e.getMessage() != null && !e.getMessage().isEmpty()) {
            httpResponse.setEntity(new StringEntity(e.getMessage(), "UTF-8"));
        }
        httpResponse.setStatusCode(e.getHTTPStatusCode());
    } catch (Exception e) {
        httpResponse = new Http11Response(HttpStatus.SC_INTERNAL_SERVER_ERROR);
        _logger.error(e.getMessage(), e);
    } finally {
        Http11Response.copyHttpResponse(httpResponse, response);
        _logger.debug("HTTP response: {}", response);
        _logger.debug("HTTP request handled by: {}", this.getClass().getName());
    }
}

Example 5 with StringEntity

use of org.openecard.apache.http.entity.StringEntity in project open-ecard by ecsec.

the class ChipGateway method sendMessage.

private <T> T sendMessage(String resource, String msg, Class<T> resClass, boolean tryAgain) throws ConnectionError, InvalidRedirectUrlException, ChipGatewayDataError {
    try {
        // open initial connection
        if (conn == null || !canReuse || (!conn.isOpen() && canReuse)) {
            openHttpStream();
        }
        // prepare request
        BasicHttpEntityEnclosingRequest req = new BasicHttpEntityEnclosingRequest("POST", resource);
        HttpRequestHelper.setDefaultHeader(req, tlsHandler.getServerAddress());
        req.setHeader("Accept", "application/json");
        ContentType reqContentType = ContentType.create("application/json", "UTF-8");
        if (LOG_HTTP_MESSAGES) {
            HttpUtils.dumpHttpRequest(LOG, "before adding content", req);
        }
        StringEntity reqMsg = new StringEntity(msg, reqContentType);
        req.setEntity(reqMsg);
        req.setHeader(reqMsg.getContentType());
        req.setHeader("Content-Length", Long.toString(reqMsg.getContentLength()));
        if (LOG_HTTP_MESSAGES) {
            LOG.debug(msg);
        }
        // send request and receive response
        LOG.debug("Sending HTTP request.");
        HttpResponse response = httpExecutor.execute(req, conn, httpCtx);
        canReuse = reuseStrategy.keepAlive(response, httpCtx);
        LOG.debug("HTTP response received.");
        int statusCode = response.getStatusLine().getStatusCode();
        checkHTTPStatusCode(statusCode);
        conn.receiveResponseEntity(response);
        HttpEntity entity = response.getEntity();
        byte[] entityData = FileUtils.toByteArray(entity.getContent());
        if (LOG_HTTP_MESSAGES) {
            HttpUtils.dumpHttpResponse(LOG, response, entityData);
        }
        // convert entity and return it
        T resultObj = parseResultObj(entityData, resClass);
        return resultObj;
    } catch (IOException ex) {
        if (!Thread.currentThread().isInterrupted() && tryAgain) {
            String errorMsg = "ChipGateway server closed the connection. Trying to connect again.";
            if (LOG.isDebugEnabled()) {
                LOG.debug(errorMsg, ex);
            } else {
                LOG.info(errorMsg);
            }
            canReuse = false;
            return sendMessage(resource, msg, resClass, false);
        } else {
            throw new ConnectionError(token.finalizeErrorAddress(ResultMinor.COMMUNICATION_ERROR), CONNECTION_OPEN_FAILED, ex);
        }
    } catch (HttpException ex) {
        throw new ConnectionError(token.finalizeErrorAddress(ResultMinor.SERVER_ERROR), HTTP_ERROR, ex);
    }
}