From d8ce7c6a2acbf371509a23775470e7614bcb6027 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Thu, 6 May 2004 04:40:15 +0000 Subject: r502: modified ldb to allow the use of an external pool memory allocator. The way to use this is to call ldb_set_alloc() with a function pointer to whatever memory allocator you like. It includes a context pointer to allow for pool based allocators. (This used to be commit 3955c482e6c2c9e975a4bb809ec8cb6068e48e34) --- source4/lib/ldb/common/ldb_alloc.c | 174 +++++++++++++++++++++++++++++++ source4/lib/ldb/common/ldb_ldif.c | 80 ++++++++------- source4/lib/ldb/common/ldb_msg.c | 13 ++- source4/lib/ldb/common/ldb_parse.c | 205 ++++++++++--------------------------- source4/lib/ldb/common/ldb_utf8.c | 4 +- source4/lib/ldb/common/util.c | 18 ---- 6 files changed, 284 insertions(+), 210 deletions(-) create mode 100644 source4/lib/ldb/common/ldb_alloc.c (limited to 'source4/lib/ldb/common') diff --git a/source4/lib/ldb/common/ldb_alloc.c b/source4/lib/ldb/common/ldb_alloc.c new file mode 100644 index 0000000000..667759e832 --- /dev/null +++ b/source4/lib/ldb/common/ldb_alloc.c @@ -0,0 +1,174 @@ +/* + ldb database library + + Copyright (C) Andrew Tridgell 2004 + + ** NOTE! The following LGPL license applies to the ldb + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +/* + * Name: ldb + * + * Component: ldb alloc + * + * Description: functions for memory allocation + * + * Author: Andrew Tridgell + */ + +#include "includes.h" + + +/* + this allows the user to choose their own allocation function +*/ +int ldb_set_alloc(struct ldb_context *ldb, + void *(*alloc)(void *context, void *ptr, size_t size), + void *context) +{ + ldb->alloc_ops.alloc = alloc; + ldb->alloc_ops.context = context; + return 0; +} + +/* + this is the default memory allocation function +*/ +static void *ldb_default_alloc(void *context, void *ptr, size_t size) +{ + /* by setting LDB_ALLOC_OFS to non-zero the test suite can + catch any places where we incorrectly use the libc alloc + funcitons directly */ +#define LDB_ALLOC_OFS 4 + /* we don't assume a modern realloc function */ + if (ptr == NULL) { + ptr = malloc(size+LDB_ALLOC_OFS); + if (ptr) return ((char *)ptr)+LDB_ALLOC_OFS; + return NULL; + } + if (size == 0) { + free(((char *)ptr)-LDB_ALLOC_OFS); + return NULL; + } + ptr = realloc(((char *)ptr)-LDB_ALLOC_OFS, size+LDB_ALLOC_OFS); + if (ptr) { + return ((char *)ptr)+LDB_ALLOC_OFS; + } + return NULL; +} + +/* + all memory allocation goes via this function +*/ +void *ldb_realloc(struct ldb_context *ldb, void *ptr, size_t size) +{ + if (!ldb->alloc_ops.alloc) { + ldb_set_alloc(ldb, ldb_default_alloc, NULL); + } + return ldb->alloc_ops.alloc(ldb->alloc_ops.context, ptr, size); +} + +void *ldb_malloc(struct ldb_context *ldb, size_t size) +{ + return ldb_realloc(ldb, NULL, size); +} + +void ldb_free(struct ldb_context *ldb, void *ptr) +{ + if (ptr != NULL) { + ldb_realloc(ldb, ptr, 0); + } +} + +void *ldb_strndup(struct ldb_context *ldb, const char *str, size_t maxlen) +{ + size_t len = strnlen(str, maxlen); + void *ret; + ret = ldb_realloc(ldb, NULL, len+1); + if (ret) { + memcpy(ret, str, len); + ((char *)ret)[len] = 0; + } + return ret; +} + +void *ldb_strdup(struct ldb_context *ldb, const char *str) +{ + size_t len = strlen(str); + void *ret; + ret = ldb_realloc(ldb, NULL, len+1); + if (ret) { + memcpy(ret, str, len+1); + } + return ret; +} + +/* + a ldb wrapper for asprintf(), using ldb_malloc() +*/ +int ldb_asprintf(struct ldb_context *ldb, char **strp, const char *fmt, ...) +{ + int len, len2; + va_list ap; + + *strp = NULL; + + va_start(ap, fmt); + len = vsnprintf(NULL, 0, fmt, ap); + va_end(ap); + if (len < 0) { + return len; + } + + *strp = ldb_malloc(ldb, len+1); + if (! *strp) { + return -1; + } + + va_start(ap, fmt); + len2 = vsnprintf(*strp, len+1, fmt, ap); + va_end(ap); + + if (len2 != len) { + /* buggy (or non-C99) vsnprintf function */ + ldb_free(ldb, *strp); + return -1; + } + + return len; +} + +/* + realloc an array, checking for integer overflow in the array size +*/ +void *ldb_realloc_array(struct ldb_context *ldb, + void *ptr, size_t el_size, unsigned count) +{ +#define MAX_MALLOC_SIZE 0x7fffffff + + if (count == 0 || + count >= MAX_MALLOC_SIZE/el_size) { + return NULL; + } + if (!ptr) { + return ldb_malloc(ldb, el_size * count); + } + return ldb_realloc(ldb, ptr, el_size * count); +} + diff --git a/source4/lib/ldb/common/ldb_ldif.c b/source4/lib/ldb/common/ldb_ldif.c index ef782e90e3..451276c48d 100644 --- a/source4/lib/ldb/common/ldb_ldif.c +++ b/source4/lib/ldb/common/ldb_ldif.c @@ -86,7 +86,7 @@ static int base64_decode(char *s) encode as base64 caller frees */ -char *ldb_base64_encode(const char *buf, int len) +char *ldb_base64_encode(struct ldb_context *ldb, const char *buf, int len) { const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; int bit_offset, byte_offset, idx, i; @@ -94,7 +94,7 @@ char *ldb_base64_encode(const char *buf, int len) int bytes = (len*8 + 5)/6; char *out; - out = malloc(bytes+2); + out = ldb_malloc(ldb, bytes+2); if (!out) return NULL; for (i=0;ielements[i].name); CHECK_RET; - ret = base64_encode_f(fprintf_fn, private_data, + ret = base64_encode_f(ldb, fprintf_fn, private_data, msg->elements[i].values[j].data, msg->elements[i].values[j].length, strlen(msg->elements[i].name)+3); @@ -282,7 +285,8 @@ int ldif_write(int (*fprintf_fn)(void *, const char *, ...), caller frees */ -static char *next_chunk(int (*fgetc_fn)(void *), void *private_data) +static char *next_chunk(struct ldb_context *ldb, + int (*fgetc_fn)(void *), void *private_data) { size_t alloc_size=0, chunk_size = 0; char *chunk = NULL; @@ -293,9 +297,9 @@ static char *next_chunk(int (*fgetc_fn)(void *), void *private_data) if (chunk_size+1 >= alloc_size) { char *c2; alloc_size += 1024; - c2 = realloc_p(chunk, char, alloc_size); + c2 = ldb_realloc_p(ldb, chunk, char, alloc_size); if (!c2) { - free(chunk); + ldb_free(ldb, chunk); errno = ENOMEM; return NULL; } @@ -402,27 +406,29 @@ static int next_attr(char **s, const char **attr, struct ldb_val *value) /* free a message from a ldif_read */ -void ldif_read_free(struct ldb_ldif *ldif) +void ldif_read_free(struct ldb_context *ldb, struct ldb_ldif *ldif) { struct ldb_message *msg = &ldif->msg; int i; for (i=0;inum_elements;i++) { - if (msg->elements[i].name) free(msg->elements[i].name); - if (msg->elements[i].values) free(msg->elements[i].values); + if (msg->elements[i].name) ldb_free(ldb, msg->elements[i].name); + if (msg->elements[i].values) ldb_free(ldb, msg->elements[i].values); } - if (msg->elements) free(msg->elements); - if (msg->private_data) free(msg->private_data); - free(ldif); + if (msg->elements) ldb_free(ldb, msg->elements); + if (msg->private_data) ldb_free(ldb, msg->private_data); + ldb_free(ldb, ldif); } /* add an empty element */ -static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned flags) +static int msg_add_empty(struct ldb_context *ldb, + struct ldb_message *msg, const char *name, unsigned flags) { struct ldb_message_element *el2, *el; - el2 = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1); + el2 = ldb_realloc_p(ldb, msg->elements, + struct ldb_message_element, msg->num_elements+1); if (!el2) { errno = ENOMEM; return -1; @@ -432,7 +438,7 @@ static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned fla el = &msg->elements[msg->num_elements]; - el->name = strdup(name); + el->name = ldb_strdup(ldb, name); el->num_values = 0; el->values = NULL; el->flags = flags; @@ -450,7 +456,8 @@ static int msg_add_empty(struct ldb_message *msg, const char *name, unsigned fla /* read from a LDIF source, creating a ldb_message */ -struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data) +struct ldb_ldif *ldif_read(struct ldb_context *ldb, + int (*fgetc_fn)(void *), void *private_data) { struct ldb_ldif *ldif; struct ldb_message *msg; @@ -461,7 +468,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data) value.data = NULL; - ldif = malloc_p(struct ldb_ldif); + ldif = ldb_malloc_p(ldb, struct ldb_ldif); if (!ldif) return NULL; ldif->changetype = LDB_CHANGETYPE_NONE; @@ -472,7 +479,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data) msg->num_elements = 0; msg->private_data = NULL; - chunk = next_chunk(fgetc_fn, private_data); + chunk = next_chunk(ldb, fgetc_fn, private_data); if (!chunk) { goto failed; } @@ -530,7 +537,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data) } if (empty) { - if (msg_add_empty(msg, (char *)value.data, flags) != 0) { + if (msg_add_empty(ldb, msg, (char *)value.data, flags) != 0) { goto failed; } continue; @@ -542,7 +549,8 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data) flags == el->flags) { /* its a continuation */ el->values = - realloc_p(el->values, struct ldb_val, el->num_values+1); + ldb_realloc_p(ldb, el->values, + struct ldb_val, el->num_values+1); if (!el->values) { goto failed; } @@ -550,16 +558,16 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data) el->num_values++; } else { /* its a new attribute */ - msg->elements = realloc_p(msg->elements, - struct ldb_message_element, - msg->num_elements+1); + msg->elements = ldb_realloc_p(ldb, msg->elements, + struct ldb_message_element, + msg->num_elements+1); if (!msg->elements) { goto failed; } el = &msg->elements[msg->num_elements]; el->flags = flags; - el->name = strdup(attr); - el->values = malloc_p(struct ldb_val); + el->name = ldb_strdup(ldb, attr); + el->values = ldb_malloc_p(ldb, struct ldb_val); if (!el->values || !el->name) { goto failed; } @@ -572,7 +580,7 @@ struct ldb_ldif *ldif_read(int (*fgetc_fn)(void *), void *private_data) return ldif; failed: - if (ldif) ldif_read_free(ldif); + if (ldif) ldif_read_free(ldb, ldif); return NULL; } @@ -591,11 +599,11 @@ static int fgetc_file(void *private_data) return fgetc(state->f); } -struct ldb_ldif *ldif_read_file(FILE *f) +struct ldb_ldif *ldif_read_file(struct ldb_context *ldb, FILE *f) { struct ldif_read_file_state state; state.f = f; - return ldif_read(fgetc_file, &state); + return ldif_read(ldb, fgetc_file, &state); } @@ -615,11 +623,11 @@ static int fgetc_string(void *private_data) return EOF; } -struct ldb_ldif *ldif_read_string(const char *s) +struct ldb_ldif *ldif_read_string(struct ldb_context *ldb, const char *s) { struct ldif_read_string_state state; state.s = s; - return ldif_read(fgetc_string, &state); + return ldif_read(ldb, fgetc_string, &state); } @@ -642,9 +650,9 @@ static int fprintf_file(void *private_data, const char *fmt, ...) return ret; } -int ldif_write_file(FILE *f, const struct ldb_ldif *ldif) +int ldif_write_file(struct ldb_context *ldb, FILE *f, const struct ldb_ldif *ldif) { struct ldif_write_file_state state; state.f = f; - return ldif_write(fprintf_file, &state, ldif); + return ldif_write(ldb, fprintf_file, &state, ldif); } diff --git a/source4/lib/ldb/common/ldb_msg.c b/source4/lib/ldb/common/ldb_msg.c index 8eb8a8c5ef..5976db81b6 100644 --- a/source4/lib/ldb/common/ldb_msg.c +++ b/source4/lib/ldb/common/ldb_msg.c @@ -87,11 +87,13 @@ struct ldb_val *ldb_msg_find_val(const struct ldb_message_element *el, /* add an empty element to a message */ -int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags) +int ldb_msg_add_empty(struct ldb_context *ldb, + struct ldb_message *msg, const char *attr_name, int flags) { struct ldb_message_element *els; - els = realloc_p(msg->elements, struct ldb_message_element, msg->num_elements+1); + els = ldb_realloc_p(ldb, msg->elements, + struct ldb_message_element, msg->num_elements+1); if (!els) { errno = ENOMEM; return -1; @@ -100,7 +102,7 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags) els[msg->num_elements].values = NULL; els[msg->num_elements].num_values = 0; els[msg->num_elements].flags = flags; - els[msg->num_elements].name = strdup(attr_name); + els[msg->num_elements].name = ldb_strdup(ldb, attr_name); if (!els[msg->num_elements].name) { return -1; } @@ -114,11 +116,12 @@ int ldb_msg_add_empty(struct ldb_message *msg, const char *attr_name, int flags) /* add an empty element to a message */ -int ldb_msg_add(struct ldb_message *msg, +int ldb_msg_add(struct ldb_context *ldb, + struct ldb_message *msg, const struct ldb_message_element *el, int flags) { - if (ldb_msg_add_empty(msg, el->name, flags) != 0) { + if (ldb_msg_add_empty(ldb, msg, el->name, flags) != 0) { return -1; } diff --git a/source4/lib/ldb/common/ldb_parse.c b/source4/lib/ldb/common/ldb_parse.c index 4f8d469e6c..75eb44fcc0 100644 --- a/source4/lib/ldb/common/ldb_parse.c +++ b/source4/lib/ldb/common/ldb_parse.c @@ -59,7 +59,7 @@ a filter is defined by: /* return next token element. Caller frees */ -static char *ldb_parse_lex(const char **s) +static char *ldb_parse_lex(struct ldb_context *ldb, const char **s) { const char *p = *s; char *ret; @@ -75,7 +75,7 @@ static char *ldb_parse_lex(const char **s) if (strchr("()&|=!", *p)) { (*s) = p+1; - ret = strndup(p, 1); + ret = ldb_strndup(ldb, p, 1); if (!ret) { errno = ENOMEM; } @@ -90,7 +90,7 @@ static char *ldb_parse_lex(const char **s) return NULL; } - ret = strndup(*s, p - *s); + ret = ldb_strndup(ldb, *s, p - *s); if (!ret) { errno = ENOMEM; } @@ -122,46 +122,42 @@ static const char *match_brace(const char *s) } -static struct ldb_parse_tree *ldb_parse_filter(const char **s); +static struct ldb_parse_tree *ldb_parse_filter(struct ldb_context *ldb, const char **s); /* ::= */ -static struct ldb_parse_tree *ldb_parse_simple(const char *s) +static struct ldb_parse_tree *ldb_parse_simple(struct ldb_context *ldb, const char *s) { char *eq, *val, *l; struct ldb_parse_tree *ret; - l = ldb_parse_lex(&s); + l = ldb_parse_lex(ldb, &s); if (!l) { - fprintf(stderr, "Unexpected end of expression\n"); return NULL; } if (strchr("()&|=", *l)) { - fprintf(stderr, "Unexpected token '%s'\n", l); - free(l); + ldb_free(ldb, l); return NULL; } - eq = ldb_parse_lex(&s); + eq = ldb_parse_lex(ldb, &s); if (!eq || strcmp(eq, "=") != 0) { - fprintf(stderr, "Expected '='\n"); - free(l); - if (eq) free(eq); + ldb_free(ldb, l); + if (eq) ldb_free(ldb, eq); return NULL; } - free(eq); + ldb_free(ldb, eq); - val = ldb_parse_lex(&s); + val = ldb_parse_lex(ldb, &s); if (val && strchr("()&|=", *val)) { - fprintf(stderr, "Unexpected token '%s'\n", val); - free(l); - if (val) free(val); + ldb_free(ldb, l); + if (val) ldb_free(ldb, val); return NULL; } - ret = malloc_p(struct ldb_parse_tree); + ret = ldb_malloc_p(ldb, struct ldb_parse_tree); if (!ret) { errno = ENOMEM; return NULL; @@ -182,11 +178,12 @@ static struct ldb_parse_tree *ldb_parse_simple(const char *s) ::= '|' ::= | */ -static struct ldb_parse_tree *ldb_parse_filterlist(enum ldb_parse_op op, const char *s) +static struct ldb_parse_tree *ldb_parse_filterlist(struct ldb_context *ldb, + enum ldb_parse_op op, const char *s) { struct ldb_parse_tree *ret, *next; - ret = malloc_p(struct ldb_parse_tree); + ret = ldb_malloc_p(ldb, struct ldb_parse_tree); if (!ret) { errno = ENOMEM; return NULL; @@ -194,31 +191,31 @@ static struct ldb_parse_tree *ldb_parse_filterlist(enum ldb_parse_op op, const c ret->operation = op; ret->u.list.num_elements = 1; - ret->u.list.elements = malloc_p(struct ldb_parse_tree *); + ret->u.list.elements = ldb_malloc_p(ldb, struct ldb_parse_tree *); if (!ret->u.list.elements) { errno = ENOMEM; - free(ret); + ldb_free(ldb, ret); return NULL; } - ret->u.list.elements[0] = ldb_parse_filter(&s); + ret->u.list.elements[0] = ldb_parse_filter(ldb, &s); if (!ret->u.list.elements[0]) { - free(ret->u.list.elements); - free(ret); + ldb_free(ldb, ret->u.list.elements); + ldb_free(ldb, ret); return NULL; } while (isspace(*s)) s++; - while (*s && (next = ldb_parse_filter(&s))) { + while (*s && (next = ldb_parse_filter(ldb, &s))) { struct ldb_parse_tree **e; - e = realloc_p(ret->u.list.elements, - struct ldb_parse_tree *, - ret->u.list.num_elements+1); + e = ldb_realloc_p(ldb, ret->u.list.elements, + struct ldb_parse_tree *, + ret->u.list.num_elements+1); if (!e) { errno = ENOMEM; - ldb_parse_tree_free(next); - ldb_parse_tree_free(ret); + ldb_parse_tree_free(ldb, next); + ldb_parse_tree_free(ldb, ret); return NULL; } ret->u.list.elements = e; @@ -234,20 +231,20 @@ static struct ldb_parse_tree *ldb_parse_filterlist(enum ldb_parse_op op, const c /* ::= '!' */ -static struct ldb_parse_tree *ldb_parse_not(const char *s) +static struct ldb_parse_tree *ldb_parse_not(struct ldb_context *ldb, const char *s) { struct ldb_parse_tree *ret; - ret = malloc_p(struct ldb_parse_tree); + ret = ldb_malloc_p(ldb, struct ldb_parse_tree); if (!ret) { errno = ENOMEM; return NULL; } ret->operation = LDB_OP_NOT; - ret->u.not.child = ldb_parse_filter(&s); + ret->u.not.child = ldb_parse_filter(ldb, &s); if (!ret->u.not.child) { - free(ret); + ldb_free(ldb, ret); return NULL; } @@ -258,67 +255,64 @@ static struct ldb_parse_tree *ldb_parse_not(const char *s) parse a filtercomp ::= | | | */ -static struct ldb_parse_tree *ldb_parse_filtercomp(const char *s) +static struct ldb_parse_tree *ldb_parse_filtercomp(struct ldb_context *ldb, + const char *s) { while (isspace(*s)) s++; switch (*s) { case '&': - return ldb_parse_filterlist(LDB_OP_AND, s+1); + return ldb_parse_filterlist(ldb, LDB_OP_AND, s+1); case '|': - return ldb_parse_filterlist(LDB_OP_OR, s+1); + return ldb_parse_filterlist(ldb, LDB_OP_OR, s+1); case '!': - return ldb_parse_not(s+1); + return ldb_parse_not(ldb, s+1); case '(': case ')': - fprintf(stderr, "Unexpected token '%c'\n", *s); return NULL; } - return ldb_parse_simple(s); + return ldb_parse_simple(ldb, s); } /* ::= '(' ')' */ -static struct ldb_parse_tree *ldb_parse_filter(const char **s) +static struct ldb_parse_tree *ldb_parse_filter(struct ldb_context *ldb, const char **s) { char *l, *s2; const char *p, *p2; struct ldb_parse_tree *ret; - l = ldb_parse_lex(s); + l = ldb_parse_lex(ldb, s); if (!l) { - fprintf(stderr, "Unexpected end of expression\n"); return NULL; } if (strcmp(l, "(") != 0) { - free(l); - fprintf(stderr, "Expected '('\n"); + ldb_free(ldb, l); return NULL; } - free(l); + ldb_free(ldb, l); p = match_brace(*s); if (!p) { - fprintf(stderr, "Parse error - mismatched braces\n"); return NULL; } p2 = p + 1; - s2 = strndup(*s, p - *s); + s2 = ldb_strndup(ldb, *s, p - *s); if (!s2) { errno = ENOMEM; return NULL; } - ret = ldb_parse_filtercomp(s2); - free(s2); + ret = ldb_parse_filtercomp(ldb, s2); + ldb_free(ldb, s2); *s = p2; @@ -331,130 +325,43 @@ static struct ldb_parse_tree *ldb_parse_filter(const char **s) expression ::= | */ -struct ldb_parse_tree *ldb_parse_tree(const char *s) +struct ldb_parse_tree *ldb_parse_tree(struct ldb_context *ldb, const char *s) { while (isspace(*s)) s++; if (*s == '(') { - return ldb_parse_filter(&s); + return ldb_parse_filter(ldb, &s); } - return ldb_parse_simple(s); + return ldb_parse_simple(ldb, s); } /* free a parse tree returned from ldb_parse_tree() */ -void ldb_parse_tree_free(struct ldb_parse_tree *tree) +void ldb_parse_tree_free(struct ldb_context *ldb, struct ldb_parse_tree *tree) { int i; switch (tree->operation) { case LDB_OP_SIMPLE: - free(tree->u.simple.attr); - if (tree->u.simple.value.data) free(tree->u.simple.value.data); + ldb_free(ldb, tree->u.simple.attr); + if (tree->u.simple.value.data) ldb_free(ldb, tree->u.simple.value.data); break; case LDB_OP_AND: case LDB_OP_OR: for (i=0;iu.list.num_elements;i++) { - ldb_parse_tree_free(tree->u.list.elements[i]); + ldb_parse_tree_free(ldb, tree->u.list.elements[i]); } - if (tree->u.list.elements) free(tree->u.list.elements); + if (tree->u.list.elements) ldb_free(ldb, tree->u.list.elements); break; case LDB_OP_NOT: - ldb_parse_tree_free(tree->u.not.child); + ldb_parse_tree_free(ldb, tree->u.not.child); break; } - free(tree); + ldb_free(ldb, tree); } -#if TEST_PROGRAM -/* - return a string representation of a parse tree - used for debugging -*/ -static char *tree_string(struct ldb_parse_tree *tree) -{ - char *s = NULL; - char *s1, *s2; - int i; - - switch (tree->operation) { - case LDB_OP_SIMPLE: - asprintf(&s, "( %s = \"%s\" )", tree->u.simple.attr, - (char *)tree->u.simple.value.data); - break; - - case LDB_OP_AND: - case LDB_OP_OR: - asprintf(&s, "( %c", tree->operation==LDB_OP_AND?'&':'|'); - if (!s) return NULL; - - for (i=0;iu.list.num_elements;i++) { - s1 = tree_string(tree->u.list.elements[i]); - if (!s1) { - free(s); - return NULL; - } - asprintf(&s2, "%s %s", s, s1); - free(s); - free(s1); - s = s2; - } - if (!s) { - return NULL; - } - asprintf(&s2, "%s )", s); - free(s); - s = s2; - break; - - case LDB_OP_NOT: - s1 = tree_string(tree->u.not.child); - asprintf(&s, "( ! %s )", s1); - free(s1); - break; - } - return s; -} - - -/* - print a tree - */ -static void print_tree(struct ldb_parse_tree *tree) -{ - char *s = tree_string(tree); - printf("%s\n", s); - free(s); -} - - - int main(void) -{ - char line[1000]; - int ret = 0; - - while (fgets(line, sizeof(line)-1, stdin)) { - struct ldb_parse_tree *tree; - - if (line[strlen(line)-1] == '\n') { - line[strlen(line)-1] = 0; - } - tree = ldb_parse_tree(line); - if (!tree) { - fprintf(stderr, "Failed to parse\n"); - ret = 1; - continue; - } - print_tree(tree); - ldb_parse_tree_free(tree); - } - - return ret; -} -#endif /* TEST_PROGRAM */ - diff --git a/source4/lib/ldb/common/ldb_utf8.c b/source4/lib/ldb/common/ldb_utf8.c index 7767b0955e..1e467d23af 100644 --- a/source4/lib/ldb/common/ldb_utf8.c +++ b/source4/lib/ldb/common/ldb_utf8.c @@ -38,10 +38,10 @@ TODO: a simple case folding function - will be replaced by a UTF8 aware function later */ -char *ldb_casefold(const char *s) +char *ldb_casefold(struct ldb_context *ldb, const char *s) { int i; - char *ret = strdup(s); + char *ret = ldb_strdup(ldb, s); if (!s) { errno = ENOMEM; return NULL; diff --git a/source4/lib/ldb/common/util.c b/source4/lib/ldb/common/util.c index 22bbc8334e..68537a7864 100644 --- a/source4/lib/ldb/common/util.c +++ b/source4/lib/ldb/common/util.c @@ -35,24 +35,6 @@ #include "includes.h" -#define MAX_MALLOC_SIZE 0x7fffffff - -/* - realloc an array, checking for integer overflow in the array size -*/ -void *realloc_array(void *ptr, size_t el_size, unsigned count) -{ - if (count == 0 || - count >= MAX_MALLOC_SIZE/el_size) { - return NULL; - } - if (!ptr) { - return malloc(el_size * count); - } - return realloc(ptr, el_size * count); -} - - /* find an element in a list, using the given comparison function and assuming that the list is already sorted using comp_fn -- cgit