from samba import Ldb, substitute_var
from samba.tests import LdbTestCase, TestCaseInTempDir, cmdline_loadparm
import samba.dcerpc.security
-import samba.security
import samba.ndr
datadir = os.path.join(os.path.dirname(__file__),
def assertSidEquals(self, text, ndr_sid):
sid_obj1 = samba.ndr.ndr_unpack(samba.dcerpc.security.dom_sid,
str(ndr_sid[0]))
- sid_obj2 = samba.security.Sid(text)
- # For now, this is the only way we can compare these since the
- # classes are in different places. Should reconcile that at some point.
- self.assertEquals(sid_obj1.sid_rev_num, sid_obj2.sid_rev_num)
- self.assertEquals(sid_obj1.num_auths, sid_obj2.num_auths)
- # FIXME: self.assertEquals(sid_obj1.id_auth, sid_obj2.id_auth)
- # FIXME: self.assertEquals(sid_obj1.sub_auths[:sid_obj1.num_auths],
- # sid_obj2.sub_auths[:sid_obj2.num_auths])
+ sid_obj2 = samba.dcerpc.security.dom_sid(text)
+ self.assertEquals(sid_obj1, sid_obj2)
class Samba3SamTestCase(MapBaseTestCase):
Compare two sids.
*****************************************************************/
-static int dom_sid_compare(const struct dom_sid *sid1, const struct dom_sid *sid2)
+int dom_sid_compare(const struct dom_sid *sid1, const struct dom_sid *sid2)
{
int i;
#
import unittest
-from samba import security
+from samba.dcerpc import security
class SecurityTokenTests(unittest.TestCase):
def setUp(self):
- self.token = security.SecurityToken()
+ self.token = security.token()
def test_is_system(self):
self.assertFalse(self.token.is_system())
class SecurityDescriptorTests(unittest.TestCase):
def setUp(self):
- self.descriptor = security.SecurityDescriptor()
+ self.descriptor = security.descriptor()
class DomSidTests(unittest.TestCase):
def test_parse_sid(self):
- sid = security.Sid("S-1-5-21")
+ sid = security.dom_sid("S-1-5-21")
self.assertEquals("S-1-5-21", str(sid))
def test_sid_equal(self):
- sid1 = security.Sid("S-1-5-21")
- sid2 = security.Sid("S-1-5-21")
+ sid1 = security.dom_sid("S-1-5-21")
+ sid2 = security.dom_sid("S-1-5-21")
self.assertTrue(sid1.__eq__(sid1))
self.assertTrue(sid1.__eq__(sid2))
def test_repr(self):
sid = security.random_sid()
- self.assertTrue(repr(sid).startswith("Sid('S-1-5-21-"))
+ self.assertTrue(repr(sid).startswith("dom_sid('S-1-5-21-"))
class PrivilegeTests(unittest.TestCase):
}
}
-static PyObject *py_dom_sid_eq(PyObject *self, PyObject *args)
+static int py_dom_sid_cmp(PyObject *self, PyObject *py_other)
{
struct dom_sid *this = py_talloc_get_ptr(self), *other;
- PyObject *py_other;
-
- if (!PyArg_ParseTuple(args, "O", &py_other))
- return NULL;
-
- other = py_talloc_get_type(py_other, struct dom_sid);
+ other = py_talloc_get_ptr(py_other);
if (other == NULL)
- return Py_False;
+ return -1;
- return dom_sid_equal(this, other)?Py_True:Py_False;
+ return dom_sid_compare(this, other);
}
static PyObject *py_dom_sid_str(PyObject *self)
return 0;
}
-static PyMethodDef py_dom_sid_extra_methods[] = {
- { "__eq__", (PyCFunction)py_dom_sid_eq, METH_VARARGS, "S.__eq__(x) -> S == x" }, \
- { NULL }
-};
-
static void py_dom_sid_patch(PyTypeObject *type)
{
type->tp_init = py_dom_sid_init;
type->tp_str = py_dom_sid_str;
type->tp_repr = py_dom_sid_repr;
- PyType_AddMethods(type, py_dom_sid_extra_methods);
+ type->tp_compare = py_dom_sid_cmp;
}
#define PY_DOM_SID_PATCH py_dom_sid_patch
return Py_None;
}
-static PyObject *py_descriptor_eq(PyObject *self, PyObject *args)
-{
- struct security_descriptor *desc1 = py_talloc_get_ptr(self), *desc2;
- PyObject *py_other;
-
- if (!PyArg_ParseTuple(args, "O", &py_other))
- return NULL;
-
- desc2 = py_talloc_get_ptr(py_other);
-
- return PyBool_FromLong(security_descriptor_equal(desc1, desc2));
-}
-
static PyObject *py_descriptor_new(PyTypeObject *self, PyObject *args, PyObject *kwargs)
{
return py_talloc_import(self, security_descriptor_initialise(NULL));
NULL },
{ "sacl_del", (PyCFunction)py_descriptor_sacl_del, METH_VARARGS,
NULL },
- { "__eq__", (PyCFunction)py_descriptor_eq, METH_VARARGS,
- NULL },
{ NULL }
};
#include "pytalloc.h"
#define PyLoadparmContext_AsLoadparmContext(obj) py_talloc_get_ptr(obj)
-#define PyLoadparmContext_Check(obj) PyObject_TypeCheck(obj, &PyLoadparmContext)
PyAPI_DATA(PyTypeObject) PyLoadparmContext;
PyAPI_DATA(PyTypeObject) PyLoadparmService;
ret = lp_load((struct loadparm_context *)self->ptr, filename);
if (!ret) {
- PyErr_SetString(PyExc_RuntimeError, "Unable to load file");
+ PyErr_Format(PyExc_RuntimeError, "Unable to load file %s", filename);
return NULL;
}
return Py_None;
ret = lp_load_default(self->ptr);
if (!ret) {
- PyErr_SetString(PyExc_RuntimeError, "Unable to load file");
+ PyErr_SetString(PyExc_RuntimeError, "Unable to load default file");
return NULL;
}
return Py_None;
self.olmmrserveridsconf = None
self.olmmrsyncreplconf = None
+
class ProvisionNames(object):
def __init__(self):
self.rootdn = None
default_lp = param.LoadParm()
#Load non-existant file
- default_lp.load(smbconf)
+ if os.path.exists(smbconf):
+ default_lp.load(smbconf)
if targetdir is not None:
privatedir_line = "private dir = " + os.path.abspath(os.path.join(targetdir, "private"))
if domainsid is None:
domainsid = security.random_sid()
- else:
- domainsid = security.Sid(domainsid)
if policyguid is None:
policyguid = str(uuid.uuid4())
Does not use a parameter table, unlike the "normal".
"""
- def __init__(self):
- self._sections = {}
+ def __init__(self, sections=None):
+ self._sections = sections or {}
def _sanitize_name(self, name):
return name.strip().lower().replace(" ","")
+ def __repr__(self):
+ return "ParamFile(%r)" % self._sections
+
def read(self, filename):
"""Read a file.
if not l:
continue
if l[0] == "[" and l[-1] == "]":
- section = self._sanitize_name(l[1:-2])
+ section = self._sanitize_name(l[1:-1])
self._sections.setdefault(section, {})
elif "=" in l:
(k, v) = l.split("=", 1)
if not section in self._sections:
return None
param = self._sanitize_name(param)
- return self._sections[section].get(param)
+ if not param in self._sections[section]:
+ return None
+ return self._sections[section][param].strip()
def __getitem__(self, section):
return self._sections[section]
def get_sam_db(self):
lp = self.get_conf()
- backends = str(lp.get("passdb backend")).split(" ")
+ backends = (lp.get("passdb backend") or "").split(" ")
if ":" in backends[0]:
(name, location) = backends[0].split(":", 2)
else:
parser.print_usage()
sys.exit(1)
-smbconf = sambaopts.get_loadparm().configfile()
+smbconf = sambaopts.get_loadparm().configfile
if opts.server_role == "dc":
server_role = "domain controller"
setup_dir = "setup"
lp = sambaopts.get_loadparm()
-smbconf = lp.configfile()
+smbconf = lp.configfile
creds = credopts.get_credentials(lp)
upgrade_provision(samba3, setup_dir, message, credentials=creds, session_info=system_session(),