mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-08-09 16:47:18 +02:00
Code Issues Projects Releases Wiki Activity

CLEANUP: conn_stream: rename cs_app_* to sc_app_*

Browse Source 
Let's start to introduce the stream connector at the app_ops level.
This is entirely self-contained into conn_stream.c. The functions
were also updated to reflect the new name, and the comments were
updated.
This commit is contained in:
Willy Tarreau 2022-05-17 18:28:19 +02:00
parent 798465b02c
commit 3a3f480d15
2 changed files with 67 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/haproxy/conn_stream-t.h
View File

@ -173,8 +173,8 @@ struct sedesc {
unsigned int flags; unsigned int flags;
}; };
/* operations available on a conn-stream */ /* operations available on a stream connector */
struct cs_app_ops { struct sc_app_ops {
void (*chk_rcv)(struct conn_stream *); /* chk_rcv function, may not be null */ void (*chk_rcv)(struct conn_stream *); /* chk_rcv function, may not be null */
void (*chk_snd)(struct conn_stream *); /* chk_snd function, may not be null */ void (*chk_snd)(struct conn_stream *); /* chk_snd function, may not be null */
void (*shutr)(struct conn_stream *); /* shut read function, may not be null */ void (*shutr)(struct conn_stream *); /* shut read function, may not be null */
@ -195,7 +195,7 @@ struct conn_stream {
struct sedesc *sedesc; /* points to the stream endpoint descriptor */ struct sedesc *sedesc; /* points to the stream endpoint descriptor */
enum obj_type *app; /* points to the applicative point (stream or check) */ enum obj_type *app; /* points to the applicative point (stream or check) */
const struct data_cb *data_cb; /* data layer callbacks. Must be set before xprt->init() */ const struct data_cb *data_cb; /* data layer callbacks. Must be set before xprt->init() */
struct cs_app_ops *ops; /* general operations used at the app layer */ struct sc_app_ops *ops; /* general operations used at the app layer */
struct sockaddr_storage *src; /* source address (pool), when known, otherwise NULL */ struct sockaddr_storage *src; /* source address (pool), when known, otherwise NULL */
struct sockaddr_storage *dst; /* destination address (pool), when known, otherwise NULL */ struct sockaddr_storage *dst; /* destination address (pool), when known, otherwise NULL */
}; };

128
src/conn_stream.c
View File

@ -23,46 +23,46 @@
DECLARE_POOL(pool_head_connstream, "conn_stream", sizeof(struct conn_stream)); DECLARE_POOL(pool_head_connstream, "conn_stream", sizeof(struct conn_stream));
DECLARE_POOL(pool_head_sedesc, "sedesc", sizeof(struct sedesc)); DECLARE_POOL(pool_head_sedesc, "sedesc", sizeof(struct sedesc));
/* functions used by default on a detached conn-stream */ /* functions used by default on a detached stream connector */
static void cs_app_shutr(struct conn_stream *cs); static void sc_app_shutr(struct conn_stream *cs);
static void cs_app_shutw(struct conn_stream *cs); static void sc_app_shutw(struct conn_stream *cs);
static void cs_app_chk_rcv(struct conn_stream *cs); static void sc_app_chk_rcv(struct conn_stream *cs);
static void cs_app_chk_snd(struct conn_stream *cs); static void sc_app_chk_snd(struct conn_stream *cs);
/* functions used on a mux-based conn-stream */ /* functions used on a mux-based stream connector */
static void cs_app_shutr_conn(struct conn_stream *cs); static void sc_app_shutr_conn(struct conn_stream *cs);
static void cs_app_shutw_conn(struct conn_stream *cs); static void sc_app_shutw_conn(struct conn_stream *cs);
static void cs_app_chk_rcv_conn(struct conn_stream *cs); static void sc_app_chk_rcv_conn(struct conn_stream *cs);
static void cs_app_chk_snd_conn(struct conn_stream *cs); static void sc_app_chk_snd_conn(struct conn_stream *cs);
/* functions used on an applet-based conn-stream */ /* functions used on an applet-based stream connector */
static void cs_app_shutr_applet(struct conn_stream *cs); static void sc_app_shutr_applet(struct conn_stream *cs);
static void cs_app_shutw_applet(struct conn_stream *cs); static void sc_app_shutw_applet(struct conn_stream *cs);
static void cs_app_chk_rcv_applet(struct conn_stream *cs); static void sc_app_chk_rcv_applet(struct conn_stream *cs);
static void cs_app_chk_snd_applet(struct conn_stream *cs); static void sc_app_chk_snd_applet(struct conn_stream *cs);
/* conn-stream operations for connections */ /* stream connector operations for connections */
struct cs_app_ops cs_app_conn_ops = { struct sc_app_ops sc_app_conn_ops = {
.chk_rcv = cs_app_chk_rcv_conn, .chk_rcv = sc_app_chk_rcv_conn,
.chk_snd = cs_app_chk_snd_conn, .chk_snd = sc_app_chk_snd_conn,
.shutr = cs_app_shutr_conn, .shutr = sc_app_shutr_conn,
.shutw = cs_app_shutw_conn, .shutw = sc_app_shutw_conn,
}; };
/* conn-stream operations for embedded tasks */ /* stream connector operations for embedded tasks */
struct cs_app_ops cs_app_embedded_ops = { struct sc_app_ops sc_app_embedded_ops = {
.chk_rcv = cs_app_chk_rcv, .chk_rcv = sc_app_chk_rcv,
.chk_snd = cs_app_chk_snd, .chk_snd = sc_app_chk_snd,
.shutr = cs_app_shutr, .shutr = sc_app_shutr,
.shutw = cs_app_shutw, .shutw = sc_app_shutw,
}; };
/* conn-stream operations for connections */ /* stream connector operations for connections */
struct cs_app_ops cs_app_applet_ops = { struct sc_app_ops sc_app_applet_ops = {
.chk_rcv = cs_app_chk_rcv_applet, .chk_rcv = sc_app_chk_rcv_applet,
.chk_snd = cs_app_chk_snd_applet, .chk_snd = sc_app_chk_snd_applet,
.shutr = cs_app_shutr_applet, .shutr = sc_app_shutr_applet,
.shutw = cs_app_shutw_applet, .shutw = sc_app_shutw_applet,
}; };
static int cs_conn_process(struct conn_stream *cs); static int cs_conn_process(struct conn_stream *cs);
@ -185,7 +185,7 @@ struct conn_stream *cs_new_from_strm(struct stream *strm, unsigned int flags)
cs->flags |= flags; cs->flags |= flags;
sc_ep_set(cs, SE_FL_DETACHED); sc_ep_set(cs, SE_FL_DETACHED);
cs->app = &strm->obj_type; cs->app = &strm->obj_type;
cs->ops = &cs_app_embedded_ops; cs->ops = &sc_app_embedded_ops;
cs->data_cb = NULL; cs->data_cb = NULL;
return cs; return cs;
} }
@ -264,7 +264,7 @@ int cs_attach_mux(struct conn_stream *cs, void *endp, void *ctx)
cs->wait_event.events = 0; cs->wait_event.events = 0;
} }
cs->ops = &cs_app_conn_ops; cs->ops = &sc_app_conn_ops;
cs->data_cb = &cs_data_conn_cb; cs->data_cb = &cs_data_conn_cb;
} }
else if (cs_check(cs)) { else if (cs_check(cs)) {
@ -293,7 +293,7 @@ static void cs_attach_applet(struct conn_stream *cs, void *endp)
sc_ep_set(cs, SE_FL_T_APPLET); sc_ep_set(cs, SE_FL_T_APPLET);
sc_ep_clr(cs, SE_FL_DETACHED); sc_ep_clr(cs, SE_FL_DETACHED);
if (cs_strm(cs)) { if (cs_strm(cs)) {
cs->ops = &cs_app_applet_ops; cs->ops = &sc_app_applet_ops;
cs->data_cb = &cs_data_applet_cb; cs->data_cb = &cs_data_applet_cb;
} }
} }
@ -315,15 +315,15 @@ int cs_attach_strm(struct conn_stream *cs, struct stream *strm)
cs->wait_event.tasklet->context = cs; cs->wait_event.tasklet->context = cs;
cs->wait_event.events = 0; cs->wait_event.events = 0;
cs->ops = &cs_app_conn_ops; cs->ops = &sc_app_conn_ops;
cs->data_cb = &cs_data_conn_cb; cs->data_cb = &cs_data_conn_cb;
} }
else if (sc_ep_test(cs, SE_FL_T_APPLET)) { else if (sc_ep_test(cs, SE_FL_T_APPLET)) {
cs->ops = &cs_app_applet_ops; cs->ops = &sc_app_applet_ops;
cs->data_cb = &cs_data_applet_cb; cs->data_cb = &cs_data_applet_cb;
} }
else { else {
cs->ops = &cs_app_embedded_ops; cs->ops = &sc_app_embedded_ops;
cs->data_cb = NULL; cs->data_cb = NULL;
} }
return 0; return 0;
@ -393,7 +393,7 @@ static void cs_detach_endp(struct conn_stream **csp)
*/ */
cs->flags &= CS_FL_ISBACK; cs->flags &= CS_FL_ISBACK;
if (cs_strm(cs)) if (cs_strm(cs))
cs->ops = &cs_app_embedded_ops; cs->ops = &sc_app_embedded_ops;
cs->data_cb = NULL; cs->data_cb = NULL;
cs_free_cond(csp); cs_free_cond(csp);
} }
@ -504,7 +504,7 @@ struct appctx *cs_applet_create(struct conn_stream *cs, struct applet *app)
* reflect the new state. If the conn-stream has CS_FL_NOHALF, we also * reflect the new state. If the conn-stream has CS_FL_NOHALF, we also
* forward the close to the write side. The owner task is woken up if it exists. * forward the close to the write side. The owner task is woken up if it exists.
*/ */
static void cs_app_shutr(struct conn_stream *cs) static void sc_app_shutr(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
@ -523,7 +523,7 @@ static void cs_app_shutr(struct conn_stream *cs)
} }
else if (cs->flags & CS_FL_NOHALF) { else if (cs->flags & CS_FL_NOHALF) {
/* we want to immediately forward this close to the write side */ /* we want to immediately forward this close to the write side */
return cs_app_shutw(cs); return sc_app_shutw(cs);
} }
/* note that if the task exists, it must unregister itself once it runs */ /* note that if the task exists, it must unregister itself once it runs */
@ -538,7 +538,7 @@ static void cs_app_shutr(struct conn_stream *cs)
* reflect the new state. It does also close everything if the CS was marked as * reflect the new state. It does also close everything if the CS was marked as
* being in error state. The owner task is woken up if it exists. * being in error state. The owner task is woken up if it exists.
*/ */
static void cs_app_shutw(struct conn_stream *cs) static void sc_app_shutw(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
struct channel *oc = cs_oc(cs); struct channel *oc = cs_oc(cs);
@ -590,7 +590,7 @@ static void cs_app_shutw(struct conn_stream *cs)
} }
/* default chk_rcv function for scheduled tasks */ /* default chk_rcv function for scheduled tasks */
static void cs_app_chk_rcv(struct conn_stream *cs) static void sc_app_chk_rcv(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
@ -610,7 +610,7 @@ static void cs_app_chk_rcv(struct conn_stream *cs)
} }
/* default chk_snd function for scheduled tasks */ /* default chk_snd function for scheduled tasks */
static void cs_app_chk_snd(struct conn_stream *cs) static void sc_app_chk_snd(struct conn_stream *cs)
{ {
struct channel *oc = cs_oc(cs); struct channel *oc = cs_oc(cs);
@ -637,16 +637,16 @@ static void cs_app_chk_snd(struct conn_stream *cs)
} }
/* /*
* This function performs a shutdown-read on a conn-stream attached to * This function performs a shutdown-read on a stream connector attached to
* a connection in a connected or init state (it does nothing for other * a connection in a connected or init state (it does nothing for other
* states). It either shuts the read side or marks itself as closed. The buffer * states). It either shuts the read side or marks itself as closed. The buffer
* flags are updated to reflect the new state. If the conn-stream has * flags are updated to reflect the new state. If the stream connector has
* CS_FL_NOHALF, we also forward the close to the write side. If a control * CS_FL_NOHALF, we also forward the close to the write side. If a control
* layer is defined, then it is supposed to be a socket layer and file * layer is defined, then it is supposed to be a socket layer and file
* descriptors are then shutdown or closed accordingly. The function * descriptors are then shutdown or closed accordingly. The function
* automatically disables polling if needed. * automatically disables polling if needed.
*/ */
static void cs_app_shutr_conn(struct conn_stream *cs) static void sc_app_shutr_conn(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
@ -668,19 +668,19 @@ static void cs_app_shutr_conn(struct conn_stream *cs)
} }
else if (cs->flags & CS_FL_NOHALF) { else if (cs->flags & CS_FL_NOHALF) {
/* we want to immediately forward this close to the write side */ /* we want to immediately forward this close to the write side */
return cs_app_shutw_conn(cs); return sc_app_shutw_conn(cs);
} }
} }
/* /*
* This function performs a shutdown-write on a conn-stream attached to * This function performs a shutdown-write on a stream connector attached to
* a connection in a connected or init state (it does nothing for other * a connection in a connected or init state (it does nothing for other
* states). It either shuts the write side or marks itself as closed. The * states). It either shuts the write side or marks itself as closed. The
* buffer flags are updated to reflect the new state. It does also close * buffer flags are updated to reflect the new state. It does also close
* everything if the CS was marked as being in error state. If there is a * everything if the CS was marked as being in error state. If there is a
* data-layer shutdown, it is called. * data-layer shutdown, it is called.
*/ */
static void cs_app_shutw_conn(struct conn_stream *cs) static void sc_app_shutw_conn(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
struct channel *oc = cs_oc(cs); struct channel *oc = cs_oc(cs);
@ -754,13 +754,13 @@ static void cs_app_shutw_conn(struct conn_stream *cs)
} }
} }
/* This function is used for inter-conn-stream calls. It is called by the /* This function is used for inter-stream connector calls. It is called by the
* consumer to inform the producer side that it may be interested in checking * consumer to inform the producer side that it may be interested in checking
* for free space in the buffer. Note that it intentionally does not update * for free space in the buffer. Note that it intentionally does not update
* timeouts, so that we can still check them later at wake-up. This function is * timeouts, so that we can still check them later at wake-up. This function is
* dedicated to connection-based conn-streams. * dedicated to connection-based stream connectors.
*/ */
static void cs_app_chk_rcv_conn(struct conn_stream *cs) static void sc_app_chk_rcv_conn(struct conn_stream *cs)
{ {
BUG_ON(!cs_conn(cs)); BUG_ON(!cs_conn(cs));
@ -770,12 +770,12 @@ static void cs_app_chk_rcv_conn(struct conn_stream *cs)
} }
/* This function is used for inter-conn-stream calls. It is called by the /* This function is used for inter-stream connector calls. It is called by the
* producer to inform the consumer side that it may be interested in checking * producer to inform the consumer side that it may be interested in checking
* for data in the buffer. Note that it intentionally does not update timeouts, * for data in the buffer. Note that it intentionally does not update timeouts,
* so that we can still check them later at wake-up. * so that we can still check them later at wake-up.
*/ */
static void cs_app_chk_snd_conn(struct conn_stream *cs) static void sc_app_chk_snd_conn(struct conn_stream *cs)
{ {
struct channel *oc = cs_oc(cs); struct channel *oc = cs_oc(cs);
@ -866,14 +866,14 @@ static void cs_app_chk_snd_conn(struct conn_stream *cs)
} }
/* /*
* This function performs a shutdown-read on a conn-stream attached to an * This function performs a shutdown-read on a stream connector attached to an
* applet in a connected or init state (it does nothing for other states). It * applet in a connected or init state (it does nothing for other states). It
* either shuts the read side or marks itself as closed. The buffer flags are * either shuts the read side or marks itself as closed. The buffer flags are
* updated to reflect the new state. If the conn-stream has CS_FL_NOHALF, * updated to reflect the new state. If the stream connector has CS_FL_NOHALF,
* we also forward the close to the write side. The owner task is woken up if * we also forward the close to the write side. The owner task is woken up if
* it exists. * it exists.
*/ */
static void cs_app_shutr_applet(struct conn_stream *cs) static void sc_app_shutr_applet(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
@ -897,18 +897,18 @@ static void cs_app_shutr_applet(struct conn_stream *cs)
} }
else if (cs->flags & CS_FL_NOHALF) { else if (cs->flags & CS_FL_NOHALF) {
/* we want to immediately forward this close to the write side */ /* we want to immediately forward this close to the write side */
return cs_app_shutw_applet(cs); return sc_app_shutw_applet(cs);
} }
} }
/* /*
* This function performs a shutdown-write on a conn-stream attached to an * This function performs a shutdown-write on a stream connector attached to an
* applet in a connected or init state (it does nothing for other states). It * applet in a connected or init state (it does nothing for other states). It
* either shuts the write side or marks itself as closed. The buffer flags are * either shuts the write side or marks itself as closed. The buffer flags are
* updated to reflect the new state. It does also close everything if the SI * updated to reflect the new state. It does also close everything if the SI
* was marked as being in error state. The owner task is woken up if it exists. * was marked as being in error state. The owner task is woken up if it exists.
*/ */
static void cs_app_shutw_applet(struct conn_stream *cs) static void sc_app_shutw_applet(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
struct channel *oc = cs_oc(cs); struct channel *oc = cs_oc(cs);
@ -962,7 +962,7 @@ static void cs_app_shutw_applet(struct conn_stream *cs)
} }
/* chk_rcv function for applets */ /* chk_rcv function for applets */
static void cs_app_chk_rcv_applet(struct conn_stream *cs) static void sc_app_chk_rcv_applet(struct conn_stream *cs)
{ {
struct channel *ic = cs_ic(cs); struct channel *ic = cs_ic(cs);
@ -979,7 +979,7 @@ static void cs_app_chk_rcv_applet(struct conn_stream *cs)
} }
/* chk_snd function for applets */ /* chk_snd function for applets */
static void cs_app_chk_snd_applet(struct conn_stream *cs) static void sc_app_chk_snd_applet(struct conn_stream *cs)
{ {
struct channel *oc = cs_oc(cs); struct channel *oc = cs_oc(cs);