Quadcap Embeddable Server

com/quadcap/net/server/WorkerInputStream.java

Go to the documentation of this file.

package com.quadcap.net.server;

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

import com.quadcap.util.Debug;
import com.quadcap.util.Util;

/**
 * An efficient worker input stream, which supports recycling.
 * Additionally, this class performs all necessary buffering and
 * some other higher level functions on the socket input stream, so
 * no extra 'buffered' are needed.
 *
 * <p>In a violoation of layering, but to achieve maximum performance,
 * this class knows how to "parse" HTTP headers.</p>
 *
 * @author Stan Bailes
 */
public final class WorkerInputStream extends InputStream {
    final static int    MAX             = 4096;
    byte[]              buf             = new byte[MAX+1];
    int                 pos             = 0;
    int                 lim             = 0;
    boolean             eof             = false;
    InputStream         in;

    //#ifdef DEBUG
    static boolean      doTrace         = false;
    FileOutputStream    log;
    //#endif
        

    public WorkerInputStream(FileOutputStream f) {
        //#ifdef DEBUG
        doTrace = (f != null);
        log = f;
        //#endif
    }

    public final void reset(InputStream in) throws IOException {
        this.in = in;
        this.eof = false;
        this.pos = 0;
        this.lim = 0;
        //#ifdef DEBUG
        if (doTrace) {
            log.write(("RESET " + Thread.currentThread().getName() +
                       "\r\n").getBytes());
        }
        //#endif
    }

    public final int read() throws IOException {
        if (pos >= lim && !eof) fill();
        int c = eof ? -1 : buf[pos++];
        return c;
    }

    public void unread(int c) {
        buf[--pos] = (byte)c;
    }

    /**
     * Fill the buffer.  Return true unless we're at end of file and have
     * returned zero bytes in this fill
     */
    final boolean fill() throws IOException {
        boolean ret = true;
        pos = 0;
        lim = in.read(buf, 0, MAX);
        if (lim < 0) {
            eof = true;
            lim = 0;
            ret = false;
        }
        //#ifdef DEBUG
        if (doTrace) log.write(buf, 0, lim);
        //#endif
        return ret;
    }

    public final int read(byte[] b, int off, int len) throws IOException {
        int rlim = off + len;
        while (off < rlim && !eof) {
            if (pos >= lim) fill();
            int cnt = lim - pos;
            if (len < cnt) cnt = len;
            if (cnt > 0) {
                System.arraycopy(buf, pos, b, off, cnt);
                pos += cnt;
                off += cnt;
            }
        }
        int cnt = off - (rlim - len);
        return cnt == 0 ? (eof ? -1 : 0) : cnt;
    }

    public final int read(byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    static byte[] CRLF = { 0x0d, 0x0a, 0x0d, 0x0a };

    /**
     * Read HTTP readers from the input stream.
     * @param hbuf We place the entire header octet sequence into hbuf,
     * terminated with CRLF
     * @param offsets We place the byte offset of the start of each
     *   header into the offsets array
     * @return the number of headers found
     */
    public final int readHeaders(byte[] hbuf, int[] offsets)
        throws IOException
    {
        int off = 0;    // offset into hbuf 
        int p = pos;
        int l = lim;
        int hcnt = 1;
        buf[lim] = (byte)'\r';
        int s = 1;
        while (true) {
            while (buf[p++] != '\r') continue;
            while (l - p < 4 - s) {
                if (p > l) {
                    p--;
                    s--;
                }
                while (p < l && buf[p++] == CRLF[s]) {
                    if (++s == 2 && off + p - pos > 2) {
                        offsets[hcnt++] = p - pos + off;
                    }
                }
                int len = p - pos;
                System.arraycopy(buf, pos, hbuf, off, len);
                fill();
                if (eof) {
                    offsets[0] = hcnt - 1;
                    return off + len;
                }
                p = 0;
                l = lim;
                buf[lim] = (byte)'\r';
                off += len;
            }
            while (buf[p++] == CRLF[s]) {
                ++s;
                final int len = p - pos;
                if (s == 2 && len+off > 2) {
                    offsets[hcnt++] = len + off;
                } else if (s == 4) {
                    System.arraycopy(buf, pos, hbuf, off, len);
                    pos = p;
                    offsets[0] = hcnt - 1;
                    return off + len;
                }
            }
            s = 1;
        }
    }

    final void show(String s, int p) {
        System.out.println("------ " + s);
        for (int i = 0; i < lim; i++) {
            if (buf[i] == '\r') System.out.print('D');
            else if (buf[i] == '\n') System.out.print('A');
            else System.out.print((char)buf[i]);
        }
        System.out.println("");
        for (int i = 0; i < p; i++) {
            System.out.print(" ");
        }
        System.out.println("^");
        System.out.println("");
    }
    
    public final void close() throws IOException {
        in.close();
        in = null;
        //#ifdef DEBUG
        if (doTrace) log.write("CLOSE\r\n".getBytes());
        //#endif
    }

    public String toString() {
        return Util.strBytes(buf, 0, lim);
    }

}