| /* |
| * HA-Proxy : High Availability-enabled HTTP/TCP proxy |
| * 2000-2002 - 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. |
| * |
| * Pending bugs : |
| * - 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 we simple (GET / HTTP/1.0). |
| * - cookie in insert+indirect mode sometimes segfaults ! |
| * - a proxy with an invalid config will prevent the startup even if disabled. |
| * |
| * ChangeLog : |
| * |
| * 2002/06/04 : 1.1.11 |
| * - fixed multi-cookie handling in client request to allow clean deletion |
| * in insert+indirect mode. Now, only the server cookie is deleted and not |
| * all the header. Should now be compliant to RFC2109. |
| * - added a "nocache" option to "cookie" to specify that we explicitly want |
| * to add a "cache-control" header when we add a cookie. |
| * It is also possible to add an "Expires: <old-date>" to keep compatibility |
| * with old/broken caches. |
| * 2002/05/10 : 1.1.10 |
| * - if a cookie is used in insert+indirect mode, it's desirable that the |
| * the servers don't see it. It was not possible to remove it correctly |
| * with regexps, so now it's removed automatically. |
| * 2002/04/19 : 1.1.9 |
| * - don't use snprintf()'s return value as an end of message since it may |
| * be larger. This caused bus errors and segfaults in internal libc's |
| * getenv() during localtime() in send_log(). |
| * - removed dead insecure send_syslog() function and all references to it. |
| * - fixed warnings on Solaris due to buggy implementation of isXXXX(). |
| * 2002/04/18 : 1.1.8 |
| * - option "dontlognull" |
| * - fixed "double space" bug in config parser |
| * - fixed an uninitialized server field in case of dispatch |
| * with no existing server which could cause a segfault during |
| * logging. |
| * - the pid logged was always the father's, which was wrong for daemons. |
| * - fixed wrong level "LOG_INFO" for message "proxy started". |
| * 2002/04/13 : |
| * - http logging is now complete : |
| * - ip:port, date, proxy, server |
| * - req_time, conn_time, hdr_time, tot_time |
| * - status, size, request |
| * - source address |
| * 2002/04/12 : 1.1.7 |
| * - added option forwardfor |
| * - added reqirep, reqidel, reqiallow, reqideny, rspirep, rspidel |
| * - added "log global" in "listen" section. |
| * 2002/04/09 : |
| * - added a new "global" section : |
| * - logs |
| * - debug, quiet, daemon modes |
| * - uid, gid, chroot, nbproc, maxconn |
| * 2002/04/08 : 1.1.6 |
| * - regex are now chained and not limited anymore. |
| * - unavailable server now returns HTTP/502. |
| * - increased per-line args limit to 40 |
| * - added reqallow/reqdeny to block some request on matches |
| * - added HTTP 400/403 responses |
| * 2002/04/03 : 1.1.5 |
| * - connection logging displayed incorrect source address. |
| * - added proxy start/stop and server up/down log events. |
| * - replaced log message short buffers with larger trash. |
| * - enlarged buffer to 8 kB and replace buffer to 4 kB. |
| * 2002/03/25 : 1.1.4 |
| * - made rise/fall/interval time configurable |
| * 2002/03/22 : 1.1.3 |
| * - fixed a bug : cr_expire and cw_expire were inverted in CL_STSHUT[WR] |
| * which could lead to loops. |
| * 2002/03/21 : 1.1.2 |
| * - fixed a bug in buffer management where we could have a loop |
| * between event_read() and process_{cli|srv} if R==BUFSIZE-MAXREWRITE. |
| * => implemented an adjustable buffer limit. |
| * - fixed a bug : expiration of tasks in wait queue timeout is used again, |
| * and running tasks are skipped. |
| * - added some debug lines for accept events. |
| * - send warnings for servers up/down. |
| * 2002/03/12 : 1.1.1 |
| * - fixed a bug in total failure handling |
| * - fixed a bug in timestamp comparison within same second (tv_cmp_ms) |
| * 2002/03/10 : 1.1.0 |
| * - fixed a few timeout bugs |
| * - rearranged the task scheduler subsystem to improve performance, |
| * add new tasks, and make it easier to later port to librt ; |
| * - allow multiple accept() for one select() wake up ; |
| * - implemented internal load balancing with basic health-check ; |
| * - cookie insertion and header add/replace/delete, with better strings |
| * support. |
| * 2002/03/08 |
| * - reworked buffer handling to fix a few rewrite bugs, and |
| * improve overall performance. |
| * - implement the "purge" option to delete server cookies in direct mode. |
| * 2002/03/07 |
| * - fixed some error cases where the maxfd was not decreased. |
| * 2002/02/26 |
| * - now supports transparent proxying, at least on linux 2.4. |
| * 2002/02/12 |
| * - soft stop works again (fixed select timeout computation). |
| * - it seems that TCP proxies sometimes cannot timeout. |
| * - added a "quiet" mode. |
| * - enforce file descriptor limitation on socket() and accept(). |
| * 2001/12/30 : release of version 1.0.2 : fixed a bug in header processing |
| * 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. Done ? |
| * - log proxies start/stop |
| * - handle hot-reconfiguration |
| * |
| */ |
| |
| #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> |
| #if defined(TPROXY) && defined(NETFILTER) |
| #include <linux/netfilter_ipv4.h> |
| #endif |
| |
| #define HAPROXY_VERSION "1.1.11" |
| #define HAPROXY_DATE "2002/06/04" |
| |
| /* 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 8192 |
| |
| // reserved buffer space for header rewriting |
| #define MAXREWRITE 4096 |
| #define REQURI_LEN 1024 |
| |
| // max # args on a configuration line |
| #define MAX_LINE_ARGS 40 |
| |
| // max # of added headers per request |
| #define MAX_NEWHDR 10 |
| |
| // max # of matches per regexp |
| #define MAX_MATCH 10 |
| |
| /* FIXME: serverid_len and cookiename_len are no longer checked in configuration file */ |
| #define COOKIENAME_LEN 16 |
| #define SERVERID_LEN 16 |
| #define CONN_RETRIES 3 |
| |
| #define CHK_CONNTIME 2000 |
| #define DEF_CHKINTR 2000 |
| #define DEF_FALLTIME 3 |
| #define DEF_RISETIME 2 |
| |
| /* default connections limit */ |
| #define DEFAULT_MAXCONN 2000 |
| |
| /* 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 |
| |
| /* this reduces the number of calls to select() by choosing appropriate |
| * sheduler precision in milliseconds. It should be near the minimum |
| * time that is needed by select() to collect all events. All timeouts |
| * are rounded up by adding this value prior to pass it to select(). |
| */ |
| #define SCHEDULER_RESOLUTION 9 |
| |
| #define MINTIME(old, new) (((new)<0)?(old):(((old)<0||(new)<(old))?(new):(old))) |
| #define SETNOW(a) (*a=now) |
| |
| /****** string-specific macros and functions ******/ |
| /* if a > max, then bound <a> to <max>. The macro returns the new <a> */ |
| #define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); }) |
| |
| /* if a < min, then bound <a> to <min>. The macro returns the new <a> */ |
| #define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); }) |
| |
| |
| #ifndef HAVE_STRLCPY |
| /* |
| * 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 strlcpy(char *dst, const char *src, int size) { |
| char *orig = dst; |
| if (size) { |
| while (--size && (*dst = *src)) { |
| src++; dst++; |
| } |
| *dst = 0; |
| } |
| return dst - orig; |
| } |
| #endif |
| |
| |
| #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 cell. 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_task sizeof(struct task) |
| #define sizeof_session sizeof(struct session) |
| #define sizeof_buffer sizeof(struct buffer) |
| #define sizeof_fdtab sizeof(struct fdtab) |
| #define sizeof_requri REQURI_LEN |
| |
| /* 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 |
| |
| /* values for task->state */ |
| #define TASK_IDLE 0 |
| #define TASK_RUNNING 1 |
| |
| /* values for proxy->state */ |
| #define PR_STNEW 0 |
| #define PR_STIDLE 1 |
| #define PR_STRUN 2 |
| #define PR_STDISABLED 3 |
| |
| /* values for proxy->mode */ |
| #define PR_MODE_TCP 0 |
| #define PR_MODE_HTTP 1 |
| #define PR_MODE_HEALTH 2 |
| |
| /* bits for proxy->options */ |
| #define PR_O_REDISP 1 /* allow reconnection to dispatch in case of errors */ |
| #define PR_O_TRANSP 2 /* transparent mode : use original DEST as dispatch */ |
| #define PR_O_COOK_RW 4 /* rewrite all direct cookies with the right serverid */ |
| #define PR_O_COOK_IND 8 /* keep only indirect cookies */ |
| #define PR_O_COOK_INS 16 /* insert cookies when not accessing a server directly */ |
| #define PR_O_COOK_ANY (PR_O_COOK_RW | PR_O_COOK_IND | PR_O_COOK_INS) |
| #define PR_O_BALANCE_RR 32 /* balance in round-robin mode */ |
| #define PR_O_BALANCE (PR_O_BALANCE_RR) |
| #define PR_O_KEEPALIVE 64 /* follow keep-alive sessions */ |
| #define PR_O_FWDFOR 128 /* insert x-forwarded-for with client address */ |
| #define PR_O_BIND_SRC 256 /* bind to a specific source address when connect()ing */ |
| #define PR_O_NULLNOLOG 512 /* a connect without request will not be logged */ |
| #define PR_O_COOK_NOC 1024 /* add a 'Cache-control' header with the cookie */ |
| |
| |
| /* various session flags */ |
| #define SN_DIRECT 1 /* connection made on the server matching the client cookie */ |
| #define SN_CLDENY 2 /* a client header matches a deny regex */ |
| #define SN_CLALLOW 4 /* a client header matches an allow regex */ |
| #define SN_SVDENY 8 /* a server header matches a deny regex */ |
| #define SN_SVALLOW 16 /* a server header matches an allow regex */ |
| |
| /* different possible states for the client side */ |
| #define CL_STHEADERS 0 |
| #define CL_STDATA 1 |
| #define CL_STSHUTR 2 |
| #define CL_STSHUTW 3 |
| #define CL_STCLOSE 4 |
| |
| /* different possible states for the server side */ |
| #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 (global.mode) */ |
| #define MODE_DEBUG 1 |
| #define MODE_STATS 2 |
| #define MODE_LOG 4 |
| #define MODE_DAEMON 8 |
| #define MODE_QUIET 16 |
| |
| /* server flags */ |
| #define SRV_RUNNING 1 |
| |
| /* what to do when a header matches a regex */ |
| #define ACT_ALLOW 0 /* allow the request */ |
| #define ACT_REPLACE 1 /* replace the matching header */ |
| #define ACT_REMOVE 2 /* remove the matching header */ |
| #define ACT_DENY 3 /* deny the request */ |
| |
| /* configuration sections */ |
| #define CFG_NONE 0 |
| #define CFG_GLOBAL 1 |
| #define CFG_LISTEN 2 |
| |
| /* fields that need to be logged. They appear as flags in session->logs.logwait */ |
| #define LW_DATE 1 /* date */ |
| #define LW_CLIP 2 /* CLient IP */ |
| #define LW_SVIP 4 /* SerVer IP */ |
| #define LW_SVID 8 /* server ID */ |
| #define LW_REQ 16 /* http REQuest */ |
| #define LW_RESP 32 /* http RESPonse */ |
| #define LW_PXIP 64 /* proxy IP */ |
| #define LW_PXID 128 /* proxy ID */ |
| #define LW_BYTES 256 /* bytes read from server */ |
| |
| /*********************************************************************/ |
| |
| #define LIST_HEAD(a) ((void *)(&(a))) |
| |
| /*********************************************************************/ |
| |
| struct hdr_exp { |
| struct hdr_exp *next; |
| regex_t *preg; /* expression to look for */ |
| int action; /* ACT_ALLOW, ACT_REPLACE, ACT_REMOVE, ACT_DENY */ |
| 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 *rlim; /* read limit, used for header rewriting */ |
| unsigned long long total; /* total data read */ |
| char data[BUFSIZE]; |
| }; |
| |
| struct server { |
| struct server *next; |
| int state; /* server state (SRV_*) */ |
| int cklen; /* the len of the cookie, to speed up checks */ |
| char *cookie; /* the id set in the cookie */ |
| char *id; /* just for identification */ |
| struct sockaddr_in addr; /* the address to connect to */ |
| int health; /* 0->rise-1 = bad; rise->rise+fall-1 = good */ |
| int rise, fall; /* time in iterations */ |
| int inter; /* time in milliseconds */ |
| int result; /* 0 = connect OK, -1 = connect KO */ |
| int curfd; /* file desc used for current test, or -1 if not in test */ |
| struct proxy *proxy; /* the proxy this server belongs to */ |
| }; |
| |
| /* The base for all tasks */ |
| struct task { |
| struct task *next, *prev; /* chaining ... */ |
| struct task *rqnext; /* chaining in run queue ... */ |
| struct task *wq; /* the wait queue this task is in */ |
| int state; /* task state : IDLE or RUNNING */ |
| struct timeval expire; /* next expiration time for this task, use only for fast sorting */ |
| int (*process)(struct task *t); /* the function which processes the task */ |
| void *context; /* the task's context */ |
| }; |
| |
| /* WARNING: if new fields are added, they must be initialized in event_accept() */ |
| struct session { |
| struct task *task; /* the task associated with this session */ |
| /* 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 flags; /* some flags describing the session */ |
| 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 */ |
| struct server *srv; /* the server being used */ |
| struct { |
| int logwait; /* log fields waiting to be collected : LW_* */ |
| struct timeval tv_accept; /* date of the accept() (beginning of the session) */ |
| long t_request; /* delay before the end of the request arrives, -1 if never occurs */ |
| long t_connect; /* delay before the connect() to the server succeeds, -1 if never occurs */ |
| long t_data; /* delay before the first data byte from the server ... */ |
| unsigned long t_close; /* total session duration */ |
| char *uri; /* first line if log needed, NULL otherwise */ |
| int status; /* HTTP status from the server, negative if from proxy */ |
| long long bytes; /* number of bytes transferred from the server */ |
| } logs; |
| }; |
| |
| 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, *cursrv; /* known servers, current server */ |
| int nbservers; /* # of 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; /* maximum number of connect retries */ |
| int options; /* PR_O_REDISP, PR_O_TRANSP */ |
| int mode; /* mode = PR_MODE_TCP, PR_MODE_HTTP or PR_MODE_HEALTH */ |
| struct sockaddr_in source_addr; /* the address to which we want to bind for connect() */ |
| struct proxy *next; |
| struct sockaddr_in logsrv1, logsrv2; /* 2 syslog servers */ |
| char logfac1, logfac2; /* log facility for both servers. -1 = disabled */ |
| int to_log; /* things to be logged (LW_*) */ |
| struct timeval stop_time; /* date to stop listening, when stopping != 0 */ |
| int nb_reqadd, nb_rspadd; |
| struct hdr_exp *req_exp; /* regular expressions for request headers */ |
| struct hdr_exp *rsp_exp; /* regular expressions for response headers */ |
| char *req_add[MAX_NEWHDR], *rsp_add[MAX_NEWHDR]; /* headers to be added */ |
| 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_maxpconn = 2000; /* # of simultaneous connections per proxy (-N) */ |
| char *cfg_cfgfile = NULL; /* configuration file */ |
| char *progname = NULL; /* program name */ |
| int pid; /* current process id */ |
| |
| /* global options */ |
| static struct { |
| int uid; |
| int gid; |
| int nbproc; |
| int maxconn; |
| int maxsock; /* max # of sockets */ |
| int mode; |
| char *chroot; |
| int logfac1, logfac2; |
| struct sockaddr_in logsrv1, logsrv2; |
| } global = { |
| logfac1 : -1, |
| logfac2 : -1, |
| /* others NULL OK */ |
| }; |
| |
| /*********************************************************************/ |
| |
| fd_set *ReadEvent, |
| *WriteEvent, |
| *StaticReadEvent, |
| *StaticWriteEvent; |
| |
| void **pool_session = NULL, |
| **pool_buffer = NULL, |
| **pool_fdtab = NULL, |
| **pool_requri = NULL, |
| **pool_task = NULL; |
| |
| struct proxy *proxy = NULL; /* list of all existing proxies */ |
| struct fdtab *fdtab = NULL; /* array of all the file descriptors */ |
| struct task *rq = NULL; /* global run queue */ |
| struct task wait_queue = { /* global wait queue */ |
| prev:LIST_HEAD(wait_queue), |
| next:LIST_HEAD(wait_queue) |
| }; |
| |
| 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] = ""; |
| |
| const char *HTTP_400 = |
| "HTTP/1.0 400 Bad request\r\n" |
| "Cache-Control: no-cache\r\n" |
| "Connection: close\r\n" |
| "\r\n" |
| "400 Bad request : Your browser sent an invalid request.\r\n"; |
| |
| const char *HTTP_403 = |
| "HTTP/1.0 403 Forbidden\r\n" |
| "Cache-Control: no-cache\r\n" |
| "Connection: close\r\n" |
| "\r\n" |
| "403 Forbidden : Request forbidden by administrative rules.\r\n"; |
| |
| const char *HTTP_502 = |
| "HTTP/1.0 502 Proxy Error\r\n" |
| "Cache-Control: no-cache\r\n" |
| "Connection: close\r\n" |
| "\r\n" |
| "502 Proxy Error : No server is available to handle this request.\r\n"; |
| |
| /*********************************************************************/ |
| /* 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); |
| int process_session(struct task *t); |
| |
| /*********************************************************************/ |
| /* general purpose functions ***************************************/ |
| /*********************************************************************/ |
| |
| void display_version() { |
| printf("HA-Proxy version " HAPROXY_VERSION " " HAPROXY_DATE"\n"); |
| printf("Copyright 2000-2002 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 ; implies -q\n" |
| " -q quiet mode : don't display messages\n" |
| " -n sets the maximum total # of connections (%d)\n" |
| " -N sets the default, per-proxy maximum # of connections (%d)\n\n", |
| name, DEFAULT_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; |
| |
| if (!(global.mode & MODE_QUIET)) { |
| 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)) { |
| 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)) { |
| va_start(argp, fmt); |
| vfprintf(out, fmt, argp); |
| fflush(out); |
| 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; |
| |
| 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 ( |
| #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 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]; |
| 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; |
| nbloggers++; |
| } |
| if (global.logfac2 >= 0) { |
| sa[nbloggers] = &global.logsrv2; |
| facilities[nbloggers] = global.logfac2; |
| nbloggers++; |
| } |
| } else { |
| if (p->logfac1 >= 0) { |
| sa[nbloggers] = &p->logsrv1; |
| facilities[nbloggers] = p->logfac1; |
| nbloggers++; |
| } |
| if (p->logfac2 >= 0) { |
| sa[nbloggers] = &p->logsrv2; |
| facilities[nbloggers] = p->logfac2; |
| nbloggers++; |
| } |
| } |
| |
| while (nbloggers-- > 0) { |
| /* 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 |
| } |
| } |
| |
| |
| /* 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) { |
| 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. |
| */ |
| 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) { |
| 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 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. |
| * The file descriptor is also closed. |
| */ |
| static inline void fd_delete(int fd) { |
| FD_CLR(fd, StaticReadEvent); |
| FD_CLR(fd, StaticWriteEvent); |
| close(fd); |
| fdtab[fd].state = FD_STCLOSE; |
| |
| 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 <t> in run queue <q>, and returns <t> */ |
| static inline struct task *task_wakeup(struct task **q, struct task *t) { |
| if (t->state == TASK_RUNNING) |
| return t; |
| else { |
| t->rqnext = *q; |
| t->state = TASK_RUNNING; |
| return *q = t; |
| } |
| } |
| |
| /* removes the task <t> from the queue <q> |
| * <s> MUST be <q>'s first task. |
| * set the run queue to point to the next one, and return it |
| */ |
| static inline struct task *task_sleep(struct task **q, struct task *t) { |
| if (t->state == TASK_RUNNING) { |
| *q = t->rqnext; |
| t->state = TASK_IDLE; /* tell that s has left the run queue */ |
| } |
| return *q; /* return next running task */ |
| } |
| |
| /* |
| * removes the task <t> 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 *t) { |
| t->prev->next = t->next; |
| t->next->prev = t->prev; |
| return t; |
| } |
| |
| /* |
| * frees a task. Its context must have been freed since it will be lost. |
| */ |
| static inline void task_free(struct task *t) { |
| pool_free(task, t); |
| } |
| |
| /* 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; |
| |
| /* 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 either returns the sockname or the original destination address. Code |
| * inspired from Patrick Schaaf's example of nf_getsockname() implementation. |
| */ |
| static int get_original_dst(int fd, struct sockaddr_in *sa, int *salen) { |
| #if defined(TPROXY) && defined(SO_ORIGINAL_DST) |
| return getsockopt(fd, SOL_IP, SO_ORIGINAL_DST, (void *)sa, salen); |
| #else |
| #if defined(TPROXY) && defined(USE_GETSOCKNAME) |
| return getsockname(fd, (struct sockaddr *)sa, salen); |
| #else |
| return -1; |
| #endif |
| #endif |
| } |
| |
| /* |
| * frees the context associated to a session. It must have been removed first. |
| */ |
| static inline void session_free(struct session *s) { |
| if (s->req) |
| pool_free(buffer, s->req); |
| if (s->rep) |
| pool_free(buffer, s->rep); |
| if (s->logs.uri) |
| pool_free(requri, s->logs.uri); |
| |
| pool_free(session, s); |
| } |
| |
| |
| /* |
| * This function initiates a connection to the current server (s->srv) if (s->direct) |
| * is set, or to the dispatch server if (s->direct) is 0. It returns 0 if |
| * it's OK, -1 if it's impossible. |
| */ |
| int connect_server(struct session *s) { |
| int one = 1; |
| int fd; |
| |
| // fprintf(stderr,"connect_server : s=%p\n",s); |
| |
| if (s->flags & SN_DIRECT) { /* srv cannot be null */ |
| s->srv_addr = s->srv->addr; |
| } |
| else if (s->proxy->options & PR_O_BALANCE) { |
| if (s->proxy->options & PR_O_BALANCE_RR) { |
| int retry = s->proxy->nbservers; |
| while (retry) { |
| if (s->proxy->cursrv == NULL) |
| s->proxy->cursrv = s->proxy->srv; |
| if (s->proxy->cursrv->state & SRV_RUNNING) |
| break; |
| s->proxy->cursrv = s->proxy->cursrv->next; |
| retry--; |
| } |
| |
| if (retry == 0) /* no server left */ |
| return -1; |
| |
| s->srv = s->proxy->cursrv; |
| s->srv_addr = s->srv->addr; |
| s->proxy->cursrv = s->proxy->cursrv->next; |
| } |
| else /* unknown balancing algorithm */ |
| return -1; |
| } |
| 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 */ |
| int salen = sizeof(struct sockaddr_in); |
| if (get_original_dst(s->cli_fd, &s->srv_addr, &salen) == -1) { |
| qfprintf(stderr, "Cannot get original server address.\n"); |
| return -1; |
| } |
| } |
| |
| if ((fd = s->srv_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) { |
| qfprintf(stderr, "Cannot get a server socket.\n"); |
| return -1; |
| } |
| |
| if (fd >= global.maxsock) { |
| Alert("socket(): not enough free sockets. Raise -n argument. Giving up.\n"); |
| close(fd); |
| return -1; |
| } |
| |
| 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 -1; |
| } |
| |
| /* allow specific binding */ |
| if (s->proxy->options & PR_O_BIND_SRC && |
| 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); |
| 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 */ |
| qfprintf(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->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 */ |
| |
| 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 *t = fdtab[fd].owner; |
| struct session *s = t->context; |
| struct buffer *b = s->req; |
| int ret, max; |
| |
| // fprintf(stderr,"event_cli_read : fd=%d, s=%p\n", fd, s); |
| |
| if (fdtab[fd].state != FD_STERROR) { |
| while (1) { |
| 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, 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 */ |
| } |
| |
| 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) */ |
| } |
| else { |
| s->res_cr = RES_ERROR; |
| fdtab[fd].state = FD_STERROR; |
| } |
| |
| if (s->res_cr != RES_SILENT) { |
| if (s->proxy->clitimeout) |
| 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 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; |
| |
| // fprintf(stderr,"event_srv_read : fd=%d, s=%p\n", fd, s); |
| |
| if (fdtab[fd].state != FD_STERROR) { |
| while (1) { |
| 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, 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 */ |
| } |
| |
| 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) */ |
| } |
| else { |
| s->res_sr = RES_ERROR; |
| fdtab[fd].state = FD_STERROR; |
| } |
| |
| if (s->res_sr != RES_SILENT) { |
| if (s->proxy->srvtimeout) |
| 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 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; |
| |
| // 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->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) { |
| #ifndef MSG_NOSIGNAL |
| int skerr, lskerr; |
| #endif |
| |
| if (max == 0) { |
| s->res_cw = RES_NULL; |
| task_wakeup(&rq, t); |
| 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(&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; |
| |
| //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->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) { |
| #ifndef MSG_NOSIGNAL |
| int skerr, lskerr; |
| #endif |
| if (max == 0) { |
| /* may be we have received a connection acknowledgement in TCP mode without data */ |
| s->res_sw = RES_NULL; |
| task_wakeup(&rq, t); |
| fdtab[fd].state = FD_STREADY; |
| 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 |
| 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; |
| } |
| |
| if (s->proxy->srvtimeout) |
| tv_delayfrom(&s->swexpire, &now, s->proxy->srvtimeout); |
| else |
| tv_eternity(&s->swexpire); |
| |
| task_wakeup(&rq, t); |
| return 0; |
| } |
| |
| |
| /* |
| * 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 must 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); |
| shutdown(s->cli_fd, SHUT_RD); |
| s->cli_state = CL_STSHUTR; |
| strcpy(s->rep->data, msg); |
| s->rep->l = len; |
| s->rep->r += len; |
| s->req->l = 0; |
| } |
| |
| |
| /* |
| * returns a message into the rep buffer, and flushes the req buffer. |
| * The reply buffer must be empty before this. |
| */ |
| void client_return(struct session *s, int len, const char *msg) { |
| strcpy(s->rep->data, msg); |
| s->rep->l = len; |
| s->rep->r += len; |
| s->req->l = 0; |
| } |
| |
| /* |
| * send a log for the session when we have enough info about it |
| */ |
| void sess_log(struct session *s) { |
| unsigned char *pn; |
| struct proxy *p = s->proxy; |
| int log; |
| char *uri; |
| char *pxid; |
| char *srv; |
| |
| /* 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; |
| |
| pn = (log & LW_CLIP) ? |
| (unsigned char *)&s->cli_addr.sin_addr : |
| (unsigned char *)"\0\0\0\0"; |
| |
| uri = (log & LW_REQ) ? s->logs.uri : "<BADREQ>"; |
| pxid = p->id; |
| //srv = (log & LW_SVID) ? s->srv->id : "<svid>"; |
| srv = ((p->to_log & LW_SVID) && s->srv != NULL) ? s->srv->id : "<NOSRV>"; |
| |
| if (p->to_log & LW_DATE) { |
| struct tm *tm = localtime(&s->logs.tv_accept.tv_sec); |
| |
| send_log(p, LOG_INFO, "%d.%d.%d.%d:%d [%02d/%s/%04d:%02d:%02d:%02d] %s %s %d/%d/%d/%d %d %lld \"%s\"\n", |
| pn[0], pn[1], pn[2], pn[3], ntohs(s->cli_addr.sin_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_connect >= 0) ? s->logs.t_connect - s->logs.t_request : -1, |
| (s->logs.t_data >= 0) ? s->logs.t_data - s->logs.t_connect : -1, |
| s->logs.t_close, |
| s->logs.status, s->logs.bytes, |
| uri); |
| } |
| else { |
| send_log(p, LOG_INFO, "%d.%d.%d.%d:%d %s %s %d/%d/%d/%d %d %lld \"%s\"\n", |
| pn[0], pn[1], pn[2], pn[3], ntohs(s->cli_addr.sin_port), |
| pxid, srv, |
| s->logs.t_request, |
| (s->logs.t_connect >= 0) ? s->logs.t_connect - s->logs.t_request : -1, |
| (s->logs.t_data >= 0) ? s->logs.t_data - s->logs.t_connect : -1, |
| s->logs.t_close, |
| s->logs.status, s->logs.bytes, |
| uri); |
| } |
| |
| s->logs.logwait = 0; |
| } |
| |
| |
| /* |
| * 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 one = 1; |
| |
| while (p->nbconn < p->maxconn) { |
| struct sockaddr_in addr; |
| int laddr = sizeof(addr); |
| if ((cfd = accept(fd, (struct sockaddr *)&addr, &laddr)) == -1) |
| return 0; /* nothing more to accept */ |
| |
| 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 ((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; |
| } |
| |
| t->next = t->prev = t->rqnext = NULL; /* task not in run queue yet */ |
| t->wq = LIST_HEAD(wait_queue); /* 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->flags = 0; |
| s->res_cr = s->res_cw = s->res_sr = s->res_sw = RES_SILENT; |
| s->cli_fd = cfd; |
| s->srv_fd = -1; |
| s->srv = NULL; |
| s->conn_retries = p->conn_retries; |
| |
| s->logs.logwait = p->to_log; |
| s->logs.tv_accept = now; |
| s->logs.t_request = -1; |
| s->logs.t_connect = -1; |
| s->logs.t_data = -1; |
| s->logs.t_close = 0; |
| s->logs.uri = NULL; |
| s->logs.status = -1; |
| s->logs.bytes = 0; |
| |
| if ((p->mode == PR_MODE_TCP || p->mode == PR_MODE_HTTP) |
| && (p->logfac1 >= 0 || p->logfac2 >= 0)) { |
| struct sockaddr_in sockname; |
| unsigned char *pn, *sn; |
| int namelen; |
| |
| namelen = sizeof(sockname); |
| if (get_original_dst(cfd, (struct sockaddr_in *)&sockname, &namelen) == -1) |
| getsockname(cfd, (struct sockaddr *)&sockname, &namelen); |
| sn = (unsigned char *)&sockname.sin_addr; |
| pn = (unsigned char *)&s->cli_addr.sin_addr; |
| |
| 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 |
| send_log(p, LOG_INFO, "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(s->cli_addr.sin_port), |
| sn[0], sn[1], sn[2], sn[3], ntohs(sockname.sin_port), |
| p->id, (p->mode == PR_MODE_HTTP) ? "HTTP" : "TCP"); |
| } |
| |
| if ((global.mode & MODE_DEBUG) && !(global.mode & MODE_QUIET)) { |
| int len; |
| len = sprintf(trash, "accept(%04x)=%04x\n", (unsigned short)fd, (unsigned short)cfd); |
| write(1, trash, len); |
| } |
| |
| if ((s->req = pool_alloc(buffer)) == NULL) { /* no memory */ |
| 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) /* reserver some space for header rewriting */ |
| s->req->rlim -= MAXREWRITE; |
| |
| 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(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_HEALTH) { /* health check mode, no client reading */ |
| client_retnclose(s, 3, "OK\n"); /* forge an "OK" response */ |
| } |
| 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); |
| |
| t->expire = s->crexpire; |
| |
| task_queue(t); |
| |
| if (p->mode != PR_MODE_HEALTH) |
| task_wakeup(&rq, t); |
| |
| p->nbconn++; |
| actconn++; |
| totalconn++; |
| |
| // fprintf(stderr, "accepting from %p => %d conn, %d total\n", p, actconn, totalconn); |
| } /* end of while (p->nbconn < p->maxconn) */ |
| return 0; |
| } |
| |
| |
| /* |
| * This function is used only for server health-checks. It handles |
| * the connection acknowledgement and returns 1 if the socket is OK, |
| * or -1 if an error occured. |
| */ |
| int event_srv_hck(int fd) { |
| struct task *t = fdtab[fd].owner; |
| struct server *s = t->context; |
| |
| int skerr, lskerr; |
| lskerr = sizeof(skerr); |
| getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
| if (skerr) |
| s->result = -1; |
| else |
| s->result = 1; |
| |
| task_wakeup(&rq, t); |
| 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 len 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 */ |
| |
| /* 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; |
| } |
| |
| |
| 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_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 session *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) { |
| /* 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; |
| |
| 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 */ |
| char newhdr[MAXREWRITE + 1]; |
| int line, len; |
| /* 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; |
| client_retnclose(t, strlen(HTTP_403), HTTP_403); |
| return 1; |
| } |
| |
| for (line = 0; line < t->proxy->nb_reqadd; line++) { |
| len = sprintf(newhdr, "%s\r\n", t->proxy->req_add[line]); |
| buffer_replace2(req, req->h, req->h, newhdr, len); |
| } |
| |
| if (t->proxy->options & PR_O_FWDFOR) { |
| /* insert an X-Forwarded-For header */ |
| unsigned char *pn; |
| pn = (unsigned char *)&t->cli_addr.sin_addr; |
| len = sprintf(newhdr, "X-Forwarded-For: %d.%d.%d.%d\r\n", |
| pn[0], pn[1], pn[2], pn[3]); |
| buffer_replace2(req, req->h, req->h, newhdr, len); |
| } |
| |
| t->cli_state = CL_STDATA; |
| req->rlim = req->data + BUFSIZE; /* no more rewrite needed */ |
| |
| t->logs.t_request = tv_delta(&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 ? */ |
| //FD_CLR(t->cli_fd, StaticReadEvent); |
| //tv_eternity(&t->crexpire); |
| break; |
| } |
| |
| /* 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 (t->logs.logwait & LW_REQ && |
| t->proxy->mode & PR_MODE_HTTP) { |
| /* 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 = 502; |
| client_retnclose(t, strlen(HTTP_502), HTTP_502); |
| 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); |
| } |
| |
| delete_header = 0; |
| |
| if ((global.mode & MODE_DEBUG) && !(global.mode & MODE_QUIET)) { |
| int len, max; |
| len = sprintf(trash, "clihdr[%04x:%04x]: ", (unsigned short)t->cli_fd, (unsigned short)t->srv_fd); |
| max = ptr - req->h; |
| UBOUND(max, sizeof(trash) - len - 1); |
| len += strlcpy(trash + len, req->h, max + 1); |
| trash[len++] = '\n'; |
| write(1, trash, len); |
| } |
| |
| /* try headers regexps */ |
| if (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; |
| } |
| 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->flags & SN_CLDENY) && (ptr >= req->h + 8) |
| && (strncmp(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. |
| */ |
| |
| if (*p1 == '$') { |
| /* skip this one */ |
| } |
| else if ((p2 - p1 == strlen(t->proxy->cookie_name)) && |
| (memcmp(p1, t->proxy->cookie_name, p2 - p1) == 0)) { |
| /* Cool... it's the right one */ |
| struct server *srv = t->proxy->srv; |
| |
| while (srv && |
| ((srv->cklen != p4 - p3) || memcmp(p3, srv->cookie, p4 - p3))) { |
| srv = srv->next; |
| } |
| |
| if (srv) { /* we found the server */ |
| t->flags |= SN_DIRECT; |
| t->srv = srv; |
| } |
| /* if this cookie was set in insert+indirect mode, then it's better that the |
| * server never sees it. |
| */ |
| 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; |
| } |
| } |
| |
| /* 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 ! */ |
| |
| 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, strlen(HTTP_400), HTTP_400); |
| return 1; |
| } |
| else if (t->res_cr == RES_ERROR || t->res_cr == RES_NULL |
| || tv_cmp2_ms(&t->crexpire, &now) <= 0) { |
| |
| /* read timeout, read error, or last read : give up. |
| * 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. |
| */ |
| tv_eternity(&t->crexpire); |
| fd_delete(t->cli_fd); |
| t->cli_state = CL_STCLOSE; |
| return 1; |
| } |
| |
| return t->cli_state != CL_STHEADERS; |
| } |
| else if (c == CL_STDATA) { |
| /* 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; |
| 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 >= 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) |
| tv_delayfrom(&t->crexpire, &now, t->proxy->clitimeout); |
| else |
| tv_eternity(&t->crexpire); |
| } |
| } |
| |
| 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); |
| 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->cwexpire, &now) <= 0)) { |
| tv_eternity(&t->cwexpire); |
| fd_delete(t->cli_fd); |
| t->cli_state = CL_STCLOSE; |
| return 1; |
| } |
| else 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); |
| 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->crexpire, &now) <= 0) { |
| tv_eternity(&t->crexpire); |
| fd_delete(t->cli_fd); |
| t->cli_state = CL_STCLOSE; |
| return 1; |
| } |
| else 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) |
| tv_delayfrom(&t->crexpire, &now, t->proxy->clitimeout); |
| else |
| tv_eternity(&t->crexpire); |
| } |
| } |
| return 0; |
| } |
| else { /* CL_STCLOSE: nothing to do */ |
| if ((global.mode & MODE_DEBUG) && !(global.mode & MODE_QUIET)) { |
| int len; |
| len = sprintf(trash, "clicls[%04x:%04x]\n", (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; |
| |
| //fprintf(stderr,"process_srv: c=%d, s=%d\n", c, s); |
| //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) == 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 ((t->proxy->options & PR_O_REDISP) && (t->conn_retries == 0)) { |
| t->flags &= ~SN_DIRECT; /* ignore cookie and force to use the dispatcher */ |
| t->srv = NULL; /* it's left to the dispatcher to choose a server */ |
| } |
| |
| if (connect_server(t) == 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; |
| t->logs.status = 502; |
| client_return(t, strlen(HTTP_502), HTTP_502); |
| } |
| } |
| 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) { |
| if ((t->proxy->options & PR_O_REDISP) && (t->conn_retries == 0)) { |
| t->flags &= ~SN_DIRECT; /* ignore cookie and force to use the dispatcher */ |
| t->srv = NULL; /* it's left to the dispatcher to choose a server */ |
| } |
| if (connect_server(t) == 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 */ |
| t->logs.t_connect = tv_delta(&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); |
| 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; |
| rep->rlim = rep->data + BUFSIZE; /* no rewrite needed */ |
| } |
| else { |
| t->srv_state = SV_STHEADERS; |
| 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) { |
| char newhdr[MAXREWRITE + 1]; |
| int line, len; |
| |
| /* we can only get here after an end of headers */ |
| /* 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)) { |
| /* the server is known, it's not the one the client requested, we have to |
| * insert a set-cookie here. |
| */ |
| len = sprintf(newhdr, "Set-Cookie: %s=%s; path=/\r\n", |
| t->proxy->cookie_name, t->srv->cookie); |
| if (t->proxy->options & PR_O_COOK_NOC) |
| len += sprintf(newhdr + len, "Cache-control: no-cache=\"set-cookie\"\r\n"); |
| |
| buffer_replace2(rep, rep->h, rep->h, newhdr, len); |
| } |
| |
| /* headers to be added */ |
| for (line = 0; line < t->proxy->nb_rspadd; line++) { |
| len = sprintf(newhdr, "%s\r\n", t->proxy->rsp_add[line]); |
| buffer_replace2(rep, rep->h, rep->h, newhdr, len); |
| } |
| |
| t->srv_state = SV_STDATA; |
| rep->rlim = rep->data + BUFSIZE; /* no more rewrite needed */ |
| t->logs.t_data = tv_delta(&t->logs.tv_accept, &now); |
| 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.logwait & LW_RESP) { |
| t->logs.logwait &= ~LW_RESP; |
| t->logs.status = atoi(rep->h + 9); |
| } |
| |
| delete_header = 0; |
| |
| if ((global.mode & MODE_DEBUG) && !(global.mode & MODE_QUIET)) { |
| int len, max; |
| len = sprintf(trash, "srvhdr[%04x:%04x]: ", (unsigned short)t->cli_fd, (unsigned short)t->srv_fd); |
| max = ptr - rep->h; |
| UBOUND(max, sizeof(trash) - len - 1); |
| len += strlcpy(trash + len, rep->h, max + 1); |
| trash[len++] = '\n'; |
| write(1, trash, len); |
| } |
| |
| /* try headers regexps */ |
| if (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; |
| } |
| break; |
| } |
| } while ((exp = exp->next) != NULL); |
| *ptr = term; /* restore the string terminator */ |
| } |
| |
| /* check for server cookies */ |
| if (!delete_header && (t->proxy->options & PR_O_COOK_ANY) |
| && (t->proxy->cookie_name != NULL) && (ptr >= rep->h + 12) |
| && (strncmp(rep->h, "Set-Cookie: ", 12) == 0)) { |
| char *p1, *p2, *p3, *p4; |
| |
| 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. |
| */ |
| |
| if ((p2 - p1 == strlen(t->proxy->cookie_name)) && |
| (strncmp(p1, t->proxy->cookie_name, p2 - p1) == 0)) { |
| /* Cool... it's the right one */ |
| |
| /* 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; |
| } |
| 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); |
| } |
| break; |
| } |
| 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 */ |
| |
| /* 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 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); |
| t->srv_state = SV_STCLOSE; |
| return 1; |
| } |
| /* read timeout, last read, or end of client write |
| * 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 || 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 |