n_str.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef NO_NSTR
 
#include "nilorea/n_common.h"
#include "nilorea/n_log.h"
#include "nilorea/n_str.h"
#include "nilorea/n_hash.h"
 
#include <errno.h>
#include <pthread.h>
#include <math.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <stdint.h>
#include <stdlib.h>
#include <dirent.h>
 
#ifdef __windows__
const char* strcasestr(const char* s1, const char* s2) {
    __n_assert(s1, return NULL);
    __n_assert(s2, return NULL);
 
    size_t n = strlen(s2);
    while (*s1) {
        if (!strnicmp(s1++, s2, n))
            return (s1 - 1);
    }
    return NULL;
} /* strcasestr */
#endif
 
void free_nstr_ptr(void* ptr) {
    N_STR* strptr = (N_STR*)ptr;
    if (ptr && strptr) {
        FreeNoLog(strptr->data);
        FreeNoLog(strptr);
    }
} /* free_nstr_ptr( ... ) */
 
int _free_nstr(N_STR** ptr) {
    __n_assert(ptr && (*ptr), return FALSE);
 
    FreeNoLog((*ptr)->data);
    FreeNoLog((*ptr));
 
    return TRUE;
} /* free_nstr( ... ) */
 
int free_nstr_nolog(N_STR** ptr) {
    if ((*ptr)) {
        FreeNoLog((*ptr)->data);
        FreeNoLog((*ptr));
    }
 
    return TRUE;
} /* free_nstr( ... ) */
 
void free_nstr_ptr_nolog(void* ptr) {
    N_STR* strptr = (N_STR*)ptr;
    if (strptr) {
        FreeNoLog(strptr->data);
        FreeNoLog(strptr);
    }
} /* free_nstr_ptr_nolog( ... ) */
 
char* trim_nocopy(char* s) {
    __n_assert(s, return NULL);
 
    if (strlen(s) == 0)
        return s;
 
    char* start = s;
 
    /* skip spaces at start */
    while (*start && isspace((unsigned char)*start))
        start++;
 
    char* end = s + strlen(s) - 1;
    /* iterate over the rest remebering last non-whitespace */
    while (*end && isspace((unsigned char)*end) && end > s) {
        end--;
    }
    end++;
    /* write the terminating zero after last non-whitespace */
    *end = 0;
 
    return start;
} /* trim_nocopy */
 
char* trim(const char* s) {
    __n_assert(s, return NULL);
 
    char* copy = strdup(s);
    __n_assert(copy, return NULL);
 
    const char* trimmed = trim_nocopy(copy);
    char* result = strdup(trimmed);
    free(copy);
    return result;
} /* trim */
 
char* nfgets(char* buffer, NSTRBYTE size, FILE* stream) {
    __n_assert(buffer, return NULL);
    __n_assert(stream, return NULL);
 
    if (size >= INT_MAX) {
        n_log(LOG_ERR, "size of %zu too big, >INT_MAX for buffer %p", size, buffer);
        return NULL;
    }
 
    if (!fgets(buffer, (int)size, stream)) {
        return NULL;
    }
 
    return buffer;
} /* nfgets(...) */
 
int empty_nstr(N_STR* nstr) {
    __n_assert(nstr, return FALSE);
    __n_assert(nstr->data, return FALSE);
 
    nstr->written = 0;
    memset(nstr->data, 0, nstr->length);
 
    return TRUE;
}
 
N_STR* new_nstr(NSTRBYTE size) {
    N_STR* str = NULL;
 
    Malloc(str, N_STR, 1);
    __n_assert(str, return NULL);
 
    str->written = 0;
    if (size == 0) {
        str->data = NULL;
        str->length = 0;
    } else {
        Malloc(str->data, char, size + 1);
        __n_assert(str->data, Free(str); return NULL);
        str->length = size;
    }
    return str;
} /* new_nstr(...) */
 
int char_to_nstr_ex(const char* from, NSTRBYTE nboct, N_STR** to) {
    if ((*to)) {
        n_log(LOG_ERR, "destination N_STR **str is not NULL (%p), it contain (%s). You must provide an empty destination.", (*to), ((*to) && (*to)->data) ? (*to)->data : "DATA_IS_NULL");
        n_log(LOG_ERR, "Data to copy: %s", _str(from));
        return FALSE;
    };
 
    (*to) = new_nstr(nboct + 1);
    __n_assert(to && (*to), return FALSE);
    /* added a sizeof( void * ) to add a consistant and secure padding at the end */
    __n_assert((*to)->data, Free((*to)); return FALSE);
 
    memcpy((*to)->data, from, nboct);
    (*to)->written = nboct;
 
    return TRUE;
} /* char_to_nstr(...) */
 
N_STR* char_to_nstr(const char* src) {
    __n_assert(src, return NULL);
    N_STR* strptr = NULL;
    size_t length = strlen(src);
    char_to_nstr_ex(src, length, &strptr);
    return strptr;
} /* char_to_str(...) */
 
N_STR* char_to_nstr_nocopy(char* src) {
    __n_assert(src, return NULL);
 
    N_STR* to = NULL;
    to = new_nstr(0);
    __n_assert(to, return NULL);
 
    to->data = src;
    to->written = strlen(src);
    to->length = to->written + 1;  // include src end of string
 
    return to;
} /* char_to_str_nocopy(...) */
 
N_STR* file_to_nstr(char* filename) {
    N_STR* tmpstr = NULL;
    struct stat filestat;
    FILE* in = NULL;
    int error = 0;
 
    __n_assert(filename, n_log(LOG_ERR, "Unable to make a string from NULL filename"); return NULL);
 
    int fd = open(filename, O_RDONLY);
    error = errno;
    if (fd == -1) {
        n_log(LOG_ERR, "Unable to open %s for reading. Errno: %s", filename, strerror(error));
        return NULL;
    }
 
    if (fstat(fd, &filestat) != 0) {
        error = errno;
#ifdef __linux__
        if (error == EOVERFLOW) {
            n_log(LOG_ERR, "%s size is too big ,EOVERFLOW)", filename);
        } else {
#endif
            n_log(LOG_ERR, "Couldn't stat %s. Errno: %s", filename, strerror(error));
#ifdef __linux__
        }
#endif
        close(fd);
        return NULL;
    }
 
    if ((uint64_t)filestat.st_size >= (uint64_t)UINT32_MAX) {
        n_log(LOG_ERR, "file size >= 4GB is not possible yet. %s is %lld oct", filename, (long long)filestat.st_size);
        close(fd);
        return NULL;
    }
 
    n_log(LOG_DEBUG, "%s file size is: %lld", filename, (long long)filestat.st_size);
 
    in = fdopen(fd, "rb");
    if (!in) {
        n_log(LOG_ERR, "fdopen failed on %s (fd=%d)", filename, fd);
        close(fd);
        return NULL;
    }
 
    tmpstr = new_nstr((size_t)filestat.st_size + 1);
    __n_assert(tmpstr, fclose(in); n_log(LOG_ERR, "Unable to get a new nstr of %ld octets", filestat.st_size + 1); return NULL);
 
    tmpstr->written = (size_t)filestat.st_size;
 
    /* an empty file (0 bytes) is a valid read, not an error: fread would be asked to
       read 0 bytes and return 0, which is not a failure. Return the empty (calloc'd,
       NUL-terminated) string so callers treat an empty file as empty content instead
       of a read error. Only read when there is at least one byte. */
    if (tmpstr->written > 0) {
        if (fread(tmpstr->data, sizeof(char), tmpstr->written, in) == 0) {
            n_log(LOG_ERR, "Couldn't read %s, fread return 0", filename);
            free_nstr(&tmpstr);
            fclose(in);
            return NULL;
        }
        if (ferror(in)) {
            n_log(LOG_ERR, "There were some errors when reading %s", filename);
            free_nstr(&tmpstr);
            fclose(in);
            return NULL;
        }
    }
 
    fclose(in);
 
    return tmpstr;
} /*file_to_nstr */
 
/* Write a whole N_STR into a file */
int nstr_to_fd(N_STR* str, FILE* out, int lock) {
#ifdef __linux__
    struct flock out_lock;
#endif
    __n_assert(out, return FALSE);
    __n_assert(str, return FALSE);
 
    int ret = TRUE;
 
    if (lock == 1) {
#ifdef __linux__
        memset(&out_lock, 0, sizeof(out_lock));
        out_lock.l_type = F_WRLCK;
        /* Place a write lock on the file. */
        fcntl(fileno(out), F_SETLKW, &out_lock);
#else
        // cppcheck-suppress uselessAssignmentArg ; intentional: suppress unused parameter warning on non-POSIX
        lock = 2;
#endif
    }
 
    size_t written_to_file = 0;
    if ((written_to_file = fwrite(str->data, sizeof(char), str->written, out)) != (size_t)str->written) {
        n_log(LOG_ERR, "Couldn't write file, fwrite %d of %d octets", written_to_file, str->written);
        ret = FALSE;
    }
    if (ferror(out)) {
        n_log(LOG_ERR, "There were some errors when writing to %d", fileno(out));
        ret = FALSE;
    }
 
    if (lock == 1) {
#ifdef __linux__
        memset(&out_lock, 0, sizeof(out_lock));
        out_lock.l_type = F_WRLCK;
        /* Place a write lock on the file. */
        fcntl(fileno(out), F_SETLKW, &out_lock);
#else
        // cppcheck-suppress uselessAssignmentArg
        // cppcheck-suppress unreadVariable
        lock = 2; /* compiler warning suppressor for non-POSIX */
#endif
    }
 
    return ret;
} /* nstr_to_fd( ... ) */
 
int nstr_to_file(N_STR* str, char* filename) {
    __n_assert(str, return FALSE);
    __n_assert(filename, return FALSE);
 
    int fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0600);  // Secure permissions: rw-------
    if (fd == -1) {
        n_log(LOG_ERR, "Couldn't open %s for writing (0600). Errno: %s", _str(filename), strerror(errno));
        return FALSE;
    }
 
    FILE* out = NULL;
    out = fdopen(fd, "wb");
    if (!out) {
        n_log(LOG_ERR, "fdopen failed for %s (fd=%d). Errno: %s", _str(filename), fd, strerror(errno));
        close(fd);
        return FALSE;
    }
 
    int ret = nstr_to_fd(str, out, 1);
 
    fclose(out);
 
    n_log(LOG_DEBUG, "%s file size is: %lld", _str(filename), (long long)str->written);
 
    return ret;
} /* nstr_to_file(...) */
 
int str_to_int_ex(const char* s, NSTRBYTE start, NSTRBYTE end, int* i, const int base) {
    char* tmpstr = NULL;
    char* endstr = NULL;
    long int l = 0;
 
    __n_assert(s, return FALSE);
 
    if (start > end) return FALSE;
 
    Malloc(tmpstr, char, sizeof(int) + end - start + 8);
    __n_assert(tmpstr, n_log(LOG_ERR, "Unable to Malloc( tmpstr , char ,  sizeof( int ) + %d - %d )", end, start); return FALSE);
 
    memcpy(tmpstr, s + start, end - start);
 
    errno = 0;
    l = strtol(tmpstr, &endstr, base);
    if ((errno == ERANGE && l == LONG_MAX) || l > INT_MAX) {
        n_log(LOG_ERR, "OVERFLOW reached when converting %s to int", tmpstr);
        Free(tmpstr);
        return FALSE;
    }
    if ((errno == ERANGE && l == LONG_MIN) || l < INT_MIN) {
        n_log(LOG_ERR, "UNDERFLOW reached when converting %s to int", tmpstr);
        Free(tmpstr);
        return FALSE;
    }
    if (*endstr != '\0' && *endstr != '\n') {
        n_log(LOG_ERR, "Impossible conversion for %s", tmpstr);
        Free(tmpstr);
        return FALSE;
    }
    Free(tmpstr);
    *i = (int)l;
    return TRUE;
} /* str_to_int_ex( ... ) */
 
int str_to_int_nolog(const char* s, NSTRBYTE start, NSTRBYTE end, int* i, const int base, N_STR** infos) {
    char* tmpstr = NULL;
    char* endstr = NULL;
    long int l = 0;
 
    __n_assert(s, return FALSE);
 
    if (start > end) return FALSE;
 
    Malloc(tmpstr, char, sizeof(int) + end - start + 8);
    __n_assert(tmpstr, n_log(LOG_ERR, "Unable to Malloc( tmpstr , char ,  sizeof( int ) + %d - %d )", end, start); return FALSE);
 
    memcpy(tmpstr, s + start, end - start);
 
    errno = 0;
    l = strtol(tmpstr, &endstr, base);
    if ((errno == ERANGE && l == LONG_MAX) || l > INT_MAX) {
        nstrprintf((*infos), "OVERFLOW reached when converting %s to int", tmpstr);
        Free(tmpstr);
        return FALSE;
    }
    if ((errno == ERANGE && l == LONG_MIN) || l < INT_MIN) {
        nstrprintf((*infos), "UNDERFLOW reached when converting %s to int", tmpstr);
        Free(tmpstr);
        return FALSE;
    }
    if (*endstr != '\0' && *endstr != '\n') {
        nstrprintf((*infos), "Impossible conversion for %s", tmpstr);
        Free(tmpstr);
        return FALSE;
    }
    Free(tmpstr);
    *i = (int)l;
    return TRUE;
} /* str_to_int_nolog( ... ) */
 
int str_to_int(const char* s, int* i, const int base) {
    int ret = FALSE;
    if (s) {
        ret = str_to_int_ex(s, 0, strlen(s), i, base);
    }
    return ret;
} /* str_to_int(...) */
 
int str_to_long_ex(const char* s, NSTRBYTE start, NSTRBYTE end, long int* i, const int base) {
    char* tmpstr = NULL;
    char* endstr = NULL;
    long l = 0;
 
    __n_assert(s, return FALSE);
 
    if (start > end) return FALSE;
 
    Malloc(tmpstr, char, sizeof(int) + end - start + 8);
    __n_assert(tmpstr, n_log(LOG_ERR, "Unable to Malloc( tmpstr , char ,  sizeof( int ) + %d - %d )", end, start); return FALSE);
 
    memcpy(tmpstr, s + start, end - start);
 
    errno = 0;
    l = strtol(tmpstr, &endstr, base);
    int error = errno;
 
    /* test return to number and errno values */
    if (tmpstr == endstr) {
        n_log(LOG_ERR, " number : %ld  invalid  (no digits found, 0 returned)", l);
        Free(tmpstr);
        return FALSE;
    } else if (error == ERANGE && l == LONG_MIN) {
        n_log(LOG_ERR, " number : %ld  invalid  (underflow occurred)", l);
        Free(tmpstr);
        return FALSE;
    } else if (error == ERANGE && l == LONG_MAX) {
        n_log(LOG_ERR, " number : %ld  invalid  (overflow occurred)", l);
        Free(tmpstr);
        return FALSE;
    } else if (error == EINVAL) /* not in all c99 implementations - gcc OK */
    {
        n_log(LOG_ERR, " number : %ld  invalid  (base contains unsupported value)", l);
        Free(tmpstr);
        return FALSE;
    } else if (error != 0 && l == 0) {
        n_log(LOG_ERR, " number : %ld  invalid  (unspecified error occurred)", l);
        Free(tmpstr);
        return FALSE;
    } else if (error == 0 && !*endstr) {
        n_log(LOG_DEBUG, " number : %ld    valid  (and represents all characters read)", l);
    } else if (error == 0 && *endstr != 0) {
        n_log(LOG_DEBUG, " number : %ld    valid  (but additional characters remain", l);
    }
    Free(tmpstr);
    *i = l;
    return TRUE;
} /* str_to_long_ex( ... ) */
 
int str_to_long_long_ex(const char* s, NSTRBYTE start, NSTRBYTE end, long long int* i, const int base) {
    char* tmpstr = NULL;
    char* endstr = NULL;
    long long l = 0;
 
    __n_assert(s, return FALSE);
 
    if (start > end) return FALSE;
 
    Malloc(tmpstr, char, sizeof(int) + end - start + 8);
    __n_assert(tmpstr, n_log(LOG_ERR, "Unable to Malloc( tmpstr , char ,  sizeof( int ) + %d - %d )", end, start); return FALSE);
 
    memcpy(tmpstr, s + start, end - start);
 
    errno = 0;
    l = strtoll(tmpstr, &endstr, base);
    int error = errno;
 
    /* test return to number and errno values */
    if (tmpstr == endstr) {
        n_log(LOG_ERR, "number: '%s' invalid (no digits found, 0 returned)", s);
        Free(tmpstr);
        return FALSE;
    } else if (error == ERANGE && l == LLONG_MIN) {
        n_log(LOG_ERR, "number: '%s' invalid (underflow occurred)", s);
        Free(tmpstr);
        return FALSE;
    } else if (error == ERANGE && l == LLONG_MAX) {
        n_log(LOG_ERR, "number: 's' invalid (overflow occurred)", s);
        Free(tmpstr);
        return FALSE;
    } else if (error == EINVAL) /* not in all c99 implementations - gcc OK */
    {
        n_log(LOG_ERR, "number: '%s' invalid (base contains unsupported value)", s);
        Free(tmpstr);
        return FALSE;
    } else if (error != 0 && l == 0) {
        n_log(LOG_ERR, "number: '%s' invalid (unspecified error occurred)", s);
        Free(tmpstr);
        return FALSE;
    } else if (error == 0 && !*endstr) {
        n_log(LOG_DEBUG, "number : '%llu' valid (and represents all characters read)", l);
    } else if (error == 0 && *endstr != 0) {
        n_log(LOG_DEBUG, " number : '%llu' valid (remaining characters: '%s')", l, s);
    }
    Free(tmpstr);
    *i = l;
    return TRUE;
} /* str_to_long_long_ex( ... ) */
 
int str_to_long(const char* s, long int* i, const int base) {
    int ret = FALSE;
    if (s) {
        ret = str_to_long_ex(s, 0, strlen(s), i, base);
    }
    return ret;
} /* str_to_long(...) */
 
int str_to_long_long(const char* s, long long int* i, const int base) {
    int ret = FALSE;
    if (s) {
        ret = str_to_long_long_ex(s, 0, strlen(s), i, base);
    }
    return ret;
} /* str_to_long(...) */
 
N_STR* nstrdup(N_STR* str) {
    N_STR* new_str = NULL;
 
    __n_assert(str, return NULL);
    __n_assert(str->data, return NULL);
 
    new_str = new_nstr(str->length);
    if (new_str) {
        if (new_str->data) {
            memcpy(new_str->data, str->data, str->written);
            new_str->length = str->length;
            new_str->written = str->written;
        } else {
            Free(new_str);
            n_log(LOG_ERR, "Error duplicating N_STR %p -> data", str);
        }
    } else {
        n_log(LOG_ERR, "Error duplicating N_STR %p", str);
    }
    return new_str;
} /* nstrdup(...) */
 
int skipw(const char* string, char toskip, NSTRBYTE* iterator, int inc) {
    int error_flag = 0;
 
    __n_assert(string, return FALSE);
 
    NSTRBYTE slen = (NSTRBYTE)strlen(string);
    if (toskip == ' ') {
        while (*iterator <= slen && isspace((unsigned char)string[*iterator])) {
            if (inc < 0 && *iterator == 0) {
                error_flag = 1;
                break;
            } else {
                if (inc > 0)
                    *iterator = *iterator + (NSTRBYTE)inc;
                else
                    *iterator = (*iterator > (NSTRBYTE)(-inc)) ? (*iterator - (NSTRBYTE)(-inc)) : 0;
            }
        }
    } else {
        while (*iterator <= slen && string[*iterator] == toskip) {
            if (inc < 0 && *iterator == 0) {
                error_flag = 1;
                break;
            } else {
                if (inc > 0)
                    *iterator = *iterator + (NSTRBYTE)inc;
                else
                    *iterator = (*iterator > (NSTRBYTE)(-inc)) ? (*iterator - (NSTRBYTE)(-inc)) : 0;
            }
        }
    }
    if (error_flag == 1 || *iterator > slen) {
        return FALSE;
    }
 
    return TRUE;
} /*skipw(...)*/
 
int skipu(const char* string, char toskip, NSTRBYTE* iterator, int inc) {
    int error_flag = 0;
 
    __n_assert(string, return FALSE);
 
    NSTRBYTE slen = (NSTRBYTE)strlen(string);
    if (toskip == ' ') {
        while (*iterator <= slen && !isspace((unsigned char)string[*iterator])) {
            if (inc < 0 && *iterator == 0) {
                error_flag = 1;
                break;
            } else {
                if (inc > 0)
                    *iterator = *iterator + (NSTRBYTE)inc;
                else
                    *iterator = (*iterator > (NSTRBYTE)(-inc)) ? (*iterator - (NSTRBYTE)(-inc)) : 0;
            }
        }
    } else {
        while (*iterator <= slen && string[*iterator] != toskip) {
            if (inc < 0 && *iterator == 0) {
                error_flag = 1;
                break;
            } else {
                if (inc > 0)
                    *iterator = *iterator + (NSTRBYTE)inc;
                else
                    *iterator = (*iterator > (NSTRBYTE)(-inc)) ? (*iterator - (NSTRBYTE)(-inc)) : 0;
            }
        }
    }
 
    if (error_flag == 1 || *iterator > slen) {
        return FALSE;
    }
 
    return TRUE;
} /*Skipu(...)*/
 
int strup(const char* string, char* dest) {
    NSTRBYTE it = 0;
 
    __n_assert(string, return FALSE);
    __n_assert(dest, return FALSE);
 
    for (it = 0; it < (NSTRBYTE)strlen(string); it++)
        dest[it] = (char)toupper(string[it]);
 
    dest[strlen(string)] = '\0';
 
    return TRUE;
} /*strup(...)*/
 
int strlo(const char* string, char* dest) {
    NSTRBYTE it = 0;
 
    __n_assert(string, return FALSE);
    __n_assert(dest, return FALSE);
 
    for (it = 0; it < (NSTRBYTE)strlen(string); it++)
        dest[it] = (char)tolower(string[it]);
 
    dest[strlen(string)] = '\0';
 
    return TRUE;
} /*strlo(...)*/
 
int strcpy_u(const char* from, char* to, NSTRBYTE to_size, char delim, NSTRBYTE* it) {
    NSTRBYTE _it = 0;
 
    __n_assert(from, return FALSE);
    __n_assert(to, return FALSE);
    __n_assert(it, return FALSE);
 
    while (_it < to_size && from[(*it)] != '\0' && from[(*it)] != delim) {
        to[_it] = from[(*it)];
        (*it) = (*it) + 1;
        _it = _it + 1;
    }
 
    if (_it == to_size) {
        _it--;
        to[_it] = '\0';
        n_log(LOG_DEBUG, "strcpy_u: not enough space to write %d octet to dest (%d max) , %s: %d", _it, to_size, __FILE__, __LINE__);
        return FALSE;
    }
 
    to[_it] = '\0';
 
    if (from[(*it)] != delim) {
        n_log(LOG_DEBUG, "strcpy_u: delim value not found, written %d octet to dest (%d max) , %s: %d", _it, to_size, __FILE__, __LINE__);
        return FALSE;
    }
    return TRUE;
} /* strcpy_u(...) */
 
char** split(const char* str, const char* delim, int empty) {
    char** tab = NULL;              /* result array */
    char* ptr = NULL;               /* tmp pointer */
    char** tmp = NULL;              /* temporary pointer for realloc */
    size_t sizeStr = 0;             /* string token size */
    size_t sizeTab = 0;             /* array size */
    const char* largestring = NULL; /* pointer to start of string */
 
    __n_assert(str, return NULL);
    __n_assert(delim, return NULL);
 
    size_t sizeDelim = strlen(delim);
    largestring = str;
 
    while ((ptr = strstr(largestring, delim)) != NULL) {
        sizeStr = (size_t)(ptr - largestring);
        if (empty == 1 || sizeStr != 0) {
            sizeTab++;
            tmp = (char**)realloc(tab, sizeof(char*) * sizeTab);
            __n_assert(tmp, goto error);
            tab = tmp;
 
            Malloc(tab[sizeTab - 1], char, sizeof(char) * (sizeStr + 1));
            __n_assert(tab[sizeTab - 1], goto error);
 
            memcpy(tab[sizeTab - 1], largestring, sizeStr);
            tab[sizeTab - 1][sizeStr] = '\0';
        }
        ptr = ptr + sizeDelim;
        largestring = ptr;
    }
 
    /* adding last part if any */
    if (strlen(largestring) != 0) {
        sizeStr = strlen(largestring);
        sizeTab++;
 
        tmp = (char**)realloc(tab, sizeof(char*) * sizeTab);
        __n_assert(tmp, goto error);
        tab = tmp;
 
        Malloc(tab[sizeTab - 1], char, sizeof(char) * (sizeStr + 1));
        __n_assert(tab[sizeTab - 1], goto error);
 
        memcpy(tab[sizeTab - 1], largestring, sizeStr);
        tab[sizeTab - 1][sizeStr] = '\0';
    } else {
        if (empty == 1) {
            sizeTab++;
 
            tmp = (char**)realloc(tab, sizeof(char*) * sizeTab);
            __n_assert(tmp, goto error);
            tab = tmp;
 
            Malloc(tab[sizeTab - 1], char, (int)(sizeof(char) * 1));
            __n_assert(tab[sizeTab - 1], goto error);
 
            tab[sizeTab - 1][0] = '\0';
        }
    }
 
    /* on ajoute une case a null pour finir le tableau */
    sizeTab++;
    tmp = (char**)realloc(tab, sizeof(char*) * sizeTab);
    __n_assert(tmp, goto error);
    tab = tmp;
    tab[sizeTab - 1] = NULL;
 
    return tab;
 
error:
    free_split_result(&tab);
    return NULL;
} /* split( ... ) */
 
int split_count(char** split_result) {
    __n_assert(split_result, return -1);
    __n_assert(split_result[0], return -1);
 
    int it = 0;
    while (split_result[it]) {
        it++;
    }
    return it;
} /* split_count(...) */
 
int free_split_result(char*** tab) {
    if (!(*tab))
        return FALSE;
 
    int it = 0;
    while ((*tab)[it]) {
        // cppcheck-suppress identicalInnerCondition ; Free() macro rechecks pointer internally
        Free((*tab)[it]);
        it++;
    }
    Free((*tab));
 
    return TRUE;
} /* free_split_result(...)*/
 
char* join(char** splitresult, const char* delim) {
    size_t delim_length = 0;
    if (delim)
        delim_length = strlen(delim);
    size_t total_length = 0;
    int it = 0;
    while (splitresult[it]) {
        // n_log( LOG_DEBUG , "split entry %d: %s" , it , splitresult[ it ] );
        size_t entry_length = strlen(splitresult[it]);
        if (entry_length >= SIZE_MAX - total_length) {
            n_log(LOG_ERR, "join: total_length overflow accumulating entry %d", it);
            return NULL;
        }
        total_length += entry_length;
        // if there is a delimitor and 'it' isn't the last entry
        if (delim && splitresult[it + 1]) {
            if (delim_length >= SIZE_MAX - total_length) {
                n_log(LOG_ERR, "join: total_length overflow accumulating delimiter at entry %d", it);
                return NULL;
            }
            total_length += delim_length;
        }
        it++;
    }
    char* result = NULL;
    Malloc(result, char, total_length + 1);
    __n_assert(result, return NULL);
    size_t position = 0;
    it = 0;
    while (splitresult[it]) {
        size_t copy_size = strlen(splitresult[it]);
        memcpy(&result[position], splitresult[it], copy_size);
        position += copy_size;
        // if there is a delimitor and 'it' isn't the last entry
        if (delim && splitresult[it + 1]) {
            memcpy(&result[position], delim, delim_length);
            position += delim_length;
        }
        it++;
    }
    result[position] = '\0';
    return result;
} /* join */
 
N_STR* nstrcat_ex(N_STR** dest, void* src, NSTRBYTE size, int resize_flag) {
    char* ptr = NULL;
    __n_assert(src, return NULL);
 
    /* guard against size + 1 overflow (also protects new_nstr's internal +1). Must come before any arithmetic using size */
    if (size >= SIZE_MAX - 1) {
        n_log(LOG_ERR, "size too large in nstrcat_ex: %zu", size);
        return NULL;
    }
 
    if (resize_flag == 0) {
        if ((*dest)) {
            /* check for written + size + 1 overflow before evaluating the expression */
            if (size > SIZE_MAX - (*dest)->written - 1) {
                n_log(LOG_ERR, "integer overflow in nstrcat_ex size calculation");
                return NULL;
            }
            if (((*dest)->written + size + 1) > (*dest)->length) {
                n_log(LOG_ERR, "%p to %p: not enough space. Resize forbidden. %zu needed, %zu available", src, (*dest), (*dest)->written + size + 1, (*dest)->length);
                return NULL;
            }
        } else {
            n_log(LOG_ERR, "%p to %p: not enough space. Resize forbidden. %zu needed, destination is NULL", src, (*dest), size + 1);
            return NULL;
        }
    }
 
    if (!(*dest)) {
        (*dest) = new_nstr(size + 1);
        if (!(*dest)) {
            n_log(LOG_ERR, "could not allocate new N_STR of size %zu", size + 1);
            return NULL;
        }
    }
 
    /* check for integer overflow before computing new size */
    if (size > SIZE_MAX - (*dest)->written - 1) {
        n_log(LOG_ERR, "integer overflow in nstrcat_ex size calculation");
        return NULL;
    }
 
    if ((*dest)->length < (*dest)->written + size + 1) {
        (*dest)->length = (*dest)->written + size + 1;
        if (Reallocz((*dest)->data, char, (*dest)->written, (*dest)->length) == FALSE) {
            free_nstr(dest);
            return NULL;
        }
    }
 
    ptr = (*dest)->data + (*dest)->written;
    memcpy(ptr, src, size);
    (*dest)->written += size;
 
    (*dest)->data[(*dest)->written] = '\0';
 
    return (*dest);
} /* nstrcat_ex( ... ) */
 
N_STR* nstrcat_bytes_ex(N_STR** dest, void* data, NSTRBYTE size) {
    __n_assert(dest, return NULL);
 
    if (size == 0) {
        n_log(LOG_ERR, "Could not copy 0 or less (%ld) octet!", size);
        return NULL;
    }
 
    return nstrcat_ex(dest, data, size, 1);
} /* nstrcat_bytes_ex( ... )*/
 
int write_and_fit_ex(char** dest, NSTRBYTE* size, NSTRBYTE* written, const char* src, NSTRBYTE src_size, NSTRBYTE additional_padding) {
    if (src_size == 0) return TRUE;
    NSTRBYTE needed_size = (*written) + src_size + 1;
    NSTRBYTE alloc_size = needed_size + additional_padding;
    /* unsigned overflow guard: also documents alloc_size >= needed_size >= 2
     * to the static analyzer (src_size >= 1 here, so needed_size >= 2). */
    if (alloc_size < needed_size) return FALSE;
 
    /* realloc if needed, also if destination is not allocated */
    if ((needed_size >= (*size)) || !(*dest)) {
        if (!(*dest)) {
            (*written) = 0;
            (*size) = 0;
        }
        if (Reallocz((*dest), char, (*size), alloc_size) == FALSE) {
            n_log(LOG_ERR, "reallocation error !!!!");
            return FALSE;
        }
        /* *size tracks total allocation (including padding) so the next
         * appends that fit in the over-allocation skip the realloc. */
        (*size) = alloc_size;
    }
    char* ptr = (*dest) + (*written);
    memcpy(ptr, src, src_size);
    (*written) += src_size;
    (*dest)[(*written)] = '\0';
 
    return TRUE;
} /* write_and_fit_ex( ...) */
 
int write_and_fit(char** dest, NSTRBYTE* size, NSTRBYTE* written, const char* src) {
    return write_and_fit_ex(dest, size, written, src, strlen(src), 8);
} /* write_and_fit( ...) */
 
int scan_dir(const char* dir, LIST* result, const int recurse) {
    return scan_dir_ex(dir, "*", result, recurse, 0);
}
 
int scan_dir_ex(const char* dir, const char* pattern, LIST* result, const int recurse, const int mode) {
    DIR* dp = NULL;
    struct dirent* entry = NULL;
    struct stat statbuf;
 
    if (!result)
        return FALSE;
 
    if ((dp = opendir(dir)) == NULL) {
        n_log(LOG_ERR, "cannot open directory: %s", dir);
        return FALSE;
    }
 
    N_STR* newname = NULL;
    while ((entry = readdir(dp)) != NULL) {
        if (!nstrprintf(newname, "%s/%s", dir, entry->d_name)) {
            n_log(LOG_ERR, "could not allocate newname for %s/%s", dir, entry->d_name);
            free_nstr(&newname);
            continue;
        }
 
        if (stat(newname->data, &statbuf) >= 0) {
            if (S_ISDIR(statbuf.st_mode) != 0) {
                if (strcmp(".", entry->d_name) == 0 || strcmp("..", entry->d_name) == 0) {
                    free_nstr(&newname);
                    continue;
                }
 
                /* Recurse */
                if (recurse != FALSE) {
                    if (scan_dir_ex(newname->data, pattern, result, recurse, mode) != TRUE) {
                        n_log(LOG_ERR, "scan_dir_ex( %s , %s , %p , %d , %d ) returned FALSE !", newname->data, pattern, result, recurse, mode);
                    }
                }
                free_nstr(&newname);
                continue;
            } else if (S_ISREG(statbuf.st_mode) != 0) {
                if (wildmatcase(newname->data, pattern) == TRUE) {
                    if (mode == 0) {
                        char* file = strdup(newname->data);
                        if (file) {
                            list_push(result, file, &free);
                        } else {
                            n_log(LOG_ERR, "Error adding %s/%s to list", dir, entry->d_name);
                        }
                    } else if (mode == 1) {
                        list_push(result, newname, &free_nstr_ptr);
                        newname = NULL;
                    }
                }
            }
        }
        if (newname)
            free_nstr(&newname);
    }
    closedir(dp);
    return TRUE;
} /*scan_dir(...) */
 
int wildmat(register const char* text, register const char* p) {
    register int last = 0;
    register int matched = 0;
    register int reverse = 0;
 
    for (; *p; text++, p++) {
        if (*text == '\0' && *p != '*')
            return WILDMAT_ABORT;
        switch (*p) {
            case '\\':
                /* Literal match with following character. */
                p++;
            /* FALLTHROUGH */
            default:
                if (*text != *p)
                    return FALSE;
                continue;
            case '?':
                /* Match anything. */
                continue;
            case '*':
                while (*++p == '*')
                    /* Consecutive stars act just like one. */
                    ;
                if (*p == '\0')
                    /* Trailing star matches everything. */
                    return TRUE;
                while (*text)
                    if ((matched = wildmat(text++, p)) != FALSE)
                        return matched;
                return WILDMAT_ABORT;
            case '[':
                reverse = p[1] == WILDMAT_NEGATE_CLASS ? TRUE : FALSE;
                if (reverse)
                    /* Inverted character class. */
                    p++;
                matched = FALSE;
                if (p[1] == ']' || p[1] == '-')
                    if (*++p == *text)
                        matched = TRUE;
                for (last = *p; *++p && *p != ']'; last = *p)
                    /* This next line requires a good C compiler. */
                    if (*p == '-' && p[1] != ']'
                            ? *text <= *++p && *text >= last
                            : *text == *p)
                        matched = TRUE;
                if (matched == reverse)
                    return FALSE;
                continue;
        }
    }
#ifdef WILDMAT_MATCH_TAR_PATTERN
    if (*text == '/')
        return TRUE;
#endif /* MATCH_TAR_ATTERN */
    return *text == '\0';
} /* wildmatch(...) */
 
int wildmatcase(register const char* text, register const char* p) {
    register int last;
    register int matched;
    register int reverse;
 
    for (; *p; text++, p++) {
        if (*text == '\0' && *p != '*')
            return WILDMAT_ABORT;
        switch (*p) {
            case '\\':
                /* Literal match with following character. */
                p++;
            /* FALLTHROUGH */
            default:
                if (toupper(*text) != toupper(*p))
                    return FALSE;
                continue;
            case '?':
                /* Match anything. */
                continue;
            case '*':
                while (*++p == '*')
                    /* Consecutive stars act just like one. */
                    ;
                if (*p == '\0')
                    /* Trailing star matches everything. */
                    return TRUE;
                while (*text)
                    if ((matched = wildmatcase(text++, p)) != FALSE)
                        return matched;
                return WILDMAT_ABORT;
            case '[':
                reverse = p[1] == WILDMAT_NEGATE_CLASS ? TRUE : FALSE;
                if (reverse)
                    /* Inverted character class. */
                    p++;
                matched = FALSE;
                if (p[1] == ']' || p[1] == '-')
                    if (toupper(*++p) == toupper(*text))
                        matched = TRUE;
                for (last = toupper(*p); *++p && *p != ']'; last = toupper(*p))
                    if (*p == '-' && p[1] != ']'
                            ? toupper(*text) <= toupper(*++p) && toupper(*text) >= last
                            : toupper(*text) == toupper(*p))
                        matched = TRUE;
                if (matched == reverse)
                    return FALSE;
                continue;
        }
    }
#ifdef WILDMAT_MATCH_TAR_PATTERN
    if (*text == '/')
        return TRUE;
#endif /* MATCH_TAR_ATTERN */
    return *text == '\0';
} /* wildmatcase(...) */
 
char* str_replace(const char* string, const char* substr, const char* replacement) {
    const char* tok = NULL;
    char* newstr = NULL;
    char* head = NULL;
 
    if (substr == NULL || substr[0] == '\0' || replacement == NULL)
        return strdup(string);
 
    size_t substr_len = strlen(substr);
    size_t replacement_len = strlen(replacement);
 
    newstr = strdup(string);
    if (!newstr) return NULL;
    head = newstr;
    while ((tok = strstr(head, substr))) {
        char* oldstr = newstr;
        size_t oldstr_len = strlen(oldstr);
        size_t base_len = oldstr_len - substr_len;
        /* Prevent size_t overflow in allocation size calculation */
        if (base_len > SIZE_MAX - 8 ||
            replacement_len > SIZE_MAX - base_len - 8) {
            n_log(LOG_ERR, "str_replace: allocation size overflow (base_len=%zu, replacement_len=%zu)", base_len, replacement_len);
            free(oldstr);
            return NULL;
        }
        size_t newlen = base_len + replacement_len + 8;
        Malloc(newstr, char, newlen);
        /*failed to alloc mem, free old string and return NULL */
        if (newstr == NULL) {
            n_log(LOG_ERR, "str_replace: could not allocate newstr of size %zu", newlen);
            free(oldstr);
            return NULL;
        }
        memcpy(newstr, oldstr, (size_t)(tok - oldstr));
        memcpy(newstr + (tok - oldstr), replacement, replacement_len);
        memcpy(newstr + (tok - oldstr) + replacement_len, tok + substr_len, oldstr_len - substr_len - (size_t)(tok - oldstr));
        memset(newstr + oldstr_len - substr_len + replacement_len, 0, 1);
        /* move back head right after the last replacement */
        head = newstr + (tok - oldstr) + replacement_len;
        free(oldstr);
    }
    return newstr;
}
 
int str_sanitize_ex(char* string, const NSTRBYTE string_len, const char* mask, const NSTRBYTE masklen, const char replacement) {
    __n_assert(string, return FALSE);
    __n_assert(mask, return FALSE);
 
    NSTRBYTE it = 0;
    for (it = 0; it < string_len; it++) {
        NSTRBYTE mask_it = 0;
        while (mask_it < masklen && mask[mask_it] != '\0') {
            if (string[it] == mask[mask_it])
                string[it] = replacement;
            mask_it++;
        }
    }
    return TRUE;
}
 
int str_sanitize(char* string, const char* mask, const char replacement) {
    return str_sanitize_ex(string, strlen(string), mask, strlen(mask), replacement);
}
 
int resize_nstr(N_STR* nstr, size_t size) {
    __n_assert(nstr, return FALSE);
    if (size == 0) {
        // Free the current buffer and reset fields
        Free(nstr->data);
        nstr->written = 0;
        nstr->length = 0;
        return TRUE;
    }
 
    if (!nstr->data) {
        Malloc(nstr->data, char, size);
        __n_assert(nstr->data, return FALSE);
    } else {
        if (Reallocz(nstr->data, char, nstr->length, size) == FALSE) {
            return FALSE;
        }
    }
 
    nstr->length = size;
 
    return TRUE;
}
 
N_STR* nstrprintf_ex(N_STR** nstr_var, const char* format, ...) {
    __n_assert(format, return NULL);
 
    va_list args;
    va_list args_copy;
    int needed_size = 0;
 
    // Calculate the required size for the formatted string
    va_start(args, format);
    va_copy(args_copy, args);  // Copy args for reuse
    needed_size = vsnprintf(NULL, 0, format, args);
    va_end(args);
 
    if (needed_size < 0) {
        va_end(args_copy);
        n_log(LOG_ERR, "there was an error while computing the new size according to format \"%s\" for N_STR %p", format, (*nstr_var));
        return NULL;
    }
 
    size_t needed = (size_t)(needed_size + 1);  // Include null-terminator
 
    // Allocate or resize the N_STR object as needed
    if (!(*nstr_var)) {
        (*nstr_var) = new_nstr(needed);
        if (!(*nstr_var) || !(*nstr_var)->data) {
            va_end(args_copy);
            n_log(LOG_ERR, "could not allocate N_STR of size %zu", needed);
            return NULL;
        }
    } else if (needed > (*nstr_var)->length) {
        if (resize_nstr((*nstr_var), needed) == FALSE) {
            va_end(args_copy);
            n_log(LOG_ERR, "could not resize N_STR %p to size %zu", (*nstr_var), needed);
            return NULL;
        }
    }
 
    // Write the formatted string into the buffer
    vsnprintf((*nstr_var)->data, needed, format, args_copy);
    va_end(args_copy);
 
    (*nstr_var)->written = (size_t)needed_size;
    return (*nstr_var);
}
 
N_STR* nstrprintf_cat_ex(N_STR** nstr_var, const char* format, ...) {
    __n_assert(format, return NULL);
 
    va_list args;
    va_start(args, format);
 
    // duplicate va_list
    va_list args_copy;
    va_copy(args_copy, args);
 
    // compute needed size
    int needed_size = vsnprintf(NULL, 0, format, args_copy);
    va_end(args_copy);
 
    if (needed_size < 0) {
        n_log(LOG_ERR, "vsnprintf size estimation failed for format \"%s\"", format);
        va_end(args);
        return NULL;
    }
 
    size_t needed = (size_t)(needed_size + 1);  // +1 for '\0'
 
    // initialize if needed
    if (!(*nstr_var)) {
        (*nstr_var) = new_nstr(needed);
        if (!(*nstr_var)) {
            va_end(args);
            return NULL;
        }
    }
 
    // check for overflow before computing total_needed
    if (needed > SIZE_MAX - (*nstr_var)->written) {
        va_end(args);
        n_log(LOG_ERR, "integer overflow computing total_needed in nstrprintf_cat_ex");
        return NULL;
    }
 
    // resize if needed
    size_t total_needed = (*nstr_var)->written + needed;
    if (total_needed > (*nstr_var)->length) {
        if (resize_nstr((*nstr_var), total_needed) == FALSE) {
            va_end(args);
            n_log(LOG_ERR, "could not resize N_STR %p to size %zu", (*nstr_var), total_needed);
            return NULL;
        }
    }
 
    // append formatted string
    char* write_ptr = (*nstr_var)->data + (*nstr_var)->written;
    int written_now = vsnprintf(write_ptr, needed, format, args);
    va_end(args);
 
    if (written_now < 0) {
        n_log(LOG_ERR, "vsnprintf failed while writing at offset %zu in N_STR %p", (*nstr_var)->written, (*nstr_var));
        return NULL;
    }
 
    (*nstr_var)->written += (size_t)written_now;
    (*nstr_var)->data[(*nstr_var)->written] = '\0';  // ensure final \0
 
    return *nstr_var;
}
 
N_STR* n_str_template_expand(const char* tmpl, HASH_TABLE* vars) {
    if (!tmpl) return NULL;
    N_STR* result = new_nstr(strlen(tmpl) + 256);
    if (!result) return NULL;
    const char* p = tmpl;
    while (*p) {
        if (p[0] == '{' && p[1] == '{') {
            const char* end = strstr(p + 2, "}}");
            if (end) {
                size_t klen = (size_t)(end - (p + 2));
                char key[256];
                if (klen < sizeof(key)) {
                    memcpy(key, p + 2, klen);
                    key[klen] = '\0';
                    char* val = NULL;
                    if (vars && ht_get_string(vars, key, &val) == TRUE && val) {
                        nstrprintf_cat(result, "%s", val);
                    } else {
                        nstrprintf_cat(result, "{{%s}}", key);
                    }
                    p = end + 2;
                    continue;
                }
            }
        }
        char ch[2] = {*p, '\0'};
        nstrprintf_cat(result, "%s", ch);
        p++;
    }
    return result;
}
 
N_STR* n_str_url_encode(const char* src) {
    if (!src) return NULL;
    size_t in_len = strlen(src);
    /* worst case: every byte expands to "%HH" -> 3x */
    if (in_len > (SIZE_MAX - 1) / 3) return NULL;
    N_STR* out = new_nstr(in_len * 3 + 1);
    if (!out) return NULL;
    for (const unsigned char* p = (const unsigned char*)src; *p; p++) {
        unsigned char c = *p;
        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
            (c >= '0' && c <= '9') ||
            c == '-' || c == '_' || c == '.' || c == '~') {
            char ch[2] = {(char)c, '\0'};
            if (!nstrprintf_cat(out, "%s", ch)) {
                free_nstr(&out);
                return NULL;
            }
        } else {
            if (!nstrprintf_cat(out, "%%%02X", c)) {
                free_nstr(&out);
                return NULL;
            }
        }
    }
    return out;
}
 
#endif /* #ifndef NOSTR */