r2792: got rid of talloc_ldb_alloc() and instead created talloc_realloc_fn(),
[bbaumbach/samba-autobuild/.git] / source4 / lib / ldb / common / ldb_alloc.c
1 /* 
2    ldb database library
3
4    Copyright (C) Andrew Tridgell  2004
5
6      ** NOTE! The following LGPL license applies to the ldb
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9    
10    This library is free software; you can redistribute it and/or
11    modify it under the terms of the GNU Lesser General Public
12    License as published by the Free Software Foundation; either
13    version 2 of the License, or (at your option) any later version.
14
15    This library is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18    Lesser General Public License for more details.
19
20    You should have received a copy of the GNU Lesser General Public
21    License along with this library; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23 */
24
25 /*
26  *  Name: ldb
27  *
28  *  Component: ldb alloc
29  *
30  *  Description: functions for memory allocation
31  *
32  *  Author: Andrew Tridgell
33  */
34
35 #include "includes.h"
36
37
38 /*
39   this allows the user to choose their own allocation function
40 */
41 int ldb_set_alloc(struct ldb_context *ldb,
42                   void *(*alloc)(const void *context, void *ptr, size_t size),
43                   void *context)
44 {
45         ldb->alloc_ops.alloc = alloc;
46         ldb->alloc_ops.context = context;
47         return 0;
48 }
49
50 /*
51   this is the default memory allocation function
52 */
53 static void *ldb_default_alloc(const void *context, void *ptr, size_t size)
54 {
55         /* by setting LDB_ALLOC_OFS to non-zero the test suite can
56            catch any places where we incorrectly use the libc alloc
57            funcitons directly */
58 #define LDB_ALLOC_OFS 4
59         /* we don't assume a modern realloc function */
60         if (ptr == NULL) {
61                 ptr = malloc(size+LDB_ALLOC_OFS);
62                 if (ptr) return ((char *)ptr)+LDB_ALLOC_OFS;
63                 return NULL;
64         }
65         if (size == 0) {
66                 free(((char *)ptr)-LDB_ALLOC_OFS);
67                 return NULL;
68         }
69         ptr = realloc(((char *)ptr)-LDB_ALLOC_OFS, size+LDB_ALLOC_OFS);
70         if (ptr) {
71                 return ((char *)ptr)+LDB_ALLOC_OFS;
72         }
73         return NULL;
74 }
75
76 /*
77   all memory allocation goes via this function
78 */
79 void *ldb_realloc(struct ldb_context *ldb, void *ptr, size_t size)
80 {
81         if (!ldb->alloc_ops.alloc) {
82                 ldb_set_alloc(ldb, ldb_default_alloc, NULL);
83         }
84         return ldb->alloc_ops.alloc(ldb->alloc_ops.context, ptr, size);
85 }
86
87 void *ldb_malloc(struct ldb_context *ldb, size_t size)
88 {
89         return ldb_realloc(ldb, NULL, size);
90 }
91
92 void ldb_free(struct ldb_context *ldb, void *ptr)
93 {
94         if (ptr != NULL) {
95                 ldb_realloc(ldb, ptr, 0);
96         }
97 }
98
99 void *ldb_strndup(struct ldb_context *ldb, const char *str, size_t maxlen)
100 {
101         size_t len = strnlen(str, maxlen);
102         void *ret;
103         ret = ldb_realloc(ldb, NULL, len+1);
104         if (ret) {
105                 memcpy(ret, str, len);
106                 ((char *)ret)[len] = 0;
107         }
108         return ret;
109 }
110
111 void *ldb_strdup(struct ldb_context *ldb, const char *str)
112 {
113         size_t len = strlen(str);
114         void *ret;
115         ret = ldb_realloc(ldb, NULL, len+1);
116         if (ret) {
117                 memcpy(ret, str, len+1);
118         }
119         return ret;
120 }
121
122 /*
123   a ldb wrapper for asprintf(), using ldb_malloc()
124 */
125 int ldb_asprintf(struct ldb_context *ldb, char **strp, const char *fmt, ...) _PRINTF_ATTRIBUTE(3, 4)
126 {
127         int len, len2;
128         va_list ap;
129         
130         *strp = NULL;
131
132         va_start(ap, fmt);
133         len = vsnprintf(NULL, 0, fmt, ap);
134         va_end(ap);
135         if (len < 0) {
136                 return len;
137         }
138
139         *strp = ldb_malloc(ldb, len+1);
140         if (! *strp) {
141                 return -1;
142         }
143
144         va_start(ap, fmt);
145         len2 = vsnprintf(*strp, len+1, fmt, ap);
146         va_end(ap);
147
148         if (len2 != len) {
149                 /* buggy (or non-C99) vsnprintf function */
150                 ldb_free(ldb, *strp);
151                 return -1;
152         }
153
154         return len;
155 }
156
157 /*
158   realloc an array, checking for integer overflow in the array size
159 */
160 void *ldb_realloc_array(struct ldb_context *ldb,
161                         void *ptr, size_t el_size, unsigned count)
162 {
163 #define MAX_MALLOC_SIZE 0x7fffffff
164
165         if (count == 0 ||
166             count >= MAX_MALLOC_SIZE/el_size) {
167                 return NULL;
168         }
169         if (!ptr) {
170                 return ldb_malloc(ldb, el_size * count);
171         }
172         return ldb_realloc(ldb, ptr, el_size * count);
173 }
174