haproxy.c

/*
 * HA-Proxy : High Availability-enabled HTTP/TCP proxy - Willy Tarreau
 * willy AT meta-x DOT org.
 *
 * 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.
 *
 * ChangeLog :
 *
 * 2001/12/19 : release of version 1.0.1 : no MSG_NOSIGNAL on solaris
 * 2001/12/16 : release of version 1.0.0.
 * 2001/12/16 : added syslog capability for each accepted connection.
 * 2001/11/19 : corrected premature end of files and occasional SIGPIPE.
 * 2001/10/31 : added health-check type servers (mode health) which replies OK then closes.
 * 2001/10/30 : added the ability to support standard TCP proxies and HTTP proxies
 * 		with or without cookies (use keyword http for this).
 * 2001/09/01 : added client/server header replacing with regexps.
 * 		eg:
 *			cliexp ^(Host:\ [^:]*).* Host:\ \1:80
 *			srvexp ^Server:\ .* Server:\ Apache
 * 2000/11/29 : first fully working release with complete FSMs and timeouts.
 * 2000/11/28 : major rewrite
 * 2000/11/26 : first write
 *
 * TODO: handle properly intermediate incomplete server headers.
 *
 */

#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 <regex.h>
#include <syslog.h>

#define HAPROXY_VERSION "1.0.1"
#define HAPROXY_DATE	"2001/12/19"

/* this is for libc5 for example */
#ifndef TCP_NODELAY
#define TCP_NODELAY	1
#endif

#ifndef SHUT_RD
#define SHUT_RD		0
#endif

#ifndef SHUT_WR
#define SHUT_WR		1
#endif

#define BUFSIZE		4096

// reserved buffer space for header rewriting
#define	MAXREWRITE	256

// max # of regexps per proxy
#define	MAX_REGEXP	10

// max # of matches per regexp
#define	MAX_MATCH	10

#define COOKIENAME_LEN	16
#define SERVERID_LEN	16
#define CONN_RETRIES	3

/* how many bits are needed to code the size of an int (eg: 32bits -> 5) */
#define	INTBITS		5

/* show stats this every millisecond, 0 to disable */
#ifndef STATTIME
#define STATTIME	2000
#endif

#define MINTIME(old, new)	(((new)<0)?(old):(((old)<0||(new)<(old))?(new):(old)))
#define SETNOW(a)		(*a=now)

#define MEM_OPTIM
#ifdef	MEM_OPTIM
/*
 * Returns a pointer to type <type> taken from the
 * pool <pool_type> or dynamically allocated. In the
 * first case, <pool_type> is updated to point to the
 * next element in the list.
 */
#define pool_alloc(type) ({			\
    void *p;					\
    if ((p = pool_##type) == NULL)		\
	p = malloc(sizeof_##type);		\
    else {					\
	pool_##type = *(void **)pool_##type;	\
    }						\
    p;						\
})

/*
 * Puts a memory area back to the corresponding pool.
 * Items are chained directly through a pointer that
 * is written in the beginning of the memory area, so
 * there's no need for any carrier cells. This implies
 * that each memory area is at least as big as one
 * pointer.
 */
#define pool_free(type, ptr) ({				\
    *(void **)ptr = (void *)pool_##type;		\
    pool_##type = (void *)ptr;				\
})

#else
#define pool_alloc(type) (calloc(1,sizeof_##type));
#define pool_free(type, ptr) (free(ptr));
#endif	/* MEM_OPTIM */

#define sizeof_session	sizeof(struct task)
#define sizeof_buffer	sizeof(struct buffer)
#define sizeof_fdtab	sizeof(struct fdtab)
#define sizeof_str256	256


/*
 * different possible states for the sockets
 */
#define FD_STCLOSE	0
#define FD_STLISTEN	1
#define FD_STCONN	2
#define FD_STREADY	3
#define FD_STERROR	4

#define TASK_IDLE	0
#define TASK_RUNNING	1

#define PR_STNEW	0
#define PR_STIDLE	1
#define PR_STRUN	2
#define PR_STDISABLED	3

#define PR_MODE_TCP	0
#define PR_MODE_HTTP	1
#define PR_MODE_HEALTH	2

#define CL_STHEADERS	0
#define CL_STDATA	1
#define CL_STSHUTR	2
#define CL_STSHUTW	3
#define CL_STCLOSE	4

#define SV_STIDLE	0
#define SV_STCONN	1
#define SV_STHEADERS	2
#define SV_STDATA	3
#define SV_STSHUTR	4
#define SV_STSHUTW	5
#define SV_STCLOSE	6

/* result of an I/O event */
#define	RES_SILENT	0	/* didn't happen */
#define RES_DATA	1	/* data were sent or received */
#define	RES_NULL	2	/* result is 0 (read == 0), or connect without need for writing */
#define RES_ERROR	3	/* result -1 or error on the socket (eg: connect()) */

/* modes of operation */
#define	MODE_DEBUG	1
#define	MODE_STATS	2
#define	MODE_LOG	4
#define	MODE_DAEMON	8

/*********************************************************************/

#define LIST_HEAD(a)	((void *)(&(a)))

/*********************************************************************/

struct hdr_exp {
    regex_t *preg;	/* expression to look for */
    char *replace;	/* expression to set instead */
};

struct buffer {
    unsigned int l;			/* data length */
    char *r, *w, *h, *lr;     		/* read ptr, write ptr, last header ptr, last read */
    char data[BUFSIZE];
};

struct server {
    struct server *next;
    char *id;				/* the id found in the cookie */
    struct sockaddr_in addr;		/* the address to connect to */
};

struct task {
    struct task *next, *prev;		/* chaining ... */
    struct task *rqnext;		/* chaining in run queue ... */
    int state;				/* task state : IDLE or RUNNING */
    struct timeval expire;		/* next expiration time for this task, use only for fast sorting */
    /* application specific below */
    struct timeval crexpire;		/* expiration date for a client read  */
    struct timeval cwexpire;		/* expiration date for a client write */
    struct timeval srexpire;		/* expiration date for a server read  */
    struct timeval swexpire;		/* expiration date for a server write */
    struct timeval cnexpire;		/* expiration date for a connect */
    char res_cr, res_cw, res_sr, res_sw;/* results of some events */
    struct proxy *proxy;		/* the proxy this socket belongs to */
    int cli_fd;				/* the client side fd */
    int srv_fd;				/* the server side fd */
    int cli_state;			/* state of the client side */
    int srv_state;			/* state of the server side */
    int conn_retries;			/* number of connect retries left */
    int conn_redisp;			/* allow reconnection to dispatch in case of errors */
    struct buffer *req;			/* request buffer */
    struct buffer *rep;			/* response buffer */
    struct sockaddr_in cli_addr;	/* the client address */
    struct sockaddr_in srv_addr;	/* the address to connect to */
    char cookie_val[SERVERID_LEN+1];	/* the cookie value, if present */
};

struct proxy {
    int listen_fd;			/* the listen socket */
    int state;				/* proxy state */
    struct sockaddr_in listen_addr;	/* the address we listen to */
    struct sockaddr_in dispatch_addr;	/* the default address to connect to */
    struct server *srv;			/* known servers */
    char *cookie_name;			/* name of the cookie to look for */
    int clitimeout;			/* client I/O timeout (in milliseconds) */
    int srvtimeout;			/* server I/O timeout (in milliseconds) */
    int contimeout;			/* connect timeout (in milliseconds) */
    char *id;				/* proxy id */
    int nbconn;				/* # of active sessions */
    int maxconn;			/* max # of active sessions */
    int conn_retries;			/* number of connect retries left */
    int conn_redisp;			/* allow to reconnect to dispatch in case of errors */
    int mode;				/* mode = PR_MODE_TCP or PR_MODE_HTTP */
    struct task task;			/* active sessions (bi-dir chaining) */
    struct task *rq;			/* sessions in the run queue (unidir chaining) */
    struct proxy *next;
    struct sockaddr_in logsrv1, logsrv2; /* 2 syslog servers */
    char logfac1, logfac2;		/* log facility for both servers. -1 = disabled */
    struct timeval stop_time;		/* date to stop listening, when stopping != 0 */
    int nb_cliexp, nb_srvexp;
    struct hdr_exp cli_exp[MAX_REGEXP];	/* regular expressions for client headers */
    struct hdr_exp srv_exp[MAX_REGEXP];	/* regular expressions for server headers */
    int grace;				/* grace time after stop request */
};

/* info about one given fd */
struct fdtab {
    int (*read)(int fd);	/* read function */
    int (*write)(int fd);	/* write function */
    struct task *owner;		/* the session (or proxy) associated with this fd */
    int state;			/* the state of this fd */
};

/*********************************************************************/

int cfg_maxconn = 2000;		/* # of simultaneous connections, (-n) */
int cfg_maxpconn = 2000;	/* # of simultaneous connections per proxy (-N) */
int cfg_maxsock = 0;		/* max # of sockets */
char *cfg_cfgfile = NULL;	/* configuration file */
char *progname = NULL;		/* program name */
int  pid;			/* current process id */
/*********************************************************************/

fd_set	*ReadEvent,
	*WriteEvent,
	*StaticReadEvent,
    	*StaticWriteEvent;

void **pool_session = NULL,
    **pool_buffer   = NULL,
    **pool_fdtab    = NULL,
    **pool_str256   = NULL;

struct proxy *proxy  = NULL;	/* list of all existing proxies */
struct fdtab *fdtab = NULL;	/* array of all the file descriptors */

static int mode = 0;		/* MODE_DEBUG, ... */
static int totalconn = 0;	/* total # of terminated sessions */
static int actconn = 0;		/* # of active sessions */
static int maxfd = 0;		/* # of the highest fd + 1 */
static int listeners = 0;	/* # of listeners */
static int stopping = 0;	/* non zero means stopping in progress */
static struct timeval now = {0,0};	/* the current date at any moment */

static regmatch_t pmatch[MAX_MATCH];  /* rm_so, rm_eo for regular expressions */
static char trash[BUFSIZE];

/*
 * Syslog facilities and levels
 */

#define MAX_SYSLOG_LEN		1024
#define NB_LOG_FACILITIES	24
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"
};


#define NB_LOG_LEVELS	8
const char *log_levels[NB_LOG_LEVELS] = {
    "emerg", "alert", "crit", "err",
    "warning", "notice", "info", "debug"
};

#define SYSLOG_PORT	514

const char *monthname[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
			     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
#define MAX_HOSTNAME_LEN	32
static char hostname[MAX_HOSTNAME_LEN] = "";

/*********************************************************************/
/*  statistics  ******************************************************/
/*********************************************************************/

static int stats_tsk_lsrch, stats_tsk_rsrch,
    stats_tsk_good, stats_tsk_right, stats_tsk_left,
    stats_tsk_new, stats_tsk_nsrch;


/*********************************************************************/
/*  function prototypes  *********************************************/
/*********************************************************************/

int event_accept(int fd);
int event_cli_read(int fd);
int event_cli_write(int fd);
int event_srv_read(int fd);
int event_srv_write(int fd);

/*********************************************************************/
/*  general purpose functions  ***************************************/
/*********************************************************************/

void display_version() {
    printf("HA-Proxy version " HAPROXY_VERSION " " HAPROXY_DATE"\n");
    printf("Copyright 2000-2001 Willy Tarreau <willy AT meta-x DOT org>\n\n");
}

/*
 * This function prints the command line usage and exits
 */
void usage(char *name) {
    display_version();
    fprintf(stderr,
	    "Usage : %s -f <cfgfile> [ -vd"
#if STATTIME > 0
	    "sl"
#endif
	    "D ] [ -n <maxconn> ] [ -N <maxpconn> ]\n"
	    "        -v displays version\n"
	    "        -d enters debug mode\n"
#if STATTIME > 0
	    "        -s enables statistics output\n"
	    "        -l enables long statistics format\n"
#endif
	    "        -D goes daemon\n"
	    "        -n sets the maximum total # of connections (%d)\n"
	    "        -N sets the default, per-proxy maximum # of connections (%d)\n\n",
	    name, cfg_maxconn, cfg_maxpconn);
    exit(1);
}


/*
 * Displays the message on stderr with the date and pid.
 */
void Alert(char *fmt, ...) {
    va_list argp;
    struct timeval tv;
    struct tm *tm;

    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, 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;

    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, getpid());
    vfprintf(stderr, fmt, argp);
    fflush(stderr);
    va_end(argp);
}


/*
 * converts <str> to a struct sockaddr_in* which is locally allocated.
 * The format is "addr:port", where "addr" can be empty or "*" to indicate
 * INADDR_ANY.
 */
struct sockaddr_in *str2sa(char *str) {
    static struct sockaddr_in sa;
    char *c;
    int port;

    bzero(&sa, 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 (
#ifndef SOLARIS
	!inet_aton(str, &sa.sin_addr)
#else
	!inet_pton(AF_INET, str, &sa.sin_addr)
#endif
	) {
	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;
}

/*
 * This function tries to send a syslog message to the syslog server at
 * address <sa>. It doesn't care about errors nor does it report them.
 * WARNING! no check is made on the prog+hostname+date length, so the
 * local hostname + the prog name must be shorter than MAX_SYSLOG_LEN-19.
 * the message will be truncated to fit the maximum length.
 */
void send_syslog(struct sockaddr_in *sa,
		 int facility, int level, char *message)
{

    static int logfd = -1;	/* syslog UDP socket */
    struct timeval tv;
    struct tm *tm;
    static char logmsg[MAX_SYSLOG_LEN];
    char *p;

    if (logfd < 0) {
	if ((logfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
	    return;
    }
    
    if (facility < 0 || level < 0
	|| sa == NULL || progname == NULL || message == NULL)
	return;

    gettimeofday(&tv, NULL);
    tm = localtime(&tv.tv_sec);

    p = logmsg;
    //p += sprintf(p, "<%d>%s %2d %02d:%02d:%02d %s %s[%d]: ",
    //		   facility * 8 + level,
    //		   monthname[tm->tm_mon],
    //		   tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
    //		   hostname, progname, pid);
    /* 20011216/WT : other progs don't set the hostname, and syslogd
     * systematically repeats it which is contrary to RFC3164.
     */
    p += sprintf(p, "<%d>%s %2d %02d:%02d:%02d %s[%d]: ",
		 facility * 8 + level,
		 monthname[tm->tm_mon],
		 tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
		 progname, pid);

    if (((char *)&logmsg - p + MAX_SYSLOG_LEN) > 0) {
	int len = strlen(message);
	if (len > ((char *)&logmsg + MAX_SYSLOG_LEN - p))
	    len = ((char *)&logmsg + MAX_SYSLOG_LEN - p);
	memcpy(p, message, len);
	p += len;
    }
#ifndef MSG_NOSIGNAL
    sendto(logfd, logmsg, p - logmsg, MSG_DONTWAIT,
	   (struct sockaddr *)sa, sizeof(*sa));
#else
    sendto(logfd, logmsg, p - logmsg, MSG_DONTWAIT | MSG_NOSIGNAL,
	   (struct sockaddr *)sa, sizeof(*sa));
#endif
}


/* sets <tv> to the current time */
static inline struct timeval *tv_now(struct timeval *tv) {
    if (tv)
	gettimeofday(tv, NULL);
    return tv;
}

/*
 * adds <ms> ms to <from>, set the result to <tv> and returns a pointer <tv>
 */
static inline 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> : returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2
 */
static inline int tv_cmp(struct timeval *tv1, struct timeval *tv2) {
    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;
}

/*
 * returns the absolute difference, in ms, between tv1 and tv2
 */
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;
}

/*
 * compares <tv1> and <tv2> modulo 1ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2
 */
static inline int tv_cmp_ms(struct timeval *tv1, struct timeval *tv2) {
    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.
 */
static inline unsigned long tv_remain(struct timeval *tv1, struct timeval *tv2) {
    unsigned long ret;
  

    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;
}


/*
 * zeroes a struct timeval
 */

static inline struct timeval *tv_eternity(struct timeval *tv) {
    tv->tv_sec = tv->tv_usec = 0;
    return tv;
}

/*
 * returns 1 if tv is null, else 0
 */
static inline int tv_iseternity(struct timeval *tv) {
    if (tv->tv_sec == 0 && tv->tv_usec == 0)
	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.
 */
static inline 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.
 */
static inline 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 + 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 first event between tv1 and tv2 into tvmin.
 * a zero tv is ignored. tvmin is returned.
 */
static inline struct timeval *tv_min(struct timeval *tvmin,
				     struct timeval *tv1, struct timeval *tv2) {

    if (tv_cmp2(tv1, tv2) <= 0)
	*tvmin = *tv1;
    else
	*tvmin = *tv2;

    return tvmin;
}



/***********************************************************/
/*   fd management   ***************************************/
/***********************************************************/



/* deletes an FD from the fdsets, and recomputes the maxfd limit */
static inline void fd_delete(int fd) {
    fdtab[fd].state = FD_STCLOSE;
    FD_CLR(fd, StaticReadEvent);
    FD_CLR(fd, StaticWriteEvent);

    while ((maxfd-1 >= 0) && (fdtab[maxfd-1].state == FD_STCLOSE))
	    maxfd--;
}

/* recomputes the maxfd limit from the fd */
static inline void fd_insert(int fd) {
    if (fd+1 > maxfd)
	maxfd = fd+1;
}

/*************************************************************/
/*   task management   ***************************************/
/*************************************************************/

/* puts the task <s> in <p>'s run queue, and returns <s> */
static inline struct task *task_wakeup(struct proxy *p, struct task *s) {
    //    fprintf(stderr,"task_wakeup: proxy %p, task %p\n", p, s);

    if (s->state == TASK_RUNNING)
	return s;
    else {
	s->rqnext = p->rq;
	s->state = TASK_RUNNING;
	return p->rq = s;
    }
}

/* removes the task <s> from <p>'s run queue.
 * <s> MUST be <p>'s first task in the queue.
 * set the run queue to point to the next one, and return it
 */
static inline struct task *task_sleep(struct proxy *p, struct task *s) {
    if (s->state == TASK_RUNNING) {
	p->rq = s->rqnext;
	s->state = TASK_IDLE; /* tell that s has left the run queue */
    }
    return p->rq; /* return next running task */
}

/*
 * removes the task <s> from its wait queue. It must have already been removed
 * from the run queue. A pointer to the task itself is returned.
 */
static inline struct task *task_delete(struct task *s) {
    s->prev->next = s->next;
    s->next->prev = s->prev;
    return s;
}

/*
 * frees  the context associated to a task. It must have been removed first.
 */
static inline void task_free(struct task *t) {
    if (t->req)
	pool_free(buffer, t->req);
    if (t->rep)
	pool_free(buffer, t->rep);
    pool_free(session, t);
}

/* inserts <task> into the list <list>, 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 *list, struct task *task) {
    struct task *start_from;

    /* first, test if the task was already in a list */
    if (task->prev == NULL) {
	//	start_from = list;
	start_from = list->prev;
	stats_tsk_new++;

	/* 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;
	    stats_tsk_nsrch++;
	}
	
	//	  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) {
	    stats_tsk_good++;
	    return task; /* it's already in the right place */
	}

	stats_tsk_right++;
	/* 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;
	    stats_tsk_rsrch++;
	}
	/* we need to unlink it now */
	task_delete(task);
    }
    else { /* walk left. */
	stats_tsk_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;
	    stats_tsk_lsrch++;
	}
#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;
	    stats_tsk_lsrch++;
	}
#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;
}


/*********************************************************************/
/*   more specific functions   ***************************************/
/*********************************************************************/

/* some prototypes */
static int maintain_proxies(void);


/*
 * This function initiates a connection to the server whose name is in <s->proxy->src->id>,
 * or the dispatch server if <id> not found. It returns 0 if
 * it's OK, -1 if it's impossible.
 */
int connect_server(struct task *s, int usecookie) {
    struct server *srv = s->proxy->srv;
    char *sn = s->cookie_val;
    int one = 1;
    int fd;

    //    fprintf(stderr,"connect_server : s=%p\n",s);

    if (usecookie) {
	while (*sn && srv && strcmp(sn, srv->id)) {
	    srv = srv->next;
	}
	if (!srv || !*sn) { /* server not found, let's use the dispatcher */
	    s->srv_addr = s->proxy->dispatch_addr;
	}
	else {
	    s->srv_addr = srv->addr;
	}
    }
    else
	s->srv_addr = s->proxy->dispatch_addr;

    if ((fd = s->srv_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
	fprintf(stderr,"Cannot get a server socket.\n");
	return -1;
    }
	
    if ((fcntl(fd, F_SETFL, O_NONBLOCK)==-1) ||
	(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)) == -1)) {
	fprintf(stderr,"Cannot set client socket to non blocking mode.\n");
	close(fd);
	return -1;
    }

    if ((connect(fd, (struct sockaddr *)&s->srv_addr, sizeof(s->srv_addr)) == -1) && (errno != EINPROGRESS)) {
	if (errno == EAGAIN) { /* no free ports left, try again later */
	    fprintf(stderr,"Cannot connect, no free ports.\n");
	    close(fd);
	    return -1;
	}
	else if (errno != EALREADY && errno != EISCONN) {
	    close(fd);
	    return -1;
	}
    }

    fdtab[fd].owner = s;
    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 */
    
    fd_insert(fd);

    if (s->proxy->contimeout)
	tv_delayfrom(&s->cnexpire, &now, s->proxy->contimeout);
    else
	tv_eternity(&s->cnexpire);
    return 0;
}
    
/*
 * this function is called on a read event from a client socket.
 * It returns 0.
 */
int event_cli_read(int fd) {
    struct task *s = fdtab[fd].owner;
    struct buffer *b = s->req;
    int ret, max;

    //    fprintf(stderr,"event_cli_read : fd=%d, s=%p\n", fd, s);

    if (b->l == 0) { /* let's realign the buffer to optimize I/O */
	b->r = b->w = b->data;
	max = BUFSIZE - MAXREWRITE;
    }
    else if (b->r > b->w) {
	max = b->data + BUFSIZE - MAXREWRITE - b->r;
    }
    else {
	max = b->w - b->r;
	if (max > BUFSIZE - MAXREWRITE)
	    max = BUFSIZE - MAXREWRITE;
    }

    if (max == 0) {
	FD_CLR(fd, StaticReadEvent);
	//fprintf(stderr, "cli_read(%d) : max=%d, d=%p, r=%p, w=%p, l=%d\n",
	//fd, max, b->data, b->r, b->w, b->l);
	return 0;
    }

    if (fdtab[fd].state != FD_STERROR) {
#ifndef MSG_NOSIGNAL
	int skerr, lskerr;
	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 */
	    }
	}
	else if (ret == 0)
	    s->res_cr = RES_NULL;
	else if (errno == EAGAIN) /* ignore EAGAIN */
	    return 0;
	else {
	    s->res_cr = RES_ERROR;
	    fdtab[fd].state = FD_STERROR;
	}
    }
    else {
	s->res_cr = RES_ERROR;
	fdtab[fd].state = FD_STERROR;
    }

    if (s->proxy->clitimeout)
	tv_delayfrom(&s->crexpire, &now, s->proxy->clitimeout);
    else
	tv_eternity(&s->crexpire);

    task_wakeup(s->proxy, s);
    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 *s = fdtab[fd].owner;
    struct buffer *b = s->rep;
    int ret, max;

    //    fprintf(stderr,"event_srv_read : fd=%d, s=%p\n", fd, s);

    if (b->l == 0) { /* let's realign the buffer to optimize I/O */
	b->r = b->w = b->data;
	max = BUFSIZE - MAXREWRITE;
    }
    else if (b->r > b->w) {
	max = b->data + BUFSIZE - MAXREWRITE - b->r;
    }
    else {
	max = b->w - b->r;
    	if (max > BUFSIZE - MAXREWRITE)
	    max = BUFSIZE - MAXREWRITE;
    }

    if (max == 0) {
	FD_CLR(fd, StaticReadEvent);
	//fprintf(stderr, "srv_read(%d) : max=%d, d=%p, r=%p, w=%p, l=%d\n",
	//fd, max, b->data, b->r, b->w, b->l);
	return 0;
    }

    if (fdtab[fd].state != FD_STERROR) {
#ifndef MSG_NOSIGNAL
	int skerr, lskerr;
	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 */
	    }
	}
	else if (ret == 0)
	    s->res_sr = RES_NULL;
	else if (errno != EAGAIN) /* ignore EAGAIN */
	    return 0;
	else {
	    s->res_sr = RES_ERROR;
	    fdtab[fd].state = FD_STERROR;
	}
    }
    else {
	s->res_sr = RES_ERROR;
	fdtab[fd].state = FD_STERROR;
    }


    if (s->proxy->srvtimeout)
	tv_delayfrom(&s->srexpire, &now, s->proxy->srvtimeout);
    else
	tv_eternity(&s->srexpire);

    task_wakeup(s->proxy, s);
    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 *s = fdtab[fd].owner;
    struct buffer *b = s->rep;
    int ret, max;

    //    fprintf(stderr,"event_cli_write : fd=%d, s=%p\n", fd, s);

    if (b->l == 0) { /* let's realign the buffer to optimize I/O */
	b->r = b->w = 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 (max == 0) {
	FD_CLR(fd, StaticWriteEvent);
	//fprintf(stderr, "cli_write(%d) : max=%d, d=%p, r=%p, w=%p, l=%d\n",
	//fd, max, b->data, b->r, b->w, b->l);
	s->res_cw = RES_NULL;
	return 0;
    }

    if (fdtab[fd].state != FD_STERROR) {
#ifndef MSG_NOSIGNAL
	int skerr, lskerr;
#endif
	if (max == 0) { /* nothing to write, just make as if we were never called */
		s->res_cw = RES_NULL;
		task_wakeup(s->proxy, s);
		return 0;
	}

#ifndef MSG_NOSIGNAL
	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);
    else
	tv_eternity(&s->cwexpire);

    task_wakeup(s->proxy, s);
    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 *s = fdtab[fd].owner;
    struct buffer *b = s->req;
    int ret, max;

    //fprintf(stderr,"event_srv_write : fd=%d, s=%p\n", fd, s);

    if (b->l == 0) { /* let's realign the buffer to optimize I/O */
	b->r = b->w = 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 (max == 0) {
	FD_CLR(fd, StaticWriteEvent);
	//fprintf(stderr, "srv_write(%d) : max=%d, d=%p, r=%p, w=%p, l=%d\n",
	//fd, max, b->data, b->r, b->w, b->l);
	s->res_sw = RES_NULL;
	return 0;
    }

    if (fdtab[fd].state != FD_STERROR) {
#ifndef MSG_NOSIGNAL
	int skerr, lskerr;
#endif
	fdtab[fd].state = FD_STREADY;
	if (max == 0) { /* nothing to write, just make as if we were never called, except to finish a connect() */
	    s->res_sw = RES_NULL;
	    task_wakeup(s->proxy, s);
	    return 0;
	}

#ifndef MSG_NOSIGNAL
	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_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;
    }

    if (s->proxy->srvtimeout)
	tv_delayfrom(&s->swexpire, &now, s->proxy->srvtimeout);
    else
	tv_eternity(&s->swexpire);

    task_wakeup(s->proxy, s);
    return 0;
}


/*
 * this function is called on a read event from a listen socket, corresponding
 * to an accept. It returns 0.
 */
int event_accept(int fd) {
    struct proxy *p = (struct proxy *)fdtab[fd].owner;
    struct task *s;
    int laddr;
    int cfd;
    int one = 1;

    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;
	return 0;
    }

    laddr = sizeof(s->cli_addr);
    if ((cfd = accept(fd, (struct sockaddr *)&s->cli_addr, &laddr)) == -1) {
	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(session, s);
	return 0;
    }

    if ((p->mode == PR_MODE_TCP || p->mode == PR_MODE_HTTP)
	&& (p->logfac1 >= 0 || p->logfac2 >= 0)) {
	struct sockaddr_in peername, sockname;
	unsigned char *pn, *sn;
	int namelen;
	char message[256];

	namelen = sizeof(peername);
	getpeername(cfd, (struct sockaddr *)&peername, &namelen);
	pn = (unsigned char *)&peername.sin_addr;

	namelen = sizeof(sockname);
	getsockname(cfd, (struct sockaddr *)&sockname, &namelen);
	sn = (unsigned char *)&sockname.sin_addr;

	sprintf(message, "Connect from %d.%d.%d.%d:%d to %d.%d.%d.%d:%d (%s/%s)\n",
		pn[0], pn[1], pn[2], pn[3], ntohs(peername.sin_port),
		sn[0], sn[1], sn[2], sn[3], ntohs(sockname.sin_port),
		p->id, (p->mode == PR_MODE_HTTP) ? "HTTP" : "TCP");

	if (p->logfac1 >= 0)
	    send_syslog(&p->logsrv1, p->logfac1, LOG_INFO, message);
	if (p->logfac2 >= 0)
	    send_syslog(&p->logsrv2, p->logfac2, LOG_INFO, message);
    }

    s->proxy = p;
    s->state = TASK_IDLE;
    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->cookie_val[0] = 0;
    s->res_cr = s->res_cw = s->res_sr = s->res_sw = RES_SILENT;
    s->rqnext = NULL; /* task not in run queue */
    s->next = s->prev = NULL;
    s->cli_fd = cfd;
    s->conn_retries = p->conn_retries;
    s->conn_redisp  = p->conn_redisp;

    if ((s->req = pool_alloc(buffer)) == NULL) { /* no memory */
	close(cfd); /* nothing can be done for this fd without memory */
	pool_free(session, s);
	return 0;
    }
    s->req->l = 0;
    s->req->h = s->req->r = s->req->lr = s->req->w = s->req->data;		/* r and w will be reset further */

    if ((s->rep = pool_alloc(buffer)) == NULL) { /* no memory */
	pool_free(buffer, s->req);
	close(cfd); /* nothing can be done for this fd without memory */
	pool_free(session, s);
	return 0;
    }
    s->rep->l = 0;
    s->rep->h = s->rep->r = s->rep->lr = s->rep->w = s->rep->data;

    fdtab[cfd].read  = &event_cli_read;
    fdtab[cfd].write = &event_cli_write;
    fdtab[cfd].owner = s;
    fdtab[cfd].state = FD_STREADY;

    if (p->mode == PR_MODE_HEALTH) {  /* health check mode, no client reading */
	FD_CLR(cfd, StaticReadEvent);
	tv_eternity(&s->crexpire);
	shutdown(s->cli_fd, SHUT_RD);
	s->cli_state = CL_STSHUTR;

	strcpy(s->rep->data, "OK\n"); /* forge an "OK" response */
	s->rep->l = 3;
	s->rep->r += 3;
    }
    else {
	FD_SET(cfd, StaticReadEvent);
    }

    fd_insert(cfd);

    tv_eternity(&s->cnexpire);
    tv_eternity(&s->srexpire);
    tv_eternity(&s->swexpire);
    tv_eternity(&s->cwexpire);

    if (s->proxy->clitimeout)
	tv_delayfrom(&s->crexpire, &now, s->proxy->clitimeout);
    else
	tv_eternity(&s->crexpire);

    s->expire = s->crexpire;

    task_queue(LIST_HEAD(p->task), s);
    task_wakeup(p, s);

    p->nbconn++;
    actconn++;
    totalconn++;

    // fprintf(stderr, "accepting from %p => %d conn, %d total\n", p, actconn, totalconn);

    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 *str, char *end) {
    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);

    if (b->r >= end) b->r += delta;
    if (b->w >= end) b->w += delta;
    if (b->h >= end) b->h += delta;
    if (b->lr >= end) b->lr += delta;
    b->l += delta;

    return delta;
}

/* same except that the string len is given */
int buffer_replace2(struct buffer *b, char *pos, char *str, int len, char *end) {
    int delta;

    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);

    if (b->r >= end) b->r += delta;
    if (b->w >= end) b->w += delta;
    if (b->h >= end) b->h += delta;
    if (b->lr >= end) b->lr += delta;
    b->l += delta;

    return delta;
}


int exp_replace(char *dst, char *src, char *str, regmatch_t *matches) {
    char *old_dst = dst;

    while (*str) {
	if (*str == '\\') {
	    str++;
	    if (isdigit(*str)) {
		int len, num;

		num = *str - '0';
		str++;

		if (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;
}

/*
 * 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 task *t) {
    int s = t->srv_state;
    int c = t->cli_state;
    struct buffer *req = t->req;
    struct buffer *rep = t->rep;

    //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) {
	char *ptr;
	
	/* read timeout, read error, or last read : give up */
	if (t->res_cr == RES_ERROR || t->res_cr == RES_NULL ||
	    tv_cmp2_ms(&t->crexpire, &now) <= 0) {
	    FD_CLR(t->cli_fd, StaticReadEvent);
	    FD_CLR(t->cli_fd, StaticWriteEvent);
	    fd_delete(t->cli_fd);
	    close(t->cli_fd);
	    tv_eternity(&t->crexpire);
	    t->cli_state = CL_STCLOSE;
	    return 1;
	}
	else if (t->res_cr == RES_SILENT) {
	    return 0;
	}
	/* now we know that there are headers to process */

	if (req->l >= BUFSIZE - MAXREWRITE) {
	    /* buffer full : stop reading till we free some space */
	    FD_CLR(t->cli_fd, StaticReadEvent);
	    tv_eternity(&t->crexpire);
	}

	ptr = req->lr;
	req->lr = req->r; /* tell that bytes up to <lr> have been read and processes */
	while (ptr < req->r) {
	    /* look for the end of the current header */
	    while (ptr < req->r && *ptr != '\n' && *ptr != '\r')
		ptr++;
	    
	    if (ptr < req->r) {
		/* now we have one complete client header between req->h and ptr */
		if (ptr == req->h) { /* empty line, end of headers */
		    t->cli_state = CL_STDATA;
		    //req->lr = ptr; /* tell that bytes up to <lr> have been read and processes */
		    return 1;
		}
		else {
		    /* we have one standard header */
		    if (mode & MODE_DEBUG) {
			int len, max;
			len = sprintf(trash, "clihdr[%04x:%04x]: ", (unsigned  short)t->cli_fd, (unsigned short)t->srv_fd);
			max = ptr - req->h;
			if (max > sizeof(trash) - len - 2)
			    max = sizeof(trash) - len - 2;
			strncat(trash+len, req->h, max); len += max;
			trash[len++] = '\n';
			trash[len] = '\0';
			//    write(1,"Client Header found: ",21);
		    	//    write(1, req->h, ptr - req->h);
		    	//    write(1, "\n", 1);
			write(1, trash, len);
		    }

		    if ((req->r >= req->h + 8) && (t->proxy->cookie_name != NULL)
			&& (strncmp(req->h, "Cookie: ", 8) == 0)) {
			char *p1, *p2, *p3, *p4;

			p1 = req->h + 8; /* first char after 'Cookie: ' */

			while (p1 < ptr) {
			    while (p1 < ptr && (isspace(*p1) || *p1 == ';'))
				p1++;

			    if (p1 == ptr)
				break;
			    else if (*p1 == ';') { /* next cookie */
				++p1;
				continue;
			    }

			    /* p1 is at the beginning of the cookie name */
			    p2 = p1;

			    while (p2 < ptr && *p2 != '=' && *p2 != ';')
				p2++;

			    if (p2 == ptr)
				break;
			    else if (*p2 == ';') { /* next cookie */
				p1=++p2;
				continue;
			    }

			    p3 = p2 + 1; /* skips the '=' sign */
			    if (p3 == ptr)
				break;

			    p4=p3;
			    while (p4 < ptr && !isspace(*p4) && *p4 != ';')
				p4++;

			    /* here, we have the cookie name between p1 and p2,
			     * and its value between p3 and p4.
			     * we can process it.
			     */

			    if ((p2-p1 == strlen(t->proxy->cookie_name)) &&
				(strncmp(p1, t->proxy->cookie_name, p2-p1) == 0)) {
				/* Cool... it's the right one */
				int l;
				l = (p4 - p3) < SERVERID_LEN ?
				    (p4 - p3) : SERVERID_LEN;
				strncpy(t->cookie_val, p3, l);
				t->cookie_val[l] = 0;
				break;
			    }
			    else {
//				fprintf(stderr,"Ignoring unknown cookie : ");
//				write(2, p1, p2-p1);
//				fprintf(stderr," = ");
//				write(2, p3, p4-p3);
//				fprintf(stderr,"\n");
			    }
			    /* we'll have to look for another cookie ... */
			    p1 = p4;
			}
			/* FIXME */
//			fprintf(stderr,"Cookie is now: <%s>\n", s->cookie_val);
		    }
		    else if (t->proxy->nb_cliexp) { /* try headers regexps */
			struct proxy *p = t->proxy;
			int exp;
			char term;

			term = *ptr;
			*ptr = '\0';
			for (exp=0; exp < p->nb_cliexp; exp++) {
			    if (regexec(p->cli_exp[exp].preg, req->h, MAX_MATCH, pmatch, 0) == 0) {
				int len = exp_replace(trash, req->h, p->cli_exp[exp].replace, pmatch);
				ptr += buffer_replace2(req, req->h, trash, len, ptr);
				break;
			    }
			}
			*ptr = term; /* restore the string terminator */
		    }
		    
		    /* look for the beginning of the next header */
		    if (ptr < req->r) {
			if (*ptr == '\n') {
			    if ((++ptr < req->r) && (*ptr == '\r'))
				ptr++;
			}
			else if (*ptr == '\r') {
			    if ((++ptr < req->r) && (*ptr == '\n'))
				ptr++;
			}
			req->h = ptr;
		    }
		}
	    }
	    else if (ptr >= req->data + BUFSIZE - MAXREWRITE) { /* no more headers */
		t->cli_state = CL_STDATA;
		FD_CLR(t->cli_fd, StaticReadEvent);
		tv_eternity(&t->crexpire);
		//req->lr = ptr; /* tell that bytes up to <lr> have been read and processes */
		return 1;
	    }
	}
	//req->lr = ptr; /* tell that bytes up to <lr> have been read and processes */
    }
    else if (c == CL_STDATA) {
	/* read or write error */
	if (t->res_cw == RES_ERROR || t->res_cr == RES_ERROR) {
	    FD_CLR(t->cli_fd, StaticReadEvent);
	    FD_CLR(t->cli_fd, StaticWriteEvent);
	    tv_eternity(&t->crexpire);
	    tv_eternity(&t->cwexpire);
	    close(t->cli_fd);
	    t->cli_state = CL_STCLOSE;
	    return 1;
	}
	/* read timeout, last read, or end of server write */
	else if (t->res_cr == RES_NULL || s == SV_STSHUTW || s == SV_STCLOSE
		 || tv_cmp2_ms(&t->crexpire, &now) <= 0) {

	    FD_CLR(t->cli_fd, StaticReadEvent);
	    //	    if (req->l == 0) /* nothing to write on the server side */
	    //		FD_CLR(t->srv_fd, StaticWriteEvent);
	    tv_eternity(&t->crexpire);
	    shutdown(t->cli_fd, SHUT_RD);
	    t->cli_state = CL_STSHUTR;
	    return 1;
	}	
	/* write timeout, or last server read and buffer empty */
	else if (((s == SV_STSHUTR || s == SV_STCLOSE) && (rep->l == 0))
		 ||(tv_cmp2_ms(&t->cwexpire, &now) <= 0)) {

	    FD_CLR(t->cli_fd, StaticWriteEvent);
	    tv_eternity(&t->cwexpire);
	    shutdown(t->cli_fd, SHUT_WR);
	    t->cli_state = CL_STSHUTW;
	    return 1;
	}

	if (req->l >= BUFSIZE - MAXREWRITE) { /* no room to read more data */
	    if (FD_ISSET(t->cli_fd, StaticReadEvent)) {
		FD_CLR(t->cli_fd, StaticReadEvent);
		tv_eternity(&t->crexpire);
	    }
	}
	else {
	    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);
	    }
	}

	if ((rep->l == 0) ||
	    ((s == SV_STHEADERS) && (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);
		else
		    tv_eternity(&t->cwexpire);
	    }
	}
	return 0; /* other cases change nothing */
    }
    else if (c == CL_STSHUTR) {
	if ((t->res_cw == RES_ERROR) ||
	    ((s == SV_STSHUTR || s == SV_STCLOSE) && (rep->l == 0))
	    || (tv_cmp2_ms(&t->crexpire, &now) <= 0)) {
	    
	    FD_CLR(t->cli_fd, StaticWriteEvent);
	    tv_eternity(&t->cwexpire);
	    fd_delete(t->cli_fd);
	    close(t->cli_fd);
	    t->cli_state = CL_STCLOSE;
	    return 1;
	}
	else if ((rep->l == 0) ||
	    ((s == SV_STHEADERS) && (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);
		else
		    tv_eternity(&t->cwexpire);
	    }
	}
	return 0;
    }
    else if (c == CL_STSHUTW) {
	if (t->res_cr == RES_ERROR || t->res_cr == RES_NULL || s == SV_STSHUTW ||
	    s == SV_STCLOSE || tv_cmp2_ms(&t->cwexpire, &now) <= 0) {
	    FD_CLR(t->cli_fd, StaticReadEvent);
	    tv_eternity(&t->crexpire);
	    fd_delete(t->cli_fd);
	    close(t->cli_fd);
	    t->cli_state = CL_STCLOSE;
	    return 1;
	}
	else if (req->l >= BUFSIZE - MAXREWRITE) { /* no room to read more data */
	    if (FD_ISSET(t->cli_fd, StaticReadEvent)) {
		FD_CLR(t->cli_fd, StaticReadEvent);
		tv_eternity(&t->crexpire);
	    }
	}
	else {
	    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);
	    }
	}
	return 0;
    }
    else { /* CL_STCLOSE: nothing to do */
	if (mode & MODE_DEBUG) {
	    int len;
	    len = sprintf(trash, "clicls[%04x:%04x]\n", t->cli_fd, 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 task *t) {
    int s = t->srv_state;
    int c = t->cli_state;
    struct buffer *req = t->req;
    struct buffer *rep = t->rep;

    //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)) { /* give up */
	    tv_eternity(&t->cnexpire);
	    t->srv_state = SV_STCLOSE;
	    return 1;
	}
	else { /* go to SV_STCONN */
	    if (connect_server(t, 1) == 0) { /* initiate a connection to the server */
		//fprintf(stderr,"0: c=%d, s=%d\n", c, s);
		t->srv_state = SV_STCONN;
	    }
	    else { /* try again */
		while (t->conn_retries-- > 0) {
		    if (connect_server(t, !t->conn_redisp || (t->conn_retries > 0)) == 0) {
			t->srv_state = SV_STCONN;
			break;
		    }
		}
		if (t->conn_retries < 0) {
		    /* if conn_retries < 0 or other error, let's abort */
		    tv_eternity(&t->cnexpire);
		    t->srv_state = SV_STCLOSE;
		}
	    }
	    return 1;
	}
    }
    else if (s == SV_STCONN) { /* connection in progress */
	if (t->res_sw == RES_SILENT && tv_cmp2_ms(&t->cnexpire, &now) > 0) {
	    //fprintf(stderr,"1: c=%d, s=%d\n", c, s);
	    return 0; /* nothing changed */
	}
	else if (t->res_sw == RES_SILENT || t->res_sw == RES_ERROR) {
	    //fprintf(stderr,"2: c=%d, s=%d\n", c, s);
	    /* timeout,  connect error or first write error */
	    FD_CLR(t->srv_fd, StaticWriteEvent);
	    fd_delete(t->srv_fd);
	    close(t->srv_fd);
	    t->conn_retries--;
	    if (t->conn_retries >= 0 &&
		connect_server(t, !t->conn_redisp || (t->conn_retries > 0)) == 0) {
		return 0; /* no state changed */
	    }
	    /* if conn_retries < 0 or other error, let's abort */
	    tv_eternity(&t->cnexpire);
	    t->srv_state = SV_STCLOSE;
	    return 1;
	}
	else { /* no error or write 0 */
	    //fprintf(stderr,"3: c=%d, s=%d\n", c, s);
	    if (req->l == 0) /* nothing to write */
		FD_CLR(t->srv_fd, StaticWriteEvent);
	    else  /* need the right to write */
		FD_SET(t->srv_fd, StaticWriteEvent);

	    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;
	    }
	    else
		t->srv_state = SV_STHEADERS;
	    return 1;
	}
    }
    else if (s == SV_STHEADERS) { /* receiving server headers */
	char *ptr;
	int header_processed = 0;

	/* read or write error */
	if (t->res_sw == RES_ERROR || t->res_sr == RES_ERROR) {
	    FD_CLR(t->srv_fd, StaticReadEvent);
	    FD_CLR(t->srv_fd, StaticWriteEvent);
	    tv_eternity(&t->srexpire);
	    tv_eternity(&t->swexpire);
	    close(t->srv_fd);
	    t->srv_state = SV_STCLOSE;
	    return 1;
	}
	/* read timeout, last read, or end of client write */
	else if (t->res_sr == RES_NULL || c == CL_STSHUTW || c == CL_STCLOSE ||
		 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;
	    return 1;
	    
	}	
	/* write timeout, or last client read and buffer empty */
	else if (((c == CL_STSHUTR || c == CL_STCLOSE) && (req->l == 0)) ||
		 (tv_cmp2_ms(&t->swexpire, &now) <= 0)) {
	    FD_CLR(t->srv_fd, StaticWriteEvent);
	    tv_eternity(&t->swexpire);
	    shutdown(t->srv_fd, SHUT_WR);
	    t->srv_state = SV_STSHUTW;
	    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);
		else
		    tv_eternity(&t->swexpire);
	    }
	}

	if (rep->l >= BUFSIZE - MAXREWRITE) { /* no room to read more data */
	    if (FD_ISSET(t->srv_fd, StaticReadEvent)) {
		FD_CLR(t->srv_fd, StaticReadEvent);
		tv_eternity(&t->srexpire);
	    }
	}

	/* now parse the partial (or complete) headers */

	//fprintf(stderr,"rep->data=%p, rep->lr=%p, rep->r=%p, rep->l=%d\n", rep->data, rep->lr, rep->r, rep->l);
	ptr = rep->lr;
	rep->lr = rep->r;

	//write(1,"rep=",4); write(1, ptr, 4); write(1,"\n",1);
	//write(1,"hdr=",4); write(1, rep->h, 4); write(1,"\n",1);
	while (ptr < rep->r) {
	    /* look for the end of the current header */
	    while (ptr < rep->r && *ptr != '\n' && *ptr != '\r')
		ptr++;
	    
	    if (ptr < rep->r) {
		//write(1,"ptr=",4); write(1, ptr, 4); write(1,"\n",1);
		/* now we have one complete header between rep->h and ptr */
		header_processed = 1;
		if (ptr == rep->h) { /* empty line, end of headers */
		    t->srv_state = SV_STDATA;
		    //rep->lr = ptr; /* tell that bytes up to <lr> have been read and processes */
		    return 1;
		}
		else {
		    /* we have one standard header */
		    if (mode & MODE_DEBUG) {
			int len, max;
			len = sprintf(trash, "srvhdr[%04x:%04x]: ", (unsigned  short)t->cli_fd, (unsigned short)t->srv_fd);
			max = ptr - rep->h;
			if (max > sizeof(trash) - len - 2)
			    max = sizeof(trash) - len - 2;
			strncat(trash+len, rep->h, max); len += max;
			trash[len++] = '\n';
			trash[len] = '\0';
			write(1, trash, len);
			//    write(1,"Server Header found: ",21);
		    	//    write(1, rep->h, ptr-rep->h);
		    	//    write(1, "\n", 1);
		    }

		    if (t->proxy->nb_srvexp) { /* try headers regexps */
			struct proxy *p = t->proxy;
			int exp;
			char term;

			term = *ptr;
			*ptr = '\0';
			for (exp=0; exp < p->nb_srvexp; exp++) {
			    if (regexec(p->srv_exp[exp].preg, rep->h, MAX_MATCH, pmatch, 0) == 0) {
				int len = exp_replace(trash, rep->h, p->srv_exp[exp].replace, pmatch);
				ptr += buffer_replace2(rep, rep->h, trash, len, ptr);
				break;
			    }
			}
			*ptr = term; /* restore the string terminator */
		    }

		    /* look for the beginning of the next header */
		    if (ptr < rep->r) {
			if (*ptr == '\n') {
			    if ((++ptr < rep->r) && (*ptr == '\r'))
				ptr++;
			}
			else if (*ptr == '\r') {
			    if ((++ptr < rep->r) && (*ptr == '\n'))
				ptr++;
			}
			rep->h = ptr;
		    }
		}
		//// rep->lr = ptr;
		//rep->lr = rep->h;
	    }
	}

	if ((rep->l < BUFSIZE - MAXREWRITE) && ! 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);
	}

	/* be nice with the client side which would like to send a complete header */
	return header_processed;
	//return 0;
    }
    else if (s == SV_STDATA) {
	/* read or write error */
	if (t->res_sw == RES_ERROR || t->res_sr == RES_ERROR) {
	    FD_CLR(t->srv_fd, StaticReadEvent);
	    FD_CLR(t->srv_fd, StaticWriteEvent);
	    tv_eternity(&t->srexpire);
	    tv_eternity(&t->swexpire);
	    close(t->srv_fd);
	    t->srv_state = SV_STCLOSE;
	    return 1;
	}
	/* read timeout, last read, or end of client write */
	else if (t->res_sr == RES_NULL || c == CL_STSHUTW || c == CL_STCLOSE ||
		 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;
	    return 1;
	    
	}	
	/* write timeout, or last client read and buffer empty */
	else if (((c == CL_STSHUTR || c == CL_STCLOSE) && (req->l == 0)) ||
		 (tv_cmp2_ms(&t->swexpire, &now) <= 0)) {
	    FD_CLR(t->srv_fd, StaticWriteEvent);
	    tv_eternity(&t->swexpire);
	    shutdown(t->srv_fd, SHUT_WR);
	    t->srv_state = SV_STSHUTW;
	    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);
		else
		    tv_eternity(&t->swexpire);
	    }
	}

	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) ||
	    ((c == CL_STSHUTR || c == CL_STCLOSE) && (req->l == 0)) ||
	    (tv_cmp2_ms(&t->swexpire, &now) <= 0)) {

	    FD_CLR(t->srv_fd, StaticWriteEvent);
	    tv_eternity(&t->swexpire);
	    fd_delete(t->srv_fd);
	    close(t->srv_fd);
	    t->srv_state = SV_STCLOSE;
	    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);
		else
		    tv_eternity(&t->swexpire);
	    }
	}
	return 0;
    }
    else if (s == SV_STSHUTW) {
	if (t->res_sr == RES_ERROR || t->res_sr == RES_NULL ||
	    c == CL_STSHUTW || c == CL_STCLOSE ||
	    tv_cmp2_ms(&t->srexpire, &now) <= 0) {

	    FD_CLR(t->srv_fd, StaticReadEvent);
	    tv_eternity(&t->srexpire);
	    fd_delete(t->srv_fd);
	    close(t->srv_fd);
	    t->srv_state = SV_STCLOSE;
	    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 (mode & MODE_DEBUG) {
	    int len;
	    len = sprintf(trash, "srvcls[%04x:%04x]\n", t->cli_fd, t->srv_fd);
	    write(1, trash, len);
	}
	return 0;
    }
    return 0;
}


/*
 * puts a task back to the wait queue in a clean state, or
 * cleans up its resources if it must be deleted.
 */
void process_task(struct task *t) {

    if (t->cli_state != CL_STCLOSE || t->srv_state != SV_STCLOSE) {
	struct timeval min1, min2;
	t->res_cw = t->res_cr = t->res_sw = t->res_sr = RES_SILENT;

	tv_min(&min1, &t->crexpire, &t->cwexpire);
	tv_min(&min2, &t->srexpire, &t->swexpire);
	tv_min(&min1, &min1, &t->cnexpire);
	tv_min(&t->expire, &min1, &min2);

	/* restore t to its place in the task list */
	task_queue(LIST_HEAD(t->proxy->task), t);

	return; /* nothing more to do */
    }

    t->proxy->nbconn--;
    actconn--;
    
    if (mode & MODE_DEBUG) {
	int len;
	len = sprintf(trash, "closed[%04x:%04x]\n", t->cli_fd, t->srv_fd);
	write(1, trash, len);
    }

    /* the task MUST not be in the run queue anymore */
    task_delete(t);
    task_free(t);
}


#if STATTIME > 0
int stats(void);
#endif

/*
 * Main select() loop.
 */

void select_loop() {
  int next_time;
#if STATTIME > 0
  int time2;
#endif
  int status;
  int fd,i;
  struct timeval delta;
  int readnotnull, writenotnull;
  struct proxy *p;

  /* stop when there's no connection left and we don't allow them anymore */
  while (actconn || listeners > 0) {
      next_time = -1;
      tv_now(&now);

      maintain_proxies();
	  
#if STATTIME > 0
      time2 = stats();
      //      fprintf(stderr,"                stats = %d\n", time2);
      next_time = MINTIME(time2, next_time);
#endif

      if (next_time >= 0) {
	  /* Convert to timeval */
	  delta.tv_sec=next_time/1000; 
	  delta.tv_usec=(next_time%1000)*1000;
      }


      /* let's restore fdset state */

      readnotnull = 0; writenotnull = 0;
      for (i = 0; i < (cfg_maxsock + 3 + 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);
      
      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 (fdtab[fd].state == FD_STCLOSE)
			  continue;

		      if (FD_ISSET(fd, WriteEvent))
			  fdtab[fd].write(fd);
		      
		      if (FD_ISSET(fd, ReadEvent))
			  fdtab[fd].read(fd);
		  }
      }
      else {
	  //	  fprintf(stderr,"select returned %d, maxfd=%d\n", status, maxfd);
      }

      for (p = proxy; p; p = p->next) {
	  struct task *t, *tnext;
	  tnext = ((struct task *)LIST_HEAD(p->task))->next;
	  while ((t = tnext) != LIST_HEAD(p->task)) { /* we haven't looped ? */
	      tnext = t->next;

	      /* wakeup expired entries. It doesn't matter if they are
	       * already running because of a previous event
	       */
	      if (tv_cmp2_ms(&t->expire, &now) <= 0) {
		  //		  fprintf(stderr,"WQ: expiring task %p : rq=%p\n", t, p->rq);
		  task_wakeup(p, t);
	      }
	      else {
		  //		  fprintf(stderr,"WQ: ignoring task %p : rq=%p\n", t, p->rq);
		  break;
	      }
	  }

	  /* process each task in the run queue now. Each task may be deleted
	   * since we only use tnext.
	   */
	  tnext = p->rq;
	  while ((t = tnext) != NULL) {
	      int fsm_resync = 0;

	      tnext = t->rqnext;
	      task_sleep(p, t);

	      do {
		  fsm_resync = 0;
		  //fprintf(stderr,"before_cli:cli=%d, srv=%d\n", t->cli_state, t->srv_state);
		  fsm_resync |= process_cli(t);
		  //fprintf(stderr,"cli/srv:cli=%d, srv=%d\n", t->cli_state, t->srv_state);
		  fsm_resync |= process_srv(t);
		  //fprintf(stderr,"after_srv:cli=%d, srv=%d\n", t->cli_state, t->srv_state);
	      } while (fsm_resync);

	      // task_queue(LIST_HEAD(p->task), t);  /* restore t to its place in the task list */
	      // it has been moved to process_task which was more logical.
	      process_task(t);
	  }
      }
  }
}


#if STATTIME > 0
/*
 * Display proxy statistics regularly. It is designed to be called from the
 * select_loop().
 */
int stats(void) {
    static int lines;
    static struct timeval nextevt;
    static struct timeval lastevt;
    static struct timeval starttime = {0,0};
    unsigned long totaltime, deltatime;
    int ret;

    if (tv_remain(&now, &nextevt) == 0) {
	deltatime = (tv_delta(&now, &lastevt)?:1);
	totaltime = (tv_delta(&now, &starttime)?:1);
	
	if (mode & MODE_STATS) {	
		if ((lines++ % 16 == 0) && !(mode & MODE_LOG))
		    fprintf(stderr,
			    "\n active   total  tsknew tskgood tskleft tskrght tsknsch tsklsch tskrsch\n");
		if (lines>1) {
			fprintf(stderr,"%07d %07d %07d %07d %07d %07d %07d %07d %07d\n",
				actconn, totalconn,
				stats_tsk_new, stats_tsk_good,
				stats_tsk_left, stats_tsk_right,
				stats_tsk_nsrch, stats_tsk_lsrch, stats_tsk_rsrch);
		}
	}
	    
	tv_delayfrom(&nextevt, &now, STATTIME);

	lastevt=now;
    }	
    ret = tv_remain(&now, &nextevt);
    return ret;
}
#endif


/*
 * 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().
 */
static int maintain_proxies(void) {
    struct proxy *p;

    p = proxy;

    if (stopping) {
	while (p) {
	    if (p->state != PR_STDISABLED) {
		if (stopping && (tv_remain(&now, &p->stop_time) == 0)) {
		    FD_CLR(p->listen_fd, StaticReadEvent);
		    close(p->listen_fd);
		    p->state = PR_STDISABLED;
		    listeners--;
		}
	    }
	    p = p->next;
	}
	return -1;
    }

    /* if there are enough free sessions, we'll activate proxies */
    if (actconn < cfg_maxconn) {
	while (p) {
	    if (p->nbconn < p->maxconn) {
		if (p->state == PR_STIDLE) {
		    FD_SET(p->listen_fd, StaticReadEvent);
		    p->state = PR_STRUN;
		}
	    }
	    else {
		if (p->state == PR_STRUN) {
		    FD_CLR(p->listen_fd, StaticReadEvent);
		    p->state = PR_STIDLE;
		}
	    }
	    p = p->next;
	}
    }
    else {  /* block all proxies */
	while (p) {
	    if (p->state == PR_STRUN) {
		FD_CLR(p->listen_fd, StaticReadEvent);
		p->state = PR_STIDLE;
	    }
	    p = p->next;
	}
    }

    return -1;
}

/*
 * this function disables health-check servers so that the process will quickly be ignored
 * by load balancers.
 */
static void soft_stop(void) {
    struct proxy *p;

    stopping = 1;
    p = proxy;
    while (p) {
	if (p->state != PR_STDISABLED)
	    tv_delayfrom(&p->stop_time, &now, p->grace);
	p = p->next;
    }
}

/*
 * upon SIGUSR1, let's have a soft stop.
 */
void sig_soft_stop(int sig) {
    soft_stop();
    signal(sig, SIG_IGN);
}


void dump(int sig) {
    struct proxy *p;

    for (p = proxy; p; p = p->next) {
	struct task *t, *tnext;
	tnext = ((struct task *)LIST_HEAD(p->task))->next;
	while ((t = tnext) != LIST_HEAD(p->task)) { /* we haven't looped ? */
	    tnext = t->next;
	    fprintf(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",
		    t, tv_remain(&now, &t->expire),
		    t->cli_state,
		    t->srv_state,
		    FD_ISSET(t->cli_fd, StaticReadEvent),
		    FD_ISSET(t->cli_fd, StaticWriteEvent),
		    FD_ISSET(t->srv_fd, StaticReadEvent),
		    FD_ISSET(t->srv_fd, StaticWriteEvent),
		    t->req->l, t->rep?t->rep->l:0, t->cli_fd
		    );
	}
    }
}

/*
 * 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 *cmd;
    char *args[10];
    int arg;
    int cfgerr = 0;

    struct proxy *curproxy = NULL;
    struct server *newsrv = NULL;

    if ((f=fopen(file,"r")) == NULL)
	return -1;

    while (fgets(line = thisline, sizeof(thisline), f) != NULL) {
	linenum++;
	/* skips leading spaces */
	while (isspace(*line))
	    line++;

	/* cleans up line contents */
	cmd = line;
	while (*cmd) {
	    if (*cmd == '#' || *cmd == ';' || *cmd == '\n' || *cmd == '\r')
		*cmd = 0; /* end of string, end of loop */
	    else
		cmd++;
	}

	if (*line == 0)
	    continue;
	
	/* fills args[0..9] with the line contents */
	for (arg=0; arg<9; arg++) {
	    int escaped = 0;

	    args[arg] = line;
	    while (*line && (escaped || !isspace(*line))) {
	        if (!escaped) {
		    if (*line == '\\')
			escaped = 1; 
		}
		else
		    escaped = 0;
		line++;
	    }

	    if (*line) {
		*(line++) = 0;
		while (isspace(*line))
		    line++;
	    }
	}

	if (!strcmp(args[0], "listen")) {  /* new proxy */
	    if (strchr(args[2], ':') == NULL) {
		Alert("parsing [%s:%d] : <listen> expects <id> and <addr:port> as arguments.\n",
		      file, linenum);
		return -1;
	    }

	    if ((curproxy = (struct proxy *)calloc(1, sizeof(struct proxy)))
		== NULL) {
		Alert("parsing [%s:%d] : out of memory\n", file, linenum);
		exit(1);
	    }
	    curproxy->next = proxy;
	    proxy = curproxy;
	    curproxy->id = strdup(args[1]);
	    curproxy->listen_addr = *str2sa(args[2]);
	    curproxy->state = PR_STNEW;
	    curproxy->task.prev = curproxy->task.next = LIST_HEAD(curproxy->task);
	    curproxy->rq = NULL;
	    /* set default values */
	    curproxy->maxconn = cfg_maxpconn;
	    curproxy->conn_retries = CONN_RETRIES;
	    curproxy->conn_redisp = 0;
	    curproxy->clitimeout = curproxy->contimeout = curproxy->srvtimeout = 0;
	    curproxy->mode = PR_MODE_TCP;
	    curproxy->logfac1 = curproxy->logfac2 = -1; /* log disabled */
	    continue;
	}
	else if (curproxy == NULL) {
	    Alert("parsing [%s:%d] : <listen> expected.\n",
		  file, linenum);
	    return -1;
	}
    
	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_STDISABLED;
	}
	else if (!strcmp(args[0], "cookie")) {  /* cookie name */
	    if (curproxy->cookie_name != NULL) {
		Alert("parsing [%s:%d] : cookie name already specified. Continuing.\n",
		      file, linenum);
		continue;
	    }

	    if (*(args[1]) == 0) {
		Alert("parsing [%s:%d] : <cookie> expects <cookie_name> as argument.\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->cookie_name = strdup(args[1]);
	}
	else if (!strcmp(args[0], "contimeout")) {  /* connect timeout */
	    if (curproxy->contimeout != 0) {
		Alert("parsing [%s:%d] : contimeout already specified. Continuing.\n",
		      file, linenum);
		continue;
	    }
	    if (*(args[1]) == 0) {
		Alert("parsing [%s:%d] : <contimeout> expects an integer <time_in_ms> as argument.\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->contimeout = atol(args[1]);
	}
	else if (!strcmp(args[0], "clitimeout")) {  /*  client timeout */
	    if (curproxy->clitimeout != 0) {
		Alert("parsing [%s:%d] : clitimeout already specified. Continuing.\n",
		      file, linenum);
		continue;
	    }
	    if (*(args[1]) == 0) {
		Alert("parsing [%s:%d] : <clitimeout> expects an integer <time_in_ms> as argument.\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->clitimeout = atol(args[1]);
	}
	else if (!strcmp(args[0], "srvtimeout")) {  /*  server timeout */
	    if (curproxy->srvtimeout != 0) {
		Alert("parsing [%s:%d] : srvtimeout already specified. Continuing.\n",
		      file, linenum);
		continue;
	    }
	    if (*(args[1]) == 0) {
		Alert("parsing [%s:%d] : <srvtimeout> expects an integer <time_in_ms> as argument.\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->srvtimeout = atol(args[1]);
	}
	else if (!strcmp(args[0], "retries")) {  /* connection retries */
	    if (*(args[1]) == 0) {
		Alert("parsing [%s:%d] : <retries> expects an integer argument (dispatch counts for one).\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->conn_retries = atol(args[1]);
	}
	else if (!strcmp(args[0], "redisp")) {  /* enable reconnections to dispatch */
	    curproxy->conn_redisp = 1;
	}
	else if (!strcmp(args[0], "maxconn")) {  /* maxconn */
	    if (*(args[1]) == 0) {
		Alert("parsing [%s:%d] : <maxconn> expects an integer argument.\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->maxconn = atol(args[1]);
	}
	else if (!strcmp(args[0], "grace")) {  /* grace time (ms) */
	    if (*(args[1]) == 0) {
		Alert("parsing [%s:%d] : <grace> expects a time in milliseconds.\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->grace = atol(args[1]);
	}
	else if (!strcmp(args[0], "dispatch")) {  /* dispatch address */
	    if (strchr(args[1], ':') == NULL) {
		Alert("parsing [%s:%d] : <dispatch> expects <addr:port> as argument.\n",
		      file, linenum);
		return -1;
	    }
	    curproxy->dispatch_addr = *str2sa(args[1]);
	}
	else if (!strcmp(args[0], "server")) {  /* server address */
	    if (strchr(args[2], ':') == NULL) {
		Alert("parsing [%s:%d] : <server> expects <name> and <addr:port> as arguments.\n",
		      file, linenum);
		return -1;
	    }
	    if ((newsrv = (struct server *)calloc(1, sizeof(struct server)))
		== NULL) {
		Alert("parsing [%s:%d] : out of memory\n", file, linenum);
		exit(1);
	    }
	    newsrv->next = curproxy->srv;
	    curproxy->srv = newsrv;
	    newsrv->id = strdup(args[1]);
	    newsrv->addr = *str2sa(args[2]);
	}
	else if (!strcmp(args[0], "log")) {  /* syslog server address */
	    struct sockaddr_in *sa;
	    int facility;

	    if (*(args[1]) == 0 || *(args[2]) == 0) {
		Alert("parsing [%s:%d] : <log> expects <address> and <facility> as arguments.\n",
		      file, linenum);
		return -1;
	    }

	    for (facility = 0; facility < NB_LOG_FACILITIES; facility++)
		if (!strcmp(log_facilities[facility], args[2]))
		    break;

	    if (facility >= NB_LOG_FACILITIES) {
		Alert("parsing [%s:%d] : unknown log facility <%s>\n", file, linenum, args[2]);
		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;
	    }
	    else if (curproxy->logfac2 == -1) {
		curproxy->logsrv2 = *sa;
		curproxy->logfac2 = facility;
	    }
	    else {
		Alert("parsing [%s:%d] : too many syslog servers\n", file, linenum);
		exit(1);
	    }

	}
	else if (!strcmp(args[0], "cliexp")) {  /* client regex */
	    regex_t *preg;
	    if (curproxy->nb_cliexp >= MAX_REGEXP) {
		Alert("parsing [%s:%d] : too many client expressions. Continuing.\n",
		      file, linenum);
		continue;
	    }

	    if (*(args[1]) == 0 || *(args[2]) == 0) {
		Alert("parsing [%s:%d] : <cliexp> expects <search> and <replace> as arguments.\n",
		      file, linenum);
		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;
	    }
	    curproxy->cli_exp[curproxy->nb_cliexp].preg = preg;
	    curproxy->cli_exp[curproxy->nb_cliexp].replace = strdup(args[2]);
	    curproxy->nb_cliexp++;
	}
	else if (!strcmp(args[0], "srvexp")) {  /* server regex */
	    regex_t *preg;
	    if (curproxy->nb_srvexp >= MAX_REGEXP) {
		Alert("parsing [%s:%d] : too many server expressions. Continuing.\n",
		      file, linenum);
		continue;
	    }

	    if (*(args[1]) == 0 || *(args[2]) == 0) {
		Alert("parsing [%s:%d] : <srvexp> expects <search> and <replace> as arguments.\n",
		      file, linenum);
		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;
	    }
	    //	    fprintf(stderr,"before=<%s> after=<%s>\n", args[1], args[2]);
	    curproxy->srv_exp[curproxy->nb_srvexp].preg = preg;
	    curproxy->srv_exp[curproxy->nb_srvexp].replace = strdup(args[2]);
	    curproxy->nb_srvexp++;
	}
	else {
	    Alert("parsing [%s:%d] : unknown keyword <%s>\n", file, linenum, args[0]);
	    exit(1);
	}
    }
    fclose(f);

    /*
     * Now, check for the integrity of all that we have collected.
     */

    if ((curproxy = proxy) == NULL) {
	Alert("parsing %s : no <listen> line. Nothing to do !\n",
	      file);
	return -1;
    }

    while (curproxy != NULL) {
	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->nb_srvexp) {
		Warning("parsing %s : server regular expressions will be ignored for listener %s.\n",
			file, curproxy->id);
	    }
	    if (curproxy->nb_cliexp) {
		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++;
	    }
	    else {
		while (newsrv != NULL) {
		    /* nothing to check for now */
		    newsrv = newsrv->next;
		}
	    }
	}
	curproxy = curproxy->next;
    }
    if (cfgerr > 0) {
	Alert("Errors found in configuration file, aborting.\n");
	return -1;
    }
    else
	return 0;
}


/*
 * 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;
    char *old_argv = *argv;
    char *tmp;

    if (1<<INTBITS != sizeof(int)*8) {
	fprintf(stderr,
		"Error: wrong architecture. Recompile so that sizeof(int)=%d\n",
		sizeof(int)*8);
	exit(1);
    }

    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);
	    }
	    else if (*flag == 'd')
		mode |= MODE_DEBUG;
	    else if (*flag == 'D')
		mode |= MODE_DAEMON;
#if STATTIME > 0
	    else if (*flag == 's')
		mode |= MODE_STATS;
	    else if (*flag == 'l')
		mode |= MODE_LOG;
#endif
	    else { /* >=2 args */
		argv++; argc--;
		if (argc == 0)
		    usage(old_argv);

		switch (*flag) {
		case 'n' : cfg_maxconn = atol(*argv); break;
		case 'N' : cfg_maxpconn = atol(*argv); break;
		case 'f' : cfg_cfgfile = *argv; break;
		default: usage(old_argv);
		}
	    }
	}
	else
	    usage(old_argv);
	    argv++; argc--;
    }

    cfg_maxsock = cfg_maxconn * 2; /* each connection needs two sockets */

    if (!cfg_cfgfile)
	usage(old_argv);

    gethostname(hostname, MAX_HOSTNAME_LEN);

    if (readcfgfile(cfg_cfgfile) < 0) {
	Alert("Error reading configuration file : %s\n", cfg_cfgfile);
	exit(1);
    }

    ReadEvent = (fd_set *)calloc(1,
		sizeof(fd_set) *
		(cfg_maxsock + 3 + FD_SETSIZE - 1) / FD_SETSIZE);
    WriteEvent = (fd_set *)calloc(1,
		sizeof(fd_set) *
		(cfg_maxsock + 3 + FD_SETSIZE - 1) / FD_SETSIZE);
    StaticReadEvent = (fd_set *)calloc(1,
		sizeof(fd_set) *
		(cfg_maxsock + 3 + FD_SETSIZE - 1) / FD_SETSIZE);
    StaticWriteEvent = (fd_set *)calloc(1,
		sizeof(fd_set) *
		(cfg_maxsock + 3 + FD_SETSIZE - 1) / FD_SETSIZE);

    fdtab = (struct fdtab *)calloc(1,
		sizeof(struct fdtab) * (cfg_maxsock + 3));
    for (i = 0; i < cfg_maxsock + 3; i++) {
	fdtab[i].state = FD_STCLOSE;
    }
}

/*
 * this function starts all the proxies. It returns 0 if OK, -1 if not.
 */
int start_proxies() {
    struct proxy *curproxy;
    int one = 1;
    int fd;

    for (curproxy = proxy; curproxy != NULL; curproxy = curproxy->next) {

	if (curproxy->state == PR_STDISABLED)
	    continue;

	if ((fd = curproxy->listen_fd =
	     socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
	    Alert("cannot create listening socket for proxy %s. Aborting.\n",
		  curproxy->id);
	    return -1;
	}
	
	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);
	    return -1;
	}

	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof(one)) == -1) {
	    Alert("cannot do so_reuseaddr for proxy %s. Continuing.\n",
		  curproxy->id);
	}
	
	if (bind(fd,
		 (struct sockaddr *)&curproxy->listen_addr,
		 sizeof(curproxy->listen_addr)) == -1) {
	    Alert("cannot bind socket for proxy %s. Aborting.\n",
		  curproxy->id);
	    close(fd);
	    return -1;
	}
	
	if (listen(fd, curproxy->maxconn) == -1) {
	    Alert("cannot listen to socket for proxy %s. Aborting.\n",
		  curproxy->id);
	    close(fd);
	    return -1;
	}
	
	/* 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 */
	curproxy->state = PR_STRUN;
	fdtab[fd].state = FD_STLISTEN;
	FD_SET(fd, StaticReadEvent);
	fd_insert(fd);
	listeners++;
//	fprintf(stderr,"Proxy %s : socket bound.\n", curproxy->id);
    }
    return 0;
}


int main(int argc, char **argv) {
    init(argc, argv);

    if (mode & MODE_DAEMON) {
	int ret;

	ret = fork();

	if (ret > 0)
	    exit(0); /* parent must leave */
	else if (ret < 0) {
	    Alert("[%s.main()] Cannot fork\n", argv[0]);
	    exit(1); /* there has been an error */
	}

	/* detach from the tty */
	close(0); close(1); close(2);
	setpgid(1, 0);
    }

    signal(SIGQUIT, dump);
    signal(SIGUSR1, sig_soft_stop);

    /* 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

    if (start_proxies() < 0)
	exit(1);

    select_loop();

    exit(0);
}