Quadcap Embeddable Server

com/quadcap/io/HeaderEnumeration.java

Go to the documentation of this file.

package com.quadcap.io;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.Enumeration;
import java.util.Map;
import java.util.NoSuchElementException;

import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackInputStream;

import com.quadcap.util.Debug;

/**
 * Return an enumeration of the headers of an RFC-822 style message.
 * This implementation assumes that the headers have already been separated
 * from the body, so that the input stream passed to the HeaderEnumeration
 * constructor returns only the header portion of the message.
 *
 * <p><i>XXX It would be pretty easy to have this class detect the
 * CRLF, CRLF sequence that ends the headers, as well....</i>
 *
 * @author Stan Bailes
 */
public class HeaderEnumeration implements Enumeration {
    String                      next;
    PushbackInputStream         is;
    StringBuffer                sb      = new StringBuffer();

    static final byte           CR      = 0x0d;
    static final byte           LF      = 0x0a;

    public HeaderEnumeration(InputStream is) {
        this.is = new PushbackInputStream(is);
    }

    /**
     * Tests if this enumeration contains more elements.
     *
     * @return  <code>true</code> if this enumeration contains more elements;
     *          <code>false</code> otherwise.
     */
    public boolean hasMoreElements() {
        if (next == null) getNext();
        return (next != null);
    }

    /**
     * Returns the next element of this enumeration.
     *
     * @return     the next element of this enumeration. 
     * @exception  NoSuchElementException  if no more elements exist.
     */
    public Object nextElement() {
        if (next == null) getNext();
        if (next == null) throw new NoSuchElementException("no more elements");
        Object ret = next;
        next = null;
        return ret;
    }

    /**
     * Run the state machine to produce the next header.
     */
    void getNext() {
        sb.setLength(0);

        int c;
        int state = 0;

        try {
            while ((c = is.read()) >= 0) {
                switch (state) {
                case 0:
                    if (c == CR) {
                        state = 1;
                    } else {
                        sb.append((char)c);
                    }
                    break;
                case 1:
                    if (c == LF) {
                        state = 2;
                    } else if (c != CR) {
                        sb.append((char)c);
                        state = 0;
                    }
                    break;
                case 2:
                    state = 0;
                    if (c == ' ' || c == '\t') {
                        sb.append(' ');
                    } else {
                        is.unread(c);
                        next = sb.toString();
                        sb.setLength(0);
                        return;
                    }
                    break;
                }
            }
            if (state == 2 && sb.toString().trim().length() > 0) {
                next = sb.toString().trim();
                sb.setLength(0);
            }
        } catch (IOException e) {
            Debug.print(e);
        }
    }

    /**
     * Helper function to build map for header (name -> value).
     *
     * @exception IOException may be thrown.
     */
    public void getHeaderMap(Map headerMap) throws IOException {
        while (hasMoreElements()) {
            String header = (String)nextElement();
            int idx = header.indexOf(':');
            if (idx >= 0) {
                String headerName = header.substring(0, idx).trim();
                String headerVal = header.substring(idx+1).trim();
                headerMap.put(headerName.toLowerCase(), headerVal);
            } else {
                throw new IOException("Bad header: '" + header + "'");
            }
        }
    }

}