blob: 21c50fc573f98a4a34795528a21bec03c49c07b9 [file] [log] [blame]
Willy Tarreau92fb9832007-10-16 17:34:28 +02001/*
2 * UNIX SOCK_STREAM protocol layer (uxst)
3 *
Willy Tarreau7c669d72008-06-20 15:04:11 +02004 * Copyright 2000-2008 Willy Tarreau <w@1wt.eu>
Willy Tarreau92fb9832007-10-16 17:34:28 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <ctype.h>
14#include <errno.h>
15#include <fcntl.h>
16#include <stdio.h>
17#include <stdlib.h>
18#include <string.h>
19#include <syslog.h>
20#include <time.h>
21
22#include <sys/param.h>
23#include <sys/socket.h>
24#include <sys/stat.h>
25#include <sys/types.h>
26#include <sys/un.h>
27
28#include <common/compat.h>
29#include <common/config.h>
30#include <common/debug.h>
Willy Tarreaud740bab2007-10-28 11:14:07 +010031#include <common/errors.h>
Willy Tarreau92fb9832007-10-16 17:34:28 +020032#include <common/memory.h>
33#include <common/mini-clist.h>
34#include <common/standard.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020035#include <common/ticks.h>
Willy Tarreau92fb9832007-10-16 17:34:28 +020036#include <common/time.h>
37#include <common/version.h>
38
Willy Tarreau92fb9832007-10-16 17:34:28 +020039#include <types/global.h>
Willy Tarreau92fb9832007-10-16 17:34:28 +020040
41#include <proto/acl.h>
42#include <proto/backend.h>
43#include <proto/buffers.h>
Willy Tarreau3e76e722007-10-17 18:57:38 +020044#include <proto/dumpstats.h>
Willy Tarreau92fb9832007-10-16 17:34:28 +020045#include <proto/fd.h>
46#include <proto/log.h>
47#include <proto/protocols.h>
48#include <proto/proto_uxst.h>
49#include <proto/queue.h>
50#include <proto/session.h>
Willy Tarreaub1356cf2008-12-07 16:06:43 +010051#include <proto/stream_interface.h>
Willy Tarreau92fb9832007-10-16 17:34:28 +020052#include <proto/stream_sock.h>
53#include <proto/task.h>
54
55#ifndef MAXPATHLEN
56#define MAXPATHLEN 128
57#endif
58
Willy Tarreaudabf2e22007-10-28 21:59:24 +010059static int uxst_bind_listeners(struct protocol *proto);
60static int uxst_unbind_listeners(struct protocol *proto);
61
62/* Note: must not be declared <const> as its list will be overwritten */
63static struct protocol proto_unix = {
64 .name = "unix_stream",
65 .sock_domain = PF_UNIX,
66 .sock_type = SOCK_STREAM,
67 .sock_prot = 0,
68 .sock_family = AF_UNIX,
69 .sock_addrlen = sizeof(struct sockaddr_un),
70 .l3_addrlen = sizeof(((struct sockaddr_un*)0)->sun_path),/* path len */
71 .read = &stream_sock_read,
72 .write = &stream_sock_write,
73 .bind_all = uxst_bind_listeners,
74 .unbind_all = uxst_unbind_listeners,
75 .enable_all = enable_all_listeners,
76 .disable_all = disable_all_listeners,
77 .listeners = LIST_HEAD_INIT(proto_unix.listeners),
78 .nb_listeners = 0,
79};
80
81
82/********************************
83 * 1) low-level socket functions
84 ********************************/
85
86
Willy Tarreau92fb9832007-10-16 17:34:28 +020087/* This function creates a named PF_UNIX stream socket at address <path>. Note
Willy Tarreaue6ad2b12007-10-18 12:45:54 +020088 * that the path cannot be NULL nor empty. <uid> and <gid> different of -1 will
89 * be used to change the socket owner. If <mode> is not 0, it will be used to
90 * restrict access to the socket. While it is known not to be portable on every
91 * OS, it's still useful where it works.
Willy Tarreau92fb9832007-10-16 17:34:28 +020092 * It returns the assigned file descriptor, or -1 in the event of an error.
93 */
Willy Tarreaue6ad2b12007-10-18 12:45:54 +020094static int create_uxst_socket(const char *path, uid_t uid, gid_t gid, mode_t mode)
Willy Tarreau92fb9832007-10-16 17:34:28 +020095{
96 char tempname[MAXPATHLEN];
97 char backname[MAXPATHLEN];
98 struct sockaddr_un addr;
99
100 int ret, sock;
101
102 /* 1. create socket names */
103 if (!path[0]) {
104 Alert("Invalid name for a UNIX socket. Aborting.\n");
105 goto err_return;
106 }
107
108 ret = snprintf(tempname, MAXPATHLEN, "%s.%d.tmp", path, pid);
109 if (ret < 0 || ret >= MAXPATHLEN) {
110 Alert("name too long for UNIX socket. Aborting.\n");
111 goto err_return;
112 }
113
114 ret = snprintf(backname, MAXPATHLEN, "%s.%d.bak", path, pid);
115 if (ret < 0 || ret >= MAXPATHLEN) {
116 Alert("name too long for UNIX socket. Aborting.\n");
117 goto err_return;
118 }
119
120 /* 2. clean existing orphaned entries */
121 if (unlink(tempname) < 0 && errno != ENOENT) {
122 Alert("error when trying to unlink previous UNIX socket. Aborting.\n");
123 goto err_return;
124 }
125
126 if (unlink(backname) < 0 && errno != ENOENT) {
127 Alert("error when trying to unlink previous UNIX socket. Aborting.\n");
128 goto err_return;
129 }
130
131 /* 3. backup existing socket */
132 if (link(path, backname) < 0 && errno != ENOENT) {
133 Alert("error when trying to preserve previous UNIX socket. Aborting.\n");
134 goto err_return;
135 }
136
137 /* 4. prepare new socket */
138 addr.sun_family = AF_UNIX;
139 strncpy(addr.sun_path, tempname, sizeof(addr.sun_path));
140 addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
141
142 sock = socket(PF_UNIX, SOCK_STREAM, 0);
143 if (sock < 0) {
144 Alert("cannot create socket for UNIX listener. Aborting.\n");
145 goto err_unlink_back;
146 }
147
148 if (sock >= global.maxsock) {
149 Alert("socket(): not enough free sockets for UNIX listener. Raise -n argument. Aborting.\n");
150 goto err_unlink_temp;
151 }
152
153 if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
154 Alert("cannot make UNIX socket non-blocking. Aborting.\n");
155 goto err_unlink_temp;
156 }
157
158 if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
159 /* note that bind() creates the socket <tempname> on the file system */
160 Alert("cannot bind socket for UNIX listener. Aborting.\n");
161 goto err_unlink_temp;
162 }
163
Willy Tarreaue6ad2b12007-10-18 12:45:54 +0200164 if (((uid != -1 || gid != -1) && (chown(tempname, uid, gid) == -1)) ||
165 (mode != 0 && chmod(tempname, mode) == -1)) {
166 Alert("cannot change UNIX socket ownership. Aborting.\n");
167 goto err_unlink_temp;
168 }
169
Willy Tarreau92fb9832007-10-16 17:34:28 +0200170 if (listen(sock, 0) < 0) {
171 Alert("cannot listen to socket for UNIX listener. Aborting.\n");
172 goto err_unlink_temp;
173 }
174
175 /* 5. install.
176 * Point of no return: we are ready, we'll switch the sockets. We don't
177 * fear loosing the socket <path> because we have a copy of it in
178 * backname.
179 */
180 if (rename(tempname, path) < 0) {
181 Alert("cannot switch final and temporary sockets for UNIX listener. Aborting.\n");
182 goto err_rename;
183 }
184
185 /* 6. cleanup */
186 unlink(backname); /* no need to keep this one either */
187
188 return sock;
189
190 err_rename:
191 ret = rename(backname, path);
192 if (ret < 0 && errno == ENOENT)
193 unlink(path);
194 err_unlink_temp:
195 unlink(tempname);
196 close(sock);
197 err_unlink_back:
198 unlink(backname);
199 err_return:
200 return -1;
201}
202
203/* Tries to destroy the UNIX stream socket <path>. The socket must not be used
204 * anymore. It practises best effort, and no error is returned.
205 */
206static void destroy_uxst_socket(const char *path)
207{
208 struct sockaddr_un addr;
209 int sock, ret;
210
211 /* We might have been chrooted, so we may not be able to access the
212 * socket. In order to avoid bothering the other end, we connect with a
213 * wrong protocol, namely SOCK_DGRAM. The return code from connect()
214 * is enough to know if the socket is still live or not. If it's live
215 * in mode SOCK_STREAM, we get EPROTOTYPE or anything else but not
216 * ECONNREFUSED. In this case, we do not touch it because it's used
217 * by some other process.
218 */
219 sock = socket(PF_UNIX, SOCK_DGRAM, 0);
220 if (sock < 0)
221 return;
222
223 addr.sun_family = AF_UNIX;
224 strncpy(addr.sun_path, path, sizeof(addr.sun_path));
Willy Tarreau10ae5482007-10-18 16:15:52 +0200225 addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200226 ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
227 if (ret < 0 && errno == ECONNREFUSED) {
228 /* Connect failed: the socket still exists but is not used
229 * anymore. Let's remove this socket now.
230 */
231 unlink(path);
232 }
233 close(sock);
234}
235
236
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100237/********************************
238 * 2) listener-oriented functions
239 ********************************/
240
241
242/* This function creates the UNIX socket associated to the listener. It changes
243 * the state from ASSIGNED to LISTEN. The socket is NOT enabled for polling.
244 * The return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL.
245 */
246static int uxst_bind_listener(struct listener *listener)
247{
248 int fd;
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100249
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100250 if (listener->state != LI_ASSIGNED)
251 return ERR_NONE; /* already bound */
252
253 fd = create_uxst_socket(((struct sockaddr_un *)&listener->addr)->sun_path,
254 listener->perm.ux.uid,
255 listener->perm.ux.gid,
256 listener->perm.ux.mode);
257 if (fd == -1)
258 return ERR_FATAL;
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100259
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100260 /* the socket is now listening */
261 listener->fd = fd;
262 listener->state = LI_LISTEN;
263
264 /* the function for the accept() event */
265 fd_insert(fd);
266 fdtab[fd].cb[DIR_RD].f = listener->accept;
267 fdtab[fd].cb[DIR_WR].f = NULL; /* never called */
268 fdtab[fd].cb[DIR_RD].b = fdtab[fd].cb[DIR_WR].b = NULL;
Willy Tarreaueabf3132008-08-29 23:36:51 +0200269 fdtab[fd].owner = listener; /* reference the listener instead of a task */
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100270 fdtab[fd].state = FD_STLISTEN;
271 fdtab[fd].peeraddr = NULL;
272 fdtab[fd].peerlen = 0;
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100273 return ERR_NONE;
274}
275
276/* This function closes the UNIX sockets for the specified listener.
277 * The listener enters the LI_ASSIGNED state. It always returns ERR_NONE.
278 */
279static int uxst_unbind_listener(struct listener *listener)
280{
281 if (listener->state == LI_READY)
282 EV_FD_CLR(listener->fd, DIR_RD);
283
284 if (listener->state >= LI_LISTEN) {
Willy Tarreau8eebe5e2007-10-28 22:07:08 +0100285 fd_delete(listener->fd);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100286 listener->state = LI_ASSIGNED;
287 destroy_uxst_socket(((struct sockaddr_un *)&listener->addr)->sun_path);
288 }
289 return ERR_NONE;
290}
291
292/* Add a listener to the list of unix stream listeners. The listener's state
293 * is automatically updated from LI_INIT to LI_ASSIGNED. The number of
294 * listeners is updated. This is the function to use to add a new listener.
295 */
296void uxst_add_listener(struct listener *listener)
297{
298 if (listener->state != LI_INIT)
299 return;
300 listener->state = LI_ASSIGNED;
301 listener->proto = &proto_unix;
302 LIST_ADDQ(&proto_unix.listeners, &listener->proto_list);
303 proto_unix.nb_listeners++;
304}
305
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100306/********************************
307 * 3) protocol-oriented functions
308 ********************************/
309
310
Willy Tarreau92fb9832007-10-16 17:34:28 +0200311/* This function creates all UNIX sockets bound to the protocol entry <proto>.
312 * It is intended to be used as the protocol's bind_all() function.
313 * The sockets will be registered but not added to any fd_set, in order not to
314 * loose them across the fork(). A call to uxst_enable_listeners() is needed
315 * to complete initialization.
316 *
317 * The return value is composed from ERR_NONE, ERR_RETRYABLE and ERR_FATAL.
318 */
319static int uxst_bind_listeners(struct protocol *proto)
320{
321 struct listener *listener;
322 int err = ERR_NONE;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200323
324 list_for_each_entry(listener, &proto->listeners, proto_list) {
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100325 err |= uxst_bind_listener(listener);
326 if (err != ERR_NONE)
Willy Tarreau92fb9832007-10-16 17:34:28 +0200327 continue;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200328 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200329 return err;
330}
331
Willy Tarreau92fb9832007-10-16 17:34:28 +0200332
333/* This function stops all listening UNIX sockets bound to the protocol
334 * <proto>. It does not detaches them from the protocol.
335 * It always returns ERR_NONE.
336 */
337static int uxst_unbind_listeners(struct protocol *proto)
338{
339 struct listener *listener;
340
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100341 list_for_each_entry(listener, &proto->listeners, proto_list)
342 uxst_unbind_listener(listener);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200343 return ERR_NONE;
344}
345
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100346
347/********************************
348 * 4) high-level functions
349 ********************************/
350
351
Willy Tarreau92fb9832007-10-16 17:34:28 +0200352/*
353 * This function is called on a read event from a listen socket, corresponding
354 * to an accept. It tries to accept as many connections as possible.
355 * It returns 0. Since we use UNIX sockets on the local system for monitoring
356 * purposes and other related things, we do not need to output as many messages
357 * as with TCP which can fall under attack.
358 */
359int uxst_event_accept(int fd) {
Willy Tarreaueabf3132008-08-29 23:36:51 +0200360 struct listener *l = fdtab[fd].owner;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200361 struct session *s;
362 struct task *t;
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100363 struct bref *bref, *back;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200364 int cfd;
365 int max_accept;
366
367 if (global.nbproc > 1)
368 max_accept = 8; /* let other processes catch some connections too */
369 else
370 max_accept = -1;
371
372 while (max_accept--) {
373 struct sockaddr_storage addr;
374 socklen_t laddr = sizeof(addr);
375
376 if ((cfd = accept(fd, (struct sockaddr *)&addr, &laddr)) == -1) {
377 switch (errno) {
378 case EAGAIN:
379 case EINTR:
380 case ECONNABORTED:
381 return 0; /* nothing more to accept */
382 case ENFILE:
383 /* Process reached system FD limit. Check system tunables. */
384 return 0;
385 case EMFILE:
386 /* Process reached process FD limit. Check 'ulimit-n'. */
387 return 0;
388 case ENOBUFS:
389 case ENOMEM:
390 /* Process reached system memory limit. Check system tunables. */
391 return 0;
392 default:
393 return 0;
394 }
395 }
396
397 if (l->nbconn >= l->maxconn) {
398 /* too many connections, we shoot this one and return.
399 * FIXME: it would be better to simply switch the listener's
400 * state to LI_FULL and disable the FD. We could re-enable
401 * it upon fd_delete(), but this requires all protocols to
402 * be switched.
403 */
Willy Tarreaua11e9762008-12-01 01:44:25 +0100404 goto out_close;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200405 }
406
407 if ((s = pool_alloc2(pool2_session)) == NULL) {
408 Alert("out of memory in uxst_event_accept().\n");
Willy Tarreaua11e9762008-12-01 01:44:25 +0100409 goto out_close;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200410 }
411
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100412 LIST_ADDQ(&sessions, &s->list);
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100413 LIST_INIT(&s->back_refs);
Willy Tarreauf54f8bd2008-11-23 19:53:55 +0100414
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100415 s->flags = 0;
Willy Tarreauf8533202008-08-16 14:55:08 +0200416 s->term_trace = 0;
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100417
Willy Tarreau92fb9832007-10-16 17:34:28 +0200418 if ((t = pool_alloc2(pool2_task)) == NULL) {
419 Alert("out of memory in uxst_event_accept().\n");
Willy Tarreaua11e9762008-12-01 01:44:25 +0100420 goto out_free_session;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200421 }
422
423 s->cli_addr = addr;
424
425 /* FIXME: should be checked earlier */
426 if (cfd >= global.maxsock) {
427 Alert("accept(): not enough free sockets. Raise -n argument. Giving up.\n");
Willy Tarreaua11e9762008-12-01 01:44:25 +0100428 goto out_free_task;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200429 }
430
431 if (fcntl(cfd, F_SETFL, O_NONBLOCK) == -1) {
432 Alert("accept(): cannot set the socket in non blocking mode. Giving up\n");
Willy Tarreaua11e9762008-12-01 01:44:25 +0100433 goto out_free_task;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200434 }
435
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200436 task_init(t);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200437 t->process = l->handler;
438 t->context = s;
Willy Tarreau91e99932008-06-30 07:51:00 +0200439 t->nice = -64; /* we want to boost priority for local stats */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200440
441 s->task = t;
Willy Tarreaub5654f62008-12-07 16:45:10 +0100442 s->listener = l;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200443 s->fe = NULL;
444 s->be = NULL;
445
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100446 s->ana_state = 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200447 s->req = s->rep = NULL; /* will be allocated later */
448
Willy Tarreaua11e9762008-12-01 01:44:25 +0100449 s->si[0].state = s->si[0].prev_state = SI_ST_EST;
450 s->si[0].err_type = SI_ET_NONE;
451 s->si[0].err_loc = NULL;
452 s->si[0].owner = t;
453 s->si[0].shutr = stream_sock_shutr;
454 s->si[0].shutw = stream_sock_shutw;
455 s->si[0].fd = cfd;
456 s->si[0].flags = SI_FL_NONE;
457 s->si[0].exp = TICK_ETERNITY;
Willy Tarreaua11e9762008-12-01 01:44:25 +0100458
459 s->si[1].state = s->si[1].prev_state = SI_ST_INI;
460 s->si[1].err_type = SI_ET_NONE;
461 s->si[1].err_loc = NULL;
462 s->si[1].owner = t;
463 s->si[1].shutr = stream_sock_shutr;
464 s->si[1].shutw = stream_sock_shutw;
465 s->si[1].exp = TICK_ETERNITY;
466 s->si[1].fd = -1; /* just to help with debugging */
467 s->si[1].flags = SI_FL_NONE;
468
469 s->srv = s->prev_srv = s->srv_conn = NULL;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200470 s->pend_pos = NULL;
471
472 memset(&s->logs, 0, sizeof(s->logs));
473 memset(&s->txn, 0, sizeof(s->txn));
474
Willy Tarreau3dfe6cd2008-12-07 22:29:48 +0100475 s->logs.tv_accept = now; /* corrected date for internal use */
476
Willy Tarreau3e76e722007-10-17 18:57:38 +0200477 s->data_state = DATA_ST_INIT;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200478 s->data_source = DATA_SRC_NONE;
479 s->uniq_id = totalconn;
480
Willy Tarreaua11e9762008-12-01 01:44:25 +0100481 if ((s->req = pool_alloc2(pool2_buffer)) == NULL)
482 goto out_free_task;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200483
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100484 buffer_init(s->req);
Willy Tarreaua11e9762008-12-01 01:44:25 +0100485 s->req->prod = &s->si[0];
486 s->req->cons = &s->si[1];
487 s->si[0].ib = s->si[1].ob = s->req;
488 s->req->flags |= BF_READ_ATTACHED; /* the producer is already connected */
489
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100490 s->req->analysers = l->analysers;
Willy Tarreaua11e9762008-12-01 01:44:25 +0100491
492 s->req->wto = TICK_ETERNITY;
493 s->req->cto = TICK_ETERNITY;
494 s->req->rto = TICK_ETERNITY;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200495
Willy Tarreaua11e9762008-12-01 01:44:25 +0100496 if ((s->rep = pool_alloc2(pool2_buffer)) == NULL)
497 goto out_free_req;
498
Willy Tarreau92fb9832007-10-16 17:34:28 +0200499 buffer_init(s->rep);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200500
Willy Tarreaua11e9762008-12-01 01:44:25 +0100501 s->rep->prod = &s->si[1];
502 s->rep->cons = &s->si[0];
503 s->si[0].ob = s->si[1].ib = s->rep;
504
505 s->rep->rto = TICK_ETERNITY;
506 s->rep->cto = TICK_ETERNITY;
507 s->rep->wto = TICK_ETERNITY;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200508
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200509 s->req->rex = TICK_ETERNITY;
510 s->req->wex = TICK_ETERNITY;
Willy Tarreauffab5b42008-08-17 18:03:28 +0200511 s->req->analyse_exp = TICK_ETERNITY;
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200512 s->rep->rex = TICK_ETERNITY;
513 s->rep->wex = TICK_ETERNITY;
Willy Tarreauffab5b42008-08-17 18:03:28 +0200514 s->rep->analyse_exp = TICK_ETERNITY;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200515
Willy Tarreaua11e9762008-12-01 01:44:25 +0100516 t->expire = TICK_ETERNITY;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200517
Willy Tarreaua11e9762008-12-01 01:44:25 +0100518 if (l->timeout) {
Willy Tarreau92fb9832007-10-16 17:34:28 +0200519 s->req->rto = *l->timeout;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200520 s->rep->wto = *l->timeout;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200521 }
522
Willy Tarreaua11e9762008-12-01 01:44:25 +0100523 fd_insert(cfd);
524 fdtab[cfd].owner = &s->si[0];
Willy Tarreaua11e9762008-12-01 01:44:25 +0100525 fdtab[cfd].state = FD_STREADY;
526 fdtab[cfd].cb[DIR_RD].f = l->proto->read;
527 fdtab[cfd].cb[DIR_RD].b = s->req;
528 fdtab[cfd].cb[DIR_WR].f = l->proto->write;
529 fdtab[cfd].cb[DIR_WR].b = s->rep;
530 fdtab[cfd].peeraddr = (struct sockaddr *)&s->cli_addr;
531 fdtab[cfd].peerlen = sizeof(s->cli_addr);
532
533 EV_FD_SET(cfd, DIR_RD);
534
Willy Tarreaufdccded2008-08-29 18:19:04 +0200535 task_wakeup(t, TASK_WOKEN_INIT);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200536
537 l->nbconn++; /* warning! right now, it's up to the handler to decrease this */
538 if (l->nbconn >= l->maxconn) {
539 EV_FD_CLR(l->fd, DIR_RD);
540 l->state = LI_FULL;
541 }
542 actconn++;
543 totalconn++;
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100544 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200545 return 0;
Willy Tarreaua11e9762008-12-01 01:44:25 +0100546
547 out_free_req:
548 pool_free2(pool2_buffer, s->req);
549 out_free_task:
550 pool_free2(pool2_task, t);
551 out_free_session:
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100552 list_for_each_entry_safe(bref, back, &s->back_refs, users) {
553 LIST_DEL(&bref->users);
554 LIST_ADDQ(&LIST_ELEM(s->list.n, struct session *, list)->back_refs, &bref->users);
555 bref->ref = s->list.n;
556 }
Willy Tarreaua11e9762008-12-01 01:44:25 +0100557 LIST_DEL(&s->list);
558 pool_free2(pool2_session, s);
559 out_close:
560 close(cfd);
561 return 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200562}
563
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100564/* Parses the request line in <cmd> and possibly starts dumping stats on
565 * s->rep with the hijack bit set. Returns 1 if OK, 0 in case of any error.
566 * The line is modified after parsing.
Willy Tarreau92fb9832007-10-16 17:34:28 +0200567 */
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100568int unix_sock_parse_request(struct session *s, char *line)
Willy Tarreau92fb9832007-10-16 17:34:28 +0200569{
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100570 char *args[MAX_UXST_ARGS + 1];
571 int arg;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200572
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100573 while (isspace((unsigned char)*line))
574 line++;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200575
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100576 arg = 0;
577 args[arg] = line;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200578
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100579 while (*line && arg < MAX_UXST_ARGS) {
580 if (isspace((unsigned char)*line)) {
581 *line++ = '\0';
Willy Tarreau92fb9832007-10-16 17:34:28 +0200582
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100583 while (isspace((unsigned char)*line))
584 line++;
585
586 args[++arg] = line;
587 continue;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200588 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100589
590 line++;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200591 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200592
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100593 while (++arg <= MAX_UXST_ARGS)
594 args[arg] = line;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200595
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100596 if (strcmp(args[0], "show") == 0) {
597 if (strcmp(args[1], "stat") == 0) {
598 if (*args[2] && *args[3] && *args[4]) {
599 s->data_ctx.stats.flags |= STAT_BOUND;
600 s->data_ctx.stats.iid = atoi(args[2]);
601 s->data_ctx.stats.type = atoi(args[3]);
602 s->data_ctx.stats.sid = atoi(args[4]);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200603 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100604
605 s->data_ctx.stats.flags |= STAT_SHOW_STAT;
606 s->data_ctx.stats.flags |= STAT_FMT_CSV;
607 s->ana_state = STATS_ST_REP;
Willy Tarreau01bf8672008-12-07 18:03:29 +0100608 buffer_install_hijacker(s, s->rep, stats_dump_raw_to_buffer);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200609 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100610 else if (strcmp(args[1], "info") == 0) {
611 s->data_ctx.stats.flags |= STAT_SHOW_INFO;
612 s->data_ctx.stats.flags |= STAT_FMT_CSV;
613 s->ana_state = STATS_ST_REP;
Willy Tarreau01bf8672008-12-07 18:03:29 +0100614 buffer_install_hijacker(s, s->rep, stats_dump_raw_to_buffer);
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100615 }
Willy Tarreau3dfe6cd2008-12-07 22:29:48 +0100616 else if (strcmp(args[1], "sess") == 0) {
617 s->ana_state = STATS_ST_REP;
618 buffer_install_hijacker(s, s->rep, stats_dump_sess_to_buffer);
619 }
620 else { /* neither "stat" nor "info" nor "sess" */
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100621 return 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200622 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100623 }
624 else { /* not "show" */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200625 return 0;
626 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100627 return 1;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200628}
629
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100630/* Processes the stats interpreter on the statistics socket.
631 * In order to ease the transition, we simply simulate the server status
632 * for now. It only knows states STATS_ST_INIT, STATS_ST_REQ, STATS_ST_REP, and
633 * STATS_ST_CLOSE. It removes the AN_REQ_UNIX_STATS bit from req->analysers
634 * once done. It always returns 0.
Willy Tarreau92fb9832007-10-16 17:34:28 +0200635 */
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100636int uxst_req_analyser_stats(struct session *s, struct buffer *req)
Willy Tarreau92fb9832007-10-16 17:34:28 +0200637{
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100638 char *line, *p;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200639
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100640 switch (s->ana_state) {
641 case STATS_ST_INIT:
642 /* Stats output not initialized yet */
643 memset(&s->data_ctx.stats, 0, sizeof(s->data_ctx.stats));
644 s->data_source = DATA_SRC_STATS;
645 s->ana_state = STATS_ST_REQ;
646 /* fall through */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200647
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100648 case STATS_ST_REQ:
649 /* Now, stats are initialized, hijack is not set, and
650 * we are waiting for a complete request line.
651 */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200652
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100653 line = s->req->data;
654 p = memchr(line, '\n', s->req->l);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200655
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100656 if (p) {
657 *p = '\0';
658 if (!unix_sock_parse_request(s, line)) {
659 /* invalid request */
660 buffer_shutw_now(s->req);
661 s->ana_state = 0;
662 req->analysers = 0;
663 return 0;
664 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200665 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200666
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100667 /* processing a valid or incomplete request */
668 if ((req->flags & BF_FULL) || /* invalid request */
669 (req->flags & BF_READ_ERROR) || /* input error */
670 (req->flags & BF_READ_TIMEOUT) || /* read timeout */
671 tick_is_expired(req->analyse_exp, now_ms) || /* request timeout */
672 (req->flags & BF_SHUTR)) { /* input closed */
673 buffer_shutw_now(s->req);
674 s->ana_state = 0;
675 req->analysers = 0;
676 return 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200677 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200678
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100679 /* don't forward nor abort */
680 buffer_write_dis(req);
681 return 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200682
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100683 case STATS_ST_REP:
684 /* do nothing while response is being processed */
685 buffer_write_dis(s->req);
686 return 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200687
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100688 case STATS_ST_CLOSE:
689 /* end of dump */
690 s->req->analysers &= ~AN_REQ_UNIX_STATS;
691 s->ana_state = 0;
692 break;
693 }
694 return 0;
695}
Willy Tarreau92fb9832007-10-16 17:34:28 +0200696
Willy Tarreau92fb9832007-10-16 17:34:28 +0200697
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100698/* This function is the unix-stream equivalent of the global process_session().
699 * It is currently limited to unix-stream processing on control sockets such as
700 * stats, and has no server-side. The two functions should be merged into one
701 * once client and server sides are better delimited. Note that the server-side
702 * still exists but remains in SI_ST_INI state forever, so that any call is a
703 * NOP.
704 */
705void uxst_process_session(struct task *t, int *next)
706{
707 struct session *s = t->context;
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100708 int resync;
709 unsigned int rqf_last, rpf_last;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200710
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100711 /* 1a: Check for low level timeouts if needed. We just set a flag on
712 * stream interfaces when their timeouts have expired.
713 */
714 if (unlikely(t->state & TASK_WOKEN_TIMER)) {
715 stream_int_check_timeouts(&s->si[0]);
716 buffer_check_timeouts(s->req);
717 buffer_check_timeouts(s->rep);
718 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200719
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100720 /* copy req/rep flags so that we can detect shutdowns */
721 rqf_last = s->req->flags;
722 rpf_last = s->rep->flags;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200723
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100724 /* 1b: check for low-level errors reported at the stream interface. */
725 if (unlikely(s->si[0].flags & SI_FL_ERR)) {
726 if (s->si[0].state == SI_ST_EST || s->si[0].state == SI_ST_DIS) {
727 s->si[0].shutr(&s->si[0]);
728 s->si[0].shutw(&s->si[0]);
729 stream_int_report_error(&s->si[0]);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200730 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100731 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200732
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100733 /* check buffer timeouts, and close the corresponding stream interfaces
734 * for future reads or writes. Note: this will also concern upper layers
735 * but we do not touch any other flag. We must be careful and correctly
736 * detect state changes when calling them.
737 */
738 if (unlikely(s->req->flags & (BF_READ_TIMEOUT|BF_WRITE_TIMEOUT))) {
739 if (s->req->flags & BF_READ_TIMEOUT)
740 s->req->prod->shutr(s->req->prod);
741 if (s->req->flags & BF_WRITE_TIMEOUT)
742 s->req->cons->shutw(s->req->cons);
743 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200744
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100745 if (unlikely(s->rep->flags & (BF_READ_TIMEOUT|BF_WRITE_TIMEOUT))) {
746 if (s->rep->flags & BF_READ_TIMEOUT)
747 s->rep->prod->shutr(s->rep->prod);
748 if (s->rep->flags & BF_WRITE_TIMEOUT)
749 s->rep->cons->shutw(s->rep->cons);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200750 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200751
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100752 /* Check for connection closure */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200753
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100754 resync_stream_interface:
Willy Tarreau92fb9832007-10-16 17:34:28 +0200755
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100756 /* nothing special to be done on client side */
757 if (unlikely(s->req->prod->state == SI_ST_DIS))
758 s->req->prod->state = SI_ST_CLO;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200759
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100760 /*
761 * Note: of the transient states (REQ, CER, DIS), only REQ may remain
762 * at this point.
763 */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200764
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100765 /**** Process layer 7 below ****/
Willy Tarreau92fb9832007-10-16 17:34:28 +0200766
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100767 resync = 0;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200768
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100769 /* Analyse request */
770 if ((s->req->flags & BF_MASK_ANALYSER) ||
771 (s->req->flags ^ rqf_last) & BF_MASK_STATIC) {
772 unsigned int flags = s->req->flags;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200773
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100774 if (s->req->prod->state >= SI_ST_EST) {
775 /* it's up to the analysers to reset write_ena */
776 buffer_write_ena(s->req);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200777
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100778 /* We will call all analysers for which a bit is set in
779 * s->req->analysers, following the bit order from LSB
780 * to MSB. The analysers must remove themselves from
781 * the list when not needed. This while() loop is in
782 * fact a cleaner if().
Willy Tarreau92fb9832007-10-16 17:34:28 +0200783 */
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100784 while (s->req->analysers) {
785 if (s->req->analysers & AN_REQ_UNIX_STATS)
786 if (!uxst_req_analyser_stats(s, s->req))
787 break;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200788
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100789 /* Just make sure that nobody set a wrong flag causing an endless loop */
790 s->req->analysers &= AN_REQ_UNIX_STATS;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200791
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100792 /* we don't want to loop anyway */
793 break;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200794 }
795 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100796 s->req->flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
797 flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
798 if (s->req->flags != flags)
799 resync = 1;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200800 }
Willy Tarreau92fb9832007-10-16 17:34:28 +0200801
Willy Tarreauf890dc92008-12-13 21:12:26 +0100802 /* if noone is interested in analysing data, let's forward everything */
803 if (!s->req->analysers && !(s->req->flags & BF_HIJACK))
804 s->req->send_max = s->req->l;
805
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100806 /* reflect what the L7 analysers have seen last */
807 rqf_last = s->req->flags;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200808
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100809 /*
810 * Now forward all shutdown requests between both sides of the buffer
811 */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200812
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100813 /* first, let's check if the request buffer needs to shutdown(write) */
814 if (unlikely((s->req->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
815 (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)))
816 buffer_shutw_now(s->req);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200817
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100818 /* shutdown(write) pending */
819 if (unlikely((s->req->flags & (BF_SHUTW|BF_SHUTW_NOW)) == BF_SHUTW_NOW))
820 s->req->cons->shutw(s->req->cons);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200821
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100822 /* shutdown(write) done on server side, we must stop the client too */
823 if (unlikely((s->req->flags & (BF_SHUTW|BF_SHUTR|BF_SHUTR_NOW)) == BF_SHUTW &&
824 !s->req->analysers))
825 buffer_shutr_now(s->req);
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100826
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100827 /* shutdown(read) pending */
828 if (unlikely((s->req->flags & (BF_SHUTR|BF_SHUTR_NOW)) == BF_SHUTR_NOW))
829 s->req->prod->shutr(s->req->prod);
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100830
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100831 /*
832 * Here we want to check if we need to resync or not.
833 */
834 if ((s->req->flags ^ rqf_last) & BF_MASK_STATIC)
835 resync = 1;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200836
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100837 s->req->flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200838
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100839 /* according to benchmarks, it makes sense to resync now */
840 if (resync)
841 goto resync_stream_interface;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200842
Willy Tarreau92fb9832007-10-16 17:34:28 +0200843
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100844 /* Analyse response */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200845
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100846 buffer_write_ena(s->rep);
847 if (unlikely(s->rep->flags & BF_HIJACK)) {
848 /* In inject mode, we wake up everytime something has
849 * happened on the write side of the buffer.
850 */
851 unsigned int flags = s->rep->flags;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200852
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100853 if ((s->rep->flags & (BF_WRITE_PARTIAL|BF_WRITE_ERROR|BF_SHUTW)) &&
854 !(s->rep->flags & BF_FULL)) {
Willy Tarreau01bf8672008-12-07 18:03:29 +0100855 s->rep->hijacker(s, s->rep);
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100856 }
857 s->rep->flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
858 flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
859 if (s->rep->flags != flags)
860 resync = 1;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200861 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100862 else if ((s->rep->flags & BF_MASK_ANALYSER) ||
863 (s->rep->flags ^ rpf_last) & BF_MASK_STATIC) {
864 unsigned int flags = s->rep->flags;
Willy Tarreau3e76e722007-10-17 18:57:38 +0200865
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100866 if (s->rep->prod->state >= SI_ST_EST) {
867 /* it's up to the analysers to reset write_ena */
868 buffer_write_ena(s->rep);
Willy Tarreau3e76e722007-10-17 18:57:38 +0200869 }
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100870 s->rep->flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
871 flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
872 if (s->rep->flags != flags)
873 resync = 1;
874 }
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100875
Willy Tarreauf890dc92008-12-13 21:12:26 +0100876 /* if noone is interested in analysing data, let's forward everything */
877 if (!s->rep->analysers && !(s->rep->flags & BF_HIJACK))
878 s->rep->send_max = s->rep->l;
879
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100880 /* reflect what the L7 analysers have seen last */
881 rpf_last = s->rep->flags;
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100882
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100883 /*
884 * Now forward all shutdown requests between both sides of the buffer
885 */
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100886
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100887 /*
888 * FIXME: this is probably where we should produce error responses.
889 */
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100890
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100891 /* first, let's check if the request buffer needs to shutdown(write) */
892 if (unlikely((s->rep->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) ==
893 (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)))
894 buffer_shutw_now(s->rep);
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100895
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100896 /* shutdown(write) pending */
897 if (unlikely((s->rep->flags & (BF_SHUTW|BF_SHUTW_NOW)) == BF_SHUTW_NOW))
898 s->rep->cons->shutw(s->rep->cons);
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100899
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100900 /* shutdown(write) done on the client side, we must stop the server too */
901 if (unlikely((s->rep->flags & (BF_SHUTW|BF_SHUTR|BF_SHUTR_NOW)) == BF_SHUTW))
902 buffer_shutr_now(s->rep);
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100903
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100904 /* shutdown(read) pending */
905 if (unlikely((s->rep->flags & (BF_SHUTR|BF_SHUTR_NOW)) == BF_SHUTR_NOW))
906 s->rep->prod->shutr(s->rep->prod);
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100907
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100908 /*
909 * Here we want to check if we need to resync or not.
910 */
911 if ((s->rep->flags ^ rpf_last) & BF_MASK_STATIC)
912 resync = 1;
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100913
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100914 s->rep->flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100915
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100916 if (resync)
917 goto resync_stream_interface;
Krzysztof Piotr Oledzki2c6962c2008-03-02 02:42:14 +0100918
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100919 if (likely(s->rep->cons->state != SI_ST_CLO)) {
920 if (s->rep->cons->state == SI_ST_EST)
921 stream_sock_data_finish(s->rep->cons);
Willy Tarreau3e76e722007-10-17 18:57:38 +0200922
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100923 s->req->flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
924 s->rep->flags &= BF_CLEAR_READ & BF_CLEAR_WRITE & BF_CLEAR_TIMEOUT;
925 s->si[0].prev_state = s->si[0].state;
926 s->si[0].flags = SI_FL_NONE;
Willy Tarreau3e76e722007-10-17 18:57:38 +0200927
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100928 /* Trick: if a request is being waiting for the server to respond,
929 * and if we know the server can timeout, we don't want the timeout
930 * to expire on the client side first, but we're still interested
931 * in passing data from the client to the server (eg: POST). Thus,
932 * we can cancel the client's request timeout if the server's
933 * request timeout is set and the server has not yet sent a response.
934 */
Willy Tarreau92fb9832007-10-16 17:34:28 +0200935
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100936 if ((s->rep->flags & (BF_WRITE_ENA|BF_SHUTR)) == 0 &&
937 (tick_isset(s->req->wex) || tick_isset(s->rep->rex)))
938 s->req->rex = TICK_ETERNITY;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200939
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200940 t->expire = tick_first(tick_first(s->req->rex, s->req->wex),
941 tick_first(s->rep->rex, s->rep->wex));
Willy Tarreaub1356cf2008-12-07 16:06:43 +0100942 if (s->req->analysers)
943 t->expire = tick_first(t->expire, s->req->analyse_exp);
944
945 if (s->si[0].exp)
946 t->expire = tick_first(t->expire, s->si[0].exp);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200947
948 /* restore t to its place in the task list */
949 task_queue(t);
950
951 *next = t->expire;
952 return; /* nothing more to do */
953 }
954
955 actconn--;
Willy Tarreaub5654f62008-12-07 16:45:10 +0100956 if (s->listener) {
957 s->listener->nbconn--;
958 if (s->listener->state == LI_FULL &&
959 s->listener->nbconn < s->listener->maxconn) {
Willy Tarreau92fb9832007-10-16 17:34:28 +0200960 /* we should reactivate the listener */
Willy Tarreaub5654f62008-12-07 16:45:10 +0100961 EV_FD_SET(s->listener->fd, DIR_RD);
962 s->listener->state = LI_READY;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200963 }
964 }
965
966 /* the task MUST not be in the run queue anymore */
967 task_delete(t);
968 session_free(s);
969 task_free(t);
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200970 *next = TICK_ETERNITY;
Willy Tarreau92fb9832007-10-16 17:34:28 +0200971}
972
Willy Tarreau92fb9832007-10-16 17:34:28 +0200973__attribute__((constructor))
974static void __uxst_protocol_init(void)
975{
976 protocol_register(&proto_unix);
Willy Tarreau92fb9832007-10-16 17:34:28 +0200977}
978
979
980/*
981 * Local variables:
982 * c-indent-level: 8
983 * c-basic-offset: 8
984 * End:
985 */