internetheaders.java

java Email you can use it to send email to others

    /**
     * Read and parse the given RFC822 message stream till the 
     * blank line separating the header from the body. The input 
     * stream is left positioned at the start of the body. The 
     * header lines are stored internally. <p>
     *
     * For efficiency, wrap a BufferedInputStream around the actual
     * input stream and pass it as the parameter. <p>
     *
     * No placeholder entries are inserted; the original order of
     * the headers is preserved.
     *
     * @param	is 	RFC822 input stream
     */
    public InternetHeaders(InputStream is) throws MessagingException {
   	headers = new ArrayList(40); 
	load(is);
    }

    /**
     * Read and parse the given RFC822 message stream till the
     * blank line separating the header from the body. Store the
     * header lines inside this InternetHeaders object. The order
     * of header lines is preserved. <p>
     *
     * Note that the header lines are added into this InternetHeaders
     * object, so any existing headers in this object will not be
     * affected.  Headers are added to the end of the existing list
     * of headers, in order.
     *
     * @param	is 	RFC822 input stream
     */
    public void load(InputStream is) throws MessagingException {
	// Read header lines until a blank line. It is valid
	// to have BodyParts with no header lines.
	String line;
	LineInputStream lis = new LineInputStream(is);
	String prevline = null;	// the previous header line, as a string
	// a buffer to accumulate the header in, when we know it's needed
	StringBuffer lineBuffer = new StringBuffer();

	try {
	    //while ((line = lis.readLine()) != null) {
	    do {
		line = lis.readLine();
		if (line != null &&
			(line.startsWith(" ") || line.startsWith("\t"))) {
		    // continuation of header
		    if (prevline != null) {
			lineBuffer.append(prevline);
			prevline = null;
		    }
		    lineBuffer.append("\r\n");
		    lineBuffer.append(line);
		} else {
		    // new header
		    if (prevline != null)
			addHeaderLine(prevline);
		    else if (lineBuffer.length() > 0) {
			// store previous header first
			addHeaderLine(lineBuffer.toString());
			lineBuffer.setLength(0);
		    }
		    prevline = line;
		}
	    } while (line != null && line.length() > 0);
	} catch (IOException ioex) {
	    throw new MessagingException("Error in input stream", ioex);
	}
    }

    /**
     * Return all the values for the specified header. The
     * values are String objects.  Returns <code>null</code>
     * if no headers with the specified name exist.
     *
     * @param	name 	header name
     * @return		array of header values, or null if none
     */
    public String[] getHeader(String name) {
	Iterator e = headers.iterator();
	// XXX - should we just step through in index order?
	List v = new ArrayList(); // accumulate return values

	while (e.hasNext()) {
	    InternetHeader h = (InternetHeader)e.next();
	    if (name.equalsIgnoreCase(h.getName()) && h.line != null) {
		v.add(h.getValue());
	    }
	}
	if (v.size() == 0)
	    return (null);
	// convert List to an array for return
	String r[] = new String[v.size()];
	r = (String[])v.toArray(r);
	return (r);
    }

    /**
     * Get all the headers for this header name, returned as a single
     * String, with headers separated by the delimiter. If the
     * delimiter is <code>null</code>, only the first header is 
     * returned.  Returns <code>null</code>
     * if no headers with the specified name exist.
     *
     * @param	name 		header name
     * @param   delimiter	delimiter
     * @return                  the value fields for all headers with
     *				this name, or null if none
     */
    public String getHeader(String name, String delimiter) {
	String s[] = getHeader(name);

	if (s == null)
	    return null;
	
	if ((s.length == 1) || delimiter == null)
	    return s[0];
	
	StringBuffer r = new StringBuffer(s[0]);
	for (int i = 1; i < s.length; i++) {
	    r.append(delimiter);
	    r.append(s[i]);
	}
	return r.toString();
    }

    /**
     * Change the first header line that matches name
     * to have value, adding a new header if no existing header
     * matches. Remove all matching headers but the first. <p>
     *
     * Note that RFC822 headers can only contain US-ASCII characters
     *
     * @param	name	header name
     * @param	value	header value
     */
    public void setHeader(String name, String value) {
	boolean found = false;

	for (int i = 0; i < headers.size(); i++) {
	    InternetHeader h = (InternetHeader)headers.get(i);
	    if (name.equalsIgnoreCase(h.getName())) {
		if (!found) {
		    int j;
		    if (h.line != null && (j = h.line.indexOf(':')) >= 0) {
			h.line = h.line.substring(0, j + 1) + " " + value;
			// preserves capitalization, spacing
		    } else {
			h.line = name + ": " + value;
		    }
		    found = true;
		} else {
		    headers.remove(i);
		    i--;    // have to look at i again
		}
	    }
	}
    
	if (!found) {
	    addHeader(name, value);
	}
    }

    /**
     * Add a header with the specified name and value to the header list. <p>
     *
     * The current implementation knows about the preferred order of most
     * well-known headers and will insert headers in that order.  In
     * addition, it knows that <code>Received</code> headers should be
     * inserted in reverse order (newest before oldest), and that they
     * should appear at the beginning of the headers, preceeded only by
     * a possible <code>Return-Path</code> header.  <p>
     *
     * Note that RFC822 headers can only contain US-ASCII characters.
     *
     * @param	name	header name
     * @param	value	header value
     */ 
    public void addHeader(String name, String value) {
	int pos = headers.size();
	boolean addReverse =
	    name.equalsIgnoreCase("Received") ||
	    name.equalsIgnoreCase("Return-Path");
	if (addReverse)
	    pos = 0;
	for (int i = headers.size() - 1; i >= 0; i--) {
	    InternetHeader h = (InternetHeader)headers.get(i);
	    if (name.equalsIgnoreCase(h.getName())) {
		if (addReverse) {
		    pos = i;
		} else {
		    headers.add(i + 1, new InternetHeader(name, value));
		    return;
		}
	    }
	    // marker for default place to add new headers
	    if (h.getName().equals(":"))
		pos = i;
	}
	headers.add(pos, new InternetHeader(name, value));
    }

    /**
     * Remove all header entries that match the given name
     * @param	name 	header name
     */
    public void removeHeader(String name) { 
	for (int i = 0; i < headers.size(); i++) {
	    InternetHeader h = (InternetHeader)headers.get(i);
	    if (name.equalsIgnoreCase(h.getName())) {
		h.line = null;
		//headers.remove(i);
		//i--;    // have to look at i again
	    }
	}
    }

    /**
     * Return all the headers as an Enumeration of
     * {@link javax.mail.Header} objects.
     *
     * @return	Header objects	
     */
    public Enumeration getAllHeaders() {
	return (new matchEnum(headers, null, false, false));
    }

    /**
     * Return all matching {@link javax.mail.Header} objects.
     *
     * @return	matching Header objects	
     */
    public Enumeration getMatchingHeaders(String[] names) {
	return (new matchEnum(headers, names, true, false));
    }

    /**
     * Return all non-matching {@link javax.mail.Header} objects.
     *
     * @return	non-matching Header objects	
     */
    public Enumeration getNonMatchingHeaders(String[] names) {
	return (new matchEnum(headers, names, false, false));
    }

    /**
     * Add an RFC822 header line to the header store.
     * If the line starts with a space or tab (a continuation line),
     * add it to the last header line in the list.  Otherwise,
     * append the new header line to the list.  <p>
     *
     * Note that RFC822 headers can only contain US-ASCII characters
     *
     * @param	line	raw RFC822 header line
     */
    public void addHeaderLine(String line) {
	try {
	    char c = line.charAt(0);
	    if (c == ' ' || c == '\t') {
		InternetHeader h =
		    (InternetHeader)headers.get(headers.size() - 1);
		h.line += "\r\n" + line;
	    } else
		headers.add(new InternetHeader(line));
	} catch (StringIndexOutOfBoundsException e) {
	    // line is empty, ignore it
	    return;
	} catch (NoSuchElementException e) {
	    // XXX - vector is empty?
	}
    }

    /**
     * Return all the header lines as an Enumeration of Strings.
     */
    public Enumeration getAllHeaderLines() { 
	return (getNonMatchingHeaderLines(null));
    }

    /**
     * Return all matching header lines as an Enumeration of Strings.
     */
    public Enumeration getMatchingHeaderLines(String[] names) {
	return (new matchEnum(headers, names, true, true));	
    }

    /**
     * Return all non-matching header lines
     */
    public Enumeration getNonMatchingHeaderLines(String[] names) {
	return (new matchEnum(headers, names, false, true));
    }
}