int idx = ap_index_of_response(status);

    int idx = ap_index_of_response(status);

    char *custom_response;

    char *custom_response;

    const char *location = apr_table_get(r->headers_out, "Location");

    const char *location = apr_table_get(r->headers_out, "Location");

    /* At this point, we are starting the response over, so we have to reset

    /* At this point, we are starting the response over, so we have to reset

     * this value.

     * this value.

     * former.

     * former.

     */

     */

    if (location == NULL) {

    if (location == NULL) {

        location = apr_table_get(r->err_headers_out, "Location");

        location = apr_table_get(r->err_headers_out, "Location");

    }

    }

    /* We need to special-case the handling of 204 and 304 responses,

    /* We need to special-case the handling of 204 and 304 responses,

     * message body.  Note that being assbackwards here is not an option.

     * message body.  Note that being assbackwards here is not an option.

     */

     */

    if (status == HTTP_NOT_MODIFIED) {

    if (status == HTTP_NOT_MODIFIED) {

        ap_finalize_request_protocol(r);

        ap_finalize_request_protocol(r);

        return;

        return;

    }

    }

    if (status == HTTP_NO_CONTENT) {

    if (status == HTTP_NO_CONTENT) {

        ap_finalize_request_protocol(r);

        ap_finalize_request_protocol(r);

        return;

        return;

    }

    }

    if (!r->assbackwards) {

    if (!r->assbackwards) {

        apr_table_t *tmp = r->headers_out;

        apr_table_t *tmp = r->headers_out;

        /* For all HTTP/1.x responses for which we generate the message,

        /* For all HTTP/1.x responses for which we generate the message,

        apr_table_clear(r->err_headers_out);

        apr_table_clear(r->err_headers_out);

        if (ap_is_HTTP_REDIRECT(status) || (status == HTTP_CREATED)) {

        if (ap_is_HTTP_REDIRECT(status) || (status == HTTP_CREATED)) {

            if ((location != NULL) && *location) {

            if ((location != NULL) && *location) {

                apr_table_setn(r->headers_out, "Location", location);

                apr_table_setn(r->headers_out, "Location", location);

            }

            }

            else {

            else {

                location = "";   /* avoids coredump when printing, below */

                location = "";   /* avoids coredump when printing, below */

            }

            }

        }

        }

        if (apr_table_get(r->subprocess_env,

        if (apr_table_get(r->subprocess_env,

                          "suppress-error-charset") != NULL) {

                          "suppress-error-charset") != NULL) {

            core_request_config *request_conf =

            core_request_config *request_conf =

                        ap_get_module_config(r->request_config, &core_module);

                        ap_get_module_config(r->request_config, &core_module);

            request_conf->suppress_charset = 1; /* avoid adding default

            request_conf->suppress_charset = 1; /* avoid adding default

            ap_set_content_type(r, "text/html");

            ap_set_content_type(r, "text/html");

        }

        }

        else {

        else {

            ap_set_content_type(r, "text/html; charset=iso-8859-1");

            ap_set_content_type(r, "text/html; charset=iso-8859-1");

        }

        }

        if ((status == HTTP_METHOD_NOT_ALLOWED)

        if ((status == HTTP_METHOD_NOT_ALLOWED)

            || (status == HTTP_NOT_IMPLEMENTED)) {

            || (status == HTTP_NOT_IMPLEMENTED)) {

            apr_table_setn(r->headers_out, "Allow", make_allow(r));

            apr_table_setn(r->headers_out, "Allow", make_allow(r));

        }

        }

        if (r->header_only) {

        if (r->header_only) {

            ap_finalize_request_protocol(r);

            ap_finalize_request_protocol(r);

            return;

            return;

        }

        }

    }

    }

    if ((custom_response = ap_response_code_string(r, idx))) {

    if ((custom_response = ap_response_code_string(r, idx))) {

        /*

        /*

         * We have a custom response output. This should only be

         * We have a custom response output. This should only be

         * a text-string to write back. But if the ErrorDocument

         * a text-string to write back. But if the ErrorDocument

         * it hasn't happened yet; we may never know if it fails.

         * it hasn't happened yet; we may never know if it fails.

         */

         */

        if (custom_response[0] == '\"') {

        if (custom_response[0] == '\"') {

            ap_rputs(custom_response + 1, r);

            ap_rputs(custom_response + 1, r);

            ap_finalize_request_protocol(r);

            ap_finalize_request_protocol(r);

            return;

            return;

            && apr_isdigit(r->status_line[2])

            && apr_isdigit(r->status_line[2])

            && apr_isspace(r->status_line[3])

            && apr_isspace(r->status_line[3])

            && apr_isalnum(r->status_line[4])) {

            && apr_isalnum(r->status_line[4])) {

            title = r->status_line;

            title = r->status_line;

        }

        }

                                 NULL);

                                 NULL);

        if (recursive_error) {

        if (recursive_error) {

            ap_rvputs_proto_in_ascii(r, "<p>Additionally, a ",

            ap_rvputs_proto_in_ascii(r, "<p>Additionally, a ",

                      status_lines[ap_index_of_response(recursive_error)],

                      status_lines[ap_index_of_response(recursive_error)],

                      "\nerror was encountered while trying to use an "

                      "\nerror was encountered while trying to use an "

        ap_rvputs_proto_in_ascii(r, "</body></html>\n", NULL);

        ap_rvputs_proto_in_ascii(r, "</body></html>\n", NULL);

    }

    }

    ap_finalize_request_protocol(r);

    ap_finalize_request_protocol(r);

}

}

/*

/*

    char *vhost_md5;

    char *vhost_md5;

    modssl_ctx_t *mctx;

    modssl_ctx_t *mctx;

    /*

    /*

     * Seed the Pseudo Random Number Generator (PRNG)

     * Seed the Pseudo Random Number Generator (PRNG)

     */

     */

    ssl_rand_seed(c->base_server, c->pool, SSL_RSCTX_CONNECT, "");

    ssl_rand_seed(c->base_server, c->pool, SSL_RSCTX_CONNECT, "");

    if (!sslconn) {

    if (!sslconn) {

        sslconn = ssl_init_connection_ctx(c);

        sslconn = ssl_init_connection_ctx(c);

    }

    }

    ssl_io_filter_init(c, ssl);

    ssl_io_filter_init(c, ssl);

    return APR_SUCCESS;

    return APR_SUCCESS;

}

}

 * request, and tack on an EOS bucket.

 * request, and tack on an EOS bucket.

 */

 */

#define HTTP_ON_HTTPS_PORT \

#define HTTP_ON_HTTPS_PORT \

#define HTTP_ON_HTTPS_PORT_BUCKET(alloc) \

#define HTTP_ON_HTTPS_PORT_BUCKET(alloc) \

    apr_bucket_immortal_create(HTTP_ON_HTTPS_PORT, \

    apr_bucket_immortal_create(HTTP_ON_HTTPS_PORT, \

            /* fake the request line */

            /* fake the request line */

            bucket = HTTP_ON_HTTPS_PORT_BUCKET(f->c->bucket_alloc);

            bucket = HTTP_ON_HTTPS_PORT_BUCKET(f->c->bucket_alloc);

            break;

            break;

      default:

      default:

    apr_size_t bytes_handled = 0, current_alloc = 0;

    apr_size_t bytes_handled = 0, current_alloc = 0;

    char *pos, *last_char = *s;

    char *pos, *last_char = *s;

    int do_alloc = (*s == NULL), saw_eos = 0;

    int do_alloc = (*s == NULL), saw_eos = 0;

    /*

    /*

     * Initialize last_char as otherwise a random value will be compared

     * Initialize last_char as otherwise a random value will be compared

    for (;;) {

    for (;;) {

        apr_brigade_cleanup(bb);

        apr_brigade_cleanup(bb);

        rv = ap_get_brigade(r->input_filters, bb, AP_MODE_GETLINE,

        rv = ap_get_brigade(r->input_filters, bb, AP_MODE_GETLINE,

                            APR_BLOCK_READ, 0);

                            APR_BLOCK_READ, 0);

        if (rv != APR_SUCCESS) {

        if (rv != APR_SUCCESS) {

            return rv;

            return rv;

        }

        }

            const char *str;

            const char *str;

            apr_size_t len;

            apr_size_t len;

            /* If we see an EOS, don't bother doing anything more. */

            /* If we see an EOS, don't bother doing anything more. */

            if (APR_BUCKET_IS_EOS(e)) {

            if (APR_BUCKET_IS_EOS(e)) {

                saw_eos = 1;

                saw_eos = 1;

            if (rv != APR_SUCCESS) {

            if (rv != APR_SUCCESS) {

                return rv;

                return rv;

            }

            }

            if (len == 0) {

            if (len == 0) {

                /* no use attempting a zero-byte alloc (hurts when

                /* no use attempting a zero-byte alloc (hurts when

            if (n < bytes_handled + len) {

            if (n < bytes_handled + len) {

                *read = bytes_handled;

                *read = bytes_handled;

                if (*s) {

                if (*s) {

                    /* ensure this string is NUL terminated */

                    /* ensure this string is NUL terminated */

                    if (bytes_handled > 0) {

                    if (bytes_handled > 0) {

                        (*s)[bytes_handled-1] = '\0';

                        (*s)[bytes_handled-1] = '\0';

                    }

                    }

                    else {

                    else {

                        (*s)[0] = '\0';

                        (*s)[0] = '\0';

                    }

                    }

                }

                }

            /* Do we have to handle the allocation ourselves? */

            /* Do we have to handle the allocation ourselves? */

            if (do_alloc) {

            if (do_alloc) {

                /* We'll assume the common case where one bucket is enough. */

                /* We'll assume the common case where one bucket is enough. */

                if (!*s) {

                if (!*s) {

                    current_alloc = len;

                    current_alloc = len;

                    if (current_alloc < MIN_LINE_ALLOC) {

                    if (current_alloc < MIN_LINE_ALLOC) {

                        current_alloc = MIN_LINE_ALLOC;

                        current_alloc = MIN_LINE_ALLOC;

                    }

                    }

                    *s = apr_palloc(r->pool, current_alloc);

                    *s = apr_palloc(r->pool, current_alloc);

                }

                }

                else if (bytes_handled + len > current_alloc) {

                else if (bytes_handled + len > current_alloc) {

                    /* Increase the buffer size */

                    /* Increase the buffer size */

                    apr_size_t new_size = current_alloc * 2;

                    apr_size_t new_size = current_alloc * 2;

                    char *new_buffer;

                    char *new_buffer;

                    memcpy(new_buffer, *s, bytes_handled);

                    memcpy(new_buffer, *s, bytes_handled);

                    current_alloc = new_size;

                    current_alloc = new_size;

                    *s = new_buffer;

                    *s = new_buffer;

                }

                }

            }

            }

            /* Just copy the rest of the data to the end of the old buffer. */

            /* Just copy the rest of the data to the end of the old buffer. */

            pos = *s + bytes_handled;

            pos = *s + bytes_handled;

            /* We've now processed that new data - update accordingly. */

            /* We've now processed that new data - update accordingly. */

            bytes_handled += len;

            bytes_handled += len;

        }

        }

        /* If we got a full line of input, stop reading */

        /* If we got a full line of input, stop reading */

        if (last_char && (*last_char == APR_ASCII_LF)) {

        if (last_char && (*last_char == APR_ASCII_LF)) {

            break;

            break;

        }

        }

    }

    }

    /* Now NUL-terminate the string at the end of the line;

    /* Now NUL-terminate the string at the end of the line;

     * if the last-but-one character is a CR, terminate there */

     * if the last-but-one character is a CR, terminate there */

    if (last_char > *s && last_char[-1] == APR_ASCII_CR) {

    if (last_char > *s && last_char[-1] == APR_ASCII_CR) {

        last_char--;

        last_char--;

    }

    }

    *last_char = '\0';

    *last_char = '\0';

    bytes_handled = last_char - *s;

    bytes_handled = last_char - *s;

    /* If we're folding, we have more work to do.

    /* If we're folding, we have more work to do.

     *

     *

     * Note that if an EOS was seen, we know we can't have another line.

     * Note that if an EOS was seen, we know we can't have another line.

     */

     */

    if (fold && bytes_handled && !saw_eos) {

    if (fold && bytes_handled && !saw_eos) {

        for (;;) {

        for (;;) {

            const char *str;

            const char *str;

            apr_size_t len;

            apr_size_t len;

             */

             */

            c = *str;

            c = *str;

            if (c == APR_ASCII_BLANK || c == APR_ASCII_TAB) {

            if (c == APR_ASCII_BLANK || c == APR_ASCII_TAB) {

                /* Do we have enough space? We may be full now. */

                /* Do we have enough space? We may be full now. */

                if (bytes_handled >= n) {

                if (bytes_handled >= n) {

                    *read = n;

                    *read = n;

                    /* ensure this string is terminated */

                    /* ensure this string is terminated */

                    (*s)[n-1] = '\0';

                    (*s)[n-1] = '\0';

                    apr_size_t next_size, next_len;

                    apr_size_t next_size, next_len;

                    char *tmp;

                    char *tmp;

                    /* If we're doing the allocations for them, we have to

                    /* If we're doing the allocations for them, we have to

                     * give ourselves a NULL and copy it on return.

                     * give ourselves a NULL and copy it on return.

                     */

                     */

                    if (do_alloc && next_len > 0) {

                    if (do_alloc && next_len > 0) {

                        char *new_buffer;

                        char *new_buffer;

                        apr_size_t new_size = bytes_handled + next_len + 1;

                        apr_size_t new_size = bytes_handled + next_len + 1;

                        /* we need to alloc an extra byte for a null */

                        /* we need to alloc an extra byte for a null */

                }

                }

            }

            }

            else { /* next character is not tab or space */

            else { /* next character is not tab or space */

                break;

                break;

            }

            }

        }

        }

    }

    }

    *read = bytes_handled;

    *read = bytes_handled;

    return APR_SUCCESS;

    return APR_SUCCESS;

}

}

    apr_size_t len;

    apr_size_t len;

    int num_blank_lines = 0;

    int num_blank_lines = 0;

    int max_blank_lines = r->server->limit_req_fields;

    int max_blank_lines = r->server->limit_req_fields;

    if (max_blank_lines <= 0) {

    if (max_blank_lines <= 0) {

        max_blank_lines = DEFAULT_LIMIT_REQUEST_FIELDS;

        max_blank_lines = DEFAULT_LIMIT_REQUEST_FIELDS;

    do {

    do {

        apr_status_t rv;

        apr_status_t rv;

        /* insure ap_rgetline allocates memory each time thru the loop

        /* insure ap_rgetline allocates memory each time thru the loop

         * if there are empty lines

         * if there are empty lines

        r->the_request = NULL;

        r->the_request = NULL;

        rv = ap_rgetline(&(r->the_request), (apr_size_t)(r->server->limit_req_line + 2),

        rv = ap_rgetline(&(r->the_request), (apr_size_t)(r->server->limit_req_line + 2),

                         &len, r, 0, bb);

                         &len, r, 0, bb);

        if (rv != APR_SUCCESS) {

        if (rv != APR_SUCCESS) {

            r->request_time = apr_time_now();

            r->request_time = apr_time_now();

    r->request_time = apr_time_now();

    r->request_time = apr_time_now();

    ll = r->the_request;

    ll = r->the_request;

    r->method = ap_getword_white(r->pool, &ll);

    r->method = ap_getword_white(r->pool, &ll);

#if 0

#if 0

#endif

#endif

    uri = ap_getword_white(r->pool, &ll);

    uri = ap_getword_white(r->pool, &ll);

    /* Provide quick information about the request method as soon as known */

    /* Provide quick information about the request method as soon as known */

    }

    }

    ap_parse_uri(r, uri);

    ap_parse_uri(r, uri);

    if (ll[0]) {

    if (ll[0]) {

        r->assbackwards = 0;

        r->assbackwards = 0;

        pro = ll;

        pro = ll;

        len = strlen(ll);

        len = strlen(ll);

    } else {

    } else {

        r->assbackwards = 1;

        r->assbackwards = 1;

        pro = "HTTP/0.9";

        pro = "HTTP/0.9";

        len = 8;

        len = 8;

    else

    else

        r->proto_num = HTTP_VERSION(1, 0);

        r->proto_num = HTTP_VERSION(1, 0);

    return 1;

    return 1;

}

}