| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file core_filters.c |
| * @brief Core input/output network filters. |
| */ |
| |
| #include "apr.h" |
| #include "apr_strings.h" |
| #include "apr_lib.h" |
| #include "apr_fnmatch.h" |
| #include "apr_hash.h" |
| #include "apr_thread_proc.h" /* for RLIMIT stuff */ |
| #include "apr_version.h" |
| |
| #define APR_WANT_IOVEC |
| #define APR_WANT_STRFUNC |
| #define APR_WANT_MEMFUNC |
| #include "apr_want.h" |
| |
| #include "ap_config.h" |
| #include "httpd.h" |
| #include "http_config.h" |
| #include "http_core.h" |
| #include "http_protocol.h" /* For index_of_response(). Grump. */ |
| #include "http_request.h" |
| #include "http_vhost.h" |
| #include "http_main.h" /* For the default_handler below... */ |
| #include "http_log.h" |
| #include "util_md5.h" |
| #include "http_connection.h" |
| #include "apr_buckets.h" |
| #include "util_filter.h" |
| #include "util_ebcdic.h" |
| #include "mpm_common.h" |
| #include "scoreboard.h" |
| #include "mod_core.h" |
| #include "ap_listen.h" |
| |
| #include "mod_so.h" /* for ap_find_loaded_module_symbol */ |
| |
| #define AP_MIN_SENDFILE_BYTES (256) |
| |
| /** |
| * Remove all zero length buckets from the brigade. |
| */ |
| #define BRIGADE_NORMALIZE(b) \ |
| do { \ |
| apr_bucket *e = APR_BRIGADE_FIRST(b); \ |
| do { \ |
| if (e->length == 0 && !APR_BUCKET_IS_METADATA(e)) { \ |
| apr_bucket *d; \ |
| d = APR_BUCKET_NEXT(e); \ |
| apr_bucket_delete(e); \ |
| e = d; \ |
| } \ |
| else { \ |
| e = APR_BUCKET_NEXT(e); \ |
| } \ |
| } while (!APR_BRIGADE_EMPTY(b) && (e != APR_BRIGADE_SENTINEL(b))); \ |
| } while (0) |
| |
| /* we know core's module_index is 0 */ |
| #undef APLOG_MODULE_INDEX |
| #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX |
| |
| struct core_output_filter_ctx { |
| apr_bucket_brigade *buffered_bb; |
| apr_pool_t *deferred_write_pool; |
| apr_size_t bytes_written; |
| struct iovec *vec; |
| apr_size_t nvec; |
| }; |
| |
| |
| apr_status_t ap_core_input_filter(ap_filter_t *f, apr_bucket_brigade *b, |
| ap_input_mode_t mode, apr_read_type_e block, |
| apr_off_t readbytes) |
| { |
| apr_status_t rv; |
| core_net_rec *net = f->ctx; |
| core_ctx_t *ctx = net->in_ctx; |
| const char *str; |
| apr_size_t len; |
| |
| if (mode == AP_MODE_INIT) { |
| /* |
| * this mode is for filters that might need to 'initialize' |
| * a connection before reading request data from a client. |
| * NNTP over SSL for example needs to handshake before the |
| * server sends the welcome message. |
| * such filters would have changed the mode before this point |
| * is reached. however, protocol modules such as NNTP should |
| * not need to know anything about SSL. given the example, if |
| * SSL is not in the filter chain, AP_MODE_INIT is a noop. |
| */ |
| return APR_SUCCESS; |
| } |
| |
| if (!ctx) |
| { |
| net->in_ctx = ctx = apr_palloc(f->c->pool, sizeof(*ctx)); |
| ctx->b = apr_brigade_create(f->c->pool, f->c->bucket_alloc); |
| ctx->tmpbb = apr_brigade_create(f->c->pool, f->c->bucket_alloc); |
| /* seed the brigade with the client socket. */ |
| rv = ap_run_insert_network_bucket(f->c, ctx->b, net->client_socket); |
| if (rv != APR_SUCCESS) |
| return rv; |
| } |
| else if (APR_BRIGADE_EMPTY(ctx->b)) { |
| return APR_EOF; |
| } |
| |
| /* ### This is bad. */ |
| BRIGADE_NORMALIZE(ctx->b); |
| |
| /* check for empty brigade again *AFTER* BRIGADE_NORMALIZE() |
| * If we have lost our socket bucket (see above), we are EOF. |
| * |
| * Ideally, this should be returning SUCCESS with EOS bucket, but |
| * some higher-up APIs (spec. read_request_line via ap_rgetline) |
| * want an error code. */ |
| if (APR_BRIGADE_EMPTY(ctx->b)) { |
| return APR_EOF; |
| } |
| |
| if (mode == AP_MODE_GETLINE) { |
| /* we are reading a single LF line, e.g. the HTTP headers */ |
| rv = apr_brigade_split_line(b, ctx->b, block, HUGE_STRING_LEN); |
| /* We should treat EAGAIN here the same as we do for EOF (brigade is |
| * empty). We do this by returning whatever we have read. This may |
| * or may not be bogus, but is consistent (for now) with EOF logic. |
| */ |
| if (APR_STATUS_IS_EAGAIN(rv) && block == APR_NONBLOCK_READ) { |
| rv = APR_SUCCESS; |
| } |
| return rv; |
| } |
| |
| /* ### AP_MODE_PEEK is a horrific name for this mode because we also |
| * eat any CRLFs that we see. That's not the obvious intention of |
| * this mode. Determine whether anyone actually uses this or not. */ |
| if (mode == AP_MODE_EATCRLF) { |
| apr_bucket *e; |
| const char *c; |
| |
| /* The purpose of this loop is to ignore any CRLF (or LF) at the end |
| * of a request. Many browsers send extra lines at the end of POST |
| * requests. We use the PEEK method to determine if there is more |
| * data on the socket, so that we know if we should delay sending the |
| * end of one request until we have served the second request in a |
| * pipelined situation. We don't want to actually delay sending a |
| * response if the server finds a CRLF (or LF), becuause that doesn't |
| * mean that there is another request, just a blank line. |
| */ |
| while (1) { |
| if (APR_BRIGADE_EMPTY(ctx->b)) |
| return APR_EOF; |
| |
| e = APR_BRIGADE_FIRST(ctx->b); |
| |
| rv = apr_bucket_read(e, &str, &len, APR_NONBLOCK_READ); |
| |
| if (rv != APR_SUCCESS) |
| return rv; |
| |
| c = str; |
| while (c < str + len) { |
| if (*c == APR_ASCII_LF) |
| c++; |
| else if (*c == APR_ASCII_CR && *(c + 1) == APR_ASCII_LF) |
| c += 2; |
| else |
| return APR_SUCCESS; |
| } |
| |
| /* If we reach here, we were a bucket just full of CRLFs, so |
| * just toss the bucket. */ |
| /* FIXME: Is this the right thing to do in the core? */ |
| apr_bucket_delete(e); |
| } |
| return APR_SUCCESS; |
| } |
| |
| /* If mode is EXHAUSTIVE, we want to just read everything until the end |
| * of the brigade, which in this case means the end of the socket. |
| * To do this, we attach the brigade that has currently been setaside to |
| * the brigade that was passed down, and send that brigade back. |
| * |
| * NOTE: This is VERY dangerous to use, and should only be done with |
| * extreme caution. FWLIW, this would be needed by an MPM like Perchild; |
| * such an MPM can easily request the socket and all data that has been |
| * read, which means that it can pass it to the correct child process. |
| */ |
| if (mode == AP_MODE_EXHAUSTIVE) { |
| apr_bucket *e; |
| |
| /* Tack on any buckets that were set aside. */ |
| APR_BRIGADE_CONCAT(b, ctx->b); |
| |
| /* Since we've just added all potential buckets (which will most |
| * likely simply be the socket bucket) we know this is the end, |
| * so tack on an EOS too. */ |
| /* We have read until the brigade was empty, so we know that we |
| * must be EOS. */ |
| e = apr_bucket_eos_create(f->c->bucket_alloc); |
| APR_BRIGADE_INSERT_TAIL(b, e); |
| return APR_SUCCESS; |
| } |
| |
| /* read up to the amount they specified. */ |
| if (mode == AP_MODE_READBYTES || mode == AP_MODE_SPECULATIVE) { |
| apr_bucket *e; |
| |
| AP_DEBUG_ASSERT(readbytes > 0); |
| |
| e = APR_BRIGADE_FIRST(ctx->b); |
| rv = apr_bucket_read(e, &str, &len, block); |
| |
| if (APR_STATUS_IS_EAGAIN(rv) && block == APR_NONBLOCK_READ) { |
| /* getting EAGAIN for a blocking read is an error; for a |
| * non-blocking read, return an empty brigade. */ |
| return APR_SUCCESS; |
| } |
| else if (rv != APR_SUCCESS) { |
| return rv; |
| } |
| else if (block == APR_BLOCK_READ && len == 0) { |
| /* We wanted to read some bytes in blocking mode. We read |
| * 0 bytes. Hence, we now assume we are EOS. |
| * |
| * When we are in normal mode, return an EOS bucket to the |
| * caller. |
| * When we are in speculative mode, leave ctx->b empty, so |
| * that the next call returns an EOS bucket. |
| */ |
| apr_bucket_delete(e); |
| |
| if (mode == AP_MODE_READBYTES) { |
| e = apr_bucket_eos_create(f->c->bucket_alloc); |
| APR_BRIGADE_INSERT_TAIL(b, e); |
| } |
| return APR_SUCCESS; |
| } |
| |
| /* Have we read as much data as we wanted (be greedy)? */ |
| if (len < readbytes) { |
| apr_size_t bucket_len; |
| |
| rv = APR_SUCCESS; |
| /* We already registered the data in e in len */ |
| e = APR_BUCKET_NEXT(e); |
| while ((len < readbytes) && (rv == APR_SUCCESS) |
| && (e != APR_BRIGADE_SENTINEL(ctx->b))) { |
| /* Check for the availability of buckets with known length */ |
| if (e->length != (apr_size_t)-1) { |
| len += e->length; |
| e = APR_BUCKET_NEXT(e); |
| } |
| else { |
| /* |
| * Read from bucket, but non blocking. If there isn't any |
| * more data, well than this is fine as well, we will |
| * not wait for more since we already got some and we are |
| * only checking if there isn't more. |
| */ |
| rv = apr_bucket_read(e, &str, &bucket_len, |
| APR_NONBLOCK_READ); |
| if (rv == APR_SUCCESS) { |
| len += bucket_len; |
| e = APR_BUCKET_NEXT(e); |
| } |
| } |
| } |
| } |
| |
| /* We can only return at most what we read. */ |
| if (len < readbytes) { |
| readbytes = len; |
| } |
| |
| rv = apr_brigade_partition(ctx->b, readbytes, &e); |
| if (rv != APR_SUCCESS) { |
| return rv; |
| } |
| |
| /* Must do move before CONCAT */ |
| ctx->tmpbb = apr_brigade_split_ex(ctx->b, e, ctx->tmpbb); |
| |
| if (mode == AP_MODE_READBYTES) { |
| APR_BRIGADE_CONCAT(b, ctx->b); |
| } |
| else if (mode == AP_MODE_SPECULATIVE) { |
| apr_bucket *copy_bucket; |
| |
| for (e = APR_BRIGADE_FIRST(ctx->b); |
| e != APR_BRIGADE_SENTINEL(ctx->b); |
| e = APR_BUCKET_NEXT(e)) |
| { |
| rv = apr_bucket_copy(e, ©_bucket); |
| if (rv != APR_SUCCESS) { |
| return rv; |
| } |
| APR_BRIGADE_INSERT_TAIL(b, copy_bucket); |
| } |
| } |
| |
| /* Take what was originally there and place it back on ctx->b */ |
| APR_BRIGADE_CONCAT(ctx->b, ctx->tmpbb); |
| } |
| return APR_SUCCESS; |
| } |
| |
| static void setaside_remaining_output(ap_filter_t *f, |
| core_output_filter_ctx_t *ctx, |
| apr_bucket_brigade *bb, |
| conn_rec *c); |
| |
| static apr_status_t send_brigade_nonblocking(apr_socket_t *s, |
| apr_bucket_brigade *bb, |
| core_output_filter_ctx_t *ctx, |
| conn_rec *c); |
| |
| static apr_status_t writev_nonblocking(apr_socket_t *s, |
| apr_bucket_brigade *bb, |
| core_output_filter_ctx_t *ctx, |
| apr_size_t bytes_to_write, |
| apr_size_t nvec, |
| conn_rec *c); |
| |
| #if APR_HAS_SENDFILE |
| static apr_status_t sendfile_nonblocking(apr_socket_t *s, |
| apr_bucket *bucket, |
| core_output_filter_ctx_t *ctx, |
| conn_rec *c); |
| #endif |
| |
| /* XXX: Should these be configurable parameters? */ |
| #define THRESHOLD_MIN_WRITE 4096 |
| |
| /* Optional function coming from mod_logio, used for logging of output |
| * traffic |
| */ |
| extern APR_OPTIONAL_FN_TYPE(ap_logio_add_bytes_out) *ap__logio_add_bytes_out; |
| |
| static int should_send_brigade(apr_bucket_brigade *bb, conn_rec *c, int *flush) |
| { |
| core_server_config *conf = |
| ap_get_core_module_config(c->base_server->module_config); |
| apr_size_t total_bytes = 0, non_file_bytes = 0; |
| apr_uint32_t eor_buckets = 0; |
| apr_bucket *bucket; |
| int need_flush = 0; |
| |
| /* Scan through the brigade and decide whether we need to flush it, |
| * based on the following rules: |
| * |
| * a) The brigade contains a flush bucket: Do a blocking write |
| * of everything up that point. |
| * |
| * b) The request is in CONN_STATE_HANDLER state, and the brigade |
| * contains at least flush_max_threshold bytes in non-file |
| * buckets: Do blocking writes until the amount of data in the |
| * buffer is less than flush_max_threshold. (The point of this |
| * rule is to provide flow control, in case a handler is |
| * streaming out lots of data faster than the data can be |
| * sent to the client.) |
| * |
| * c) The request is in CONN_STATE_HANDLER state, and the brigade |
| * contains at least flush_max_pipelined EOR buckets: |
| * Do blocking writes until less than flush_max_pipelined EOR |
| * buckets are left. (The point of this rule is to prevent too many |
| * FDs being kept open by pipelined requests, possibly allowing a |
| * DoS). |
| * |
| * d) The brigade contains a morphing bucket: otherwise ap_save_brigade() |
| * could read the whole bucket into memory. |
| */ |
| for (bucket = APR_BRIGADE_FIRST(bb); |
| bucket != APR_BRIGADE_SENTINEL(bb); |
| bucket = APR_BUCKET_NEXT(bucket)) { |
| |
| if (!APR_BUCKET_IS_METADATA(bucket)) { |
| if (bucket->length == (apr_size_t)-1) { |
| if (flush) { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE6, 0, c, |
| "core_output_filter: flushing because " |
| "of morphing bucket"); |
| } |
| need_flush = 1; |
| break; |
| } |
| |
| total_bytes += bucket->length; |
| if (!APR_BUCKET_IS_FILE(bucket)) { |
| non_file_bytes += bucket->length; |
| if (non_file_bytes > conf->flush_max_threshold) { |
| if (flush) { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE6, 0, c, |
| "core_output_filter: flushing because " |
| "of max threshold"); |
| } |
| need_flush = 1; |
| break; |
| } |
| } |
| } |
| else if (APR_BUCKET_IS_FLUSH(bucket)) { |
| if (flush) { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE6, 0, c, |
| "core_output_filter: flushing because " |
| "of FLUSH bucket"); |
| } |
| need_flush = 1; |
| break; |
| } |
| else if (AP_BUCKET_IS_EOR(bucket) |
| && conf->flush_max_pipelined >= 0 |
| && ++eor_buckets > conf->flush_max_pipelined) { |
| if (flush) { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE6, 0, c, |
| "core_output_filter: flushing because " |
| "of max pipelined"); |
| } |
| need_flush = 1; |
| break; |
| } |
| } |
| if (flush) { |
| *flush = need_flush; |
| } |
| |
| /* Also send if above flush_min_threshold, or if there are FILE buckets */ |
| return (need_flush |
| || total_bytes >= THRESHOLD_MIN_WRITE |
| || total_bytes > non_file_bytes); |
| } |
| |
| apr_status_t ap_core_output_filter(ap_filter_t *f, apr_bucket_brigade *new_bb) |
| { |
| conn_rec *c = f->c; |
| core_net_rec *net = f->ctx; |
| core_output_filter_ctx_t *ctx = net->out_ctx; |
| apr_bucket_brigade *bb = NULL; |
| apr_status_t rv = APR_SUCCESS; |
| |
| /* Fail quickly if the connection has already been aborted. */ |
| if (c->aborted) { |
| if (new_bb != NULL) { |
| apr_brigade_cleanup(new_bb); |
| } |
| return APR_ECONNABORTED; |
| } |
| |
| if (ctx == NULL) { |
| ctx = apr_pcalloc(c->pool, sizeof(*ctx)); |
| net->out_ctx = (core_output_filter_ctx_t *)ctx; |
| /* |
| * Need to create buffered_bb brigade with correct lifetime. Passing |
| * NULL to ap_save_brigade() would result in a brigade |
| * allocated from bb->pool which might be wrong. |
| */ |
| ctx->buffered_bb = apr_brigade_create(c->pool, c->bucket_alloc); |
| } |
| |
| if (new_bb != NULL) |
| bb = new_bb; |
| |
| if ((ctx->buffered_bb != NULL) && |
| !APR_BRIGADE_EMPTY(ctx->buffered_bb)) { |
| if (new_bb != NULL) { |
| APR_BRIGADE_PREPEND(bb, ctx->buffered_bb); |
| } |
| else { |
| bb = ctx->buffered_bb; |
| } |
| } |
| else if (new_bb == NULL) { |
| c->data_in_output_filters = 0; |
| return APR_SUCCESS; |
| } |
| |
| if (!new_bb || should_send_brigade(bb, c, NULL)) { |
| apr_socket_t *sock = net->client_socket; |
| apr_interval_time_t sock_timeout = 0; |
| |
| /* Non-blocking writes on the socket in any case. */ |
| apr_socket_timeout_get(sock, &sock_timeout); |
| apr_socket_timeout_set(sock, 0); |
| |
| do { |
| rv = send_brigade_nonblocking(sock, bb, ctx, c); |
| if (new_bb && APR_STATUS_IS_EAGAIN(rv)) { |
| /* Scan through the brigade and decide whether we must absolutely |
| * flush the remaining data, based on should_send_brigade() &flush |
| * rules. If so, wait for writability and retry, otherwise we did |
| * our best already and can wait for the next call. |
| */ |
| int flush; |
| (void)should_send_brigade(bb, c, &flush); |
| if (flush) { |
| apr_int32_t nfd; |
| apr_pollfd_t pfd; |
| memset(&pfd, 0, sizeof(pfd)); |
| pfd.reqevents = APR_POLLOUT; |
| pfd.desc_type = APR_POLL_SOCKET; |
| pfd.desc.s = sock; |
| pfd.p = c->pool; |
| do { |
| rv = apr_poll(&pfd, 1, &nfd, sock_timeout); |
| } while (APR_STATUS_IS_EINTR(rv)); |
| } |
| } |
| } while (rv == APR_SUCCESS && !APR_BRIGADE_EMPTY(bb)); |
| |
| /* Restore original socket timeout before leaving. */ |
| apr_socket_timeout_set(sock, sock_timeout); |
| } |
| |
| if (rv != APR_SUCCESS && !APR_STATUS_IS_EAGAIN(rv)) { |
| /* The client has aborted the connection */ |
| ap_log_cerror( |
| APLOG_MARK, APLOG_TRACE1, rv, c, |
| "core_output_filter: writing data to the network"); |
| /* |
| * Set c->aborted before apr_brigade_cleanup to have the correct status |
| * when logging the request as apr_brigade_cleanup triggers the logging |
| * of the request if it contains an EOR bucket. |
| */ |
| c->aborted = 1; |
| apr_brigade_cleanup(bb); |
| return rv; |
| } |
| |
| setaside_remaining_output(f, ctx, bb, c); |
| return APR_SUCCESS; |
| } |
| |
| /* |
| * This function assumes that either ctx->buffered_bb == NULL, or |
| * ctx->buffered_bb is empty, or ctx->buffered_bb == bb |
| */ |
| static void setaside_remaining_output(ap_filter_t *f, |
| core_output_filter_ctx_t *ctx, |
| apr_bucket_brigade *bb, |
| conn_rec *c) |
| { |
| apr_bucket *bucket; |
| |
| /* Don't set aside leading empty buckets, all previous data have been |
| * consumed so it's safe to delete them now. |
| */ |
| while (((bucket = APR_BRIGADE_FIRST(bb)) != APR_BRIGADE_SENTINEL(bb)) && |
| (APR_BUCKET_IS_METADATA(bucket) || (bucket->length == 0))) { |
| apr_bucket_delete(bucket); |
| } |
| |
| c->data_in_output_filters = 0; |
| if (!APR_BRIGADE_EMPTY(bb)) { |
| c->data_in_output_filters = 1; |
| if (bb != ctx->buffered_bb) { |
| if (!ctx->deferred_write_pool) { |
| apr_pool_create(&ctx->deferred_write_pool, c->pool); |
| apr_pool_tag(ctx->deferred_write_pool, "deferred_write"); |
| } |
| ap_save_brigade(f, &(ctx->buffered_bb), &bb, |
| ctx->deferred_write_pool); |
| } |
| } |
| else if (ctx->deferred_write_pool) { |
| /* |
| * There are no more requests in the pipeline. We can just clear the |
| * pool. |
| */ |
| apr_pool_clear(ctx->deferred_write_pool); |
| } |
| } |
| |
| #ifndef APR_MAX_IOVEC_SIZE |
| #define NVEC_MIN 16 |
| #define NVEC_MAX NVEC_MIN |
| #else |
| #if APR_MAX_IOVEC_SIZE > 16 |
| #define NVEC_MIN 16 |
| #else |
| #define NVEC_MIN APR_MAX_IOVEC_SIZE |
| #endif |
| #define NVEC_MAX APR_MAX_IOVEC_SIZE |
| #endif |
| |
| static APR_INLINE int is_in_memory_bucket(apr_bucket *b) |
| { |
| /* These buckets' data are already in memory. */ |
| return APR_BUCKET_IS_HEAP(b) |
| || APR_BUCKET_IS_POOL(b) |
| || APR_BUCKET_IS_TRANSIENT(b) |
| || APR_BUCKET_IS_IMMORTAL(b); |
| } |
| |
| #if APR_HAS_SENDFILE |
| static APR_INLINE int can_sendfile_bucket(apr_bucket *b) |
| { |
| /* Use sendfile to send the bucket unless: |
| * - the bucket is not a file bucket, or |
| * - the file is too small for sendfile to be useful, or |
| * - sendfile is disabled in the httpd config via "EnableSendfile off". |
| */ |
| if (APR_BUCKET_IS_FILE(b) && b->length >= AP_MIN_SENDFILE_BYTES) { |
| apr_file_t *file = ((apr_bucket_file *)b->data)->fd; |
| return apr_file_flags_get(file) & APR_SENDFILE_ENABLED; |
| } |
| else { |
| return 0; |
| } |
| } |
| #endif |
| |
| #if defined(WIN32) && (APR_MAJOR_VERSION == 1 && APR_MINOR_VERSION <= 7) |
| #undef APR_TCP_NOPUSH_FLAG |
| #define APR_TCP_NOPUSH_FLAG 0 |
| #endif |
| |
| static APR_INLINE void sock_nopush(apr_socket_t *s, int to) |
| { |
| /* Disable TCP_NOPUSH handling on OSX since unsetting it won't push |
| * retained data, which might introduce delays if further data don't |
| * come soon enough or cause the last chunk to be sent only when the |
| * connection is shutdown (e.g. after KeepAliveTimeout). |
| */ |
| #if APR_TCP_NOPUSH_FLAG && !defined(__APPLE__) |
| (void)apr_socket_opt_set(s, APR_TCP_NOPUSH, to); |
| #endif |
| } |
| |
| static apr_status_t send_brigade_nonblocking(apr_socket_t *s, |
| apr_bucket_brigade *bb, |
| core_output_filter_ctx_t *ctx, |
| conn_rec *c) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| core_server_config *conf = |
| ap_get_core_module_config(c->base_server->module_config); |
| apr_size_t nvec = 0, nbytes = 0; |
| apr_bucket *bucket, *next; |
| const char *data; |
| apr_size_t length; |
| |
| for (bucket = APR_BRIGADE_FIRST(bb); |
| bucket != APR_BRIGADE_SENTINEL(bb); |
| bucket = next) { |
| next = APR_BUCKET_NEXT(bucket); |
| |
| #if APR_HAS_SENDFILE |
| if (can_sendfile_bucket(bucket)) { |
| if (nvec > 0) { |
| sock_nopush(s, 1); |
| rv = writev_nonblocking(s, bb, ctx, nbytes, nvec, c); |
| if (rv != APR_SUCCESS) { |
| goto cleanup; |
| } |
| nbytes = 0; |
| nvec = 0; |
| } |
| rv = sendfile_nonblocking(s, bucket, ctx, c); |
| if (rv != APR_SUCCESS) { |
| goto cleanup; |
| } |
| continue; |
| } |
| #endif /* APR_HAS_SENDFILE */ |
| |
| if (bucket->length) { |
| /* Non-blocking read first, in case this is a morphing |
| * bucket type. */ |
| rv = apr_bucket_read(bucket, &data, &length, APR_NONBLOCK_READ); |
| if (APR_STATUS_IS_EAGAIN(rv)) { |
| /* Read would block; flush any pending data and retry. */ |
| if (nvec) { |
| rv = writev_nonblocking(s, bb, ctx, nbytes, nvec, c); |
| if (rv != APR_SUCCESS) { |
| goto cleanup; |
| } |
| nbytes = 0; |
| nvec = 0; |
| } |
| sock_nopush(s, 0); |
| |
| rv = apr_bucket_read(bucket, &data, &length, APR_BLOCK_READ); |
| } |
| if (rv != APR_SUCCESS) { |
| goto cleanup; |
| } |
| |
| /* reading may have split the bucket, so recompute next: */ |
| next = APR_BUCKET_NEXT(bucket); |
| } |
| |
| if (!bucket->length) { |
| /* Don't delete empty buckets until all the previous ones have been |
| * sent (nvec == 0); this must happen in sequence since metabuckets |
| * like EOR could free the data still pointed to by the iovec. So |
| * unless the latter is empty, let writev_nonblocking() cleanup the |
| * brigade in order. |
| */ |
| if (!nvec) { |
| apr_bucket_delete(bucket); |
| } |
| continue; |
| } |
| |
| /* Make sure that these new data fit in our iovec. */ |
| if (nvec == ctx->nvec) { |
| if (nvec == NVEC_MAX) { |
| sock_nopush(s, 1); |
| rv = writev_nonblocking(s, bb, ctx, nbytes, nvec, c); |
| if (rv != APR_SUCCESS) { |
| goto cleanup; |
| } |
| nbytes = 0; |
| nvec = 0; |
| } |
| else { |
| struct iovec *newvec; |
| apr_size_t newn = nvec * 2; |
| if (newn < NVEC_MIN) { |
| newn = NVEC_MIN; |
| } |
| else if (newn > NVEC_MAX) { |
| newn = NVEC_MAX; |
| } |
| newvec = apr_palloc(c->pool, newn * sizeof(struct iovec)); |
| if (nvec) { |
| memcpy(newvec, ctx->vec, nvec * sizeof(struct iovec)); |
| } |
| ctx->vec = newvec; |
| ctx->nvec = newn; |
| } |
| } |
| nbytes += length; |
| ctx->vec[nvec].iov_base = (void *)data; |
| ctx->vec[nvec].iov_len = length; |
| nvec++; |
| |
| /* Flush above max threshold, unless the brigade still contains in |
| * memory buckets which we want to try writing in the same pass (if |
| * we are at the end of the brigade, the write will happen outside |
| * the loop anyway). |
| */ |
| if (nbytes > conf->flush_max_threshold |
| && next != APR_BRIGADE_SENTINEL(bb) |
| && !is_in_memory_bucket(next)) { |
| sock_nopush(s, 1); |
| rv = writev_nonblocking(s, bb, ctx, nbytes, nvec, c); |
| if (rv != APR_SUCCESS) { |
| goto cleanup; |
| } |
| nbytes = 0; |
| nvec = 0; |
| } |
| } |
| if (nvec > 0) { |
| rv = writev_nonblocking(s, bb, ctx, nbytes, nvec, c); |
| } |
| |
| cleanup: |
| sock_nopush(s, 0); |
| return rv; |
| } |
| |
| static apr_status_t writev_nonblocking(apr_socket_t *s, |
| apr_bucket_brigade *bb, |
| core_output_filter_ctx_t *ctx, |
| apr_size_t bytes_to_write, |
| apr_size_t nvec, |
| conn_rec *c) |
| { |
| apr_status_t rv; |
| struct iovec *vec = ctx->vec; |
| apr_size_t bytes_written = 0; |
| apr_size_t i, offset = 0; |
| |
| do { |
| apr_size_t n = 0; |
| rv = apr_socket_sendv(s, vec + offset, nvec - offset, &n); |
| bytes_written += n; |
| |
| for (i = offset; i < nvec; ) { |
| apr_bucket *bucket = APR_BRIGADE_FIRST(bb); |
| if (!bucket->length) { |
| apr_bucket_delete(bucket); |
| } |
| else if (n >= vec[i].iov_len) { |
| apr_bucket_delete(bucket); |
| n -= vec[i++].iov_len; |
| offset++; |
| } |
| else { |
| if (n) { |
| apr_bucket_split(bucket, n); |
| apr_bucket_delete(bucket); |
| vec[i].iov_len -= n; |
| vec[i].iov_base = (char *) vec[i].iov_base + n; |
| } |
| break; |
| } |
| } |
| } while (rv == APR_SUCCESS && bytes_written < bytes_to_write); |
| |
| if ((ap__logio_add_bytes_out != NULL) && (bytes_written > 0)) { |
| ap__logio_add_bytes_out(c, bytes_written); |
| } |
| ctx->bytes_written += bytes_written; |
| |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE6, rv, c, |
| "writev_nonblocking: %"APR_SIZE_T_FMT"/%"APR_SIZE_T_FMT, |
| bytes_written, bytes_to_write); |
| return rv; |
| } |
| |
| #if APR_HAS_SENDFILE |
| |
| static apr_status_t sendfile_nonblocking(apr_socket_t *s, |
| apr_bucket *bucket, |
| core_output_filter_ctx_t *ctx, |
| conn_rec *c) |
| { |
| apr_status_t rv; |
| apr_file_t *file = ((apr_bucket_file *)bucket->data)->fd; |
| apr_size_t bytes_written = bucket->length; /* bytes_to_write for now */ |
| apr_off_t file_offset = bucket->start; |
| |
| rv = apr_socket_sendfile(s, file, NULL, &file_offset, &bytes_written, 0); |
| if ((ap__logio_add_bytes_out != NULL) && (bytes_written > 0)) { |
| ap__logio_add_bytes_out(c, bytes_written); |
| } |
| ctx->bytes_written += bytes_written; |
| |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE6, rv, c, |
| "sendfile_nonblocking: %" APR_SIZE_T_FMT "/%" APR_SIZE_T_FMT, |
| bytes_written, bucket->length); |
| if (bytes_written >= bucket->length) { |
| apr_bucket_delete(bucket); |
| } |
| else if (bytes_written > 0) { |
| apr_bucket_split(bucket, bytes_written); |
| apr_bucket_delete(bucket); |
| if (rv == APR_SUCCESS) { |
| rv = APR_EAGAIN; |
| } |
| } |
| return rv; |
| } |
| |
| #endif |
