Annotation of embedaddon/lighttpd/src/connections.c, revision 1.1
1.1 ! misho 1: #include "buffer.h"
! 2: #include "server.h"
! 3: #include "log.h"
! 4: #include "connections.h"
! 5: #include "fdevent.h"
! 6:
! 7: #include "request.h"
! 8: #include "response.h"
! 9: #include "network.h"
! 10: #include "http_chunk.h"
! 11: #include "stat_cache.h"
! 12: #include "joblist.h"
! 13:
! 14: #include "plugin.h"
! 15:
! 16: #include "inet_ntop_cache.h"
! 17:
! 18: #include <sys/stat.h>
! 19:
! 20: #include <stdlib.h>
! 21: #include <stdio.h>
! 22: #include <unistd.h>
! 23: #include <errno.h>
! 24: #include <string.h>
! 25: #include <fcntl.h>
! 26: #include <assert.h>
! 27:
! 28: #ifdef USE_OPENSSL
! 29: # include <openssl/ssl.h>
! 30: # include <openssl/err.h>
! 31: #endif
! 32:
! 33: #ifdef HAVE_SYS_FILIO_H
! 34: # include <sys/filio.h>
! 35: #endif
! 36:
! 37: #include "sys-socket.h"
! 38:
! 39: typedef struct {
! 40: PLUGIN_DATA;
! 41: } plugin_data;
! 42:
! 43: static connection *connections_get_new_connection(server *srv) {
! 44: connections *conns = srv->conns;
! 45: size_t i;
! 46:
! 47: if (conns->size == 0) {
! 48: conns->size = 128;
! 49: conns->ptr = NULL;
! 50: conns->ptr = malloc(sizeof(*conns->ptr) * conns->size);
! 51: for (i = 0; i < conns->size; i++) {
! 52: conns->ptr[i] = connection_init(srv);
! 53: }
! 54: } else if (conns->size == conns->used) {
! 55: conns->size += 128;
! 56: conns->ptr = realloc(conns->ptr, sizeof(*conns->ptr) * conns->size);
! 57:
! 58: for (i = conns->used; i < conns->size; i++) {
! 59: conns->ptr[i] = connection_init(srv);
! 60: }
! 61: }
! 62:
! 63: connection_reset(srv, conns->ptr[conns->used]);
! 64: #if 0
! 65: fprintf(stderr, "%s.%d: add: ", __FILE__, __LINE__);
! 66: for (i = 0; i < conns->used + 1; i++) {
! 67: fprintf(stderr, "%d ", conns->ptr[i]->fd);
! 68: }
! 69: fprintf(stderr, "\n");
! 70: #endif
! 71:
! 72: conns->ptr[conns->used]->ndx = conns->used;
! 73: return conns->ptr[conns->used++];
! 74: }
! 75:
! 76: static int connection_del(server *srv, connection *con) {
! 77: size_t i;
! 78: connections *conns = srv->conns;
! 79: connection *temp;
! 80:
! 81: if (con == NULL) return -1;
! 82:
! 83: if (-1 == con->ndx) return -1;
! 84:
! 85: buffer_reset(con->uri.authority);
! 86: buffer_reset(con->uri.path);
! 87: buffer_reset(con->uri.query);
! 88: buffer_reset(con->request.orig_uri);
! 89:
! 90: i = con->ndx;
! 91:
! 92: /* not last element */
! 93:
! 94: if (i != conns->used - 1) {
! 95: temp = conns->ptr[i];
! 96: conns->ptr[i] = conns->ptr[conns->used - 1];
! 97: conns->ptr[conns->used - 1] = temp;
! 98:
! 99: conns->ptr[i]->ndx = i;
! 100: conns->ptr[conns->used - 1]->ndx = -1;
! 101: }
! 102:
! 103: conns->used--;
! 104:
! 105: con->ndx = -1;
! 106: #if 0
! 107: fprintf(stderr, "%s.%d: del: (%d)", __FILE__, __LINE__, conns->used);
! 108: for (i = 0; i < conns->used; i++) {
! 109: fprintf(stderr, "%d ", conns->ptr[i]->fd);
! 110: }
! 111: fprintf(stderr, "\n");
! 112: #endif
! 113: return 0;
! 114: }
! 115:
! 116: int connection_close(server *srv, connection *con) {
! 117: #ifdef USE_OPENSSL
! 118: server_socket *srv_sock = con->srv_socket;
! 119: #endif
! 120:
! 121: #ifdef USE_OPENSSL
! 122: if (srv_sock->is_ssl) {
! 123: if (con->ssl) SSL_free(con->ssl);
! 124: con->ssl = NULL;
! 125: }
! 126: #endif
! 127:
! 128: fdevent_event_del(srv->ev, &(con->fde_ndx), con->fd);
! 129: fdevent_unregister(srv->ev, con->fd);
! 130: #ifdef __WIN32
! 131: if (closesocket(con->fd)) {
! 132: log_error_write(srv, __FILE__, __LINE__, "sds",
! 133: "(warning) close:", con->fd, strerror(errno));
! 134: }
! 135: #else
! 136: if (close(con->fd)) {
! 137: log_error_write(srv, __FILE__, __LINE__, "sds",
! 138: "(warning) close:", con->fd, strerror(errno));
! 139: }
! 140: #endif
! 141:
! 142: srv->cur_fds--;
! 143: #if 0
! 144: log_error_write(srv, __FILE__, __LINE__, "sd",
! 145: "closed()", con->fd);
! 146: #endif
! 147:
! 148: connection_del(srv, con);
! 149: connection_set_state(srv, con, CON_STATE_CONNECT);
! 150:
! 151: return 0;
! 152: }
! 153:
! 154: #if 0
! 155: static void dump_packet(const unsigned char *data, size_t len) {
! 156: size_t i, j;
! 157:
! 158: if (len == 0) return;
! 159:
! 160: for (i = 0; i < len; i++) {
! 161: if (i % 16 == 0) fprintf(stderr, " ");
! 162:
! 163: fprintf(stderr, "%02x ", data[i]);
! 164:
! 165: if ((i + 1) % 16 == 0) {
! 166: fprintf(stderr, " ");
! 167: for (j = 0; j <= i % 16; j++) {
! 168: unsigned char c;
! 169:
! 170: if (i-15+j >= len) break;
! 171:
! 172: c = data[i-15+j];
! 173:
! 174: fprintf(stderr, "%c", c > 32 && c < 128 ? c : '.');
! 175: }
! 176:
! 177: fprintf(stderr, "\n");
! 178: }
! 179: }
! 180:
! 181: if (len % 16 != 0) {
! 182: for (j = i % 16; j < 16; j++) {
! 183: fprintf(stderr, " ");
! 184: }
! 185:
! 186: fprintf(stderr, " ");
! 187: for (j = i & ~0xf; j < len; j++) {
! 188: unsigned char c;
! 189:
! 190: c = data[j];
! 191: fprintf(stderr, "%c", c > 32 && c < 128 ? c : '.');
! 192: }
! 193: fprintf(stderr, "\n");
! 194: }
! 195: }
! 196: #endif
! 197:
! 198: static int connection_handle_read_ssl(server *srv, connection *con) {
! 199: #ifdef USE_OPENSSL
! 200: int r, ssl_err, len, count = 0, read_offset, toread;
! 201: buffer *b = NULL;
! 202:
! 203: if (!con->srv_socket->is_ssl) return -1;
! 204:
! 205: ERR_clear_error();
! 206: do {
! 207: if (NULL != con->read_queue->last) {
! 208: b = con->read_queue->last->mem;
! 209: }
! 210:
! 211: if (NULL == b || b->size - b->used < 1024) {
! 212: b = chunkqueue_get_append_buffer(con->read_queue);
! 213: len = SSL_pending(con->ssl);
! 214: if (len < 4*1024) len = 4*1024; /* always alloc >= 4k buffer */
! 215: buffer_prepare_copy(b, len + 1);
! 216:
! 217: /* overwrite everything with 0 */
! 218: memset(b->ptr, 0, b->size);
! 219: }
! 220:
! 221: read_offset = (b->used > 0) ? b->used - 1 : 0;
! 222: toread = b->size - 1 - read_offset;
! 223:
! 224: len = SSL_read(con->ssl, b->ptr + read_offset, toread);
! 225:
! 226: if (con->renegotiations > 1 && con->conf.ssl_disable_client_renegotiation) {
! 227: log_error_write(srv, __FILE__, __LINE__, "s", "SSL: renegotiation initiated by client, killing connection");
! 228: connection_set_state(srv, con, CON_STATE_ERROR);
! 229: return -1;
! 230: }
! 231:
! 232: if (len > 0) {
! 233: if (b->used > 0) b->used--;
! 234: b->used += len;
! 235: b->ptr[b->used++] = '\0';
! 236:
! 237: con->bytes_read += len;
! 238:
! 239: count += len;
! 240: }
! 241: } while (len == toread && count < MAX_READ_LIMIT);
! 242:
! 243:
! 244: if (len < 0) {
! 245: int oerrno = errno;
! 246: switch ((r = SSL_get_error(con->ssl, len))) {
! 247: case SSL_ERROR_WANT_READ:
! 248: case SSL_ERROR_WANT_WRITE:
! 249: con->is_readable = 0;
! 250:
! 251: /* the manual says we have to call SSL_read with the same arguments next time.
! 252: * we ignore this restriction; no one has complained about it in 1.5 yet, so it probably works anyway.
! 253: */
! 254:
! 255: return 0;
! 256: case SSL_ERROR_SYSCALL:
! 257: /**
! 258: * man SSL_get_error()
! 259: *
! 260: * SSL_ERROR_SYSCALL
! 261: * Some I/O error occurred. The OpenSSL error queue may contain more
! 262: * information on the error. If the error queue is empty (i.e.
! 263: * ERR_get_error() returns 0), ret can be used to find out more about
! 264: * the error: If ret == 0, an EOF was observed that violates the
! 265: * protocol. If ret == -1, the underlying BIO reported an I/O error
! 266: * (for socket I/O on Unix systems, consult errno for details).
! 267: *
! 268: */
! 269: while((ssl_err = ERR_get_error())) {
! 270: /* get all errors from the error-queue */
! 271: log_error_write(srv, __FILE__, __LINE__, "sds", "SSL:",
! 272: r, ERR_error_string(ssl_err, NULL));
! 273: }
! 274:
! 275: switch(oerrno) {
! 276: default:
! 277: log_error_write(srv, __FILE__, __LINE__, "sddds", "SSL:",
! 278: len, r, oerrno,
! 279: strerror(oerrno));
! 280: break;
! 281: }
! 282:
! 283: break;
! 284: case SSL_ERROR_ZERO_RETURN:
! 285: /* clean shutdown on the remote side */
! 286:
! 287: if (r == 0) {
! 288: /* FIXME: later */
! 289: }
! 290:
! 291: /* fall thourgh */
! 292: default:
! 293: while((ssl_err = ERR_get_error())) {
! 294: switch (ERR_GET_REASON(ssl_err)) {
! 295: case SSL_R_SSL_HANDSHAKE_FAILURE:
! 296: case SSL_R_TLSV1_ALERT_UNKNOWN_CA:
! 297: case SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN:
! 298: case SSL_R_SSLV3_ALERT_BAD_CERTIFICATE:
! 299: if (!con->conf.log_ssl_noise) continue;
! 300: break;
! 301: default:
! 302: break;
! 303: }
! 304: /* get all errors from the error-queue */
! 305: log_error_write(srv, __FILE__, __LINE__, "sds", "SSL:",
! 306: r, ERR_error_string(ssl_err, NULL));
! 307: }
! 308: break;
! 309: }
! 310:
! 311: connection_set_state(srv, con, CON_STATE_ERROR);
! 312:
! 313: return -1;
! 314: } else if (len == 0) {
! 315: con->is_readable = 0;
! 316: /* the other end close the connection -> KEEP-ALIVE */
! 317:
! 318: return -2;
! 319: } else {
! 320: joblist_append(srv, con);
! 321: }
! 322:
! 323: return 0;
! 324: #else
! 325: UNUSED(srv);
! 326: UNUSED(con);
! 327: return -1;
! 328: #endif
! 329: }
! 330:
! 331: /* 0: everything ok, -1: error, -2: con closed */
! 332: static int connection_handle_read(server *srv, connection *con) {
! 333: int len;
! 334: buffer *b;
! 335: int toread, read_offset;
! 336:
! 337: if (con->srv_socket->is_ssl) {
! 338: return connection_handle_read_ssl(srv, con);
! 339: }
! 340:
! 341: b = (NULL != con->read_queue->last) ? con->read_queue->last->mem : NULL;
! 342:
! 343: /* default size for chunks is 4kb; only use bigger chunks if FIONREAD tells
! 344: * us more than 4kb is available
! 345: * if FIONREAD doesn't signal a big chunk we fill the previous buffer
! 346: * if it has >= 1kb free
! 347: */
! 348: #if defined(__WIN32)
! 349: if (NULL == b || b->size - b->used < 1024) {
! 350: b = chunkqueue_get_append_buffer(con->read_queue);
! 351: buffer_prepare_copy(b, 4 * 1024);
! 352: }
! 353:
! 354: read_offset = (b->used == 0) ? 0 : b->used - 1;
! 355: len = recv(con->fd, b->ptr + read_offset, b->size - 1 - read_offset, 0);
! 356: #else
! 357: if (ioctl(con->fd, FIONREAD, &toread) || toread == 0 || toread <= 4*1024) {
! 358: if (NULL == b || b->size - b->used < 1024) {
! 359: b = chunkqueue_get_append_buffer(con->read_queue);
! 360: buffer_prepare_copy(b, 4 * 1024);
! 361: }
! 362: } else {
! 363: if (toread > MAX_READ_LIMIT) toread = MAX_READ_LIMIT;
! 364: b = chunkqueue_get_append_buffer(con->read_queue);
! 365: buffer_prepare_copy(b, toread + 1);
! 366: }
! 367:
! 368: read_offset = (b->used == 0) ? 0 : b->used - 1;
! 369: len = read(con->fd, b->ptr + read_offset, b->size - 1 - read_offset);
! 370: #endif
! 371:
! 372: if (len < 0) {
! 373: con->is_readable = 0;
! 374:
! 375: if (errno == EAGAIN) return 0;
! 376: if (errno == EINTR) {
! 377: /* we have been interrupted before we could read */
! 378: con->is_readable = 1;
! 379: return 0;
! 380: }
! 381:
! 382: if (errno != ECONNRESET) {
! 383: /* expected for keep-alive */
! 384: log_error_write(srv, __FILE__, __LINE__, "ssd", "connection closed - read failed: ", strerror(errno), errno);
! 385: }
! 386:
! 387: connection_set_state(srv, con, CON_STATE_ERROR);
! 388:
! 389: return -1;
! 390: } else if (len == 0) {
! 391: con->is_readable = 0;
! 392: /* the other end close the connection -> KEEP-ALIVE */
! 393:
! 394: /* pipelining */
! 395:
! 396: return -2;
! 397: } else if ((size_t)len < b->size - 1) {
! 398: /* we got less then expected, wait for the next fd-event */
! 399:
! 400: con->is_readable = 0;
! 401: }
! 402:
! 403: if (b->used > 0) b->used--;
! 404: b->used += len;
! 405: b->ptr[b->used++] = '\0';
! 406:
! 407: con->bytes_read += len;
! 408: #if 0
! 409: dump_packet(b->ptr, len);
! 410: #endif
! 411:
! 412: return 0;
! 413: }
! 414:
! 415: static int connection_handle_write_prepare(server *srv, connection *con) {
! 416: if (con->mode == DIRECT) {
! 417: /* static files */
! 418: switch(con->request.http_method) {
! 419: case HTTP_METHOD_GET:
! 420: case HTTP_METHOD_POST:
! 421: case HTTP_METHOD_HEAD:
! 422: break;
! 423: case HTTP_METHOD_OPTIONS:
! 424: /*
! 425: * 400 is coming from the request-parser BEFORE uri.path is set
! 426: * 403 is from the response handler when noone else catched it
! 427: *
! 428: * */
! 429: if ((!con->http_status || con->http_status == 200) && con->uri.path->used &&
! 430: con->uri.path->ptr[0] != '*') {
! 431: response_header_insert(srv, con, CONST_STR_LEN("Allow"), CONST_STR_LEN("OPTIONS, GET, HEAD, POST"));
! 432:
! 433: con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;
! 434: con->parsed_response &= ~HTTP_CONTENT_LENGTH;
! 435:
! 436: con->http_status = 200;
! 437: con->file_finished = 1;
! 438:
! 439: chunkqueue_reset(con->write_queue);
! 440: }
! 441: break;
! 442: default:
! 443: if (0 == con->http_status) {
! 444: con->http_status = 501;
! 445: }
! 446: break;
! 447: }
! 448: }
! 449:
! 450: if (con->http_status == 0) {
! 451: con->http_status = 403;
! 452: }
! 453:
! 454: switch(con->http_status) {
! 455: case 204: /* class: header only */
! 456: case 205:
! 457: case 304:
! 458: /* disable chunked encoding again as we have no body */
! 459: con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;
! 460: con->parsed_response &= ~HTTP_CONTENT_LENGTH;
! 461: chunkqueue_reset(con->write_queue);
! 462:
! 463: con->file_finished = 1;
! 464: break;
! 465: default: /* class: header + body */
! 466: if (con->mode != DIRECT) break;
! 467:
! 468: /* only custom body for 4xx and 5xx */
! 469: if (con->http_status < 400 || con->http_status >= 600) break;
! 470:
! 471: con->file_finished = 0;
! 472:
! 473: buffer_reset(con->physical.path);
! 474:
! 475: /* try to send static errorfile */
! 476: if (!buffer_is_empty(con->conf.errorfile_prefix)) {
! 477: stat_cache_entry *sce = NULL;
! 478:
! 479: buffer_copy_string_buffer(con->physical.path, con->conf.errorfile_prefix);
! 480: buffer_append_long(con->physical.path, con->http_status);
! 481: buffer_append_string_len(con->physical.path, CONST_STR_LEN(".html"));
! 482:
! 483: if (HANDLER_ERROR != stat_cache_get_entry(srv, con, con->physical.path, &sce)) {
! 484: con->file_finished = 1;
! 485:
! 486: http_chunk_append_file(srv, con, con->physical.path, 0, sce->st.st_size);
! 487: response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_BUF_LEN(sce->content_type));
! 488: }
! 489: }
! 490:
! 491: if (!con->file_finished) {
! 492: buffer *b;
! 493:
! 494: buffer_reset(con->physical.path);
! 495:
! 496: con->file_finished = 1;
! 497: b = chunkqueue_get_append_buffer(con->write_queue);
! 498:
! 499: /* build default error-page */
! 500: buffer_copy_string_len(b, CONST_STR_LEN(
! 501: "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n"
! 502: "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
! 503: " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"
! 504: "<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n"
! 505: " <head>\n"
! 506: " <title>"));
! 507: buffer_append_long(b, con->http_status);
! 508: buffer_append_string_len(b, CONST_STR_LEN(" - "));
! 509: buffer_append_string(b, get_http_status_name(con->http_status));
! 510:
! 511: buffer_append_string_len(b, CONST_STR_LEN(
! 512: "</title>\n"
! 513: " </head>\n"
! 514: " <body>\n"
! 515: " <h1>"));
! 516: buffer_append_long(b, con->http_status);
! 517: buffer_append_string_len(b, CONST_STR_LEN(" - "));
! 518: buffer_append_string(b, get_http_status_name(con->http_status));
! 519:
! 520: buffer_append_string_len(b, CONST_STR_LEN("</h1>\n"
! 521: " </body>\n"
! 522: "</html>\n"
! 523: ));
! 524:
! 525: response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html"));
! 526: }
! 527: break;
! 528: }
! 529:
! 530: if (con->file_finished) {
! 531: /* we have all the content and chunked encoding is not used, set a content-length */
! 532:
! 533: if ((!(con->parsed_response & HTTP_CONTENT_LENGTH)) &&
! 534: (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) == 0) {
! 535: off_t qlen = chunkqueue_length(con->write_queue);
! 536:
! 537: /**
! 538: * The Content-Length header only can be sent if we have content:
! 539: * - HEAD doesn't have a content-body (but have a content-length)
! 540: * - 1xx, 204 and 304 don't have a content-body (RFC 2616 Section 4.3)
! 541: *
! 542: * Otherwise generate a Content-Length header as chunked encoding is not
! 543: * available
! 544: */
! 545: if ((con->http_status >= 100 && con->http_status < 200) ||
! 546: con->http_status == 204 ||
! 547: con->http_status == 304) {
! 548: data_string *ds;
! 549: /* no Content-Body, no Content-Length */
! 550: if (NULL != (ds = (data_string*) array_get_element(con->response.headers, "Content-Length"))) {
! 551: buffer_reset(ds->value); /* Headers with empty values are ignored for output */
! 552: }
! 553: } else if (qlen > 0 || con->request.http_method != HTTP_METHOD_HEAD) {
! 554: /* qlen = 0 is important for Redirects (301, ...) as they MAY have
! 555: * a content. Browsers are waiting for a Content otherwise
! 556: */
! 557: buffer_copy_off_t(srv->tmp_buf, qlen);
! 558:
! 559: response_header_overwrite(srv, con, CONST_STR_LEN("Content-Length"), CONST_BUF_LEN(srv->tmp_buf));
! 560: }
! 561: }
! 562: } else {
! 563: /**
! 564: * the file isn't finished yet, but we have all headers
! 565: *
! 566: * to get keep-alive we either need:
! 567: * - Content-Length: ... (HTTP/1.0 and HTTP/1.0) or
! 568: * - Transfer-Encoding: chunked (HTTP/1.1)
! 569: */
! 570:
! 571: if (((con->parsed_response & HTTP_CONTENT_LENGTH) == 0) &&
! 572: ((con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) == 0)) {
! 573: con->keep_alive = 0;
! 574: }
! 575:
! 576: /**
! 577: * if the backend sent a Connection: close, follow the wish
! 578: *
! 579: * NOTE: if the backend sent Connection: Keep-Alive, but no Content-Length, we
! 580: * will close the connection. That's fine. We can always decide the close
! 581: * the connection
! 582: *
! 583: * FIXME: to be nice we should remove the Connection: ...
! 584: */
! 585: if (con->parsed_response & HTTP_CONNECTION) {
! 586: /* a subrequest disable keep-alive although the client wanted it */
! 587: if (con->keep_alive && !con->response.keep_alive) {
! 588: con->keep_alive = 0;
! 589: }
! 590: }
! 591: }
! 592:
! 593: if (con->request.http_method == HTTP_METHOD_HEAD) {
! 594: /**
! 595: * a HEAD request has the same as a GET
! 596: * without the content
! 597: */
! 598: con->file_finished = 1;
! 599:
! 600: chunkqueue_reset(con->write_queue);
! 601: con->response.transfer_encoding &= ~HTTP_TRANSFER_ENCODING_CHUNKED;
! 602: }
! 603:
! 604: http_response_write_header(srv, con);
! 605:
! 606: return 0;
! 607: }
! 608:
! 609: static int connection_handle_write(server *srv, connection *con) {
! 610: switch(network_write_chunkqueue(srv, con, con->write_queue, MAX_WRITE_LIMIT)) {
! 611: case 0:
! 612: con->write_request_ts = srv->cur_ts;
! 613: if (con->file_finished) {
! 614: connection_set_state(srv, con, CON_STATE_RESPONSE_END);
! 615: joblist_append(srv, con);
! 616: }
! 617: break;
! 618: case -1: /* error on our side */
! 619: log_error_write(srv, __FILE__, __LINE__, "sd",
! 620: "connection closed: write failed on fd", con->fd);
! 621: connection_set_state(srv, con, CON_STATE_ERROR);
! 622: joblist_append(srv, con);
! 623: break;
! 624: case -2: /* remote close */
! 625: connection_set_state(srv, con, CON_STATE_ERROR);
! 626: joblist_append(srv, con);
! 627: break;
! 628: case 1:
! 629: con->write_request_ts = srv->cur_ts;
! 630: con->is_writable = 0;
! 631:
! 632: /* not finished yet -> WRITE */
! 633: break;
! 634: }
! 635:
! 636: return 0;
! 637: }
! 638:
! 639:
! 640:
! 641: connection *connection_init(server *srv) {
! 642: connection *con;
! 643:
! 644: UNUSED(srv);
! 645:
! 646: con = calloc(1, sizeof(*con));
! 647:
! 648: con->fd = 0;
! 649: con->ndx = -1;
! 650: con->fde_ndx = -1;
! 651: con->bytes_written = 0;
! 652: con->bytes_read = 0;
! 653: con->bytes_header = 0;
! 654: con->loops_per_request = 0;
! 655:
! 656: #define CLEAN(x) \
! 657: con->x = buffer_init();
! 658:
! 659: CLEAN(request.uri);
! 660: CLEAN(request.request_line);
! 661: CLEAN(request.request);
! 662: CLEAN(request.pathinfo);
! 663:
! 664: CLEAN(request.orig_uri);
! 665:
! 666: CLEAN(uri.scheme);
! 667: CLEAN(uri.authority);
! 668: CLEAN(uri.path);
! 669: CLEAN(uri.path_raw);
! 670: CLEAN(uri.query);
! 671:
! 672: CLEAN(physical.doc_root);
! 673: CLEAN(physical.path);
! 674: CLEAN(physical.basedir);
! 675: CLEAN(physical.rel_path);
! 676: CLEAN(physical.etag);
! 677: CLEAN(parse_request);
! 678:
! 679: CLEAN(server_name);
! 680: CLEAN(error_handler);
! 681: CLEAN(dst_addr_buf);
! 682: #if defined USE_OPENSSL && ! defined OPENSSL_NO_TLSEXT
! 683: CLEAN(tlsext_server_name);
! 684: #endif
! 685:
! 686: #undef CLEAN
! 687: con->write_queue = chunkqueue_init();
! 688: con->read_queue = chunkqueue_init();
! 689: con->request_content_queue = chunkqueue_init();
! 690: chunkqueue_set_tempdirs(con->request_content_queue, srv->srvconf.upload_tempdirs);
! 691:
! 692: con->request.headers = array_init();
! 693: con->response.headers = array_init();
! 694: con->environment = array_init();
! 695:
! 696: /* init plugin specific connection structures */
! 697:
! 698: con->plugin_ctx = calloc(1, (srv->plugins.used + 1) * sizeof(void *));
! 699:
! 700: con->cond_cache = calloc(srv->config_context->used, sizeof(cond_cache_t));
! 701: config_setup_connection(srv, con);
! 702:
! 703: return con;
! 704: }
! 705:
! 706: void connections_free(server *srv) {
! 707: connections *conns = srv->conns;
! 708: size_t i;
! 709:
! 710: for (i = 0; i < conns->size; i++) {
! 711: connection *con = conns->ptr[i];
! 712:
! 713: connection_reset(srv, con);
! 714:
! 715: chunkqueue_free(con->write_queue);
! 716: chunkqueue_free(con->read_queue);
! 717: chunkqueue_free(con->request_content_queue);
! 718: array_free(con->request.headers);
! 719: array_free(con->response.headers);
! 720: array_free(con->environment);
! 721:
! 722: #define CLEAN(x) \
! 723: buffer_free(con->x);
! 724:
! 725: CLEAN(request.uri);
! 726: CLEAN(request.request_line);
! 727: CLEAN(request.request);
! 728: CLEAN(request.pathinfo);
! 729:
! 730: CLEAN(request.orig_uri);
! 731:
! 732: CLEAN(uri.scheme);
! 733: CLEAN(uri.authority);
! 734: CLEAN(uri.path);
! 735: CLEAN(uri.path_raw);
! 736: CLEAN(uri.query);
! 737:
! 738: CLEAN(physical.doc_root);
! 739: CLEAN(physical.path);
! 740: CLEAN(physical.basedir);
! 741: CLEAN(physical.etag);
! 742: CLEAN(physical.rel_path);
! 743: CLEAN(parse_request);
! 744:
! 745: CLEAN(server_name);
! 746: CLEAN(error_handler);
! 747: CLEAN(dst_addr_buf);
! 748: #if defined USE_OPENSSL && ! defined OPENSSL_NO_TLSEXT
! 749: CLEAN(tlsext_server_name);
! 750: #endif
! 751: #undef CLEAN
! 752: free(con->plugin_ctx);
! 753: free(con->cond_cache);
! 754:
! 755: free(con);
! 756: }
! 757:
! 758: free(conns->ptr);
! 759: }
! 760:
! 761:
! 762: int connection_reset(server *srv, connection *con) {
! 763: size_t i;
! 764:
! 765: plugins_call_connection_reset(srv, con);
! 766:
! 767: con->is_readable = 1;
! 768: con->is_writable = 1;
! 769: con->http_status = 0;
! 770: con->file_finished = 0;
! 771: con->file_started = 0;
! 772: con->got_response = 0;
! 773:
! 774: con->parsed_response = 0;
! 775:
! 776: con->bytes_written = 0;
! 777: con->bytes_written_cur_second = 0;
! 778: con->bytes_read = 0;
! 779: con->bytes_header = 0;
! 780: con->loops_per_request = 0;
! 781:
! 782: con->request.http_method = HTTP_METHOD_UNSET;
! 783: con->request.http_version = HTTP_VERSION_UNSET;
! 784:
! 785: con->request.http_if_modified_since = NULL;
! 786: con->request.http_if_none_match = NULL;
! 787:
! 788: con->response.keep_alive = 0;
! 789: con->response.content_length = -1;
! 790: con->response.transfer_encoding = 0;
! 791:
! 792: con->mode = DIRECT;
! 793:
! 794: #define CLEAN(x) \
! 795: if (con->x) buffer_reset(con->x);
! 796:
! 797: CLEAN(request.uri);
! 798: CLEAN(request.request_line);
! 799: CLEAN(request.pathinfo);
! 800: CLEAN(request.request);
! 801:
! 802: /* CLEAN(request.orig_uri); */
! 803:
! 804: CLEAN(uri.scheme);
! 805: /* CLEAN(uri.authority); */
! 806: /* CLEAN(uri.path); */
! 807: CLEAN(uri.path_raw);
! 808: /* CLEAN(uri.query); */
! 809:
! 810: CLEAN(physical.doc_root);
! 811: CLEAN(physical.path);
! 812: CLEAN(physical.basedir);
! 813: CLEAN(physical.rel_path);
! 814: CLEAN(physical.etag);
! 815:
! 816: CLEAN(parse_request);
! 817:
! 818: CLEAN(server_name);
! 819: CLEAN(error_handler);
! 820: #if defined USE_OPENSSL && ! defined OPENSSL_NO_TLSEXT
! 821: CLEAN(tlsext_server_name);
! 822: #endif
! 823: #undef CLEAN
! 824:
! 825: #define CLEAN(x) \
! 826: if (con->x) con->x->used = 0;
! 827:
! 828: #undef CLEAN
! 829:
! 830: #define CLEAN(x) \
! 831: con->request.x = NULL;
! 832:
! 833: CLEAN(http_host);
! 834: CLEAN(http_range);
! 835: CLEAN(http_content_type);
! 836: #undef CLEAN
! 837: con->request.content_length = 0;
! 838:
! 839: array_reset(con->request.headers);
! 840: array_reset(con->response.headers);
! 841: array_reset(con->environment);
! 842:
! 843: chunkqueue_reset(con->write_queue);
! 844: chunkqueue_reset(con->request_content_queue);
! 845:
! 846: /* the plugins should cleanup themself */
! 847: for (i = 0; i < srv->plugins.used; i++) {
! 848: plugin *p = ((plugin **)(srv->plugins.ptr))[i];
! 849: plugin_data *pd = p->data;
! 850:
! 851: if (!pd) continue;
! 852:
! 853: if (con->plugin_ctx[pd->id] != NULL) {
! 854: log_error_write(srv, __FILE__, __LINE__, "sb", "missing cleanup in", p->name);
! 855: }
! 856:
! 857: con->plugin_ctx[pd->id] = NULL;
! 858: }
! 859:
! 860: /* The cond_cache gets reset in response.c */
! 861: /* config_cond_cache_reset(srv, con); */
! 862:
! 863: con->header_len = 0;
! 864: con->in_error_handler = 0;
! 865:
! 866: config_setup_connection(srv, con);
! 867:
! 868: return 0;
! 869: }
! 870:
! 871: /**
! 872: * handle all header and content read
! 873: *
! 874: * we get called by the state-engine and by the fdevent-handler
! 875: */
! 876: static int connection_handle_read_state(server *srv, connection *con) {
! 877: connection_state_t ostate = con->state;
! 878: chunk *c, *last_chunk;
! 879: off_t last_offset;
! 880: chunkqueue *cq = con->read_queue;
! 881: chunkqueue *dst_cq = con->request_content_queue;
! 882: int is_closed = 0; /* the connection got closed, if we don't have a complete header, -> error */
! 883:
! 884: if (con->is_readable) {
! 885: con->read_idle_ts = srv->cur_ts;
! 886:
! 887: switch(connection_handle_read(srv, con)) {
! 888: case -1:
! 889: return -1;
! 890: case -2:
! 891: is_closed = 1;
! 892: break;
! 893: default:
! 894: break;
! 895: }
! 896: }
! 897:
! 898: /* the last chunk might be empty */
! 899: for (c = cq->first; c;) {
! 900: if (cq->first == c && c->mem->used == 0) {
! 901: /* the first node is empty */
! 902: /* ... and it is empty, move it to unused */
! 903:
! 904: cq->first = c->next;
! 905: if (cq->first == NULL) cq->last = NULL;
! 906:
! 907: c->next = cq->unused;
! 908: cq->unused = c;
! 909: cq->unused_chunks++;
! 910:
! 911: c = cq->first;
! 912: } else if (c->next && c->next->mem->used == 0) {
! 913: chunk *fc;
! 914: /* next node is the last one */
! 915: /* ... and it is empty, move it to unused */
! 916:
! 917: fc = c->next;
! 918: c->next = fc->next;
! 919:
! 920: fc->next = cq->unused;
! 921: cq->unused = fc;
! 922: cq->unused_chunks++;
! 923:
! 924: /* the last node was empty */
! 925: if (c->next == NULL) {
! 926: cq->last = c;
! 927: }
! 928:
! 929: c = c->next;
! 930: } else {
! 931: c = c->next;
! 932: }
! 933: }
! 934:
! 935: /* we might have got several packets at once
! 936: */
! 937:
! 938: switch(ostate) {
! 939: case CON_STATE_READ:
! 940: /* if there is a \r\n\r\n in the chunkqueue
! 941: *
! 942: * scan the chunk-queue twice
! 943: * 1. to find the \r\n\r\n
! 944: * 2. to copy the header-packet
! 945: *
! 946: */
! 947:
! 948: last_chunk = NULL;
! 949: last_offset = 0;
! 950:
! 951: for (c = cq->first; c; c = c->next) {
! 952: buffer b;
! 953: size_t i;
! 954:
! 955: b.ptr = c->mem->ptr + c->offset;
! 956: b.used = c->mem->used - c->offset;
! 957: if (b.used > 0) b.used--; /* buffer "used" includes terminating zero */
! 958:
! 959: for (i = 0; i < b.used; i++) {
! 960: char ch = b.ptr[i];
! 961:
! 962: if ('\r' == ch) {
! 963: /* chec if \n\r\n follows */
! 964: size_t j = i+1;
! 965: chunk *cc = c;
! 966: const char header_end[] = "\r\n\r\n";
! 967: int header_end_match_pos = 1;
! 968:
! 969: for ( ; cc; cc = cc->next, j = 0 ) {
! 970: buffer bb;
! 971: bb.ptr = cc->mem->ptr + cc->offset;
! 972: bb.used = cc->mem->used - cc->offset;
! 973: if (bb.used > 0) bb.used--; /* buffer "used" includes terminating zero */
! 974:
! 975: for ( ; j < bb.used; j++) {
! 976: ch = bb.ptr[j];
! 977:
! 978: if (ch == header_end[header_end_match_pos]) {
! 979: header_end_match_pos++;
! 980: if (4 == header_end_match_pos) {
! 981: last_chunk = cc;
! 982: last_offset = j+1;
! 983: goto found_header_end;
! 984: }
! 985: } else {
! 986: goto reset_search;
! 987: }
! 988: }
! 989: }
! 990: }
! 991: reset_search: ;
! 992: }
! 993: }
! 994: found_header_end:
! 995:
! 996: /* found */
! 997: if (last_chunk) {
! 998: buffer_reset(con->request.request);
! 999:
! 1000: for (c = cq->first; c; c = c->next) {
! 1001: buffer b;
! 1002:
! 1003: b.ptr = c->mem->ptr + c->offset;
! 1004: b.used = c->mem->used - c->offset;
! 1005:
! 1006: if (c == last_chunk) {
! 1007: b.used = last_offset + 1;
! 1008: }
! 1009:
! 1010: buffer_append_string_buffer(con->request.request, &b);
! 1011:
! 1012: if (c == last_chunk) {
! 1013: c->offset += last_offset;
! 1014:
! 1015: break;
! 1016: } else {
! 1017: /* the whole packet was copied */
! 1018: c->offset = c->mem->used - 1;
! 1019: }
! 1020: }
! 1021:
! 1022: connection_set_state(srv, con, CON_STATE_REQUEST_END);
! 1023: } else if (chunkqueue_length(cq) > 64 * 1024) {
! 1024: log_error_write(srv, __FILE__, __LINE__, "s", "oversized request-header -> sending Status 414");
! 1025:
! 1026: con->http_status = 414; /* Request-URI too large */
! 1027: con->keep_alive = 0;
! 1028: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1029: }
! 1030: break;
! 1031: case CON_STATE_READ_POST:
! 1032: for (c = cq->first; c && (dst_cq->bytes_in != (off_t)con->request.content_length); c = c->next) {
! 1033: off_t weWant, weHave, toRead;
! 1034:
! 1035: weWant = con->request.content_length - dst_cq->bytes_in;
! 1036:
! 1037: assert(c->mem->used);
! 1038:
! 1039: weHave = c->mem->used - c->offset - 1;
! 1040:
! 1041: toRead = weHave > weWant ? weWant : weHave;
! 1042:
! 1043: /* the new way, copy everything into a chunkqueue whcih might use tempfiles */
! 1044: if (con->request.content_length > 64 * 1024) {
! 1045: chunk *dst_c = NULL;
! 1046: /* copy everything to max 1Mb sized tempfiles */
! 1047:
! 1048: /*
! 1049: * if the last chunk is
! 1050: * - smaller than 1Mb (size < 1Mb)
! 1051: * - not read yet (offset == 0)
! 1052: * -> append to it
! 1053: * otherwise
! 1054: * -> create a new chunk
! 1055: *
! 1056: * */
! 1057:
! 1058: if (dst_cq->last &&
! 1059: dst_cq->last->type == FILE_CHUNK &&
! 1060: dst_cq->last->file.is_temp &&
! 1061: dst_cq->last->offset == 0) {
! 1062: /* ok, take the last chunk for our job */
! 1063:
! 1064: if (dst_cq->last->file.length < 1 * 1024 * 1024) {
! 1065: dst_c = dst_cq->last;
! 1066:
! 1067: if (dst_c->file.fd == -1) {
! 1068: /* this should not happen as we cache the fd, but you never know */
! 1069: dst_c->file.fd = open(dst_c->file.name->ptr, O_WRONLY | O_APPEND);
! 1070: #ifdef FD_CLOEXEC
! 1071: fcntl(dst_c->file.fd, F_SETFD, FD_CLOEXEC);
! 1072: #endif
! 1073: }
! 1074: } else {
! 1075: /* the chunk is too large now, close it */
! 1076: dst_c = dst_cq->last;
! 1077:
! 1078: if (dst_c->file.fd != -1) {
! 1079: close(dst_c->file.fd);
! 1080: dst_c->file.fd = -1;
! 1081: }
! 1082: dst_c = chunkqueue_get_append_tempfile(dst_cq);
! 1083: }
! 1084: } else {
! 1085: dst_c = chunkqueue_get_append_tempfile(dst_cq);
! 1086: }
! 1087:
! 1088: /* we have a chunk, let's write to it */
! 1089:
! 1090: if (dst_c->file.fd == -1) {
! 1091: /* we don't have file to write to,
! 1092: * EACCES might be one reason.
! 1093: *
! 1094: * Instead of sending 500 we send 413 and say the request is too large
! 1095: * */
! 1096:
! 1097: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 1098: "denying upload as opening to temp-file for upload failed:",
! 1099: dst_c->file.name, strerror(errno));
! 1100:
! 1101: con->http_status = 413; /* Request-Entity too large */
! 1102: con->keep_alive = 0;
! 1103: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1104:
! 1105: break;
! 1106: }
! 1107:
! 1108: if (toRead != write(dst_c->file.fd, c->mem->ptr + c->offset, toRead)) {
! 1109: /* write failed for some reason ... disk full ? */
! 1110: log_error_write(srv, __FILE__, __LINE__, "sbs",
! 1111: "denying upload as writing to file failed:",
! 1112: dst_c->file.name, strerror(errno));
! 1113:
! 1114: con->http_status = 413; /* Request-Entity too large */
! 1115: con->keep_alive = 0;
! 1116: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1117:
! 1118: close(dst_c->file.fd);
! 1119: dst_c->file.fd = -1;
! 1120:
! 1121: break;
! 1122: }
! 1123:
! 1124: dst_c->file.length += toRead;
! 1125:
! 1126: if (dst_cq->bytes_in + toRead == (off_t)con->request.content_length) {
! 1127: /* we read everything, close the chunk */
! 1128: close(dst_c->file.fd);
! 1129: dst_c->file.fd = -1;
! 1130: }
! 1131: } else {
! 1132: buffer *b;
! 1133:
! 1134: if (dst_cq->last &&
! 1135: dst_cq->last->type == MEM_CHUNK) {
! 1136: b = dst_cq->last->mem;
! 1137: } else {
! 1138: b = chunkqueue_get_append_buffer(dst_cq);
! 1139: /* prepare buffer size for remaining POST data; is < 64kb */
! 1140: buffer_prepare_copy(b, con->request.content_length - dst_cq->bytes_in + 1);
! 1141: }
! 1142: buffer_append_string_len(b, c->mem->ptr + c->offset, toRead);
! 1143: }
! 1144:
! 1145: c->offset += toRead;
! 1146: dst_cq->bytes_in += toRead;
! 1147: }
! 1148:
! 1149: /* Content is ready */
! 1150: if (dst_cq->bytes_in == (off_t)con->request.content_length) {
! 1151: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1152: }
! 1153:
! 1154: break;
! 1155: default: break;
! 1156: }
! 1157:
! 1158: /* the connection got closed and we didn't got enough data to leave one of the READ states
! 1159: * the only way is to leave here */
! 1160: if (is_closed && ostate == con->state) {
! 1161: connection_set_state(srv, con, CON_STATE_ERROR);
! 1162: }
! 1163:
! 1164: chunkqueue_remove_finished_chunks(cq);
! 1165:
! 1166: return 0;
! 1167: }
! 1168:
! 1169: static handler_t connection_handle_fdevent(server *srv, void *context, int revents) {
! 1170: connection *con = context;
! 1171:
! 1172: joblist_append(srv, con);
! 1173:
! 1174: if (con->srv_socket->is_ssl) {
! 1175: /* ssl may read and write for both reads and writes */
! 1176: if (revents & (FDEVENT_IN | FDEVENT_OUT)) {
! 1177: con->is_readable = 1;
! 1178: con->is_writable = 1;
! 1179: }
! 1180: } else {
! 1181: if (revents & FDEVENT_IN) {
! 1182: con->is_readable = 1;
! 1183: }
! 1184: if (revents & FDEVENT_OUT) {
! 1185: con->is_writable = 1;
! 1186: /* we don't need the event twice */
! 1187: }
! 1188: }
! 1189:
! 1190:
! 1191: if (revents & ~(FDEVENT_IN | FDEVENT_OUT)) {
! 1192: /* looks like an error */
! 1193:
! 1194: /* FIXME: revents = 0x19 still means that we should read from the queue */
! 1195: if (revents & FDEVENT_HUP) {
! 1196: if (con->state == CON_STATE_CLOSE) {
! 1197: con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
! 1198: } else {
! 1199: /* sigio reports the wrong event here
! 1200: *
! 1201: * there was no HUP at all
! 1202: */
! 1203: #ifdef USE_LINUX_SIGIO
! 1204: if (srv->ev->in_sigio == 1) {
! 1205: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1206: "connection closed: poll() -> HUP", con->fd);
! 1207: } else {
! 1208: connection_set_state(srv, con, CON_STATE_ERROR);
! 1209: }
! 1210: #else
! 1211: connection_set_state(srv, con, CON_STATE_ERROR);
! 1212: #endif
! 1213:
! 1214: }
! 1215: } else if (revents & FDEVENT_ERR) {
! 1216: /* error, connection reset, whatever... we don't want to spam the logfile */
! 1217: #if 0
! 1218: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1219: "connection closed: poll() -> ERR", con->fd);
! 1220: #endif
! 1221: connection_set_state(srv, con, CON_STATE_ERROR);
! 1222: } else {
! 1223: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1224: "connection closed: poll() -> ???", revents);
! 1225: }
! 1226: }
! 1227:
! 1228: if (con->state == CON_STATE_READ ||
! 1229: con->state == CON_STATE_READ_POST) {
! 1230: connection_handle_read_state(srv, con);
! 1231: }
! 1232:
! 1233: if (con->state == CON_STATE_WRITE &&
! 1234: !chunkqueue_is_empty(con->write_queue) &&
! 1235: con->is_writable) {
! 1236:
! 1237: if (-1 == connection_handle_write(srv, con)) {
! 1238: connection_set_state(srv, con, CON_STATE_ERROR);
! 1239:
! 1240: log_error_write(srv, __FILE__, __LINE__, "ds",
! 1241: con->fd,
! 1242: "handle write failed.");
! 1243: }
! 1244: }
! 1245:
! 1246: if (con->state == CON_STATE_CLOSE) {
! 1247: /* flush the read buffers */
! 1248: int len;
! 1249: char buf[1024];
! 1250:
! 1251: len = read(con->fd, buf, sizeof(buf));
! 1252: if (len == 0 || (len < 0 && errno != EAGAIN && errno != EINTR) ) {
! 1253: con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
! 1254: }
! 1255: }
! 1256:
! 1257: return HANDLER_FINISHED;
! 1258: }
! 1259:
! 1260:
! 1261: connection *connection_accept(server *srv, server_socket *srv_socket) {
! 1262: /* accept everything */
! 1263:
! 1264: /* search an empty place */
! 1265: int cnt;
! 1266: sock_addr cnt_addr;
! 1267: socklen_t cnt_len;
! 1268: /* accept it and register the fd */
! 1269:
! 1270: /**
! 1271: * check if we can still open a new connections
! 1272: *
! 1273: * see #1216
! 1274: */
! 1275:
! 1276: if (srv->conns->used >= srv->max_conns) {
! 1277: return NULL;
! 1278: }
! 1279:
! 1280: cnt_len = sizeof(cnt_addr);
! 1281:
! 1282: if (-1 == (cnt = accept(srv_socket->fd, (struct sockaddr *) &cnt_addr, &cnt_len))) {
! 1283: switch (errno) {
! 1284: case EAGAIN:
! 1285: #if EWOULDBLOCK != EAGAIN
! 1286: case EWOULDBLOCK:
! 1287: #endif
! 1288: case EINTR:
! 1289: /* we were stopped _before_ we had a connection */
! 1290: case ECONNABORTED: /* this is a FreeBSD thingy */
! 1291: /* we were stopped _after_ we had a connection */
! 1292: break;
! 1293: case EMFILE:
! 1294: /* out of fds */
! 1295: break;
! 1296: default:
! 1297: log_error_write(srv, __FILE__, __LINE__, "ssd", "accept failed:", strerror(errno), errno);
! 1298: }
! 1299: return NULL;
! 1300: } else {
! 1301: connection *con;
! 1302:
! 1303: srv->cur_fds++;
! 1304:
! 1305: /* ok, we have the connection, register it */
! 1306: #if 0
! 1307: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1308: "appected()", cnt);
! 1309: #endif
! 1310: srv->con_opened++;
! 1311:
! 1312: con = connections_get_new_connection(srv);
! 1313:
! 1314: con->fd = cnt;
! 1315: con->fde_ndx = -1;
! 1316: #if 0
! 1317: gettimeofday(&(con->start_tv), NULL);
! 1318: #endif
! 1319: fdevent_register(srv->ev, con->fd, connection_handle_fdevent, con);
! 1320:
! 1321: connection_set_state(srv, con, CON_STATE_REQUEST_START);
! 1322:
! 1323: con->connection_start = srv->cur_ts;
! 1324: con->dst_addr = cnt_addr;
! 1325: buffer_copy_string(con->dst_addr_buf, inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
! 1326: con->srv_socket = srv_socket;
! 1327:
! 1328: if (-1 == (fdevent_fcntl_set(srv->ev, con->fd))) {
! 1329: log_error_write(srv, __FILE__, __LINE__, "ss", "fcntl failed: ", strerror(errno));
! 1330: return NULL;
! 1331: }
! 1332: #ifdef USE_OPENSSL
! 1333: /* connect FD to SSL */
! 1334: if (srv_socket->is_ssl) {
! 1335: if (NULL == (con->ssl = SSL_new(srv_socket->ssl_ctx))) {
! 1336: log_error_write(srv, __FILE__, __LINE__, "ss", "SSL:",
! 1337: ERR_error_string(ERR_get_error(), NULL));
! 1338:
! 1339: return NULL;
! 1340: }
! 1341:
! 1342: con->renegotiations = 0;
! 1343: SSL_set_app_data(con->ssl, con);
! 1344: SSL_set_accept_state(con->ssl);
! 1345:
! 1346: if (1 != (SSL_set_fd(con->ssl, cnt))) {
! 1347: log_error_write(srv, __FILE__, __LINE__, "ss", "SSL:",
! 1348: ERR_error_string(ERR_get_error(), NULL));
! 1349: return NULL;
! 1350: }
! 1351: }
! 1352: #endif
! 1353: return con;
! 1354: }
! 1355: }
! 1356:
! 1357:
! 1358: int connection_state_machine(server *srv, connection *con) {
! 1359: int done = 0, r;
! 1360: #ifdef USE_OPENSSL
! 1361: server_socket *srv_sock = con->srv_socket;
! 1362: #endif
! 1363:
! 1364: if (srv->srvconf.log_state_handling) {
! 1365: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1366: "state at start",
! 1367: con->fd,
! 1368: connection_get_state(con->state));
! 1369: }
! 1370:
! 1371: while (done == 0) {
! 1372: size_t ostate = con->state;
! 1373:
! 1374: switch (con->state) {
! 1375: case CON_STATE_REQUEST_START: /* transient */
! 1376: if (srv->srvconf.log_state_handling) {
! 1377: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1378: "state for fd", con->fd, connection_get_state(con->state));
! 1379: }
! 1380:
! 1381: con->request_start = srv->cur_ts;
! 1382: con->read_idle_ts = srv->cur_ts;
! 1383:
! 1384: con->request_count++;
! 1385: con->loops_per_request = 0;
! 1386:
! 1387: connection_set_state(srv, con, CON_STATE_READ);
! 1388:
! 1389: break;
! 1390: case CON_STATE_REQUEST_END: /* transient */
! 1391: if (srv->srvconf.log_state_handling) {
! 1392: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1393: "state for fd", con->fd, connection_get_state(con->state));
! 1394: }
! 1395:
! 1396: buffer_reset(con->uri.authority);
! 1397: buffer_reset(con->uri.path);
! 1398: buffer_reset(con->uri.query);
! 1399: buffer_reset(con->request.orig_uri);
! 1400:
! 1401: if (http_request_parse(srv, con)) {
! 1402: /* we have to read some data from the POST request */
! 1403:
! 1404: connection_set_state(srv, con, CON_STATE_READ_POST);
! 1405:
! 1406: break;
! 1407: }
! 1408:
! 1409: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1410:
! 1411: break;
! 1412: case CON_STATE_HANDLE_REQUEST:
! 1413: /*
! 1414: * the request is parsed
! 1415: *
! 1416: * decided what to do with the request
! 1417: * -
! 1418: *
! 1419: *
! 1420: */
! 1421:
! 1422: if (srv->srvconf.log_state_handling) {
! 1423: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1424: "state for fd", con->fd, connection_get_state(con->state));
! 1425: }
! 1426:
! 1427: switch (r = http_response_prepare(srv, con)) {
! 1428: case HANDLER_FINISHED:
! 1429: if (con->mode == DIRECT) {
! 1430: if (con->http_status == 404 ||
! 1431: con->http_status == 403) {
! 1432: /* 404 error-handler */
! 1433:
! 1434: if (con->in_error_handler == 0 &&
! 1435: (!buffer_is_empty(con->conf.error_handler) ||
! 1436: !buffer_is_empty(con->error_handler))) {
! 1437: /* call error-handler */
! 1438:
! 1439: con->error_handler_saved_status = con->http_status;
! 1440: con->http_status = 0;
! 1441:
! 1442: if (buffer_is_empty(con->error_handler)) {
! 1443: buffer_copy_string_buffer(con->request.uri, con->conf.error_handler);
! 1444: } else {
! 1445: buffer_copy_string_buffer(con->request.uri, con->error_handler);
! 1446: }
! 1447: buffer_reset(con->physical.path);
! 1448:
! 1449: con->in_error_handler = 1;
! 1450:
! 1451: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1452:
! 1453: done = -1;
! 1454: break;
! 1455: } else if (con->in_error_handler) {
! 1456: /* error-handler is a 404 */
! 1457:
! 1458: con->http_status = con->error_handler_saved_status;
! 1459: }
! 1460: } else if (con->in_error_handler) {
! 1461: /* error-handler is back and has generated content */
! 1462: /* if Status: was set, take it otherwise use 200 */
! 1463: }
! 1464: }
! 1465: if (con->http_status == 0) con->http_status = 200;
! 1466:
! 1467: /* we have something to send, go on */
! 1468: connection_set_state(srv, con, CON_STATE_RESPONSE_START);
! 1469: break;
! 1470: case HANDLER_WAIT_FOR_FD:
! 1471: srv->want_fds++;
! 1472:
! 1473: fdwaitqueue_append(srv, con);
! 1474:
! 1475: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1476:
! 1477: break;
! 1478: case HANDLER_COMEBACK:
! 1479: done = -1;
! 1480: case HANDLER_WAIT_FOR_EVENT:
! 1481: /* come back here */
! 1482: connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
! 1483:
! 1484: break;
! 1485: case HANDLER_ERROR:
! 1486: /* something went wrong */
! 1487: connection_set_state(srv, con, CON_STATE_ERROR);
! 1488: break;
! 1489: default:
! 1490: log_error_write(srv, __FILE__, __LINE__, "sdd", "unknown ret-value: ", con->fd, r);
! 1491: break;
! 1492: }
! 1493:
! 1494: break;
! 1495: case CON_STATE_RESPONSE_START:
! 1496: /*
! 1497: * the decision is done
! 1498: * - create the HTTP-Response-Header
! 1499: *
! 1500: */
! 1501:
! 1502: if (srv->srvconf.log_state_handling) {
! 1503: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1504: "state for fd", con->fd, connection_get_state(con->state));
! 1505: }
! 1506:
! 1507: if (-1 == connection_handle_write_prepare(srv, con)) {
! 1508: connection_set_state(srv, con, CON_STATE_ERROR);
! 1509:
! 1510: break;
! 1511: }
! 1512:
! 1513: connection_set_state(srv, con, CON_STATE_WRITE);
! 1514: break;
! 1515: case CON_STATE_RESPONSE_END: /* transient */
! 1516: /* log the request */
! 1517:
! 1518: if (srv->srvconf.log_state_handling) {
! 1519: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1520: "state for fd", con->fd, connection_get_state(con->state));
! 1521: }
! 1522:
! 1523: plugins_call_handle_request_done(srv, con);
! 1524:
! 1525: srv->con_written++;
! 1526:
! 1527: if (con->keep_alive) {
! 1528: connection_set_state(srv, con, CON_STATE_REQUEST_START);
! 1529:
! 1530: #if 0
! 1531: con->request_start = srv->cur_ts;
! 1532: con->read_idle_ts = srv->cur_ts;
! 1533: #endif
! 1534: } else {
! 1535: switch(r = plugins_call_handle_connection_close(srv, con)) {
! 1536: case HANDLER_GO_ON:
! 1537: case HANDLER_FINISHED:
! 1538: break;
! 1539: default:
! 1540: log_error_write(srv, __FILE__, __LINE__, "sd", "unhandling return value", r);
! 1541: break;
! 1542: }
! 1543:
! 1544: #ifdef USE_OPENSSL
! 1545: if (srv_sock->is_ssl) {
! 1546: switch (SSL_shutdown(con->ssl)) {
! 1547: case 1:
! 1548: /* done */
! 1549: break;
! 1550: case 0:
! 1551: /* wait for fd-event
! 1552: *
! 1553: * FIXME: wait for fdevent and call SSL_shutdown again
! 1554: *
! 1555: */
! 1556:
! 1557: break;
! 1558: default:
! 1559: log_error_write(srv, __FILE__, __LINE__, "ss", "SSL:",
! 1560: ERR_error_string(ERR_get_error(), NULL));
! 1561: }
! 1562: }
! 1563: #endif
! 1564: if ((0 == shutdown(con->fd, SHUT_WR))) {
! 1565: con->close_timeout_ts = srv->cur_ts;
! 1566: connection_set_state(srv, con, CON_STATE_CLOSE);
! 1567: } else {
! 1568: connection_close(srv, con);
! 1569: }
! 1570:
! 1571: srv->con_closed++;
! 1572: }
! 1573:
! 1574: connection_reset(srv, con);
! 1575:
! 1576: break;
! 1577: case CON_STATE_CONNECT:
! 1578: if (srv->srvconf.log_state_handling) {
! 1579: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1580: "state for fd", con->fd, connection_get_state(con->state));
! 1581: }
! 1582:
! 1583: chunkqueue_reset(con->read_queue);
! 1584:
! 1585: con->request_count = 0;
! 1586:
! 1587: break;
! 1588: case CON_STATE_CLOSE:
! 1589: if (srv->srvconf.log_state_handling) {
! 1590: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1591: "state for fd", con->fd, connection_get_state(con->state));
! 1592: }
! 1593:
! 1594: /* we have to do the linger_on_close stuff regardless
! 1595: * of con->keep_alive; even non-keepalive sockets may
! 1596: * still have unread data, and closing before reading
! 1597: * it will make the client not see all our output.
! 1598: */
! 1599: {
! 1600: int len;
! 1601: char buf[1024];
! 1602:
! 1603: len = read(con->fd, buf, sizeof(buf));
! 1604: if (len == 0 || (len < 0 && errno != EAGAIN && errno != EINTR) ) {
! 1605: con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);
! 1606: }
! 1607: }
! 1608:
! 1609: if (srv->cur_ts - con->close_timeout_ts > HTTP_LINGER_TIMEOUT) {
! 1610: connection_close(srv, con);
! 1611:
! 1612: if (srv->srvconf.log_state_handling) {
! 1613: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1614: "connection closed for fd", con->fd);
! 1615: }
! 1616: }
! 1617:
! 1618: break;
! 1619: case CON_STATE_READ_POST:
! 1620: case CON_STATE_READ:
! 1621: if (srv->srvconf.log_state_handling) {
! 1622: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1623: "state for fd", con->fd, connection_get_state(con->state));
! 1624: }
! 1625:
! 1626: connection_handle_read_state(srv, con);
! 1627: break;
! 1628: case CON_STATE_WRITE:
! 1629: if (srv->srvconf.log_state_handling) {
! 1630: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1631: "state for fd", con->fd, connection_get_state(con->state));
! 1632: }
! 1633:
! 1634: /* only try to write if we have something in the queue */
! 1635: if (!chunkqueue_is_empty(con->write_queue)) {
! 1636: #if 0
! 1637: log_error_write(srv, __FILE__, __LINE__, "dsd",
! 1638: con->fd,
! 1639: "packets to write:",
! 1640: con->write_queue->used);
! 1641: #endif
! 1642: }
! 1643: if (!chunkqueue_is_empty(con->write_queue) && con->is_writable) {
! 1644: if (-1 == connection_handle_write(srv, con)) {
! 1645: log_error_write(srv, __FILE__, __LINE__, "ds",
! 1646: con->fd,
! 1647: "handle write failed.");
! 1648: connection_set_state(srv, con, CON_STATE_ERROR);
! 1649: }
! 1650: }
! 1651:
! 1652: break;
! 1653: case CON_STATE_ERROR: /* transient */
! 1654:
! 1655: /* even if the connection was drop we still have to write it to the access log */
! 1656: if (con->http_status) {
! 1657: plugins_call_handle_request_done(srv, con);
! 1658: }
! 1659: #ifdef USE_OPENSSL
! 1660: if (srv_sock->is_ssl) {
! 1661: int ret, ssl_r;
! 1662: unsigned long err;
! 1663: ERR_clear_error();
! 1664: switch ((ret = SSL_shutdown(con->ssl))) {
! 1665: case 1:
! 1666: /* ok */
! 1667: break;
! 1668: case 0:
! 1669: ERR_clear_error();
! 1670: if (-1 != (ret = SSL_shutdown(con->ssl))) break;
! 1671:
! 1672: /* fall through */
! 1673: default:
! 1674:
! 1675: switch ((ssl_r = SSL_get_error(con->ssl, ret))) {
! 1676: case SSL_ERROR_WANT_WRITE:
! 1677: case SSL_ERROR_WANT_READ:
! 1678: break;
! 1679: case SSL_ERROR_SYSCALL:
! 1680: /* perhaps we have error waiting in our error-queue */
! 1681: if (0 != (err = ERR_get_error())) {
! 1682: do {
! 1683: log_error_write(srv, __FILE__, __LINE__, "sdds", "SSL:",
! 1684: ssl_r, ret,
! 1685: ERR_error_string(err, NULL));
! 1686: } while((err = ERR_get_error()));
! 1687: } else if (errno != 0) { /* ssl bug (see lighttpd ticket #2213): sometimes errno == 0 */
! 1688: switch(errno) {
! 1689: case EPIPE:
! 1690: case ECONNRESET:
! 1691: break;
! 1692: default:
! 1693: log_error_write(srv, __FILE__, __LINE__, "sddds", "SSL (error):",
! 1694: ssl_r, ret, errno,
! 1695: strerror(errno));
! 1696: break;
! 1697: }
! 1698: }
! 1699:
! 1700: break;
! 1701: default:
! 1702: while((err = ERR_get_error())) {
! 1703: log_error_write(srv, __FILE__, __LINE__, "sdds", "SSL:",
! 1704: ssl_r, ret,
! 1705: ERR_error_string(err, NULL));
! 1706: }
! 1707:
! 1708: break;
! 1709: }
! 1710: }
! 1711: ERR_clear_error();
! 1712: }
! 1713: #endif
! 1714:
! 1715: switch(con->mode) {
! 1716: case DIRECT:
! 1717: #if 0
! 1718: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1719: "emergency exit: direct",
! 1720: con->fd);
! 1721: #endif
! 1722: break;
! 1723: default:
! 1724: switch(r = plugins_call_handle_connection_close(srv, con)) {
! 1725: case HANDLER_GO_ON:
! 1726: case HANDLER_FINISHED:
! 1727: break;
! 1728: default:
! 1729: log_error_write(srv, __FILE__, __LINE__, "sd", "unhandling return value", r);
! 1730: break;
! 1731: }
! 1732: break;
! 1733: }
! 1734:
! 1735: connection_reset(srv, con);
! 1736:
! 1737: /* close the connection */
! 1738: if ((0 == shutdown(con->fd, SHUT_WR))) {
! 1739: con->close_timeout_ts = srv->cur_ts;
! 1740: connection_set_state(srv, con, CON_STATE_CLOSE);
! 1741:
! 1742: if (srv->srvconf.log_state_handling) {
! 1743: log_error_write(srv, __FILE__, __LINE__, "sd",
! 1744: "shutdown for fd", con->fd);
! 1745: }
! 1746: } else {
! 1747: connection_close(srv, con);
! 1748: }
! 1749:
! 1750: con->keep_alive = 0;
! 1751:
! 1752: srv->con_closed++;
! 1753:
! 1754: break;
! 1755: default:
! 1756: log_error_write(srv, __FILE__, __LINE__, "sdd",
! 1757: "unknown state:", con->fd, con->state);
! 1758:
! 1759: break;
! 1760: }
! 1761:
! 1762: if (done == -1) {
! 1763: done = 0;
! 1764: } else if (ostate == con->state) {
! 1765: done = 1;
! 1766: }
! 1767: }
! 1768:
! 1769: if (srv->srvconf.log_state_handling) {
! 1770: log_error_write(srv, __FILE__, __LINE__, "sds",
! 1771: "state at exit:",
! 1772: con->fd,
! 1773: connection_get_state(con->state));
! 1774: }
! 1775:
! 1776: switch(con->state) {
! 1777: case CON_STATE_READ_POST:
! 1778: case CON_STATE_READ:
! 1779: case CON_STATE_CLOSE:
! 1780: fdevent_event_set(srv->ev, &(con->fde_ndx), con->fd, FDEVENT_IN);
! 1781: break;
! 1782: case CON_STATE_WRITE:
! 1783: /* request write-fdevent only if we really need it
! 1784: * - if we have data to write
! 1785: * - if the socket is not writable yet
! 1786: */
! 1787: if (!chunkqueue_is_empty(con->write_queue) &&
! 1788: (con->is_writable == 0) &&
! 1789: (con->traffic_limit_reached == 0)) {
! 1790: fdevent_event_set(srv->ev, &(con->fde_ndx), con->fd, FDEVENT_OUT);
! 1791: } else {
! 1792: fdevent_event_del(srv->ev, &(con->fde_ndx), con->fd);
! 1793: }
! 1794: break;
! 1795: default:
! 1796: fdevent_event_del(srv->ev, &(con->fde_ndx), con->fd);
! 1797: break;
! 1798: }
! 1799:
! 1800: return 0;
! 1801: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to connections.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src