1
2 /*
3 * Copyright (C) Igor Sysoev
4 */
5
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9 #include <ngx_event.h>
10
11
12 static ngx_int_t ngx_enable_accept_events(ngx_cycle_t *cycle);
13 static ngx_int_t ngx_disable_accept_events(ngx_cycle_t *cycle);
14 static void ngx_close_accepted_connection(ngx_connection_t *c);
15
16
17 void
18 ngx_event_accept(ngx_event_t *ev)
19 {
20 socklen_t socklen;
21 ngx_err_t err;
22 ngx_log_t *log;
23 ngx_socket_t s;
24 ngx_event_t *rev, *wev;
25 ngx_listening_t *ls;
26 ngx_connection_t *c, *lc;
27 ngx_event_conf_t *ecf;
28 u_char sa[NGX_SOCKADDRLEN];
29
30 ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);
31
32 if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
33 ev->available = 1;
34
35 } else if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {
36 ev->available = ecf->multi_accept;
37 }
38
39 lc = ev->data;
40 ls = lc->listening;
41 ev->ready = 0;
42
43 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
44 "accept on %V, ready: %d", &ls->addr_text, ev->available);
45
46 do {
47 socklen = NGX_SOCKADDRLEN;
48
49 s = accept(lc->fd, (struct sockaddr *) sa, &socklen);
50
51 if (s == -1) {
52 err = ngx_socket_errno;
53
54 if (err == NGX_EAGAIN) {
55 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, err,
56 "accept() not ready");
57 return;
58 }
59
60 ngx_log_error((ngx_uint_t) ((err == NGX_ECONNABORTED) ?
61 NGX_LOG_ERR : NGX_LOG_ALERT),
62 ev->log, err, "accept() failed");
63
64 if (err == NGX_ECONNABORTED) {
65 if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
66 ev->available--;
67 }
68
69 if (ev->available) {
70 continue;
71 }
72 }
73
74 return;
75 }
76
77 #if (NGX_STAT_STUB)
78 (void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);
79 #endif
80
81 ngx_accept_disabled = ngx_cycle->connection_n / 8
82 - ngx_cycle->free_connection_n;
83
84 c = ngx_get_connection(s, ev->log);
85
86 if (c == NULL) {
87 if (ngx_close_socket(s) == -1) {
88 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
89 ngx_close_socket_n " failed");
90 }
91
92 return;
93 }
94
95 #if (NGX_STAT_STUB)
96 (void) ngx_atomic_fetch_add(ngx_stat_active, 1);
97 #endif
98
99 c->pool = ngx_create_pool(ls->pool_size, ev->log);
100 if (c->pool == NULL) {
101 ngx_close_accepted_connection(c);
102 return;
103 }
104
105 c->sockaddr = ngx_palloc(c->pool, socklen);
106 if (c->sockaddr == NULL) {
107 ngx_close_accepted_connection(c);
108 return;
109 }
110
111 ngx_memcpy(c->sockaddr, sa, socklen);
112
113 log = ngx_palloc(c->pool, sizeof(ngx_log_t));
114 if (log == NULL) {
115 ngx_close_accepted_connection(c);
116 return;
117 }
118
119 /* set a blocking mode for aio and non-blocking mode for others */
120
121 if (ngx_inherited_nonblocking) {
122 if (ngx_event_flags & NGX_USE_AIO_EVENT) {
123 if (ngx_blocking(s) == -1) {
124 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
125 ngx_blocking_n " failed");
126 ngx_close_accepted_connection(c);
127 return;
128 }
129 }
130
131 } else {
132 if (!(ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT))) {
133 if (ngx_nonblocking(s) == -1) {
134 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
135 ngx_nonblocking_n " failed");
136 ngx_close_accepted_connection(c);
137 return;
138 }
139 }
140 }
141
142 *log = ls->log;
143
144 c->recv = ngx_recv;
145 c->send = ngx_send;
146 c->recv_chain = ngx_recv_chain;
147 c->send_chain = ngx_send_chain;
148
149 c->log = log;
150 c->pool->log = log;
151
152 c->socklen = socklen;
153 c->listening = ls;
154 c->local_sockaddr = ls->sockaddr;
155 c->local_socklen = ls->socklen;
156
157 c->unexpected_eof = 1;
158
159 rev = c->read;
160 wev = c->write;
161
162 wev->ready = 1;
163
164 if (ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT)) {
165 /* rtsig, aio, iocp */
166 rev->ready = 1;
167 }
168
169 if (ev->deferred_accept) {
170 rev->ready = 1;
171 #if (NGX_HAVE_KQUEUE)
172 rev->available = 1;
173 #endif
174 }
175
176 rev->log = log;
177 wev->log = log;
178
179 /*
180 * TODO: MT: - ngx_atomic_fetch_add()
181 * or protection by critical section or light mutex
182 *
183 * TODO: MP: - allocated in a shared memory
184 * - ngx_atomic_fetch_add()
185 * or protection by critical section or light mutex
186 */
187
188 c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
189
190 #if (NGX_STAT_STUB)
191 (void) ngx_atomic_fetch_add(ngx_stat_handled, 1);
192 #endif
193
194 #if (NGX_THREADS)
195 rev->lock = &c->lock;
196 wev->lock = &c->lock;
197 rev->own_lock = &c->lock;
198 wev->own_lock = &c->lock;
199 #endif
200
201 if (ls->addr_ntop) {
202 c->addr_text.data = ngx_pnalloc(c->pool, ls->addr_text_max_len);
203 if (c->addr_text.data == NULL) {
204 ngx_close_accepted_connection(c);
205 return;
206 }
207
208 c->addr_text.len = ngx_sock_ntop(c->sockaddr, c->addr_text.data,
209 ls->addr_text_max_len, 0);
210 if (c->addr_text.len == 0) {
211 ngx_close_accepted_connection(c);
212 return;
213 }
214 }
215
216 #if (NGX_DEBUG)
217 {
218
219 in_addr_t i;
220 ngx_event_debug_t *dc;
221 struct sockaddr_in *sin;
222
223 sin = (struct sockaddr_in *) sa;
224 dc = ecf->debug_connection.elts;
225 for (i = 0; i < ecf->debug_connection.nelts; i++) {
226 if ((sin->sin_addr.s_addr & dc[i].mask) == dc[i].addr) {
227 log->log_level = NGX_LOG_DEBUG_CONNECTION|NGX_LOG_DEBUG_ALL;
228 break;
229 }
230 }
231
232 }
233 #endif
234
235 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, log, 0,
236 "*%d accept: %V fd:%d", c->number, &c->addr_text, s);
237
238 if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOLL_EVENT) == 0) {
239 if (ngx_add_conn(c) == NGX_ERROR) {
240 ngx_close_accepted_connection(c);
241 return;
242 }
243 }
244
245 log->data = NULL;
246 log->handler = NULL;
247
248 ls->handler(c);
249
250 if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
251 ev->available--;
252 }
253
254 } while (ev->available);
255 }
256
257
258 ngx_int_t
259 ngx_trylock_accept_mutex(ngx_cycle_t *cycle)
260 {
261 if (ngx_shmtx_trylock(&ngx_accept_mutex)) {
262
263 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
264 "accept mutex locked");
265
266 if (ngx_accept_mutex_held
267 && ngx_accept_events == 0
268 && !(ngx_event_flags & NGX_USE_RTSIG_EVENT))
269 {
270 return NGX_OK;
271 }
272
273 if (ngx_enable_accept_events(cycle) == NGX_ERROR) {
274 ngx_shmtx_unlock(&ngx_accept_mutex);
275 return NGX_ERROR;
276 }
277
278 ngx_accept_events = 0;
279 ngx_accept_mutex_held = 1;
280
281 return NGX_OK;
282 }
283
284 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
285 "accept mutex lock failed: %ui", ngx_accept_mutex_held);
286
287 if (ngx_accept_mutex_held) {
288 if (ngx_disable_accept_events(cycle) == NGX_ERROR) {
289 return NGX_ERROR;
290 }
291
292 ngx_accept_mutex_held = 0;
293 }
294
295 return NGX_OK;
296 }
297
298
299 static ngx_int_t
300 ngx_enable_accept_events(ngx_cycle_t *cycle)
301 {
302 ngx_uint_t i;
303 ngx_listening_t *ls;
304 ngx_connection_t *c;
305
306 ls = cycle->listening.elts;
307 for (i = 0; i < cycle->listening.nelts; i++) {
308
309 c = ls[i].connection;
310
311 if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
312
313 if (ngx_add_conn(c) == NGX_ERROR) {
314 return NGX_ERROR;
315 }
316
317 } else {
318 if (ngx_add_event(c->read, NGX_READ_EVENT, 0) == NGX_ERROR) {
319 return NGX_ERROR;
320 }
321 }
322 }
323
324 return NGX_OK;
325 }
326
327
328 static ngx_int_t
329 ngx_disable_accept_events(ngx_cycle_t *cycle)
330 {
331 ngx_uint_t i;
332 ngx_listening_t *ls;
333 ngx_connection_t *c;
334
335 ls = cycle->listening.elts;
336 for (i = 0; i < cycle->listening.nelts; i++) {
337
338 c = ls[i].connection;
339
340 if (!c->read->active) {
341 continue;
342 }
343
344 if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
345 if (ngx_del_conn(c, NGX_DISABLE_EVENT) == NGX_ERROR) {
346 return NGX_ERROR;
347 }
348
349 } else {
350 if (ngx_del_event(c->read, NGX_READ_EVENT, NGX_DISABLE_EVENT)
351 == NGX_ERROR)
352 {
353 return NGX_ERROR;
354 }
355 }
356 }
357
358 return NGX_OK;
359 }
360
361
362 static void
363 ngx_close_accepted_connection(ngx_connection_t *c)
364 {
365 ngx_socket_t fd;
366
367 ngx_free_connection(c);
368
369 fd = c->fd;
370 c->fd = (ngx_socket_t) -1;
371
372 if (ngx_close_socket(fd) == -1) {
373 ngx_log_error(NGX_LOG_ALERT, c->log, ngx_socket_errno,
374 ngx_close_socket_n " failed");
375 }
376
377 if (c->pool) {
378 ngx_destroy_pool(c->pool);
379 }
380
381 #if (NGX_STAT_STUB)
382 (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
383 #endif
384 }
385
386
387 u_char *
388 ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len)
389 {
390 return ngx_snprintf(buf, len, " while accepting new connection on %V",
391 log->data);
392 }
393
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.