py_talloc_Object *obj = (py_talloc_Object *)self;
talloc_free(obj->talloc_ctx);
obj->talloc_ctx = NULL;
- PyObject_Del(self);
+ self->ob_type->tp_free(self);
}
PyObject *py_talloc_import_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx,
void *ptr)
{
- py_talloc_Object *ret = PyObject_New(py_talloc_Object, py_type);
+ 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;
.tp_new = py_ldb_dn_new,
.tp_dealloc = py_talloc_dealloc,
.tp_basicsize = sizeof(PyLdbObject),
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
/* Debug */
}
PyTypeObject PyLdb = {
- PyObject_HEAD_INIT(NULL)
.tp_name = "Ldb",
.tp_methods = py_ldb_methods,
.tp_repr = (reprfunc)py_ldb_repr,
.tp_str = (reprfunc)py_ldb_module_str,
.tp_basicsize = sizeof(py_talloc_Object),
.tp_dealloc = py_talloc_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
struct ldb_message_element *PyObject_AsMessageElement(TALLOC_CTX *mem_ctx,
.tp_iter = (getiterfunc)py_ldb_msg_element_iter,
.tp_as_sequence = &py_ldb_msg_element_seq,
.tp_new = py_ldb_msg_element_new,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args)
if (!PyObject_AsDn(NULL, pydn, NULL, &ret->dn))
return NULL;
- return py_talloc_import(&PyLdbMessage, ret);
+ return py_talloc_import(type, ret);
}
PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg)
.tp_dealloc = py_talloc_dealloc,
.tp_new = py_ldb_msg_new,
.tp_repr = (reprfunc)py_ldb_msg_repr,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *tree)
.tp_name = "Tree",
.tp_basicsize = sizeof(PyLdbTreeObject),
.tp_dealloc = py_talloc_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
/* Ldb_module */
.tp_new = registry_new,
.tp_basicsize = sizeof(py_talloc_Object),
.tp_dealloc = py_talloc_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
static PyObject *py_hive_key_del(PyObject *self, PyObject *args)
.tp_new = hive_open,
.tp_basicsize = sizeof(py_talloc_Object),
.tp_dealloc = py_talloc_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
PyTypeObject PyRegistryKey = {
.tp_name = "RegistryKey",
.tp_basicsize = sizeof(py_talloc_Object),
.tp_dealloc = py_talloc_dealloc,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
};
static PyObject *py_open_samba(PyObject *self, PyObject *args, PyObject *kwargs)
return lp_set_cmdline($self, parm_name, parm_value);
}
+ char *private_path(const char *name, TALLOC_CTX *mem_ctx) {
+ return private_path(mem_ctx, $self, name);
+ }
+
%feature("docstring") set "S.get(name, service_name) -> value\n" \
"Find specified parameter.";
PyObject *get(const char *param_name, const char *service_name)
}
%}
-
-char *private_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
- const char *name);
LoadParm.is_myname = new_instancemethod(_param.LoadParm_is_myname,None,LoadParm)
LoadParm.use = new_instancemethod(_param.LoadParm_use,None,LoadParm)
LoadParm.set = new_instancemethod(_param.LoadParm_set,None,LoadParm)
+LoadParm.private_path = new_instancemethod(_param.LoadParm_private_path,None,LoadParm)
LoadParm.get = new_instancemethod(_param.LoadParm_get,None,LoadParm)
LoadParm_swigregister = _param.LoadParm_swigregister
LoadParm_swigregister(LoadParm)
param_section_swigregister = _param.param_section_swigregister
param_section_swigregister(param_section)
-private_path = _param.private_path
return false;
return lp_set_cmdline(self, parm_name, parm_value);
}
+SWIGINTERN char *loadparm_context_private_path(loadparm_context *self,char const *name,TALLOC_CTX *mem_ctx){
+ return private_path(mem_ctx, self, name);
+ }
SWIGINTERN PyObject *loadparm_context_get(loadparm_context *self,char const *param_name,char const *service_name){
struct parm_struct *parm = NULL;
void *parm_ptr = NULL;
}
+SWIGINTERN PyObject *_wrap_LoadParm_private_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ loadparm_context *arg1 = (loadparm_context *) 0 ;
+ char *arg2 = (char *) 0 ;
+ TALLOC_CTX *arg3 = (TALLOC_CTX *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "name", NULL
+ };
+ char *result = 0 ;
+
+ arg1 = loadparm_init(NULL);
+ arg3 = NULL;
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_private_path",kwnames,&obj0,&obj1)) SWIG_fail;
+ if (obj0) {
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_private_path" "', argument " "1"" of type '" "loadparm_context *""'");
+ }
+ arg1 = (loadparm_context *)(argp1);
+ }
+ if (obj1) {
+ res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm_private_path" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ }
+ result = (char *)loadparm_context_private_path(arg1,(char const *)arg2,arg3);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_LoadParm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
loadparm_context *arg1 = (loadparm_context *) 0 ;
return SWIG_Python_InitShadowInstance(args);
}
-SWIGINTERN PyObject *_wrap_private_path(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
- PyObject *resultobj = 0;
- TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
- struct loadparm_context *arg2 = (struct loadparm_context *) 0 ;
- char *arg3 = (char *) 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- char * kwnames[] = {
- (char *) "lp_ctx",(char *) "name", NULL
- };
- char *result = 0 ;
-
- arg2 = loadparm_init(NULL);
- arg1 = NULL;
- if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:private_path",kwnames,&obj0,&obj1)) SWIG_fail;
- if (obj0) {
- res2 = SWIG_ConvertPtr(obj0, &argp2,SWIGTYPE_p_loadparm_context, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "private_path" "', argument " "2"" of type '" "struct loadparm_context *""'");
- }
- arg2 = (struct loadparm_context *)(argp2);
- }
- if (obj1) {
- res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "private_path" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- }
- result = (char *)private_path(arg1,arg2,(char const *)arg3);
- resultobj = SWIG_FromCharPtr((const char *)result);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return resultobj;
-fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return NULL;
-}
-
-
static PyMethodDef SwigMethods[] = {
{ (char *)"new_LoadParm", (PyCFunction)_wrap_new_LoadParm, METH_NOARGS, NULL},
{ (char *)"LoadParm_default_service", (PyCFunction) _wrap_LoadParm_default_service, METH_VARARGS | METH_KEYWORDS, NULL},
"S.set(name, value) -> bool\n"
"Change a parameter.\n"
""},
+ { (char *)"LoadParm_private_path", (PyCFunction) _wrap_LoadParm_private_path, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"LoadParm_get", (PyCFunction) _wrap_LoadParm_get, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"delete_LoadParm", (PyCFunction) _wrap_delete_LoadParm, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"LoadParm_swigregister", LoadParm_swigregister, METH_VARARGS, NULL},
{ (char *)"delete_param_section", (PyCFunction)_wrap_delete_param_section, METH_O, NULL},
{ (char *)"param_section_swigregister", param_section_swigregister, METH_VARARGS, NULL},
{ (char *)"param_section_swiginit", param_section_swiginit, METH_VARARGS, NULL},
- { (char *)"private_path", (PyCFunction) _wrap_private_path, METH_VARARGS | METH_KEYWORDS, NULL},
{ NULL, NULL, 0, NULL }
};
python_uuid_OBJ_FILES = $(pyscriptsrcdir)/uuidmodule.o
-[PYTHON::python_misc]
-LIBRARY_REALNAME = samba/misc.$(SHLIBEXT)
-PRIVATE_DEPENDENCIES = LIBNDR LIBLDB SAMDB CREDENTIALS swig_ldb
+[PYTHON::python_glue]
+LIBRARY_REALNAME = samba/glue.$(SHLIBEXT)
+PRIVATE_DEPENDENCIES = LIBNDR LIBLDB SAMDB CREDENTIALS swig_ldb python_dcerpc_misc python_dcerpc_security
-python_misc_OBJ_FILES = $(pyscriptsrcdir)/pymisc.o
+python_glue_OBJ_FILES = $(pyscriptsrcdir)/pyglue.o
-$(python_misc_OBJ_FILES): CFLAGS+=$(CFLAG_NO_CAST_QUAL) -I$(ldbsrcdir)
+$(python_glue_OBJ_FILES): CFLAGS+=$(CFLAG_NO_CAST_QUAL) -I$(ldbsrcdir)
_PY_FILES = $(shell find $(pyscriptsrcdir)/samba ../lib/subunit/python -name "*.py")
#define PyErr_LDB_OR_RAISE(py_ldb, ldb) \
if (!PyLdb_Check(py_ldb)) { \
- PyErr_SetString(PyExc_TypeError, "Ldb connection object required"); \
- return NULL; \
+ /*PyErr_SetString(PyExc_TypeError, "Ldb connection object required"); \
+ return NULL; \ */ \
} \
ldb = PyLdb_AsLdbContext(py_ldb);
{ NULL }
};
-void initmisc(void)
+void initglue(void)
{
PyObject *m;
- m = Py_InitModule3("misc", py_misc_methods,
+ m = Py_InitModule3("glue", py_misc_methods,
"Python bindings for miscellaneous Samba functions.");
if (m == NULL)
return;
import ldb
import credentials
-import misc
+import glue
class Ldb(ldb.Ldb):
"""Simple Samba-specific LDB subclass that takes care
if session_info is not None:
self.set_session_info(session_info)
- assert misc.ldb_register_samba_handlers(self) == 0
+ glue.ldb_register_samba_handlers(self)
if lp is not None:
self.set_loadparm(lp)
if url is not None:
self.connect(url)
+ def set_credentials(self, credentials):
+ glue.ldb_set_credentials(self, credentials)
- set_credentials = misc.ldb_set_credentials
- set_session_info = misc.ldb_set_session_info
- set_loadparm = misc.ldb_set_loadparm
+ def set_session_info(self, session_info):
+ glue.ldb_set_session_info(self, session_info)
+
+ def set_loadparm(self, lp_ctx):
+ glue.ldb_set_loadparm(self, lp_ctx)
def searchone(self, attribute, basedn=None, expression=None,
scope=ldb.SCOPE_BASE):
return False
return True
-version = misc.version
+version = glue.version
__docformat__ = "restructuredText"
import samba
-import misc
+import glue
import ldb
class IDmapDB(samba.Ldb):
self.connect(lp.get("idmap database"))
def connect(self, url):
- super(IDmapDB, self).connect(misc.private_path(self.lp, url))
+ super(IDmapDB, self).connect(self.lp.private_path(url))
def setup_name_mapping(self, sid, type, unixid):
"""Setup a mapping between a sam name and a unix name.
import pwd
import grp
import time
-import uuid, misc
+import uuid, glue
import socket
import param
import registry
if policyguid is None:
policyguid = str(uuid.uuid4())
if adminpass is None:
- adminpass = misc.random_password(12)
+ adminpass = glue.generate_random_str(12)
if krbtgtpass is None:
- krbtgtpass = misc.random_password(12)
+ krbtgtpass = glue.generate_random_str(12)
if machinepass is None:
- machinepass = misc.random_password(12)
+ machinepass = glue.generate_random_str(12)
if dnspass is None:
- dnspass = misc.random_password(12)
+ dnspass = glue.generate_random_str(12)
root_uid = findnss_uid([root or "root"])
nobody_uid = findnss_uid([nobody or "nobody"])
users_gid = findnss_gid([users or "users"])
root = findnss(pwd.getpwnam, ["root"])[0]
if adminpass is None:
- adminpass = misc.random_password(12)
+ adminpass = glue.generate_random_str(12)
if targetdir is not None:
if (not os.path.exists(os.path.join(targetdir, "etc"))):
"""Convenience functions for using the SAM."""
import samba
-import misc
+import glue
import ldb
from samba.idmap import IDmapDB
import pwd
self.lp = lp
super(SamDB, self).__init__(session_info=session_info, credentials=credentials,
modules_dir=modules_dir, lp=lp)
- assert misc.dsdb_set_global_schema(self) == 0
+ glue.dsdb_set_global_schema(self)
if url:
self.connect(url)
else:
self.connect(lp.get("sam database"))
def connect(self, url):
- super(SamDB, self).connect(misc.private_path(self.lp, url))
+ super(SamDB, self).connect(self.lp.private_path(url))
def add_foreign(self, domaindn, sid, desc):
"""Add a foreign security principle."""
:param sid: The new domain sid to use.
"""
- misc.samdb_set_domain_sid(self, sid)
+ glue.samdb_set_domain_sid(self, sid)
def attach_schema_from_ldif(self, pf, df):
- misc.dsdb_attach_schema_from_ldif_file(self, pf, df)
+ glue.dsdb_attach_schema_from_ldif_file(self, pf, df)
def set_invocation_id(self, invocation_id):
"""Set the invocation id for this SamDB handle.
:param invocation_id: GUID of the invocation id.
"""
- misc.dsdb_set_ntds_invocation_id(self, invocation_id)
+ glue.dsdb_set_ntds_invocation_id(self, invocation_id)
def setexpiry(self, user, expiry_seconds, noexpiry):
"""Set the password expiry for a user
accountExpires = 0
else:
userAccountControl = userAccountControl & ~0x10000
- accountExpires = misc.unix2nttime(expiry_seconds + int(time.time()))
+ accountExpires = glue.unix2nttime(expiry_seconds + int(time.time()))
mod = """
dn: %s