CVS diff for request.c between 1.15 and 1.7:

void simple_parse_header(msg*);

#define MIN(a,b)  (a <= b ? a : b) 

int simple_parse_request(msg*);
int simple_parse_request_line(msg*);

int read_request(msg * req) { 

int read_request(msg* req) { 

    /* initialize fields in msg* req */

    /* Initialize connection settings */ 

    req->simple = 1;                    /* Assume HTTP/0.9 by default */

    req->status = START_LINE;
    req->is_cgi = 0;

    /* RFC 2616 - Section 5

       Request  = Request-Line              ; Section 5.1
       *(( general-header        ; Section 4.5
       | request-header         ; Section 5.3
       | entity-header ) CRLF)  ; Section 7.1
       CRLF
       [ message-body ]          ; Section 4.3

       Request-Line   = Method SP Request-URI SP HTTP-Version CRLF
     */

    /* man 2 recv

       All  three  routines  return  the length of the message on
       successful completion.  If a message is too long to fit in
       the supplied buffer, excess bytes may be discarded depend-
       ing on the type of socket the  message  is  received  from
       (see socket(2)).

       If  no  messages  are available at the socket, the receive
       calls wait for a message to arrive, unless the  socket  is
       nonblocking  (see  fcntl(2)) in which case the value -1 is
       returned and the external variable errno  set  to  EAGAIN.
       The  receive  calls normally return any data available, up
       to the requested amount, rather than waiting  for  receipt
       of the full amount requested.
     */

    /* additional initialization */ 

    /* Keep-alive loop */
    for (;;) {
        pth_event_t ev_read;
        
        /* Set per-request settings */
        req->simple = 1;                    /* Assume HTTP/0.9 by default */
        req->status = START_LINE;
        req->is_cgi = 0;
        req->p_buf_left = MAX_BUF_SIZE - 1; // off 1 to put '\0'
        req->p_buf_head = req->p_buf;
        req->p_eof = 0;
        req->p_buf_read = 0;
        req->p_entity_body = NULL;

        /* Wait the "keep-alive" timeout even for new connections */
        ev_read = pth_event(PTH_EVENT_TIME,
                            pth_timeout(MIN(cow_rto_s, ka_max_dur), 0));
        ret_val = cow_read_line(req->fdp, req->p_buf, MAX_BUF_SIZE, ev_read);
        pth_event_free(ev_read, PTH_FREE_THIS);

        /* If a socket error/timeout occurs, just close the connection */
        if (ret_val < 0) {
            cow_close_socket(req->fdp);
            --cow_cur_conn;
            return (ret_val);
        }
        //printf("DEBUG: read line '%s' with retval %d, %d remains (%s)\n", req->p_buf, ret_val, req->fdp->incnt, req->fdp->inptr);
        
        /* Parse the first line of the request */
        ret_val = parse_request_line(req);
        if (ret_val < 0) {
            cow_close_socket(req->fdp);

            return ret_val;
        }

        /* Parse all header lines */
        for (;;) {
            ev_read = pth_event(PTH_EVENT_TIME,
                                pth_timeout(cow_rto_s, cow_rto_u));
            int len = cow_read_line(req->fdp, req->p_buf, MAX_BUF_SIZE, ev_read);
            pth_event_free(ev_read, PTH_FREE_THIS);
            if (len < 0) {
                /* Error; close connection */
                cow_close_socket(req->fdp);
                return len;
            } else if (len == 0) {
                /* Blank header line --> end of headers */
                break;
            }
            //printf("DEBUG: read header '%s' with ret val %d, %d remains (%s)\n", req->p_buf, len, req->fdp->incnt, req->fdp->inptr);

            /* Parse the header */
            parse_header(req);
        }

        /* Done reading/parsing headers.  Actually do the request now */
        cow_tot_parsed++;
        switch (req->p_method) {
            case M_HEAD:
            case M_GET:
                ret_val = response_get(req);
                break;
            case M_POST:                // not yet
                STATIC_RESPONSE(req->fdp, 501);
                ret_val = -1;
                break;
#ifdef ENABLE_PUT
            case M_PUT:
                PRINT("method is put....\n");
                process_header_end(req);
                ret_val = response_put(req);
                PRINT("breaking put\n");
                break;
#endif
            default:
                /* Send back a 503 if we get something we don't recognize */
                PRINT("def...\n");
                STATIC_RESPONSE(req->fdp, 503);
                ret_val = -1;
        }
#ifdef USE_TCPCORK
        /* Flush pending output */
        setsockopt(req->fdp, SOL_TCP, TCP_CORK, &zero, sizeof(zero));
#else
        ap_bflush(req->fdp);
#endif

        /* Any type of error condition means keep-alive can't continue. */
        if (ret_val < 0) {
            /* Error */
            cow_close_socket(req->fdp);
            --cow_cur_conn;
            return -1;
        }

        /*
         * If keep-alive is not active or if we've done our maximum number of
         * requests on this connection, close the connection.
         */
        if ((req->ka_status != KA_ACTIVE) || (--req->ka_count == 0)) {
            cow_close_socket(req->fdp);
            --cow_cur_conn;
            return 0;
        }

        /* Loop back and wait for another request on this socket */
    }
}

inline int read_request_ka(msg * req) {
    /* timeout */
    pth_event_t ev_read;

    /* Clear our buffers and prepare for the next request (if any) */

    /* Read the first "chunk" of the first request on this connection */
    ret_val = read_request_more(req);

    for (;;)                    // keep-alive loop
    {
        /* If a socket error occurs, just close the connection */
        if (ret_val < 0) {
            COW_CLOSE(req->fdp);

    /*
     * Set the timeout for reading to be the minimum of either the
     * keepalive timeout or the regular socket timeout.
     */
    ev_read = pth_event(PTH_EVENT_TIME,
                        pth_timeout(MIN(cow_rto_s, ka_max_dur), 0));
#ifdef USE_TCPCORK
    /* Try to read another request from the socket; -1 here means timeout */ 

            return (ret_val);
        }

        /* Did we reach the end of the headers? */
        if (1 == ret_val) {
            // we can use simple_parse_request
            ret_val = simple_parse_request(req);
            if (0 > ret_val)    // error
            {
                // bad header. appropreate response has been sent.
                COW_CLOSE(req->fdp);
                return -1;
            }

        } else {
            /*
             * The request data we've seen so far did not end in \r\n\r\n or
             * \n\n, which means one of
             * 1. Read header not completed.
             * 2. The request includes a body (e.g. POST method) and we've
             *    already passed the end of the headers and started reading
             *    the body.
             */
            ret_val = parse_request(req);
            if (0 != ret_val) {
                COW_CLOSE(req->fdp);
                return -1;
            }
        }

        if ((KA_ACTIVE != req->ka_status) || (1 > --req->ka_count)) {
            COW_CLOSE(req->fdp) return ret_val;
        }

        /* read the [first] portion for the second time or later */
        ret_val = read_request_ka(req);

    }                           // end oF KEEP-ALIVE LOOP
}                               // end of read_request()

inline int read_request_ka(msg * req) {
    /* timeout */
    pth_event_t ev_read;

    // extend this to handle ka.
    ev_read = pth_event(PTH_EVENT_TIME, pth_timeout(ka_max_dur, 0));

    // read and recv are equivalent, so pick one
    // if ka timeout -> -1

        return 1;
    }

    if (0 > req->p_buf_read) {
        // read error, possible bad connection.
        return (-1);

        return -1;
    } else if (0 > req->p_buf_read) {
        /* read error, timeout or bad connection */
        return -1;
    }
 

    }

    req->p_buf_left -= req->p_buf_read;
    req->p_buf_head = (char *)(&req->p_buf_head[req->p_buf_read]);
    {
        char *t = req->p_buf_head;
        if (10 == (int)*(t - 1) &&
            13 == (int)*(t - 2) && 10 == (int)*(t - 3) && 13 == (int)*(t - 4)) {
            req->p_header_end = t;
            return 1;
        }
    }
    req->p_buf_head[0] = '\0';
    req->p_header_end = NULL;
    return 0;
}

/****
 * read_request_more()
 *
 * Reads the next chunk of the request.  This function blocks the current
 * thread until at least one more byte of the request can be read (or until
 * EOF is seen) and then returns.  It does not necessarily read the entire
 * request, just "more" of it.  The return value indicates whether the
 * request is complete or not.
 *
 * @param req The request structure containing the file descriptor to read
 *            from and the buffers to read into.
 *
 * @return 1 if the request has been completely read, 0 if it has only been
 *         partially read, and -1 if an error occurred.
 ****/
inline int read_request_more(msg * req) {
    /* timeout */
    pth_event_t ev_read;

    /*
     * Right now this only supports regular socket timeout.  We should also
     * make it handle keep-alive timeouts.
     */
    ev_read = pth_event(PTH_EVENT_TIME, pth_timeout(cow_rto_s, cow_rto_u));
    req->p_buf_read =
        pth_read_ev(req->fdp, req->p_buf_head, req->p_buf_left, ev_read) ;
    pth_event_free(ev_read, PTH_FREE_THIS);

    if (0 > req->p_buf_read) {
        // Read error; timeout or bad connection.
        return (-1);
    } else if (0 == req->p_buf_read) {
        /* EOF encountered as only character */
        req->p_eof = 1;
        return 1;
    }

    /* TODO: Pth was already yielding waiting for input; why yield now? */
    //pth_yield(NULL);

    /*
     * Update request structure to reflect how much of the request has been
     * read.  Also NULL terminate the data we've read so far.
     */

int parse_request(msg * req) {
    /*
       Request-Line   = Method SP Request-URI SP HTTP-Version CRLF
     */

    int retval = 0;

    if (START_LINE == req->status)      // the first line
        retval = parse_request_line(req);

    if (retval)
        return retval;

    // parse header lines

/****
 * parse_request_line()
 *
 * Parses the first line of an HTTP request.  The request type, URI and
 * protocol version information is all stored in the provided request
 * structure.
 *
 * @param req The HTTP request structure which contains the request buffers
 *            and which the request information should be stored to.
 *
 * @return 0 on success, -1 on failure
 ****/
int parse_request_line(msg* req) { 

    retval = parse_header(req);
    if (retval)
        return retval;

    switch (req->p_method) {
    case M_HEAD:
    case M_GET:
        response_get(req);
        break;
    case M_POST:                // not yet
        PRINT("method is post\n");
        response_post(req);
        PRINT("breaking post\n");
    case M_PUT:
        PRINT("method is put....\n");
        process_header_end(req);
        response_put(req);
        PRINT("breaking put\n");
        break;
    default:
        PRINT("def...\n");
        response_default(req->fdp);
        return -1;
    }

    return 0;
}

int parse_request_line(msg * req) {

        response_501(req->fdp); 

        //printf("DEBUG: Service = '%s'\n", logline);

        STATIC_RESPONSE(req->fdp, 501);

    while (*(++uri) == ' ') { 

    while (*(++uri) == ' ')

        ;

    /* scan to end of URI */
    stop = uri;
    for (;;) {

         * Make sure we don't scan off the end of the input in our attempt to
         * find non-whitespace. 

         * End of URI will be a space (if we're using HTTP/1.0 or above) or
         * the null-terminator (if we got an HTTP/0.9 simple request). 

        if (uri > req->p_buf_head) {
            /*
             * End of input; have we filled up the entire buffer or have we
             * just not received the entire request from the network yet?
             */
            if (0 >= req->p_buf_left || req->p_header_end)
                /*
                 * Buffer is full or the request is finished; we can't read 
                 * any more from the network.  Fail now.
                 */
                return -1;

            /*
             * There's still room to read more into the buffer.  Move our uri

        if (*stop == '\0' || *stop == ' ')
            break;

        /*
         * \r should mean end of URI and be followed by \n, but since
         * cow_read_line already stripped trailing \r\n's, this must be
         * a stray (and an error).
         */
        if (*stop == '\r') {
            STATIC_RESPONSE(req->fdp, 400);
            return -1;
        }

        /* Not there yet... */ 

             * pointer back one character and try to read some more.
             */
            --uri;
            if (0 > read_request_more(req))
                return -1;
        }
    }

    stop = uri;

    /* BNF: SP */
    /* scan to end of non-whitespace */
    while (*stop != '\0' && *stop != ' ') {

        if (stop > req->p_buf_head) {
            /* We just scanned past the end of the current input. */

    }

    /* If the URI is too long, return an error page */ 

            if (0 >= req->p_buf_left) {
                /* Request too long to parse */
                return -1;
            }

            /*
             * Back up one character and try to read some more from the
             * network
             */
            --stop;
            if (0 > read_request_more(req))
                return -1;
        }
    }

        response_414(req->fdp); 

        STATIC_RESPONSE(req->fdp, 414); 

            if (0 == p1 || 0 == p2) 

            if (p1 == 0 || p1+p2 < 2) { 

            response_400(req->fdp); 

            STATIC_RESPONSE(req->fdp, 400); 

    /*

    return 0; 

     * Scan until we reach a \n; at that point we'll know for sure
     * that the request line can be processed.
     */
    while (*(++stop) != '\0') {
        if (stop > req->p_buf_head) {
            /* Scanned past end of input */
            if (0 == req->p_buf_left)
                /* request too long; exceeded server capacity */
                return -1;

            /*
             * Back up one character and try to read some more of the
             * request from the network.
             */
            --stop;
            if (0 > read_request_more(req))
                return -1;
        }

        /*
         * If we reach a \n or a \r\n, then we know we've read enough to
         * process the request line.  Then we can return to the user.
         */
        if ('\n' == *stop) {
            req->status = ONE_CRLF;
            return 0;
        } else if ('\r' == *stop && '\n' == *(1 + stop)) {
            req->status = ONE_CRLF;
            req->p_pos = stop + 1;
            return 0;
        }
    }
    // unreachable
    assert(0);
    return -1;                  /* error */

        line = req->header_line;

        line = req->p_buf; 

        /*
         * At this point, one \r\n (or \n) was just parsed so another immediate
         * \r\n (or \n) means we got the end of the header.
         */
        if (('\r' == line[0]) && ('\n' == line[1])) {
            req->p_entity_body = &line[2];
            req->header_line = &line[2];
            return 0;
        } else if ('\n' == line[0]) {
            req->p_entity_body = &line[1];
            req->header_line = &line[1];
            break;
        }

        if (NULL == value) {
            /*
             * No name/value separator found.  Jump to the end of this line.

        if (NULL == value)
            return 0;
         

             * If we have not yet read enough from the network to find the
             * end of the line, keep reading until we have it or until we
             * detect a socket error.
             */
            while (NULL == (req->header_line = strchr(line, '\n'))) {
                int retval = read_request_more(req);
                if (retval < 0)
                    return -1;
            }
            req->header_line++;
        }

        // while((c=*value)&&(c==' '||c=='\t')) // original 

        /* Find the start of the value */

                /*
                 * We should only encounter a NULL character if we haven't read

                /* Empty header value */
                return 0; 

                 * enough of the request yet.  Read some more of the request and
                 * then continue the loop.  If we're out of buffer space, fail
                 * now.
                 */
                if (0 >= req->p_buf_left || req->p_header_end)
                    return -1;
                retval = read_request_more(req);
                if (retval < 0)
                    return -1;
                continue;

            //not yet 

            // TODO 

            req->if_modified_since = value;
        }

        else if (!memcmp(line, "CONTENT_TYPE", 13) && !req->content_type) {

            // TODO
            
        } else if (!memcmp(line, "CONTENT_TYPE", 13) && !req->content_type) {
            // TODO 

            req->content_type = value;

            req->content_length = value;

        } else if (!memcmp(line, "CONNECTION", 11)
                 // && ka_max 
                 // && req->keepalive != KA_STOPPED)
                 && ka_max_con && req->ka_status != KA_STOPPED) {
            // TODO: Fix keepalive 

            // TODO

        } else if (!memcmp(line, "CONNECTION", 11) && 
                    ka_max_con && req->ka_status != KA_STOPPED) {
            if (0 == memcmp(value, "close", 5)) {
                req->ka_status = KA_INACTIVE;
            }

            // TODO: deal with other "connection" headers

            req->header_referer = value; 

#ifdef LOGGING

            // TODO
#endif

        /****** What is this doing here?

#endif
        } 

        } else if (req->is_cgi) {
            // init value of is_cgi is 0.
            // not yet implemented
            check_CRLF = 0;
         ******/

        }

        /*
         * Jump to end of this header and set parsing point to the
         * beginning of the next header.  If we can't find the '\n', it
         * means we haven't read enough of the request from the network yet
         * and we'll have to keep reading chunks until we find the end of
         * this line (or until an error occurs).
         */
        while (NULL == (req->header_line = strchr(line, '\n'))) {
            int retval = read_request_more(req);
            if (retval < 0)
                return -1;
        }
        req->header_line++;