javax.mail.Header Java Examples

public String toString() {
    StringBuffer buf = new StringBuffer();
    buf.append("MDN From:").append(getPartnership().getReceiverIDs());
    buf.append("To:").append(getPartnership().getSenderIDs());

    Enumeration<Header> headerEn = getHeaders().getAllHeaders();
    buf.append(System.getProperty("line.separator") + "Headers:{");

    while (headerEn.hasMoreElements()) {
        Header header = headerEn.nextElement();
        buf.append(header.getName()).append("=").append(header.getValue());

        if (headerEn.hasMoreElements()) {
            buf.append(", ");
        }
    }

    buf.append("}");
    buf.append(System.getProperty("line.separator") + "Attributes:").append(getAttributes());
    buf.append(System.getProperty("line.separator") + "Text: " + System.getProperty("line.separator"));
    buf.append(getText()).append(System.getProperty("line.separator"));

    return buf.toString();
}
 

/**
 * Parses metadata stored in a Debian Control File-like format.
 *
 * @see <a href="https://cran.r-project.org/doc/manuals/r-release/R-exts.html#The-DESCRIPTION-file">Description File</a>
 */
public static Map<String, String> parseDescriptionFile(final InputStream in) {
  checkNotNull(in);
  try {
    LinkedHashMap<String, String> results = new LinkedHashMap<>();
    InternetHeaders headers = new InternetHeaders(in);
    Enumeration headerEnumeration = headers.getAllHeaders();
    while (headerEnumeration.hasMoreElements()) {
      Header header = (Header) headerEnumeration.nextElement();
      String name = header.getName();
      String value = header.getValue()
          .replace("\r\n", "\n")
          .replace("\r", "\n"); // TODO: "should" be ASCII only, otherwise need to know encoding?
      results.put(name, value); // TODO: Supposedly no duplicates, is this true?
    }
    return results;
  } catch (MessagingException e) {
    throw new RException(null, e);
  }
}
 

@Override
public Collection<MailAddress> match(Mail mail) throws javax.mail.MessagingException {
    MimeMessage mm = mail.getMessage();
    int count = 0;
    for (Enumeration<Header> e = mm.getAllHeaders(); e.hasMoreElements();) {
        Header hdr = e.nextElement();
        if (hdr.getName().equals(RFC2822Headers.RECEIVED)) {
            count++;
        }
    }
    if (count >= limit) {
        return mail.getRecipients();
    } else {
        return null;
    }
}
 

@SuppressWarnings( "unchecked")
@PublicAtsApi
public List<PackageHeader> getAllHeaders() throws PackageException {

    try {
        List<PackageHeader> headers = new ArrayList<PackageHeader>();

        Enumeration<Header> messageHeaders = message.getAllHeaders();
        while (messageHeaders.hasMoreElements()) {
            Header messageHeader = messageHeaders.nextElement();
            headers.add(new PackageHeader(messageHeader.getName(), messageHeader.getValue()));
        }

        return headers;

    } catch (MessagingException me) {
        throw new PackageException(me);
    }
}
 

private String addHeadersTrace(
                                Enumeration<?> headers,
                                String level ) {

    final String level1 = level;
    final String level2 = "\t" + level1;
    final String prefix = getPrefixTrace(level1, "HEADERS START: ");

    StringBuilder headersString = new StringBuilder();

    boolean hasHeaders = headers.hasMoreElements();
    if (hasHeaders) {
        headersString.append(level1 + "HEADERS START:\n");
        while (headers.hasMoreElements()) {
            Header header = (Header) headers.nextElement();
            headersString.append(level2 + header.getName() + ": "
                                 + normalizeNewLinesTrace(prefix, header.getValue()) + "\n");
        }
        headersString.append(level1 + "HEADERS END:\n");
    }

    return headersString.toString();
}
 

public void validateCustomHeaders(final Email email, final MimeMessage sentMessage)
        throws MessagingException, IOException {
    Map<String, String> customHeaders = email.getCustomHeaders();
    List<Header> internetHeaders = (List<Header>) Collections.list(sentMessage.getAllHeaders());
    List<String> headerKeys = internetHeaders.stream().map(Header::getName).collect(toList());

    assertions.assertThat(headerKeys)
            .as("Should contains all the headers keys provided at construction time")
            .containsAll(customHeaders.keySet());

    customHeaders.entrySet().stream()
            .forEach(entry -> {
                try {
                    assertions.assertThat(sentMessage.getHeader(entry.getKey())).isNotNull().containsExactly(entry.getValue());
                } catch (MessagingException e) {
                }
            });
}
 

protected MessageHeaders getHeaders(MimeMessage message) throws MessagingException {

        Map<String, String> headerMap = new HashMap<>();

        // oh wow 2015 and it's untyped and uses Enumeration
        Enumeration allHeaders = message.getAllHeaders();
        while (allHeaders.hasMoreElements()) {
            Header header = (Header) allHeaders.nextElement();
            String headerName = header.getName();
            String headerVal = header.getValue();

            headerMap.put(headerName, headerVal);

        }

        return new MessageHeaders(headerMap);
    }
 

@Override
public List<String> getHeaderNames() throws SieveMailException {
    Set<String> headerNames = new HashSet<>();
    try {
        Enumeration<Header> allHeaders = getMessage().getAllHeaders();
        while (allHeaders.hasMoreElements()) {
            headerNames.add(allHeaders.nextElement().getName());
        }
        return new ArrayList<>(headerNames);
    } catch (MessagingException ex) {
        throw new SieveMailException(ex);
    }
}
 

private static String formatHeader( Message thisMessage ) throws Exception {
	Enumeration<Header> E	= thisMessage.getAllHeaders();
	StringBuilder	tmp	= new StringBuilder(128);
	while (E.hasMoreElements()){
		Header hdr = E.nextElement();
		tmp.append( hdr.getName() );
		tmp.append( ": " );
		tmp.append( hdr.getValue() );
		tmp.append( "\r\n" );
	}
	
	return tmp.toString();
}
 

@Override
public boolean test(Part input) {
	try {
		// @formatter:off
		return list(input.getMatchingHeaders(new String[] { "Content-ID" }))
				.stream()
				.map(Header::getValue)
				.anyMatch(contentId::equals);
		// @formatter:on
	} catch (MessagingException e) {
		throw new AssertionError("Failed to access message", e);
	}
}
 

private void clearAllHeaders(MimeMessage message) throws javax.mail.MessagingException {
    Enumeration<Header> headers = message.getAllHeaders();

    while (headers.hasMoreElements()) {
        Header header = headers.nextElement();
        try {
            message.removeHeader(header.getName());
        } catch (javax.mail.MessagingException me) {
            LOGGER.error("Cannot remove header.", me);
        }
    }
    message.saveChanges();
}
 

private List<String> headerNamesStartingByPrefix(Mail mail) throws MessagingException {
    ImmutableList.Builder<String> headerToRemove = ImmutableList.builder();
    List<Header> headers = new MimeMessageUtils(mail.getMessage()).toHeaderList();
    for (Header header: headers) {
        if (header.getName().startsWith(prefix)) {
            headerToRemove.add(header.getName());
        }
    }
    return headerToRemove.build();
}
 

public List<Header> toHeaderList() throws MessagingException {
    ImmutableList.Builder<Header> headers = ImmutableList.builder();
    Enumeration<Header> allHeaders = message.getAllHeaders();
    while (allHeaders.hasMoreElements()) {
        headers.add(allHeaders.nextElement());
    }
    return headers.build();
}
 

@Override
public Collection<MailAddress> match(Mail mail) throws MessagingException {
    List<Header> headers = new MimeMessageUtils(mail.getMessage()).toHeaderList();

    for (Header header: headers) {
        if (header.getName().startsWith(prefix)) {
            return mail.getRecipients();
        }
    }

    return matchSpecific(mail);
}
 

private void prependHeader(MimeMessage message, String signatureHeader)
        throws MessagingException {
    List<String> prevHeader = Collections.list(message.getAllHeaderLines());
    Collections.list(message.getAllHeaders())
        .stream()
        .map(Header::getName)
        .forEach(Throwing.consumer(message::removeHeader).sneakyThrow());

    message.addHeaderLine(signatureHeader);
    prevHeader
        .forEach(Throwing.consumer(message::addHeaderLine).sneakyThrow());
}
 

private void copyRelevantHeaders(MimeMessage originalMessage, MimeMessage newMessage) throws MessagingException {
    Enumeration<Header> headerEnum = originalMessage.getMatchingHeaders(
            new String[] { RFC2822Headers.DATE, RFC2822Headers.FROM, RFC2822Headers.REPLY_TO, RFC2822Headers.TO, 
                    RFC2822Headers.SUBJECT, RFC2822Headers.RETURN_PATH });
    while (headerEnum.hasMoreElements()) {
        Header header = headerEnum.nextElement();
        newMessage.addHeader(header.getName(), header.getValue());
    }
}
 

private static CompositeData convert(MessageAndAddresses maa) {
    if (maa == null) {
        return null;
    }
    try {
        TabularData addrData = new TabularDataSupport(TAB_ADDR_TYPE);
        for(Address addr : maa.getAddresses()) {
            addrData.put(new CompositeDataSupport(ROW_ADDR_TYPE, new String[]{"addressType", "address"}, new Object[]{addr.getType(), addr.toString()}));
        }
        TabularData headerData = new TabularDataSupport(TAB_HEADER_TYPE);
        Enumeration en = maa.getMessage().getAllHeaders();
        while (en.hasMoreElements()) {
            Header header = (Header) en.nextElement();
            headerData.put(new CompositeDataSupport(ROW_HEADER_TYPE, new String[]{"header-name", "header-value"}, new Object[]{header.getName(), header.getValue()}));
        }
        String error = null;
        if (maa.getException() != null) {
            StringWriter sw = new StringWriter();
            sw.append(maa.getException().toString());
            maa.getException().printStackTrace(new PrintWriter(sw));
            sw.flush();
            error = sw.toString();
        }
        return new CompositeDataSupport(MAIL_INFO_TYPE,
                new String[] {"messageId", "date", "subject", "toAddresses", "headers", "errorDescription"},
                new Object[]{maa.getMessage().getMessageID(), new Date(maa.getTimestamp()), maa.getMessage().getSubject(), addrData, headerData, error}
        );
    } catch (OpenDataException | MessagingException e) {
        throw new IllegalArgumentException("cannot convert MessageAndAddresses to CompositeData", e);
    }
}
 

@VisibleForTesting
void processTextBodyAsAttachment(MimeMessage mimeMessage) throws MessagingException {
    List<Header> contentHeaders = getContentHeadersFromMimeMessage(mimeMessage);

    removeAllContentHeaderFromMimeMessage(mimeMessage, contentHeaders);

    Multipart multipart = new MimeMultipart();
    multipart.addBodyPart(createMimeBodyPartWithContentHeadersFromMimeMessage(mimeMessage, contentHeaders));

    mimeMessage.setContent(multipart);
    mimeMessage.saveChanges();
}
 

public static MimeMessageWrapper wrap(MimeMessage mimeMessage) throws MessagingException {
    try {
        return new MimeMessageWrapper(mimeMessage);
    } catch (MessagingException e) {
        // Copying a mime message fails when the body is empty
        // Copying manually the headers is the best alternative...

        MimeMessageWrapper result = new MimeMessageWrapper();
        ThrowingConsumer<Header> consumer = header -> result.addHeader(header.getName(), header.getValue());
        Collections.list(mimeMessage.getAllHeaders())
            .forEach(Throwing.consumer(consumer).sneakyThrow());
        result.setText(""); // Avoid future body reads to fail
        return result;
    }
}
 

private MimeBodyPart createMimeBodyPartWithContentHeadersFromMimeMessage(MimeMessage mimeMessage, List<Header> contentHeaders) throws MessagingException {
    MimeBodyPart fileBody = new MimeBodyPart(mimeMessage.getRawInputStream());
    for (Header header : contentHeaders) {
        fileBody.setHeader(header.getName(), header.getValue());
    }

    fileBody.setDisposition(Part.ATTACHMENT);
    return fileBody;
}
 

private static Optional<ImmutableMap<String, HeadersDto>> fetchPerRecipientsHeaders(Set<AdditionalField> additionalFields, Mail mail) {
    if (!additionalFields.contains(AdditionalField.PER_RECIPIENTS_HEADERS)) {
        return Optional.empty();
    }
    Multimap<MailAddress, PerRecipientHeaders.Header> headersByRecipient = mail
            .getPerRecipientSpecificHeaders()
            .getHeadersByRecipient();

    return Optional.of(headersByRecipient
        .keySet()
        .stream()
        .collect(Guavate.toImmutableMap(MailAddress::asString, (address) -> fetchPerRecipientHeader(headersByRecipient, address))));
}
 

private static HeadersDto fetchPerRecipientHeader(
        Multimap<MailAddress, PerRecipientHeaders.Header> headersByRecipient,
        MailAddress address) {
    return new HeadersDto(headersByRecipient.get(address)
        .stream()
        .collect(Guavate.toImmutableListMultimap(PerRecipientHeaders.Header::getName, PerRecipientHeaders.Header::getValue)));
}
 

@Override
public Enumeration<Header> getAllHeaders() throws MessagingException {
    if (headers == null) {
        loadHeaders();
    }
    return headers.getAllHeaders();
}
 

@Override
public Enumeration<Header> getMatchingHeaders(String[] names) throws MessagingException {
    if (headers == null) {
        loadHeaders();
    }
    return headers.getMatchingHeaders(names);
}
 

@Override
public Enumeration<Header> getNonMatchingHeaders(String[] names) throws MessagingException {
    if (headers == null) {
        loadHeaders();
    }
    return headers.getNonMatchingHeaders(names);
}
 

public static String printHeaders(Enumeration<Header> hdrs, String nameValueSeparator, String valuePairSeparator) {
    String headers = "";
    while (hdrs.hasMoreElements()) {
        Header h = hdrs.nextElement();
        headers = headers + valuePairSeparator + h.getName() + nameValueSeparator + h.getValue();
    }

    return (headers);

}
 

private static RequestBuilder getRequestBuilder(String method, URL urlObj, NameValuePair[] params, Enumeration<Header> headers) throws URISyntaxException {

        RequestBuilder req = null;
        if (method == null || method.equalsIgnoreCase(Method.GET)) {
            //default get
            req = RequestBuilder.get();
        } else if (method.equalsIgnoreCase(Method.POST)) {
            req = RequestBuilder.post();
        } else if (method.equalsIgnoreCase(Method.HEAD)) {
            req = RequestBuilder.head();
        } else if (method.equalsIgnoreCase(Method.PUT)) {
            req = RequestBuilder.put();
        } else if (method.equalsIgnoreCase(Method.DELETE)) {
            req = RequestBuilder.delete();
        } else if (method.equalsIgnoreCase(Method.TRACE)) {
            req = RequestBuilder.trace();
        } else {
            throw new IllegalArgumentException("Illegal HTTP Method: " + method);
        }
        req.setUri(urlObj.toURI());
        if (params != null && params.length > 0) {
            req.addParameters(params);
        }
        if (headers != null) {
            boolean removeHeaderFolding = "true".equals(Properties.getProperty(HTTP_PROP_REMOVE_HEADER_FOLDING, "true"));
            while (headers.hasMoreElements()) {
                Header header = headers.nextElement();
                String headerValue = header.getValue();
                if (removeHeaderFolding) {
                    headerValue = headerValue.replaceAll("\r\n[ \t]*", " ");
                }
                req.setHeader(header.getName(), headerValue);
            }
        }
        return req;
    }
 

@Before
public void setUp() throws Exception {
    javaMailJMSStatistics = new JavaMailJMSStatistics();
    javaMailJMSStatistics.registerInJMX();
    mimeMessage = Mockito.mock(MimeMessage.class);
    when(mimeMessage.getAllHeaders()).thenReturn(Collections.enumeration(Arrays.asList(new Header("h1", "v1"), new Header("h2", "v2"))));
    when(mimeMessage.getMessageID()).thenReturn("MessageId");
    when(mimeMessage.getSubject()).thenReturn("MessageSubject");
}
 

public void copyHeaders(InternetHeaders srcHeaders) {
    Enumeration<Header> headerEn = srcHeaders.getAllHeaders();
    while (headerEn.hasMoreElements()) {
        Header header = headerEn.nextElement();
        setHeader(header.getName(), header.getValue());
    }
}
 

public String toString() {
    StringBuffer buf = new StringBuffer();
    buf.append("Message From:").append(getPartnership().getSenderIDs());
    buf.append("To:").append(getPartnership().getReceiverIDs());

    Enumeration<Header> headerEn = getHeaders().getAllHeaders();
    buf.append(System.getProperty("line.separator") + "Headers:{");

    while (headerEn.hasMoreElements()) {
        Header header = headerEn.nextElement();
        buf.append(header.getName()).append("=").append(header.getValue());

        if (headerEn.hasMoreElements()) {
            buf.append(", ");
        }
    }

    buf.append("}");
    buf.append(System.getProperty("line.separator") + "Attributes:").append(getAttributes());

    MessageMDN mdn = getMDN();

    if (mdn != null) {
        buf.append(System.getProperty("line.separator") + "MDN:");
        buf.append(mdn.toString());
    }

    return buf.toString();
}