mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-20 21:31:28 +02:00
Code Issues Projects Releases Wiki Activity

MINOR: rhttp: large renaming to use rhttp prefix

Browse Source 
Previous commit renames 'proto_reverse_connect' module to 'proto_rhttp'.
This commits follows this by replacing various custom prefix by 'rhttp_'
to make the code uniform.

Note that 'reverse_' prefix was kept in connection module. This is
because if a new reversable protocol not based on HTTP is implemented,
it may be necessary to reused the same connection function which are
protocol agnostic.
This commit is contained in:
Amaury Denoyelle 2023-11-21 11:10:34 +01:00
parent e09af499b4
commit 55e78ff7e1
14 changed files with 100 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/haproxy/listener-t.h
View File

@ -210,8 +210,8 @@ struct bind_conf {
char *arg; /* argument passed to "bind" for better error reporting */
char *file; /* file where the section appears */
int line; /* line where the section appears */
char *reverse_srvname; /* name of server when using "rhttp@" address */
int reverse_nbconn; /* count of connections to initiate in parallel */
char *rhttp_srvname; /* name of server when using "rhttp@" address */
int rhttp_nbconn; /* count of connections to initiate in parallel */
__decl_thread(HA_RWLOCK_T sni_lock); /* lock the SNI trees during add/del operations */
struct thread_set thread_set; /* entire set of the allowed threads (0=no restriction) */
struct rx_settings settings; /* all the settings needed for the listening socket */

18
include/haproxy/proto_rhttp.h
View File

@ -5,17 +5,17 @@
#include <haproxy/listener-t.h>
#include <haproxy/receiver-t.h>
int rev_bind_receiver(struct receiver *rx, char **errmsg);
int rhttp_bind_receiver(struct receiver *rx, char **errmsg);
int rev_bind_listener(struct listener *listener, char *errmsg, int errlen);
void rev_enable_listener(struct listener *l);
void rev_disable_listener(struct listener *l);
struct connection *rev_accept_conn(struct listener *l, int *status);
void rev_unbind_receiver(struct listener *l);
int rev_set_affinity(struct connection *conn, int new_tid);
int rhttp_bind_listener(struct listener *listener, char *errmsg, int errlen);
void rhttp_enable_listener(struct listener *l);
void rhttp_disable_listener(struct listener *l);
struct connection *rhttp_accept_conn(struct listener *l, int *status);
void rhttp_unbind_receiver(struct listener *l);
int rhttp_set_affinity(struct connection *conn, int new_tid);
int rev_accepting_conn(const struct receiver *rx);
int rhttp_accepting_conn(const struct receiver *rx);
void rev_notify_preconn_err(struct listener *l);
void rhttp_notify_preconn_err(struct listener *l);
#endif /* _HAPROXY_PROTO_RHTTP_H */

2
include/haproxy/protocol-t.h
View File

@ -39,7 +39,7 @@ struct connection;
*/
#define AF_CUST_EXISTING_FD (AF_MAX + 1)
#define AF_CUST_SOCKPAIR (AF_MAX + 2)
#define AF_CUST_REV_SRV (AF_MAX + 3)
#define AF_CUST_RHTTP_SRV (AF_MAX + 3)
#define AF_CUST_MAX (AF_MAX + 4)
/*

2
include/haproxy/receiver-t.h
View File

@ -90,7 +90,7 @@ struct receiver {
struct server *srv; /* Underlying server used to initiate reverse pre-connect. */
struct connection *pend_conn; /* Pending connection waiting to complete reversal before being accepted. */
enum li_preconn_state state; /* State for transition logging. */
} reverse_connect;
} rhttp;
/* warning: this struct is huge, keep it at the bottom */
struct sockaddr_storage addr; /* the address the socket is bound to */

2
include/haproxy/server-t.h
View File

@ -142,7 +142,7 @@ enum srv_initaddr {
#define SRV_F_NON_STICK 0x0004 /* never add connections allocated to this server to a stick table */
#define SRV_F_USE_NS_FROM_PP 0x0008 /* use namespace associated with connection if present */
#define SRV_F_FORCED_ID 0x0010 /* server's ID was forced in the configuration */
#define SRV_F_REVERSE 0x0020 /* reverse connect server which requires idle connection for transfers */
#define SRV_F_RHTTP 0x0020 /* reverse HTTP server which requires idle connection for transfers */
#define SRV_F_AGENTPORT 0x0040 /* this server has a agent port configured */
#define SRV_F_AGENTADDR 0x0080 /* this server has a agent addr configured */
#define SRV_F_COOKIESET 0x0100 /* this server has a cookie configured, so don't generate dynamic cookies */

2
include/haproxy/server.h
View File

@ -314,7 +314,7 @@ static inline int srv_is_transparent(const struct server *srv)
/* A reverse server does not have any address but it is not used as a
* transparent one.
*/
return (!is_addr(&srv->addr) && !(srv->flags & SRV_F_REVERSE)) ||
return (!is_addr(&srv->addr) && !(srv->flags & SRV_F_RHTTP)) ||
(srv->flags & SRV_F_MAPPORTS);
}

4
src/backend.c
View File

@ -1361,7 +1361,7 @@ static int connect_server(struct stream *s)
srv = objt_server(s->target);
/* Override reuse-mode if reverse-connect is used. */
if (srv && srv->flags & SRV_F_REVERSE)
if (srv && srv->flags & SRV_F_RHTTP)
reuse_mode = PR_O_REUSE_ALWS;
err = alloc_dst_address(&s->scb->dst, srv, s);
@ -1596,7 +1596,7 @@ static int connect_server(struct stream *s)
skip_reuse:
/* no reuse or failed to reuse the connection above, pick a new one */
if (!srv_conn) {
if (srv && (srv->flags & SRV_F_REVERSE)) {
if (srv && (srv->flags & SRV_F_RHTTP)) {
DBG_TRACE_USER("cannot open a new connection for reverse server", STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
s->conn_err_type = STRM_ET_CONN_ERR;
return SF_ERR_INTERNAL;

10
src/cfgparse.c
View File

@ -162,7 +162,7 @@ int str2listener(char *str, struct proxy *curproxy, struct bind_conf *bind_conf,
if (!ss2)
goto fail;
if (ss2->ss_family == AF_CUST_REV_SRV) {
if (ss2->ss_family == AF_CUST_RHTTP_SRV) {
/* Check if a previous non reverse HTTP present is
* already defined. If DGRAM or STREAM is set, this
* indicates that we are currently parsing the second
@ -174,8 +174,8 @@ int str2listener(char *str, struct proxy *curproxy, struct bind_conf *bind_conf,
goto fail;
}
bind_conf->reverse_srvname = strdup(str + strlen("rhttp@"));
if (!bind_conf->reverse_srvname) {
bind_conf->rhttp_srvname = strdup(str + strlen("rhttp@"));
if (!bind_conf->rhttp_srvname) {
memprintf(err, "Cannot allocate reverse HTTP bind.\n");
goto fail;
}
@ -3889,8 +3889,8 @@ out_uri_auth_compat:
if ((curproxy->mode != PR_MODE_HTTP) && (curproxy->options & PR_O_REUSE_MASK) != PR_O_REUSE_NEVR)
curproxy->options &= ~PR_O_REUSE_MASK;
if ((curproxy->mode != PR_MODE_HTTP) && newsrv->flags & SRV_F_REVERSE) {
ha_alert("%s '%s' : server %s uses reverse addressing which can only be used with HTTP mode.\n",
if ((curproxy->mode != PR_MODE_HTTP) && newsrv->flags & SRV_F_RHTTP) {
ha_alert("%s '%s' : server %s uses reverse HTTP addressing which can only be used with HTTP mode.\n",
proxy_type_str(curproxy), curproxy->id, newsrv->id);
cfgerr++;
err_code |= ERR_FATAL | ERR_ALERT;

8
src/connection.c
View File

@ -126,7 +126,7 @@ fail:
/* If mux init failed, consider connection on error.
* This is necessary to ensure connection is freed by
* proto-reverse-connect receiver task.
* proto-rhttp receiver task.
*/
if (!conn->mux)
conn->flags |= CO_FL_ERROR;
@ -134,7 +134,7 @@ fail:
/* If connection is interrupted without CO_FL_ERROR, receiver task won't free it. */
BUG_ON(!(conn->flags & CO_FL_ERROR));
task_wakeup(l->rx.reverse_connect.task, TASK_WOKEN_ANY);
task_wakeup(l->rx.rhttp.task, TASK_WOKEN_ANY);
}
return -1;
} else
@ -591,7 +591,7 @@ void conn_free(struct connection *conn)
if (conn_reverse_in_preconnect(conn)) {
struct listener *l = conn_active_reverse_listener(conn);
rev_notify_preconn_err(l);
rhttp_notify_preconn_err(l);
}
conn_force_unsubscribe(conn);
@ -2681,7 +2681,7 @@ int conn_reverse(struct connection *conn)
conn->target = &l->obj_type;
conn->flags |= CO_FL_ACT_REVERSING;
task_wakeup(l->rx.reverse_connect.task, TASK_WOKEN_ANY);
task_wakeup(l->rx.rhttp.task, TASK_WOKEN_ANY);
}
/* Invert source and destination addresses if already set. */

18
src/listener.c
View File

@ -289,13 +289,13 @@ void listener_set_state(struct listener *l, enum li_state st)
_HA_ATOMIC_INC(&px->li_paused);
break;
case LI_LISTEN:
BUG_ON(l->rx.fd == -1 && !l->rx.reverse_connect.task);
BUG_ON(l->rx.fd == -1 && !l->rx.rhttp.task);
_HA_ATOMIC_INC(&px->li_bound);
break;
case LI_READY:
case LI_FULL:
case LI_LIMITED:
BUG_ON(l->rx.fd == -1 && !l->rx.reverse_connect.task);
BUG_ON(l->rx.fd == -1 && !l->rx.rhttp.task);
_HA_ATOMIC_INC(&px->li_ready);
l->flags |= LI_F_FINALIZED;
break;
@ -322,7 +322,7 @@ void enable_listener(struct listener *listener)
do_unbind_listener(listener);
if (listener->state == LI_LISTEN) {
BUG_ON(listener->rx.fd == -1 && !listener->rx.reverse_connect.task);
BUG_ON(listener->rx.fd == -1 && !listener->rx.rhttp.task);
if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
(!!master != !!(listener->rx.flags & RX_F_MWORKER))) {
/* we don't want to enable this listener and don't
@ -800,9 +800,9 @@ int create_listeners(struct bind_conf *bc, const struct sockaddr_storage *ss,
l->rx.iocb = proto->default_iocb;
l->rx.fd = fd;
l->rx.reverse_connect.task = NULL;
l->rx.reverse_connect.srv = NULL;
l->rx.reverse_connect.pend_conn = NULL;
l->rx.rhttp.task = NULL;
l->rx.rhttp.srv = NULL;
l->rx.rhttp.pend_conn = NULL;
memcpy(&l->rx.addr, ss, sizeof(*ss));
if (proto->fam->set_port)
@ -1959,7 +1959,7 @@ struct bind_conf *bind_conf_alloc(struct proxy *fe, const char *file,
#endif
LIST_INIT(&bind_conf->listeners);
bind_conf->reverse_srvname = NULL;
bind_conf->rhttp_srvname = NULL;
return bind_conf;
@ -2260,7 +2260,7 @@ static int bind_parse_nbconn(char **args, int cur_arg, struct proxy *px, struct
const struct listener *l;
l = LIST_NEXT(&conf->listeners, struct listener *, by_bind);
if (l->rx.addr.ss_family != AF_CUST_REV_SRV) {
if (l->rx.addr.ss_family != AF_CUST_RHTTP_SRV) {
memprintf(err, "'%s' : only valid for reverse HTTP listeners.", args[cur_arg]);
return ERR_ALERT | ERR_FATAL;
}
@ -2276,7 +2276,7 @@ static int bind_parse_nbconn(char **args, int cur_arg, struct proxy *px, struct
return ERR_ALERT | ERR_FATAL;
}
conf->reverse_nbconn = val;
conf->rhttp_nbconn = val;
return 0;
}

119
src/proto_rhttp.c
View File

@ -18,35 +18,35 @@
#include <haproxy/proto_rhttp.h>
struct proto_fam proto_fam_reverse_connect = {
.name = "reverse_connect",
.sock_domain = AF_CUST_REV_SRV,
struct proto_fam proto_fam_rhttp = {
.name = "rhttp",
.sock_domain = AF_CUST_RHTTP_SRV,
.sock_family = AF_INET,
.bind = rev_bind_receiver,
.bind = rhttp_bind_receiver,
};
struct protocol proto_reverse_connect = {
struct protocol proto_rhttp = {
.name = "rev",
/* connection layer (no outgoing connection) */
.listen = rev_bind_listener,
.enable = rev_enable_listener,
.disable = rev_disable_listener,
.listen = rhttp_bind_listener,
.enable = rhttp_enable_listener,
.disable = rhttp_disable_listener,
.add = default_add_listener,
.unbind = rev_unbind_receiver,
.unbind = rhttp_unbind_receiver,
.resume = default_resume_listener,
.accept_conn = rev_accept_conn,
.set_affinity = rev_set_affinity,
.accept_conn = rhttp_accept_conn,
.set_affinity = rhttp_set_affinity,
/* address family */
.fam = &proto_fam_reverse_connect,
.fam = &proto_fam_rhttp,
/* socket layer */
.proto_type = PROTO_TYPE_STREAM,
.sock_type = SOCK_STREAM,
.sock_prot = IPPROTO_TCP,
.rx_listening = rev_accepting_conn,
.receivers = LIST_HEAD_INIT(proto_reverse_connect.receivers),
.rx_listening = rhttp_accepting_conn,
.receivers = LIST_HEAD_INIT(proto_rhttp.receivers),
};
static struct connection *new_reverse_conn(struct listener *l, struct server *srv)
@ -112,8 +112,7 @@ static struct connection *new_reverse_conn(struct listener *l, struct server *sr
conn->destroy_cb(conn);
/* Mark connection as non-reversable. This prevents conn_free()
* to reschedule reverse_connect task on freeing a preconnect
* connection.
* to reschedule rhttp task on freeing a preconnect connection.
*/
conn->reverse.target = NULL;
conn_free(conn);
@ -126,33 +125,33 @@ static struct connection *new_reverse_conn(struct listener *l, struct server *sr
* reversal is completed. This is used to cleanup any reference to the
* connection and rearm a new preconnect attempt.
*/
void rev_notify_preconn_err(struct listener *l)
void rhttp_notify_preconn_err(struct listener *l)
{
/* For the moment reverse connection are bound only on first thread. */
BUG_ON(tid != 0);
/* Receiver must reference a reverse connection as pending. */
BUG_ON(!l->rx.reverse_connect.pend_conn);
BUG_ON(!l->rx.rhttp.pend_conn);
/* Remove reference to the freed connection. */
l->rx.reverse_connect.pend_conn = NULL;
l->rx.rhttp.pend_conn = NULL;
if (l->rx.reverse_connect.state != LI_PRECONN_ST_ERR) {
if (l->rx.rhttp.state != LI_PRECONN_ST_ERR) {
send_log(l->bind_conf->frontend, LOG_ERR,
"preconnect %s::%s: Error encountered.\n",
l->bind_conf->frontend->id, l->bind_conf->reverse_srvname);
l->rx.reverse_connect.state = LI_PRECONN_ST_ERR;
l->bind_conf->frontend->id, l->bind_conf->rhttp_srvname);
l->rx.rhttp.state = LI_PRECONN_ST_ERR;
}
/* Rearm a new preconnect attempt. */
l->rx.reverse_connect.task->expire = MS_TO_TICKS(now_ms + 1000);
task_queue(l->rx.reverse_connect.task);
l->rx.rhttp.task->expire = MS_TO_TICKS(now_ms + 1000);
task_queue(l->rx.rhttp.task);
}
struct task *rev_process(struct task *task, void *ctx, unsigned int state)
struct task *rhttp_process(struct task *task, void *ctx, unsigned int state)
{
struct listener *l = ctx;
struct connection *conn = l->rx.reverse_connect.pend_conn;
struct connection *conn = l->rx.rhttp.pend_conn;
if (conn) {
/* Either connection is on error ot the connect timeout fired. */
@ -176,8 +175,8 @@ struct task *rev_process(struct task *task, void *ctx, unsigned int state)
conn_free(conn);
}
/* conn_free() must report preconnect failure using rev_notify_preconn_err(). */
BUG_ON(l->rx.reverse_connect.pend_conn);
/* conn_free() must report preconnect failure using rhttp_notify_preconn_err(). */
BUG_ON(l->rx.rhttp.pend_conn);
}
else {
/* Spurious receiver task woken up despite pend_conn not ready/on error. */
@ -185,21 +184,21 @@ struct task *rev_process(struct task *task, void *ctx, unsigned int state)
/* A connection is ready to be accepted. */
listener_accept(l);
l->rx.reverse_connect.task->expire = TICK_ETERNITY;
l->rx.rhttp.task->expire = TICK_ETERNITY;
}
}
else {
struct server *srv = l->rx.reverse_connect.srv;
struct server *srv = l->rx.rhttp.srv;
/* No pending reverse connection, prepare a new one. Store it in the
* listener and return NULL. Connection will be returned later after
* reversal is completed.
*/
conn = new_reverse_conn(l, srv);
l->rx.reverse_connect.pend_conn = conn;
l->rx.rhttp.pend_conn = conn;
/* On success task will be woken up by H2 mux after reversal. */
l->rx.reverse_connect.task->expire = conn ?
l->rx.rhttp.task->expire = conn ?
tick_add_ifset(now_ms, srv->proxy->timeout.connect) :
MS_TO_TICKS(now_ms + 1000);
}
@ -207,13 +206,13 @@ struct task *rev_process(struct task *task, void *ctx, unsigned int state)
return task;
}
int rev_bind_receiver(struct receiver *rx, char **errmsg)
int rhttp_bind_receiver(struct receiver *rx, char **errmsg)
{
rx->flags |= RX_F_BOUND;
return ERR_NONE;
}
int rev_bind_listener(struct listener *listener, char *errmsg, int errlen)
int rhttp_bind_listener(struct listener *listener, char *errmsg, int errlen)
{
struct task *task;
struct proxy *be;
@ -226,21 +225,21 @@ int rev_bind_listener(struct listener *listener, char *errmsg, int errlen)
snprintf(errmsg, errlen, "Out of memory.");
goto err;
}
task->process = rev_process;
task->process = rhttp_process;
task->context = listener;
listener->rx.reverse_connect.task = task;
listener->rx.reverse_connect.state = LI_PRECONN_ST_STOP;
listener->rx.rhttp.task = task;
listener->rx.rhttp.state = LI_PRECONN_ST_STOP;
/* Set maxconn which is defined via the special kw nbconn for reverse
* connect. Use a default value of 1 if not set. This guarantees that
* listener will be automatically re-enable each time it fell back below
* it due to a connection error.
*/
listener->bind_conf->maxconn = listener->bind_conf->reverse_nbconn;
listener->bind_conf->maxconn = listener->bind_conf->rhttp_nbconn;
if (!listener->bind_conf->maxconn)
listener->bind_conf->maxconn = 1;
name = strdup(listener->bind_conf->reverse_srvname);
name = strdup(listener->bind_conf->rhttp_srvname);
if (!name) {
snprintf(errmsg, errlen, "Out of memory.");
goto err;
@ -262,8 +261,8 @@ int rev_bind_listener(struct listener *listener, char *errmsg, int errlen)
goto err;
}
if (srv->flags & SRV_F_REVERSE) {
snprintf(errmsg, errlen, "Cannot use reverse server '%s/%s' as target to a reverse bind.", ist0(be_name), ist0(sv_name));
if (srv->flags & SRV_F_RHTTP) {
snprintf(errmsg, errlen, "Cannot use reverse HTTP server '%s/%s' as target to a reverse bind.", ist0(be_name), ist0(sv_name));
goto err;
}
@ -290,7 +289,7 @@ int rev_bind_listener(struct listener *listener, char *errmsg, int errlen)
ha_free(&name);
listener->rx.reverse_connect.srv = srv;
listener->rx.rhttp.srv = srv;
listener_set_state(listener, LI_LISTEN);
return ERR_NONE;
@ -300,32 +299,32 @@ int rev_bind_listener(struct listener *listener, char *errmsg, int errlen)
return ERR_ALERT | ERR_FATAL;
}
void rev_enable_listener(struct listener *l)
void rhttp_enable_listener(struct listener *l)
{
if (l->rx.reverse_connect.state < LI_PRECONN_ST_INIT) {
if (l->rx.rhttp.state < LI_PRECONN_ST_INIT) {
send_log(l->bind_conf->frontend, LOG_INFO,
"preconnect %s::%s: Initiating.\n",
l->bind_conf->frontend->id, l->bind_conf->reverse_srvname);
l->rx.reverse_connect.state = LI_PRECONN_ST_INIT;
l->bind_conf->frontend->id, l->bind_conf->rhttp_srvname);
l->rx.rhttp.state = LI_PRECONN_ST_INIT;
}
task_wakeup(l->rx.reverse_connect.task, TASK_WOKEN_ANY);
task_wakeup(l->rx.rhttp.task, TASK_WOKEN_ANY);
}
void rev_disable_listener(struct listener *l)
void rhttp_disable_listener(struct listener *l)
{
if (l->rx.reverse_connect.state < LI_PRECONN_ST_FULL) {
if (l->rx.rhttp.state < LI_PRECONN_ST_FULL) {
send_log(l->bind_conf->frontend, LOG_INFO,
"preconnect %s::%s: Running with nbconn %d reached.\n",
l->bind_conf->frontend->id, l->bind_conf->reverse_srvname,
l->bind_conf->frontend->id, l->bind_conf->rhttp_srvname,
l->bind_conf->maxconn);
l->rx.reverse_connect.state = LI_PRECONN_ST_FULL;
l->rx.rhttp.state = LI_PRECONN_ST_FULL;
}
}
struct connection *rev_accept_conn(struct listener *l, int *status)
struct connection *rhttp_accept_conn(struct listener *l, int *status)
{
struct connection *conn = l->rx.reverse_connect.pend_conn;
struct connection *conn = l->rx.rhttp.pend_conn;
if (!conn) {
/* Reverse connect listener must have an explicit maxconn set
@ -335,8 +334,8 @@ struct connection *rev_accept_conn(struct listener *l, int *status)
/* Instantiate a new conn if maxconn not yet exceeded. */
if (l->nbconn <= l->bind_conf->maxconn) {
l->rx.reverse_connect.pend_conn = new_reverse_conn(l, l->rx.reverse_connect.srv);
if (!l->rx.reverse_connect.pend_conn) {
l->rx.rhttp.pend_conn = new_reverse_conn(l, l->rx.rhttp.srv);
if (!l->rx.rhttp.pend_conn) {
*status = CO_AC_PAUSE;
return NULL;
}
@ -352,18 +351,18 @@ struct connection *rev_accept_conn(struct listener *l, int *status)
conn->flags |= CO_FL_REVERSED;
conn->mux->ctl(conn, MUX_REVERSE_CONN, NULL);
l->rx.reverse_connect.pend_conn = NULL;
l->rx.rhttp.pend_conn = NULL;
*status = CO_AC_NONE;
return conn;
}
void rev_unbind_receiver(struct listener *l)
void rhttp_unbind_receiver(struct listener *l)
{
l->rx.flags &= ~RX_F_BOUND;
}
int rev_set_affinity(struct connection *conn, int new_tid)
int rhttp_set_affinity(struct connection *conn, int new_tid)
{
/* TODO reversal conn rebinding after is disabled for the moment as we
* did not test possible race conditions.
@ -371,9 +370,9 @@ int rev_set_affinity(struct connection *conn, int new_tid)
return -1;
}
int rev_accepting_conn(const struct receiver *rx)
int rhttp_accepting_conn(const struct receiver *rx)
{
return 1;
}
INITCALL1(STG_REGISTER, protocol_register, &proto_reverse_connect);
INITCALL1(STG_REGISTER, protocol_register, &proto_rhttp);

4
src/proxy.c
View File

@ -358,7 +358,7 @@ void free_proxy(struct proxy *p)
free(l->name);
free(l->per_thr);
free(l->counters);
task_destroy(l->rx.reverse_connect.task);
task_destroy(l->rx.rhttp.task);
EXTRA_COUNTERS_FREE(l->extra_counters);
free(l);
@ -372,7 +372,7 @@ void free_proxy(struct proxy *p)
free(bind_conf->arg);
free(bind_conf->settings.interface);
LIST_DELETE(&bind_conf->by_fe);
free(bind_conf->reverse_srvname);
free(bind_conf->rhttp_srvname);
free(bind_conf);
}

4
src/server.c
View File

@ -3009,12 +3009,12 @@ static int _srv_parse_init(struct server **srv, char **args, int *cur_arg,
}
if (!port1 || !port2) {
if (sk->ss_family != AF_CUST_REV_SRV) {
if (sk->ss_family != AF_CUST_RHTTP_SRV) {
/* no port specified, +offset, -offset */
newsrv->flags |= SRV_F_MAPPORTS;
}
else {
newsrv->flags |= SRV_F_REVERSE;
newsrv->flags |= SRV_F_RHTTP;
}
}

4
src/tools.c
View File

@ -1105,7 +1105,7 @@ struct sockaddr_storage *str2sa_range(const char *str, int *port, int *low, int
}
else if (strncmp(str2, "rhttp@", 3) == 0) {
str2 += 4;
ss.ss_family = AF_CUST_REV_SRV;
ss.ss_family = AF_CUST_RHTTP_SRV;
}
else if (*str2 == '/') {
ss.ss_family = AF_UNIX;
@ -1194,7 +1194,7 @@ struct sockaddr_storage *str2sa_range(const char *str, int *port, int *low, int
memcpy(un->sun_path, pfx, prefix_path_len);
memcpy(un->sun_path + prefix_path_len + abstract, str2, adr_len + 1 - abstract);
}
else if (ss.ss_family == AF_CUST_REV_SRV) {
else if (ss.ss_family == AF_CUST_RHTTP_SRV) {
/* Nothing to do here. */
}
else { /* IPv4 and IPv6 */