diff --git a/include/proto/sample.h b/include/proto/sample.h index db703ef20..d78e82dd7 100644 --- a/include/proto/sample.h +++ b/include/proto/sample.h @@ -43,6 +43,7 @@ struct sample_fetch *find_sample_fetch(const char *kw, int len); int smp_resolve_args(struct proxy *p); int smp_expr_output_type(struct sample_expr *expr); int c_none(struct sample *smp); +int smp_dup(struct sample *smp); /* * This function just apply a cast on sample. It returns 0 if the cast is not diff --git a/include/types/sample.h b/include/types/sample.h index 46bc75b6a..0f189fd7f 100644 --- a/include/types/sample.h +++ b/include/types/sample.h @@ -40,8 +40,6 @@ enum { SMP_T_IPV6, /* ipv6 type */ SMP_T_STR, /* char string type */ SMP_T_BIN, /* buffer type */ - SMP_T_CSTR, /* constant char string type, data need dup before conversion */ - SMP_T_CBIN, /* constant buffer type, data need dup before conversion */ SMP_TYPES /* number of types, must always be last */ }; @@ -203,6 +201,7 @@ enum { SMP_F_VOL_TXN = 1 << 5, /* result sensitive to new transaction (eg: HTTP version) */ SMP_F_VOL_SESS = 1 << 6, /* result sensitive to new session (eg: src IP) */ SMP_F_VOLATILE = (1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6), /* any volatility condition */ + SMP_F_CONST = 1 << 7, /* This sample use constant memory. May diplicate it before changes */ }; /* needed below */ diff --git a/src/compression.c b/src/compression.c index f42f77101..3c53a077b 100644 --- a/src/compression.c +++ b/src/compression.c @@ -628,7 +628,8 @@ smp_fetch_res_comp_algo(struct proxy *px, struct session *l4, void *l7, unsigned if (!l4->comp_algo) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags = SMP_F_CONST; smp->data.str.str = l4->comp_algo->name; smp->data.str.len = l4->comp_algo->name_len; return 1; diff --git a/src/dumpstats.c b/src/dumpstats.c index 31b59f499..0b305859b 100644 --- a/src/dumpstats.c +++ b/src/dumpstats.c @@ -4845,7 +4845,8 @@ static int stats_map_lookup(struct stream_interface *si) chunk_reset(&trash); /* execute pattern matching */ - sample.type = SMP_T_CSTR; + sample.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; pat = NULL; @@ -4935,8 +4936,8 @@ static int stats_map_lookup(struct stream_interface *si) else { memcpy(&sample.data, &smp->data, sizeof(sample.data)); sample.type = smp->type; - if (sample_casts[sample.type][SMP_T_CSTR] && - sample_casts[sample.type][SMP_T_CSTR](&sample)) + if (sample_casts[sample.type][SMP_T_STR] && + sample_casts[sample.type][SMP_T_STR](&sample)) chunk_appendf(&trash, "return=\"%s\", type=\"%s\"\n", sample.data.str.str, smp_to_type[smp->type]); else diff --git a/src/map.c b/src/map.c index 52f077d8e..e48408aa3 100644 --- a/src/map.c +++ b/src/map.c @@ -61,15 +61,16 @@ int map_parse_ip6(const char *text, struct sample_storage *smp) /* Parse a string and store a pointer to it into the sample. The original * string must be left in memory because we return a direct memory reference. - * The output type is CSTR. + * The output type is SMP_T_STR. There is no risk that the data will be + * overwritten because sample_conv_map() makes a const sample with this + * output. */ int map_parse_str(const char *text, struct sample_storage *smp) { - /* The loose of the "const" is balanced by the SMP_T_CSTR type */ smp->data.str.str = (char *)text; smp->data.str.len = strlen(text); smp->data.str.size = smp->data.str.len + 1; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; return 1; } @@ -472,6 +473,7 @@ static int sample_conv_map(const struct arg *arg_p, struct sample *smp) /* copy new data */ smp->type = sample->type; + smp->flags |= SMP_F_CONST; memcpy(&smp->data, &sample->data, sizeof(smp->data)); return 1; } diff --git a/src/pattern.c b/src/pattern.c index fa3b7c561..d41e08633 100644 --- a/src/pattern.c +++ b/src/pattern.c @@ -94,15 +94,15 @@ int pat_match_types[PAT_MATCH_NUM] = { [PAT_MATCH_BOOL] = SMP_T_UINT, [PAT_MATCH_INT] = SMP_T_UINT, [PAT_MATCH_IP] = SMP_T_ADDR, - [PAT_MATCH_BIN] = SMP_T_CBIN, - [PAT_MATCH_LEN] = SMP_T_CSTR, - [PAT_MATCH_STR] = SMP_T_CSTR, - [PAT_MATCH_BEG] = SMP_T_CSTR, - [PAT_MATCH_SUB] = SMP_T_CSTR, - [PAT_MATCH_DIR] = SMP_T_CSTR, - [PAT_MATCH_DOM] = SMP_T_CSTR, - [PAT_MATCH_END] = SMP_T_CSTR, - [PAT_MATCH_REG] = SMP_T_CSTR, + [PAT_MATCH_BIN] = SMP_T_BIN, + [PAT_MATCH_LEN] = SMP_T_STR, + [PAT_MATCH_STR] = SMP_T_STR, + [PAT_MATCH_BEG] = SMP_T_STR, + [PAT_MATCH_SUB] = SMP_T_STR, + [PAT_MATCH_DIR] = SMP_T_STR, + [PAT_MATCH_DOM] = SMP_T_STR, + [PAT_MATCH_END] = SMP_T_STR, + [PAT_MATCH_REG] = SMP_T_STR, }; /* @@ -202,8 +202,8 @@ int pat_parse_nothing(const char *text, struct pattern *pattern, char **err) /* Parse a string. It is allocated and duplicated. */ int pat_parse_str(const char *text, struct pattern *pattern, char **err) { - pattern->type = SMP_T_CSTR; - pattern->expect_type = SMP_T_CSTR; + pattern->type = SMP_T_STR; + pattern->expect_type = SMP_T_STR; pattern->ptr.str = (char *)text; pattern->len = strlen(text); return 1; @@ -214,8 +214,8 @@ int pat_parse_bin(const char *text, struct pattern *pattern, char **err) { struct chunk *trash; - pattern->type = SMP_T_CBIN; - pattern->expect_type = SMP_T_CBIN; + pattern->type = SMP_T_BIN; + pattern->expect_type = SMP_T_BIN; trash = get_trash_chunk(); pattern->len = trash->size; pattern->ptr.str = trash->str; @@ -238,7 +238,7 @@ int pat_parse_reg(const char *text, struct pattern *pattern, char **err) pattern->ptr.reg->regstr = (char *)text; pattern->freeptrbuf = NULL; - pattern->expect_type = SMP_T_CSTR; + pattern->expect_type = SMP_T_STR; return 1; } @@ -328,7 +328,7 @@ int pat_parse_len(const char *text, struct pattern *pattern, char **err) int ret; ret = pat_parse_int(text, pattern, err); - pattern->expect_type = SMP_T_CSTR; + pattern->expect_type = SMP_T_STR; return ret; } @@ -933,7 +933,7 @@ int pat_idx_tree_str(struct pattern_expr *expr, struct pattern *pat, char **err) struct pattern_tree *node; /* Only string can be indexed */ - if (pat->type != SMP_T_CSTR && pat->type != SMP_T_STR) { + if (pat->type != SMP_T_STR) { memprintf(err, "internal error: string expected, but the type is '%s'", smp_to_type[pat->type]); return 0; @@ -1149,7 +1149,6 @@ int pattern_lookup(const char *key, struct pattern_expr *expr, if (!eb_is_empty(&expr->pattern_tree) && pattern.type != SMP_T_IPV6) { /* Check the pattern type */ if (pattern.type != SMP_T_STR && - pattern.type != SMP_T_CSTR && pattern.type != SMP_T_IPV4) { memprintf(err, "Unexpected pattern type."); return 0; diff --git a/src/payload.c b/src/payload.c index d9d66f92a..4bfd27743 100644 --- a/src/payload.c +++ b/src/payload.c @@ -375,10 +375,10 @@ smp_fetch_ssl_hello_sni(struct proxy *px, struct session *s, void *l7, unsigned name_len = (data[7] << 8) + data[8]; if (name_type == 0) { /* hostname */ - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; smp->data.str.str = (char *)data + 9; smp->data.str.len = name_len; - smp->flags = SMP_F_VOLATILE; + smp->flags = SMP_F_VOLATILE | SMP_F_CONST; return 1; } } @@ -410,8 +410,8 @@ fetch_rdp_cookie_name(struct session *s, struct sample *smp, const char *cname, if (!s || !s->req) return 0; - smp->flags = 0; - smp->type = SMP_T_CSTR; + smp->flags = SMP_F_CONST; + smp->type = SMP_T_STR; bleft = s->req->buf->i; if (bleft <= 11) @@ -478,11 +478,11 @@ fetch_rdp_cookie_name(struct session *s, struct sample *smp, const char *cname, goto not_cookie; smp->data.str.len = (char *)data - smp->data.str.str; - smp->flags = SMP_F_VOLATILE; + smp->flags = SMP_F_VOLATILE | SMP_F_CONST; return 1; too_short: - smp->flags = SMP_F_MAY_CHANGE; + smp->flags = SMP_F_MAY_CHANGE | SMP_F_CONST; not_cookie: return 0; } @@ -566,13 +566,13 @@ smp_fetch_payload_lv(struct proxy *px, struct session *s, void *l7, unsigned int goto too_short; /* init chunk as read only */ - smp->type = SMP_T_CBIN; + smp->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); - smp->flags = SMP_F_VOLATILE; return 1; too_short: - smp->flags = SMP_F_MAY_CHANGE; + smp->flags = SMP_F_MAY_CHANGE | SMP_F_CONST; return 0; } @@ -603,16 +603,16 @@ smp_fetch_payload(struct proxy *px, struct session *s, void *l7, unsigned int op goto too_short; /* init chunk as read only */ - smp->type = SMP_T_CBIN; + smp->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)); - smp->flags = SMP_F_VOLATILE; if (!buf_size && !channel_full(chn) && !channel_input_closed(chn)) smp->flags |= SMP_F_MAY_CHANGE; return 1; too_short: - smp->flags = SMP_F_MAY_CHANGE; + smp->flags = SMP_F_MAY_CHANGE | SMP_F_CONST; return 0; } @@ -650,27 +650,27 @@ static int val_payload_lv(struct arg *arg, char **err_msg) * instance IPv4/IPv6 must be declared IPv4. */ static struct sample_fetch_kw_list smp_kws = {ILH, { - { "payload", smp_fetch_payload, ARG2(2,UINT,UINT), NULL, SMP_T_CBIN, SMP_USE_L6REQ|SMP_USE_L6RES }, - { "payload_lv", smp_fetch_payload_lv, ARG3(2,UINT,UINT,SINT), val_payload_lv, SMP_T_CBIN, SMP_USE_L6REQ|SMP_USE_L6RES }, - { "rdp_cookie", smp_fetch_rdp_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_L6REQ }, + { "payload", smp_fetch_payload, ARG2(2,UINT,UINT), NULL, SMP_T_BIN, SMP_USE_L6REQ|SMP_USE_L6RES }, + { "payload_lv", smp_fetch_payload_lv, ARG3(2,UINT,UINT,SINT), val_payload_lv, SMP_T_BIN, SMP_USE_L6REQ|SMP_USE_L6RES }, + { "rdp_cookie", smp_fetch_rdp_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_L6REQ }, { "rdp_cookie_cnt", smp_fetch_rdp_cookie_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_L6REQ }, { "rep_ssl_hello_type", smp_fetch_ssl_hello_type, 0, NULL, SMP_T_UINT, SMP_USE_L6RES }, { "req_len", smp_fetch_len, 0, NULL, SMP_T_UINT, SMP_USE_L6REQ }, { "req_ssl_hello_type", smp_fetch_ssl_hello_type, 0, NULL, SMP_T_UINT, SMP_USE_L6REQ }, - { "req_ssl_sni", smp_fetch_ssl_hello_sni, 0, NULL, SMP_T_CSTR, SMP_USE_L6REQ }, + { "req_ssl_sni", smp_fetch_ssl_hello_sni, 0, NULL, SMP_T_STR, SMP_USE_L6REQ }, { "req_ssl_ver", smp_fetch_req_ssl_ver, 0, NULL, SMP_T_UINT, SMP_USE_L6REQ }, { "req.len", smp_fetch_len, 0, NULL, SMP_T_UINT, SMP_USE_L6REQ }, - { "req.payload", smp_fetch_payload, ARG2(2,UINT,UINT), NULL, SMP_T_CBIN, SMP_USE_L6REQ }, - { "req.payload_lv", smp_fetch_payload_lv, ARG3(2,UINT,UINT,SINT), val_payload_lv, SMP_T_CBIN, SMP_USE_L6REQ }, - { "req.rdp_cookie", smp_fetch_rdp_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_L6REQ }, + { "req.payload", smp_fetch_payload, ARG2(2,UINT,UINT), NULL, SMP_T_BIN, SMP_USE_L6REQ }, + { "req.payload_lv", smp_fetch_payload_lv, ARG3(2,UINT,UINT,SINT), val_payload_lv, SMP_T_BIN, SMP_USE_L6REQ }, + { "req.rdp_cookie", smp_fetch_rdp_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_L6REQ }, { "req.rdp_cookie_cnt", smp_fetch_rdp_cookie_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_L6REQ }, { "req.ssl_hello_type", smp_fetch_ssl_hello_type, 0, NULL, SMP_T_UINT, SMP_USE_L6REQ }, - { "req.ssl_sni", smp_fetch_ssl_hello_sni, 0, NULL, SMP_T_CSTR, SMP_USE_L6REQ }, + { "req.ssl_sni", smp_fetch_ssl_hello_sni, 0, NULL, SMP_T_STR, SMP_USE_L6REQ }, { "req.ssl_ver", smp_fetch_req_ssl_ver, 0, NULL, SMP_T_UINT, SMP_USE_L6REQ }, { "res.len", smp_fetch_len, 0, NULL, SMP_T_UINT, SMP_USE_L6RES }, - { "res.payload", smp_fetch_payload, ARG2(2,UINT,UINT), NULL, SMP_T_CBIN, SMP_USE_L6RES }, - { "res.payload_lv", smp_fetch_payload_lv, ARG3(2,UINT,UINT,SINT), val_payload_lv, SMP_T_CBIN, SMP_USE_L6RES }, + { "res.payload", smp_fetch_payload, ARG2(2,UINT,UINT), NULL, SMP_T_BIN, SMP_USE_L6RES }, + { "res.payload_lv", smp_fetch_payload_lv, ARG3(2,UINT,UINT,SINT), val_payload_lv, SMP_T_BIN, SMP_USE_L6RES }, { "res.ssl_hello_type", smp_fetch_ssl_hello_type, 0, NULL, SMP_T_UINT, SMP_USE_L6RES }, { "wait_end", smp_fetch_wait_end, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN }, { /* END */ }, diff --git a/src/proto_http.c b/src/proto_http.c index 7c0c9159b..eca5a33f4 100644 --- a/src/proto_http.c +++ b/src/proto_http.c @@ -8990,7 +8990,7 @@ static int pat_parse_meth(const char *text, struct pattern *pattern, char **err) return 0; } pattern->ptr.str = trash->str; - pattern->expect_type = SMP_T_CSTR; + pattern->expect_type = SMP_T_STR; pattern->len = len; } else @@ -9016,17 +9016,19 @@ smp_fetch_meth(struct proxy *px, struct session *l4, void *l7, unsigned int opt, CHECK_HTTP_MESSAGE_FIRST_PERM(); meth = txn->meth; + smp->flags = 0; smp->type = SMP_T_UINT; smp->data.uint = meth; if (meth == HTTP_METH_OTHER) { if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE) /* ensure the indexes are not affected */ return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.len = txn->req.sl.rq.m_l; smp->data.str.str = txn->req.chn->buf->p; } - smp->flags = SMP_F_VOL_1ST; + smp->flags |= SMP_F_VOL_1ST; return 1; } @@ -9075,11 +9077,11 @@ smp_fetch_rqver(struct proxy *px, struct session *l4, void *l7, unsigned int opt if (len <= 0) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; smp->data.str.str = ptr; smp->data.str.len = len; - smp->flags = SMP_F_VOL_1ST; + smp->flags = SMP_F_VOL_1ST | SMP_F_CONST; return 1; } @@ -9103,11 +9105,11 @@ smp_fetch_stver(struct proxy *px, struct session *l4, void *l7, unsigned int opt if (len <= 0) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; smp->data.str.str = ptr; smp->data.str.len = len; - smp->flags = SMP_F_VOL_1ST; + smp->flags = SMP_F_VOL_1ST | SMP_F_CONST; return 1; } @@ -9143,10 +9145,10 @@ smp_fetch_url(struct proxy *px, struct session *l4, void *l7, unsigned int opt, CHECK_HTTP_MESSAGE_FIRST(); - smp->type = SMP_T_CSTR; + 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->flags = SMP_F_VOL_1ST; + smp->flags = SMP_F_VOL_1ST | SMP_F_CONST; return 1; } @@ -9238,8 +9240,8 @@ smp_fetch_fhdr(struct proxy *px, struct session *l4, void *l7, unsigned int opt, /* prepare to report multiple occurrences for ACL fetches */ smp->flags |= SMP_F_NOT_LAST; - smp->type = SMP_T_CSTR; - smp->flags |= SMP_F_VOL_HDR; + smp->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)) return 1; @@ -9326,8 +9328,8 @@ smp_fetch_hdr(struct proxy *px, struct session *l4, void *l7, unsigned int opt, /* prepare to report multiple occurrences for ACL fetches */ smp->flags |= SMP_F_NOT_LAST; - smp->type = SMP_T_CSTR; - smp->flags |= SMP_F_VOL_HDR; + smp->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)) return 1; @@ -9434,14 +9436,14 @@ smp_fetch_path(struct proxy *px, struct session *l4, void *l7, unsigned int opt, return 0; /* OK, we got the '/' ! */ - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; smp->data.str.str = ptr; while (ptr < end && *ptr != '?') ptr++; smp->data.str.len = ptr - smp->data.str.str; - smp->flags = SMP_F_VOL_1ST; + smp->flags = SMP_F_VOL_1ST | SMP_F_CONST; return 1; } @@ -9652,7 +9654,8 @@ smp_fetch_http_auth_grp(struct proxy *px, struct session *l4, void *l7, unsigned /* pat_match_auth() will need the user list */ smp->ctx.a[0] = args->data.usr; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags = SMP_F_CONST; smp->data.str.str = l4->txn.auth.user; smp->data.str.len = strlen(l4->txn.auth.user); @@ -9773,7 +9776,8 @@ smp_fetch_capture_header_req(struct proxy *px, struct session *l4, void *l7, uns if (idx > (fe->nb_req_cap - 1) || txn->req.cap == NULL || txn->req.cap[idx] == NULL) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.str = txn->req.cap[idx]; smp->data.str.len = strlen(txn->req.cap[idx]); @@ -9799,7 +9803,8 @@ smp_fetch_capture_header_res(struct proxy *px, struct session *l4, void *l7, uns if (idx > (fe->nb_rsp_cap - 1) || txn->rsp.cap == NULL || txn->rsp.cap[idx] == NULL) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.str = txn->rsp.cap[idx]; smp->data.str.len = strlen(txn->rsp.cap[idx]); @@ -9827,7 +9832,8 @@ smp_fetch_capture_req_method(struct proxy *px, struct session *l4, void *l7, uns temp->str = txn->uri; temp->len = ptr - txn->uri; smp->data.str = *temp; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags = SMP_F_CONST; return 1; @@ -9864,7 +9870,8 @@ smp_fetch_capture_req_uri(struct proxy *px, struct session *l4, void *l7, unsign smp->data.str = *temp; smp->data.str.len = ptr - temp->str; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags = SMP_F_CONST; return 1; } @@ -9948,7 +9955,8 @@ smp_fetch_cookie(struct proxy *px, struct session *l4, void *l7, unsigned int op smp->ctx.a[1] = smp->ctx.a[0] + ctx->vlen; } - smp->type = SMP_T_CSTR; + smp->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, (opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ, @@ -10024,7 +10032,8 @@ smp_fetch_cookie_cnt(struct proxy *px, struct session *l4, void *l7, unsigned in val_end = val_beg + ctx.vlen; } - smp->type = SMP_T_CSTR; + smp->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, (opt & SMP_OPT_DIR) == SMP_OPT_DIR_REQ, @@ -10171,8 +10180,8 @@ smp_fetch_url_param(struct proxy *px, struct session *l4, void *l7, unsigned int delim)) return 0; - smp->type = SMP_T_CSTR; - smp->flags = SMP_F_VOL_1ST; + smp->type = SMP_T_STR; + smp->flags = SMP_F_VOL_1ST | SMP_F_CONST; return 1; } @@ -10424,23 +10433,23 @@ static struct acl_kw_list acl_kws = {ILH, { /************************************************************************/ /* Note: must not be declared as its list will be overwritten */ static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, { - { "base", smp_fetch_base, 0, NULL, SMP_T_CSTR, SMP_USE_HRQHV }, + { "base", smp_fetch_base, 0, NULL, SMP_T_STR, SMP_USE_HRQHV }, { "base32", smp_fetch_base32, 0, NULL, SMP_T_UINT, SMP_USE_HRQHV }, { "base32+src", smp_fetch_base32_src, 0, NULL, SMP_T_BIN, SMP_USE_HRQHV }, - { "capture.req.uri", smp_fetch_capture_req_uri, 0, NULL, SMP_T_CSTR, SMP_USE_HRQHP }, - { "capture.req.method", smp_fetch_capture_req_method, 0, NULL, SMP_T_CSTR, SMP_USE_HRQHP }, + { "capture.req.uri", smp_fetch_capture_req_uri, 0, NULL, SMP_T_STR, SMP_USE_HRQHP }, + { "capture.req.method", smp_fetch_capture_req_method, 0, NULL, SMP_T_STR, SMP_USE_HRQHP }, /* capture are allocated and are permanent in the session */ - { "capture.req.hdr", smp_fetch_capture_header_req, ARG1(1, UINT), NULL, SMP_T_CSTR, SMP_USE_HRQHP }, - { "capture.res.hdr", smp_fetch_capture_header_res, ARG1(1, UINT), NULL, SMP_T_CSTR, SMP_USE_HRSHP }, + { "capture.req.hdr", smp_fetch_capture_header_req, ARG1(1, UINT), NULL, SMP_T_STR, SMP_USE_HRQHP }, + { "capture.res.hdr", smp_fetch_capture_header_res, ARG1(1, UINT), NULL, SMP_T_STR, SMP_USE_HRSHP }, /* cookie is valid in both directions (eg: for "stick ...") but cook* * are only here to match the ACL's name, are request-only and are used * for ACL compatibility only. */ - { "cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_HRQHV }, - { "cookie", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_HRQHV|SMP_USE_HRSHV }, + { "cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRQHV }, + { "cookie", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRQHV|SMP_USE_HRSHV }, { "cook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, { "cook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, @@ -10448,73 +10457,73 @@ static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, { * only here to match the ACL's name, are request-only and are used for * ACL compatibility only. */ - { "hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_CSTR, SMP_USE_HRQHV|SMP_USE_HRSHV }, + { "hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRQHV|SMP_USE_HRSHV }, { "hdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, { "hdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRQHV }, { "hdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_UINT, SMP_USE_HRQHV }, { "http_auth", smp_fetch_http_auth, ARG1(1,USR), NULL, SMP_T_BOOL, SMP_USE_HRQHV }, - { "http_auth_group", smp_fetch_http_auth_grp, ARG1(1,USR), NULL, SMP_T_CSTR, SMP_USE_HRQHV }, + { "http_auth_group", smp_fetch_http_auth_grp, ARG1(1,USR), NULL, SMP_T_STR, SMP_USE_HRQHV }, { "http_first_req", smp_fetch_http_first_req, 0, NULL, SMP_T_BOOL, SMP_USE_HRQHP }, { "method", smp_fetch_meth, 0, NULL, SMP_T_UINT, SMP_USE_HRQHP }, - { "path", smp_fetch_path, 0, NULL, SMP_T_CSTR, SMP_USE_HRQHV }, + { "path", smp_fetch_path, 0, NULL, SMP_T_STR, SMP_USE_HRQHV }, /* HTTP protocol on the request path */ { "req.proto_http", smp_fetch_proto_http, 0, NULL, SMP_T_BOOL, SMP_USE_HRQHP }, { "req_proto_http", smp_fetch_proto_http, 0, NULL, SMP_T_BOOL, SMP_USE_HRQHP }, /* HTTP version on the request path */ - { "req.ver", smp_fetch_rqver, 0, NULL, SMP_T_CSTR, SMP_USE_HRQHV }, - { "req_ver", smp_fetch_rqver, 0, NULL, SMP_T_CSTR, SMP_USE_HRQHV }, + { "req.ver", smp_fetch_rqver, 0, NULL, SMP_T_STR, SMP_USE_HRQHV }, + { "req_ver", smp_fetch_rqver, 0, NULL, SMP_T_STR, SMP_USE_HRQHV }, /* HTTP version on the response path */ - { "res.ver", smp_fetch_stver, 0, NULL, SMP_T_CSTR, SMP_USE_HRSHV }, - { "resp_ver", smp_fetch_stver, 0, NULL, SMP_T_CSTR, SMP_USE_HRSHV }, + { "res.ver", smp_fetch_stver, 0, NULL, SMP_T_STR, SMP_USE_HRSHV }, + { "resp_ver", smp_fetch_stver, 0, NULL, SMP_T_STR, SMP_USE_HRSHV }, /* explicit req.{cook,hdr} are used to force the fetch direction to be request-only */ - { "req.cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_HRQHV }, + { "req.cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRQHV }, { "req.cook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, { "req.cook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, - { "req.fhdr", smp_fetch_fhdr, ARG2(0,STR,SINT), val_hdr, SMP_T_CSTR, SMP_USE_HRQHV }, + { "req.fhdr", smp_fetch_fhdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRQHV }, { "req.fhdr_cnt", smp_fetch_fhdr_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, - { "req.hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_CSTR, SMP_USE_HRQHV }, + { "req.hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRQHV }, { "req.hdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, { "req.hdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRQHV }, { "req.hdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_UINT, SMP_USE_HRQHV }, /* explicit req.{cook,hdr} are used to force the fetch direction to be response-only */ - { "res.cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_HRSHV }, + { "res.cook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRSHV }, { "res.cook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRSHV }, { "res.cook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRSHV }, - { "res.fhdr", smp_fetch_fhdr, ARG2(0,STR,SINT), val_hdr, SMP_T_CSTR, SMP_USE_HRSHV }, + { "res.fhdr", smp_fetch_fhdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRSHV }, { "res.fhdr_cnt", smp_fetch_fhdr_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRSHV }, - { "res.hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_CSTR, SMP_USE_HRSHV }, + { "res.hdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRSHV }, { "res.hdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRSHV }, { "res.hdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRSHV }, { "res.hdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_UINT, SMP_USE_HRSHV }, /* scook is valid only on the response and is used for ACL compatibility */ - { "scook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_HRSHV }, + { "scook", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRSHV }, { "scook_cnt", smp_fetch_cookie_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRSHV }, { "scook_val", smp_fetch_cookie_val, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRSHV }, - { "set-cookie", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_CSTR, SMP_USE_HRSHV }, /* deprecated */ + { "set-cookie", smp_fetch_cookie, ARG1(0,STR), NULL, SMP_T_STR, SMP_USE_HRSHV }, /* deprecated */ /* shdr is valid only on the response and is used for ACL compatibility */ - { "shdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_CSTR, SMP_USE_HRSHV }, + { "shdr", smp_fetch_hdr, ARG2(0,STR,SINT), val_hdr, SMP_T_STR, SMP_USE_HRSHV }, { "shdr_cnt", smp_fetch_hdr_cnt, ARG1(0,STR), NULL, SMP_T_UINT, SMP_USE_HRSHV }, { "shdr_ip", smp_fetch_hdr_ip, ARG2(0,STR,SINT), val_hdr, SMP_T_IPV4, SMP_USE_HRSHV }, { "shdr_val", smp_fetch_hdr_val, ARG2(0,STR,SINT), val_hdr, SMP_T_UINT, SMP_USE_HRSHV }, { "status", smp_fetch_stcode, 0, NULL, SMP_T_UINT, SMP_USE_HRSHP }, - { "url", smp_fetch_url, 0, NULL, SMP_T_CSTR, SMP_USE_HRQHV }, + { "url", smp_fetch_url, 0, NULL, SMP_T_STR, SMP_USE_HRQHV }, { "url32", smp_fetch_url32, 0, NULL, SMP_T_UINT, SMP_USE_HRQHV }, { "url32+src", smp_fetch_url32_src, 0, NULL, SMP_T_BIN, SMP_USE_HRQHV }, { "url_ip", smp_fetch_url_ip, 0, NULL, SMP_T_IPV4, SMP_USE_HRQHV }, { "url_port", smp_fetch_url_port, 0, NULL, SMP_T_UINT, SMP_USE_HRQHV }, - { "url_param", smp_fetch_url_param, ARG2(1,STR,STR), NULL, SMP_T_CSTR, SMP_USE_HRQHV }, - { "urlp" , smp_fetch_url_param, ARG2(1,STR,STR), NULL, SMP_T_CSTR, SMP_USE_HRQHV }, + { "url_param", smp_fetch_url_param, ARG2(1,STR,STR), NULL, SMP_T_STR, SMP_USE_HRQHV }, + { "urlp" , smp_fetch_url_param, ARG2(1,STR,STR), NULL, SMP_T_STR, SMP_USE_HRQHV }, { "urlp_val", smp_fetch_url_param_val, ARG2(1,STR,STR), NULL, SMP_T_UINT, SMP_USE_HRQHV }, { /* END */ }, }}; diff --git a/src/sample.c b/src/sample.c index 7568d270e..e6653fa71 100644 --- a/src/sample.c +++ b/src/sample.c @@ -38,8 +38,6 @@ const char *smp_to_type[SMP_TYPES] = { [SMP_T_IPV6] = "ipv6", [SMP_T_STR] = "str", [SMP_T_BIN] = "bin", - [SMP_T_CSTR] = "cstr", - [SMP_T_CBIN] = "cbin", }; /* static sample used in sample_process() when

is NULL */ @@ -425,6 +423,7 @@ static int c_ip2str(struct sample *smp) trash->len = strlen(trash->str); smp->data.str = *trash; smp->type = SMP_T_STR; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -446,6 +445,7 @@ static int c_ipv62str(struct sample *smp) trash->len = strlen(trash->str); smp->data.str = *trash; smp->type = SMP_T_STR; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -469,9 +469,11 @@ static int c_str2addr(struct sample *smp) if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6)) return 0; smp->type = SMP_T_IPV6; + smp->flags &= ~SMP_F_CONST; return 1; } smp->type = SMP_T_IPV4; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -480,6 +482,7 @@ static int c_str2ip(struct sample *smp) if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4)) return 0; smp->type = SMP_T_IPV4; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -488,6 +491,7 @@ static int c_str2ipv6(struct sample *smp) if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6)) return 0; smp->type = SMP_T_IPV6; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -511,6 +515,7 @@ static int c_bin2str(struct sample *smp) trash->str[ptr] = 0; smp->data.str = *trash; smp->type = SMP_T_STR; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -529,36 +534,48 @@ static int c_int2str(struct sample *smp) trash->len = strlen(pos); smp->data.str = *trash; smp->type = SMP_T_STR; + smp->flags &= ~SMP_F_CONST; return 1; } -static inline void _c_datadup(struct sample *smp) +/* This function duplicates data and removes the flag "const". */ +int smp_dup(struct sample *smp) { - struct chunk *trash = get_trash_chunk(); + struct chunk *trash; - 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; -} + /* If the const flag is not set, we don't need to duplicate the + * pattern as it can be modified in place. + */ + if (!(smp->flags & SMP_F_CONST)) + return 1; -static int c_datadup(struct sample *smp) -{ - _c_datadup(smp); - if (smp->type == SMP_T_CSTR) - smp->type = SMP_T_STR; - else - smp->type = SMP_T_BIN; + switch (smp->type) { + case SMP_T_BOOL: + case SMP_T_UINT: + case SMP_T_SINT: + case SMP_T_ADDR: + case SMP_T_IPV4: + case SMP_T_IPV6: + /* These type are not const. */ + break; + case SMP_T_STR: + 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; + break; + default: + /* Other cases are unexpected. */ + return 0; + } + + /* remove const flag */ + smp->flags &= ~SMP_F_CONST; return 1; } -static int c_bindup(struct sample *smp) -{ - _c_datadup(smp); - smp->type = SMP_T_BIN; - return 1; -} - - int c_none(struct sample *smp) { return 1; @@ -586,6 +603,7 @@ static int c_str2int(struct sample *smp) smp->data.uint = ret; smp->type = SMP_T_UINT; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -596,17 +614,15 @@ static int c_str2int(struct sample *smp) /*****************************************************************/ sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = { -/* to: BOOL UINT SINT ADDR IPV4 IPV6 STR BIN CSTR CBIN */ -/* from: BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, c_int2str, NULL, }, -/* UINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, c_int2str, NULL, }, -/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, c_int2str, NULL, }, -/* ADDR */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, -/* IPV4 */ { NULL, c_ip2int, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, NULL, c_ip2str, NULL, }, -/* IPV6 */ { NULL, NULL, NULL, c_none, NULL, c_none, c_ipv62str, NULL, c_ipv62str, NULL, }, -/* STR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_none, c_none, }, -/* BIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_bin2str, c_none, }, -/* CSTR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_datadup, c_bindup, c_none, c_none, }, -/* CBIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_datadup, c_bin2str, c_none, }, +/* to: BOOL UINT SINT ADDR IPV4 IPV6 STR BIN */ +/* from: BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, }, +/* UINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, }, +/* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, }, +/* ADDR */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, +/* IPV4 */ { NULL, c_ip2int, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, NULL, }, +/* IPV6 */ { NULL, NULL, NULL, c_none, NULL, c_none, c_ipv62str, NULL, }, +/* STR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, }, +/* BIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, }, }; /* @@ -1094,13 +1110,13 @@ struct sample *sample_fetch_string(struct proxy *px, struct session *l4, void *l if (!smp) return NULL; - if (!sample_casts[smp->type][SMP_T_CSTR]) + if (!sample_casts[smp->type][SMP_T_STR]) return NULL; - if (!sample_casts[smp->type][SMP_T_CSTR](smp)) + if (!sample_casts[smp->type][SMP_T_STR](smp)) return NULL; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; return smp; } @@ -1123,6 +1139,7 @@ static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp) } smp->data.str = *trash; smp->type = SMP_T_STR; + smp->flags &= ~SMP_F_CONST; return 1; } @@ -1130,6 +1147,9 @@ static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp) { int i; + if (!smp_dup(smp)) + return 0; + if (!smp->data.str.size) return 0; @@ -1137,7 +1157,6 @@ static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp) if ((smp->data.str.str[i] >= 'A') && (smp->data.str.str[i] <= 'Z')) smp->data.str.str[i] += 'a' - 'A'; } - smp->type = SMP_T_STR; return 1; } @@ -1145,6 +1164,9 @@ static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp) { int i; + if (!smp_dup(smp)) + return 0; + if (!smp->data.str.size) return 0; @@ -1152,7 +1174,6 @@ static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp) if ((smp->data.str.str[i] >= 'a') && (smp->data.str.str[i] <= 'z')) smp->data.str.str[i] += 'A' - 'a'; } - smp->type = SMP_T_STR; return 1; } @@ -1202,7 +1223,8 @@ smp_fetch_env(struct proxy *px, struct session *s, void *l7, unsigned int opt, if (!env) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags = SMP_F_CONST; smp->data.str.str = env; smp->data.str.len = strlen(env); return 1; @@ -1252,7 +1274,7 @@ smp_fetch_rand(struct proxy *px, struct session *s, void *l7, unsigned int opt, static struct sample_fetch_kw_list smp_kws = {ILH, { { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN }, { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN }, - { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_CSTR, SMP_USE_INTRN }, + { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN }, { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_UINT, SMP_USE_INTRN }, { "rand", smp_fetch_rand, ARG1(0,UINT), NULL, SMP_T_UINT, SMP_USE_INTRN }, { /* END */ }, diff --git a/src/ssl_sock.c b/src/ssl_sock.c index 188c1e327..e6a341e50 100644 --- a/src/ssl_sock.c +++ b/src/ssl_sock.c @@ -2192,7 +2192,8 @@ smp_fetch_ssl_c_sig_alg(struct proxy *px, struct session *l4, void *l7, unsigned return 0; } - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.len = strlen(smp->data.str.str); X509_free(crt); @@ -2233,7 +2234,8 @@ smp_fetch_ssl_c_key_alg(struct proxy *px, struct session *l4, void *l7, unsigned return 0; } - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.len = strlen(smp->data.str.str); X509_free(crt); @@ -2442,7 +2444,8 @@ smp_fetch_ssl_f_sig_alg(struct proxy *px, struct session *l4, void *l7, unsigned if (!smp->data.str.str) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.len = strlen(smp->data.str.str); return 1; @@ -2479,7 +2482,8 @@ smp_fetch_ssl_f_key_alg(struct proxy *px, struct session *l4, void *l7, unsigned if (!smp->data.str.str) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.len = strlen(smp->data.str.str); return 1; @@ -2610,7 +2614,8 @@ smp_fetch_ssl_fc_cipher(struct proxy *px, struct session *l4, void *l7, unsigned if (!smp->data.str.str) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags |= SMP_F_CONST; smp->data.str.len = strlen(smp->data.str.str); return 1; @@ -2670,8 +2675,8 @@ smp_fetch_ssl_fc_npn(struct proxy *px, struct session *l4, void *l7, unsigned in { struct connection *conn; - smp->flags = 0; - smp->type = SMP_T_CSTR; + smp->flags = SMP_F_CONST; + smp->type = SMP_T_STR; if (!l4) return 0; @@ -2698,8 +2703,8 @@ smp_fetch_ssl_fc_alpn(struct proxy *px, struct session *l4, void *l7, unsigned i { struct connection *conn; - smp->flags = 0; - smp->type = SMP_T_CSTR; + smp->flags = SMP_F_CONST; + smp->type = SMP_T_STR; if (!l4) return 0; @@ -2738,7 +2743,8 @@ smp_fetch_ssl_fc_protocol(struct proxy *px, struct session *l4, void *l7, unsign if (!smp->data.str.str) return 0; - smp->type = SMP_T_CSTR; + smp->type = SMP_T_STR; + smp->flags = SMP_F_CONST; smp->data.str.len = strlen(smp->data.str.str); return 1; @@ -2752,8 +2758,8 @@ smp_fetch_ssl_fc_session_id(struct proxy *px, struct session *l4, void *l7, unsi SSL_SESSION *sess; struct connection *conn; - smp->flags = 0; - smp->type = SMP_T_CBIN; + smp->flags = SMP_F_CONST; + smp->type = SMP_T_BIN; if (!l4) return 0; @@ -2783,8 +2789,8 @@ smp_fetch_ssl_fc_sni(struct proxy *px, struct session *l4, void *l7, unsigned in #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME struct connection *conn; - smp->flags = 0; - smp->type = SMP_T_CSTR; + smp->flags = SMP_F_CONST; + smp->type = SMP_T_STR; if (!l4) return 0; @@ -3520,19 +3526,19 @@ static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, { { "ssl_f_version", smp_fetch_ssl_f_version, 0, NULL, SMP_T_UINT, SMP_USE_L5CLI }, { "ssl_fc", smp_fetch_ssl_fc, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI }, { "ssl_fc_alg_keysize", smp_fetch_ssl_fc_alg_keysize, 0, NULL, SMP_T_UINT, SMP_USE_L5CLI }, - { "ssl_fc_cipher", smp_fetch_ssl_fc_cipher, 0, NULL, SMP_T_CSTR, SMP_USE_L5CLI }, + { "ssl_fc_cipher", smp_fetch_ssl_fc_cipher, 0, NULL, SMP_T_STR, SMP_USE_L5CLI }, { "ssl_fc_has_crt", smp_fetch_ssl_fc_has_crt, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI }, { "ssl_fc_has_sni", smp_fetch_ssl_fc_has_sni, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI }, #ifdef OPENSSL_NPN_NEGOTIATED - { "ssl_fc_npn", smp_fetch_ssl_fc_npn, 0, NULL, SMP_T_CSTR, SMP_USE_L5CLI }, + { "ssl_fc_npn", smp_fetch_ssl_fc_npn, 0, NULL, SMP_T_STR, SMP_USE_L5CLI }, #endif #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation - { "ssl_fc_alpn", smp_fetch_ssl_fc_alpn, 0, NULL, SMP_T_CSTR, SMP_USE_L5CLI }, + { "ssl_fc_alpn", smp_fetch_ssl_fc_alpn, 0, NULL, SMP_T_STR, SMP_USE_L5CLI }, #endif - { "ssl_fc_protocol", smp_fetch_ssl_fc_protocol, 0, NULL, SMP_T_CSTR, SMP_USE_L5CLI }, + { "ssl_fc_protocol", smp_fetch_ssl_fc_protocol, 0, NULL, SMP_T_STR, SMP_USE_L5CLI }, { "ssl_fc_use_keysize", smp_fetch_ssl_fc_use_keysize, 0, NULL, SMP_T_UINT, SMP_USE_L5CLI }, - { "ssl_fc_session_id", smp_fetch_ssl_fc_session_id, 0, NULL, SMP_T_CBIN, SMP_USE_L5CLI }, - { "ssl_fc_sni", smp_fetch_ssl_fc_sni, 0, NULL, SMP_T_CSTR, SMP_USE_L5CLI }, + { "ssl_fc_session_id", smp_fetch_ssl_fc_session_id, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI }, + { "ssl_fc_sni", smp_fetch_ssl_fc_sni, 0, NULL, SMP_T_STR, SMP_USE_L5CLI }, { NULL, NULL, 0, 0, 0 }, }}; diff --git a/src/stick_table.c b/src/stick_table.c index 92c4dd44c..c6463ec7b 100644 --- a/src/stick_table.c +++ b/src/stick_table.c @@ -594,8 +594,6 @@ static sample_to_key_fct sample_to_key[SMP_TYPES][STKTABLE_TYPES] = { /* IPV6 */ { k_ip2ip, k_ip2ipv6, k_ip2int, k_ip2str, NULL }, /* STR */ { k_str2ip, k_str2ipv6, k_str2int, k_str2str, k_str2str }, /* BIN */ { NULL, NULL, NULL, k_bin2str, k_str2str }, -/* CSTR */ { k_str2ip, k_str2ipv6, k_str2int, k_str2str, k_str2str }, -/* CBIN */ { NULL, NULL, NULL, k_bin2str, k_str2str }, };