encode.c

Go to the documentation of this file.

/*
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2.1 of the License, or (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/**
 * $Id: a99b1b9d8b86b4f27b6f371f0cfee7cd52eaea91 $
 *
 * @file src/lib/util/encode.c
 * @brief Generic functions for decoding protocols.
 *
 * @copyright 2022 Network RADIUS SAS (legal@networkradius.com)
 */
#include <freeradius-devel/io/test_point.h>
#include <freeradius-devel/util/proto.h>
#include <freeradius-devel/util/encode.h>
 
/** Encode an array of values from the network
 *
 * @param[out] dbuff            buffer to write the TLV to.
 * @param[in] da_stack          Describing nesting of options.
 * @param[in] depth             in the da_stack.
 * @param[in,out] cursor        Current attribute we're encoding.
 * @param[in] encode_ctx        Containing DHCPv4 dictionary.
 * @param[in] encode_value      Function to perform encoding of a single value.
 * @return
 *      - >0 length of data encoded.
 *      - <= 0 on error.
 */
ssize_t fr_pair_array_to_network(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, int depth,
                                 fr_dcursor_t *cursor, void *encode_ctx, fr_encode_dbuff_t encode_value)
{
        ssize_t                 slen;
        fr_dbuff_t              work_dbuff = FR_DBUFF(dbuff);
        fr_pair_t               *vp;
        fr_dict_attr_t const    *da = da_stack->da[depth];
 
        FR_PROTO_STACK_PRINT(da_stack, depth);
 
        if (!fr_cond_assert_msg(da->flags.array,
                                "%s: Internal sanity check failed, attribute \"%s\" does not have array bit set",
                                __FUNCTION__, da->name)) return PAIR_ENCODE_FATAL_ERROR;
 
        while (fr_dbuff_extend(&work_dbuff)) {
                fr_dbuff_t      element_dbuff = FR_DBUFF(&work_dbuff);
 
                /*
                 *      Encoding "no data" in an array doesn't make sense.
                 */
                slen = encode_value(&element_dbuff, da_stack, depth, cursor, encode_ctx);
                if (slen <= 0) return slen;
 
                fr_dbuff_set(&work_dbuff, &element_dbuff);
 
                vp = fr_dcursor_current(cursor);
                if (!vp || (vp->da != da)) break;               /* Stop if we have an attribute of a different type */
        }
 
        return fr_dbuff_set(dbuff, &work_dbuff);
}
 
ssize_t fr_pair_cursor_to_network(fr_dbuff_t *dbuff,
                                  fr_da_stack_t *da_stack, unsigned int depth,
                                  fr_dcursor_t *cursor, void *encode_ctx, fr_encode_dbuff_t encode_pair)
{
        fr_dbuff_t              work_dbuff = FR_DBUFF(dbuff);
        fr_pair_t const         *vp;
        ssize_t                 len;
 
        while (true) {
                FR_PROTO_STACK_PRINT(da_stack, depth);
 
                vp = fr_dcursor_current(cursor);
                fr_assert(!vp->da->flags.internal);
 
                len = encode_pair(&work_dbuff, da_stack, depth + 1, cursor, encode_ctx);
                if (len < 0) return len;
 
                /*
                 *      If nothing updated the attribute, stop
                 */
                if (!fr_dcursor_current(cursor) || (vp == fr_dcursor_current(cursor))) break;
 
                vp = fr_dcursor_current(cursor);
                if (!vp) break;
 
                fr_proto_da_stack_build(da_stack, vp->da);
        }
 
        FR_PROTO_HEX_DUMP(fr_dbuff_start(&work_dbuff), fr_dbuff_used(&work_dbuff), "Done cursor");
 
        return fr_dbuff_set(dbuff, &work_dbuff);
}
 
/** Encode a foreign reference to the network
 *
 * @param[out] dbuff            buffer to write the TLV to.
 * @param[in] da_stack          Describing nesting of options.
 * @param[in] depth             in the da_stack.
 * @param[in,out] cursor        Current attribute we're encoding.
 * @return
 *      - >0 length of data encoded.
 *      - 0 if we ran out of space.
 *      - < 0 on error.
 */
ssize_t fr_pair_ref_to_network(fr_dbuff_t *dbuff, fr_da_stack_t *da_stack, unsigned int depth,
                               fr_dcursor_t *cursor)
{
        ssize_t                 slen;
        fr_dict_attr_t const    *da;
        fr_pair_t const         *vp = fr_dcursor_current(cursor);
        fr_dbuff_t              work_dbuff = FR_DBUFF(dbuff);
 
        fr_dict_attr_t const *ref;
        fr_dict_protocol_t const *proto;
 
        FR_PROTO_STACK_PRINT(da_stack, depth);
 
        da = da_stack->da[depth];
        fr_assert(da->type == FR_TYPE_GROUP);
 
        ref = fr_dict_attr_ref(da);
        if (!ref) {
                fr_strerror_printf("Invalid attribute reference for %s", da->name);
                return 0;
        }
 
        proto = fr_dict_protocol(ref->dict);
        fr_assert(proto != NULL);
 
        if (!proto->encode) {
                fr_strerror_printf("Attribute %s -> %s does not have an encoder", da->name, ref->name);
                return 0;
        }
 
        /*
         *      The foreign functions don't take a cursor, so we have to update the cursor ourselves.
         */
        slen = proto->encode(&work_dbuff, &vp->vp_group);
        if (slen < 0) return slen;
 
        FR_PROTO_HEX_DUMP(fr_dbuff_start(&work_dbuff), fr_dbuff_used(&work_dbuff), "group ref");
 
        vp = fr_dcursor_next(cursor);
        fr_proto_da_stack_build(da_stack, vp ? vp->da : NULL);
 
        return fr_dbuff_set(dbuff, &work_dbuff);
}
 
/** Generic encode value.
 *
 */
ssize_t fr_pair_encode_value(fr_dbuff_t *dbuff, UNUSED fr_da_stack_t *da_stack, UNUSED unsigned int depth,
                              fr_dcursor_t *cursor, UNUSED void *encode_ctx)
{
        fr_pair_t const         *vp = fr_dcursor_current(cursor);
        fr_dbuff_t              work_dbuff = FR_DBUFF(dbuff);
 
        if (!fr_type_is_leaf(vp->vp_type)) {
                FR_PROTO_TRACE("Cannot use generic encoder for data type %s", fr_type_to_str(vp->vp_type));
                fr_strerror_printf("Cannot encode data type %s", fr_type_to_str(vp->vp_type));
                return PAIR_ENCODE_FATAL_ERROR;
        }
 
        if (fr_value_box_to_network(&work_dbuff, &vp->data) <= 0) return PAIR_ENCODE_FATAL_ERROR;
 
        (void) fr_dcursor_next(cursor);
 
        return fr_dbuff_set(dbuff, &work_dbuff);        
}