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     connection_set_state(srv, con, CON_STATE_REQUEST_END);
 804 }
 805
 806 /**
 807  * handle request header read
 808  *
 809  * we get called by the state-engine and by the fdevent-handler
 810  */
 811 static int connection_handle_read_state(server *srv, connection *con)  {
 812         int is_closed = 0; /* the connection got closed, if we don't have a complete header, -> error */
 813
 814         if (con->request_count > 1 && 0 == con->bytes_read) {
 815
 816                 /* update request_start timestamp when first byte of
 817                  * next request is received on a keep-alive connection */
 818                 con->request_start = srv->cur_ts;
 819                 if (con->conf.high_precision_timestamps)
 820                         log_clock_gettime_realtime(&con->request_start_hp);
 821
 822                 if (!chunkqueue_is_empty(con->read_queue)) {
 823                         /*(if partially read next request and unable to read() any bytes below,
 824                          * then will unnecessarily scan again here before subsequent read())*/
 825                         connection_read_header(srv, con);
 826                         if (con->state != CON_STATE_READ) {
 827                                 con->read_idle_ts = srv->cur_ts;
 828                                 return 0;
 829                         }
 830                 }
 831         }
 832
 833         if (con->is_readable) {
 834                 con->read_idle_ts = srv->cur_ts;
 835
 836                 switch (con->network_read(srv, con, con->read_queue, MAX_READ_LIMIT)) {
 837                 case -1:
 838                         connection_set_state(srv, con, CON_STATE_ERROR);
 839                         return -1;
 840                 case -2:
 841                         is_closed = 1;
 842                         break;
 843                 default:
 844                         break;
 845                 }
 846         }
 847
 848         connection_read_header(srv, con);
 849
 850         if (con->state == CON_STATE_READ && is_closed) {
 851                 /* the connection got closed and we didn't got enough data to leave CON_STATE_READ;
 852                  * the only way is to leave here */
 853                 connection_set_state(srv, con, CON_STATE_ERROR);
 854         }
 855
 856         return 0;
 857 }
 858
 859 static handler_t connection_handle_fdevent(server *srv, void *context, int revents) {
 860         connection *con = context;
 861
 862         joblist_append(srv, con);
 863
 864         if (con->is_ssl_sock) {
 865                 /* ssl may read and write for both reads and writes */
 866                 if (revents & (FDEVENT_IN | FDEVENT_OUT)) {
 867                         con->is_readable = 1;
 868                         con->is_writable = 1;
 869                 }
 870         } else {
 871                 if (revents & FDEVENT_IN) {
 872                         con->is_readable = 1;
 873                 }
 874                 if (revents & FDEVENT_OUT) {
 875                         con->is_writable = 1;
 876                         /* we don't need the event twice */
 877                 }
 878         }
 879
 880
 881         if (con->state == CON_STATE_READ) {
 882                 connection_handle_read_state(srv, con);
 883         }
 884
 885         if (con->state == CON_STATE_WRITE &&
 886             !chunkqueue_is_empty(con->write_queue) &&
 887             con->is_writable) {
 888                 connection_handle_write(srv, con);
 889         }
 890
 891         if (con->state == CON_STATE_CLOSE) {
 892                 /* flush the read buffers */
 893                 connection_read_for_eos(srv, con);
 894         }
 895
 896
 897         /* attempt (above) to read data in kernel socket buffers
 898          * prior to handling FDEVENT_HUP and FDEVENT_ERR */
 899
 900         if ((revents & ~(FDEVENT_IN | FDEVENT_OUT)) && con->state != CON_STATE_ERROR) {
 901                 if (con->state == CON_STATE_CLOSE) {
 902                         con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
 903                 } else if (revents & FDEVENT_HUP) {
 904                         connection_set_state(srv, con, CON_STATE_ERROR);
 905                 } else if (revents & FDEVENT_RDHUP) {
 906                         int events = fdevent_event_get_interest(srv->ev, con->fd);
 907                         events &= ~(FDEVENT_IN|FDEVENT_RDHUP);
 908                         con->conf.stream_request_body &= ~(FDEVENT_STREAM_REQUEST_BUFMIN|FDEVENT_STREAM_REQUEST_POLLIN);
 909                         con->conf.stream_request_body |= FDEVENT_STREAM_REQUEST_POLLRDHUP;
 910                         con->is_readable = 1; /*(can read 0 for end-of-stream)*/
 911                         if (chunkqueue_is_empty(con->read_queue)) con->keep_alive = 0;
 912                         if (con->request.content_length < -1) { /*(transparent proxy mode; no more data to read)*/
 913                                 con->request.content_length = con->request_content_queue->bytes_in;
 914                         }
 915                         if (sock_addr_get_family(&con->dst_addr) == AF_UNIX) {
 916                                 /* future: will getpeername() on AF_UNIX properly check if still connected? */
 917                                 fdevent_event_set(srv->ev, con->fd, events);
 918                         } else if (fdevent_is_tcp_half_closed(con->fd)) {
 919                                 /* Success of fdevent_is_tcp_half_closed() after FDEVENT_RDHUP indicates TCP FIN received,
 920                                  * but does not distinguish between client shutdown(fd, SHUT_WR) and client close(fd).
 921                                  * Remove FDEVENT_RDHUP so that we do not spin on the ready event.
 922                                  * However, a later TCP RST will not be detected until next write to socket.
 923                                  * future: might getpeername() to check for TCP RST on half-closed sockets
 924                                  * (without FDEVENT_RDHUP interest) when checking for write timeouts
 925                                  * once a second in server.c, though getpeername() on Windows might not indicate this */
 926                                 con->conf.stream_request_body |= FDEVENT_STREAM_REQUEST_TCP_FIN;
 927                                 fdevent_event_set(srv->ev, con->fd, events);
 928                         } else {
 929                                 /* Failure of fdevent_is_tcp_half_closed() indicates TCP RST
 930                                  * (or unable to tell (unsupported OS), though should not
 931                                  * be setting FDEVENT_RDHUP in that case) */
 932                                 connection_set_state(srv, con, CON_STATE_ERROR);
 933                         }
 934                 } else if (revents & FDEVENT_ERR) { /* error, connection reset */
 935                         connection_set_state(srv, con, CON_STATE_ERROR);
 936                 } else {
 937                         log_error_write(srv, __FILE__, __LINE__, "sd",
 938                                         "connection closed: poll() -> ???", revents);
 939                 }
 940         }
 941
 942         return HANDLER_FINISHED;
 943 }
 944
 945
 946 connection *connection_accept(server *srv, server_socket *srv_socket) {
 947         int cnt;
 948         sock_addr cnt_addr;
 949         size_t cnt_len = sizeof(cnt_addr); /*(size_t intentional; not socklen_t)*/
 950
 951         /**
 952          * check if we can still open a new connections
 953          *
 954          * see #1216
 955          */
 956
 957         if (srv->conns->used >= srv->max_conns) {
 958                 return NULL;
 959         }
 960
 961         cnt = fdevent_accept_listenfd(srv_socket->fd, (struct sockaddr *) &cnt_addr, &cnt_len);
 962         if (-1 == cnt) {
 963                 switch (errno) {
 964                 case EAGAIN:
 965 #if EWOULDBLOCK != EAGAIN
 966                 case EWOULDBLOCK:
 967 #endif
 968                 case EINTR:
 969                         /* we were stopped _before_ we had a connection */
 970                 case ECONNABORTED: /* this is a FreeBSD thingy */
 971                         /* we were stopped _after_ we had a connection */
 972                         break;
 973                 case EMFILE:
 974                         /* out of fds */
 975                         break;
 976                 default:
 977                         log_error_write(srv, __FILE__, __LINE__, "ssd", "accept failed:", strerror(errno), errno);
 978                 }
 979                 return NULL;
 980         } else {
 981                 if (sock_addr_get_family(&cnt_addr) != AF_UNIX) {
 982                         network_accept_tcp_nagle_disable(cnt);
 983                 }
 984                 return connection_accepted(srv, srv_socket, &cnt_addr, cnt);
 985         }
 986 }
 987
 988
 989 /* 0: everything ok, -1: error, -2: con closed */
 990 static int connection_read_cq(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
 991         ssize_t len;
 992         char *mem = NULL;
 993         size_t mem_len = 0;
 994         force_assert(cq == con->read_queue);       /*(code transform assumption; minimize diff)*/
 995         force_assert(max_bytes == MAX_READ_LIMIT); /*(code transform assumption; minimize diff)*/
 996
 997         /* check avail data to read and obtain memory into which to read
 998          * fill previous chunk if it has sufficient space
 999          * (use mem_len=0 to obtain large buffer at least half of chunk_buf_sz)
1000          */
1001         {
1002                 int frd;
1003                 if (0 == fdevent_ioctl_fionread(con->fd, S_IFSOCK, &frd)) {
1004                         mem_len = (frd < MAX_READ_LIMIT) ? (size_t)frd : MAX_READ_LIMIT;
1005                 }
1006         }
1007         mem = chunkqueue_get_memory(con->read_queue, &mem_len);
1008
1009 #if defined(__WIN32)
1010         len = recv(con->fd, mem, mem_len, 0);
1011 #else
1012         len = read(con->fd, mem, mem_len);
1013 #endif /* __WIN32 */
1014
1015         chunkqueue_use_memory(con->read_queue, len > 0 ? len : 0);
1016
1017         if (len < 0) {
1018                 con->is_readable = 0;
1019
1020 #if defined(__WIN32)
1021                 {
1022                         int lastError = WSAGetLastError();
1023                         switch (lastError) {
1024                         case EAGAIN:
1025                                 return 0;
1026                         case EINTR:
1027                                 /* we have been interrupted before we could read */
1028                                 con->is_readable = 1;
1029                                 return 0;
1030                         case ECONNRESET:
1031                                 /* suppress logging for this error, expected for keep-alive */
1032                                 break;
1033                         default:
1034                                 log_error_write(srv, __FILE__, __LINE__, "sd", "connection closed - recv failed: ", lastError);
1035                                 break;
1036                         }
1037                 }
1038 #else /* __WIN32 */
1039                 switch (errno) {
1040                 case EAGAIN:
1041                         return 0;
1042                 case EINTR:
1043                         /* we have been interrupted before we could read */
1044                         con->is_readable = 1;
1045                         return 0;
1046                 case ECONNRESET:
1047                         /* suppress logging for this error, expected for keep-alive */
1048                         break;
1049                 default:
1050                         log_error_write(srv, __FILE__, __LINE__, "ssd", "connection closed - read failed: ", strerror(errno), errno);
1051                         break;
1052                 }
1053 #endif /* __WIN32 */
1054
1055                 connection_set_state(srv, con, CON_STATE_ERROR);
1056
1057                 return -1;
1058         } else if (len == 0) {
1059                 con->is_readable = 0;
1060                 /* the other end close the connection -> KEEP-ALIVE */
1061
1062                 /* pipelining */
1063
1064                 return -2;
1065         } else if (len != (ssize_t) mem_len) {
1066                 /* we got less then expected, wait for the next fd-event */
1067
1068                 con->is_readable = 0;
1069         }
1070
1071         con->bytes_read += len;
1072         return 0;
1073 }
1074
1075
1076 static int connection_write_cq(server *srv, connection *con, chunkqueue *cq, off_t max_bytes) {
1077         return srv->network_backend_write(srv, con->fd, cq, max_bytes);
1078 }
1079
1080
1081 connection *connection_accepted(server *srv, server_socket *srv_socket, sock_addr *cnt_addr, int cnt) {
1082                 connection *con;
1083
1084                 srv->cur_fds++;
1085
1086                 /* ok, we have the connection, register it */
1087 #if 0
1088                 log_error_write(srv, __FILE__, __LINE__, "sd",
1089                                 "appected()", cnt);
1090 #endif
1091                 srv->con_opened++;
1092
1093                 con = connections_get_new_connection(srv);
1094
1095                 con->fd = cnt;
1096                 fdevent_register(srv->ev, con->fd, connection_handle_fdevent, con);
1097                 con->network_read = connection_read_cq;
1098                 con->network_write = connection_write_cq;
1099
1100                 connection_set_state(srv, con, CON_STATE_REQUEST_START);
1101
1102                 con->connection_start = srv->cur_ts;
1103                 con->dst_addr = *cnt_addr;
1104                 buffer_copy_string(con->dst_addr_buf, inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
1105                 con->srv_socket = srv_socket;
1106                 con->is_ssl_sock = srv_socket->is_ssl;
1107
1108                 config_cond_cache_reset(srv, con);
1109                 con->conditional_is_valid[COMP_SERVER_SOCKET] = 1;
1110                 con->conditional_is_valid[COMP_HTTP_REMOTE_IP] = 1;
1111
1112                 buffer_copy_string_len(con->proto, CONST_STR_LEN("http"));
1113                 if (HANDLER_GO_ON != plugins_call_handle_connection_accept(srv, con)) {
1114                         connection_reset(srv, con);
1115                         connection_close(srv, con);
1116                         return NULL;
1117                 }
1118                 if (con->http_status < 0) connection_set_state(srv, con, CON_STATE_WRITE);
1119                 return con;
1120 }
1121
1122
1123 static int connection_handle_request(server *srv, connection *con) {
1124                         int r = http_response_prepare(srv, con);
1125                         switch (r) {
1126                         case HANDLER_WAIT_FOR_EVENT:
1127                                 if (!con->file_finished && (!con->file_started || 0 == con->conf.stream_response_body)) {
1128                                         break; /* come back here */
1129                                 }
1130                                 /* response headers received from backend; fall through to start response */
1131                                 /* fall through */
1132                         case HANDLER_FINISHED:
1133                                 if (con->http_status == 0) con->http_status = 200;
1134                                 if (con->error_handler_saved_status > 0) {
1135                                         con->request.http_method = con->error_handler_saved_method;
1136                                 }
1137                                 if (con->mode == DIRECT || con->conf.error_intercept) {
1138                                         if (con->error_handler_saved_status) {
1139                                                 const int subreq_status = con->http_status;
1140                                                 if (con->error_handler_saved_status > 0) {
1141                                                         con->http_status = con->error_handler_saved_status;
1142                                                 } else if (con->http_status == 404 || con->http_status == 403) {
1143                                                         /* error-handler-404 is a 404 */
1144                                                         con->http_status = -con->error_handler_saved_status;
1145                                                 } else {
1146                                                         /* error-handler-404 is back and has generated content */
1147                                                         /* if Status: was set, take it otherwise use 200 */
1148                                                 }
1149                                                 if (200 <= subreq_status && subreq_status <= 299) {
1150                                                         /*(flag value to indicate that error handler succeeded)
1151                                                          *(for (con->mode == DIRECT))*/
1152                                                         con->error_handler_saved_status = 65535; /* >= 1000 */
1153                                                 }
1154                                         } else if (con->http_status >= 400) {
1155                                                 buffer *error_handler = NULL;
1156                                                 if (!buffer_string_is_empty(con->conf.error_handler)) {
1157                                                         error_handler = con->conf.error_handler;
1158                                                 } else if ((con->http_status == 404 || con->http_status == 403)
1159                                                            && !buffer_string_is_empty(con->conf.error_handler_404)) {
1160                                                         error_handler = con->conf.error_handler_404;
1161                                                 }
1162
1163                                                 if (error_handler) {
1164                                                         /* call error-handler */
1165
1166                                                         /* set REDIRECT_STATUS to save current HTTP status code
1167                                                          * for access by dynamic handlers
1168                                                          * https://redmine.lighttpd.net/issues/1828 */
1169                                                         buffer_copy_int(srv->tmp_buf, con->http_status);
1170                                                         http_header_env_set(con, CONST_STR_LEN("REDIRECT_STATUS"), CONST_BUF_LEN(srv->tmp_buf));
1171
1172                                                         if (error_handler == con->conf.error_handler) {
1173                                                                 plugins_call_connection_reset(srv, con);
1174
1175                                                                 if (con->request.content_length) {
1176                                                                         if (con->request.content_length != con->request_content_queue->bytes_in) {
1177                                                                                 con->keep_alive = 0;
1178                                                                         }
1179                                                                         con->request.content_length = 0;
1180                                                                         chunkqueue_reset(con->request_content_queue);
1181                                                                 }
1182
1183                                                                 con->is_writable = 1;
1184                                                                 con->file_finished = 0;
1185                                                                 con->file_started = 0;
1186
1187                                                                 con->error_handler_saved_status = con->http_status;
1188                                                                 con->error_handler_saved_method = con->request.http_method;
1189
1190                                                                 con->request.http_method = HTTP_METHOD_GET;
1191                                                         } else { /*(preserve behavior for server.error-handler-404)*/
1192                                                                 con->error_handler_saved_status = -con->http_status; /*(negative to flag old behavior)*/
1193                                                         }
1194
1195                                                         buffer_copy_buffer(con->request.uri, error_handler);
1196                                                         connection_handle_errdoc_init(con);
1197                                                         con->http_status = 0; /*(after connection_handle_errdoc_init())*/
1198
1199                                                         return 1;
1200                                                 }
1201                                         }
1202                                 }
1203
1204                                 /* we have something to send, go on */
1205                                 connection_set_state(srv, con, CON_STATE_RESPONSE_START);
1206                                 break;
1207                         case HANDLER_WAIT_FOR_FD:
1208                                 srv->want_fds++;
1209
1210                                 fdwaitqueue_append(srv, con);
1211
1212                                 break;
1213                         case HANDLER_COMEBACK:
1214                                 return 1;
1215                         case HANDLER_ERROR:
1216                                 /* something went wrong */
1217                                 connection_set_state(srv, con, CON_STATE_ERROR);
1218                                 break;
1219                         default:
1220                                 log_error_write(srv, __FILE__, __LINE__, "sdd", "unknown ret-value: ", con->fd, r);
1221                                 break;
1222                         }
1223
1224                         return 0;
1225 }
1226
1227
1228 int connection_state_machine(server *srv, connection *con) {
1229         connection_state_t ostate;
1230         int r;
1231
1232         if (srv->srvconf.log_state_handling) {
1233                 log_error_write(srv, __FILE__, __LINE__, "sds",
1234                                 "state at enter",
1235                                 con->fd,
1236                                 connection_get_state(con->state));
1237         }
1238
1239         do {
1240                 if (srv->srvconf.log_state_handling) {
1241                         log_error_write(srv, __FILE__, __LINE__, "sds",
1242                                         "state for fd", con->fd, connection_get_state(con->state));
1243                 }
1244
1245                 switch ((ostate = con->state)) {
1246                 case CON_STATE_REQUEST_START: /* transient */
1247                         con->request_start = srv->cur_ts;
1248                         con->read_idle_ts = srv->cur_ts;
1249                         if (con->conf.high_precision_timestamps)
1250                                 log_clock_gettime_realtime(&con->request_start_hp);
1251
1252                         con->request_count++;
1253                         con->loops_per_request = 0;
1254
1255                         connection_set_state(srv, con, CON_STATE_READ);
1256                         /* fall through */
1257                 case CON_STATE_READ:
1258                         connection_handle_read_state(srv, con);
1259                         if (con->state != CON_STATE_REQUEST_END) break;
1260                         /* fall through */
1261                 case CON_STATE_REQUEST_END: /* transient */
1262                         ostate = (0 == con->request.content_length)
1263                           ? CON_STATE_HANDLE_REQUEST
1264                           : CON_STATE_READ_POST;
1265                         connection_set_state(srv, con, ostate);
1266                         /* fall through */
1267                 case CON_STATE_READ_POST:
1268                 case CON_STATE_HANDLE_REQUEST:
1269                         if (connection_handle_request(srv, con)) {
1270                                 /* redo loop; will not match con->state */
1271                                 ostate = CON_STATE_CONNECT;
1272                                 break;
1273                         }
1274
1275                         if (con->state == CON_STATE_HANDLE_REQUEST
1276                             && ostate == CON_STATE_READ_POST) {
1277                                 ostate = CON_STATE_HANDLE_REQUEST;
1278                         }
1279
1280                         if (con->state != CON_STATE_RESPONSE_START) break;
1281                         /* fall through */
1282                 case CON_STATE_RESPONSE_START: /* transient */
1283                         if (-1 == connection_handle_write_prepare(srv, con)) {
1284                                 connection_set_state(srv, con, CON_STATE_ERROR);
1285                                 break;
1286                         }
1287                         connection_set_state(srv, con, CON_STATE_WRITE);
1288                         /* fall through */
1289                 case CON_STATE_WRITE:
1290                         connection_handle_write_state(srv, con);
1291                         if (con->state != CON_STATE_RESPONSE_END) break;
1292                         /* fall through */
1293                 case CON_STATE_RESPONSE_END: /* transient */
1294                 case CON_STATE_ERROR:        /* transient */
1295                         connection_handle_response_end_state(srv, con);
1296                         break;
1297                 case CON_STATE_CLOSE:
1298                         connection_handle_close_state(srv, con);
1299                         break;
1300                 case CON_STATE_CONNECT:
1301                         break;
1302                 default:
1303                         log_error_write(srv, __FILE__, __LINE__, "sdd",
1304                                         "unknown state:", con->fd, con->state);
1305                         break;
1306                 }
1307         } while (ostate != con->state);
1308
1309         if (srv->srvconf.log_state_handling) {
1310                 log_error_write(srv, __FILE__, __LINE__, "sds",
1311                                 "state at exit:",
1312                                 con->fd,
1313                                 connection_get_state(con->state));
1314         }
1315
1316         r = 0;
1317         switch(con->state) {
1318         case CON_STATE_READ:
1319                 r = FDEVENT_IN | FDEVENT_RDHUP;
1320                 break;
1321         case CON_STATE_WRITE:
1322                 /* request write-fdevent only if we really need it
1323                  * - if we have data to write
1324                  * - if the socket is not writable yet
1325                  */
1326                 if (!chunkqueue_is_empty(con->write_queue) &&
1327                     (con->is_writable == 0) &&
1328                     (con->traffic_limit_reached == 0)) {
1329                         r |= FDEVENT_OUT;
1330                 }
1331                 /* fall through */
1332         case CON_STATE_READ_POST:
1333                 if (con->conf.stream_request_body & FDEVENT_STREAM_REQUEST_POLLIN) {
1334                         r |= FDEVENT_IN | FDEVENT_RDHUP;
1335                 }
1336                 break;
1337         case CON_STATE_CLOSE:
1338                 r = FDEVENT_IN;
1339                 break;
1340         default:
1341                 break;
1342         }
1343         if (con->fd >= 0) {
1344                 const int events = fdevent_event_get_interest(srv->ev, con->fd);
1345                 if (con->is_readable < 0) {
1346                         con->is_readable = 0;
1347                         r |= FDEVENT_IN;
1348                 }
1349                 if (con->is_writable < 0) {
1350                         con->is_writable = 0;
1351                         r |= FDEVENT_OUT;
1352                 }
1353                 if (events & FDEVENT_RDHUP) {
1354                         r |= FDEVENT_RDHUP;
1355                 }
1356                 if (r != events) {
1357                         /* update timestamps when enabling interest in events */
1358                         if ((r & FDEVENT_IN) && !(events & FDEVENT_IN)) {
1359                                 con->read_idle_ts = srv->cur_ts;
1360                         }
1361                         if ((r & FDEVENT_OUT) && !(events & FDEVENT_OUT)) {
1362                                 con->write_request_ts = srv->cur_ts;
1363                         }
1364                         fdevent_event_set(srv->ev, con->fd, r);
1365                 }
1366         }
1367
1368         return 0;
1369 }