[BIGMOVE] exploded the monolithic haproxy.c file into multiple files.
The files are now stored under :
- include/haproxy for the generic includes
- include/types.h for the structures needed within prototypes
- include/proto.h for function prototypes and inline functions
- src/*.c for the C files
Most include files are now covered by LGPL. A last move still needs
to be done to put inline functions under GPL and not LGPL.
Version has been set to 1.3.0 in the code but some control still
needs to be done before releasing.
diff --git a/src/appsession.c b/src/appsession.c
new file mode 100644
index 0000000..da7315a
--- /dev/null
+++ b/src/appsession.c
@@ -0,0 +1,222 @@
+/*
+ * AppSession functions.
+ *
+ * Copyright 2004-2006 Alexander Lazic, Klaus Wagner
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <stdio.h>
+
+#include <haproxy/appsession.h>
+#include <haproxy/chtbl.h>
+#include <haproxy/list.h>
+#include <haproxy/time.h>
+
+#include <types/buffers.h>
+#include <types/global.h>
+#include <types/proxy.h>
+#include <types/server.h>
+
+#include <proto/task.h>
+
+
+void **pool_appsess = NULL;
+struct app_pool apools;
+int have_appsession;
+
+#if defined(DEBUG_HASH)
+void print_table(const CHTbl *htbl)
+{
+ ListElmt *element;
+ int i;
+ appsess *asession;
+
+ /*********************************************************************
+ * *
+ * Display the chained hash table. *
+ * *
+ *********************************************************************/
+
+ fprintf(stdout, "Table size is %d\n", chtbl_size(htbl));
+
+ for (i = 0; i < TBLSIZ; i++) {
+ fprintf(stdout, "Bucket[%03d]\n", i);
+
+ for (element = list_head(&htbl->table[i]);
+ element != NULL; element = list_next(element)) {
+ //fprintf(stdout, "%c", *(char *)list_data(element));
+ asession = (appsess *)list_data(element);
+ fprintf(stdout, "ELEM :%s:", asession->sessid);
+ fprintf(stdout, " Server :%s: \n", asession->serverid);
+ //fprintf(stdout, " Server request_count :%li:\n",asession->request_count);
+ }
+
+ fprintf(stdout, "\n");
+ }
+ return;
+} /* end print_table */
+#endif
+
+int appsession_init(void)
+{
+ static int initialized = 0;
+ int idlen;
+ struct server *s;
+ struct proxy *p = proxy;
+
+ if (!initialized) {
+ if (!appsession_task_init()) {
+ apools.sessid = NULL;
+ apools.serverid = NULL;
+ apools.ser_waste = 0;
+ apools.ser_use = 0;
+ apools.ser_msize = sizeof(void *);
+ apools.ses_waste = 0;
+ apools.ses_use = 0;
+ apools.ses_msize = sizeof(void *);
+ while (p) {
+ s = p->srv;
+ if (apools.ses_msize < p->appsession_len)
+ apools.ses_msize = p->appsession_len;
+ while (s) {
+ idlen = strlen(s->id);
+ if (apools.ser_msize < idlen)
+ apools.ser_msize = idlen;
+ s = s->next;
+ }
+ p = p->next;
+ }
+ /* we use strings, so reserve space for '\0' */
+ apools.ser_msize ++;
+ apools.ses_msize ++;
+ }
+ else {
+ fprintf(stderr, "appsession_task_init failed\n");
+ return -1;
+ }
+ initialized ++;
+ }
+ return 0;
+}
+
+int appsession_task_init(void)
+{
+ static int initialized = 0;
+ struct task *t;
+ if (!initialized) {
+ if ((t = pool_alloc(task)) == NULL)
+ return -1;
+ t->next = t->prev = t->rqnext = NULL;
+ t->wq = LIST_HEAD(wait_queue[0]);
+ t->state = TASK_IDLE;
+ t->context = NULL;
+ tv_delayfrom(&t->expire, &now, TBLCHKINT);
+ task_queue(t);
+ t->process = appsession_refresh;
+ initialized ++;
+ }
+ return 0;
+}
+
+int appsession_refresh(struct task *t)
+{
+ struct proxy *p = proxy;
+ CHTbl *htbl;
+ ListElmt *element, *last;
+ int i;
+ appsess *asession;
+ void *data;
+
+ while (p) {
+ if (p->appsession_name != NULL) {
+ htbl = &p->htbl_proxy;
+ /* if we ever give up the use of TBLSIZ, we need to change this */
+ for (i = 0; i < TBLSIZ; i++) {
+ last = NULL;
+ for (element = list_head(&htbl->table[i]);
+ element != NULL; element = list_next(element)) {
+ asession = (appsess *)list_data(element);
+ if (tv_cmp2_ms(&asession->expire, &now) <= 0) {
+ if ((global.mode & MODE_DEBUG) &&
+ (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
+ int len;
+ /*
+ on Linux NULL pointers are catched by sprintf, on solaris -> segfault
+ */
+ len = sprintf(trash, "appsession_refresh: cleaning up expired Session '%s' on Server %s\n",
+ asession->sessid, asession->serverid?asession->serverid:"(null)");
+ write(1, trash, len);
+ }
+ /* delete the expired element from within the hash table */
+ if ((list_rem_next(&htbl->table[i], last, (void **)&data) == 0)
+ && (htbl->table[i].destroy != NULL)) {
+ htbl->table[i].destroy(data);
+ }
+ if (last == NULL) {/* patient lost his head, get a new one */
+ element = list_head(&htbl->table[i]);
+ if (element == NULL) break; /* no heads left, go to next patient */
+ }
+ else
+ element = last;
+ }/* end if (tv_cmp2_ms(&asession->expire, &now) <= 0) */
+ else
+ last = element;
+ }/* end for (element = list_head(&htbl->table[i]); element != NULL; element = list_next(element)) */
+ }
+ }
+ p = p->next;
+ }
+ tv_delayfrom(&t->expire, &now, TBLCHKINT); /* check expiration every 5 seconds */
+ return TBLCHKINT;
+} /* end appsession_refresh */
+
+int match_str(const void *key1, const void *key2)
+{
+ appsess *temp1,*temp2;
+ temp1 = (appsess *)key1;
+ temp2 = (appsess *)key2;
+
+ //fprintf(stdout,">>>>>>>>>>>>>>temp1->sessid :%s:\n",temp1->sessid);
+ //fprintf(stdout,">>>>>>>>>>>>>>temp2->sessid :%s:\n",temp2->sessid);
+
+ return (strcmp(temp1->sessid,temp2->sessid) == 0);
+}/* end match_str */
+
+void destroy(void *data) {
+ appsess *temp1;
+
+ //printf("destroy called\n");
+ temp1 = (appsess *)data;
+
+ if (temp1->sessid)
+ pool_free_to(apools.sessid, temp1->sessid);
+
+ if (temp1->serverid)
+ pool_free_to(apools.serverid, temp1->serverid);
+
+ pool_free(appsess, temp1);
+} /* end destroy */
+
+void appsession_cleanup( void )
+{
+ struct proxy *p = proxy;
+
+ while(p) {
+ chtbl_destroy(&(p->htbl_proxy));
+ p = p->next;
+ }
+}/* end appsession_cleanup() */
+
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/backend.c b/src/backend.c
new file mode 100644
index 0000000..ec99790
--- /dev/null
+++ b/src/backend.c
@@ -0,0 +1,618 @@
+/*
+ * Backend variables and functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <syslog.h>
+
+#include <haproxy/compat.h>
+#include <haproxy/time.h>
+
+#include <types/buffers.h>
+#include <types/global.h>
+#include <types/polling.h>
+#include <types/proxy.h>
+#include <types/server.h>
+#include <types/session.h>
+
+#include <proto/backend.h>
+#include <proto/fd.h>
+#include <proto/log.h>
+#include <proto/proto_http.h>
+#include <proto/queue.h>
+#include <proto/stream_sock.h>
+#include <proto/task.h>
+
+
+/*
+ * This function recounts the number of usable active and backup servers for
+ * proxy <p>. These numbers are returned into the p->srv_act and p->srv_bck.
+ * This function also recomputes the total active and backup weights.
+ */
+void recount_servers(struct proxy *px)
+{
+ struct server *srv;
+
+ px->srv_act = 0; px->srv_bck = px->tot_wact = px->tot_wbck = 0;
+ for (srv = px->srv; srv != NULL; srv = srv->next) {
+ if (srv->state & SRV_RUNNING) {
+ if (srv->state & SRV_BACKUP) {
+ px->srv_bck++;
+ px->tot_wbck += srv->eweight + 1;
+ } else {
+ px->srv_act++;
+ px->tot_wact += srv->eweight + 1;
+ }
+ }
+ }
+}
+
+/* This function recomputes the server map for proxy px. It
+ * relies on px->tot_wact and px->tot_wbck, so it must be
+ * called after recount_servers(). It also expects px->srv_map
+ * to be initialized to the largest value needed.
+ */
+void recalc_server_map(struct proxy *px)
+{
+ int o, tot, flag;
+ struct server *cur, *best;
+
+ if (px->srv_act) {
+ flag = SRV_RUNNING;
+ tot = px->tot_wact;
+ } else if (px->srv_bck) {
+ flag = SRV_RUNNING | SRV_BACKUP;
+ if (px->options & PR_O_USE_ALL_BK)
+ tot = px->tot_wbck;
+ else
+ tot = 1; /* the first server is enough */
+ } else {
+ px->srv_map_sz = 0;
+ return;
+ }
+
+ /* this algorithm gives priority to the first server, which means that
+ * it will respect the declaration order for equivalent weights, and
+ * that whatever the weights, the first server called will always be
+ * the first declard. This is an important asumption for the backup
+ * case, where we want the first server only.
+ */
+ for (cur = px->srv; cur; cur = cur->next)
+ cur->wscore = 0;
+
+ for (o = 0; o < tot; o++) {
+ int max = 0;
+ best = NULL;
+ for (cur = px->srv; cur; cur = cur->next) {
+ if ((cur->state & (SRV_RUNNING | SRV_BACKUP)) == flag) {
+ int v;
+
+ /* If we are forced to return only one server, we don't want to
+ * go further, because we would return the wrong one due to
+ * divide overflow.
+ */
+ if (tot == 1) {
+ best = cur;
+ break;
+ }
+
+ cur->wscore += cur->eweight + 1;
+ v = (cur->wscore + tot) / tot; /* result between 0 and 3 */
+ if (best == NULL || v > max) {
+ max = v;
+ best = cur;
+ }
+ }
+ }
+ px->srv_map[o] = best;
+ best->wscore -= tot;
+ }
+ px->srv_map_sz = tot;
+}
+
+
+/*
+ * This function marks the session as 'assigned' in direct or dispatch modes,
+ * or tries to assign one in balance mode, according to the algorithm. It does
+ * nothing if the session had already been assigned a server.
+ *
+ * It may return :
+ * SRV_STATUS_OK if everything is OK. s->srv will be valid.
+ * SRV_STATUS_NOSRV if no server is available. s->srv = NULL.
+ * SRV_STATUS_FULL if all servers are saturated. s->srv = NULL.
+ * SRV_STATUS_INTERNAL for other unrecoverable errors.
+ *
+ * Upon successful return, the session flag SN_ASSIGNED to indicate that it does
+ * not need to be called anymore. This usually means that s->srv can be trusted
+ * in balance and direct modes. This flag is not cleared, so it's to the caller
+ * to clear it if required (eg: redispatch).
+ *
+ */
+
+int assign_server(struct session *s)
+{
+#ifdef DEBUG_FULL
+ fprintf(stderr,"assign_server : s=%p\n",s);
+#endif
+
+ if (s->pend_pos)
+ return SRV_STATUS_INTERNAL;
+
+ if (!(s->flags & SN_ASSIGNED)) {
+ if ((s->proxy->options & PR_O_BALANCE) && !(s->flags & SN_DIRECT)) {
+ if (!s->proxy->srv_act && !s->proxy->srv_bck)
+ return SRV_STATUS_NOSRV;
+
+ if (s->proxy->options & PR_O_BALANCE_RR) {
+ s->srv = get_server_rr_with_conns(s->proxy);
+ if (!s->srv)
+ return SRV_STATUS_FULL;
+ }
+ else if (s->proxy->options & PR_O_BALANCE_SH) {
+ int len;
+
+ if (s->cli_addr.ss_family == AF_INET)
+ len = 4;
+ else if (s->cli_addr.ss_family == AF_INET6)
+ len = 16;
+ else /* unknown IP family */
+ return SRV_STATUS_INTERNAL;
+
+ s->srv = get_server_sh(s->proxy,
+ (void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
+ len);
+ }
+ else /* unknown balancing algorithm */
+ return SRV_STATUS_INTERNAL;
+ }
+ s->flags |= SN_ASSIGNED;
+ }
+ return SRV_STATUS_OK;
+}
+
+
+/*
+ * This function assigns a server address to a session, and sets SN_ADDR_SET.
+ * The address is taken from the currently assigned server, or from the
+ * dispatch or transparent address.
+ *
+ * It may return :
+ * SRV_STATUS_OK if everything is OK.
+ * SRV_STATUS_INTERNAL for other unrecoverable errors.
+ *
+ * Upon successful return, the session flag SN_ADDR_SET is set. This flag is
+ * not cleared, so it's to the caller to clear it if required.
+ *
+ */
+int assign_server_address(struct session *s)
+{
+#ifdef DEBUG_FULL
+ fprintf(stderr,"assign_server_address : s=%p\n",s);
+#endif
+
+ if (s->flags & SN_DIRECT || s->proxy->options & PR_O_BALANCE) {
+ /* A server is necessarily known for this session */
+ if (!(s->flags & SN_ASSIGNED))
+ return SRV_STATUS_INTERNAL;
+
+ s->srv_addr = s->srv->addr;
+
+ /* if this server remaps proxied ports, we'll use
+ * the port the client connected to with an offset. */
+ if (s->srv->state & SRV_MAPPORTS) {
+ struct sockaddr_in sockname;
+ socklen_t namelen = sizeof(sockname);
+
+ if (!(s->proxy->options & PR_O_TRANSP) ||
+ get_original_dst(s->cli_fd, (struct sockaddr_in *)&sockname, &namelen) == -1)
+ getsockname(s->cli_fd, (struct sockaddr *)&sockname, &namelen);
+ s->srv_addr.sin_port = htons(ntohs(s->srv_addr.sin_port) + ntohs(sockname.sin_port));
+ }
+ }
+ else if (*(int *)&s->proxy->dispatch_addr.sin_addr) {
+ /* connect to the defined dispatch addr */
+ s->srv_addr = s->proxy->dispatch_addr;
+ }
+ else if (s->proxy->options & PR_O_TRANSP) {
+ /* in transparent mode, use the original dest addr if no dispatch specified */
+ socklen_t salen = sizeof(s->srv_addr);
+
+ if (get_original_dst(s->cli_fd, &s->srv_addr, &salen) == -1) {
+ qfprintf(stderr, "Cannot get original server address.\n");
+ return SRV_STATUS_INTERNAL;
+ }
+ }
+
+ s->flags |= SN_ADDR_SET;
+ return SRV_STATUS_OK;
+}
+
+
+/* This function assigns a server to session <s> if required, and can add the
+ * connection to either the assigned server's queue or to the proxy's queue.
+ *
+ * Returns :
+ *
+ * SRV_STATUS_OK if everything is OK.
+ * SRV_STATUS_NOSRV if no server is available. s->srv = NULL.
+ * SRV_STATUS_QUEUED if the connection has been queued.
+ * SRV_STATUS_FULL if the server(s) is/are saturated and the
+ * connection could not be queued.
+ * SRV_STATUS_INTERNAL for other unrecoverable errors.
+ *
+ */
+int assign_server_and_queue(struct session *s)
+{
+ struct pendconn *p;
+ int err;
+
+ if (s->pend_pos)
+ return SRV_STATUS_INTERNAL;
+
+ if (s->flags & SN_ASSIGNED) {
+ /* a server does not need to be assigned, perhaps because we're in
+ * direct mode, or in dispatch or transparent modes where the server
+ * is not needed.
+ */
+ if (s->srv &&
+ s->srv->maxconn && s->srv->cur_sess >= srv_dynamic_maxconn(s->srv)) {
+ p = pendconn_add(s);
+ if (p)
+ return SRV_STATUS_QUEUED;
+ else
+ return SRV_STATUS_FULL;
+ }
+ return SRV_STATUS_OK;
+ }
+
+ /* a server needs to be assigned */
+ err = assign_server(s);
+ switch (err) {
+ case SRV_STATUS_OK:
+ /* in balance mode, we might have servers with connection limits */
+ if (s->srv &&
+ s->srv->maxconn && s->srv->cur_sess >= srv_dynamic_maxconn(s->srv)) {
+ p = pendconn_add(s);
+ if (p)
+ return SRV_STATUS_QUEUED;
+ else
+ return SRV_STATUS_FULL;
+ }
+ return SRV_STATUS_OK;
+
+ case SRV_STATUS_FULL:
+ /* queue this session into the proxy's queue */
+ p = pendconn_add(s);
+ if (p)
+ return SRV_STATUS_QUEUED;
+ else
+ return SRV_STATUS_FULL;
+
+ case SRV_STATUS_NOSRV:
+ case SRV_STATUS_INTERNAL:
+ return err;
+ default:
+ return SRV_STATUS_INTERNAL;
+ }
+}
+
+
+/*
+ * This function initiates a connection to the server assigned to this session
+ * (s->srv, s->srv_addr). It will assign a server if none is assigned yet.
+ * It can return one of :
+ * - SN_ERR_NONE if everything's OK
+ * - SN_ERR_SRVTO if there are no more servers
+ * - SN_ERR_SRVCL if the connection was refused by the server
+ * - SN_ERR_PRXCOND if the connection has been limited by the proxy (maxconn)
+ * - SN_ERR_RESOURCE if a system resource is lacking (eg: fd limits, ports, ...)
+ * - SN_ERR_INTERNAL for any other purely internal errors
+ * Additionnally, in the case of SN_ERR_RESOURCE, an emergency log will be emitted.
+ */
+int connect_server(struct session *s)
+{
+ int fd, err;
+
+ if (!(s->flags & SN_ADDR_SET)) {
+ err = assign_server_address(s);
+ if (err != SRV_STATUS_OK)
+ return SN_ERR_INTERNAL;
+ }
+
+ if ((fd = s->srv_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+ qfprintf(stderr, "Cannot get a server socket.\n");
+
+ if (errno == ENFILE)
+ send_log(s->proxy, LOG_EMERG,
+ "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
+ s->proxy->id, maxfd);
+ else if (errno == EMFILE)
+ send_log(s->proxy, LOG_EMERG,
+ "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
+ s->proxy->id, maxfd);
+ else if (errno == ENOBUFS || errno == ENOMEM)
+ send_log(s->proxy, LOG_EMERG,
+ "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
+ s->proxy->id, maxfd);
+ /* this is a resource error */
+ return SN_ERR_RESOURCE;
+ }
+
+ if (fd >= global.maxsock) {
+ /* do not log anything there, it's a normal condition when this option
+ * is used to serialize connections to a server !
+ */
+ Alert("socket(): not enough free sockets. Raise -n argument. Giving up.\n");
+ close(fd);
+ return SN_ERR_PRXCOND; /* it is a configuration limit */
+ }
+
+ if ((fcntl(fd, F_SETFL, O_NONBLOCK)==-1) ||
+ (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)) == -1)) {
+ qfprintf(stderr,"Cannot set client socket to non blocking mode.\n");
+ close(fd);
+ return SN_ERR_INTERNAL;
+ }
+
+ if (s->proxy->options & PR_O_TCP_SRV_KA)
+ setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
+
+ /* allow specific binding :
+ * - server-specific at first
+ * - proxy-specific next
+ */
+ if (s->srv != NULL && s->srv->state & SRV_BIND_SRC) {
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof(one));
+ if (bind(fd, (struct sockaddr *)&s->srv->source_addr, sizeof(s->srv->source_addr)) == -1) {
+ Alert("Cannot bind to source address before connect() for server %s/%s. Aborting.\n",
+ s->proxy->id, s->srv->id);
+ close(fd);
+ send_log(s->proxy, LOG_EMERG,
+ "Cannot bind to source address before connect() for server %s/%s.\n",
+ s->proxy->id, s->srv->id);
+ return SN_ERR_RESOURCE;
+ }
+ }
+ else if (s->proxy->options & PR_O_BIND_SRC) {
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof(one));
+ if (bind(fd, (struct sockaddr *)&s->proxy->source_addr, sizeof(s->proxy->source_addr)) == -1) {
+ Alert("Cannot bind to source address before connect() for proxy %s. Aborting.\n", s->proxy->id);
+ close(fd);
+ send_log(s->proxy, LOG_EMERG,
+ "Cannot bind to source address before connect() for server %s/%s.\n",
+ s->proxy->id, s->srv->id);
+ return SN_ERR_RESOURCE;
+ }
+ }
+
+ if ((connect(fd, (struct sockaddr *)&s->srv_addr, sizeof(s->srv_addr)) == -1) &&
+ (errno != EINPROGRESS) && (errno != EALREADY) && (errno != EISCONN)) {
+
+ if (errno == EAGAIN || errno == EADDRINUSE) {
+ char *msg;
+ if (errno == EAGAIN) /* no free ports left, try again later */
+ msg = "no free ports";
+ else
+ msg = "local address already in use";
+
+ qfprintf(stderr,"Cannot connect: %s.\n",msg);
+ close(fd);
+ send_log(s->proxy, LOG_EMERG,
+ "Connect() failed for server %s/%s: %s.\n",
+ s->proxy->id, s->srv->id, msg);
+ return SN_ERR_RESOURCE;
+ } else if (errno == ETIMEDOUT) {
+ //qfprintf(stderr,"Connect(): ETIMEDOUT");
+ close(fd);
+ return SN_ERR_SRVTO;
+ } else {
+ // (errno == ECONNREFUSED || errno == ENETUNREACH || errno == EACCES || errno == EPERM)
+ //qfprintf(stderr,"Connect(): %d", errno);
+ close(fd);
+ return SN_ERR_SRVCL;
+ }
+ }
+
+ fdtab[fd].owner = s->task;
+ fdtab[fd].read = &event_srv_read;
+ fdtab[fd].write = &event_srv_write;
+ fdtab[fd].state = FD_STCONN; /* connection in progress */
+
+ FD_SET(fd, StaticWriteEvent); /* for connect status */
+#if defined(DEBUG_FULL) && defined(ENABLE_EPOLL)
+ if (PrevReadEvent) {
+ assert(!(FD_ISSET(fd, PrevReadEvent)));
+ assert(!(FD_ISSET(fd, PrevWriteEvent)));
+ }
+#endif
+
+ fd_insert(fd);
+ if (s->srv) {
+ s->srv->cur_sess++;
+ if (s->srv->cur_sess > s->srv->cur_sess_max)
+ s->srv->cur_sess_max = s->srv->cur_sess;
+ }
+
+ if (s->proxy->contimeout)
+ tv_delayfrom(&s->cnexpire, &now, s->proxy->contimeout);
+ else
+ tv_eternity(&s->cnexpire);
+ return SN_ERR_NONE; /* connection is OK */
+}
+
+
+/*
+ * This function checks the retry count during the connect() job.
+ * It updates the session's srv_state and retries, so that the caller knows
+ * what it has to do. It uses the last connection error to set the log when
+ * it expires. It returns 1 when it has expired, and 0 otherwise.
+ */
+int srv_count_retry_down(struct session *t, int conn_err)
+{
+ /* we are in front of a retryable error */
+ t->conn_retries--;
+ if (t->conn_retries < 0) {
+ /* if not retryable anymore, let's abort */
+ tv_eternity(&t->cnexpire);
+ srv_close_with_err(t, conn_err, SN_FINST_C,
+ 503, t->proxy->errmsg.len503, t->proxy->errmsg.msg503);
+ if (t->srv)
+ t->srv->failed_conns++;
+ t->proxy->failed_conns++;
+
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+ return 1;
+ }
+ return 0;
+}
+
+
+/*
+ * This function performs the retryable part of the connect() job.
+ * It updates the session's srv_state and retries, so that the caller knows
+ * what it has to do. It returns 1 when it breaks out of the loop, or 0 if
+ * it needs to redispatch.
+ */
+int srv_retryable_connect(struct session *t)
+{
+ int conn_err;
+
+ /* This loop ensures that we stop before the last retry in case of a
+ * redispatchable server.
+ */
+ do {
+ /* initiate a connection to the server */
+ conn_err = connect_server(t);
+ switch (conn_err) {
+
+ case SN_ERR_NONE:
+ //fprintf(stderr,"0: c=%d, s=%d\n", c, s);
+ t->srv_state = SV_STCONN;
+ return 1;
+
+ case SN_ERR_INTERNAL:
+ tv_eternity(&t->cnexpire);
+ srv_close_with_err(t, SN_ERR_INTERNAL, SN_FINST_C,
+ 500, t->proxy->errmsg.len500, t->proxy->errmsg.msg500);
+ if (t->srv)
+ t->srv->failed_conns++;
+ t->proxy->failed_conns++;
+ /* release other sessions waiting for this server */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+ return 1;
+ }
+ /* ensure that we have enough retries left */
+ if (srv_count_retry_down(t, conn_err)) {
+ /* let's try to offer this slot to anybody */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+ return 1;
+ }
+ } while (t->srv == NULL || t->conn_retries > 0 || !(t->proxy->options & PR_O_REDISP));
+
+ /* We're on our last chance, and the REDISP option was specified.
+ * We will ignore cookie and force to balance or use the dispatcher.
+ */
+ /* let's try to offer this slot to anybody */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ if (t->srv)
+ t->srv->failed_conns++;
+ t->proxy->failed_conns++;
+
+ t->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
+ t->srv = NULL; /* it's left to the dispatcher to choose a server */
+ if ((t->flags & SN_CK_MASK) == SN_CK_VALID) {
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_DOWN;
+ }
+ return 0;
+}
+
+
+/* This function performs the "redispatch" part of a connection attempt. It
+ * will assign a server if required, queue the connection if required, and
+ * handle errors that might arise at this level. It can change the server
+ * state. It will return 1 if it encounters an error, switches the server
+ * state, or has to queue a connection. Otherwise, it will return 0 indicating
+ * that the connection is ready to use.
+ */
+
+int srv_redispatch_connect(struct session *t)
+{
+ int conn_err;
+
+ /* We know that we don't have any connection pending, so we will
+ * try to get a new one, and wait in this state if it's queued
+ */
+ conn_err = assign_server_and_queue(t);
+ switch (conn_err) {
+ case SRV_STATUS_OK:
+ break;
+
+ case SRV_STATUS_NOSRV:
+ /* note: it is guaranteed that t->srv == NULL here */
+ tv_eternity(&t->cnexpire);
+ srv_close_with_err(t, SN_ERR_SRVTO, SN_FINST_C,
+ 503, t->proxy->errmsg.len503, t->proxy->errmsg.msg503);
+ if (t->srv)
+ t->srv->failed_conns++;
+ t->proxy->failed_conns++;
+
+ return 1;
+
+ case SRV_STATUS_QUEUED:
+ /* FIXME-20060503 : we should use the queue timeout instead */
+ if (t->proxy->contimeout)
+ tv_delayfrom(&t->cnexpire, &now, t->proxy->contimeout);
+ else
+ tv_eternity(&t->cnexpire);
+ t->srv_state = SV_STIDLE;
+ /* do nothing else and do not wake any other session up */
+ return 1;
+
+ case SRV_STATUS_FULL:
+ case SRV_STATUS_INTERNAL:
+ default:
+ tv_eternity(&t->cnexpire);
+ srv_close_with_err(t, SN_ERR_INTERNAL, SN_FINST_C,
+ 500, t->proxy->errmsg.len500, t->proxy->errmsg.msg500);
+ if (t->srv)
+ t->srv->failed_conns++;
+ t->proxy->failed_conns++;
+
+ /* release other sessions waiting for this server */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+ return 1;
+ }
+ /* if we get here, it's because we got SRV_STATUS_OK, which also
+ * means that the connection has not been queued.
+ */
+ return 0;
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/base64.c b/src/base64.c
index 79e86c2..a427d5d 100644
--- a/src/base64.c
+++ b/src/base64.c
@@ -1,6 +1,7 @@
/*
* Ascii to Base64 conversion as described in RFC1421.
- * Copyright 2006 Willy Tarreau <willy@w.ods.org>
+ *
+ * Copyright 2006 Willy Tarreau <w@1wt.eu>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@@ -9,8 +10,9 @@
*
*/
-#include <include/base64.h>
+#include <haproxy/base64.h>
+const char base64tab[64]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/* Encodes <ilen> bytes from <in> to <out> for at most <olen> chars (including
* the trailing zero). Returns the number of bytes written. No check is made
@@ -19,7 +21,6 @@
*/
int a2base64(char *in, int ilen, char *out, int olen)
{
- char base64[64]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int convlen;
convlen = ((ilen + 2) / 3) * 4;
@@ -29,10 +30,10 @@
/* we don't need to check olen anymore */
while (ilen >= 3) {
- out[0] = base64[(((unsigned char)in[0]) >> 2)];
- out[1] = base64[(((unsigned char)in[0] & 0x03) << 4) | (((unsigned char)in[1]) >> 4)];
- out[2] = base64[(((unsigned char)in[1] & 0x0F) << 2) | (((unsigned char)in[2]) >> 6)];
- out[3] = base64[(((unsigned char)in[2] & 0x3F))];
+ out[0] = base64tab[(((unsigned char)in[0]) >> 2)];
+ out[1] = base64tab[(((unsigned char)in[0] & 0x03) << 4) | (((unsigned char)in[1]) >> 4)];
+ out[2] = base64tab[(((unsigned char)in[1] & 0x0F) << 2) | (((unsigned char)in[2]) >> 6)];
+ out[3] = base64tab[(((unsigned char)in[2] & 0x3F))];
out += 4;
in += 3; ilen -= 3;
}
@@ -40,14 +41,14 @@
if (!ilen) {
out[0] = '\0';
} else {
- out[0] = base64[((unsigned char)in[0]) >> 2];
+ out[0] = base64tab[((unsigned char)in[0]) >> 2];
if (ilen == 1) {
- out[1] = base64[((unsigned char)in[0] & 0x03) << 4];
+ out[1] = base64tab[((unsigned char)in[0] & 0x03) << 4];
out[2] = '=';
} else {
- out[1] = base64[(((unsigned char)in[0] & 0x03) << 4) |
+ out[1] = base64tab[(((unsigned char)in[0] & 0x03) << 4) |
(((unsigned char)in[1]) >> 4)];
- out[2] = base64[((unsigned char)in[1] & 0x0F) << 2];
+ out[2] = base64tab[((unsigned char)in[1] & 0x0F) << 2];
}
out[3] = '=';
out[4] = '\0';
diff --git a/src/buffers.c b/src/buffers.c
new file mode 100644
index 0000000..bbc1f28
--- /dev/null
+++ b/src/buffers.c
@@ -0,0 +1,116 @@
+/*
+ * Buffer management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <string.h>
+#include <proto/buffers.h>
+
+void **pool_buffer = NULL;
+
+/* writes <len> bytes from message <msg> to buffer <buf>. Returns 0 in case of
+ * success, or the number of bytes available otherwise.
+ * FIXME-20060521: handle unaligned data.
+ */
+int buffer_write(struct buffer *buf, const char *msg, int len)
+{
+ int max;
+
+ max = buffer_realign(buf);
+
+ if (len > max)
+ return max;
+
+ memcpy(buf->r, msg, len);
+ buf->l += len;
+ buf->r += len;
+ if (buf->r == buf->data + BUFSIZE)
+ buf->r = buf->data;
+ return 0;
+}
+
+/*
+ * this function writes the string <str> at position <pos> which must be in buffer <b>,
+ * and moves <end> just after the end of <str>.
+ * <b>'s parameters (l, r, w, h, lr) are recomputed to be valid after the shift.
+ * the shift value (positive or negative) is returned.
+ * If there's no space left, the move is not done.
+ *
+ */
+int buffer_replace(struct buffer *b, char *pos, char *end, char *str)
+{
+ int delta;
+ int len;
+
+ len = strlen(str);
+ delta = len - (end - pos);
+
+ if (delta + b->r >= b->data + BUFSIZE)
+ return 0; /* no space left */
+
+ /* first, protect the end of the buffer */
+ memmove(end + delta, end, b->data + b->l - end);
+
+ /* now, copy str over pos */
+ memcpy(pos, str,len);
+
+ /* we only move data after the displaced zone */
+ if (b->r > pos) b->r += delta;
+ if (b->w > pos) b->w += delta;
+ if (b->h > pos) b->h += delta;
+ if (b->lr > pos) b->lr += delta;
+ b->l += delta;
+
+ return delta;
+}
+
+/*
+ * same except that the string length is given, which allows str to be NULL if
+ * len is 0.
+ */
+int buffer_replace2(struct buffer *b, char *pos, char *end, char *str, int len)
+{
+ int delta;
+
+ delta = len - (end - pos);
+
+ if (delta + b->r >= b->data + BUFSIZE)
+ return 0; /* no space left */
+
+ if (b->data + b->l < end) {
+ /* The data has been stolen, we could have crashed.
+ * Maybe we should abort() ? */
+ return 0;
+ }
+
+ /* first, protect the end of the buffer */
+ memmove(end + delta, end, b->data + b->l - end);
+
+ /* now, copy str over pos */
+ if (len)
+ memcpy(pos, str, len);
+
+ /* we only move data after the displaced zone */
+ if (b->r > pos) b->r += delta;
+ if (b->w > pos) b->w += delta;
+ if (b->h > pos) b->h += delta;
+ if (b->lr > pos) b->lr += delta;
+ b->l += delta;
+
+ return delta;
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/capture.c b/src/capture.c
new file mode 100644
index 0000000..3a7c2c6
--- /dev/null
+++ b/src/capture.c
@@ -0,0 +1,24 @@
+/*
+ * Capture variables and functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <stdlib.h>
+#include <types/capture.h>
+
+void **pool_capture = NULL;
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/cfgparse.c b/src/cfgparse.c
new file mode 100644
index 0000000..52b6e08
--- /dev/null
+++ b/src/cfgparse.c
@@ -0,0 +1,2058 @@
+/*
+ * Configuration parser
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <ctype.h>
+
+#include <haproxy/cfgparse.h>
+#include <haproxy/config.h>
+#include <haproxy/memory.h>
+#include <haproxy/standard.h>
+#include <haproxy/time.h>
+#include <haproxy/uri_auth.h>
+
+#include <types/capture.h>
+#include <types/global.h>
+#include <types/polling.h>
+#include <types/proxy.h>
+#include <types/queue.h>
+
+#include <proto/backend.h>
+#include <proto/checks.h>
+#include <proto/log.h>
+#include <proto/server.h>
+#include <proto/task.h>
+
+
+const char *HTTP_302 =
+ "HTTP/1.0 302 Found\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "Location: "; /* not terminated since it will be concatenated with the URL */
+
+/* same as 302 except that the browser MUST retry with the GET method */
+const char *HTTP_303 =
+ "HTTP/1.0 303 See Other\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "Location: "; /* not terminated since it will be concatenated with the URL */
+
+const char *HTTP_400 =
+ "HTTP/1.0 400 Bad request\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "<html><body><h1>400 Bad request</h1>\nYour browser sent an invalid request.\n</body></html>\n";
+
+const char *HTTP_403 =
+ "HTTP/1.0 403 Forbidden\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "<html><body><h1>403 Forbidden</h1>\nRequest forbidden by administrative rules.\n</body></html>\n";
+
+const char *HTTP_408 =
+ "HTTP/1.0 408 Request Time-out\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "<html><body><h1>408 Request Time-out</h1>\nYour browser didn't send a complete request in time.\n</body></html>\n";
+
+const char *HTTP_500 =
+ "HTTP/1.0 500 Server Error\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "<html><body><h1>500 Server Error</h1>\nAn internal server error occured.\n</body></html>\n";
+
+const char *HTTP_502 =
+ "HTTP/1.0 502 Bad Gateway\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "<html><body><h1>502 Bad Gateway</h1>\nThe server returned an invalid or incomplete response.\n</body></html>\n";
+
+const char *HTTP_503 =
+ "HTTP/1.0 503 Service Unavailable\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "<html><body><h1>503 Service Unavailable</h1>\nNo server is available to handle this request.\n</body></html>\n";
+
+const char *HTTP_504 =
+ "HTTP/1.0 504 Gateway Time-out\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n"
+ "<html><body><h1>504 Gateway Time-out</h1>\nThe server didn't respond in time.\n</body></html>\n";
+
+
+static struct proxy defproxy; /* fake proxy used to assign default values on all instances */
+int cfg_maxpconn = DEFAULT_MAXCONN; /* # of simultaneous connections per proxy (-N) */
+int cfg_maxconn = 0; /* # of simultaneous connections, (-n) */
+
+/*
+ * converts <str> to a list of listeners which are dynamically allocated.
+ * The format is "{addr|'*'}:port[-end][,{addr|'*'}:port[-end]]*", where :
+ * - <addr> can be empty or "*" to indicate INADDR_ANY ;
+ * - <port> is a numerical port from 1 to 65535 ;
+ * - <end> indicates to use the range from <port> to <end> instead (inclusive).
+ * This can be repeated as many times as necessary, separated by a coma.
+ * The <tail> argument is a pointer to a current list which should be appended
+ * to the tail of the new list. The pointer to the new list is returned.
+ */
+static struct listener *str2listener(char *str, struct listener *tail)
+{
+ struct listener *l;
+ char *c, *next, *range, *dupstr;
+ int port, end;
+
+ next = dupstr = strdup(str);
+
+ while (next && *next) {
+ struct sockaddr_storage ss;
+
+ str = next;
+ /* 1) look for the end of the first address */
+ if ((next = strrchr(str, ',')) != NULL) {
+ *next++ = 0;
+ }
+
+ /* 2) look for the addr/port delimiter, it's the last colon. */
+ if ((range = strrchr(str, ':')) == NULL) {
+ Alert("Missing port number: '%s'\n", str);
+ goto fail;
+ }
+
+ *range++ = 0;
+
+ if (strrchr(str, ':') != NULL) {
+ /* IPv6 address contains ':' */
+ memset(&ss, 0, sizeof(ss));
+ ss.ss_family = AF_INET6;
+
+ if (!inet_pton(ss.ss_family, str, &((struct sockaddr_in6 *)&ss)->sin6_addr)) {
+ Alert("Invalid server address: '%s'\n", str);
+ goto fail;
+ }
+ }
+ else {
+ memset(&ss, 0, sizeof(ss));
+ ss.ss_family = AF_INET;
+
+ if (*str == '*' || *str == '\0') { /* INADDR_ANY */
+ ((struct sockaddr_in *)&ss)->sin_addr.s_addr = INADDR_ANY;
+ }
+ else if (!inet_pton(ss.ss_family, str, &((struct sockaddr_in *)&ss)->sin_addr)) {
+ struct hostent *he;
+
+ if ((he = gethostbyname(str)) == NULL) {
+ Alert("Invalid server name: '%s'\n", str);
+ goto fail;
+ }
+ else
+ ((struct sockaddr_in *)&ss)->sin_addr =
+ *(struct in_addr *) *(he->h_addr_list);
+ }
+ }
+
+ /* 3) look for the port-end delimiter */
+ if ((c = strchr(range, '-')) != NULL) {
+ *c++ = 0;
+ end = atol(c);
+ }
+ else {
+ end = atol(range);
+ }
+
+ port = atol(range);
+
+ if (port < 1 || port > 65535) {
+ Alert("Invalid port '%d' specified for address '%s'.\n", port, str);
+ goto fail;
+ }
+
+ if (end < 1 || end > 65535) {
+ Alert("Invalid port '%d' specified for address '%s'.\n", end, str);
+ goto fail;
+ }
+
+ for (; port <= end; port++) {
+ l = (struct listener *)calloc(1, sizeof(struct listener));
+ l->next = tail;
+ tail = l;
+
+ l->fd = -1;
+ l->addr = ss;
+ if (ss.ss_family == AF_INET6)
+ ((struct sockaddr_in6 *)(&l->addr))->sin6_port = htons(port);
+ else
+ ((struct sockaddr_in *)(&l->addr))->sin_port = htons(port);
+
+ } /* end for(port) */
+ } /* end while(next) */
+ free(dupstr);
+ return tail;
+ fail:
+ free(dupstr);
+ return NULL;
+}
+
+
+/*
+ * parse a line in a <global> section. Returns 0 if OK, -1 if error.
+ */
+int cfg_parse_global(char *file, int linenum, char **args)
+{
+
+ if (!strcmp(args[0], "global")) { /* new section */
+ /* no option, nothing special to do */
+ return 0;
+ }
+ else if (!strcmp(args[0], "daemon")) {
+ global.mode |= MODE_DAEMON;
+ }
+ else if (!strcmp(args[0], "debug")) {
+ global.mode |= MODE_DEBUG;
+ }
+ else if (!strcmp(args[0], "noepoll")) {
+ cfg_polling_mechanism &= ~POLL_USE_EPOLL;
+ }
+ else if (!strcmp(args[0], "nopoll")) {
+ cfg_polling_mechanism &= ~POLL_USE_POLL;
+ }
+ else if (!strcmp(args[0], "quiet")) {
+ global.mode |= MODE_QUIET;
+ }
+ else if (!strcmp(args[0], "stats")) {
+ global.mode |= MODE_STATS;
+ }
+ else if (!strcmp(args[0], "uid")) {
+ if (global.uid != 0) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ global.uid = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "gid")) {
+ if (global.gid != 0) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ global.gid = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "nbproc")) {
+ if (global.nbproc != 0) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ global.nbproc = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "maxconn")) {
+ if (global.maxconn != 0) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ global.maxconn = atol(args[1]);
+#ifdef SYSTEM_MAXCONN
+ if (global.maxconn > DEFAULT_MAXCONN && cfg_maxconn <= DEFAULT_MAXCONN) {
+ Alert("parsing [%s:%d] : maxconn value %d too high for this system.\nLimiting to %d. Please use '-n' to force the value.\n", file, linenum, global.maxconn, DEFAULT_MAXCONN);
+ global.maxconn = DEFAULT_MAXCONN;
+ }
+#endif /* SYSTEM_MAXCONN */
+ }
+ else if (!strcmp(args[0], "ulimit-n")) {
+ if (global.rlimit_nofile != 0) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ global.rlimit_nofile = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "chroot")) {
+ if (global.chroot != NULL) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects a directory as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ global.chroot = strdup(args[1]);
+ }
+ else if (!strcmp(args[0], "pidfile")) {
+ if (global.pidfile != NULL) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects a file name as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ global.pidfile = strdup(args[1]);
+ }
+ else if (!strcmp(args[0], "log")) { /* syslog server address */
+ struct sockaddr_in *sa;
+ int facility, level;
+
+ if (*(args[1]) == 0 || *(args[2]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <address> and <facility> as arguments.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ facility = get_log_facility(args[2]);
+ if (facility < 0) {
+ Alert("parsing [%s:%d] : unknown log facility '%s'\n", file, linenum, args[2]);
+ exit(1);
+ }
+
+ level = 7; /* max syslog level = debug */
+ if (*(args[3])) {
+ level = get_log_level(args[3]);
+ if (level < 0) {
+ Alert("parsing [%s:%d] : unknown optional log level '%s'\n", file, linenum, args[3]);
+ exit(1);
+ }
+ }
+
+ sa = str2sa(args[1]);
+ if (!sa->sin_port)
+ sa->sin_port = htons(SYSLOG_PORT);
+
+ if (global.logfac1 == -1) {
+ global.logsrv1 = *sa;
+ global.logfac1 = facility;
+ global.loglev1 = level;
+ }
+ else if (global.logfac2 == -1) {
+ global.logsrv2 = *sa;
+ global.logfac2 = facility;
+ global.loglev2 = level;
+ }
+ else {
+ Alert("parsing [%s:%d] : too many syslog servers\n", file, linenum);
+ return -1;
+ }
+
+ }
+ else {
+ Alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], "global");
+ return -1;
+ }
+ return 0;
+}
+
+
+static void init_default_instance()
+{
+ memset(&defproxy, 0, sizeof(defproxy));
+ defproxy.mode = PR_MODE_TCP;
+ defproxy.state = PR_STNEW;
+ defproxy.maxconn = cfg_maxpconn;
+ defproxy.conn_retries = CONN_RETRIES;
+ defproxy.logfac1 = defproxy.logfac2 = -1; /* log disabled */
+}
+
+/*
+ * parse a line in a <listen> section. Returns 0 if OK, -1 if error.
+ */
+int cfg_parse_listen(char *file, int linenum, char **args)
+{
+ static struct proxy *curproxy = NULL;
+ struct server *newsrv = NULL;
+ char *err;
+ int rc;
+
+ if (!strcmp(args[0], "listen")) { /* new proxy */
+ if (!*args[1]) {
+ Alert("parsing [%s:%d] : '%s' expects an <id> argument and\n"
+ " optionnally supports [addr1]:port1[-end1]{,[addr]:port[-end]}...\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+
+ if ((curproxy = (struct proxy *)calloc(1, sizeof(struct proxy))) == NULL) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+
+ curproxy->next = proxy;
+ proxy = curproxy;
+ LIST_INIT(&curproxy->pendconns);
+
+ curproxy->id = strdup(args[1]);
+
+ /* parse the listener address if any */
+ if (*args[2]) {
+ curproxy->listen = str2listener(args[2], curproxy->listen);
+ if (!curproxy->listen)
+ return -1;
+ global.maxsock++;
+ }
+
+ /* set default values */
+ curproxy->state = defproxy.state;
+ curproxy->maxconn = defproxy.maxconn;
+ curproxy->conn_retries = defproxy.conn_retries;
+ curproxy->options = defproxy.options;
+
+ if (defproxy.check_req)
+ curproxy->check_req = strdup(defproxy.check_req);
+ curproxy->check_len = defproxy.check_len;
+
+ if (defproxy.cookie_name)
+ curproxy->cookie_name = strdup(defproxy.cookie_name);
+ curproxy->cookie_len = defproxy.cookie_len;
+
+ if (defproxy.capture_name)
+ curproxy->capture_name = strdup(defproxy.capture_name);
+ curproxy->capture_namelen = defproxy.capture_namelen;
+ curproxy->capture_len = defproxy.capture_len;
+
+ if (defproxy.errmsg.msg400)
+ curproxy->errmsg.msg400 = strdup(defproxy.errmsg.msg400);
+ curproxy->errmsg.len400 = defproxy.errmsg.len400;
+
+ if (defproxy.errmsg.msg403)
+ curproxy->errmsg.msg403 = strdup(defproxy.errmsg.msg403);
+ curproxy->errmsg.len403 = defproxy.errmsg.len403;
+
+ if (defproxy.errmsg.msg408)
+ curproxy->errmsg.msg408 = strdup(defproxy.errmsg.msg408);
+ curproxy->errmsg.len408 = defproxy.errmsg.len408;
+
+ if (defproxy.errmsg.msg500)
+ curproxy->errmsg.msg500 = strdup(defproxy.errmsg.msg500);
+ curproxy->errmsg.len500 = defproxy.errmsg.len500;
+
+ if (defproxy.errmsg.msg502)
+ curproxy->errmsg.msg502 = strdup(defproxy.errmsg.msg502);
+ curproxy->errmsg.len502 = defproxy.errmsg.len502;
+
+ if (defproxy.errmsg.msg503)
+ curproxy->errmsg.msg503 = strdup(defproxy.errmsg.msg503);
+ curproxy->errmsg.len503 = defproxy.errmsg.len503;
+
+ if (defproxy.errmsg.msg504)
+ curproxy->errmsg.msg504 = strdup(defproxy.errmsg.msg504);
+ curproxy->errmsg.len504 = defproxy.errmsg.len504;
+
+ curproxy->clitimeout = defproxy.clitimeout;
+ curproxy->contimeout = defproxy.contimeout;
+ curproxy->srvtimeout = defproxy.srvtimeout;
+ curproxy->mode = defproxy.mode;
+ curproxy->logfac1 = defproxy.logfac1;
+ curproxy->logsrv1 = defproxy.logsrv1;
+ curproxy->loglev1 = defproxy.loglev1;
+ curproxy->logfac2 = defproxy.logfac2;
+ curproxy->logsrv2 = defproxy.logsrv2;
+ curproxy->loglev2 = defproxy.loglev2;
+ curproxy->to_log = defproxy.to_log & ~LW_COOKIE & ~LW_REQHDR & ~ LW_RSPHDR;
+ curproxy->grace = defproxy.grace;
+ curproxy->uri_auth = defproxy.uri_auth;
+ curproxy->source_addr = defproxy.source_addr;
+ curproxy->mon_net = defproxy.mon_net;
+ curproxy->mon_mask = defproxy.mon_mask;
+ return 0;
+ }
+ else if (!strcmp(args[0], "defaults")) { /* use this one to assign default values */
+ /* some variables may have already been initialized earlier */
+ if (defproxy.check_req) free(defproxy.check_req);
+ if (defproxy.cookie_name) free(defproxy.cookie_name);
+ if (defproxy.capture_name) free(defproxy.capture_name);
+ if (defproxy.errmsg.msg400) free(defproxy.errmsg.msg400);
+ if (defproxy.errmsg.msg403) free(defproxy.errmsg.msg403);
+ if (defproxy.errmsg.msg408) free(defproxy.errmsg.msg408);
+ if (defproxy.errmsg.msg500) free(defproxy.errmsg.msg500);
+ if (defproxy.errmsg.msg502) free(defproxy.errmsg.msg502);
+ if (defproxy.errmsg.msg503) free(defproxy.errmsg.msg503);
+ if (defproxy.errmsg.msg504) free(defproxy.errmsg.msg504);
+ /* we cannot free uri_auth because it might already be used */
+ init_default_instance();
+ curproxy = &defproxy;
+ return 0;
+ }
+ else if (curproxy == NULL) {
+ Alert("parsing [%s:%d] : 'listen' or 'defaults' expected.\n", file, linenum);
+ return -1;
+ }
+
+ if (!strcmp(args[0], "bind")) { /* new listen addresses */
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (strchr(args[1], ':') == NULL) {
+ Alert("parsing [%s:%d] : '%s' expects [addr1]:port1[-end1]{,[addr]:port[-end]}... as arguments.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->listen = str2listener(args[1], curproxy->listen);
+ if (!curproxy->listen)
+ return -1;
+ global.maxsock++;
+ return 0;
+ }
+ else if (!strcmp(args[0], "monitor-net")) { /* set the range of IPs to ignore */
+ if (!*args[1] || !str2net(args[1], &curproxy->mon_net, &curproxy->mon_mask)) {
+ Alert("parsing [%s:%d] : '%s' expects address[/mask].\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ /* flush useless bits */
+ curproxy->mon_net.s_addr &= curproxy->mon_mask.s_addr;
+ return 0;
+ }
+ else if (!strcmp(args[0], "mode")) { /* sets the proxy mode */
+ if (!strcmp(args[1], "http")) curproxy->mode = PR_MODE_HTTP;
+ else if (!strcmp(args[1], "tcp")) curproxy->mode = PR_MODE_TCP;
+ else if (!strcmp(args[1], "health")) curproxy->mode = PR_MODE_HEALTH;
+ else {
+ Alert("parsing [%s:%d] : unknown proxy mode '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "disabled")) { /* disables this proxy */
+ curproxy->state = PR_STSTOPPED;
+ }
+ else if (!strcmp(args[0], "enabled")) { /* enables this proxy (used to revert a disabled default) */
+ curproxy->state = PR_STNEW;
+ }
+ else if (!strcmp(args[0], "cookie")) { /* cookie name */
+ int cur_arg;
+ // if (curproxy == &defproxy) {
+ // Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ // return -1;
+ // }
+
+ if (curproxy->cookie_name != NULL) {
+ // Alert("parsing [%s:%d] : cookie name already specified. Continuing.\n",
+ // file, linenum);
+ // return 0;
+ free(curproxy->cookie_name);
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <cookie_name> as argument.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->cookie_name = strdup(args[1]);
+ curproxy->cookie_len = strlen(curproxy->cookie_name);
+
+ cur_arg = 2;
+ while (*(args[cur_arg])) {
+ if (!strcmp(args[cur_arg], "rewrite")) {
+ curproxy->options |= PR_O_COOK_RW;
+ }
+ else if (!strcmp(args[cur_arg], "indirect")) {
+ curproxy->options |= PR_O_COOK_IND;
+ }
+ else if (!strcmp(args[cur_arg], "insert")) {
+ curproxy->options |= PR_O_COOK_INS;
+ }
+ else if (!strcmp(args[cur_arg], "nocache")) {
+ curproxy->options |= PR_O_COOK_NOC;
+ }
+ else if (!strcmp(args[cur_arg], "postonly")) {
+ curproxy->options |= PR_O_COOK_POST;
+ }
+ else if (!strcmp(args[cur_arg], "prefix")) {
+ curproxy->options |= PR_O_COOK_PFX;
+ }
+ else {
+ Alert("parsing [%s:%d] : '%s' supports 'rewrite', 'insert', 'prefix', 'indirect', 'nocache' and 'postonly' options.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ cur_arg++;
+ }
+ if (!POWEROF2(curproxy->options & (PR_O_COOK_RW|PR_O_COOK_IND))) {
+ Alert("parsing [%s:%d] : cookie 'rewrite' and 'indirect' modes are incompatible.\n",
+ file, linenum);
+ return -1;
+ }
+
+ if (!POWEROF2(curproxy->options & (PR_O_COOK_RW|PR_O_COOK_INS|PR_O_COOK_PFX))) {
+ Alert("parsing [%s:%d] : cookie 'rewrite', 'insert' and 'prefix' modes are incompatible.\n",
+ file, linenum);
+ return -1;
+ }
+ }/* end else if (!strcmp(args[0], "cookie")) */
+ else if (!strcmp(args[0], "appsession")) { /* cookie name */
+ // if (curproxy == &defproxy) {
+ // Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ // return -1;
+ // }
+
+ if (curproxy->appsession_name != NULL) {
+ // Alert("parsing [%s:%d] : cookie name already specified. Continuing.\n",
+ // file, linenum);
+ // return 0;
+ free(curproxy->appsession_name);
+ }
+
+ if (*(args[5]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects 'appsession' <cookie_name> 'len' <len> 'timeout' <timeout>.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ have_appsession = 1;
+ curproxy->appsession_name = strdup(args[1]);
+ curproxy->appsession_name_len = strlen(curproxy->appsession_name);
+ curproxy->appsession_len = atoi(args[3]);
+ curproxy->appsession_timeout = atoi(args[5]);
+ rc = chtbl_init(&(curproxy->htbl_proxy), TBLSIZ, hashpjw, match_str, destroy);
+ if (rc) {
+ Alert("Error Init Appsession Hashtable.\n");
+ return -1;
+ }
+ } /* Url App Session */
+ else if (!strcmp(args[0], "capture")) {
+ if (!strcmp(args[1], "cookie")) { /* name of a cookie to capture */
+ // if (curproxy == &defproxy) {
+ // Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ // return -1;
+ // }
+
+ if (curproxy->capture_name != NULL) {
+ // Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n",
+ // file, linenum, args[0]);
+ // return 0;
+ free(curproxy->capture_name);
+ }
+
+ if (*(args[4]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects 'cookie' <cookie_name> 'len' <len>.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->capture_name = strdup(args[2]);
+ curproxy->capture_namelen = strlen(curproxy->capture_name);
+ curproxy->capture_len = atol(args[4]);
+ if (curproxy->capture_len >= CAPTURE_LEN) {
+ Warning("parsing [%s:%d] : truncating capture length to %d bytes.\n",
+ file, linenum, CAPTURE_LEN - 1);
+ curproxy->capture_len = CAPTURE_LEN - 1;
+ }
+ curproxy->to_log |= LW_COOKIE;
+ }
+ else if (!strcmp(args[1], "request") && !strcmp(args[2], "header")) {
+ struct cap_hdr *hdr;
+
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s %s' not allowed in 'defaults' section.\n", file, linenum, args[0], args[1]);
+ return -1;
+ }
+
+ if (*(args[3]) == 0 || strcmp(args[4], "len") != 0 || *(args[5]) == 0) {
+ Alert("parsing [%s:%d] : '%s %s' expects 'header' <header_name> 'len' <len>.\n",
+ file, linenum, args[0], args[1]);
+ return -1;
+ }
+
+ hdr = calloc(sizeof(struct cap_hdr), 1);
+ hdr->next = curproxy->req_cap;
+ hdr->name = strdup(args[3]);
+ hdr->namelen = strlen(args[3]);
+ hdr->len = atol(args[5]);
+ hdr->index = curproxy->nb_req_cap++;
+ curproxy->req_cap = hdr;
+ curproxy->to_log |= LW_REQHDR;
+ }
+ else if (!strcmp(args[1], "response") && !strcmp(args[2], "header")) {
+ struct cap_hdr *hdr;
+
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s %s' not allowed in 'defaults' section.\n", file, linenum, args[0], args[1]);
+ return -1;
+ }
+
+ if (*(args[3]) == 0 || strcmp(args[4], "len") != 0 || *(args[5]) == 0) {
+ Alert("parsing [%s:%d] : '%s %s' expects 'header' <header_name> 'len' <len>.\n",
+ file, linenum, args[0], args[1]);
+ return -1;
+ }
+ hdr = calloc(sizeof(struct cap_hdr), 1);
+ hdr->next = curproxy->rsp_cap;
+ hdr->name = strdup(args[3]);
+ hdr->namelen = strlen(args[3]);
+ hdr->len = atol(args[5]);
+ hdr->index = curproxy->nb_rsp_cap++;
+ curproxy->rsp_cap = hdr;
+ curproxy->to_log |= LW_RSPHDR;
+ }
+ else {
+ Alert("parsing [%s:%d] : '%s' expects 'cookie' or 'request header' or 'response header'.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "contimeout")) { /* connect timeout */
+ if (curproxy->contimeout != defproxy.contimeout) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer <time_in_ms> as argument.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->contimeout = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "clitimeout")) { /* client timeout */
+ if (curproxy->clitimeout != defproxy.clitimeout) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n",
+ file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer <time_in_ms> as argument.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->clitimeout = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "srvtimeout")) { /* server timeout */
+ if (curproxy->srvtimeout != defproxy.srvtimeout) {
+ Alert("parsing [%s:%d] : '%s' already specified. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer <time_in_ms> as argument.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->srvtimeout = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "retries")) { /* connection retries */
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer argument (dispatch counts for one).\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->conn_retries = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "stats")) {
+ if (curproxy != &defproxy && curproxy->uri_auth == defproxy.uri_auth)
+ curproxy->uri_auth = NULL; /* we must detach from the default config */
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects 'uri', 'realm', 'auth', 'scope' or 'enable'.\n", file, linenum, args[0]);
+ return -1;
+ } else if (!strcmp(args[1], "uri")) {
+ if (*(args[2]) == 0) {
+ Alert("parsing [%s:%d] : 'uri' needs an URI prefix.\n", file, linenum);
+ return -1;
+ } else if (!stats_set_uri(&curproxy->uri_auth, args[2])) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+ } else if (!strcmp(args[1], "realm")) {
+ if (*(args[2]) == 0) {
+ Alert("parsing [%s:%d] : 'realm' needs an realm name.\n", file, linenum);
+ return -1;
+ } else if (!stats_set_realm(&curproxy->uri_auth, args[2])) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+ } else if (!strcmp(args[1], "auth")) {
+ if (*(args[2]) == 0) {
+ Alert("parsing [%s:%d] : 'auth' needs a user:password account.\n", file, linenum);
+ return -1;
+ } else if (!stats_add_auth(&curproxy->uri_auth, args[2])) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+ } else if (!strcmp(args[1], "scope")) {
+ if (*(args[2]) == 0) {
+ Alert("parsing [%s:%d] : 'scope' needs a proxy name.\n", file, linenum);
+ return -1;
+ } else if (!stats_add_scope(&curproxy->uri_auth, args[2])) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+ } else if (!strcmp(args[1], "enable")) {
+ if (!stats_check_init_uri_auth(&curproxy->uri_auth)) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+ } else {
+ Alert("parsing [%s:%d] : unknown stats parameter '%s' (expects 'uri', 'realm', 'auth' or 'enable').\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "option")) {
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an option name.\n", file, linenum, args[0]);
+ return -1;
+ }
+ if (!strcmp(args[1], "redispatch"))
+ /* enable reconnections to dispatch */
+ curproxy->options |= PR_O_REDISP;
+#ifdef TPROXY
+ else if (!strcmp(args[1], "transparent"))
+ /* enable transparent proxy connections */
+ curproxy->options |= PR_O_TRANSP;
+#endif
+ else if (!strcmp(args[1], "keepalive"))
+ /* enable keep-alive */
+ curproxy->options |= PR_O_KEEPALIVE;
+ else if (!strcmp(args[1], "forwardfor"))
+ /* insert x-forwarded-for field */
+ curproxy->options |= PR_O_FWDFOR;
+ else if (!strcmp(args[1], "logasap"))
+ /* log as soon as possible, without waiting for the session to complete */
+ curproxy->options |= PR_O_LOGASAP;
+ else if (!strcmp(args[1], "abortonclose"))
+ /* abort connection if client closes during queue or connect() */
+ curproxy->options |= PR_O_ABRT_CLOSE;
+ else if (!strcmp(args[1], "httpclose"))
+ /* force connection: close in both directions in HTTP mode */
+ curproxy->options |= PR_O_HTTP_CLOSE;
+ else if (!strcmp(args[1], "forceclose"))
+ /* force connection: close in both directions in HTTP mode and enforce end of session */
+ curproxy->options |= PR_O_FORCE_CLO | PR_O_HTTP_CLOSE;
+ else if (!strcmp(args[1], "checkcache"))
+ /* require examination of cacheability of the 'set-cookie' field */
+ curproxy->options |= PR_O_CHK_CACHE;
+ else if (!strcmp(args[1], "httplog"))
+ /* generate a complete HTTP log */
+ curproxy->to_log |= LW_DATE | LW_CLIP | LW_SVID | LW_REQ | LW_PXID | LW_RESP | LW_BYTES;
+ else if (!strcmp(args[1], "tcplog"))
+ /* generate a detailed TCP log */
+ curproxy->to_log |= LW_DATE | LW_CLIP | LW_SVID | LW_PXID | LW_BYTES;
+ else if (!strcmp(args[1], "dontlognull")) {
+ /* don't log empty requests */
+ curproxy->options |= PR_O_NULLNOLOG;
+ }
+ else if (!strcmp(args[1], "tcpka")) {
+ /* enable TCP keep-alives on client and server sessions */
+ curproxy->options |= PR_O_TCP_CLI_KA | PR_O_TCP_SRV_KA;
+ }
+ else if (!strcmp(args[1], "clitcpka")) {
+ /* enable TCP keep-alives on client sessions */
+ curproxy->options |= PR_O_TCP_CLI_KA;
+ }
+ else if (!strcmp(args[1], "srvtcpka")) {
+ /* enable TCP keep-alives on server sessions */
+ curproxy->options |= PR_O_TCP_SRV_KA;
+ }
+ else if (!strcmp(args[1], "allbackups")) {
+ /* Use all backup servers simultaneously */
+ curproxy->options |= PR_O_USE_ALL_BK;
+ }
+ else if (!strcmp(args[1], "httpchk")) {
+ /* use HTTP request to check servers' health */
+ if (curproxy->check_req != NULL) {
+ free(curproxy->check_req);
+ }
+ curproxy->options |= PR_O_HTTP_CHK;
+ if (!*args[2]) { /* no argument */
+ curproxy->check_req = strdup(DEF_CHECK_REQ); /* default request */
+ curproxy->check_len = strlen(DEF_CHECK_REQ);
+ } else if (!*args[3]) { /* one argument : URI */
+ int reqlen = strlen(args[2]) + strlen("OPTIONS / HTTP/1.0\r\n\r\n");
+ curproxy->check_req = (char *)malloc(reqlen);
+ curproxy->check_len = snprintf(curproxy->check_req, reqlen,
+ "OPTIONS %s HTTP/1.0\r\n\r\n", args[2]); /* URI to use */
+ } else { /* more arguments : METHOD URI [HTTP_VER] */
+ int reqlen = strlen(args[2]) + strlen(args[3]) + 3 + strlen("\r\n\r\n");
+ if (*args[4])
+ reqlen += strlen(args[4]);
+ else
+ reqlen += strlen("HTTP/1.0");
+
+ curproxy->check_req = (char *)malloc(reqlen);
+ curproxy->check_len = snprintf(curproxy->check_req, reqlen,
+ "%s %s %s\r\n\r\n", args[2], args[3], *args[4]?args[4]:"HTTP/1.0");
+ }
+ }
+ else if (!strcmp(args[1], "persist")) {
+ /* persist on using the server specified by the cookie, even when it's down */
+ curproxy->options |= PR_O_PERSIST;
+ }
+ else {
+ Alert("parsing [%s:%d] : unknown option '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+ return 0;
+ }
+ else if (!strcmp(args[0], "redispatch") || !strcmp(args[0], "redisp")) {
+ /* enable reconnections to dispatch */
+ curproxy->options |= PR_O_REDISP;
+ }
+#ifdef TPROXY
+ else if (!strcmp(args[0], "transparent")) {
+ /* enable transparent proxy connections */
+ curproxy->options |= PR_O_TRANSP;
+ }
+#endif
+ else if (!strcmp(args[0], "maxconn")) { /* maxconn */
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects an integer argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->maxconn = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "grace")) { /* grace time (ms) */
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects a time in milliseconds.\n", file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->grace = atol(args[1]);
+ }
+ else if (!strcmp(args[0], "dispatch")) { /* dispatch address */
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+ if (strchr(args[1], ':') == NULL) {
+ Alert("parsing [%s:%d] : '%s' expects <addr:port> as argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+ curproxy->dispatch_addr = *str2sa(args[1]);
+ }
+ else if (!strcmp(args[0], "balance")) { /* set balancing with optional algorithm */
+ if (*(args[1])) {
+ if (!strcmp(args[1], "roundrobin")) {
+ curproxy->options |= PR_O_BALANCE_RR;
+ }
+ else if (!strcmp(args[1], "source")) {
+ curproxy->options |= PR_O_BALANCE_SH;
+ }
+ else {
+ Alert("parsing [%s:%d] : '%s' only supports 'roundrobin' and 'source' options.\n", file, linenum, args[0]);
+ return -1;
+ }
+ }
+ else /* if no option is set, use round-robin by default */
+ curproxy->options |= PR_O_BALANCE_RR;
+ }
+ else if (!strcmp(args[0], "server")) { /* server address */
+ int cur_arg;
+ char *rport;
+ char *raddr;
+ short realport;
+ int do_check;
+
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (!*args[2]) {
+ Alert("parsing [%s:%d] : '%s' expects <name> and <addr>[:<port>] as arguments.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+ if ((newsrv = (struct server *)calloc(1, sizeof(struct server))) == NULL) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+
+ /* the servers are linked backwards first */
+ newsrv->next = curproxy->srv;
+ curproxy->srv = newsrv;
+ newsrv->proxy = curproxy;
+
+ LIST_INIT(&newsrv->pendconns);
+ do_check = 0;
+ newsrv->state = SRV_RUNNING; /* early server setup */
+ newsrv->id = strdup(args[1]);
+
+ /* several ways to check the port component :
+ * - IP => port=+0, relative
+ * - IP: => port=+0, relative
+ * - IP:N => port=N, absolute
+ * - IP:+N => port=+N, relative
+ * - IP:-N => port=-N, relative
+ */
+ raddr = strdup(args[2]);
+ rport = strchr(raddr, ':');
+ if (rport) {
+ *rport++ = 0;
+ realport = atol(rport);
+ if (!isdigit((int)*rport))
+ newsrv->state |= SRV_MAPPORTS;
+ } else {
+ realport = 0;
+ newsrv->state |= SRV_MAPPORTS;
+ }
+
+ newsrv->addr = *str2sa(raddr);
+ newsrv->addr.sin_port = htons(realport);
+ free(raddr);
+
+ newsrv->curfd = -1; /* no health-check in progress */
+ newsrv->inter = DEF_CHKINTR;
+ newsrv->rise = DEF_RISETIME;
+ newsrv->fall = DEF_FALLTIME;
+ newsrv->health = newsrv->rise; /* up, but will fall down at first failure */
+ cur_arg = 3;
+ while (*args[cur_arg]) {
+ if (!strcmp(args[cur_arg], "cookie")) {
+ newsrv->cookie = strdup(args[cur_arg + 1]);
+ newsrv->cklen = strlen(args[cur_arg + 1]);
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "rise")) {
+ newsrv->rise = atol(args[cur_arg + 1]);
+ newsrv->health = newsrv->rise;
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "fall")) {
+ newsrv->fall = atol(args[cur_arg + 1]);
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "inter")) {
+ newsrv->inter = atol(args[cur_arg + 1]);
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "port")) {
+ newsrv->check_port = atol(args[cur_arg + 1]);
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "backup")) {
+ newsrv->state |= SRV_BACKUP;
+ cur_arg ++;
+ }
+ else if (!strcmp(args[cur_arg], "weight")) {
+ int w;
+ w = atol(args[cur_arg + 1]);
+ if (w < 1 || w > 256) {
+ Alert("parsing [%s:%d] : weight of server %s is not within 1 and 256 (%d).\n",
+ file, linenum, newsrv->id, w);
+ return -1;
+ }
+ newsrv->uweight = w - 1;
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "minconn")) {
+ newsrv->minconn = atol(args[cur_arg + 1]);
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "maxconn")) {
+ newsrv->maxconn = atol(args[cur_arg + 1]);
+ cur_arg += 2;
+ }
+ else if (!strcmp(args[cur_arg], "check")) {
+ global.maxsock++;
+ do_check = 1;
+ cur_arg += 1;
+ }
+ else if (!strcmp(args[cur_arg], "source")) { /* address to which we bind when connecting */
+ if (!*args[cur_arg + 1]) {
+ Alert("parsing [%s:%d] : '%s' expects <addr>[:<port>] as argument.\n",
+ file, linenum, "source");
+ return -1;
+ }
+ newsrv->state |= SRV_BIND_SRC;
+ newsrv->source_addr = *str2sa(args[cur_arg + 1]);
+ cur_arg += 2;
+ }
+ else {
+ Alert("parsing [%s:%d] : server %s only supports options 'backup', 'cookie', 'check', 'inter', 'rise', 'fall', 'port', 'source', 'minconn', 'maxconn' and 'weight'.\n",
+ file, linenum, newsrv->id);
+ return -1;
+ }
+ }
+
+ if (do_check) {
+ if (!newsrv->check_port && !(newsrv->state & SRV_MAPPORTS))
+ newsrv->check_port = realport; /* by default */
+ if (!newsrv->check_port) {
+ Alert("parsing [%s:%d] : server %s has neither service port nor check port. Check has been disabled.\n",
+ file, linenum, newsrv->id);
+ return -1;
+ }
+ newsrv->state |= SRV_CHECKED;
+ }
+
+ if (newsrv->state & SRV_BACKUP)
+ curproxy->srv_bck++;
+ else
+ curproxy->srv_act++;
+ }
+ else if (!strcmp(args[0], "log")) { /* syslog server address */
+ struct sockaddr_in *sa;
+ int facility;
+
+ if (*(args[1]) && *(args[2]) == 0 && !strcmp(args[1], "global")) {
+ curproxy->logfac1 = global.logfac1;
+ curproxy->logsrv1 = global.logsrv1;
+ curproxy->loglev1 = global.loglev1;
+ curproxy->logfac2 = global.logfac2;
+ curproxy->logsrv2 = global.logsrv2;
+ curproxy->loglev2 = global.loglev2;
+ }
+ else if (*(args[1]) && *(args[2])) {
+ int level;
+
+ facility = get_log_facility(args[2]);
+ if (facility < 0) {
+ Alert("parsing [%s:%d] : unknown log facility '%s'\n", file, linenum, args[2]);
+ exit(1);
+ }
+
+ level = 7; /* max syslog level = debug */
+ if (*(args[3])) {
+ level = get_log_level(args[3]);
+ if (level < 0) {
+ Alert("parsing [%s:%d] : unknown optional log level '%s'\n", file, linenum, args[3]);
+ exit(1);
+ }
+ }
+
+ sa = str2sa(args[1]);
+ if (!sa->sin_port)
+ sa->sin_port = htons(SYSLOG_PORT);
+
+ if (curproxy->logfac1 == -1) {
+ curproxy->logsrv1 = *sa;
+ curproxy->logfac1 = facility;
+ curproxy->loglev1 = level;
+ }
+ else if (curproxy->logfac2 == -1) {
+ curproxy->logsrv2 = *sa;
+ curproxy->logfac2 = facility;
+ curproxy->loglev2 = level;
+ }
+ else {
+ Alert("parsing [%s:%d] : too many syslog servers\n", file, linenum);
+ return -1;
+ }
+ }
+ else {
+ Alert("parsing [%s:%d] : 'log' expects either <address[:port]> and <facility> or 'global' as arguments.\n",
+ file, linenum);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "source")) { /* address to which we bind when connecting */
+ if (!*args[1]) {
+ Alert("parsing [%s:%d] : '%s' expects <addr>[:<port>] as argument.\n",
+ file, linenum, "source");
+ return -1;
+ }
+
+ curproxy->source_addr = *str2sa(args[1]);
+ curproxy->options |= PR_O_BIND_SRC;
+ }
+ else if (!strcmp(args[0], "cliexp") || !strcmp(args[0], "reqrep")) { /* replace request header from a regex */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0 || *(args[2]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> and <replace> as arguments.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->req_exp, preg, ACT_REPLACE, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "reqdel")) { /* delete request header from a regex */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_REMOVE, NULL);
+ }
+ else if (!strcmp(args[0], "reqdeny")) { /* deny a request if a header matches this regex */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_DENY, NULL);
+ }
+ else if (!strcmp(args[0], "reqpass")) { /* pass this header without allowing or denying the request */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_PASS, NULL);
+ }
+ else if (!strcmp(args[0], "reqallow")) { /* allow a request if a header matches this regex */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_ALLOW, NULL);
+ }
+ else if (!strcmp(args[0], "reqirep")) { /* replace request header from a regex, ignoring case */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0 || *(args[2]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> and <replace> as arguments.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->req_exp, preg, ACT_REPLACE, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "reqidel")) { /* delete request header from a regex ignoring case */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_REMOVE, NULL);
+ }
+ else if (!strcmp(args[0], "reqideny")) { /* deny a request if a header matches this regex ignoring case */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_DENY, NULL);
+ }
+ else if (!strcmp(args[0], "reqipass")) { /* pass this header without allowing or denying the request */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_PASS, NULL);
+ }
+ else if (!strcmp(args[0], "reqiallow")) { /* allow a request if a header matches this regex ignoring case */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <regex> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ chain_regex(&curproxy->req_exp, preg, ACT_ALLOW, NULL);
+ }
+ else if (!strcmp(args[0], "reqadd")) { /* add request header */
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (curproxy->nb_reqadd >= MAX_NEWHDR) {
+ Alert("parsing [%s:%d] : too many '%s'. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <header> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ curproxy->req_add[curproxy->nb_reqadd++] = strdup(args[1]);
+ }
+ else if (!strcmp(args[0], "srvexp") || !strcmp(args[0], "rsprep")) { /* replace response header from a regex */
+ regex_t *preg;
+
+ if (*(args[1]) == 0 || *(args[2]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> and <replace> as arguments.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->rsp_exp, preg, ACT_REPLACE, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "rspdel")) { /* delete response header from a regex */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->rsp_exp, preg, ACT_REMOVE, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "rspdeny")) { /* block response header from a regex */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->rsp_exp, preg, ACT_DENY, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "rspirep")) { /* replace response header from a regex ignoring case */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0 || *(args[2]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> and <replace> as arguments.\n",
+ file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->rsp_exp, preg, ACT_REPLACE, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "rspidel")) { /* delete response header from a regex ignoring case */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->rsp_exp, preg, ACT_REMOVE, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "rspideny")) { /* block response header from a regex ignoring case */
+ regex_t *preg;
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <search> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ preg = calloc(1, sizeof(regex_t));
+ if (regcomp(preg, args[1], REG_EXTENDED | REG_ICASE) != 0) {
+ Alert("parsing [%s:%d] : bad regular expression '%s'.\n", file, linenum, args[1]);
+ return -1;
+ }
+
+ err = chain_regex(&curproxy->rsp_exp, preg, ACT_DENY, strdup(args[2]));
+ if (err) {
+ Alert("parsing [%s:%d] : invalid character or unterminated sequence in replacement string near '%c'.\n",
+ file, linenum, *err);
+ return -1;
+ }
+ }
+ else if (!strcmp(args[0], "rspadd")) { /* add response header */
+ if (curproxy == &defproxy) {
+ Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ if (curproxy->nb_rspadd >= MAX_NEWHDR) {
+ Alert("parsing [%s:%d] : too many '%s'. Continuing.\n", file, linenum, args[0]);
+ return 0;
+ }
+
+ if (*(args[1]) == 0) {
+ Alert("parsing [%s:%d] : '%s' expects <header> as an argument.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+ curproxy->rsp_add[curproxy->nb_rspadd++] = strdup(args[1]);
+ }
+ else if (!strcmp(args[0], "errorloc") ||
+ !strcmp(args[0], "errorloc302") ||
+ !strcmp(args[0], "errorloc303")) { /* error location */
+ int errnum, errlen;
+ char *err;
+
+ // if (curproxy == &defproxy) {
+ // Alert("parsing [%s:%d] : '%s' not allowed in 'defaults' section.\n", file, linenum, args[0]);
+ // return -1;
+ // }
+
+ if (*(args[2]) == 0) {
+ Alert("parsing [%s:%d] : <errorloc> expects <error> and <url> as arguments.\n", file, linenum);
+ return -1;
+ }
+
+ errnum = atol(args[1]);
+ if (!strcmp(args[0], "errorloc303")) {
+ err = malloc(strlen(HTTP_303) + strlen(args[2]) + 5);
+ errlen = sprintf(err, "%s%s\r\n\r\n", HTTP_303, args[2]);
+ } else {
+ err = malloc(strlen(HTTP_302) + strlen(args[2]) + 5);
+ errlen = sprintf(err, "%s%s\r\n\r\n", HTTP_302, args[2]);
+ }
+
+ if (errnum == 400) {
+ if (curproxy->errmsg.msg400) {
+ //Warning("parsing [%s:%d] : error %d already defined.\n", file, linenum, errnum);
+ free(curproxy->errmsg.msg400);
+ }
+ curproxy->errmsg.msg400 = err;
+ curproxy->errmsg.len400 = errlen;
+ }
+ else if (errnum == 403) {
+ if (curproxy->errmsg.msg403) {
+ //Warning("parsing [%s:%d] : error %d already defined.\n", file, linenum, errnum);
+ free(curproxy->errmsg.msg403);
+ }
+ curproxy->errmsg.msg403 = err;
+ curproxy->errmsg.len403 = errlen;
+ }
+ else if (errnum == 408) {
+ if (curproxy->errmsg.msg408) {
+ //Warning("parsing [%s:%d] : error %d already defined.\n", file, linenum, errnum);
+ free(curproxy->errmsg.msg408);
+ }
+ curproxy->errmsg.msg408 = err;
+ curproxy->errmsg.len408 = errlen;
+ }
+ else if (errnum == 500) {
+ if (curproxy->errmsg.msg500) {
+ //Warning("parsing [%s:%d] : error %d already defined.\n", file, linenum, errnum);
+ free(curproxy->errmsg.msg500);
+ }
+ curproxy->errmsg.msg500 = err;
+ curproxy->errmsg.len500 = errlen;
+ }
+ else if (errnum == 502) {
+ if (curproxy->errmsg.msg502) {
+ //Warning("parsing [%s:%d] : error %d already defined.\n", file, linenum, errnum);
+ free(curproxy->errmsg.msg502);
+ }
+ curproxy->errmsg.msg502 = err;
+ curproxy->errmsg.len502 = errlen;
+ }
+ else if (errnum == 503) {
+ if (curproxy->errmsg.msg503) {
+ //Warning("parsing [%s:%d] : error %d already defined.\n", file, linenum, errnum);
+ free(curproxy->errmsg.msg503);
+ }
+ curproxy->errmsg.msg503 = err;
+ curproxy->errmsg.len503 = errlen;
+ }
+ else if (errnum == 504) {
+ if (curproxy->errmsg.msg504) {
+ //Warning("parsing [%s:%d] : error %d already defined.\n", file, linenum, errnum);
+ free(curproxy->errmsg.msg504);
+ }
+ curproxy->errmsg.msg504 = err;
+ curproxy->errmsg.len504 = errlen;
+ }
+ else {
+ Warning("parsing [%s:%d] : error %d relocation will be ignored.\n", file, linenum, errnum);
+ free(err);
+ }
+ }
+ else {
+ Alert("parsing [%s:%d] : unknown keyword '%s' in '%s' section\n", file, linenum, args[0], "listen");
+ return -1;
+ }
+ return 0;
+}
+
+
+/*
+ * This function reads and parses the configuration file given in the argument.
+ * returns 0 if OK, -1 if error.
+ */
+int readcfgfile(char *file)
+{
+ char thisline[256];
+ char *line;
+ FILE *f;
+ int linenum = 0;
+ char *end;
+ char *args[MAX_LINE_ARGS];
+ int arg;
+ int cfgerr = 0;
+ int nbchk, mininter;
+ int confsect = CFG_NONE;
+
+ struct proxy *curproxy = NULL;
+ struct server *newsrv = NULL;
+
+ if ((f=fopen(file,"r")) == NULL)
+ return -1;
+
+ init_default_instance();
+
+ while (fgets(line = thisline, sizeof(thisline), f) != NULL) {
+ linenum++;
+
+ end = line + strlen(line);
+
+ /* skip leading spaces */
+ while (isspace((int)*line))
+ line++;
+
+ arg = 0;
+ args[arg] = line;
+
+ while (*line && arg < MAX_LINE_ARGS) {
+ /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
+ * C equivalent value. Other combinations left unchanged (eg: \1).
+ */
+ if (*line == '\\') {
+ int skip = 0;
+ if (line[1] == ' ' || line[1] == '\\' || line[1] == '#') {
+ *line = line[1];
+ skip = 1;
+ }
+ else if (line[1] == 'r') {
+ *line = '\r';
+ skip = 1;
+ }
+ else if (line[1] == 'n') {
+ *line = '\n';
+ skip = 1;
+ }
+ else if (line[1] == 't') {
+ *line = '\t';
+ skip = 1;
+ }
+ else if (line[1] == 'x') {
+ if ((line + 3 < end ) && ishex(line[2]) && ishex(line[3])) {
+ unsigned char hex1, hex2;
+ hex1 = toupper(line[2]) - '0';
+ hex2 = toupper(line[3]) - '0';
+ if (hex1 > 9) hex1 -= 'A' - '9' - 1;
+ if (hex2 > 9) hex2 -= 'A' - '9' - 1;
+ *line = (hex1<<4) + hex2;
+ skip = 3;
+ }
+ else {
+ Alert("parsing [%s:%d] : invalid or incomplete '\\x' sequence in '%s'.\n", file, linenum, args[0]);
+ return -1;
+ }
+ }
+ if (skip) {
+ memmove(line + 1, line + 1 + skip, end - (line + skip + 1));
+ end -= skip;
+ }
+ line++;
+ }
+ else if (*line == '#' || *line == '\n' || *line == '\r') {
+ /* end of string, end of loop */
+ *line = 0;
+ break;
+ }
+ else if (isspace((int)*line)) {
+ /* a non-escaped space is an argument separator */
+ *line++ = 0;
+ while (isspace((int)*line))
+ line++;
+ args[++arg] = line;
+ }
+ else {
+ line++;
+ }
+ }
+
+ /* empty line */
+ if (!**args)
+ continue;
+
+ /* zero out remaining args */
+ while (++arg < MAX_LINE_ARGS) {
+ args[arg] = line;
+ }
+
+ if (!strcmp(args[0], "listen") || !strcmp(args[0], "defaults")) /* new proxy */
+ confsect = CFG_LISTEN;
+ else if (!strcmp(args[0], "global")) /* global config */
+ confsect = CFG_GLOBAL;
+ /* else it's a section keyword */
+
+ switch (confsect) {
+ case CFG_LISTEN:
+ if (cfg_parse_listen(file, linenum, args) < 0)
+ return -1;
+ break;
+ case CFG_GLOBAL:
+ if (cfg_parse_global(file, linenum, args) < 0)
+ return -1;
+ break;
+ default:
+ Alert("parsing [%s:%d] : unknown keyword '%s' out of section.\n", file, linenum, args[0]);
+ return -1;
+ }
+
+
+ }
+ fclose(f);
+
+ /*
+ * Now, check for the integrity of all that we have collected.
+ */
+
+ /* will be needed further to delay some tasks */
+ tv_now(&now);
+
+ if ((curproxy = proxy) == NULL) {
+ Alert("parsing %s : no <listen> line. Nothing to do !\n",
+ file);
+ return -1;
+ }
+
+ while (curproxy != NULL) {
+ if (curproxy->state == PR_STSTOPPED) {
+ curproxy = curproxy->next;
+ continue;
+ }
+
+ if (curproxy->listen == NULL) {
+ Alert("parsing %s : listener %s has no listen address. Please either specify a valid address on the <listen> line, or use the <bind> keyword.\n", file, curproxy->id);
+ cfgerr++;
+ }
+ else if ((curproxy->mode != PR_MODE_HEALTH) &&
+ !(curproxy->options & (PR_O_TRANSP | PR_O_BALANCE)) &&
+ (*(int *)&curproxy->dispatch_addr.sin_addr == 0)) {
+ Alert("parsing %s : listener %s has no dispatch address and is not in transparent or balance mode.\n",
+ file, curproxy->id);
+ cfgerr++;
+ }
+ else if ((curproxy->mode != PR_MODE_HEALTH) && (curproxy->options & PR_O_BALANCE)) {
+ if (curproxy->options & PR_O_TRANSP) {
+ Alert("parsing %s : listener %s cannot use both transparent and balance mode.\n",
+ file, curproxy->id);
+ cfgerr++;
+ }
+#ifdef WE_DONT_SUPPORT_SERVERLESS_LISTENERS
+ else if (curproxy->srv == NULL) {
+ Alert("parsing %s : listener %s needs at least 1 server in balance mode.\n",
+ file, curproxy->id);
+ cfgerr++;
+ }
+#endif
+ else if (*(int *)&curproxy->dispatch_addr.sin_addr != 0) {
+ Warning("parsing %s : dispatch address of listener %s will be ignored in balance mode.\n",
+ file, curproxy->id);
+ }
+ }
+ else if (curproxy->mode == PR_MODE_TCP || curproxy->mode == PR_MODE_HEALTH) { /* TCP PROXY or HEALTH CHECK */
+ if (curproxy->cookie_name != NULL) {
+ Warning("parsing %s : cookie will be ignored for listener %s.\n",
+ file, curproxy->id);
+ }
+ if ((newsrv = curproxy->srv) != NULL) {
+ Warning("parsing %s : servers will be ignored for listener %s.\n",
+ file, curproxy->id);
+ }
+ if (curproxy->rsp_exp != NULL) {
+ Warning("parsing %s : server regular expressions will be ignored for listener %s.\n",
+ file, curproxy->id);
+ }
+ if (curproxy->req_exp != NULL) {
+ Warning("parsing %s : client regular expressions will be ignored for listener %s.\n",
+ file, curproxy->id);
+ }
+ }
+ else if (curproxy->mode == PR_MODE_HTTP) { /* HTTP PROXY */
+ if ((curproxy->cookie_name != NULL) && ((newsrv = curproxy->srv) == NULL)) {
+ Alert("parsing %s : HTTP proxy %s has a cookie but no server list !\n",
+ file, curproxy->id);
+ cfgerr++;
+ }
+ }
+
+ /* first, we will invert the servers list order */
+ newsrv = NULL;
+ while (curproxy->srv) {
+ struct server *next;
+
+ next = curproxy->srv->next;
+ curproxy->srv->next = newsrv;
+ newsrv = curproxy->srv;
+ if (!next)
+ break;
+ curproxy->srv = next;
+ }
+
+ /* now, newsrv == curproxy->srv */
+ if (newsrv) {
+ struct server *srv;
+ int pgcd;
+ int act, bck;
+
+ /* We will factor the weights to reduce the table,
+ * using Euclide's largest common divisor algorithm
+ */
+ pgcd = newsrv->uweight + 1;
+ for (srv = newsrv->next; srv && pgcd > 1; srv = srv->next) {
+ int t, w;
+
+ w = srv->uweight + 1;
+ while (w) {
+ t = pgcd % w;
+ pgcd = w;
+ w = t;
+ }
+ }
+
+ act = bck = 0;
+ for (srv = newsrv; srv; srv = srv->next) {
+ srv->eweight = ((srv->uweight + 1) / pgcd) - 1;
+ if (srv->state & SRV_BACKUP)
+ bck += srv->eweight + 1;
+ else
+ act += srv->eweight + 1;
+ }
+
+ /* this is the largest map we will ever need for this servers list */
+ if (act < bck)
+ act = bck;
+
+ curproxy->srv_map = (struct server **)calloc(act, sizeof(struct server *));
+ /* recounts servers and their weights */
+ recount_servers(curproxy);
+ recalc_server_map(curproxy);
+ }
+
+ if (curproxy->options & PR_O_LOGASAP)
+ curproxy->to_log &= ~LW_BYTES;
+
+ if (curproxy->errmsg.msg400 == NULL) {
+ curproxy->errmsg.msg400 = (char *)HTTP_400;
+ curproxy->errmsg.len400 = strlen(HTTP_400);
+ }
+ if (curproxy->errmsg.msg403 == NULL) {
+ curproxy->errmsg.msg403 = (char *)HTTP_403;
+ curproxy->errmsg.len403 = strlen(HTTP_403);
+ }
+ if (curproxy->errmsg.msg408 == NULL) {
+ curproxy->errmsg.msg408 = (char *)HTTP_408;
+ curproxy->errmsg.len408 = strlen(HTTP_408);
+ }
+ if (curproxy->errmsg.msg500 == NULL) {
+ curproxy->errmsg.msg500 = (char *)HTTP_500;
+ curproxy->errmsg.len500 = strlen(HTTP_500);
+ }
+ if (curproxy->errmsg.msg502 == NULL) {
+ curproxy->errmsg.msg502 = (char *)HTTP_502;
+ curproxy->errmsg.len502 = strlen(HTTP_502);
+ }
+ if (curproxy->errmsg.msg503 == NULL) {
+ curproxy->errmsg.msg503 = (char *)HTTP_503;
+ curproxy->errmsg.len503 = strlen(HTTP_503);
+ }
+ if (curproxy->errmsg.msg504 == NULL) {
+ curproxy->errmsg.msg504 = (char *)HTTP_504;
+ curproxy->errmsg.len504 = strlen(HTTP_504);
+ }
+
+ /*
+ * If this server supports a maxconn parameter, it needs a dedicated
+ * tasks to fill the emptied slots when a connection leaves.
+ */
+ newsrv = curproxy->srv;
+ while (newsrv != NULL) {
+ if (newsrv->minconn >= newsrv->maxconn) {
+ /* Only 'minconn' was specified, or it was higher than or equal
+ * to 'maxconn'. Let's turn this into maxconn and clean it, as
+ * this will avoid further useless expensive computations.
+ */
+ newsrv->maxconn = newsrv->minconn;
+ newsrv->minconn = 0;
+ }
+
+ if (newsrv->maxconn > 0) {
+ struct task *t;
+
+ if ((t = pool_alloc(task)) == NULL) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+
+ t->next = t->prev = t->rqnext = NULL; /* task not in run queue yet */
+ t->wq = LIST_HEAD(wait_queue[1]); /* already assigned to the eternity queue */
+ t->state = TASK_IDLE;
+ t->process = process_srv_queue;
+ t->context = newsrv;
+ newsrv->queue_mgt = t;
+
+ /* never run it unless specifically woken up */
+ tv_eternity(&t->expire);
+ task_queue(t);
+ }
+ newsrv = newsrv->next;
+ }
+
+ /* now we'll start this proxy's health checks if any */
+ /* 1- count the checkers to run simultaneously */
+ nbchk = 0;
+ mininter = 0;
+ newsrv = curproxy->srv;
+ while (newsrv != NULL) {
+ if (newsrv->state & SRV_CHECKED) {
+ if (!mininter || mininter > newsrv->inter)
+ mininter = newsrv->inter;
+ nbchk++;
+ }
+ newsrv = newsrv->next;
+ }
+
+ /* 2- start them as far as possible from each others while respecting
+ * their own intervals. For this, we will start them after their own
+ * interval added to the min interval divided by the number of servers,
+ * weighted by the server's position in the list.
+ */
+ if (nbchk > 0) {
+ struct task *t;
+ int srvpos;
+
+ newsrv = curproxy->srv;
+ srvpos = 0;
+ while (newsrv != NULL) {
+ /* should this server be checked ? */
+ if (newsrv->state & SRV_CHECKED) {
+ if ((t = pool_alloc(task)) == NULL) {
+ Alert("parsing [%s:%d] : out of memory.\n", file, linenum);
+ return -1;
+ }
+
+ t->next = t->prev = t->rqnext = NULL; /* task not in run queue yet */
+ t->wq = LIST_HEAD(wait_queue[0]); /* but already has a wait queue assigned */
+ t->state = TASK_IDLE;
+ t->process = process_chk;
+ t->context = newsrv;
+
+ /* check this every ms */
+ tv_delayfrom(&t->expire, &now,
+ newsrv->inter + mininter * srvpos / nbchk);
+ task_queue(t);
+ //task_wakeup(&rq, t);
+ srvpos++;
+ }
+ newsrv = newsrv->next;
+ }
+ }
+
+ curproxy = curproxy->next;
+ }
+ if (cfgerr > 0) {
+ Alert("Errors found in configuration file, aborting.\n");
+ return -1;
+ }
+ else
+ return 0;
+}
+
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/checks.c b/src/checks.c
new file mode 100644
index 0000000..8fd3e8e
--- /dev/null
+++ b/src/checks.c
@@ -0,0 +1,393 @@
+/*
+ * Health-checks functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <haproxy/compat.h>
+#include <haproxy/config.h>
+#include <haproxy/mini-clist.h>
+#include <haproxy/time.h>
+
+#include <types/global.h>
+#include <types/polling.h>
+#include <types/proxy.h>
+#include <types/session.h>
+
+#include <proto/backend.h>
+#include <proto/fd.h>
+#include <proto/log.h>
+#include <proto/queue.h>
+#include <proto/server.h>
+#include <proto/task.h>
+
+
+/* Sets server <s> down, notifies by all available means, recounts the
+ * remaining servers on the proxy and transfers queued sessions whenever
+ * possible to other servers.
+ */
+void set_server_down(struct server *s)
+{
+ struct pendconn *pc, *pc_bck, *pc_end;
+ struct session *sess;
+ int xferred;
+
+ s->state &= ~SRV_RUNNING;
+
+ if (s->health == s->rise) {
+ recount_servers(s->proxy);
+ recalc_server_map(s->proxy);
+
+ /* we might have sessions queued on this server and waiting for
+ * a connection. Those which are redispatchable will be queued
+ * to another server or to the proxy itself.
+ */
+ xferred = 0;
+ FOREACH_ITEM_SAFE(pc, pc_bck, &s->pendconns, pc_end, struct pendconn *, list) {
+ sess = pc->sess;
+ if ((sess->proxy->options & PR_O_REDISP)) {
+ /* The REDISP option was specified. We will ignore
+ * cookie and force to balance or use the dispatcher.
+ */
+ sess->flags &= ~(SN_DIRECT | SN_ASSIGNED | SN_ADDR_SET);
+ sess->srv = NULL; /* it's left to the dispatcher to choose a server */
+ if ((sess->flags & SN_CK_MASK) == SN_CK_VALID) {
+ sess->flags &= ~SN_CK_MASK;
+ sess->flags |= SN_CK_DOWN;
+ }
+ pendconn_free(pc);
+ task_wakeup(&rq, sess->task);
+ xferred++;
+ }
+ }
+
+ sprintf(trash, "%sServer %s/%s is DOWN. %d active and %d backup servers left.%s"
+ " %d sessions active, %d requeued, %d remaining in queue.\n",
+ s->state & SRV_BACKUP ? "Backup " : "",
+ s->proxy->id, s->id, s->proxy->srv_act, s->proxy->srv_bck,
+ (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
+ s->cur_sess, xferred, s->nbpend);
+
+ Warning("%s", trash);
+ send_log(s->proxy, LOG_ALERT, "%s", trash);
+
+ if (s->proxy->srv_bck == 0 && s->proxy->srv_act == 0) {
+ Alert("Proxy %s has no server available !\n", s->proxy->id);
+ send_log(s->proxy, LOG_EMERG, "Proxy %s has no server available !\n", s->proxy->id);
+ }
+ s->down_trans++;
+ }
+ s->health = 0; /* failure */
+}
+
+
+/*
+ * This function is used only for server health-checks. It handles
+ * the connection acknowledgement. If the proxy requires HTTP health-checks,
+ * it sends the request. In other cases, it returns 1 if the socket is OK,
+ * or -1 if an error occured.
+ */
+int event_srv_chk_w(int fd)
+{
+ struct task *t = fdtab[fd].owner;
+ struct server *s = t->context;
+ int skerr;
+ socklen_t lskerr = sizeof(skerr);
+
+ skerr = 1;
+ if ((getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr) == -1)
+ || (skerr != 0)) {
+ /* in case of TCP only, this tells us if the connection failed */
+ s->result = -1;
+ fdtab[fd].state = FD_STERROR;
+ FD_CLR(fd, StaticWriteEvent);
+ }
+ else if (s->result != -1) {
+ /* we don't want to mark 'UP' a server on which we detected an error earlier */
+ if (s->proxy->options & PR_O_HTTP_CHK) {
+ int ret;
+ /* we want to check if this host replies to "OPTIONS / HTTP/1.0"
+ * so we'll send the request, and won't wake the checker up now.
+ */
+#ifndef MSG_NOSIGNAL
+ ret = send(fd, s->proxy->check_req, s->proxy->check_len, MSG_DONTWAIT);
+#else
+ ret = send(fd, s->proxy->check_req, s->proxy->check_len, MSG_DONTWAIT | MSG_NOSIGNAL);
+#endif
+ if (ret == s->proxy->check_len) {
+ FD_SET(fd, StaticReadEvent); /* prepare for reading reply */
+ FD_CLR(fd, StaticWriteEvent); /* nothing more to write */
+ return 0;
+ }
+ else {
+ s->result = -1;
+ FD_CLR(fd, StaticWriteEvent);
+ }
+ }
+ else {
+ /* good TCP connection is enough */
+ s->result = 1;
+ }
+ }
+
+ task_wakeup(&rq, t);
+ return 0;
+}
+
+
+/*
+ * This function is used only for server health-checks. It handles
+ * the server's reply to an HTTP request. It returns 1 if the server replies
+ * 2xx or 3xx (valid responses), or -1 in other cases.
+ */
+int event_srv_chk_r(int fd)
+{
+ char reply[64];
+ int len, result;
+ struct task *t = fdtab[fd].owner;
+ struct server *s = t->context;
+ int skerr;
+ socklen_t lskerr = sizeof(skerr);
+
+ result = len = -1;
+
+ getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
+ if (!skerr) {
+#ifndef MSG_NOSIGNAL
+ len = recv(fd, reply, sizeof(reply), 0);
+#else
+ /* Warning! Linux returns EAGAIN on SO_ERROR if data are still available
+ * but the connection was closed on the remote end. Fortunately, recv still
+ * works correctly and we don't need to do the getsockopt() on linux.
+ */
+ len = recv(fd, reply, sizeof(reply), MSG_NOSIGNAL);
+#endif
+
+ if ((len >= sizeof("HTTP/1.0 000")) &&
+ !memcmp(reply, "HTTP/1.", 7) &&
+ (reply[9] == '2' || reply[9] == '3')) /* 2xx or 3xx */
+ result = 1;
+ }
+
+ if (result == -1)
+ fdtab[fd].state = FD_STERROR;
+
+ if (s->result != -1)
+ s->result = result;
+
+ FD_CLR(fd, StaticReadEvent);
+ task_wakeup(&rq, t);
+ return 0;
+}
+
+/*
+ * manages a server health-check. Returns
+ * the time the task accepts to wait, or TIME_ETERNITY for infinity.
+ */
+int process_chk(struct task *t)
+{
+ struct server *s = t->context;
+ struct sockaddr_in sa;
+ int fd;
+
+ //fprintf(stderr, "process_chk: task=%p\n", t);
+
+ new_chk:
+ fd = s->curfd;
+ if (fd < 0) { /* no check currently running */
+ //fprintf(stderr, "process_chk: 2\n");
+ if (tv_cmp2_ms(&t->expire, &now) > 0) { /* not good time yet */
+ task_queue(t); /* restore t to its place in the task list */
+ return tv_remain2(&now, &t->expire);
+ }
+
+ /* we don't send any health-checks when the proxy is stopped or when
+ * the server should not be checked.
+ */
+ if (!(s->state & SRV_CHECKED) || s->proxy->state == PR_STSTOPPED) {
+ while (tv_cmp2_ms(&t->expire, &now) <= 0)
+ tv_delayfrom(&t->expire, &t->expire, s->inter);
+ task_queue(t); /* restore t to its place in the task list */
+ return tv_remain2(&now, &t->expire);
+ }
+
+ /* we'll initiate a new check */
+ s->result = 0; /* no result yet */
+ if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) != -1) {
+ if ((fd < global.maxsock) &&
+ (fcntl(fd, F_SETFL, O_NONBLOCK) != -1) &&
+ (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)) != -1)) {
+ //fprintf(stderr, "process_chk: 3\n");
+
+ /* we'll connect to the check port on the server */
+ sa = s->addr;
+ sa.sin_port = htons(s->check_port);
+
+ /* allow specific binding :
+ * - server-specific at first
+ * - proxy-specific next
+ */
+ if (s->state & SRV_BIND_SRC) {
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof(one));
+ if (bind(fd, (struct sockaddr *)&s->source_addr, sizeof(s->source_addr)) == -1) {
+ Alert("Cannot bind to source address before connect() for server %s/%s. Aborting.\n",
+ s->proxy->id, s->id);
+ s->result = -1;
+ }
+ }
+ else if (s->proxy->options & PR_O_BIND_SRC) {
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof(one));
+ if (bind(fd, (struct sockaddr *)&s->proxy->source_addr, sizeof(s->proxy->source_addr)) == -1) {
+ Alert("Cannot bind to source address before connect() for proxy %s. Aborting.\n",
+ s->proxy->id);
+ s->result = -1;
+ }
+ }
+
+ if (!s->result) {
+ if ((connect(fd, (struct sockaddr *)&sa, sizeof(sa)) != -1) || (errno == EINPROGRESS)) {
+ /* OK, connection in progress or established */
+
+ //fprintf(stderr, "process_chk: 4\n");
+
+ s->curfd = fd; /* that's how we know a test is in progress ;-) */
+ fdtab[fd].owner = t;
+ fdtab[fd].read = &event_srv_chk_r;
+ fdtab[fd].write = &event_srv_chk_w;
+ fdtab[fd].state = FD_STCONN; /* connection in progress */
+ FD_SET(fd, StaticWriteEvent); /* for connect status */
+#ifdef DEBUG_FULL
+ assert (!FD_ISSET(fd, StaticReadEvent));
+#endif
+ fd_insert(fd);
+ /* FIXME: we allow up to <inter> for a connection to establish, but we should use another parameter */
+ tv_delayfrom(&t->expire, &now, s->inter);
+ task_queue(t); /* restore t to its place in the task list */
+ return tv_remain(&now, &t->expire);
+ }
+ else if (errno != EALREADY && errno != EISCONN && errno != EAGAIN) {
+ s->result = -1; /* a real error */
+ }
+ }
+ }
+ close(fd); /* socket creation error */
+ }
+
+ if (!s->result) { /* nothing done */
+ //fprintf(stderr, "process_chk: 6\n");
+ while (tv_cmp2_ms(&t->expire, &now) <= 0)
+ tv_delayfrom(&t->expire, &t->expire, s->inter);
+ goto new_chk; /* may be we should initialize a new check */
+ }
+
+ /* here, we have seen a failure */
+ if (s->health > s->rise) {
+ s->health--; /* still good */
+ s->failed_checks++;
+ }
+ else
+ set_server_down(s);
+
+ //fprintf(stderr, "process_chk: 7\n");
+ /* FIXME: we allow up to <inter> for a connection to establish, but we should use another parameter */
+ while (tv_cmp2_ms(&t->expire, &now) <= 0)
+ tv_delayfrom(&t->expire, &t->expire, s->inter);
+ goto new_chk;
+ }
+ else {
+ //fprintf(stderr, "process_chk: 8\n");
+ /* there was a test running */
+ if (s->result > 0) { /* good server detected */
+ //fprintf(stderr, "process_chk: 9\n");
+ s->health++; /* was bad, stays for a while */
+ if (s->health >= s->rise) {
+ s->state |= SRV_RUNNING;
+
+ if (s->health == s->rise) {
+ int xferred;
+
+ recount_servers(s->proxy);
+ recalc_server_map(s->proxy);
+
+ /* check if we can handle some connections queued at the proxy. We
+ * will take as many as we can handle.
+ */
+ for (xferred = 0; !s->maxconn || xferred < srv_dynamic_maxconn(s); xferred++) {
+ struct session *sess;
+ struct pendconn *p;
+
+ p = pendconn_from_px(s->proxy);
+ if (!p)
+ break;
+ p->sess->srv = s;
+ sess = p->sess;
+ pendconn_free(p);
+ task_wakeup(&rq, sess->task);
+ }
+
+ sprintf(trash,
+ "%sServer %s/%s is UP. %d active and %d backup servers online.%s"
+ " %d sessions requeued, %d total in queue.\n",
+ s->state & SRV_BACKUP ? "Backup " : "",
+ s->proxy->id, s->id, s->proxy->srv_act, s->proxy->srv_bck,
+ (s->proxy->srv_bck && !s->proxy->srv_act) ? " Running on backup." : "",
+ xferred, s->nbpend);
+
+ Warning("%s", trash);
+ send_log(s->proxy, LOG_NOTICE, "%s", trash);
+ }
+
+ s->health = s->rise + s->fall - 1; /* OK now */
+ }
+ s->curfd = -1; /* no check running anymore */
+ //FD_CLR(fd, StaticWriteEvent);
+ fd_delete(fd);
+ while (tv_cmp2_ms(&t->expire, &now) <= 0)
+ tv_delayfrom(&t->expire, &t->expire, s->inter);
+ goto new_chk;
+ }
+ else if (s->result < 0 || tv_cmp2_ms(&t->expire, &now) <= 0) {
+ //fprintf(stderr, "process_chk: 10\n");
+ /* failure or timeout detected */
+ if (s->health > s->rise) {
+ s->health--; /* still good */
+ s->failed_checks++;
+ }
+ else
+ set_server_down(s);
+ s->curfd = -1;
+ //FD_CLR(fd, StaticWriteEvent);
+ fd_delete(fd);
+ while (tv_cmp2_ms(&t->expire, &now) <= 0)
+ tv_delayfrom(&t->expire, &t->expire, s->inter);
+ goto new_chk;
+ }
+ /* if result is 0 and there's no timeout, we have to wait again */
+ }
+ //fprintf(stderr, "process_chk: 11\n");
+ s->result = 0;
+ task_queue(t); /* restore t to its place in the task list */
+ return tv_remain2(&now, &t->expire);
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/chtbl.c b/src/chtbl.c
index 481b3ac..c8e794f 100644
--- a/src/chtbl.c
+++ b/src/chtbl.c
@@ -18,8 +18,8 @@
#include <stdlib.h>
#include <string.h>
-#include <include/list.h>
-#include <include/chtbl.h>
+#include <haproxy/list.h>
+#include <haproxy/chtbl.h>
/*****************************************************************************
* *
@@ -30,47 +30,47 @@
int chtbl_init(CHTbl *htbl, int buckets, int (*h)(const void *key), int
(*match)(const void *key1, const void *key2), void (*destroy)(void*data)) {
- int i;
+ int i;
- /*****************************************************************************
- * *
- * Allocate space for the hash table. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Allocate space for the hash table. *
+ * *
+ *****************************************************************************/
- if ((htbl->table = (List *)malloc(buckets * sizeof(List))) == NULL)
- return -1;
+ if ((htbl->table = (List *)malloc(buckets * sizeof(List))) == NULL)
+ return -1;
- /*****************************************************************************
- * *
- * Initialize the buckets. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Initialize the buckets. *
+ * *
+ *****************************************************************************/
- htbl->buckets = buckets;
+ htbl->buckets = buckets;
- for (i = 0; i < htbl->buckets; i++)
- list_init(&htbl->table[i], destroy);
+ for (i = 0; i < htbl->buckets; i++)
+ list_init(&htbl->table[i], destroy);
- /*****************************************************************************
- * *
- * Encapsulate the functions. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Encapsulate the functions. *
+ * *
+ *****************************************************************************/
- htbl->h = h;
- htbl->match = match;
- htbl->destroy = destroy;
+ htbl->h = h;
+ htbl->match = match;
+ htbl->destroy = destroy;
- /*****************************************************************************
- * *
- * Initialize the number of elements in the table. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Initialize the number of elements in the table. *
+ * *
+ *****************************************************************************/
- htbl->size = 0;
+ htbl->size = 0;
- return 0;
+ return 0;
} /* end chtbl_init () */
/*****************************************************************************
@@ -81,35 +81,35 @@
void chtbl_destroy(CHTbl *htbl) {
- int i;
+ int i;
- /*****************************************************************************
- * *
- * Destroy each bucket. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Destroy each bucket. *
+ * *
+ *****************************************************************************/
- for (i = 0; i < htbl->buckets; i++) {
- list_destroy(&htbl->table[i]);
- } /* end for () */
+ for (i = 0; i < htbl->buckets; i++) {
+ list_destroy(&htbl->table[i]);
+ } /* end for () */
- /*****************************************************************************
- * *
- * Free the storage allocated for the hash table. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Free the storage allocated for the hash table. *
+ * *
+ *****************************************************************************/
- free(htbl->table);
+ free(htbl->table);
- /*****************************************************************************
- * *
- * No operations are allowed now, but clear the structure as a precaution. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * No operations are allowed now, but clear the structure as a precaution. *
+ * *
+ *****************************************************************************/
- memset(htbl, 0, sizeof(CHTbl));
+ memset(htbl, 0, sizeof(CHTbl));
- return;
+ return;
} /* end chtbl_destroy() */
/*****************************************************************************
@@ -120,38 +120,38 @@
int chtbl_insert(CHTbl *htbl, const void *data) {
- void *temp;
- int bucket,retval;
+ void *temp;
+ int bucket,retval;
- /*****************************************************************************
- * *
- * Do nothing if the data is already in the table. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Do nothing if the data is already in the table. *
+ * *
+ *****************************************************************************/
- temp = (void *)data;
+ temp = (void *)data;
- if (chtbl_lookup(htbl, &temp) == 0)
- return 1;
+ if (chtbl_lookup(htbl, &temp) == 0)
+ return 1;
- /*****************************************************************************
- * *
- * Hash the key. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Hash the key. *
+ * *
+ *****************************************************************************/
- bucket = htbl->h(data) % htbl->buckets;
+ bucket = htbl->h(data) % htbl->buckets;
- /*****************************************************************************
- * *
- * Insert the data into the bucket. *
- * *
- *****************************************************************************/
+ /*****************************************************************************
+ * *
+ * Insert the data into the bucket. *
+ * *
+ *****************************************************************************/
- if ((retval = list_ins_next(&htbl->table[bucket], NULL, data)) == 0)
- htbl->size++;
+ if ((retval = list_ins_next(&htbl->table[bucket], NULL, data)) == 0)
+ htbl->size++;
- return retval;
+ return retval;
} /* end chtbl_insert() */
/*****************************************************************************
@@ -162,53 +162,54 @@
int chtbl_remove(CHTbl *htbl, void **data) {
- ListElmt *element, *prev;
- int bucket;
+ ListElmt *element, *prev;
+ int bucket;
- /*****************************************************************************
- * *
- * Hash the key. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Hash the key. *
+ * *
+ *********************************************************************/
- bucket = htbl->h(*data) % htbl->buckets;
+ bucket = htbl->h(*data) % htbl->buckets;
- /*****************************************************************************
- * *
- * Search for the data in the bucket. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Search for the data in the bucket. *
+ * *
+ *********************************************************************/
- prev = NULL;
+ prev = NULL;
- for (element = list_head(&htbl->table[bucket]); element != NULL; element = list_next(element)) {
- if (htbl->match(*data, list_data(element))) {
+ for (element = list_head(&htbl->table[bucket]);
+ element != NULL; element = list_next(element)) {
+ if (htbl->match(*data, list_data(element))) {
- /***********************************************************************
- * *
- * Remove the data from the bucket. *
- * *
- ***********************************************************************/
+ /*****************************************************
+ * *
+ * Remove the data from the bucket. *
+ * *
+ *****************************************************/
- if (list_rem_next(&htbl->table[bucket], prev, data) == 0) {
- htbl->size--;
- return 0;
- } /* end if() */
- else {
- return -1;
- }/* end else */
- }/* end if (htbl->match(*data, list_data(element))) */
+ if (list_rem_next(&htbl->table[bucket], prev, data) == 0) {
+ htbl->size--;
+ return 0;
+ } /* end if() */
+ else {
+ return -1;
+ }/* end else */
+ }/* end if (htbl->match(*data, list_data(element))) */
- prev = element;
- }/* end for() */
+ prev = element;
+ }/* end for() */
- /*****************************************************************************
- * *
- * Return that the data was not found. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Return that the data was not found. *
+ * *
+ *********************************************************************/
- return -1;
+ return -1;
} /* end int chtbl_remove(CHTbl *htbl, void **data) */
/*****************************************************************************
@@ -219,42 +220,50 @@
int chtbl_lookup(const CHTbl *htbl, void **data) {
- ListElmt *element;
- int bucket;
+ ListElmt *element;
+ int bucket;
- /*****************************************************************************
- * *
- * Hash the key. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Hash the key. *
+ * *
+ *********************************************************************/
- bucket = htbl->h(*data) % htbl->buckets;
+ bucket = htbl->h(*data) % htbl->buckets;
- /*****************************************************************************
- * *
- * Search for the data in the bucket. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Search for the data in the bucket. *
+ * *
+ *********************************************************************/
- for (element = list_head(&htbl->table[bucket]); element != NULL; element = list_next(element)) {
- if (htbl->match(*data, list_data(element))) {
+ for (element = list_head(&htbl->table[bucket]);
+ element != NULL; element = list_next(element)) {
+ if (htbl->match(*data, list_data(element))) {
- /***********************************************************************
- * *
- * Pass back the data from the table. *
- * *
- ***********************************************************************/
+ /*****************************************************
+ * *
+ * Pass back the data from the table. *
+ * *
+ *****************************************************/
- *data = list_data(element);
- return 0;
- }/* end if() */
- }/* end for() */
+ *data = list_data(element);
+ return 0;
+ }/* end if() */
+ }/* end for() */
- /*****************************************************************************
- * *
- * Return that the data was not found. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Return that the data was not found. *
+ * *
+ *********************************************************************/
- return -1;
+ return -1;
} /* end chtbl_lookup() */
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/client.c b/src/client.c
new file mode 100644
index 0000000..d42e8aa
--- /dev/null
+++ b/src/client.c
@@ -0,0 +1,397 @@
+/*
+ * Client-side variables and functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <haproxy/compat.h>
+#include <haproxy/time.h>
+
+#include <types/backend.h>
+#include <types/buffers.h>
+#include <types/global.h>
+#include <types/httperr.h>
+#include <types/polling.h>
+#include <types/proxy.h>
+#include <types/server.h>
+#include <types/session.h>
+
+#include <proto/client.h>
+#include <proto/fd.h>
+#include <proto/log.h>
+#include <proto/proto_http.h>
+#include <proto/stream_sock.h>
+#include <proto/task.h>
+
+
+
+/*
+ * FIXME: This should move to the STREAM_SOCK code then split into TCP and HTTP.
+ */
+
+/*
+ * this function is called on a read event from a listen socket, corresponding
+ * to an accept. It tries to accept as many connections as possible.
+ * It returns 0.
+ */
+int event_accept(int fd) {
+ struct proxy *p = (struct proxy *)fdtab[fd].owner;
+ struct session *s;
+ struct task *t;
+ int cfd;
+ int max_accept;
+
+ if (global.nbproc > 1)
+ max_accept = 8; /* let other processes catch some connections too */
+ else
+ max_accept = -1;
+
+ while (p->nbconn < p->maxconn && max_accept--) {
+ struct sockaddr_storage addr;
+ socklen_t laddr = sizeof(addr);
+
+ if ((cfd = accept(fd, (struct sockaddr *)&addr, &laddr)) == -1) {
+ switch (errno) {
+ case EAGAIN:
+ case EINTR:
+ case ECONNABORTED:
+ return 0; /* nothing more to accept */
+ case ENFILE:
+ send_log(p, LOG_EMERG,
+ "Proxy %s reached system FD limit at %d. Please check system tunables.\n",
+ p->id, maxfd);
+ return 0;
+ case EMFILE:
+ send_log(p, LOG_EMERG,
+ "Proxy %s reached process FD limit at %d. Please check 'ulimit-n' and restart.\n",
+ p->id, maxfd);
+ return 0;
+ case ENOBUFS:
+ case ENOMEM:
+ send_log(p, LOG_EMERG,
+ "Proxy %s reached system memory limit at %d sockets. Please check system tunables.\n",
+ p->id, maxfd);
+ return 0;
+ default:
+ return 0;
+ }
+ }
+
+ if ((s = pool_alloc(session)) == NULL) { /* disable this proxy for a while */
+ Alert("out of memory in event_accept().\n");
+ FD_CLR(fd, StaticReadEvent);
+ p->state = PR_STIDLE;
+ close(cfd);
+ return 0;
+ }
+
+ /* if this session comes from a known monitoring system, we want to ignore
+ * it as soon as possible, which means closing it immediately for TCP.
+ */
+ s->flags = 0;
+ if (addr.ss_family == AF_INET &&
+ p->mon_mask.s_addr &&
+ (((struct sockaddr_in *)&addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr) {
+ if (p->mode == PR_MODE_TCP) {
+ close(cfd);
+ pool_free(session, s);
+ continue;
+ }
+ s->flags |= SN_MONITOR;
+ }
+
+ if ((t = pool_alloc(task)) == NULL) { /* disable this proxy for a while */
+ Alert("out of memory in event_accept().\n");
+ FD_CLR(fd, StaticReadEvent);
+ p->state = PR_STIDLE;
+ close(cfd);
+ pool_free(session, s);
+ return 0;
+ }
+
+ s->cli_addr = addr;
+ if (cfd >= global.maxsock) {
+ Alert("accept(): not enough free sockets. Raise -n argument. Giving up.\n");
+ close(cfd);
+ pool_free(task, t);
+ pool_free(session, s);
+ return 0;
+ }
+
+ if ((fcntl(cfd, F_SETFL, O_NONBLOCK) == -1) ||
+ (setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY,
+ (char *) &one, sizeof(one)) == -1)) {
+ Alert("accept(): cannot set the socket in non blocking mode. Giving up\n");
+ close(cfd);
+ pool_free(task, t);
+ pool_free(session, s);
+ return 0;
+ }
+
+ if (p->options & PR_O_TCP_CLI_KA)
+ setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one));
+
+ t->next = t->prev = t->rqnext = NULL; /* task not in run queue yet */
+ t->wq = LIST_HEAD(wait_queue[0]); /* but already has a wait queue assigned */
+ t->state = TASK_IDLE;
+ t->process = process_session;
+ t->context = s;
+
+ s->task = t;
+ s->proxy = p;
+ s->cli_state = (p->mode == PR_MODE_HTTP) ? CL_STHEADERS : CL_STDATA; /* no HTTP headers for non-HTTP proxies */
+ s->srv_state = SV_STIDLE;
+ s->req = s->rep = NULL; /* will be allocated later */
+
+ s->res_cr = s->res_cw = s->res_sr = s->res_sw = RES_SILENT;
+ s->cli_fd = cfd;
+ s->srv_fd = -1;
+ s->req_line.len = -1;
+ s->auth_hdr.len = -1;
+ s->srv = NULL;
+ s->pend_pos = NULL;
+ s->conn_retries = p->conn_retries;
+
+ if (s->flags & SN_MONITOR)
+ s->logs.logwait = 0;
+ else
+ s->logs.logwait = p->to_log;
+
+ s->logs.tv_accept = now;
+ s->logs.t_request = -1;
+ s->logs.t_queue = -1;
+ s->logs.t_connect = -1;
+ s->logs.t_data = -1;
+ s->logs.t_close = 0;
+ s->logs.uri = NULL;
+ s->logs.cli_cookie = NULL;
+ s->logs.srv_cookie = NULL;
+ s->logs.status = -1;
+ s->logs.bytes = 0;
+ s->logs.prx_queue_size = 0; /* we get the number of pending conns before us */
+ s->logs.srv_queue_size = 0; /* we will get this number soon */
+
+ s->data_source = DATA_SRC_NONE;
+
+ s->uniq_id = totalconn;
+ p->cum_conn++;
+
+ if (p->nb_req_cap > 0) {
+ if ((s->req_cap =
+ pool_alloc_from(p->req_cap_pool, p->nb_req_cap*sizeof(char *)))
+ == NULL) { /* no memory */
+ close(cfd); /* nothing can be done for this fd without memory */
+ pool_free(task, t);
+ pool_free(session, s);
+ return 0;
+ }
+ memset(s->req_cap, 0, p->nb_req_cap*sizeof(char *));
+ }
+ else
+ s->req_cap = NULL;
+
+ if (p->nb_rsp_cap > 0) {
+ if ((s->rsp_cap =
+ pool_alloc_from(p->rsp_cap_pool, p->nb_rsp_cap*sizeof(char *)))
+ == NULL) { /* no memory */
+ if (s->req_cap != NULL)
+ pool_free_to(p->req_cap_pool, s->req_cap);
+ close(cfd); /* nothing can be done for this fd without memory */
+ pool_free(task, t);
+ pool_free(session, s);
+ return 0;
+ }
+ memset(s->rsp_cap, 0, p->nb_rsp_cap*sizeof(char *));
+ }
+ else
+ s->rsp_cap = NULL;
+
+ if ((p->mode == PR_MODE_TCP || p->mode == PR_MODE_HTTP)
+ && (p->logfac1 >= 0 || p->logfac2 >= 0)) {
+ struct sockaddr_storage sockname;
+ socklen_t namelen = sizeof(sockname);
+
+ if (addr.ss_family != AF_INET ||
+ !(s->proxy->options & PR_O_TRANSP) ||
+ get_original_dst(cfd, (struct sockaddr_in *)&sockname, &namelen) == -1)
+ getsockname(cfd, (struct sockaddr *)&sockname, &namelen);
+
+ if (p->to_log) {
+ /* we have the client ip */
+ if (s->logs.logwait & LW_CLIP)
+ if (!(s->logs.logwait &= ~LW_CLIP))
+ sess_log(s);
+ }
+ else if (s->cli_addr.ss_family == AF_INET) {
+ char pn[INET_ADDRSTRLEN], sn[INET_ADDRSTRLEN];
+ if (inet_ntop(AF_INET, (const void *)&((struct sockaddr_in *)&sockname)->sin_addr,
+ sn, sizeof(sn)) &&
+ inet_ntop(AF_INET, (const void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
+ pn, sizeof(pn))) {
+ send_log(p, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n",
+ pn, ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port),
+ sn, ntohs(((struct sockaddr_in *)&sockname)->sin_port),
+ p->id, (p->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
+ }
+ }
+ else {
+ char pn[INET6_ADDRSTRLEN], sn[INET6_ADDRSTRLEN];
+ if (inet_ntop(AF_INET6, (const void *)&((struct sockaddr_in6 *)&sockname)->sin6_addr,
+ sn, sizeof(sn)) &&
+ inet_ntop(AF_INET6, (const void *)&((struct sockaddr_in6 *)&s->cli_addr)->sin6_addr,
+ pn, sizeof(pn))) {
+ send_log(p, LOG_INFO, "Connect from %s:%d to %s:%d (%s/%s)\n",
+ pn, ntohs(((struct sockaddr_in6 *)&s->cli_addr)->sin6_port),
+ sn, ntohs(((struct sockaddr_in6 *)&sockname)->sin6_port),
+ p->id, (p->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");
+ }
+ }
+ }
+
+ if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
+ struct sockaddr_in sockname;
+ socklen_t namelen = sizeof(sockname);
+ int len;
+ if (addr.ss_family != AF_INET ||
+ !(s->proxy->options & PR_O_TRANSP) ||
+ get_original_dst(cfd, (struct sockaddr_in *)&sockname, &namelen) == -1)
+ getsockname(cfd, (struct sockaddr *)&sockname, &namelen);
+
+ if (s->cli_addr.ss_family == AF_INET) {
+ char pn[INET_ADDRSTRLEN];
+ inet_ntop(AF_INET,
+ (const void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
+ pn, sizeof(pn));
+
+ len = sprintf(trash, "%08x:%s.accept(%04x)=%04x from [%s:%d]\n",
+ s->uniq_id, p->id, (unsigned short)fd, (unsigned short)cfd,
+ pn, ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port));
+ }
+ else {
+ char pn[INET6_ADDRSTRLEN];
+ inet_ntop(AF_INET6,
+ (const void *)&((struct sockaddr_in6 *)(&s->cli_addr))->sin6_addr,
+ pn, sizeof(pn));
+
+ len = sprintf(trash, "%08x:%s.accept(%04x)=%04x from [%s:%d]\n",
+ s->uniq_id, p->id, (unsigned short)fd, (unsigned short)cfd,
+ pn, ntohs(((struct sockaddr_in6 *)(&s->cli_addr))->sin6_port));
+ }
+
+ write(1, trash, len);
+ }
+
+ if ((s->req = pool_alloc(buffer)) == NULL) { /* no memory */
+ if (s->rsp_cap != NULL)
+ pool_free_to(p->rsp_cap_pool, s->rsp_cap);
+ if (s->req_cap != NULL)
+ pool_free_to(p->req_cap_pool, s->req_cap);
+ close(cfd); /* nothing can be done for this fd without memory */
+ pool_free(task, t);
+ pool_free(session, s);
+ return 0;
+ }
+
+ s->req->l = 0;
+ s->req->total = 0;
+ s->req->h = s->req->r = s->req->lr = s->req->w = s->req->data; /* r and w will be reset further */
+ s->req->rlim = s->req->data + BUFSIZE;
+ if (s->cli_state == CL_STHEADERS) /* reserve some space for header rewriting */
+ s->req->rlim -= MAXREWRITE;
+
+ if ((s->rep = pool_alloc(buffer)) == NULL) { /* no memory */
+ pool_free(buffer, s->req);
+ if (s->rsp_cap != NULL)
+ pool_free_to(p->rsp_cap_pool, s->rsp_cap);
+ if (s->req_cap != NULL)
+ pool_free_to(p->req_cap_pool, s->req_cap);
+ close(cfd); /* nothing can be done for this fd without memory */
+ pool_free(task, t);
+ pool_free(session, s);
+ return 0;
+ }
+ s->rep->l = 0;
+ s->rep->total = 0;
+ s->rep->h = s->rep->r = s->rep->lr = s->rep->w = s->rep->rlim = s->rep->data;
+
+ fdtab[cfd].read = &event_cli_read;
+ fdtab[cfd].write = &event_cli_write;
+ fdtab[cfd].owner = t;
+ fdtab[cfd].state = FD_STREADY;
+
+ if ((p->mode == PR_MODE_HTTP && (s->flags & SN_MONITOR)) ||
+ (p->mode == PR_MODE_HEALTH && (p->options & PR_O_HTTP_CHK)))
+ /* Either we got a request from a monitoring system on an HTTP instance,
+ * or we're in health check mode with the 'httpchk' option enabled. In
+ * both cases, we return a fake "HTTP/1.0 200 OK" response and we exit.
+ */
+ client_retnclose(s, 19, "HTTP/1.0 200 OK\r\n\r\n"); /* forge a 200 response */
+ else if (p->mode == PR_MODE_HEALTH) { /* health check mode, no client reading */
+ client_retnclose(s, 3, "OK\n"); /* forge an "OK" response */
+ }
+ else {
+ FD_SET(cfd, StaticReadEvent);
+ }
+
+#if defined(DEBUG_FULL) && defined(ENABLE_EPOLL)
+ if (PrevReadEvent) {
+ assert(!(FD_ISSET(cfd, PrevReadEvent)));
+ assert(!(FD_ISSET(cfd, PrevWriteEvent)));
+ }
+#endif
+ fd_insert(cfd);
+
+ tv_eternity(&s->cnexpire);
+ tv_eternity(&s->srexpire);
+ tv_eternity(&s->swexpire);
+ tv_eternity(&s->crexpire);
+ tv_eternity(&s->cwexpire);
+
+ if (s->proxy->clitimeout) {
+ if (FD_ISSET(cfd, StaticReadEvent))
+ tv_delayfrom(&s->crexpire, &now, s->proxy->clitimeout);
+ if (FD_ISSET(cfd, StaticWriteEvent))
+ tv_delayfrom(&s->cwexpire, &now, s->proxy->clitimeout);
+ }
+
+ tv_min(&t->expire, &s->crexpire, &s->cwexpire);
+
+ task_queue(t);
+
+ if (p->mode != PR_MODE_HEALTH)
+ task_wakeup(&rq, t);
+
+ p->nbconn++;
+ if (p->nbconn > p->nbconn_max)
+ p->nbconn_max = p->nbconn;
+ actconn++;
+ totalconn++;
+
+ // fprintf(stderr, "accepting from %p => %d conn, %d total, task=%p\n", p, actconn, totalconn, t);
+ } /* end of while (p->nbconn < p->maxconn) */
+ return 0;
+}
+
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/fd.c b/src/fd.c
new file mode 100644
index 0000000..b7ff8ad
--- /dev/null
+++ b/src/fd.c
@@ -0,0 +1,503 @@
+/*
+ * File descriptors management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+/*
+ * FIXME:
+ * - we still use 'listeners' to check whether we want to stop or not.
+ * - the various pollers should be moved to other external files, possibly
+ * dynamic libs.
+ * - merge event_cli_read() and event_srv_read(). The difference is res_*,
+ * buffer (at the beginning) and timeouts (at the end).
+ * => event_tcp_read(). It may be called from event_accept().
+ * - extract the connect code from event_srv_write()
+ * => event_tcp_connect(). It must then call event_write().
+ * - merge the remaining event_cli_write() and event_srv_write()
+ * => single event_tcp_write(). Check buffer, fd_state, res*, and timeouts.
+ *
+ */
+
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <haproxy/compat.h>
+#include <haproxy/config.h>
+#include <haproxy/time.h>
+
+#include <types/fd.h>
+#include <types/global.h>
+
+#include <proto/polling.h>
+#include <proto/task.h>
+
+struct fdtab *fdtab = NULL; /* array of all the file descriptors */
+int maxfd; /* # of the highest fd + 1 */
+int totalconn; /* total # of terminated sessions */
+int actconn; /* # of active sessions */
+
+fd_set *StaticReadEvent, *StaticWriteEvent;
+int cfg_polling_mechanism = 0; /* POLL_USE_{SELECT|POLL|EPOLL} */
+
+
+/******************************
+ * pollers
+ ******************************/
+
+
+/*
+ * FIXME: this is dirty, but at the moment, there's no other solution to remove
+ * the old FDs from outside the loop. Perhaps we should export a global 'poll'
+ * structure with pointers to functions such as init_fd() and close_fd(), plus
+ * a private structure with several pointers to places such as below.
+ */
+
+#if defined(ENABLE_EPOLL)
+fd_set *PrevReadEvent = NULL, *PrevWriteEvent = NULL;
+
+#if defined(USE_MY_EPOLL)
+_syscall1 (int, epoll_create, int, size);
+_syscall4 (int, epoll_ctl, int, epfd, int, op, int, fd, struct epoll_event *, event);
+_syscall4 (int, epoll_wait, int, epfd, struct epoll_event *, events, int, maxevents, int, timeout);
+#endif
+
+/*
+ * Main epoll() loop.
+ * does 3 actions :
+ * 0 (POLL_LOOP_ACTION_INIT) : initializes necessary private structures
+ * 1 (POLL_LOOP_ACTION_RUN) : runs the loop
+ * 2 (POLL_LOOP_ACTION_CLEAN) : cleans up
+ *
+ * returns 0 if initialization failed, !0 otherwise.
+ */
+
+int epoll_loop(int action)
+{
+ int next_time;
+ int status;
+ int fd;
+
+ int fds, count;
+ int pr, pw, sr, sw;
+ unsigned rn, ro, wn, wo; /* read new, read old, write new, write old */
+ struct epoll_event ev;
+
+ /* private data */
+ static struct epoll_event *epoll_events = NULL;
+ static int epoll_fd;
+
+ if (action == POLL_LOOP_ACTION_INIT) {
+ epoll_fd = epoll_create(global.maxsock + 1);
+ if (epoll_fd < 0)
+ return 0;
+ else {
+ epoll_events = (struct epoll_event*)
+ calloc(1, sizeof(struct epoll_event) * global.maxsock);
+ PrevReadEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ PrevWriteEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ }
+ return 1;
+ }
+ else if (action == POLL_LOOP_ACTION_CLEAN) {
+ if (PrevWriteEvent) free(PrevWriteEvent);
+ if (PrevReadEvent) free(PrevReadEvent);
+ if (epoll_events) free(epoll_events);
+ close(epoll_fd);
+ epoll_fd = 0;
+ return 1;
+ }
+
+ /* OK, it's POLL_LOOP_ACTION_RUN */
+
+ tv_now(&now);
+
+ while (1) {
+ next_time = process_runnable_tasks();
+
+ /* stop when there's no connection left and we don't allow them anymore */
+ if (!actconn && listeners == 0)
+ break;
+
+ for (fds = 0; (fds << INTBITS) < maxfd; fds++) {
+
+ rn = ((int*)StaticReadEvent)[fds]; ro = ((int*)PrevReadEvent)[fds];
+ wn = ((int*)StaticWriteEvent)[fds]; wo = ((int*)PrevWriteEvent)[fds];
+
+ if ((ro^rn) | (wo^wn)) {
+ for (count = 0, fd = fds << INTBITS; count < (1<<INTBITS) && fd < maxfd; count++, fd++) {
+#define FDSETS_ARE_INT_ALIGNED
+#ifdef FDSETS_ARE_INT_ALIGNED
+
+#define WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+#ifdef WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+ pr = (ro >> count) & 1;
+ pw = (wo >> count) & 1;
+ sr = (rn >> count) & 1;
+ sw = (wn >> count) & 1;
+#else
+ pr = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&ro);
+ pw = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&wo);
+ sr = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&rn);
+ sw = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&wn);
+#endif
+#else
+ pr = FD_ISSET(fd, PrevReadEvent);
+ pw = FD_ISSET(fd, PrevWriteEvent);
+ sr = FD_ISSET(fd, StaticReadEvent);
+ sw = FD_ISSET(fd, StaticWriteEvent);
+#endif
+ if (!((sr^pr) | (sw^pw)))
+ continue;
+
+ ev.events = (sr ? EPOLLIN : 0) | (sw ? EPOLLOUT : 0);
+ ev.data.fd = fd;
+
+#ifdef EPOLL_CTL_MOD_WORKAROUND
+ /* I encountered a rarely reproducible problem with
+ * EPOLL_CTL_MOD where a modified FD (systematically
+ * the one in epoll_events[0], fd#7) would sometimes
+ * be set EPOLL_OUT while asked for a read ! This is
+ * with the 2.4 epoll patch. The workaround is to
+ * delete then recreate in case of modification.
+ * This is in 2.4 up to epoll-lt-0.21 but not in 2.6
+ * nor RHEL kernels.
+ */
+
+ if ((pr | pw) && fdtab[fd].state != FD_STCLOSE)
+ epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev);
+
+ if ((sr | sw))
+ epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);
+#else
+ if ((pr | pw)) {
+ /* the file-descriptor already exists... */
+ if ((sr | sw)) {
+ /* ...and it will still exist */
+ if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &ev) < 0) {
+ // perror("epoll_ctl(MOD)");
+ // exit(1);
+ }
+ } else {
+ /* ...and it will be removed */
+ if (fdtab[fd].state != FD_STCLOSE &&
+ epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev) < 0) {
+ // perror("epoll_ctl(DEL)");
+ // exit(1);
+ }
+ }
+ } else {
+ /* the file-descriptor did not exist, let's add it */
+ if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
+ // perror("epoll_ctl(ADD)");
+ // exit(1);
+ }
+ }
+#endif // EPOLL_CTL_MOD_WORKAROUND
+ }
+ ((int*)PrevReadEvent)[fds] = rn;
+ ((int*)PrevWriteEvent)[fds] = wn;
+ }
+ }
+
+ /* now let's wait for events */
+ status = epoll_wait(epoll_fd, epoll_events, maxfd, next_time);
+ tv_now(&now);
+
+ for (count = 0; count < status; count++) {
+ fd = epoll_events[count].data.fd;
+
+ if (FD_ISSET(fd, StaticReadEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (epoll_events[count].events & ( EPOLLIN | EPOLLERR | EPOLLHUP ))
+ fdtab[fd].read(fd);
+ }
+
+ if (FD_ISSET(fd, StaticWriteEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (epoll_events[count].events & ( EPOLLOUT | EPOLLERR | EPOLLHUP ))
+ fdtab[fd].write(fd);
+ }
+ }
+ }
+ return 1;
+}
+#endif
+
+
+
+#if defined(ENABLE_POLL)
+/*
+ * Main poll() loop.
+ * does 3 actions :
+ * 0 (POLL_LOOP_ACTION_INIT) : initializes necessary private structures
+ * 1 (POLL_LOOP_ACTION_RUN) : runs the loop
+ * 2 (POLL_LOOP_ACTION_CLEAN) : cleans up
+ *
+ * returns 0 if initialization failed, !0 otherwise.
+ */
+
+int poll_loop(int action)
+{
+ int next_time;
+ int status;
+ int fd, nbfd;
+
+ int fds, count;
+ int sr, sw;
+ unsigned rn, wn; /* read new, write new */
+
+ /* private data */
+ static struct pollfd *poll_events = NULL;
+
+ if (action == POLL_LOOP_ACTION_INIT) {
+ poll_events = (struct pollfd*)
+ calloc(1, sizeof(struct pollfd) * global.maxsock);
+ return 1;
+ }
+ else if (action == POLL_LOOP_ACTION_CLEAN) {
+ if (poll_events)
+ free(poll_events);
+ return 1;
+ }
+
+ /* OK, it's POLL_LOOP_ACTION_RUN */
+
+ tv_now(&now);
+
+ while (1) {
+ next_time = process_runnable_tasks();
+
+ /* stop when there's no connection left and we don't allow them anymore */
+ if (!actconn && listeners == 0)
+ break;
+
+ nbfd = 0;
+ for (fds = 0; (fds << INTBITS) < maxfd; fds++) {
+
+ rn = ((int*)StaticReadEvent)[fds];
+ wn = ((int*)StaticWriteEvent)[fds];
+
+ if ((rn|wn)) {
+ for (count = 0, fd = fds << INTBITS; count < (1<<INTBITS) && fd < maxfd; count++, fd++) {
+#define FDSETS_ARE_INT_ALIGNED
+#ifdef FDSETS_ARE_INT_ALIGNED
+
+#define WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+#ifdef WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+ sr = (rn >> count) & 1;
+ sw = (wn >> count) & 1;
+#else
+ sr = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&rn);
+ sw = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&wn);
+#endif
+#else
+ sr = FD_ISSET(fd, StaticReadEvent);
+ sw = FD_ISSET(fd, StaticWriteEvent);
+#endif
+ if ((sr|sw)) {
+ poll_events[nbfd].fd = fd;
+ poll_events[nbfd].events = (sr ? POLLIN : 0) | (sw ? POLLOUT : 0);
+ nbfd++;
+ }
+ }
+ }
+ }
+
+ /* now let's wait for events */
+ status = poll(poll_events, nbfd, next_time);
+ tv_now(&now);
+
+ for (count = 0; status > 0 && count < nbfd; count++) {
+ fd = poll_events[count].fd;
+
+ if (!(poll_events[count].revents & ( POLLOUT | POLLIN | POLLERR | POLLHUP )))
+ continue;
+
+ /* ok, we found one active fd */
+ status--;
+
+ if (FD_ISSET(fd, StaticReadEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (poll_events[count].revents & ( POLLIN | POLLERR | POLLHUP ))
+ fdtab[fd].read(fd);
+ }
+
+ if (FD_ISSET(fd, StaticWriteEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (poll_events[count].revents & ( POLLOUT | POLLERR | POLLHUP ))
+ fdtab[fd].write(fd);
+ }
+ }
+ }
+ return 1;
+}
+#endif
+
+
+
+/*
+ * Main select() loop.
+ * does 3 actions :
+ * 0 (POLL_LOOP_ACTION_INIT) : initializes necessary private structures
+ * 1 (POLL_LOOP_ACTION_RUN) : runs the loop
+ * 2 (POLL_LOOP_ACTION_CLEAN) : cleans up
+ *
+ * returns 0 if initialization failed, !0 otherwise.
+ */
+
+
+int select_loop(int action)
+{
+ int next_time;
+ int status;
+ int fd,i;
+ struct timeval delta;
+ int readnotnull, writenotnull;
+ static fd_set *ReadEvent = NULL, *WriteEvent = NULL;
+
+ if (action == POLL_LOOP_ACTION_INIT) {
+ ReadEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ WriteEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ return 1;
+ }
+ else if (action == POLL_LOOP_ACTION_CLEAN) {
+ if (WriteEvent) free(WriteEvent);
+ if (ReadEvent) free(ReadEvent);
+ return 1;
+ }
+
+ /* OK, it's POLL_LOOP_ACTION_RUN */
+
+ tv_now(&now);
+
+ while (1) {
+ next_time = process_runnable_tasks();
+
+ /* stop when there's no connection left and we don't allow them anymore */
+ if (!actconn && listeners == 0)
+ break;
+
+ if (next_time > 0) { /* FIXME */
+ /* Convert to timeval */
+ /* to avoid eventual select loops due to timer precision */
+ next_time += SCHEDULER_RESOLUTION;
+ delta.tv_sec = next_time / 1000;
+ delta.tv_usec = (next_time % 1000) * 1000;
+ }
+ else if (next_time == 0) { /* allow select to return immediately when needed */
+ delta.tv_sec = delta.tv_usec = 0;
+ }
+
+
+ /* let's restore fdset state */
+
+ readnotnull = 0; writenotnull = 0;
+ for (i = 0; i < (maxfd + FD_SETSIZE - 1)/(8*sizeof(int)); i++) {
+ readnotnull |= (*(((int*)ReadEvent)+i) = *(((int*)StaticReadEvent)+i)) != 0;
+ writenotnull |= (*(((int*)WriteEvent)+i) = *(((int*)StaticWriteEvent)+i)) != 0;
+ }
+
+ // /* just a verification code, needs to be removed for performance */
+ // for (i=0; i<maxfd; i++) {
+ // if (FD_ISSET(i, ReadEvent) != FD_ISSET(i, StaticReadEvent))
+ // abort();
+ // if (FD_ISSET(i, WriteEvent) != FD_ISSET(i, StaticWriteEvent))
+ // abort();
+ //
+ // }
+
+ status = select(maxfd,
+ readnotnull ? ReadEvent : NULL,
+ writenotnull ? WriteEvent : NULL,
+ NULL,
+ (next_time >= 0) ? &delta : NULL);
+
+ /* this is an experiment on the separation of the select work */
+ // status = (readnotnull ? select(maxfd, ReadEvent, NULL, NULL, (next_time >= 0) ? &delta : NULL) : 0);
+ // status |= (writenotnull ? select(maxfd, NULL, WriteEvent, NULL, (next_time >= 0) ? &delta : NULL) : 0);
+
+ tv_now(&now);
+
+ if (status > 0) { /* must proceed with events */
+
+ int fds;
+ char count;
+
+ for (fds = 0; (fds << INTBITS) < maxfd; fds++)
+ if ((((int *)(ReadEvent))[fds] | ((int *)(WriteEvent))[fds]) != 0)
+ for (count = 1<<INTBITS, fd = fds << INTBITS; count && fd < maxfd; count--, fd++) {
+
+ /* if we specify read first, the accepts and zero reads will be
+ * seen first. Moreover, system buffers will be flushed faster.
+ */
+ if (FD_ISSET(fd, ReadEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ fdtab[fd].read(fd);
+ }
+
+ if (FD_ISSET(fd, WriteEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ fdtab[fd].write(fd);
+ }
+ }
+ }
+ else {
+ // fprintf(stderr,"select returned %d, maxfd=%d\n", status, maxfd);
+ }
+ }
+ return 1;
+}
+
+
+
+/*********************
+ * generic functions
+ *********************/
+
+
+/* Deletes an FD from the fdsets, and recomputes the maxfd limit.
+ * The file descriptor is also closed.
+ */
+void fd_delete(int fd)
+{
+ FD_CLR(fd, StaticReadEvent);
+ FD_CLR(fd, StaticWriteEvent);
+#if defined(ENABLE_EPOLL)
+ if (PrevReadEvent) {
+ FD_CLR(fd, PrevReadEvent);
+ FD_CLR(fd, PrevWriteEvent);
+ }
+#endif
+
+ close(fd);
+ fdtab[fd].state = FD_STCLOSE;
+
+ while ((maxfd-1 >= 0) && (fdtab[maxfd-1].state == FD_STCLOSE))
+ maxfd--;
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/haproxy.c b/src/haproxy.c
new file mode 100644
index 0000000..e339a7b
--- /dev/null
+++ b/src/haproxy.c
@@ -0,0 +1,869 @@
+/*
+ * HA-Proxy : High Availability-enabled HTTP/TCP proxy
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Please refer to RFC2068 or RFC2616 for informations about HTTP protocol, and
+ * RFC2965 for informations about cookies usage. More generally, the IETF HTTP
+ * Working Group's web site should be consulted for protocol related changes :
+ *
+ * http://ftp.ics.uci.edu/pub/ietf/http/
+ *
+ * Pending bugs (may be not fixed because never reproduced) :
+ * - solaris only : sometimes, an HTTP proxy with only a dispatch address causes
+ * the proxy to terminate (no core) if the client breaks the connection during
+ * the response. Seen on 1.1.8pre4, but never reproduced. May not be related to
+ * the snprintf() bug since requests were simple (GET / HTTP/1.0), but may be
+ * related to missing setsid() (fixed in 1.1.15)
+ * - a proxy with an invalid config will prevent the startup even if disabled.
+ *
+ * ChangeLog has moved to the CHANGELOG file.
+ *
+ * TODO:
+ * - handle properly intermediate incomplete server headers. Done ?
+ * - handle hot-reconfiguration
+ * - fix client/server state transition when server is in connect or headers state
+ * and client suddenly disconnects. The server *should* switch to SHUT_WR, but
+ * still handle HTTP headers.
+ * - remove MAX_NEWHDR
+ * - cut this huge file into several ones
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <sys/resource.h>
+#include <time.h>
+#include <syslog.h>
+
+#ifdef DEBUG_FULL
+#include <assert.h>
+#endif
+
+#include <haproxy/appsession.h>
+#include <haproxy/base64.h>
+#include <haproxy/cfgparse.h>
+#include <haproxy/compat.h>
+#include <haproxy/config.h>
+#include <haproxy/defaults.h>
+#include <haproxy/memory.h>
+#include <haproxy/mini-clist.h>
+#include <haproxy/regex.h>
+#include <haproxy/standard.h>
+#include <haproxy/time.h>
+#include <haproxy/uri_auth.h>
+#include <haproxy/version.h>
+
+#include <types/capture.h>
+#include <types/global.h>
+#include <types/httperr.h>
+#include <types/proto_http.h>
+
+#include <proto/backend.h>
+#include <proto/buffers.h>
+#include <proto/client.h>
+#include <proto/fd.h>
+#include <proto/log.h>
+#include <proto/polling.h>
+#include <proto/proxy.h>
+#include <proto/queue.h>
+#include <proto/server.h>
+#include <proto/stream_sock.h>
+#include <proto/task.h>
+
+/*********************************************************************/
+
+/*********************************************************************/
+
+char *cfg_cfgfile = NULL; /* configuration file */
+char *progname = NULL; /* program name */
+int pid; /* current process id */
+
+/* global options */
+struct global global = {
+ logfac1 : -1,
+ logfac2 : -1,
+ loglev1 : 7, /* max syslog level : debug */
+ loglev2 : 7,
+ /* others NULL OK */
+};
+
+/*********************************************************************/
+
+int stopping; /* non zero means stopping in progress */
+
+/* Here we store informations about the pids of the processes we may pause
+ * or kill. We will send them a signal every 10 ms until we can bind to all
+ * our ports. With 200 retries, that's about 2 seconds.
+ */
+#define MAX_START_RETRIES 200
+static int nb_oldpids = 0;
+static int *oldpids = NULL;
+static int oldpids_sig; /* use USR1 or TERM */
+
+/* this is used to drain data, and as a temporary buffer for sprintf()... */
+char trash[BUFSIZE];
+
+const int zero = 0;
+const int one = 1;
+
+/*
+ * Syslog facilities and levels. Conforming to RFC3164.
+ */
+
+#define MAX_HOSTNAME_LEN 32
+static char hostname[MAX_HOSTNAME_LEN] = "";
+
+
+/*********************************************************************/
+/* general purpose functions ***************************************/
+/*********************************************************************/
+
+void display_version()
+{
+ printf("HA-Proxy version " HAPROXY_VERSION " " HAPROXY_DATE"\n");
+ printf("Copyright 2000-2006 Willy Tarreau <w@1wt.eu>\n\n");
+}
+
+/*
+ * This function prints the command line usage and exits
+ */
+void usage(char *name)
+{
+ display_version();
+ fprintf(stderr,
+ "Usage : %s -f <cfgfile> [ -vdV"
+ "D ] [ -n <maxconn> ] [ -N <maxpconn> ]\n"
+ " [ -p <pidfile> ] [ -m <max megs> ]\n"
+ " -v displays version\n"
+ " -d enters debug mode ; -db only disables background mode.\n"
+ " -V enters verbose mode (disables quiet mode)\n"
+ " -D goes daemon ; implies -q\n"
+ " -q quiet mode : don't display messages\n"
+ " -c check mode : only check config file and exit\n"
+ " -n sets the maximum total # of connections (%d)\n"
+ " -m limits the usable amount of memory (in MB)\n"
+ " -N sets the default, per-proxy maximum # of connections (%d)\n"
+ " -p writes pids of all children to this file\n"
+#if defined(ENABLE_EPOLL)
+ " -de disables epoll() usage even when available\n"
+#endif
+#if defined(ENABLE_POLL)
+ " -dp disables poll() usage even when available\n"
+#endif
+ " -sf/-st [pid ]* finishes/terminates old pids. Must be last arguments.\n"
+ "\n",
+ name, DEFAULT_MAXCONN, cfg_maxpconn);
+ exit(1);
+}
+
+
+
+/*********************************************************************/
+/* more specific functions ***************************************/
+/*********************************************************************/
+
+/*
+ * upon SIGUSR1, let's have a soft stop.
+ */
+void sig_soft_stop(int sig)
+{
+ soft_stop();
+ signal(sig, SIG_IGN);
+}
+
+/*
+ * upon SIGTTOU, we pause everything
+ */
+void sig_pause(int sig)
+{
+ pause_proxies();
+ signal(sig, sig_pause);
+}
+
+/*
+ * upon SIGTTIN, let's have a soft stop.
+ */
+void sig_listen(int sig)
+{
+ listen_proxies();
+ signal(sig, sig_listen);
+}
+
+/*
+ * this function dumps every server's state when the process receives SIGHUP.
+ */
+void sig_dump_state(int sig)
+{
+ struct proxy *p = proxy;
+
+ Warning("SIGHUP received, dumping servers states.\n");
+ while (p) {
+ struct server *s = p->srv;
+
+ send_log(p, LOG_NOTICE, "SIGHUP received, dumping servers states for proxy %s.\n", p->id);
+ while (s) {
+ snprintf(trash, sizeof(trash),
+ "SIGHUP: Server %s/%s is %s. Conn: %d act, %d pend, %d tot.",
+ p->id, s->id,
+ (s->state & SRV_RUNNING) ? "UP" : "DOWN",
+ s->cur_sess, s->nbpend, s->cum_sess);
+ Warning("%s\n", trash);
+ send_log(p, LOG_NOTICE, "%s\n", trash);
+ s = s->next;
+ }
+
+ if (p->srv_act == 0) {
+ snprintf(trash, sizeof(trash),
+ "SIGHUP: Proxy %s %s ! Conn: %d act, %d pend (%d unass), %d tot.",
+ p->id,
+ (p->srv_bck) ? "is running on backup servers" : "has no server available",
+ p->nbconn, p->totpend, p->nbpend, p->cum_conn);
+ } else {
+ snprintf(trash, sizeof(trash),
+ "SIGHUP: Proxy %s has %d active servers and %d backup servers available."
+ " Conn: %d act, %d pend (%d unass), %d tot.",
+ p->id, p->srv_act, p->srv_bck,
+ p->nbconn, p->totpend, p->nbpend, p->cum_conn);
+ }
+ Warning("%s\n", trash);
+ send_log(p, LOG_NOTICE, "%s\n", trash);
+
+ p = p->next;
+ }
+ signal(sig, sig_dump_state);
+}
+
+void dump(int sig)
+{
+ struct task *t, *tnext;
+ struct session *s;
+
+ tnext = ((struct task *)LIST_HEAD(wait_queue[0]))->next;
+ while ((t = tnext) != LIST_HEAD(wait_queue[0])) { /* we haven't looped ? */
+ tnext = t->next;
+ s = t->context;
+ qfprintf(stderr,"[dump] wq: task %p, still %ld ms, "
+ "cli=%d, srv=%d, cr=%d, cw=%d, sr=%d, sw=%d, "
+ "req=%d, rep=%d, clifd=%d\n",
+ s, tv_remain(&now, &t->expire),
+ s->cli_state,
+ s->srv_state,
+ FD_ISSET(s->cli_fd, StaticReadEvent),
+ FD_ISSET(s->cli_fd, StaticWriteEvent),
+ FD_ISSET(s->srv_fd, StaticReadEvent),
+ FD_ISSET(s->srv_fd, StaticWriteEvent),
+ s->req->l, s->rep?s->rep->l:0, s->cli_fd
+ );
+ }
+}
+
+#ifdef DEBUG_MEMORY
+static void fast_stop(void)
+{
+ struct proxy *p;
+ p = proxy;
+ while (p) {
+ p->grace = 0;
+ p = p->next;
+ }
+ soft_stop();
+}
+
+void sig_int(int sig)
+{
+ /* This would normally be a hard stop,
+ but we want to be sure about deallocation,
+ and so on, so we do a soft stop with
+ 0 GRACE time
+ */
+ fast_stop();
+ /* If we are killed twice, we decide to die*/
+ signal(sig, SIG_DFL);
+}
+
+void sig_term(int sig)
+{
+ /* This would normally be a hard stop,
+ but we want to be sure about deallocation,
+ and so on, so we do a soft stop with
+ 0 GRACE time
+ */
+ fast_stop();
+ /* If we are killed twice, we decide to die*/
+ signal(sig, SIG_DFL);
+}
+#endif
+
+
+/*
+ * This function initializes all the necessary variables. It only returns
+ * if everything is OK. If something fails, it exits.
+ */
+void init(int argc, char **argv)
+{
+ int i;
+ int arg_mode = 0; /* MODE_DEBUG, ... */
+ char *old_argv = *argv;
+ char *tmp;
+ char *cfg_pidfile = NULL;
+
+ if (1<<INTBITS != sizeof(int)*8) {
+ fprintf(stderr,
+ "Error: wrong architecture. Recompile so that sizeof(int)=%d\n",
+ (int)(sizeof(int)*8));
+ exit(1);
+ }
+
+ /*
+ * Initialize the previously static variables.
+ */
+
+ totalconn = actconn = maxfd = listeners = stopping = 0;
+
+
+#ifdef HAPROXY_MEMMAX
+ global.rlimit_memmax = HAPROXY_MEMMAX;
+#endif
+
+ /* initialize the libc's localtime structures once for all so that we
+ * won't be missing memory if we want to send alerts under OOM conditions.
+ */
+ tv_now(&now);
+ localtime(&now.tv_sec);
+ start_date = now;
+
+ init_log();
+
+ cfg_polling_mechanism = POLL_USE_SELECT; /* select() is always available */
+#if defined(ENABLE_POLL)
+ cfg_polling_mechanism |= POLL_USE_POLL;
+#endif
+#if defined(ENABLE_EPOLL)
+ cfg_polling_mechanism |= POLL_USE_EPOLL;
+#endif
+
+ pid = getpid();
+ progname = *argv;
+ while ((tmp = strchr(progname, '/')) != NULL)
+ progname = tmp + 1;
+
+ argc--; argv++;
+ while (argc > 0) {
+ char *flag;
+
+ if (**argv == '-') {
+ flag = *argv+1;
+
+ /* 1 arg */
+ if (*flag == 'v') {
+ display_version();
+ exit(0);
+ }
+#if defined(ENABLE_EPOLL)
+ else if (*flag == 'd' && flag[1] == 'e')
+ cfg_polling_mechanism &= ~POLL_USE_EPOLL;
+#endif
+#if defined(ENABLE_POLL)
+ else if (*flag == 'd' && flag[1] == 'p')
+ cfg_polling_mechanism &= ~POLL_USE_POLL;
+#endif
+ else if (*flag == 'V')
+ arg_mode |= MODE_VERBOSE;
+ else if (*flag == 'd' && flag[1] == 'b')
+ arg_mode |= MODE_FOREGROUND;
+ else if (*flag == 'd')
+ arg_mode |= MODE_DEBUG;
+ else if (*flag == 'c')
+ arg_mode |= MODE_CHECK;
+ else if (*flag == 'D')
+ arg_mode |= MODE_DAEMON | MODE_QUIET;
+ else if (*flag == 'q')
+ arg_mode |= MODE_QUIET;
+ else if (*flag == 's' && (flag[1] == 'f' || flag[1] == 't')) {
+ /* list of pids to finish ('f') or terminate ('t') */
+
+ if (flag[1] == 'f')
+ oldpids_sig = SIGUSR1; /* finish then exit */
+ else
+ oldpids_sig = SIGTERM; /* terminate immediately */
+ argv++; argc--;
+
+ if (argc > 0) {
+ oldpids = calloc(argc, sizeof(int));
+ while (argc > 0) {
+ oldpids[nb_oldpids] = atol(*argv);
+ if (oldpids[nb_oldpids] <= 0)
+ usage(old_argv);
+ argc--; argv++;
+ nb_oldpids++;
+ }
+ }
+ }
+ else { /* >=2 args */
+ argv++; argc--;
+ if (argc == 0)
+ usage(old_argv);
+
+ switch (*flag) {
+ case 'n' : cfg_maxconn = atol(*argv); break;
+ case 'm' : global.rlimit_memmax = atol(*argv); break;
+ case 'N' : cfg_maxpconn = atol(*argv); break;
+ case 'f' : cfg_cfgfile = *argv; break;
+ case 'p' : cfg_pidfile = *argv; break;
+ default: usage(old_argv);
+ }
+ }
+ }
+ else
+ usage(old_argv);
+ argv++; argc--;
+ }
+
+ global.mode = MODE_STARTING | /* during startup, we want most of the alerts */
+ (arg_mode & (MODE_DAEMON | MODE_FOREGROUND | MODE_VERBOSE
+ | MODE_QUIET | MODE_CHECK | MODE_DEBUG));
+
+ if (!cfg_cfgfile)
+ usage(old_argv);
+
+ gethostname(hostname, MAX_HOSTNAME_LEN);
+
+ have_appsession = 0;
+ global.maxsock = 10; /* reserve 10 fds ; will be incremented by socket eaters */
+ if (readcfgfile(cfg_cfgfile) < 0) {
+ Alert("Error reading configuration file : %s\n", cfg_cfgfile);
+ exit(1);
+ }
+ if (have_appsession)
+ appsession_init();
+
+ if (global.mode & MODE_CHECK) {
+ qfprintf(stdout, "Configuration file is valid : %s\n", cfg_cfgfile);
+ exit(0);
+ }
+
+ if (cfg_maxconn > 0)
+ global.maxconn = cfg_maxconn;
+
+ if (cfg_pidfile) {
+ if (global.pidfile)
+ free(global.pidfile);
+ global.pidfile = strdup(cfg_pidfile);
+ }
+
+ if (global.maxconn == 0)
+ global.maxconn = DEFAULT_MAXCONN;
+
+ global.maxsock += global.maxconn * 2; /* each connection needs two sockets */
+
+ if (arg_mode & (MODE_DEBUG | MODE_FOREGROUND)) {
+ /* command line debug mode inhibits configuration mode */
+ global.mode &= ~(MODE_DAEMON | MODE_QUIET);
+ }
+ global.mode |= (arg_mode & (MODE_DAEMON | MODE_FOREGROUND | MODE_QUIET |
+ MODE_VERBOSE | MODE_DEBUG | MODE_STATS | MODE_LOG));
+
+ if ((global.mode & MODE_DEBUG) && (global.mode & (MODE_DAEMON | MODE_QUIET))) {
+ Warning("<debug> mode incompatible with <quiet> and <daemon>. Keeping <debug> only.\n");
+ global.mode &= ~(MODE_DAEMON | MODE_QUIET);
+ }
+
+ if ((global.nbproc > 1) && !(global.mode & MODE_DAEMON)) {
+ if (!(global.mode & (MODE_FOREGROUND | MODE_DEBUG)))
+ Warning("<nbproc> is only meaningful in daemon mode. Setting limit to 1 process.\n");
+ global.nbproc = 1;
+ }
+
+ if (global.nbproc < 1)
+ global.nbproc = 1;
+
+ StaticReadEvent = (fd_set *)calloc(1,
+ sizeof(fd_set) *
+ (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ StaticWriteEvent = (fd_set *)calloc(1,
+ sizeof(fd_set) *
+ (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+
+ fdtab = (struct fdtab *)calloc(1,
+ sizeof(struct fdtab) * (global.maxsock));
+ for (i = 0; i < global.maxsock; i++) {
+ fdtab[i].state = FD_STCLOSE;
+ }
+}
+
+void deinit(void)
+{
+ struct proxy *p = proxy;
+ struct cap_hdr *h,*h_next;
+ struct server *s,*s_next;
+ struct listener *l,*l_next;
+
+ while (p) {
+ if (p->id)
+ free(p->id);
+
+ if (p->check_req)
+ free(p->check_req);
+
+ if (p->cookie_name)
+ free(p->cookie_name);
+
+ if (p->capture_name)
+ free(p->capture_name);
+
+ /* only strup if the user have set in config.
+ When should we free it?!
+ if (p->errmsg.msg400) free(p->errmsg.msg400);
+ if (p->errmsg.msg403) free(p->errmsg.msg403);
+ if (p->errmsg.msg408) free(p->errmsg.msg408);
+ if (p->errmsg.msg500) free(p->errmsg.msg500);
+ if (p->errmsg.msg502) free(p->errmsg.msg502);
+ if (p->errmsg.msg503) free(p->errmsg.msg503);
+ if (p->errmsg.msg504) free(p->errmsg.msg504);
+ */
+ if (p->appsession_name)
+ free(p->appsession_name);
+
+ h = p->req_cap;
+ while (h) {
+ h_next = h->next;
+ if (h->name)
+ free(h->name);
+ pool_destroy(h->pool);
+ free(h);
+ h = h_next;
+ }/* end while(h) */
+
+ h = p->rsp_cap;
+ while (h) {
+ h_next = h->next;
+ if (h->name)
+ free(h->name);
+
+ pool_destroy(h->pool);
+ free(h);
+ h = h_next;
+ }/* end while(h) */
+
+ s = p->srv;
+ while (s) {
+ s_next = s->next;
+ if (s->id)
+ free(s->id);
+
+ if (s->cookie)
+ free(s->cookie);
+
+ free(s);
+ s = s_next;
+ }/* end while(s) */
+
+ l = p->listen;
+ while (l) {
+ l_next = l->next;
+ free(l);
+ l = l_next;
+ }/* end while(l) */
+
+ pool_destroy((void **) p->req_cap_pool);
+ pool_destroy((void **) p->rsp_cap_pool);
+ p = p->next;
+ }/* end while(p) */
+
+ if (global.chroot) free(global.chroot);
+ if (global.pidfile) free(global.pidfile);
+
+ if (StaticReadEvent) free(StaticReadEvent);
+ if (StaticWriteEvent) free(StaticWriteEvent);
+ if (fdtab) free(fdtab);
+
+ pool_destroy(pool_session);
+ pool_destroy(pool_buffer);
+ pool_destroy(pool_requri);
+ pool_destroy(pool_task);
+ pool_destroy(pool_capture);
+ pool_destroy(pool_appsess);
+
+ if (have_appsession) {
+ pool_destroy(apools.serverid);
+ pool_destroy(apools.sessid);
+ }
+} /* end deinit() */
+
+/* sends the signal <sig> to all pids found in <oldpids> */
+static void tell_old_pids(int sig)
+{
+ int p;
+ for (p = 0; p < nb_oldpids; p++)
+ kill(oldpids[p], sig);
+}
+
+int main(int argc, char **argv)
+{
+ int err, retry;
+ struct rlimit limit;
+ FILE *pidfile = NULL;
+ init(argc, argv);
+
+ signal(SIGQUIT, dump);
+ signal(SIGUSR1, sig_soft_stop);
+ signal(SIGHUP, sig_dump_state);
+#ifdef DEBUG_MEMORY
+ signal(SIGINT, sig_int);
+ signal(SIGTERM, sig_term);
+#endif
+
+ /* on very high loads, a sigpipe sometimes happen just between the
+ * getsockopt() which tells "it's OK to write", and the following write :-(
+ */
+#ifndef MSG_NOSIGNAL
+ signal(SIGPIPE, SIG_IGN);
+#endif
+
+ /* We will loop at most 100 times with 10 ms delay each time.
+ * That's at most 1 second. We only send a signal to old pids
+ * if we cannot grab at least one port.
+ */
+ retry = MAX_START_RETRIES;
+ err = ERR_NONE;
+ while (retry >= 0) {
+ struct timeval w;
+ err = start_proxies(retry == 0 || nb_oldpids == 0);
+ if (err != ERR_RETRYABLE)
+ break;
+ if (nb_oldpids == 0)
+ break;
+
+ /* FIXME-20060514: Solaris and OpenBSD do not support shutdown() on
+ * listening sockets. So on those platforms, it would be wiser to
+ * simply send SIGUSR1, which will not be undoable.
+ */
+ tell_old_pids(SIGTTOU);
+ /* give some time to old processes to stop listening */
+ w.tv_sec = 0;
+ w.tv_usec = 10*1000;
+ select(0, NULL, NULL, NULL, &w);
+ retry--;
+ }
+
+ /* Note: start_proxies() sends an alert when it fails. */
+ if (err != ERR_NONE) {
+ if (retry != MAX_START_RETRIES && nb_oldpids)
+ tell_old_pids(SIGTTIN);
+ exit(1);
+ }
+
+ if (listeners == 0) {
+ Alert("[%s.main()] No enabled listener found (check the <listen> keywords) ! Exiting.\n", argv[0]);
+ /* Note: we don't have to send anything to the old pids because we
+ * never stopped them. */
+ exit(1);
+ }
+
+ /* prepare pause/play signals */
+ signal(SIGTTOU, sig_pause);
+ signal(SIGTTIN, sig_listen);
+
+ if (global.mode & MODE_DAEMON) {
+ global.mode &= ~MODE_VERBOSE;
+ global.mode |= MODE_QUIET;
+ }
+
+ /* MODE_QUIET can inhibit alerts and warnings below this line */
+
+ global.mode &= ~MODE_STARTING;
+ if ((global.mode & MODE_QUIET) && !(global.mode & MODE_VERBOSE)) {
+ /* detach from the tty */
+ fclose(stdin); fclose(stdout); fclose(stderr);
+ close(0); close(1); close(2);
+ }
+
+ /* open log & pid files before the chroot */
+ if (global.mode & MODE_DAEMON && global.pidfile != NULL) {
+ int pidfd;
+ unlink(global.pidfile);
+ pidfd = open(global.pidfile, O_CREAT | O_WRONLY | O_TRUNC, 0644);
+ if (pidfd < 0) {
+ Alert("[%s.main()] Cannot create pidfile %s\n", argv[0], global.pidfile);
+ if (nb_oldpids)
+ tell_old_pids(SIGTTIN);
+ exit(1);
+ }
+ pidfile = fdopen(pidfd, "w");
+ }
+
+ /* chroot if needed */
+ if (global.chroot != NULL) {
+ if (chroot(global.chroot) == -1) {
+ Alert("[%s.main()] Cannot chroot(%s).\n", argv[0], global.chroot);
+ if (nb_oldpids)
+ tell_old_pids(SIGTTIN);
+ }
+ chdir("/");
+ }
+
+ /* ulimits */
+ if (!global.rlimit_nofile)
+ global.rlimit_nofile = global.maxsock;
+
+ if (global.rlimit_nofile) {
+ limit.rlim_cur = limit.rlim_max = global.rlimit_nofile;
+ if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
+ Warning("[%s.main()] Cannot raise FD limit to %d.\n", argv[0], global.rlimit_nofile);
+ }
+ }
+
+ if (global.rlimit_memmax) {
+ limit.rlim_cur = limit.rlim_max =
+ global.rlimit_memmax * 1048576 / global.nbproc;
+#ifdef RLIMIT_AS
+ if (setrlimit(RLIMIT_AS, &limit) == -1) {
+ Warning("[%s.main()] Cannot fix MEM limit to %d megs.\n",
+ argv[0], global.rlimit_memmax);
+ }
+#else
+ if (setrlimit(RLIMIT_DATA, &limit) == -1) {
+ Warning("[%s.main()] Cannot fix MEM limit to %d megs.\n",
+ argv[0], global.rlimit_memmax);
+ }
+#endif
+ }
+
+ if (nb_oldpids)
+ tell_old_pids(oldpids_sig);
+
+ /* Note that any error at this stage will be fatal because we will not
+ * be able to restart the old pids.
+ */
+
+ /* setgid / setuid */
+ if (global.gid && setgid(global.gid) == -1) {
+ Alert("[%s.main()] Cannot set gid %d.\n", argv[0], global.gid);
+ exit(1);
+ }
+
+ if (global.uid && setuid(global.uid) == -1) {
+ Alert("[%s.main()] Cannot set uid %d.\n", argv[0], global.uid);
+ exit(1);
+ }
+
+ /* check ulimits */
+ limit.rlim_cur = limit.rlim_max = 0;
+ getrlimit(RLIMIT_NOFILE, &limit);
+ if (limit.rlim_cur < global.maxsock) {
+ Warning("[%s.main()] FD limit (%d) too low for maxconn=%d/maxsock=%d. Please raise 'ulimit-n' to %d or more to avoid any trouble.\n",
+ argv[0], limit.rlim_cur, global.maxconn, global.maxsock, global.maxsock);
+ }
+
+ if (global.mode & MODE_DAEMON) {
+ int ret = 0;
+ int proc;
+
+ /* the father launches the required number of processes */
+ for (proc = 0; proc < global.nbproc; proc++) {
+ ret = fork();
+ if (ret < 0) {
+ Alert("[%s.main()] Cannot fork.\n", argv[0]);
+ if (nb_oldpids)
+ exit(1); /* there has been an error */
+ }
+ else if (ret == 0) /* child breaks here */
+ break;
+ if (pidfile != NULL) {
+ fprintf(pidfile, "%d\n", ret);
+ fflush(pidfile);
+ }
+ }
+ /* close the pidfile both in children and father */
+ if (pidfile != NULL)
+ fclose(pidfile);
+ free(global.pidfile);
+
+ if (proc == global.nbproc)
+ exit(0); /* parent must leave */
+
+ /* if we're NOT in QUIET mode, we should now close the 3 first FDs to ensure
+ * that we can detach from the TTY. We MUST NOT do it in other cases since
+ * it would have already be done, and 0-2 would have been affected to listening
+ * sockets
+ */
+ if (!(global.mode & MODE_QUIET)) {
+ /* detach from the tty */
+ fclose(stdin); fclose(stdout); fclose(stderr);
+ close(0); close(1); close(2); /* close all fd's */
+ global.mode |= MODE_QUIET; /* ensure that we won't say anything from now */
+ }
+ pid = getpid(); /* update child's pid */
+ setsid();
+ }
+
+#if defined(ENABLE_EPOLL)
+ if (cfg_polling_mechanism & POLL_USE_EPOLL) {
+ if (epoll_loop(POLL_LOOP_ACTION_INIT)) {
+ epoll_loop(POLL_LOOP_ACTION_RUN);
+ epoll_loop(POLL_LOOP_ACTION_CLEAN);
+ cfg_polling_mechanism &= POLL_USE_EPOLL;
+ }
+ else {
+ Warning("epoll() is not available. Using poll()/select() instead.\n");
+ cfg_polling_mechanism &= ~POLL_USE_EPOLL;
+ }
+ }
+#endif
+
+#if defined(ENABLE_POLL)
+ if (cfg_polling_mechanism & POLL_USE_POLL) {
+ if (poll_loop(POLL_LOOP_ACTION_INIT)) {
+ poll_loop(POLL_LOOP_ACTION_RUN);
+ poll_loop(POLL_LOOP_ACTION_CLEAN);
+ cfg_polling_mechanism &= POLL_USE_POLL;
+ }
+ else {
+ Warning("poll() is not available. Using select() instead.\n");
+ cfg_polling_mechanism &= ~POLL_USE_POLL;
+ }
+ }
+#endif
+ if (cfg_polling_mechanism & POLL_USE_SELECT) {
+ if (select_loop(POLL_LOOP_ACTION_INIT)) {
+ select_loop(POLL_LOOP_ACTION_RUN);
+ select_loop(POLL_LOOP_ACTION_CLEAN);
+ cfg_polling_mechanism &= POLL_USE_SELECT;
+ }
+ }
+
+
+ /* Free all Hash Keys and all Hash elements */
+ appsession_cleanup();
+ /* Do some cleanup */
+ deinit();
+
+ exit(0);
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/hashpjw.c b/src/hashpjw.c
index a207eb9..78c0a5b 100644
--- a/src/hashpjw.c
+++ b/src/hashpjw.c
@@ -16,7 +16,8 @@
* *
*****************************************************************************/
-#include <include/hashpjw.h>
+#include <haproxy/hashpjw.h>
+#include <haproxy/appsession.h>
/*****************************************************************************
* *
@@ -26,37 +27,44 @@
int hashpjw(const void *key) {
- const char *ptr;
- unsigned int val;
- appsess *appsession_temp;
+ const char *ptr;
+ unsigned int val;
+ appsess *appsession_temp;
- /*****************************************************************************
- * *
- * Hash the key by performing a number of bit operations on it. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Hash the key by performing a number of bit operations on it. *
+ * *
+ *********************************************************************/
- val = 0;
- appsession_temp = (appsess *)key;
- ptr = appsession_temp->sessid;
+ val = 0;
+ appsession_temp = (appsess *)key;
+ ptr = appsession_temp->sessid;
- while (*ptr != '\0') {
+ while (*ptr != '\0') {
- int tmp;
+ int tmp;
- val = (val << 4) + (*ptr);
+ val = (val << 4) + (*ptr);
- if((tmp = (val & 0xf0000000))) {
- val = val ^ (tmp >> 24);
- val = val ^ tmp;
- }
- ptr++;
- }/* end while */
+ if((tmp = (val & 0xf0000000))) {
+ val = val ^ (tmp >> 24);
+ val = val ^ tmp;
+ }
+ ptr++;
+ }/* end while */
- /*****************************************************************************
- * *
- * In practice, replace PRIME_TBLSIZ with the actual table size. *
- * *
- *****************************************************************************/
- return val % PRIME_TBLSIZ;
+ /*********************************************************************
+ * *
+ * In practice, replace PRIME_TBLSIZ with the actual table size. *
+ * *
+ *********************************************************************/
+ return val % PRIME_TBLSIZ;
}/* end hashpjw */
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/list.c b/src/list.c
index 364ed14..0eaf6ce 100644
--- a/src/list.c
+++ b/src/list.c
@@ -18,7 +18,7 @@
#include <stdlib.h>
#include <string.h>
-#include <include/list.h>
+#include <haproxy/list.h>
/*****************************************************************************
* *
@@ -28,17 +28,17 @@
void list_init(List *list, void (*destroy)(void *data)) {
- /*****************************************************************************
- * *
- * Initialize the list. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Initialize the list. *
+ * *
+ *********************************************************************/
- list->size = 0;
- list->destroy = destroy;
- list->head = NULL;
- list->tail = NULL;
- return;
+ list->size = 0;
+ list->destroy = destroy;
+ list->head = NULL;
+ list->tail = NULL;
+ return;
} /* end list_init() */
/*****************************************************************************
@@ -49,39 +49,39 @@
void list_destroy(List *list) {
- void *data;
- int rc;
+ void *data;
+ int rc;
- /*****************************************************************************
- * *
- * Remove each element. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Remove each element. *
+ * *
+ *********************************************************************/
- while (list_size(list) > 0) {
+ while (list_size(list) > 0) {
- rc = list_rem_next(list, NULL, (void **)&data);
+ rc = list_rem_next(list, NULL, (void **)&data);
- if (( rc == 0) && (list->destroy != NULL)) {
+ if (( rc == 0) && (list->destroy != NULL)) {
- /***********************************************************************
- * *
- * Call a user-defined function to free dynamically allocated data. *
- * *
- ***********************************************************************/
+ /*******************************************************************
+ * *
+ * Call a user-defined function to free dynamically allocated data.*
+ * *
+ *******************************************************************/
- list->destroy(data);
- }/* end if() */
- }/* end while() */
+ list->destroy(data);
+ }/* end if() */
+ }/* end while() */
- /*****************************************************************************
- * *
- * No operations are allowed now, but clear the structure as a precaution. *
- * *
- *****************************************************************************/
+ /**************************************************************************
+ * *
+ * No operations are allowed now, but clear the structure as a precaution.*
+ * *
+ **************************************************************************/
- memset(list, 0, sizeof(List));
- return;
+ memset(list, 0, sizeof(List));
+ return;
} /* void list_destroy(List *list) */
/*****************************************************************************
@@ -92,62 +92,62 @@
int list_ins_next(List *list, ListElmt *element, const void *data) {
- ListElmt *new_element;
+ ListElmt *new_element;
- /*****************************************************************************
- * *
- * Allocate storage for the element. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Allocate storage for the element. *
+ * *
+ *********************************************************************/
- if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL)
- return -1;
+ if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL)
+ return -1;
- /*****************************************************************************
- * *
- * Insert the element into the list. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Insert the element into the list. *
+ * *
+ *********************************************************************/
- new_element->data = (void *)data;
+ new_element->data = (void *)data;
- if (element == NULL) {
+ if (element == NULL) {
- /**************************************************************************
- * *
- * Handle insertion at the head of the list. *
- * *
- **************************************************************************/
+ /*************************************************************
+ * *
+ * Handle insertion at the head of the list. *
+ * *
+ *************************************************************/
- if (list_size(list) == 0)
- list->tail = new_element;
+ if (list_size(list) == 0)
+ list->tail = new_element;
- new_element->next = list->head;
- list->head = new_element;
- }/* end if (element == NULL) */
- else {
+ new_element->next = list->head;
+ list->head = new_element;
+ }/* end if (element == NULL) */
+ else {
- /**************************************************************************
- * *
- * Handle insertion somewhere other than at the head. *
- * *
- **************************************************************************/
+ /*************************************************************
+ * *
+ * Handle insertion somewhere other than at the head. *
+ * *
+ *************************************************************/
- if (element->next == NULL)
- list->tail = new_element;
+ if (element->next == NULL)
+ list->tail = new_element;
- new_element->next = element->next;
- element->next = new_element;
- }/* end else */
+ new_element->next = element->next;
+ element->next = new_element;
+ }/* end else */
- /*****************************************************************************
- * *
- * Adjust the size of the list to account for the inserted element. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Adjust the size of the list to account for the inserted element. *
+ * *
+ *********************************************************************/
- list->size++;
- return 0;
+ list->size++;
+ return 0;
} /* end list_ins_next() */
/*****************************************************************************
@@ -158,71 +158,78 @@
int list_rem_next(List *list, ListElmt *element, void **data) {
- ListElmt *old_element;
+ ListElmt *old_element;
- /*****************************************************************************
- * *
- * Do not allow removal from an empty list. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Do not allow removal from an empty list. *
+ * *
+ *********************************************************************/
- if (list_size(list) == 0)
- return -1;
+ if (list_size(list) == 0)
+ return -1;
- /*****************************************************************************
- * *
- * Remove the element from the list. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Remove the element from the list. *
+ * *
+ *********************************************************************/
- if (element == NULL) {
+ if (element == NULL) {
- /**************************************************************************
- * *
- * Handle removal from the head of the list. *
- * *
- **************************************************************************/
+ /*************************************************************
+ * *
+ * Handle removal from the head of the list. *
+ * *
+ *************************************************************/
- *data = list->head->data;
- old_element = list->head;
- list->head = list->head->next;
+ *data = list->head->data;
+ old_element = list->head;
+ list->head = list->head->next;
- if (list_size(list) == 1)
- list->tail = NULL;
- }/* end if (element == NULL) */
- else {
+ if (list_size(list) == 1)
+ list->tail = NULL;
+ }/* end if (element == NULL) */
+ else {
- /**************************************************************************
- * *
- * Handle removal from somewhere other than the head. *
- * *
- **************************************************************************/
+ /*************************************************************
+ * *
+ * Handle removal from somewhere other than the head. *
+ * *
+ *************************************************************/
- if (element->next == NULL)
- return -1;
+ if (element->next == NULL)
+ return -1;
- *data = element->next->data;
- old_element = element->next;
- element->next = element->next->next;
+ *data = element->next->data;
+ old_element = element->next;
+ element->next = element->next->next;
- if (element->next == NULL)
- list->tail = element;
- }/* end else */
+ if (element->next == NULL)
+ list->tail = element;
+ }/* end else */
- /*****************************************************************************
- * *
- * Free the storage allocated by the abstract data type. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Free the storage allocated by the abstract data type. *
+ * *
+ *********************************************************************/
- free(old_element);
+ free(old_element);
- /*****************************************************************************
- * *
- * Adjust the size of the list to account for the removed element. *
- * *
- *****************************************************************************/
+ /*********************************************************************
+ * *
+ * Adjust the size of the list to account for the removed element. *
+ * *
+ *********************************************************************/
- list->size--;
- return 0;
+ list->size--;
+ return 0;
}
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/log.c b/src/log.c
new file mode 100644
index 0000000..d311ac8
--- /dev/null
+++ b/src/log.c
@@ -0,0 +1,459 @@
+/*
+ * General logging functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <sys/time.h>
+
+#include <haproxy/standard.h>
+
+#include <types/backend.h>
+#include <types/global.h>
+#include <types/httperr.h>
+#include <types/log.h>
+#include <types/proxy.h>
+#include <types/session.h>
+
+
+const char *log_facilities[NB_LOG_FACILITIES] = {
+ "kern", "user", "mail", "daemon",
+ "auth", "syslog", "lpr", "news",
+ "uucp", "cron", "auth2", "ftp",
+ "ntp", "audit", "alert", "cron2",
+ "local0", "local1", "local2", "local3",
+ "local4", "local5", "local6", "local7"
+};
+
+
+const char *log_levels[NB_LOG_LEVELS] = {
+ "emerg", "alert", "crit", "err",
+ "warning", "notice", "info", "debug"
+};
+
+const char *monthname[12] = {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
+const char sess_term_cond[8] = "-cCsSPRI"; /* normal, CliTo, CliErr, SrvTo, SrvErr, PxErr, Resource, Internal */
+const char sess_fin_state[8] = "-RCHDLQ7"; /* cliRequest, srvConnect, srvHeader, Data, Last, Queue, unknown */
+const char sess_cookie[4] = "NIDV"; /* No cookie, Invalid cookie, cookie for a Down server, Valid cookie */
+const char sess_set_cookie[8] = "N1I3PD5R"; /* No set-cookie, unknown, Set-Cookie Inserted, unknown,
+ Set-cookie seen and left unchanged (passive), Set-cookie Deleted,
+ unknown, Set-cookie Rewritten */
+void **pool_requri = NULL;
+
+
+/*
+ * Displays the message on stderr with the date and pid. Overrides the quiet
+ * mode during startup.
+ */
+void Alert(char *fmt, ...)
+{
+ va_list argp;
+ struct timeval tv;
+ struct tm *tm;
+
+ if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
+ va_start(argp, fmt);
+
+ gettimeofday(&tv, NULL);
+ tm = localtime(&tv.tv_sec);
+ fprintf(stderr, "[ALERT] %03d/%02d%02d%02d (%d) : ",
+ tm->tm_yday, tm->tm_hour, tm->tm_min, tm->tm_sec, (int)getpid());
+ vfprintf(stderr, fmt, argp);
+ fflush(stderr);
+ va_end(argp);
+ }
+}
+
+
+/*
+ * Displays the message on stderr with the date and pid.
+ */
+void Warning(char *fmt, ...)
+{
+ va_list argp;
+ struct timeval tv;
+ struct tm *tm;
+
+ if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
+ va_start(argp, fmt);
+
+ gettimeofday(&tv, NULL);
+ tm = localtime(&tv.tv_sec);
+ fprintf(stderr, "[WARNING] %03d/%02d%02d%02d (%d) : ",
+ tm->tm_yday, tm->tm_hour, tm->tm_min, tm->tm_sec, (int)getpid());
+ vfprintf(stderr, fmt, argp);
+ fflush(stderr);
+ va_end(argp);
+ }
+}
+
+/*
+ * Displays the message on <out> only if quiet mode is not set.
+ */
+void qfprintf(FILE *out, char *fmt, ...)
+{
+ va_list argp;
+
+ if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
+ va_start(argp, fmt);
+ vfprintf(out, fmt, argp);
+ fflush(out);
+ va_end(argp);
+ }
+}
+
+/*
+ * returns log level for <lev> or -1 if not found.
+ */
+int get_log_level(const char *lev)
+{
+ int level;
+
+ level = NB_LOG_LEVELS - 1;
+ while (level >= 0 && strcmp(log_levels[level], lev))
+ level--;
+
+ return level;
+}
+
+
+/*
+ * returns log facility for <fac> or -1 if not found.
+ */
+int get_log_facility(const char *fac)
+{
+ int facility;
+
+ facility = NB_LOG_FACILITIES - 1;
+ while (facility >= 0 && strcmp(log_facilities[facility], fac))
+ facility--;
+
+ return facility;
+}
+
+
+#define FD_SETS_ARE_BITFIELDS
+#ifdef FD_SETS_ARE_BITFIELDS
+/*
+ * This map is used with all the FD_* macros to check whether a particular bit
+ * is set or not. Each bit represents an ACSII code. FD_SET() sets those bytes
+ * which should be encoded. When FD_ISSET() returns non-zero, it means that the
+ * byte should be encoded. Be careful to always pass bytes from 0 to 255
+ * exclusively to the macros.
+ */
+fd_set hdr_encode_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
+fd_set url_encode_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
+
+#else
+#error "Check if your OS uses bitfields for fd_sets"
+#endif
+
+/*
+ * This function sends a syslog message to both log servers of a proxy,
+ * or to global log servers if the proxy is NULL.
+ * It also tries not to waste too much time computing the message header.
+ * It doesn't care about errors nor does it report them.
+ */
+void send_log(struct proxy *p, int level, char *message, ...)
+{
+ static int logfd = -1; /* syslog UDP socket */
+ static long tvsec = -1; /* to force the string to be initialized */
+ struct timeval tv;
+ va_list argp;
+ static char logmsg[MAX_SYSLOG_LEN];
+ static char *dataptr = NULL;
+ int fac_level;
+ int hdr_len, data_len;
+ struct sockaddr_in *sa[2];
+ int facilities[2], loglevel[2];
+ int nbloggers = 0;
+ char *log_ptr;
+
+ if (logfd < 0) {
+ if ((logfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
+ return;
+ }
+
+ if (level < 0 || progname == NULL || message == NULL)
+ return;
+
+ gettimeofday(&tv, NULL);
+ if (tv.tv_sec != tvsec || dataptr == NULL) {
+ /* this string is rebuild only once a second */
+ struct tm *tm = localtime(&tv.tv_sec);
+ tvsec = tv.tv_sec;
+
+ hdr_len = snprintf(logmsg, sizeof(logmsg),
+ "<<<<>%s %2d %02d:%02d:%02d %s[%d]: ",
+ monthname[tm->tm_mon],
+ tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
+ progname, pid);
+ /* WARNING: depending upon implementations, snprintf may return
+ * either -1 or the number of bytes that would be needed to store
+ * the total message. In both cases, we must adjust it.
+ */
+ if (hdr_len < 0 || hdr_len > sizeof(logmsg))
+ hdr_len = sizeof(logmsg);
+
+ dataptr = logmsg + hdr_len;
+ }
+
+ va_start(argp, message);
+ data_len = vsnprintf(dataptr, logmsg + sizeof(logmsg) - dataptr, message, argp);
+ if (data_len < 0 || data_len > (logmsg + sizeof(logmsg) - dataptr))
+ data_len = logmsg + sizeof(logmsg) - dataptr;
+ va_end(argp);
+ dataptr[data_len - 1] = '\n'; /* force a break on ultra-long lines */
+
+ if (p == NULL) {
+ if (global.logfac1 >= 0) {
+ sa[nbloggers] = &global.logsrv1;
+ facilities[nbloggers] = global.logfac1;
+ loglevel[nbloggers] = global.loglev1;
+ nbloggers++;
+ }
+ if (global.logfac2 >= 0) {
+ sa[nbloggers] = &global.logsrv2;
+ facilities[nbloggers] = global.logfac2;
+ loglevel[nbloggers] = global.loglev2;
+ nbloggers++;
+ }
+ } else {
+ if (p->logfac1 >= 0) {
+ sa[nbloggers] = &p->logsrv1;
+ facilities[nbloggers] = p->logfac1;
+ loglevel[nbloggers] = p->loglev1;
+ nbloggers++;
+ }
+ if (p->logfac2 >= 0) {
+ sa[nbloggers] = &p->logsrv2;
+ facilities[nbloggers] = p->logfac2;
+ loglevel[nbloggers] = p->loglev2;
+ nbloggers++;
+ }
+ }
+
+ while (nbloggers-- > 0) {
+ /* we can filter the level of the messages that are sent to each logger */
+ if (level > loglevel[nbloggers])
+ continue;
+
+ /* For each target, we may have a different facility.
+ * We can also have a different log level for each message.
+ * This induces variations in the message header length.
+ * Since we don't want to recompute it each time, nor copy it every
+ * time, we only change the facility in the pre-computed header,
+ * and we change the pointer to the header accordingly.
+ */
+ fac_level = (facilities[nbloggers] << 3) + level;
+ log_ptr = logmsg + 3; /* last digit of the log level */
+ do {
+ *log_ptr = '0' + fac_level % 10;
+ fac_level /= 10;
+ log_ptr--;
+ } while (fac_level && log_ptr > logmsg);
+ *log_ptr = '<';
+
+ /* the total syslog message now starts at logptr, for dataptr+data_len-logptr */
+
+#ifndef MSG_NOSIGNAL
+ sendto(logfd, log_ptr, dataptr + data_len - log_ptr, MSG_DONTWAIT,
+ (struct sockaddr *)sa[nbloggers], sizeof(**sa));
+#else
+ sendto(logfd, log_ptr, dataptr + data_len - log_ptr, MSG_DONTWAIT | MSG_NOSIGNAL,
+ (struct sockaddr *)sa[nbloggers], sizeof(**sa));
+#endif
+ }
+}
+
+
+/*
+ * send a log for the session when we have enough info about it
+ */
+void sess_log(struct session *s)
+{
+ char pn[INET6_ADDRSTRLEN + strlen(":65535")];
+ struct proxy *p = s->proxy;
+ int log;
+ char *uri;
+ char *pxid;
+ char *srv;
+ struct tm *tm;
+
+ /* This is a first attempt at a better logging system.
+ * For now, we rely on send_log() to provide the date, although it obviously
+ * is the date of the log and not of the request, and most fields are not
+ * computed.
+ */
+
+ log = p->to_log & ~s->logs.logwait;
+
+ if (s->cli_addr.ss_family == AF_INET)
+ inet_ntop(AF_INET,
+ (const void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
+ pn, sizeof(pn));
+ else
+ inet_ntop(AF_INET6,
+ (const void *)&((struct sockaddr_in6 *)(&s->cli_addr))->sin6_addr,
+ pn, sizeof(pn));
+
+ uri = (log & LW_REQ) ? s->logs.uri ? s->logs.uri : "<BADREQ>" : "";
+ pxid = p->id;
+ srv = (p->to_log & LW_SVID) ?
+ (s->data_source != DATA_SRC_STATS) ?
+ (s->srv != NULL) ? s->srv->id : "<NOSRV>" : "<STATS>" : "-";
+
+ tm = localtime(&s->logs.tv_accept.tv_sec);
+ if (p->to_log & LW_REQ) {
+ char tmpline[MAX_SYSLOG_LEN], *h;
+ int hdr;
+
+ h = tmpline;
+ if (p->to_log & LW_REQHDR && (h < tmpline + sizeof(tmpline) - 10)) {
+ *(h++) = ' ';
+ *(h++) = '{';
+ for (hdr = 0; hdr < p->nb_req_cap; hdr++) {
+ if (hdr)
+ *(h++) = '|';
+ if (s->req_cap[hdr] != NULL)
+ h = encode_string(h, tmpline + sizeof(tmpline) - 7,
+ '#', hdr_encode_map, s->req_cap[hdr]);
+ }
+ *(h++) = '}';
+ }
+
+ if (p->to_log & LW_RSPHDR && (h < tmpline + sizeof(tmpline) - 7)) {
+ *(h++) = ' ';
+ *(h++) = '{';
+ for (hdr = 0; hdr < p->nb_rsp_cap; hdr++) {
+ if (hdr)
+ *(h++) = '|';
+ if (s->rsp_cap[hdr] != NULL)
+ h = encode_string(h, tmpline + sizeof(tmpline) - 4,
+ '#', hdr_encode_map, s->rsp_cap[hdr]);
+ }
+ *(h++) = '}';
+ }
+
+ if (h < tmpline + sizeof(tmpline) - 4) {
+ *(h++) = ' ';
+ *(h++) = '"';
+ h = encode_string(h, tmpline + sizeof(tmpline) - 1,
+ '#', url_encode_map, uri);
+ *(h++) = '"';
+ }
+ *h = '\0';
+
+ send_log(p, LOG_INFO,
+ "%s:%d [%02d/%s/%04d:%02d:%02d:%02d]"
+ " %s %s %d/%d/%d/%d/%s%d %d %s%lld"
+ " %s %s %c%c%c%c %d/%d/%d %d/%d%s\n",
+ pn,
+ (s->cli_addr.ss_family == AF_INET) ?
+ ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port) :
+ ntohs(((struct sockaddr_in6 *)&s->cli_addr)->sin6_port),
+ tm->tm_mday, monthname[tm->tm_mon], tm->tm_year+1900,
+ tm->tm_hour, tm->tm_min, tm->tm_sec,
+ pxid, srv,
+ s->logs.t_request,
+ (s->logs.t_queue >= 0) ? s->logs.t_queue - s->logs.t_request : -1,
+ (s->logs.t_connect >= 0) ? s->logs.t_connect - s->logs.t_queue : -1,
+ (s->logs.t_data >= 0) ? s->logs.t_data - s->logs.t_connect : -1,
+ (p->to_log & LW_BYTES) ? "" : "+", s->logs.t_close,
+ s->logs.status,
+ (p->to_log & LW_BYTES) ? "" : "+", s->logs.bytes,
+ s->logs.cli_cookie ? s->logs.cli_cookie : "-",
+ s->logs.srv_cookie ? s->logs.srv_cookie : "-",
+ sess_term_cond[(s->flags & SN_ERR_MASK) >> SN_ERR_SHIFT],
+ sess_fin_state[(s->flags & SN_FINST_MASK) >> SN_FINST_SHIFT],
+ (p->options & PR_O_COOK_ANY) ? sess_cookie[(s->flags & SN_CK_MASK) >> SN_CK_SHIFT] : '-',
+ (p->options & PR_O_COOK_ANY) ? sess_set_cookie[(s->flags & SN_SCK_MASK) >> SN_SCK_SHIFT] : '-',
+ s->srv ? s->srv->cur_sess : 0, p->nbconn, actconn,
+ s->logs.srv_queue_size, s->logs.prx_queue_size, tmpline);
+ }
+ else {
+ send_log(p, LOG_INFO, "%s:%d [%02d/%s/%04d:%02d:%02d:%02d]"
+ " %s %s %d/%d/%s%d %s%lld"
+ " %c%c %d/%d/%d %d/%d\n",
+ pn,
+ (s->cli_addr.ss_family == AF_INET) ?
+ ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port) :
+ ntohs(((struct sockaddr_in6 *)&s->cli_addr)->sin6_port),
+ tm->tm_mday, monthname[tm->tm_mon], tm->tm_year+1900,
+ tm->tm_hour, tm->tm_min, tm->tm_sec,
+ pxid, srv,
+ (s->logs.t_queue >= 0) ? s->logs.t_queue : -1,
+ (s->logs.t_connect >= 0) ? s->logs.t_connect - s->logs.t_queue : -1,
+ (p->to_log & LW_BYTES) ? "" : "+", s->logs.t_close,
+ (p->to_log & LW_BYTES) ? "" : "+", s->logs.bytes,
+ sess_term_cond[(s->flags & SN_ERR_MASK) >> SN_ERR_SHIFT],
+ sess_fin_state[(s->flags & SN_FINST_MASK) >> SN_FINST_SHIFT],
+ s->srv ? s->srv->cur_sess : 0, p->nbconn, actconn,
+ s->logs.srv_queue_size, s->logs.prx_queue_size);
+ }
+
+ s->logs.logwait = 0;
+}
+
+
+/*
+ * Initializes some data needed later.
+ */
+void init_log()
+{
+ int i;
+ char *tmp;
+
+ /* initialize the log header encoding map : '{|}"#' should be encoded with
+ * '#' as prefix, as well as non-printable characters ( <32 or >= 127 ).
+ * URL encoding only requires '"', '#' to be encoded as well as non-
+ * printable characters above.
+ */
+ memset(hdr_encode_map, 0, sizeof(hdr_encode_map));
+ memset(url_encode_map, 0, sizeof(url_encode_map));
+ for (i = 0; i < 32; i++) {
+ FD_SET(i, hdr_encode_map);
+ FD_SET(i, url_encode_map);
+ }
+ for (i = 127; i < 256; i++) {
+ FD_SET(i, hdr_encode_map);
+ FD_SET(i, url_encode_map);
+ }
+
+ tmp = "\"#{|}";
+ while (*tmp) {
+ FD_SET(*tmp, hdr_encode_map);
+ tmp++;
+ }
+
+ tmp = "\"#";
+ while (*tmp) {
+ FD_SET(*tmp, url_encode_map);
+ tmp++;
+ }
+}
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/polling.c b/src/polling.c
new file mode 100644
index 0000000..af01290
--- /dev/null
+++ b/src/polling.c
@@ -0,0 +1,455 @@
+/*
+ * File descriptors management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <haproxy/compat.h>
+#include <haproxy/config.h>
+#include <haproxy/time.h>
+
+#include <types/fd.h>
+#include <types/global.h>
+#include <types/polling.h>
+
+#include <proto/task.h>
+
+fd_set *StaticReadEvent, *StaticWriteEvent;
+int cfg_polling_mechanism = 0; /* POLL_USE_{SELECT|POLL|EPOLL} */
+
+/*
+ * FIXME: this is dirty, but at the moment, there's no other solution to remove
+ * the old FDs from outside the loop. Perhaps we should export a global 'poll'
+ * structure with pointers to functions such as init_fd() and close_fd(), plus
+ * a private structure with several pointers to places such as below.
+ */
+
+#if defined(ENABLE_EPOLL)
+fd_set *PrevReadEvent = NULL, *PrevWriteEvent = NULL;
+
+#if defined(USE_MY_EPOLL)
+_syscall1 (int, epoll_create, int, size);
+_syscall4 (int, epoll_ctl, int, epfd, int, op, int, fd, struct epoll_event *, event);
+_syscall4 (int, epoll_wait, int, epfd, struct epoll_event *, events, int, maxevents, int, timeout);
+#endif
+
+#endif
+
+
+#if defined(ENABLE_EPOLL)
+/*
+ * Main epoll() loop.
+ * does 3 actions :
+ * 0 (POLL_LOOP_ACTION_INIT) : initializes necessary private structures
+ * 1 (POLL_LOOP_ACTION_RUN) : runs the loop
+ * 2 (POLL_LOOP_ACTION_CLEAN) : cleans up
+ *
+ * returns 0 if initialization failed, !0 otherwise.
+ */
+
+int epoll_loop(int action)
+{
+ int next_time;
+ int status;
+ int fd;
+
+ int fds, count;
+ int pr, pw, sr, sw;
+ unsigned rn, ro, wn, wo; /* read new, read old, write new, write old */
+ struct epoll_event ev;
+
+ /* private data */
+ static struct epoll_event *epoll_events = NULL;
+ static int epoll_fd;
+
+ if (action == POLL_LOOP_ACTION_INIT) {
+ epoll_fd = epoll_create(global.maxsock + 1);
+ if (epoll_fd < 0)
+ return 0;
+ else {
+ epoll_events = (struct epoll_event*)
+ calloc(1, sizeof(struct epoll_event) * global.maxsock);
+ PrevReadEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ PrevWriteEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ }
+ return 1;
+ }
+ else if (action == POLL_LOOP_ACTION_CLEAN) {
+ if (PrevWriteEvent) free(PrevWriteEvent);
+ if (PrevReadEvent) free(PrevReadEvent);
+ if (epoll_events) free(epoll_events);
+ close(epoll_fd);
+ epoll_fd = 0;
+ return 1;
+ }
+
+ /* OK, it's POLL_LOOP_ACTION_RUN */
+
+ tv_now(&now);
+
+ while (1) {
+ next_time = process_runnable_tasks();
+
+ /* stop when there's no connection left and we don't allow them anymore */
+ if (!actconn && listeners == 0)
+ break;
+
+ for (fds = 0; (fds << INTBITS) < maxfd; fds++) {
+
+ rn = ((int*)StaticReadEvent)[fds]; ro = ((int*)PrevReadEvent)[fds];
+ wn = ((int*)StaticWriteEvent)[fds]; wo = ((int*)PrevWriteEvent)[fds];
+
+ if ((ro^rn) | (wo^wn)) {
+ for (count = 0, fd = fds << INTBITS; count < (1<<INTBITS) && fd < maxfd; count++, fd++) {
+#define FDSETS_ARE_INT_ALIGNED
+#ifdef FDSETS_ARE_INT_ALIGNED
+
+#define WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+#ifdef WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+ pr = (ro >> count) & 1;
+ pw = (wo >> count) & 1;
+ sr = (rn >> count) & 1;
+ sw = (wn >> count) & 1;
+#else
+ pr = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&ro);
+ pw = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&wo);
+ sr = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&rn);
+ sw = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&wn);
+#endif
+#else
+ pr = FD_ISSET(fd, PrevReadEvent);
+ pw = FD_ISSET(fd, PrevWriteEvent);
+ sr = FD_ISSET(fd, StaticReadEvent);
+ sw = FD_ISSET(fd, StaticWriteEvent);
+#endif
+ if (!((sr^pr) | (sw^pw)))
+ continue;
+
+ ev.events = (sr ? EPOLLIN : 0) | (sw ? EPOLLOUT : 0);
+ ev.data.fd = fd;
+
+#ifdef EPOLL_CTL_MOD_WORKAROUND
+ /* I encountered a rarely reproducible problem with
+ * EPOLL_CTL_MOD where a modified FD (systematically
+ * the one in epoll_events[0], fd#7) would sometimes
+ * be set EPOLL_OUT while asked for a read ! This is
+ * with the 2.4 epoll patch. The workaround is to
+ * delete then recreate in case of modification.
+ * This is in 2.4 up to epoll-lt-0.21 but not in 2.6
+ * nor RHEL kernels.
+ */
+
+ if ((pr | pw) && fdtab[fd].state != FD_STCLOSE)
+ epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev);
+
+ if ((sr | sw))
+ epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);
+#else
+ if ((pr | pw)) {
+ /* the file-descriptor already exists... */
+ if ((sr | sw)) {
+ /* ...and it will still exist */
+ if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &ev) < 0) {
+ // perror("epoll_ctl(MOD)");
+ // exit(1);
+ }
+ } else {
+ /* ...and it will be removed */
+ if (fdtab[fd].state != FD_STCLOSE &&
+ epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev) < 0) {
+ // perror("epoll_ctl(DEL)");
+ // exit(1);
+ }
+ }
+ } else {
+ /* the file-descriptor did not exist, let's add it */
+ if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
+ // perror("epoll_ctl(ADD)");
+ // exit(1);
+ }
+ }
+#endif // EPOLL_CTL_MOD_WORKAROUND
+ }
+ ((int*)PrevReadEvent)[fds] = rn;
+ ((int*)PrevWriteEvent)[fds] = wn;
+ }
+ }
+
+ /* now let's wait for events */
+ status = epoll_wait(epoll_fd, epoll_events, maxfd, next_time);
+ tv_now(&now);
+
+ for (count = 0; count < status; count++) {
+ fd = epoll_events[count].data.fd;
+
+ if (FD_ISSET(fd, StaticReadEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (epoll_events[count].events & ( EPOLLIN | EPOLLERR | EPOLLHUP ))
+ fdtab[fd].read(fd);
+ }
+
+ if (FD_ISSET(fd, StaticWriteEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (epoll_events[count].events & ( EPOLLOUT | EPOLLERR | EPOLLHUP ))
+ fdtab[fd].write(fd);
+ }
+ }
+ }
+ return 1;
+}
+#endif
+
+
+
+#if defined(ENABLE_POLL)
+/*
+ * Main poll() loop.
+ * does 3 actions :
+ * 0 (POLL_LOOP_ACTION_INIT) : initializes necessary private structures
+ * 1 (POLL_LOOP_ACTION_RUN) : runs the loop
+ * 2 (POLL_LOOP_ACTION_CLEAN) : cleans up
+ *
+ * returns 0 if initialization failed, !0 otherwise.
+ */
+
+int poll_loop(int action)
+{
+ int next_time;
+ int status;
+ int fd, nbfd;
+
+ int fds, count;
+ int sr, sw;
+ unsigned rn, wn; /* read new, write new */
+
+ /* private data */
+ static struct pollfd *poll_events = NULL;
+
+ if (action == POLL_LOOP_ACTION_INIT) {
+ poll_events = (struct pollfd*)
+ calloc(1, sizeof(struct pollfd) * global.maxsock);
+ return 1;
+ }
+ else if (action == POLL_LOOP_ACTION_CLEAN) {
+ if (poll_events)
+ free(poll_events);
+ return 1;
+ }
+
+ /* OK, it's POLL_LOOP_ACTION_RUN */
+
+ tv_now(&now);
+
+ while (1) {
+ next_time = process_runnable_tasks();
+
+ /* stop when there's no connection left and we don't allow them anymore */
+ if (!actconn && listeners == 0)
+ break;
+
+ nbfd = 0;
+ for (fds = 0; (fds << INTBITS) < maxfd; fds++) {
+
+ rn = ((int*)StaticReadEvent)[fds];
+ wn = ((int*)StaticWriteEvent)[fds];
+
+ if ((rn|wn)) {
+ for (count = 0, fd = fds << INTBITS; count < (1<<INTBITS) && fd < maxfd; count++, fd++) {
+#define FDSETS_ARE_INT_ALIGNED
+#ifdef FDSETS_ARE_INT_ALIGNED
+
+#define WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+#ifdef WE_REALLY_NOW_THAT_FDSETS_ARE_INTS
+ sr = (rn >> count) & 1;
+ sw = (wn >> count) & 1;
+#else
+ sr = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&rn);
+ sw = FD_ISSET(fd&((1<<INTBITS)-1), (typeof(fd_set*))&wn);
+#endif
+#else
+ sr = FD_ISSET(fd, StaticReadEvent);
+ sw = FD_ISSET(fd, StaticWriteEvent);
+#endif
+ if ((sr|sw)) {
+ poll_events[nbfd].fd = fd;
+ poll_events[nbfd].events = (sr ? POLLIN : 0) | (sw ? POLLOUT : 0);
+ nbfd++;
+ }
+ }
+ }
+ }
+
+ /* now let's wait for events */
+ status = poll(poll_events, nbfd, next_time);
+ tv_now(&now);
+
+ for (count = 0; status > 0 && count < nbfd; count++) {
+ fd = poll_events[count].fd;
+
+ if (!(poll_events[count].revents & ( POLLOUT | POLLIN | POLLERR | POLLHUP )))
+ continue;
+
+ /* ok, we found one active fd */
+ status--;
+
+ if (FD_ISSET(fd, StaticReadEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (poll_events[count].revents & ( POLLIN | POLLERR | POLLHUP ))
+ fdtab[fd].read(fd);
+ }
+
+ if (FD_ISSET(fd, StaticWriteEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ if (poll_events[count].revents & ( POLLOUT | POLLERR | POLLHUP ))
+ fdtab[fd].write(fd);
+ }
+ }
+ }
+ return 1;
+}
+#endif
+
+
+
+/*
+ * Main select() loop.
+ * does 3 actions :
+ * 0 (POLL_LOOP_ACTION_INIT) : initializes necessary private structures
+ * 1 (POLL_LOOP_ACTION_RUN) : runs the loop
+ * 2 (POLL_LOOP_ACTION_CLEAN) : cleans up
+ *
+ * returns 0 if initialization failed, !0 otherwise.
+ */
+
+
+int select_loop(int action)
+{
+ int next_time;
+ int status;
+ int fd,i;
+ struct timeval delta;
+ int readnotnull, writenotnull;
+ static fd_set *ReadEvent = NULL, *WriteEvent = NULL;
+
+ if (action == POLL_LOOP_ACTION_INIT) {
+ ReadEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ WriteEvent = (fd_set *)
+ calloc(1, sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE);
+ return 1;
+ }
+ else if (action == POLL_LOOP_ACTION_CLEAN) {
+ if (WriteEvent) free(WriteEvent);
+ if (ReadEvent) free(ReadEvent);
+ return 1;
+ }
+
+ /* OK, it's POLL_LOOP_ACTION_RUN */
+
+ tv_now(&now);
+
+ while (1) {
+ next_time = process_runnable_tasks();
+
+ /* stop when there's no connection left and we don't allow them anymore */
+ if (!actconn && listeners == 0)
+ break;
+
+ if (next_time > 0) { /* FIXME */
+ /* Convert to timeval */
+ /* to avoid eventual select loops due to timer precision */
+ next_time += SCHEDULER_RESOLUTION;
+ delta.tv_sec = next_time / 1000;
+ delta.tv_usec = (next_time % 1000) * 1000;
+ }
+ else if (next_time == 0) { /* allow select to return immediately when needed */
+ delta.tv_sec = delta.tv_usec = 0;
+ }
+
+
+ /* let's restore fdset state */
+
+ readnotnull = 0; writenotnull = 0;
+ for (i = 0; i < (maxfd + FD_SETSIZE - 1)/(8*sizeof(int)); i++) {
+ readnotnull |= (*(((int*)ReadEvent)+i) = *(((int*)StaticReadEvent)+i)) != 0;
+ writenotnull |= (*(((int*)WriteEvent)+i) = *(((int*)StaticWriteEvent)+i)) != 0;
+ }
+
+ // /* just a verification code, needs to be removed for performance */
+ // for (i=0; i<maxfd; i++) {
+ // if (FD_ISSET(i, ReadEvent) != FD_ISSET(i, StaticReadEvent))
+ // abort();
+ // if (FD_ISSET(i, WriteEvent) != FD_ISSET(i, StaticWriteEvent))
+ // abort();
+ //
+ // }
+
+ status = select(maxfd,
+ readnotnull ? ReadEvent : NULL,
+ writenotnull ? WriteEvent : NULL,
+ NULL,
+ (next_time >= 0) ? &delta : NULL);
+
+ /* this is an experiment on the separation of the select work */
+ // status = (readnotnull ? select(maxfd, ReadEvent, NULL, NULL, (next_time >= 0) ? &delta : NULL) : 0);
+ // status |= (writenotnull ? select(maxfd, NULL, WriteEvent, NULL, (next_time >= 0) ? &delta : NULL) : 0);
+
+ tv_now(&now);
+
+ if (status > 0) { /* must proceed with events */
+
+ int fds;
+ char count;
+
+ for (fds = 0; (fds << INTBITS) < maxfd; fds++)
+ if ((((int *)(ReadEvent))[fds] | ((int *)(WriteEvent))[fds]) != 0)
+ for (count = 1<<INTBITS, fd = fds << INTBITS; count && fd < maxfd; count--, fd++) {
+
+ /* if we specify read first, the accepts and zero reads will be
+ * seen first. Moreover, system buffers will be flushed faster.
+ */
+ if (FD_ISSET(fd, ReadEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ fdtab[fd].read(fd);
+ }
+
+ if (FD_ISSET(fd, WriteEvent)) {
+ if (fdtab[fd].state == FD_STCLOSE)
+ continue;
+ fdtab[fd].write(fd);
+ }
+ }
+ }
+ else {
+ // fprintf(stderr,"select returned %d, maxfd=%d\n", status, maxfd);
+ }
+ }
+ return 1;
+}
+
+
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/proto_http.c b/src/proto_http.c
new file mode 100644
index 0000000..9368362
--- /dev/null
+++ b/src/proto_http.c
@@ -0,0 +1,2769 @@
+/*
+ * HTTP protocol analyzer
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <haproxy/appsession.h>
+#include <haproxy/compat.h>
+#include <haproxy/config.h>
+#include <haproxy/memory.h>
+#include <haproxy/mini-clist.h>
+#include <haproxy/standard.h>
+#include <haproxy/time.h>
+#include <haproxy/uri_auth.h>
+#include <haproxy/version.h>
+
+#include <types/capture.h>
+#include <types/client.h>
+#include <types/global.h>
+#include <types/httperr.h>
+#include <types/polling.h>
+#include <types/proxy.h>
+#include <types/server.h>
+
+#include <proto/backend.h>
+#include <proto/buffers.h>
+#include <proto/fd.h>
+#include <proto/log.h>
+#include <proto/proto_http.h>
+#include <proto/queue.h>
+#include <proto/session.h>
+#include <proto/task.h>
+
+
+/* Warning: this one is an sprintf() fmt string, with <realm> as its only argument */
+const char *HTTP_401_fmt =
+ "HTTP/1.0 401 Unauthorized\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "WWW-Authenticate: Basic realm=\"%s\"\r\n"
+ "\r\n"
+ "<html><body><h1>401 Unauthorized</h1>\nYou need a valid user and password to access this content.\n</body></html>\n";
+
+
+#ifdef DEBUG_FULL
+static char *cli_stnames[5] = {"HDR", "DAT", "SHR", "SHW", "CLS" };
+static char *srv_stnames[7] = {"IDL", "CON", "HDR", "DAT", "SHR", "SHW", "CLS" };
+#endif
+
+
+/*
+ * returns a message to the client ; the connection is shut down for read,
+ * and the request is cleared so that no server connection can be initiated.
+ * The client must be in a valid state for this (HEADER, DATA ...).
+ * Nothing is performed on the server side.
+ * The reply buffer doesn't need to be empty before this.
+ */
+void client_retnclose(struct session *s, int len, const char *msg)
+{
+ FD_CLR(s->cli_fd, StaticReadEvent);
+ FD_SET(s->cli_fd, StaticWriteEvent);
+ tv_eternity(&s->crexpire);
+ if (s->proxy->clitimeout)
+ tv_delayfrom(&s->cwexpire, &now, s->proxy->clitimeout);
+ else
+ tv_eternity(&s->cwexpire);
+ shutdown(s->cli_fd, SHUT_RD);
+ s->cli_state = CL_STSHUTR;
+ buffer_flush(s->rep);
+ buffer_write(s->rep, msg, len);
+ s->req->l = 0;
+}
+
+
+/*
+ * returns a message into the rep buffer, and flushes the req buffer.
+ * The reply buffer doesn't need to be empty before this.
+ */
+void client_return(struct session *s, int len, const char *msg)
+{
+ buffer_flush(s->rep);
+ buffer_write(s->rep, msg, len);
+ s->req->l = 0;
+}
+
+
+/* This function turns the server state into the SV_STCLOSE, and sets
+ * indicators accordingly. Note that if <status> is 0, no message is
+ * returned.
+ */
+void srv_close_with_err(struct session *t, int err, int finst,
+ int status, int msglen, char *msg)
+{
+ t->srv_state = SV_STCLOSE;
+ if (status > 0) {
+ t->logs.status = status;
+ if (t->proxy->mode == PR_MODE_HTTP)
+ client_return(t, msglen, msg);
+ }
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= err;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= finst;
+}
+
+
+/* Processes the client and server jobs of a session task, then
+ * puts it back to the wait queue in a clean state, or
+ * cleans up its resources if it must be deleted. Returns
+ * the time the task accepts to wait, or TIME_ETERNITY for
+ * infinity.
+ */
+int process_session(struct task *t)
+{
+ struct session *s = t->context;
+ int fsm_resync = 0;
+
+ do {
+ fsm_resync = 0;
+ //fprintf(stderr,"before_cli:cli=%d, srv=%d\n", s->cli_state, s->srv_state);
+ fsm_resync |= process_cli(s);
+ //fprintf(stderr,"cli/srv:cli=%d, srv=%d\n", s->cli_state, s->srv_state);
+ fsm_resync |= process_srv(s);
+ //fprintf(stderr,"after_srv:cli=%d, srv=%d\n", s->cli_state, s->srv_state);
+ } while (fsm_resync);
+
+ if (s->cli_state != CL_STCLOSE || s->srv_state != SV_STCLOSE) {
+ struct timeval min1, min2;
+ s->res_cw = s->res_cr = s->res_sw = s->res_sr = RES_SILENT;
+
+ tv_min(&min1, &s->crexpire, &s->cwexpire);
+ tv_min(&min2, &s->srexpire, &s->swexpire);
+ tv_min(&min1, &min1, &s->cnexpire);
+ tv_min(&t->expire, &min1, &min2);
+
+ /* restore t to its place in the task list */
+ task_queue(t);
+
+#ifdef DEBUG_FULL
+ /* DEBUG code : this should never ever happen, otherwise it indicates
+ * that a task still has something to do and will provoke a quick loop.
+ */
+ if (tv_remain2(&now, &t->expire) <= 0)
+ exit(100);
+#endif
+
+ return tv_remain2(&now, &t->expire); /* nothing more to do */
+ }
+
+ s->proxy->nbconn--;
+ actconn--;
+
+ if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
+ int len;
+ len = sprintf(trash, "%08x:%s.closed[%04x:%04x]\n", s->uniq_id, s->proxy->id, (unsigned short)s->cli_fd, (unsigned short)s->srv_fd);
+ write(1, trash, len);
+ }
+
+ s->logs.t_close = tv_diff(&s->logs.tv_accept, &now);
+ if (s->rep != NULL)
+ s->logs.bytes = s->rep->total;
+
+ /* let's do a final log if we need it */
+ if (s->logs.logwait && (!(s->proxy->options & PR_O_NULLNOLOG) || s->req->total))
+ sess_log(s);
+
+ /* the task MUST not be in the run queue anymore */
+ task_delete(t);
+ session_free(s);
+ task_free(t);
+ return TIME_ETERNITY; /* rest in peace for eternity */
+}
+
+
+/*
+ * FIXME: This should move to the HTTP_flow_analyzer code
+ */
+
+/*
+ * manages the client FSM and its socket. BTW, it also tries to handle the
+ * cookie. It returns 1 if a state has changed (and a resync may be needed),
+ * 0 else.
+ */
+int process_cli(struct session *t)
+{
+ int s = t->srv_state;
+ int c = t->cli_state;
+ struct buffer *req = t->req;
+ struct buffer *rep = t->rep;
+ int method_checked = 0;
+ appsess *asession_temp = NULL;
+ appsess local_asession;
+
+#ifdef DEBUG_FULL
+ fprintf(stderr,"process_cli: c=%s s=%s set(r,w)=%d,%d exp(r,w)=%d.%d,%d.%d\n",
+ cli_stnames[c], srv_stnames[s],
+ FD_ISSET(t->cli_fd, StaticReadEvent), FD_ISSET(t->cli_fd, StaticWriteEvent),
+ t->crexpire.tv_sec, t->crexpire.tv_usec,
+ t->cwexpire.tv_sec, t->cwexpire.tv_usec);
+#endif
+ //fprintf(stderr,"process_cli: c=%d, s=%d, cr=%d, cw=%d, sr=%d, sw=%d\n", c, s,
+ //FD_ISSET(t->cli_fd, StaticReadEvent), FD_ISSET(t->cli_fd, StaticWriteEvent),
+ //FD_ISSET(t->srv_fd, StaticReadEvent), FD_ISSET(t->srv_fd, StaticWriteEvent)
+ //);
+ if (c == CL_STHEADERS) {
+ /* now parse the partial (or complete) headers */
+ while (req->lr < req->r) { /* this loop only sees one header at each iteration */
+ char *ptr;
+ int delete_header;
+ char *request_line = NULL;
+
+ ptr = req->lr;
+
+ /* look for the end of the current header */
+ while (ptr < req->r && *ptr != '\n' && *ptr != '\r')
+ ptr++;
+
+ if (ptr == req->h) { /* empty line, end of headers */
+ int line, len;
+
+ /*
+ * first, let's check that it's not a leading empty line, in
+ * which case we'll ignore and remove it (according to RFC2616).
+ */
+ if (req->h == req->data) {
+ /* to get a complete header line, we need the ending \r\n, \n\r, \r or \n too */
+ if (ptr > req->r - 2) {
+ /* this is a partial header, let's wait for more to come */
+ req->lr = ptr;
+ break;
+ }
+
+ /* now we know that *ptr is either \r or \n,
+ * and that there are at least 1 char after it.
+ */
+ if ((ptr[0] == ptr[1]) || (ptr[1] != '\r' && ptr[1] != '\n'))
+ req->lr = ptr + 1; /* \r\r, \n\n, \r[^\n], \n[^\r] */
+ else
+ req->lr = ptr + 2; /* \r\n or \n\r */
+ /* ignore empty leading lines */
+ buffer_replace2(req, req->h, req->lr, NULL, 0);
+ req->h = req->lr;
+ continue;
+ }
+
+ /* we can only get here after an end of headers */
+ /* we'll have something else to do here : add new headers ... */
+
+ if (t->flags & SN_CLDENY) {
+ /* no need to go further */
+ t->logs.status = 403;
+ t->logs.t_request = tv_diff(&t->logs.tv_accept, &now); /* let's log the request time */
+ client_retnclose(t, t->proxy->errmsg.len403, t->proxy->errmsg.msg403);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_PRXCOND;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_R;
+ return 1;
+ }
+
+ /* Right now, we know that we have processed the entire headers
+ * and that unwanted requests have been filtered out. We can do
+ * whatever we want.
+ */
+
+ if (t->proxy->uri_auth != NULL
+ && t->req_line.len >= t->proxy->uri_auth->uri_len + 4) { /* +4 for "GET /" */
+ if (!memcmp(t->req_line.str + 4,
+ t->proxy->uri_auth->uri_prefix, t->proxy->uri_auth->uri_len)
+ && !memcmp(t->req_line.str, "GET ", 4)) {
+ struct user_auth *user;
+ int authenticated;
+
+ /* we are in front of a interceptable URI. Let's check
+ * if there's an authentication and if it's valid.
+ */
+ user = t->proxy->uri_auth->users;
+ if (!user) {
+ /* no user auth required, it's OK */
+ authenticated = 1;
+ } else {
+ authenticated = 0;
+
+ /* a user list is defined, we have to check.
+ * skip 21 chars for "Authorization: Basic ".
+ */
+ if (t->auth_hdr.len < 21 || memcmp(t->auth_hdr.str + 14, " Basic ", 7))
+ user = NULL;
+
+ while (user) {
+ if ((t->auth_hdr.len == user->user_len + 21)
+ && !memcmp(t->auth_hdr.str+21, user->user_pwd, user->user_len)) {
+ authenticated = 1;
+ break;
+ }
+ user = user->next;
+ }
+ }
+
+ if (!authenticated) {
+ int msglen;
+
+ /* no need to go further */
+
+ msglen = sprintf(trash, HTTP_401_fmt, t->proxy->uri_auth->auth_realm);
+ t->logs.status = 401;
+ client_retnclose(t, msglen, trash);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_PRXCOND;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_R;
+ return 1;
+ }
+
+ t->cli_state = CL_STSHUTR;
+ req->rlim = req->data + BUFSIZE; /* no more rewrite needed */
+ t->logs.t_request = tv_diff(&t->logs.tv_accept, &now);
+ t->data_source = DATA_SRC_STATS;
+ t->data_state = DATA_ST_INIT;
+ produce_content(t);
+ return 1;
+ }
+ }
+
+
+ for (line = 0; line < t->proxy->nb_reqadd; line++) {
+ len = sprintf(trash, "%s\r\n", t->proxy->req_add[line]);
+ buffer_replace2(req, req->h, req->h, trash, len);
+ }
+
+ if (t->proxy->options & PR_O_FWDFOR) {
+ if (t->cli_addr.ss_family == AF_INET) {
+ unsigned char *pn;
+ pn = (unsigned char *)&((struct sockaddr_in *)&t->cli_addr)->sin_addr;
+ len = sprintf(trash, "X-Forwarded-For: %d.%d.%d.%d\r\n",
+ pn[0], pn[1], pn[2], pn[3]);
+ buffer_replace2(req, req->h, req->h, trash, len);
+ }
+ else if (t->cli_addr.ss_family == AF_INET6) {
+ char pn[INET6_ADDRSTRLEN];
+ inet_ntop(AF_INET6,
+ (const void *)&((struct sockaddr_in6 *)(&t->cli_addr))->sin6_addr,
+ pn, sizeof(pn));
+ len = sprintf(trash, "X-Forwarded-For: %s\r\n", pn);
+ buffer_replace2(req, req->h, req->h, trash, len);
+ }
+ }
+
+ /* add a "connection: close" line if needed */
+ if (t->proxy->options & PR_O_HTTP_CLOSE)
+ buffer_replace2(req, req->h, req->h, "Connection: close\r\n", 19);
+
+ if (!memcmp(req->data, "POST ", 5)) {
+ /* this is a POST request, which is not cacheable by default */
+ t->flags |= SN_POST;
+ }
+
+ t->cli_state = CL_STDATA;
+ req->rlim = req->data + BUFSIZE; /* no more rewrite needed */
+
+ t->logs.t_request = tv_diff(&t->logs.tv_accept, &now);
+ /* FIXME: we'll set the client in a wait state while we try to
+ * connect to the server. Is this really needed ? wouldn't it be
+ * better to release the maximum of system buffers instead ?
+ * The solution is to enable the FD but set its time-out to
+ * eternity as long as the server-side does not enable data xfer.
+ * CL_STDATA also has to take care of this, which is done below.
+ */
+ //FD_CLR(t->cli_fd, StaticReadEvent);
+ //tv_eternity(&t->crexpire);
+
+ /* FIXME: if we break here (as up to 1.1.23), having the client
+ * shutdown its connection can lead to an abort further.
+ * it's better to either return 1 or even jump directly to the
+ * data state which will save one schedule.
+ */
+ //break;
+
+ if (!t->proxy->clitimeout ||
+ (t->srv_state < SV_STDATA && t->proxy->srvtimeout))
+ /* If the client has no timeout, or if the server is not ready yet,
+ * and we know for sure that it can expire, then it's cleaner to
+ * disable the timeout on the client side so that too low values
+ * cannot make the sessions abort too early.
+ *
+ * FIXME-20050705: the server needs a way to re-enable this time-out
+ * when it switches its state, otherwise a client can stay connected
+ * indefinitely. This now seems to be OK.
+ */
+ tv_eternity(&t->crexpire);
+
+ goto process_data;
+ }
+
+ /* to get a complete header line, we need the ending \r\n, \n\r, \r or \n too */
+ if (ptr > req->r - 2) {
+ /* this is a partial header, let's wait for more to come */
+ req->lr = ptr;
+ break;
+ }
+
+ /* now we know that *ptr is either \r or \n,
+ * and that there are at least 1 char after it.
+ */
+ if ((ptr[0] == ptr[1]) || (ptr[1] != '\r' && ptr[1] != '\n'))
+ req->lr = ptr + 1; /* \r\r, \n\n, \r[^\n], \n[^\r] */
+ else
+ req->lr = ptr + 2; /* \r\n or \n\r */
+
+ /*
+ * now we know that we have a full header ; we can do whatever
+ * we want with these pointers :
+ * req->h = beginning of header
+ * ptr = end of header (first \r or \n)
+ * req->lr = beginning of next line (next rep->h)
+ * req->r = end of data (not used at this stage)
+ */
+
+ if (!method_checked && (t->proxy->appsession_name != NULL) &&
+ ((memcmp(req->h, "GET ", 4) == 0) || (memcmp(req->h, "POST ", 4) == 0)) &&
+ ((request_line = memchr(req->h, ';', req->lr - req->h)) != NULL)) {
+
+ /* skip ; */
+ request_line++;
+
+ /* look if we have a jsessionid */
+
+ if (strncasecmp(request_line, t->proxy->appsession_name, t->proxy->appsession_name_len) == 0) {
+
+ /* skip jsessionid= */
+ request_line += t->proxy->appsession_name_len + 1;
+
+ /* First try if we allready have an appsession */
+ asession_temp = &local_asession;
+
+ if ((asession_temp->sessid = pool_alloc_from(apools.sessid, apools.ses_msize)) == NULL) {
+ Alert("Not enough memory process_cli():asession_temp->sessid:calloc().\n");
+ send_log(t->proxy, LOG_ALERT, "Not enough Memory process_cli():asession_temp->sessid:calloc().\n");
+ return 0;
+ }
+
+ /* Copy the sessionid */
+ memcpy(asession_temp->sessid, request_line, t->proxy->appsession_len);
+ asession_temp->sessid[t->proxy->appsession_len] = 0;
+ asession_temp->serverid = NULL;
+
+ /* only do insert, if lookup fails */
+ if (chtbl_lookup(&(t->proxy->htbl_proxy), (void *)&asession_temp)) {
+ if ((asession_temp = pool_alloc(appsess)) == NULL) {
+ Alert("Not enough memory process_cli():asession:calloc().\n");
+ send_log(t->proxy, LOG_ALERT, "Not enough memory process_cli():asession:calloc().\n");
+ return 0;
+ }
+ asession_temp->sessid = local_asession.sessid;
+ asession_temp->serverid = local_asession.serverid;
+ chtbl_insert(&(t->proxy->htbl_proxy), (void *) asession_temp);
+ } /* end if (chtbl_lookup()) */
+ else {
+ /*free wasted memory;*/
+ pool_free_to(apools.sessid, local_asession.sessid);
+ }
+
+ tv_delayfrom(&asession_temp->expire, &now, t->proxy->appsession_timeout);
+ asession_temp->request_count++;
+
+#if defined(DEBUG_HASH)
+ print_table(&(t->proxy->htbl_proxy));
+#endif
+
+ if (asession_temp->serverid == NULL) {
+ Alert("Found Application Session without matching server.\n");
+ } else {
+ struct server *srv = t->proxy->srv;
+ while (srv) {
+ if (strcmp(srv->id, asession_temp->serverid) == 0) {
+ if (srv->state & SRV_RUNNING || t->proxy->options & PR_O_PERSIST) {
+ /* we found the server and it's usable */
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_VALID | SN_DIRECT | SN_ASSIGNED;
+ t->srv = srv;
+ break;
+ } else {
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_DOWN;
+ }
+ } /* end if (strcmp()) */
+ srv = srv->next;
+ }/* end while(srv) */
+ }/* end else of if (asession_temp->serverid == NULL) */
+ }/* end if (strncasecmp(request_line,t->proxy->appsession_name,apssesion_name_len) == 0) */
+ else {
+ //fprintf(stderr,">>>>>>>>>>>>>>>>>>>>>>NO SESSION\n");
+ }
+ method_checked = 1;
+ } /* end if (!method_checked ...) */
+ else{
+ //printf("No Methode-Header with Session-String\n");
+ }
+
+ if (t->logs.logwait & LW_REQ) {
+ /* we have a complete HTTP request that we must log */
+ int urilen;
+
+ if ((t->logs.uri = pool_alloc(requri)) == NULL) {
+ Alert("HTTP logging : out of memory.\n");
+ t->logs.status = 500;
+ client_retnclose(t, t->proxy->errmsg.len500, t->proxy->errmsg.msg500);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_PRXCOND;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_R;
+ return 1;
+ }
+
+ urilen = ptr - req->h;
+ if (urilen >= REQURI_LEN)
+ urilen = REQURI_LEN - 1;
+ memcpy(t->logs.uri, req->h, urilen);
+ t->logs.uri[urilen] = 0;
+
+ if (!(t->logs.logwait &= ~LW_REQ))
+ sess_log(t);
+ }
+ else if (t->logs.logwait & LW_REQHDR) {
+ struct cap_hdr *h;
+ int len;
+ for (h = t->proxy->req_cap; h; h = h->next) {
+ if ((h->namelen + 2 <= ptr - req->h) &&
+ (req->h[h->namelen] == ':') &&
+ (strncasecmp(req->h, h->name, h->namelen) == 0)) {
+
+ if (t->req_cap[h->index] == NULL)
+ t->req_cap[h->index] = pool_alloc_from(h->pool, h->len + 1);
+
+ len = ptr - (req->h + h->namelen + 2);
+ if (len > h->len)
+ len = h->len;
+
+ memcpy(t->req_cap[h->index], req->h + h->namelen + 2, len);
+ t->req_cap[h->index][len]=0;
+ }
+ }
+
+ }
+
+ delete_header = 0;
+
+ if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
+ int len, max;
+ len = sprintf(trash, "%08x:%s.clihdr[%04x:%04x]: ", t->uniq_id, t->proxy->id, (unsigned short)t->cli_fd, (unsigned short)t->srv_fd);
+ max = ptr - req->h;
+ UBOUND(max, sizeof(trash) - len - 1);
+ len += strlcpy2(trash + len, req->h, max + 1);
+ trash[len++] = '\n';
+ write(1, trash, len);
+ }
+
+
+ /* remove "connection: " if needed */
+ if (!delete_header && (t->proxy->options & PR_O_HTTP_CLOSE)
+ && (strncasecmp(req->h, "Connection: ", 12) == 0)) {
+ delete_header = 1;
+ }
+
+ /* try headers regexps */
+ if (!delete_header && t->proxy->req_exp != NULL
+ && !(t->flags & SN_CLDENY)) {
+ struct hdr_exp *exp;
+ char term;
+
+ term = *ptr;
+ *ptr = '\0';
+ exp = t->proxy->req_exp;
+ do {
+ if (regexec(exp->preg, req->h, MAX_MATCH, pmatch, 0) == 0) {
+ switch (exp->action) {
+ case ACT_ALLOW:
+ if (!(t->flags & SN_CLDENY))
+ t->flags |= SN_CLALLOW;
+ break;
+ case ACT_REPLACE:
+ if (!(t->flags & SN_CLDENY)) {
+ int len = exp_replace(trash, req->h, exp->replace, pmatch);
+ ptr += buffer_replace2(req, req->h, ptr, trash, len);
+ }
+ break;
+ case ACT_REMOVE:
+ if (!(t->flags & SN_CLDENY))
+ delete_header = 1;
+ break;
+ case ACT_DENY:
+ if (!(t->flags & SN_CLALLOW))
+ t->flags |= SN_CLDENY;
+ break;
+ case ACT_PASS: /* we simply don't deny this one */
+ break;
+ }
+ break;
+ }
+ } while ((exp = exp->next) != NULL);
+ *ptr = term; /* restore the string terminator */
+ }
+
+ /* Now look for cookies. Conforming to RFC2109, we have to support
+ * attributes whose name begin with a '$', and associate them with
+ * the right cookie, if we want to delete this cookie.
+ * So there are 3 cases for each cookie read :
+ * 1) it's a special attribute, beginning with a '$' : ignore it.
+ * 2) it's a server id cookie that we *MAY* want to delete : save
+ * some pointers on it (last semi-colon, beginning of cookie...)
+ * 3) it's an application cookie : we *MAY* have to delete a previous
+ * "special" cookie.
+ * At the end of loop, if a "special" cookie remains, we may have to
+ * remove it. If no application cookie persists in the header, we
+ * *MUST* delete it
+ */
+ if (!delete_header &&
+ (t->proxy->cookie_name != NULL || t->proxy->capture_name != NULL || t->proxy->appsession_name !=NULL)
+ && !(t->flags & SN_CLDENY) && (ptr >= req->h + 8)
+ && (strncasecmp(req->h, "Cookie: ", 8) == 0)) {
+ char *p1, *p2, *p3, *p4;
+ char *del_colon, *del_cookie, *colon;
+ int app_cookies;
+
+ p1 = req->h + 8; /* first char after 'Cookie: ' */
+ colon = p1;
+ /* del_cookie == NULL => nothing to be deleted */
+ del_colon = del_cookie = NULL;
+ app_cookies = 0;
+
+ while (p1 < ptr) {
+ /* skip spaces and colons, but keep an eye on these ones */
+ while (p1 < ptr) {
+ if (*p1 == ';' || *p1 == ',')
+ colon = p1;
+ else if (!isspace((int)*p1))
+ break;
+ p1++;
+ }
+
+ if (p1 == ptr)
+ break;
+
+ /* p1 is at the beginning of the cookie name */
+ p2 = p1;
+ while (p2 < ptr && *p2 != '=')
+ p2++;
+
+ if (p2 == ptr)
+ break;
+
+ p3 = p2 + 1; /* skips the '=' sign */
+ if (p3 == ptr)
+ break;
+
+ p4 = p3;
+ while (p4 < ptr && !isspace((int)*p4) && *p4 != ';' && *p4 != ',')
+ p4++;
+
+ /* here, we have the cookie name between p1 and p2,
+ * and its value between p3 and p4.
+ * we can process it :
+ *
+ * Cookie: NAME=VALUE;
+ * | || || |
+ * | || || +--> p4
+ * | || |+-------> p3
+ * | || +--------> p2
+ * | |+------------> p1
+ * | +-------------> colon
+ * +--------------------> req->h
+ */
+
+ if (*p1 == '$') {
+ /* skip this one */
+ }
+ else {
+ /* first, let's see if we want to capture it */
+ if (t->proxy->capture_name != NULL &&
+ t->logs.cli_cookie == NULL &&
+ (p4 - p1 >= t->proxy->capture_namelen) &&
+ memcmp(p1, t->proxy->capture_name, t->proxy->capture_namelen) == 0) {
+ int log_len = p4 - p1;
+
+ if ((t->logs.cli_cookie = pool_alloc(capture)) == NULL) {
+ Alert("HTTP logging : out of memory.\n");
+ } else {
+ if (log_len > t->proxy->capture_len)
+ log_len = t->proxy->capture_len;
+ memcpy(t->logs.cli_cookie, p1, log_len);
+ t->logs.cli_cookie[log_len] = 0;
+ }
+ }
+
+ if ((p2 - p1 == t->proxy->cookie_len) && (t->proxy->cookie_name != NULL) &&
+ (memcmp(p1, t->proxy->cookie_name, p2 - p1) == 0)) {
+ /* Cool... it's the right one */
+ struct server *srv = t->proxy->srv;
+ char *delim;
+
+ /* if we're in cookie prefix mode, we'll search the delimitor so that we
+ * have the server ID betweek p3 and delim, and the original cookie between
+ * delim+1 and p4. Otherwise, delim==p4 :
+ *
+ * Cookie: NAME=SRV~VALUE;
+ * | || || | |
+ * | || || | +--> p4
+ * | || || +--------> delim
+ * | || |+-----------> p3
+ * | || +------------> p2
+ * | |+----------------> p1
+ * | +-----------------> colon
+ * +------------------------> req->h
+ */
+
+ if (t->proxy->options & PR_O_COOK_PFX) {
+ for (delim = p3; delim < p4; delim++)
+ if (*delim == COOKIE_DELIM)
+ break;
+ }
+ else
+ delim = p4;
+
+
+ /* Here, we'll look for the first running server which supports the cookie.
+ * This allows to share a same cookie between several servers, for example
+ * to dedicate backup servers to specific servers only.
+ * However, to prevent clients from sticking to cookie-less backup server
+ * when they have incidentely learned an empty cookie, we simply ignore
+ * empty cookies and mark them as invalid.
+ */
+ if (delim == p3)
+ srv = NULL;
+
+ while (srv) {
+ if ((srv->cklen == delim - p3) && !memcmp(p3, srv->cookie, delim - p3)) {
+ if (srv->state & SRV_RUNNING || t->proxy->options & PR_O_PERSIST) {
+ /* we found the server and it's usable */
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_VALID | SN_DIRECT | SN_ASSIGNED;
+ t->srv = srv;
+ break;
+ } else {
+ /* we found a server, but it's down */
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_DOWN;
+ }
+ }
+ srv = srv->next;
+ }
+
+ if (!srv && !(t->flags & SN_CK_DOWN)) {
+ /* no server matched this cookie */
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_INVALID;
+ }
+
+ /* depending on the cookie mode, we may have to either :
+ * - delete the complete cookie if we're in insert+indirect mode, so that
+ * the server never sees it ;
+ * - remove the server id from the cookie value, and tag the cookie as an
+ * application cookie so that it does not get accidentely removed later,
+ * if we're in cookie prefix mode
+ */
+ if ((t->proxy->options & PR_O_COOK_PFX) && (delim != p4)) {
+ buffer_replace2(req, p3, delim + 1, NULL, 0);
+ p4 -= (delim + 1 - p3);
+ ptr -= (delim + 1 - p3);
+ del_cookie = del_colon = NULL;
+ app_cookies++; /* protect the header from deletion */
+ }
+ else if (del_cookie == NULL &&
+ (t->proxy->options & (PR_O_COOK_INS | PR_O_COOK_IND)) == (PR_O_COOK_INS | PR_O_COOK_IND)) {
+ del_cookie = p1;
+ del_colon = colon;
+ }
+ } else {
+ /* now we know that we must keep this cookie since it's
+ * not ours. But if we wanted to delete our cookie
+ * earlier, we cannot remove the complete header, but we
+ * can remove the previous block itself.
+ */
+ app_cookies++;
+
+ if (del_cookie != NULL) {
+ buffer_replace2(req, del_cookie, p1, NULL, 0);
+ p4 -= (p1 - del_cookie);
+ ptr -= (p1 - del_cookie);
+ del_cookie = del_colon = NULL;
+ }
+ }
+
+ if ((t->proxy->appsession_name != NULL) &&
+ (memcmp(p1, t->proxy->appsession_name, p2 - p1) == 0)) {
+ /* first, let's see if the cookie is our appcookie*/
+
+ /* Cool... it's the right one */
+
+ asession_temp = &local_asession;
+
+ if ((asession_temp->sessid = pool_alloc_from(apools.sessid, apools.ses_msize)) == NULL) {
+ Alert("Not enough memory process_cli():asession->sessid:malloc().\n");
+ send_log(t->proxy, LOG_ALERT, "Not enough memory process_cli():asession->sessid:malloc().\n");
+ return 0;
+ }
+
+ memcpy(asession_temp->sessid, p3, t->proxy->appsession_len);
+ asession_temp->sessid[t->proxy->appsession_len] = 0;
+ asession_temp->serverid = NULL;
+
+ /* only do insert, if lookup fails */
+ if (chtbl_lookup(&(t->proxy->htbl_proxy), (void *) &asession_temp) != 0) {
+ if ((asession_temp = pool_alloc(appsess)) == NULL) {
+ Alert("Not enough memory process_cli():asession:calloc().\n");
+ send_log(t->proxy, LOG_ALERT, "Not enough memory process_cli():asession:calloc().\n");
+ return 0;
+ }
+
+ asession_temp->sessid = local_asession.sessid;
+ asession_temp->serverid = local_asession.serverid;
+ chtbl_insert(&(t->proxy->htbl_proxy), (void *) asession_temp);
+ } else {
+ /* free wasted memory */
+ pool_free_to(apools.sessid, local_asession.sessid);
+ }
+
+ if (asession_temp->serverid == NULL) {
+ Alert("Found Application Session without matching server.\n");
+ } else {
+ struct server *srv = t->proxy->srv;
+ while (srv) {
+ if (strcmp(srv->id, asession_temp->serverid) == 0) {
+ if (srv->state & SRV_RUNNING || t->proxy->options & PR_O_PERSIST) {
+ /* we found the server and it's usable */
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_VALID | SN_DIRECT | SN_ASSIGNED;
+ t->srv = srv;
+ break;
+ } else {
+ t->flags &= ~SN_CK_MASK;
+ t->flags |= SN_CK_DOWN;
+ }
+ }
+ srv = srv->next;
+ }/* end while(srv) */
+ }/* end else if server == NULL */
+
+ tv_delayfrom(&asession_temp->expire, &now, t->proxy->appsession_timeout);
+ }/* end if ((t->proxy->appsession_name != NULL) ... */
+ }
+
+ /* we'll have to look for another cookie ... */
+ p1 = p4;
+ } /* while (p1 < ptr) */
+
+ /* There's no more cookie on this line.
+ * We may have marked the last one(s) for deletion.
+ * We must do this now in two ways :
+ * - if there is no app cookie, we simply delete the header ;
+ * - if there are app cookies, we must delete the end of the
+ * string properly, including the colon/semi-colon before
+ * the cookie name.
+ */
+ if (del_cookie != NULL) {
+ if (app_cookies) {
+ buffer_replace2(req, del_colon, ptr, NULL, 0);
+ /* WARNING! <ptr> becomes invalid for now. If some code
+ * below needs to rely on it before the end of the global
+ * header loop, we need to correct it with this code :
+ */
+ ptr = del_colon;
+ }
+ else
+ delete_header = 1;
+ }
+ } /* end of cookie processing on this header */
+
+ /* let's look if we have to delete this header */
+ if (delete_header && !(t->flags & SN_CLDENY)) {
+ buffer_replace2(req, req->h, req->lr, NULL, 0);
+ /* WARNING: ptr is not valid anymore, since the header may have
+ * been deleted or truncated ! */
+ } else {
+ /* try to catch the first line as the request */
+ if (t->req_line.len < 0) {
+ t->req_line.str = req->h;
+ t->req_line.len = ptr - req->h;
+ }
+
+ /* We might also need the 'Authorization: ' header */
+ if (t->auth_hdr.len < 0 &&
+ t->proxy->uri_auth != NULL &&
+ ptr > req->h + 15 &&
+ !strncasecmp("Authorization: ", req->h, 15)) {
+ t->auth_hdr.str = req->h;
+ t->auth_hdr.len = ptr - req->h;
+ }
+ }
+
+ req->h = req->lr;
+ } /* while (req->lr < req->r) */
+
+ /* end of header processing (even if incomplete) */
+
+ if ((req->l < req->rlim - req->data) && ! FD_ISSET(t->cli_fd, StaticReadEvent)) {
+ /* fd in StaticReadEvent was disabled, perhaps because of a previous buffer
+ * full. We cannot loop here since event_cli_read will disable it only if
+ * req->l == rlim-data
+ */
+ FD_SET(t->cli_fd, StaticReadEvent);
+ if (t->proxy->clitimeout)
+ tv_delayfrom(&t->crexpire, &now, t->proxy->clitimeout);
+ else
+ tv_eternity(&t->crexpire);
+ }
+
+ /* Since we are in header mode, if there's no space left for headers, we
+ * won't be able to free more later, so the session will never terminate.
+ */
+ if (req->l >= req->rlim - req->data) {
+ t->logs.status = 400;
+ client_retnclose(t, t->proxy->errmsg.len400, t->proxy->errmsg.msg400);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_PRXCOND;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_R;
+ return 1;
+ }
+ else if (t->res_cr == RES_ERROR || t->res_cr == RES_NULL) {
+ /* read error, or last read : give up. */
+ tv_eternity(&t->crexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLICL;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_R;
+ return 1;
+ }
+ else if (tv_cmp2_ms(&t->crexpire, &now) <= 0) {
+
+ /* read timeout : give up with an error message.
+ */
+ t->logs.status = 408;
+ client_retnclose(t, t->proxy->errmsg.len408, t->proxy->errmsg.msg408);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLITO;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_R;
+ return 1;
+ }
+
+ return t->cli_state != CL_STHEADERS;
+ }
+ else if (c == CL_STDATA) {
+ process_data:
+ /* FIXME: this error handling is partly buggy because we always report
+ * a 'DATA' phase while we don't know if the server was in IDLE, CONN
+ * or HEADER phase. BTW, it's not logical to expire the client while
+ * we're waiting for the server to connect.
+ */
+ /* read or write error */
+ if (t->res_cw == RES_ERROR || t->res_cr == RES_ERROR) {
+ tv_eternity(&t->crexpire);
+ tv_eternity(&t->cwexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLICL;
+ if (!(t->flags & SN_FINST_MASK)) {
+ if (t->pend_pos)
+ t->flags |= SN_FINST_Q;
+ else if (s == SV_STCONN)
+ t->flags |= SN_FINST_C;
+ else
+ t->flags |= SN_FINST_D;
+ }
+ return 1;
+ }
+ /* last read, or end of server write */
+ else if (t->res_cr == RES_NULL || s == SV_STSHUTW || s == SV_STCLOSE) {
+ FD_CLR(t->cli_fd, StaticReadEvent);
+ tv_eternity(&t->crexpire);
+ shutdown(t->cli_fd, SHUT_RD);
+ t->cli_state = CL_STSHUTR;
+ return 1;
+ }
+ /* last server read and buffer empty */
+ else if ((s == SV_STSHUTR || s == SV_STCLOSE) && (rep->l == 0)) {
+ FD_CLR(t->cli_fd, StaticWriteEvent);
+ tv_eternity(&t->cwexpire);
+ shutdown(t->cli_fd, SHUT_WR);
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->cli_fd, StaticReadEvent);
+ if (t->proxy->clitimeout)
+ tv_delayfrom(&t->crexpire, &now, t->proxy->clitimeout);
+ t->cli_state = CL_STSHUTW;
+ //fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
+ return 1;
+ }
+ /* read timeout */
+ else if (tv_cmp2_ms(&t->crexpire, &now) <= 0) {
+ FD_CLR(t->cli_fd, StaticReadEvent);
+ tv_eternity(&t->crexpire);
+ shutdown(t->cli_fd, SHUT_RD);
+ t->cli_state = CL_STSHUTR;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLITO;
+ if (!(t->flags & SN_FINST_MASK)) {
+ if (t->pend_pos)
+ t->flags |= SN_FINST_Q;
+ else if (s == SV_STCONN)
+ t->flags |= SN_FINST_C;
+ else
+ t->flags |= SN_FINST_D;
+ }
+ return 1;
+ }
+ /* write timeout */
+ else if (tv_cmp2_ms(&t->cwexpire, &now) <= 0) {
+ FD_CLR(t->cli_fd, StaticWriteEvent);
+ tv_eternity(&t->cwexpire);
+ shutdown(t->cli_fd, SHUT_WR);
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->cli_fd, StaticReadEvent);
+ if (t->proxy->clitimeout)
+ tv_delayfrom(&t->crexpire, &now, t->proxy->clitimeout);
+
+ t->cli_state = CL_STSHUTW;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLITO;
+ if (!(t->flags & SN_FINST_MASK)) {
+ if (t->pend_pos)
+ t->flags |= SN_FINST_Q;
+ else if (s == SV_STCONN)
+ t->flags |= SN_FINST_C;
+ else
+ t->flags |= SN_FINST_D;
+ }
+ return 1;
+ }
+
+ if (req->l >= req->rlim - req->data) {
+ /* no room to read more data */
+ if (FD_ISSET(t->cli_fd, StaticReadEvent)) {
+ /* stop reading until we get some space */
+ FD_CLR(t->cli_fd, StaticReadEvent);
+ tv_eternity(&t->crexpire);
+ }
+ } else {
+ /* there's still some space in the buffer */
+ if (! FD_ISSET(t->cli_fd, StaticReadEvent)) {
+ FD_SET(t->cli_fd, StaticReadEvent);
+ if (!t->proxy->clitimeout ||
+ (t->srv_state < SV_STDATA && t->proxy->srvtimeout))
+ /* If the client has no timeout, or if the server not ready yet, and we
+ * know for sure that it can expire, then it's cleaner to disable the
+ * timeout on the client side so that too low values cannot make the
+ * sessions abort too early.
+ */
+ tv_eternity(&t->crexpire);
+ else
+ tv_delayfrom(&t->crexpire, &now, t->proxy->clitimeout);
+ }
+ }
+
+ if ((rep->l == 0) ||
+ ((s < SV_STDATA) /* FIXME: this may be optimized && (rep->w == rep->h)*/)) {
+ if (FD_ISSET(t->cli_fd, StaticWriteEvent)) {
+ FD_CLR(t->cli_fd, StaticWriteEvent); /* stop writing */
+ tv_eternity(&t->cwexpire);
+ }
+ } else {
+ /* buffer not empty */
+ if (! FD_ISSET(t->cli_fd, StaticWriteEvent)) {
+ FD_SET(t->cli_fd, StaticWriteEvent); /* restart writing */
+ if (t->proxy->clitimeout) {
+ tv_delayfrom(&t->cwexpire, &now, t->proxy->clitimeout);
+ /* FIXME: to prevent the client from expiring read timeouts during writes,
+ * we refresh it. */
+ t->crexpire = t->cwexpire;
+ }
+ else
+ tv_eternity(&t->cwexpire);
+ }
+ }
+ return 0; /* other cases change nothing */
+ }
+ else if (c == CL_STSHUTR) {
+ if (t->res_cw == RES_ERROR) {
+ tv_eternity(&t->cwexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLICL;
+ if (!(t->flags & SN_FINST_MASK)) {
+ if (t->pend_pos)
+ t->flags |= SN_FINST_Q;
+ else if (s == SV_STCONN)
+ t->flags |= SN_FINST_C;
+ else
+ t->flags |= SN_FINST_D;
+ }
+ return 1;
+ }
+ else if ((s == SV_STSHUTR || s == SV_STCLOSE) && (rep->l == 0)
+ && !(t->flags & SN_SELF_GEN)) {
+ tv_eternity(&t->cwexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ return 1;
+ }
+ else if (tv_cmp2_ms(&t->cwexpire, &now) <= 0) {
+ tv_eternity(&t->cwexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLITO;
+ if (!(t->flags & SN_FINST_MASK)) {
+ if (t->pend_pos)
+ t->flags |= SN_FINST_Q;
+ else if (s == SV_STCONN)
+ t->flags |= SN_FINST_C;
+ else
+ t->flags |= SN_FINST_D;
+ }
+ return 1;
+ }
+
+ if (t->flags & SN_SELF_GEN) {
+ produce_content(t);
+ if (rep->l == 0) {
+ tv_eternity(&t->cwexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ return 1;
+ }
+ }
+
+ if ((rep->l == 0)
+ || ((s == SV_STHEADERS) /* FIXME: this may be optimized && (rep->w == rep->h)*/)) {
+ if (FD_ISSET(t->cli_fd, StaticWriteEvent)) {
+ FD_CLR(t->cli_fd, StaticWriteEvent); /* stop writing */
+ tv_eternity(&t->cwexpire);
+ }
+ } else {
+ /* buffer not empty */
+ if (! FD_ISSET(t->cli_fd, StaticWriteEvent)) {
+ FD_SET(t->cli_fd, StaticWriteEvent); /* restart writing */
+ if (t->proxy->clitimeout) {
+ tv_delayfrom(&t->cwexpire, &now, t->proxy->clitimeout);
+ /* FIXME: to prevent the client from expiring read timeouts during writes,
+ * we refresh it. */
+ t->crexpire = t->cwexpire;
+ }
+ else
+ tv_eternity(&t->cwexpire);
+ }
+ }
+ return 0;
+ }
+ else if (c == CL_STSHUTW) {
+ if (t->res_cr == RES_ERROR) {
+ tv_eternity(&t->crexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLICL;
+ if (!(t->flags & SN_FINST_MASK)) {
+ if (t->pend_pos)
+ t->flags |= SN_FINST_Q;
+ else if (s == SV_STCONN)
+ t->flags |= SN_FINST_C;
+ else
+ t->flags |= SN_FINST_D;
+ }
+ return 1;
+ }
+ else if (t->res_cr == RES_NULL || s == SV_STSHUTW || s == SV_STCLOSE) {
+ tv_eternity(&t->crexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ return 1;
+ }
+ else if (tv_cmp2_ms(&t->crexpire, &now) <= 0) {
+ tv_eternity(&t->crexpire);
+ fd_delete(t->cli_fd);
+ t->cli_state = CL_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_CLITO;
+ if (!(t->flags & SN_FINST_MASK)) {
+ if (t->pend_pos)
+ t->flags |= SN_FINST_Q;
+ else if (s == SV_STCONN)
+ t->flags |= SN_FINST_C;
+ else
+ t->flags |= SN_FINST_D;
+ }
+ return 1;
+ }
+ else if (req->l >= req->rlim - req->data) {
+ /* no room to read more data */
+
+ /* FIXME-20050705: is it possible for a client to maintain a session
+ * after the timeout by sending more data after it receives a close ?
+ */
+
+ if (FD_ISSET(t->cli_fd, StaticReadEvent)) {
+ /* stop reading until we get some space */
+ FD_CLR(t->cli_fd, StaticReadEvent);
+ tv_eternity(&t->crexpire);
+ //fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
+ }
+ } else {
+ /* there's still some space in the buffer */
+ if (! FD_ISSET(t->cli_fd, StaticReadEvent)) {
+ FD_SET(t->cli_fd, StaticReadEvent);
+ if (t->proxy->clitimeout)
+ tv_delayfrom(&t->crexpire, &now, t->proxy->clitimeout);
+ else
+ tv_eternity(&t->crexpire);
+ //fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
+ }
+ }
+ return 0;
+ }
+ else { /* CL_STCLOSE: nothing to do */
+ if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
+ int len;
+ len = sprintf(trash, "%08x:%s.clicls[%04x:%04x]\n", t->uniq_id, t->proxy->id, (unsigned short)t->cli_fd, (unsigned short)t->srv_fd);
+ write(1, trash, len);
+ }
+ return 0;
+ }
+ return 0;
+}
+
+
+/*
+ * manages the server FSM and its socket. It returns 1 if a state has changed
+ * (and a resync may be needed), 0 else.
+ */
+int process_srv(struct session *t)
+{
+ int s = t->srv_state;
+ int c = t->cli_state;
+ struct buffer *req = t->req;
+ struct buffer *rep = t->rep;
+ appsess *asession_temp = NULL;
+ appsess local_asession;
+ int conn_err;
+
+#ifdef DEBUG_FULL
+ fprintf(stderr,"process_srv: c=%s, s=%s\n", cli_stnames[c], srv_stnames[s]);
+#endif
+ //fprintf(stderr,"process_srv: c=%d, s=%d, cr=%d, cw=%d, sr=%d, sw=%d\n", c, s,
+ //FD_ISSET(t->cli_fd, StaticReadEvent), FD_ISSET(t->cli_fd, StaticWriteEvent),
+ //FD_ISSET(t->srv_fd, StaticReadEvent), FD_ISSET(t->srv_fd, StaticWriteEvent)
+ //);
+ if (s == SV_STIDLE) {
+ if (c == CL_STHEADERS)
+ return 0; /* stay in idle, waiting for data to reach the client side */
+ else if (c == CL_STCLOSE || c == CL_STSHUTW ||
+ (c == CL_STSHUTR &&
+ (t->req->l == 0 || t->proxy->options & PR_O_ABRT_CLOSE))) { /* give up */
+ tv_eternity(&t->cnexpire);
+ if (t->pend_pos)
+ t->logs.t_queue = tv_diff(&t->logs.tv_accept, &now);
+ /* note that this must not return any error because it would be able to
+ * overwrite the client_retnclose() output.
+ */
+ srv_close_with_err(t, SN_ERR_CLICL, t->pend_pos ? SN_FINST_Q : SN_FINST_C, 0, 0, NULL);
+
+ return 1;
+ }
+ else {
+ /* Right now, we will need to create a connection to the server.
+ * We might already have tried, and got a connection pending, in
+ * which case we will not do anything till it's pending. It's up
+ * to any other session to release it and wake us up again.
+ */
+ if (t->pend_pos) {
+ if (tv_cmp2_ms(&t->cnexpire, &now) > 0)
+ return 0;
+ else {
+ /* we've been waiting too long here */
+ tv_eternity(&t->cnexpire);
+ t->logs.t_queue = tv_diff(&t->logs.tv_accept, &now);
+ srv_close_with_err(t, SN_ERR_SRVTO, SN_FINST_Q,
+ 503, t->proxy->errmsg.len503, t->proxy->errmsg.msg503);
+ if (t->srv)
+ t->srv->failed_conns++;
+ t->proxy->failed_conns++;
+ return 1;
+ }
+ }
+
+ do {
+ /* first, get a connection */
+ if (srv_redispatch_connect(t))
+ return t->srv_state != SV_STIDLE;
+
+ /* try to (re-)connect to the server, and fail if we expire the
+ * number of retries.
+ */
+ if (srv_retryable_connect(t)) {
+ t->logs.t_queue = tv_diff(&t->logs.tv_accept, &now);
+ return t->srv_state != SV_STIDLE;
+ }
+
+ } while (1);
+ }
+ }
+ else if (s == SV_STCONN) { /* connection in progress */
+ if (c == CL_STCLOSE || c == CL_STSHUTW ||
+ (c == CL_STSHUTR &&
+ (t->req->l == 0 || t->proxy->options & PR_O_ABRT_CLOSE))) { /* give up */
+ tv_eternity(&t->cnexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv)
+ t->srv->cur_sess--;
+
+ /* note that this must not return any error because it would be able to
+ * overwrite the client_retnclose() output.
+ */
+ srv_close_with_err(t, SN_ERR_CLICL, SN_FINST_C, 0, 0, NULL);
+ return 1;
+ }
+ if (t->res_sw == RES_SILENT && tv_cmp2_ms(&t->cnexpire, &now) > 0) {
+ //fprintf(stderr,"1: c=%d, s=%d, now=%d.%06d, exp=%d.%06d\n", c, s, now.tv_sec, now.tv_usec, t->cnexpire.tv_sec, t->cnexpire.tv_usec);
+ return 0; /* nothing changed */
+ }
+ else if (t->res_sw == RES_SILENT || t->res_sw == RES_ERROR) {
+ /* timeout, asynchronous connect error or first write error */
+ //fprintf(stderr,"2: c=%d, s=%d\n", c, s);
+
+ fd_delete(t->srv_fd);
+ if (t->srv)
+ t->srv->cur_sess--;
+
+ if (t->res_sw == RES_SILENT)
+ conn_err = SN_ERR_SRVTO; // it was a connect timeout.
+ else
+ conn_err = SN_ERR_SRVCL; // it was an asynchronous connect error.
+
+ /* ensure that we have enough retries left */
+ if (srv_count_retry_down(t, conn_err))
+ return 1;
+
+ do {
+ /* Now we will try to either reconnect to the same server or
+ * connect to another server. If the connection gets queued
+ * because all servers are saturated, then we will go back to
+ * the SV_STIDLE state.
+ */
+ if (srv_retryable_connect(t)) {
+ t->logs.t_queue = tv_diff(&t->logs.tv_accept, &now);
+ return t->srv_state != SV_STCONN;
+ }
+
+ /* we need to redispatch the connection to another server */
+ if (srv_redispatch_connect(t))
+ return t->srv_state != SV_STCONN;
+ } while (1);
+ }
+ else { /* no error or write 0 */
+ t->logs.t_connect = tv_diff(&t->logs.tv_accept, &now);
+
+ //fprintf(stderr,"3: c=%d, s=%d\n", c, s);
+ if (req->l == 0) /* nothing to write */ {
+ FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+ } else /* need the right to write */ {
+ FD_SET(t->srv_fd, StaticWriteEvent);
+ if (t->proxy->srvtimeout) {
+ tv_delayfrom(&t->swexpire, &now, t->proxy->srvtimeout);
+ /* FIXME: to prevent the server from expiring read timeouts during writes,
+ * we refresh it. */
+ t->srexpire = t->swexpire;
+ }
+ else
+ tv_eternity(&t->swexpire);
+ }
+
+ if (t->proxy->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+ else
+ tv_eternity(&t->srexpire);
+
+ t->srv_state = SV_STDATA;
+ if (t->srv)
+ t->srv->cum_sess++;
+ rep->rlim = rep->data + BUFSIZE; /* no rewrite needed */
+
+ /* if the user wants to log as soon as possible, without counting
+ bytes from the server, then this is the right moment. */
+ if (t->proxy->to_log && !(t->logs.logwait & LW_BYTES)) {
+ t->logs.t_close = t->logs.t_connect; /* to get a valid end date */
+ sess_log(t);
+ }
+ }
+ else {
+ t->srv_state = SV_STHEADERS;
+ if (t->srv)
+ t->srv->cum_sess++;
+ rep->rlim = rep->data + BUFSIZE - MAXREWRITE; /* rewrite needed */
+ }
+ tv_eternity(&t->cnexpire);
+ return 1;
+ }
+ }
+ else if (s == SV_STHEADERS) { /* receiving server headers */
+ /* now parse the partial (or complete) headers */
+ while (rep->lr < rep->r) { /* this loop only sees one header at each iteration */
+ char *ptr;
+ int delete_header;
+
+ ptr = rep->lr;
+
+ /* look for the end of the current header */
+ while (ptr < rep->r && *ptr != '\n' && *ptr != '\r')
+ ptr++;
+
+ if (ptr == rep->h) {
+ int line, len;
+
+ /* we can only get here after an end of headers */
+
+ /* first, we'll block if security checks have caught nasty things */
+ if (t->flags & SN_CACHEABLE) {
+ if ((t->flags & SN_CACHE_COOK) &&
+ (t->flags & SN_SCK_ANY) &&
+ (t->proxy->options & PR_O_CHK_CACHE)) {
+
+ /* we're in presence of a cacheable response containing
+ * a set-cookie header. We'll block it as requested by
+ * the 'checkcache' option, and send an alert.
+ */
+ tv_eternity(&t->srexpire);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv) {
+ t->srv->cur_sess--;
+ t->srv->failed_secu++;
+ }
+ t->proxy->failed_secu++;
+ t->srv_state = SV_STCLOSE;
+ t->logs.status = 502;
+ client_return(t, t->proxy->errmsg.len502, t->proxy->errmsg.msg502);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_PRXCOND;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_H;
+
+ Alert("Blocking cacheable cookie in response from instance %s, server %s.\n", t->proxy->id, t->srv->id);
+ send_log(t->proxy, LOG_ALERT, "Blocking cacheable cookie in response from instance %s, server %s.\n", t->proxy->id, t->srv->id);
+
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ }
+
+ /* next, we'll block if an 'rspideny' or 'rspdeny' filter matched */
+ if (t->flags & SN_SVDENY) {
+ tv_eternity(&t->srexpire);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv) {
+ t->srv->cur_sess--;
+ t->srv->failed_secu++;
+ }
+ t->proxy->failed_secu++;
+ t->srv_state = SV_STCLOSE;
+ t->logs.status = 502;
+ client_return(t, t->proxy->errmsg.len502, t->proxy->errmsg.msg502);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_PRXCOND;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_H;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+
+ /* we'll have something else to do here : add new headers ... */
+
+ if ((t->srv) && !(t->flags & SN_DIRECT) && (t->proxy->options & PR_O_COOK_INS) &&
+ (!(t->proxy->options & PR_O_COOK_POST) || (t->flags & SN_POST))) {
+ /* the server is known, it's not the one the client requested, we have to
+ * insert a set-cookie here, except if we want to insert only on POST
+ * requests and this one isn't. Note that servers which don't have cookies
+ * (eg: some backup servers) will return a full cookie removal request.
+ */
+ len = sprintf(trash, "Set-Cookie: %s=%s; path=/\r\n",
+ t->proxy->cookie_name,
+ t->srv->cookie ? t->srv->cookie : "; Expires=Thu, 01-Jan-1970 00:00:01 GMT");
+
+ t->flags |= SN_SCK_INSERTED;
+
+ /* Here, we will tell an eventual cache on the client side that we don't
+ * want it to cache this reply because HTTP/1.0 caches also cache cookies !
+ * Some caches understand the correct form: 'no-cache="set-cookie"', but
+ * others don't (eg: apache <= 1.3.26). So we use 'private' instead.
+ */
+ if (t->proxy->options & PR_O_COOK_NOC)
+ //len += sprintf(newhdr + len, "Cache-control: no-cache=\"set-cookie\"\r\n");
+ len += sprintf(trash + len, "Cache-control: private\r\n");
+
+ if (rep->data + rep->l < rep->h)
+ /* The data has been stolen, we will crash cleanly instead of corrupting memory */
+ *(int *)0 = 0;
+ buffer_replace2(rep, rep->h, rep->h, trash, len);
+ }
+
+ /* headers to be added */
+ for (line = 0; line < t->proxy->nb_rspadd; line++) {
+ len = sprintf(trash, "%s\r\n", t->proxy->rsp_add[line]);
+ buffer_replace2(rep, rep->h, rep->h, trash, len);
+ }
+
+ /* add a "connection: close" line if needed */
+ if (t->proxy->options & PR_O_HTTP_CLOSE)
+ buffer_replace2(rep, rep->h, rep->h, "Connection: close\r\n", 19);
+
+ t->srv_state = SV_STDATA;
+ rep->rlim = rep->data + BUFSIZE; /* no more rewrite needed */
+ t->logs.t_data = tv_diff(&t->logs.tv_accept, &now);
+
+ /* client connection already closed or option 'httpclose' required :
+ * we close the server's outgoing connection right now.
+ */
+ if ((req->l == 0) &&
+ (c == CL_STSHUTR || c == CL_STCLOSE || t->proxy->options & PR_O_FORCE_CLO)) {
+ FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+
+ shutdown(t->srv_fd, SHUT_WR);
+ t->srv_state = SV_STSHUTW;
+ }
+
+ /* if the user wants to log as soon as possible, without counting
+ bytes from the server, then this is the right moment. */
+ if (t->proxy->to_log && !(t->logs.logwait & LW_BYTES)) {
+ t->logs.t_close = t->logs.t_data; /* to get a valid end date */
+ t->logs.bytes = rep->h - rep->data;
+ sess_log(t);
+ }
+ break;
+ }
+
+ /* to get a complete header line, we need the ending \r\n, \n\r, \r or \n too */
+ if (ptr > rep->r - 2) {
+ /* this is a partial header, let's wait for more to come */
+ rep->lr = ptr;
+ break;
+ }
+
+ // fprintf(stderr,"h=%p, ptr=%p, lr=%p, r=%p, *h=", rep->h, ptr, rep->lr, rep->r);
+ // write(2, rep->h, ptr - rep->h); fprintf(stderr,"\n");
+
+ /* now we know that *ptr is either \r or \n,
+ * and that there are at least 1 char after it.
+ */
+ if ((ptr[0] == ptr[1]) || (ptr[1] != '\r' && ptr[1] != '\n'))
+ rep->lr = ptr + 1; /* \r\r, \n\n, \r[^\n], \n[^\r] */
+ else
+ rep->lr = ptr + 2; /* \r\n or \n\r */
+
+ /*
+ * now we know that we have a full header ; we can do whatever
+ * we want with these pointers :
+ * rep->h = beginning of header
+ * ptr = end of header (first \r or \n)
+ * rep->lr = beginning of next line (next rep->h)
+ * rep->r = end of data (not used at this stage)
+ */
+
+
+ if (t->logs.status == -1) {
+ t->logs.logwait &= ~LW_RESP;
+ t->logs.status = atoi(rep->h + 9);
+ switch (t->logs.status) {
+ case 200:
+ case 203:
+ case 206:
+ case 300:
+ case 301:
+ case 410:
+ /* RFC2616 @13.4:
+ * "A response received with a status code of
+ * 200, 203, 206, 300, 301 or 410 MAY be stored
+ * by a cache (...) unless a cache-control
+ * directive prohibits caching."
+ *
+ * RFC2616 @9.5: POST method :
+ * "Responses to this method are not cacheable,
+ * unless the response includes appropriate
+ * Cache-Control or Expires header fields."
+ */
+ if (!(t->flags & SN_POST) && (t->proxy->options & PR_O_CHK_CACHE))
+ t->flags |= SN_CACHEABLE | SN_CACHE_COOK;
+ break;
+ default:
+ break;
+ }
+ }
+ else if (t->logs.logwait & LW_RSPHDR) {
+ struct cap_hdr *h;
+ int len;
+ for (h = t->proxy->rsp_cap; h; h = h->next) {
+ if ((h->namelen + 2 <= ptr - rep->h) &&
+ (rep->h[h->namelen] == ':') &&
+ (strncasecmp(rep->h, h->name, h->namelen) == 0)) {
+
+ if (t->rsp_cap[h->index] == NULL)
+ t->rsp_cap[h->index] = pool_alloc_from(h->pool, h->len + 1);
+
+ len = ptr - (rep->h + h->namelen + 2);
+ if (len > h->len)
+ len = h->len;
+
+ memcpy(t->rsp_cap[h->index], rep->h + h->namelen + 2, len);
+ t->rsp_cap[h->index][len]=0;
+ }
+ }
+
+ }
+
+ delete_header = 0;
+
+ if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
+ int len, max;
+ len = sprintf(trash, "%08x:%s.srvhdr[%04x:%04x]: ", t->uniq_id, t->proxy->id, (unsigned short)t->cli_fd, (unsigned short)t->srv_fd);
+ max = ptr - rep->h;
+ UBOUND(max, sizeof(trash) - len - 1);
+ len += strlcpy2(trash + len, rep->h, max + 1);
+ trash[len++] = '\n';
+ write(1, trash, len);
+ }
+
+ /* remove "connection: " if needed */
+ if (!delete_header && (t->proxy->options & PR_O_HTTP_CLOSE)
+ && (strncasecmp(rep->h, "Connection: ", 12) == 0)) {
+ delete_header = 1;
+ }
+
+ /* try headers regexps */
+ if (!delete_header && t->proxy->rsp_exp != NULL
+ && !(t->flags & SN_SVDENY)) {
+ struct hdr_exp *exp;
+ char term;
+
+ term = *ptr;
+ *ptr = '\0';
+ exp = t->proxy->rsp_exp;
+ do {
+ if (regexec(exp->preg, rep->h, MAX_MATCH, pmatch, 0) == 0) {
+ switch (exp->action) {
+ case ACT_ALLOW:
+ if (!(t->flags & SN_SVDENY))
+ t->flags |= SN_SVALLOW;
+ break;
+ case ACT_REPLACE:
+ if (!(t->flags & SN_SVDENY)) {
+ int len = exp_replace(trash, rep->h, exp->replace, pmatch);
+ ptr += buffer_replace2(rep, rep->h, ptr, trash, len);
+ }
+ break;
+ case ACT_REMOVE:
+ if (!(t->flags & SN_SVDENY))
+ delete_header = 1;
+ break;
+ case ACT_DENY:
+ if (!(t->flags & SN_SVALLOW))
+ t->flags |= SN_SVDENY;
+ break;
+ case ACT_PASS: /* we simply don't deny this one */
+ break;
+ }
+ break;
+ }
+ } while ((exp = exp->next) != NULL);
+ *ptr = term; /* restore the string terminator */
+ }
+
+ /* check for cache-control: or pragma: headers */
+ if (!delete_header && (t->flags & SN_CACHEABLE)) {
+ if (strncasecmp(rep->h, "Pragma: no-cache", 16) == 0)
+ t->flags &= ~SN_CACHEABLE & ~SN_CACHE_COOK;
+ else if (strncasecmp(rep->h, "Cache-control: ", 15) == 0) {
+ if (strncasecmp(rep->h + 15, "no-cache", 8) == 0) {
+ if (rep->h + 23 == ptr || rep->h[23] == ',')
+ t->flags &= ~SN_CACHEABLE & ~SN_CACHE_COOK;
+ else {
+ if (strncasecmp(rep->h + 23, "=\"set-cookie", 12) == 0
+ && (rep->h[35] == '"' || rep->h[35] == ','))
+ t->flags &= ~SN_CACHE_COOK;
+ }
+ } else if ((strncasecmp(rep->h + 15, "private", 7) == 0 &&
+ (rep->h + 22 == ptr || rep->h[22] == ','))
+ || (strncasecmp(rep->h + 15, "no-store", 8) == 0 &&
+ (rep->h + 23 == ptr || rep->h[23] == ','))) {
+ t->flags &= ~SN_CACHEABLE & ~SN_CACHE_COOK;
+ } else if (strncasecmp(rep->h + 15, "max-age=0", 9) == 0 &&
+ (rep->h + 24 == ptr || rep->h[24] == ',')) {
+ t->flags &= ~SN_CACHEABLE & ~SN_CACHE_COOK;
+ } else if (strncasecmp(rep->h + 15, "s-maxage=0", 10) == 0 &&
+ (rep->h + 25 == ptr || rep->h[25] == ',')) {
+ t->flags &= ~SN_CACHEABLE & ~SN_CACHE_COOK;
+ } else if (strncasecmp(rep->h + 15, "public", 6) == 0 &&
+ (rep->h + 21 == ptr || rep->h[21] == ',')) {
+ t->flags |= SN_CACHEABLE | SN_CACHE_COOK;
+ }
+ }
+ }
+
+ /* check for server cookies */
+ if (!delete_header /*&& (t->proxy->options & PR_O_COOK_ANY)*/
+ && (t->proxy->cookie_name != NULL || t->proxy->capture_name != NULL || t->proxy->appsession_name !=NULL)
+ && (strncasecmp(rep->h, "Set-Cookie: ", 12) == 0)) {
+ char *p1, *p2, *p3, *p4;
+
+ t->flags |= SN_SCK_ANY;
+
+ p1 = rep->h + 12; /* first char after 'Set-Cookie: ' */
+
+ while (p1 < ptr) { /* in fact, we'll break after the first cookie */
+ while (p1 < ptr && (isspace((int)*p1)))
+ p1++;
+
+ if (p1 == ptr || *p1 == ';') /* end of cookie */
+ break;
+
+ /* p1 is at the beginning of the cookie name */
+ p2 = p1;
+
+ while (p2 < ptr && *p2 != '=' && *p2 != ';')
+ p2++;
+
+ if (p2 == ptr || *p2 == ';') /* next cookie */
+ break;
+
+ p3 = p2 + 1; /* skips the '=' sign */
+ if (p3 == ptr)
+ break;
+
+ p4 = p3;
+ while (p4 < ptr && !isspace((int)*p4) && *p4 != ';')
+ p4++;
+
+ /* here, we have the cookie name between p1 and p2,
+ * and its value between p3 and p4.
+ * we can process it.
+ */
+
+ /* first, let's see if we want to capture it */
+ if (t->proxy->capture_name != NULL &&
+ t->logs.srv_cookie == NULL &&
+ (p4 - p1 >= t->proxy->capture_namelen) &&
+ memcmp(p1, t->proxy->capture_name, t->proxy->capture_namelen) == 0) {
+ int log_len = p4 - p1;
+
+ if ((t->logs.srv_cookie = pool_alloc(capture)) == NULL) {
+ Alert("HTTP logging : out of memory.\n");
+ }
+
+ if (log_len > t->proxy->capture_len)
+ log_len = t->proxy->capture_len;
+ memcpy(t->logs.srv_cookie, p1, log_len);
+ t->logs.srv_cookie[log_len] = 0;
+ }
+
+ if ((p2 - p1 == t->proxy->cookie_len) && (t->proxy->cookie_name != NULL) &&
+ (memcmp(p1, t->proxy->cookie_name, p2 - p1) == 0)) {
+ /* Cool... it's the right one */
+ t->flags |= SN_SCK_SEEN;
+
+ /* If the cookie is in insert mode on a known server, we'll delete
+ * this occurrence because we'll insert another one later.
+ * We'll delete it too if the "indirect" option is set and we're in
+ * a direct access. */
+ if (((t->srv) && (t->proxy->options & PR_O_COOK_INS)) ||
+ ((t->flags & SN_DIRECT) && (t->proxy->options & PR_O_COOK_IND))) {
+ /* this header must be deleted */
+ delete_header = 1;
+ t->flags |= SN_SCK_DELETED;
+ }
+ else if ((t->srv) && (t->proxy->options & PR_O_COOK_RW)) {
+ /* replace bytes p3->p4 with the cookie name associated
+ * with this server since we know it.
+ */
+ buffer_replace2(rep, p3, p4, t->srv->cookie, t->srv->cklen);
+ t->flags |= SN_SCK_INSERTED | SN_SCK_DELETED;
+ }
+ else if ((t->srv) && (t->proxy->options & PR_O_COOK_PFX)) {
+ /* insert the cookie name associated with this server
+ * before existing cookie, and insert a delimitor between them..
+ */
+ buffer_replace2(rep, p3, p3, t->srv->cookie, t->srv->cklen + 1);
+ p3[t->srv->cklen] = COOKIE_DELIM;
+ t->flags |= SN_SCK_INSERTED | SN_SCK_DELETED;
+ }
+ break;
+ }
+
+ /* first, let's see if the cookie is our appcookie*/
+ if ((t->proxy->appsession_name != NULL) &&
+ (memcmp(p1, t->proxy->appsession_name, p2 - p1) == 0)) {
+
+ /* Cool... it's the right one */
+
+ size_t server_id_len = strlen(t->srv->id) + 1;
+ asession_temp = &local_asession;
+
+ if ((asession_temp->sessid = pool_alloc_from(apools.sessid, apools.ses_msize)) == NULL) {
+ Alert("Not enought Memory process_srv():asession->sessid:malloc().\n");
+ send_log(t->proxy, LOG_ALERT, "Not enought Memory process_srv():asession->sessid:malloc().\n");
+ }
+ memcpy(asession_temp->sessid, p3, t->proxy->appsession_len);
+ asession_temp->sessid[t->proxy->appsession_len] = 0;
+ asession_temp->serverid = NULL;
+
+ /* only do insert, if lookup fails */
+ if (chtbl_lookup(&(t->proxy->htbl_proxy), (void *) &asession_temp) != 0) {
+ if ((asession_temp = pool_alloc(appsess)) == NULL) {
+ Alert("Not enought Memory process_srv():asession:calloc().\n");
+ send_log(t->proxy, LOG_ALERT, "Not enought Memory process_srv():asession:calloc().\n");
+ return 0;
+ }
+ asession_temp->sessid = local_asession.sessid;
+ asession_temp->serverid = local_asession.serverid;
+ chtbl_insert(&(t->proxy->htbl_proxy), (void *) asession_temp);
+ }/* end if (chtbl_lookup()) */
+ else {
+ /* free wasted memory */
+ pool_free_to(apools.sessid, local_asession.sessid);
+ } /* end else from if (chtbl_lookup()) */
+
+ if (asession_temp->serverid == NULL) {
+ if ((asession_temp->serverid = pool_alloc_from(apools.serverid, apools.ser_msize)) == NULL) {
+ Alert("Not enought Memory process_srv():asession->sessid:malloc().\n");
+ send_log(t->proxy, LOG_ALERT, "Not enought Memory process_srv():asession->sessid:malloc().\n");
+ }
+ asession_temp->serverid[0] = '\0';
+ }
+
+ if (asession_temp->serverid[0] == '\0')
+ memcpy(asession_temp->serverid,t->srv->id,server_id_len);
+
+ tv_delayfrom(&asession_temp->expire, &now, t->proxy->appsession_timeout);
+
+#if defined(DEBUG_HASH)
+ print_table(&(t->proxy->htbl_proxy));
+#endif
+ break;
+ }/* end if ((t->proxy->appsession_name != NULL) ... */
+ else {
+ // fprintf(stderr,"Ignoring unknown cookie : ");
+ // write(2, p1, p2-p1);
+ // fprintf(stderr," = ");
+ // write(2, p3, p4-p3);
+ // fprintf(stderr,"\n");
+ }
+ break; /* we don't want to loop again since there cannot be another cookie on the same line */
+ } /* we're now at the end of the cookie value */
+ } /* end of cookie processing */
+
+ /* check for any set-cookie in case we check for cacheability */
+ if (!delete_header && !(t->flags & SN_SCK_ANY) &&
+ (t->proxy->options & PR_O_CHK_CACHE) &&
+ (strncasecmp(rep->h, "Set-Cookie: ", 12) == 0)) {
+ t->flags |= SN_SCK_ANY;
+ }
+
+ /* let's look if we have to delete this header */
+ if (delete_header && !(t->flags & SN_SVDENY))
+ buffer_replace2(rep, rep->h, rep->lr, "", 0);
+
+ rep->h = rep->lr;
+ } /* while (rep->lr < rep->r) */
+
+ /* end of header processing (even if incomplete) */
+
+ if ((rep->l < rep->rlim - rep->data) && ! FD_ISSET(t->srv_fd, StaticReadEvent)) {
+ /* fd in StaticReadEvent was disabled, perhaps because of a previous buffer
+ * full. We cannot loop here since event_srv_read will disable it only if
+ * rep->l == rlim-data
+ */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+ else
+ tv_eternity(&t->srexpire);
+ }
+
+ /* read error, write error */
+ if (t->res_sw == RES_ERROR || t->res_sr == RES_ERROR) {
+ tv_eternity(&t->srexpire);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv) {
+ t->srv->cur_sess--;
+ t->srv->failed_resp++;
+ }
+ t->proxy->failed_resp++;
+
+ t->srv_state = SV_STCLOSE;
+ t->logs.status = 502;
+ client_return(t, t->proxy->errmsg.len502, t->proxy->errmsg.msg502);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVCL;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_H;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ /* end of client write or end of server read.
+ * since we are in header mode, if there's no space left for headers, we
+ * won't be able to free more later, so the session will never terminate.
+ */
+ else if (t->res_sr == RES_NULL || c == CL_STSHUTW || c == CL_STCLOSE || rep->l >= rep->rlim - rep->data) {
+ FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ shutdown(t->srv_fd, SHUT_RD);
+ t->srv_state = SV_STSHUTR;
+ //fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
+ return 1;
+ }
+ /* read timeout : return a 504 to the client.
+ */
+ else if (FD_ISSET(t->srv_fd, StaticReadEvent) && tv_cmp2_ms(&t->srexpire, &now) <= 0) {
+ tv_eternity(&t->srexpire);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv) {
+ t->srv->cur_sess--;
+ t->srv->failed_resp++;
+ }
+ t->proxy->failed_resp++;
+ t->srv_state = SV_STCLOSE;
+ t->logs.status = 504;
+ client_return(t, t->proxy->errmsg.len504, t->proxy->errmsg.msg504);
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVTO;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_H;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ /* last client read and buffer empty */
+ /* FIXME!!! here, we don't want to switch to SHUTW if the
+ * client shuts read too early, because we may still have
+ * some work to do on the headers.
+ * The side-effect is that if the client completely closes its
+ * connection during SV_STHEADER, the connection to the server
+ * is kept until a response comes back or the timeout is reached.
+ */
+ else if ((/*c == CL_STSHUTR ||*/ c == CL_STCLOSE) && (req->l == 0)) {
+ FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+
+ shutdown(t->srv_fd, SHUT_WR);
+ t->srv_state = SV_STSHUTW;
+ return 1;
+ }
+ /* write timeout */
+ /* FIXME!!! here, we don't want to switch to SHUTW if the
+ * client shuts read too early, because we may still have
+ * some work to do on the headers.
+ */
+ else if (FD_ISSET(t->srv_fd, StaticWriteEvent) && tv_cmp2_ms(&t->swexpire, &now) <= 0) {
+ FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+ shutdown(t->srv_fd, SHUT_WR);
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+
+ t->srv_state = SV_STSHUTW;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVTO;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_H;
+ return 1;
+ }
+
+ if (req->l == 0) {
+ if (FD_ISSET(t->srv_fd, StaticWriteEvent)) {
+ FD_CLR(t->srv_fd, StaticWriteEvent); /* stop writing */
+ tv_eternity(&t->swexpire);
+ }
+ }
+ else { /* client buffer not empty */
+ if (! FD_ISSET(t->srv_fd, StaticWriteEvent)) {
+ FD_SET(t->srv_fd, StaticWriteEvent); /* restart writing */
+ if (t->proxy->srvtimeout) {
+ tv_delayfrom(&t->swexpire, &now, t->proxy->srvtimeout);
+ /* FIXME: to prevent the server from expiring read timeouts during writes,
+ * we refresh it. */
+ t->srexpire = t->swexpire;
+ }
+ else
+ tv_eternity(&t->swexpire);
+ }
+ }
+
+ /* be nice with the client side which would like to send a complete header
+ * FIXME: COMPLETELY BUGGY !!! not all headers may be processed because the client
+ * would read all remaining data at once ! The client should not write past rep->lr
+ * when the server is in header state.
+ */
+ //return header_processed;
+ return t->srv_state != SV_STHEADERS;
+ }
+ else if (s == SV_STDATA) {
+ /* read or write error */
+ if (t->res_sw == RES_ERROR || t->res_sr == RES_ERROR) {
+ tv_eternity(&t->srexpire);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv) {
+ t->srv->cur_sess--;
+ t->srv->failed_resp++;
+ }
+ t->proxy->failed_resp++;
+ t->srv_state = SV_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVCL;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_D;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ /* last read, or end of client write */
+ else if (t->res_sr == RES_NULL || c == CL_STSHUTW || c == CL_STCLOSE) {
+ FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ shutdown(t->srv_fd, SHUT_RD);
+ t->srv_state = SV_STSHUTR;
+ //fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
+ return 1;
+ }
+ /* end of client read and no more data to send */
+ else if ((c == CL_STSHUTR || c == CL_STCLOSE) && (req->l == 0)) {
+ FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+ shutdown(t->srv_fd, SHUT_WR);
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+
+ t->srv_state = SV_STSHUTW;
+ return 1;
+ }
+ /* read timeout */
+ else if (tv_cmp2_ms(&t->srexpire, &now) <= 0) {
+ FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ shutdown(t->srv_fd, SHUT_RD);
+ t->srv_state = SV_STSHUTR;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVTO;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_D;
+ return 1;
+ }
+ /* write timeout */
+ else if (tv_cmp2_ms(&t->swexpire, &now) <= 0) {
+ FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+ shutdown(t->srv_fd, SHUT_WR);
+ /* We must ensure that the read part is still alive when switching
+ * to shutw */
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+ t->srv_state = SV_STSHUTW;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVTO;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_D;
+ return 1;
+ }
+
+ /* recompute request time-outs */
+ if (req->l == 0) {
+ if (FD_ISSET(t->srv_fd, StaticWriteEvent)) {
+ FD_CLR(t->srv_fd, StaticWriteEvent); /* stop writing */
+ tv_eternity(&t->swexpire);
+ }
+ }
+ else { /* buffer not empty, there are still data to be transferred */
+ if (! FD_ISSET(t->srv_fd, StaticWriteEvent)) {
+ FD_SET(t->srv_fd, StaticWriteEvent); /* restart writing */
+ if (t->proxy->srvtimeout) {
+ tv_delayfrom(&t->swexpire, &now, t->proxy->srvtimeout);
+ /* FIXME: to prevent the server from expiring read timeouts during writes,
+ * we refresh it. */
+ t->srexpire = t->swexpire;
+ }
+ else
+ tv_eternity(&t->swexpire);
+ }
+ }
+
+ /* recompute response time-outs */
+ if (rep->l == BUFSIZE) { /* no room to read more data */
+ if (FD_ISSET(t->srv_fd, StaticReadEvent)) {
+ FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ }
+ }
+ else {
+ if (! FD_ISSET(t->srv_fd, StaticReadEvent)) {
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+ else
+ tv_eternity(&t->srexpire);
+ }
+ }
+
+ return 0; /* other cases change nothing */
+ }
+ else if (s == SV_STSHUTR) {
+ if (t->res_sw == RES_ERROR) {
+ //FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv) {
+ t->srv->cur_sess--;
+ t->srv->failed_resp++;
+ }
+ t->proxy->failed_resp++;
+ //close(t->srv_fd);
+ t->srv_state = SV_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVCL;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_D;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ else if ((c == CL_STSHUTR || c == CL_STCLOSE) && (req->l == 0)) {
+ //FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv)
+ t->srv->cur_sess--;
+ //close(t->srv_fd);
+ t->srv_state = SV_STCLOSE;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ else if (tv_cmp2_ms(&t->swexpire, &now) <= 0) {
+ //FD_CLR(t->srv_fd, StaticWriteEvent);
+ tv_eternity(&t->swexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv)
+ t->srv->cur_sess--;
+ //close(t->srv_fd);
+ t->srv_state = SV_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVTO;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_D;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ else if (req->l == 0) {
+ if (FD_ISSET(t->srv_fd, StaticWriteEvent)) {
+ FD_CLR(t->srv_fd, StaticWriteEvent); /* stop writing */
+ tv_eternity(&t->swexpire);
+ }
+ }
+ else { /* buffer not empty */
+ if (! FD_ISSET(t->srv_fd, StaticWriteEvent)) {
+ FD_SET(t->srv_fd, StaticWriteEvent); /* restart writing */
+ if (t->proxy->srvtimeout) {
+ tv_delayfrom(&t->swexpire, &now, t->proxy->srvtimeout);
+ /* FIXME: to prevent the server from expiring read timeouts during writes,
+ * we refresh it. */
+ t->srexpire = t->swexpire;
+ }
+ else
+ tv_eternity(&t->swexpire);
+ }
+ }
+ return 0;
+ }
+ else if (s == SV_STSHUTW) {
+ if (t->res_sr == RES_ERROR) {
+ //FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv) {
+ t->srv->cur_sess--;
+ t->srv->failed_resp++;
+ }
+ t->proxy->failed_resp++;
+ //close(t->srv_fd);
+ t->srv_state = SV_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVCL;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_D;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ else if (t->res_sr == RES_NULL || c == CL_STSHUTW || c == CL_STCLOSE) {
+ //FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv)
+ t->srv->cur_sess--;
+ //close(t->srv_fd);
+ t->srv_state = SV_STCLOSE;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ else if (tv_cmp2_ms(&t->srexpire, &now) <= 0) {
+ //FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ fd_delete(t->srv_fd);
+ if (t->srv)
+ t->srv->cur_sess--;
+ //close(t->srv_fd);
+ t->srv_state = SV_STCLOSE;
+ if (!(t->flags & SN_ERR_MASK))
+ t->flags |= SN_ERR_SRVTO;
+ if (!(t->flags & SN_FINST_MASK))
+ t->flags |= SN_FINST_D;
+ /* We used to have a free connection slot. Since we'll never use it,
+ * we have to inform the server that it may be used by another session.
+ */
+ if (may_dequeue_tasks(t->srv, t->proxy))
+ task_wakeup(&rq, t->srv->queue_mgt);
+
+ return 1;
+ }
+ else if (rep->l == BUFSIZE) { /* no room to read more data */
+ if (FD_ISSET(t->srv_fd, StaticReadEvent)) {
+ FD_CLR(t->srv_fd, StaticReadEvent);
+ tv_eternity(&t->srexpire);
+ }
+ }
+ else {
+ if (! FD_ISSET(t->srv_fd, StaticReadEvent)) {
+ FD_SET(t->srv_fd, StaticReadEvent);
+ if (t->proxy->srvtimeout)
+ tv_delayfrom(&t->srexpire, &now, t->proxy->srvtimeout);
+ else
+ tv_eternity(&t->srexpire);
+ }
+ }
+ return 0;
+ }
+ else { /* SV_STCLOSE : nothing to do */
+ if ((global.mode & MODE_DEBUG) && (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
+ int len;
+ len = sprintf(trash, "%08x:%s.srvcls[%04x:%04x]\n", t->uniq_id, t->proxy->id, (unsigned short)t->cli_fd, (unsigned short)t->srv_fd);
+ write(1, trash, len);
+ }
+ return 0;
+ }
+ return 0;
+}
+
+
+/*
+ * Produces data for the session <s> depending on its source. Expects to be
+ * called with s->cli_state == CL_STSHUTR. Right now, only statistics can be
+ * produced. It stops by itself by unsetting the SN_SELF_GEN flag from the
+ * session, which it uses to keep on being called when there is free space in
+ * the buffer, of simply by letting an empty buffer upon return. It returns 1
+ * if it changes the session state from CL_STSHUTR, otherwise 0.
+ */
+int produce_content(struct session *s)
+{
+ struct buffer *rep = s->rep;
+ struct proxy *px;
+ struct server *sv;
+ int msglen;
+
+ if (s->data_source == DATA_SRC_NONE) {
+ s->flags &= ~SN_SELF_GEN;
+ return 1;
+ }
+ else if (s->data_source == DATA_SRC_STATS) {
+ msglen = 0;
+
+ if (s->data_state == DATA_ST_INIT) { /* the function had not been called yet */
+ unsigned int up;
+
+ s->flags |= SN_SELF_GEN; // more data will follow
+
+ /* send the start of the HTTP response */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "HTTP/1.0 200 OK\r\n"
+ "Cache-Control: no-cache\r\n"
+ "Connection: close\r\n"
+ "\r\n\r\n");
+
+ s->logs.status = 200;
+ client_retnclose(s, msglen, trash); // send the start of the response.
+ msglen = 0;
+
+ if (!(s->flags & SN_ERR_MASK)) // this is not really an error but it is
+ s->flags |= SN_ERR_PRXCOND; // to mark that it comes from the proxy
+ if (!(s->flags & SN_FINST_MASK))
+ s->flags |= SN_FINST_R;
+
+ /* WARNING! This must fit in the first buffer !!! */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<html><head><title>Statistics Report for " PRODUCT_NAME "</title>\n"
+ "<meta http-equiv=\"content-type\" content=\"text/html; charset=iso-8859-1\">\n"
+ "<style type=\"text/css\"><!--\n"
+ "body {"
+ " font-family: helvetica, arial;"
+ " font-size: 12px;"
+ " font-weight: normal;"
+ " color: black;"
+ " background: white;"
+ "}\n"
+ "td {"
+ " font-size: 12px;"
+ " align: center;"
+ "}\n"
+ "h1 {"
+ " font-size: xx-large;"
+ " margin-bottom: 0.5em;"
+ "}\n"
+ "h2 {"
+ " font-family: helvetica, arial;"
+ " font-size: x-large;"
+ " font-weight: bold;"
+ " font-style: italic;"
+ " color: #6020a0;"
+ " margin-top: 0em;"
+ " margin-bottom: 0em;"
+ "}\n"
+ "h3 {"
+ " font-family: helvetica, arial;"
+ " font-size: 16px;"
+ " font-weight: bold;"
+ " color: #b00040;"
+ " background: #e8e8d0;"
+ " margin-top: 0em;"
+ " margin-bottom: 0em;"
+ "}\n"
+ "li {"
+ " margin-top: 0.25em;"
+ " margin-right: 2em;"
+ "}\n"
+ ".hr {"
+ " margin-top: 0.25em;"
+ " border-color: black;"
+ " border-bottom-style: solid;"
+ "}\n"
+ "table.tbl { border-collapse: collapse; border-width: 1px; border-style: solid; border-color: gray;}\n"
+ "table.tbl td { border-width: 1px 1px 1px 1px; border-style: solid solid solid solid; border-color: gray; }\n"
+ "table.tbl th { border-width: 1px; border-style: solid solid solid solid; border-color: gray; }\n"
+ "table.lgd { border-collapse: collapse; border-width: 1px; border-style: none none none solid; border-color: black;}\n"
+ "table.lgd td { border-width: 1px; border-style: solid solid solid solid; border-color: gray; padding: 2px;}\n"
+ "-->"
+ "</style></head>");
+
+ if (buffer_write(rep, trash, msglen) != 0)
+ return 0;
+ msglen = 0;
+
+ up = (now.tv_sec - start_date.tv_sec);
+
+ /* WARNING! this has to fit the first packet too */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<body><h1>" PRODUCT_NAME "</h1>\n"
+ "<h2>Statistics Report for pid %d</h2>\n"
+ "<hr width=\"100%%\" class=\"hr\">\n"
+ "<h3>> General process information</h3>\n"
+ "<table border=0><tr><td align=\"left\">\n"
+ "<p><b>pid = </b> %d (nbproc = %d)<br>\n"
+ "<b>uptime = </b> %dd %dh%02dm%02ds<br>\n"
+ "<b>system limits :</b> memmax = %s%s ; ulimit-n = %d<br>\n"
+ "<b>maxsock = </b> %d<br>\n"
+ "<b>maxconn = </b> %d (current conns = %d)<br>\n"
+ "</td><td width=\"10%%\">\n"
+ "</td><td align=\"right\">\n"
+ "<table class=\"lgd\">"
+ "<tr><td bgcolor=\"#C0FFC0\"> </td><td style=\"border-style: none;\">active UP </td>"
+ "<td bgcolor=\"#B0D0FF\"> </td><td style=\"border-style: none;\">backup UP </td></tr>"
+ "<tr><td bgcolor=\"#FFFFA0\"></td><td style=\"border-style: none;\">active UP, going down </td>"
+ "<td bgcolor=\"#C060FF\"></td><td style=\"border-style: none;\">backup UP, going down </td></tr>"
+ "<tr><td bgcolor=\"#FFD020\"></td><td style=\"border-style: none;\">active DOWN, going up </td>"
+ "<td bgcolor=\"#FF80FF\"></td><td style=\"border-style: none;\">backup DOWN, going up </td></tr>"
+ "<tr><td bgcolor=\"#FF9090\"></td><td style=\"border-style: none;\">active or backup DOWN </td>"
+ "<td bgcolor=\"#E0E0E0\"></td><td style=\"border-style: none;\">not checked </td></tr>"
+ "</table>\n"
+ "</tr></table>\n"
+ "",
+ pid, pid, global.nbproc,
+ up / 86400, (up % 86400) / 3600,
+ (up % 3600) / 60, (up % 60),
+ global.rlimit_memmax ? ultoa(global.rlimit_memmax) : "unlimited",
+ global.rlimit_memmax ? " MB" : "",
+ global.rlimit_nofile,
+ global.maxsock,
+ global.maxconn,
+ actconn
+ );
+
+ if (buffer_write(rep, trash, msglen) != 0)
+ return 0;
+ msglen = 0;
+
+ s->data_state = DATA_ST_DATA;
+ memset(&s->data_ctx, 0, sizeof(s->data_ctx));
+
+ px = s->data_ctx.stats.px = proxy;
+ s->data_ctx.stats.px_st = DATA_ST_INIT;
+ }
+
+ while (s->data_ctx.stats.px) {
+ int dispatch_sess, dispatch_cum;
+ int failed_checks, down_trans;
+ int failed_secu, failed_conns, failed_resp;
+
+ if (s->data_ctx.stats.px_st == DATA_ST_INIT) {
+ /* we are on a new proxy */
+ px = s->data_ctx.stats.px;
+
+ /* skip the disabled proxies */
+ if (px->state == PR_STSTOPPED)
+ goto next_proxy;
+
+ if (s->proxy->uri_auth && s->proxy->uri_auth->scope) {
+ /* we have a limited scope, we have to check the proxy name */
+ struct stat_scope *scope;
+ int len;
+
+ len = strlen(px->id);
+ scope = s->proxy->uri_auth->scope;
+
+ while (scope) {
+ /* match exact proxy name */
+ if (scope->px_len == len && !memcmp(px->id, scope->px_id, len))
+ break;
+
+ /* match '.' which means 'self' proxy */
+ if (!strcmp(scope->px_id, ".") && px == s->proxy)
+ break;
+ scope = scope->next;
+ }
+
+ /* proxy name not found */
+ if (scope == NULL)
+ goto next_proxy;
+ }
+
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<h3>> Proxy instance %s : "
+ "%d conns (maxconn=%d), %d queued (%d unassigned), %d total conns</h3>\n"
+ "",
+ px->id,
+ px->nbconn, px->maxconn, px->totpend, px->nbpend, px->cum_conn);
+
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<table cols=\"16\" class=\"tbl\">\n"
+ "<tr align=\"center\" bgcolor=\"#20C0C0\">"
+ "<th colspan=5>Server</th>"
+ "<th colspan=2>Queue</th>"
+ "<th colspan=4>Sessions</th>"
+ "<th colspan=5>Errors</th></tr>\n"
+ "<tr align=\"center\" bgcolor=\"#20C0C0\">"
+ "<th>Name</th><th>Weight</th><th>Status</th><th>Act.</th><th>Bck.</th>"
+ "<th>Curr.</th><th>Max.</th>"
+ "<th>Curr.</th><th>Max.</th><th>Limit</th><th>Cumul.</th>"
+ "<th>Conn.</th><th>Resp.</th><th>Sec.</th><th>Check</th><th>Down</th></tr>\n");
+
+ if (buffer_write(rep, trash, msglen) != 0)
+ return 0;
+ msglen = 0;
+
+ s->data_ctx.stats.sv = px->srv;
+ s->data_ctx.stats.px_st = DATA_ST_DATA;
+ }
+
+ px = s->data_ctx.stats.px;
+
+ /* stats.sv has been initialized above */
+ while (s->data_ctx.stats.sv != NULL) {
+ static char *act_tab_bg[5] = { /*down*/"#FF9090", /*rising*/"#FFD020", /*failing*/"#FFFFA0", /*up*/"#C0FFC0", /*unchecked*/"#E0E0E0" };
+ static char *bck_tab_bg[5] = { /*down*/"#FF9090", /*rising*/"#FF80ff", /*failing*/"#C060FF", /*up*/"#B0D0FF", /*unchecked*/"#E0E0E0" };
+ static char *srv_hlt_st[5] = { "DOWN", "DN %d/%d ↑", "UP %d/%d ↓", "UP", "<i>no check</i>" };
+ int sv_state; /* 0=DOWN, 1=going up, 2=going down, 3=UP */
+
+ sv = s->data_ctx.stats.sv;
+
+ /* FIXME: produce some small strings for "UP/DOWN x/y &#xxxx;" */
+ if (!(sv->state & SRV_CHECKED))
+ sv_state = 4;
+ else if (sv->state & SRV_RUNNING)
+ if (sv->health == sv->rise + sv->fall - 1)
+ sv_state = 3; /* UP */
+ else
+ sv_state = 2; /* going down */
+ else
+ if (sv->health)
+ sv_state = 1; /* going up */
+ else
+ sv_state = 0; /* DOWN */
+
+ /* name, weight */
+ msglen += snprintf(trash, sizeof(trash),
+ "<tr align=center bgcolor=\"%s\"><td>%s</td><td>%d</td><td>",
+ (sv->state & SRV_BACKUP) ? bck_tab_bg[sv_state] : act_tab_bg[sv_state],
+ sv->id, sv->uweight+1);
+ /* status */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen, srv_hlt_st[sv_state],
+ (sv->state & SRV_RUNNING) ? (sv->health - sv->rise + 1) : (sv->health),
+ (sv->state & SRV_RUNNING) ? (sv->fall) : (sv->rise));
+
+ /* act, bck */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "</td><td>%s</td><td>%s</td>",
+ (sv->state & SRV_BACKUP) ? "-" : "Y",
+ (sv->state & SRV_BACKUP) ? "Y" : "-");
+
+ /* queue : current, max */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td>",
+ sv->nbpend, sv->nbpend_max);
+
+ /* sessions : current, max, limit, cumul */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td><td align=right>%s</td><td align=right>%d</td>",
+ sv->cur_sess, sv->cur_sess_max, sv->maxconn ? ultoa(sv->maxconn) : "-", sv->cum_sess);
+
+ /* errors : connect, response, security */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td><td align=right>%d</td>\n",
+ sv->failed_conns, sv->failed_resp, sv->failed_secu);
+
+ /* check failures : unique, fatal */
+ if (sv->state & SRV_CHECKED)
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td></tr>\n",
+ sv->failed_checks, sv->down_trans);
+ else
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>-</td><td align=right>-</td></tr>\n");
+
+ if (buffer_write(rep, trash, msglen) != 0)
+ return 0;
+ msglen = 0;
+
+ s->data_ctx.stats.sv = sv->next;
+ } /* while sv */
+
+ /* now we are past the last server, we'll dump information about the dispatcher */
+
+ /* We have to count down from the proxy to the servers to tell how
+ * many sessions are on the dispatcher, and how many checks have
+ * failed. We cannot count this during the servers dump because it
+ * might be interrupted multiple times.
+ */
+ dispatch_sess = px->nbconn;
+ dispatch_cum = px->cum_conn;
+ failed_secu = px->failed_secu;
+ failed_conns = px->failed_conns;
+ failed_resp = px->failed_resp;
+ failed_checks = down_trans = 0;
+
+ sv = px->srv;
+ while (sv) {
+ dispatch_sess -= sv->cur_sess;
+ dispatch_cum -= sv->cum_sess;
+ failed_conns -= sv->failed_conns;
+ failed_resp -= sv->failed_resp;
+ failed_secu -= sv->failed_secu;
+ if (sv->state & SRV_CHECKED) {
+ failed_checks += sv->failed_checks;
+ down_trans += sv->down_trans;
+ }
+ sv = sv->next;
+ }
+
+ /* name, weight, status, act, bck */
+ msglen += snprintf(trash + msglen, sizeof(trash),
+ "<tr align=center bgcolor=\"#e8e8d0\">"
+ "<td>Dispatcher</td><td>-</td>"
+ "<td>%s</td><td>-</td><td>-</td>",
+ px->state == PR_STRUN ? "UP" : "DOWN");
+
+ /* queue : current, max */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td>",
+ px->nbpend, px->nbpend_max);
+
+ /* sessions : current, max, limit, cumul. */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td><td align=right>%d</td><td align=right>%d</td>",
+ dispatch_sess, px->nbconn_max, px->maxconn, dispatch_cum);
+
+ /* errors : connect, response, security */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td><td align=right>%d</td>\n",
+ failed_conns, failed_resp, failed_secu);
+
+ /* check failures : unique, fatal */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>-</td><td align=right>-</td></tr>\n");
+
+
+ /* now the summary for the whole proxy */
+ /* name, weight, status, act, bck */
+ msglen += snprintf(trash + msglen, sizeof(trash),
+ "<tr align=center style=\"color: #ffff80; background: #20C0C0;\">"
+ "<td><b>Total</b></td><td>-</td>"
+ "<td><b>%s</b></td><td><b>%d</b></td><td><b>%d</b></td>",
+ (px->state == PR_STRUN && ((px->srv == NULL) || px->srv_act || px->srv_bck)) ? "UP" : "DOWN",
+ px->srv_act, px->srv_bck);
+
+ /* queue : current, max */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right><b>%d</b></td><td align=right><b>%d</b></td>",
+ px->totpend, px->nbpend_max);
+
+ /* sessions : current, max, limit, cumul */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right><b>%d</b></td><td align=right><b>%d</b></td><td align=right><b>%d</b></td><td align=right><b>%d</b></td>",
+ px->nbconn, px->nbconn_max, px->maxconn, px->cum_conn);
+
+ /* errors : connect, response, security */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td><td align=right>%d</td>\n",
+ px->failed_conns, px->failed_resp, px->failed_secu);
+
+ /* check failures : unique, fatal */
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen,
+ "<td align=right>%d</td><td align=right>%d</td></tr>\n",
+ failed_checks, down_trans);
+
+ msglen += snprintf(trash + msglen, sizeof(trash) - msglen, "</table><p>\n");
+
+ if (buffer_write(rep, trash, msglen) != 0)
+ return 0;
+ msglen = 0;
+
+ s->data_ctx.stats.px_st = DATA_ST_INIT;
+ next_proxy:
+ s->data_ctx.stats.px = px->next;
+ } /* proxy loop */
+ /* here, we just have reached the sv == NULL and px == NULL */
+ s->flags &= ~SN_SELF_GEN;
+ return 1;
+ }
+ else {
+ /* unknown data source */
+ s->logs.status = 500;
+ client_retnclose(s, s->proxy->errmsg.len500, s->proxy->errmsg.msg500);
+ if (!(s->flags & SN_ERR_MASK))
+ s->flags |= SN_ERR_PRXCOND;
+ if (!(s->flags & SN_FINST_MASK))
+ s->flags |= SN_FINST_R;
+ s->flags &= SN_SELF_GEN;
+ return 1;
+ }
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/proxy.c b/src/proxy.c
new file mode 100644
index 0000000..b1beb4b
--- /dev/null
+++ b/src/proxy.c
@@ -0,0 +1,357 @@
+/*
+ * Proxy variables and functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+
+#include <haproxy/defaults.h>
+#include <haproxy/compat.h>
+#include <haproxy/time.h>
+
+#include <types/global.h>
+#include <types/polling.h>
+
+#include <proto/client.h>
+#include <proto/fd.h>
+#include <proto/log.h>
+#include <proto/proxy.h>
+
+
+int listeners; /* # of listeners */
+struct proxy *proxy = NULL; /* list of all existing proxies */
+
+
+/*
+ * this function starts all the proxies. Its return value is composed from
+ * ERR_NONE, ERR_RETRYABLE and ERR_FATAL. Retryable errors will only be printed
+ * if <verbose> is not zero.
+ */
+int start_proxies(int verbose)
+{
+ struct proxy *curproxy;
+ struct listener *listener;
+ int err = ERR_NONE;
+ int fd, pxerr;
+
+ for (curproxy = proxy; curproxy != NULL; curproxy = curproxy->next) {
+ if (curproxy->state != PR_STNEW)
+ continue; /* already initialized */
+
+ pxerr = 0;
+ for (listener = curproxy->listen; listener != NULL; listener = listener->next) {
+ if (listener->fd != -1)
+ continue; /* already initialized */
+
+ if ((fd = socket(listener->addr.ss_family, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+ if (verbose)
+ Alert("cannot create listening socket for proxy %s. Aborting.\n",
+ curproxy->id);
+ err |= ERR_RETRYABLE;
+ pxerr |= 1;
+ continue;
+ }
+
+ if (fd >= global.maxsock) {
+ Alert("socket(): not enough free sockets for proxy %s. Raise -n argument. Aborting.\n",
+ curproxy->id);
+ close(fd);
+ err |= ERR_FATAL;
+ pxerr |= 1;
+ break;
+ }
+
+ if ((fcntl(fd, F_SETFL, O_NONBLOCK) == -1) ||
+ (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY,
+ (char *) &one, sizeof(one)) == -1)) {
+ Alert("cannot make socket non-blocking for proxy %s. Aborting.\n",
+ curproxy->id);
+ close(fd);
+ err |= ERR_FATAL;
+ pxerr |= 1;
+ break;
+ }
+
+ if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof(one)) == -1) {
+ Alert("cannot do so_reuseaddr for proxy %s. Continuing.\n",
+ curproxy->id);
+ }
+
+#ifdef SO_REUSEPORT
+ /* OpenBSD supports this. As it's present in old libc versions of Linux,
+ * it might return an error that we will silently ignore.
+ */
+ setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (char *) &one, sizeof(one));
+#endif
+ if (bind(fd,
+ (struct sockaddr *)&listener->addr,
+ listener->addr.ss_family == AF_INET6 ?
+ sizeof(struct sockaddr_in6) :
+ sizeof(struct sockaddr_in)) == -1) {
+ if (verbose)
+ Alert("cannot bind socket for proxy %s. Aborting.\n",
+ curproxy->id);
+ close(fd);
+ err |= ERR_RETRYABLE;
+ pxerr |= 1;
+ continue;
+ }
+
+ if (listen(fd, curproxy->maxconn) == -1) {
+ if (verbose)
+ Alert("cannot listen to socket for proxy %s. Aborting.\n",
+ curproxy->id);
+ close(fd);
+ err |= ERR_RETRYABLE;
+ pxerr |= 1;
+ continue;
+ }
+
+ /* the socket is ready */
+ listener->fd = fd;
+
+ /* the function for the accept() event */
+ fdtab[fd].read = &event_accept;
+ fdtab[fd].write = NULL; /* never called */
+ fdtab[fd].owner = (struct task *)curproxy; /* reference the proxy instead of a task */
+ fdtab[fd].state = FD_STLISTEN;
+ FD_SET(fd, StaticReadEvent);
+ fd_insert(fd);
+ listeners++;
+ }
+
+ if (!pxerr) {
+ curproxy->state = PR_STRUN;
+ send_log(curproxy, LOG_NOTICE, "Proxy %s started.\n", curproxy->id);
+ }
+ }
+
+ return err;
+}
+
+
+/*
+ * this function enables proxies when there are enough free sessions,
+ * or stops them when the table is full. It is designed to be called from the
+ * select_loop(). It returns the time left before next expiration event
+ * during stop time, TIME_ETERNITY otherwise.
+ */
+int maintain_proxies(void)
+{
+ struct proxy *p;
+ struct listener *l;
+ int tleft; /* time left */
+
+ p = proxy;
+ tleft = TIME_ETERNITY; /* infinite time */
+
+ /* if there are enough free sessions, we'll activate proxies */
+ if (actconn < global.maxconn) {
+ while (p) {
+ if (p->nbconn < p->maxconn) {
+ if (p->state == PR_STIDLE) {
+ for (l = p->listen; l != NULL; l = l->next) {
+ FD_SET(l->fd, StaticReadEvent);
+ }
+ p->state = PR_STRUN;
+ }
+ }
+ else {
+ if (p->state == PR_STRUN) {
+ for (l = p->listen; l != NULL; l = l->next) {
+ FD_CLR(l->fd, StaticReadEvent);
+ }
+ p->state = PR_STIDLE;
+ }
+ }
+ p = p->next;
+ }
+ }
+ else { /* block all proxies */
+ while (p) {
+ if (p->state == PR_STRUN) {
+ for (l = p->listen; l != NULL; l = l->next) {
+ FD_CLR(l->fd, StaticReadEvent);
+ }
+ p->state = PR_STIDLE;
+ }
+ p = p->next;
+ }
+ }
+
+ if (stopping) {
+ p = proxy;
+ while (p) {
+ if (p->state != PR_STSTOPPED) {
+ int t;
+ t = tv_remain2(&now, &p->stop_time);
+ if (t == 0) {
+ Warning("Proxy %s stopped.\n", p->id);
+ send_log(p, LOG_WARNING, "Proxy %s stopped.\n", p->id);
+
+ for (l = p->listen; l != NULL; l = l->next) {
+ fd_delete(l->fd);
+ listeners--;
+ }
+ p->state = PR_STSTOPPED;
+ }
+ else {
+ tleft = MINTIME(t, tleft);
+ }
+ }
+ p = p->next;
+ }
+ }
+ return tleft;
+}
+
+
+/*
+ * this function disables health-check servers so that the process will quickly be ignored
+ * by load balancers. Note that if a proxy was already in the PAUSED state, then its grace
+ * time will not be used since it would already not listen anymore to the socket.
+ */
+void soft_stop(void)
+{
+ struct proxy *p;
+
+ stopping = 1;
+ p = proxy;
+ tv_now(&now); /* else, the old time before select will be used */
+ while (p) {
+ if (p->state != PR_STSTOPPED) {
+ Warning("Stopping proxy %s in %d ms.\n", p->id, p->grace);
+ send_log(p, LOG_WARNING, "Stopping proxy %s in %d ms.\n", p->id, p->grace);
+ tv_delayfrom(&p->stop_time, &now, p->grace);
+ }
+ p = p->next;
+ }
+}
+
+
+/*
+ * Linux unbinds the listen socket after a SHUT_RD, and ignores SHUT_WR.
+ * Solaris refuses either shutdown().
+ * OpenBSD ignores SHUT_RD but closes upon SHUT_WR and refuses to rebind.
+ * So a common validation path involves SHUT_WR && listen && SHUT_RD.
+ * If disabling at least one listener returns an error, then the proxy
+ * state is set to PR_STERROR because we don't know how to resume from this.
+ */
+void pause_proxy(struct proxy *p)
+{
+ struct listener *l;
+ for (l = p->listen; l != NULL; l = l->next) {
+ if (shutdown(l->fd, SHUT_WR) == 0 &&
+ listen(l->fd, p->maxconn) == 0 &&
+ shutdown(l->fd, SHUT_RD) == 0) {
+ FD_CLR(l->fd, StaticReadEvent);
+ if (p->state != PR_STERROR)
+ p->state = PR_STPAUSED;
+ }
+ else
+ p->state = PR_STERROR;
+ }
+}
+
+/*
+ * This function temporarily disables listening so that another new instance
+ * can start listening. It is designed to be called upon reception of a
+ * SIGTTOU, after which either a SIGUSR1 can be sent to completely stop
+ * the proxy, or a SIGTTIN can be sent to listen again.
+ */
+void pause_proxies(void)
+{
+ int err;
+ struct proxy *p;
+
+ err = 0;
+ p = proxy;
+ tv_now(&now); /* else, the old time before select will be used */
+ while (p) {
+ if (p->state != PR_STERROR &&
+ p->state != PR_STSTOPPED &&
+ p->state != PR_STPAUSED) {
+ Warning("Pausing proxy %s.\n", p->id);
+ send_log(p, LOG_WARNING, "Pausing proxy %s.\n", p->id);
+ pause_proxy(p);
+ if (p->state != PR_STPAUSED) {
+ err |= 1;
+ Warning("Proxy %s failed to enter pause mode.\n", p->id);
+ send_log(p, LOG_WARNING, "Proxy %s failed to enter pause mode.\n", p->id);
+ }
+ }
+ p = p->next;
+ }
+ if (err) {
+ Warning("Some proxies refused to pause, performing soft stop now.\n");
+ send_log(p, LOG_WARNING, "Some proxies refused to pause, performing soft stop now.\n");
+ soft_stop();
+ }
+}
+
+
+/*
+ * This function reactivates listening. This can be used after a call to
+ * sig_pause(), for example when a new instance has failed starting up.
+ * It is designed to be called upon reception of a SIGTTIN.
+ */
+void listen_proxies(void)
+{
+ struct proxy *p;
+ struct listener *l;
+
+ p = proxy;
+ tv_now(&now); /* else, the old time before select will be used */
+ while (p) {
+ if (p->state == PR_STPAUSED) {
+ Warning("Enabling proxy %s.\n", p->id);
+ send_log(p, LOG_WARNING, "Enabling proxy %s.\n", p->id);
+
+ for (l = p->listen; l != NULL; l = l->next) {
+ if (listen(l->fd, p->maxconn) == 0) {
+ if (actconn < global.maxconn && p->nbconn < p->maxconn) {
+ FD_SET(l->fd, StaticReadEvent);
+ p->state = PR_STRUN;
+ }
+ else
+ p->state = PR_STIDLE;
+ } else {
+ int port;
+
+ if (l->addr.ss_family == AF_INET6)
+ port = ntohs(((struct sockaddr_in6 *)(&l->addr))->sin6_port);
+ else
+ port = ntohs(((struct sockaddr_in *)(&l->addr))->sin_port);
+
+ Warning("Port %d busy while trying to enable proxy %s.\n",
+ port, p->id);
+ send_log(p, LOG_WARNING, "Port %d busy while trying to enable proxy %s.\n",
+ port, p->id);
+ /* Another port might have been enabled. Let's stop everything. */
+ pause_proxy(p);
+ break;
+ }
+ }
+ }
+ p = p->next;
+ }
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/queue.c b/src/queue.c
new file mode 100644
index 0000000..67c0d7c
--- /dev/null
+++ b/src/queue.c
@@ -0,0 +1,139 @@
+/*
+ * Queue management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <haproxy/time.h>
+
+#include <types/proxy.h>
+#include <types/session.h>
+
+#include <proto/queue.h>
+#include <proto/server.h>
+#include <proto/task.h>
+
+
+void **pool_pendconn = NULL;
+
+/* returns the effective dynamic maxconn for a server, considering the minconn
+ * and the proxy's usage relative to its saturation.
+ */
+unsigned int srv_dynamic_maxconn(struct server *s)
+{
+ return s->minconn ?
+ ((s->maxconn * s->proxy->nbconn / s->proxy->maxconn) < s->minconn) ? s->minconn :
+ (s->maxconn * s->proxy->nbconn / s->proxy->maxconn) : s->maxconn;
+}
+
+
+/*
+ * Manages a server's connection queue. If woken up, will try to dequeue as
+ * many pending sessions as possible, and wake them up. The task has nothing
+ * else to do, so it always returns TIME_ETERNITY.
+ */
+int process_srv_queue(struct task *t)
+{
+ struct server *s = (struct server*)t->context;
+ struct proxy *p = s->proxy;
+ int xferred;
+
+ /* First, check if we can handle some connections queued at the proxy. We
+ * will take as many as we can handle.
+ */
+ for (xferred = 0; s->cur_sess + xferred < srv_dynamic_maxconn(s); xferred++) {
+ struct session *sess;
+
+ sess = pendconn_get_next_sess(s, p);
+ if (sess == NULL)
+ break;
+ task_wakeup(&rq, sess->task);
+ }
+
+ return TIME_ETERNITY;
+}
+
+/* Detaches the next pending connection from either a server or a proxy, and
+ * returns its associated session. If no pending connection is found, NULL is
+ * returned. Note that neither <srv> nor <px> can be NULL.
+ */
+struct session *pendconn_get_next_sess(struct server *srv, struct proxy *px)
+{
+ struct pendconn *p;
+ struct session *sess;
+
+ p = pendconn_from_srv(srv);
+ if (!p) {
+ p = pendconn_from_px(px);
+ if (!p)
+ return NULL;
+ p->sess->srv = srv;
+ }
+ sess = p->sess;
+ pendconn_free(p);
+ return sess;
+}
+
+/* Adds the session <sess> to the pending connection list of server <sess>->srv
+ * or to the one of <sess>->proxy if srv is NULL. All counters and back pointers
+ * are updated accordingly. Returns NULL if no memory is available, otherwise the
+ * pendconn itself.
+ */
+struct pendconn *pendconn_add(struct session *sess)
+{
+ struct pendconn *p;
+
+ p = pool_alloc(pendconn);
+ if (!p)
+ return NULL;
+
+ sess->pend_pos = p;
+ p->sess = sess;
+ p->srv = sess->srv;
+ if (sess->srv) {
+ LIST_ADDQ(&sess->srv->pendconns, &p->list);
+ sess->logs.srv_queue_size += sess->srv->nbpend;
+ sess->srv->nbpend++;
+ if (sess->srv->nbpend > sess->srv->nbpend_max)
+ sess->srv->nbpend_max = sess->srv->nbpend;
+ } else {
+ LIST_ADDQ(&sess->proxy->pendconns, &p->list);
+ sess->logs.prx_queue_size += sess->proxy->nbpend;
+ sess->proxy->nbpend++;
+ if (sess->proxy->nbpend > sess->proxy->nbpend_max)
+ sess->proxy->nbpend_max = sess->proxy->nbpend;
+ }
+ sess->proxy->totpend++;
+ return p;
+}
+
+/*
+ * Detaches pending connection <p>, decreases the pending count, and frees
+ * the pending connection. The connection might have been queued to a specific
+ * server as well as to the proxy. The session also gets marked unqueued.
+ */
+void pendconn_free(struct pendconn *p)
+{
+ LIST_DEL(&p->list);
+ p->sess->pend_pos = NULL;
+ if (p->srv)
+ p->srv->nbpend--;
+ else
+ p->sess->proxy->nbpend--;
+ p->sess->proxy->totpend--;
+ pool_free(pendconn, p);
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/regex.c b/src/regex.c
new file mode 100644
index 0000000..4c37760
--- /dev/null
+++ b/src/regex.c
@@ -0,0 +1,130 @@
+/*
+ * Regex and string management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <haproxy/regex.h>
+#include <haproxy/standard.h>
+#include <proto/log.h>
+
+/* regex trash buffer used by various regex tests */
+regmatch_t pmatch[MAX_MATCH]; /* rm_so, rm_eo for regular expressions */
+
+
+
+int exp_replace(char *dst, char *src, char *str, regmatch_t *matches)
+{
+ char *old_dst = dst;
+
+ while (*str) {
+ if (*str == '\\') {
+ str++;
+ if (isdigit((int)*str)) {
+ int len, num;
+
+ num = *str - '0';
+ str++;
+
+ if (matches[num].rm_eo > -1 && matches[num].rm_so > -1) {
+ len = matches[num].rm_eo - matches[num].rm_so;
+ memcpy(dst, src + matches[num].rm_so, len);
+ dst += len;
+ }
+
+ } else if (*str == 'x') {
+ unsigned char hex1, hex2;
+ str++;
+
+ hex1 = toupper(*str++) - '0';
+ hex2 = toupper(*str++) - '0';
+
+ if (hex1 > 9) hex1 -= 'A' - '9' - 1;
+ if (hex2 > 9) hex2 -= 'A' - '9' - 1;
+ *dst++ = (hex1<<4) + hex2;
+ } else {
+ *dst++ = *str++;
+ }
+ } else {
+ *dst++ = *str++;
+ }
+ }
+ *dst = '\0';
+ return dst - old_dst;
+}
+
+/* returns NULL if the replacement string <str> is valid, or the pointer to the first error */
+char *check_replace_string(char *str)
+{
+ char *err = NULL;
+ while (*str) {
+ if (*str == '\\') {
+ err = str; /* in case of a backslash, we return the pointer to it */
+ str++;
+ if (!*str)
+ return err;
+ else if (isdigit((int)*str))
+ err = NULL;
+ else if (*str == 'x') {
+ str++;
+ if (!ishex(*str))
+ return err;
+ str++;
+ if (!ishex(*str))
+ return err;
+ err = NULL;
+ }
+ else {
+ Warning("'\\%c' : deprecated use of a backslash before something not '\\','x' or a digit.\n", *str);
+ err = NULL;
+ }
+ }
+ str++;
+ }
+ return err;
+}
+
+
+/* returns the pointer to an error in the replacement string, or NULL if OK */
+char *chain_regex(struct hdr_exp **head, regex_t *preg, int action, char *replace)
+{
+ struct hdr_exp *exp;
+
+ if (replace != NULL) {
+ char *err;
+ err = check_replace_string(replace);
+ if (err)
+ return err;
+ }
+
+ while (*head != NULL)
+ head = &(*head)->next;
+
+ exp = calloc(1, sizeof(struct hdr_exp));
+
+ exp->preg = preg;
+ exp->replace = replace;
+ exp->action = action;
+ *head = exp;
+
+ return NULL;
+}
+
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/server.c b/src/server.c
new file mode 100644
index 0000000..50c025d
--- /dev/null
+++ b/src/server.c
@@ -0,0 +1,23 @@
+/*
+ * Server management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <types/backend.h>
+#include <types/proxy.h>
+#include <types/server.h>
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/session.c b/src/session.c
new file mode 100644
index 0000000..0722d0f
--- /dev/null
+++ b/src/session.c
@@ -0,0 +1,73 @@
+/*
+ * Server management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <stdlib.h>
+#include <haproxy/memory.h>
+
+#include <types/backend.h>
+#include <types/capture.h>
+#include <types/log.h>
+#include <types/proxy.h>
+#include <types/server.h>
+
+#include <proto/session.h>
+#include <proto/queue.h>
+
+
+void **pool_session = NULL;
+
+/*
+ * frees the context associated to a session. It must have been removed first.
+ */
+void session_free(struct session *s)
+{
+ if (s->pend_pos)
+ pendconn_free(s->pend_pos);
+ if (s->req)
+ pool_free(buffer, s->req);
+ if (s->rep)
+ pool_free(buffer, s->rep);
+
+ if (s->rsp_cap != NULL) {
+ struct cap_hdr *h;
+ for (h = s->proxy->rsp_cap; h; h = h->next) {
+ if (s->rsp_cap[h->index] != NULL)
+ pool_free_to(h->pool, s->rsp_cap[h->index]);
+ }
+ pool_free_to(s->proxy->rsp_cap_pool, s->rsp_cap);
+ }
+ if (s->req_cap != NULL) {
+ struct cap_hdr *h;
+ for (h = s->proxy->req_cap; h; h = h->next) {
+ if (s->req_cap[h->index] != NULL)
+ pool_free_to(h->pool, s->req_cap[h->index]);
+ }
+ pool_free_to(s->proxy->req_cap_pool, s->req_cap);
+ }
+
+ if (s->logs.uri)
+ pool_free(requri, s->logs.uri);
+ if (s->logs.cli_cookie)
+ pool_free(capture, s->logs.cli_cookie);
+ if (s->logs.srv_cookie)
+ pool_free(capture, s->logs.srv_cookie);
+
+ pool_free(session, s);
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/standard.c b/src/standard.c
new file mode 100644
index 0000000..e218055
--- /dev/null
+++ b/src/standard.c
@@ -0,0 +1,214 @@
+/*
+ * General purpose functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <netdb.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <haproxy/standard.h>
+#include <proto/log.h>
+
+/* enough to store 2^63=18446744073709551615 */
+static char itoa_str[21];
+
+/*
+ * copies at most <size-1> chars from <src> to <dst>. Last char is always
+ * set to 0, unless <size> is 0. The number of chars copied is returned
+ * (excluding the terminating zero).
+ * This code has been optimized for size and speed : on x86, it's 45 bytes
+ * long, uses only registers, and consumes only 4 cycles per char.
+ */
+int strlcpy2(char *dst, const char *src, int size)
+{
+ char *orig = dst;
+ if (size) {
+ while (--size && (*dst = *src)) {
+ src++; dst++;
+ }
+ *dst = 0;
+ }
+ return dst - orig;
+}
+
+/*
+ * This function simply returns a statically allocated string containing
+ * the ascii representation for number 'n' in decimal.
+ */
+char *ultoa(unsigned long n)
+{
+ char *pos;
+
+ pos = itoa_str + sizeof(itoa_str) - 1;
+ *pos-- = '\0';
+
+ do {
+ *pos-- = '0' + n % 10;
+ n /= 10;
+ } while (n && pos >= itoa_str);
+ return pos + 1;
+}
+
+
+/*
+ * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
+ *
+ * It looks like this one would be a good candidate for inlining, but this is
+ * not interesting because it around 35 bytes long and often called multiple
+ * times within the same function.
+ */
+int ishex(char s)
+{
+ s -= '0';
+ if ((unsigned char)s <= 9)
+ return 1;
+ s -= 'A' - '0';
+ if ((unsigned char)s <= 5)
+ return 1;
+ s -= 'a' - 'A';
+ if ((unsigned char)s <= 5)
+ return 1;
+ return 0;
+}
+
+
+/*
+ * converts <str> to a struct sockaddr_in* which is locally allocated.
+ * The format is "addr:port", where "addr" can be a dotted IPv4 address,
+ * a host name, or empty or "*" to indicate INADDR_ANY.
+ */
+struct sockaddr_in *str2sa(char *str)
+{
+ static struct sockaddr_in sa;
+ char *c;
+ int port;
+
+ memset(&sa, 0, sizeof(sa));
+ str = strdup(str);
+
+ if ((c = strrchr(str,':')) != NULL) {
+ *c++ = '\0';
+ port = atol(c);
+ }
+ else
+ port = 0;
+
+ if (*str == '*' || *str == '\0') { /* INADDR_ANY */
+ sa.sin_addr.s_addr = INADDR_ANY;
+ }
+ else if (!inet_pton(AF_INET, str, &sa.sin_addr)) {
+ struct hostent *he;
+
+ if ((he = gethostbyname(str)) == NULL) {
+ Alert("Invalid server name: '%s'\n", str);
+ }
+ else
+ sa.sin_addr = *(struct in_addr *) *(he->h_addr_list);
+ }
+ sa.sin_port = htons(port);
+ sa.sin_family = AF_INET;
+
+ free(str);
+ return &sa;
+}
+
+/*
+ * converts <str> to a two struct in_addr* which are locally allocated.
+ * The format is "addr[/mask]", where "addr" cannot be empty, and mask
+ * is optionnal and either in the dotted or CIDR notation.
+ * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
+ */
+int str2net(char *str, struct in_addr *addr, struct in_addr *mask)
+{
+ char *c;
+ unsigned long len;
+
+ memset(mask, 0, sizeof(*mask));
+ memset(addr, 0, sizeof(*addr));
+ str = strdup(str);
+
+ if ((c = strrchr(str, '/')) != NULL) {
+ *c++ = '\0';
+ /* c points to the mask */
+ if (strchr(c, '.') != NULL) { /* dotted notation */
+ if (!inet_pton(AF_INET, c, mask))
+ return 0;
+ }
+ else { /* mask length */
+ char *err;
+ len = strtol(c, &err, 10);
+ if (!*c || (err && *err) || (unsigned)len > 32)
+ return 0;
+ if (len)
+ mask->s_addr = htonl(~0UL << (32 - len));
+ else
+ mask->s_addr = 0;
+ }
+ }
+ else {
+ mask->s_addr = ~0UL;
+ }
+ if (!inet_pton(AF_INET, str, addr)) {
+ struct hostent *he;
+
+ if ((he = gethostbyname(str)) == NULL) {
+ return 0;
+ }
+ else
+ *addr = *(struct in_addr *) *(he->h_addr_list);
+ }
+ free(str);
+ return 1;
+}
+
+/* will try to encode the string <string> replacing all characters tagged in
+ * <map> with the hexadecimal representation of their ASCII-code (2 digits)
+ * prefixed by <escape>, and will store the result between <start> (included)
+ * and <stop> (excluded), and will always terminate the string with a '\0'
+ * before <stop>. The position of the '\0' is returned if the conversion
+ * completes. If bytes are missing between <start> and <stop>, then the
+ * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
+ * cannot even be stored so we return <start> without writing the 0.
+ * The input string must also be zero-terminated.
+ */
+const char hextab[16] = "0123456789ABCDEF";
+char *encode_string(char *start, char *stop,
+ const char escape, const fd_set *map,
+ const char *string)
+{
+ if (start < stop) {
+ stop--; /* reserve one byte for the final '\0' */
+ while (start < stop && *string != '\0') {
+ if (!FD_ISSET((unsigned char)(*string), map))
+ *start++ = *string;
+ else {
+ if (start + 3 >= stop)
+ break;
+ *start++ = escape;
+ *start++ = hextab[(*string >> 4) & 15];
+ *start++ = hextab[*string & 15];
+ }
+ string++;
+ }
+ *start = '\0';
+ }
+ return start;
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/stream_sock.c b/src/stream_sock.c
new file mode 100644
index 0000000..e305461
--- /dev/null
+++ b/src/stream_sock.c
@@ -0,0 +1,462 @@
+/*
+ * Functions operating on SOCK_STREAM and buffers.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <haproxy/compat.h>
+#include <haproxy/time.h>
+
+#include <types/backend.h>
+#include <types/buffers.h>
+#include <types/global.h>
+#include <types/httperr.h>
+#include <types/polling.h>
+#include <types/proxy.h>
+#include <types/server.h>
+#include <types/session.h>
+
+#include <proto/client.h>
+#include <proto/fd.h>
+#include <proto/log.h>
+#include <proto/proto_http.h>
+#include <proto/stream_sock.h>
+#include <proto/task.h>
+
+
+/*
+ * this function is called on a read event from a client socket.
+ * It returns 0.
+ */
+int event_cli_read(int fd) {
+ struct task *t = fdtab[fd].owner;
+ struct session *s = t->context;
+ struct buffer *b = s->req;
+ int ret, max;
+
+#ifdef DEBUG_FULL
+ fprintf(stderr,"event_cli_read : fd=%d, s=%p\n", fd, s);
+#endif
+
+ if (fdtab[fd].state != FD_STERROR) {
+#ifdef FILL_BUFFERS
+ while (1)
+#else
+ do
+#endif
+ {
+ if (b->l == 0) { /* let's realign the buffer to optimize I/O */
+ b->r = b->w = b->h = b->lr = b->data;
+ max = b->rlim - b->data;
+ }
+ else if (b->r > b->w) {
+ max = b->rlim - b->r;
+ }
+ else {
+ max = b->w - b->r;
+ /* FIXME: theorically, if w>0, we shouldn't have rlim < data+size anymore
+ * since it means that the rewrite protection has been removed. This
+ * implies that the if statement can be removed.
+ */
+ if (max > b->rlim - b->data)
+ max = b->rlim - b->data;
+ }
+
+ if (max == 0) { /* not anymore room to store data */
+ FD_CLR(fd, StaticReadEvent);
+ break;
+ }
+
+#ifndef MSG_NOSIGNAL
+ {
+ int skerr;
+ socklen_t lskerr = sizeof(skerr);
+
+ getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
+ if (skerr)
+ ret = -1;
+ else
+ ret = recv(fd, b->r, max, 0);
+ }
+#else
+ ret = recv(fd, b->r, max, MSG_NOSIGNAL);
+#endif
+ if (ret > 0) {
+ b->r += ret;
+ b->l += ret;
+ s->res_cr = RES_DATA;
+
+ if (b->r == b->data + BUFSIZE) {
+ b->r = b->data; /* wrap around the buffer */
+ }
+
+ b->total += ret;
+ /* we hope to read more data or to get a close on next round */
+ continue;
+ }
+ else if (ret == 0) {
+ s->res_cr = RES_NULL;
+ break;
+ }
+ else if (errno == EAGAIN) {/* ignore EAGAIN */
+ break;
+ }
+ else {
+ s->res_cr = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ break;
+ }
+ } /* while(1) */
+#ifndef FILL_BUFFERS
+ while (0);
+#endif
+ }
+ else {
+ s->res_cr = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ }
+
+ if (s->res_cr != RES_SILENT) {
+ if (s->proxy->clitimeout && FD_ISSET(fd, StaticReadEvent))
+ tv_delayfrom(&s->crexpire, &now, s->proxy->clitimeout);
+ else
+ tv_eternity(&s->crexpire);
+
+ task_wakeup(&rq, t);
+ }
+
+ return 0;
+}
+
+
+/*
+ * this function is called on a write event from a client socket.
+ * It returns 0.
+ */
+int event_cli_write(int fd) {
+ struct task *t = fdtab[fd].owner;
+ struct session *s = t->context;
+ struct buffer *b = s->rep;
+ int ret, max;
+
+#ifdef DEBUG_FULL
+ fprintf(stderr,"event_cli_write : fd=%d, s=%p\n", fd, s);
+#endif
+
+ if (b->l == 0) { /* let's realign the buffer to optimize I/O */
+ b->r = b->w = b->h = b->lr = b->data;
+ // max = BUFSIZE; BUG !!!!
+ max = 0;
+ }
+ else if (b->r > b->w) {
+ max = b->r - b->w;
+ }
+ else
+ max = b->data + BUFSIZE - b->w;
+
+ if (fdtab[fd].state != FD_STERROR) {
+ if (max == 0) {
+ s->res_cw = RES_NULL;
+ task_wakeup(&rq, t);
+ tv_eternity(&s->cwexpire);
+ FD_CLR(fd, StaticWriteEvent);
+ return 0;
+ }
+
+#ifndef MSG_NOSIGNAL
+ {
+ int skerr;
+ socklen_t lskerr = sizeof(skerr);
+
+ getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
+ if (skerr)
+ ret = -1;
+ else
+ ret = send(fd, b->w, max, MSG_DONTWAIT);
+ }
+#else
+ ret = send(fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL);
+#endif
+
+ if (ret > 0) {
+ b->l -= ret;
+ b->w += ret;
+
+ s->res_cw = RES_DATA;
+
+ if (b->w == b->data + BUFSIZE) {
+ b->w = b->data; /* wrap around the buffer */
+ }
+ }
+ else if (ret == 0) {
+ /* nothing written, just make as if we were never called */
+ // s->res_cw = RES_NULL;
+ return 0;
+ }
+ else if (errno == EAGAIN) /* ignore EAGAIN */
+ return 0;
+ else {
+ s->res_cw = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ }
+ }
+ else {
+ s->res_cw = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ }
+
+ if (s->proxy->clitimeout) {
+ tv_delayfrom(&s->cwexpire, &now, s->proxy->clitimeout);
+ /* FIXME: to prevent the client from expiring read timeouts during writes,
+ * we refresh it. A solution would be to merge read+write timeouts into a
+ * unique one, although that needs some study particularly on full-duplex
+ * TCP connections. */
+ s->crexpire = s->cwexpire;
+ }
+ else
+ tv_eternity(&s->cwexpire);
+
+ task_wakeup(&rq, t);
+ return 0;
+}
+
+
+/*
+ * this function is called on a read event from a server socket.
+ * It returns 0.
+ */
+int event_srv_read(int fd) {
+ struct task *t = fdtab[fd].owner;
+ struct session *s = t->context;
+ struct buffer *b = s->rep;
+ int ret, max;
+
+#ifdef DEBUG_FULL
+ fprintf(stderr,"event_srv_read : fd=%d, s=%p\n", fd, s);
+#endif
+
+ if (fdtab[fd].state != FD_STERROR) {
+#ifdef FILL_BUFFERS
+ while (1)
+#else
+ do
+#endif
+ {
+ if (b->l == 0) { /* let's realign the buffer to optimize I/O */
+ b->r = b->w = b->h = b->lr = b->data;
+ max = b->rlim - b->data;
+ }
+ else if (b->r > b->w) {
+ max = b->rlim - b->r;
+ }
+ else {
+ max = b->w - b->r;
+ /* FIXME: theorically, if w>0, we shouldn't have rlim < data+size anymore
+ * since it means that the rewrite protection has been removed. This
+ * implies that the if statement can be removed.
+ */
+ if (max > b->rlim - b->data)
+ max = b->rlim - b->data;
+ }
+
+ if (max == 0) { /* not anymore room to store data */
+ FD_CLR(fd, StaticReadEvent);
+ break;
+ }
+
+#ifndef MSG_NOSIGNAL
+ {
+ int skerr;
+ socklen_t lskerr = sizeof(skerr);
+
+ getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
+ if (skerr)
+ ret = -1;
+ else
+ ret = recv(fd, b->r, max, 0);
+ }
+#else
+ ret = recv(fd, b->r, max, MSG_NOSIGNAL);
+#endif
+ if (ret > 0) {
+ b->r += ret;
+ b->l += ret;
+ s->res_sr = RES_DATA;
+
+ if (b->r == b->data + BUFSIZE) {
+ b->r = b->data; /* wrap around the buffer */
+ }
+
+ b->total += ret;
+ /* we hope to read more data or to get a close on next round */
+ continue;
+ }
+ else if (ret == 0) {
+ s->res_sr = RES_NULL;
+ break;
+ }
+ else if (errno == EAGAIN) {/* ignore EAGAIN */
+ break;
+ }
+ else {
+ s->res_sr = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ break;
+ }
+ } /* while(1) */
+#ifndef FILL_BUFFERS
+ while (0);
+#endif
+ }
+ else {
+ s->res_sr = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ }
+
+ if (s->res_sr != RES_SILENT) {
+ if (s->proxy->srvtimeout && FD_ISSET(fd, StaticReadEvent))
+ tv_delayfrom(&s->srexpire, &now, s->proxy->srvtimeout);
+ else
+ tv_eternity(&s->srexpire);
+
+ task_wakeup(&rq, t);
+ }
+
+ return 0;
+}
+
+
+/*
+ * this function is called on a write event from a server socket.
+ * It returns 0.
+ */
+int event_srv_write(int fd) {
+ struct task *t = fdtab[fd].owner;
+ struct session *s = t->context;
+ struct buffer *b = s->req;
+ int ret, max;
+
+#ifdef DEBUG_FULL
+ fprintf(stderr,"event_srv_write : fd=%d, s=%p\n", fd, s);
+#endif
+
+ if (b->l == 0) { /* let's realign the buffer to optimize I/O */
+ b->r = b->w = b->h = b->lr = b->data;
+ // max = BUFSIZE; BUG !!!!
+ max = 0;
+ }
+ else if (b->r > b->w) {
+ max = b->r - b->w;
+ }
+ else
+ max = b->data + BUFSIZE - b->w;
+
+ if (fdtab[fd].state != FD_STERROR) {
+ if (max == 0) {
+ /* may be we have received a connection acknowledgement in TCP mode without data */
+ if (s->srv_state == SV_STCONN) {
+ int skerr;
+ socklen_t lskerr = sizeof(skerr);
+ getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
+ if (skerr) {
+ s->res_sw = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ task_wakeup(&rq, t);
+ tv_eternity(&s->swexpire);
+ FD_CLR(fd, StaticWriteEvent);
+ return 0;
+ }
+ }
+
+ s->res_sw = RES_NULL;
+ task_wakeup(&rq, t);
+ fdtab[fd].state = FD_STREADY;
+ tv_eternity(&s->swexpire);
+ FD_CLR(fd, StaticWriteEvent);
+ return 0;
+ }
+
+#ifndef MSG_NOSIGNAL
+ {
+ int skerr;
+ socklen_t lskerr = sizeof(skerr);
+ getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr);
+ if (skerr)
+ ret = -1;
+ else
+ ret = send(fd, b->w, max, MSG_DONTWAIT);
+ }
+#else
+ ret = send(fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL);
+#endif
+ fdtab[fd].state = FD_STREADY;
+ if (ret > 0) {
+ b->l -= ret;
+ b->w += ret;
+
+ s->res_sw = RES_DATA;
+
+ if (b->w == b->data + BUFSIZE) {
+ b->w = b->data; /* wrap around the buffer */
+ }
+ }
+ else if (ret == 0) {
+ /* nothing written, just make as if we were never called */
+ // s->res_sw = RES_NULL;
+ return 0;
+ }
+ else if (errno == EAGAIN) /* ignore EAGAIN */
+ return 0;
+ else {
+ s->res_sw = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ }
+ }
+ else {
+ s->res_sw = RES_ERROR;
+ fdtab[fd].state = FD_STERROR;
+ }
+
+ /* We don't want to re-arm read/write timeouts if we're trying to connect,
+ * otherwise it could loop indefinitely !
+ */
+ if (s->srv_state != SV_STCONN) {
+ if (s->proxy->srvtimeout) {
+ tv_delayfrom(&s->swexpire, &now, s->proxy->srvtimeout);
+ /* FIXME: to prevent the server from expiring read timeouts during writes,
+ * we refresh it. A solution would be to merge read+write+connect timeouts
+ * into a unique one since we don't mind expiring on read or write, and none
+ * of them is enabled while waiting for connect(), although that needs some
+ * study particularly on full-duplex TCP connections. */
+ s->srexpire = s->swexpire;
+ }
+ else
+ tv_eternity(&s->swexpire);
+ }
+
+ task_wakeup(&rq, t);
+ return 0;
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/task.c b/src/task.c
new file mode 100644
index 0000000..2c4adee
--- /dev/null
+++ b/src/task.c
@@ -0,0 +1,201 @@
+/*
+ * Task management functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <haproxy/config.h>
+#include <haproxy/mini-clist.h>
+#include <haproxy/time.h>
+
+#include <proto/task.h>
+
+
+/* FIXME : this should be removed very quickly ! */
+extern int maintain_proxies(void);
+
+void **pool_task= NULL;
+struct task *rq = NULL; /* global run queue */
+struct task wait_queue[2] = { /* global wait queue */
+ {
+ prev:LIST_HEAD(wait_queue[0]), /* expirable tasks */
+ next:LIST_HEAD(wait_queue[0]),
+ },
+ {
+ prev:LIST_HEAD(wait_queue[1]), /* non-expirable tasks */
+ next:LIST_HEAD(wait_queue[1]),
+ },
+};
+
+
+/* inserts <task> into its assigned wait queue, where it may already be. In this case, it
+ * may be only moved or left where it was, depending on its timing requirements.
+ * <task> is returned.
+ */
+struct task *task_queue(struct task *task)
+{
+ struct task *list = task->wq;
+ struct task *start_from;
+
+ /* This is a very dirty hack to queue non-expirable tasks in another queue
+ * in order to avoid pulluting the tail of the standard queue. This will go
+ * away with the new O(log(n)) scheduler anyway.
+ */
+ if (tv_iseternity(&task->expire)) {
+ /* if the task was queued in the standard wait queue, we must dequeue it */
+ if (task->prev) {
+ if (task->wq == LIST_HEAD(wait_queue[1]))
+ return task;
+ else {
+ task_delete(task);
+ task->prev = NULL;
+ }
+ }
+ list = task->wq = LIST_HEAD(wait_queue[1]);
+ } else {
+ /* if the task was queued in the eternity queue, we must dequeue it */
+ if (task->prev && (task->wq == LIST_HEAD(wait_queue[1]))) {
+ task_delete(task);
+ task->prev = NULL;
+ list = task->wq = LIST_HEAD(wait_queue[0]);
+ }
+ }
+
+ /* next, test if the task was already in a list */
+ if (task->prev == NULL) {
+ // start_from = list;
+ start_from = list->prev;
+ /* insert the unlinked <task> into the list, searching back from the last entry */
+ while (start_from != list && tv_cmp2(&task->expire, &start_from->expire) < 0) {
+ start_from = start_from->prev;
+ }
+
+ // while (start_from->next != list && tv_cmp2(&task->expire, &start_from->next->expire) > 0) {
+ // start_from = start_from->next;
+ // stats_tsk_nsrch++;
+ // }
+ }
+ else if (task->prev == list ||
+ tv_cmp2(&task->expire, &task->prev->expire) >= 0) { /* walk right */
+ start_from = task->next;
+ if (start_from == list || tv_cmp2(&task->expire, &start_from->expire) <= 0) {
+ return task; /* it's already in the right place */
+ }
+
+ /* if the task is not at the right place, there's little chance that
+ * it has only shifted a bit, and it will nearly always be queued
+ * at the end of the list because of constant timeouts
+ * (observed in real case).
+ */
+#ifndef WE_REALLY_THINK_THAT_THIS_TASK_MAY_HAVE_SHIFTED
+ start_from = list->prev; /* assume we'll queue to the end of the list */
+ while (start_from != list && tv_cmp2(&task->expire, &start_from->expire) < 0) {
+ start_from = start_from->prev;
+ }
+#else /* WE_REALLY_... */
+ /* insert the unlinked <task> into the list, searching after position <start_from> */
+ while (start_from->next != list && tv_cmp2(&task->expire, &start_from->next->expire) > 0) {
+ start_from = start_from->next;
+ }
+#endif /* WE_REALLY_... */
+
+ /* we need to unlink it now */
+ task_delete(task);
+ }
+ else { /* walk left. */
+#ifdef LEFT_TO_TOP /* not very good */
+ start_from = list;
+ while (start_from->next != list && tv_cmp2(&task->expire, &start_from->next->expire) > 0) {
+ start_from = start_from->next;
+ }
+#else
+ start_from = task->prev->prev; /* valid because of the previous test above */
+ while (start_from != list && tv_cmp2(&task->expire, &start_from->expire) < 0) {
+ start_from = start_from->prev;
+ }
+#endif
+ /* we need to unlink it now */
+ task_delete(task);
+ }
+ task->prev = start_from;
+ task->next = start_from->next;
+ task->next->prev = task;
+ start_from->next = task;
+ return task;
+}
+
+/*
+ * This does 4 things :
+ * - wake up all expired tasks
+ * - call all runnable tasks
+ * - call maintain_proxies() to enable/disable the listeners
+ * - return the delay till next event in ms, -1 = wait indefinitely
+ * Note: this part should be rewritten with the O(ln(n)) scheduler.
+ *
+ */
+
+int process_runnable_tasks()
+{
+ int next_time;
+ int time2;
+ struct task *t, *tnext;
+
+ next_time = TIME_ETERNITY; /* set the timer to wait eternally first */
+
+ /* look for expired tasks and add them to the run queue.
+ */
+ tnext = ((struct task *)LIST_HEAD(wait_queue[0]))->next;
+ while ((t = tnext) != LIST_HEAD(wait_queue[0])) { /* we haven't looped ? */
+ tnext = t->next;
+ if (t->state & TASK_RUNNING)
+ continue;
+
+ if (tv_iseternity(&t->expire))
+ continue;
+
+ /* wakeup expired entries. It doesn't matter if they are
+ * already running because of a previous event
+ */
+ if (tv_cmp_ms(&t->expire, &now) <= 0) {
+ task_wakeup(&rq, t);
+ }
+ else {
+ /* first non-runnable task. Use its expiration date as an upper bound */
+ int temp_time = tv_remain(&now, &t->expire);
+ if (temp_time)
+ next_time = temp_time;
+ break;
+ }
+ }
+
+ /* process each task in the run queue now. Each task may be deleted
+ * since we only use the run queue's head. Note that any task can be
+ * woken up by any other task and it will be processed immediately
+ * after as it will be queued on the run queue's head.
+ */
+ while ((t = rq) != NULL) {
+ int temp_time;
+
+ task_sleep(&rq, t);
+ temp_time = t->process(t);
+ next_time = MINTIME(temp_time, next_time);
+ }
+
+ /* maintain all proxies in a consistent state. This should quickly become a task */
+ time2 = maintain_proxies();
+ return MINTIME(time2, next_time);
+}
+
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/time.c b/src/time.c
new file mode 100644
index 0000000..d495ed1
--- /dev/null
+++ b/src/time.c
@@ -0,0 +1,172 @@
+/*
+ * Time calculation functions.
+ *
+ * Copyright 2000-2006 Willy Tarreau <w@1wt.eu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+
+#include <sys/time.h>
+#include <haproxy/time.h>
+
+struct timeval now; /* the current date at any moment */
+struct timeval start_date; /* the process's start date */
+
+/*
+ * adds <ms> ms to <from>, set the result to <tv> and returns a pointer <tv>
+ */
+struct timeval *tv_delayfrom(struct timeval *tv, struct timeval *from, int ms)
+{
+ if (!tv || !from)
+ return NULL;
+ tv->tv_usec = from->tv_usec + (ms%1000)*1000;
+ tv->tv_sec = from->tv_sec + (ms/1000);
+ while (tv->tv_usec >= 1000000) {
+ tv->tv_usec -= 1000000;
+ tv->tv_sec++;
+ }
+ return tv;
+}
+
+/*
+ * compares <tv1> and <tv2> modulo 1ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2
+ * Must not be used when either argument is eternity. Use tv_cmp2_ms() for that.
+ */
+int tv_cmp_ms(struct timeval *tv1, struct timeval *tv2)
+{
+ if (tv1->tv_sec == tv2->tv_sec) {
+ if (tv2->tv_usec >= tv1->tv_usec + 1000)
+ return -1;
+ else if (tv1->tv_usec >= tv2->tv_usec + 1000)
+ return 1;
+ else
+ return 0;
+ }
+ else if ((tv2->tv_sec > tv1->tv_sec + 1) ||
+ ((tv2->tv_sec == tv1->tv_sec + 1) && (tv2->tv_usec + 1000000 >= tv1->tv_usec + 1000)))
+ return -1;
+ else if ((tv1->tv_sec > tv2->tv_sec + 1) ||
+ ((tv1->tv_sec == tv2->tv_sec + 1) && (tv1->tv_usec + 1000000 >= tv2->tv_usec + 1000)))
+ return 1;
+ else
+ return 0;
+}
+
+/*
+ * compares <tv1> and <tv2> : returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2,
+ * considering that 0 is the eternity.
+ */
+int tv_cmp2(struct timeval *tv1, struct timeval *tv2)
+{
+ if (tv_iseternity(tv1))
+ if (tv_iseternity(tv2))
+ return 0; /* same */
+ else
+ return 1; /* tv1 later than tv2 */
+ else if (tv_iseternity(tv2))
+ return -1; /* tv2 later than tv1 */
+
+ if (tv1->tv_sec > tv2->tv_sec)
+ return 1;
+ else if (tv1->tv_sec < tv2->tv_sec)
+ return -1;
+ else if (tv1->tv_usec > tv2->tv_usec)
+ return 1;
+ else if (tv1->tv_usec < tv2->tv_usec)
+ return -1;
+ else
+ return 0;
+}
+
+/*
+ * compares <tv1> and <tv2> modulo 1 ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2,
+ * considering that 0 is the eternity.
+ */
+int tv_cmp2_ms(struct timeval *tv1, struct timeval *tv2)
+{
+ if (tv_iseternity(tv1))
+ if (tv_iseternity(tv2))
+ return 0; /* same */
+ else
+ return 1; /* tv1 later than tv2 */
+ else if (tv_iseternity(tv2))
+ return -1; /* tv2 later than tv1 */
+
+ if (tv1->tv_sec == tv2->tv_sec) {
+ if (tv1->tv_usec >= tv2->tv_usec + 1000)
+ return 1;
+ else if (tv2->tv_usec >= tv1->tv_usec + 1000)
+ return -1;
+ else
+ return 0;
+ }
+ else if ((tv1->tv_sec > tv2->tv_sec + 1) ||
+ ((tv1->tv_sec == tv2->tv_sec + 1) && (tv1->tv_usec + 1000000 >= tv2->tv_usec + 1000)))
+ return 1;
+ else if ((tv2->tv_sec > tv1->tv_sec + 1) ||
+ ((tv2->tv_sec == tv1->tv_sec + 1) && (tv2->tv_usec + 1000000 >= tv1->tv_usec + 1000)))
+ return -1;
+ else
+ return 0;
+}
+
+/*
+ * returns the remaining time between tv1=now and event=tv2
+ * if tv2 is passed, 0 is returned.
+ * Returns TIME_ETERNITY if tv2 is eternity.
+ */
+unsigned long tv_remain2(struct timeval *tv1, struct timeval *tv2)
+{
+ unsigned long ret;
+
+ if (tv_iseternity(tv2))
+ return TIME_ETERNITY;
+
+ if (tv_cmp_ms(tv1, tv2) >= 0)
+ return 0; /* event elapsed */
+
+ ret = (tv2->tv_sec - tv1->tv_sec) * 1000;
+ if (tv2->tv_usec > tv1->tv_usec)
+ ret += (tv2->tv_usec - tv1->tv_usec) / 1000;
+ else
+ ret -= (tv1->tv_usec - tv2->tv_usec) / 1000;
+ return (unsigned long) ret;
+}
+
+
+/*
+ * returns the absolute difference, in ms, between tv1 and tv2
+ * Must not be used when either argument is eternity.
+ */
+unsigned long tv_delta(struct timeval *tv1, struct timeval *tv2)
+{
+ int cmp;
+ unsigned long ret;
+
+
+ cmp = tv_cmp(tv1, tv2);
+ if (!cmp)
+ return 0; /* same dates, null diff */
+ else if (cmp < 0) {
+ struct timeval *tmp = tv1;
+ tv1 = tv2;
+ tv2 = tmp;
+ }
+ ret = (tv1->tv_sec - tv2->tv_sec) * 1000;
+ if (tv1->tv_usec > tv2->tv_usec)
+ ret += (tv1->tv_usec - tv2->tv_usec) / 1000;
+ else
+ ret -= (tv2->tv_usec - tv1->tv_usec) / 1000;
+ return (unsigned long) ret;
+}
+
+/*
+ * Local variables:
+ * c-indent-level: 8
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/uri_auth.c b/src/uri_auth.c
index 84570ef..498d735 100644
--- a/src/uri_auth.c
+++ b/src/uri_auth.c
@@ -1,7 +1,7 @@
/*
* URI-based user authentication using the HTTP basic method.
*
- * Copyright 2006 Willy Tarreau <willy@w.ods.org>
+ * Copyright 2006 Willy Tarreau <w@1wt.eu>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@@ -12,8 +12,9 @@
#include <stdlib.h>
#include <string.h>
-#include <include/uri_auth.h>
-#include <include/base64.h>
+
+#include <haproxy/base64.h>
+#include <haproxy/uri_auth.h>
/*