ext.c

Go to the documentation of this file.

/*
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/** 'compositing' using talloced structures
 *
 * @file src/lib/util/ext.c
 *
 * @copyright 2020 The FreeRADIUS server project
 * @copyright 2020 Arran Cudbard-Bell <a.cudbardb@freeradius.org>
 */
RCSID("$Id: 4cc429de6c78ee53b86cb96e349e6f4be0031d04 $")
 
#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/ext.h>
#include <freeradius-devel/util/misc.h>
#include <freeradius-devel/util/syserror.h>
 
/** Add a variable length extension to a talloc chunk
 *
 * This is used to build a structure from a primary struct type and one or more
 * extension structures.  The memory for the composed structure is contiguous which
 * has performance benefits, and means we don't have the overhead of talloc headers
 * for each of the extensions.
 *
 * @note When a new extension is allocated its memory will be zeroed.
 *
 * @note It is highly recommended to allocate composed structures within a talloc_pool
 * to avoid the overhead of malloc+memcpy.
 *
 * @param[in] def               Extension definitions.
 * @param[in,out] chunk_p       The chunk to add an extension for.
 *                              Under certain circumstances the value of *chunk_p will
 *                              be changed to point to a new memory block.
 *                              All cached copies of the previous pointer should be
 *                              updated.
 * @param[in] ext               to alloc.
 * @param[in] ext_len           The length of the extension.
 * @return
 *      - NULL if we failed allocating an extension.
 *      - A pointer to the extension we allocated.
 */
void *fr_ext_alloc_size(fr_ext_t const *def, void **chunk_p, int ext, size_t ext_len)
{
        size_t                  aligned_len = ROUND_UP_POW2(ext_len, FR_EXT_ALIGNMENT);
        size_t                  chunk_len;
        size_t                  hdr_len = 0;
 
        size_t                  offset;
 
        fr_ext_info_t const     *info = &def->info[ext];
        void                    *n_chunk, *chunk = *chunk_p;
        uint8_t                 *ext_offsets;
        uint8_t                 *ext_ptr;
        char const              *type;
 
        fr_assert(chunk != NULL);
        fr_assert(talloc_parent(chunk) != NULL);
 
        ext_offsets = fr_ext_offsets(def, *chunk_p);
        if (ext_offsets[ext]) return fr_ext_ptr(*chunk_p, ext_offsets[ext], info->has_hdr);
 
        if (info->has_hdr) hdr_len = sizeof(fr_ext_hdr_t);      /* Add space for a length prefix */
 
        /*
         *      Packing the offsets into a uint8_t array
         *      means the offset address of the final
         *      extension must be less than or equal to
         *      UINT8_MAX * FR_EXT_ALIGNMENT.
         */
        chunk_len = talloc_get_size(chunk);
        offset = ROUND_UP_DIV(chunk_len, FR_EXT_ALIGNMENT);
        if (unlikely(offset > UINT8_MAX)) {
                fr_strerror_const("Insufficient space remaining for extensions");
                return NULL;
        }
 
        /*
         *      talloc_realloc_size unhelpfully forgets
         *      the name of the chunk, so we need to
         *      record it and set it back again.
         */
        type = talloc_get_name(chunk);
        n_chunk = talloc_realloc_size(NULL, chunk, (offset * FR_EXT_ALIGNMENT) + hdr_len + aligned_len);
        if (!n_chunk) {
                fr_strerror_printf("Failed reallocing %s (%s).  Tried to realloc %zu bytes -> %zu bytes",
                                   type, fr_syserror(errno), chunk_len, chunk_len + aligned_len);
                return NULL;
        }
        talloc_set_name_const(n_chunk, type);
 
        ext_offsets = fr_ext_offsets(def, n_chunk);
        ext_offsets[ext] = (uint8_t)offset;
 
        ext_ptr = ((uint8_t *)n_chunk) + chunk_len;
        memset(ext_ptr, 0, hdr_len + aligned_len);
 
        *chunk_p = n_chunk;
 
        if (info->has_hdr) {
                fr_ext_hdr_t *ext_hdr = (fr_ext_hdr_t *)ext_ptr;
 
                ext_hdr->len = ext_len;         /* Record the real size */
                return &ext_hdr->data;          /* Pointer to the data portion */
        }
 
        return ext_ptr;
}
 
/** Return the length of an extension
 *
 * @param[in] def               Extension definitions.
 * @param[in] chunk             to return extension length for.
 * @param[in] ext               to return length for.
 * @return
 *      - 0 if no extension exists or is of zero length.
 *      - >0 the length of the extension.
 */
size_t fr_ext_len(fr_ext_t const *def, TALLOC_CTX const *chunk, int ext)
{
        uint8_t                 offset;
        fr_ext_info_t const     *info;
        fr_ext_hdr_t            *ext_hdr;
        uint8_t                 *ext_offsets;
 
        ext_offsets = fr_ext_offsets(def, chunk);
        offset = ext_offsets[ext];
        if (!offset) return 0;
 
        info = &def->info[ext];
        if (!info->has_hdr) return info->min;           /* Fixed size */
 
        ext_hdr = fr_ext_ptr(chunk, offset, false);     /* false as we're getting the header */
        return ext_hdr->len;
}
 
/** Copy extension data from one attribute to another
 *
 * @param[in] def               Extension definitions.
 * @param[in,out] chunk_dst     to copy extension to.
 *                              Under certain circumstances the value of *chunk_dst will
 *                              be changed to point to a new memory block.
 *                              All cached copies of the previous pointer should be
 *                              updated.
 * @param[in] chunk_src         to copy extension from.
 * @param[in] ext               to copy.
 * @return
 *      - NULL if we failed to allocate an extension structure.
 *      - A pointer to the offset of the extension in da_out.
 */
void *fr_ext_copy(fr_ext_t const *def, TALLOC_CTX **chunk_dst, TALLOC_CTX const *chunk_src, int ext)
{
        int                     i;
        uint8_t                 *ext_src_offsets = fr_ext_offsets(def, chunk_src);
        uint8_t                 *ext_dst_offsets = fr_ext_offsets(def, *chunk_dst);
        void                    *ext_src_ptr, *ext_dst_ptr;
        fr_ext_info_t const     *info = &def->info[ext];
 
        if (!info->can_copy) {
                fr_strerror_const("Extension cannot be copied");
                return NULL;
        }
 
        if (!ext_src_offsets[ext]) return NULL;
 
        ext_src_ptr = fr_ext_ptr(chunk_src, ext_src_offsets[ext], info->has_hdr);
 
        /*
         *      Only alloc if the extension doesn't
         *      already exist.
         */
        if (!ext_dst_offsets[ext]) {
                if (info->alloc) {
                        ext_dst_ptr = info->alloc(def, chunk_dst, ext,
                                                  ext_src_ptr,
                                                  fr_ext_len(def, chunk_src, ext));
                /*
                 *      If there's no special alloc function
                 *      we just allocate a chunk of the same
                 *      size.
                 */
                } else {
                        ext_dst_ptr = fr_ext_alloc_size(def, chunk_dst, ext,
                                                        fr_ext_len(def, chunk_src, ext));
                }
        } else {
                ext_dst_ptr = fr_ext_ptr(*chunk_dst, ext_dst_offsets[ext], info->has_hdr);
        }
 
        if (info->copy) {
                info->copy(ext,
                           *chunk_dst,
                           ext_dst_ptr, fr_ext_len(def, *chunk_dst, ext),
                           chunk_src,
                           ext_src_ptr, fr_ext_len(def, chunk_src, ext));
        /*
         *      If there's no special copy function
         *      we just copy the data from the old
         *      extension to the new one.
         */
        } else {
                memcpy(ext_dst_ptr, ext_src_ptr, fr_ext_len(def, *chunk_dst, ext));
        }
 
        /*
         *      Call any fixup functions
         */
        ext_dst_offsets = fr_ext_offsets(def, *chunk_dst);
        for (i = 0; i < def->max; i++) {
                if (i == ext) continue;
 
                if (!ext_dst_offsets[i]) continue;
 
                if (info->fixup &&
                    info->fixup(i, *chunk_dst,
                                fr_ext_ptr(*chunk_dst, ext_dst_offsets[i], info->has_hdr),
                                fr_ext_len(def, *chunk_dst, i)) < 0) return NULL;
        }
 
        return ext_dst_ptr;
}
 
/** Copy all the extensions from one attribute to another
 *
 * @param[in] def               Extension definitions.
 * @param[in,out] chunk_dst     to copy extensions to.
 *                              Under certain circumstances the value of *chunk_dst will
 *                              be changed to point to a new memory block.
 *                              All cached copies of the previous pointer should be
 *                              updated.
 * @param[in] chunk_src         to copy extensions from.
 * @return
 *      - 0 on success.
 *      - -1 if a copy operation failed.
 */
int fr_ext_copy_all(fr_ext_t const *def, TALLOC_CTX **chunk_dst, TALLOC_CTX const *chunk_src)
{
        int     i;
        uint8_t *ext_src_offsets = fr_ext_offsets(def, chunk_src);      /* old chunk array */
        uint8_t *ext_dst_offsets = fr_ext_offsets(def, *chunk_dst);     /* new chunk array */
        bool    ext_new_alloc[def->max];
 
        /*
         *      Do the operation in two phases.
         *
         *      Phase 1 allocates space for all the extensions.
         */
        for (i = 0; i < def->max; i++) {
                fr_ext_info_t const *info = &def->info[i];
 
                if (!ext_src_offsets[i] || !info->can_copy) {
                no_copy:
                        ext_new_alloc[i] = false;
                        continue;
                }
 
                if (info->alloc) {
                        if (!info->alloc(def, chunk_dst, i,
                                         fr_ext_ptr(chunk_src, ext_src_offsets[i], info->has_hdr),
                                         fr_ext_len(def, chunk_src, i))) goto no_copy;
                /*
                 *      If there's no special alloc function
                 *      we just allocate a chunk of the same
                 *      size.
                 */
                } else {
                        fr_ext_alloc_size(def, chunk_dst, i, fr_ext_len(def, chunk_src, i));
                }
                ext_new_alloc[i] = true;
                ext_dst_offsets = fr_ext_offsets(def, *chunk_dst);      /* Grab new offsets, chunk might have changed */
        }
 
        /*
         *      Phase 2 populates the extension memory.
         *
         *      We do this in two phases to avoid invalidating
         *      any pointers from extensions back to the extended
         *      talloc chunk.
         */
        for (i = 0; i < def->max; i++) {
                fr_ext_info_t const *info = &def->info[i];
 
                if (!ext_src_offsets[i] || !ext_dst_offsets[i]) continue;
 
                if (!ext_new_alloc[i]) {
                        if (info->fixup &&
                            info->fixup(i, *chunk_dst,
                                        fr_ext_ptr(*chunk_dst, ext_dst_offsets[i], info->has_hdr),
                                        fr_ext_len(def, *chunk_dst, i)) < 0) return -1;
                        continue;
                }
                if (!info->can_copy) continue;
 
                if (info->copy) {
                        if (info->copy(i,
                                       *chunk_dst,
                                       fr_ext_ptr(*chunk_dst, ext_dst_offsets[i], info->has_hdr),
                                       fr_ext_len(def, *chunk_dst, i),
                                       chunk_src,
                                       fr_ext_ptr(chunk_src, ext_src_offsets[i], info->has_hdr),
                                       fr_ext_len(def, chunk_src, i)) < 0) return -1;
                /*
                 *      If there's no special copy function
                 *      we just copy the data from the old
                 *      extension to the new one.
                 */
                } else {
                        memcpy(fr_ext_ptr(*chunk_dst, ext_dst_offsets[i], info->has_hdr),
                               fr_ext_ptr(chunk_src, ext_src_offsets[i], info->has_hdr),
                               fr_ext_len(def, *chunk_dst, i));
                }
        }
 
        return 0;
}
 
/** Print out all extensions and hexdump their contents
 *
 * This function is intended to be called from interactive debugging
 * sessions only.  It does not use the normal logging infrastructure.
 *
 * @param[in] def               Extension definitions.
 * @param[in] name              the identifier of the structure
 *                              being debugged i.e da->name.
 * @param[in] chunk             to debug.
 */
void fr_ext_debug(fr_ext_t const *def, char const *name, void const *chunk)
{
        int i;
 
        FR_FAULT_LOG("%s ext total_len=%zu", name, talloc_get_size(chunk));
        for (i = 0; i < (int)def->max; i++) {
                uint8_t *ext_offsets = fr_ext_offsets(def, chunk);
 
                if (ext_offsets[i]) {
                        void            *ext = fr_ext_ptr(chunk, ext_offsets[i], def->info[i].has_hdr);
                        size_t          ext_len = fr_ext_len(def, chunk, i);
                        char const      *ext_name = fr_table_ordered_str_by_num(def->name_table,
                                                                                *def->name_table_len,
                                                                                i, "<INVALID>");
 
                        if (ext_len > 1024) {
                                FR_FAULT_LOG("%s ext id=%s - possibly bad length %zu - limiting dump to 1024",
                                             name, ext_name, ext_len);
                                ext_len = 1024;
                        }
 
                        FR_FAULT_LOG("%s ext id=%s start=%p end=%p len=%zu",
                                     name, ext_name, ext, ((uint8_t *)ext) + ext_len, ext_len);
                        FR_FAULT_LOG_HEX(ext, ext_len);
                }
        }
}