s/tmpl_data/tmpl_value_box/g

diff --git a/src/include/tmpl.h b/src/include/tmpl.h
index 6ac75034c49731a9d280c9ea6881f45499697d45..61ce26ca6dd484da4249ad675d43e735e9414d08 100644 (file)
--- a/src/include/tmpl.h
+++ b/src/include/tmpl.h
@@ -246,10 +246,10 @@ typedef struct vp_tmpl_t {
  *
  * @{
  */
-#define tmpl_data              data.literal
-#define tmpl_data_type         data.literal.type
-#define tmpl_data_length       data.literal.data.length
-#define tmpl_data_value                data.literal.data
+#define tmpl_value_box         data.literal
+#define tmpl_value_box_type            data.literal.type
+#define tmpl_value_box_length  data.literal.data.length
+#define tmpl_value_box_datum           data.literal.data
 /* @} **/
 
 /** @name Field accessors for #TMPL_TYPE_REGEX_STRUCT and #TMPL_TYPE_REGEX

diff --git a/src/main/evaluate.c b/src/main/evaluate.c
index 5c160682330141686d389bcd405585fff2ba1d1b..c3d86338873c6f16d8ba0631027ff5d081510f55 100644 (file)
--- a/src/main/evaluate.c
+++ b/src/main/evaluate.c
@@ -503,11 +503,11 @@ do {\
                EVAL_DEBUG("NORMALISATION TYPE %s (IMPLICIT FROM RHS REF)",
                           fr_int2str(dict_attr_types, cast->type, "<INVALID>"));
        } else if (map->lhs->type == TMPL_TYPE_DATA) {
-               cast_type = map->lhs->tmpl_data_type;
+               cast_type = map->lhs->tmpl_value_box_type;
                EVAL_DEBUG("NORMALISATION TYPE %s (IMPLICIT FROM LHS DATA)",
                           fr_int2str(dict_attr_types, cast_type, "<INVALID>"));
        } else if (map->rhs->type == TMPL_TYPE_DATA) {
-               cast_type = map->rhs->tmpl_data_type;
+               cast_type = map->rhs->tmpl_value_box_type;
                EVAL_DEBUG("NORMALISATION TYPE %s (IMPLICIT FROM RHS DATA)",
                           fr_int2str(dict_attr_types, cast_type, "<INVALID>"));
        }
@@ -540,8 +540,8 @@ do {\
                break;
 
        case TMPL_TYPE_DATA:
-               rhs_type = map->rhs->tmpl_data_type;
-               rhs = &map->rhs->tmpl_data_value;
+               rhs_type = map->rhs->tmpl_value_box_type;
+               rhs = &map->rhs->tmpl_value_box_datum;
 
                CHECK_INT_CAST(lhs, rhs);
                CAST(lhs);
@@ -680,7 +680,7 @@ int radius_evaluate_map(REQUEST *request, UNUSED int modreturn, UNUSED int depth
 
        case TMPL_TYPE_DATA:
                rcode = cond_normalise_and_cmp(request, c,
-                                             map->lhs->tmpl_data_type, NULL, &map->lhs->tmpl_data_value);
+                                             map->lhs->tmpl_value_box_type, NULL, &map->lhs->tmpl_value_box_datum);
                break;
 
        case TMPL_TYPE_UNPARSED:

diff --git a/src/main/map.c b/src/main/map.c
index 09ec526675c201c4e62bf3724a72090ed8a30d7d..03d4cc2b55fed70a63555fda38b31b3f3863807e 100644 (file)
--- a/src/main/map.c
+++ b/src/main/map.c
@@ -131,18 +131,18 @@ bool map_cast_from_hex(vp_map_t *map, FR_TOKEN rhs_type, char const *rhs)
        map->rhs = tmpl_alloc(map, TMPL_TYPE_DATA, NULL, 0, T_INVALID);
        if (!map->rhs) goto free_vp;
 
-       map->rhs->tmpl_data_type = da->type;
-       map->rhs->tmpl_data_length = vp->vp_length;
+       map->rhs->tmpl_value_box_type = da->type;
+       map->rhs->tmpl_value_box_length = vp->vp_length;
        if (vp->da->flags.is_pointer) {
                if (vp->da->type == PW_TYPE_STRING) {
-                       map->rhs->tmpl_data_value.datum.ptr = talloc_bstrndup(map->rhs, vp->vp_ptr, vp->vp_length);
+                       map->rhs->tmpl_value_box_datum.datum.ptr = talloc_bstrndup(map->rhs, vp->vp_ptr, vp->vp_length);
                        map->rhs->quote = T_SINGLE_QUOTED_STRING;
                } else {
-                       map->rhs->tmpl_data_value.datum.ptr = talloc_memdup(map->rhs, vp->vp_ptr, vp->vp_length);
+                       map->rhs->tmpl_value_box_datum.datum.ptr = talloc_memdup(map->rhs, vp->vp_ptr, vp->vp_length);
                        map->rhs->quote = T_BARE_WORD;
                }
        } else {
-               value_box_copy(map->rhs, &map->rhs->tmpl_data_value, vp->da->type, &vp->data);
+               value_box_copy(map->rhs, &map->rhs->tmpl_value_box_datum, vp->da->type, &vp->data);
                map->rhs->quote = T_BARE_WORD;
        }
        map->rhs->name = fr_pair_value_asprint(map->rhs, vp, fr_token_quote[map->rhs->quote]);
@@ -953,14 +953,14 @@ int map_to_vp(TALLOC_CTX *ctx, VALUE_PAIR **out, REQUEST *request, vp_map_t cons
                new = fr_pair_afrom_da(ctx, map->lhs->tmpl_da);
                if (!new) return -1;
 
-               if (map->lhs->tmpl_da->type == map->rhs->tmpl_data_type) {
-                       if (value_box_copy(new, &new->data, new->da->type, &map->rhs->tmpl_data_value) < 0) {
+               if (map->lhs->tmpl_da->type == map->rhs->tmpl_value_box_type) {
+                       if (value_box_copy(new, &new->data, new->da->type, &map->rhs->tmpl_value_box_datum) < 0) {
                                rcode = -1;
                                goto error;
                        }
                } else {
-                       if (value_box_cast(new, &new->data, new->da->type, new->da, map->rhs->tmpl_data_type,
-                                           NULL, &map->rhs->tmpl_data_value) < 0) {
+                       if (value_box_cast(new, &new->data, new->da->type, new->da, map->rhs->tmpl_value_box_type,
+                                           NULL, &map->rhs->tmpl_value_box_datum) < 0) {
                                REDEBUG("Implicit cast failed: %s", fr_strerror());
                                rcode = -1;
                                goto error;

diff --git a/src/main/modcall.c b/src/main/modcall.c
index 62157938eea773ab4d5b7bffbabd6aedaf7a6811..e08446dd05e65239d3033e578c8cf93d8e649db9 100644 (file)
--- a/src/main/modcall.c
+++ b/src/main/modcall.c
@@ -1300,14 +1300,14 @@ int unlang_fixup_update(vp_map_t *map, UNUSED void *ctx)
                 *      Fixup LHS da if it doesn't match the type
                 *      of the RHS.
                 */
-               if (map->lhs->tmpl_da->type != map->rhs->tmpl_data_type) {
+               if (map->lhs->tmpl_da->type != map->rhs->tmpl_value_box_type) {
                        fr_dict_attr_t const *da;
 
                        da = fr_dict_attr_by_type(NULL, map->lhs->tmpl_da->vendor, map->lhs->tmpl_da->attr,
-                                                 map->rhs->tmpl_data_type);
+                                                 map->rhs->tmpl_value_box_type);
                        if (!da) {
                                fr_strerror_printf("Cannot find %s variant of attribute \"%s\"",
-                                                  fr_int2str(dict_attr_types, map->rhs->tmpl_data_type,
+                                                  fr_int2str(dict_attr_types, map->rhs->tmpl_value_box_type,
                                                   "<INVALID>"), map->lhs->tmpl_da->name);
                                return -1;
                        }

diff --git a/src/main/parser.c b/src/main/parser.c
index a2318cc4d0e0545c11fe150c2f32b035340d8022..6f510b074782400f8e919c8e74a82b871d7190c5 100644 (file)
--- a/src/main/parser.c
+++ b/src/main/parser.c
@@ -1123,7 +1123,7 @@ static ssize_t condition_tokenize(TALLOC_CTX *ctx, CONF_ITEM *ci, char const *st
 
                                                da = fr_dict_attr_by_type(NULL, c->data.map->lhs->tmpl_da->vendor,
                                                                          c->data.map->lhs->tmpl_da->attr,
-                                                                         c->data.map->rhs->tmpl_data_type);
+                                                                         c->data.map->rhs->tmpl_value_box_type);
                                                if (!da) {
                                                        return_rhs("Cannot find type for attribute");
                                                }

diff --git a/src/main/tmpl.c b/src/main/tmpl.c
index 995557e3b5e6202739e5657fdfcd7981059ebaef..639d167dbbfcdd2afacafc567947caf9b93461e2 100644 (file)
--- a/src/main/tmpl.c
+++ b/src/main/tmpl.c
@@ -618,17 +618,17 @@ int tmpl_afrom_value_box(TALLOC_CTX *ctx, vp_tmpl_t **out, value_box_t *data,
                  (type == PW_TYPE_STRING) ? T_DOUBLE_QUOTED_STRING : T_BARE_WORD);
 
        if (steal) {
-               if (value_box_steal(vpt, &vpt->tmpl_data_value, type, data) < 0) {
+               if (value_box_steal(vpt, &vpt->tmpl_value_box_datum, type, data) < 0) {
                        talloc_free(vpt);
                        return -1;
                }
-               vpt->tmpl_data_type = type;
+               vpt->tmpl_value_box_type = type;
        } else {
-               if (value_box_copy(vpt, &vpt->tmpl_data_value, type, data) < 0) {
+               if (value_box_copy(vpt, &vpt->tmpl_value_box_datum, type, data) < 0) {
                        talloc_free(vpt);
                        return -1;
                }
-               vpt->tmpl_data_type = type;
+               vpt->tmpl_value_box_type = type;
        }
        *out = vpt;
 
@@ -1067,11 +1067,11 @@ ssize_t tmpl_afrom_str(TALLOC_CTX *ctx, vp_tmpl_t **out, char const *in, size_t
                        binlen = (inlen - 2) / 2;
 
                        vpt = tmpl_alloc(ctx, TMPL_TYPE_DATA, in, inlen, type);
-                       vpt->tmpl_data_value.datum.ptr = talloc_array(vpt, uint8_t, binlen);
-                       vpt->tmpl_data_length = binlen;
-                       vpt->tmpl_data_type = PW_TYPE_OCTETS;
+                       vpt->tmpl_value_box_datum.datum.ptr = talloc_array(vpt, uint8_t, binlen);
+                       vpt->tmpl_value_box_length = binlen;
+                       vpt->tmpl_value_box_type = PW_TYPE_OCTETS;
 
-                       len = fr_hex2bin(vpt->tmpl_data_value.datum.ptr, binlen, in + 2, inlen - 2);
+                       len = fr_hex2bin(vpt->tmpl_value_box_datum.datum.ptr, binlen, in + 2, inlen - 2);
                        if (len != binlen) {
                                fr_strerror_printf("Hex string contains none hex char");
                                talloc_free(vpt);
@@ -1232,12 +1232,12 @@ int tmpl_cast_in_place(vp_tmpl_t *vpt, PW_TYPE type, fr_dict_attr_t const *enumv
 
        switch (vpt->type) {
        case TMPL_TYPE_UNPARSED:
-               vpt->tmpl_data_type = type;
+               vpt->tmpl_value_box_type = type;
 
                /*
                 *      Why do we pass a pointer to the tmpl type? Goddamn WiMAX.
                 */
-               if (value_box_from_str(vpt, &vpt->tmpl_data_value, &vpt->tmpl_data_type,
+               if (value_box_from_str(vpt, &vpt->tmpl_value_box_datum, &vpt->tmpl_value_box_type,
                                        enumv, vpt->name, vpt->len, '\0') < 0) return -1;
                vpt->type = TMPL_TYPE_DATA;
                break;
@@ -1246,26 +1246,26 @@ int tmpl_cast_in_place(vp_tmpl_t *vpt, PW_TYPE type, fr_dict_attr_t const *enumv
        {
                value_box_t new;
 
-               if (type == vpt->tmpl_data_type) return 0;      /* noop */
+               if (type == vpt->tmpl_value_box_type) return 0; /* noop */
 
-               if (value_box_cast(vpt, &new, type, enumv, vpt->tmpl_data_type,
-                                   NULL, &vpt->tmpl_data_value) < 0) return -1;
+               if (value_box_cast(vpt, &new, type, enumv, vpt->tmpl_value_box_type,
+                                   NULL, &vpt->tmpl_value_box_datum) < 0) return -1;
 
                /*
                 *      Free old value buffers
                 */
-               switch (vpt->tmpl_data_type) {
+               switch (vpt->tmpl_value_box_type) {
                case PW_TYPE_STRING:
                case PW_TYPE_OCTETS:
-                       talloc_free(vpt->tmpl_data_value.datum.ptr);
+                       talloc_free(vpt->tmpl_value_box_datum.datum.ptr);
                        break;
 
                default:
                        break;
                }
 
-               value_box_copy(vpt, &vpt->tmpl_data_value, type, &new);
-               vpt->tmpl_data_type = type;
+               value_box_copy(vpt, &vpt->tmpl_value_box_datum, type, &new);
+               vpt->tmpl_value_box_type = type;
        }
                break;
 
@@ -1289,12 +1289,12 @@ void tmpl_cast_in_place_str(vp_tmpl_t *vpt)
        rad_assert(vpt != NULL);
        rad_assert(vpt->type == TMPL_TYPE_UNPARSED);
 
-       vpt->tmpl_data.vp_strvalue = talloc_typed_strdup(vpt, vpt->name);
-       rad_assert(vpt->tmpl_data.vp_strvalue != NULL);
+       vpt->tmpl_value_box.vp_strvalue = talloc_typed_strdup(vpt, vpt->name);
+       rad_assert(vpt->tmpl_value_box.vp_strvalue != NULL);
 
        vpt->type = TMPL_TYPE_DATA;
-       vpt->tmpl_data_type = PW_TYPE_STRING;
-       vpt->tmpl_data_length = talloc_array_length(vpt->tmpl_data.vp_strvalue) - 1;
+       vpt->tmpl_value_box_type = PW_TYPE_STRING;
+       vpt->tmpl_value_box_length = talloc_array_length(vpt->tmpl_value_box.vp_strvalue) - 1;
 }
 
 /** Expand a #vp_tmpl_t to a string, parse it as an attribute of type cast, create a #VALUE_PAIR from the result
@@ -1332,9 +1332,9 @@ int tmpl_cast_to_vp(VALUE_PAIR **out, REQUEST *request,
 
        if (vpt->type == TMPL_TYPE_DATA) {
                VERIFY_VP(vp);
-               rad_assert(vp->da->type == vpt->tmpl_data_type);
+               rad_assert(vp->da->type == vpt->tmpl_value_box_type);
 
-               value_box_copy(vp, &vp->data, vpt->tmpl_data_type, &vpt->tmpl_data_value);
+               value_box_copy(vp, &vp->data, vpt->tmpl_value_box_type, &vpt->tmpl_value_box_datum);
                *out = vp;
                return 0;
        }
@@ -1607,8 +1607,8 @@ ssize_t _tmpl_to_type(void *out,
                ret = tmpl_find_vp(&vp, request, vpt);
                if (ret < 0) return -2;
 
-               to_cast = &vpt->tmpl_data_value;
-               src_type = vpt->tmpl_data_type;
+               to_cast = &vpt->tmpl_value_box_datum;
+               src_type = vpt->tmpl_value_box_type;
        }
                break;
 
@@ -1919,8 +1919,8 @@ ssize_t _tmpl_to_atype(TALLOC_CTX *ctx, void *out,
        {
                RDEBUG4("EXPAND TMPL DATA");
 
-               to_cast = &vpt->tmpl_data_value;
-               src_type = vpt->tmpl_data_type;
+               to_cast = &vpt->tmpl_value_box_datum;
+               src_type = vpt->tmpl_value_box_type;
 
                switch (src_type) {
                case PW_TYPE_STRING:
@@ -2135,7 +2135,7 @@ do_literal:
                break;
 
        case TMPL_TYPE_DATA:
-               return value_box_snprint(out, outlen, vpt->tmpl_data_type, values, &vpt->tmpl_data_value,
+               return value_box_snprint(out, outlen, vpt->tmpl_value_box_type, values, &vpt->tmpl_value_box_datum,
                                         fr_token_quote[vpt->quote]);
 
        default:
@@ -2662,24 +2662,24 @@ void tmpl_verify(char const *file, int line, vp_tmpl_t const *vpt)
                        if (!fr_cond_assert(0)) fr_exit_now(1);
                }
 
-               if (vpt->tmpl_data_type == PW_TYPE_INVALID) {
+               if (vpt->tmpl_value_box_type == PW_TYPE_INVALID) {
                        FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA type was "
                                     "PW_TYPE_INVALID (uninitialised)", file, line);
                        if (!fr_cond_assert(0)) fr_exit_now(1);
                }
 
-               if (vpt->tmpl_data_type >= PW_TYPE_MAX) {
+               if (vpt->tmpl_value_box_type >= PW_TYPE_MAX) {
                        FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA type was "
-                                    "%i (outside the range of PW_TYPEs)", file, line, vpt->tmpl_data_type);
+                                    "%i (outside the range of PW_TYPEs)", file, line, vpt->tmpl_value_box_type);
                        if (!fr_cond_assert(0)) fr_exit_now(1);
                }
                /*
                 *      Unlike VALUE_PAIRs we can't guarantee that VALUE_PAIR_TMPL buffers will
                 *      be talloced. They may be allocated on the stack or in global variables.
                 */
-               switch (vpt->tmpl_data_type) {
+               switch (vpt->tmpl_value_box_type) {
                case PW_TYPE_STRING:
-                       if (vpt->tmpl_data.vp_strvalue[vpt->tmpl_data_length] != '\0') {
+                       if (vpt->tmpl_value_box.vp_strvalue[vpt->tmpl_value_box_length] != '\0') {
                                FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA char buffer not \\0 "
                                             "terminated", file, line);
                                if (!fr_cond_assert(0)) fr_exit_now(1);
@@ -2695,7 +2695,7 @@ void tmpl_verify(char const *file, int line, vp_tmpl_t const *vpt)
                        break;
 
                default:
-                       if (vpt->tmpl_data_length == 0) {
+                       if (vpt->tmpl_value_box_length == 0) {
                                FR_FAULT_LOG("CONSISTENCY CHECK FAILED %s[%u]: TMPL_TYPE_DATA data pointer not NULL "
                                             "but len field is zero", file, line);
                                if (!fr_cond_assert(0)) fr_exit_now(1);

diff --git a/src/modules/rlm_cache/drivers/rlm_cache_redis/rlm_cache_redis.c b/src/modules/rlm_cache/drivers/rlm_cache_redis/rlm_cache_redis.c
index a356909de1b6edd357d0f4619a1881e07ddf6a00..ec273bb6cb6af97aaae9b98eba161d47f546ef78 100644 (file)
--- a/src/modules/rlm_cache/drivers/rlm_cache_redis/rlm_cache_redis.c
+++ b/src/modules/rlm_cache/drivers/rlm_cache_redis/rlm_cache_redis.c
@@ -209,7 +209,7 @@ static cache_status_t cache_entry_find(rlm_cache_entry_t **out,
        if ((head->lhs->tmpl_da->vendor == 0) && (head->lhs->tmpl_da->attr == PW_CACHE_CREATED)) {
                vp_map_t *map;
 
-               c->created = head->rhs->tmpl_data_value.datum.date;
+               c->created = head->rhs->tmpl_value_box_datum.datum.date;
 
                map = head;
                head = head->next;
@@ -222,7 +222,7 @@ static cache_status_t cache_entry_find(rlm_cache_entry_t **out,
        if ((head->lhs->tmpl_da->vendor == 0) && (head->lhs->tmpl_da->attr == PW_CACHE_EXPIRES)) {
                vp_map_t *map;
 
-               c->expires = head->rhs->tmpl_data_value.datum.date;
+               c->expires = head->rhs->tmpl_value_box_datum.datum.date;
 
                map = head;
                head = head->next;
@@ -288,9 +288,9 @@ static cache_status_t cache_entry_insert(UNUSED rlm_cache_config_t const *config
         *      Encode the entry created date
         */
        tmpl_init(&created_value, TMPL_TYPE_DATA, "<TEMP>", 6, T_BARE_WORD);
-       created_value.tmpl_data_type = PW_TYPE_DATE;
-       created_value.tmpl_data_length = sizeof(created_value.tmpl_data_value.datum.date);
-       created_value.tmpl_data_value.datum.date = c->created;
+       created_value.tmpl_value_box_type = PW_TYPE_DATE;
+       created_value.tmpl_value_box_length = sizeof(created_value.tmpl_value_box_datum.datum.date);
+       created_value.tmpl_value_box_datum.datum.date = c->created;
 
        /*
         *      Encode the entry expiry time
@@ -299,9 +299,9 @@ static cache_status_t cache_entry_insert(UNUSED rlm_cache_config_t const *config
         *      to ignore entries that were created before the last epoch.
         */
        tmpl_init(&expires_value, TMPL_TYPE_DATA, "<TEMP>", 6, T_BARE_WORD);
-       expires_value.tmpl_data_type = PW_TYPE_DATE;
-       expires_value.tmpl_data_length = sizeof(expires_value.tmpl_data_value.datum.date);
-       expires_value.tmpl_data_value.datum.date = c->expires;
+       expires_value.tmpl_value_box_type = PW_TYPE_DATE;
+       expires_value.tmpl_value_box_length = sizeof(expires_value.tmpl_value_box_datum.datum.date);
+       expires_value.tmpl_value_box_datum.datum.date = c->expires;
        expires.next = c->maps; /* Head of the list */
 
        for (cnt = 0, map = &created; map; cnt++, map = map->next);

diff --git a/src/modules/rlm_cache/rlm_cache.c b/src/modules/rlm_cache/rlm_cache.c
index ff982083e381ef96d923ddbe3931a584aafe24af..4241d94dce21cdb597d62907f3f524f44f170e7d 100644 (file)
--- a/src/modules/rlm_cache/rlm_cache.c
+++ b/src/modules/rlm_cache/rlm_cache.c
@@ -370,7 +370,7 @@ static rlm_rcode_t cache_insert(rlm_cache_t const *inst, REQUEST *request, rlm_c
                        do_rhs:
                                MEM(c_map->rhs = tmpl_init(talloc(c_map, vp_tmpl_t),
                                                           TMPL_TYPE_DATA, map->rhs->name, map->rhs->len, T_BARE_WORD));
-                               if (value_box_copy(c_map->rhs, &c_map->rhs->tmpl_data_value,
+                               if (value_box_copy(c_map->rhs, &c_map->rhs->tmpl_value_box_datum,
                                                    vp->da->type, &vp->data) < 0) {
                                        REDEBUG("Failed copying attribute value");
                                error:
@@ -378,7 +378,7 @@ static rlm_rcode_t cache_insert(rlm_cache_t const *inst, REQUEST *request, rlm_c
                                        talloc_free(c);
                                        return RLM_MODULE_FAIL;
                                }
-                               c_map->rhs->tmpl_data_type = vp->da->type;
+                               c_map->rhs->tmpl_value_box_type = vp->da->type;
                                if (vp->da->type == PW_TYPE_STRING) {
                                        c_map->rhs->quote = is_printable(vp->vp_strvalue, vp->vp_length) ?
                                                T_SINGLE_QUOTED_STRING : T_DOUBLE_QUOTED_STRING;
@@ -829,8 +829,8 @@ static ssize_t cache_xlat(UNUSED TALLOC_CTX *ctx, char **out, UNUSED size_t free
                    (map->lhs->tmpl_tag != target.tmpl_tag) ||
                    (map->lhs->tmpl_list != target.tmpl_list)) continue;
 
-               *out = value_box_asprint(request, map->rhs->tmpl_data_type, map->lhs->tmpl_da,
-                                         &map->rhs->tmpl_data_value, '\0');
+               *out = value_box_asprint(request, map->rhs->tmpl_value_box_type, map->lhs->tmpl_da,
+                                         &map->rhs->tmpl_value_box_datum, '\0');
                ret = talloc_array_length(*out) - 1;
                break;
        }

diff --git a/src/modules/rlm_cache/serialize.c b/src/modules/rlm_cache/serialize.c
index 14aed0b7d312c347817bf4ca3b22af7e6cbb5cf4..c0aa2f88e47c2f9bc1bfe4ac2e3313be6f4dfc82 100644 (file)
--- a/src/modules/rlm_cache/serialize.c
+++ b/src/modules/rlm_cache/serialize.c
@@ -74,8 +74,8 @@ int cache_serialize(TALLOC_CTX *ctx, char **out, rlm_cache_entry_t const *c)
                        goto error;
                }
 
-               value = value_box_asprint(value_pool, map->rhs->tmpl_data_type,
-                                          map->lhs->tmpl_da, &map->rhs->tmpl_data_value, '\'');
+               value = value_box_asprint(value_pool, map->rhs->tmpl_value_box_type,
+                                          map->lhs->tmpl_da, &map->rhs->tmpl_value_box_datum, '\'');
                if (!value) goto error;
 
                to_store = talloc_asprintf_append_buffer(to_store, "%s %s %s\n", attr,
@@ -150,12 +150,12 @@ int cache_deserialize(rlm_cache_entry_t *c, char *in, ssize_t inlen)
                 */
                if (map->lhs->tmpl_da->vendor == 0) switch (map->lhs->tmpl_da->attr) {
                case PW_CACHE_CREATED:
-                       c->created = map->rhs->tmpl_data_value.datum.date;
+                       c->created = map->rhs->tmpl_value_box_datum.datum.date;
                        talloc_free(map);
                        goto next;
 
                case PW_CACHE_EXPIRES:
-                       c->expires = map->rhs->tmpl_data_value.datum.date;
+                       c->expires = map->rhs->tmpl_value_box_datum.datum.date;
                        talloc_free(map);
                        goto next;
 

diff --git a/src/modules/rlm_json/rlm_json.c b/src/modules/rlm_json/rlm_json.c
index d7173169767603848f07706d7030216efca494d9..97b578191db7044c71306259c7ecf0e05054de21 100644 (file)
--- a/src/modules/rlm_json/rlm_json.c
+++ b/src/modules/rlm_json/rlm_json.c
@@ -156,12 +156,12 @@ static int mod_map_proc_instantiate(void *proc_inst, UNUSED void *mod_inst,
                        break;
 
                case TMPL_TYPE_DATA:
-                       if (map->rhs->tmpl_data_type != PW_TYPE_STRING) {
+                       if (map->rhs->tmpl_value_box_type != PW_TYPE_STRING) {
                                cf_log_err_cp(cp, "Right side of map must be a string");
                                return -1;
                        }
-                       p = map->rhs->tmpl_data_value.datum.strvalue;
-                       slen = fr_jpath_parse(cache, &cache->jpath, p, map->rhs->tmpl_data_length);
+                       p = map->rhs->tmpl_value_box_datum.datum.strvalue;
+                       slen = fr_jpath_parse(cache, &cache->jpath, p, map->rhs->tmpl_value_box_length);
                        if (slen <= 0) goto error;
                        break;
 

diff --git a/src/modules/rlm_redis/redis.c b/src/modules/rlm_redis/redis.c
index b926a5a799b5a5ae18328bcd30dae6d6a2e4bf3e..00fcd94dd242f6551d1f2aebe8baf5fdca3d24ec 100644 (file)
--- a/src/modules/rlm_redis/redis.c
+++ b/src/modules/rlm_redis/redis.c
@@ -390,11 +390,11 @@ int fr_redis_tuple_from_map(TALLOC_CTX *pool, char const *out[], size_t out_len[
        key = talloc_bstrndup(pool, key_buf, key_len);
        if (!key) return -1;
 
-       switch (map->rhs->tmpl_data_type) {
+       switch (map->rhs->tmpl_value_box_type) {
        case PW_TYPE_STRING:
        case PW_TYPE_OCTETS:
-               out[2] = map->rhs->tmpl_data_value.datum.ptr;
-               out_len[2] = map->rhs->tmpl_data_length;
+               out[2] = map->rhs->tmpl_value_box_datum.datum.ptr;
+               out_len[2] = map->rhs->tmpl_value_box_length;
                break;
 
        /*
@@ -405,8 +405,8 @@ int fr_redis_tuple_from_map(TALLOC_CTX *pool, char const *out[], size_t out_len[
                char    value[256];
                size_t  len;
 
-               len = value_box_snprint(value, sizeof(value), map->rhs->tmpl_data_type, map->lhs->tmpl_da,
-                                       &map->rhs->tmpl_data_value, '\0');
+               len = value_box_snprint(value, sizeof(value), map->rhs->tmpl_value_box_type, map->lhs->tmpl_da,
+                                       &map->rhs->tmpl_value_box_datum, '\0');
                new = talloc_bstrndup(pool, value, len);
                if (!new) {
                        talloc_free(key);

diff --git a/src/modules/rlm_redis_ippool/rlm_redis_ippool.c b/src/modules/rlm_redis_ippool/rlm_redis_ippool.c
index 06c821ff4eb08099daaf3f4829251d0521786a47..fe84e042c6aefa0ce584d118b733c1896d466d2b 100644 (file)
--- a/src/modules/rlm_redis_ippool/rlm_redis_ippool.c
+++ b/src/modules/rlm_redis_ippool/rlm_redis_ippool.c
@@ -619,7 +619,7 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
        if (reply->elements > 1) {
                vp_tmpl_t ip_rhs = {
                        .type = TMPL_TYPE_DATA,
-                       .tmpl_data_type = PW_TYPE_STRING
+                       .tmpl_value_box_type = PW_TYPE_STRING
                };
                vp_map_t ip_map = {
                        .lhs = inst->allocated_address_attr,
@@ -642,26 +642,26 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                                memset(&tmp, 0, sizeof(tmp));
 
                                tmp.datum.integer = ntohl((uint32_t)reply->element[1]->integer);
-                               tmp.length = sizeof(ip_map.rhs->tmpl_data_value.datum.integer);
+                               tmp.length = sizeof(ip_map.rhs->tmpl_value_box_datum.datum.integer);
 
-                               if (value_box_cast(NULL, &ip_map.rhs->tmpl_data_value, PW_TYPE_IPV4_ADDR,
+                               if (value_box_cast(NULL, &ip_map.rhs->tmpl_value_box_datum, PW_TYPE_IPV4_ADDR,
                                                    NULL, PW_TYPE_INTEGER, NULL, &tmp)) {
                                        REDEBUG("Failed converting integer to IPv4 address: %s", fr_strerror());
                                        ret = IPPOOL_RCODE_FAIL;
                                        goto finish;
                                }
                        } else {
-                               ip_map.rhs->tmpl_data_value.datum.integer = ntohl((uint32_t)reply->element[1]->integer);
-                               ip_map.rhs->tmpl_data_length = sizeof(ip_map.rhs->tmpl_data_value.datum.integer);
-                               ip_map.rhs->tmpl_data_type = PW_TYPE_INTEGER;
+                               ip_map.rhs->tmpl_value_box_datum.datum.integer = ntohl((uint32_t)reply->element[1]->integer);
+                               ip_map.rhs->tmpl_value_box_length = sizeof(ip_map.rhs->tmpl_value_box_datum.datum.integer);
+                               ip_map.rhs->tmpl_value_box_type = PW_TYPE_INTEGER;
                        }
                }
                        goto do_ip_map;
 
                case REDIS_REPLY_STRING:
-                       ip_map.rhs->tmpl_data_value.datum.strvalue = reply->element[1]->str;
-                       ip_map.rhs->tmpl_data_length = reply->element[1]->len;
-                       ip_map.rhs->tmpl_data_type = PW_TYPE_STRING;
+                       ip_map.rhs->tmpl_value_box_datum.datum.strvalue = reply->element[1]->str;
+                       ip_map.rhs->tmpl_value_box_length = reply->element[1]->len;
+                       ip_map.rhs->tmpl_value_box_type = PW_TYPE_STRING;
 
                do_ip_map:
                        if (map_to_request(request, &ip_map, map_to_vp, NULL) < 0) {
@@ -691,7 +691,7 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                        vp_tmpl_t range_rhs = {
                                .name = "",
                                .type = TMPL_TYPE_DATA,
-                               .tmpl_data_type = PW_TYPE_STRING,
+                               .tmpl_value_box_type = PW_TYPE_STRING,
                                .quote = T_DOUBLE_QUOTED_STRING
                        };
                        vp_map_t range_map = {
@@ -700,9 +700,9 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                                .rhs = &range_rhs
                        };
 
-                       range_map.rhs->tmpl_data_value.datum.strvalue = reply->element[2]->str;
-                       range_map.rhs->tmpl_data_length = reply->element[2]->len;
-                       range_map.rhs->tmpl_data_type = PW_TYPE_STRING;
+                       range_map.rhs->tmpl_value_box_datum.datum.strvalue = reply->element[2]->str;
+                       range_map.rhs->tmpl_value_box_length = reply->element[2]->len;
+                       range_map.rhs->tmpl_value_box_type = PW_TYPE_STRING;
                        if (map_to_request(request, &range_map, map_to_vp, NULL) < 0) {
                                ret = IPPOOL_RCODE_FAIL;
                                goto finish;
@@ -728,7 +728,7 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                vp_tmpl_t expiry_rhs = {
                        .name = "",
                        .type = TMPL_TYPE_DATA,
-                       .tmpl_data_type = PW_TYPE_STRING,
+                       .tmpl_value_box_type = PW_TYPE_STRING,
                        .quote = T_DOUBLE_QUOTED_STRING
                };
                vp_map_t expiry_map = {
@@ -744,9 +744,9 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                        goto finish;
                }
 
-               expiry_map.rhs->tmpl_data_value.datum.integer = reply->element[3]->integer;
-               expiry_map.rhs->tmpl_data_length = sizeof(expiry_map.rhs->tmpl_data_value.datum.integer);
-               expiry_map.rhs->tmpl_data_type = PW_TYPE_INTEGER;
+               expiry_map.rhs->tmpl_value_box_datum.datum.integer = reply->element[3]->integer;
+               expiry_map.rhs->tmpl_value_box_length = sizeof(expiry_map.rhs->tmpl_value_box_datum.datum.integer);
+               expiry_map.rhs->tmpl_value_box_type = PW_TYPE_INTEGER;
                if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
                        ret = IPPOOL_RCODE_FAIL;
                        goto finish;
@@ -773,7 +773,7 @@ static ippool_rcode_t redis_ippool_update(rlm_redis_ippool_t const *inst, REQUES
        fr_redis_rcode_t        status;
        ippool_rcode_t          ret = IPPOOL_RCODE_SUCCESS;
 
-       vp_tmpl_t               range_rhs = { .name = "", .type = TMPL_TYPE_DATA, .tmpl_data_type = PW_TYPE_STRING, .quote = T_DOUBLE_QUOTED_STRING };
+       vp_tmpl_t               range_rhs = { .name = "", .type = TMPL_TYPE_DATA, .tmpl_value_box_type = PW_TYPE_STRING, .quote = T_DOUBLE_QUOTED_STRING };
        vp_map_t                range_map = { .lhs = inst->range_attr, .op = T_OP_SET, .rhs = &range_rhs };
 
        gettimeofday(&now, NULL);
@@ -851,9 +851,9 @@ static ippool_rcode_t redis_ippool_update(rlm_redis_ippool_t const *inst, REQUES
                 *      Add range ID to request
                 */
                case REDIS_REPLY_STRING:
-                       range_map.rhs->tmpl_data_value.datum.strvalue = reply->element[1]->str;
-                       range_map.rhs->tmpl_data_length = reply->element[1]->len;
-                       range_map.rhs->tmpl_data_type = PW_TYPE_STRING;
+                       range_map.rhs->tmpl_value_box_datum.datum.strvalue = reply->element[1]->str;
+                       range_map.rhs->tmpl_value_box_length = reply->element[1]->len;
+                       range_map.rhs->tmpl_value_box_type = PW_TYPE_STRING;
                        if (map_to_request(request, &range_map, map_to_vp, NULL) < 0) {
                                ret = IPPOOL_RCODE_FAIL;
                                goto finish;
@@ -878,7 +878,7 @@ static ippool_rcode_t redis_ippool_update(rlm_redis_ippool_t const *inst, REQUES
                vp_tmpl_t expiry_rhs = {
                        .name = "",
                        .type = TMPL_TYPE_DATA,
-                       .tmpl_data_type = PW_TYPE_STRING,
+                       .tmpl_value_box_type = PW_TYPE_STRING,
                        .quote = T_DOUBLE_QUOTED_STRING
                };
                vp_map_t expiry_map = {
@@ -887,9 +887,9 @@ static ippool_rcode_t redis_ippool_update(rlm_redis_ippool_t const *inst, REQUES
                        .rhs = &expiry_rhs
                };
 
-               expiry_map.rhs->tmpl_data_value.datum.integer = expires;
-               expiry_map.rhs->tmpl_data_length = sizeof(expiry_map.rhs->tmpl_data_value.datum.integer);
-               expiry_map.rhs->tmpl_data_type = PW_TYPE_INTEGER;
+               expiry_map.rhs->tmpl_value_box_datum.datum.integer = expires;
+               expiry_map.rhs->tmpl_value_box_length = sizeof(expiry_map.rhs->tmpl_value_box_datum.datum.integer);
+               expiry_map.rhs->tmpl_value_box_type = PW_TYPE_INTEGER;
                if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
                        ret = IPPOOL_RCODE_FAIL;
                        goto finish;
@@ -1145,9 +1145,9 @@ static rlm_rcode_t mod_action(rlm_redis_ippool_t const *inst, REQUEST *request,
                                        .rhs = &ip_rhs
                                };
 
-                               ip_rhs.tmpl_data_length = strlen(ip_str);
-                               ip_rhs.tmpl_data_value.datum.strvalue = ip_str;
-                               ip_rhs.tmpl_data_type = PW_TYPE_STRING;
+                               ip_rhs.tmpl_value_box_length = strlen(ip_str);
+                               ip_rhs.tmpl_value_box_datum.datum.strvalue = ip_str;
+                               ip_rhs.tmpl_value_box_type = PW_TYPE_STRING;
 
                                if (map_to_request(request, &ip_map, map_to_vp, NULL) < 0) return RLM_MODULE_FAIL;
                        }