/** * @param auth * @param msg * @param request * @throws Exception */ private void saveDraft(AuthProfile auth, MimeMessage msg, HttpServletRequest request) throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); msg.writeTo(bos); byte bMsg[] = bos.toByteArray(); // serialize the message byte array ObjectOutputStream os = new ObjectOutputStream(bos); os.writeObject(bMsg); // create an email db item MsgDbObject item = new MsgDbObject(); item.setEmail(bMsg); String md5Header = new String(MD5.getHashString(bMsg)).toUpperCase(new Locale("en", "US")); ConnectionMetaHandler handler = getConnectionHandler(request); ConnectionProfile profile = getConnectionProfile(request); FolderControllerFactory factory = new FolderControllerFactory(auth, profile, handler); FolderController foldCont = factory.getFolderController(); FolderDbObject fItem = foldCont.getDraftsFolder(); item.setUniqueId(md5Header); item.setFolderId(fItem.getId()); item.setUnread(new Boolean(false)); item.setUsername(auth.getUsername()); item.setMsgSize(new Long(bMsg.length)); // save the email db item. MailControllerFactory mailFact = new MailControllerFactory(auth, profile, handler, fItem.getFolderName()); MailController mailCont = mailFact.getMailController(); mailCont.appendEmail(item); }
public static void main(String args[]) throws Exception { // // create the generator for creating an smime/compressed message // SMIMECompressedGenerator gen = new SMIMECompressedGenerator(); // // create the base for our message // MimeBodyPart msg = new MimeBodyPart(); msg.setText("Hello world!"); MimeBodyPart mp = gen.generate(msg, new ZlibCompressor()); // // Get a Session object and create the mail message // Properties props = System.getProperties(); Session session = Session.getDefaultInstance(props, null); Address fromUser = new InternetAddress("\"Eric H. Echidna\"<*****@*****.**>"); Address toUser = new InternetAddress("*****@*****.**"); MimeMessage body = new MimeMessage(session); body.setFrom(fromUser); body.setRecipient(Message.RecipientType.TO, toUser); body.setSubject("example compressed message"); body.setContent(mp.getContent(), mp.getContentType()); body.saveChanges(); body.writeTo(new FileOutputStream("compressed.message")); }
@Override public final void pre_commit(boolean dirty) throws DataFault { /* All commits to this object forces a write back of the message * as it is hard to tell if the message has changed. * */ hash = -1; try { if (m != null) { // StreamData sd = new MessageStreamData(m); StreamData sd = new ByteArrayStreamData(); // can't call saveChanges on imported imap message if (auto_save) { m.saveChanges(); } m.writeTo(sd.getOutputStream()); // getLogger().debug("update value to "+sd); record.setProperty(MESSAGE, sd); m = null; // force re-read } } catch (Exception e) { getContext().error(e, "Error writing mail message"); } }
public void setMessage(MimeMessage message) { if (message != null) { // serialize the message this.message = message; ByteArrayOutputStream baos = new ByteArrayOutputStream(); try { message.writeTo(baos); baos.flush(); serializedBytes = baos.toByteArray(); this.contentType = message.getContentType(); // see if this is a multi-part message Object content = message.getContent(); if (content instanceof Multipart) { Multipart mp = (Multipart) content; this.parts = mp.getCount(); } else { this.parts = 0; } } catch (MessagingException e) { Debug.logError(e, module); } catch (IOException e) { Debug.logError(e, module); } finally { try { baos.close(); } catch (IOException e) { Debug.logError(e, module); } } } }
/** * Create a Message from an email * * @param email Email to be set to raw of message * @return Message containing base64 encoded email. * @throws IOException * @throws MessagingException */ private Message createMessageWithEmail(MimeMessage email) throws MessagingException, IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); email.writeTo(baos); String encodedEmail = Base64.encodeBase64URLSafeString(baos.toByteArray()); Message message = new Message(); message.setRaw(encodedEmail); return message; }
public OutputStream exportMessage(String username, String accountId, Message message) throws Exception { Properties props = System.getProperties(); Session session = Session.getDefaultInstance(props, null); MimeMessage mimeMessage = new MimeMessage(session); mimeMessage = Utils.mergeToMimeMessage(message, mimeMessage); OutputStream outputStream = new ByteArrayOutputStream(); mimeMessage.writeTo(outputStream); return outputStream; }
/** * Extracts an email from the queue and consumes the email. * * @return Text of the email * @throws MessagingException * @throws IOException */ protected String popEmail() throws MessagingException, IOException { List<WiserMessage> wiserMessageList = wiser.getMessages(); if (wiserMessageList.isEmpty()) { return null; } WiserMessage wiserMessage = wiserMessageList.get(wiserMessageList.size() - 1); wiserMessageList.remove(wiserMessageList.size() - 1); MimeMessage message = wiserMessage.getMimeMessage(); ByteArrayOutputStream os = new ByteArrayOutputStream(); message.writeTo(os); String body = os.toString(); return 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); } }
private void dump(MimeMessage m) throws MessagingException, IOException, FileNotFoundException { File file = new File(m.getMessageNumber() + ".eml"); // InputStream in = m.getInputStream(); // BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file)); // // byte[] buffer = new byte[32 * 1024]; // int bytesRead = 0; // while ((bytesRead = in.read(buffer)) != -1) { // out.write(buffer, 0, bytesRead); // } m.writeTo(out); // in.close(); out.close(); }
@Override public void marshal(Exchange exchange, Object graph, OutputStream stream) throws NoTypeConversionAvailableException, MessagingException, IOException { if (multipartWithoutAttachment || headersInline || exchange.getIn().hasAttachments()) { ContentType contentType = getContentType(exchange); // remove the Content-Type header. This will be wrong afterwards... exchange.getOut().removeHeader(Exchange.CONTENT_TYPE); byte[] bodyContent = ExchangeHelper.convertToMandatoryType(exchange, byte[].class, graph); Session session = Session.getInstance(System.getProperties()); MimeMessage mm = new MimeMessage(session); MimeMultipart mp = new MimeMultipart(multipartSubType); BodyPart part = new MimeBodyPart(); writeBodyPart(bodyContent, part, contentType); mp.addBodyPart(part); for (Map.Entry<String, Attachment> entry : exchange.getIn().getAttachmentObjects().entrySet()) { String attachmentFilename = entry.getKey(); Attachment attachment = entry.getValue(); part = new MimeBodyPart(); part.setDataHandler(attachment.getDataHandler()); part.setFileName(MimeUtility.encodeText(attachmentFilename, "UTF-8", null)); String ct = attachment.getDataHandler().getContentType(); contentType = new ContentType(ct); part.setHeader(CONTENT_TYPE, ct); if (!contentType.match("text/*") && binaryContent) { part.setHeader(CONTENT_TRANSFER_ENCODING, "binary"); } // Set headers to the attachment for (String headerName : attachment.getHeaderNames()) { List<String> values = attachment.getHeaderAsList(headerName); for (String value : values) { part.setHeader(headerName, value); } } mp.addBodyPart(part); exchange.getOut().removeAttachment(attachmentFilename); } mm.setContent(mp); // copy headers if required and if the content can be converted into // a String if (headersInline && includeHeaders != null) { for (Map.Entry<String, Object> entry : exchange.getIn().getHeaders().entrySet()) { if (includeHeaders.matcher(entry.getKey()).matches()) { String headerStr = ExchangeHelper.convertToType(exchange, String.class, entry.getValue()); if (headerStr != null) { mm.setHeader(entry.getKey(), headerStr); } } } } mm.saveChanges(); Enumeration<?> hl = mm.getAllHeaders(); List<String> headers = new ArrayList<String>(); if (!headersInline) { while (hl.hasMoreElements()) { Object ho = hl.nextElement(); if (ho instanceof Header) { Header h = (Header) ho; exchange.getOut().setHeader(h.getName(), h.getValue()); headers.add(h.getName()); } } mm.saveChanges(); } mm.writeTo(stream, headers.toArray(new String[0])); } else { // keep the original data InputStream is = ExchangeHelper.convertToMandatoryType(exchange, InputStream.class, graph); IOHelper.copyAndCloseInput(is, stream); } }
private String getContent(MimeMessage msg) throws Exception { ByteArrayOutputStream buf = new ByteArrayOutputStream(); msg.writeTo(buf); return new String(buf.toByteArray()); }
/** * 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); } }
// 测试生成邮件 public static void main(String[] args) throws Exception { WithAttachmentMessage mail = new WithAttachmentMessage(); Session session = Session.getDefaultInstance(new Properties()); MimeMessage message = mail.createMessage(session); message.writeTo(new FileOutputStream("withAttachmentMail.eml")); }