[SCM] Samba Shared Repository - branch master updated -
release-4-0-0alpha8-154-g826ee30
Andrew Tridgell
tridge at samba.org
Wed Jul 1 05:16:25 GMT 2009
The branch, master has been updated
via 826ee307fcfc24a1f133628ffec657222569b611 (commit)
via 27620c85e7d55e6e522b39c7aea8f83c2b5eb9b1 (commit)
via 0534ae012b3ef962f52fef9968eef30e88668874 (commit)
via 5fe1d8dc1275e43d96da1297f5fb0d0088a1c3ab (commit)
via 6a192020a230ab8e085f32b5559c0fe0d2f5c1a4 (commit)
via 386211a81ce9091db0d6dbb711dc656af412c649 (commit)
via 08ed6a2281121a4acca29d4f40d6959449ec9eab (commit)
via 269b16212a65c9506147db381ecdcbdd58347af6 (commit)
via 12510329217dd2b8027794b63258a34797a0f940 (commit)
via 956b5a0003a3ab82d2d7cffb7aee6e5281b4fbb4 (commit)
via 2d981919b8dd63655a39ccaa4fd7bdb39d1830f6 (commit)
via 45ba09457eadc8832ff40d2f8c0d5a6cc14ae3f3 (commit)
via f7a6206b55ee849ceddf7e97be3fc008100ba1c6 (commit)
via b2c3c08b461042de683b0e49dcaa5f9386c72f9e (commit)
via 9faa0745e9598a9096a7c69c30c273b47393e819 (commit)
from b31f1e6d5bffddf5eb8df940bc4ff19f8bb5a7c4 (commit)
http://gitweb.samba.org/?p=samba.git;a=shortlog;h=master
- Log -----------------------------------------------------------------
commit 826ee307fcfc24a1f133628ffec657222569b611
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 15:15:13 2009 +1000
removed a generated file
commit 27620c85e7d55e6e522b39c7aea8f83c2b5eb9b1
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 15:13:49 2009 +1000
use a talloc_reparent in a very ugly way
this works around some terrible use of talloc in the libnet code
commit 0534ae012b3ef962f52fef9968eef30e88668874
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:53:32 2009 +1000
use the new talloc_reparent in two places
commit 5fe1d8dc1275e43d96da1297f5fb0d0088a1c3ab
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:53:01 2009 +1000
changes to remove the ambiguity in talloc_free() and talloc_steal()
These changes follow from the discussions on samba-technical. The
changes are in several parts, and stem from the inherent ambiguity
that was in talloc_free() and talloc_steal() when the pointer that is
being changes has more than one parent, via references.
The changes are:
1) when you call talloc_free() on a pointer with more than one parent
the free will fail, and talloc will log an error to stderr like this:
ERROR: talloc_free with references at some/foo.c:123
reference at other/bar.c:201
reference at other/foobar.c:641
2) Similarly, when you call talloc_steal() on a pointer with more
than one parent, the steal will fail and talloc will log an error to
stderr like this:
ERROR: talloc_steal with references at some/foo.c:123
reference at other/bar.c:201
3) A new function talloc_reparent() has been added to change a parent
in a controlled fashion. You need to supply both the old parent and
the new parent. It handles the case whether either the old parent was
a normal parent or a reference
The use of stderr in the logging is ugly (and potentially dangerous),
and will be removed in a future patch. We'll need to add a debug
registration function to talloc.
commit 6a192020a230ab8e085f32b5559c0fe0d2f5c1a4
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:08:43 2009 +1000
gensec_start now steals the auth_context
commit 386211a81ce9091db0d6dbb711dc656af412c649
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:08:13 2009 +1000
A rather strange varient of talloc_unlink
A dcerpc request may have a reference from a still completing async
callback, but we now consider the request to be complete. We want to
lose the main parent, leaving just the reference, if any.
commit 08ed6a2281121a4acca29d4f40d6959449ec9eab
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:06:56 2009 +1000
another case that should use py_talloc_reference
commit 269b16212a65c9506147db381ecdcbdd58347af6
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:06:38 2009 +1000
use py_talloc_reference instead of py_talloc_import
This is one of the few cases where we want the object to be owned by
both the python object and C code
commit 12510329217dd2b8027794b63258a34797a0f940
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:05:53 2009 +1000
py_talloc_import now uses a steal, so this free is incorrect
commit 956b5a0003a3ab82d2d7cffb7aee6e5281b4fbb4
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:05:17 2009 +1000
fixed use of reference in pytalloc
The previous code caused memory leaks, and also caused situations
where talloc_free could be called on pointers with multiple parents
The new approach is to have two functions:
py_talloc_import : steals the pointer, so it becomes wholly owned by
the python object
py_talloc_reference: uses a reference, so it is owned by both python
and C
commit 2d981919b8dd63655a39ccaa4fd7bdb39d1830f6
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:02:37 2009 +1000
use a talloc_unlink() as ops may have a reference
commit 45ba09457eadc8832ff40d2f8c0d5a6cc14ae3f3
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:02:12 2009 +1000
fixed the reference to the global_schema
commit f7a6206b55ee849ceddf7e97be3fc008100ba1c6
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:01:44 2009 +1000
removed a redundent talloc_steal
commit b2c3c08b461042de683b0e49dcaa5f9386c72f9e
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 14:01:24 2009 +1000
fixed the use of talloc_steal in ntlmssp_server
The previous use of talloc_steal could cause a steal of a pointer that
had references. This ensures that doesn't happen
commit 9faa0745e9598a9096a7c69c30c273b47393e819
Author: Andrew Tridgell <tridge at samba.org>
Date: Wed Jul 1 13:59:52 2009 +1000
fixed rpc smb code to not reply on talloc_free being a function pointer
The upcoming talloc_free/talloc_reference changes change talloc_free
to be a macro. These two bits of code relied on it being a function
pointer
-----------------------------------------------------------------------
Summary of changes:
lib/talloc/pytalloc.c | 26 ++++++-
lib/talloc/pytalloc.h | 1 +
lib/talloc/talloc.c | 119 +++++++++++++++++++++++++-----
lib/talloc/talloc.h | 16 +++--
source4/auth/gensec/gensec.c | 4 +-
source4/auth/ntlmssp/ntlmssp_server.c | 5 +-
source4/auth/pyauth.c | 2 +-
source4/auth/samba_server_gensec.c | 2 -
source4/bin/python/samba/tests/shares.py | 74 ------------------
source4/dsdb/schema/schema_set.c | 5 +-
source4/ldap_server/ldap_backend.c | 2 +-
source4/libnet/libnet_join.c | 2 +-
source4/libnet/libnet_rpc.c | 13 +++-
source4/librpc/ndr/py_security.c | 1 -
source4/librpc/rpc/dcerpc.c | 2 +-
source4/librpc/rpc/dcerpc_smb.c | 8 ++-
source4/librpc/rpc/dcerpc_smb2.c | 7 ++-
source4/param/pyparam.c | 2 +-
source4/smb_server/smb/negprot.c | 2 +-
19 files changed, 171 insertions(+), 122 deletions(-)
delete mode 100644 source4/bin/python/samba/tests/shares.py
Changeset truncated at 500 lines:
diff --git a/lib/talloc/pytalloc.c b/lib/talloc/pytalloc.c
index 30da9ee..3ce49d6 100644
--- a/lib/talloc/pytalloc.c
+++ b/lib/talloc/pytalloc.c
@@ -43,7 +43,27 @@ PyObject *py_talloc_import_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx,
if (ret->talloc_ctx == NULL) {
return NULL;
}
- if (talloc_reference(ret->talloc_ctx, mem_ctx) == NULL) {
+ if (talloc_steal(ret->talloc_ctx, mem_ctx) == NULL) {
+ return NULL;
+ }
+ ret->ptr = ptr;
+ return (PyObject *)ret;
+}
+
+
+/**
+ * Import an existing talloc pointer into a Python object, leaving the
+ * original parent, and creating a reference to the object in the python
+ * object
+ */
+PyObject *py_talloc_reference(PyTypeObject *py_type, void *ptr)
+{
+ py_talloc_Object *ret = (py_talloc_Object *)py_type->tp_alloc(py_type, 0);
+ ret->talloc_ctx = talloc_new(NULL);
+ if (ret->talloc_ctx == NULL) {
+ return NULL;
+ }
+ if (talloc_reference(ret->talloc_ctx, ptr) == NULL) {
return NULL;
}
ret->ptr = ptr;
@@ -58,6 +78,6 @@ PyObject *py_talloc_default_repr(PyObject *obj)
py_talloc_Object *talloc_obj = (py_talloc_Object *)obj;
PyTypeObject *type = (PyTypeObject*)PyObject_Type(obj);
- return PyString_FromFormat("<%s talloc object at 0x%x>",
- type->tp_name, (intptr_t)talloc_obj->ptr);
+ return PyString_FromFormat("<%s talloc object at 0x%p>",
+ type->tp_name, talloc_obj->ptr);
}
diff --git a/lib/talloc/pytalloc.h b/lib/talloc/pytalloc.h
index c5a1428..00282c4 100644
--- a/lib/talloc/pytalloc.h
+++ b/lib/talloc/pytalloc.h
@@ -43,6 +43,7 @@ void py_talloc_dealloc(PyObject* self);
#define py_talloc_get_mem_ctx(py_obj) ((py_talloc_Object *)py_obj)->talloc_ctx
PyObject *py_talloc_import_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx, void *ptr);
+PyObject *py_talloc_reference(PyTypeObject *py_type, void *ptr);
#define py_talloc_import(py_type, talloc_ptr) py_talloc_import_ex(py_type, talloc_ptr, talloc_ptr)
/* Sane default implementation of reprfunc. */
diff --git a/lib/talloc/talloc.c b/lib/talloc/talloc.c
index 33cbfd7..bf2fb1f 100644
--- a/lib/talloc/talloc.c
+++ b/lib/talloc/talloc.c
@@ -107,6 +107,7 @@ static void *autofree_context;
struct talloc_reference_handle {
struct talloc_reference_handle *next, *prev;
void *ptr;
+ const char *location;
};
typedef int (*talloc_destructor_t)(void *);
@@ -465,7 +466,7 @@ static inline void *_talloc_named_const(const void *context, size_t size, const
same underlying data, and you want to be able to free the two instances separately,
and in either order
*/
-void *_talloc_reference(const void *context, const void *ptr)
+void *_talloc_reference(const void *context, const void *ptr, const char *location)
{
struct talloc_chunk *tc;
struct talloc_reference_handle *handle;
@@ -482,6 +483,7 @@ void *_talloc_reference(const void *context, const void *ptr)
own destructor on the context if they want to */
talloc_set_destructor(handle, talloc_reference_destructor);
handle->ptr = discard_const_p(void, ptr);
+ handle->location = location;
_TLIST_ADD(tc->refs, handle);
return handle->ptr;
}
@@ -490,7 +492,7 @@ void *_talloc_reference(const void *context, const void *ptr)
/*
internal talloc_free call
*/
-static inline int _talloc_free(void *ptr)
+static inline int _talloc_free_internal(void *ptr)
{
struct talloc_chunk *tc;
@@ -510,9 +512,9 @@ static inline int _talloc_free(void *ptr)
* pointer.
*/
is_child = talloc_is_parent(tc->refs, ptr);
- _talloc_free(tc->refs);
+ _talloc_free_internal(tc->refs);
if (is_child) {
- return _talloc_free(ptr);
+ return _talloc_free_internal(ptr);
}
return -1;
}
@@ -559,12 +561,12 @@ static inline int _talloc_free(void *ptr)
struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
if (p) new_parent = TC_PTR_FROM_CHUNK(p);
}
- if (unlikely(_talloc_free(child) == -1)) {
+ if (unlikely(_talloc_free_internal(child) == -1)) {
if (new_parent == null_context) {
struct talloc_chunk *p = talloc_parent_chunk(ptr);
if (p) new_parent = TC_PTR_FROM_CHUNK(p);
}
- talloc_steal(new_parent, child);
+ _talloc_steal_internal(new_parent, child);
}
}
@@ -600,7 +602,7 @@ static inline int _talloc_free(void *ptr)
ptr on success, or NULL if it could not be transferred.
passing NULL as ptr will always return NULL with no side effects.
*/
-void *_talloc_steal(const void *new_ctx, const void *ptr)
+void *_talloc_steal_internal(const void *new_ctx, const void *ptr)
{
struct talloc_chunk *tc, *new_tc;
@@ -653,6 +655,66 @@ void *_talloc_steal(const void *new_ctx, const void *ptr)
}
+/*
+ move a lump of memory from one talloc context to another return the
+ ptr on success, or NULL if it could not be transferred.
+ passing NULL as ptr will always return NULL with no side effects.
+*/
+void *_talloc_steal(const void *new_ctx, const void *ptr, const char *location)
+{
+ struct talloc_chunk *tc;
+
+ if (unlikely(ptr == NULL)) {
+ return NULL;
+ }
+
+ tc = talloc_chunk_from_ptr(ptr);
+
+ if (unlikely(tc->refs != NULL) && talloc_parent(ptr) != new_ctx) {
+ struct talloc_reference_handle *h;
+ fprintf(stderr, "ERROR: talloc_steal with references at %s\n", location);
+ for (h=tc->refs; h; h=h->next) {
+ fprintf(stderr, "\treference at %s\n", h->location);
+ }
+ return NULL;
+ }
+
+ return _talloc_steal_internal(new_ctx, ptr);
+}
+
+/*
+ this is like a talloc_steal(), but you must supply the old
+ parent. This resolves the ambiguity in a talloc_steal() which is
+ called on a context that has more than one parent (via references)
+
+ The old parent can be either a reference or a parent
+*/
+void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
+{
+ struct talloc_chunk *tc;
+ struct talloc_reference_handle *h;
+
+ if (unlikely(ptr == NULL)) {
+ return NULL;
+ }
+
+ if (old_parent == talloc_parent(ptr)) {
+ return _talloc_steal_internal(new_parent, ptr);
+ }
+
+ tc = talloc_chunk_from_ptr(ptr);
+ for (h=tc->refs;h;h=h->next) {
+ if (talloc_parent(h) == old_parent) {
+ if (_talloc_steal_internal(new_parent, h) != h) {
+ return NULL;
+ }
+ return ptr;
+ }
+ }
+
+ /* it wasn't a parent */
+ return NULL;
+}
/*
remove a secondary reference to a pointer. This undo's what
@@ -680,7 +742,7 @@ static inline int talloc_unreference(const void *context, const void *ptr)
return -1;
}
- return _talloc_free(h);
+ return _talloc_free_internal(h);
}
/*
@@ -717,7 +779,7 @@ int talloc_unlink(const void *context, void *ptr)
tc_p = talloc_chunk_from_ptr(ptr);
if (tc_p->refs == NULL) {
- return _talloc_free(ptr);
+ return _talloc_free_internal(ptr);
}
new_p = talloc_parent_chunk(tc_p->refs);
@@ -731,7 +793,7 @@ int talloc_unlink(const void *context, void *ptr)
return -1;
}
- talloc_steal(new_parent, ptr);
+ _talloc_steal_internal(new_parent, ptr);
return 0;
}
@@ -784,7 +846,7 @@ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
va_end(ap);
if (unlikely(name == NULL)) {
- _talloc_free(ptr);
+ _talloc_free_internal(ptr);
return NULL;
}
@@ -882,7 +944,7 @@ void *talloc_init(const char *fmt, ...)
va_end(ap);
if (unlikely(name == NULL)) {
- _talloc_free(ptr);
+ _talloc_free_internal(ptr);
return NULL;
}
@@ -916,12 +978,12 @@ void talloc_free_children(void *ptr)
struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
if (p) new_parent = TC_PTR_FROM_CHUNK(p);
}
- if (unlikely(_talloc_free(child) == -1)) {
+ if (unlikely(talloc_free(child) == -1)) {
if (new_parent == null_context) {
struct talloc_chunk *p = talloc_parent_chunk(ptr);
if (p) new_parent = TC_PTR_FROM_CHUNK(p);
}
- talloc_steal(new_parent, child);
+ _talloc_steal_internal(new_parent, child);
}
}
@@ -969,9 +1031,26 @@ void *talloc_named_const(const void *context, size_t size, const char *name)
will not be freed if the ref_count is > 1 or the destructor (if
any) returns non-zero
*/
-int talloc_free(void *ptr)
+int _talloc_free(void *ptr, const char *location)
{
- return _talloc_free(ptr);
+ struct talloc_chunk *tc;
+
+ if (unlikely(ptr == NULL)) {
+ return -1;
+ }
+
+ tc = talloc_chunk_from_ptr(ptr);
+
+ if (unlikely(tc->refs != NULL)) {
+ struct talloc_reference_handle *h;
+ fprintf(stderr, "ERROR: talloc_free with references at %s\n", location);
+ for (h=tc->refs; h; h=h->next) {
+ fprintf(stderr, "\treference at %s\n", h->location);
+ }
+ return -1;
+ }
+
+ return _talloc_free_internal(ptr);
}
@@ -988,7 +1067,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
/* size zero is equivalent to free() */
if (unlikely(size == 0)) {
- _talloc_free(ptr);
+ talloc_free(ptr);
return NULL;
}
@@ -1085,7 +1164,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
void *_talloc_move(const void *new_ctx, const void *_pptr)
{
const void **pptr = discard_const_p(const void *,_pptr);
- void *ret = _talloc_steal(new_ctx, *pptr);
+ void *ret = talloc_steal(new_ctx, *pptr);
(*pptr) = NULL;
return ret;
}
@@ -1306,7 +1385,7 @@ void talloc_enable_null_tracking(void)
*/
void talloc_disable_null_tracking(void)
{
- _talloc_free(null_context);
+ talloc_free(null_context);
null_context = NULL;
}
@@ -1688,7 +1767,7 @@ static int talloc_autofree_destructor(void *ptr)
static void talloc_autofree(void)
{
- _talloc_free(autofree_context);
+ talloc_free(autofree_context);
}
/*
diff --git a/lib/talloc/talloc.h b/lib/talloc/talloc.h
index a4b33c3..9d1aa0d 100644
--- a/lib/talloc/talloc.h
+++ b/lib/talloc/talloc.h
@@ -69,15 +69,15 @@ typedef void TALLOC_CTX;
} while(0)
/* this extremely strange macro is to avoid some braindamaged warning
stupidity in gcc 4.1.x */
-#define talloc_steal(ctx, ptr) ({ _TALLOC_TYPEOF(ptr) __talloc_steal_ret = (_TALLOC_TYPEOF(ptr))_talloc_steal((ctx),(ptr)); __talloc_steal_ret; })
+#define talloc_steal(ctx, ptr) ({ _TALLOC_TYPEOF(ptr) __talloc_steal_ret = (_TALLOC_TYPEOF(ptr))_talloc_steal((ctx),(ptr), __location__); __talloc_steal_ret; })
#else
#define talloc_set_destructor(ptr, function) \
_talloc_set_destructor((ptr), (int (*)(void *))(function))
#define _TALLOC_TYPEOF(ptr) void *
-#define talloc_steal(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_steal((ctx),(ptr))
+#define talloc_steal(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_steal((ctx),(ptr), __location__)
#endif
-#define talloc_reference(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_reference((ctx),(ptr))
+#define talloc_reference(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_reference((ctx),(ptr), __location__)
#define talloc_move(ctx, ptr) (_TALLOC_TYPEOF(*(ptr)))_talloc_move((ctx),(void *)(ptr))
/* useful macros for creating type checked pointers */
@@ -106,6 +106,8 @@ typedef void TALLOC_CTX;
#define talloc_get_type_abort(ptr, type) (type *)_talloc_get_type_abort(ptr, #type, __location__)
#define talloc_find_parent_bytype(ptr, type) (type *)talloc_find_parent_byname(ptr, #type)
+#define talloc_free(ctx) _talloc_free(ctx, __location__)
+
#if TALLOC_DEPRECATED
#define talloc_zero_p(ctx, type) talloc_zero(ctx, type)
@@ -124,7 +126,7 @@ void *talloc_pool(const void *context, size_t size);
void _talloc_set_destructor(const void *ptr, int (*_destructor)(void *));
int talloc_increase_ref_count(const void *ptr);
size_t talloc_reference_count(const void *ptr);
-void *_talloc_reference(const void *context, const void *ptr);
+void *_talloc_reference(const void *context, const void *ptr, const char *location);
int talloc_unlink(const void *context, void *ptr);
const char *talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
void talloc_set_name_const(const void *ptr, const char *name);
@@ -137,10 +139,12 @@ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *loca
void *talloc_parent(const void *ptr);
const char *talloc_parent_name(const void *ptr);
void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
-int talloc_free(void *ptr);
+int _talloc_free(void *ptr, const char *location);
void talloc_free_children(void *ptr);
void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name);
-void *_talloc_steal(const void *new_ctx, const void *ptr);
+void *_talloc_steal(const void *new_ctx, const void *ptr, const char *location);
+void *_talloc_steal_internal(const void *new_ctx, const void *ptr);
+void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr);
void *_talloc_move(const void *new_ctx, const void *pptr);
size_t talloc_total_size(const void *ptr);
size_t talloc_total_blocks(const void *ptr);
diff --git a/source4/auth/gensec/gensec.c b/source4/auth/gensec/gensec.c
index 2feb545..1addf93 100644
--- a/source4/auth/gensec/gensec.c
+++ b/source4/auth/gensec/gensec.c
@@ -504,6 +504,8 @@ const char **gensec_security_oids(struct gensec_security *gensec_security,
@param mem_ctx The parent TALLOC memory context.
@param gensec_security Returned GENSEC context pointer.
@note The mem_ctx is only a parent and may be NULL.
+ @note, the auth context is moved to be a child of the
+ @ gensec_security return
*/
static NTSTATUS gensec_start(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
@@ -532,7 +534,7 @@ static NTSTATUS gensec_start(TALLOC_CTX *mem_ctx,
(*gensec_security)->event_ctx = ev;
SMB_ASSERT(settings->lp_ctx != NULL);
(*gensec_security)->settings = talloc_reference(*gensec_security, settings);
- (*gensec_security)->auth_context = talloc_reference(*gensec_security, auth_context);
+ (*gensec_security)->auth_context = talloc_steal(*gensec_security, auth_context);
return NT_STATUS_OK;
}
diff --git a/source4/auth/ntlmssp/ntlmssp_server.c b/source4/auth/ntlmssp/ntlmssp_server.c
index 00d3e56..28169d9 100644
--- a/source4/auth/ntlmssp/ntlmssp_server.c
+++ b/source4/auth/ntlmssp/ntlmssp_server.c
@@ -458,6 +458,7 @@ static NTSTATUS ntlmssp_server_postauth(struct gensec_security *gensec_security,
} else if (user_session_key && user_session_key->data) {
session_key = *user_session_key;
+ talloc_steal(gensec_ntlmssp_state, session_key.data);
DEBUG(10,("ntlmssp_server_auth: Using unmodified nt session key.\n"));
dump_data_pw("unmodified session key:\n", session_key.data, session_key.length);
@@ -467,6 +468,7 @@ static NTSTATUS ntlmssp_server_postauth(struct gensec_security *gensec_security,
} else if (lm_session_key && lm_session_key->data) {
/* Very weird to have LM key, but no user session key, but anyway.. */
session_key = *lm_session_key;
+ talloc_steal(gensec_ntlmssp_state, session_key.data);
DEBUG(10,("ntlmssp_server_auth: Using unmodified lm session key.\n"));
dump_data_pw("unmodified session key:\n", session_key.data, session_key.length);
@@ -511,9 +513,6 @@ static NTSTATUS ntlmssp_server_postauth(struct gensec_security *gensec_security,
gensec_ntlmssp_state->session_key = session_key;
}
- /* keep the session key around on the new context */
- talloc_steal(gensec_ntlmssp_state, session_key.data);
-
if ((gensec_security->want_features & GENSEC_FEATURE_SIGN)
|| (gensec_security->want_features & GENSEC_FEATURE_SEAL)) {
nt_status = ntlmssp_sign_init(gensec_ntlmssp_state);
diff --git a/source4/auth/pyauth.c b/source4/auth/pyauth.c
index e97174f..04880b7 100644
--- a/source4/auth/pyauth.c
+++ b/source4/auth/pyauth.c
@@ -32,7 +32,7 @@ PyTypeObject PyAuthSession = {
PyObject *PyAuthSession_FromSession(struct auth_session_info *session)
{
- return py_talloc_import(&PyAuthSession, session);
+ return py_talloc_reference(&PyAuthSession, session);
}
static PyObject *py_system_session(PyObject *module, PyObject *args)
diff --git a/source4/auth/samba_server_gensec.c b/source4/auth/samba_server_gensec.c
index 0576b15..31f52fc 100644
--- a/source4/auth/samba_server_gensec.c
+++ b/source4/auth/samba_server_gensec.c
@@ -61,8 +61,6 @@ NTSTATUS samba_server_gensec_start(TALLOC_CTX *mem_ctx,
return nt_status;
}
- talloc_steal(gensec_ctx, auth_context);
-
gensec_set_credentials(gensec_ctx, server_credentials);
if (target_service) {
diff --git a/source4/bin/python/samba/tests/shares.py b/source4/bin/python/samba/tests/shares.py
deleted file mode 100644
index 9130c36..0000000
--- a/source4/bin/python/samba/tests/shares.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/python
-
-# Unix SMB/CIFS implementation. Tests for shares
-# Copyright (C) Jelmer Vernooij <jelmer at samba.org> 2009
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-#
-from samba.shares import SharesContainer
-from unittest import TestCase
-
-
-class MockService(object):
-
- def __init__(self, data):
- self.data = data
-
- def __getitem__(self, name):
- return self.data[name]
-
-
-class MockLoadParm(object):
-
- def __init__(self, data):
- self.data = data
-
- def __getitem__(self, name):
- return MockService(self.data[name])
-
- def __contains__(self, name):
--
Samba Shared Repository
More information about the samba-cvs
mailing list