int num_lines, i;
char *msgid, *msgstr;
TDB_DATA key, data;
+ TALLOC_CTX *tmp_ctx = talloc_new(NULL);
- lines = file_lines_load(msg_file, &num_lines);
+ lines = file_lines_load(msg_file, &num_lines, tmp_ctx);
if (!lines) {
+ talloc_free(tmp_ctx);
return False;
}
- if (tdb_lockall(tdb) != 0) return False;
+ if (tdb_lockall(tdb) != 0) {
+ talloc_free(tmp_ctx);
+ return False;
+ }
/* wipe the db */
tdb_traverse(tdb, tdb_traverse_delete_fn, NULL);
}
}
- file_lines_free(lines);
+ talloc_free(tmp_ctx);
tdb_unlockall(tdb);
return True;
load a file into memory from a fd.
****************************************************************************/
-char *fd_load(int fd, size_t *size)
+char *fd_load(int fd, size_t *size, TALLOC_CTX *mem_ctx)
{
struct stat sbuf;
char *p;
if (fstat(fd, &sbuf) != 0) return NULL;
- p = (char *)malloc(sbuf.st_size+1);
+ p = (char *)talloc_size(mem_ctx, sbuf.st_size+1);
if (!p) return NULL;
if (read(fd, p, sbuf.st_size) != sbuf.st_size) {
- SAFE_FREE(p);
+ talloc_free(p);
return NULL;
}
p[sbuf.st_size] = 0;
/****************************************************************************
load a file into memory
****************************************************************************/
-char *file_load(const char *fname, size_t *size)
+char *file_load(const char *fname, size_t *size, TALLOC_CTX *mem_ctx)
{
int fd;
char *p;
fd = open(fname,O_RDONLY);
if (fd == -1) return NULL;
- p = fd_load(fd, size);
+ p = fd_load(fd, size, mem_ctx);
close(fd);
}
#endif
if (!p) {
- p = file_load(fname, &s2);
+ p = file_load(fname, &s2, talloc_autofree_context());
if (!p) return NULL;
if (s2 != size) {
DEBUG(1,("incorrect size for %s - got %d expected %d\n",
fname, s2, size));
- if (p) free(p);
+ talloc_free(p);
return NULL;
}
}
load a file into memory and return an array of pointers to lines in the file
must be freed with file_lines_free().
****************************************************************************/
-char **file_lines_load(const char *fname, int *numlines)
+char **file_lines_load(const char *fname, int *numlines, TALLOC_CTX *mem_ctx)
{
char *p;
size_t size;
- p = file_load(fname, &size);
+ p = file_load(fname, &size, mem_ctx);
if (!p) return NULL;
return file_lines_parse(p, size, numlines);
must be freed with file_lines_free(). If convert is true calls unix_to_dos on
the list.
****************************************************************************/
-char **fd_lines_load(int fd, int *numlines)
+char **fd_lines_load(int fd, int *numlines, TALLOC_CTX *mem_ctx)
{
char *p;
size_t size;
- p = fd_load(fd, &size);
+ p = fd_load(fd, &size, mem_ctx);
if (!p) return NULL;
return file_lines_parse(p, size, numlines);
}
-/****************************************************************************
-free lines loaded with file_lines_load
-****************************************************************************/
-void file_lines_free(char **lines)
-{
- if (!lines) return;
- SAFE_FREE(lines[0]);
- SAFE_FREE(lines);
-}
-
-
/****************************************************************************
take a lislist of lines and modify them to produce a list where \ continues
a line
#define BUFR_INC 1024
-/* -------------------------------------------------------------------------- **
- * Variables...
- *
- * DEBUGLEVEL - The ubiquitous DEBUGLEVEL. This determines which DEBUG()
- * messages will be produced.
- * bufr - pointer to a global buffer. This is probably a kludge,
- * but it was the nicest kludge I could think of (for now).
- * bSize - The size of the global buffer <bufr>.
- */
-
-static char *bufr = NULL;
-static int bSize = 0;
-
/* we can't use FILE* due to the 256 fd limit - use this cheap hack
instead */
typedef struct {
char *buf;
char *p;
size_t size;
+ char *bufr;
+ int bSize;
} myFILE;
static int mygetc(myFILE *f)
static void myfile_close(myFILE *f)
{
- if (!f) return;
- SAFE_FREE(f->buf);
- SAFE_FREE(f);
+ talloc_free(f);
}
/* -------------------------------------------------------------------------- **
{
/* Check that the buffer is big enough for the next character. */
- if( i > (bSize - 2) )
+ if( i > (InFile->bSize - 2) )
{
char *tb;
- tb = realloc_p(bufr, char, bSize + BUFR_INC);
+ tb = talloc_realloc(InFile, InFile->bufr, char, InFile->bSize + BUFR_INC);
if( NULL == tb )
{
DEBUG(0, ("%s Memory re-allocation failure.", func) );
return( False );
}
- bufr = tb;
- bSize += BUFR_INC;
+ InFile->bufr = tb;
+ InFile->bSize += BUFR_INC;
}
/* Handle a single character. */
switch( c )
{
case ']': /* Found the closing bracket. */
- bufr[end] = '\0';
+ InFile->bufr[end] = '\0';
if( 0 == end ) /* Don't allow an empty name. */
{
DEBUG(0, ("%s Empty section name in configuration file.\n", func ));
return( False );
}
- if( !sfunc(bufr) ) /* Got a valid name. Deal with it. */
+ if( !sfunc(InFile->bufr) ) /* Got a valid name. Deal with it. */
return( False );
(void)EatComment( InFile ); /* Finish off the line. */
return( True );
case '\n': /* Got newline before closing ']'. */
- i = Continuation( bufr, i ); /* Check for line continuation. */
+ i = Continuation( InFile->bufr, i ); /* Check for line continuation. */
if( i < 0 )
{
- bufr[end] = '\0';
+ InFile->bufr[end] = '\0';
DEBUG(0, ("%s Badly formed line in configuration file: %s\n",
- func, bufr ));
+ func, InFile->bufr ));
return( False );
}
- end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
+ end = ( (i > 0) && (' ' == InFile->bufr[i - 1]) ) ? (i - 1) : (i);
c = mygetc( InFile ); /* Continue with next line. */
break;
default: /* All else are a valid name chars. */
if( isspace( c ) ) /* One space per whitespace region. */
{
- bufr[end] = ' ';
+ InFile->bufr[end] = ' ';
i = end + 1;
c = EatWhitespace( InFile );
}
else /* All others copy verbatim. */
{
- bufr[i++] = c;
+ InFile->bufr[i++] = c;
end = i;
c = mygetc( InFile );
}
}
/* We arrive here if we've met the EOF before the closing bracket. */
- DEBUG(0, ("%s Unexpected EOF in the configuration file: %s\n", func, bufr ));
+ DEBUG(0, ("%s Unexpected EOF in the configuration file\n", func));
return( False );
} /* Section */
while( 0 == vstart ) /* Loop until we've found the start of the value. */
{
- if( i > (bSize - 2) ) /* Ensure there's space for next char. */
+ if( i > (InFile->bSize - 2) ) /* Ensure there's space for next char. */
{
char *tb;
- tb = realloc_p( bufr, char, bSize + BUFR_INC );
+ tb = talloc_realloc(InFile, InFile->bufr, char, InFile->bSize + BUFR_INC );
if( NULL == tb )
{
DEBUG(0, ("%s Memory re-allocation failure.", func) );
return( False );
}
- bufr = tb;
- bSize += BUFR_INC;
+ InFile->bufr = tb;
+ InFile->bSize += BUFR_INC;
}
switch( c )
DEBUG(0, ("%s Invalid parameter name in config. file.\n", func ));
return( False );
}
- bufr[end++] = '\0'; /* Mark end of string & advance. */
+ InFile->bufr[end++] = '\0'; /* Mark end of string & advance. */
i = end; /* New string starts here. */
vstart = end; /* New string is parameter value. */
- bufr[i] = '\0'; /* New string is nul, for now. */
+ InFile->bufr[i] = '\0'; /* New string is nul, for now. */
break;
case '\n': /* Find continuation char, else error. */
- i = Continuation( bufr, i );
+ i = Continuation( InFile->bufr, i );
if( i < 0 )
{
- bufr[end] = '\0';
+ InFile->bufr[end] = '\0';
DEBUG(1,("%s Ignoring badly formed line in configuration file: %s\n",
- func, bufr ));
+ func, InFile->bufr ));
return( True );
}
- end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
+ end = ( (i > 0) && (' ' == InFile->bufr[i - 1]) ) ? (i - 1) : (i);
c = mygetc( InFile ); /* Read past eoln. */
break;
case '\0': /* Shouldn't have EOF within param name. */
case EOF:
- bufr[i] = '\0';
- DEBUG(1,("%s Unexpected end-of-file at: %s\n", func, bufr ));
+ InFile->bufr[i] = '\0';
+ DEBUG(1,("%s Unexpected end-of-file at: %s\n", func, InFile->bufr ));
return( True );
default:
if( isspace( c ) ) /* One ' ' per whitespace region. */
{
- bufr[end] = ' ';
+ InFile->bufr[end] = ' ';
i = end + 1;
c = EatWhitespace( InFile );
}
else /* All others verbatim. */
{
- bufr[i++] = c;
+ InFile->bufr[i++] = c;
end = i;
c = mygetc( InFile );
}
while( (EOF !=c) && (c > 0) )
{
- if( i > (bSize - 2) ) /* Make sure there's enough room. */
+ if( i > (InFile->bSize - 2) ) /* Make sure there's enough room. */
{
char *tb;
- tb = realloc_p( bufr, char, bSize + BUFR_INC );
+ tb = talloc_realloc(InFile, InFile->bufr, char, InFile->bSize + BUFR_INC );
if( NULL == tb )
{
DEBUG(0, ("%s Memory re-allocation failure.", func) );
return( False );
}
- bufr = tb;
- bSize += BUFR_INC;
+ InFile->bufr = tb;
+ InFile->bSize += BUFR_INC;
}
switch( c )
break; /* removes them. */
case '\n': /* Marks end of value unless there's a '\'. */
- i = Continuation( bufr, i );
+ i = Continuation( InFile->bufr, i );
if( i < 0 )
c = 0;
else
{
- for( end = i; (end >= 0) && isspace((int)bufr[end]); end-- )
+ for( end = i; (end >= 0) && isspace((int)InFile->bufr[end]); end-- )
;
c = mygetc( InFile );
}
break;
default: /* All others verbatim. Note that spaces do */
- bufr[i++] = c; /* not advance <end>. This allows trimming */
+ InFile->bufr[i++] = c; /* not advance <end>. This allows trimming */
if( !isspace( c ) ) /* of whitespace at the end of the line. */
end = i;
c = mygetc( InFile );
break;
}
}
- bufr[end] = '\0'; /* End of value. */
+ InFile->bufr[end] = '\0'; /* End of value. */
- return( pfunc( bufr, &bufr[vstart] ) ); /* Pass name & value to pfunc(). */
+ return( pfunc( InFile->bufr, &InFile->bufr[vstart] ) ); /* Pass name & value to pfunc(). */
} /* Parameter */
static BOOL Parse( myFILE *InFile,
const char *func = "params.c:OpenConfFile() -";
myFILE *ret;
- ret = malloc_p(myFILE);
+ ret = talloc(talloc_autofree_context(), myFILE);
if (!ret) return NULL;
- ret->buf = file_load(FileName, &ret->size);
+ ret->buf = file_load(FileName, &ret->size, ret);
if( NULL == ret->buf )
{
DEBUG( 1,
("%s Unable to open configuration file \"%s\":\n\t%s\n",
func, FileName, strerror(errno)) );
- SAFE_FREE(ret);
+ talloc_free(ret);
return NULL;
}
ret->p = ret->buf;
+ ret->bufr = NULL;
+ ret->bSize = 0;
return( ret );
} /* OpenConfFile */
DEBUG( 3, ("%s Processing configuration file \"%s\"\n", func, FileName) );
- if( NULL != bufr ) /* If we already have a buffer */
+ if( NULL != InFile->bufr ) /* If we already have a buffer */
result = Parse( InFile, sfunc, pfunc ); /* (recursive call), then just */
/* use it. */
else /* If we don't have a buffer */
{ /* allocate one, then parse, */
- bSize = BUFR_INC; /* then free. */
- bufr = (char *)malloc( bSize );
- if( NULL == bufr )
+ InFile->bSize = BUFR_INC; /* then free. */
+ InFile->bufr = talloc_array(InFile, char, InFile->bSize );
+ if( NULL == InFile->bufr )
{
DEBUG(0,("%s memory allocation failure.\n", func));
myfile_close(InFile);
return( False );
}
result = Parse( InFile, sfunc, pfunc );
- SAFE_FREE( bufr );
- bufr = NULL;
- bSize = 0;
+ InFile->bufr = NULL;
+ InFile->bSize = 0;
}
myfile_close(InFile);
#include "librpc/gen_ndr/ndr_lsa.h"
#include "scripting/ejs/ejsrpc.h"
-NTSTATUS ejs_pull_rpc(int eid, const char *callname,
- struct MprVar *v, void *ptr, ejs_pull_function_t ejs_pull)
-{
- struct ejs_rpc *ejs = talloc(ptr, struct ejs_rpc);
- NT_STATUS_HAVE_NO_MEMORY(ejs);
- ejs->eid = eid;
- ejs->callname = callname;
- return ejs_pull(ejs, v, ptr);
-}
-
-
-NTSTATUS ejs_push_rpc(int eid, const char *callname,
- struct MprVar *v, const void *ptr, ejs_push_function_t ejs_push)
-{
- struct ejs_rpc *ejs = talloc(ptr, struct ejs_rpc);
- NT_STATUS_HAVE_NO_MEMORY(ejs);
- ejs->eid = eid;
- ejs->callname = callname;
- return ejs_push(ejs, v, ptr);
-}
-
/*
set the switch var to be used by the next union switch
*/
int ejs_rpc_call(int eid, int argc, struct MprVar **argv, const char *callname,
ejs_pull_function_t ejs_pull, ejs_push_function_t ejs_push);
-NTSTATUS ejs_pull_rpc(int eid, const char *callname, struct MprVar *v, void *ptr, ejs_pull_function_t ejs_pull);
-NTSTATUS ejs_push_rpc(int eid, const char *callname, struct MprVar *v, const void *ptr, ejs_push_function_t ejs_push);
NTSTATUS ejs_pull_struct_start(struct ejs_rpc *ejs, struct MprVar **v, const char *name);
NTSTATUS ejs_push_struct_start(struct ejs_rpc *ejs, struct MprVar **v, const char *name);
void *ptr;
struct rpc_request *req;
int callnum;
+ struct ejs_rpc *ejs;
if (argc != 2 ||
argv[0]->type != MPR_TYPE_OBJECT ||
}
callnum = call - iface->calls;
+ ejs = talloc(mprMemCtx(), struct ejs_rpc);
+ if (ejs == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+
+ ejs->eid = eid;
+ ejs->callname = callname;
+
/* allocate the C structure */
- ptr = talloc_zero_size(mprMemCtx(), call->struct_size);
+ ptr = talloc_zero_size(ejs, call->struct_size);
if (ptr == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
}
/* convert the mpr object into a C structure */
- status = ejs_pull_rpc(eid, callname, io, ptr, ejs_pull);
+ status = ejs_pull(ejs, io, ptr);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
req = dcerpc_ndr_request_send(p, NULL, iface, callnum, ptr, ptr);
if (req == NULL) {
status = NT_STATUS_NO_MEMORY;
- talloc_free(ptr);
goto done;
}
status = dcerpc_ndr_request_recv(req);
ndr_print_function_debug(call->ndr_print, call->name, NDR_OUT, ptr);
}
- status = ejs_push_rpc(eid, callname, io, ptr, ejs_push);
+ status = ejs_push(ejs, io, ptr);
- talloc_free(ptr);
done:
+ talloc_free(ejs);
ejsSetReturnValue(eid, mprNTSTATUS(status));
if (NT_STATUS_EQUAL(status, NT_STATUS_INTERNAL_ERROR)) {
return -1;
for (i=1;argv[i];i++) {
argv_list = str_list_add(argv_list, argv[i]);
}
+ talloc_steal(mem_ctx, argv_list);
v = mprList("ARGV", argv_list);
mprSetPropertyValue(&v, "length", mprCreateIntegerVar(i-1));
mprCreateProperty(ejsGetGlobalObject(eid), "ARGV", &v);
/* load the script and advance past interpreter line*/
- script = file_load(fname, &script_size);
+ script = file_load(fname, &script_size, mem_ctx);
if ((script_size > 2) && script[0] == '#' && script[1] == '!') {
script += 2;
/* generate the seeds - after this everything is deterministic */
if (options.use_preset_seeds) {
int numops;
- char **preset = file_lines_load(options.seeds_file, &numops);
+ char **preset = file_lines_load(options.seeds_file, &numops, NULL);
if (!preset) {
printf("Failed to load %s - %s\n", options.seeds_file, strerror(errno));
exit(1);
options.analyze_continuous = True;
break;
case 'i':
- options.ignore_patterns = file_lines_load(optarg, NULL);
+ options.ignore_patterns = file_lines_load(optarg, NULL, NULL);
break;
case 'h':
usage();
p = lp_parm_string(-1, "torture", "unclist");
if (p) {
- unc_list = file_lines_load(p, &num_unc_names);
+ unc_list = file_lines_load(p, &num_unc_names, NULL);
if (!unc_list || num_unc_names <= 0) {
printf("Failed to load unc names list from '%s'\n", p);
exit(1);
exit(1);
}
- data = (uint8_t *)file_load(ctx_filename, &size);
+ data = (uint8_t *)file_load(ctx_filename, &size, mem_ctx);
if (!data) {
perror(ctx_filename);
exit(1);
}
if (filename)
- data = (uint8_t *)file_load(filename, &size);
+ data = (uint8_t *)file_load(filename, &size, mem_ctx);
else
data = (uint8_t *)stdin_load(mem_ctx, &size);
git.samba.org / sfrench / samba-autobuild / .git / commitdiff