nginx-ranges: src/http/ngx_http_upstream.c comparison

comparison src/http/ngx_http_upstream.c @ 132:91372f004adf NGINX_0_3_13

nginx 0.3.13 *) Feature: the IMAP/POP3 proxy supports STARTTLS and STLS. *) Bugfix: the IMAP/POP3 proxy did not work with the select, poll, and /dev/poll methods. *) Bugfix: in SSI handling. *) Bugfix: now Solaris sendfilev() is not used to transfer the client request body to FastCGI-server via the unix domain socket. *) Bugfix: the "auth_basic" directive did not disable the authorization; bug appeared in 0.3.11.

author	Igor Sysoev <http://sysoev.ru>
date	Mon, 05 Dec 2005 00:00:00 +0300
parents	82d695e3d662
children	8e6d4d96ec4c

comparison

equal deleted inserted replaced

-:add6b1e86d38
+:91372f004adf
 NULL,                                  /* exit master */
 NGX_MODULE_V1_PADDING
 };
-static ngx_http_log_op_name_t ngx_http_upstream_log_fmt_ops[] = {
+static ngx_http_log_op_name_t  ngx_http_upstream_log_fmt_ops[] = {
 { ngx_string("upstream_status"), 0, NULL,
 ngx_http_upstream_log_status_getlen,
 ngx_http_upstream_log_status },
 { ngx_string("upstream_response_time"), 0, NULL,
 ngx_http_upstream_log_response_time_getlen,
 static ngx_http_variable_t  ngx_http_upstream_vars[] = {
 { ngx_string("upstream_status"),
-ngx_http_upstream_status_variable, 0, 0, 0 },
+ngx_http_upstream_status_variable, 0, NGX_HTTP_VAR_NOHASH, 0 },
 { ngx_string("upstream_response_time"),
-ngx_http_upstream_response_time_variable, 0, 0, 0 },
+ngx_http_upstream_response_time_variable, 0, NGX_HTTP_VAR_NOHASH, 0 },
 { ngx_null_string, NULL, 0, 0, 0 }
 };
 ev->write, &r->uri);
 c = r->connection;
 u = r->upstream;
-if (c->closed) {
+if (c->error) {
 ngx_http_upstream_finalize_request(r, u,
 NGX_HTTP_CLIENT_CLOSED_REQUEST);
 return;
 }
 if (!ev->pending_eof) {
 return;
 }
 ev->eof = 1;
-c->closed = 1;
+c->error = 1;
 if (ev->kq_errno) {
 ev->error = 1;
 }
 } else { /* n == 0 */
 err = 0;
 }
 ev->eof = 1;
-c->closed = 1;
+c->error = 1;
 if (!u->cachable && u->peer.connection) {
 ngx_log_error(NGX_LOG_INFO, ev->log, err,
 "client closed prematurely connection, "
 "so upstream connection is closed too");
 static void
 ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
 {
+int                             tcp_nodelay;
 ssize_t                         size;
 ngx_int_t                       rc;
 ngx_uint_t                      i, key;
 ngx_list_part_t                *part;
 ngx_table_elt_t                *h;
 ngx_event_pipe_t               *p;
+ngx_connection_t               *c;
 ngx_pool_cleanup_t             *cl;
 ngx_pool_cleanup_file_t        *clf;
 ngx_http_core_loc_conf_t       *clcf;
 ngx_http_upstream_header_t     *hh;
 ngx_http_upstream_main_conf_t  *umcf;
 }
 }
 }
 }
+c = r->connection;
 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 if (u->pipe == NULL) {
 if (u->input_filter == NULL) {
 if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
 ngx_http_upstream_finalize_request(r, u, 0);
 return;
 }
+if (clcf->tcp_nodelay && c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
+ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");
+tcp_nodelay = 1;
+if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
+(const void *) &tcp_nodelay, sizeof(int)) == -1)
+{
+ngx_connection_error(c, ngx_socket_errno,
+"setsockopt(TCP_NODELAY) failed");
+ngx_http_upstream_finalize_request(r, u, 0);
+return;
+}
+c->tcp_nodelay = NGX_TCP_NODELAY_SET;
+}
 size = u->buffer.last - u->buffer.pos;
 if (size) {
 u->buffer.last = u->buffer.pos;
 if (u->input_filter(u->input_filter_ctx, size) == NGX_ERROR) {
 ngx_http_upstream_finalize_request(r, u, 0);
 return;
 }
-ngx_http_upstream_process_non_buffered_body(r->connection->write);
+ngx_http_upstream_process_non_buffered_body(c->write);
 } else {
 u->buffer.pos = u->buffer.start;
 u->buffer.last = u->buffer.start;
 #if 0
 if (u->cache && u->cache->ctx.file.fd != NGX_INVALID_FILE) {
 if (ngx_close_file(u->cache->ctx.file.fd) == NGX_FILE_ERROR) {
-ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
+ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
 ngx_close_file_n " \"%s\" failed",
 u->cache->ctx.file.name.data);
 }
 }
 p->output_ctx = r;
 p->tag = u->output.tag;
 p->bufs = u->conf->bufs;
 p->busy_size = u->conf->busy_buffers_size;
 p->upstream = u->peer.connection;
-p->downstream = r->connection;
+p->downstream = c;
 p->pool = r->pool;
-p->log = r->connection->log;
+p->log = c->log;
 p->cachable = u->cachable;
 p->temp_file = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
 if (p->temp_file == NULL) {
 ngx_http_upstream_finalize_request(r, u, 0);
 return;
 }
 p->temp_file->file.fd = NGX_INVALID_FILE;
-p->temp_file->file.log = r->connection->log;
+p->temp_file->file.log = c->log;
 p->temp_file->path = u->conf->temp_path;
 p->temp_file->pool = r->pool;
 if (u->cachable) {
 p->temp_file->persistent = 1;
 * because the writing a new data may interfere with sendfile()
 * that uses the same kernel file pages (at least on FreeBSD)
 */
 p->cyclic_temp_file = 1;
-r->connection->sendfile = 0;
+c->sendfile = 0;
 } else {
 p->cyclic_temp_file = 0;
 }
 ngx_http_upstream_process_non_buffered_body(ngx_event_t *ev)
 {
 size_t                     size;
 ssize_t                    n;
 ngx_buf_t                 *b;
+ngx_int_t                  rc;
 ngx_uint_t                 do_write;
-ngx_connection_t          *c;
+ngx_connection_t          *c, *client;
 ngx_http_request_t        *r;
 ngx_http_upstream_t       *u;
 ngx_http_core_loc_conf_t  *clcf;
 c = ev->data;
 }
 }
 r = c->data;
 u = r->upstream;
+client = r->connection;
 b = &u->buffer;
 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 for ( ;; ) {
 if (do_write) {
 if (u->out_bufs || u->busy_bufs) {
-if (ngx_http_output_filter(r, u->out_bufs) == NGX_ERROR) {
+rc = ngx_http_output_filter(r, u->out_bufs);
+if (client->destroyed) {
+return;
+}
+if (rc == NGX_ERROR) {
 ngx_http_upstream_finalize_request(r, u, 0);
 return;
 }
 ngx_chain_update_chains(&u->free_bufs, &u->busy_bufs,
 }
 break;
 }
-if (ngx_handle_write_event(r->connection->write, clcf->send_lowat)
+if (client->data == r) {
-== NGX_ERROR)
+if (ngx_handle_write_event(client->write, clcf->send_lowat)
-{
+== NGX_ERROR)
-ngx_http_upstream_finalize_request(r, u, 0);
+{
-return;
+ngx_http_upstream_finalize_request(r, u, 0);
-}
+return;
+}
-if (r->connection->write->active) {
+}
-ngx_add_timer(r->connection->write, clcf->send_timeout);
+if (client->write->active) {
-} else if (r->connection->write->timer_set) {
+ngx_add_timer(client->write, clcf->send_timeout);
-ngx_del_timer(r->connection->write);
+} else if (client->write->timer_set) {
+ngx_del_timer(client->write);
 }
 if (ngx_handle_read_event(u->peer.connection->read, 0) == NGX_ERROR) {
 ngx_http_upstream_finalize_request(r, u, 0);
 return;
 }
 if (u->peer.connection->read->active) {
 ngx_add_timer(u->peer.connection->read, u->conf->read_timeout);
-} else if (r->connection->read->timer_set) {
+} else if (u->peer.connection->read->timer_set) {
-ngx_del_timer(r->connection->read);
+ngx_del_timer(u->peer.connection->read);
 }
 }
 static ngx_int_t
 static void
 ngx_http_upstream_process_body(ngx_event_t *ev)
 {
 ngx_event_pipe_t     *p;
-ngx_connection_t     *c;
+ngx_connection_t     *c, *downstream;
 ngx_http_request_t   *r;
 ngx_http_upstream_t  *u;
 c = ev->data;
 r = c->data;
 u = r->upstream;
+downstream = r->connection;
 if (ev->write) {
 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
 "http upstream process downstream");
 c->log->action = "sending to client";
 return;
 }
 if (ngx_event_pipe(p, ev->write) == NGX_ABORT) {
+if (downstream->destroyed) {
+return;
+}
 ngx_http_upstream_finalize_request(r, u, 0);
 return;
 }
 } else {
 return;
 }
 if (ngx_event_pipe(p, ev->write) == NGX_ABORT) {
+if (downstream->destroyed) {
+return;
+}
 ngx_http_upstream_finalize_request(r, u, 0);
 return;
 }
 }
 default:
 status = NGX_HTTP_BAD_GATEWAY;
 }
 }
-if (r->connection->closed) {
+if (r->connection->error) {
 ngx_http_upstream_finalize_request(r, u,
 NGX_HTTP_CLIENT_CLOSED_REQUEST);
 return;
 }

Mercurial > hg > nginx-ranges

comparison src/http/ngx_http_upstream.c @ 132:91372f004adf NGINX_0_3_13