granicus.if.org Git - apache/blob - server/connection.c

   1 /* Copyright 1999-2004 Apache Software Foundation
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include "apr.h"
  17 #include "apr_strings.h"
  18
  19 #define CORE_PRIVATE
  20 #include "ap_config.h"
  21 #include "httpd.h"
  22 #include "http_connection.h"
  23 #include "http_request.h"
  24 #include "http_protocol.h"
  25 #include "ap_mpm.h"
  26 #include "mpm_default.h"
  27 #include "http_config.h"
  28 #include "http_core.h"
  29 #include "http_vhost.h"
  30 #include "scoreboard.h"
  31 #include "http_log.h"
  32 #include "util_filter.h"
  33
  34 APR_HOOK_STRUCT(
  35             APR_HOOK_LINK(create_connection)
  36             APR_HOOK_LINK(process_connection)
  37             APR_HOOK_LINK(pre_connection)
  38 )
  39 AP_IMPLEMENT_HOOK_RUN_FIRST(conn_rec *,create_connection,
  40                             (apr_pool_t *p, server_rec *server, apr_socket_t *csd, long conn_id, void *sbh, apr_bucket_alloc_t *alloc),
  41                             (p, server, csd, conn_id, sbh, alloc), NULL)
  42 AP_IMPLEMENT_HOOK_RUN_FIRST(int,process_connection,(conn_rec *c),(c),DECLINED)
  43 AP_IMPLEMENT_HOOK_RUN_ALL(int,pre_connection,(conn_rec *c, void *csd),(c, csd),OK,DECLINED)
  44 /*
  45  * More machine-dependent networking gooo... on some systems,
  46  * you've got to be *really* sure that all the packets are acknowledged
  47  * before closing the connection, since the client will not be able
  48  * to see the last response if their TCP buffer is flushed by a RST
  49  * packet from us, which is what the server's TCP stack will send
  50  * if it receives any request data after closing the connection.
  51  *
  52  * In an ideal world, this function would be accomplished by simply
  53  * setting the socket option SO_LINGER and handling it within the
  54  * server's TCP stack while the process continues on to the next request.
  55  * Unfortunately, it seems that most (if not all) operating systems
  56  * block the server process on close() when SO_LINGER is used.
  57  * For those that don't, see USE_SO_LINGER below.  For the rest,
  58  * we have created a home-brew lingering_close.
  59  *
  60  * Many operating systems tend to block, puke, or otherwise mishandle
  61  * calls to shutdown only half of the connection.  You should define
  62  * NO_LINGCLOSE in ap_config.h if such is the case for your system.
  63  */
  64 #ifndef MAX_SECS_TO_LINGER
  65 #define MAX_SECS_TO_LINGER 30
  66 #endif
  67
  68 AP_CORE_DECLARE(void) ap_flush_conn(conn_rec *c)
  69 {
  70     apr_bucket_brigade *bb;
  71     apr_bucket *b;
  72
  73     bb = apr_brigade_create(c->pool, c->bucket_alloc);
  74     b = apr_bucket_flush_create(c->bucket_alloc);
  75     APR_BRIGADE_INSERT_TAIL(bb, b);
  76     ap_pass_brigade(c->output_filters, bb);
  77 }
  78
  79 /* we now proceed to read from the client until we get EOF, or until
  80  * MAX_SECS_TO_LINGER has passed.  the reasons for doing this are
  81  * documented in a draft:
  82  *
  83  * http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-connection-00.txt
  84  *
  85  * in a nutshell -- if we don't make this effort we risk causing
  86  * TCP RST packets to be sent which can tear down a connection before
  87  * all the response data has been sent to the client.
  88  */
  89 #define SECONDS_TO_LINGER  2
  90 AP_DECLARE(void) ap_lingering_close(conn_rec *c)
  91 {
  92     char dummybuf[512];
  93     apr_size_t nbytes = sizeof(dummybuf);
  94     apr_status_t rc;
  95     apr_int32_t timeout;
  96     apr_int32_t total_linger_time = 0;
  97     apr_socket_t *csd = ap_get_module_config(c->conn_config, &core_module);
  98
  99     if (!csd) {
 100         return;
 101     }
 102
 103     ap_update_child_status(c->sbh, SERVER_CLOSING, NULL);
 104
 105 #ifdef NO_LINGCLOSE
 106     ap_flush_conn(c); /* just close it */
 107     apr_socket_close(csd);
 108     return;
 109 #endif
 110
 111     /* Close the connection, being careful to send out whatever is still
 112      * in our buffers.  If possible, try to avoid a hard close until the
 113      * client has ACKed our FIN and/or has stopped sending us data.
 114      */
 115
 116     /* Send any leftover data to the client, but never try to again */
 117     ap_flush_conn(c);
 118
 119     if (c->aborted) {
 120         apr_socket_close(csd);
 121         return;
 122     }
 123
 124     /* Shut down the socket for write, which will send a FIN
 125      * to the peer.
 126      */
 127     if (apr_socket_shutdown(csd, APR_SHUTDOWN_WRITE) != APR_SUCCESS
 128         || c->aborted) {
 129         apr_socket_close(csd);
 130         return;
 131     }
 132
 133     /* Read all data from the peer until we reach "end-of-file" (FIN
 134      * from peer) or we've exceeded our overall timeout. If the client does
 135      * not send us bytes within 2 seconds (a value pulled from Apache 1.3
 136      * which seems to work well), close the connection.
 137      */
 138     timeout = apr_time_from_sec(SECONDS_TO_LINGER);
 139     apr_socket_timeout_set(csd, timeout);
 140     apr_socket_opt_set(csd, APR_INCOMPLETE_READ, 1);
 141     while (1) {
 142         nbytes = sizeof(dummybuf);
 143         rc = apr_socket_recv(csd, dummybuf, &nbytes);
 144         if (rc != APR_SUCCESS || nbytes == 0)
 145             break;
 146
 147         total_linger_time += SECONDS_TO_LINGER;
 148         if (total_linger_time >= MAX_SECS_TO_LINGER) {
 149             break;
 150         }
 151     }
 152
 153     apr_socket_close(csd);
 154     return;
 155 }
 156
 157 AP_CORE_DECLARE(void) ap_process_connection(conn_rec *c, void *csd)
 158 {
 159     int rc;
 160     ap_update_vhost_given_ip(c);
 161
 162     rc = ap_run_pre_connection(c, csd);
 163     if (rc != OK && rc != DONE) {
 164         c->aborted = 1;
 165     }
 166
 167     if (!c->aborted) {
 168         ap_run_process_connection(c);
 169     }
 170 }
 171