public MimeBodyPart(Body body, String mimeType) throws MessagingException {
mHeader = new MimeHeader();
if (mimeType != null) {
addHeader(MimeHeader.HEADER_CONTENT_TYPE, mimeType);
}
MimeMessageHelper.setBody(this, body);
}
private void writeFailureWithExplanation(
HttpServletResponse response, Exception e, MimeMessage mimeMessage, MdnData mdnData)
throws IOException {
try {
setHeadersForMDN(response, mdnData, mimeMessage);
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
mimeMessage.writeTo(response.getOutputStream());
log.error("Returned MDN with failure: " + MimeMessageHelper.toString(mimeMessage), e);
log.error(
"---------- REQUEST FAILURE INFORMATION ENDS HERE --------------"); // Being helpful to
// those who must read
// the error logs
} catch (MessagingException e1) {
String msg = "Unable to return failure to sender; " + e1.getMessage();
log.error(msg);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
response.getWriter().write(msg);
}
}
/**
* Receives the POST'ed AS2 message.
*
* <p>Important to note that the HTTP headers contains the MIME headers for the payload. Since the
* the request can only be read once, using getReader()/getInputStream()
*/
protected void doPost(final HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
/*
https://www.rfc-editor.org/rfc/rfc2311.txt section 3.4
There are two formats for signed messages defined for S/MIME:
application/pkcs7-mime and SignedData, and multipart/signed. In
general, the multipart/signed form is preferred for sending, and
receiving agents SHOULD be able to handle both.
Signing Using application/pkcs7-mime and SignedData
This signing format uses the application/pkcs7-mime MIME type. The
steps to create this format are:
Step 1. The MIME entity is prepared according to section 3.1
Step 2. The MIME entity and other required data is processed into a
PKCS #7 object of type signedData
Step 3. The PKCS #7 object is inserted into an
application/pkcs7-mime MIME entity
The smime-type parameter for messages using application/pkcs7-mime
and SignedData is "signed-data". The file extension for this type of
message is ".p7m".
Creating a multipart/signed Message
Step 1. The MIME entity to be signed is prepared according to
section 3.1, taking special care for clear-signing.
Step 2. The MIME entity is presented to PKCS #7 processing in order
to obtain an object of type signedData with an empty
contentInfo field.
Step 3. The MIME entity is inserted into the first part of a
multipart/signed message with no processing other than that
described in section 3.1.
Step 4. Transfer encoding is applied to the detached signature and
it is inserted into a MIME entity of type
application/pkcs7-signature
Step 5. The MIME entity of the application/pkcs7-signature is
inserted into the second part of the multipart/signed
entity
The multipart/signed Content type has two required parameters: the
protocol parameter and the micalg parameter.
The protocol parameter MUST be "application/pkcs7-signature". Note
that quotation marks are required around the protocol parameter
because MIME requires that the "/" character in the parameter value
MUST be quoted.
*/
InternetHeaders headers = copyHttpHeadersIntoMap(request);
// Receives the data, validates the headers, signature etc., invokes the persistence handler
// and finally returns the MdnData to be sent back to the caller
try {
// Performs the actual reception of the message by parsing the HTTP POST request
MdnData mdnData =
inboundMessageReceiver.receive(
headers,
request.getInputStream(),
messageRepository,
rawStatisticsRepository,
ourAccessPointIdentifier);
// Creates the S/MIME message to be returned to the sender
MimeMessage mimeMessage = mdnMimeMessageFactory.createMdn(mdnData, headers);
// Add MDN headers to http response
setHeadersForMDN(response, mdnData, mimeMessage);
response.setStatus(HttpServletResponse.SC_OK);
// Try to write the MDN mime message to http response
try {
mimeMessage.writeTo(response.getOutputStream());
response.getOutputStream().flush();
log.debug("Served request, status=OK:\n" + MimeMessageHelper.toString(mimeMessage));
log.debug("------------- INFO ON PROCESSED REQUEST ENDS HERE -----------");
} catch (MessagingException e) {
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
response.getWriter().write("Severe error during write of MDN " + e.getMessage());
}
} catch (ErrorWithMdnException e) {
// Reception of AS2 message failed, send back a MDN indicating failure (always use HTTP 200
// for MDN)
log.warn("AS2 reception error: " + e.getMessage(), e);
log.warn("Returning negative MDN with explanatory message");
MdnData mdnData = e.getMdnData();
MimeMessage mimeMessage = mdnMimeMessageFactory.createMdn(mdnData, headers);
writeMimeMessageWithNegativeMdn(response, e, mimeMessage, mdnData);
} catch (Exception e) {
// Unexpected internal error, cannot proceed, return HTTP 500 and partly MDN to indicating the
// problem
log.error("Internal error occured: " + e.getMessage(), e);
log.error("Attempting to return MDN with explanatory message and HTTP 500 status");
MdnData mdnData =
MdnData.Builder.buildProcessingErrorFromHeaders(headers, null, e.getMessage());
MimeMessage mimeMessage = mdnMimeMessageFactory.createMdn(mdnData, headers);
writeFailureWithExplanation(response, e, mimeMessage, mdnData);
}
}
MimeBodyPart(MimeHeader header, Body body) throws MessagingException {
mHeader = header;
MimeMessageHelper.setBody(this, body);
}
