20 Commits

Author	SHA1	Message	Date
Willy Tarreau	ef38c39287	MEDIUM: sample: systematically pass the keyword pointer to the keyword ... We're having a lot of duplicate code just because of minor variants between fetch functions that could be dealt with if the functions had the pointer to the original keyword, so let's pass it as the last argument. An earlier version used to pass a pointer to the sample_fetch element, but this is not the best solution for two reasons : - fetch functions will solely rely on the keyword string - some other smp_fetch_* users do not have the pointer to the original keyword and were forced to pass NULL. So finally we're passing a pointer to the keyword as a const char *, which perfectly fits the original purpose.	2013-08-01 21:17:13 +02:00
Willy Tarreau	dc13c11c1e	BUG/MEDIUM: prevent gcc from moving empty keywords lists into BSS ... Benoit Dolez reported a failure to start haproxy 1.5-dev19. The process would immediately report an internal error with missing fetches from some crap instead of ACL names. The cause is that some versions of gcc seem to trim static structs containing a variable array when moving them to BSS, and only keep the fixed size, which is just a list head for all ACL and sample fetch keywords. This was confirmed at least with gcc 3.4.6. And we can't move these structs to const because they contain a list element which is needed to link all of them together during the parsing. The bug indeed appeared with 1.5-dev19 because it's the first one to have some empty ACL keyword lists. One solution is to impose -fno-zero-initialized-in-bss to everyone but this is not really nice. Another solution consists in ensuring the struct is never empty so that it does not move there. The easy solution consists in having a non-null list head since it's not yet initialized. A new "ILH" list head type was thus created for this purpose : create an Initialized List Head so that gcc cannot move the struct to BSS. This fixes the issue for this version of gcc and does not create any burden for the declarations.	2013-06-21 23:29:02 +02:00
Willy Tarreau	6d4e4e8dd2	MEDIUM: acl: remove a lot of useless ACLs that are equivalent to their fetches ... The following 116 ACLs were removed because they're redundant with their fetch function since last commit which allows the fetch function to be used instead for types BOOL, INT and IP. Most places are now left with an empty ACL keyword list that was not removed so that it's easier to add other ACLs later. always_false, always_true, avg_queue, be_conn, be_id, be_sess_rate, connslots, nbsrv, queue, srv_conn, srv_id, srv_is_up, srv_sess_rate, res.comp, fe_conn, fe_id, fe_sess_rate, dst_conn, so_id, wait_end, http_auth, http_first_req, status, dst, dst_port, src, src_port, sc1_bytes_in_rate, sc1_bytes_out_rate, sc1_clr_gpc0, sc1_conn_cnt, sc1_conn_cur, sc1_conn_rate, sc1_get_gpc0, sc1_gpc0_rate, sc1_http_err_cnt, sc1_http_err_rate, sc1_http_req_cnt, sc1_http_req_rate, sc1_inc_gpc0, sc1_kbytes_in, sc1_kbytes_out, sc1_sess_cnt, sc1_sess_rate, sc1_tracked, sc1_trackers, sc2_bytes_in_rate, sc2_bytes_out_rate, sc2_clr_gpc0, sc2_conn_cnt, sc2_conn_cur, sc2_conn_rate, sc2_get_gpc0, sc2_gpc0_rate, sc2_http_err_cnt, sc2_http_err_rate, sc2_http_req_cnt, sc2_http_req_rate, sc2_inc_gpc0, sc2_kbytes_in, sc2_kbytes_out, sc2_sess_cnt, sc2_sess_rate, sc2_tracked, sc2_trackers, sc3_bytes_in_rate, sc3_bytes_out_rate, sc3_clr_gpc0, sc3_conn_cnt, sc3_conn_cur, sc3_conn_rate, sc3_get_gpc0, sc3_gpc0_rate, sc3_http_err_cnt, sc3_http_err_rate, sc3_http_req_cnt, sc3_http_req_rate, sc3_inc_gpc0, sc3_kbytes_in, sc3_kbytes_out, sc3_sess_cnt, sc3_sess_rate, sc3_tracked, sc3_trackers, src_bytes_in_rate, src_bytes_out_rate, src_clr_gpc0, src_conn_cnt, src_conn_cur, src_conn_rate, src_get_gpc0, src_gpc0_rate, src_http_err_cnt, src_http_err_rate, src_http_req_cnt, src_http_req_rate, src_inc_gpc0, src_kbytes_in, src_kbytes_out, src_sess_cnt, src_sess_rate, src_updt_conn_cnt, table_avl, table_cnt, ssl_c_ca_err, ssl_c_ca_err_depth, ssl_c_err, ssl_c_used, ssl_c_verify, ssl_c_version, ssl_f_version, ssl_fc, ssl_fc_alg_keysize, ssl_fc_has_crt, ssl_fc_has_sni, ssl_fc_use_keysize,	2013-06-11 21:22:58 +02:00
Willy Tarreau	d86e29d2a1	CLEANUP: acl: remove unused references to ACL_USE_* ... Now that acl->requires is not used anymore, we can remove all references to it as well as all ACL_USE_* flags.	2013-04-03 02:13:00 +02:00
Willy Tarreau	c48c90dfa5	MAJOR: acl: remove the arg_mask from the ACL definition and use the sample fetch's ... Now that ACLs solely rely on sample fetch functions, make them use the same arg mask. All inconsistencies have been fixed separately prior to this patch, so this patch almost only adds a new pointer indirection and removes all references to ARG*() in the definitions. The parsing is still performed by the ACL code though.	2013-04-03 02:12:58 +02:00
Willy Tarreau	8ed669b12a	MAJOR: acl: make all ACLs reference the fetch function via a sample. ... ACL fetch functions used to directly reference a fetch function. Now that all ACL fetches have their sample fetches equivalent, we can make ACLs reference a sample fetch keyword instead. In order to simplify the code, a sample keyword name may be NULL if it is the same as the ACL's, which is the most common case. A minor change appeared, http_auth always expects one argument though the ACL allowed it to be missing and reported as such afterwards, so fix the ACL to match this. This is not really a bug.	2013-04-03 02:12:58 +02:00
Willy Tarreau	0ccb744ffb	MINOR: listener: rename sample fetch functions and declare the sample keywords ... The following sample fetch functions were only usable by ACLs but are now usable by sample fetches too : dst_conn, so_id, The fetch functions have been renamed "smp_fetch_*".	2013-04-03 02:12:57 +02:00
Willy Tarreau	50de90a228	MINOR: listeners: make the accept loop more robust when maxaccept==0 ... If some listeners are mistakenly configured with 0 as the maxaccept value, then we now consider them as limited to one accept() at a time. This will avoid some issues as fixed by the past commit.	2012-11-23 20:22:10 +01:00
Willy Tarreau	16a2147dfe	MEDIUM: adjust the maxaccept per listener depending on the number of processes ... global.tune.maxaccept was used for all listeners. This becomes really not convenient when some listeners are bound to a single process and other ones are bound to many processes. Now we change the principle : we count the number of processes a listener is bound to, and apply the maxaccept either entirely if there is a single process, or divided by twice the number of processes in order to maintain fairness. The default limit has also been increased from 32 to 64 as it appeared that on small machines, 32 was too low to achieve high connection rates.	2012-11-19 12:39:59 +01:00
Willy Tarreau	6b3b0d4736	MEDIUM: listener: provide a fallback for accept4() when not supported ... It happens that on some systems, the libc is recent enough to permit building with accept4() but the kernel does not support it. The result is then a disaster since no connection is accepted. We now detect this and automatically fall back to accept() and fcntl() when this happens.	2012-10-22 19:32:55 +02:00
Willy Tarreau	1bc4aab290	MEDIUM: listener: add support for linux's accept4() syscall ... On Linux, accept4() does the same as accept() except that it allows the caller to specify some flags to set on the resulting socket. We use this to set the O_NONBLOCK flag and thus to save one fcntl() call in each connection. The effect is a small performance gain of around 1%. The option is automatically enabled when target linux2628 is set, or when the USE_ACCEPT4 Makefile variable is set. If the libc is too old to provide the equivalent function, this is automatically detected and our own function is used instead. In any case it is possible to force the use of our implementation with USE_MY_ACCEPT4.	2012-10-08 20:11:03 +02:00
Willy Tarreau	b3fb60bdcd	BUG/MEDIUM: listener: don't pause protocols that do not support it ... Pausing a UNIX_STREAM socket results in a major pain because the socket does not correctly resume, it wakes poll() but return EAGAIN on accept(), resulting in a busy loop. So let's only pause protocols that support it. This issues has existed since UNIX sockets were introduced on bind lines.	2012-10-04 08:58:21 +02:00
Willy Tarreau	82569f9158	MEDIUM: monitor: simplify handling of monitor-net and mode health ... We were having several different behaviours with monitor-net and "mode health" : - monitor-net on TCP connections was evaluated just after accept(), did not count a connection on the frontend and were not subject to tcp-request connection rules, and caused an immediate close(). - monitor-net in HTTP mode was evaluated once the session was accepted (eg: on top of SSL), returned "HTTP/1.0 200 OK\r\n\r\n" over the connection's data layer and instanciated a session which was responsible for closing this connection. A connection AND a session were counted for the frontend ; - "mode health" with "option httpchk" would do exactly the same as monitor-net in HTTP mode ; - "mode health" without "option httpchk" would do the same as above except that "OK" was returned instead of "HTTP/1.0 200 OK\r\n\r\n". None of them took care of cleaning the input buffer, sometimes resulting in a TCP reset to be emitted after the last packet if a request was received over the connection. Given the inconsistencies and the complexity in keeping all these features handled at the right position, we now slightly changed the way they are handled : - all of them are handled just after the "tcp-request connection" rules, so that all of them may be blocked using such rules, offering more flexibility and consistency ; - no connection handshake is performed anymore for non-TCP modes - all of them send the response as raw data over the socket, there is no more difference between TCP and HTTP mode for example (these rules were never meant to be served over SSL connections and were never documented as able to do that). - any possible pending data on the incoming socket is drained before the response is sent, in order to avoid the risk of a reset. - none of them exactly did what was documented ! This results in more consistent, more flexible and more accurate handling of monitor rules, with smaller and more robust code.	2012-09-28 00:01:22 +02:00
Willy Tarreau	eb6cead1de	MINOR: standard: make memprintf() support a NULL destination ... Doing so removes many checks that were systematically made because the callees don't know if the caller passed a valid pointer.	2012-09-24 10:53:16 +02:00
Willy Tarreau	4348fad1c1	MAJOR: listeners: use dual-linked lists to chain listeners with frontends ... Navigating through listeners was very inconvenient and error-prone. Not to mention that listeners were linked in reverse order and reverted afterwards. In order to definitely get rid of these issues, we now do the following : - frontends have a dual-linked list of bind_conf - frontends have a dual-linked list of listeners - bind_conf have a dual-linked list of listeners - listeners have a pointer to their bind_conf This way we can now navigate from anywhere to anywhere and always find the proper bind_conf for a given listener, as well as find the list of listeners for a current bind_conf.	2012-09-20 16:48:07 +02:00
Willy Tarreau	51fb7651c4	MINOR: listener: add a scope field in the bind keyword lists ... This scope is used to report what the keywords are used for (eg: TCP, UNIX, ...). It is now reported by bind_dump_kws().	2012-09-18 18:27:14 +02:00
Willy Tarreau	8638f4850f	MEDIUM: config: enumerate full list of registered "bind" keywords upon error ... When an unknown "bind" keyword is detected, dump the list of all registered keywords. Unsupported default alternatives are also reported as "not supported".	2012-09-18 18:27:14 +02:00
Willy Tarreau	3dcc341720	MEDIUM: config: move the common "bind" settings to listener.c ... These ones are better placed in listener.c than in cfgparse.c, by relying on the bind keyword registration subsystem.	2012-09-18 17:17:28 +02:00
Willy Tarreau	269826659d	MEDIUM: listener: add a minimal framework to register "bind" keyword options ... With the arrival of SSL, the "bind" keyword has received even more options, all of which are processed in cfgparse in a cumbersome way. So it's time to let modules register their own bind options. This is done very similarly to the ACLs with a small difference in that we make the difference between an unknown option and a known, unimplemented option.	2012-09-15 22:33:08 +02:00
Willy Tarreau	d1d5454180	REORG: split "protocols" files into protocol and listener ... It was becoming confusing to have protocols and listeners in the same files, split them.	2012-09-15 22:29:32 +02:00