Mercurial > hg > nginx-mail
comparison src/event/ngx_event_connect.c @ 0:f0b350454894 NGINX_0_1_0
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 } |