CVS diff for request.c between 1.15 and 1.11:

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

/****
 * read_request_chunk()
 *
 * 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_chunk(msg* req) {
    /* timeout */
    pth_event_t ev_read;

    /*
     * If there's no room to read any more data or if we've already received
     * EOF, just fail.
     */
    if (req->p_buf_left <= 0 || req->p_eof)
        return -1;

    /*
     * 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.
     */
    req->p_buf_left -= req->p_buf_read;
    req->p_buf_head += req->p_buf_read;
    //req->p_buf_head = (char *)(&req->p_buf_head[req->p_buf_read]);
    req->p_buf_head[0] = '\0';

    /*
     * If the end of the data we've read ends with \r\n\r\n or \n\n then we're
     * done reading the request.
     */
    if (strcmp((req->p_buf_head-4), "\r\n\r\n") == 0 ||
        strcmp((req->p_buf_head-4), "\n\n") == 0) {
        req->p_header_end = req->p_buf_head;
        return 1;
    } else {
        /* Still haven't seen the end of the request */
        req->p_header_end = NULL;
        return 0;
    }
}

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
    if (!req->simple) {
        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:
        /* Send back a 503 if we get something we don't recognize */
        PRINT("def...\n");
        STATIC_RESPONSE(req->fdp, 503);
        return -1;
    }

    return 0;
} 

    req->header_line = 1 + req->p_pos;
 

/*** simple_parse_*() ***/

int simple_parse_request(msg * req) {

/*
 * HTTP_request_message := request_line request_header
 *
 * request_line here means the "start-line"
 * request_header means "(message-header CRLF)"
 */

    int retval = 0;

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

    /* Parse all header lines */
    simple_parse_header(req);

    switch (req->p_method) {
    case M_HEAD:
    case M_GET:
// for now, return here.
// fix here -> the caller read_request() will handle... or
// is there any better way?
// return 0;
//printf("(before %d)\n", (int)pth_self());
        response_get(req);
//printf("(after  %d)\n", (int)pth_self());
        break;
    /* post not yet handled. it's put for now... */
    /* diff btwn POST and PUT:
       POST = pass (usu. cgi) the entity body to the uri
       PUT  = server just put the entity body to the uri
     */
    case M_POST:
        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:
        /* Send back a 503 if we get something we don't recognize */
        PRINT("def...\n");
        STATIC_RESPONSE(req->fdp, 503);
        return -1;
    }
    return 0;
}

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

    char *uri, *stop;
    char *logline = req->p_buf;

    /* Method */
    if (!memcmp(logline, "GET ", 4)) {
        req->p_method = M_GET;
        uri = logline + 3;
    } else if (!memcmp(logline, "PUT ", 4)) {
        req->p_method = M_PUT;
        uri = logline + 3;
    } else if (!memcmp(logline, "HEAD ", 5)) {
        req->p_method = M_HEAD;
        uri = logline + 4;
    } else if (!memcmp(logline, "POST ", 5)) {
        req->p_method = M_POST;
        uri = logline + 4;
    } else {
        // bad request or not implemented
        STATIC_RESPONSE(req->fdp, 501);
        return -1;
    }

    /* Scan to start of non-whitespace (i.e. the URI) */
    while (*(++uri) == ' ') {
        /*
         * Make sure we don't scan off the end of the input in our attempt to
         * find non-whitespace.
         */
        if (uri >= req->p_buf_head)
            return -1;
    }

    /* Scan to end of non-whitespace (i.e. the end of the URI) */
    stop = uri;
    while (*stop != '\0' && *stop != ' ' && *stop != '\n' && *stop != '\r') {
        ++stop;
        /* Make sure URI doesn't overflow buffer */
        if (stop > req->p_buf_head)
            return -1;
    }

    /* If the URI is too long, return an error page */
    if (stop - uri > MAX_REQ_URI_LEN) {
        STATIC_RESPONSE(req->fdp, 414);
        return -1;
    }

    req->p_uri_len = stop - uri;
    memcpy(req->p_uri, uri, req->p_uri_len);
    req->p_uri[req->p_uri_len] = '\0';

    /* HTTP-Version */
    if (*stop == ' ') {
        /* if found, we should get an HTTP/x.x */
        int p1, p2;

        if (sscanf(++stop, "HTTP/%d.%d", &p1, &p2) == 2 && p1 >= 1) {
            req->hv_major = p1;
            req->hv_minor = p2;
            req->simple = 0;
            if (0 == p1 || 0 == p2)
                req->ka_status = KA_INACTIVE;
        } else {
#ifdef LOGGING
            fprintf(ELOG, "Malformed request '%s %s'\n",
                    req->p_uri, stop);
#endif
            STATIC_RESPONSE(req->fdp, 400);
            return -1;
        }
    } else {
        /* No HTTP/x.y present; use HTTP/0.9 */
        req->simple = 1;
        req->ka_status = KA_INACTIVE;
    }

    /*
     * Move the cursor to the end of the request line (identified by either \n
     * or \r\n).
     */
    while (*(++stop) != '\0') {
        if (stop >= req->p_buf_head)
            return -1;
        if ('\n' == *stop) {
            req->status = ONE_CRLF;
            req->p_pos = stop;
            return 0;
        } else if ('\r' == *stop && '\n' == *(1 + stop)) {
            req->status = ONE_CRLF;
            req->p_pos = stop + 1;
            return 0;
        }
    }

    /*
     * This function is only called from simple_parse_request(), which is only
     * called when we know \r\n\r\n or \n\n were found.  Therefore, we should
     * never get down here since we're guaranteed of reaching the end of the
     * requestline.
     */
    assert(0);
    return -1;
}

/*
 * Name: process_header_end
 *
 * Description: takes a request and performs some final checking before
 * init_cgi or init_get
 * Returns -1 for error or NPH;  0 for success
 */


/****
 * simple_parse_header()
 *
 * Parses all request headers after the main request line.  This function is
 * no longer as picky as it used to be; it accepts \n as a valid header end
 * in addition to \r\n and also ignores bogus/malformed headers without
 * raising an error.
 *
 * @param req The request structure containing the buffers to parse.
 ****/
void simple_parse_header(msg* req) {
/*

[70]RFC 2068                        HTTP/1.1                    January 1997


   equivalent to the parameters on a programming language method
   invocation.

          request-header = Accept                   ; Section 14.1
                         | Accept-Charset           ; Section 14.2
                         | Accept-Encoding          ; Section 14.3
                         | Accept-Language          ; Section 14.4
                         | Authorization            ; Section 14.8
                         | From                     ; Section 14.22
                         | Host                     ; Section 14.23
                         | If-Modified-Since        ; Section 14.24
                         | If-Match                 ; Section 14.25
                         | If-None-Match            ; Section 14.26
                         | If-Range                 ; Section 14.27
                         | If-Unmodified-Since      ; Section 14.28
                         | Max-Forwards             ; Section 14.31
                         | Proxy-Authorization      ; Section 14.34
                         | Range                    ; Section 14.36
                         | Referer                  ; Section 14.37
                         | User-Agent               ; Section 14.42

   Request-header field names can be extended reliably only in
   combination with a change in the protocol version. However, new or
   experimental header fields MAY be given the semantics of request-
   header fields if all parties in the communication recognize them to
   be request-header fields.  Unrecognized header fields are treated as
   entity-header fields.

*/

    char c;
    char *value;
    char *line;
    int check_CRLF;

    /*
     * This 'simple' function should only get called if we've read the end
     * of the headers.
     */
    assert(req->p_header_end != NULL);

    req->header_line = 1 + req->p_pos;
    for (;;) {
        line = req->header_line;

        /*
         * 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];
            break;
        } else if ('\n' == line[0]) {
            req->p_entity_body = &line[1];
            req->header_line = &line[1];
            break;
        }

        /*
         * Look for the ":" between the header name and value.  If we don't
         * find it, we'll just ignore this header and continue with the next
         * one.
         */
        assert(req->p_header_end != NULL);
        assert(line < req->p_header_end);
        assert(*(req->p_header_end-1) == '\n');
        value = strchr(line, ':');
        if (NULL == value) {
            /* No name/value separator found.  Jump to end of this line */
            req->header_line = strchr(line, '\n');

            /*
             * Since this is a simple_* function, it's only being called if we
             * already read the end of the headers.  It should be impossible
             * to hit the end of the buffer before finding the header end.
             */
            assert(req->header_line != NULL);

            /* Continue parsing with the next header */
            req->header_line++;
            continue;
        }

        /*
         * Figure out which header this is; it looks like this code may have
         * been taken from Boa.
         */
        *value++ = '\0';
        to_upper(line);         // header type is case insensitive
        // while((c=*value)&&(c==' '||c=='\t')) // original
        for (;;) {
            c = *value;

            assert(c != '\0');      /* can't be null in simple_*() */
            if (c == ' ' || c == '\t') {
                /* Ignore whitespace */
                value++;
            } else {
                break;
            }
        }

        if (!memcmp(line, "HOST", 5)) {
            // TODO: Implement virtual hosts

        } else if (!memcmp(line, "IF_MODIFIED_SINCE", 18)
                 && !req->if_modified_since) {
            req->if_modified_since = value;

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

        } else if (!memcmp(line, "CONTENT_LENGTH", 15) && !req->content_length) {
            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

        } else if (!memcmp(line, "REFERER", 8)) {
            req->header_referer = value;

        } else if (!memcmp (line, "ACCEPT", 7)) {
            // TODO: Honor Accept: headers

        } else if (!memcmp(line, "USER_AGENT", 11)) {
            req->header_user_agent = value;

        /****** What is this doing here?
        } 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.  Since this is a simple_*
         * function, it's only being called if we already read the end
         * of the headers.  It should be impossible to hit the end of
         * the buffer before finding the header end.
         */
         req->header_line = strchr(value, '\n');
         assert(req->header_line != NULL);
         req->header_line++;
    }
}