source: roaraudio/libroar/memmgr.c @ 4971:f5853509f5e3

Last change on this file since 4971:f5853509f5e3 was 4971:f5853509f5e3, checked in by phi, 13 years ago

Use a non-\0-char buffer for zero-size malloc guard segment

File size: 4.8 KB
Line 
1//memmgr.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2010-2011
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 *  NOTE for everyone want's to change something and send patches:
25 *  read README and HACKING! There a addition information on
26 *  the license of this document you need to read before you send
27 *  any patches.
28 *
29 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
30 *  or libpulse*:
31 *  The libs libroaresd, libroararts and libroarpulse link this lib
32 *  and are therefore GPL. Because of this it may be illigal to use
33 *  them with any software that uses libesd, libartsc or libpulse*.
34 */
35
36#include "libroar.h"
37
38#ifdef ROAR_USE_MEMMGR
39#define NULL_BUFFER_CONST "RoarAudio"
40static char _libroar_null_buffer[] = NULL_BUFFER_CONST; // A byte sequense >= 8 byte.
41#endif
42
43#define _err(x) do { roar_err_set((x)); return NULL; } while (0)
44
45#ifdef ROAR_USE_MEMMGR
46void * roar_mm_calloc(size_t nmemb, size_t size) {
47 void * ret;
48
49 if ( nmemb == 0 || size == 0 )
50  return _libroar_null_buffer;
51
52#ifdef ROAR_HAVE_CALLOC
53 roar_err_clear_all();
54 ret = calloc(nmemb, size);
55
56 if ( ret == NULL )
57  roar_err_update();
58
59 return ret;
60#else
61 ret = roar_mm_malloc(nmemb*size);
62 if ( ret == NULL )
63  return NULL;
64
65 memset(ret, 0, nmemb*size);
66
67 return ret;
68#endif
69}
70
71void * roar_mm_malloc(size_t size) {
72 void * ret;
73
74 if ( size == 0 )
75  return _libroar_null_buffer;
76
77#ifdef ROAR_HAVE_MALLOC
78 roar_err_clear_all();
79 ret = malloc(size);
80
81 if ( ret == NULL )
82  roar_err_update();
83
84 return ret;
85#elif defined(ROAR_HAVE_CALLOC)
86 return roar_mm_calloc(1, size);
87#elif defined(ROAR_HAVE_REALLOC)
88 return roar_mm_realloc(NULL, size);
89#else
90 _err(ROAR_ERROR_NOSYS);
91#endif
92}
93
94int    roar_mm_free(void *ptr) {
95 if ( ptr == _libroar_null_buffer )
96  return 0;
97
98#ifdef ROAR_HAVE_FREE
99 free(ptr);
100 return 0;
101#elif defined(ROAR_HAVE_REALLOC)
102 if ( roar_mm_realloc(ptr, 0) != _libroar_null_buffer )
103  return -1;
104 return 0;
105#else
106 roar_err_set(ROAR_ERROR_NOSYS);
107 return -1;
108#endif
109}
110
111void * roar_mm_realloc(void *ptr, size_t size) {
112#ifdef ROAR_HAVE_REALLOC
113 void * ret;
114#endif
115
116 if ( ptr == NULL )
117  return roar_mm_malloc(size);
118
119 if ( size == 0 ) {
120  roar_mm_free(ptr);
121  return _libroar_null_buffer;
122 }
123
124#ifdef ROAR_HAVE_REALLOC
125 roar_err_clear_all();
126 ret = realloc(ptr, size);
127
128 if ( ret == NULL )
129  roar_err_update();
130
131 return ret;
132#else
133 _err(ROAR_ERROR_NOTSUP);
134#endif
135}
136#endif
137
138void * roar_mm_memdup(const void * s, size_t len) {
139 void * ret;
140
141 if ( s == NULL )
142  _err(ROAR_ERROR_FAULT);
143
144 ret = roar_mm_malloc(len);
145
146 if ( ret == NULL )
147  return NULL;
148
149 memcpy(ret, s, len);
150
151 return ret;
152}
153
154#if defined(ROAR_USE_MEMMGR) || !defined(ROAR_HAVE_STRDUP)
155char * roar_mm_strdup(const char *s) {
156 void * ret;
157#ifndef ROAR_HAVE_STRDUP
158 ssize_t len;
159#endif
160
161 if ( s == NULL )
162  _err(ROAR_ERROR_FAULT);
163
164#ifdef ROAR_HAVE_STRDUP
165 roar_err_clear_all();
166 ret = strdup(s);
167
168 if ( ret == NULL )
169  roar_err_update();
170#else
171 len = roar_mm_strlen(s);
172 if ( len == -1 )
173  return NULL;
174
175 ret = roar_mm_memdup(s, len+1);
176#endif
177
178 return ret;
179}
180#endif
181
182#if defined(ROAR_USE_MEMMGR) || !defined(ROAR_HAVE_STRNDUP)
183char *roar_mm_strndup(const char *s, size_t n) {
184 void * ret;
185#ifndef ROAR_HAVE_STRDUP
186 ssize_t len;
187#endif
188
189 if ( s == NULL )
190  _err(ROAR_ERROR_FAULT);
191
192#ifdef ROAR_HAVE_STRDUP
193 roar_err_clear_all();
194 ret = strndup(s, n);
195
196 if ( ret == NULL )
197  roar_err_update();
198#else
199 len = roar_mm_strnlen(s, n);
200 if ( len == -1 )
201  return NULL;
202
203 ret = roar_mm_memdup(s, len+1);
204#endif
205
206 return ret;
207}
208#endif
209
210#ifndef ROAR_HAVE_STRLEN
211ssize_t roar_mm_strlen(const char *s) {
212 size_t ret = 0;
213
214 if ( s == NULL ) {
215  roar_err_set(ROAR_ERROR_FAULT);
216  return -1;
217 }
218
219 for (; *s != 0; s++, ret++);
220
221 return ret;
222}
223#endif
224
225ssize_t roar_mm_strnlen(const char *s, size_t maxlen) {
226 size_t ret = 0;
227
228 if ( s == NULL ) {
229  roar_err_set(ROAR_ERROR_FAULT);
230  return -1;
231 }
232
233#ifdef ROAR_HAVE_STRNLEN
234 ret = strnlen(s, maxlen);
235#else
236 for (; ret < maxlen && *s != 0; s++, ret++);
237#endif
238
239 if ( ret == maxlen ) {
240  roar_err_set(ROAR_ERROR_MSGSIZE);
241  return -1;
242 }
243
244 return ret;
245}
246
247//ll
Note: See TracBrowser for help on using the repository browser.