alloc-util.c 1.61 KB
Newer Older
1
/* SPDX-License-Identifier: LGPL-2.1+ */
2

3 4 5
#include <stdint.h>
#include <string.h>

6
#include "alloc-util.h"
7
#include "macro.h"
8 9 10
#include "util.h"

void* memdup(const void *p, size_t l) {
11
        void *ret;
12

13 14 15 16 17 18 19 20 21 22
        assert(l == 0 || p);

        ret = malloc(l);
        if (!ret)
                return NULL;

        memcpy(ret, p, l);
        return ret;
}

23
void* memdup_suffix0(const void *p, size_t l) {
24 25 26 27 28
        void *ret;

        assert(l == 0 || p);

        /* The same as memdup() but place a safety NUL byte after the allocated memory */
29

30 31
        ret = malloc(l + 1);
        if (!ret)
32 33
                return NULL;

34 35
        *((uint8_t*) mempcpy(ret, p, l)) = 0;
        return ret;
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
}

void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
        size_t a, newalloc;
        void *q;

        assert(p);
        assert(allocated);

        if (*allocated >= need)
                return *p;

        newalloc = MAX(need * 2, 64u / size);
        a = newalloc * size;

        /* check for overflows */
        if (a < size * need)
                return NULL;

        q = realloc(*p, a);
        if (!q)
                return NULL;

        *p = q;
        *allocated = newalloc;
        return q;
}

void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
        size_t prev;
        uint8_t *q;

        assert(p);
        assert(allocated);

        prev = *allocated;

        q = greedy_realloc(p, allocated, need, size);
        if (!q)
                return NULL;

        if (*allocated > prev)
                memzero(q + prev * size, (*allocated - prev) * size);

        return q;
}