sinjuginas/haproxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MINOR: samples: rename union from "data" to "u"

Browse Source 
The union name "data" is a little bit heavy while we read the source
code because we can read "data.data.sint". The rename from "data" to "u"
makes the read easiest like "data.u.sint".
This commit is contained in:
Thierry FOURNIER 2015-08-19 09:07:19 +02:00 committed by Willy Tarreau
parent 654398a937
commit 136f9d34a9
20 changed files with 605 additions and 605 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/types/sample.h
View File

@ -253,7 +253,7 @@ union sample_value {
/* Used to store sample constant */
struct sample_data {
int type; /* SMP_T_* */
union sample_value data; /* sample data */
union sample_value u; /* sample data */
};
/* a sample is a typed data extracted from a stream. It has a type, contents,

2
src/auth.c
View File

@ -276,7 +276,7 @@ pat_match_auth(struct sample *smp, struct pattern_expr *expr, int fill)
/* Browse the userlist for searching user. */
for (u = ul->users; u; u = u->next) {
if (strcmp(smp->data.data.str.str, u->user) == 0)
if (strcmp(smp->data.u.str.str, u->user) == 0)
break;
}
if (!u)

50
src/backend.c
View File

@ -476,7 +476,7 @@ struct server *get_server_rch(struct stream *s)
b_rew(s->req.buf, rewind = s->req.buf->o);
ret = fetch_rdp_cookie_name(s, &smp, px->hh_name, px->hh_len);
len = smp.data.data.str.len;
len = smp.data.u.str.len;
b_adv(s->req.buf, rewind);
@ -490,7 +490,7 @@ struct server *get_server_rch(struct stream *s)
/* Found a the hh_name in the headers.
* we will compute the hash based on this value ctx.val.
*/
hash = gen_hash(px, smp.data.data.str.str, len);
hash = gen_hash(px, smp.data.u.str.str, len);
if ((px->lbprm.algo & BE_LB_HASH_MOD) == BE_LB_HMOD_AVAL)
hash = full_hash(hash);
@ -1218,10 +1218,10 @@ int connect_server(struct stream *s)
if (smp) {
/* get write access to terminate with a zero */
smp_dup(smp);
if (smp->data.data.str.len >= smp->data.data.str.size)
smp->data.data.str.len = smp->data.data.str.size - 1;
smp->data.data.str.str[smp->data.data.str.len] = 0;
ssl_sock_set_servername(srv_conn, smp->data.data.str.str);
if (smp->data.u.str.len >= smp->data.u.str.size)
smp->data.u.str.len = smp->data.u.str.size - 1;
smp->data.u.str.str[smp->data.u.str.len] = 0;
ssl_sock_set_servername(srv_conn, smp->data.u.str.str);
srv_conn->flags |= CO_FL_PRIVATE;
}
}
@ -1361,14 +1361,14 @@ int tcp_persist_rdp_cookie(struct stream *s, struct channel *req, int an_bit)
memset(&smp, 0, sizeof(smp));
ret = fetch_rdp_cookie_name(s, &smp, s->be->rdp_cookie_name, s->be->rdp_cookie_len);
if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || smp.data.data.str.len == 0)
if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || smp.data.u.str.len == 0)
goto no_cookie;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
/* Considering an rdp cookie detected using acl, str ended with <cr><lf> and should return */
addr.sin_addr.s_addr = strtoul(smp.data.data.str.str, &p, 10);
addr.sin_addr.s_addr = strtoul(smp.data.u.str.str, &p, 10);
if (*p != '.')
goto no_cookie;
p++;
@ -1606,11 +1606,11 @@ smp_fetch_nbsrv(const struct arg *args, struct sample *smp, const char *kw, void
px = args->data.prx;
if (px->srv_act)
smp->data.data.sint = px->srv_act;
smp->data.u.sint = px->srv_act;
else if (px->lbprm.fbck)
smp->data.data.sint = 1;
smp->data.u.sint = 1;
else
smp->data.data.sint = px->srv_bck;
smp->data.u.sint = px->srv_bck;
return 1;
}
@ -1629,9 +1629,9 @@ smp_fetch_srv_is_up(const struct arg *args, struct sample *smp, const char *kw,
smp->data.type = SMP_T_BOOL;
if (!(srv->admin & SRV_ADMF_MAINT) &&
(!(srv->check.state & CHK_ST_CONFIGURED) || (srv->state != SRV_ST_STOPPED)))
smp->data.data.sint = 1;
smp->data.u.sint = 1;
else
smp->data.data.sint = 0;
smp->data.u.sint = 0;
return 1;
}
@ -1646,7 +1646,7 @@ smp_fetch_connslots(const struct arg *args, struct sample *smp, const char *kw,
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
for (iterator = args->data.prx->srv; iterator; iterator = iterator->next) {
if (iterator->state == SRV_ST_STOPPED)
@ -1654,11 +1654,11 @@ smp_fetch_connslots(const struct arg *args, struct sample *smp, const char *kw,
if (iterator->maxconn == 0 || iterator->maxqueue == 0) {
/* configuration is stupid */
smp->data.data.sint = -1; /* FIXME: stupid value! */
smp->data.u.sint = -1; /* FIXME: stupid value! */
return 1;
}
smp->data.data.sint += (iterator->maxconn - iterator->cur_sess)
smp->data.u.sint += (iterator->maxconn - iterator->cur_sess)
+ (iterator->maxqueue - iterator->nbpend);
}
@ -1671,7 +1671,7 @@ smp_fetch_be_id(const struct arg *args, struct sample *smp, const char *kw, void
{
smp->flags = SMP_F_VOL_TXN;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = smp->strm->be->uuid;
smp->data.u.sint = smp->strm->be->uuid;
return 1;
}
@ -1683,7 +1683,7 @@ smp_fetch_srv_id(const struct arg *args, struct sample *smp, const char *kw, voi
return 0;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = objt_server(smp->strm->target)->puid;
smp->data.u.sint = objt_server(smp->strm->target)->puid;
return 1;
}
@ -1697,7 +1697,7 @@ smp_fetch_be_sess_rate(const struct arg *args, struct sample *smp, const char *k
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = read_freq_ctr(&args->data.prx->be_sess_per_sec);
smp->data.u.sint = read_freq_ctr(&args->data.prx->be_sess_per_sec);
return 1;
}
@ -1710,7 +1710,7 @@ smp_fetch_be_conn(const struct arg *args, struct sample *smp, const char *kw, vo
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = args->data.prx->beconn;
smp->data.u.sint = args->data.prx->beconn;
return 1;
}
@ -1723,7 +1723,7 @@ smp_fetch_queue_size(const struct arg *args, struct sample *smp, const char *kw,
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = args->data.prx->totpend;
smp->data.u.sint = args->data.prx->totpend;
return 1;
}
@ -1753,9 +1753,9 @@ smp_fetch_avg_queue_size(const struct arg *args, struct sample *smp, const char
nbsrv = px->srv_bck;
if (nbsrv > 0)
smp->data.data.sint = (px->totpend + nbsrv - 1) / nbsrv;
smp->data.u.sint = (px->totpend + nbsrv - 1) / nbsrv;
else
smp->data.data.sint = px->totpend * 2;
smp->data.u.sint = px->totpend * 2;
return 1;
}
@ -1769,7 +1769,7 @@ smp_fetch_srv_conn(const struct arg *args, struct sample *smp, const char *kw, v
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = args->data.srv->cur_sess;
smp->data.u.sint = args->data.srv->cur_sess;
return 1;
}
@ -1782,7 +1782,7 @@ smp_fetch_srv_sess_rate(const struct arg *args, struct sample *smp, const char *
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = read_freq_ctr(&args->data.srv->sess_per_sec);
smp->data.u.sint = read_freq_ctr(&args->data.srv->sess_per_sec);
return 1;
}

6
src/compression.c
View File

@ -841,7 +841,7 @@ static int
smp_fetch_res_comp(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = (smp->strm->comp_algo != NULL);
smp->data.u.sint = (smp->strm->comp_algo != NULL);
return 1;
}
@ -854,8 +854,8 @@ smp_fetch_res_comp_algo(const struct arg *args, struct sample *smp, const char *
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
smp->data.data.str.str = smp->strm->comp_algo->cfg_name;
smp->data.data.str.len = smp->strm->comp_algo->cfg_name_len;
smp->data.u.str.str = smp->strm->comp_algo->cfg_name;
smp->data.u.str.len = smp->strm->comp_algo->cfg_name_len;
return 1;
}

8
src/da.c
View File

@ -147,8 +147,8 @@ static int da_haproxy(const struct arg *args, struct sample *smp, void *private)
tmp = get_trash_chunk();
chunk_reset(tmp);
i = smp->data.data.str.len > sizeof(useragentbuf) ? sizeof(useragentbuf) : smp->data.data.str.len;
memcpy(useragentbuf, smp->data.data.str.str, i - 1);
i = smp->data.u.str.len > sizeof(useragentbuf) ? sizeof(useragentbuf) : smp->data.u.str.len;
memcpy(useragentbuf, smp->data.u.str.str, i - 1);
useragentbuf[i - 1] = 0;
useragent = (const char *)useragentbuf;
@ -211,8 +211,8 @@ static int da_haproxy(const struct arg *args, struct sample *smp, void *private)
tmp->str[tmp->len] = 0;
}
smp->data.data.str.str = tmp->str;
smp->data.data.str.len = strlen(tmp->str);
smp->data.u.str.str = tmp->str;
smp->data.u.str.len = strlen(tmp->str);
return 1;
}

4
src/dumpstats.c
View File

@ -5635,8 +5635,8 @@ static int stats_map_lookup(struct stream_interface *si)
/* execute pattern matching */
sample.data.type = SMP_T_STR;
sample.flags |= SMP_F_CONST;
sample.data.data.str.len = appctx->ctx.map.chunk.len;
sample.data.data.str.str = appctx->ctx.map.chunk.str;
sample.data.u.str.len = appctx->ctx.map.chunk.len;
sample.data.u.str.str = appctx->ctx.map.chunk.str;
if (appctx->ctx.map.expr->pat_head->match &&
sample_convert(&sample, appctx->ctx.map.expr->pat_head->expect_type))
pat = appctx->ctx.map.expr->pat_head->match(&sample, appctx->ctx.map.expr, 1);

6
src/frontend.c
View File

@ -163,7 +163,7 @@ smp_fetch_fe_id(const struct arg *args, struct sample *smp, const char *kw, void
{
smp->flags = SMP_F_VOL_SESS;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = smp->sess->fe->uuid;
smp->data.u.sint = smp->sess->fe->uuid;
return 1;
}
@ -176,7 +176,7 @@ smp_fetch_fe_sess_rate(const struct arg *args, struct sample *smp, const char *k
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = read_freq_ctr(&args->data.prx->fe_sess_per_sec);
smp->data.u.sint = read_freq_ctr(&args->data.prx->fe_sess_per_sec);
return 1;
}
@ -189,7 +189,7 @@ smp_fetch_fe_conn(const struct arg *args, struct sample *smp, const char *kw, vo
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = args->data.prx->feconn;
smp->data.u.sint = args->data.prx->feconn;
return 1;
}

32
src/hlua.c
View File

@ -385,16 +385,16 @@ static int hlua_smp2lua(lua_State *L, struct sample *smp)
switch (smp->data.type) {
case SMP_T_SINT:
case SMP_T_BOOL:
lua_pushinteger(L, smp->data.data.sint);
lua_pushinteger(L, smp->data.u.sint);
break;
case SMP_T_BIN:
case SMP_T_STR:
lua_pushlstring(L, smp->data.data.str.str, smp->data.data.str.len);
lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
break;
case SMP_T_METH:
switch (smp->data.data.meth.meth) {
switch (smp->data.u.meth.meth) {
case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
@ -404,7 +404,7 @@ static int hlua_smp2lua(lua_State *L, struct sample *smp)
case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
case HTTP_METH_OTHER:
lua_pushlstring(L, smp->data.data.meth.str.str, smp->data.data.meth.str.len);
lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
break;
default:
lua_pushnil(L);
@ -417,7 +417,7 @@ static int hlua_smp2lua(lua_State *L, struct sample *smp)
case SMP_T_ADDR: /* This type is never used to qualify a sample. */
if (sample_casts[smp->data.type][SMP_T_STR] &&
sample_casts[smp->data.type][SMP_T_STR](smp))
lua_pushlstring(L, smp->data.data.str.str, smp->data.data.str.len);
lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
else
lua_pushnil(L);
break;
@ -438,11 +438,11 @@ static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
case SMP_T_BIN:
case SMP_T_STR:
lua_pushlstring(L, smp->data.data.str.str, smp->data.data.str.len);
lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
break;
case SMP_T_METH:
switch (smp->data.data.meth.meth) {
switch (smp->data.u.meth.meth) {
case HTTP_METH_OPTIONS: lua_pushstring(L, "OPTIONS"); break;
case HTTP_METH_GET: lua_pushstring(L, "GET"); break;
case HTTP_METH_HEAD: lua_pushstring(L, "HEAD"); break;
@ -452,7 +452,7 @@ static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
case HTTP_METH_TRACE: lua_pushstring(L, "TRACE"); break;
case HTTP_METH_CONNECT: lua_pushstring(L, "CONNECT"); break;
case HTTP_METH_OTHER:
lua_pushlstring(L, smp->data.data.meth.str.str, smp->data.data.meth.str.len);
lua_pushlstring(L, smp->data.u.meth.str.str, smp->data.u.meth.str.len);
break;
default:
lua_pushstring(L, "");
@ -467,7 +467,7 @@ static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
case SMP_T_ADDR: /* This type is never used to qualify a sample. */
if (sample_casts[smp->data.type][SMP_T_STR] &&
sample_casts[smp->data.type][SMP_T_STR](smp))
lua_pushlstring(L, smp->data.data.str.str, smp->data.data.str.len);
lua_pushlstring(L, smp->data.u.str.str, smp->data.u.str.len);
else
lua_pushstring(L, "");
break;
@ -488,19 +488,19 @@ static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
case LUA_TNUMBER:
smp->data.type = SMP_T_SINT;
smp->data.data.sint = lua_tointeger(L, ud);
smp->data.u.sint = lua_tointeger(L, ud);
break;
case LUA_TBOOLEAN:
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = lua_toboolean(L, ud);
smp->data.u.sint = lua_toboolean(L, ud);
break;
case LUA_TSTRING:
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
smp->data.data.str.str = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.data.str.len);
smp->data.u.str.str = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.u.str.len);
break;
case LUA_TUSERDATA:
@ -510,7 +510,7 @@ static int hlua_lua2smp(lua_State *L, int ud, struct sample *smp)
case LUA_TTHREAD:
case LUA_TLIGHTUSERDATA:
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
break;
}
return 1;
@ -1370,12 +1370,12 @@ __LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
desc = MAY_LJMP(hlua_checkmap(L, 1));
if (desc->pat.expect_type == SMP_T_SINT) {
smp.data.type = SMP_T_SINT;
smp.data.data.sint = MAY_LJMP(luaL_checkinteger(L, 2));
smp.data.u.sint = MAY_LJMP(luaL_checkinteger(L, 2));
}
else {
smp.data.type = SMP_T_STR;
smp.flags = SMP_F_CONST;
smp.data.data.str.str = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.data.str.len));
smp.data.u.str.str = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.u.str.len));
}
pat = pattern_exec_match(&desc->pat, &smp, 1);
@ -1388,7 +1388,7 @@ __LJMP static inline int _hlua_map_lookup(struct lua_State *L, int str)
}
/* The Lua pattern must return a string, so we can't check the returned type */
lua_pushlstring(L, pat->data->data.str.str, pat->data->data.str.len);
lua_pushlstring(L, pat->data->u.str.str, pat->data->u.str.len);
return 1;
}

4
src/listener.c
View File

@ -594,7 +594,7 @@ static int
smp_fetch_dconn(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_SINT;
smp->data.data.sint = smp->sess->listener->nbconn;
smp->data.u.sint = smp->sess->listener->nbconn;
return 1;
}
@ -603,7 +603,7 @@ static int
smp_fetch_so_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_SINT;
smp->data.data.sint = smp->sess->listener->luid;
smp->data.u.sint = smp->sess->listener->luid;
return 1;
}

4
src/log.c
View File

@ -993,9 +993,9 @@ int build_logline(struct stream *s, char *dst, size_t maxsize, struct list *list
key = sample_fetch_as_type(be, sess, s, SMP_OPT_DIR_RES|SMP_OPT_FINAL, tmp->expr, SMP_T_STR);
if (tmp->options & LOG_OPT_HTTP)
ret = encode_chunk(tmplog, dst + maxsize,
'%', http_encode_map, key ? &key->data.data.str : &empty);
'%', http_encode_map, key ? &key->data.u.str : &empty);
else
ret = lf_text_len(tmplog, key ? key->data.data.str.str : NULL, key ? key->data.data.str.len : 0, dst + maxsize - tmplog, tmp);
ret = lf_text_len(tmplog, key ? key->data.u.str.str : NULL, key ? key->data.u.str.len : 0, dst + maxsize - tmplog, tmp);
if (ret == 0)
goto out;
tmplog = ret;

24
src/map.c
View File

@ -29,7 +29,7 @@
*/
int map_parse_ip(const char *text, struct sample_data *data)
{
if (!buf2ip(text, strlen(text), &data->data.ipv4))
if (!buf2ip(text, strlen(text), &data->u.ipv4))
return 0;
data->type = SMP_T_IPV4;
return 1;
@ -40,7 +40,7 @@ int map_parse_ip(const char *text, struct sample_data *data)
*/
int map_parse_ip6(const char *text, struct sample_data *data)
{
if (!buf2ip6(text, strlen(text), &data->data.ipv6))
if (!buf2ip6(text, strlen(text), &data->u.ipv6))
return 0;
data->type = SMP_T_IPV6;
return 1;
@ -54,9 +54,9 @@ int map_parse_ip6(const char *text, struct sample_data *data)
*/
int map_parse_str(const char *text, struct sample_data *data)
{
data->data.str.str = (char *)text;
data->data.str.len = strlen(text);
data->data.str.size = data->data.str.len + 1;
data->u.str.str = (char *)text;
data->u.str.len = strlen(text);
data->u.str.size = data->u.str.len + 1;
data->type = SMP_T_STR;
return 1;
}
@ -68,7 +68,7 @@ int map_parse_str(const char *text, struct sample_data *data)
int map_parse_int(const char *text, struct sample_data *data)
{
data->type = SMP_T_SINT;
data->data.sint = read_int64(&text, text + strlen(text));
data->u.sint = read_int64(&text, text + strlen(text));
if (*text != '\0')
return 0;
return 1;
@ -163,13 +163,13 @@ static int sample_conv_map(const struct arg *arg_p, struct sample *smp, void *pr
if (pat->data) {
smp->data.type = pat->data->type;
smp->flags |= SMP_F_CONST;
memcpy(&smp->data.data, &pat->data->data, sizeof(smp->data.data));
memcpy(&smp->data.u, &pat->data->u, sizeof(smp->data.u));
return 1;
}
/* Return just int sample containing 1. */
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 1;
smp->data.u.sint = 1;
return 1;
}
@ -183,22 +183,22 @@ static int sample_conv_map(const struct arg *arg_p, struct sample *smp, void *pr
case SMP_T_STR:
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
smp->data.data.str = arg_p[1].data.str;
smp->data.u.str = arg_p[1].data.str;
break;
case SMP_T_SINT:
smp->data.type = SMP_T_SINT;
smp->data.data.sint = arg_p[1].data.sint;
smp->data.u.sint = arg_p[1].data.sint;
break;
case SMP_T_IPV4:
smp->data.type = SMP_T_IPV4;
smp->data.data.ipv4 = arg_p[1].data.ipv4;
smp->data.u.ipv4 = arg_p[1].data.ipv4;
break;
case SMP_T_IPV6:
smp->data.type = SMP_T_IPV6;
smp->data.data.ipv6 = arg_p[1].data.ipv6;
smp->data.u.ipv6 = arg_p[1].data.ipv6;
break;
}

118
src/pattern.c
View File

@ -425,7 +425,7 @@ int pat_parse_ip(const char *text, struct pattern *pattern, int mflags, char **e
/* always return false */
struct pattern *pat_match_nothing(struct sample *smp, struct pattern_expr *expr, int fill)
{
if (smp->data.data.sint) {
if (smp->data.u.sint) {
if (fill) {
static_pattern.data = NULL;
static_pattern.ref = NULL;
@ -454,12 +454,12 @@ struct pattern *pat_match_str(struct sample *smp, struct pattern_expr *expr, int
/* Lookup a string in the expression's pattern tree. */
if (!eb_is_empty(&expr->pattern_tree)) {
/* we may have to force a trailing zero on the test pattern */
prev = smp->data.data.str.str[smp->data.data.str.len];
prev = smp->data.u.str.str[smp->data.u.str.len];
if (prev)
smp->data.data.str.str[smp->data.data.str.len] = '\0';
node = ebst_lookup(&expr->pattern_tree, smp->data.data.str.str);
smp->data.u.str.str[smp->data.u.str.len] = '\0';
node = ebst_lookup(&expr->pattern_tree, smp->data.u.str.str);
if (prev)
smp->data.data.str.str[smp->data.data.str.len] = prev;
smp->data.u.str.str[smp->data.u.str.len] = prev;
if (node) {
if (fill) {
@ -478,7 +478,7 @@ struct pattern *pat_match_str(struct sample *smp, struct pattern_expr *expr, int
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.str.len, seed),
lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
pat_lru_tree, expr, expr->revision);
if (lru && lru->domain)
return lru->data;
@ -487,12 +487,12 @@ struct pattern *pat_match_str(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if (pattern->len != smp->data.data.str.len)
if (pattern->len != smp->data.u.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
if ((icase && strncasecmp(pattern->ptr.str, smp->data.data.str.str, smp->data.data.str.len) == 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.data.str.str, smp->data.data.str.len) == 0)) {
if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.str, smp->data.u.str.len) == 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.u.str.str, smp->data.u.str.len) == 0)) {
ret = pattern;
break;
}
@ -515,7 +515,7 @@ struct pattern *pat_match_bin(struct sample *smp, struct pattern_expr *expr, int
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.str.len, seed),
lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
pat_lru_tree, expr, expr->revision);
if (lru && lru->domain)
return lru->data;
@ -524,10 +524,10 @@ struct pattern *pat_match_bin(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if (pattern->len != smp->data.data.str.len)
if (pattern->len != smp->data.u.str.len)
continue;
if (memcmp(pattern->ptr.str, smp->data.data.str.str, smp->data.data.str.len) == 0) {
if (memcmp(pattern->ptr.str, smp->data.u.str.str, smp->data.u.str.len) == 0) {
ret = pattern;
break;
}
@ -552,7 +552,7 @@ struct pattern *pat_match_reg(struct sample *smp, struct pattern_expr *expr, int
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.str.len, seed),
lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
pat_lru_tree, expr, expr->revision);
if (lru && lru->domain)
return lru->data;
@ -561,7 +561,7 @@ struct pattern *pat_match_reg(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if (regex_exec2(pattern->ptr.reg, smp->data.data.str.str, smp->data.data.str.len)) {
if (regex_exec2(pattern->ptr.reg, smp->data.u.str.str, smp->data.u.str.len)) {
ret = pattern;
break;
}
@ -588,12 +588,12 @@ struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int
/* Lookup a string in the expression's pattern tree. */
if (!eb_is_empty(&expr->pattern_tree)) {
/* we may have to force a trailing zero on the test pattern */
prev = smp->data.data.str.str[smp->data.data.str.len];
prev = smp->data.u.str.str[smp->data.u.str.len];
if (prev)
smp->data.data.str.str[smp->data.data.str.len] = '\0';
node = ebmb_lookup_longest(&expr->pattern_tree, smp->data.data.str.str);
smp->data.u.str.str[smp->data.u.str.len] = '\0';
node = ebmb_lookup_longest(&expr->pattern_tree, smp->data.u.str.str);
if (prev)
smp->data.data.str.str[smp->data.data.str.len] = prev;
smp->data.u.str.str[smp->data.u.str.len] = prev;
if (node) {
if (fill) {
@ -612,7 +612,7 @@ struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.str.len, seed),
lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
pat_lru_tree, expr, expr->revision);
if (lru && lru->domain)
return lru->data;
@ -621,12 +621,12 @@ struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if (pattern->len > smp->data.data.str.len)
if (pattern->len > smp->data.u.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
if ((icase && strncasecmp(pattern->ptr.str, smp->data.data.str.str, pattern->len) != 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.data.str.str, pattern->len) != 0))
if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.str, pattern->len) != 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.u.str.str, pattern->len) != 0))
continue;
ret = pattern;
@ -651,7 +651,7 @@ struct pattern *pat_match_end(struct sample *smp, struct pattern_expr *expr, int
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.str.len, seed),
lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
pat_lru_tree, expr, expr->revision);
if (lru && lru->domain)
return lru->data;
@ -660,12 +660,12 @@ struct pattern *pat_match_end(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if (pattern->len > smp->data.data.str.len)
if (pattern->len > smp->data.u.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
if ((icase && strncasecmp(pattern->ptr.str, smp->data.data.str.str + smp->data.data.str.len - pattern->len, pattern->len) != 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.data.str.str + smp->data.data.str.len - pattern->len, pattern->len) != 0))
if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.str + smp->data.u.str.len - pattern->len, pattern->len) != 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.u.str.str + smp->data.u.str.len - pattern->len, pattern->len) != 0))
continue;
ret = pattern;
@ -694,7 +694,7 @@ struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.str.len, seed),
lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
pat_lru_tree, expr, expr->revision);
if (lru && lru->domain)
return lru->data;
@ -703,13 +703,13 @@ struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if (pattern->len > smp->data.data.str.len)
if (pattern->len > smp->data.u.str.len)
continue;
end = smp->data.data.str.str + smp->data.data.str.len - pattern->len;
end = smp->data.u.str.str + smp->data.u.str.len - pattern->len;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
if (icase) {
for (c = smp->data.data.str.str; c <= end; c++) {
for (c = smp->data.u.str.str; c <= end; c++) {
if (tolower(*c) != tolower(*pattern->ptr.str))
continue;
if (strncasecmp(pattern->ptr.str, c, pattern->len) == 0) {
@ -718,7 +718,7 @@ struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int
}
}
} else {
for (c = smp->data.data.str.str; c <= end; c++) {
for (c = smp->data.u.str.str; c <= end; c++) {
if (*c != *pattern->ptr.str)
continue;
if (strncmp(pattern->ptr.str, c, pattern->len) == 0) {
@ -759,13 +759,13 @@ static int match_word(struct sample *smp, struct pattern *pattern, int mflags, u
while (pl > 0 && is_delimiter(ps[pl - 1], delimiters))
pl--;
if (pl > smp->data.data.str.len)
if (pl > smp->data.u.str.len)
return PAT_NOMATCH;
may_match = 1;
icase = mflags & PAT_MF_IGNORE_CASE;
end = smp->data.data.str.str + smp->data.data.str.len - pl;
for (c = smp->data.data.str.str; c <= end; c++) {
end = smp->data.u.str.str + smp->data.u.str.len - pl;
for (c = smp->data.u.str.str; c <= end; c++) {
if (is_delimiter(*c, delimiters)) {
may_match = 1;
continue;
@ -832,8 +832,8 @@ struct pattern *pat_match_int(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.data.sint) &&
(!pattern->val.range.max_set || smp->data.data.sint <= pattern->val.range.max))
if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.sint) &&
(!pattern->val.range.max_set || smp->data.u.sint <= pattern->val.range.max))
return pattern;
}
return NULL;
@ -847,8 +847,8 @@ struct pattern *pat_match_len(struct sample *smp, struct pattern_expr *expr, int
list_for_each_entry(lst, &expr->patterns, list) {
pattern = &lst->pat;
if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.data.str.len) &&
(!pattern->val.range.max_set || smp->data.data.str.len <= pattern->val.range.max))
if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.str.len) &&
(!pattern->val.range.max_set || smp->data.u.str.len <= pattern->val.range.max))
return pattern;
}
return NULL;
@ -869,7 +869,7 @@ struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int
/* Lookup an IPv4 address in the expression's pattern tree using
* the longest match method.
*/
s = &smp->data.data.ipv4;
s = &smp->data.u.ipv4;
node = ebmb_lookup_longest(&expr->pattern_tree, &s->s_addr);
if (node) {
if (fill) {
@ -891,7 +891,7 @@ struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int
*/
memset(&tmp6, 0, 10);
*(uint16_t*)&tmp6.s6_addr[10] = htons(0xffff);
*(uint32_t*)&tmp6.s6_addr[12] = smp->data.data.ipv4.s_addr;
*(uint32_t*)&tmp6.s6_addr[12] = smp->data.u.ipv4.s_addr;
node = ebmb_lookup_longest(&expr->pattern_tree_2, &tmp6);
if (node) {
if (fill) {
@ -912,7 +912,7 @@ struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int
/* Lookup an IPv6 address in the expression's pattern tree using
* the longest match method.
*/
node = ebmb_lookup_longest(&expr->pattern_tree_2, &smp->data.data.ipv6);
node = ebmb_lookup_longest(&expr->pattern_tree_2, &smp->data.u.ipv6);
if (node) {
if (fill) {
elt = ebmb_entry(node, struct pattern_tree, node);
@ -932,16 +932,16 @@ struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int
* - ::0000:ip:v4 (old ipv4 mapped)
* - 2002:ip:v4:: (6to4)
*/
if ((*(uint32_t*)&smp->data.data.ipv6.s6_addr[0] == 0 &&
*(uint32_t*)&smp->data.data.ipv6.s6_addr[4] == 0 &&
(*(uint32_t*)&smp->data.data.ipv6.s6_addr[8] == 0 ||
*(uint32_t*)&smp->data.data.ipv6.s6_addr[8] == htonl(0xFFFF))) ||
*(uint16_t*)&smp->data.data.ipv6.s6_addr[0] == htons(0x2002)) {
if (*(uint32_t*)&smp->data.data.ipv6.s6_addr[0] == 0)
v4 = *(uint32_t*)&smp->data.data.ipv6.s6_addr[12];
if ((*(uint32_t*)&smp->data.u.ipv6.s6_addr[0] == 0 &&
*(uint32_t*)&smp->data.u.ipv6.s6_addr[4] == 0 &&
(*(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == 0 ||
*(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == htonl(0xFFFF))) ||
*(uint16_t*)&smp->data.u.ipv6.s6_addr[0] == htons(0x2002)) {
if (*(uint32_t*)&smp->data.u.ipv6.s6_addr[0] == 0)
v4 = *(uint32_t*)&smp->data.u.ipv6.s6_addr[12];
else
v4 = htonl((ntohs(*(uint16_t*)&smp->data.data.ipv6.s6_addr[2]) << 16) +
ntohs(*(uint16_t*)&smp->data.data.ipv6.s6_addr[4]));
v4 = htonl((ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[2]) << 16) +
ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[4]));
/* Lookup an IPv4 address in the expression's pattern tree using the longest
* match method.
@ -969,7 +969,7 @@ struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int
/* The input sample is IPv4, use it as is. */
if (smp->data.type == SMP_T_IPV4) {
v4 = smp->data.data.ipv4.s_addr;
v4 = smp->data.u.ipv4.s_addr;
}
else if (smp->data.type == SMP_T_IPV6) {
/* v4 match on a V6 sample. We want to check at least for
@ -978,15 +978,15 @@ struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int
* - ::0000:ip:v4 (old ipv4 mapped)
* - 2002:ip:v4:: (6to4)
*/
if (*(uint32_t*)&smp->data.data.ipv6.s6_addr[0] == 0 &&
*(uint32_t*)&smp->data.data.ipv6.s6_addr[4] == 0 &&
(*(uint32_t*)&smp->data.data.ipv6.s6_addr[8] == 0 ||
*(uint32_t*)&smp->data.data.ipv6.s6_addr[8] == htonl(0xFFFF))) {
v4 = *(uint32_t*)&smp->data.data.ipv6.s6_addr[12];
if (*(uint32_t*)&smp->data.u.ipv6.s6_addr[0] == 0 &&
*(uint32_t*)&smp->data.u.ipv6.s6_addr[4] == 0 &&
(*(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == 0 ||
*(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == htonl(0xFFFF))) {
v4 = *(uint32_t*)&smp->data.u.ipv6.s6_addr[12];
}
else if (*(uint16_t*)&smp->data.data.ipv6.s6_addr[0] == htons(0x2002)) {
v4 = htonl((ntohs(*(uint16_t*)&smp->data.data.ipv6.s6_addr[2]) << 16) +
ntohs(*(uint16_t*)&smp->data.data.ipv6.s6_addr[4]));
else if (*(uint16_t*)&smp->data.u.ipv6.s6_addr[0] == htons(0x2002)) {
v4 = htonl((ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[2]) << 16) +
ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[4]));
}
else
continue;

26
src/payload.c
View File

@ -36,7 +36,7 @@ smp_fetch_wait_end(const struct arg *args, struct sample *smp, const char *kw, v
return 0;
}
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = 1;
smp->data.u.sint = 1;
return 1;
}
@ -51,7 +51,7 @@ smp_fetch_len(const struct arg *args, struct sample *smp, const char *kw, void *
return 0;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = chn->buf->i;
smp->data.u.sint = chn->buf->i;
smp->flags = SMP_F_VOLATILE | SMP_F_MAY_CHANGE;
return 1;
}
@ -160,7 +160,7 @@ smp_fetch_req_ssl_ec_ext(const struct arg *args, struct sample *smp, const char
/* Elliptic curves extension */
if (ext_type == 10) {
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = 1;
smp->data.u.sint = 1;
smp->flags = SMP_F_VOLATILE;
return 1;
}
@ -225,7 +225,7 @@ smp_fetch_ssl_hello_type(const struct arg *args, struct sample *smp, const char
}
smp->data.type = SMP_T_SINT;
smp->data.data.sint = hs_type;
smp->data.u.sint = hs_type;
smp->flags = SMP_F_VOLATILE;
return 1;
@ -339,7 +339,7 @@ smp_fetch_req_ssl_ver(const struct arg *args, struct sample *smp, const char *kw
* the protocol version.
*/
smp->data.type = SMP_T_SINT;
smp->data.data.sint = version;
smp->data.u.sint = version;
smp->flags = SMP_F_VOLATILE;
return 1;
@ -493,8 +493,8 @@ smp_fetch_ssl_hello_sni(const struct arg *args, struct sample *smp, const char *
if (name_type == 0) { /* hostname */
smp->data.type = SMP_T_STR;
smp->data.data.str.str = (char *)data + 9;
smp->data.data.str.len = name_len;
smp->data.u.str.str = (char *)data + 9;
smp->data.u.str.len = name_len;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
return 1;
}
@ -580,8 +580,8 @@ fetch_rdp_cookie_name(struct stream *s, struct sample *smp, const char *cname, i
}
/* data points to cookie value */
smp->data.data.str.str = (char *)data;
smp->data.data.str.len = 0;
smp->data.u.str.str = (char *)data;
smp->data.u.str.len = 0;
while (bleft > 0 && *data != '\r') {
data++;
@ -594,7 +594,7 @@ fetch_rdp_cookie_name(struct stream *s, struct sample *smp, const char *cname, i
if (data[0] != '\r' || data[1] != '\n')
goto not_cookie;
smp->data.data.str.len = (char *)data - smp->data.data.str.str;
smp->data.u.str.len = (char *)data - smp->data.u.str.str;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
return 1;
@ -629,7 +629,7 @@ smp_fetch_rdp_cookie_cnt(const struct arg *args, struct sample *smp, const char
smp->flags = SMP_F_VOLATILE;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = ret;
smp->data.u.sint = ret;
return 1;
}
@ -682,7 +682,7 @@ smp_fetch_payload_lv(const struct arg *arg_p, struct sample *smp, const char *kw
/* init chunk as read only */
smp->data.type = SMP_T_BIN;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
chunk_initlen(&smp->data.data.str, chn->buf->p + buf_offset, 0, buf_size);
chunk_initlen(&smp->data.u.str, chn->buf->p + buf_offset, 0, buf_size);
return 1;
too_short:
@ -714,7 +714,7 @@ smp_fetch_payload(const struct arg *arg_p, struct sample *smp, const char *kw, v
/* init chunk as read only */
smp->data.type = SMP_T_BIN;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
chunk_initlen(&smp->data.data.str, chn->buf->p + buf_offset, 0, buf_size ? buf_size : (chn->buf->i - buf_offset));
chunk_initlen(&smp->data.u.str, chn->buf->p + buf_offset, 0, buf_size ? buf_size : (chn->buf->i - buf_offset));
if (!buf_size && channel_may_recv(chn) && !channel_input_closed(chn))
smp->flags |= SMP_F_MAY_CHANGE;

222
src/proto_http.c
View File

@ -3684,11 +3684,11 @@ resume_execution:
if (smp) {
if (smp->data.type == SMP_T_IPV4) {
((struct sockaddr_in *)&cli_conn->addr.from)->sin_family = AF_INET;
((struct sockaddr_in *)&cli_conn->addr.from)->sin_addr.s_addr = smp->data.data.ipv4.s_addr;
((struct sockaddr_in *)&cli_conn->addr.from)->sin_addr.s_addr = smp->data.u.ipv4.s_addr;
((struct sockaddr_in *)&cli_conn->addr.from)->sin_port = 0;
} else if (smp->data.type == SMP_T_IPV6) {
((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_family = AF_INET6;
memcpy(&((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_addr, &smp->data.data.ipv6, sizeof(struct in6_addr));
memcpy(&((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_addr, &smp->data.u.ipv6, sizeof(struct in6_addr));
((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_port = 0;
}
}
@ -9987,7 +9987,7 @@ smp_prefetch_http(struct proxy *px, struct stream *s, unsigned int opt,
if (unlikely(s->req.buf->i + s->req.buf->p >
s->req.buf->data + s->req.buf->size - global.tune.maxrewrite)) {
msg->msg_state = HTTP_MSG_ERROR;
smp->data.data.sint = 1;
smp->data.u.sint = 1;
return 1;
}
@ -10014,7 +10014,7 @@ smp_prefetch_http(struct proxy *px, struct stream *s, unsigned int opt,
}
/* everything's OK */
smp->data.data.sint = 1;
smp->data.u.sint = 1;
return 1;
}
@ -10069,14 +10069,14 @@ smp_fetch_meth(const struct arg *args, struct sample *smp, const char *kw, void
meth = txn->meth;
smp->data.type = SMP_T_METH;
smp->data.data.meth.meth = meth;
smp->data.u.meth.meth = meth;
if (meth == HTTP_METH_OTHER) {
if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
/* ensure the indexes are not affected */
return 0;
smp->flags |= SMP_F_CONST;
smp->data.data.meth.str.len = txn->req.sl.rq.m_l;
smp->data.data.meth.str.str = txn->req.chn->buf->p;
smp->data.u.meth.str.len = txn->req.sl.rq.m_l;
smp->data.u.meth.str.str = txn->req.chn->buf->p;
}
smp->flags |= SMP_F_VOL_1ST;
return 1;
@ -10094,19 +10094,19 @@ static struct pattern *pat_match_meth(struct sample *smp, struct pattern_expr *e
/* well-known method */
if (pattern->val.i != HTTP_METH_OTHER) {
if (smp->data.data.meth.meth == pattern->val.i)
if (smp->data.u.meth.meth == pattern->val.i)
return pattern;
else
continue;
}
/* Other method, we must compare the strings */
if (pattern->len != smp->data.data.meth.str.len)
if (pattern->len != smp->data.u.meth.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
if ((icase && strncasecmp(pattern->ptr.str, smp->data.data.meth.str.str, smp->data.data.meth.str.len) == 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.data.meth.str.str, smp->data.data.meth.str.len) == 0))
if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.meth.str.str, smp->data.u.meth.str.len) == 0) ||
(!icase && strncmp(pattern->ptr.str, smp->data.u.meth.str.str, smp->data.u.meth.str.len) == 0))
return pattern;
}
return NULL;
@ -10129,8 +10129,8 @@ smp_fetch_rqver(const struct arg *args, struct sample *smp, const char *kw, void
return 0;
smp->data.type = SMP_T_STR;
smp->data.data.str.str = ptr;
smp->data.data.str.len = len;
smp->data.u.str.str = ptr;
smp->data.u.str.len = len;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
@ -10157,8 +10157,8 @@ smp_fetch_stver(const struct arg *args, struct sample *smp, const char *kw, void
return 0;
smp->data.type = SMP_T_STR;
smp->data.data.str.str = ptr;
smp->data.data.str.len = len;
smp->data.u.str.str = ptr;
smp->data.u.str.len = len;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
@ -10182,7 +10182,7 @@ smp_fetch_stcode(const struct arg *args, struct sample *smp, const char *kw, voi
ptr = txn->rsp.chn->buf->p + txn->rsp.sl.st.c;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = __strl2ui(ptr, len);
smp->data.u.sint = __strl2ui(ptr, len);
smp->flags = SMP_F_VOL_1ST;
return 1;
}
@ -10217,8 +10217,8 @@ smp_fetch_body(const struct arg *args, struct sample *smp, const char *kw, void
if (block1 == len) {
/* buffer is not wrapped (or empty) */
smp->data.type = SMP_T_BIN;
smp->data.data.str.str = body;
smp->data.data.str.len = len;
smp->data.u.str.str = body;
smp->data.u.str.len = len;
smp->flags = SMP_F_VOL_TEST | SMP_F_CONST;
}
else {
@ -10227,8 +10227,8 @@ smp_fetch_body(const struct arg *args, struct sample *smp, const char *kw, void
memcpy(temp->str, body, block1);
memcpy(temp->str + block1, msg->chn->buf->data, len - block1);
smp->data.type = SMP_T_BIN;
smp->data.data.str.str = temp->str;
smp->data.data.str.len = len;
smp->data.u.str.str = temp->str;
smp->data.u.str.len = len;
smp->flags = SMP_F_VOL_TEST;
}
return 1;
@ -10252,7 +10252,7 @@ smp_fetch_body_len(const struct arg *args, struct sample *smp, const char *kw, v
msg = &txn->rsp;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = http_body_bytes(msg);
smp->data.u.sint = http_body_bytes(msg);
smp->flags = SMP_F_VOL_TEST;
return 1;
@ -10277,7 +10277,7 @@ smp_fetch_body_size(const struct arg *args, struct sample *smp, const char *kw,
msg = &txn->rsp;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = msg->body_len;
smp->data.u.sint = msg->body_len;
smp->flags = SMP_F_VOL_TEST;
return 1;
@ -10294,8 +10294,8 @@ smp_fetch_url(const struct arg *args, struct sample *smp, const char *kw, void *
txn = smp->strm->txn;
smp->data.type = SMP_T_STR;
smp->data.data.str.len = txn->req.sl.rq.u_l;
smp->data.data.str.str = txn->req.chn->buf->p + txn->req.sl.rq.u;
smp->data.u.str.len = txn->req.sl.rq.u_l;
smp->data.u.str.str = txn->req.chn->buf->p + txn->req.sl.rq.u;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
}
@ -10314,7 +10314,7 @@ smp_fetch_url_ip(const struct arg *args, struct sample *smp, const char *kw, voi
return 0;
smp->data.type = SMP_T_IPV4;
smp->data.data.ipv4 = ((struct sockaddr_in *)&addr)->sin_addr;
smp->data.u.ipv4 = ((struct sockaddr_in *)&addr)->sin_addr;
smp->flags = 0;
return 1;
}
@ -10333,7 +10333,7 @@ smp_fetch_url_port(const struct arg *args, struct sample *smp, const char *kw, v
return 0;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = ntohs(((struct sockaddr_in *)&addr)->sin_port);
smp->data.u.sint = ntohs(((struct sockaddr_in *)&addr)->sin_port);
smp->flags = 0;
return 1;
}
@ -10391,7 +10391,7 @@ smp_fetch_fhdr(const struct arg *args, struct sample *smp, const char *kw, void
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_VOL_HDR | SMP_F_CONST;
if (http_get_fhdr(msg, name_str, name_len, idx, occ, ctx, &smp->data.data.str.str, &smp->data.data.str.len))
if (http_get_fhdr(msg, name_str, name_len, idx, occ, ctx, &smp->data.u.str.str, &smp->data.u.str.len))
return 1;
smp->flags &= ~SMP_F_NOT_LAST;
@ -10428,7 +10428,7 @@ smp_fetch_fhdr_cnt(const struct arg *args, struct sample *smp, const char *kw, v
cnt++;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = cnt;
smp->data.u.sint = cnt;
smp->flags = SMP_F_VOL_HDR;
return 1;
}
@ -10461,8 +10461,8 @@ smp_fetch_hdr_names(const struct arg *args, struct sample *smp, const char *kw,
}
smp->data.type = SMP_T_STR;
smp->data.data.str.str = temp->str;
smp->data.data.str.len = temp->len;
smp->data.u.str.str = temp->str;
smp->data.u.str.len = temp->len;
smp->flags = SMP_F_VOL_HDR;
return 1;
}
@ -10519,7 +10519,7 @@ smp_fetch_hdr(const struct arg *args, struct sample *smp, const char *kw, void *
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_VOL_HDR | SMP_F_CONST;
if (http_get_hdr(msg, name_str, name_len, idx, occ, ctx, &smp->data.data.str.str, &smp->data.data.str.len))
if (http_get_hdr(msg, name_str, name_len, idx, occ, ctx, &smp->data.u.str.str, &smp->data.u.str.len))
return 1;
smp->flags &= ~SMP_F_NOT_LAST;
@ -10555,7 +10555,7 @@ smp_fetch_hdr_cnt(const struct arg *args, struct sample *smp, const char *kw, vo
cnt++;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = cnt;
smp->data.u.sint = cnt;
smp->flags = SMP_F_VOL_HDR;
return 1;
}
@ -10572,7 +10572,7 @@ smp_fetch_hdr_val(const struct arg *args, struct sample *smp, const char *kw, vo
if (ret > 0) {
smp->data.type = SMP_T_SINT;
smp->data.data.sint = strl2ic(smp->data.data.str.str, smp->data.data.str.len);
smp->data.u.sint = strl2ic(smp->data.u.str.str, smp->data.u.str.len);
}
return ret;
@ -10588,15 +10588,15 @@ smp_fetch_hdr_ip(const struct arg *args, struct sample *smp, const char *kw, voi
int ret;
while ((ret = smp_fetch_hdr(args, smp, kw, private)) > 0) {
if (url2ipv4((char *)smp->data.data.str.str, &smp->data.data.ipv4)) {
if (url2ipv4((char *)smp->data.u.str.str, &smp->data.u.ipv4)) {
smp->data.type = SMP_T_IPV4;
break;
} else {
struct chunk *temp = get_trash_chunk();
if (smp->data.data.str.len < temp->size - 1) {
memcpy(temp->str, smp->data.data.str.str, smp->data.data.str.len);
temp->str[smp->data.data.str.len] = '\0';
if (inet_pton(AF_INET6, temp->str, &smp->data.data.ipv6)) {
if (smp->data.u.str.len < temp->size - 1) {
memcpy(temp->str, smp->data.u.str.str, smp->data.u.str.len);
temp->str[smp->data.u.str.len] = '\0';
if (inet_pton(AF_INET6, temp->str, &smp->data.u.ipv6)) {
smp->data.type = SMP_T_IPV6;
break;
}
@ -10629,12 +10629,12 @@ smp_fetch_path(const struct arg *args, struct sample *smp, const char *kw, void
/* OK, we got the '/' ! */
smp->data.type = SMP_T_STR;
smp->data.data.str.str = ptr;
smp->data.u.str.str = ptr;
while (ptr < end && *ptr != '?')
ptr++;
smp->data.data.str.len = ptr - smp->data.data.str.str;
smp->data.u.str.len = ptr - smp->data.u.str.str;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
}
@ -10665,8 +10665,8 @@ smp_fetch_base(const struct arg *args, struct sample *smp, const char *kw, void
temp = get_trash_chunk();
memcpy(temp->str, ctx.line + ctx.val, ctx.vlen);
smp->data.type = SMP_T_STR;
smp->data.data.str.str = temp->str;
smp->data.data.str.len = ctx.vlen;
smp->data.u.str.str = temp->str;
smp->data.u.str.len = ctx.vlen;
/* now retrieve the path */
end = txn->req.chn->buf->p + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
@ -10677,8 +10677,8 @@ smp_fetch_base(const struct arg *args, struct sample *smp, const char *kw, void
for (ptr = beg; ptr < end && *ptr != '?'; ptr++);
if (beg < ptr && *beg == '/') {
memcpy(smp->data.data.str.str + smp->data.data.str.len, beg, ptr - beg);
smp->data.data.str.len += ptr - beg;
memcpy(smp->data.u.str.str + smp->data.u.str.len, beg, ptr - beg);
smp->data.u.str.len += ptr - beg;
}
smp->flags = SMP_F_VOL_1ST;
@ -10729,7 +10729,7 @@ smp_fetch_base32(const struct arg *args, struct sample *smp, const char *kw, voi
hash = full_hash(hash);
smp->data.type = SMP_T_SINT;
smp->data.data.sint = hash;
smp->data.u.sint = hash;
smp->flags = SMP_F_VOL_1ST;
return 1;
}
@ -10754,7 +10754,7 @@ smp_fetch_base32_src(const struct arg *args, struct sample *smp, const char *kw,
return 0;
temp = get_trash_chunk();
*(unsigned int *)temp->str = htonl(smp->data.data.sint);
*(unsigned int *)temp->str = htonl(smp->data.u.sint);
temp->len += sizeof(unsigned int);
switch (cli_conn->addr.from.ss_family) {
@ -10770,7 +10770,7 @@ smp_fetch_base32_src(const struct arg *args, struct sample *smp, const char *kw,
return 0;
}
smp->data.data.str = *temp;
smp->data.u.str = *temp;
smp->data.type = SMP_T_BIN;
return 1;
}
@ -10798,8 +10798,8 @@ smp_fetch_query(const struct arg *args, struct sample *smp, const char *kw, void
} while (*ptr++ != '?');
smp->data.type = SMP_T_STR;
smp->data.data.str.str = ptr;
smp->data.data.str.len = end - ptr;
smp->data.u.str.str = ptr;
smp->data.u.str.len = end - ptr;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
}
@ -10814,7 +10814,7 @@ smp_fetch_proto_http(const struct arg *args, struct sample *smp, const char *kw,
CHECK_HTTP_MESSAGE_FIRST_PERM();
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = 1;
smp->data.u.sint = 1;
return 1;
}
@ -10823,7 +10823,7 @@ static int
smp_fetch_http_first_req(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = !(smp->strm->txn->flags & TX_NOT_FIRST);
smp->data.u.sint = !(smp->strm->txn->flags & TX_NOT_FIRST);
return 1;
}
@ -10841,7 +10841,7 @@ smp_fetch_http_auth(const struct arg *args, struct sample *smp, const char *kw,
return 0;
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = check_user(args->data.usr, smp->strm->txn->auth.user,
smp->data.u.sint = check_user(args->data.usr, smp->strm->txn->auth.user,
smp->strm->txn->auth.pass);
return 1;
}
@ -10871,8 +10871,8 @@ smp_fetch_http_auth_grp(const struct arg *args, struct sample *smp, const char *
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
smp->data.data.str.str = smp->strm->txn->auth.user;
smp->data.data.str.len = strlen(smp->strm->txn->auth.user);
smp->data.u.str.str = smp->strm->txn->auth.user;
smp->data.u.str.len = strlen(smp->strm->txn->auth.user);
return 1;
}
@ -10991,8 +10991,8 @@ smp_fetch_capture_header_req(const struct arg *args, struct sample *smp, const c
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
smp->data.data.str.str = smp->strm->req_cap[idx];
smp->data.data.str.len = strlen(smp->strm->req_cap[idx]);
smp->data.u.str.str = smp->strm->req_cap[idx];
smp->data.u.str.len = strlen(smp->strm->req_cap[idx]);
return 1;
}
@ -11016,8 +11016,8 @@ smp_fetch_capture_header_res(const struct arg *args, struct sample *smp, const c
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
smp->data.data.str.str = smp->strm->res_cap[idx];
smp->data.data.str.len = strlen(smp->strm->res_cap[idx]);
smp->data.u.str.str = smp->strm->res_cap[idx];
smp->data.u.str.len = strlen(smp->strm->res_cap[idx]);
return 1;
}
@ -11041,7 +11041,7 @@ smp_fetch_capture_req_method(const struct arg *args, struct sample *smp, const c
temp = get_trash_chunk();
temp->str = txn->uri;
temp->len = ptr - txn->uri;
smp->data.data.str = *temp;
smp->data.u.str = *temp;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
@ -11077,8 +11077,8 @@ smp_fetch_capture_req_uri(const struct arg *args, struct sample *smp, const char
while (*ptr != ' ' && *ptr != '\0') /* find space after URI */
ptr++;
smp->data.data.str = *temp;
smp->data.data.str.len = ptr - temp->str;
smp->data.u.str = *temp;
smp->data.u.str.len = ptr - temp->str;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
@ -11097,11 +11097,11 @@ smp_fetch_capture_req_ver(const struct arg *args, struct sample *smp, const char
return 0;
if (txn->req.flags & HTTP_MSGF_VER_11)
smp->data.data.str.str = "HTTP/1.1";
smp->data.u.str.str = "HTTP/1.1";
else
smp->data.data.str.str = "HTTP/1.0";
smp->data.u.str.str = "HTTP/1.0";
smp->data.data.str.len = 8;
smp->data.u.str.len = 8;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
return 1;
@ -11120,11 +11120,11 @@ smp_fetch_capture_res_ver(const struct arg *args, struct sample *smp, const char
return 0;
if (txn->rsp.flags & HTTP_MSGF_VER_11)
smp->data.data.str.str = "HTTP/1.1";
smp->data.u.str.str = "HTTP/1.1";
else
smp->data.data.str.str = "HTTP/1.0";
smp->data.u.str.str = "HTTP/1.0";
smp->data.data.str.len = 8;
smp->data.u.str.len = 8;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
return 1;
@ -11217,12 +11217,12 @@ int smp_fetch_cookie(const struct arg *args, struct sample *smp, const char *kw,
smp->ctx.a[0] = extract_cookie_value(smp->ctx.a[0], smp->ctx.a[1],
args->data.str.str, args->data.str.len,
(smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ,
&smp->data.data.str.str,
&smp->data.data.str.len);
&smp->data.u.str.str,
&smp->data.u.str.len);
if (smp->ctx.a[0]) {
found = 1;
if (occ >= 0) {
/* one value was returned into smp->data.data.str.{str,len} */
/* one value was returned into smp->data.u.str.{str,len} */
smp->flags |= SMP_F_NOT_LAST;
return 1;
}
@ -11296,14 +11296,14 @@ smp_fetch_cookie_cnt(const struct arg *args, struct sample *smp, const char *kw,
while ((val_beg = extract_cookie_value(val_beg, val_end,
args->data.str.str, args->data.str.len,
(smp->opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ,
&smp->data.data.str.str,
&smp->data.data.str.len))) {
&smp->data.u.str.str,
&smp->data.u.str.len))) {
cnt++;
}
}
smp->data.type = SMP_T_SINT;
smp->data.data.sint = cnt;
smp->data.u.sint = cnt;
smp->flags |= SMP_F_VOL_HDR;
return 1;
}
@ -11318,7 +11318,7 @@ smp_fetch_cookie_val(const struct arg *args, struct sample *smp, const char *kw,
if (ret > 0) {
smp->data.type = SMP_T_SINT;
smp->data.data.sint = strl2ic(smp->data.data.str.str, smp->data.data.str.len);
smp->data.u.sint = strl2ic(smp->data.u.str.str, smp->data.u.str.len);
}
return ret;
@ -11571,12 +11571,12 @@ smp_fetch_param(char delim, const char *name, int name_len, const struct arg *ar
temp = get_trash_chunk();
memcpy(temp->str, vstart, chunks[1] - vstart);
memcpy(temp->str + ( chunks[1] - vstart ), chunks[2], vend - chunks[2]);
smp->data.data.str.str = temp->str;
smp->data.data.str.len = ( chunks[1] - vstart ) + ( vend - chunks[2] );
smp->data.u.str.str = temp->str;
smp->data.u.str.len = ( chunks[1] - vstart ) + ( vend - chunks[2] );
} else {
/* Contiguous case. */
smp->data.data.str.str = (char *)vstart;
smp->data.data.str.len = vend - vstart;
smp->data.u.str.str = (char *)vstart;
smp->data.u.str.len = vend - vstart;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
}
@ -11720,7 +11720,7 @@ smp_fetch_url_param_val(const struct arg *args, struct sample *smp, const char *
if (ret > 0) {
smp->data.type = SMP_T_SINT;
smp->data.data.sint = strl2ic(smp->data.data.str.str, smp->data.data.str.len);
smp->data.u.sint = strl2ic(smp->data.u.str.str, smp->data.u.str.len);
}
return ret;
@ -11772,7 +11772,7 @@ smp_fetch_url32(const struct arg *args, struct sample *smp, const char *kw, void
hash = full_hash(hash);
smp->data.type = SMP_T_SINT;
smp->data.data.sint = hash;
smp->data.u.sint = hash;
smp->flags = SMP_F_VOL_1ST;
return 1;
}
@ -11795,7 +11795,7 @@ smp_fetch_url32_src(const struct arg *args, struct sample *smp, const char *kw,
return 0;
/* The returned hash is a 32 bytes integer. */
hash = smp->data.data.sint;
hash = smp->data.u.sint;
temp = get_trash_chunk();
memcpy(temp->str + temp->len, &hash, sizeof(hash));
@ -11814,7 +11814,7 @@ smp_fetch_url32_src(const struct arg *args, struct sample *smp, const char *kw,
return 0;
}
smp->data.data.str = *temp;
smp->data.u.str = *temp;
smp->data.type = SMP_T_BIN;
return 1;
}
@ -11847,7 +11847,7 @@ static int sample_conv_http_date(const struct arg *args, struct sample *smp, voi
struct chunk *temp;
struct tm *tm;
/* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
time_t curr_date = smp->data.data.sint & 0x007fffffffffffffLL;
time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
/* add offset */
if (args && (args[0].type == ARGT_SINT))
@ -11863,7 +11863,7 @@ static int sample_conv_http_date(const struct arg *args, struct sample *smp, voi
day[tm->tm_wday], tm->tm_mday, mon[tm->tm_mon], 1900+tm->tm_year,
tm->tm_hour, tm->tm_min, tm->tm_sec);
smp->data.data.str = *temp;
smp->data.u.str = *temp;
smp->data.type = SMP_T_STR;
return 1;
}
@ -11896,8 +11896,8 @@ static inline int language_range_match(const char *range, int range_len,
/* Arguments: The list of expected value, the number of parts returned and the separator */
static int sample_conv_q_prefered(const struct arg *args, struct sample *smp, void *private)
{
const char *al = smp->data.data.str.str;
const char *end = al + smp->data.data.str.len;
const char *al = smp->data.u.str.str;
const char *end = al + smp->data.u.str.len;
const char *token;
int toklen;
int qvalue;
@ -11909,9 +11909,9 @@ static int sample_conv_q_prefered(const struct arg *args, struct sample *smp, vo
* function will be peek in the constant configuration string.
*/
smp->flags |= SMP_F_CONST;
smp->data.data.str.size = 0;
smp->data.data.str.str = "";
smp->data.data.str.len = 0;
smp->data.u.str.size = 0;
smp->data.u.str.str = "";
smp->data.u.str.len = 0;
/* Parse the accept language */
while (1) {
@ -12011,8 +12011,8 @@ process_value:
* break the process.
*/
if (qvalue > best_q) {
smp->data.data.str.str = (char *)w;
smp->data.data.str.len = str - w;
smp->data.u.str.str = (char *)w;
smp->data.u.str.len = str - w;
if (qvalue >= 1000)
break;
best_q = qvalue;
@ -12031,13 +12031,13 @@ expect_comma:
}
/* Set default value if required. */
if (smp->data.data.str.len == 0 && args[1].type == ARGT_STR) {
smp->data.data.str.str = args[1].data.str.str;
smp->data.data.str.len = args[1].data.str.len;
if (smp->data.u.str.len == 0 && args[1].type == ARGT_STR) {
smp->data.u.str.str = args[1].data.str.str;
smp->data.u.str.len = args[1].data.str.len;
}
/* Return true only if a matching language was found. */
return smp->data.data.str.len != 0;
return smp->data.u.str.len != 0;
}
/* This fetch url-decode any input string. */
@ -12047,17 +12047,17 @@ static int sample_conv_url_dec(const struct arg *args, struct sample *smp, void
* the end of the buffer, copy the string in other buffer
* before decoding.
*/
if (smp->flags & SMP_F_CONST || smp->data.data.str.size <= smp->data.data.str.len) {
if (smp->flags & SMP_F_CONST || smp->data.u.str.size <= smp->data.u.str.len) {
struct chunk *str = get_trash_chunk();
memcpy(str->str, smp->data.data.str.str, smp->data.data.str.len);
smp->data.data.str.str = str->str;
smp->data.data.str.size = str->size;
memcpy(str->str, smp->data.u.str.str, smp->data.u.str.len);
smp->data.u.str.str = str->str;
smp->data.u.str.size = str->size;
smp->flags &= ~SMP_F_CONST;
}
/* Add final \0 required by url_decode(), and convert the input string. */
smp->data.data.str.str[smp->data.data.str.len] = '\0';
smp->data.data.str.len = url_decode(smp->data.data.str.str);
smp->data.u.str.str[smp->data.u.str.len] = '\0';
smp->data.u.str.len = url_decode(smp->data.u.str.str);
return 1;
}
@ -12091,12 +12091,12 @@ static int smp_conv_req_capture(const struct arg *args, struct sample *smp, void
return 0;
/* Check length. */
len = smp->data.data.str.len;
len = smp->data.u.str.len;
if (len > hdr->len)
len = hdr->len;
/* Capture input data. */
memcpy(smp->strm->req_cap[idx], smp->data.data.str.str, len);
memcpy(smp->strm->req_cap[idx], smp->data.u.str.str, len);
smp->strm->req_cap[idx][len] = '\0';
return 1;
@ -12132,12 +12132,12 @@ static int smp_conv_res_capture(const struct arg *args, struct sample *smp, void
return 0;
/* Check length. */
len = smp->data.data.str.len;
len = smp->data.u.str.len;
if (len > hdr->len)
len = hdr->len;
/* Capture input data. */
memcpy(smp->strm->res_cap[idx], smp->data.data.str.str, len);
memcpy(smp->strm->res_cap[idx], smp->data.u.str.str, len);
smp->strm->res_cap[idx][len] = '\0';
return 1;
@ -12334,11 +12334,11 @@ int http_action_req_capture(struct http_req_rule *rule, struct proxy *px, struct
if (cap[h->index] == NULL) /* no more capture memory */
return 1;
len = key->data.data.str.len;
len = key->data.u.str.len;
if (len > h->len)
len = h->len;
memcpy(cap[h->index], key->data.data.str.str, len);
memcpy(cap[h->index], key->data.u.str.str, len);
cap[h->index][len] = 0;
return 1;
}
@ -12377,11 +12377,11 @@ int http_action_req_capture_by_id(struct http_req_rule *rule, struct proxy *px,
if (cap[h->index] == NULL) /* no more capture memory */
return 1;
len = key->data.data.str.len;
len = key->data.u.str.len;
if (len > h->len)
len = h->len;
memcpy(cap[h->index], key->data.data.str.str, len);
memcpy(cap[h->index], key->data.u.str.str, len);
cap[h->index][len] = 0;
return 1;
}
@ -12546,11 +12546,11 @@ int http_action_res_capture_by_id(struct http_res_rule *rule, struct proxy *px,
if (cap[h->index] == NULL) /* no more capture memory */
return 1;
len = key->data.data.str.len;
len = key->data.u.str.len;
if (len > h->len)
len = h->len;
memcpy(cap[h->index], key->data.data.str.str, len);
memcpy(cap[h->index], key->data.u.str.str, len);
cap[h->index][len] = 0;
return 1;
}

16
src/proto_tcp.c
View File

@ -1222,11 +1222,11 @@ resume_execution:
if (cap[h->index] == NULL) /* no more capture memory */
continue;
len = key->data.data.str.len;
len = key->data.u.str.len;
if (len > h->len)
len = h->len;
memcpy(cap[h->index], key->data.data.str.str, len);
memcpy(cap[h->index], key->data.u.str.str, len);
cap[h->index][len] = 0;
}
else {
@ -1999,11 +1999,11 @@ int smp_fetch_src(const struct arg *args, struct sample *smp, const char *kw, vo
switch (cli_conn->addr.from.ss_family) {
case AF_INET:
smp->data.data.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.from)->sin_addr;
smp->data.u.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.from)->sin_addr;
smp->data.type = SMP_T_IPV4;
break;
case AF_INET6:
smp->data.data.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_addr;
smp->data.u.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_addr;
smp->data.type = SMP_T_IPV6;
break;
default:
@ -2024,7 +2024,7 @@ smp_fetch_sport(const struct arg *args, struct sample *smp, const char *k, void
return 0;
smp->data.type = SMP_T_SINT;
if (!(smp->data.data.sint = get_host_port(&cli_conn->addr.from)))
if (!(smp->data.u.sint = get_host_port(&cli_conn->addr.from)))
return 0;
smp->flags = 0;
@ -2044,11 +2044,11 @@ smp_fetch_dst(const struct arg *args, struct sample *smp, const char *kw, void *
switch (cli_conn->addr.to.ss_family) {
case AF_INET:
smp->data.data.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.to)->sin_addr;
smp->data.u.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.to)->sin_addr;
smp->data.type = SMP_T_IPV4;
break;
case AF_INET6:
smp->data.data.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.to)->sin6_addr;
smp->data.u.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.to)->sin6_addr;
smp->data.type = SMP_T_IPV6;
break;
default:
@ -2071,7 +2071,7 @@ smp_fetch_dport(const struct arg *args, struct sample *smp, const char *kw, void
conn_get_to_addr(cli_conn);
smp->data.type = SMP_T_SINT;
if (!(smp->data.data.sint = get_host_port(&cli_conn->addr.to)))
if (!(smp->data.u.sint = get_host_port(&cli_conn->addr.to)))
return 0;
smp->flags = 0;

340
src/sample.c
View File

@ -499,7 +499,7 @@ struct sample_conv *find_sample_conv(const char *kw, int len)
static int c_ip2int(struct sample *smp)
{
smp->data.data.sint = ntohl(smp->data.data.ipv4.s_addr);
smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
smp->data.type = SMP_T_SINT;
return 1;
}
@ -508,11 +508,11 @@ static int c_ip2str(struct sample *smp)
{
struct chunk *trash = get_trash_chunk();
if (!inet_ntop(AF_INET, (void *)&smp->data.data.ipv4, trash->str, trash->size))
if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->str, trash->size))
return 0;
trash->len = strlen(trash->str);
smp->data.data.str = *trash;
smp->data.u.str = *trash;
smp->data.type = SMP_T_STR;
smp->flags &= ~SMP_F_CONST;
@ -521,14 +521,14 @@ static int c_ip2str(struct sample *smp)
static int c_ip2ipv6(struct sample *smp)
{
v4tov6(&smp->data.data.ipv6, &smp->data.data.ipv4);
v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
smp->data.type = SMP_T_IPV6;
return 1;
}
static int c_ipv62ip(struct sample *smp)
{
if (!v6tov4(&smp->data.data.ipv4, &smp->data.data.ipv6))
if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
return 0;
smp->data.type = SMP_T_IPV6;
return 1;
@ -538,11 +538,11 @@ static int c_ipv62str(struct sample *smp)
{
struct chunk *trash = get_trash_chunk();
if (!inet_ntop(AF_INET6, (void *)&smp->data.data.ipv6, trash->str, trash->size))
if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->str, trash->size))
return 0;
trash->len = strlen(trash->str);
smp->data.data.str = *trash;
smp->data.u.str = *trash;
smp->data.type = SMP_T_STR;
smp->flags &= ~SMP_F_CONST;
return 1;
@ -551,29 +551,29 @@ static int c_ipv62str(struct sample *smp)
/*
static int c_ipv62ip(struct sample *smp)
{
return v6tov4(&smp->data.data.ipv4, &smp->data.data.ipv6);
return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
}
*/
static int c_int2ip(struct sample *smp)
{
smp->data.data.ipv4.s_addr = htonl((unsigned int)smp->data.data.sint);
smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
smp->data.type = SMP_T_IPV4;
return 1;
}
static int c_int2ipv6(struct sample *smp)
{
smp->data.data.ipv4.s_addr = htonl((unsigned int)smp->data.data.sint);
v4tov6(&smp->data.data.ipv6, &smp->data.data.ipv4);
smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
smp->data.type = SMP_T_IPV6;
return 1;
}
static int c_str2addr(struct sample *smp)
{
if (!buf2ip(smp->data.data.str.str, smp->data.data.str.len, &smp->data.data.ipv4)) {
if (!buf2ip6(smp->data.data.str.str, smp->data.data.str.len, &smp->data.data.ipv6))
if (!buf2ip(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv4)) {
if (!buf2ip6(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv6))
return 0;
smp->data.type = SMP_T_IPV6;
smp->flags &= ~SMP_F_CONST;
@ -586,7 +586,7 @@ static int c_str2addr(struct sample *smp)
static int c_str2ip(struct sample *smp)
{
if (!buf2ip(smp->data.data.str.str, smp->data.data.str.len, &smp->data.data.ipv4))
if (!buf2ip(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv4))
return 0;
smp->data.type = SMP_T_IPV4;
smp->flags &= ~SMP_F_CONST;
@ -595,7 +595,7 @@ static int c_str2ip(struct sample *smp)
static int c_str2ipv6(struct sample *smp)
{
if (!buf2ip6(smp->data.data.str.str, smp->data.data.str.len, &smp->data.data.ipv6))
if (!buf2ip6(smp->data.u.str.str, smp->data.u.str.len, &smp->data.u.ipv6))
return 0;
smp->data.type = SMP_T_IPV6;
smp->flags &= ~SMP_F_CONST;
@ -610,9 +610,9 @@ static int c_bin2str(struct sample *smp)
{
int i;
for (i = 0; i < smp->data.data.str.len; i++) {
if (!smp->data.data.str.str[i]) {
smp->data.data.str.len = i;
for (i = 0; i < smp->data.u.str.len; i++) {
if (!smp->data.u.str.str[i]) {
smp->data.u.str.len = i;
break;
}
}
@ -624,14 +624,14 @@ static int c_int2str(struct sample *smp)
struct chunk *trash = get_trash_chunk();
char *pos;
pos = lltoa_r(smp->data.data.sint, trash->str, trash->size);
pos = lltoa_r(smp->data.u.sint, trash->str, trash->size);
if (!pos)
return 0;
trash->size = trash->size - (pos - trash->str);
trash->str = pos;
trash->len = strlen(pos);
smp->data.data.str = *trash;
smp->data.u.str = *trash;
smp->data.type = SMP_T_STR;
smp->flags &= ~SMP_F_CONST;
return 1;
@ -660,9 +660,9 @@ int smp_dup(struct sample *smp)
case SMP_T_BIN:
/* Duplicate data. */
trash = get_trash_chunk();
trash->len = smp->data.data.str.len < trash->size ? smp->data.data.str.len : trash->size;
memcpy(trash->str, smp->data.data.str.str, trash->len);
smp->data.data.str = *trash;
trash->len = smp->data.u.str.len < trash->size ? smp->data.u.str.len : trash->size;
memcpy(trash->str, smp->data.u.str.str, trash->len);
smp->data.u.str = *trash;
break;
default:
/* Other cases are unexpected. */
@ -684,13 +684,13 @@ static int c_str2int(struct sample *smp)
const char *str;
const char *end;
if (smp->data.data.str.len == 0)
if (smp->data.u.str.len == 0)
return 0;
str = smp->data.data.str.str;
end = smp->data.data.str.str + smp->data.data.str.len;
str = smp->data.u.str.str;
end = smp->data.u.str.str + smp->data.u.str.len;
smp->data.data.sint = read_int64(&str, end);
smp->data.u.sint = read_int64(&str, end);
smp->data.type = SMP_T_SINT;
smp->flags &= ~SMP_F_CONST;
return 1;
@ -701,15 +701,15 @@ static int c_str2meth(struct sample *smp)
enum http_meth_t meth;
int len;
meth = find_http_meth(smp->data.data.str.str, smp->data.data.str.len);
meth = find_http_meth(smp->data.u.str.str, smp->data.u.str.len);
if (meth == HTTP_METH_OTHER) {
len = smp->data.data.str.len;
smp->data.data.meth.str.str = smp->data.data.str.str;
smp->data.data.meth.str.len = len;
len = smp->data.u.str.len;
smp->data.u.meth.str.str = smp->data.u.str.str;
smp->data.u.meth.str.len = len;
}
else
smp->flags &= ~SMP_F_CONST;
smp->data.data.meth.meth = meth;
smp->data.u.meth.meth = meth;
smp->data.type = SMP_T_METH;
return 1;
}
@ -719,18 +719,18 @@ static int c_meth2str(struct sample *smp)
int len;
enum http_meth_t meth;
if (smp->data.data.meth.meth == HTTP_METH_OTHER) {
if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
/* The method is unknown. Copy the original pointer. */
len = smp->data.data.meth.str.len;
smp->data.data.str.str = smp->data.data.meth.str.str;
smp->data.data.str.len = len;
len = smp->data.u.meth.str.len;
smp->data.u.str.str = smp->data.u.meth.str.str;
smp->data.u.str.len = len;
smp->data.type = SMP_T_STR;
}
else if (smp->data.data.meth.meth < HTTP_METH_OTHER) {
else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
/* The method is known, copy the pointer containing the string. */
meth = smp->data.data.meth.meth;
smp->data.data.str.str = http_known_methods[meth].name;
smp->data.data.str.len = http_known_methods[meth].len;
meth = smp->data.u.meth.meth;
smp->data.u.str.str = http_known_methods[meth].name;
smp->data.u.str.len = http_known_methods[meth].len;
smp->flags |= SMP_F_CONST;
smp->data.type = SMP_T_STR;
}
@ -747,16 +747,16 @@ static int c_addr2bin(struct sample *smp)
if (smp->data.type == SMP_T_IPV4) {
chk->len = 4;
memcpy(chk->str, &smp->data.data.ipv4, chk->len);
memcpy(chk->str, &smp->data.u.ipv4, chk->len);
}
else if (smp->data.type == SMP_T_IPV6) {
chk->len = 16;
memcpy(chk->str, &smp->data.data.ipv6, chk->len);
memcpy(chk->str, &smp->data.u.ipv6, chk->len);
}
else
return 0;
smp->data.data.str = *chk;
smp->data.u.str = *chk;
smp->data.type = SMP_T_BIN;
return 1;
}
@ -765,10 +765,10 @@ static int c_int2bin(struct sample *smp)
{
struct chunk *chk = get_trash_chunk();
*(unsigned long long int *)chk->str = htonll(smp->data.data.sint);
*(unsigned long long int *)chk->str = htonll(smp->data.u.sint);
chk->len = 8;
smp->data.data.str = *chk;
smp->data.u.str = *chk;
smp->data.type = SMP_T_BIN;
return 1;
}
@ -1397,9 +1397,9 @@ static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *
else {
/* Display the displayable chars*. */
fprintf(stderr, "<");
for (i = 0; i < tmp.data.data.str.len; i++) {
if (isprint(tmp.data.data.str.str[i]))
fputc(tmp.data.data.str.str[i], stderr);
for (i = 0; i < tmp.data.u.str.len; i++) {
if (isprint(tmp.data.u.str.str[i]))
fputc(tmp.data.u.str.str[i], stderr);
else
fputc('.', stderr);
}
@ -1417,12 +1417,12 @@ static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, v
int b64_len;
trash->len = 0;
b64_len = a2base64(smp->data.data.str.str, smp->data.data.str.len, trash->str, trash->size);
b64_len = a2base64(smp->data.u.str.str, smp->data.u.str.len, trash->str, trash->size);
if (b64_len < 0)
return 0;
trash->len = b64_len;
smp->data.data.str = *trash;
smp->data.u.str = *trash;
smp->data.type = SMP_T_STR;
smp->flags &= ~SMP_F_CONST;
return 1;
@ -1435,12 +1435,12 @@ static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void
int ptr = 0;
trash->len = 0;
while (ptr < smp->data.data.str.len && trash->len <= trash->size - 2) {
c = smp->data.data.str.str[ptr++];
while (ptr < smp->data.u.str.len && trash->len <= trash->size - 2) {
c = smp->data.u.str.str[ptr++];
trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
trash->str[trash->len++] = hextab[c & 0xF];
}
smp->data.data.str = *trash;
smp->data.u.str = *trash;
smp->data.type = SMP_T_STR;
smp->flags &= ~SMP_F_CONST;
return 1;
@ -1449,9 +1449,9 @@ static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void
/* hashes the binary input into a 32-bit unsigned int */
static int sample_conv_djb2(const struct arg *arg_p, struct sample *smp, void *private)
{
smp->data.data.sint = hash_djb2(smp->data.data.str.str, smp->data.data.str.len);
smp->data.u.sint = hash_djb2(smp->data.u.str.str, smp->data.u.str.len);
if (arg_p && arg_p->data.sint)
smp->data.data.sint = full_hash(smp->data.data.sint);
smp->data.u.sint = full_hash(smp->data.u.sint);
smp->data.type = SMP_T_SINT;
return 1;
}
@ -1463,12 +1463,12 @@ static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp, vo
if (!smp_dup(smp))
return 0;
if (!smp->data.data.str.size)
if (!smp->data.u.str.size)
return 0;
for (i = 0; i < smp->data.data.str.len; i++) {
if ((smp->data.data.str.str[i] >= 'A') && (smp->data.data.str.str[i] <= 'Z'))
smp->data.data.str.str[i] += 'a' - 'A';
for (i = 0; i < smp->data.u.str.len; i++) {
if ((smp->data.u.str.str[i] >= 'A') && (smp->data.u.str.str[i] <= 'Z'))
smp->data.u.str.str[i] += 'a' - 'A';
}
return 1;
}
@ -1480,12 +1480,12 @@ static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, vo
if (!smp_dup(smp))
return 0;
if (!smp->data.data.str.size)
if (!smp->data.u.str.size)
return 0;
for (i = 0; i < smp->data.data.str.len; i++) {
if ((smp->data.data.str.str[i] >= 'a') && (smp->data.data.str.str[i] <= 'z'))
smp->data.data.str.str[i] += 'A' - 'a';
for (i = 0; i < smp->data.u.str.len; i++) {
if ((smp->data.u.str.str[i] >= 'a') && (smp->data.u.str.str[i] <= 'z'))
smp->data.u.str.str[i] += 'A' - 'a';
}
return 1;
}
@ -1493,7 +1493,7 @@ static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp, vo
/* takes the netmask in arg_p */
static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp, void *private)
{
smp->data.data.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
smp->data.u.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
smp->data.type = SMP_T_IPV4;
return 1;
}
@ -1506,7 +1506,7 @@ static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *p
{
struct chunk *temp;
/* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
time_t curr_date = smp->data.data.sint & 0x007fffffffffffffLL;
time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
struct tm *tm;
/* add offset */
@ -1518,7 +1518,7 @@ static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *p
return 0;
temp = get_trash_chunk();
temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
smp->data.data.str = *temp;
smp->data.u.str = *temp;
smp->data.type = SMP_T_STR;
return 1;
}
@ -1526,9 +1526,9 @@ static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *p
/* hashes the binary input into a 32-bit unsigned int */
static int sample_conv_sdbm(const struct arg *arg_p, struct sample *smp, void *private)
{
smp->data.data.sint = hash_sdbm(smp->data.data.str.str, smp->data.data.str.len);
smp->data.u.sint = hash_sdbm(smp->data.u.str.str, smp->data.u.str.len);
if (arg_p && arg_p->data.sint)
smp->data.data.sint = full_hash(smp->data.data.sint);
smp->data.u.sint = full_hash(smp->data.u.sint);
smp->data.type = SMP_T_SINT;
return 1;
}
@ -1541,7 +1541,7 @@ static int sample_conv_utime(const struct arg *args, struct sample *smp, void *p
{
struct chunk *temp;
/* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
time_t curr_date = smp->data.data.sint & 0x007fffffffffffffLL;
time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
struct tm *tm;
/* add offset */
@ -1553,7 +1553,7 @@ static int sample_conv_utime(const struct arg *args, struct sample *smp, void *p
return 0;
temp = get_trash_chunk();
temp->len = strftime(temp->str, temp->size, args[0].data.str.str, tm);
smp->data.data.str = *temp;
smp->data.u.str = *temp;
smp->data.type = SMP_T_STR;
return 1;
}
@ -1561,9 +1561,9 @@ static int sample_conv_utime(const struct arg *args, struct sample *smp, void *p
/* hashes the binary input into a 32-bit unsigned int */
static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *private)
{
smp->data.data.sint = hash_wt6(smp->data.data.str.str, smp->data.data.str.len);
smp->data.u.sint = hash_wt6(smp->data.u.str.str, smp->data.u.str.len);
if (arg_p && arg_p->data.sint)
smp->data.data.sint = full_hash(smp->data.data.sint);
smp->data.u.sint = full_hash(smp->data.u.sint);
smp->data.type = SMP_T_SINT;
return 1;
}
@ -1571,9 +1571,9 @@ static int sample_conv_wt6(const struct arg *arg_p, struct sample *smp, void *pr
/* hashes the binary input into a 32-bit unsigned int */
static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
{
smp->data.data.sint = hash_crc32(smp->data.data.str.str, smp->data.data.str.len);
smp->data.u.sint = hash_crc32(smp->data.u.str.str, smp->data.u.str.len);
if (arg_p && arg_p->data.sint)
smp->data.data.sint = full_hash(smp->data.data.sint);
smp->data.u.sint = full_hash(smp->data.u.sint);
smp->data.type = SMP_T_SINT;
return 1;
}
@ -1666,8 +1666,8 @@ static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *p
temp = get_trash_chunk();
temp->len = 0;
p = smp->data.data.str.str;
while (p < smp->data.data.str.str + smp->data.data.str.len) {
p = smp->data.u.str.str;
while (p < smp->data.u.str.str + smp->data.u.str.len) {
if (input_type == IT_ASCII) {
/* Read input as ASCII. */
@ -1676,7 +1676,7 @@ static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *p
}
else {
/* Read input as UTF8. */
ret = utf8_next(p, smp->data.data.str.len - ( p - smp->data.data.str.str ), &c);
ret = utf8_next(p, smp->data.u.str.len - ( p - smp->data.u.str.str ), &c);
p += utf8_return_length(ret);
if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
@ -1754,7 +1754,7 @@ static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *p
}
smp->flags &= ~SMP_F_CONST;
smp->data.data.str = *temp;
smp->data.u.str = *temp;
smp->data.type = SMP_T_STR;
return 1;
@ -1765,18 +1765,18 @@ static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *p
* Optional second arg is the length to truncate */
static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
{
if (smp->data.data.str.len <= arg_p[0].data.sint) {
smp->data.data.str.len = 0;
if (smp->data.u.str.len <= arg_p[0].data.sint) {
smp->data.u.str.len = 0;
return 1;
}
if (smp->data.data.str.size)
smp->data.data.str.size -= arg_p[0].data.sint;
smp->data.data.str.len -= arg_p[0].data.sint;
smp->data.data.str.str += arg_p[0].data.sint;
if (smp->data.u.str.size)
smp->data.u.str.size -= arg_p[0].data.sint;
smp->data.u.str.len -= arg_p[0].data.sint;
smp->data.u.str.str += arg_p[0].data.sint;
if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.data.str.len))
smp->data.data.str.len = arg_p[1].data.sint;
if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.len))
smp->data.u.str.len = arg_p[1].data.sint;
return 1;
}
@ -1830,8 +1830,8 @@ static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *
return 0;
field = 1;
end = start = smp->data.data.str.str;
while (end - smp->data.data.str.str < smp->data.data.str.len) {
end = start = smp->data.u.str.str;
while (end - smp->data.u.str.str < smp->data.u.str.len) {
for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
if (*end == arg_p[1].data.str.str[i]) {
@ -1847,22 +1847,22 @@ static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *
/* Field not found */
if (field != arg_p[0].data.sint) {
smp->data.data.str.len = 0;
smp->data.u.str.len = 0;
return 1;
}
found:
smp->data.data.str.len = end - start;
smp->data.u.str.len = end - start;
/* If ret string is len 0, no need to
change pointers or to update size */
if (!smp->data.data.str.len)
if (!smp->data.u.str.len)
return 1;
smp->data.data.str.str = start;
smp->data.u.str.str = start;
/* Compute remaining size if needed
Note: smp->data.data.str.size cannot be set to 0 */
if (smp->data.data.str.size)
smp->data.data.str.size -= start - smp->data.data.str.str;
Note: smp->data.u.str.size cannot be set to 0 */
if (smp->data.u.str.size)
smp->data.u.str.size -= start - smp->data.u.str.str;
return 1;
}
@ -1882,8 +1882,8 @@ static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *p
word = 0;
inword = 0;
end = start = smp->data.data.str.str;
while (end - smp->data.data.str.str < smp->data.data.str.len) {
end = start = smp->data.u.str.str;
while (end - smp->data.u.str.str < smp->data.u.str.len) {
issep = 0;
for (i = 0 ; i < arg_p[1].data.str.len ; i++) {
if (*end == arg_p[1].data.str.str[i]) {
@ -1908,22 +1908,22 @@ static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *p
/* Field not found */
if (word != arg_p[0].data.sint) {
smp->data.data.str.len = 0;
smp->data.u.str.len = 0;
return 1;
}
found:
smp->data.data.str.len = end - start;
smp->data.u.str.len = end - start;
/* If ret string is len 0, no need to
change pointers or to update size */
if (!smp->data.data.str.len)
if (!smp->data.u.str.len)
return 1;
smp->data.data.str.str = start;
smp->data.u.str.str = start;
/* Compute remaining size if needed
Note: smp->data.data.str.size cannot be set to 0 */
if (smp->data.data.str.size)
smp->data.data.str.size -= start - smp->data.data.str.str;
Note: smp->data.u.str.size cannot be set to 0 */
if (smp->data.u.str.size)
smp->data.u.str.size -= start - smp->data.u.str.str;
return 1;
}
@ -1974,8 +1974,8 @@ static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void
int flag, max;
int found;
start = smp->data.data.str.str;
end = start + smp->data.data.str.len;
start = smp->data.u.str.str;
end = start + smp->data.u.str.len;
flag = 0;
while (1) {
@ -2030,7 +2030,7 @@ static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void
flag |= REG_NOTBOL;
}
smp->data.data.str = *trash;
smp->data.u.str = *trash;
return 1;
}
@ -2071,7 +2071,7 @@ static inline int sample_conv_var2smp(const struct arg *arg, struct stream *strm
switch (arg->type) {
case ARGT_SINT:
smp->data.type = SMP_T_SINT;
smp->data.data.sint = arg->data.sint;
smp->data.u.sint = arg->data.sint;
return 1;
case ARGT_VAR:
if (!vars_get_by_desc(&arg->data.var, strm, smp))
@ -2091,7 +2091,7 @@ static inline int sample_conv_var2smp(const struct arg *arg, struct stream *strm
*/
static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
{
smp->data.data.sint = ~smp->data.data.sint;
smp->data.u.sint = ~smp->data.u.sint;
return 1;
}
@ -2104,7 +2104,7 @@ static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, v
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
smp->data.data.sint &= tmp.data.data.sint;
smp->data.u.sint &= tmp.data.u.sint;
return 1;
}
@ -2117,7 +2117,7 @@ static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, vo
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
smp->data.data.sint |= tmp.data.data.sint;
smp->data.u.sint |= tmp.data.u.sint;
return 1;
}
@ -2130,7 +2130,7 @@ static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, v
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
smp->data.data.sint ^= tmp.data.data.sint;
smp->data.u.sint ^= tmp.data.u.sint;
return 1;
}
@ -2169,7 +2169,7 @@ static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, vo
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
smp->data.data.sint = arith_add(smp->data.data.sint, tmp.data.data.sint);
smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
return 1;
}
@ -2188,17 +2188,17 @@ static int sample_conv_arith_sub(const struct arg *arg_p,
* than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
* of -LLONG_MIN and correct the result.
*/
if (tmp.data.data.sint == LLONG_MIN) {
smp->data.data.sint = arith_add(smp->data.data.sint, LLONG_MAX);
if (smp->data.data.sint < LLONG_MAX)
smp->data.data.sint++;
if (tmp.data.u.sint == LLONG_MIN) {
smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
if (smp->data.u.sint < LLONG_MAX)
smp->data.u.sint++;
return 1;
}
/* standard substraction: we use the "add" function and negate
* the second operand.
*/
smp->data.data.sint = arith_add(smp->data.data.sint, -tmp.data.data.sint);
smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
return 1;
}
@ -2217,32 +2217,32 @@ static int sample_conv_arith_mul(const struct arg *arg_p,
return 0;
/* prevent divide by 0 during the check */
if (!smp->data.data.sint || !tmp.data.data.sint) {
smp->data.data.sint = 0;
if (!smp->data.u.sint || !tmp.data.u.sint) {
smp->data.u.sint = 0;
return 1;
}
/* The multiply between LLONG_MIN and -1 returns a
* "floting point exception".
*/
if (smp->data.data.sint == LLONG_MIN && tmp.data.data.sint == -1) {
smp->data.data.sint = LLONG_MAX;
if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
smp->data.u.sint = LLONG_MAX;
return 1;
}
/* execute standard multiplication. */
c = smp->data.data.sint * tmp.data.data.sint;
c = smp->data.u.sint * tmp.data.u.sint;
/* check for overflow and makes capped multiply. */
if (smp->data.data.sint != c / tmp.data.data.sint) {
if ((smp->data.data.sint < 0) == (tmp.data.data.sint < 0)) {
smp->data.data.sint = LLONG_MAX;
if (smp->data.u.sint != c / tmp.data.u.sint) {
if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
smp->data.u.sint = LLONG_MAX;
return 1;
}
smp->data.data.sint = LLONG_MIN;
smp->data.u.sint = LLONG_MIN;
return 1;
}
smp->data.data.sint = c;
smp->data.u.sint = c;
return 1;
}
@ -2259,18 +2259,18 @@ static int sample_conv_arith_div(const struct arg *arg_p,
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
if (tmp.data.data.sint) {
if (tmp.data.u.sint) {
/* The divide between LLONG_MIN and -1 returns a
* "floting point exception".
*/
if (smp->data.data.sint == LLONG_MIN && tmp.data.data.sint == -1) {
smp->data.data.sint = LLONG_MAX;
if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
smp->data.u.sint = LLONG_MAX;
return 1;
}
smp->data.data.sint /= tmp.data.data.sint;
smp->data.u.sint /= tmp.data.u.sint;
return 1;
}
smp->data.data.sint = LLONG_MAX;
smp->data.u.sint = LLONG_MAX;
return 1;
}
@ -2286,18 +2286,18 @@ static int sample_conv_arith_mod(const struct arg *arg_p,
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
if (tmp.data.data.sint) {
if (tmp.data.u.sint) {
/* The divide between LLONG_MIN and -1 returns a
* "floting point exception".
*/
if (smp->data.data.sint == LLONG_MIN && tmp.data.data.sint == -1) {
smp->data.data.sint = 0;
if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
smp->data.u.sint = 0;
return 1;
}
smp->data.data.sint %= tmp.data.data.sint;
smp->data.u.sint %= tmp.data.u.sint;
return 1;
}
smp->data.data.sint = 0;
smp->data.u.sint = 0;
return 1;
}
@ -2307,10 +2307,10 @@ static int sample_conv_arith_mod(const struct arg *arg_p,
static int sample_conv_arith_neg(const struct arg *arg_p,
struct sample *smp, void *private)
{
if (smp->data.data.sint == LLONG_MIN)
smp->data.data.sint = LLONG_MAX;
if (smp->data.u.sint == LLONG_MIN)
smp->data.u.sint = LLONG_MAX;
else
smp->data.data.sint = -smp->data.data.sint;
smp->data.u.sint = -smp->data.u.sint;
return 1;
}
@ -2320,7 +2320,7 @@ static int sample_conv_arith_neg(const struct arg *arg_p,
static int sample_conv_arith_bool(const struct arg *arg_p,
struct sample *smp, void *private)
{
smp->data.data.sint = !!smp->data.data.sint;
smp->data.u.sint = !!smp->data.u.sint;
smp->data.type = SMP_T_BOOL;
return 1;
}
@ -2331,7 +2331,7 @@ static int sample_conv_arith_bool(const struct arg *arg_p,
static int sample_conv_arith_not(const struct arg *arg_p,
struct sample *smp, void *private)
{
smp->data.data.sint = !smp->data.data.sint;
smp->data.u.sint = !smp->data.u.sint;
smp->data.type = SMP_T_BOOL;
return 1;
}
@ -2342,7 +2342,7 @@ static int sample_conv_arith_not(const struct arg *arg_p,
static int sample_conv_arith_odd(const struct arg *arg_p,
struct sample *smp, void *private)
{
smp->data.data.sint = smp->data.data.sint & 1;
smp->data.u.sint = smp->data.u.sint & 1;
smp->data.type = SMP_T_BOOL;
return 1;
}
@ -2353,7 +2353,7 @@ static int sample_conv_arith_odd(const struct arg *arg_p,
static int sample_conv_arith_even(const struct arg *arg_p,
struct sample *smp, void *private)
{
smp->data.data.sint = !(smp->data.data.sint & 1);
smp->data.u.sint = !(smp->data.u.sint & 1);
smp->data.type = SMP_T_BOOL;
return 1;
}
@ -2367,7 +2367,7 @@ static int
smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = 1;
smp->data.u.sint = 1;
return 1;
}
@ -2376,7 +2376,7 @@ static int
smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
return 1;
}
@ -2395,8 +2395,8 @@ smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
smp->data.data.str.str = env;
smp->data.data.str.len = strlen(env);
smp->data.u.str.str = env;
smp->data.u.str.len = strlen(env);
return 1;
}
@ -2406,11 +2406,11 @@ smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *
static int
smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.data.sint = date.tv_sec;
smp->data.u.sint = date.tv_sec;
/* add offset */
if (args && args[0].type == ARGT_SINT)
smp->data.data.sint += args[0].data.sint;
smp->data.u.sint += args[0].data.sint;
smp->data.type = SMP_T_SINT;
smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
@ -2422,7 +2422,7 @@ static int
smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_SINT;
smp->data.data.sint = global.nbproc;
smp->data.u.sint = global.nbproc;
return 1;
}
@ -2431,7 +2431,7 @@ static int
smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_SINT;
smp->data.data.sint = relative_pid;
smp->data.u.sint = relative_pid;
return 1;
}
@ -2441,11 +2441,11 @@ smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void
static int
smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.data.sint = random();
smp->data.u.sint = random();
/* reduce if needed. Don't do a modulo, use all bits! */
if (args && args[0].type == ARGT_SINT)
smp->data.data.sint = (smp->data.data.sint * args[0].data.sint) / ((u64)RAND_MAX+1);
smp->data.u.sint = (smp->data.u.sint * args[0].data.sint) / ((u64)RAND_MAX+1);
smp->data.type = SMP_T_SINT;
smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
@ -2457,7 +2457,7 @@ static int
smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = stopping;
smp->data.u.sint = stopping;
return 1;
}
@ -2465,8 +2465,8 @@ static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const
{
smp->flags |= SMP_F_CONST;
smp->data.type = SMP_T_STR;
smp->data.data.str.str = args[0].data.str.str;
smp->data.data.str.len = args[0].data.str.len;
smp->data.u.str.str = args[0].data.str.str;
smp->data.u.str.len = args[0].data.str.len;
return 1;
}
@ -2491,28 +2491,28 @@ static int smp_check_const_bool(struct arg *args, char **err)
static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = args[0].data.sint;
smp->data.u.sint = args[0].data.sint;
return 1;
}
static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_SINT;
smp->data.data.sint = args[0].data.sint;
smp->data.u.sint = args[0].data.sint;
return 1;
}
static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_IPV4;
smp->data.data.ipv4 = args[0].data.ipv4;
smp->data.u.ipv4 = args[0].data.ipv4;
return 1;
}
static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->data.type = SMP_T_IPV6;
smp->data.data.ipv6 = args[0].data.ipv6;
smp->data.u.ipv6 = args[0].data.ipv6;
return 1;
}
@ -2533,8 +2533,8 @@ static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const
{
smp->flags |= SMP_F_CONST;
smp->data.type = SMP_T_BIN;
smp->data.data.str.str = args[0].data.str.str;
smp->data.data.str.len = args[0].data.str.len;
smp->data.u.str.str = args[0].data.str.str;
smp->data.u.str.len = args[0].data.str.len;
return 1;
}
@ -2568,14 +2568,14 @@ static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, cons
smp->data.type = SMP_T_METH;
if (args[0].type == ARGT_SINT) {
smp->flags &= ~SMP_F_CONST;
smp->data.data.meth.meth = args[0].data.sint;
smp->data.data.meth.str.str = "";
smp->data.data.meth.str.len = 0;
smp->data.u.meth.meth = args[0].data.sint;
smp->data.u.meth.str.str = "";
smp->data.u.meth.str.len = 0;
} else {
smp->flags |= SMP_F_CONST;
smp->data.data.meth.meth = HTTP_METH_OTHER;
smp->data.data.meth.str.str = args[0].data.str.str;
smp->data.data.meth.str.len = args[0].data.str.len;
smp->data.u.meth.meth = HTTP_METH_OTHER;
smp->data.u.meth.str.str = args[0].data.str.str;
smp->data.u.meth.str.len = args[0].data.str.len;
}
return 1;
}

88
src/ssl_sock.c
View File

@ -3405,7 +3405,7 @@ smp_fetch_ssl_fc_has_crt(const struct arg *args, struct sample *smp, const char
smp->flags = 0;
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = SSL_SOCK_ST_FL_VERIFY_DONE & conn->xprt_st ? 1 : 0;
smp->data.u.sint = SSL_SOCK_ST_FL_VERIFY_DONE & conn->xprt_st ? 1 : 0;
return 1;
}
@ -3444,7 +3444,7 @@ smp_fetch_ssl_x_der(const struct arg *args, struct sample *smp, const char *kw,
if (ssl_sock_crt2der(crt, smp_trash) <= 0)
goto out;
smp->data.data.str = *smp_trash;
smp->data.u.str = *smp_trash;
smp->data.type = SMP_T_BIN;
ret = 1;
out:
@ -3488,7 +3488,7 @@ smp_fetch_ssl_x_serial(const struct arg *args, struct sample *smp, const char *k
if (ssl_sock_get_serial(crt, smp_trash) <= 0)
goto out;
smp->data.data.str = *smp_trash;
smp->data.u.str = *smp_trash;
smp->data.type = SMP_T_BIN;
ret = 1;
out:
@ -3532,7 +3532,7 @@ smp_fetch_ssl_x_sha1(const struct arg *args, struct sample *smp, const char *kw,
digest = EVP_sha1();
X509_digest(crt, digest, (unsigned char *)smp_trash->str, (unsigned int *)&smp_trash->len);
smp->data.data.str = *smp_trash;
smp->data.u.str = *smp_trash;
smp->data.type = SMP_T_BIN;
ret = 1;
out:
@ -3575,7 +3575,7 @@ smp_fetch_ssl_x_notafter(const struct arg *args, struct sample *smp, const char
if (ssl_sock_get_time(X509_get_notAfter(crt), smp_trash) <= 0)
goto out;
smp->data.data.str = *smp_trash;
smp->data.u.str = *smp_trash;
smp->data.type = SMP_T_STR;
ret = 1;
out:
@ -3633,7 +3633,7 @@ smp_fetch_ssl_x_i_dn(const struct arg *args, struct sample *smp, const char *kw,
goto out;
smp->data.type = SMP_T_STR;
smp->data.data.str = *smp_trash;
smp->data.u.str = *smp_trash;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
@ -3675,7 +3675,7 @@ smp_fetch_ssl_x_notbefore(const struct arg *args, struct sample *smp, const char
if (ssl_sock_get_time(X509_get_notBefore(crt), smp_trash) <= 0)
goto out;
smp->data.data.str = *smp_trash;
smp->data.u.str = *smp_trash;
smp->data.type = SMP_T_STR;
ret = 1;
out:
@ -3733,7 +3733,7 @@ smp_fetch_ssl_x_s_dn(const struct arg *args, struct sample *smp, const char *kw,
goto out;
smp->data.type = SMP_T_STR;
smp->data.data.str = *smp_trash;
smp->data.u.str = *smp_trash;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
@ -3765,7 +3765,7 @@ smp_fetch_ssl_c_used(const struct arg *args, struct sample *smp, const char *kw,
}
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = (crt != NULL);
smp->data.u.sint = (crt != NULL);
return 1;
}
@ -3796,7 +3796,7 @@ smp_fetch_ssl_x_version(const struct arg *args, struct sample *smp, const char *
if (!crt)
return 0;
smp->data.data.sint = (unsigned int)(1 + X509_get_version(crt));
smp->data.u.sint = (unsigned int)(1 + X509_get_version(crt));
/* SSL_get_peer_certificate increase X509 * ref count */
if (cert_peer)
X509_free(crt);
@ -3835,8 +3835,8 @@ smp_fetch_ssl_x_sig_alg(const struct arg *args, struct sample *smp, const char *
nid = OBJ_obj2nid((ASN1_OBJECT *)(crt->cert_info->signature->algorithm));
smp->data.data.str.str = (char *)OBJ_nid2sn(nid);
if (!smp->data.data.str.str) {
smp->data.u.str.str = (char *)OBJ_nid2sn(nid);
if (!smp->data.u.str.str) {
/* SSL_get_peer_certificate increase X509 * ref count */
if (cert_peer)
X509_free(crt);
@ -3845,7 +3845,7 @@ smp_fetch_ssl_x_sig_alg(const struct arg *args, struct sample *smp, const char *
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
smp->data.data.str.len = strlen(smp->data.data.str.str);
smp->data.u.str.len = strlen(smp->data.u.str.str);
/* SSL_get_peer_certificate increase X509 * ref count */
if (cert_peer)
X509_free(crt);
@ -3883,8 +3883,8 @@ smp_fetch_ssl_x_key_alg(const struct arg *args, struct sample *smp, const char *
nid = OBJ_obj2nid((ASN1_OBJECT *)(crt->cert_info->key->algor->algorithm));
smp->data.data.str.str = (char *)OBJ_nid2sn(nid);
if (!smp->data.data.str.str) {
smp->data.u.str.str = (char *)OBJ_nid2sn(nid);
if (!smp->data.u.str.str) {
/* SSL_get_peer_certificate increase X509 * ref count */
if (cert_peer)
X509_free(crt);
@ -3893,7 +3893,7 @@ smp_fetch_ssl_x_key_alg(const struct arg *args, struct sample *smp, const char *
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
smp->data.data.str.len = strlen(smp->data.data.str.str);
smp->data.u.str.len = strlen(smp->data.u.str.str);
if (cert_peer)
X509_free(crt);
@ -3911,7 +3911,7 @@ smp_fetch_ssl_fc(const struct arg *args, struct sample *smp, const char *kw, voi
struct connection *conn = objt_conn(smp->strm->si[back_conn].end);
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = (conn && conn->xprt == &ssl_sock);
smp->data.u.sint = (conn && conn->xprt == &ssl_sock);
return 1;
}
@ -3923,7 +3923,7 @@ smp_fetch_ssl_fc_has_sni(const struct arg *args, struct sample *smp, const char
struct connection *conn = objt_conn(smp->sess->origin);
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = (conn && conn->xprt == &ssl_sock) &&
smp->data.u.sint = (conn && conn->xprt == &ssl_sock) &&
conn->xprt_ctx &&
SSL_get_servername(conn->xprt_ctx, TLSEXT_NAMETYPE_host_name) != NULL;
return 1;
@ -3939,7 +3939,7 @@ smp_fetch_ssl_fc_is_resumed(const struct arg *args, struct sample *smp, const ch
struct connection *conn = objt_conn(smp->sess->origin);
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = (conn && conn->xprt == &ssl_sock) &&
smp->data.u.sint = (conn && conn->xprt == &ssl_sock) &&
conn->xprt_ctx &&
SSL_session_reused(conn->xprt_ctx);
return 1;
@ -3961,13 +3961,13 @@ smp_fetch_ssl_fc_cipher(const struct arg *args, struct sample *smp, const char *
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
smp->data.data.str.str = (char *)SSL_get_cipher_name(conn->xprt_ctx);
if (!smp->data.data.str.str)
smp->data.u.str.str = (char *)SSL_get_cipher_name(conn->xprt_ctx);
if (!smp->data.u.str.str)
return 0;
smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
smp->data.data.str.len = strlen(smp->data.data.str.str);
smp->data.u.str.len = strlen(smp->data.u.str.str);
return 1;
}
@ -3993,7 +3993,7 @@ smp_fetch_ssl_fc_alg_keysize(const struct arg *args, struct sample *smp, const c
if (!SSL_get_cipher_bits(conn->xprt_ctx, &sint))
return 0;
smp->data.data.sint = sint;
smp->data.u.sint = sint;
smp->data.type = SMP_T_SINT;
return 1;
@ -4015,8 +4015,8 @@ smp_fetch_ssl_fc_use_keysize(const struct arg *args, struct sample *smp, const c
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
smp->data.data.sint = (unsigned int)SSL_get_cipher_bits(conn->xprt_ctx, NULL);
if (!smp->data.data.sint)
smp->data.u.sint = (unsigned int)SSL_get_cipher_bits(conn->xprt_ctx, NULL);
if (!smp->data.u.sint)
return 0;
smp->data.type = SMP_T_SINT;
@ -4037,11 +4037,11 @@ smp_fetch_ssl_fc_npn(const struct arg *args, struct sample *smp, const char *kw,
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
smp->data.data.str.str = NULL;
smp->data.u.str.str = NULL;
SSL_get0_next_proto_negotiated(conn->xprt_ctx,
(const unsigned char **)&smp->data.data.str.str, (unsigned *)&smp->data.data.str.len);
(const unsigned char **)&smp->data.u.str.str, (unsigned *)&smp->data.u.str.len);
if (!smp->data.data.str.str)
if (!smp->data.u.str.str)
return 0;
return 1;
@ -4061,11 +4061,11 @@ smp_fetch_ssl_fc_alpn(const struct arg *args, struct sample *smp, const char *kw
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
smp->data.data.str.str = NULL;
smp->data.u.str.str = NULL;
SSL_get0_alpn_selected(conn->xprt_ctx,
(const unsigned char **)&smp->data.data.str.str, (unsigned *)&smp->data.data.str.len);
(const unsigned char **)&smp->data.u.str.str, (unsigned *)&smp->data.u.str.len);
if (!smp->data.data.str.str)
if (!smp->data.u.str.str)
return 0;
return 1;
@ -4088,13 +4088,13 @@ smp_fetch_ssl_fc_protocol(const struct arg *args, struct sample *smp, const char
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
smp->data.data.str.str = (char *)SSL_get_version(conn->xprt_ctx);
if (!smp->data.data.str.str)
smp->data.u.str.str = (char *)SSL_get_version(conn->xprt_ctx);
if (!smp->data.u.str.str)
return 0;
smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
smp->data.data.str.len = strlen(smp->data.data.str.str);
smp->data.u.str.len = strlen(smp->data.u.str.str);
return 1;
}
@ -4122,8 +4122,8 @@ smp_fetch_ssl_fc_session_id(const struct arg *args, struct sample *smp, const ch
if (!ssl_sess)
return 0;
smp->data.data.str.str = (char *)SSL_SESSION_get_id(ssl_sess, (unsigned int *)&smp->data.data.str.len);
if (!smp->data.data.str.str || !smp->data.data.str.len)
smp->data.u.str.str = (char *)SSL_SESSION_get_id(ssl_sess, (unsigned int *)&smp->data.u.str.len);
if (!smp->data.u.str.str || !smp->data.u.str.len)
return 0;
return 1;
@ -4145,11 +4145,11 @@ smp_fetch_ssl_fc_sni(const struct arg *args, struct sample *smp, const char *kw,
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
smp->data.data.str.str = (char *)SSL_get_servername(conn->xprt_ctx, TLSEXT_NAMETYPE_host_name);
if (!smp->data.data.str.str)
smp->data.u.str.str = (char *)SSL_get_servername(conn->xprt_ctx, TLSEXT_NAMETYPE_host_name);
if (!smp->data.u.str.str)
return 0;
smp->data.data.str.len = strlen(smp->data.data.str.str);
smp->data.u.str.len = strlen(smp->data.u.str.str);
return 1;
#else
return 0;
@ -4186,7 +4186,7 @@ smp_fetch_ssl_fc_unique_id(const struct arg *args, struct sample *smp, const cha
return 0;
finished_trash->len = finished_len;
smp->data.data.str = *finished_trash;
smp->data.u.str = *finished_trash;
smp->data.type = SMP_T_BIN;
return 1;
@ -4211,7 +4211,7 @@ smp_fetch_ssl_c_ca_err(const struct arg *args, struct sample *smp, const char *k
}
smp->data.type = SMP_T_SINT;
smp->data.data.sint = (unsigned long long int)SSL_SOCK_ST_TO_CA_ERROR(conn->xprt_st);
smp->data.u.sint = (unsigned long long int)SSL_SOCK_ST_TO_CA_ERROR(conn->xprt_st);
smp->flags = 0;
return 1;
@ -4233,7 +4233,7 @@ smp_fetch_ssl_c_ca_err_depth(const struct arg *args, struct sample *smp, const c
}
smp->data.type = SMP_T_SINT;
smp->data.data.sint = (long long int)SSL_SOCK_ST_TO_CAEDEPTH(conn->xprt_st);
smp->data.u.sint = (long long int)SSL_SOCK_ST_TO_CAEDEPTH(conn->xprt_st);
smp->flags = 0;
return 1;
@ -4255,7 +4255,7 @@ smp_fetch_ssl_c_err(const struct arg *args, struct sample *smp, const char *kw,
}
smp->data.type = SMP_T_SINT;
smp->data.data.sint = (long long int)SSL_SOCK_ST_TO_CRTERROR(conn->xprt_st);
smp->data.u.sint = (long long int)SSL_SOCK_ST_TO_CRTERROR(conn->xprt_st);
smp->flags = 0;
return 1;
@ -4280,7 +4280,7 @@ smp_fetch_ssl_c_verify(const struct arg *args, struct sample *smp, const char *k
return 0;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = (long long int)SSL_get_verify_result(conn->xprt_ctx);
smp->data.u.sint = (long long int)SSL_get_verify_result(conn->xprt_ctx);
smp->flags = 0;
return 1;

114
src/stick_table.c
View File

@ -458,28 +458,28 @@ int stktable_parse_type(char **args, int *myidx, unsigned long *type, size_t *ke
static void *k_int2int(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
kdata->integer = smp->data.data.sint;
kdata->integer = smp->data.u.sint;
return (void *)&kdata->integer;
}
static void *k_ip2ip(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
if (smp->data.type == SMP_T_IPV6) {
v6tov4(&kdata->ip, &smp->data.data.ipv6);
v6tov4(&kdata->ip, &smp->data.u.ipv6);
return (void *)&kdata->ip.s_addr;
}
else {
return (void *)&smp->data.data.ipv4.s_addr;
return (void *)&smp->data.u.ipv4.s_addr;
}
}
static void *k_ip2ipv6(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
if (smp->data.type == SMP_T_IPV6) {
return (void *)&smp->data.data.ipv6.s6_addr;
return (void *)&smp->data.u.ipv6.s6_addr;
}
else {
v4tov6(&kdata->ipv6, &smp->data.data.ipv4);
v4tov6(&kdata->ipv6, &smp->data.u.ipv4);
return (void *)&kdata->ipv6.s6_addr;
}
}
@ -487,36 +487,36 @@ static void *k_ip2ipv6(struct sample *smp, union stktable_key_data *kdata, size_
static void *k_ip2int(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
if (smp->data.type == SMP_T_IPV6) {
if (!v6tov4(&kdata->ip, &smp->data.data.ipv6))
if (!v6tov4(&kdata->ip, &smp->data.u.ipv6))
return NULL;
kdata->integer = ntohl(kdata->ip.s_addr);
}
else {
kdata->integer = ntohl(smp->data.data.ipv4.s_addr);
kdata->integer = ntohl(smp->data.u.ipv4.s_addr);
}
return (void *)&kdata->integer;
}
static void *k_int2ip(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
kdata->ip.s_addr = htonl((unsigned int)smp->data.data.sint);
kdata->ip.s_addr = htonl((unsigned int)smp->data.u.sint);
return (void *)&kdata->ip.s_addr;
}
static void *k_str2str(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
*len = smp->data.data.str.len;
return (void *)smp->data.data.str.str;
*len = smp->data.u.str.len;
return (void *)smp->data.u.str.str;
}
static void *k_ip2str(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
if (smp->data.type == SMP_T_IPV6) {
if (!inet_ntop(AF_INET6, &smp->data.data.ipv6, kdata->buf, *len))
if (!inet_ntop(AF_INET6, &smp->data.u.ipv6, kdata->buf, *len))
return NULL;
}
else {
if (!inet_ntop(AF_INET, &smp->data.data.ipv4, kdata->buf, *len))
if (!inet_ntop(AF_INET, &smp->data.u.ipv4, kdata->buf, *len))
return NULL;
}
@ -529,12 +529,12 @@ static void *k_ip2bin(struct sample *smp, union stktable_key_data *kdata, size_t
if (smp->data.type == SMP_T_IPV4) {
if (*len > 4)
*len = 4;
memcpy(kdata->buf, &smp->data.data.ipv4, *len);
memcpy(kdata->buf, &smp->data.u.ipv4, *len);
}
else if (smp->data.type == SMP_T_IPV6) {
if (*len > 16)
*len = 16;
memcpy(kdata->buf, &smp->data.data.ipv6, *len);
memcpy(kdata->buf, &smp->data.u.ipv6, *len);
}
else
*len = 0;
@ -548,8 +548,8 @@ static void *k_bin2str(struct sample *smp, union stktable_key_data *kdata, size_
int max = *len;
int size = 0;
while (ptr < smp->data.data.str.len && size <= max - 2) {
c = smp->data.data.str.str[ptr++];
while (ptr < smp->data.u.str.len && size <= max - 2) {
c = smp->data.u.str.str[ptr++];
kdata->buf[size++] = hextab[(c >> 4) & 0xF];
kdata->buf[size++] = hextab[c & 0xF];
}
@ -561,7 +561,7 @@ static void *k_int2str(struct sample *smp, union stktable_key_data *kdata, size_
{
void *key;
key = (void *)lltoa_r(smp->data.data.sint, kdata->buf, *len);
key = (void *)lltoa_r(smp->data.u.sint, kdata->buf, *len);
if (!key)
return NULL;
@ -571,7 +571,7 @@ static void *k_int2str(struct sample *smp, union stktable_key_data *kdata, size_
static void *k_str2ip(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
if (!buf2ip(smp->data.data.str.str, smp->data.data.str.len, &kdata->ip))
if (!buf2ip(smp->data.u.str.str, smp->data.u.str.len, &kdata->ip))
return NULL;
return (void *)&kdata->ip.s_addr;
@ -579,7 +579,7 @@ static void *k_str2ip(struct sample *smp, union stktable_key_data *kdata, size_t
static void *k_str2ipv6(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
if (!inet_pton(AF_INET6, smp->data.data.str.str, &kdata->ipv6))
if (!inet_pton(AF_INET6, smp->data.u.str.str, &kdata->ipv6))
return NULL;
return (void *)&kdata->ipv6.s6_addr;
@ -590,8 +590,8 @@ static void *k_str2int(struct sample *smp, union stktable_key_data *kdata, size_
int i;
kdata->integer = 0;
for (i = 0; i < smp->data.data.str.len; i++) {
uint32_t val = smp->data.data.str.str[i] - '0';
for (i = 0; i < smp->data.u.str.len; i++) {
uint32_t val = smp->data.u.str.str[i] - '0';
if (val > 9)
break;
@ -643,7 +643,7 @@ struct stktable_key *smp_to_stkey(struct sample *smp, struct stktable *t)
if ((static_table_key->key_len < t->key_size) && (t->type != STKTABLE_TYPE_STRING)) {
/* need padding with null */
/* assume static_table_key.key_len is less than sizeof(static_table_key.data.data.buf)
/* assume static_table_key.key_len is less than sizeof(static_table_key.data.u.buf)
cause t->key_size is necessary less than sizeof(static_table_key.data) */
if ((char *)static_table_key->key > (char *)&static_table_key->data &&
@ -812,7 +812,7 @@ static int sample_conv_in_table(const struct arg *arg_p, struct sample *smp, voi
ts = stktable_lookup_key(t, key);
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = !!ts;
smp->data.u.sint = !!ts;
smp->flags = SMP_F_VOL_TEST;
return 1;
}
@ -838,7 +838,7 @@ static int sample_conv_table_bytes_in_rate(const struct arg *arg_p, struct sampl
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -848,7 +848,7 @@ static int sample_conv_table_bytes_in_rate(const struct arg *arg_p, struct sampl
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
t->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
return 1;
}
@ -874,7 +874,7 @@ static int sample_conv_table_conn_cnt(const struct arg *arg_p, struct sample *sm
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -884,7 +884,7 @@ static int sample_conv_table_conn_cnt(const struct arg *arg_p, struct sample *sm
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, conn_cnt);
smp->data.u.sint = stktable_data_cast(ptr, conn_cnt);
return 1;
}
@ -909,7 +909,7 @@ static int sample_conv_table_conn_cur(const struct arg *arg_p, struct sample *sm
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -919,7 +919,7 @@ static int sample_conv_table_conn_cur(const struct arg *arg_p, struct sample *sm
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, conn_cur);
smp->data.u.sint = stktable_data_cast(ptr, conn_cur);
return 1;
}
@ -944,7 +944,7 @@ static int sample_conv_table_conn_rate(const struct arg *arg_p, struct sample *s
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -954,7 +954,7 @@ static int sample_conv_table_conn_rate(const struct arg *arg_p, struct sample *s
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
t->data_arg[STKTABLE_DT_CONN_RATE].u);
return 1;
}
@ -980,7 +980,7 @@ static int sample_conv_table_bytes_out_rate(const struct arg *arg_p, struct samp
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -990,7 +990,7 @@ static int sample_conv_table_bytes_out_rate(const struct arg *arg_p, struct samp
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
t->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
return 1;
}
@ -1016,7 +1016,7 @@ static int sample_conv_table_gpc0(const struct arg *arg_p, struct sample *smp, v
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1026,7 +1026,7 @@ static int sample_conv_table_gpc0(const struct arg *arg_p, struct sample *smp, v
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, gpc0);
smp->data.u.sint = stktable_data_cast(ptr, gpc0);
return 1;
}
@ -1051,7 +1051,7 @@ static int sample_conv_table_gpc0_rate(const struct arg *arg_p, struct sample *s
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1061,7 +1061,7 @@ static int sample_conv_table_gpc0_rate(const struct arg *arg_p, struct sample *s
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
t->data_arg[STKTABLE_DT_GPC0_RATE].u);
return 1;
}
@ -1087,7 +1087,7 @@ static int sample_conv_table_http_err_cnt(const struct arg *arg_p, struct sample
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1097,7 +1097,7 @@ static int sample_conv_table_http_err_cnt(const struct arg *arg_p, struct sample
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, http_err_cnt);
smp->data.u.sint = stktable_data_cast(ptr, http_err_cnt);
return 1;
}
@ -1122,7 +1122,7 @@ static int sample_conv_table_http_err_rate(const struct arg *arg_p, struct sampl
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1132,7 +1132,7 @@ static int sample_conv_table_http_err_rate(const struct arg *arg_p, struct sampl
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
t->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
return 1;
}
@ -1158,7 +1158,7 @@ static int sample_conv_table_http_req_cnt(const struct arg *arg_p, struct sample
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1168,7 +1168,7 @@ static int sample_conv_table_http_req_cnt(const struct arg *arg_p, struct sample
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, http_req_cnt);
smp->data.u.sint = stktable_data_cast(ptr, http_req_cnt);
return 1;
}
@ -1193,7 +1193,7 @@ static int sample_conv_table_http_req_rate(const struct arg *arg_p, struct sampl
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1203,7 +1203,7 @@ static int sample_conv_table_http_req_rate(const struct arg *arg_p, struct sampl
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
t->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
return 1;
}
@ -1229,7 +1229,7 @@ static int sample_conv_table_kbytes_in(const struct arg *arg_p, struct sample *s
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1239,7 +1239,7 @@ static int sample_conv_table_kbytes_in(const struct arg *arg_p, struct sample *s
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
smp->data.u.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
return 1;
}
@ -1264,7 +1264,7 @@ static int sample_conv_table_kbytes_out(const struct arg *arg_p, struct sample *
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1274,7 +1274,7 @@ static int sample_conv_table_kbytes_out(const struct arg *arg_p, struct sample *
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
smp->data.u.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
return 1;
}
@ -1299,7 +1299,7 @@ static int sample_conv_table_server_id(const struct arg *arg_p, struct sample *s
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1309,7 +1309,7 @@ static int sample_conv_table_server_id(const struct arg *arg_p, struct sample *s
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, server_id);
smp->data.u.sint = stktable_data_cast(ptr, server_id);
return 1;
}
@ -1334,7 +1334,7 @@ static int sample_conv_table_sess_cnt(const struct arg *arg_p, struct sample *sm
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1344,7 +1344,7 @@ static int sample_conv_table_sess_cnt(const struct arg *arg_p, struct sample *sm
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, sess_cnt);
smp->data.u.sint = stktable_data_cast(ptr, sess_cnt);
return 1;
}
@ -1369,7 +1369,7 @@ static int sample_conv_table_sess_rate(const struct arg *arg_p, struct sample *s
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
@ -1379,7 +1379,7 @@ static int sample_conv_table_sess_rate(const struct arg *arg_p, struct sample *s
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
t->data_arg[STKTABLE_DT_SESS_RATE].u);
return 1;
}
@ -1404,11 +1404,11 @@ static int sample_conv_table_trackers(const struct arg *arg_p, struct sample *sm
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
ts = stktable_lookup_key(t, key);
if (ts)
smp->data.data.sint = ts->ref_cnt;
smp->data.u.sint = ts->ref_cnt;
return 1;
}

80
src/stream.c
View File

@ -2672,7 +2672,7 @@ smp_fetch_sc_tracked(const struct arg *args, struct sample *smp, const char *kw,
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_BOOL;
smp->data.data.sint = !!smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw);
smp->data.u.sint = !!smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw);
return 1;
}
@ -2691,13 +2691,13 @@ smp_fetch_sc_get_gpc0(const struct arg *args, struct sample *smp, const char *kw
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, gpc0);
smp->data.u.sint = stktable_data_cast(ptr, gpc0);
}
return 1;
}
@ -2717,12 +2717,12 @@ smp_fetch_sc_gpc0_rate(const struct arg *args, struct sample *smp, const char *k
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0_RATE);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u);
}
return 1;
@ -2742,7 +2742,7 @@ smp_fetch_sc_inc_gpc0(const struct arg *args, struct sample *smp, const char *kw
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) == NULL)
stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw);
@ -2757,12 +2757,12 @@ smp_fetch_sc_inc_gpc0(const struct arg *args, struct sample *smp, const char *kw
if (ptr1) {
update_freq_ctr_period(&stktable_data_cast(ptr1, gpc0_rate),
stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u, 1);
smp->data.data.sint = (&stktable_data_cast(ptr1, gpc0_rate))->curr_ctr;
smp->data.u.sint = (&stktable_data_cast(ptr1, gpc0_rate))->curr_ctr;
}
ptr2 = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0);
if (ptr2)
smp->data.data.sint = ++stktable_data_cast(ptr2, gpc0);
smp->data.u.sint = ++stktable_data_cast(ptr2, gpc0);
/* If data was modified, we need to touch to re-schedule sync */
if (ptr1 || ptr2)
@ -2785,7 +2785,7 @@ smp_fetch_sc_clr_gpc0(const struct arg *args, struct sample *smp, const char *kw
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) == NULL)
stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw);
@ -2794,7 +2794,7 @@ smp_fetch_sc_clr_gpc0(const struct arg *args, struct sample *smp, const char *kw
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, gpc0);
smp->data.u.sint = stktable_data_cast(ptr, gpc0);
stktable_data_cast(ptr, gpc0) = 0;
/* If data was modified, we need to touch to re-schedule sync */
stktable_touch(stkctr->table, stkctr_entry(stkctr), 1);
@ -2816,12 +2816,12 @@ smp_fetch_sc_conn_cnt(const struct arg *args, struct sample *smp, const char *kw
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_CNT);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, conn_cnt);
smp->data.u.sint = stktable_data_cast(ptr, conn_cnt);
}
return 1;
}
@ -2840,12 +2840,12 @@ smp_fetch_sc_conn_rate(const struct arg *args, struct sample *smp, const char *k
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_RATE);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
stkctr->table->data_arg[STKTABLE_DT_CONN_RATE].u);
}
return 1;
@ -2882,7 +2882,7 @@ smp_fetch_src_updt_conn_cnt(const struct arg *args, struct sample *smp, const ch
return 0; /* parameter not stored in this table */
smp->data.type = SMP_T_SINT;
smp->data.data.sint = ++stktable_data_cast(ptr, conn_cnt);
smp->data.u.sint = ++stktable_data_cast(ptr, conn_cnt);
/* Touch was previously performed by stktable_update_key */
smp->flags = SMP_F_VOL_TEST;
return 1;
@ -2902,12 +2902,12 @@ smp_fetch_sc_conn_cur(const struct arg *args, struct sample *smp, const char *kw
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_CUR);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, conn_cur);
smp->data.u.sint = stktable_data_cast(ptr, conn_cur);
}
return 1;
}
@ -2926,12 +2926,12 @@ smp_fetch_sc_sess_cnt(const struct arg *args, struct sample *smp, const char *kw
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, sess_cnt);
smp->data.u.sint = stktable_data_cast(ptr, sess_cnt);
}
return 1;
}
@ -2949,12 +2949,12 @@ smp_fetch_sc_sess_rate(const struct arg *args, struct sample *smp, const char *k
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u);
}
return 1;
@ -2974,12 +2974,12 @@ smp_fetch_sc_http_req_cnt(const struct arg *args, struct sample *smp, const char
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, http_req_cnt);
smp->data.u.sint = stktable_data_cast(ptr, http_req_cnt);
}
return 1;
}
@ -2998,12 +2998,12 @@ smp_fetch_sc_http_req_rate(const struct arg *args, struct sample *smp, const cha
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
}
return 1;
@ -3023,12 +3023,12 @@ smp_fetch_sc_http_err_cnt(const struct arg *args, struct sample *smp, const char
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_CNT);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, http_err_cnt);
smp->data.u.sint = stktable_data_cast(ptr, http_err_cnt);
}
return 1;
}
@ -3047,12 +3047,12 @@ smp_fetch_sc_http_err_rate(const struct arg *args, struct sample *smp, const cha
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_RATE);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
}
return 1;
@ -3072,12 +3072,12 @@ smp_fetch_sc_kbytes_in(const struct arg *args, struct sample *smp, const char *k
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_IN_CNT);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
smp->data.u.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
}
return 1;
}
@ -3096,12 +3096,12 @@ smp_fetch_sc_bytes_in_rate(const struct arg *args, struct sample *smp, const cha
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_IN_RATE);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
stkctr->table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
}
return 1;
@ -3121,12 +3121,12 @@ smp_fetch_sc_kbytes_out(const struct arg *args, struct sample *smp, const char *
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_OUT_CNT);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
smp->data.u.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
}
return 1;
}
@ -3145,12 +3145,12 @@ smp_fetch_sc_bytes_out_rate(const struct arg *args, struct sample *smp, const ch
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = 0;
smp->data.u.sint = 0;
if (stkctr_entry(stkctr) != NULL) {
void *ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_OUT_RATE);
if (!ptr)
return 0; /* parameter not stored */
smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
stkctr->table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
}
return 1;
@ -3169,7 +3169,7 @@ smp_fetch_sc_trackers(const struct arg *args, struct sample *smp, const char *kw
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = stkctr_entry(stkctr)->ref_cnt;
smp->data.u.sint = stkctr_entry(stkctr)->ref_cnt;
return 1;
}
@ -3181,7 +3181,7 @@ smp_fetch_table_cnt(const struct arg *args, struct sample *smp, const char *kw,
{
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = args->data.prx->table.current;
smp->data.u.sint = args->data.prx->table.current;
return 1;
}
@ -3196,7 +3196,7 @@ smp_fetch_table_avl(const struct arg *args, struct sample *smp, const char *kw,
px = args->data.prx;
smp->flags = SMP_F_VOL_TEST;
smp->data.type = SMP_T_SINT;
smp->data.data.sint = px->table.size - px->table.current;
smp->data.u.sint = px->table.size - px->table.current;
return 1;
}

64
src/vars.c
View File

@ -83,12 +83,12 @@ void vars_prune(struct vars *vars, struct stream *strm)
list_for_each_entry_safe(var, tmp, &vars->head, l) {
if (var->data.type == SMP_T_STR ||
var->data.type == SMP_T_BIN) {
free(var->data.data.str.str);
size += var->data.data.str.len;
free(var->data.u.str.str);
size += var->data.u.str.len;
}
else if (var->data.type == SMP_T_METH) {
free(var->data.data.meth.str.str);
size += var->data.data.meth.str.len;
free(var->data.u.meth.str.str);
size += var->data.u.meth.str.len;
}
LIST_DEL(&var->l);
pool_free2(var_pool, var);
@ -108,12 +108,12 @@ void vars_prune_per_sess(struct vars *vars)
list_for_each_entry_safe(var, tmp, &vars->head, l) {
if (var->data.type == SMP_T_STR ||
var->data.type == SMP_T_BIN) {
free(var->data.data.str.str);
size += var->data.data.str.len;
free(var->data.u.str.str);
size += var->data.u.str.len;
}
else if (var->data.type == SMP_T_METH) {
free(var->data.data.meth.str.str);
size += var->data.data.meth.str.len;
free(var->data.u.meth.str.str);
size += var->data.u.meth.str.len;
}
LIST_DEL(&var->l);
pool_free2(var_pool, var);
@ -251,7 +251,7 @@ static int smp_fetch_var(const struct arg *args, struct sample *smp, const char
/* Copy sample. */
smp->data.type = var->data.type;
smp->flags |= SMP_F_CONST;
memcpy(&smp->data.data, &var->data.data, sizeof(smp->data.data));
memcpy(&smp->data.u, &var->data.u, sizeof(smp->data.u));
return 1;
}
@ -271,12 +271,12 @@ static int sample_store(struct vars *vars, const char *name, struct stream *strm
/* free its used memory. */
if (var->data.type == SMP_T_STR ||
var->data.type == SMP_T_BIN) {
free(var->data.data.str.str);
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -var->data.data.str.len);
free(var->data.u.str.str);
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -var->data.u.str.len);
}
else if (var->data.type == SMP_T_METH) {
free(var->data.data.meth.str.str);
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -var->data.data.meth.str.len);
free(var->data.u.meth.str.str);
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -var->data.u.meth.str.len);
}
} else {
@ -299,44 +299,44 @@ static int sample_store(struct vars *vars, const char *name, struct stream *strm
switch (var->data.type) {
case SMP_T_BOOL:
case SMP_T_SINT:
var->data.data.sint = smp->data.data.sint;
var->data.u.sint = smp->data.u.sint;
break;
case SMP_T_IPV4:
var->data.data.ipv4 = smp->data.data.ipv4;
var->data.u.ipv4 = smp->data.u.ipv4;
break;
case SMP_T_IPV6:
var->data.data.ipv6 = smp->data.data.ipv6;
var->data.u.ipv6 = smp->data.u.ipv6;
break;
case SMP_T_STR:
case SMP_T_BIN:
if (!var_accounting_add(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, smp->data.data.str.len)) {
if (!var_accounting_add(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, smp->data.u.str.len)) {
var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
return 0;
}
var->data.data.str.str = malloc(smp->data.data.str.len);
if (!var->data.data.str.str) {
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -smp->data.data.str.len);
var->data.u.str.str = malloc(smp->data.u.str.len);
if (!var->data.u.str.str) {
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -smp->data.u.str.len);
var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
return 0;
}
var->data.data.str.len = smp->data.data.str.len;
memcpy(var->data.data.str.str, smp->data.data.str.str, var->data.data.str.len);
var->data.u.str.len = smp->data.u.str.len;
memcpy(var->data.u.str.str, smp->data.u.str.str, var->data.u.str.len);
break;
case SMP_T_METH:
if (!var_accounting_add(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, smp->data.data.meth.str.len)) {
if (!var_accounting_add(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, smp->data.u.meth.str.len)) {
var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
return 0;
}
var->data.data.meth.str.str = malloc(smp->data.data.meth.str.len);
if (!var->data.data.meth.str.str) {
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -smp->data.data.meth.str.len);
var->data.u.meth.str.str = malloc(smp->data.u.meth.str.len);
if (!var->data.u.meth.str.str) {
var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -smp->data.u.meth.str.len);
var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
return 0;
}
var->data.data.meth.meth = smp->data.data.meth.meth;
var->data.data.meth.str.len = smp->data.data.meth.str.len;
var->data.data.meth.str.size = smp->data.data.meth.str.len;
memcpy(var->data.data.meth.str.str, smp->data.data.meth.str.str, var->data.data.meth.str.len);
var->data.u.meth.meth = smp->data.u.meth.meth;
var->data.u.meth.str.len = smp->data.u.meth.str.len;
var->data.u.meth.str.size = smp->data.u.meth.str.len;
memcpy(var->data.u.meth.str.str, smp->data.u.meth.str.str, var->data.u.meth.str.len);
break;
}
return 1;
@ -444,7 +444,7 @@ int vars_get_by_name(const char *name, size_t len, struct stream *strm, struct s
/* Copy sample. */
smp->data.type = var->data.type;
smp->flags = SMP_F_CONST;
memcpy(&smp->data.data, &var->data.data, sizeof(smp->data.data));
memcpy(&smp->data.u, &var->data.u, sizeof(smp->data.u));
return 1;
}
@ -478,7 +478,7 @@ int vars_get_by_desc(const struct var_desc *var_desc, struct stream *strm, struc
/* Copy sample. */
smp->data.type = var->data.type;
smp->flags = SMP_F_CONST;
memcpy(&smp->data.data, &var->data.data, sizeof(smp->data.data));
memcpy(&smp->data.u, &var->data.u, sizeof(smp->data.u));
return 1;
}