do not use reserved names.
[protos/libecoli.git] / lib / ecoli_malloc.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
3  */
4
5 #include <ecoli_init.h>
6 #include <ecoli_test.h>
7 #include <ecoli_malloc.h>
8
9 #include <stdlib.h>
10 #include <string.h>
11 #include <errno.h>
12
13 EC_LOG_TYPE_REGISTER(malloc);
14
15 static int init_done = 0;
16
17 struct ec_malloc_handler ec_malloc_handler;
18
19 int ec_malloc_register(ec_malloc_t usr_malloc, ec_free_t usr_free,
20         ec_realloc_t usr_realloc)
21 {
22         if (usr_malloc == NULL || usr_free == NULL || usr_realloc == NULL) {
23                 errno = EINVAL;
24                 return -1;
25         }
26
27         if (init_done) {
28                 errno = EBUSY;
29                 return -1;
30         }
31
32         ec_malloc_handler.malloc = usr_malloc;
33         ec_malloc_handler.free = usr_free;
34         ec_malloc_handler.realloc = usr_realloc;
35
36         return 0;
37 }
38
39 void *__ec_malloc(size_t size, const char *file, unsigned int line)
40 {
41         return ec_malloc_handler.malloc(size, file, line);
42 }
43
44 void *ec_malloc_func(size_t size)
45 {
46         return __ec_malloc(size, __FILE__, __LINE__);
47 }
48
49 void __ec_free(void *ptr, const char *file, unsigned int line)
50 {
51         ec_malloc_handler.free(ptr, file, line);
52 }
53
54 void ec_free_func(void *ptr)
55 {
56         __ec_free(ptr, __FILE__, __LINE__);
57 }
58
59 void *__ec_calloc(size_t nmemb, size_t size, const char *file,
60         unsigned int line)
61 {
62         void *ptr;
63         size_t total;
64
65         /* check overflow */
66         total = size * nmemb;
67         if (nmemb != 0 && size != (total / nmemb)) {
68                 errno = ENOMEM;
69                 return NULL;
70         }
71
72         ptr = __ec_malloc(total, file, line);
73         if (ptr == NULL)
74                 return NULL;
75
76         memset(ptr, 0, total);
77         return ptr;
78 }
79
80 void *__ec_realloc(void *ptr, size_t size, const char *file, unsigned int line)
81 {
82         return ec_malloc_handler.realloc(ptr, size, file, line);
83 }
84
85 char *__ec_strdup(const char *s, const char *file, unsigned int line)
86 {
87         size_t sz = strlen(s) + 1;
88         char *s2;
89
90         s2 = __ec_malloc(sz, file, line);
91         if (s2 == NULL)
92                 return NULL;
93
94         memcpy(s2, s, sz);
95
96         return s2;
97 }
98
99 char *__ec_strndup(const char *s, size_t n, const char *file, unsigned int line)
100 {
101         size_t sz = strnlen(s, n);
102         char *s2;
103
104         s2 = __ec_malloc(sz + 1, file, line);
105         if (s2 == NULL)
106                 return NULL;
107
108         memcpy(s2, s, sz);
109         s2[sz] = '\0';
110
111         return s2;
112 }
113
114 static int ec_malloc_init_func(void)
115 {
116         init_done = 1;
117         return 0;
118 }
119
120 static struct ec_init ec_malloc_init = {
121         .init = ec_malloc_init_func,
122         .priority = 40,
123 };
124
125 EC_INIT_REGISTER(ec_malloc_init);
126
127 /* LCOV_EXCL_START */
128 static int ec_malloc_testcase(void)
129 {
130         int ret, testres = 0;
131         char *ptr, *ptr2;
132
133         ret = ec_malloc_register(NULL, NULL, NULL);
134         testres |= EC_TEST_CHECK(ret == -1,
135                 "should not be able to register NULL malloc handlers");
136         ret = ec_malloc_register(__ec_malloc, __ec_free, __ec_realloc);
137         testres |= EC_TEST_CHECK(ret == -1,
138                 "should not be able to register after init");
139
140         /* registration is tested in the test main.c */
141
142         ptr = ec_malloc(10);
143         if (ptr == NULL)
144                 return -1;
145         memset(ptr, 0, 10);
146         ptr2 = ec_realloc(ptr, 20);
147         EC_TEST_CHECK(ptr2 != NULL, "cannot realloc ptr\n");
148         if (ptr2 == NULL)
149                 ec_free(ptr);
150         else
151                 ec_free(ptr2);
152         ptr = NULL;
153         ptr2 = NULL;
154
155         ptr = ec_malloc_func(10);
156         if (ptr == NULL)
157                 return -1;
158         memset(ptr, 0, 10);
159         ec_free_func(ptr);
160         ptr = NULL;
161
162         ptr = ec_calloc(2, (size_t)-1);
163         EC_TEST_CHECK(ptr == NULL, "bad overflow check in ec_calloc\n");
164
165         return testres;
166 }
167 /* LCOV_EXCL_STOP */
168
169 static struct ec_test ec_malloc_test = {
170         .name = "malloc",
171         .test = ec_malloc_testcase,
172 };
173
174 EC_TEST_REGISTER(ec_malloc_test);