I can not use free() on char pointer returned from a function

Question

I cannot clear the str variable that is allocated in the ft_itoa_base() function. Error pointer being freed was not allocated.

void            work_ptr_accuracy(t_args *args, char **return_str, \
        va_list *arg)
{
    int                     size_accuracy;
    char                    *str_tmp;
    char                    *str;
    unsigned long long int  n;

    str_tmp = NULL;
    str = NULL;
    if (args->accuracy != -1)
    {
        size_accuracy = args->accuracy;
        n = va_arg(*arg, unsigned long long int);
        str = ft_itoa_base(n, 16, LOWERCASE);
        *return_str = ft_substr(str, 0, size_accuracy);
        free(str);
        str_tmp = ft_strjoin("0x", *return_str);
        free(*return_str);
        *return_str = str_tmp;
    }
}

this is ft_itoa_base()

char        *ft_itoa_base(unsigned long long int value, \
        unsigned long long int base, int regist)
{
    int                     len;
    unsigned long long int  digit;
    char                    *return_str;
    char                    *base_tmp;

    base_tmp = get_register(regist);
    if (value == 0)
        return ("0");
    len = 0;
    digit = value;
    ft_baselen(digit, base, &len);  
    if (!(return_str = (char *)malloc(sizeof(char) * (len + 1))))
        return (NULL);
    return_str[len] = '\0';
    while (digit)
    {
        return_str[--len] = base_tmp[digit % base];
        digit /= base;
    }
    if (value < 0 && base == 10)
        return_str[0] = '-';
    return (return_str);
}

this is my ft_substr()

/*
** Function:        char *ft_substr
**
** Description:     Allocates (with malloc(3)) and returns a substring
** from the string ’s’.
** The substring begins at index ’start’ and is of
** maximum size ’len’.
*/

char    *ft_substr(const char *s, unsigned int start, size_t len)
{
    unsigned int    i;
    unsigned int    j;
    char            *str;

    i = 0;
    j = 0;
    if (!s)
        return (NULL);
    if (start >= ft_strlen(s))
    {
        if (!(str = (char *)malloc(1)))
            return (NULL);
        str[0] = '\0';
        return (str);
    }
    while (s[i] != s[start])
        i++;
    if (!(str = (char *)malloc((len * sizeof(char)) + 1)))
        return (NULL);
    while (j < len && s[i])
        str[j++] = s[i++];
    str[j] = '\0';
    return (str);
}

Answer 1

Bad design of ft_itoa_base. return ("0") returns a pointer to statically allocated array consisting of two chars ( '0' and '\0'). That one cannot be free-ed.

Compare to this implementation by lwang <marvin@42.fr>

#include <stdlib.h>
#include <stdio.h>

int     ft_abs(int nb)
{
    if (nb < 0)
        nb = -nb;
    return (nb);
}

char    *ft_itoa_base(int value, int base)
{
    char    *str;
    int     size;
    char    *tab;
    int     flag;
    int     tmp;
    flag = 0;
    size = 0;
    tab = "0123456789ABCDEF";
    if (base < 2 || base > 16)
        return (0);
    if (value < 0 && base == 10)
        flag = 1;
    tmp = value;
    while (tmp /= base)
        size++;
    size = size + flag + 1;
    str = (char *)malloc(sizeof(char) * size  + 1);
    str[size] = '\0';
    if (flag == 1)
        str[0] = '-';
    while (size > flag)
    {
        str[size - 1] = tab[ft_abs(value % base)];
        size--;
        value /=base;
    }
    return (str);
}