/// <summary>
/// 发送html邮件
/// </summary>
/// <exception cref="MessagingException"> </exception>
/// <exception cref="AddressException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void sendHtmlMail(String from, String[] to, String title, String text) throws javax.mail.internet.AddressException, javax.mail.MessagingException
public virtual void sendHtmlMail(string from, string[] to, string title, string text)
{
long start = DateTimeHelperClass.CurrentUnixTimeMillis();
MimeMessage mimeMessage = mailSender.createMimeMessage();
MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage, true, "GBK");
InternetAddress[] toArray = new InternetAddress[to.Length];
for (int i = 0; i < to.Length; i++)
{
toArray[i] = new InternetAddress(to[i]);
}
messageHelper.From = new InternetAddress(from);
messageHelper.To = toArray;
messageHelper.Subject = title;
messageHelper.setText(text, true);
mimeMessage = messageHelper.MimeMessage;
mailSender.send(mimeMessage);
long end = DateTimeHelperClass.CurrentUnixTimeMillis();
LOG.info("send mail start:" + start + " end :" + end);
}
protected ITransmissionResponse HandleResponse(HttpResponse httpResponse)
{
Trace span = this.root.Child();
// tracer.newChild(root.context()).name("response").start();
span.Record(Annotations.ServiceName("response"));
span.Record(Annotations.ClientSend());
try
{
HttpResponse response = httpResponse;
span.Record(Annotations.Tag("code", response.StatusCode.ToString()));
// span.tag("code", String.valueOf(response.getStatusLine().getStatusCode()));
if (response.StatusCode != HttpStatusCode.OK)
{
Logger.ErrorFormat(
"AS2 HTTP POST expected HTTP OK, but got : {0} from {1}",
response.StatusCode,
this.transmissionRequest.GetEndpoint().Address);
// Throws exception
this.HandleFailedRequest(response);
}
// handle normal HTTP OK response
Logger.DebugFormat(
"AS2 transmission to {0} returned HTTP OK, verify MDN response",
this.transmissionRequest.GetEndpoint().Address);
string contentTypeHeader = response.Headers["Content-Type"];
if (string.IsNullOrWhiteSpace(contentTypeHeader))
{
throw new HyperwayTransmissionException(
"No Content-Type header in response, probably a server error.");
}
// Read MIME Message
MimeMessage mimeMessage;
using (var m = new MemoryStream())
{
// Add headers to MIME Message
foreach (var headerName in response.Headers.AllKeys)
{
var headerText = $"{headerName}: {response.Headers[headerName]}";
var headerData = Encoding.ASCII.GetBytes(headerText);
m.Write(headerData, 0, headerData.Length);
m.Write(new byte[] { 13, 10 }, 0, 2);
}
m.Write(new byte[] { 13, 10 }, 0, 2);
var messageData = response.Entity.Content;
m.Write(messageData, 0, messageData.Length);
m.Seek(0, SeekOrigin.Begin);
mimeMessage = MimeMessage.Load(m);
mimeMessage.Headers[HeaderId.ContentType] = response.Headers["Content-Type"];
}
SMimeReader sMimeReader = new SMimeReader(mimeMessage);
// Timestamp of reception of MDN
Timestamp t3 = this.timestampProvider.Generate(sMimeReader.GetSignature(), Direction.OUT);
MultipartSigned signedMessage = mimeMessage.Body as MultipartSigned;
using (this.secureMimeContext())
{
Debug.Assert(signedMessage != null, nameof(signedMessage) + " != null");
var signatures = signedMessage.Verify();
var signature = signatures.First();
var mimeCertificate = signature.SignerCertificate as SecureMimeDigitalCertificate;
// Verify if the certificate used by the receiving Access Point in
// the response message does not match its certificate published by the SMP
Debug.Assert(mimeCertificate != null, nameof(mimeCertificate) + " != null");
X509Certificate certificate = mimeCertificate.Certificate;
if (!this.transmissionRequest.GetEndpoint().Certificate.Equals(certificate))
{
throw new HyperwayTransmissionException(
String.Format(
"Certificate in MDN ('{0}') does not match certificate from SMP ('{1}').",
certificate.SubjectDN, // .getSubjectX500Principal().getName(),
this.transmissionRequest.GetEndpoint().Certificate.SubjectDN)); // .getSubjectX500Principal().getName()));
}
Logger.Debug("MDN signature was verified for : " + certificate.SubjectDN);
}
// Verifies the actual MDN
MdnMimeMessageInspector mdnMimeMessageInspector = new MdnMimeMessageInspector(mimeMessage);
String msg = mdnMimeMessageInspector.GetPlainTextPartAsText();
if (!mdnMimeMessageInspector.IsOkOrWarning(new Mic(this.outboundMic)))
{
Logger.ErrorFormat("AS2 transmission failed with some error message '{0}'.", msg);
throw new HyperwayTransmissionException(String.Format("AS2 transmission failed : {0}", msg));
}
// Read structured content
MimeEntity mimeBodyPart = mdnMimeMessageInspector.GetMessageDispositionNotificationPart();
var internetHeaders = mimeBodyPart.Headers;
// InternetHeaders internetHeaders = new InternetHeaders((InputStream)mimeBodyPart.getContent());
// Fetch timestamp if set
DateTime date = t3.GetDate();
if (internetHeaders.Any(x => x.Field == MdnHeader.Date))
{
var dateText = internetHeaders.First(x => x.Field == MdnHeader.Date).Value;
date = As2DateUtil.Rfc822.Parse(dateText);
}
// Return TransmissionResponse
return(new As2TransmissionResponse(
this.transmissionIdentifier,
this.transmissionRequest,
this.outboundMic,
MimeMessageHelper.ToBytes(mimeMessage),
t3,
date));
}
catch (TimestampException e)
{
throw new HyperwayTransmissionException(e.Message, e);
}
catch (Exception e)
{
throw new HyperwayTransmissionException("Unable to parse received content.", e);
}
finally
{
span.Record(Annotations.ClientRecv());
}
}
protected HttpPost PrepareHttpRequest()
{
Trace span = this.root.Child();
span.Record(Annotations.ServiceName("request"));
span.Record(Annotations.ClientSend());
try
{
HttpPost httpPost;
// Create the body part of the MIME message containing our content to be transmitted.
MimeEntity mimeBodyPart = MimeMessageHelper.CreateMimeBodyPart(
this.transmissionRequest.GetPayload(),
"application/xml");
// Digest method to use.
SMimeDigestMethod digestMethod =
SMimeDigestMethod.FindByTransportProfile(
this.transmissionRequest.GetEndpoint().TransportProfile);
// Create a complete S/MIME message using the body part containing our content as the
// signed part of the S/MIME message.
MimeMessage signedMimeMessage =
this.sMimeMessageFactory.CreateSignedMimeMessage(mimeBodyPart, digestMethod);
var signedMultipart = (signedMimeMessage.Body as MultipartSigned);
Debug.Assert(signedMultipart != null, nameof(signedMultipart) + " != null");
this.outboundMic = MimeMessageHelper.CalculateMic(signedMultipart[0], digestMethod);
span.Record(Annotations.Tag("mic", this.outboundMic.ToString()));
span.Record(Annotations.Tag("endpoint url", this.transmissionRequest.GetEndpoint().Address.ToString()));
// Initiate POST request
httpPost = new HttpPost(this.transmissionRequest.GetEndpoint().Address);
foreach (var header in signedMimeMessage.Headers)
{
span.Record(Annotations.Tag(header.Field, header.Value));
httpPost.AddHeader(header.Field, header.Value.Replace("\r\n\t", string.Empty));
}
signedMimeMessage.Headers.Clear();
this.transmissionIdentifier = TransmissionIdentifier.FromHeader(httpPost.Headers[As2Header.MessageId]);
// Write content to OutputStream without headers.
using (var m = new MemoryStream())
{
signedMultipart.WriteTo(m);
httpPost.Entity = m.ToBuffer();
}
var contentType = signedMultipart.Headers[HeaderId.ContentType];
// Set all headers specific to AS2 (not MIME).
httpPost.Host = "skynet.sediva.it";
httpPost.Headers.Add("Content-Type", this.NormalizeHeaderValue(contentType));
httpPost.Headers.Add(As2Header.As2From, this.fromIdentifier);
httpPost.Headers.Add(
As2Header.As2To,
CertificateUtils.ExtractCommonName(this.transmissionRequest.GetEndpoint().Certificate));
httpPost.Headers.Add(As2Header.DispositionNotificationTo, "*****@*****.**");
httpPost.Headers.Add(
As2Header.DispositionNotificationOptions,
As2DispositionNotificationOptions.GetDefault(digestMethod).ToString());
httpPost.Headers.Add(As2Header.As2Version, As2Header.Version);
httpPost.Headers.Add(As2Header.Subject, "AS2 message from HYPERWAY");
httpPost.Headers.Add(As2Header.Date, As2DateUtil.Rfc822.GetFormat(DateTime.Now));
return(httpPost);
}
catch (Exception)
{
throw new HyperwayTransmissionException(
"Unable to stream S/MIME message into byte array output stream");
}
finally
{
span.Record(Annotations.ClientRecv());
}
}
public void DoPost()
{
var headers = this.httpContext.Request.Headers;
var messageId = headers["message-id"];
if (string.IsNullOrWhiteSpace(messageId))
{
var errorResult = new ContentResult();
errorResult.StatusCode = StatusCodes.Status400BadRequest;
errorResult.Content = "Header field 'Message-ID' not found.";
throw new NotSupportedException("error management");
// return errorResult;
}
Trace root = Trace.Create();
root.Record(Annotations.ServiceName("as2servlet.post"));
root.Record(Annotations.ServerRecv());
root.Record(Annotations.Tag("message-id", messageId));
Logger.Debug("Receiving HTTP POST request");
try
{
// Read MIME message
var bodyStream = this.httpContext.Request.Body;
var bodyData = bodyStream.ToBuffer();
MimeMessage mimeMessage =
MimeMessageHelper.CreateMimeMessageAssistedByHeaders(bodyData.ToStream(), headers);
try
{
Trace span = root.Child();
span.Record(Annotations.ServiceName("as2message"));
span.Record(Annotations.ServerRecv());
MimeMessage mdn = this.inboundHandlerProvider().Receive(headers, mimeMessage);
span.Record(Annotations.ServerSend());
span = root.Child();
span.Record(Annotations.ServiceName("mdn"));
span.Record(Annotations.ServerRecv());
this.WriteMdn(this.httpContext.Response, mdn, (int)HttpStatusCode.OK);
span.Record(Annotations.ServerSend());
}
catch (HyperwayAs2InboundException e)
{
String identifier = Guid.NewGuid().ToString();
Logger.ErrorFormat("Error [{0}] {1}", identifier, e);
// Open message for reading
SMimeReader sMimeReader = new SMimeReader(mimeMessage);
// Begin builder
MdnBuilder mdnBuilder = MdnBuilder.NewInstance(mimeMessage);
// Original Message-Id
mdnBuilder.AddHeader(MdnHeader.OriginalMessageId, headers[As2Header.MessageId]);
// Disposition from exception
mdnBuilder.AddHeader(MdnHeader.Disposition, e.Disposition);
mdnBuilder.AddText(String.Format("Error [{0}]", identifier), e.Message);
// Build and add headers
MimeMessage mdn = this.sMimeMessageFactory.CreateSignedMimeMessage(
mdnBuilder.Build(),
sMimeReader.GetDigestMethod());
mdn.Headers.Add(As2Header.As2Version, As2Header.Version);
mdn.Headers.Add(As2Header.As2From, headers[As2Header.As2To]);
mdn.Headers.Add(As2Header.As2To, headers[As2Header.As2From]);
this.WriteMdn(this.httpContext.Response, mdn, (int)HttpStatusCode.BadRequest);
}
}
catch (Exception e)
{
root.Record(Annotations.Tag("exception", e.Message));
// Unexpected internal error, cannot proceed, return HTTP 500 and partly MDN to indicating the problem
Logger.ErrorFormat("Internal error occured: {0}", e.Message);
Logger.Error("Attempting to return MDN with explanatory message and HTTP 500 status");
// TODO: manage failure
this.WriteFailureWithExplanation(this.httpContext.Request, this.httpContext.Response, e);
}
// MDC.clear();
root.Record(Annotations.ServerSend());
}
