static inline
int sample_convert(struct sample *sample, int req_type)
{
- if (!sample_casts[sample->type][req_type])
+ if (!sample_casts[sample->data.type][req_type])
return 0;
- if (sample_casts[sample->type][req_type] == c_none)
+ if (sample_casts[sample->data.type][req_type] == c_none)
return 1;
- return sample_casts[sample->type][req_type](sample);
+ return sample_casts[sample->data.type][req_type](sample);
}
#endif /* _PROTO_SAMPLE_H */
struct chunk str;
};
-/* a sample is a typed data extracted from a stream. It has a type, contents,
- * validity constraints, a context for use in iterative calls.
- */
-struct sample {
- unsigned int flags; /* SMP_F_* */
+/* Used to store sample constant */
+struct sample_data {
int type; /* SMP_T_* */
union {
long long int sint; /* used for signed 64bits integers */
struct chunk str; /* used for char strings or buffers */
struct meth meth; /* used for http method */
} data; /* sample data */
+};
+
+/* a sample is a typed data extracted from a stream. It has a type, contents,
+ * validity constraints, a context for use in iterative calls.
+ */
+struct sample {
+ unsigned int flags; /* SMP_F_* */
+ struct sample_data data;
union smp_ctx ctx;
/* Some sample analyzer (sample-fetch or converters) needs to
unsigned int opt; /* fetch options (SMP_OPT_*) */
};
-/* Used to store sample constant */
-struct sample_data {
- int type; /* SMP_T_* */
- union {
- long long int sint; /* used for signed 64bits integers */
- struct in_addr ipv4; /* used for ipv4 addresses */
- struct in6_addr ipv6; /* used for ipv6 addresses */
- struct chunk str; /* used for char strings or buffers */
- struct meth meth; /* used for http method */
- } data; /* sample data */
-};
-
/* Descriptor for a sample conversion */
struct sample_conv {
const char *kw; /* configuration keyword */
/* Browse the userlist for searching user. */
for (u = ul->users; u; u = u->next) {
- if (strcmp(smp->data.str.str, u->user) == 0)
+ if (strcmp(smp->data.data.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.str.len;
+ len = smp.data.data.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.str.str, len);
+ hash = gen_hash(px, smp.data.data.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.str.len >= smp->data.str.size)
- smp->data.str.len = smp->data.str.size - 1;
- smp->data.str.str[smp->data.str.len] = 0;
- ssl_sock_set_servername(srv_conn, smp->data.str.str);
+ 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);
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.str.len == 0)
+ if (ret == 0 || (smp.flags & SMP_F_MAY_CHANGE) || smp.data.data.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.str.str, &p, 10);
+ addr.sin_addr.s_addr = strtoul(smp.data.data.str.str, &p, 10);
if (*p != '.')
goto no_cookie;
p++;
struct proxy *px;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
+ smp->data.type = SMP_T_SINT;
px = args->data.prx;
if (px->srv_act)
- smp->data.sint = px->srv_act;
+ smp->data.data.sint = px->srv_act;
else if (px->lbprm.fbck)
- smp->data.sint = 1;
+ smp->data.data.sint = 1;
else
- smp->data.sint = px->srv_bck;
+ smp->data.data.sint = px->srv_bck;
return 1;
}
struct server *srv = args->data.srv;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_BOOL;
+ 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.sint = 1;
+ smp->data.data.sint = 1;
else
- smp->data.sint = 0;
+ smp->data.data.sint = 0;
return 1;
}
struct server *iterator;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = -1; /* FIXME: stupid value! */
+ smp->data.data.sint = -1; /* FIXME: stupid value! */
return 1;
}
- smp->data.sint += (iterator->maxconn - iterator->cur_sess)
+ smp->data.data.sint += (iterator->maxconn - iterator->cur_sess)
+ (iterator->maxqueue - iterator->nbpend);
}
smp_fetch_be_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TXN;
- smp->type = SMP_T_SINT;
- smp->data.sint = smp->strm->be->uuid;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = smp->strm->be->uuid;
return 1;
}
if (!objt_server(smp->strm->target))
return 0;
- smp->type = SMP_T_SINT;
- smp->data.sint = objt_server(smp->strm->target)->puid;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = objt_server(smp->strm->target)->puid;
return 1;
}
smp_fetch_be_sess_rate(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = read_freq_ctr(&args->data.prx->be_sess_per_sec);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = read_freq_ctr(&args->data.prx->be_sess_per_sec);
return 1;
}
smp_fetch_be_conn(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = args->data.prx->beconn;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = args->data.prx->beconn;
return 1;
}
smp_fetch_queue_size(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = args->data.prx->totpend;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = args->data.prx->totpend;
return 1;
}
struct proxy *px;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
+ smp->data.type = SMP_T_SINT;
px = args->data.prx;
if (px->srv_act)
nbsrv = px->srv_bck;
if (nbsrv > 0)
- smp->data.sint = (px->totpend + nbsrv - 1) / nbsrv;
+ smp->data.data.sint = (px->totpend + nbsrv - 1) / nbsrv;
else
- smp->data.sint = px->totpend * 2;
+ smp->data.data.sint = px->totpend * 2;
return 1;
}
smp_fetch_srv_conn(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = args->data.srv->cur_sess;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = args->data.srv->cur_sess;
return 1;
}
smp_fetch_srv_sess_rate(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = read_freq_ctr(&args->data.srv->sess_per_sec);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = read_freq_ctr(&args->data.srv->sess_per_sec);
return 1;
}
static int
smp_fetch_res_comp(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_BOOL;
- smp->data.sint = (smp->strm->comp_algo != NULL);
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = (smp->strm->comp_algo != NULL);
return 1;
}
if (!smp->strm->comp_algo)
return 0;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
- smp->data.str.str = smp->strm->comp_algo->cfg_name;
- smp->data.str.len = smp->strm->comp_algo->cfg_name_len;
+ smp->data.data.str.str = smp->strm->comp_algo->cfg_name;
+ smp->data.data.str.len = smp->strm->comp_algo->cfg_name_len;
return 1;
}
tmp = get_trash_chunk();
chunk_reset(tmp);
- i = smp->data.str.len > sizeof(useragentbuf) ? sizeof(useragentbuf) : smp->data.str.len;
- memcpy(useragentbuf, smp->data.str.str, i - 1);
+ i = smp->data.data.str.len > sizeof(useragentbuf) ? sizeof(useragentbuf) : smp->data.data.str.len;
+ memcpy(useragentbuf, smp->data.data.str.str, i - 1);
useragentbuf[i - 1] = 0;
useragent = (const char *)useragentbuf;
tmp->str[tmp->len] = 0;
}
- smp->data.str.str = tmp->str;
- smp->data.str.len = strlen(tmp->str);
+ smp->data.data.str.str = tmp->str;
+ smp->data.data.str.len = strlen(tmp->str);
return 1;
}
chunk_reset(&trash);
/* execute pattern matching */
- sample.type = SMP_T_STR;
+ sample.data.type = SMP_T_STR;
sample.flags |= SMP_F_CONST;
- sample.data.str.len = appctx->ctx.map.chunk.len;
- sample.data.str.str = appctx->ctx.map.chunk.str;
+ sample.data.data.str.len = appctx->ctx.map.chunk.len;
+ sample.data.data.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_fetch_fe_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_SESS;
- smp->type = SMP_T_SINT;
- smp->data.sint = smp->sess->fe->uuid;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = smp->sess->fe->uuid;
return 1;
}
smp_fetch_fe_sess_rate(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = read_freq_ctr(&args->data.prx->fe_sess_per_sec);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = read_freq_ctr(&args->data.prx->fe_sess_per_sec);
return 1;
}
smp_fetch_fe_conn(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = args->data.prx->feconn;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = args->data.prx->feconn;
return 1;
}
*/
static int hlua_smp2lua(lua_State *L, struct sample *smp)
{
- switch (smp->type) {
+ switch (smp->data.type) {
case SMP_T_SINT:
case SMP_T_BOOL:
- lua_pushinteger(L, smp->data.sint);
+ lua_pushinteger(L, smp->data.data.sint);
break;
case SMP_T_BIN:
case SMP_T_STR:
- lua_pushlstring(L, smp->data.str.str, smp->data.str.len);
+ lua_pushlstring(L, smp->data.data.str.str, smp->data.data.str.len);
break;
case SMP_T_METH:
- switch (smp->data.meth.meth) {
+ switch (smp->data.data.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.meth.str.str, smp->data.meth.str.len);
+ lua_pushlstring(L, smp->data.data.meth.str.str, smp->data.data.meth.str.len);
break;
default:
lua_pushnil(L);
case SMP_T_IPV4:
case SMP_T_IPV6:
case SMP_T_ADDR: /* This type is never used to qualify a sample. */
- if (sample_casts[smp->type][SMP_T_STR] &&
- sample_casts[smp->type][SMP_T_STR](smp))
- lua_pushlstring(L, smp->data.str.str, smp->data.str.len);
+ 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);
else
lua_pushnil(L);
break;
*/
static int hlua_smp2lua_str(lua_State *L, struct sample *smp)
{
- switch (smp->type) {
+ switch (smp->data.type) {
case SMP_T_BIN:
case SMP_T_STR:
- lua_pushlstring(L, smp->data.str.str, smp->data.str.len);
+ lua_pushlstring(L, smp->data.data.str.str, smp->data.data.str.len);
break;
case SMP_T_METH:
- switch (smp->data.meth.meth) {
+ switch (smp->data.data.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.meth.str.str, smp->data.meth.str.len);
+ lua_pushlstring(L, smp->data.data.meth.str.str, smp->data.data.meth.str.len);
break;
default:
lua_pushstring(L, "");
case SMP_T_IPV4:
case SMP_T_IPV6:
case SMP_T_ADDR: /* This type is never used to qualify a sample. */
- if (sample_casts[smp->type][SMP_T_STR] &&
- sample_casts[smp->type][SMP_T_STR](smp))
- lua_pushlstring(L, smp->data.str.str, smp->data.str.len);
+ 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);
else
lua_pushstring(L, "");
break;
switch (lua_type(L, ud)) {
case LUA_TNUMBER:
- smp->type = SMP_T_SINT;
- smp->data.sint = lua_tointeger(L, ud);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = lua_tointeger(L, ud);
break;
case LUA_TBOOLEAN:
- smp->type = SMP_T_BOOL;
- smp->data.sint = lua_toboolean(L, ud);
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = lua_toboolean(L, ud);
break;
case LUA_TSTRING:
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
- smp->data.str.str = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.str.len);
+ smp->data.data.str.str = (char *)lua_tolstring(L, ud, (size_t *)&smp->data.data.str.len);
break;
case LUA_TUSERDATA:
case LUA_TFUNCTION:
case LUA_TTHREAD:
case LUA_TLIGHTUSERDATA:
- smp->type = SMP_T_BOOL;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = 0;
break;
}
return 1;
MAY_LJMP(check_args(L, 2, "lookup"));
desc = MAY_LJMP(hlua_checkmap(L, 1));
if (desc->pat.expect_type == SMP_T_SINT) {
- smp.type = SMP_T_SINT;
- smp.data.sint = MAY_LJMP(luaL_checkinteger(L, 2));
+ smp.data.type = SMP_T_SINT;
+ smp.data.data.sint = MAY_LJMP(luaL_checkinteger(L, 2));
}
else {
- smp.type = SMP_T_STR;
+ smp.data.type = SMP_T_STR;
smp.flags = SMP_F_CONST;
- smp.data.str.str = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.str.len));
+ smp.data.data.str.str = (char *)MAY_LJMP(luaL_checklstring(L, 2, (size_t *)&smp.data.data.str.len));
}
pat = pattern_exec_match(&desc->pat, &smp, 1);
}
/* Apply expected cast. */
- if (!sample_casts[smp.type][conv->in_type]) {
+ if (!sample_casts[smp.data.type][conv->in_type]) {
hlua_pusherror(L, "invalid input argument: cannot cast '%s' to '%s'",
- smp_to_type[smp.type], smp_to_type[conv->in_type]);
+ smp_to_type[smp.data.type], smp_to_type[conv->in_type]);
WILL_LJMP(lua_error(L));
}
- if (sample_casts[smp.type][conv->in_type] != c_none &&
- !sample_casts[smp.type][conv->in_type](&smp)) {
+ if (sample_casts[smp.data.type][conv->in_type] != c_none &&
+ !sample_casts[smp.data.type][conv->in_type](&smp)) {
hlua_pusherror(L, "error during the input argument casting");
WILL_LJMP(lua_error(L));
}
static int
smp_fetch_dconn(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_SINT;
- smp->data.sint = smp->sess->listener->nbconn;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = smp->sess->listener->nbconn;
return 1;
}
static int
smp_fetch_so_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_SINT;
- smp->data.sint = smp->sess->listener->luid;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.str : &empty);
+ '%', http_encode_map, key ? &key->data.data.str : &empty);
else
- ret = lf_text_len(tmplog, key ? key->data.str.str : NULL, key ? key->data.str.len : 0, dst + maxsize - tmplog, tmp);
+ ret = lf_text_len(tmplog, key ? key->data.data.str.str : NULL, key ? key->data.data.str.len : 0, dst + maxsize - tmplog, tmp);
if (ret == 0)
goto out;
tmplog = ret;
if (pat) {
/* Copy sample. */
if (pat->data) {
- smp->type = pat->data->type;
+ smp->data.type = pat->data->type;
smp->flags |= SMP_F_CONST;
- memcpy(&smp->data, &pat->data->data, sizeof(smp->data));
+ memcpy(&smp->data.data, &pat->data->data, sizeof(smp->data.data));
return 1;
}
/* Return just int sample containing 1. */
- smp->type = SMP_T_SINT;
- smp->data.sint = 1;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 1;
return 1;
}
switch (desc->conv->out_type) {
case SMP_T_STR:
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
- smp->data.str = arg_p[1].data.str;
+ smp->data.data.str = arg_p[1].data.str;
break;
case SMP_T_SINT:
- smp->type = SMP_T_SINT;
- smp->data.sint = arg_p[1].data.sint;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = arg_p[1].data.sint;
break;
case SMP_T_IPV4:
- smp->type = SMP_T_IPV4;
- smp->data.ipv4 = arg_p[1].data.ipv4;
+ smp->data.type = SMP_T_IPV4;
+ smp->data.data.ipv4 = arg_p[1].data.ipv4;
break;
case SMP_T_IPV6:
- smp->type = SMP_T_IPV6;
- smp->data.ipv6 = arg_p[1].data.ipv6;
+ smp->data.type = SMP_T_IPV6;
+ smp->data.data.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.sint) {
+ if (smp->data.data.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.str.str[smp->data.str.len];
+ prev = smp->data.data.str.str[smp->data.data.str.len];
if (prev)
- smp->data.str.str[smp->data.str.len] = '\0';
- node = ebst_lookup(&expr->pattern_tree, smp->data.str.str);
+ smp->data.data.str.str[smp->data.data.str.len] = '\0';
+ node = ebst_lookup(&expr->pattern_tree, smp->data.data.str.str);
if (prev)
- smp->data.str.str[smp->data.str.len] = prev;
+ smp->data.data.str.str[smp->data.data.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.str.str, smp->data.str.len, seed),
+ lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.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.str.len)
+ if (pattern->len != smp->data.data.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
- if ((icase && strncasecmp(pattern->ptr.str, smp->data.str.str, smp->data.str.len) == 0) ||
- (!icase && strncmp(pattern->ptr.str, smp->data.str.str, smp->data.str.len) == 0)) {
+ 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)) {
ret = pattern;
break;
}
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
- lru = lru64_get(XXH64(smp->data.str.str, smp->data.str.len, seed),
+ lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.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.str.len)
+ if (pattern->len != smp->data.data.str.len)
continue;
- if (memcmp(pattern->ptr.str, smp->data.str.str, smp->data.str.len) == 0) {
+ if (memcmp(pattern->ptr.str, smp->data.data.str.str, smp->data.data.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.str.str, smp->data.str.len, seed),
+ lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.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.str.str, smp->data.str.len)) {
+ if (regex_exec2(pattern->ptr.reg, smp->data.data.str.str, smp->data.data.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.str.str[smp->data.str.len];
+ prev = smp->data.data.str.str[smp->data.data.str.len];
if (prev)
- smp->data.str.str[smp->data.str.len] = '\0';
- node = ebmb_lookup_longest(&expr->pattern_tree, smp->data.str.str);
+ smp->data.data.str.str[smp->data.data.str.len] = '\0';
+ node = ebmb_lookup_longest(&expr->pattern_tree, smp->data.data.str.str);
if (prev)
- smp->data.str.str[smp->data.str.len] = prev;
+ smp->data.data.str.str[smp->data.data.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.str.str, smp->data.str.len, seed),
+ lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.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.str.len)
+ if (pattern->len > smp->data.data.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
- if ((icase && strncasecmp(pattern->ptr.str, smp->data.str.str, pattern->len) != 0) ||
- (!icase && strncmp(pattern->ptr.str, smp->data.str.str, pattern->len) != 0))
+ 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))
continue;
ret = pattern;
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
- lru = lru64_get(XXH64(smp->data.str.str, smp->data.str.len, seed),
+ lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.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.str.len)
+ if (pattern->len > smp->data.data.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
- if ((icase && strncasecmp(pattern->ptr.str, smp->data.str.str + smp->data.str.len - pattern->len, pattern->len) != 0) ||
- (!icase && strncmp(pattern->ptr.str, smp->data.str.str + smp->data.str.len - pattern->len, pattern->len) != 0))
+ 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))
continue;
ret = pattern;
if (pat_lru_tree) {
unsigned long long seed = pat_lru_seed ^ (long)expr;
- lru = lru64_get(XXH64(smp->data.str.str, smp->data.str.len, seed),
+ lru = lru64_get(XXH64(smp->data.data.str.str, smp->data.data.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.str.len)
+ if (pattern->len > smp->data.data.str.len)
continue;
- end = smp->data.str.str + smp->data.str.len - pattern->len;
+ end = smp->data.data.str.str + smp->data.data.str.len - pattern->len;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
if (icase) {
- for (c = smp->data.str.str; c <= end; c++) {
+ for (c = smp->data.data.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.str.str; c <= end; c++) {
+ for (c = smp->data.data.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.str.len)
+ if (pl > smp->data.data.str.len)
return PAT_NOMATCH;
may_match = 1;
icase = mflags & PAT_MF_IGNORE_CASE;
- end = smp->data.str.str + smp->data.str.len - pl;
- for (c = smp->data.str.str; c <= end; c++) {
+ end = smp->data.data.str.str + smp->data.data.str.len - pl;
+ for (c = smp->data.data.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.sint) &&
- (!pattern->val.range.max_set || smp->data.sint <= pattern->val.range.max))
+ 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))
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.str.len) &&
- (!pattern->val.range.max_set || smp->data.str.len <= pattern->val.range.max))
+ 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))
return pattern;
}
return NULL;
struct pattern *pattern;
/* The input sample is IPv4. Try to match in the trees. */
- if (smp->type == SMP_T_IPV4) {
+ if (smp->data.type == SMP_T_IPV4) {
/* Lookup an IPv4 address in the expression's pattern tree using
* the longest match method.
*/
- s = &smp->data.ipv4;
+ s = &smp->data.data.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.ipv4.s_addr;
+ *(uint32_t*)&tmp6.s6_addr[12] = smp->data.data.ipv4.s_addr;
node = ebmb_lookup_longest(&expr->pattern_tree_2, &tmp6);
if (node) {
if (fill) {
}
/* The input sample is IPv6. Try to match in the trees. */
- if (smp->type == SMP_T_IPV6) {
+ if (smp->data.type == SMP_T_IPV6) {
/* 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.ipv6);
+ node = ebmb_lookup_longest(&expr->pattern_tree_2, &smp->data.data.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.ipv6.s6_addr[0] == 0 &&
- *(uint32_t*)&smp->data.ipv6.s6_addr[4] == 0 &&
- (*(uint32_t*)&smp->data.ipv6.s6_addr[8] == 0 ||
- *(uint32_t*)&smp->data.ipv6.s6_addr[8] == htonl(0xFFFF))) ||
- *(uint16_t*)&smp->data.ipv6.s6_addr[0] == htons(0x2002)) {
- if (*(uint32_t*)&smp->data.ipv6.s6_addr[0] == 0)
- v4 = *(uint32_t*)&smp->data.ipv6.s6_addr[12];
+ 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];
else
- v4 = htonl((ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[2]) << 16) +
- ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[4]));
+ v4 = htonl((ntohs(*(uint16_t*)&smp->data.data.ipv6.s6_addr[2]) << 16) +
+ ntohs(*(uint16_t*)&smp->data.data.ipv6.s6_addr[4]));
/* Lookup an IPv4 address in the expression's pattern tree using the longest
* match method.
pattern = &lst->pat;
/* The input sample is IPv4, use it as is. */
- if (smp->type == SMP_T_IPV4) {
- v4 = smp->data.ipv4.s_addr;
+ if (smp->data.type == SMP_T_IPV4) {
+ v4 = smp->data.data.ipv4.s_addr;
}
- else if (smp->type == SMP_T_IPV6) {
+ else if (smp->data.type == SMP_T_IPV6) {
/* v4 match on a V6 sample. We want to check at least for
* the following forms :
* - ::ffff:ip:v4 (ipv4 mapped)
* - ::0000:ip:v4 (old ipv4 mapped)
* - 2002:ip:v4:: (6to4)
*/
- if (*(uint32_t*)&smp->data.ipv6.s6_addr[0] == 0 &&
- *(uint32_t*)&smp->data.ipv6.s6_addr[4] == 0 &&
- (*(uint32_t*)&smp->data.ipv6.s6_addr[8] == 0 ||
- *(uint32_t*)&smp->data.ipv6.s6_addr[8] == htonl(0xFFFF))) {
- v4 = *(uint32_t*)&smp->data.ipv6.s6_addr[12];
+ 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];
}
- else if (*(uint16_t*)&smp->data.ipv6.s6_addr[0] == htons(0x2002)) {
- v4 = htonl((ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[2]) << 16) +
- ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[4]));
+ 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
continue;
smp->flags |= SMP_F_MAY_CHANGE;
return 0;
}
- smp->type = SMP_T_BOOL;
- smp->data.sint = 1;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = 1;
return 1;
}
if (!chn->buf)
return 0;
- smp->type = SMP_T_SINT;
- smp->data.sint = chn->buf->i;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = chn->buf->i;
smp->flags = SMP_F_VOLATILE | SMP_F_MAY_CHANGE;
return 1;
}
/* Elliptic curves extension */
if (ext_type == 10) {
- smp->type = SMP_T_BOOL;
- smp->data.sint = 1;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = 1;
smp->flags = SMP_F_VOLATILE;
return 1;
}
goto not_ssl_hello;
}
- smp->type = SMP_T_SINT;
- smp->data.sint = hs_type;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = hs_type;
smp->flags = SMP_F_VOLATILE;
return 1;
/* OK that's enough. We have at least the whole message, and we have
* the protocol version.
*/
- smp->type = SMP_T_SINT;
- smp->data.sint = version;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = version;
smp->flags = SMP_F_VOLATILE;
return 1;
name_len = (data[7] << 8) + data[8];
if (name_type == 0) { /* hostname */
- smp->type = SMP_T_STR;
- smp->data.str.str = (char *)data + 9;
- smp->data.str.len = name_len;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str.str = (char *)data + 9;
+ smp->data.data.str.len = name_len;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
return 1;
}
return 0;
smp->flags = SMP_F_CONST;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
bleft = s->req.buf->i;
if (bleft <= 11)
}
/* data points to cookie value */
- smp->data.str.str = (char *)data;
- smp->data.str.len = 0;
+ smp->data.data.str.str = (char *)data;
+ smp->data.data.str.len = 0;
while (bleft > 0 && *data != '\r') {
data++;
if (data[0] != '\r' || data[1] != '\n')
goto not_cookie;
- smp->data.str.len = (char *)data - smp->data.str.str;
+ smp->data.data.str.len = (char *)data - smp->data.data.str.str;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
return 1;
return 0;
smp->flags = SMP_F_VOLATILE;
- smp->type = SMP_T_SINT;
- smp->data.sint = ret;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = ret;
return 1;
}
goto too_short;
/* init chunk as read only */
- smp->type = SMP_T_BIN;
+ smp->data.type = SMP_T_BIN;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
- chunk_initlen(&smp->data.str, chn->buf->p + buf_offset, 0, buf_size);
+ chunk_initlen(&smp->data.data.str, chn->buf->p + buf_offset, 0, buf_size);
return 1;
too_short:
goto too_short;
/* init chunk as read only */
- smp->type = SMP_T_BIN;
+ smp->data.type = SMP_T_BIN;
smp->flags = SMP_F_VOLATILE | SMP_F_CONST;
- chunk_initlen(&smp->data.str, chn->buf->p + buf_offset, 0, buf_size ? buf_size : (chn->buf->i - buf_offset));
+ chunk_initlen(&smp->data.data.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;
smp = sample_fetch_as_type(px, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->arg.act.p[0], SMP_T_ADDR);
if (smp) {
- if (smp->type == SMP_T_IPV4) {
+ 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.ipv4.s_addr;
+ ((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_port = 0;
- } else if (smp->type == SMP_T_IPV6) {
+ } 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.ipv6, sizeof(struct in6_addr));
+ memcpy(&((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_addr, &smp->data.data.ipv6, sizeof(struct in6_addr));
((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_port = 0;
}
}
msg = &txn->req;
/* Check for a dependency on a request */
- smp->type = SMP_T_BOOL;
+ smp->data.type = SMP_T_BOOL;
if ((opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ) {
/* If the buffer does not leave enough free space at the end,
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.sint = 1;
+ smp->data.data.sint = 1;
return 1;
}
}
/* everything's OK */
- smp->data.sint = 1;
+ smp->data.data.sint = 1;
return 1;
}
CHECK_HTTP_MESSAGE_FIRST_PERM();
meth = txn->meth;
- smp->type = SMP_T_METH;
- smp->data.meth.meth = meth;
+ smp->data.type = SMP_T_METH;
+ smp->data.data.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.meth.str.len = txn->req.sl.rq.m_l;
- smp->data.meth.str.str = txn->req.chn->buf->p;
+ smp->data.data.meth.str.len = txn->req.sl.rq.m_l;
+ smp->data.data.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.meth.meth == pattern->val.i)
+ if (smp->data.data.meth.meth == pattern->val.i)
return pattern;
else
continue;
}
/* Other method, we must compare the strings */
- if (pattern->len != smp->data.meth.str.len)
+ if (pattern->len != smp->data.data.meth.str.len)
continue;
icase = expr->mflags & PAT_MF_IGNORE_CASE;
- if ((icase && strncasecmp(pattern->ptr.str, smp->data.meth.str.str, smp->data.meth.str.len) == 0) ||
- (!icase && strncmp(pattern->ptr.str, smp->data.meth.str.str, smp->data.meth.str.len) == 0))
+ 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))
return pattern;
}
return NULL;
if (len <= 0)
return 0;
- smp->type = SMP_T_STR;
- smp->data.str.str = ptr;
- smp->data.str.len = len;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str.str = ptr;
+ smp->data.data.str.len = len;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
if (len <= 0)
return 0;
- smp->type = SMP_T_STR;
- smp->data.str.str = ptr;
- smp->data.str.len = len;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str.str = ptr;
+ smp->data.data.str.len = len;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
len = txn->rsp.sl.st.c_l;
ptr = txn->rsp.chn->buf->p + txn->rsp.sl.st.c;
- smp->type = SMP_T_SINT;
- smp->data.sint = __strl2ui(ptr, len);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = __strl2ui(ptr, len);
smp->flags = SMP_F_VOL_1ST;
return 1;
}
if (block1 == len) {
/* buffer is not wrapped (or empty) */
- smp->type = SMP_T_BIN;
- smp->data.str.str = body;
- smp->data.str.len = len;
+ smp->data.type = SMP_T_BIN;
+ smp->data.data.str.str = body;
+ smp->data.data.str.len = len;
smp->flags = SMP_F_VOL_TEST | SMP_F_CONST;
}
else {
temp = get_trash_chunk();
memcpy(temp->str, body, block1);
memcpy(temp->str + block1, msg->chn->buf->data, len - block1);
- smp->type = SMP_T_BIN;
- smp->data.str.str = temp->str;
- smp->data.str.len = len;
+ smp->data.type = SMP_T_BIN;
+ smp->data.data.str.str = temp->str;
+ smp->data.data.str.len = len;
smp->flags = SMP_F_VOL_TEST;
}
return 1;
else
msg = &txn->rsp;
- smp->type = SMP_T_SINT;
- smp->data.sint = http_body_bytes(msg);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = http_body_bytes(msg);
smp->flags = SMP_F_VOL_TEST;
return 1;
else
msg = &txn->rsp;
- smp->type = SMP_T_SINT;
- smp->data.sint = msg->body_len;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = msg->body_len;
smp->flags = SMP_F_VOL_TEST;
return 1;
CHECK_HTTP_MESSAGE_FIRST();
txn = smp->strm->txn;
- smp->type = SMP_T_STR;
- smp->data.str.len = txn->req.sl.rq.u_l;
- smp->data.str.str = txn->req.chn->buf->p + txn->req.sl.rq.u;
+ 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->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
}
if (((struct sockaddr_in *)&addr)->sin_family != AF_INET)
return 0;
- smp->type = SMP_T_IPV4;
- smp->data.ipv4 = ((struct sockaddr_in *)&addr)->sin_addr;
+ smp->data.type = SMP_T_IPV4;
+ smp->data.data.ipv4 = ((struct sockaddr_in *)&addr)->sin_addr;
smp->flags = 0;
return 1;
}
if (((struct sockaddr_in *)&addr)->sin_family != AF_INET)
return 0;
- smp->type = SMP_T_SINT;
- smp->data.sint = ntohs(((struct sockaddr_in *)&addr)->sin_port);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = ntohs(((struct sockaddr_in *)&addr)->sin_port);
smp->flags = 0;
return 1;
}
/* prepare to report multiple occurrences for ACL fetches */
smp->flags |= SMP_F_NOT_LAST;
- smp->type = SMP_T_STR;
+ 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.str.str, &smp->data.str.len))
+ if (http_get_fhdr(msg, name_str, name_len, idx, occ, ctx, &smp->data.data.str.str, &smp->data.data.str.len))
return 1;
smp->flags &= ~SMP_F_NOT_LAST;
while (http_find_full_header2(name, len, msg->chn->buf->p, idx, &ctx))
cnt++;
- smp->type = SMP_T_SINT;
- smp->data.sint = cnt;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = cnt;
smp->flags = SMP_F_VOL_HDR;
return 1;
}
temp->len += ctx.del;
}
- smp->type = SMP_T_STR;
- smp->data.str.str = temp->str;
- smp->data.str.len = temp->len;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str.str = temp->str;
+ smp->data.data.str.len = temp->len;
smp->flags = SMP_F_VOL_HDR;
return 1;
}
/* prepare to report multiple occurrences for ACL fetches */
smp->flags |= SMP_F_NOT_LAST;
- smp->type = SMP_T_STR;
+ 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.str.str, &smp->data.str.len))
+ if (http_get_hdr(msg, name_str, name_len, idx, occ, ctx, &smp->data.data.str.str, &smp->data.data.str.len))
return 1;
smp->flags &= ~SMP_F_NOT_LAST;
while (http_find_header2(name, len, msg->chn->buf->p, idx, &ctx))
cnt++;
- smp->type = SMP_T_SINT;
- smp->data.sint = cnt;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = cnt;
smp->flags = SMP_F_VOL_HDR;
return 1;
}
int ret = smp_fetch_hdr(args, smp, kw, private);
if (ret > 0) {
- smp->type = SMP_T_SINT;
- smp->data.sint = strl2ic(smp->data.str.str, smp->data.str.len);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = strl2ic(smp->data.data.str.str, smp->data.data.str.len);
}
return ret;
int ret;
while ((ret = smp_fetch_hdr(args, smp, kw, private)) > 0) {
- if (url2ipv4((char *)smp->data.str.str, &smp->data.ipv4)) {
- smp->type = SMP_T_IPV4;
+ if (url2ipv4((char *)smp->data.data.str.str, &smp->data.data.ipv4)) {
+ smp->data.type = SMP_T_IPV4;
break;
} else {
struct chunk *temp = get_trash_chunk();
- if (smp->data.str.len < temp->size - 1) {
- memcpy(temp->str, smp->data.str.str, smp->data.str.len);
- temp->str[smp->data.str.len] = '\0';
- if (inet_pton(AF_INET6, temp->str, &smp->data.ipv6)) {
- smp->type = SMP_T_IPV6;
+ 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)) {
+ smp->data.type = SMP_T_IPV6;
break;
}
}
return 0;
/* OK, we got the '/' ! */
- smp->type = SMP_T_STR;
- smp->data.str.str = ptr;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str.str = ptr;
while (ptr < end && *ptr != '?')
ptr++;
- smp->data.str.len = ptr - smp->data.str.str;
+ smp->data.data.str.len = ptr - smp->data.data.str.str;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
}
/* OK we have the header value in ctx.line+ctx.val for ctx.vlen bytes */
temp = get_trash_chunk();
memcpy(temp->str, ctx.line + ctx.val, ctx.vlen);
- smp->type = SMP_T_STR;
- smp->data.str.str = temp->str;
- smp->data.str.len = ctx.vlen;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str.str = temp->str;
+ smp->data.data.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.str.str + smp->data.str.len, beg, ptr - beg);
- smp->data.str.len += ptr - beg;
+ memcpy(smp->data.data.str.str + smp->data.data.str.len, beg, ptr - beg);
+ smp->data.data.str.len += ptr - beg;
}
smp->flags = SMP_F_VOL_1ST;
}
hash = full_hash(hash);
- smp->type = SMP_T_SINT;
- smp->data.sint = hash;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = hash;
smp->flags = SMP_F_VOL_1ST;
return 1;
}
return 0;
temp = get_trash_chunk();
- *(unsigned int *)temp->str = htonl(smp->data.sint);
+ *(unsigned int *)temp->str = htonl(smp->data.data.sint);
temp->len += sizeof(unsigned int);
switch (cli_conn->addr.from.ss_family) {
return 0;
}
- smp->data.str = *temp;
- smp->type = SMP_T_BIN;
+ smp->data.data.str = *temp;
+ smp->data.type = SMP_T_BIN;
return 1;
}
return 0;
} while (*ptr++ != '?');
- smp->type = SMP_T_STR;
- smp->data.str.str = ptr;
- smp->data.str.len = end - ptr;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str.str = ptr;
+ smp->data.data.str.len = end - ptr;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
return 1;
}
CHECK_HTTP_MESSAGE_FIRST_PERM();
- smp->type = SMP_T_BOOL;
- smp->data.sint = 1;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = 1;
return 1;
}
static int
smp_fetch_http_first_req(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_BOOL;
- smp->data.sint = !(smp->strm->txn->flags & TX_NOT_FIRST);
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = !(smp->strm->txn->flags & TX_NOT_FIRST);
return 1;
}
if (!get_http_auth(smp->strm))
return 0;
- smp->type = SMP_T_BOOL;
- smp->data.sint = check_user(args->data.usr, smp->strm->txn->auth.user,
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = check_user(args->data.usr, smp->strm->txn->auth.user,
smp->strm->txn->auth.pass);
return 1;
}
/* pat_match_auth() will need the user list */
smp->ctx.a[0] = args->data.usr;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
- smp->data.str.str = smp->strm->txn->auth.user;
- smp->data.str.len = strlen(smp->strm->txn->auth.user);
+ smp->data.data.str.str = smp->strm->txn->auth.user;
+ smp->data.data.str.len = strlen(smp->strm->txn->auth.user);
return 1;
}
if (idx > (fe->nb_req_cap - 1) || smp->strm->req_cap == NULL || smp->strm->req_cap[idx] == NULL)
return 0;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
- smp->data.str.str = smp->strm->req_cap[idx];
- smp->data.str.len = strlen(smp->strm->req_cap[idx]);
+ smp->data.data.str.str = smp->strm->req_cap[idx];
+ smp->data.data.str.len = strlen(smp->strm->req_cap[idx]);
return 1;
}
if (idx > (fe->nb_rsp_cap - 1) || smp->strm->res_cap == NULL || smp->strm->res_cap[idx] == NULL)
return 0;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
- smp->data.str.str = smp->strm->res_cap[idx];
- smp->data.str.len = strlen(smp->strm->res_cap[idx]);
+ smp->data.data.str.str = smp->strm->res_cap[idx];
+ smp->data.data.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.str = *temp;
- smp->type = SMP_T_STR;
+ smp->data.data.str = *temp;
+ smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
return 1;
while (*ptr != ' ' && *ptr != '\0') /* find space after URI */
ptr++;
- smp->data.str = *temp;
- smp->data.str.len = ptr - temp->str;
- smp->type = SMP_T_STR;
+ smp->data.data.str = *temp;
+ smp->data.data.str.len = ptr - temp->str;
+ smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
return 1;
return 0;
if (txn->req.flags & HTTP_MSGF_VER_11)
- smp->data.str.str = "HTTP/1.1";
+ smp->data.data.str.str = "HTTP/1.1";
else
- smp->data.str.str = "HTTP/1.0";
+ smp->data.data.str.str = "HTTP/1.0";
- smp->data.str.len = 8;
- smp->type = SMP_T_STR;
+ smp->data.data.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.str.str = "HTTP/1.1";
+ smp->data.data.str.str = "HTTP/1.1";
else
- smp->data.str.str = "HTTP/1.0";
+ smp->data.data.str.str = "HTTP/1.0";
- smp->data.str.len = 8;
- smp->type = SMP_T_STR;
+ smp->data.data.str.len = 8;
+ smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
return 1;
smp->ctx.a[1] = smp->ctx.a[0] + ctx->vlen;
}
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
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.str.str,
- &smp->data.str.len);
+ &smp->data.data.str.str,
+ &smp->data.data.str.len);
if (smp->ctx.a[0]) {
found = 1;
if (occ >= 0) {
- /* one value was returned into smp->data.str.{str,len} */
+ /* one value was returned into smp->data.data.str.{str,len} */
smp->flags |= SMP_F_NOT_LAST;
return 1;
}
val_end = val_beg + ctx.vlen;
}
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
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.str.str,
- &smp->data.str.len))) {
+ &smp->data.data.str.str,
+ &smp->data.data.str.len))) {
cnt++;
}
}
- smp->type = SMP_T_SINT;
- smp->data.sint = cnt;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = cnt;
smp->flags |= SMP_F_VOL_HDR;
return 1;
}
int ret = smp_fetch_cookie(args, smp, kw, private);
if (ret > 0) {
- smp->type = SMP_T_SINT;
- smp->data.sint = strl2ic(smp->data.str.str, smp->data.str.len);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = strl2ic(smp->data.data.str.str, smp->data.data.str.len);
}
return ret;
/* Create sample. If the value is contiguous, return the pointer as CONST,
* if the value is wrapped, copy-it in a buffer.
*/
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
if (chunks[2] &&
vstart >= chunks[0] && vstart <= chunks[1] &&
vend >= chunks[2] && vend <= chunks[3]) {
temp = get_trash_chunk();
memcpy(temp->str, vstart, chunks[1] - vstart);
memcpy(temp->str + ( chunks[1] - vstart ), chunks[2], vend - chunks[2]);
- smp->data.str.str = temp->str;
- smp->data.str.len = ( chunks[1] - vstart ) + ( vend - chunks[2] );
+ smp->data.data.str.str = temp->str;
+ smp->data.data.str.len = ( chunks[1] - vstart ) + ( vend - chunks[2] );
} else {
/* Contiguous case. */
- smp->data.str.str = (char *)vstart;
- smp->data.str.len = vend - vstart;
+ smp->data.data.str.str = (char *)vstart;
+ smp->data.data.str.len = vend - vstart;
smp->flags = SMP_F_VOL_1ST | SMP_F_CONST;
}
int ret = smp_fetch_url_param(args, smp, kw, private);
if (ret > 0) {
- smp->type = SMP_T_SINT;
- smp->data.sint = strl2ic(smp->data.str.str, smp->data.str.len);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = strl2ic(smp->data.data.str.str, smp->data.data.str.len);
}
return ret;
}
hash = full_hash(hash);
- smp->type = SMP_T_SINT;
- smp->data.sint = hash;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = hash;
smp->flags = SMP_F_VOL_1ST;
return 1;
}
return 0;
/* The returned hash is a 32 bytes integer. */
- hash = smp->data.sint;
+ hash = smp->data.data.sint;
temp = get_trash_chunk();
memcpy(temp->str + temp->len, &hash, sizeof(hash));
return 0;
}
- smp->data.str = *temp;
- smp->type = SMP_T_BIN;
+ smp->data.data.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.sint & 0x007fffffffffffffLL;
+ time_t curr_date = smp->data.data.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.str = *temp;
- smp->type = SMP_T_STR;
+ smp->data.data.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.str.str;
- const char *end = al + smp->data.str.len;
+ const char *al = smp->data.data.str.str;
+ const char *end = al + smp->data.data.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.str.size = 0;
- smp->data.str.str = "";
- smp->data.str.len = 0;
+ smp->data.data.str.size = 0;
+ smp->data.data.str.str = "";
+ smp->data.data.str.len = 0;
/* Parse the accept language */
while (1) {
* break the process.
*/
if (qvalue > best_q) {
- smp->data.str.str = (char *)w;
- smp->data.str.len = str - w;
+ smp->data.data.str.str = (char *)w;
+ smp->data.data.str.len = str - w;
if (qvalue >= 1000)
break;
best_q = qvalue;
}
/* Set default value if required. */
- if (smp->data.str.len == 0 && args[1].type == ARGT_STR) {
- smp->data.str.str = args[1].data.str.str;
- smp->data.str.len = args[1].data.str.len;
+ 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;
}
/* Return true only if a matching language was found. */
- return smp->data.str.len != 0;
+ return smp->data.data.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.str.size <= smp->data.str.len) {
+ if (smp->flags & SMP_F_CONST || smp->data.data.str.size <= smp->data.data.str.len) {
struct chunk *str = get_trash_chunk();
- memcpy(str->str, smp->data.str.str, smp->data.str.len);
- smp->data.str.str = str->str;
- smp->data.str.size = str->size;
+ 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;
smp->flags &= ~SMP_F_CONST;
}
/* Add final \0 required by url_decode(), and convert the input string. */
- smp->data.str.str[smp->data.str.len] = '\0';
- smp->data.str.len = url_decode(smp->data.str.str);
+ smp->data.data.str.str[smp->data.data.str.len] = '\0';
+ smp->data.data.str.len = url_decode(smp->data.data.str.str);
return 1;
}
return 0;
/* Check length. */
- len = smp->data.str.len;
+ len = smp->data.data.str.len;
if (len > hdr->len)
len = hdr->len;
/* Capture input data. */
- memcpy(smp->strm->req_cap[idx], smp->data.str.str, len);
+ memcpy(smp->strm->req_cap[idx], smp->data.data.str.str, len);
smp->strm->req_cap[idx][len] = '\0';
return 1;
return 0;
/* Check length. */
- len = smp->data.str.len;
+ len = smp->data.data.str.len;
if (len > hdr->len)
len = hdr->len;
/* Capture input data. */
- memcpy(smp->strm->res_cap[idx], smp->data.str.str, len);
+ memcpy(smp->strm->res_cap[idx], smp->data.data.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.str.len;
+ len = key->data.data.str.len;
if (len > h->len)
len = h->len;
- memcpy(cap[h->index], key->data.str.str, len);
+ memcpy(cap[h->index], key->data.data.str.str, len);
cap[h->index][len] = 0;
return 1;
}
if (cap[h->index] == NULL) /* no more capture memory */
return 1;
- len = key->data.str.len;
+ len = key->data.data.str.len;
if (len > h->len)
len = h->len;
- memcpy(cap[h->index], key->data.str.str, len);
+ memcpy(cap[h->index], key->data.data.str.str, len);
cap[h->index][len] = 0;
return 1;
}
if (cap[h->index] == NULL) /* no more capture memory */
return 1;
- len = key->data.str.len;
+ len = key->data.data.str.len;
if (len > h->len)
len = h->len;
- memcpy(cap[h->index], key->data.str.str, len);
+ memcpy(cap[h->index], key->data.data.str.str, len);
cap[h->index][len] = 0;
return 1;
}
if (cap[h->index] == NULL) /* no more capture memory */
continue;
- len = key->data.str.len;
+ len = key->data.data.str.len;
if (len > h->len)
len = h->len;
- memcpy(cap[h->index], key->data.str.str, len);
+ memcpy(cap[h->index], key->data.data.str.str, len);
cap[h->index][len] = 0;
}
else {
switch (cli_conn->addr.from.ss_family) {
case AF_INET:
- smp->data.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.from)->sin_addr;
- smp->type = SMP_T_IPV4;
+ smp->data.data.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.from)->sin_addr;
+ smp->data.type = SMP_T_IPV4;
break;
case AF_INET6:
- smp->data.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_addr;
- smp->type = SMP_T_IPV6;
+ smp->data.data.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.from)->sin6_addr;
+ smp->data.type = SMP_T_IPV6;
break;
default:
return 0;
if (!cli_conn)
return 0;
- smp->type = SMP_T_SINT;
- if (!(smp->data.sint = get_host_port(&cli_conn->addr.from)))
+ smp->data.type = SMP_T_SINT;
+ if (!(smp->data.data.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.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.to)->sin_addr;
- smp->type = SMP_T_IPV4;
+ smp->data.data.ipv4 = ((struct sockaddr_in *)&cli_conn->addr.to)->sin_addr;
+ smp->data.type = SMP_T_IPV4;
break;
case AF_INET6:
- smp->data.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.to)->sin6_addr;
- smp->type = SMP_T_IPV6;
+ smp->data.data.ipv6 = ((struct sockaddr_in6 *)&cli_conn->addr.to)->sin6_addr;
+ smp->data.type = SMP_T_IPV6;
break;
default:
return 0;
conn_get_to_addr(cli_conn);
- smp->type = SMP_T_SINT;
- if (!(smp->data.sint = get_host_port(&cli_conn->addr.to)))
+ smp->data.type = SMP_T_SINT;
+ if (!(smp->data.data.sint = get_host_port(&cli_conn->addr.to)))
return 0;
smp->flags = 0;
static int c_ip2int(struct sample *smp)
{
- smp->data.sint = ntohl(smp->data.ipv4.s_addr);
- smp->type = SMP_T_SINT;
+ smp->data.data.sint = ntohl(smp->data.data.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.ipv4, trash->str, trash->size))
+ if (!inet_ntop(AF_INET, (void *)&smp->data.data.ipv4, trash->str, trash->size))
return 0;
trash->len = strlen(trash->str);
- smp->data.str = *trash;
- smp->type = SMP_T_STR;
+ smp->data.data.str = *trash;
+ smp->data.type = SMP_T_STR;
smp->flags &= ~SMP_F_CONST;
return 1;
static int c_ip2ipv6(struct sample *smp)
{
- v4tov6(&smp->data.ipv6, &smp->data.ipv4);
- smp->type = SMP_T_IPV6;
+ v4tov6(&smp->data.data.ipv6, &smp->data.data.ipv4);
+ smp->data.type = SMP_T_IPV6;
return 1;
}
static int c_ipv62ip(struct sample *smp)
{
- if (!v6tov4(&smp->data.ipv4, &smp->data.ipv6))
+ if (!v6tov4(&smp->data.data.ipv4, &smp->data.data.ipv6))
return 0;
- smp->type = SMP_T_IPV6;
+ smp->data.type = SMP_T_IPV6;
return 1;
}
{
struct chunk *trash = get_trash_chunk();
- if (!inet_ntop(AF_INET6, (void *)&smp->data.ipv6, trash->str, trash->size))
+ if (!inet_ntop(AF_INET6, (void *)&smp->data.data.ipv6, trash->str, trash->size))
return 0;
trash->len = strlen(trash->str);
- smp->data.str = *trash;
- smp->type = SMP_T_STR;
+ smp->data.data.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.ipv4, &smp->data.ipv6);
+ return v6tov4(&smp->data.data.ipv4, &smp->data.data.ipv6);
}
*/
static int c_int2ip(struct sample *smp)
{
- smp->data.ipv4.s_addr = htonl((unsigned int)smp->data.sint);
- smp->type = SMP_T_IPV4;
+ smp->data.data.ipv4.s_addr = htonl((unsigned int)smp->data.data.sint);
+ smp->data.type = SMP_T_IPV4;
return 1;
}
static int c_int2ipv6(struct sample *smp)
{
- smp->data.ipv4.s_addr = htonl((unsigned int)smp->data.sint);
- v4tov6(&smp->data.ipv6, &smp->data.ipv4);
- smp->type = SMP_T_IPV6;
+ smp->data.data.ipv4.s_addr = htonl((unsigned int)smp->data.data.sint);
+ v4tov6(&smp->data.data.ipv6, &smp->data.data.ipv4);
+ smp->data.type = SMP_T_IPV6;
return 1;
}
static int c_str2addr(struct sample *smp)
{
- if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4)) {
- if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6))
+ 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))
return 0;
- smp->type = SMP_T_IPV6;
+ smp->data.type = SMP_T_IPV6;
smp->flags &= ~SMP_F_CONST;
return 1;
}
- smp->type = SMP_T_IPV4;
+ smp->data.type = SMP_T_IPV4;
smp->flags &= ~SMP_F_CONST;
return 1;
}
static int c_str2ip(struct sample *smp)
{
- if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4))
+ if (!buf2ip(smp->data.data.str.str, smp->data.data.str.len, &smp->data.data.ipv4))
return 0;
- smp->type = SMP_T_IPV4;
+ smp->data.type = SMP_T_IPV4;
smp->flags &= ~SMP_F_CONST;
return 1;
}
static int c_str2ipv6(struct sample *smp)
{
- if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6))
+ if (!buf2ip6(smp->data.data.str.str, smp->data.data.str.len, &smp->data.data.ipv6))
return 0;
- smp->type = SMP_T_IPV6;
+ smp->data.type = SMP_T_IPV6;
smp->flags &= ~SMP_F_CONST;
return 1;
}
{
int i;
- for (i = 0; i < smp->data.str.len; i++) {
- if (!smp->data.str.str[i]) {
- smp->data.str.len = i;
+ for (i = 0; i < smp->data.data.str.len; i++) {
+ if (!smp->data.data.str.str[i]) {
+ smp->data.data.str.len = i;
break;
}
}
struct chunk *trash = get_trash_chunk();
char *pos;
- pos = lltoa_r(smp->data.sint, trash->str, trash->size);
+ pos = lltoa_r(smp->data.data.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.str = *trash;
- smp->type = SMP_T_STR;
+ smp->data.data.str = *trash;
+ smp->data.type = SMP_T_STR;
smp->flags &= ~SMP_F_CONST;
return 1;
}
if (!(smp->flags & SMP_F_CONST))
return 1;
- switch (smp->type) {
+ switch (smp->data.type) {
case SMP_T_BOOL:
case SMP_T_SINT:
case SMP_T_ADDR:
case SMP_T_BIN:
/* Duplicate data. */
trash = get_trash_chunk();
- trash->len = smp->data.str.len < trash->size ? smp->data.str.len : trash->size;
- memcpy(trash->str, smp->data.str.str, trash->len);
- smp->data.str = *trash;
+ 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;
break;
default:
/* Other cases are unexpected. */
const char *str;
const char *end;
- if (smp->data.str.len == 0)
+ if (smp->data.data.str.len == 0)
return 0;
- str = smp->data.str.str;
- end = smp->data.str.str + smp->data.str.len;
+ str = smp->data.data.str.str;
+ end = smp->data.data.str.str + smp->data.data.str.len;
- smp->data.sint = read_int64(&str, end);
- smp->type = SMP_T_SINT;
+ smp->data.data.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.str.str, smp->data.str.len);
+ meth = find_http_meth(smp->data.data.str.str, smp->data.data.str.len);
if (meth == HTTP_METH_OTHER) {
- len = smp->data.str.len;
- smp->data.meth.str.str = smp->data.str.str;
- smp->data.meth.str.len = len;
+ len = smp->data.data.str.len;
+ smp->data.data.meth.str.str = smp->data.data.str.str;
+ smp->data.data.meth.str.len = len;
}
else
smp->flags &= ~SMP_F_CONST;
- smp->data.meth.meth = meth;
- smp->type = SMP_T_METH;
+ smp->data.data.meth.meth = meth;
+ smp->data.type = SMP_T_METH;
return 1;
}
int len;
enum http_meth_t meth;
- if (smp->data.meth.meth == HTTP_METH_OTHER) {
+ if (smp->data.data.meth.meth == HTTP_METH_OTHER) {
/* The method is unknown. Copy the original pointer. */
- len = smp->data.meth.str.len;
- smp->data.str.str = smp->data.meth.str.str;
- smp->data.str.len = len;
- smp->type = SMP_T_STR;
+ len = smp->data.data.meth.str.len;
+ smp->data.data.str.str = smp->data.data.meth.str.str;
+ smp->data.data.str.len = len;
+ smp->data.type = SMP_T_STR;
}
- else if (smp->data.meth.meth < HTTP_METH_OTHER) {
+ else if (smp->data.data.meth.meth < HTTP_METH_OTHER) {
/* The method is known, copy the pointer containing the string. */
- meth = smp->data.meth.meth;
- smp->data.str.str = http_known_methods[meth].name;
- smp->data.str.len = http_known_methods[meth].len;
+ 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;
smp->flags |= SMP_F_CONST;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
}
else {
/* Unknown method */
{
struct chunk *chk = get_trash_chunk();
- if (smp->type == SMP_T_IPV4) {
+ if (smp->data.type == SMP_T_IPV4) {
chk->len = 4;
- memcpy(chk->str, &smp->data.ipv4, chk->len);
+ memcpy(chk->str, &smp->data.data.ipv4, chk->len);
}
- else if (smp->type == SMP_T_IPV6) {
+ else if (smp->data.type == SMP_T_IPV6) {
chk->len = 16;
- memcpy(chk->str, &smp->data.ipv6, chk->len);
+ memcpy(chk->str, &smp->data.data.ipv6, chk->len);
}
else
return 0;
- smp->data.str = *chk;
- smp->type = SMP_T_BIN;
+ smp->data.data.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.sint);
+ *(unsigned long long int *)chk->str = htonll(smp->data.data.sint);
chk->len = 8;
- smp->data.str = *chk;
- smp->type = SMP_T_BIN;
+ smp->data.data.str = *chk;
+ smp->data.type = SMP_T_BIN;
return 1;
}
* - c_none => nothing to do (let's optimize it)
* - other => apply cast and prepare to fail
*/
- if (!sample_casts[p->type][conv_expr->conv->in_type])
+ if (!sample_casts[p->data.type][conv_expr->conv->in_type])
return NULL;
- if (sample_casts[p->type][conv_expr->conv->in_type] != c_none &&
- !sample_casts[p->type][conv_expr->conv->in_type](p))
+ if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
+ !sample_casts[p->data.type][conv_expr->conv->in_type](p))
return NULL;
/* OK cast succeeded */
return NULL;
}
- if (!sample_casts[smp->type][smp_type])
+ if (!sample_casts[smp->data.type][smp_type])
return NULL;
- if (!sample_casts[smp->type][smp_type](smp))
+ if (!sample_casts[smp->data.type][smp_type](smp))
return NULL;
smp->flags &= ~SMP_F_MAY_CHANGE;
struct sample tmp;
if (!(global.mode & MODE_QUIET) || (global.mode & (MODE_VERBOSE | MODE_STARTING))) {
- fprintf(stderr, "[debug converter] type: %s ", smp_to_type[smp->type]);
- if (!sample_casts[smp->type][SMP_T_STR]) {
+ fprintf(stderr, "[debug converter] type: %s ", smp_to_type[smp->data.type]);
+ if (!sample_casts[smp->data.type][SMP_T_STR]) {
fprintf(stderr, "(undisplayable)");
} else {
memcpy(&tmp, smp, sizeof(struct sample));
tmp.flags = SMP_F_CONST;
- if (!sample_casts[smp->type][SMP_T_STR](&tmp))
+ if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
fprintf(stderr, "(undisplayable)");
else {
/* Display the displayable chars*. */
fprintf(stderr, "<");
- for (i = 0; i < tmp.data.str.len; i++) {
- if (isprint(tmp.data.str.str[i]))
- fputc(tmp.data.str.str[i], 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);
else
fputc('.', stderr);
}
int b64_len;
trash->len = 0;
- b64_len = a2base64(smp->data.str.str, smp->data.str.len, trash->str, trash->size);
+ b64_len = a2base64(smp->data.data.str.str, smp->data.data.str.len, trash->str, trash->size);
if (b64_len < 0)
return 0;
trash->len = b64_len;
- smp->data.str = *trash;
- smp->type = SMP_T_STR;
+ smp->data.data.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.str.len && trash->len <= trash->size - 2) {
- c = smp->data.str.str[ptr++];
+ while (ptr < smp->data.data.str.len && trash->len <= trash->size - 2) {
+ c = smp->data.data.str.str[ptr++];
trash->str[trash->len++] = hextab[(c >> 4) & 0xF];
trash->str[trash->len++] = hextab[c & 0xF];
}
- smp->data.str = *trash;
- smp->type = SMP_T_STR;
+ smp->data.data.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.sint = hash_djb2(smp->data.str.str, smp->data.str.len);
+ smp->data.data.sint = hash_djb2(smp->data.data.str.str, smp->data.data.str.len);
if (arg_p && arg_p->data.sint)
- smp->data.sint = full_hash(smp->data.sint);
- smp->type = SMP_T_SINT;
+ smp->data.data.sint = full_hash(smp->data.data.sint);
+ smp->data.type = SMP_T_SINT;
return 1;
}
if (!smp_dup(smp))
return 0;
- if (!smp->data.str.size)
+ if (!smp->data.data.str.size)
return 0;
- for (i = 0; i < smp->data.str.len; i++) {
- if ((smp->data.str.str[i] >= 'A') && (smp->data.str.str[i] <= 'Z'))
- smp->data.str.str[i] += 'a' - 'A';
+ 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';
}
return 1;
}
if (!smp_dup(smp))
return 0;
- if (!smp->data.str.size)
+ if (!smp->data.data.str.size)
return 0;
- for (i = 0; i < smp->data.str.len; i++) {
- if ((smp->data.str.str[i] >= 'a') && (smp->data.str.str[i] <= 'z'))
- smp->data.str.str[i] += 'A' - 'a';
+ 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';
}
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.ipv4.s_addr &= arg_p->data.ipv4.s_addr;
- smp->type = SMP_T_IPV4;
+ smp->data.data.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.sint & 0x007fffffffffffffLL;
+ time_t curr_date = smp->data.data.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.str = *temp;
- smp->type = SMP_T_STR;
+ smp->data.data.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.sint = hash_sdbm(smp->data.str.str, smp->data.str.len);
+ smp->data.data.sint = hash_sdbm(smp->data.data.str.str, smp->data.data.str.len);
if (arg_p && arg_p->data.sint)
- smp->data.sint = full_hash(smp->data.sint);
- smp->type = SMP_T_SINT;
+ smp->data.data.sint = full_hash(smp->data.data.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.sint & 0x007fffffffffffffLL;
+ time_t curr_date = smp->data.data.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.str = *temp;
- smp->type = SMP_T_STR;
+ smp->data.data.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.sint = hash_wt6(smp->data.str.str, smp->data.str.len);
+ smp->data.data.sint = hash_wt6(smp->data.data.str.str, smp->data.data.str.len);
if (arg_p && arg_p->data.sint)
- smp->data.sint = full_hash(smp->data.sint);
- smp->type = SMP_T_SINT;
+ smp->data.data.sint = full_hash(smp->data.data.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.sint = hash_crc32(smp->data.str.str, smp->data.str.len);
+ smp->data.data.sint = hash_crc32(smp->data.data.str.str, smp->data.data.str.len);
if (arg_p && arg_p->data.sint)
- smp->data.sint = full_hash(smp->data.sint);
- smp->type = SMP_T_SINT;
+ smp->data.data.sint = full_hash(smp->data.data.sint);
+ smp->data.type = SMP_T_SINT;
return 1;
}
temp = get_trash_chunk();
temp->len = 0;
- p = smp->data.str.str;
- while (p < smp->data.str.str + smp->data.str.len) {
+ p = smp->data.data.str.str;
+ while (p < smp->data.data.str.str + smp->data.data.str.len) {
if (input_type == IT_ASCII) {
/* Read input as ASCII. */
}
else {
/* Read input as UTF8. */
- ret = utf8_next(p, smp->data.str.len - ( p - smp->data.str.str ), &c);
+ ret = utf8_next(p, smp->data.data.str.len - ( p - smp->data.data.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.str = *temp;
- smp->type = SMP_T_STR;
+ smp->data.data.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.str.len <= arg_p[0].data.sint) {
- smp->data.str.len = 0;
+ if (smp->data.data.str.len <= arg_p[0].data.sint) {
+ smp->data.data.str.len = 0;
return 1;
}
- if (smp->data.str.size)
- smp->data.str.size -= arg_p[0].data.sint;
- smp->data.str.len -= arg_p[0].data.sint;
- smp->data.str.str += arg_p[0].data.sint;
+ 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 ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.str.len))
- smp->data.str.len = arg_p[1].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;
return 1;
}
return 0;
field = 1;
- end = start = smp->data.str.str;
- while (end - smp->data.str.str < smp->data.str.len) {
+ end = start = smp->data.data.str.str;
+ while (end - smp->data.data.str.str < smp->data.data.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.str.len = 0;
+ smp->data.data.str.len = 0;
return 1;
}
found:
- smp->data.str.len = end - start;
+ smp->data.data.str.len = end - start;
/* If ret string is len 0, no need to
change pointers or to update size */
- if (!smp->data.str.len)
+ if (!smp->data.data.str.len)
return 1;
- smp->data.str.str = start;
+ smp->data.data.str.str = start;
/* Compute remaining size if needed
- Note: smp->data.str.size cannot be set to 0 */
- if (smp->data.str.size)
- smp->data.str.size -= start - smp->data.str.str;
+ 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;
return 1;
}
word = 0;
inword = 0;
- end = start = smp->data.str.str;
- while (end - smp->data.str.str < smp->data.str.len) {
+ end = start = smp->data.data.str.str;
+ while (end - smp->data.data.str.str < smp->data.data.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.str.len = 0;
+ smp->data.data.str.len = 0;
return 1;
}
found:
- smp->data.str.len = end - start;
+ smp->data.data.str.len = end - start;
/* If ret string is len 0, no need to
change pointers or to update size */
- if (!smp->data.str.len)
+ if (!smp->data.data.str.len)
return 1;
- smp->data.str.str = start;
+ smp->data.data.str.str = start;
/* Compute remaining size if needed
- Note: smp->data.str.size cannot be set to 0 */
- if (smp->data.str.size)
- smp->data.str.size -= start - smp->data.str.str;
+ 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;
return 1;
}
int flag, max;
int found;
- start = smp->data.str.str;
- end = start + smp->data.str.len;
+ start = smp->data.data.str.str;
+ end = start + smp->data.data.str.len;
flag = 0;
while (1) {
flag |= REG_NOTBOL;
}
- smp->data.str = *trash;
+ smp->data.data.str = *trash;
return 1;
}
{
switch (arg->type) {
case ARGT_SINT:
- smp->type = SMP_T_SINT;
- smp->data.sint = arg->data.sint;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = arg->data.sint;
return 1;
case ARGT_VAR:
if (!vars_get_by_desc(&arg->data.var, strm, smp))
return 0;
- if (!sample_casts[smp->type][SMP_T_SINT])
+ if (!sample_casts[smp->data.type][SMP_T_SINT])
return 0;
- if (!sample_casts[smp->type][SMP_T_SINT](smp))
+ if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
return 0;
return 1;
default:
*/
static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
{
- smp->data.sint = ~smp->data.sint;
+ smp->data.data.sint = ~smp->data.data.sint;
return 1;
}
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
- smp->data.sint &= tmp.data.sint;
+ smp->data.data.sint &= tmp.data.data.sint;
return 1;
}
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
- smp->data.sint |= tmp.data.sint;
+ smp->data.data.sint |= tmp.data.data.sint;
return 1;
}
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
- smp->data.sint ^= tmp.data.sint;
+ smp->data.data.sint ^= tmp.data.data.sint;
return 1;
}
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
- smp->data.sint = arith_add(smp->data.sint, tmp.data.sint);
+ smp->data.data.sint = arith_add(smp->data.data.sint, tmp.data.data.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.sint == LLONG_MIN) {
- smp->data.sint = arith_add(smp->data.sint, LLONG_MAX);
- if (smp->data.sint < LLONG_MAX)
- smp->data.sint++;
+ 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++;
return 1;
}
/* standard substraction: we use the "add" function and negate
* the second operand.
*/
- smp->data.sint = arith_add(smp->data.sint, -tmp.data.sint);
+ smp->data.data.sint = arith_add(smp->data.data.sint, -tmp.data.data.sint);
return 1;
}
return 0;
/* prevent divide by 0 during the check */
- if (!smp->data.sint || !tmp.data.sint) {
- smp->data.sint = 0;
+ if (!smp->data.data.sint || !tmp.data.data.sint) {
+ smp->data.data.sint = 0;
return 1;
}
/* The multiply between LLONG_MIN and -1 returns a
* "floting point exception".
*/
- if (smp->data.sint == LLONG_MIN && tmp.data.sint == -1) {
- smp->data.sint = LLONG_MAX;
+ if (smp->data.data.sint == LLONG_MIN && tmp.data.data.sint == -1) {
+ smp->data.data.sint = LLONG_MAX;
return 1;
}
/* execute standard multiplication. */
- c = smp->data.sint * tmp.data.sint;
+ c = smp->data.data.sint * tmp.data.data.sint;
/* check for overflow and makes capped multiply. */
- if (smp->data.sint != c / tmp.data.sint) {
- if ((smp->data.sint < 0) == (tmp.data.sint < 0)) {
- smp->data.sint = LLONG_MAX;
+ 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;
return 1;
}
- smp->data.sint = LLONG_MIN;
+ smp->data.data.sint = LLONG_MIN;
return 1;
}
- smp->data.sint = c;
+ smp->data.data.sint = c;
return 1;
}
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
- if (tmp.data.sint) {
+ if (tmp.data.data.sint) {
/* The divide between LLONG_MIN and -1 returns a
* "floting point exception".
*/
- if (smp->data.sint == LLONG_MIN && tmp.data.sint == -1) {
- smp->data.sint = LLONG_MAX;
+ if (smp->data.data.sint == LLONG_MIN && tmp.data.data.sint == -1) {
+ smp->data.data.sint = LLONG_MAX;
return 1;
}
- smp->data.sint /= tmp.data.sint;
+ smp->data.data.sint /= tmp.data.data.sint;
return 1;
}
- smp->data.sint = LLONG_MAX;
+ smp->data.data.sint = LLONG_MAX;
return 1;
}
if (!sample_conv_var2smp(arg_p, smp->strm, &tmp))
return 0;
- if (tmp.data.sint) {
+ if (tmp.data.data.sint) {
/* The divide between LLONG_MIN and -1 returns a
* "floting point exception".
*/
- if (smp->data.sint == LLONG_MIN && tmp.data.sint == -1) {
- smp->data.sint = 0;
+ if (smp->data.data.sint == LLONG_MIN && tmp.data.data.sint == -1) {
+ smp->data.data.sint = 0;
return 1;
}
- smp->data.sint %= tmp.data.sint;
+ smp->data.data.sint %= tmp.data.data.sint;
return 1;
}
- smp->data.sint = 0;
+ smp->data.data.sint = 0;
return 1;
}
static int sample_conv_arith_neg(const struct arg *arg_p,
struct sample *smp, void *private)
{
- if (smp->data.sint == LLONG_MIN)
- smp->data.sint = LLONG_MAX;
+ if (smp->data.data.sint == LLONG_MIN)
+ smp->data.data.sint = LLONG_MAX;
else
- smp->data.sint = -smp->data.sint;
+ smp->data.data.sint = -smp->data.data.sint;
return 1;
}
static int sample_conv_arith_bool(const struct arg *arg_p,
struct sample *smp, void *private)
{
- smp->data.sint = !!smp->data.sint;
- smp->type = SMP_T_BOOL;
+ smp->data.data.sint = !!smp->data.data.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.sint = !smp->data.sint;
- smp->type = SMP_T_BOOL;
+ smp->data.data.sint = !smp->data.data.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.sint = smp->data.sint & 1;
- smp->type = SMP_T_BOOL;
+ smp->data.data.sint = smp->data.data.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.sint = !(smp->data.sint & 1);
- smp->type = SMP_T_BOOL;
+ smp->data.data.sint = !(smp->data.data.sint & 1);
+ smp->data.type = SMP_T_BOOL;
return 1;
}
static int
smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_BOOL;
- smp->data.sint = 1;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = 1;
return 1;
}
static int
smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_BOOL;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = 0;
return 1;
}
if (!env)
return 0;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
- smp->data.str.str = env;
- smp->data.str.len = strlen(env);
+ smp->data.data.str.str = env;
+ smp->data.data.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.sint = date.tv_sec;
+ smp->data.data.sint = date.tv_sec;
/* add offset */
if (args && args[0].type == ARGT_SINT)
- smp->data.sint += args[0].data.sint;
+ smp->data.data.sint += args[0].data.sint;
- smp->type = SMP_T_SINT;
+ smp->data.type = SMP_T_SINT;
smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
return 1;
}
static int
smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_SINT;
- smp->data.sint = global.nbproc;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = global.nbproc;
return 1;
}
static int
smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_SINT;
- smp->data.sint = relative_pid;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = relative_pid;
return 1;
}
static int
smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->data.sint = random();
+ smp->data.data.sint = random();
/* reduce if needed. Don't do a modulo, use all bits! */
if (args && args[0].type == ARGT_SINT)
- smp->data.sint = (smp->data.sint * args[0].data.sint) / ((u64)RAND_MAX+1);
+ smp->data.data.sint = (smp->data.data.sint * args[0].data.sint) / ((u64)RAND_MAX+1);
- smp->type = SMP_T_SINT;
+ smp->data.type = SMP_T_SINT;
smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
return 1;
}
static int
smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_BOOL;
- smp->data.sint = stopping;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = stopping;
return 1;
}
static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags |= SMP_F_CONST;
- smp->type = SMP_T_STR;
- smp->data.str.str = args[0].data.str.str;
- smp->data.str.len = args[0].data.str.len;
+ 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;
return 1;
}
static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_BOOL;
- smp->data.sint = args[0].data.sint;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.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->type = SMP_T_SINT;
- smp->data.sint = args[0].data.sint;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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->type = SMP_T_IPV4;
- smp->data.ipv4 = args[0].data.ipv4;
+ smp->data.type = SMP_T_IPV4;
+ smp->data.data.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->type = SMP_T_IPV6;
- smp->data.ipv6 = args[0].data.ipv6;
+ smp->data.type = SMP_T_IPV6;
+ smp->data.data.ipv6 = args[0].data.ipv6;
return 1;
}
static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags |= SMP_F_CONST;
- smp->type = SMP_T_BIN;
- smp->data.str.str = args[0].data.str.str;
- smp->data.str.len = args[0].data.str.len;
+ 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;
return 1;
}
static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- smp->type = SMP_T_METH;
+ smp->data.type = SMP_T_METH;
if (args[0].type == ARGT_SINT) {
smp->flags &= ~SMP_F_CONST;
- smp->data.meth.meth = args[0].data.sint;
- smp->data.meth.str.str = "";
- smp->data.meth.str.len = 0;
+ smp->data.data.meth.meth = args[0].data.sint;
+ smp->data.data.meth.str.str = "";
+ smp->data.data.meth.str.len = 0;
} else {
smp->flags |= SMP_F_CONST;
- smp->data.meth.meth = HTTP_METH_OTHER;
- smp->data.meth.str.str = args[0].data.str.str;
- smp->data.meth.str.len = args[0].data.str.len;
+ 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;
}
return 1;
}
}
smp->flags = 0;
- smp->type = SMP_T_BOOL;
- smp->data.sint = SSL_SOCK_ST_FL_VERIFY_DONE & conn->xprt_st ? 1 : 0;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.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.str = *smp_trash;
- smp->type = SMP_T_BIN;
+ smp->data.data.str = *smp_trash;
+ smp->data.type = SMP_T_BIN;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
if (ssl_sock_get_serial(crt, smp_trash) <= 0)
goto out;
- smp->data.str = *smp_trash;
- smp->type = SMP_T_BIN;
+ smp->data.data.str = *smp_trash;
+ smp->data.type = SMP_T_BIN;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
digest = EVP_sha1();
X509_digest(crt, digest, (unsigned char *)smp_trash->str, (unsigned int *)&smp_trash->len);
- smp->data.str = *smp_trash;
- smp->type = SMP_T_BIN;
+ smp->data.data.str = *smp_trash;
+ smp->data.type = SMP_T_BIN;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
if (ssl_sock_get_time(X509_get_notAfter(crt), smp_trash) <= 0)
goto out;
- smp->data.str = *smp_trash;
- smp->type = SMP_T_STR;
+ smp->data.data.str = *smp_trash;
+ smp->data.type = SMP_T_STR;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
else if (ssl_sock_get_dn_oneline(name, smp_trash) <= 0)
goto out;
- smp->type = SMP_T_STR;
- smp->data.str = *smp_trash;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.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.str = *smp_trash;
- smp->type = SMP_T_STR;
+ smp->data.data.str = *smp_trash;
+ smp->data.type = SMP_T_STR;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
else if (ssl_sock_get_dn_oneline(name, smp_trash) <= 0)
goto out;
- smp->type = SMP_T_STR;
- smp->data.str = *smp_trash;
+ smp->data.type = SMP_T_STR;
+ smp->data.data.str = *smp_trash;
ret = 1;
out:
/* SSL_get_peer_certificate, it increase X509 * ref count */
X509_free(crt);
}
- smp->type = SMP_T_BOOL;
- smp->data.sint = (crt != NULL);
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = (crt != NULL);
return 1;
}
if (!crt)
return 0;
- smp->data.sint = (unsigned int)(1 + X509_get_version(crt));
+ smp->data.data.sint = (unsigned int)(1 + X509_get_version(crt));
/* SSL_get_peer_certificate increase X509 * ref count */
if (cert_peer)
X509_free(crt);
- smp->type = SMP_T_SINT;
+ smp->data.type = SMP_T_SINT;
return 1;
}
nid = OBJ_obj2nid((ASN1_OBJECT *)(crt->cert_info->signature->algorithm));
- smp->data.str.str = (char *)OBJ_nid2sn(nid);
- if (!smp->data.str.str) {
+ smp->data.data.str.str = (char *)OBJ_nid2sn(nid);
+ if (!smp->data.data.str.str) {
/* SSL_get_peer_certificate increase X509 * ref count */
if (cert_peer)
X509_free(crt);
return 0;
}
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
- smp->data.str.len = strlen(smp->data.str.str);
+ smp->data.data.str.len = strlen(smp->data.data.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.str.str = (char *)OBJ_nid2sn(nid);
- if (!smp->data.str.str) {
+ smp->data.data.str.str = (char *)OBJ_nid2sn(nid);
+ if (!smp->data.data.str.str) {
/* SSL_get_peer_certificate increase X509 * ref count */
if (cert_peer)
X509_free(crt);
return 0;
}
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
- smp->data.str.len = strlen(smp->data.str.str);
+ smp->data.data.str.len = strlen(smp->data.data.str.str);
if (cert_peer)
X509_free(crt);
int back_conn = (kw[4] == 'b') ? 1 : 0;
struct connection *conn = objt_conn(smp->strm->si[back_conn].end);
- smp->type = SMP_T_BOOL;
- smp->data.sint = (conn && conn->xprt == &ssl_sock);
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = (conn && conn->xprt == &ssl_sock);
return 1;
}
#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
struct connection *conn = objt_conn(smp->sess->origin);
- smp->type = SMP_T_BOOL;
- smp->data.sint = (conn && conn->xprt == &ssl_sock) &&
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.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->type = SMP_T_BOOL;
- smp->data.sint = (conn && conn->xprt == &ssl_sock) &&
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.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.str.str = (char *)SSL_get_cipher_name(conn->xprt_ctx);
- if (!smp->data.str.str)
+ smp->data.data.str.str = (char *)SSL_get_cipher_name(conn->xprt_ctx);
+ if (!smp->data.data.str.str)
return 0;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags |= SMP_F_CONST;
- smp->data.str.len = strlen(smp->data.str.str);
+ smp->data.data.str.len = strlen(smp->data.data.str.str);
return 1;
}
if (!SSL_get_cipher_bits(conn->xprt_ctx, &sint))
return 0;
- smp->data.sint = sint;
- smp->type = SMP_T_SINT;
+ smp->data.data.sint = sint;
+ smp->data.type = SMP_T_SINT;
return 1;
}
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
- smp->data.sint = (unsigned int)SSL_get_cipher_bits(conn->xprt_ctx, NULL);
- if (!smp->data.sint)
+ smp->data.data.sint = (unsigned int)SSL_get_cipher_bits(conn->xprt_ctx, NULL);
+ if (!smp->data.data.sint)
return 0;
- smp->type = SMP_T_SINT;
+ smp->data.type = SMP_T_SINT;
return 1;
}
struct connection *conn;
smp->flags = SMP_F_CONST;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
conn = objt_conn(smp->sess->origin);
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
- smp->data.str.str = NULL;
+ smp->data.data.str.str = NULL;
SSL_get0_next_proto_negotiated(conn->xprt_ctx,
- (const unsigned char **)&smp->data.str.str, (unsigned *)&smp->data.str.len);
+ (const unsigned char **)&smp->data.data.str.str, (unsigned *)&smp->data.data.str.len);
- if (!smp->data.str.str)
+ if (!smp->data.data.str.str)
return 0;
return 1;
struct connection *conn;
smp->flags = SMP_F_CONST;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
conn = objt_conn(smp->sess->origin);
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
- smp->data.str.str = NULL;
+ smp->data.data.str.str = NULL;
SSL_get0_alpn_selected(conn->xprt_ctx,
- (const unsigned char **)&smp->data.str.str, (unsigned *)&smp->data.str.len);
+ (const unsigned char **)&smp->data.data.str.str, (unsigned *)&smp->data.data.str.len);
- if (!smp->data.str.str)
+ if (!smp->data.data.str.str)
return 0;
return 1;
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
- smp->data.str.str = (char *)SSL_get_version(conn->xprt_ctx);
- if (!smp->data.str.str)
+ smp->data.data.str.str = (char *)SSL_get_version(conn->xprt_ctx);
+ if (!smp->data.data.str.str)
return 0;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
smp->flags = SMP_F_CONST;
- smp->data.str.len = strlen(smp->data.str.str);
+ smp->data.data.str.len = strlen(smp->data.data.str.str);
return 1;
}
struct connection *conn;
smp->flags = SMP_F_CONST;
- smp->type = SMP_T_BIN;
+ smp->data.type = SMP_T_BIN;
conn = objt_conn(smp->strm->si[back_conn].end);
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
if (!ssl_sess)
return 0;
- smp->data.str.str = (char *)SSL_SESSION_get_id(ssl_sess, (unsigned int *)&smp->data.str.len);
- if (!smp->data.str.str || !smp->data.str.len)
+ 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)
return 0;
return 1;
struct connection *conn;
smp->flags = SMP_F_CONST;
- smp->type = SMP_T_STR;
+ smp->data.type = SMP_T_STR;
conn = objt_conn(smp->sess->origin);
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
- smp->data.str.str = (char *)SSL_get_servername(conn->xprt_ctx, TLSEXT_NAMETYPE_host_name);
- if (!smp->data.str.str)
+ smp->data.data.str.str = (char *)SSL_get_servername(conn->xprt_ctx, TLSEXT_NAMETYPE_host_name);
+ if (!smp->data.data.str.str)
return 0;
- smp->data.str.len = strlen(smp->data.str.str);
+ smp->data.data.str.len = strlen(smp->data.data.str.str);
return 1;
#else
return 0;
return 0;
finished_trash->len = finished_len;
- smp->data.str = *finished_trash;
- smp->type = SMP_T_BIN;
+ smp->data.data.str = *finished_trash;
+ smp->data.type = SMP_T_BIN;
return 1;
#else
return 0;
}
- smp->type = SMP_T_SINT;
- smp->data.sint = (unsigned long long int)SSL_SOCK_ST_TO_CA_ERROR(conn->xprt_st);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = (unsigned long long int)SSL_SOCK_ST_TO_CA_ERROR(conn->xprt_st);
smp->flags = 0;
return 1;
return 0;
}
- smp->type = SMP_T_SINT;
- smp->data.sint = (long long int)SSL_SOCK_ST_TO_CAEDEPTH(conn->xprt_st);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = (long long int)SSL_SOCK_ST_TO_CAEDEPTH(conn->xprt_st);
smp->flags = 0;
return 1;
return 0;
}
- smp->type = SMP_T_SINT;
- smp->data.sint = (long long int)SSL_SOCK_ST_TO_CRTERROR(conn->xprt_st);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = (long long int)SSL_SOCK_ST_TO_CRTERROR(conn->xprt_st);
smp->flags = 0;
return 1;
if (!conn->xprt_ctx)
return 0;
- smp->type = SMP_T_SINT;
- smp->data.sint = (long long int)SSL_get_verify_result(conn->xprt_ctx);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint;
+ kdata->integer = smp->data.data.sint;
return (void *)&kdata->integer;
}
static void *k_ip2ip(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
- if (smp->type == SMP_T_IPV6) {
- v6tov4(&kdata->ip, &smp->data.ipv6);
+ if (smp->data.type == SMP_T_IPV6) {
+ v6tov4(&kdata->ip, &smp->data.data.ipv6);
return (void *)&kdata->ip.s_addr;
}
else {
- return (void *)&smp->data.ipv4.s_addr;
+ return (void *)&smp->data.data.ipv4.s_addr;
}
}
static void *k_ip2ipv6(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
- if (smp->type == SMP_T_IPV6) {
- return (void *)&smp->data.ipv6.s6_addr;
+ if (smp->data.type == SMP_T_IPV6) {
+ return (void *)&smp->data.data.ipv6.s6_addr;
}
else {
- v4tov6(&kdata->ipv6, &smp->data.ipv4);
+ v4tov6(&kdata->ipv6, &smp->data.data.ipv4);
return (void *)&kdata->ipv6.s6_addr;
}
}
static void *k_ip2int(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
- if (smp->type == SMP_T_IPV6) {
- if (!v6tov4(&kdata->ip, &smp->data.ipv6))
+ if (smp->data.type == SMP_T_IPV6) {
+ if (!v6tov4(&kdata->ip, &smp->data.data.ipv6))
return NULL;
kdata->integer = ntohl(kdata->ip.s_addr);
}
else {
- kdata->integer = ntohl(smp->data.ipv4.s_addr);
+ kdata->integer = ntohl(smp->data.data.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.sint);
+ kdata->ip.s_addr = htonl((unsigned int)smp->data.data.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.str.len;
- return (void *)smp->data.str.str;
+ *len = smp->data.data.str.len;
+ return (void *)smp->data.data.str.str;
}
static void *k_ip2str(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
- if (smp->type == SMP_T_IPV6) {
- if (!inet_ntop(AF_INET6, &smp->data.ipv6, kdata->buf, *len))
+ if (smp->data.type == SMP_T_IPV6) {
+ if (!inet_ntop(AF_INET6, &smp->data.data.ipv6, kdata->buf, *len))
return NULL;
}
else {
- if (!inet_ntop(AF_INET, &smp->data.ipv4, kdata->buf, *len))
+ if (!inet_ntop(AF_INET, &smp->data.data.ipv4, kdata->buf, *len))
return NULL;
}
static void *k_ip2bin(struct sample *smp, union stktable_key_data *kdata, size_t *len)
{
- if (smp->type == SMP_T_IPV4) {
+ if (smp->data.type == SMP_T_IPV4) {
if (*len > 4)
*len = 4;
- memcpy(kdata->buf, &smp->data.ipv4, *len);
+ memcpy(kdata->buf, &smp->data.data.ipv4, *len);
}
- else if (smp->type == SMP_T_IPV6) {
+ else if (smp->data.type == SMP_T_IPV6) {
if (*len > 16)
*len = 16;
- memcpy(kdata->buf, &smp->data.ipv6, *len);
+ memcpy(kdata->buf, &smp->data.data.ipv6, *len);
}
else
*len = 0;
int max = *len;
int size = 0;
- while (ptr < smp->data.str.len && size <= max - 2) {
- c = smp->data.str.str[ptr++];
+ while (ptr < smp->data.data.str.len && size <= max - 2) {
+ c = smp->data.data.str.str[ptr++];
kdata->buf[size++] = hextab[(c >> 4) & 0xF];
kdata->buf[size++] = hextab[c & 0xF];
}
{
void *key;
- key = (void *)lltoa_r(smp->data.sint, kdata->buf, *len);
+ key = (void *)lltoa_r(smp->data.data.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.str.str, smp->data.str.len, &kdata->ip))
+ if (!buf2ip(smp->data.data.str.str, smp->data.data.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.str.str, &kdata->ipv6))
+ if (!inet_pton(AF_INET6, smp->data.data.str.str, &kdata->ipv6))
return NULL;
return (void *)&kdata->ipv6.s6_addr;
int i;
kdata->integer = 0;
- for (i = 0; i < smp->data.str.len; i++) {
- uint32_t val = smp->data.str.str[i] - '0';
+ for (i = 0; i < smp->data.data.str.len; i++) {
+ uint32_t val = smp->data.data.str.str[i] - '0';
if (val > 9)
break;
*/
struct stktable_key *smp_to_stkey(struct sample *smp, struct stktable *t)
{
- if (!sample_to_key[smp->type][t->type])
+ if (!sample_to_key[smp->data.type][t->type])
return NULL;
static_table_key->key_len = t->key_size;
- static_table_key->key = sample_to_key[smp->type][t->type](smp, &static_table_key->data, &static_table_key->key_len);
+ static_table_key->key = sample_to_key[smp->data.type][t->type](smp, &static_table_key->data, &static_table_key->key_len);
if (!static_table_key->key)
return NULL;
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.buf)
+ /* assume static_table_key.key_len is less than sizeof(static_table_key.data.data.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->type = SMP_T_BOOL;
- smp->data.sint = !!ts;
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = !!ts;
smp->flags = SMP_F_VOL_TEST;
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
t->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, conn_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, conn_cnt);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, conn_cur);
+ smp->data.data.sint = stktable_data_cast(ptr, conn_cur);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
t->data_arg[STKTABLE_DT_CONN_RATE].u);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
t->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, gpc0);
+ smp->data.data.sint = stktable_data_cast(ptr, gpc0);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
t->data_arg[STKTABLE_DT_GPC0_RATE].u);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, http_err_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, http_err_cnt);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
t->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, http_req_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, http_req_cnt);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
t->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
+ smp->data.data.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
+ smp->data.data.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, server_id);
+ smp->data.data.sint = stktable_data_cast(ptr, server_id);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = stktable_data_cast(ptr, sess_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, sess_cnt);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (!ts) /* key not present */
if (!ptr)
return 0; /* parameter not stored */
- smp->data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
t->data_arg[STKTABLE_DT_SESS_RATE].u);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = 0;
ts = stktable_lookup_key(t, key);
if (ts)
- smp->data.sint = ts->ref_cnt;
+ smp->data.data.sint = ts->ref_cnt;
return 1;
}
smp_fetch_sc_tracked(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_BOOL;
- smp->data.sint = !!smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw);
+ smp->data.type = SMP_T_BOOL;
+ smp->data.data.sint = !!smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw);
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, gpc0);
+ smp->data.data.sint = stktable_data_cast(ptr, gpc0);
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u);
}
return 1;
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = (&stktable_data_cast(ptr1, gpc0_rate))->curr_ctr;
+ smp->data.data.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.sint = ++stktable_data_cast(ptr2, gpc0);
+ smp->data.data.sint = ++stktable_data_cast(ptr2, gpc0);
/* If data was modified, we need to touch to re-schedule sync */
if (ptr1 || ptr2)
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, gpc0);
+ smp->data.data.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);
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, conn_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, conn_cnt);
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
stkctr->table->data_arg[STKTABLE_DT_CONN_RATE].u);
}
return 1;
if (!ptr)
return 0; /* parameter not stored in this table */
- smp->type = SMP_T_SINT;
- smp->data.sint = ++stktable_data_cast(ptr, conn_cnt);
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = ++stktable_data_cast(ptr, conn_cnt);
/* Touch was previously performed by stktable_update_key */
smp->flags = SMP_F_VOL_TEST;
return 1;
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, conn_cur);
+ smp->data.data.sint = stktable_data_cast(ptr, conn_cur);
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, sess_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, sess_cnt);
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u);
}
return 1;
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, http_req_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, http_req_cnt);
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
}
return 1;
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, http_err_cnt);
+ smp->data.data.sint = stktable_data_cast(ptr, http_err_cnt);
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
}
return 1;
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
+ smp->data.data.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
stkctr->table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
}
return 1;
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
+ smp->data.data.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
}
return 1;
}
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = 0;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.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.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
+ smp->data.data.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
stkctr->table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
}
return 1;
return 0;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = stkctr_entry(stkctr)->ref_cnt;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = stkctr_entry(stkctr)->ref_cnt;
return 1;
}
smp_fetch_table_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = args->data.prx->table.current;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = args->data.prx->table.current;
return 1;
}
px = args->data.prx;
smp->flags = SMP_F_VOL_TEST;
- smp->type = SMP_T_SINT;
- smp->data.sint = px->table.size - px->table.current;
+ smp->data.type = SMP_T_SINT;
+ smp->data.data.sint = px->table.size - px->table.current;
return 1;
}
return 0;
/* Copy sample. */
- smp->type = var->data.type;
+ smp->data.type = var->data.type;
smp->flags |= SMP_F_CONST;
- memcpy(&smp->data, &var->data.data, sizeof(smp->data));
+ memcpy(&smp->data.data, &var->data.data, sizeof(smp->data.data));
return 1;
}
}
/* Set type. */
- var->data.type = smp->type;
+ var->data.type = smp->data.type;
/* Copy data. If the data needs memory, the function can fail. */
switch (var->data.type) {
case SMP_T_BOOL:
case SMP_T_SINT:
- var->data.data.sint = smp->data.sint;
+ var->data.data.sint = smp->data.data.sint;
break;
case SMP_T_IPV4:
- var->data.data.ipv4 = smp->data.ipv4;
+ var->data.data.ipv4 = smp->data.data.ipv4;
break;
case SMP_T_IPV6:
- var->data.data.ipv6 = smp->data.ipv6;
+ var->data.data.ipv6 = smp->data.data.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.str.len)) {
+ if (!var_accounting_add(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, smp->data.data.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.str.len);
+ 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.str.len);
+ var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -smp->data.data.str.len);
var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
return 0;
}
- var->data.data.str.len = smp->data.str.len;
- memcpy(var->data.data.str.str, smp->data.str.str, var->data.data.str.len);
+ 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);
break;
case SMP_T_METH:
- if (!var_accounting_add(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, smp->data.meth.str.len)) {
+ if (!var_accounting_add(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, smp->data.data.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.meth.str.len);
+ 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.meth.str.len);
+ var_accounting_diff(vars, &strm->sess->vars, &strm->vars_txn, &strm->vars_reqres, -smp->data.data.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.meth.meth;
- var->data.data.meth.str.len = smp->data.meth.str.len;
- var->data.data.meth.str.size = smp->data.meth.str.len;
- memcpy(var->data.data.meth.str.str, smp->data.meth.str.str, var->data.data.meth.str.len);
+ 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);
break;
}
return 1;
return 0;
/* Copy sample. */
- smp->type = var->data.type;
+ smp->data.type = var->data.type;
smp->flags = SMP_F_CONST;
- memcpy(&smp->data, &var->data.data, sizeof(smp->data));
+ memcpy(&smp->data.data, &var->data.data, sizeof(smp->data.data));
return 1;
}
return 0;
/* Copy sample. */
- smp->type = var->data.type;
+ smp->data.type = var->data.type;
smp->flags = SMP_F_CONST;
- memcpy(&smp->data, &var->data.data, sizeof(smp->data));
+ memcpy(&smp->data.data, &var->data.data, sizeof(smp->data.data));
return 1;
}
projects / thirdparty / haproxy.git / commitdiff
