/* 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,
/* 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)
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);
/* 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);
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;
}
}
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++;
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;
}
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;
}
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)
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);
}
{
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;
}
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;
}
{
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;
}
{
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;
}
{
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;
}
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;
}
{
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;
}
{
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;
}
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;
}
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;
}
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;
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;
}
/* 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);
{
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;
}
{
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;
}
{
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;
}
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;
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);
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;
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;
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, "");
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;
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:
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;
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);
}
/* 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;
}
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;
}
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;
}
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;
*/
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;
*/
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;
*/
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;
}
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;
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;
}
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;
}
/* 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;
/* 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) {
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;
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;
}
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;
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;
}
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;
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;
}
/* 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) {
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;
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;
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;
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;
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;
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) {
}
}
} 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) {
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;
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;
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;
/* 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) {
*/
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) {
/* 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);
* - ::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.
/* 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
* - ::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;
return 0;
}
smp->data.type = SMP_T_BOOL;
- smp->data.data.sint = 1;
+ smp->data.u.sint = 1;
return 1;
}
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;
}
/* 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;
}
}
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;
* 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;
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;
}
}
/* 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++;
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;
smp->flags = SMP_F_VOLATILE;
smp->data.type = SMP_T_SINT;
- smp->data.data.sint = ret;
+ smp->data.u.sint = ret;
return 1;
}
/* 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:
/* 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;
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;
}
}
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;
}
}
/* everything's OK */
- smp->data.data.sint = 1;
+ smp->data.u.sint = 1;
return 1;
}
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;
/* 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;
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;
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;
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;
}
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 {
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;
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;
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;
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;
}
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;
}
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;
}
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;
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;
}
}
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;
}
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;
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;
}
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;
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;
}
/* 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;
}
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;
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;
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;
}
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) {
return 0;
}
- smp->data.data.str = *temp;
+ smp->data.u.str = *temp;
smp->data.type = SMP_T_BIN;
return 1;
}
} 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;
}
CHECK_HTTP_MESSAGE_FIRST_PERM();
smp->data.type = SMP_T_BOOL;
- smp->data.data.sint = 1;
+ smp->data.u.sint = 1;
return 1;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
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;
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;
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;
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;
}
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;
}
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;
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;
}
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;
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;
}
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));
return 0;
}
- smp->data.data.str = *temp;
+ smp->data.u.str = *temp;
smp->data.type = SMP_T_BIN;
return 1;
}
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))
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;
}
/* 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;
* 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) {
* 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;
}
/* 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. */
* 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;
}
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;
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;
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;
}
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;
}
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;
}
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 {
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:
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;
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:
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;
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;
}
{
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;
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;
{
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;
/*
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;
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;
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;
{
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;
}
}
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;
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. */
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;
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;
}
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;
}
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;
}
{
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;
}
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);
}
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;
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;
/* 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;
}
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;
}
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;
}
/* 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;
}
{
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 */
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;
}
/* 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;
}
{
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 */
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;
}
/* 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;
}
/* 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;
}
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. */
}
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)
}
smp->flags &= ~SMP_F_CONST;
- smp->data.data.str = *temp;
+ smp->data.u.str = *temp;
smp->data.type = SMP_T_STR;
return 1;
* 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;
}
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]) {
/* 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;
}
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]) {
/* 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;
}
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) {
flag |= REG_NOTBOL;
}
- smp->data.data.str = *trash;
+ smp->data.u.str = *trash;
return 1;
}
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))
*/
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;
}
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;
}
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;
}
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;
}
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;
}
* 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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
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;
}
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;
}
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;
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;
}
{
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;
}
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;
}
{
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;
}
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;
}
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;
}
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:
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:
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:
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:
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 */
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:
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 */
}
smp->data.type = SMP_T_BOOL;
- smp->data.data.sint = (crt != NULL);
+ smp->data.u.sint = (crt != NULL);
return 1;
}
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);
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);
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);
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);
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);
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;
}
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;
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;
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;
}
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;
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;
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;
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;
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;
}
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;
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;
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;
}
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;
}
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;
}
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;
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;
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;
}
}
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;
}
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;
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];
}
{
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;
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;
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;
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;
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 &&
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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 */
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;
}
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;
}
{
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;
}
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;
}
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;
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);
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)
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);
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);
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;
}
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;
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;
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;
}
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;
}
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;
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;
}
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;
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;
}
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;
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;
}
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;
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;
}
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;
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;
}
{
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;
}
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;
}
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);
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);
/* 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;
}
/* 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 {
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;
/* 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;
}
/* 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;
}
projects / thirdparty / haproxy.git / commitdiff
