r24809: Consolidate the use of temporary talloc contexts.

This adds the two functions talloc_stackframe() and talloc_tos().

 * When a new talloc stackframe is allocated with talloc_stackframe(), then
 * the TALLOC_CTX returned with talloc_tos() is reset to that new
 * frame. Whenever that stack frame is TALLOC_FREE()'ed, then the reverse
 * happens: The previous talloc_tos() is restored.
 *
 * This API is designed to be robust in the sense that if someone forgets to
 * TALLOC_FREE() a stackframe, then the next outer one correctly cleans up and
 * resets the talloc_tos().

The original motivation for this patch was to get rid of the
sid_string_static & friends buffers. Explicitly passing talloc context
everywhere clutters code too much for my taste, so an implicit
talloc_tos() is introduced here. Many of these static buffers are
replaced by a single static pointer.

The intended use would thus be that low-level functions can rather
freely push stuff to talloc_tos, the upper layers clean up by freeing
the stackframe. The more of these stackframes are used and correctly
freed the more exact the memory cleanup happens.

This patch removes the main_loop_talloc_ctx, tmp_talloc_ctx and
lp_talloc_ctx (did I forget any?)

So, never do a

tmp_ctx = talloc_init("foo");

anymore, instead, use

tmp_ctx = talloc_stackframe()

:-)

Volker
(This used to be commit 6585ea2cb7f417e14540495b9c7380fe9c8c717b)

1 files changed, 11 insertions, 73 deletions

diff --git a/source3/rpc_parse/parse_misc.c b/source3/rpc_parse/parse_misc.c
index 15a71a11be..54d8ae4785 100644
--- a/source3/rpc_parse/parse_misc.c
+++ b/source3/rpc_parse/parse_misc.c
@@ -25,68 +25,6 @@
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_RPC_PARSE
 
-/****************************************************************************
- A temporary TALLOC context for things like unistrs, that is valid for
- the life of a complete RPC call.
-****************************************************************************/
-
-static TALLOC_CTX *current_rpc_talloc = NULL;
-
-static TALLOC_CTX *get_current_rpc_talloc(void)
-{
-    return current_rpc_talloc;
-}
-
-void set_current_rpc_talloc( TALLOC_CTX *ctx)
-{
-	current_rpc_talloc = ctx;
-}
-
-static TALLOC_CTX *main_loop_talloc = NULL;
-
-/*******************************************************************
-free up temporary memory - called from the main loop
-********************************************************************/
-
-void main_loop_TALLOC_FREE(void)
-{
-    if (!main_loop_talloc)
-        return;
-    talloc_destroy(main_loop_talloc);
-    main_loop_talloc = NULL;
-}
-
-/*******************************************************************
- Get a talloc context that is freed in the main loop...
-********************************************************************/
-
-TALLOC_CTX *main_loop_talloc_get(void)
-{
-    if (!main_loop_talloc) {
-        main_loop_talloc = talloc_init("main loop talloc (mainly parse_misc)");
-        if (!main_loop_talloc)
-            smb_panic("main_loop_talloc: malloc fail");
-    }
-
-    return main_loop_talloc;
-}
-
-/*******************************************************************
- Try and get a talloc context. Get the rpc one if possible, else
- get the main loop one. The main loop one is more dangerous as it
- goes away between packets, the rpc one will stay around for as long
- as a current RPC lasts.
-********************************************************************/ 
-
-TALLOC_CTX *get_talloc_ctx(void)
-{
-	TALLOC_CTX *tc = get_current_rpc_talloc();
-
-	if (tc)
-		return tc;
-	return main_loop_talloc_get();
-}
-
 /*******************************************************************
  Reads or writes a UTIME type.
 ********************************************************************/
@@ -449,7 +387,7 @@ void init_unistr(UNISTR *str, const char *buf)
 	len = strlen(buf) + 1;
 
 	if (len) {
-		str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
+		str->buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, len);
 		if (str->buffer == NULL)
 			smb_panic("init_unistr: malloc fail");
 
@@ -485,7 +423,7 @@ BOOL smb_io_unistr(const char *desc, UNISTR *uni, prs_struct *ps, int depth)
 static void create_rpc_blob(RPC_DATA_BLOB *str, size_t len)
 {
 	if (len) {
-		str->buffer = (uint8 *)TALLOC_ZERO(get_talloc_ctx(), len);
+		str->buffer = (uint8 *)TALLOC_ZERO(talloc_tos(), len);
 		if (str->buffer == NULL)
 			smb_panic("create_rpc_blob: talloc fail");
 		str->buf_len = len;
@@ -591,7 +529,7 @@ void init_regval_buffer(REGVAL_BUFFER *str, const uint8 *buf, size_t len)
 
 	if (buf != NULL) {
 		SMB_ASSERT(str->buf_max_len >= str->buf_len);
-		str->buffer = (uint16 *)TALLOC_ZERO(get_talloc_ctx(),
+		str->buffer = (uint16 *)TALLOC_ZERO(talloc_tos(),
 						    str->buf_max_len);
 		if (str->buffer == NULL)
 			smb_panic("init_regval_buffer: talloc fail");
@@ -668,7 +606,7 @@ void copy_unistr2(UNISTR2 *str, const UNISTR2 *from)
 	   reallocation of memory. */
 	if (str->buffer == NULL) {
 		if (str->uni_max_len) {
-	   		str->buffer = (uint16 *)TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_max_len);
+			str->buffer = (uint16 *)TALLOC_ZERO_ARRAY(talloc_tos(), uint16, str->uni_max_len);
 			if ((str->buffer == NULL)) {
 				smb_panic("copy_unistr2: talloc fail");
 				return;
@@ -701,7 +639,7 @@ void init_string2(STRING2 *str, const char *buf, size_t max_len, size_t str_len)
 
 	/* store the string */
 	if(str_len != 0) {
-		str->buffer = (uint8 *)TALLOC_ZERO(get_talloc_ctx(),
+		str->buffer = (uint8 *)TALLOC_ZERO(talloc_tos(),
 						   str->str_max_len);
 		if (str->buffer == NULL)
 			smb_panic("init_string2: malloc fail");
@@ -778,7 +716,7 @@ void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags)
 	}
 	
 
-	str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
+	str->buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, len);
 	if (str->buffer == NULL) {
 		smb_panic("init_unistr2: malloc fail");
 		return;
@@ -814,7 +752,7 @@ void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags)
 
 void init_unistr4(UNISTR4 *uni4, const char *buf, enum unistr2_term_codes flags)
 {
-	uni4->string = TALLOC_P( get_talloc_ctx(), UNISTR2 );
+	uni4->string = TALLOC_P( talloc_tos(), UNISTR2 );
 	if (!uni4->string) {
 		smb_panic("init_unistr4: talloc fail");
 		return;
@@ -913,7 +851,7 @@ void init_unistr2_from_unistr(UNISTR2 *to, const UNISTR *from)
 
 	/* allocate the space and copy the string buffer */
 	if (i) {
-		to->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, i);
+		to->buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, i);
 		if (to->buffer == NULL)
 			smb_panic("init_unistr2_from_unistr: malloc fail");
 		memcpy(to->buffer, from->buffer, i*sizeof(uint16));
@@ -1117,7 +1055,7 @@ BOOL prs_unistr4_array(const char *desc, prs_struct *ps, int depth, UNISTR4_ARRA
 
 	if (UNMARSHALLING(ps)) {
 		if (array->count) {
-			if ( !(array->strings = TALLOC_ZERO_ARRAY( get_talloc_ctx(), UNISTR4, array->count)) )
+			if ( !(array->strings = TALLOC_ZERO_ARRAY( talloc_tos(), UNISTR4, array->count)) )
 				return False;
 		} else {
 			array->strings = NULL;
@@ -1152,7 +1090,7 @@ BOOL init_unistr4_array( UNISTR4_ARRAY *array, uint32 count, const char **string
 	/* allocate memory for the array of UNISTR4 objects */
 
 	if (array->count) {
-		if ( !(array->strings = TALLOC_ZERO_ARRAY(get_talloc_ctx(), UNISTR4, count )) )
+		if ( !(array->strings = TALLOC_ZERO_ARRAY(talloc_tos(), UNISTR4, count )) )
 			return False;
 	} else {
 		array->strings = NULL;
@@ -1707,7 +1645,7 @@ void init_unistr3(UNISTR3 *str, const char *buf)
 	str->uni_str_len = strlen(buf) + 1;
 
 	if (str->uni_str_len) {
-		str->str.buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_str_len);
+		str->str.buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, str->uni_str_len);
 		if (str->str.buffer == NULL)
 			smb_panic("init_unistr3: malloc fail");