Quadcap Embeddable Server

com/quadcap/http/util/HeaderParser.java

Go to the documentation of this file.

package com.quadcap.http.util;

/* Copyright 1999 - 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.io.IOException;
import java.io.InputStream;

import java.util.HashMap;
import java.util.Map;

import com.quadcap.util.text.OctetMap;
import com.quadcap.util.text.Scanner;

import com.quadcap.util.Debug;

/**
 * An HTTP header parser.
 *
 * @author Stan Bailes
 */
public class HeaderParser {

    /**
     * Parsing helper: Get the next bytes all of which are in the
     * specified map
     *
     * @param scanner the current scanner input source
     * @param map the octet map specifying the bytes we want
     */
    public static String getToken(Scanner scanner, OctetMap map) 
        throws IOException 
    {
        scanner.skipWhile(OctetMap.wsChars);
        return scanner.parseWhile(map);
    }

    /**
     * Parse the HTTP headers in this input source
     *
     * @exception IOException may be thrown
     */
    public static void parseHeaders(Scanner scanner, Map headers)
        throws IOException 
    {

        boolean done = false;
        String name = null, val = null;
        while (!done) {
            int c = scanner.peek();
            if (c == -1) break;
            if (OctetMap.wsChars.has(c)) {
                if (val != null) {
                    val = val + " " + getToken(scanner, 
                                               OctetMap.fieldValueChars);
                } else {
                    throw new IOException("Unexpected ws in headers");
                }
            } else {
                if (val != null) {
                    headers.put(name, val);
                    val = null;
                }

                if (c == '\r') {
                    done = true;
                } else if (c == '\n') {
                    scanner.matchChar('\n');
                    break;
                } else {
                    name = getToken(scanner, 
                                    OctetMap.tokenChars).toLowerCase();
                    scanner.matchChar(':');
                    val = getToken(scanner, OctetMap.fieldValueChars);
                }
            }
            parseCRLF(scanner);
        }                
        if (val != null) {
            headers.put(name, val);
        }
    }

    /**
     * Skip trailing whitespace followed by CRLF
     *
     * @param scanner the current scanner input source
     * @exception IOException if anything other than CRLF is found
     */
    public static void parseCRLF(Scanner scanner) throws IOException {
        scanner.skipWhile(OctetMap.wsChars);
        if (scanner.peek() == '\n') {
            scanner.matchChar('\n');
        } else {
            while (scanner.peek() == '\r') scanner.matchChar('\r');
            scanner.matchChar('\n');
        }
    }

    /**
     * Utility method to parse HTTP headers from an input stream, leaving
     * the stream posisitioned after the blank line following the headers.
     */
    public static Map parseHeaders(InputStream is) throws IOException {
        Map map = new HashMap();
        Scanner scanner = new Scanner(is, false);
        parseHeaders(scanner, map);
        return map;
    }

}