Mercurial > hg > nginx
comparison src/event/ngx_event_acceptex.c @ 543:511a89da35ad release-0.2.0
nginx-0.2.0-RELEASE import
*) The pid-file names used during online upgrade was changed and now is
not required a manual rename operation. The old master process adds
the ".oldbin" suffix to its pid-file and executes a new binary file.
The new master process creates usual pid-file without the ".newbin"
suffix. If the master process exits, then old master process renames
back its pid-file with the ".oldbin" suffix to the pid-file without
suffix.
*) Change: the "worker_connections" directive, new name of the
"connections" directive; now the directive specifies maximum number
of connections, but not maximum socket descriptor number.
*) Feature: SSL supports the session cache inside one worker process.
*) Feature: the "satisfy_any" directive.
*) Change: the ngx_http_access_module and ngx_http_auth_basic_module do
not run for subrequests.
*) Feature: the "worker_rlimit_nofile" and "worker_rlimit_sigpending"
directives.
*) Bugfix: if all backend using in load-balancing failed after one
error, then nginx did not try do connect to them during 60 seconds.
*) Bugfix: in IMAP/POP3 command argument parsing.
Thanks to Rob Mueller.
*) Bugfix: errors while using SSL in IMAP/POP3 proxy.
*) Bugfix: errors while using SSI and gzipping.
*) Bugfix: the "Expires" and "Cache-Control" header lines were omitted
from the 304 responses.
Thanks to Alexandr Kukushkin.
author | Igor Sysoev <igor@sysoev.ru> |
---|---|
date | Fri, 23 Sep 2005 11:02:22 +0000 |
parents | 371c1cee100d |
children | e48ebafc6939 |
comparison
equal
deleted
inserted
replaced
542:3a7cecdbb994 | 543:511a89da35ad |
---|---|
7 #include <ngx_config.h> | 7 #include <ngx_config.h> |
8 #include <ngx_core.h> | 8 #include <ngx_core.h> |
9 #include <ngx_event.h> | 9 #include <ngx_event.h> |
10 | 10 |
11 | 11 |
12 void ngx_event_acceptex(ngx_event_t *rev) | 12 static void ngx_close_posted_connection(ngx_connection_t *c); |
13 | |
14 | |
15 void | |
16 ngx_event_acceptex(ngx_event_t *rev) | |
13 { | 17 { |
14 ngx_connection_t *c; | 18 ngx_connection_t *c; |
15 | 19 |
16 c = rev->data; | 20 c = rev->data; |
21 | |
22 c->log->handler = ngx_accept_log_error; | |
17 | 23 |
18 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "AcceptEx: %d", c->fd); | 24 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "AcceptEx: %d", c->fd); |
19 | 25 |
20 if (rev->ovlp.error) { | 26 if (rev->ovlp.error) { |
21 ngx_log_error(NGX_LOG_CRIT, c->log, rev->ovlp.error, | 27 ngx_log_error(NGX_LOG_CRIT, c->log, rev->ovlp.error, |
76 return; | 82 return; |
77 | 83 |
78 } | 84 } |
79 | 85 |
80 | 86 |
81 int ngx_event_post_acceptex(ngx_listening_t *ls, int n) | 87 ngx_int_t |
88 ngx_event_post_acceptex(ngx_listening_t *ls, ngx_uint_t n) | |
82 { | 89 { |
83 u_long rcvd; | 90 u_long rcvd; |
84 ngx_int_t i; | |
85 ngx_err_t err; | 91 ngx_err_t err; |
92 ngx_log_t *log; | |
93 ngx_uint_t i; | |
86 ngx_event_t *rev, *wev; | 94 ngx_event_t *rev, *wev; |
87 ngx_socket_t s; | 95 ngx_socket_t s; |
88 ngx_connection_t *c; | 96 ngx_connection_t *c; |
89 | 97 |
90 for (i = 0; i < n; i++) { | 98 for (i = 0; i < n; i++) { |
91 | 99 |
92 /* TODO: look up reused sockets */ | 100 /* TODO: look up reused sockets */ |
93 | 101 |
94 s = ngx_socket(ls->family, ls->type, 0); | 102 s = ngx_socket(ls->family, ls->type, 0); |
95 | 103 |
96 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ls->log, 0, | 104 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, &ls->log, 0, |
97 ngx_socket_n " s:%d", s); | 105 ngx_socket_n " s:%d", s); |
98 | 106 |
99 if (s == -1) { | 107 if (s == -1) { |
100 ngx_log_error(NGX_LOG_ALERT, ls->log, ngx_socket_errno, | 108 ngx_log_error(NGX_LOG_ALERT, &ls->log, ngx_socket_errno, |
101 ngx_socket_n " for AcceptEx() %s post failed", | 109 ngx_socket_n " failed"); |
102 ls->addr_text.data); | 110 |
103 | 111 return NGX_ERROR; |
104 return NGX_ERROR; | 112 } |
105 } | 113 |
106 | 114 c = ngx_get_connection(s, &ls->log); |
107 /* | 115 |
108 * Winsock assignes a socket number divisible by 4 | 116 if (c == NULL) { |
109 * so to find a connection we divide a socket number by 4. | 117 return NGX_ERROR; |
110 */ | 118 } |
111 | 119 |
112 if (s % 4) { | 120 rev = c->read; |
113 ngx_log_error(NGX_LOG_EMERG, ls->log, 0, | 121 wev = c->write; |
114 ngx_socket_n | |
115 " created socket %d, not divisible by 4", s); | |
116 | |
117 exit(1); | |
118 } | |
119 | |
120 c = &ngx_cycle->connections[s / 4]; | |
121 rev = &ngx_cycle->read_events[s / 4]; | |
122 wev = &ngx_cycle->write_events[s / 4]; | |
123 | 122 |
124 ngx_memzero(c, sizeof(ngx_connection_t)); | 123 ngx_memzero(c, sizeof(ngx_connection_t)); |
124 | |
125 c->read = rev; | |
126 c->write = wev; | |
127 c->fd = s; | |
128 c->log = &ls->log; | |
129 | |
130 c->pool = ngx_create_pool(ls->pool_size, &ls->log); | |
131 if (c->pool == NULL) { | |
132 ngx_close_posted_connection(c); | |
133 return NGX_ERROR; | |
134 } | |
135 | |
136 log = ngx_palloc(c->pool, sizeof(ngx_log_t)); | |
137 if (log == NULL) { | |
138 ngx_close_posted_connection(c); | |
139 return NGX_ERROR; | |
140 } | |
141 | |
142 c->buffer = ngx_create_temp_buf(c->pool, ls->post_accept_buffer_size | |
143 + 2 * (ls->socklen + 16)); | |
144 if (c->buffer == NULL) { | |
145 ngx_close_posted_connection(c); | |
146 return NGX_ERROR; | |
147 } | |
148 | |
149 c->local_sockaddr = ngx_palloc(c->pool, ls->socklen); | |
150 if (c->local_sockaddr == NULL) { | |
151 ngx_close_posted_connection(c); | |
152 return NGX_ERROR; | |
153 } | |
154 | |
155 c->sockaddr = ngx_palloc(c->pool, ls->socklen); | |
156 if (c->sockaddr == NULL) { | |
157 ngx_close_posted_connection(c); | |
158 return NGX_ERROR; | |
159 } | |
160 | |
161 *log = ls->log; | |
162 c->log = log; | |
163 | |
164 c->recv = ngx_recv; | |
165 c->send = ngx_send; | |
166 c->send_chain = ngx_send_chain; | |
167 | |
168 c->unexpected_eof = 1; | |
169 | |
170 c->ctx = ls->ctx; | |
171 c->servers = ls->servers; | |
172 | |
173 c->listening = ls; | |
174 | |
125 ngx_memzero(rev, sizeof(ngx_event_t)); | 175 ngx_memzero(rev, sizeof(ngx_event_t)); |
126 ngx_memzero(wev, sizeof(ngx_event_t)); | 176 ngx_memzero(wev, sizeof(ngx_event_t)); |
127 | 177 |
128 c->listening = ls; | 178 rev->data = c; |
179 wev->data = c; | |
129 | 180 |
130 rev->index = NGX_INVALID_INDEX; | 181 rev->index = NGX_INVALID_INDEX; |
131 wev->index = NGX_INVALID_INDEX; | 182 wev->index = NGX_INVALID_INDEX; |
132 | 183 |
133 rev->ovlp.event = rev; | 184 rev->ovlp.event = rev; |
134 wev->ovlp.event = wev; | 185 wev->ovlp.event = wev; |
135 rev->handler = ngx_event_acceptex; | 186 rev->handler = ngx_event_acceptex; |
136 | 187 |
137 rev->data = c; | |
138 wev->data = c; | |
139 | |
140 c->read = rev; | |
141 c->write = wev; | |
142 | |
143 c->fd = s; | |
144 c->unexpected_eof = 1; | |
145 | |
146 rev->ready = 1; | 188 rev->ready = 1; |
147 wev->write = 1; | 189 wev->write = 1; |
148 wev->ready = 1; | 190 wev->ready = 1; |
149 | 191 |
150 c->ctx = ls->ctx; | 192 rev->log = c->log; |
151 c->servers = ls->servers; | 193 wev->log = c->log; |
152 | |
153 c->recv = ngx_recv; | |
154 c->send = ngx_send; | |
155 c->send_chain = ngx_send_chain; | |
156 | |
157 c->pool = ngx_create_pool(ls->pool_size, ls->log); | |
158 if (c->pool == NULL) { | |
159 return NGX_ERROR; | |
160 } | |
161 | |
162 c->buffer = ngx_create_temp_buf(c->pool, | |
163 ls->post_accept_buffer_size | |
164 + 2 * (c->listening->socklen + 16)); | |
165 if (c->buffer == NULL) { | |
166 return NGX_ERROR; | |
167 } | |
168 | |
169 c->local_sockaddr = ngx_palloc(c->pool, ls->socklen); | |
170 if (c->local_sockaddr == NULL) { | |
171 return NGX_ERROR; | |
172 } | |
173 | |
174 c->sockaddr = ngx_palloc(c->pool, ls->socklen); | |
175 if (c->sockaddr == NULL) { | |
176 return NGX_ERROR; | |
177 } | |
178 | |
179 c->log = ngx_palloc(c->pool, sizeof(ngx_log_t)); | |
180 if (c->log == NULL) { | |
181 return NGX_ERROR; | |
182 } | |
183 | |
184 ngx_memcpy(c->log, ls->log, sizeof(ngx_log_t)); | |
185 c->read->log = c->log; | |
186 c->write->log = c->log; | |
187 | 194 |
188 if (ngx_add_event(rev, 0, NGX_IOCP_IO) == NGX_ERROR) { | 195 if (ngx_add_event(rev, 0, NGX_IOCP_IO) == NGX_ERROR) { |
196 ngx_close_posted_connection(c); | |
189 return NGX_ERROR; | 197 return NGX_ERROR; |
190 } | 198 } |
191 | 199 |
192 if (acceptex(ls->fd, s, c->buffer->pos, ls->post_accept_buffer_size, | 200 if (acceptex(ls->fd, s, c->buffer->pos, ls->post_accept_buffer_size, |
193 ls->socklen + 16, ls->socklen + 16, | 201 ls->socklen + 16, ls->socklen + 16, |
194 &rcvd, (LPOVERLAPPED) &rev->ovlp) == 0) | 202 &rcvd, (LPOVERLAPPED) &rev->ovlp) == 0) |
195 { | 203 { |
196 | 204 |
197 err = ngx_socket_errno; | 205 err = ngx_socket_errno; |
198 if (err != WSA_IO_PENDING) { | 206 if (err != WSA_IO_PENDING) { |
199 ngx_log_error(NGX_LOG_ALERT, ls->log, err, | 207 ngx_log_error(NGX_LOG_ALERT, &ls->log, err, |
200 "AcceptEx() %s falied", ls->addr_text.data); | 208 "AcceptEx() %s falied", ls->addr_text.data); |
201 | 209 |
210 ngx_close_posted_connection(c); | |
202 return NGX_ERROR; | 211 return NGX_ERROR; |
203 } | 212 } |
204 } | 213 } |
205 } | 214 } |
206 | 215 |
207 return NGX_OK; | 216 return NGX_OK; |
208 } | 217 } |
218 | |
219 | |
220 static void | |
221 ngx_close_posted_connection(ngx_connection_t *c) | |
222 { | |
223 ngx_socket_t fd; | |
224 | |
225 ngx_free_connection(c); | |
226 | |
227 fd = c->fd; | |
228 c->fd = (ngx_socket_t) -1; | |
229 | |
230 if (ngx_close_socket(fd) == -1) { | |
231 ngx_log_error(NGX_LOG_ALERT, c->log, ngx_socket_errno, | |
232 ngx_close_socket_n " failed"); | |
233 } | |
234 | |
235 if (c->pool) { | |
236 ngx_destroy_pool(c->pool); | |
237 } | |
238 } | |
239 | |
240 | |
241 u_char * | |
242 ngx_acceptex_log_error(ngx_log_t *log, u_char *buf, size_t len) | |
243 { | |
244 return ngx_snprintf(buf, len, " while posting AcceptEx() on %V", log->data); | |
245 } |