src/connections.c

   1 #include "first.h"
   2
   3 #include "base.h"
   4 #include "buffer.h"
   5 #include "burl.h"       /* HTTP_PARSEOPT_HEADER_STRICT */
   6 #include "log.h"
   7 #include "connections.h"
   8 #include "fdevent.h"
   9 #include "http_header.h"
  10
  11 #include "configfile.h"
  12 #include "request.h"
  13 #include "response.h"
  14 #include "network.h"
  15 #include "http_chunk.h"
  16 #include "stat_cache.h"
  17 #include "joblist.h"
  18
  19 #include "plugin.h"
  20
  21 #include "inet_ntop_cache.h"
  22
  23 #include <sys/stat.h>
  24
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #include <string.h>
  29
  30 #ifdef HAVE_SYS_FILIO_H
  31 # include <sys/filio.h>
  32 #endif
  33
  34 #include "sys-socket.h"
  35
  36 typedef struct {
  37                 PLUGIN_DATA;
  38 } plugin_data;
  39
  40 __attribute_cold__
  41 static connection *connection_init(server *srv);
  42
  43 static int connection_reset(server *srv, connection *con);
  44
  45
  46 static connection *connections_get_new_connection(server *srv) {
  47         connections *conns = srv->conns;
  48         size_t i;
  49
  50         if (conns->size == conns->used) {
  51                 conns->size += srv->max_conns >= 128 ? 128 : srv->max_conns > 16 ? 16 : srv->max_conns;
  52                 conns->ptr = realloc(conns->ptr, sizeof(*conns->ptr) * conns->size);
  53                 force_assert(NULL != conns->ptr);
  54
  55                 for (i = conns->used; i < conns->size; i++) {
  56                         conns->ptr[i] = connection_init(srv);
  57                         connection_reset(srv, conns->ptr[i]);
  58                 }
  59         }
  60
  61         conns->ptr[conns->used]->ndx = conns->used;
  62         return conns->ptr[conns->used++];
  63 }
  64
  65 static int connection_del(server *srv, connection *con) {
  66         size_t i;
  67         connections *conns = srv->conns;
  68         connection *temp;
  69
  70         if (con == NULL) return -1;
  71
  72         if (-1 == con->ndx) return -1;
  73
  74         buffer_clear(con->uri.authority);
  75         buffer_reset(con->uri.path);
  76         buffer_reset(con->uri.query);
  77         buffer_reset(con->request.orig_uri);
  78
  79         i = con->ndx;
  80
  81         /* not last element */
  82
  83         if (i != conns->used - 1) {
  84                 temp = conns->ptr[i];
  85                 conns->ptr[i] = conns->ptr[conns->used - 1];
  86                 conns->ptr[conns->used - 1] = temp;
  87
  88                 conns->ptr[i]->ndx = i;
  89                 conns->ptr[conns->used - 1]->ndx = -1;
  90         }
  91
  92         conns->used--;
  93
  94         con->ndx = -1;
  95 #if 0
  96         fprintf(stderr, "%s.%d: del: (%d)", __FILE__, __LINE__, conns->used);
  97         for (i = 0; i < conns->used; i++) {
  98                 fprintf(stderr, "%d ", conns->ptr[i]->fd);
  99         }
 100         fprintf(stderr, "\n");
 101 #endif
 102         return 0;
 103 }
 104
 105 static int connection_close(server *srv, connection *con) {
 106         if (con->fd < 0) con->fd = -con->fd;
 107
 108         plugins_call_handle_connection_close(srv, con);
 109
 110         con->request_count = 0;
 111         chunkqueue_reset(con->read_queue);
 112
 113         fdevent_event_del(srv->ev, con->fd);
 114         fdevent_unregister(srv->ev, con->fd);
 115 #ifdef __WIN32
 116         if (closesocket(con->fd)) {
 117                 log_error_write(srv, __FILE__, __LINE__, "sds",
 118                                 "(warning) close:", con->fd, strerror(errno));
 119         }
 120 #else
 121         if (close(con->fd)) {
 122                 log_error_write(srv, __FILE__, __LINE__, "sds",
 123                                 "(warning) close:", con->fd, strerror(errno));
 124         }
 125 #endif
 126         else {
 127                 srv->cur_fds--;
 128         }
 129
 130         if (srv->srvconf.log_state_handling) {
 131                 log_error_write(srv, __FILE__, __LINE__, "sd",
 132                                 "connection closed for fd", con->fd);
 133         }
 134         con->fd = -1;
 135         con->is_ssl_sock = 0;
 136
 137         /* plugins should have cleaned themselves up */
 138         for (size_t i = 0; i < srv->plugins.used; ++i) {
 139                 plugin *p = ((plugin **)(srv->plugins.ptr))[i];
 140                 plugin_data *pd = p->data;
 141                 if (!pd || NULL == con->plugin_ctx[pd->id]) continue;
 142                 log_error_write(srv, __FILE__, __LINE__, "sb",
 143                                 "missing cleanup in", p->name);
 144                 con->plugin_ctx[pd->id] = NULL;
 145         }
 146
 147         connection_del(srv, con);
 148         connection_set_state(srv, con, CON_STATE_CONNECT);
 149
 150         return 0;
 151 }
 152
 153 static void connection_read_for_eos_plain(server *srv, connection *con) {
 154         /* we have to do the linger_on_close stuff regardless
 155          * of con->keep_alive; even non-keepalive sockets may
 156          * still have unread data, and closing before reading
 157          * it will make the client not see all our output.
 158          */
 159         ssize_t len;
 160         const int type = con->dst_addr.plain.sa_family;
 161         char buf[16384];
 162         do {
 163                 len = fdevent_socket_read_discard(con->fd, buf, sizeof(buf),
 164                                                   type, SOCK_STREAM);
 165         } while (len > 0 || (len < 0 && errno == EINTR));
 166
 167         if (len < 0 && errno == EAGAIN) return;
 168       #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
 169         if (len < 0 && errno == EWOULDBLOCK) return;
 170       #endif
 171
 172         /* 0 == len || (len < 0 && (errno is a non-recoverable error)) */
 173                 con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
 174 }
 175
 176 static void connection_read_for_eos_ssl(server *srv, connection *con) {
 177         if (con->network_read(srv, con, con->read_queue, MAX_READ_LIMIT) < 0)
 178                 con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
 179         chunkqueue_reset(con->read_queue);
 180 }
 181
 182 static void connection_read_for_eos(server *srv, connection *con) {
 183         !con->is_ssl_sock
 184           ? connection_read_for_eos_plain(srv, con)
 185           : connection_read_for_eos_ssl(srv, con);
 186 }
 187
 188 static void connection_handle_close_state(server *srv, connection *con) {
 189         connection_read_for_eos(srv, con);
 190
 191         if (srv->cur_ts - con->close_timeout_ts > HTTP_LINGER_TIMEOUT) {
 192                 connection_close(srv, con);
 193         }
 194 }
 195
 196 static void connection_handle_shutdown(server *srv, connection *con) {
 197         plugins_call_handle_connection_shut_wr(srv, con);
 198
 199         srv->con_closed++;
 200         connection_reset(srv, con);
 201
 202         /* close the connection */
 203         if (con->fd >= 0
 204             && (con->is_ssl_sock || 0 == shutdown(con->fd, SHUT_WR))) {
 205                 con->close_timeout_ts = srv->cur_ts;
 206                 connection_set_state(srv, con, CON_STATE_CLOSE);
 207
 208                 if (srv->srvconf.log_state_handling) {
 209                         log_error_write(srv, __FILE__, __LINE__, "sd",
 210                                         "shutdown for fd", con->fd);
 211                 }
 212         } else {
 213                 connection_close(srv, con);
 214         }
 215 }
 216
 217 static void connection_handle_response_end_state(server *srv, connection *con) {
 218         /* log the request */
 219         /* (even if error, connection dropped, still write to access log if http_status) */
 220         if (con->http_status) {
 221                 plugins_call_handle_request_done(srv, con);
 222         }
 223
 224         if (con->state != CON_STATE_ERROR) srv->con_written++;
 225
 226         if (con->request.content_length != con->request_content_queue->bytes_in
 227             || con->state == CON_STATE_ERROR) {
 228                 /* request body is present and has not been read completely */
 229                 con->keep_alive = 0;
 230         }
 231
 232         if (con->keep_alive) {
 233                 connection_reset(srv, con);
 234 #if 0
 235                 con->request_start = srv->cur_ts;
 236                 con->read_idle_ts = srv->cur_ts;
 237 #endif
 238                 connection_set_state(srv, con, CON_STATE_REQUEST_START);
 239         } else {
 240                 connection_handle_shutdown(srv, con);
 241         }
 242 }
 243
 244 static void connection_handle_errdoc_init(connection *con) {
 245         /* modules that produce headers required with error response should
 246          * typically also produce an error document.  Make an exception for
 247          * mod_auth WWW-Authenticate response header. */
 248         buffer *www_auth = NULL;
 249         if (401 == con->http_status) {
 250                 buffer *vb = http_header_response_get(con, HTTP_HEADER_OTHER, CONST_STR_LEN("WWW-Authenticate"));
 251                 if (NULL != vb) www_auth = buffer_init_buffer(vb);
 252         }
 253
 254         buffer_reset(con->physical.path);
 255         con->response.htags = 0;
 256         array_reset_data_strings(con->response.headers);
 257         http_response_body_clear(con, 0);
 258
 259         if (NULL != www_auth) {
 260                 http_header_response_set(con, HTTP_HEADER_OTHER, CONST_STR_LEN("WWW-Authenticate"), CONST_BUF_LEN(www_auth));
 261                 buffer_free(www_auth);
 262         }
 263 }
 264
 265 static int connection_handle_write_prepare(server *srv, connection *con) {
 266         if (con->mode == DIRECT) {
 267                 /* static files */
 268                 switch(con->request.http_method) {
 269                 case HTTP_METHOD_GET:
 270                 case HTTP_METHOD_POST:
 271                 case HTTP_METHOD_HEAD:
 272                         break;
 273                 case HTTP_METHOD_OPTIONS:
 274                         /*
 275                          * 400 is coming from the request-parser BEFORE uri.path is set
 276                          * 403 is from the response handler when noone else catched it
 277                          *
 278                          * */
 279                         if ((!con->http_status || con->http_status == 200) && !buffer_string_is_empty(con->uri.path) &&
 280                             con->uri.path->ptr[0] != '*') {
 281                                 http_response_body_clear(con, 0);
 282                                 http_header_response_append(con, HTTP_HEADER_OTHER, CONST_STR_LEN("Allow"), CONST_STR_LEN("OPTIONS, GET, HEAD, POST"));
 283                                 con->http_status = 200;
 284                                 con->file_finished = 1;
 285
 286                         }
 287                         break;
 288                 default:
 289                         if (0 == con->http_status) {
 290                                 con->http_status = 501;
 291                         }
 292                         break;
 293                 }
 294         }
 295
 296         if (con->http_status == 0) {
 297                 con->http_status = 403;
 298         }
 299
 300         switch(con->http_status) {
 301         case 204: /* class: header only */
 302         case 205:
 303         case 304:
 304                 /* disable chunked encoding again as we have no body */
 305                 http_response_body_clear(con, 1);
 306                 con->file_finished = 1;
 307                 break;
 308         default: /* class: header + body */
 309                 /* only custom body for 4xx and 5xx */
 310                 if (con->http_status < 400 || con->http_status >= 600) break;
 311
 312                 if (con->mode != DIRECT && (!con->conf.error_intercept || con->error_handler_saved_status)) break;
 313                 if (con->mode == DIRECT && con->error_handler_saved_status >= 65535) break;
 314
 315                 con->file_finished = 0;
 316
 317                 connection_handle_errdoc_init(con);
 318
 319                 /* try to send static errorfile */
 320                 if (!buffer_string_is_empty(con->conf.errorfile_prefix)) {
 321                         stat_cache_entry *sce = NULL;
 322
 323                         buffer_copy_buffer(con->physical.path, con->conf.errorfile_prefix);
 324                         buffer_append_int(con->physical.path, con->http_status);
 325                         buffer_append_string_len(con->physical.path, CONST_STR_LEN(".html"));
 326
 327                         if (0 == http_chunk_append_file(srv, con, con->physical.path)) {
 328                                 con->file_finished = 1;
 329                                 if (HANDLER_ERROR != stat_cache_get_entry(srv, con, con->physical.path, &sce)) {
 330                                         stat_cache_content_type_get(srv, con, con->physical.path, sce);
 331                                         http_header_response_set(con, HTTP_HEADER_CONTENT_TYPE, CONST_STR_LEN("Content-Type"), CONST_BUF_LEN(sce->content_type));
 332                                 }
 333                         }
 334                 }
 335
 336                 if (!con->file_finished) {
 337                         buffer *b = srv->tmp_buf;
 338
 339                         buffer_reset(con->physical.path);
 340
 341                         con->file_finished = 1;
 342
 343                         /* build default error-page */
 344                         buffer_copy_string_len(b, CONST_STR_LEN(
 345                                            "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n"
 346                                            "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
 347                                            "         \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"
 348                                            "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n"
 349                                            " <head>\n"
 350                                            "  <title>"));
 351                         http_status_append(b, con->http_status);
 352
 353                         buffer_append_string_len(b, CONST_STR_LEN(
 354                                              "</title>\n"
 355                                              " </head>\n"
 356                                              " <body>\n"
 357                                              "  <h1>"));
 358                         http_status_append(b, con->http_status);
 359
 360                         buffer_append_string_len(b, CONST_STR_LEN("</h1>\n"
 361                                              " </body>\n"
 362                                              "</html>\n"
 363                                              ));
 364
 365                         (void)http_chunk_append_mem(srv, con, CONST_BUF_LEN(b));
 366
 367                         http_header_response_set(con, HTTP_HEADER_CONTENT_TYPE, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html"));
 368                 }
 369                 break;
 370         }
 371
 372         /* Allow filter plugins to change response headers before they are written. */
 373         switch(plugins_call_handle_response_start(srv, con)) {
 374         case HANDLER_GO_ON:
 375         case HANDLER_FINISHED:
 376                 break;
 377         default:
 378                 log_error_write(srv, __FILE__, __LINE__, "s", "response_start plugin failed");
 379                 return -1;
 380         }
 381
 382         if (con->file_finished) {
 383                 /* we have all the content and chunked encoding is not used, set a content-length */
 384
 385                 if (!(con->response.htags & (HTTP_HEADER_CONTENT_LENGTH|HTTP_HEADER_TRANSFER_ENCODING))) {
 386                         off_t qlen = chunkqueue_length(con->write_queue);
 387
 388                         /**
 389                          * The Content-Length header only can be sent if we have content:
 390                          * - HEAD doesn't have a content-body (but have a content-length)
 391                          * - 1xx, 204 and 304 don't have a content-body (RFC 2616 Section 4.3)
 392                          *
 393                          * Otherwise generate a Content-Length header as chunked encoding is not
 394                          * available
 395                          */
 396                         if ((con->http_status >= 100 && con->http_status < 200) ||
 397                             con->http_status == 204 ||
 398                             con->http_status == 304) {
 399                                 /* no Content-Body, no Content-Length */
 400                                 http_header_response_unset(con, HTTP_HEADER_CONTENT_LENGTH, CONST_STR_LEN("Content-Length"));
 401                         } else if (qlen > 0 || con->request.http_method != HTTP_METHOD_HEAD) {
 402                                 /* qlen = 0 is important for Redirects (301, ...) as they MAY have
 403                                  * a content. Browsers are waiting for a Content otherwise
 404                                  */
 405                                 buffer_copy_int(srv->tmp_buf, qlen);
 406                                 http_header_response_set(con, HTTP_HEADER_CONTENT_LENGTH, CONST_STR_LEN("Content-Length"), CONST_BUF_LEN(srv->tmp_buf));
 407                         }
 408                 }
 409         } else {
 410                 /**
 411                  * the file isn't finished yet, but we have all headers
 412                  *
 413                  * to get keep-alive we either need:
 414                  * - Content-Length: ... (HTTP/1.0 and HTTP/1.0) or
 415                  * - Transfer-Encoding: chunked (HTTP/1.1)
 416                  * - Upgrade: ... (lighttpd then acts as transparent proxy)
 417                  */
 418
 419                 if (!(con->response.htags & (HTTP_HEADER_CONTENT_LENGTH|HTTP_HEADER_TRANSFER_ENCODING|HTTP_HEADER_UPGRADE))) {
 420                         if (con->request.http_method == HTTP_METHOD_CONNECT
 421                             && con->http_status == 200) {
 422                                 /*(no transfer-encoding if successful CONNECT)*/
 423                         } else if (con->request.http_version == HTTP_VERSION_1_1) {
 424                                 off_t qlen = chunkqueue_length(con->write_queue);
 425                                 con->response.send_chunked = 1;
 426                                 if (qlen) {
 427                                         /* create initial Transfer-Encoding: chunked segment */
 428                                         buffer * const b = chunkqueue_prepend_buffer_open(con->write_queue);
 429                                         buffer_append_uint_hex(b, (uintmax_t)qlen);
 430                                         buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
 431                                         chunkqueue_prepend_buffer_commit(con->write_queue);
 432                                         chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("\r\n"));
 433                                 }
 434                                 http_header_response_append(con, HTTP_HEADER_TRANSFER_ENCODING, CONST_STR_LEN("Transfer-Encoding"), CONST_STR_LEN("chunked"));
 435                         } else {
 436                                 con->keep_alive = 0;
 437                         }
 438                 }
 439         }
 440
 441         if (con->request.http_method == HTTP_METHOD_HEAD) {
 442                 /**
 443                  * a HEAD request has the same as a GET
 444                  * without the content
 445                  */
 446                 http_response_body_clear(con, 1);
 447                 con->file_finished = 1;
 448         }
 449
 450         http_response_write_header(srv, con);
 451
 452         return 0;
 453 }
 454
 455 static void connection_handle_write(server *srv, connection *con) {
 456         switch(connection_write_chunkqueue(srv, con, con->write_queue, MAX_WRITE_LIMIT)) {
 457         case 0:
 458                 con->write_request_ts = srv->cur_ts;
 459                 if (con->file_finished) {
 460                         connection_set_state(srv, con, CON_STATE_RESPONSE_END);
 461                 }
 462                 break;
 463         case -1: /* error on our side */
 464                 log_error_write(srv, __FILE__, __LINE__, "sd",
 465                                 "connection closed: write failed on fd", con->fd);
 466                 connection_set_state(srv, con, CON_STATE_ERROR);
 467                 break;
 468         case -2: /* remote close */
 469                 connection_set_state(srv, con, CON_STATE_ERROR);
 470                 break;
 471         case 1:
 472                 con->write_request_ts = srv->cur_ts;
 473                 con->is_writable = 0;
 474
 475                 /* not finished yet -> WRITE */
 476                 break;
 477         }
 478 }
 479
 480 static void connection_handle_write_state(server *srv, connection *con) {
 481     do {
 482         /* only try to write if we have something in the queue */
 483         if (!chunkqueue_is_empty(con->write_queue)) {
 484             if (con->is_writable) {
 485                 connection_handle_write(srv, con);
 486                 if (con->state != CON_STATE_WRITE) break;
 487             }
 488         } else if (con->file_finished) {
 489             connection_set_state(srv, con, CON_STATE_RESPONSE_END);
 490             break;
 491         }
 492
 493         if (con->mode != DIRECT && !con->file_finished) {
 494             int r = plugins_call_handle_subrequest(srv, con);
 495             switch(r) {
 496             case HANDLER_WAIT_FOR_EVENT:
 497             case HANDLER_FINISHED:
 498             case HANDLER_GO_ON:
 499                 break;
 500             case HANDLER_WAIT_FOR_FD:
 501                 srv->want_fds++;
 502                 fdwaitqueue_append(srv, con);
 503                 break;
 504             case HANDLER_COMEBACK:
 505             default:
 506                 log_error_write(srv, __FILE__, __LINE__, "sdd",
 507                                 "unexpected subrequest handler ret-value:",
 508                                 con->fd, r);
 509                 /* fall through */
 510             case HANDLER_ERROR:
 511                 connection_set_state(srv, con, CON_STATE_ERROR);
 512                 break;
 513             }
 514         }
 515     } while (con->state == CON_STATE_WRITE
 516              && (!chunkqueue_is_empty(con->write_queue)
 517                  ? con->is_writable
 518                  : con->file_finished));
 519 }
 520
 521
 522
 523 __attribute_cold__
 524 static connection *connection_init(server *srv) {
 525         connection *con;
 526
 527         UNUSED(srv);
 528
 529         con = calloc(1, sizeof(*con));
 530         force_assert(NULL != con);
 531
 532         con->fd = 0;
 533         con->ndx = -1;
 534         con->bytes_written = 0;
 535         con->bytes_read = 0;
 536         con->bytes_header = 0;
 537         con->loops_per_request = 0;
 538
 539 #define CLEAN(x) \
 540         con->x = buffer_init();
 541
 542         CLEAN(request.uri);
 543         CLEAN(request.request);
 544         CLEAN(request.pathinfo);
 545
 546         CLEAN(request.orig_uri);
 547
 548         CLEAN(uri.scheme);
 549         CLEAN(uri.authority);
 550         CLEAN(uri.path);
 551         CLEAN(uri.path_raw);
 552         CLEAN(uri.query);
 553
 554         CLEAN(physical.doc_root);
 555         CLEAN(physical.path);
 556         CLEAN(physical.basedir);
 557         CLEAN(physical.rel_path);
 558         CLEAN(physical.etag);
 559
 560         CLEAN(server_name);
 561         CLEAN(proto);
 562         CLEAN(dst_addr_buf);
 563
 564 #undef CLEAN
 565         con->write_queue = chunkqueue_init();
 566         con->read_queue = chunkqueue_init();
 567         con->request_content_queue = chunkqueue_init();
 568
 569         con->request.headers      = array_init();
 570         con->response.headers     = array_init();
 571         con->environment     = array_init();
 572
 573         /* init plugin specific connection structures */
 574
 575         con->plugin_ctx = calloc(1, (srv->plugins.used + 1) * sizeof(void *));
 576         force_assert(NULL != con->plugin_ctx);
 577
 578         con->cond_cache = calloc(srv->config_context->used, sizeof(cond_cache_t));
 579         force_assert(NULL != con->cond_cache);
 580         config_setup_connection(srv, con);
 581
 582         return con;
 583 }
 584
 585 void connections_free(server *srv) {
 586         connections *conns = srv->conns;
 587         size_t i;
 588
 589         if (NULL == conns) return;
 590
 591         for (i = 0; i < conns->size; i++) {
 592                 connection *con = conns->ptr[i];
 593
 594                 connection_reset(srv, con);
 595
 596                 chunkqueue_free(con->write_queue);
 597                 chunkqueue_free(con->read_queue);
 598                 chunkqueue_free(con->request_content_queue);
 599                 array_free(con->request.headers);
 600                 array_free(con->response.headers);
 601                 array_free(con->environment);
 602
 603 #define CLEAN(x) \
 604         buffer_free(con->x);
 605
 606                 CLEAN(request.uri);
 607                 CLEAN(request.request);
 608                 CLEAN(request.pathinfo);
 609
 610                 CLEAN(request.orig_uri);
 611
 612                 CLEAN(uri.scheme);
 613                 CLEAN(uri.authority);
 614                 CLEAN(uri.path);
 615                 CLEAN(uri.path_raw);
 616                 CLEAN(uri.query);
 617
 618                 CLEAN(physical.doc_root);
 619                 CLEAN(physical.path);
 620                 CLEAN(physical.basedir);
 621                 CLEAN(physical.etag);
 622                 CLEAN(physical.rel_path);
 623
 624                 CLEAN(server_name);
 625                 CLEAN(proto);
 626                 CLEAN(dst_addr_buf);
 627 #undef CLEAN
 628                 free(con->plugin_ctx);
 629                 free(con->cond_cache);
 630
 631                 free(con);
 632         }
 633
 634         free(conns->ptr);
 635         free(conns);
 636         srv->conns = NULL;
 637 }
 638
 639
 640 static int connection_reset(server *srv, connection *con) {
 641         plugins_call_connection_reset(srv, con);
 642
 643         connection_response_reset(srv, con);
 644         con->is_readable = 1;
 645
 646         con->bytes_written = 0;
 647         con->bytes_written_cur_second = 0;
 648         con->bytes_read = 0;
 649         con->bytes_header = 0;
 650         con->loops_per_request = 0;
 651
 652         con->request.http_method = HTTP_METHOD_UNSET;
 653         con->request.http_version = HTTP_VERSION_UNSET;
 654
 655 #define CLEAN(x) \
 656         buffer_reset(con->x);
 657
 658         CLEAN(request.uri);
 659         CLEAN(request.pathinfo);
 660
 661         /* CLEAN(request.orig_uri); */
 662
 663         /* CLEAN(uri.path); */
 664         CLEAN(uri.path_raw);
 665         /* CLEAN(uri.query); */
 666 #undef CLEAN
 667
 668         buffer_clear(con->uri.scheme);
 669         /*buffer_clear(con->proto);*//* set to default in connection_accepted() */
 670         /*buffer_clear(con->uri.authority);*/
 671         buffer_clear(con->server_name);
 672
 673         con->request.http_host = NULL;
 674         con->request.content_length = 0;
 675         con->request.te_chunked = 0;
 676         con->request.htags = 0;
 677
 678         array_reset_data_strings(con->request.headers);
 679         array_reset_data_strings(con->environment);
 680
 681         chunkqueue_reset(con->request_content_queue);
 682
 683         /* The cond_cache gets reset in response.c */
 684         /* config_cond_cache_reset(srv, con); */
 685
 686         con->header_len = 0;
 687         con->async_callback = 0;
 688         con->error_handler_saved_status = 0;
 689         /*con->error_handler_saved_method = HTTP_METHOD_UNSET;*/
 690         /*(error_handler_saved_method value is not valid unless error_handler_saved_status is set)*/
 691
 692         config_setup_connection(srv, con);
 693
 694         return 0;
 695 }
 696
 697 static void connection_read_header(server *srv, connection *con)  {
 698     chunkqueue * const cq = con->read_queue;
 699     chunk *c;
 700     size_t hlen = 0;
 701     int le = 0;
 702     buffer *save = NULL;
 703
 704     for (c = cq->first; c; c = c->next) {
 705         size_t clen = buffer_string_length(c->mem) - c->offset;
 706         const char * const b = c->mem->ptr + c->offset;
 707         const char *n = b;
 708         if (0 == clen) continue;
 709         if (le) { /*(line end sequence cross chunk boundary)*/
 710             if (n[0] == '\r')   ++n;
 711             if (n[0] == '\n') { ++n; hlen += n - b; break; }
 712             if (n[0] == '\0') { hlen += n - b; continue; }
 713             le = 0;
 714         }
 715         for (const char * const end = b+clen; (n = memchr(n,'\n',end-n)); ++n) {
 716             if (n[1] == '\r')   ++n;
 717             if (n[1] == '\n') { hlen += n - b + 2; break; }
 718             if (n[1] == '\0') { n = NULL; le = 1; break; }
 719         }
 720         if (n) break;
 721         hlen += clen;
 722     }
 723
 724     if (hlen > srv->srvconf.max_request_field_size) {
 725         log_error_write(srv, __FILE__, __LINE__, "s",
 726                         "oversized request-header -> sending Status 431");
 727         con->http_status = 431; /* Request Header Fields Too Large */
 728         con->keep_alive = 0;
 729         connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
 730     }
 731
 732     if (NULL == c) return; /* incomplete request headers */
 733
 734     con->header_len = hlen;
 735
 736     buffer_clear(con->request.request);
 737
 738     for (c = cq->first; c; c = c->next) {
 739         size_t len = buffer_string_length(c->mem) - c->offset;
 740         if (len > hlen) len = hlen;
 741         buffer_append_string_len(con->request.request,
 742                                  c->mem->ptr + c->offset, len);
 743         c->offset += len;
 744         cq->bytes_out += len;
 745         if (0 == (hlen -= len)) break;
 746     }
 747
 748     chunkqueue_remove_finished_chunks(cq);
 749
 750     /* skip past \r\n or \n after previous POST request when keep-alive */
 751     if (con->request_count > 1) {
 752         char * const s = con->request.request->ptr;
 753       #ifdef __COVERITY__
 754         if (buffer_string_length(con->request.request) < 2) {
 755             return;
 756         }
 757       #endif
 758         if (s[0] == '\r' && s[1] == '\n') {
 759             size_t len = buffer_string_length(con->request.request);
 760             memmove(s, s+2, len-2);
 761             buffer_string_set_length(con->request.request, len-2);
 762         }
 763         else if (s[0] == '\n') {
 764             if (!(con->conf.http_parseopts & HTTP_PARSEOPT_HEADER_STRICT)) {
 765                 size_t len = buffer_string_length(con->request.request);
 766                 memmove(s, s+1, len-1);
 767                 buffer_string_set_length(con->request.request, len-1);
 768             }
 769         }
 770     }
 771
 772     if (con->conf.log_request_header) {
 773         log_error_write(srv, __FILE__, __LINE__, "sdsdSb",
 774           "fd:", con->fd,
 775           "request-len:", buffer_string_length(con->request.request),
 776           "\n", con->request.request);
 777     }
 778
 779     buffer_clear(con->uri.authority);
 780     buffer_reset(con->uri.path);
 781     buffer_reset(con->uri.query);
 782     buffer_reset(con->request.orig_uri);
 783
 784     if (srv->srvconf.log_request_header_on_error) {
 785         /* copy request only if we may need to log it upon error */
 786         save = buffer_init_buffer(con->request.request);
 787     }
 788
 789     con->http_status = http_request_parse(srv, con, con->request.request);
 790     if (0 != con->http_status) {
 791         con->keep_alive = 0;
 792         con->request.content_length = 0;
 793
 794         if (srv->srvconf.log_request_header_on_error) {
 795             log_error_write(srv, __FILE__, __LINE__, "Sb",
 796                             "request-header:\n", save);
 797         }
 798     }
 799
 800     if (NULL != save) buffer_free(save);
 801     buffer_reset(con->request.request);
 802
 803     if (!con->conf.allow_http11) con->request.http_version = HTTP_VERSION_1_0;
 804
 805     connection_set_state(srv, con, CON_STATE_REQUEST_END);
 806 }
 807
 808 /**
 809  * handle request header read
 810  *
 811  * we get called by the state-engine and by the fdevent-handler
 812  */
 813 static int connection_handle_read_state(server *srv, connection *con)  {
 814         int is_closed = 0; /* the connection got closed, if we don't have a complete header, -> error */
 815
 816         if (con->request_count > 1 && 0 == con->bytes_read) {
 817
 818                 /* update request_start timestamp when first byte of
 819                  * next request is received on a keep-alive connection */
 820                 con->request_start = srv->cur_ts;
 821                 if (con->conf.high_precision_timestamps)
 822                         log_clock_gettime_realtime(&con->request_start_hp);
 823
 824                 if (!chunkqueue_is_empty(con->read_queue)) {
 825                         /*(if partially read next request and unable to read() any bytes below,
 826                          * then will unnecessarily scan again here before subsequent read())*/
 827                         connection_read_header(srv, con);
 828                         if (con->state != CON_STATE_READ) {
 829                                 con->read_idle_ts = srv->cur_ts;
 830                                 return 0;
 831                         }
 832                 }
 833         }
 834
 835         if (con->is_readable) {
 836                 con->read_idle_ts = srv->cur_ts;
 837
 838                 switch (con->network_read(srv, con, con->read_queue, MAX_READ_LIMIT)) {
 839                 case -1:
 840                         connection_set_state(srv, con, CON_STATE_ERROR);
 841                         return -1;
 842                 case -2:
 843                         is_closed = 1;
 844                         break;
 845                 default:
 846                         break;
 847                 }
 848         }
 849
 850         connection_read_header(srv, con);
 851
 852         if (con->state == CON_STATE_READ && is_closed) {
 853                 /* the connection got closed and we didn't got enough data to leave CON_STATE_READ;
 854                  * the only way is to leave here */
 855                 connection_set_state(srv, con, CON_STATE_ERROR);
 856         }
 857
 858         return 0;
 859 }
 860
 861 static handler_t connection_handle_fdevent(server *srv, void *context, int revents) {
 862         connection *con = context;
 863
 864         joblist_append(srv, con);
 865
 866         if (con->is_ssl_sock) {
 867                 /* ssl may read and write for both reads and writes */
 868                 if (revents & (FDEVENT_IN | FDEVENT_OUT)) {
 869                         con->is_readable = 1;
 870                         con->is_writable = 1;
 871                 }
 872         } else {
 873                 if (revents & FDEVENT_IN) {
 874                         con->is_readable = 1;
 875                 }
 876                 if (revents & FDEVENT_OUT) {
 877                         con->is_writable = 1;
 878                         /* we don't need the event twice */
 879                 }
 880         }
 881
 882
 883         if (con->state == CON_STATE_READ) {
 884                 connection_handle_read_state(srv, con);
 885         }
 886
 887         if (con->state == CON_STATE_WRITE &&
 888             !chunkqueue_is_empty(con->write_queue) &&
 889             con->is_writable) {
 890                 connection_handle_write(srv, con);
 891         }
 892
 893         if (con->state == CON_STATE_CLOSE) {
 894                 /* flush the read buffers */
 895                 connection_read_for_eos(srv, con);
 896         }
 897
 898
 899         /* attempt (above) to read data in kernel socket buffers
 900          * prior to handling FDEVENT_HUP and FDEVENT_ERR */
 901
 902         if ((revents & ~(FDEVENT_IN | FDEVENT_OUT)) && con->state != CON_STATE_ERROR) {
 903                 if (con->state == CON_STATE_CLOSE) {
 904                         con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
 905                 } else if (revents & FDEVENT_HUP) {
 906                         connection_set_state(srv, con, CON_STATE_ERROR);
 907                 } else if (revents & FDEVENT_RDHUP) {
 908                         int events = fdevent_event_get_interest(srv->ev, con->fd);
 909                         events &= ~(FDEVENT_IN|FDEVENT_RDHUP);
 910                         con->conf.stream_request_body &= ~(FDEVENT_STREAM_REQUEST_BUFMIN|FDEVENT_STREAM_REQUEST_POLLIN);
 911                         con->conf.stream_request_body |= FDEVENT_STREAM_REQUEST_POLLRDHUP;
 912                         con->is_readable = 1; /*(can read 0 for end-of-stream)*/
 913                         if (chunkqueue_is_empty(con->read_queue)) con->keep_alive = 0;
 914                         if (con->request.content_length < -1) { /*(transparent proxy mode; no more data to read)*/
 915                                 con->request.content_length = con->request_content_queue->bytes_in;
 916                         }
 917                         if (sock_addr_get_family(&con->dst_addr) == AF_UNIX) {
 918                                 /* future: will getpeername() on AF_UNIX properly check if still connected? */
 919                                 fdevent_event_set(srv->ev, con->fd, events);
 920                         } else if (fdevent_is_tcp_half_closed(con->fd)) {
 921                                 /* Success of fdevent_is_tcp_half_closed() after FDEVENT_RDHUP indicates TCP FIN received,
 922                                  * but does not distinguish between client shutdown(fd, SHUT_WR) and client close(fd).
 923                                  * Remove FDEVENT_RDHUP so that we do not spin on the ready event.
 924                                  * However, a later TCP RST will not be detected until next write to socket.
 925                                  * future: might getpeername() to check for TCP RST on half-closed sockets
 926                                  * (without FDEVENT_RDHUP interest) when checking for write timeouts
 927                                  * once a second in server.c, though getpeername() on Windows might not indicate this */
 928                                 con->conf.stream_request_body |= FDEVENT_STREAM_REQUEST_TCP_FIN;
 929                                 fdevent_event_set(srv->ev, con->fd, events);
 930                         } else {
 931                                 /* Failure of fdevent_is_tcp_half_closed() indicates TCP RST
 932                                  * (or unable to tell (unsupported OS), though should not
 933                                  * be setting FDEVENT_RDHUP in that case) */
 934                                 connection_set_state(srv, con, CON_STATE_ERROR);
 935                         }
 936                 } else if (revents & FDEVENT_ERR) { /* error, connection reset */
 937                         connection_set_state(srv, con, CON_STATE_ERROR);
 938                 } else {
 939                         log_error_write(srv, __FILE__, __LINE__, "sd",
 940                                         "connection closed: poll() -> ???", revents);
 941                 }
 942         }
 943
 944         return HANDLER_FINISHED;
 945 }
 946
 947
 948 connection *connection_accept(server *srv, server_socket *srv_socket) {
 949         int cnt;
 950         sock_addr cnt_addr;
 951         size_t cnt_len = sizeof(cnt_addr); /*(size_t intentional; not socklen_t)*/
 952
 953         /**
 954          * check if we can still open a new connections
 955          *
 956          * see #1216
 957          */
 958
 959         if (srv->conns->used >= srv->max_conns) {
 960                 return NULL;
 961         }
 962
 963         cnt = fdevent_accept_listenfd(srv_socket->fd, (struct sockaddr *) &cnt_addr, &cnt_len);
 964         if (-1 == cnt) {
 965                 switch (errno) {
 966                 case EAGAIN:
 967 #if EWOULDBLOCK != EAGAIN
 968                 case EWOULDBLOCK:
 969 #endif
 970                 case EINTR:
 971                         /* we were stopped _before_ we had a connection */
 972                 case ECONNABORTED: /* this is a FreeBSD thingy */
 973                         /* we were stopped _after_ we had a connection */
 974                         break;
 975                 case EMFILE:
 976                         /* out of fds */
 977                         break;
 978                 default:
 979                         log_error_write(srv, __FILE__, __LINE__, "ssd", "accept failed:", strerror(errno), errno);
 980                 }
 981                 return NULL;
 982         } else {
 983                 if (sock_addr_get_family(&cnt_addr) != AF_UNIX) {
 984                         network_accept_tcp_nagle_disable(cnt);
 985                 }
 986                 return connection_accepted(srv, srv_socket, &cnt_addr, cnt);
 987         }
 988 }
 989
 990
 991 /* 0: everything ok, -1: error, -2: con closed */
 992 static int connection_read_cq(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
 993         ssize_t len;
 994         char *mem = NULL;
 995         size_t mem_len = 0;
 996         force_assert(cq == con->read_queue);       /*(code transform assumption; minimize diff)*/
 997         force_assert(max_bytes == MAX_READ_LIMIT); /*(code transform assumption; minimize diff)*/
 998
 999         /* check avail data to read and obtain memory into which to read
1000          * fill previous chunk if it has sufficient space
1001          * (use mem_len=0 to obtain large buffer at least half of chunk_buf_sz)
1002          */
1003         {
1004                 int frd;
1005                 if (0 == fdevent_ioctl_fionread(con->fd, S_IFSOCK, &frd)) {
1006                         mem_len = (frd < MAX_READ_LIMIT) ? (size_t)frd : MAX_READ_LIMIT;
1007                 }
1008         }
1009         mem = chunkqueue_get_memory(con->read_queue, &mem_len);
1010
1011 #if defined(__WIN32)
1012         len = recv(con->fd, mem, mem_len, 0);
1013 #else
1014         len = read(con->fd, mem, mem_len);
1015 #endif /* __WIN32 */
1016
1017         chunkqueue_use_memory(con->read_queue, len > 0 ? len : 0);
1018
1019         if (len < 0) {
1020                 con->is_readable = 0;
1021
1022 #if defined(__WIN32)
1023                 {
1024                         int lastError = WSAGetLastError();
1025                         switch (lastError) {
1026                         case EAGAIN:
1027                                 return 0;
1028                         case EINTR:
1029                                 /* we have been interrupted before we could read */
1030                                 con->is_readable = 1;
1031                                 return 0;
1032                         case ECONNRESET:
1033                                 /* suppress logging for this error, expected for keep-alive */
1034                                 break;
1035                         default:
1036                                 log_error_write(srv, __FILE__, __LINE__, "sd", "connection closed - recv failed: ", lastError);
1037                                 break;
1038                         }
1039                 }
1040 #else /* __WIN32 */
1041                 switch (errno) {
1042                 case EAGAIN:
1043                         return 0;
1044                 case EINTR:
1045                         /* we have been interrupted before we could read */
1046                         con->is_readable = 1;
1047                         return 0;
1048                 case ECONNRESET:
1049                         /* suppress logging for this error, expected for keep-alive */
1050                         break;
1051                 default:
1052                         log_error_write(srv, __FILE__, __LINE__, "ssd", "connection closed - read failed: ", strerror(errno), errno);
1053                         break;
1054                 }
1055 #endif /* __WIN32 */
1056
1057                 connection_set_state(srv, con, CON_STATE_ERROR);
1058
1059                 return -1;
1060         } else if (len == 0) {
1061                 con->is_readable = 0;
1062                 /* the other end close the connection -> KEEP-ALIVE */
1063
1064                 /* pipelining */
1065
1066                 return -2;
1067         } else if (len != (ssize_t) mem_len) {
1068                 /* we got less then expected, wait for the next fd-event */
1069
1070                 con->is_readable = 0;
1071         }
1072
1073         con->bytes_read += len;
1074         return 0;
1075 }
1076
1077
1078 static int connection_write_cq(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
1079         return srv->network_backend_write(srv, con->fd, cq, max_bytes);
1080 }
1081
1082
1083 connection *connection_accepted(server *srv, server_socket *srv_socket, sock_addr *cnt_addr, int cnt) {
1084                 connection *con;
1085
1086                 srv->cur_fds++;
1087
1088                 /* ok, we have the connection, register it */
1089 #if 0
1090                 log_error_write(srv, __FILE__, __LINE__, "sd",
1091                                 "appected()", cnt);
1092 #endif
1093                 srv->con_opened++;
1094
1095                 con = connections_get_new_connection(srv);
1096
1097                 con->fd = cnt;
1098                 fdevent_register(srv->ev, con->fd, connection_handle_fdevent, con);
1099                 con->network_read = connection_read_cq;
1100                 con->network_write = connection_write_cq;
1101
1102                 connection_set_state(srv, con, CON_STATE_REQUEST_START);
1103
1104                 con->connection_start = srv->cur_ts;
1105                 con->dst_addr = *cnt_addr;
1106                 buffer_copy_string(con->dst_addr_buf, inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
1107                 con->srv_socket = srv_socket;
1108                 con->is_ssl_sock = srv_socket->is_ssl;
1109
1110                 config_cond_cache_reset(srv, con);
1111                 con->conditional_is_valid[COMP_SERVER_SOCKET] = 1;
1112                 con->conditional_is_valid[COMP_HTTP_REMOTE_IP] = 1;
1113
1114                 buffer_copy_string_len(con->proto, CONST_STR_LEN("http"));
1115                 if (HANDLER_GO_ON != plugins_call_handle_connection_accept(srv, con)) {
1116                         connection_reset(srv, con);
1117                         connection_close(srv, con);
1118                         return NULL;
1119                 }
1120                 if (con->http_status < 0) connection_set_state(srv, con, CON_STATE_WRITE);
1121                 return con;
1122 }
1123
1124
1125 static int connection_handle_request(server *srv, connection *con) {
1126                         int r = http_response_prepare(srv, con);
1127                         switch (r) {
1128                         case HANDLER_WAIT_FOR_EVENT:
1129                                 if (!con->file_finished && (!con->file_started || 0 == con->conf.stream_response_body)) {
1130                                         break; /* come back here */
1131                                 }
1132                                 /* response headers received from backend; fall through to start response */
1133                                 /* fall through */
1134                         case HANDLER_FINISHED:
1135                                 if (con->http_status == 0) con->http_status = 200;
1136                                 if (con->error_handler_saved_status > 0) {
1137                                         con->request.http_method = con->error_handler_saved_method;
1138                                 }
1139                                 if (con->mode == DIRECT || con->conf.error_intercept) {
1140                                         if (con->error_handler_saved_status) {
1141                                                 const int subreq_status = con->http_status;
1142                                                 if (con->error_handler_saved_status > 0) {
1143                                                         con->http_status = con->error_handler_saved_status;
1144                                                 } else if (con->http_status == 404 || con->http_status == 403) {
1145                                                         /* error-handler-404 is a 404 */
1146                                                         con->http_status = -con->error_handler_saved_status;
1147                                                 } else {
1148                                                         /* error-handler-404 is back and has generated content */
1149                                                         /* if Status: was set, take it otherwise use 200 */
1150                                                 }
1151                                                 if (200 <= subreq_status && subreq_status <= 299) {
1152                                                         /*(flag value to indicate that error handler succeeded)
1153                                                          *(for (con->mode == DIRECT))*/
1154                                                         con->error_handler_saved_status = 65535; /* >= 1000 */
1155                                                 }
1156                                         } else if (con->http_status >= 400) {
1157                                                 buffer *error_handler = NULL;
1158                                                 if (!buffer_string_is_empty(con->conf.error_handler)) {
1159                                                         error_handler = con->conf.error_handler;
1160                                                 } else if ((con->http_status == 404 || con->http_status == 403)
1161                                                            && !buffer_string_is_empty(con->conf.error_handler_404)) {
1162                                                         error_handler = con->conf.error_handler_404;
1163                                                 }
1164
1165                                                 if (error_handler) {
1166                                                         /* call error-handler */
1167
1168                                                         /* set REDIRECT_STATUS to save current HTTP status code
1169                                                          * for access by dynamic handlers
1170                                                          * https://redmine.lighttpd.net/issues/1828 */
1171                                                         buffer_copy_int(srv->tmp_buf, con->http_status);
1172                                                         http_header_env_set(con, CONST_STR_LEN("REDIRECT_STATUS"), CONST_BUF_LEN(srv->tmp_buf));
1173
1174                                                         if (error_handler == con->conf.error_handler) {
1175                                                                 plugins_call_connection_reset(srv, con);
1176
1177                                                                 if (con->request.content_length) {
1178                                                                         if (con->request.content_length != con->request_content_queue->bytes_in) {
1179                                                                                 con->keep_alive = 0;
1180                                                                         }
1181                                                                         con->request.content_length = 0;
1182                                                                         chunkqueue_reset(con->request_content_queue);
1183                                                                 }
1184
1185                                                                 con->is_writable = 1;
1186                                                                 con->file_finished = 0;
1187                                                                 con->file_started = 0;
1188
1189                                                                 con->error_handler_saved_status = con->http_status;
1190                                                                 con->error_handler_saved_method = con->request.http_method;
1191
1192                                                                 con->request.http_method = HTTP_METHOD_GET;
1193                                                         } else { /*(preserve behavior for server.error-handler-404)*/
1194                                                                 con->error_handler_saved_status = -con->http_status; /*(negative to flag old behavior)*/
1195                                                         }
1196
1197                                                         buffer_copy_buffer(con->request.uri, error_handler);
1198                                                         connection_handle_errdoc_init(con);
1199                                                         con->http_status = 0; /*(after connection_handle_errdoc_init())*/
1200
1201                                                         return 1;
1202                                                 }
1203                                         }
1204                                 }
1205
1206                                 /* we have something to send, go on */
1207                                 connection_set_state(srv, con, CON_STATE_RESPONSE_START);
1208                                 break;
1209                         case HANDLER_WAIT_FOR_FD:
1210                                 srv->want_fds++;
1211
1212                                 fdwaitqueue_append(srv, con);
1213
1214                                 break;
1215                         case HANDLER_COMEBACK:
1216                                 return 1;
1217                         case HANDLER_ERROR:
1218                                 /* something went wrong */
1219                                 connection_set_state(srv, con, CON_STATE_ERROR);
1220                                 break;
1221                         default:
1222                                 log_error_write(srv, __FILE__, __LINE__, "sdd", "unknown ret-value: ", con->fd, r);
1223                                 break;
1224                         }
1225
1226                         return 0;
1227 }
1228
1229
1230 int connection_state_machine(server *srv, connection *con) {
1231         connection_state_t ostate;
1232         int r;
1233
1234         if (srv->srvconf.log_state_handling) {
1235                 log_error_write(srv, __FILE__, __LINE__, "sds",
1236                                 "state at enter",
1237                                 con->fd,
1238                                 connection_get_state(con->state));
1239         }
1240
1241         do {
1242                 if (srv->srvconf.log_state_handling) {
1243                         log_error_write(srv, __FILE__, __LINE__, "sds",
1244                                         "state for fd", con->fd, connection_get_state(con->state));
1245                 }
1246
1247                 switch ((ostate = con->state)) {
1248                 case CON_STATE_REQUEST_START: /* transient */
1249                         con->request_start = srv->cur_ts;
1250                         con->read_idle_ts = srv->cur_ts;
1251                         if (con->conf.high_precision_timestamps)
1252                                 log_clock_gettime_realtime(&con->request_start_hp);
1253
1254                         con->request_count++;
1255                         con->loops_per_request = 0;
1256
1257                         connection_set_state(srv, con, CON_STATE_READ);
1258                         /* fall through */
1259                 case CON_STATE_READ:
1260                         connection_handle_read_state(srv, con);
1261                         if (con->state != CON_STATE_REQUEST_END) break;
1262                         /* fall through */
1263                 case CON_STATE_REQUEST_END: /* transient */
1264                         ostate = (0 == con->request.content_length)
1265                           ? CON_STATE_HANDLE_REQUEST
1266                           : CON_STATE_READ_POST;
1267                         connection_set_state(srv, con, ostate);
1268                         /* fall through */
1269                 case CON_STATE_READ_POST:
1270                 case CON_STATE_HANDLE_REQUEST:
1271                         if (connection_handle_request(srv, con)) {
1272                                 /* redo loop; will not match con->state */
1273                                 ostate = CON_STATE_CONNECT;
1274                                 break;
1275                         }
1276
1277                         if (con->state == CON_STATE_HANDLE_REQUEST
1278                             && ostate == CON_STATE_READ_POST) {
1279                                 ostate = CON_STATE_HANDLE_REQUEST;
1280                         }
1281
1282                         if (con->state != CON_STATE_RESPONSE_START) break;
1283                         /* fall through */
1284                 case CON_STATE_RESPONSE_START: /* transient */
1285                         if (-1 == connection_handle_write_prepare(srv, con)) {
1286                                 connection_set_state(srv, con, CON_STATE_ERROR);
1287                                 break;
1288                         }
1289                         connection_set_state(srv, con, CON_STATE_WRITE);
1290                         /* fall through */
1291                 case CON_STATE_WRITE:
1292                         connection_handle_write_state(srv, con);
1293                         if (con->state != CON_STATE_RESPONSE_END) break;
1294                         /* fall through */
1295                 case CON_STATE_RESPONSE_END: /* transient */
1296                 case CON_STATE_ERROR:        /* transient */
1297                         connection_handle_response_end_state(srv, con);
1298                         break;
1299                 case CON_STATE_CLOSE:
1300                         connection_handle_close_state(srv, con);
1301                         break;
1302                 case CON_STATE_CONNECT:
1303                         break;
1304                 default:
1305                         log_error_write(srv, __FILE__, __LINE__, "sdd",
1306                                         "unknown state:", con->fd, con->state);
1307                         break;
1308                 }
1309         } while (ostate != con->state);
1310
1311         if (srv->srvconf.log_state_handling) {
1312                 log_error_write(srv, __FILE__, __LINE__, "sds",
1313                                 "state at exit:",
1314                                 con->fd,
1315                                 connection_get_state(con->state));
1316         }
1317
1318         r = 0;
1319         switch(con->state) {
1320         case CON_STATE_READ:
1321                 r = FDEVENT_IN | FDEVENT_RDHUP;
1322                 break;
1323         case CON_STATE_WRITE:
1324                 /* request write-fdevent only if we really need it
1325                  * - if we have data to write
1326                  * - if the socket is not writable yet
1327                  */
1328                 if (!chunkqueue_is_empty(con->write_queue) &&
1329                     (con->is_writable == 0) &&
1330                     (con->traffic_limit_reached == 0)) {
1331                         r |= FDEVENT_OUT;
1332                 }
1333                 /* fall through */
1334         case CON_STATE_READ_POST:
1335                 if (con->conf.stream_request_body & FDEVENT_STREAM_REQUEST_POLLIN) {
1336                         r |= FDEVENT_IN | FDEVENT_RDHUP;
1337                 }
1338                 break;
1339         case CON_STATE_CLOSE:
1340                 r = FDEVENT_IN;
1341                 break;
1342         default:
1343                 break;
1344         }
1345         if (con->fd >= 0) {
1346                 const int events = fdevent_event_get_interest(srv->ev, con->fd);
1347                 if (con->is_readable < 0) {
1348                         con->is_readable = 0;
1349                         r |= FDEVENT_IN;
1350                 }
1351                 if (con->is_writable < 0) {
1352                         con->is_writable = 0;
1353                         r |= FDEVENT_OUT;
1354                 }
1355                 if (events & FDEVENT_RDHUP) {
1356                         r |= FDEVENT_RDHUP;
1357                 }
1358                 if (r != events) {
1359                         /* update timestamps when enabling interest in events */
1360                         if ((r & FDEVENT_IN) && !(events & FDEVENT_IN)) {
1361                                 con->read_idle_ts = srv->cur_ts;
1362                         }
1363                         if ((r & FDEVENT_OUT) && !(events & FDEVENT_OUT)) {
1364                                 con->write_request_ts = srv->cur_ts;
1365                         }
1366                         fdevent_event_set(srv->ev, con->fd, r);
1367                 }
1368         }
1369
1370         return 0;
1371 }