sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-31 17:18:04 +03:00
Code

move genparser to use talloc contexts instead of [m|c|re]alloc() and free()s

Browse Source
This commit is contained in:
Simo Sorce 0001-01-01 00:00:00 +00:00
parent 5a472e2a3c
commit 70fce680c0
2 changed files with 163 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
source/lib/genparser.c
View File

@ -34,12 +34,12 @@ static int all_zero(const char *ptr, unsigned size)
} }
/* encode a buffer of bytes into a escaped string */ /* encode a buffer of bytes into a escaped string */
static char *encode_bytes(const char *ptr, unsigned len) static char *encode_bytes(TALLOC_CTX *mem_ctx, const char *ptr, unsigned len)
{ {
const char *hexdig = "0123456789abcdef"; const char *hexdig = "0123456789abcdef";
char *ret, *p; char *ret, *p;
unsigned i; unsigned i;
ret = malloc(len*3 + 1); /* worst case size */ ret = talloc(mem_ctx, len*3 + 1); /* worst case size */
if (!ret) return NULL; if (!ret) return NULL;
for (p=ret,i=0;i<len;i++) { for (p=ret,i=0;i<len;i++) {
if (isalnum(ptr[i]) || isspace(ptr[i]) || if (isalnum(ptr[i]) || isspace(ptr[i]) ||
@ -61,11 +61,16 @@ static char *encode_bytes(const char *ptr, unsigned len)
} }
/* decode an escaped string from encode_bytes() into a buffer */ /* decode an escaped string from encode_bytes() into a buffer */
static char *decode_bytes(const char *s, unsigned *len) static char *decode_bytes(TALLOC_CTX *mem_ctx, const char *s, unsigned *len)
{ {
char *ret, *p; char *ret, *p;
unsigned i; unsigned i;
ret = calloc(1, strlen(s)+1); /* worst case length */ int slen = strlen(s) + 1;
ret = talloc(mem_ctx, slen); /* worst case length */
if (!ret)
return NULL;
memset(ret, 0, slen);
if (*s == '{') s++; if (*s == '{') s++;
@ -75,7 +80,6 @@ static char *decode_bytes(const char *s, unsigned *len)
} else if (s[i] == '\\') { } else if (s[i] == '\\') {
unsigned v; unsigned v;
if (sscanf(&s[i+1], "%02x", &v) != 1 || v > 255) { if (sscanf(&s[i+1], "%02x", &v) != 1 || v > 255) {
free(ret);
return NULL; return NULL;
} }
*(unsigned char *)p = v; *(unsigned char *)p = v;
@ -96,11 +100,11 @@ static char *decode_bytes(const char *s, unsigned *len)
parse_string */ parse_string */
/* allocate more space if needed */ /* allocate more space if needed */
static int addgen_alloc(struct parse_string *p, int n) static int addgen_alloc(TALLOC_CTX *mem_ctx, struct parse_string *p, int n)
{ {
if (p->length + n <= p->allocated) return 0; if (p->length + n <= p->allocated) return 0;
p->allocated = p->length + n + 200; p->allocated = p->length + n + 200;
p->s = realloc(p->s, p->allocated); p->s = talloc_realloc(mem_ctx, p->s, p->allocated);
if (!p->s) { if (!p->s) {
errno = ENOMEM; errno = ENOMEM;
return -1; return -1;
@ -109,9 +113,9 @@ static int addgen_alloc(struct parse_string *p, int n)
} }
/* add a character to the buffer */ /* add a character to the buffer */
static int addchar(struct parse_string *p, char c) static int addchar(TALLOC_CTX *mem_ctx, struct parse_string *p, char c)
{ {
if (addgen_alloc(p, 2) != 0) { if (addgen_alloc(mem_ctx, p, 2) != 0) {
return -1; return -1;
} }
p->s[p->length++] = c; p->s[p->length++] = c;
@ -120,10 +124,10 @@ static int addchar(struct parse_string *p, char c)
} }
/* add a string to the buffer */ /* add a string to the buffer */
int addstr(struct parse_string *p, const char *s) int addstr(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *s)
{ {
int len = strlen(s); int len = strlen(s);
if (addgen_alloc(p, len+1) != 0) { if (addgen_alloc(mem_ctx, p, len+1) != 0) {
return -1; return -1;
} }
memcpy(p->s + p->length, s, len+1); memcpy(p->s + p->length, s, len+1);
@ -132,10 +136,10 @@ int addstr(struct parse_string *p, const char *s)
} }
/* add a string to the buffer with a tab prefix */ /* add a string to the buffer with a tab prefix */
static int addtabbed(struct parse_string *p, const char *s, unsigned indent) static int addtabbed(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *s, unsigned indent)
{ {
int len = strlen(s); int len = strlen(s);
if (addgen_alloc(p, indent+len+1) != 0) { if (addgen_alloc(mem_ctx, p, indent+len+1) != 0) {
return -1; return -1;
} }
while (indent--) { while (indent--) {
@ -147,7 +151,7 @@ static int addtabbed(struct parse_string *p, const char *s, unsigned indent)
} }
/* note! this can only be used for results up to 60 chars wide! */ /* note! this can only be used for results up to 60 chars wide! */
int addshort(struct parse_string *p, const char *fmt, ...) int addshort(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *fmt, ...)
{ {
char buf[60]; char buf[60];
int n; int n;
@ -155,7 +159,7 @@ int addshort(struct parse_string *p, const char *fmt, ...)
va_start(ap, fmt); va_start(ap, fmt);
n = vsnprintf(buf, sizeof(buf), fmt, ap); n = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap); va_end(ap);
if (addgen_alloc(p, n + 1) != 0) { if (addgen_alloc(mem_ctx, p, n + 1) != 0) {
return -1; return -1;
} }
if (n != 0) { if (n != 0) {
@ -170,7 +174,7 @@ int addshort(struct parse_string *p, const char *fmt, ...)
this is here to make it easier for people to write dump functions this is here to make it easier for people to write dump functions
for their own types for their own types
*/ */
int gen_addgen(struct parse_string *p, const char *fmt, ...) int gen_addgen(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *fmt, ...)
{ {
char *buf = NULL; char *buf = NULL;
int n; int n;
@ -178,7 +182,7 @@ int gen_addgen(struct parse_string *p, const char *fmt, ...)
va_start(ap, fmt); va_start(ap, fmt);
n = vasprintf(&buf, fmt, ap); n = vasprintf(&buf, fmt, ap);
va_end(ap); va_end(ap);
if (addgen_alloc(p, n + 1) != 0) { if (addgen_alloc(mem_ctx, p, n + 1) != 0) {
if (buf) free(buf); if (buf) free(buf);
return -1; return -1;
} }
@ -192,7 +196,8 @@ int gen_addgen(struct parse_string *p, const char *fmt, ...)
} }
/* dump a enumerated type */ /* dump a enumerated type */
int gen_dump_enum(const struct enum_struct *einfo, int gen_dump_enum(TALLOC_CTX *mem_ctx,
const struct enum_struct *einfo,
struct parse_string *p, struct parse_string *p,
const char *ptr, const char *ptr,
unsigned indent) unsigned indent)
@ -201,36 +206,37 @@ int gen_dump_enum(const struct enum_struct *einfo,
int i; int i;
for (i=0;einfo[i].name;i++) { for (i=0;einfo[i].name;i++) {
if (v == einfo[i].value) { if (v == einfo[i].value) {
addstr(p, einfo[i].name); addstr(mem_ctx, p, einfo[i].name);
return 0; return 0;
} }
} }
/* hmm, maybe we should just fail? */ /* hmm, maybe we should just fail? */
return gen_dump_unsigned(p, ptr, indent); return gen_dump_unsigned(mem_ctx, p, ptr, indent);
} }
/* dump a single non-array element, hanlding struct and enum */ /* dump a single non-array element, hanlding struct and enum */
static int gen_dump_one(struct parse_string *p, static int gen_dump_one(TALLOC_CTX *mem_ctx,
const struct parse_struct *pinfo, struct parse_string *p,
const char *ptr, const struct parse_struct *pinfo,
unsigned indent) const char *ptr,
unsigned indent)
{ {
if (pinfo->dump_fn == gen_dump_char && pinfo->ptr_count == 1) { if (pinfo->dump_fn == gen_dump_char && pinfo->ptr_count == 1) {
char *s = encode_bytes(ptr, strlen(ptr)); char *s = encode_bytes(mem_ctx, ptr, strlen(ptr));
if (addchar(p,'{') || if (addchar(mem_ctx, p,'{') ||
addstr(p, s) || addstr(mem_ctx, p, s) ||
addstr(p, "}")) { addstr(mem_ctx, p, "}")) {
free(s);
return -1; return -1;
} }
return 0; return 0;
} }
return pinfo->dump_fn(p, ptr, indent); return pinfo->dump_fn(mem_ctx, p, ptr, indent);
} }
/* handle dumping of an array of arbitrary type */ /* handle dumping of an array of arbitrary type */
static int gen_dump_array(struct parse_string *p, static int gen_dump_array(TALLOC_CTX *mem_ctx,
struct parse_string *p,
const struct parse_struct *pinfo, const struct parse_struct *pinfo,
const char *ptr, const char *ptr,
int array_len, int array_len,
@ -242,13 +248,12 @@ static int gen_dump_array(struct parse_string *p,
if (array_len != 0 && if (array_len != 0 &&
pinfo->ptr_count == 0 && pinfo->ptr_count == 0 &&
pinfo->dump_fn == gen_dump_char) { pinfo->dump_fn == gen_dump_char) {
char *s = encode_bytes(ptr, array_len); char *s = encode_bytes(mem_ctx, ptr, array_len);
if (!s) return -1; if (!s) return -1;
if (addtabbed(p, pinfo->name, indent) || if (addtabbed(mem_ctx, p, pinfo->name, indent) ||
addstr(p, " = {") || addstr(mem_ctx, p, " = {") ||
addstr(p, s) || addstr(mem_ctx, p, s) ||
addstr(p, "}\n")) { addstr(mem_ctx, p, "}\n")) {
free(s);
return -1; return -1;
} }
free(s); free(s);
@ -272,23 +277,23 @@ static int gen_dump_array(struct parse_string *p,
continue; continue;
} }
if (count == 0) { if (count == 0) {
if (addtabbed(p, pinfo->name, indent) || if (addtabbed(mem_ctx, p, pinfo->name, indent) ||
addshort(p, " = %u:", i)) { addshort(mem_ctx, p, " = %u:", i)) {
return -1; return -1;
} }
} else { } else {
if (addshort(p, ", %u:", i) != 0) { if (addshort(mem_ctx, p, ", %u:", i) != 0) {
return -1; return -1;
} }
} }
if (gen_dump_one(p, pinfo, p2, indent) != 0) { if (gen_dump_one(mem_ctx, p, pinfo, p2, indent) != 0) {
return -1; return -1;
} }
ptr += size; ptr += size;
count++; count++;
} }
if (count) { if (count) {
return addstr(p, "\n"); return addstr(mem_ctx, p, "\n");
} }
return 0; return 0;
} }
@ -325,36 +330,35 @@ static int find_var(const struct parse_struct *pinfo,
} }
int gen_dump_struct(const struct parse_struct *pinfo, int gen_dump_struct(TALLOC_CTX *mem_ctx,
const struct parse_struct *pinfo,
struct parse_string *p, struct parse_string *p,
const char *ptr, const char *ptr,
unsigned indent) unsigned indent)
{ {
char *s = gen_dump(pinfo, ptr, indent+1); char *s = gen_dump(mem_ctx, pinfo, ptr, indent+1);
if (!s) return -1; if (!s) return -1;
if (addstr(p, "{\n") || if (addstr(mem_ctx, p, "{\n") ||
addstr(p,s) || addstr(mem_ctx, p, s) ||
addtabbed(p,"}", indent)) { addtabbed(mem_ctx, p, "}", indent)) {
free(s);
return -1; return -1;
} }
free(s);
return 0; return 0;
} }
static int gen_dump_string(struct parse_string *p, static int gen_dump_string(TALLOC_CTX *mem_ctx,
struct parse_string *p,
const struct parse_struct *pinfo, const struct parse_struct *pinfo,
const char *data, const char *data,
unsigned indent) unsigned indent)
{ {
const char *ptr = *(char **)data; const char *ptr = *(char **)data;
char *s = encode_bytes(ptr, strlen(ptr)); char *s = encode_bytes(mem_ctx, ptr, strlen(ptr));
if (addtabbed(p, pinfo->name, indent) || if (addtabbed(mem_ctx, p, pinfo->name, indent) ||
addstr(p, " = ") || addstr(mem_ctx, p, " = ") ||
addchar(p,'{') || addchar(mem_ctx, p, '{') ||
addstr(p, s) || addstr(mem_ctx, p, s) ||
addstr(p, "}\n")) { addstr(mem_ctx, p, "}\n")) {
free(s);
return -1; return -1;
} }
return 0; return 0;
@ -370,7 +374,7 @@ static int len_nullterm(const char *ptr, int size, int array_len)
if (size == 1) { if (size == 1) {
len = strnlen(ptr, array_len); len = strnlen(ptr, array_len);
} else { } else {
for (len=0;len<array_len;len++) { for (len=0; len < array_len; len++) {
if (all_zero(ptr+len*size, size)) break; if (all_zero(ptr+len*size, size)) break;
} }
} }
@ -383,7 +387,8 @@ static int len_nullterm(const char *ptr, int size, int array_len)
/* the generic dump routine. Scans the parse information for this structure /* the generic dump routine. Scans the parse information for this structure
and processes it recursively */ and processes it recursively */
char *gen_dump(const struct parse_struct *pinfo, char *gen_dump(TALLOC_CTX *mem_ctx,
const struct parse_struct *pinfo,
const char *data, const char *data,
unsigned indent) unsigned indent)
{ {
@ -394,7 +399,7 @@ char *gen_dump(const struct parse_struct *pinfo,
p.allocated = 0; p.allocated = 0;
p.s = NULL; p.s = NULL;
if (addstr(&p, "") != 0) { if (addstr(mem_ctx, &p, "") != 0) {
return NULL; return NULL;
} }
@ -412,7 +417,7 @@ char *gen_dump(const struct parse_struct *pinfo,
if (pinfo[i].flags & FLAG_NULLTERM) { if (pinfo[i].flags & FLAG_NULLTERM) {
len = len_nullterm(ptr, size, len); len = len_nullterm(ptr, size, len);
} }
if (gen_dump_array(&p, &pinfo[i], ptr, if (gen_dump_array(mem_ctx, &p, &pinfo[i], ptr,
len, indent)) { len, indent)) {
goto failed; goto failed;
} }
@ -433,7 +438,8 @@ char *gen_dump(const struct parse_struct *pinfo,
} }
p2.ptr_count--; p2.ptr_count--;
p2.dynamic_len = NULL; p2.dynamic_len = NULL;
if (gen_dump_array(&p, &p2, *(char **)ptr, if (gen_dump_array(mem_ctx, &p, &p2,
*(char **)ptr,
len, indent) != 0) { len, indent) != 0) {
goto failed; goto failed;
} }
@ -447,7 +453,7 @@ char *gen_dump(const struct parse_struct *pinfo,
/* assume char* is a null terminated string */ /* assume char* is a null terminated string */
if (pinfo[i].size == 1 && pinfo[i].ptr_count == 1 && if (pinfo[i].size == 1 && pinfo[i].ptr_count == 1 &&
pinfo[i].dump_fn == gen_dump_char) { pinfo[i].dump_fn == gen_dump_char) {
if (gen_dump_string(&p, &pinfo[i], ptr, indent) != 0) { if (gen_dump_string(mem_ctx, &p, &pinfo[i], ptr, indent) != 0) {
goto failed; goto failed;
} }
continue; continue;
@ -458,17 +464,16 @@ char *gen_dump(const struct parse_struct *pinfo,
ptr = *(const char **)ptr; ptr = *(const char **)ptr;
} }
if (addtabbed(&p, pinfo[i].name, indent) || if (addtabbed(mem_ctx, &p, pinfo[i].name, indent) ||
addstr(&p, " = ") || addstr(mem_ctx, &p, " = ") ||
gen_dump_one(&p, &pinfo[i], ptr, indent) || gen_dump_one(mem_ctx, &p, &pinfo[i], ptr, indent) ||
addstr(&p, "\n")) { addstr(mem_ctx, &p, "\n")) {
goto failed; goto failed;
} }
} }
return p.s; return p.s;
failed: failed:
free(p.s);
return NULL; return NULL;
} }
@ -495,7 +500,8 @@ static char *match_braces(char *s, char c)
} }
/* parse routine for enumerated types */ /* parse routine for enumerated types */
int gen_parse_enum(const struct enum_struct *einfo, int gen_parse_enum(TALLOC_CTX *mem_ctx,
const struct enum_struct *einfo,
char *ptr, char *ptr,
const char *str) const char *str)
{ {
@ -524,37 +530,41 @@ int gen_parse_enum(const struct enum_struct *einfo,
/* parse all base types */ /* parse all base types */
static int gen_parse_base(const struct parse_struct *pinfo, static int gen_parse_base(TALLOC_CTX *mem_ctx,
const struct parse_struct *pinfo,
char *ptr, char *ptr,
const char *str) const char *str)
{ {
if (pinfo->parse_fn == gen_parse_char && pinfo->ptr_count==1) { if (pinfo->parse_fn == gen_parse_char && pinfo->ptr_count==1) {
unsigned len; unsigned len;
char *s = decode_bytes(str, &len); char *s = decode_bytes(mem_ctx, str, &len);
if (!s) return -1; if (!s) return -1;
*(char **)ptr = s; *(char **)ptr = s;
return 0; return 0;
} }
if (pinfo->ptr_count) { if (pinfo->ptr_count) {
unsigned size = pinfo->ptr_count>1?sizeof(void *):pinfo->size;
struct parse_struct p2 = *pinfo; struct parse_struct p2 = *pinfo;
*(void **)ptr = calloc(1, pinfo->ptr_count>1?sizeof(void *):pinfo->size); *(void **)ptr = talloc(mem_ctx, size);
if (! *(void **)ptr) { if (! *(void **)ptr) {
return -1; return -1;
} }
memset(*(void **)ptr, 0, size);
ptr = *(char **)ptr; ptr = *(char **)ptr;
p2.ptr_count--; p2.ptr_count--;
return gen_parse_base(&p2, ptr, str); return gen_parse_base(mem_ctx, &p2, ptr, str);
} }
return pinfo->parse_fn(ptr, str); return pinfo->parse_fn(mem_ctx, ptr, str);
} }
/* parse a generic array */ /* parse a generic array */
static int gen_parse_array(const struct parse_struct *pinfo, static int gen_parse_array(TALLOC_CTX *mem_ctx,
char *ptr, const struct parse_struct *pinfo,
const char *str, char *ptr,
int array_len) const char *str,
int array_len)
{ {
char *p, *p2; char *p, *p2;
unsigned size = pinfo->size; unsigned size = pinfo->size;
@ -564,11 +574,10 @@ static int gen_parse_array(const struct parse_struct *pinfo,
pinfo->ptr_count == 0 && pinfo->ptr_count == 0 &&
pinfo->dump_fn == gen_dump_char) { pinfo->dump_fn == gen_dump_char) {
unsigned len = 0; unsigned len = 0;
char *s = decode_bytes(str, &len); char *s = decode_bytes(mem_ctx, str, &len);
if (!s) return -1; if (!s || (len > array_len)) return -1;
memset(ptr, 0, array_len); memset(ptr, 0, array_len);
memcpy(ptr, s, len); memcpy(ptr, s, len);
free(s);
return 0; return 0;
} }
@ -593,7 +602,7 @@ static int gen_parse_array(const struct parse_struct *pinfo,
p[strlen(p)-1] = 0; p[strlen(p)-1] = 0;
} }
if (gen_parse_base(pinfo, ptr + idx*size, p) != 0) { if (gen_parse_base(mem_ctx, pinfo, ptr + idx*size, p) != 0) {
return -1; return -1;
} }
@ -605,7 +614,8 @@ static int gen_parse_array(const struct parse_struct *pinfo,
} }
/* parse one element, hanlding dynamic and static arrays */ /* parse one element, hanlding dynamic and static arrays */
static int gen_parse_one(const struct parse_struct *pinfo, static int gen_parse_one(TALLOC_CTX *mem_ctx,
const struct parse_struct *pinfo,
const char *name, const char *name,
char *data, char *data,
const char *str) const char *str)
@ -621,7 +631,8 @@ static int gen_parse_one(const struct parse_struct *pinfo,
} }
if (pinfo[i].array_len) { if (pinfo[i].array_len) {
return gen_parse_array(&pinfo[i], data+pinfo[i].offset, return gen_parse_array(mem_ctx, &pinfo[i],
data+pinfo[i].offset,
str, pinfo[i].array_len); str, pinfo[i].array_len);
} }
@ -632,33 +643,33 @@ static int gen_parse_one(const struct parse_struct *pinfo,
return -1; return -1;
} }
if (len > 0) { if (len > 0) {
unsigned size;
struct parse_struct p2 = pinfo[i]; struct parse_struct p2 = pinfo[i];
char *ptr; char *ptr;
size = pinfo[i].ptr_count>1?sizeof(void*):pinfo[i].size; unsigned size = pinfo[i].ptr_count>1?sizeof(void*):pinfo[i].size;
ptr = calloc(len, size); ptr = talloc(mem_ctx, len*size);
if (!ptr) { if (!ptr) {
errno = ENOMEM; errno = ENOMEM;
return -1; return -1;
} }
memset(ptr, 0, len*size);
*((char **)(data + pinfo[i].offset)) = ptr; *((char **)(data + pinfo[i].offset)) = ptr;
p2.ptr_count--; p2.ptr_count--;
p2.dynamic_len = NULL; p2.dynamic_len = NULL;
return gen_parse_array(&p2, ptr, str, len); return gen_parse_array(mem_ctx, &p2, ptr, str, len);
} }
return 0; return 0;
} }
return gen_parse_base(&pinfo[i], data + pinfo[i].offset, str); return gen_parse_base(mem_ctx, &pinfo[i], data + pinfo[i].offset, str);
} }
int gen_parse_struct(const struct parse_struct *pinfo, char *ptr, const char *str) int gen_parse_struct(TALLOC_CTX * mem_ctx, const struct parse_struct *pinfo, char *ptr, const char *str)
{ {
return gen_parse(pinfo, ptr, str); return gen_parse(mem_ctx, pinfo, ptr, str);
} }
/* the main parse routine */ /* the main parse routine */
int gen_parse(const struct parse_struct *pinfo, char *data, const char *s) int gen_parse(TALLOC_CTX *mem_ctx, const struct parse_struct *pinfo, char *data, const char *s)
{ {
char *str, *s0; char *str, *s0;
@ -694,7 +705,7 @@ int gen_parse(const struct parse_struct *pinfo, char *data, const char *s)
*str++ = 0; *str++ = 0;
if (gen_parse_one(pinfo, name, data, value) != 0) { if (gen_parse_one(mem_ctx, pinfo, name, data, value) != 0) {
free(s0); free(s0);
return -1; return -1;
} }
@ -708,68 +719,68 @@ int gen_parse(const struct parse_struct *pinfo, char *data, const char *s)
/* for convenience supply some standard dumpers and parsers here */ /* for convenience supply some standard dumpers and parsers here */
int gen_parse_char(char *ptr, const char *str) int gen_parse_char(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(unsigned char *)ptr = atoi(str); *(unsigned char *)ptr = atoi(str);
return 0; return 0;
} }
int gen_parse_int(char *ptr, const char *str) int gen_parse_int(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(int *)ptr = atoi(str); *(int *)ptr = atoi(str);
return 0; return 0;
} }
int gen_parse_unsigned(char *ptr, const char *str) int gen_parse_unsigned(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(unsigned *)ptr = strtoul(str, NULL, 10); *(unsigned *)ptr = strtoul(str, NULL, 10);
return 0; return 0;
} }
int gen_parse_time_t(char *ptr, const char *str) int gen_parse_time_t(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(time_t *)ptr = strtoul(str, NULL, 10); *(time_t *)ptr = strtoul(str, NULL, 10);
return 0; return 0;
} }
int gen_parse_double(char *ptr, const char *str) int gen_parse_double(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(double *)ptr = atof(str); *(double *)ptr = atof(str);
return 0; return 0;
} }
int gen_parse_float(char *ptr, const char *str) int gen_parse_float(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(float *)ptr = atof(str); *(float *)ptr = atof(str);
return 0; return 0;
} }
int gen_dump_char(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_char(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%u", *(unsigned char *)(ptr)); return addshort(mem_ctx, p, "%u", *(unsigned char *)(ptr));
} }
int gen_dump_int(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_int(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%d", *(int *)(ptr)); return addshort(mem_ctx, p, "%d", *(int *)(ptr));
} }
int gen_dump_unsigned(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_unsigned(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%u", *(unsigned *)(ptr)); return addshort(mem_ctx, p, "%u", *(unsigned *)(ptr));
} }
int gen_dump_time_t(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_time_t(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%u", *(time_t *)(ptr)); return addshort(mem_ctx, p, "%u", *(time_t *)(ptr));
} }
int gen_dump_double(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_double(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%lg", *(double *)(ptr)); return addshort(mem_ctx, p, "%lg", *(double *)(ptr));
} }
int gen_dump_float(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_float(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%g", *(float *)(ptr)); return addshort(mem_ctx, p, "%g", *(float *)(ptr));
} }

82
source/lib/genparser_samba.c
View File

@ -22,25 +22,25 @@
/* PARSE functions */ /* PARSE functions */
int gen_parse_uint8(char *ptr, const char *str) int gen_parse_uint8(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(uint8 *)ptr = atoi(str); *(uint8 *)ptr = atoi(str);
return 0; return 0;
} }
int gen_parse_uint16(char *ptr, const char *str) int gen_parse_uint16(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(uint16 *)ptr = atoi(str); *(uint16 *)ptr = atoi(str);
return 0; return 0;
} }
int gen_parse_uint32(char *ptr, const char *str) int gen_parse_uint32(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
*(uint32 *)ptr = strtoul(str, NULL, 10); *(uint32 *)ptr = strtoul(str, NULL, 10);
return 0; return 0;
} }
int gen_parse_NTTIME(char *ptr, const char *str) int gen_parse_NTTIME(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
if(sscanf(str, "%u,%u", &(((NTTIME *)(ptr))->high), &(((NTTIME *)(ptr))->low)) != 2) { if(sscanf(str, "%u,%u", &(((NTTIME *)(ptr))->high), &(((NTTIME *)(ptr))->low)) != 2) {
errno = EINVAL; errno = EINVAL;
@ -49,19 +49,19 @@ int gen_parse_NTTIME(char *ptr, const char *str)
return 0; return 0;
} }
int gen_parse_DOM_SID(char *ptr, const char *str) int gen_parse_DOM_SID(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
if(!string_to_sid((DOM_SID *)ptr, str)) return -1; if(!string_to_sid((DOM_SID *)ptr, str)) return -1;
return 0; return 0;
} }
int gen_parse_SEC_ACCESS(char *ptr, const char *str) int gen_parse_SEC_ACCESS(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
((SEC_ACCESS *)ptr)->mask = strtoul(str, NULL, 10); ((SEC_ACCESS *)ptr)->mask = strtoul(str, NULL, 10);
return 0; return 0;
} }
int gen_parse_GUID(char *ptr, const char *str) int gen_parse_GUID(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
int info[GUID_SIZE]; int info[GUID_SIZE];
int i; int i;
@ -89,27 +89,27 @@ int gen_parse_GUID(char *ptr, const char *str)
return 0; return 0;
} }
int gen_parse_SEC_ACE(char *ptr, const char *str) int gen_parse_SEC_ACE(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
return gen_parse_struct(pinfo_security_ace_info, ptr, str); return gen_parse_struct(mem_ctx, pinfo_security_ace_info, ptr, str);
} }
int gen_parse_SEC_ACL(char *ptr, const char *str) int gen_parse_SEC_ACL(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
return gen_parse_struct(pinfo_security_acl_info, ptr, str); return gen_parse_struct(mem_ctx, pinfo_security_acl_info, ptr, str);
} }
int gen_parse_SEC_DESC(char *ptr, const char *str) int gen_parse_SEC_DESC(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
return gen_parse_struct(pinfo_security_descriptor_info, ptr, str); return gen_parse_struct(mem_ctx, pinfo_security_descriptor_info, ptr, str);
} }
int gen_parse_LUID_ATTR(char *ptr, const char *str) int gen_parse_LUID_ATTR(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
return gen_parse_struct(pinfo_luid_attr_info, ptr, str); return gen_parse_struct(mem_ctx, pinfo_luid_attr_info, ptr, str);
} }
int gen_parse_LUID(char *ptr, const char *str) int gen_parse_LUID(TALLOC_CTX *mem_ctx, char *ptr, const char *str)
{ {
if(sscanf(str, "%u,%u", &(((LUID *)(ptr))->high), &(((LUID *)(ptr))->low)) != 2) { if(sscanf(str, "%u,%u", &(((LUID *)(ptr))->high), &(((LUID *)(ptr))->low)) != 2) {
errno = EINVAL; errno = EINVAL;
@ -122,79 +122,79 @@ int gen_parse_LUID(char *ptr, const char *str)
/* DUMP functions */ /* DUMP functions */
int gen_dump_uint8(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_uint8(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%u", *(uint8 *)(ptr)); return addshort(mem_ctx, p, "%u", *(uint8 *)(ptr));
} }
int gen_dump_uint16(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_uint16(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%u", *(uint16 *)(ptr)); return addshort(mem_ctx, p, "%u", *(uint16 *)(ptr));
} }
int gen_dump_uint32(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_uint32(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%u", *(uint32 *)(ptr)); return addshort(mem_ctx, p, "%u", *(uint32 *)(ptr));
} }
int gen_dump_NTTIME(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_NTTIME(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
uint32 low, high; uint32 low, high;
high = ((NTTIME *)(ptr))->high; high = ((NTTIME *)(ptr))->high;
low = ((NTTIME *)(ptr))->low; low = ((NTTIME *)(ptr))->low;
return addshort(p, "%u,%u", high, low); return addshort(mem_ctx, p, "%u,%u", high, low);
} }
int gen_dump_DOM_SID(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_DOM_SID(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
fstring sidstr; fstring sidstr;
sid_to_string(sidstr, (DOM_SID *)ptr); sid_to_string(sidstr, (DOM_SID *)ptr);
return addstr(p, sidstr); return addstr(mem_ctx, p, sidstr);
} }
int gen_dump_SEC_ACCESS(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_SEC_ACCESS(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return addshort(p, "%u", ((SEC_ACCESS *)ptr)->mask); return addshort(mem_ctx, p, "%u", ((SEC_ACCESS *)ptr)->mask);
} }
int gen_dump_GUID(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_GUID(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
int i, r; int i, r;
for (i = 0; i < (GUID_SIZE - 1); i++) { for (i = 0; i < (GUID_SIZE - 1); i++) {
if (!(r = addshort(p, "%d,", ((GUID *)ptr)->info[i]))) return r; if (!(r = addshort(mem_ctx, p, "%d,", ((GUID *)ptr)->info[i]))) return r;
} }
return addshort(p, "%d", ((GUID *)ptr)->info[i]); return addshort(mem_ctx, p, "%d", ((GUID *)ptr)->info[i]);
} }
int gen_dump_SEC_ACE(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_SEC_ACE(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return gen_dump_struct(pinfo_security_ace_info, p, ptr, indent); return gen_dump_struct(mem_ctx, pinfo_security_ace_info, p, ptr, indent);
} }
int gen_dump_SEC_ACL(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_SEC_ACL(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return gen_dump_struct(pinfo_security_acl_info, p, ptr, indent); return gen_dump_struct(mem_ctx, pinfo_security_acl_info, p, ptr, indent);
} }
int gen_dump_SEC_DESC(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_SEC_DESC(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return gen_dump_struct(pinfo_security_descriptor_info, p, ptr, indent); return gen_dump_struct(mem_ctx, pinfo_security_descriptor_info, p, ptr, indent);
} }
int gen_dump_LUID_ATTR(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_LUID_ATTR(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
return gen_dump_struct(pinfo_luid_attr_info, p, ptr, indent); return gen_dump_struct(mem_ctx, pinfo_luid_attr_info, p, ptr, indent);
} }
int gen_dump_LUID(struct parse_string *p, const char *ptr, unsigned indent) int gen_dump_LUID(TALLOC_CTX *mem_ctx, struct parse_string *p, const char *ptr, unsigned indent)
{ {
uint32 low, high; uint32 low, high;
high = ((LUID *)(ptr))->high; high = ((LUID *)(ptr))->high;
low = ((LUID *)(ptr))->low; low = ((LUID *)(ptr))->low;
return addshort(p, "%u,%u", high, low); return addshort(mem_ctx, p, "%u,%u", high, low);
} }