Revert "s/tmpl_data_value/tmpl_data_box/g"

So i can apply the large patch set I was working on cleanly...

diff --git a/src/include/tmpl.h b/src/include/tmpl.h
index e73419ba601e8cd5b5938d4b1d6ac0e7458f3c9a..6ac75034c49731a9d280c9ea6881f45499697d45 100644 (file)
--- a/src/include/tmpl.h
+++ b/src/include/tmpl.h
@@ -249,7 +249,7 @@ 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_box          data.literal.data
+#define tmpl_data_value                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 7361209c139303fffb523476c3d18b5f32c78181..97ec2d7d0bad871836ae4140cd2085f1e9e4ee78 100644 (file)
--- a/src/main/evaluate.c
+++ b/src/main/evaluate.c
@@ -541,7 +541,7 @@ do {\
 
        case TMPL_TYPE_DATA:
                rhs_type = map->rhs->tmpl_data_type;
-               rhs = &map->rhs->tmpl_data_box;
+               rhs = &map->rhs->tmpl_data_value;
 
                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_box);
+                                             map->lhs->tmpl_data_type, NULL, &map->lhs->tmpl_data_value);
                break;
 
        case TMPL_TYPE_UNPARSED:

diff --git a/src/main/map.c b/src/main/map.c
index 7b6e67b4f04558ca599acb9d1f556bc809bf49e5..731ce3d1f4635fffcc88b0cbb966a193ab30992c 100644 (file)
--- a/src/main/map.c
+++ b/src/main/map.c
@@ -135,14 +135,14 @@ bool map_cast_from_hex(vp_map_t *map, FR_TOKEN rhs_type, char const *rhs)
        map->rhs->tmpl_data_length = vp->vp_length;
        if (vp->da->flags.is_pointer) {
                if (vp->da->type == PW_TYPE_STRING) {
-                       map->rhs->tmpl_data_box.ptr = talloc_bstrndup(map->rhs, vp->data.ptr, vp->vp_length);
+                       map->rhs->tmpl_data_value.ptr = talloc_bstrndup(map->rhs, vp->data.ptr, vp->vp_length);
                        map->rhs->quote = T_SINGLE_QUOTED_STRING;
                } else {
-                       map->rhs->tmpl_data_box.ptr = talloc_memdup(map->rhs, vp->data.ptr, vp->vp_length);
+                       map->rhs->tmpl_data_value.ptr = talloc_memdup(map->rhs, vp->data.ptr, vp->vp_length);
                        map->rhs->quote = T_BARE_WORD;
                }
        } else {
-               memcpy(&map->rhs->tmpl_data_box, &vp->data.datum, sizeof(map->rhs->tmpl_data_box));
+               memcpy(&map->rhs->tmpl_data_value, &vp->data.datum, sizeof(map->rhs->tmpl_data_value));
                map->rhs->quote = T_BARE_WORD;
        }
        map->rhs->name = fr_pair_value_asprint(map->rhs, vp, fr_token_quote[map->rhs->quote]);
@@ -954,13 +954,13 @@ int map_to_vp(TALLOC_CTX *ctx, VALUE_PAIR **out, REQUEST *request, vp_map_t cons
                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_box) < 0) {
+                       if (value_box_copy(new, &new->data, new->da->type, &map->rhs->tmpl_data_value) < 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_box) < 0) {
+                                           NULL, &map->rhs->tmpl_data_value) < 0) {
                                REDEBUG("Implicit cast failed: %s", fr_strerror());
                                rcode = -1;
                                goto error;

diff --git a/src/main/tmpl.c b/src/main/tmpl.c
index b38c9445d3abc21a5f8fe6e5ffcbecb829f2b191..44cea6bf7f1379abf4c9ccca7c39feaaad681e6a 100644 (file)
--- a/src/main/tmpl.c
+++ b/src/main/tmpl.c
@@ -618,13 +618,13 @@ 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_box, type, data) < 0) {
+               if (value_box_steal(vpt, &vpt->tmpl_data_value, type, data) < 0) {
                        talloc_free(vpt);
                        return -1;
                }
                vpt->tmpl_data_type = type;
        } else {
-               if (value_box_copy(vpt, &vpt->tmpl_data_box, type, data) < 0) {
+               if (value_box_copy(vpt, &vpt->tmpl_data_value, type, data) < 0) {
                        talloc_free(vpt);
                        return -1;
                }
@@ -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_box.ptr = talloc_array(vpt, uint8_t, binlen);
+                       vpt->tmpl_data_value.ptr = talloc_array(vpt, uint8_t, binlen);
                        vpt->tmpl_data_length = binlen;
                        vpt->tmpl_data_type = PW_TYPE_OCTETS;
 
-                       len = fr_hex2bin(vpt->tmpl_data_box.ptr, binlen, in + 2, inlen - 2);
+                       len = fr_hex2bin(vpt->tmpl_data_value.ptr, binlen, in + 2, inlen - 2);
                        if (len != binlen) {
                                fr_strerror_printf("Hex string contains none hex char");
                                talloc_free(vpt);
@@ -1237,22 +1237,34 @@ int tmpl_cast_in_place(vp_tmpl_t *vpt, PW_TYPE type, fr_dict_attr_t const *enumv
                /*
                 *      Why do we pass a pointer to the tmpl type? Goddamn WiMAX.
                 */
-               if (value_box_from_str(vpt, &vpt->tmpl_data_box, &vpt->tmpl_data_type,
+               if (value_box_from_str(vpt, &vpt->tmpl_data_value, &vpt->tmpl_data_type,
                                        enumv, vpt->name, vpt->len, '\0') < 0) return -1;
                vpt->type = TMPL_TYPE_DATA;
                break;
 
        case TMPL_TYPE_DATA:
        {
-               value_box_t tmp;
+               value_box_t new;
 
                if (type == vpt->tmpl_data_type) return 0;      /* noop */
 
-               if (value_box_cast(vpt, &tmp, type, enumv, vpt->tmpl_data_type,
-                                   NULL, &vpt->tmpl_data_box) < 0) return -1;
+               if (value_box_cast(vpt, &new, type, enumv, vpt->tmpl_data_type,
+                                   NULL, &vpt->tmpl_data_value) < 0) return -1;
 
-               if (value_box_copy(vpt, &vpt->tmpl_data_box, type, &tmp) < 0) return -1;
+               /*
+                *      Free old value buffers
+                */
+               switch (vpt->tmpl_data_type) {
+               case PW_TYPE_STRING:
+               case PW_TYPE_OCTETS:
+                       talloc_free(vpt->tmpl_data_value.ptr);
+                       break;
+
+               default:
+                       break;
+               }
 
+               memcpy(&vpt->tmpl_data_value, &new, sizeof(vpt->tmpl_data_value));
                vpt->tmpl_data_type = type;
        }
                break;
@@ -1322,7 +1334,7 @@ int tmpl_cast_to_vp(VALUE_PAIR **out, REQUEST *request,
                VERIFY_VP(vp);
                rad_assert(vp->da->type == vpt->tmpl_data_type);
 
-               value_box_copy(vp, &vp->data, vpt->tmpl_data_type, &vpt->tmpl_data_box);
+               value_box_copy(vp, &vp->data, vpt->tmpl_data_type, &vpt->tmpl_data_value);
                *out = vp;
                return 0;
        }
@@ -1595,7 +1607,7 @@ ssize_t _tmpl_to_type(void *out,
                ret = tmpl_find_vp(&vp, request, vpt);
                if (ret < 0) return -2;
 
-               to_cast = &vpt->tmpl_data_box;
+               to_cast = &vpt->tmpl_data_value;
                src_type = vpt->tmpl_data_type;
        }
                break;
@@ -1907,7 +1919,7 @@ ssize_t _tmpl_to_atype(TALLOC_CTX *ctx, void *out,
        {
                RDEBUG4("EXPAND TMPL DATA");
 
-               to_cast = &vpt->tmpl_data_box;
+               to_cast = &vpt->tmpl_data_value;
                src_type = vpt->tmpl_data_type;
 
                switch (src_type) {
@@ -2123,7 +2135,7 @@ do_literal:
                break;
 
        case TMPL_TYPE_DATA:
-               return value_box_snprint(out, outlen, vpt->tmpl_data_type, values, &vpt->tmpl_data_box,
+               return value_box_snprint(out, outlen, vpt->tmpl_data_type, values, &vpt->tmpl_data_value,
                                         fr_token_quote[vpt->quote]);
 
        default:

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 02061e5fd5f267d85677b0d1d860a7e4ee23e667..fa20b1336141b7e0b624982bcee4427044eaf6ba 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_box.date;
+               c->created = head->rhs->tmpl_data_value.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_box.date;
+               c->expires = head->rhs->tmpl_data_value.date;
 
                map = head;
                head = head->next;
@@ -289,8 +289,8 @@ static cache_status_t cache_entry_insert(UNUSED rlm_cache_config_t const *config
         */
        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_box.date);
-       created_value.tmpl_data_box.date = c->created;
+       created_value.tmpl_data_length = sizeof(created_value.tmpl_data_value.date);
+       created_value.tmpl_data_value.date = c->created;
 
        /*
         *      Encode the entry expiry time
@@ -300,8 +300,8 @@ static cache_status_t cache_entry_insert(UNUSED rlm_cache_config_t const *config
         */
        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_box.date);
-       expires_value.tmpl_data_box.date = c->expires;
+       expires_value.tmpl_data_length = sizeof(expires_value.tmpl_data_value.date);
+       expires_value.tmpl_data_value.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 badaa5b13354133183e68cccdea5269139e93430..ff982083e381ef96d923ddbe3931a584aafe24af 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_box,
+                               if (value_box_copy(c_map->rhs, &c_map->rhs->tmpl_data_value,
                                                    vp->da->type, &vp->data) < 0) {
                                        REDEBUG("Failed copying attribute value");
                                error:
@@ -830,7 +830,7 @@ static ssize_t cache_xlat(UNUSED TALLOC_CTX *ctx, char **out, UNUSED size_t free
                    (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_box, '\0');
+                                         &map->rhs->tmpl_data_value, '\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 0f6d623dddafc18b128135fae6d03f94213b7ba1..8aae02ab60820fb1f8435a61d22aefea603b0dfb 100644 (file)
--- a/src/modules/rlm_cache/serialize.c
+++ b/src/modules/rlm_cache/serialize.c
@@ -75,7 +75,7 @@ int cache_serialize(TALLOC_CTX *ctx, char **out, rlm_cache_entry_t const *c)
                }
 
                value = value_box_asprint(value_pool, map->rhs->tmpl_data_type,
-                                          map->lhs->tmpl_da, &map->rhs->tmpl_data_box, '\'');
+                                          map->lhs->tmpl_da, &map->rhs->tmpl_data_value, '\'');
                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_box.date;
+                       c->created = map->rhs->tmpl_data_value.date;
                        talloc_free(map);
                        goto next;
 
                case PW_CACHE_EXPIRES:
-                       c->expires = map->rhs->tmpl_data_box.date;
+                       c->expires = map->rhs->tmpl_data_value.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 a9b3db5ef120d04274e76351767f59c18b81114f..1b1f8fd5eefed5a682f98761976a3405cd95e6e3 100644 (file)
--- a/src/modules/rlm_json/rlm_json.c
+++ b/src/modules/rlm_json/rlm_json.c
@@ -160,7 +160,7 @@ static int mod_map_proc_instantiate(void *proc_inst, UNUSED void *mod_inst,
                                cf_log_err_cp(cp, "Right side of map must be a string");
                                return -1;
                        }
-                       p = map->rhs->tmpl_data_box.strvalue;
+                       p = map->rhs->tmpl_data_value.strvalue;
                        slen = fr_jpath_parse(cache, &cache->jpath, p, map->rhs->tmpl_data_length);
                        if (slen <= 0) goto error;
                        break;

diff --git a/src/modules/rlm_redis/redis.c b/src/modules/rlm_redis/redis.c
index bb160fd0e941949b52cc0eb058187226f6daec3a..9d520b7cc1daefc3123639e6c0744bb602f322db 100644 (file)
--- a/src/modules/rlm_redis/redis.c
+++ b/src/modules/rlm_redis/redis.c
@@ -393,7 +393,7 @@ int fr_redis_tuple_from_map(TALLOC_CTX *pool, char const *out[], size_t out_len[
        switch (map->rhs->tmpl_data_type) {
        case PW_TYPE_STRING:
        case PW_TYPE_OCTETS:
-               out[2] = map->rhs->tmpl_data_box.ptr;
+               out[2] = map->rhs->tmpl_data_value.ptr;
                out_len[2] = map->rhs->tmpl_data_length;
                break;
 
@@ -406,7 +406,7 @@ int fr_redis_tuple_from_map(TALLOC_CTX *pool, char const *out[], size_t out_len[
                size_t  len;
 
                len = value_box_snprint(value, sizeof(value), map->rhs->tmpl_data_type, map->lhs->tmpl_da,
-                                       &map->rhs->tmpl_data_box, '\0');
+                                       &map->rhs->tmpl_data_value, '\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 5fb4472757d6d4fd18fe4df49f32c0b88e984516..86ef62f65caa356a2058f30c026b43241949d441 100644 (file)
--- a/src/modules/rlm_redis_ippool/rlm_redis_ippool.c
+++ b/src/modules/rlm_redis_ippool/rlm_redis_ippool.c
@@ -642,24 +642,24 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                                memset(&tmp, 0, sizeof(tmp));
 
                                tmp.integer = ntohl((uint32_t)reply->element[1]->integer);
-                               tmp.length = sizeof(ip_map.rhs->tmpl_data_box.integer);
+                               tmp.length = sizeof(ip_map.rhs->tmpl_data_value.integer);
 
-                               if (value_box_cast(NULL, &ip_map.rhs->tmpl_data_box, PW_TYPE_IPV4_ADDR,
+                               if (value_box_cast(NULL, &ip_map.rhs->tmpl_data_value, 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_box.integer = ntohl((uint32_t)reply->element[1]->integer);
-                               ip_map.rhs->tmpl_data_length = sizeof(ip_map.rhs->tmpl_data_box.integer);
+                               ip_map.rhs->tmpl_data_value.integer = ntohl((uint32_t)reply->element[1]->integer);
+                               ip_map.rhs->tmpl_data_length = sizeof(ip_map.rhs->tmpl_data_value.integer);
                                ip_map.rhs->tmpl_data_type = PW_TYPE_INTEGER;
                        }
                }
                        goto do_ip_map;
 
                case REDIS_REPLY_STRING:
-                       ip_map.rhs->tmpl_data_box.strvalue = reply->element[1]->str;
+                       ip_map.rhs->tmpl_data_value.strvalue = reply->element[1]->str;
                        ip_map.rhs->tmpl_data_length = reply->element[1]->len;
                        ip_map.rhs->tmpl_data_type = PW_TYPE_STRING;
 
@@ -700,7 +700,7 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                                .rhs = &range_rhs
                        };
 
-                       range_map.rhs->tmpl_data_box.strvalue = reply->element[2]->str;
+                       range_map.rhs->tmpl_data_value.strvalue = reply->element[2]->str;
                        range_map.rhs->tmpl_data_length = reply->element[2]->len;
                        range_map.rhs->tmpl_data_type = PW_TYPE_STRING;
                        if (map_to_request(request, &range_map, map_to_vp, NULL) < 0) {
@@ -744,8 +744,8 @@ static ippool_rcode_t redis_ippool_allocate(rlm_redis_ippool_t const *inst, REQU
                        goto finish;
                }
 
-               expiry_map.rhs->tmpl_data_box.integer = reply->element[3]->integer;
-               expiry_map.rhs->tmpl_data_length = sizeof(expiry_map.rhs->tmpl_data_box.integer);
+               expiry_map.rhs->tmpl_data_value.integer = reply->element[3]->integer;
+               expiry_map.rhs->tmpl_data_length = sizeof(expiry_map.rhs->tmpl_data_value.integer);
                expiry_map.rhs->tmpl_data_type = PW_TYPE_INTEGER;
                if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
                        ret = IPPOOL_RCODE_FAIL;
@@ -851,7 +851,7 @@ 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_box.strvalue = reply->element[1]->str;
+                       range_map.rhs->tmpl_data_value.strvalue = reply->element[1]->str;
                        range_map.rhs->tmpl_data_length = reply->element[1]->len;
                        range_map.rhs->tmpl_data_type = PW_TYPE_STRING;
                        if (map_to_request(request, &range_map, map_to_vp, NULL) < 0) {
@@ -887,8 +887,8 @@ static ippool_rcode_t redis_ippool_update(rlm_redis_ippool_t const *inst, REQUES
                        .rhs = &expiry_rhs
                };
 
-               expiry_map.rhs->tmpl_data_box.integer = expires;
-               expiry_map.rhs->tmpl_data_length = sizeof(expiry_map.rhs->tmpl_data_box.integer);
+               expiry_map.rhs->tmpl_data_value.integer = expires;
+               expiry_map.rhs->tmpl_data_length = sizeof(expiry_map.rhs->tmpl_data_value.integer);
                expiry_map.rhs->tmpl_data_type = PW_TYPE_INTEGER;
                if (map_to_request(request, &expiry_map, map_to_vp, NULL) < 0) {
                        ret = IPPOOL_RCODE_FAIL;
@@ -1146,7 +1146,7 @@ static rlm_rcode_t mod_action(rlm_redis_ippool_t const *inst, REQUEST *request,
                                };
 
                                ip_rhs.tmpl_data_length = strlen(ip_str);
-                               ip_rhs.tmpl_data_box.strvalue = ip_str;
+                               ip_rhs.tmpl_data_value.strvalue = ip_str;
                                ip_rhs.tmpl_data_type = PW_TYPE_STRING;
 
                                if (map_to_request(request, &ip_map, map_to_vp, NULL) < 0) return RLM_MODULE_FAIL;