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     /* Close the connection, being careful to send out whatever is still
 134      * in our buffers.  If possible, try to avoid a hard close until the
 135      * client has ACKed our FIN and/or has stopped sending us data.
 136      */
 137
 138     /* Send any leftover data to the client, but never try to again */
 139     ap_flush_conn(c);
 140
 141 #ifdef NO_LINGCLOSE
 142     apr_socket_close(csd);
 143     return 1;
 144 #else
 145     /* Shut down the socket for write, which will send a FIN
 146      * to the peer.
 147      */
 148     if (c->aborted
 149             || apr_socket_shutdown(csd, APR_SHUTDOWN_WRITE) != APR_SUCCESS) {
 150         apr_socket_close(csd);
 151         return 1;
 152     }
 153     return 0;
 154 #endif
 155 }
 156
 157 AP_DECLARE(void) ap_lingering_close(conn_rec *c)
 158 {
 159     char dummybuf[512];
 160     apr_size_t nbytes;
 161     apr_time_t now, timeup = 0;
 162     apr_socket_t *csd = ap_get_conn_socket(c);
 163
 164     if (ap_start_lingering_close(c)) {
 165         return;
 166     }
 167
 168     /* Read available data from the client whilst it continues sending
 169      * it, for a maximum time of MAX_SECS_TO_LINGER.  If the client
 170      * does not send any data within 2 seconds (a value pulled from
 171      * Apache 1.3 which seems to work well), give up.
 172      */
 173     apr_socket_timeout_set(csd, apr_time_from_sec(SECONDS_TO_LINGER));
 174     apr_socket_opt_set(csd, APR_INCOMPLETE_READ, 1);
 175
 176     /* The common path here is that the initial apr_socket_recv() call
 177      * will return 0 bytes read; so that case must avoid the expensive
 178      * apr_time_now() call and time arithmetic. */
 179
 180     do {
 181         nbytes = sizeof(dummybuf);
 182         if (apr_socket_recv(csd, dummybuf, &nbytes) || nbytes == 0)
 183             break;
 184
 185         now = apr_time_now();
 186         if (timeup == 0) {
 187             /*
 188              * First time through;
 189              * calculate now + 30 seconds (MAX_SECS_TO_LINGER).
 190              *
 191              * If some module requested a shortened waiting period, only wait for
 192              * 2s (SECONDS_TO_LINGER). This is useful for mitigating certain
 193              * DoS attacks.
 194              */
 195             if (apr_table_get(c->notes, "short-lingering-close")) {
 196                 timeup = now + apr_time_from_sec(SECONDS_TO_LINGER);
 197             }
 198             else {
 199                 timeup = now + apr_time_from_sec(MAX_SECS_TO_LINGER);
 200             }
 201             continue;
 202         }
 203     } while (now < timeup);
 204
 205     apr_socket_close(csd);
 206 }
 207
 208 AP_CORE_DECLARE(void) ap_process_connection(conn_rec *c, void *csd)
 209 {
 210     int rc;
 211     ap_update_vhost_given_ip(c);
 212
 213     rc = ap_run_pre_connection(c, csd);
 214     if (rc != OK && rc != DONE) {
 215         c->aborted = 1;
 216     }
 217
 218     if (!c->aborted) {
 219         ap_run_process_connection(c);
 220     }
 221 }