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

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "apr.h"
  18 #include "apr_strings.h"
  19
  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 "http_config.h"
  27 #include "http_core.h"
  28 #include "http_vhost.h"
  29 #include "scoreboard.h"
  30 #include "http_log.h"
  31 #include "util_filter.h"
  32
  33 APR_HOOK_STRUCT(
  34             APR_HOOK_LINK(create_connection)
  35             APR_HOOK_LINK(process_connection)
  36             APR_HOOK_LINK(pre_connection)
  37             APR_HOOK_LINK(pre_close_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 AP_IMPLEMENT_HOOK_RUN_ALL(int,pre_close_connection,(conn_rec *c),(c),OK,DECLINED)
  45
  46 /*
  47  * More machine-dependent networking gooo... on some systems,
  48  * you've got to be *really* sure that all the packets are acknowledged
  49  * before closing the connection, since the client will not be able
  50  * to see the last response if their TCP buffer is flushed by a RST
  51  * packet from us, which is what the server's TCP stack will send
  52  * if it receives any request data after closing the connection.
  53  *
  54  * In an ideal world, this function would be accomplished by simply
  55  * setting the socket option SO_LINGER and handling it within the
  56  * server's TCP stack while the process continues on to the next request.
  57  * Unfortunately, it seems that most (if not all) operating systems
  58  * block the server process on close() when SO_LINGER is used.
  59  * For those that don't, see USE_SO_LINGER below.  For the rest,
  60  * we have created a home-brew lingering_close.
  61  *
  62  * Many operating systems tend to block, puke, or otherwise mishandle
  63  * calls to shutdown only half of the connection.  You should define
  64  * NO_LINGCLOSE in ap_config.h if such is the case for your system.
  65  */
  66 #ifndef MAX_SECS_TO_LINGER
  67 #define MAX_SECS_TO_LINGER 30
  68 #endif
  69
  70 AP_CORE_DECLARE(apr_status_t) ap_shutdown_conn(conn_rec *c, int flush)
  71 {
  72     apr_status_t rv;
  73     apr_bucket_brigade *bb;
  74     apr_bucket *b;
  75
  76     bb = apr_brigade_create(c->pool, c->bucket_alloc);
  77
  78     if (flush) {
  79         /* FLUSH bucket */
  80         b = apr_bucket_flush_create(c->bucket_alloc);
  81         APR_BRIGADE_INSERT_TAIL(bb, b);
  82     }
  83
  84     /* End Of Connection bucket */
  85     b = ap_bucket_eoc_create(c->bucket_alloc);
  86     APR_BRIGADE_INSERT_TAIL(bb, b);
  87
  88     rv = ap_pass_brigade(c->output_filters, bb);
  89     apr_brigade_destroy(bb);
  90     return rv;
  91 }
  92
  93 AP_CORE_DECLARE(void) ap_flush_conn(conn_rec *c)
  94 {
  95     (void)ap_shutdown_conn(c, 1);
  96 }
  97
  98 AP_DECLARE(int) ap_prep_lingering_close(conn_rec *c)
  99 {
 100     /* Give protocol handlers one last chance to raise their voice */
 101     ap_run_pre_close_connection(c);
 102
 103     if (c->sbh) {
 104         ap_update_child_status(c->sbh, SERVER_CLOSING, NULL);
 105     }
 106     return 0;
 107 }
 108
 109 /* we now proceed to read from the client until we get EOF, or until
 110  * MAX_SECS_TO_LINGER has passed.  The reasons for doing this are
 111  * documented in a draft:
 112  *
 113  * http://tools.ietf.org/html/draft-ietf-http-connection-00.txt
 114  *
 115  * in a nutshell -- if we don't make this effort we risk causing
 116  * TCP RST packets to be sent which can tear down a connection before
 117  * all the response data has been sent to the client.
 118  */
 119 #define SECONDS_TO_LINGER  2
 120
 121 AP_DECLARE(int) ap_start_lingering_close(conn_rec *c)
 122 {
 123     apr_socket_t *csd = ap_get_conn_socket(c);
 124
 125     if (!csd) {
 126         return 1;
 127     }
 128
 129     if (ap_prep_lingering_close(c)) {
 130         return 1;
 131     }
 132
 133 #ifdef NO_LINGCLOSE
 134     ap_flush_conn(c); /* just close it */
 135     apr_socket_close(csd);
 136     return 1;
 137 #endif
 138
 139     /* Close the connection, being careful to send out whatever is still
 140      * in our buffers.  If possible, try to avoid a hard close until the
 141      * client has ACKed our FIN and/or has stopped sending us data.
 142      */
 143
 144     /* Send any leftover data to the client, but never try to again */
 145     ap_flush_conn(c);
 146
 147     if (c->aborted) {
 148         apr_socket_close(csd);
 149         return 1;
 150     }
 151
 152     /* Shut down the socket for write, which will send a FIN
 153      * to the peer.
 154      */
 155     if (apr_socket_shutdown(csd, APR_SHUTDOWN_WRITE) != APR_SUCCESS
 156         || c->aborted) {
 157         apr_socket_close(csd);
 158         return 1;
 159     }
 160
 161     return 0;
 162 }
 163
 164 AP_DECLARE(void) ap_lingering_close(conn_rec *c)
 165 {
 166     char dummybuf[512];
 167     apr_size_t nbytes;
 168     apr_time_t now, timeup = 0;
 169     apr_socket_t *csd = ap_get_conn_socket(c);
 170
 171     if (ap_start_lingering_close(c)) {
 172         return;
 173     }
 174
 175     /* Read available data from the client whilst it continues sending
 176      * it, for a maximum time of MAX_SECS_TO_LINGER.  If the client
 177      * does not send any data within 2 seconds (a value pulled from
 178      * Apache 1.3 which seems to work well), give up.
 179      */
 180     apr_socket_timeout_set(csd, apr_time_from_sec(SECONDS_TO_LINGER));
 181     apr_socket_opt_set(csd, APR_INCOMPLETE_READ, 1);
 182
 183     /* The common path here is that the initial apr_socket_recv() call
 184      * will return 0 bytes read; so that case must avoid the expensive
 185      * apr_time_now() call and time arithmetic. */
 186
 187     do {
 188         nbytes = sizeof(dummybuf);
 189         if (apr_socket_recv(csd, dummybuf, &nbytes) || nbytes == 0)
 190             break;
 191
 192         now = apr_time_now();
 193         if (timeup == 0) {
 194             /*
 195              * First time through;
 196              * calculate now + 30 seconds (MAX_SECS_TO_LINGER).
 197              *
 198              * If some module requested a shortened waiting period, only wait for
 199              * 2s (SECONDS_TO_LINGER). This is useful for mitigating certain
 200              * DoS attacks.
 201              */
 202             if (apr_table_get(c->notes, "short-lingering-close")) {
 203                 timeup = now + apr_time_from_sec(SECONDS_TO_LINGER);
 204             }
 205             else {
 206                 timeup = now + apr_time_from_sec(MAX_SECS_TO_LINGER);
 207             }
 208             continue;
 209         }
 210     } while (now < timeup);
 211
 212     apr_socket_close(csd);
 213 }
 214
 215 AP_CORE_DECLARE(void) ap_process_connection(conn_rec *c, void *csd)
 216 {
 217     int rc;
 218     ap_update_vhost_given_ip(c);
 219
 220     rc = ap_run_pre_connection(c, csd);
 221     if (rc != OK && rc != DONE) {
 222         c->aborted = 1;
 223     }
 224
 225     if (!c->aborted) {
 226         ap_run_process_connection(c);
 227     }
 228 }