Mercurial > hg > nginx-vendor-0-6

comparison src/event/ngx_event_connect.c @ 0:f0b350454894 NGINX_0_1_0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx 0.1.0 *) The first public version.
author Igor Sysoev <http://sysoev.ru>
date Mon, 04 Oct 2004 00:00:00 +0400
parents
children 4b2dafa26fe2
comparison
equal deleted inserted replaced
-1:000000000000 0:f0b350454894
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 #include <ngx_event_connect.h>
11 #include <nginx.h>
12
13
14 /* AF_INET only */
15
16 int ngx_event_connect_peer(ngx_peer_connection_t *pc)
17 {
18 int rc;
19 ngx_uint_t instance;
20 u_int event;
21 time_t now;
22 ngx_err_t err;
23 ngx_peer_t *peer;
24 ngx_socket_t s;
25 ngx_event_t *rev, *wev;
26 ngx_connection_t *c;
27 ngx_event_conf_t *ecf;
28 struct sockaddr_in addr;
29
30 now = ngx_time();
31
32 /* ngx_lock_mutex(pc->peers->mutex); */
33
34 if (pc->peers->last_cached) {
35
36 /* cached connection */
37
38 c = pc->peers->cached[pc->peers->last_cached];
39 pc->peers->last_cached--;
40
41 /* ngx_unlock_mutex(pc->peers->mutex); */
42
43 #if (NGX_THREADS)
44 c->read->lock = c->read->own_lock;
45 c->write->lock = c->write->own_lock;
46 #endif
47
48 pc->connection = c;
49 pc->cached = 1;
50 return NGX_OK;
51 }
52
53 pc->cached = 0;
54 pc->connection = NULL;
55
56 if (pc->peers->number == 1) {
57 peer = &pc->peers->peers[0];
58
59 } else {
60
61 /* there are several peers */
62
63 if (pc->tries == pc->peers->number) {
64
65 /* it's a first try - get a current peer */
66
67 pc->cur_peer = pc->peers->current++;
68
69 if (pc->peers->current >= pc->peers->number) {
70 pc->peers->current = 0;
71 }
72 }
73
74 if (pc->peers->max_fails == 0) {
75 peer = &pc->peers->peers[pc->cur_peer];
76
77 } else {
78
79 /* the peers support a fault tolerance */
80
81 for ( ;; ) {
82 peer = &pc->peers->peers[pc->cur_peer];
83
84 if (peer->fails <= pc->peers->max_fails
85 || (now - peer->accessed > pc->peers->fail_timeout))
86 {
87 break;
88 }
89
90 pc->cur_peer++;
91
92 if (pc->cur_peer >= pc->peers->number) {
93 pc->cur_peer = 0;
94 }
95
96 pc->tries--;
97
98 if (pc->tries == 0) {
99 /* ngx_unlock_mutex(pc->peers->mutex); */
100
101 return NGX_ERROR;
102 }
103 }
104 }
105 }
106
107 /* ngx_unlock_mutex(pc->peers->mutex); */
108
109
110 s = ngx_socket(AF_INET, SOCK_STREAM, IPPROTO_IP, 0);
111
112 if (s == -1) {
113 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
114 ngx_socket_n " failed");
115 return NGX_ERROR;
116 }
117
118
119 ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);
120
121 /* disable warning: Win32 SOCKET is u_int while UNIX socket is int */
122
123 if ((ngx_uint_t) s >= ecf->connections) {
124
125 ngx_log_error(NGX_LOG_ALERT, pc->log, 0,
126 "socket() returned socket #%d while only %d "
127 "connections was configured, closing the socket",
128 s, ecf->connections);
129
130 if (ngx_close_socket(s) == -1) {
131 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
132 ngx_close_socket_n "failed");
133 }
134
135 /* TODO: sleep for some time */
136
137 return NGX_ERROR;
138 }
139
140
141 if (pc->rcvbuf) {
142 if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
143 (const void *) &pc->rcvbuf, sizeof(int)) == -1) {
144 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
145 "setsockopt(SO_RCVBUF) failed");
146
147 if (ngx_close_socket(s) == -1) {
148 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
149 ngx_close_socket_n " failed");
150 }
151
152 return NGX_ERROR;
153 }
154 }
155
156 if (ngx_nonblocking(s) == -1) {
157 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
158 ngx_nonblocking_n " failed");
159
160 if (ngx_close_socket(s) == -1) {
161 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
162 ngx_close_socket_n " failed");
163 }
164
165 return NGX_ERROR;
166 }
167
168 #if (WIN32)
169 /*
170 * Winsock assignes a socket number divisible by 4
171 * so to find a connection we divide a socket number by 4.
172 */
173
174 if (s % 4) {
175 ngx_log_error(NGX_LOG_EMERG, pc->log, 0,
176 ngx_socket_n
177 " created socket %d, not divisible by 4", s);
178 exit(1);
179 }
180
181 c = &ngx_cycle->connections[s / 4];
182 rev = &ngx_cycle->read_events[s / 4];
183 wev = &ngx_cycle->write_events[s / 4];
184
185 #else
186
187 c = &ngx_cycle->connections[s];
188 rev = &ngx_cycle->read_events[s];
189 wev = &ngx_cycle->write_events[s];
190
191 #endif
192
193 instance = rev->instance;
194
195 #if (NGX_THREADS)
196
197 if (*(&c->lock)) {
198 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, pc->log, 0,
199 "spinlock in connect, fd:%d", s);
200 ngx_spinlock(&c->lock, 1000);
201 ngx_unlock(&c->lock);
202 }
203
204 #endif
205
206 ngx_memzero(c, sizeof(ngx_connection_t));
207 ngx_memzero(rev, sizeof(ngx_event_t));
208 ngx_memzero(wev, sizeof(ngx_event_t));
209
210 rev->instance = !instance;
211 wev->instance = !instance;
212
213 rev->index = NGX_INVALID_INDEX;
214 wev->index = NGX_INVALID_INDEX;
215
216 rev->data = c;
217 wev->data = c;
218
219 c->read = rev;
220 c->write = wev;
221 wev->write = 1;
222
223 c->log = pc->log;
224 rev->log = pc->log;
225 wev->log = pc->log;
226
227 c->fd = s;
228
229 c->log_error = pc->log_error;
230
231 pc->connection = c;
232
233 /*
234 * TODO: MT: - atomic increment (x86: lock xadd)
235 * or protection by critical section or mutex
236 *
237 * TODO: MP: - allocated in a shared memory
238 * - atomic increment (x86: lock xadd)
239 * or protection by critical section or mutex
240 */
241
242 c->number = ngx_atomic_inc(ngx_connection_counter);
243
244 #if (NGX_THREADS)
245 rev->lock = pc->lock;
246 wev->lock = pc->lock;
247 rev->own_lock = &c->lock;
248 wev->own_lock = &c->lock;
249 #endif
250
251 if (ngx_add_conn) {
252 if (ngx_add_conn(c) == NGX_ERROR) {
253 return NGX_ERROR;
254 }
255 }
256
257 ngx_memzero(&addr, sizeof(struct sockaddr_in));
258
259 addr.sin_family = AF_INET;
260 addr.sin_port = peer->port;
261 addr.sin_addr.s_addr = peer->addr;
262
263 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, pc->log, 0,
264 "connect to %s, #%d", peer->addr_port_text.data, c->number);
265
266 rc = connect(s, (struct sockaddr *) &addr, sizeof(struct sockaddr_in));
267
268 if (rc == -1) {
269 err = ngx_socket_errno;
270
271 /* Winsock returns WSAEWOULDBLOCK (NGX_EAGAIN) */
272
273 if (err != NGX_EINPROGRESS && err != NGX_EAGAIN) {
274 ngx_connection_error(c, err, "connect() failed");
275
276 if (ngx_close_socket(s) == -1) {
277 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
278 ngx_close_socket_n " failed");
279 }
280
281 c->fd = (ngx_socket_t) -1;
282
283 return NGX_CONNECT_ERROR;
284 }
285 }
286
287 if (ngx_add_conn) {
288 if (rc == -1) {
289 /* NGX_EINPROGRESS */
290 return NGX_AGAIN;
291 }
292
293 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");
294 return NGX_OK;
295 }
296
297 if (ngx_event_flags & NGX_USE_AIO_EVENT) {
298
299 /* aio, iocp */
300
301 if (ngx_blocking(s) == -1) {
302 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
303 ngx_blocking_n " failed");
304
305 if (ngx_close_socket(s) == -1) {
306 ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
307 ngx_close_socket_n " failed");
308 }
309
310 return NGX_ERROR;
311 }
312
313 /*
314 * aio allows to post operation on non-connected socket
315 * at least in FreeBSD.
316 * NT does not support it.
317 *
318 * TODO: check in Win32, etc. As workaround we can use NGX_ONESHOT_EVENT
319 */
320
321 rev->ready = 1;
322 wev->ready = 1;
323
324 return NGX_OK;
325 }
326
327 if (ngx_event_flags & NGX_USE_CLEAR_EVENT) { /* kqueue */
328 event = NGX_CLEAR_EVENT;
329
330 } else { /* select, poll, /dev/poll */
331 event = NGX_LEVEL_EVENT;
332 }
333
334 if (ngx_add_event(rev, NGX_READ_EVENT, event) != NGX_OK) {
335 return NGX_ERROR;
336 }
337
338 if (rc == -1) {
339
340 /* NGX_EINPROGRESS */
341
342 if (ngx_add_event(wev, NGX_WRITE_EVENT, event) != NGX_OK) {
343 return NGX_ERROR;
344 }
345
346 return NGX_AGAIN;
347 }
348
349 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, pc->log, 0, "connected");
350
351 wev->ready = 1;
352
353 return NGX_OK;
354 }
355
356
357 void ngx_event_connect_peer_failed(ngx_peer_connection_t *pc)
358 {
359 time_t now;
360
361 now = ngx_time();
362
363 /* ngx_lock_mutex(pc->peers->mutex); */
364
365 pc->peers->peers[pc->cur_peer].fails++;
366 pc->peers->peers[pc->cur_peer].accessed = now;
367
368 /* ngx_unlock_mutex(pc->peers->mutex); */
369
370 pc->cur_peer++;
371
372 if (pc->cur_peer >= pc->peers->number) {
373 pc->cur_peer = 0;
374 }
375
376 pc->tries--;
377
378 return;
379 }