s3:librpc: add smbXsrv.idl
[Samba/gebeck_regimport.git] / source4 / dsdb / pydsdb.c
blobd3486a41ec66a760d09d215440acfb8855d50b4f
1 /*
2 Unix SMB/CIFS implementation.
3 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007-2010
4 Copyright (C) Matthias Dieter Wallnöfer 2009
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 #include <Python.h>
21 #include "includes.h"
22 #include <ldb.h>
23 #include <pyldb.h>
24 #include "dsdb/samdb/samdb.h"
25 #include "libcli/security/security.h"
26 #include "librpc/ndr/libndr.h"
27 #include "system/kerberos.h"
28 #include "auth/kerberos/kerberos.h"
29 #include "librpc/rpc/pyrpc_util.h"
30 #include "lib/policy/policy.h"
32 void initdsdb(void);
34 /* There's no Py_ssize_t in 2.4, apparently */
35 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5
36 typedef int Py_ssize_t;
37 typedef inquiry lenfunc;
38 typedef intargfunc ssizeargfunc;
39 #endif
41 /* FIXME: These should be in a header file somewhere */
42 #define PyErr_LDB_OR_RAISE(py_ldb, ldb) \
43 /* if (!PyLdb_Check(py_ldb)) { \
44 PyErr_SetString(py_ldb_get_exception(), "Ldb connection object required"); \
45 return NULL; \
46 } */\
47 ldb = pyldb_Ldb_AsLdbContext(py_ldb);
49 static PyObject *py_ldb_get_exception(void)
51 PyObject *mod = PyImport_ImportModule("ldb");
52 if (mod == NULL)
53 return NULL;
55 return PyObject_GetAttrString(mod, "LdbError");
58 static void PyErr_SetLdbError(PyObject *error, int ret, struct ldb_context *ldb_ctx)
60 if (ret == LDB_ERR_PYTHON_EXCEPTION)
61 return; /* Python exception should already be set, just keep that */
63 PyErr_SetObject(error,
64 Py_BuildValue(discard_const_p(char, "(i,s)"), ret,
65 ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
68 static PyObject *py_samdb_server_site_name(PyObject *self, PyObject *args)
70 PyObject *py_ldb, *result;
71 struct ldb_context *ldb;
72 const char *site;
73 TALLOC_CTX *mem_ctx;
75 if (!PyArg_ParseTuple(args, "O", &py_ldb))
76 return NULL;
78 PyErr_LDB_OR_RAISE(py_ldb, ldb);
80 mem_ctx = talloc_new(NULL);
81 if (mem_ctx == NULL) {
82 PyErr_NoMemory();
83 return NULL;
86 site = samdb_server_site_name(ldb, mem_ctx);
87 if (site == NULL) {
88 PyErr_SetString(PyExc_RuntimeError, "Failed to find server site");
89 talloc_free(mem_ctx);
90 return NULL;
93 result = PyString_FromString(site);
94 talloc_free(mem_ctx);
95 return result;
98 static PyObject *py_dsdb_convert_schema_to_openldap(PyObject *self,
99 PyObject *args)
101 char *target_str, *mapping;
102 PyObject *py_ldb;
103 struct ldb_context *ldb;
104 PyObject *ret;
105 char *retstr;
107 if (!PyArg_ParseTuple(args, "Oss", &py_ldb, &target_str, &mapping))
108 return NULL;
110 PyErr_LDB_OR_RAISE(py_ldb, ldb);
112 retstr = dsdb_convert_schema_to_openldap(ldb, target_str, mapping);
113 if (retstr == NULL) {
114 PyErr_SetString(PyExc_RuntimeError,
115 "dsdb_convert_schema_to_openldap failed");
116 return NULL;
119 ret = PyString_FromString(retstr);
120 talloc_free(retstr);
121 return ret;
124 static PyObject *py_samdb_set_domain_sid(PyLdbObject *self, PyObject *args)
126 PyObject *py_ldb, *py_sid;
127 struct ldb_context *ldb;
128 struct dom_sid *sid;
129 bool ret;
131 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_sid))
132 return NULL;
134 PyErr_LDB_OR_RAISE(py_ldb, ldb);
136 sid = dom_sid_parse_talloc(NULL, PyString_AsString(py_sid));
137 if (sid == NULL) {
138 PyErr_NoMemory();
139 return NULL;
142 ret = samdb_set_domain_sid(ldb, sid);
143 talloc_free(sid);
144 if (!ret) {
145 PyErr_SetString(PyExc_RuntimeError, "set_domain_sid failed");
146 return NULL;
148 Py_RETURN_NONE;
151 static PyObject *py_samdb_set_ntds_settings_dn(PyLdbObject *self, PyObject *args)
153 PyObject *py_ldb, *py_ntds_settings_dn;
154 struct ldb_context *ldb;
155 struct ldb_dn *ntds_settings_dn;
156 TALLOC_CTX *tmp_ctx;
157 bool ret;
159 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ntds_settings_dn))
160 return NULL;
162 PyErr_LDB_OR_RAISE(py_ldb, ldb);
164 tmp_ctx = talloc_new(NULL);
165 if (tmp_ctx == NULL) {
166 PyErr_NoMemory();
167 return NULL;
170 if (!pyldb_Object_AsDn(tmp_ctx, py_ntds_settings_dn, ldb, &ntds_settings_dn)) {
171 /* exception thrown by "pyldb_Object_AsDn" */
172 talloc_free(tmp_ctx);
173 return NULL;
176 ret = samdb_set_ntds_settings_dn(ldb, ntds_settings_dn);
177 talloc_free(tmp_ctx);
178 if (!ret) {
179 PyErr_SetString(PyExc_RuntimeError, "set_ntds_settings_dn failed");
180 return NULL;
182 Py_RETURN_NONE;
185 static PyObject *py_samdb_get_domain_sid(PyLdbObject *self, PyObject *args)
187 PyObject *py_ldb;
188 struct ldb_context *ldb;
189 const struct dom_sid *sid;
190 PyObject *ret;
191 char *retstr;
193 if (!PyArg_ParseTuple(args, "O", &py_ldb))
194 return NULL;
196 PyErr_LDB_OR_RAISE(py_ldb, ldb);
198 sid = samdb_domain_sid(ldb);
199 if (!sid) {
200 PyErr_SetString(PyExc_RuntimeError, "samdb_domain_sid failed");
201 return NULL;
204 retstr = dom_sid_string(NULL, sid);
205 if (retstr == NULL) {
206 PyErr_NoMemory();
207 return NULL;
209 ret = PyString_FromString(retstr);
210 talloc_free(retstr);
211 return ret;
214 static PyObject *py_samdb_ntds_invocation_id(PyObject *self, PyObject *args)
216 PyObject *py_ldb, *result;
217 struct ldb_context *ldb;
218 const struct GUID *guid;
219 char *retstr;
221 if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
222 return NULL;
225 PyErr_LDB_OR_RAISE(py_ldb, ldb);
227 guid = samdb_ntds_invocation_id(ldb);
228 if (guid == NULL) {
229 PyErr_SetString(PyExc_RuntimeError,
230 "Failed to find NTDS invocation ID");
231 return NULL;
234 retstr = GUID_string(NULL, guid);
235 if (retstr == NULL) {
236 PyErr_NoMemory();
237 return NULL;
239 result = PyString_FromString(retstr);
240 talloc_free(retstr);
241 return result;
244 static PyObject *py_dsdb_get_oid_from_attid(PyObject *self, PyObject *args)
246 PyObject *py_ldb;
247 struct ldb_context *ldb;
248 uint32_t attid;
249 struct dsdb_schema *schema;
250 const char *oid;
251 PyObject *ret;
252 WERROR status;
253 TALLOC_CTX *mem_ctx;
255 if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid))
256 return NULL;
258 PyErr_LDB_OR_RAISE(py_ldb, ldb);
260 mem_ctx = talloc_new(NULL);
261 if (!mem_ctx) {
262 PyErr_NoMemory();
263 return NULL;
266 schema = dsdb_get_schema(ldb, mem_ctx);
267 if (!schema) {
268 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb \n");
269 talloc_free(mem_ctx);
270 return NULL;
273 status = dsdb_schema_pfm_oid_from_attid(schema->prefixmap, attid,
274 mem_ctx, &oid);
275 if (!W_ERROR_IS_OK(status)) {
276 PyErr_SetWERROR(status);
277 talloc_free(mem_ctx);
278 return NULL;
281 ret = PyString_FromString(oid);
283 talloc_free(mem_ctx);
285 return ret;
289 static PyObject *py_dsdb_get_attid_from_lDAPDisplayName(PyObject *self, PyObject *args)
291 PyObject *py_ldb, *is_schema_nc;
292 struct ldb_context *ldb;
293 struct dsdb_schema *schema;
294 const char *ldap_display_name;
295 bool schema_nc = false;
296 const struct dsdb_attribute *a;
297 uint32_t attid;
299 if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &is_schema_nc))
300 return NULL;
302 PyErr_LDB_OR_RAISE(py_ldb, ldb);
304 if (is_schema_nc) {
305 if (!PyBool_Check(is_schema_nc)) {
306 PyErr_SetString(PyExc_TypeError, "Expected boolean is_schema_nc");
307 return NULL;
309 if (is_schema_nc == Py_True) {
310 schema_nc = true;
314 schema = dsdb_get_schema(ldb, NULL);
316 if (!schema) {
317 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
318 return NULL;
321 a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
322 if (a == NULL) {
323 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
324 return NULL;
327 attid = dsdb_attribute_get_attid(a, schema_nc);
329 return PyLong_FromUnsignedLong(attid);
333 return the systemFlags as int from the attribute name
335 static PyObject *py_dsdb_get_systemFlags_from_lDAPDisplayName(PyObject *self, PyObject *args)
337 PyObject *py_ldb;
338 struct ldb_context *ldb;
339 struct dsdb_schema *schema;
340 const char *ldap_display_name;
341 const struct dsdb_attribute *attribute;
343 if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
344 return NULL;
346 PyErr_LDB_OR_RAISE(py_ldb, ldb);
348 schema = dsdb_get_schema(ldb, NULL);
350 if (!schema) {
351 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
352 return NULL;
355 attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
356 if (attribute == NULL) {
357 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
358 return NULL;
361 return PyInt_FromLong(attribute->systemFlags);
365 return the linkID from the attribute name
367 static PyObject *py_dsdb_get_linkId_from_lDAPDisplayName(PyObject *self, PyObject *args)
369 PyObject *py_ldb;
370 struct ldb_context *ldb;
371 struct dsdb_schema *schema;
372 const char *ldap_display_name;
373 const struct dsdb_attribute *attribute;
375 if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
376 return NULL;
378 PyErr_LDB_OR_RAISE(py_ldb, ldb);
380 schema = dsdb_get_schema(ldb, NULL);
382 if (!schema) {
383 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
384 return NULL;
387 attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
388 if (attribute == NULL) {
389 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
390 return NULL;
393 return PyInt_FromLong(attribute->linkID);
397 return the backlink attribute name (if any) for an attribute
399 static PyObject *py_dsdb_get_backlink_from_lDAPDisplayName(PyObject *self, PyObject *args)
401 PyObject *py_ldb;
402 struct ldb_context *ldb;
403 struct dsdb_schema *schema;
404 const char *ldap_display_name;
405 const struct dsdb_attribute *attribute, *target_attr;
407 if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
408 return NULL;
410 PyErr_LDB_OR_RAISE(py_ldb, ldb);
412 schema = dsdb_get_schema(ldb, NULL);
414 if (!schema) {
415 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
416 return NULL;
419 attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
420 if (attribute == NULL) {
421 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
422 return NULL;
425 if (attribute->linkID == 0) {
426 Py_RETURN_NONE;
429 target_attr = dsdb_attribute_by_linkID(schema, attribute->linkID ^ 1);
430 if (target_attr == NULL) {
431 /* when we add pseudo-backlinks we'll need to handle
432 them here */
433 Py_RETURN_NONE;
436 return PyString_FromString(target_attr->lDAPDisplayName);
440 static PyObject *py_dsdb_get_lDAPDisplayName_by_attid(PyObject *self, PyObject *args)
442 PyObject *py_ldb;
443 struct ldb_context *ldb;
444 struct dsdb_schema *schema;
445 const struct dsdb_attribute *a;
446 uint32_t attid;
448 if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid))
449 return NULL;
451 PyErr_LDB_OR_RAISE(py_ldb, ldb);
453 schema = dsdb_get_schema(ldb, NULL);
455 if (!schema) {
456 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
457 return NULL;
460 a = dsdb_attribute_by_attributeID_id(schema, attid);
461 if (a == NULL) {
462 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '0x%08x'", attid);
463 return NULL;
466 return PyString_FromString(a->lDAPDisplayName);
471 return the attribute syntax oid as a string from the attribute name
473 static PyObject *py_dsdb_get_syntax_oid_from_lDAPDisplayName(PyObject *self, PyObject *args)
475 PyObject *py_ldb;
476 struct ldb_context *ldb;
477 struct dsdb_schema *schema;
478 const char *ldap_display_name;
479 const struct dsdb_attribute *attribute;
481 if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
482 return NULL;
484 PyErr_LDB_OR_RAISE(py_ldb, ldb);
486 schema = dsdb_get_schema(ldb, NULL);
488 if (!schema) {
489 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
490 return NULL;
493 attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
494 if (attribute == NULL) {
495 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
496 return NULL;
499 return PyString_FromString(attribute->syntax->ldap_oid);
503 convert a python string to a DRSUAPI drsuapi_DsReplicaAttribute attribute
505 static PyObject *py_dsdb_DsReplicaAttribute(PyObject *self, PyObject *args)
507 PyObject *py_ldb, *el_list, *ret;
508 struct ldb_context *ldb;
509 char *ldap_display_name;
510 const struct dsdb_attribute *a;
511 struct dsdb_schema *schema;
512 struct dsdb_syntax_ctx syntax_ctx;
513 struct ldb_message_element *el;
514 struct drsuapi_DsReplicaAttribute *attr;
515 TALLOC_CTX *tmp_ctx;
516 WERROR werr;
517 Py_ssize_t i;
519 if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) {
520 return NULL;
523 PyErr_LDB_OR_RAISE(py_ldb, ldb);
525 if (!PyList_Check(el_list)) {
526 PyErr_Format(PyExc_TypeError, "ldif_elements must be a list");
527 return NULL;
530 schema = dsdb_get_schema(ldb, NULL);
531 if (!schema) {
532 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
533 return NULL;
536 a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
537 if (a == NULL) {
538 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
539 return NULL;
542 dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
543 syntax_ctx.is_schema_nc = false;
545 tmp_ctx = talloc_new(ldb);
546 if (tmp_ctx == NULL) {
547 PyErr_NoMemory();
548 return NULL;
551 el = talloc_zero(tmp_ctx, struct ldb_message_element);
552 if (el == NULL) {
553 PyErr_NoMemory();
554 talloc_free(tmp_ctx);
555 return NULL;
558 el->name = ldap_display_name;
559 el->num_values = PyList_Size(el_list);
561 el->values = talloc_array(el, struct ldb_val, el->num_values);
562 if (el->values == NULL) {
563 PyErr_NoMemory();
564 talloc_free(tmp_ctx);
565 return NULL;
568 for (i = 0; i < el->num_values; i++) {
569 PyObject *item = PyList_GetItem(el_list, i);
570 if (!PyString_Check(item)) {
571 PyErr_Format(PyExc_TypeError, "ldif_elements should be strings");
572 talloc_free(tmp_ctx);
573 return NULL;
575 el->values[i].data = (uint8_t *)PyString_AsString(item);
576 el->values[i].length = PyString_Size(item);
579 attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute);
580 if (attr == NULL) {
581 PyErr_NoMemory();
582 talloc_free(tmp_ctx);
583 return NULL;
586 werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr);
587 PyErr_WERROR_IS_ERR_RAISE(werr);
589 ret = py_return_ndr_struct("samba.dcerpc.drsuapi", "DsReplicaAttribute", attr, attr);
591 talloc_free(tmp_ctx);
593 return ret;
598 normalise a ldb attribute list
600 static PyObject *py_dsdb_normalise_attributes(PyObject *self, PyObject *args)
602 PyObject *py_ldb, *el_list, *ret;
603 struct ldb_context *ldb;
604 char *ldap_display_name;
605 const struct dsdb_attribute *a;
606 struct dsdb_schema *schema;
607 struct dsdb_syntax_ctx syntax_ctx;
608 struct ldb_message_element *el;
609 struct drsuapi_DsReplicaAttribute *attr;
610 TALLOC_CTX *tmp_ctx;
611 WERROR werr;
612 Py_ssize_t i;
614 if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) {
615 return NULL;
618 PyErr_LDB_OR_RAISE(py_ldb, ldb);
620 if (!PyList_Check(el_list)) {
621 PyErr_Format(PyExc_TypeError, "ldif_elements must be a list");
622 return NULL;
625 schema = dsdb_get_schema(ldb, NULL);
626 if (!schema) {
627 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
628 return NULL;
631 a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
632 if (a == NULL) {
633 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
634 return NULL;
637 dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
638 syntax_ctx.is_schema_nc = false;
640 tmp_ctx = talloc_new(ldb);
641 if (tmp_ctx == NULL) {
642 PyErr_NoMemory();
643 return NULL;
646 el = talloc_zero(tmp_ctx, struct ldb_message_element);
647 if (el == NULL) {
648 PyErr_NoMemory();
649 talloc_free(tmp_ctx);
650 return NULL;
653 el->name = ldap_display_name;
654 el->num_values = PyList_Size(el_list);
656 el->values = talloc_array(el, struct ldb_val, el->num_values);
657 if (el->values == NULL) {
658 PyErr_NoMemory();
659 talloc_free(tmp_ctx);
660 return NULL;
663 for (i = 0; i < el->num_values; i++) {
664 PyObject *item = PyList_GetItem(el_list, i);
665 if (!PyString_Check(item)) {
666 PyErr_Format(PyExc_TypeError, "ldif_elements should be strings");
667 talloc_free(tmp_ctx);
668 return NULL;
670 el->values[i].data = (uint8_t *)PyString_AsString(item);
671 el->values[i].length = PyString_Size(item);
674 /* Normalise "objectClass" attribute if needed */
675 if (ldb_attr_cmp(a->lDAPDisplayName, "objectClass") == 0) {
676 int iret;
677 iret = dsdb_sort_objectClass_attr(ldb, schema, tmp_ctx, el,
678 tmp_ctx, el);
679 if (iret != LDB_SUCCESS) {
680 PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb));
681 talloc_free(tmp_ctx);
682 return NULL;
686 /* first run ldb_to_drsuapi, then convert back again. This has
687 * the effect of normalising the attributes
690 attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute);
691 if (attr == NULL) {
692 PyErr_NoMemory();
693 talloc_free(tmp_ctx);
694 return NULL;
697 werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr);
698 PyErr_WERROR_IS_ERR_RAISE(werr);
700 /* now convert back again */
701 werr = a->syntax->drsuapi_to_ldb(&syntax_ctx, a, attr, el, el);
702 PyErr_WERROR_IS_ERR_RAISE(werr);
704 ret = py_return_ndr_struct("ldb", "MessageElement", el, el);
706 talloc_free(tmp_ctx);
708 return ret;
712 static PyObject *py_dsdb_set_ntds_invocation_id(PyObject *self, PyObject *args)
714 PyObject *py_ldb, *py_guid;
715 bool ret;
716 struct GUID guid;
717 struct ldb_context *ldb;
718 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_guid))
719 return NULL;
721 PyErr_LDB_OR_RAISE(py_ldb, ldb);
722 GUID_from_string(PyString_AsString(py_guid), &guid);
724 ret = samdb_set_ntds_invocation_id(ldb, &guid);
725 if (!ret) {
726 PyErr_SetString(PyExc_RuntimeError, "set_ntds_invocation_id failed");
727 return NULL;
729 Py_RETURN_NONE;
732 static PyObject *py_samdb_ntds_objectGUID(PyObject *self, PyObject *args)
734 PyObject *py_ldb, *result;
735 struct ldb_context *ldb;
736 const struct GUID *guid;
737 char *retstr;
739 if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
740 return NULL;
743 PyErr_LDB_OR_RAISE(py_ldb, ldb);
745 guid = samdb_ntds_objectGUID(ldb);
746 if (guid == NULL) {
747 PyErr_SetString(PyExc_RuntimeError, "Failed to find NTDS GUID");
748 return NULL;
751 retstr = GUID_string(NULL, guid);
752 if (retstr == NULL) {
753 PyErr_NoMemory();
754 return NULL;
756 result = PyString_FromString(retstr);
757 talloc_free(retstr);
758 return result;
761 static PyObject *py_dsdb_set_global_schema(PyObject *self, PyObject *args)
763 PyObject *py_ldb;
764 struct ldb_context *ldb;
765 int ret;
766 if (!PyArg_ParseTuple(args, "O", &py_ldb))
767 return NULL;
769 PyErr_LDB_OR_RAISE(py_ldb, ldb);
771 ret = dsdb_set_global_schema(ldb);
772 PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
774 Py_RETURN_NONE;
777 static PyObject *py_dsdb_load_partition_usn(PyObject *self, PyObject *args)
779 PyObject *py_dn, *py_ldb, *result;
780 struct ldb_dn *dn;
781 uint64_t highest_uSN, urgent_uSN;
782 struct ldb_context *ldb;
783 TALLOC_CTX *mem_ctx;
784 int ret;
786 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_dn)) {
787 return NULL;
790 PyErr_LDB_OR_RAISE(py_ldb, ldb);
792 mem_ctx = talloc_new(NULL);
793 if (mem_ctx == NULL) {
794 PyErr_NoMemory();
795 return NULL;
798 if (!pyldb_Object_AsDn(mem_ctx, py_dn, ldb, &dn)) {
799 talloc_free(mem_ctx);
800 return NULL;
803 ret = dsdb_load_partition_usn(ldb, dn, &highest_uSN, &urgent_uSN);
804 if (ret != LDB_SUCCESS) {
805 PyErr_Format(PyExc_RuntimeError,
806 "Failed to load partition [%s] uSN - %s",
807 ldb_dn_get_linearized(dn),
808 ldb_errstring(ldb));
809 talloc_free(mem_ctx);
810 return NULL;
813 talloc_free(mem_ctx);
815 result = PyDict_New();
817 PyDict_SetItemString(result, "uSNHighest", PyInt_FromLong((uint64_t)highest_uSN));
818 PyDict_SetItemString(result, "uSNUrgent", PyInt_FromLong((uint64_t)urgent_uSN));
821 return result;
824 static PyObject *py_dsdb_set_am_rodc(PyObject *self, PyObject *args)
826 PyObject *py_ldb;
827 bool ret;
828 struct ldb_context *ldb;
829 int py_val;
831 if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &py_val))
832 return NULL;
834 PyErr_LDB_OR_RAISE(py_ldb, ldb);
835 ret = samdb_set_am_rodc(ldb, (bool)py_val);
836 if (!ret) {
837 PyErr_SetString(PyExc_RuntimeError, "set_am_rodc failed");
838 return NULL;
840 Py_RETURN_NONE;
843 static PyObject *py_dsdb_set_schema_from_ldif(PyObject *self, PyObject *args)
845 WERROR result;
846 char *pf, *df, *dn;
847 PyObject *py_ldb;
848 struct ldb_context *ldb;
850 if (!PyArg_ParseTuple(args, "Osss", &py_ldb, &pf, &df, &dn))
851 return NULL;
853 PyErr_LDB_OR_RAISE(py_ldb, ldb);
855 result = dsdb_set_schema_from_ldif(ldb, pf, df, dn);
856 PyErr_WERROR_IS_ERR_RAISE(result);
858 Py_RETURN_NONE;
861 static PyObject *py_dsdb_set_schema_from_ldb(PyObject *self, PyObject *args)
863 PyObject *py_ldb;
864 struct ldb_context *ldb;
865 PyObject *py_from_ldb;
866 struct ldb_context *from_ldb;
867 struct dsdb_schema *schema;
868 int ret;
869 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_from_ldb))
870 return NULL;
872 PyErr_LDB_OR_RAISE(py_ldb, ldb);
874 PyErr_LDB_OR_RAISE(py_from_ldb, from_ldb);
876 schema = dsdb_get_schema(from_ldb, NULL);
877 if (!schema) {
878 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on 'from' ldb!\n");
879 return NULL;
882 ret = dsdb_reference_schema(ldb, schema, true);
883 PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
885 Py_RETURN_NONE;
888 static PyObject *py_dsdb_write_prefixes_from_schema_to_ldb(PyObject *self, PyObject *args)
890 PyObject *py_ldb;
891 struct ldb_context *ldb;
892 WERROR result;
893 struct dsdb_schema *schema;
895 if (!PyArg_ParseTuple(args, "O", &py_ldb))
896 return NULL;
898 PyErr_LDB_OR_RAISE(py_ldb, ldb);
900 schema = dsdb_get_schema(ldb, NULL);
901 if (!schema) {
902 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on ldb!\n");
903 return NULL;
906 result = dsdb_write_prefixes_from_schema_to_ldb(NULL, ldb, schema);
907 PyErr_WERROR_IS_ERR_RAISE(result);
909 Py_RETURN_NONE;
913 static PyObject *py_dsdb_get_partitions_dn(PyObject *self, PyObject *args)
915 struct ldb_context *ldb;
916 struct ldb_dn *dn;
917 PyObject *py_ldb, *ret;
918 PyObject *mod;
920 mod = PyImport_ImportModule("ldb");
922 if (!PyArg_ParseTuple(args, "O", &py_ldb))
923 return NULL;
925 PyErr_LDB_OR_RAISE(py_ldb, ldb);
927 dn = samdb_partitions_dn(ldb, NULL);
928 if (dn == NULL) {
929 PyErr_NoMemory();
930 return NULL;
932 ret = pyldb_Dn_FromDn(dn);
933 talloc_free(dn);
934 return ret;
939 call into samdb_rodc()
941 static PyObject *py_dsdb_am_rodc(PyObject *self, PyObject *args)
943 PyObject *py_ldb;
944 struct ldb_context *ldb;
945 int ret;
946 bool am_rodc;
948 if (!PyArg_ParseTuple(args, "O", &py_ldb))
949 return NULL;
951 PyErr_LDB_OR_RAISE(py_ldb, ldb);
953 ret = samdb_rodc(ldb, &am_rodc);
954 if (ret != LDB_SUCCESS) {
955 PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb));
956 return NULL;
959 return PyBool_FromLong(am_rodc);
963 call into samdb_is_pdc()
965 static PyObject *py_dsdb_am_pdc(PyObject *self, PyObject *args)
967 PyObject *py_ldb;
968 struct ldb_context *ldb;
969 bool am_pdc;
971 if (!PyArg_ParseTuple(args, "O", &py_ldb))
972 return NULL;
974 PyErr_LDB_OR_RAISE(py_ldb, ldb);
976 am_pdc = samdb_is_pdc(ldb);
977 return PyBool_FromLong(am_pdc);
981 static PyMethodDef py_dsdb_methods[] = {
982 { "_samdb_server_site_name", (PyCFunction)py_samdb_server_site_name,
983 METH_VARARGS, "Get the server site name as a string"},
984 { "_dsdb_convert_schema_to_openldap",
985 (PyCFunction)py_dsdb_convert_schema_to_openldap, METH_VARARGS,
986 "dsdb_convert_schema_to_openldap(ldb, target_str, mapping) -> str\n"
987 "Create an OpenLDAP schema from a schema." },
988 { "_samdb_set_domain_sid", (PyCFunction)py_samdb_set_domain_sid,
989 METH_VARARGS,
990 "samdb_set_domain_sid(samdb, sid)\n"
991 "Set SID of domain to use." },
992 { "_samdb_get_domain_sid", (PyCFunction)py_samdb_get_domain_sid,
993 METH_VARARGS,
994 "samdb_get_domain_sid(samdb)\n"
995 "Get SID of domain in use." },
996 { "_samdb_ntds_invocation_id", (PyCFunction)py_samdb_ntds_invocation_id,
997 METH_VARARGS, "get the NTDS invocation ID GUID as a string"},
998 { "_samdb_set_ntds_settings_dn", (PyCFunction)py_samdb_set_ntds_settings_dn,
999 METH_VARARGS,
1000 "samdb_set_ntds_settings_dn(samdb, ntds_settings_dn)\n"
1001 "Set NTDS Settings DN for this LDB (allows it to be set before the DB fully exists)." },
1002 { "_dsdb_get_oid_from_attid", (PyCFunction)py_dsdb_get_oid_from_attid,
1003 METH_VARARGS, NULL },
1004 { "_dsdb_get_attid_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_attid_from_lDAPDisplayName,
1005 METH_VARARGS, NULL },
1006 { "_dsdb_get_syntax_oid_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_syntax_oid_from_lDAPDisplayName,
1007 METH_VARARGS, NULL },
1008 { "_dsdb_get_systemFlags_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_systemFlags_from_lDAPDisplayName,
1009 METH_VARARGS, NULL },
1010 { "_dsdb_get_linkId_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_linkId_from_lDAPDisplayName,
1011 METH_VARARGS, NULL },
1012 { "_dsdb_get_lDAPDisplayName_by_attid", (PyCFunction)py_dsdb_get_lDAPDisplayName_by_attid,
1013 METH_VARARGS, NULL },
1014 { "_dsdb_get_backlink_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_backlink_from_lDAPDisplayName,
1015 METH_VARARGS, NULL },
1016 { "_dsdb_set_ntds_invocation_id",
1017 (PyCFunction)py_dsdb_set_ntds_invocation_id, METH_VARARGS,
1018 NULL },
1019 { "_samdb_ntds_objectGUID", (PyCFunction)py_samdb_ntds_objectGUID,
1020 METH_VARARGS, "get the NTDS objectGUID as a string"},
1021 { "_dsdb_set_global_schema", (PyCFunction)py_dsdb_set_global_schema,
1022 METH_VARARGS, NULL },
1023 { "_dsdb_load_partition_usn", (PyCFunction)py_dsdb_load_partition_usn,
1024 METH_VARARGS,
1025 "get uSNHighest and uSNUrgent from the partition @REPLCHANGED"},
1026 { "_dsdb_set_am_rodc",
1027 (PyCFunction)py_dsdb_set_am_rodc, METH_VARARGS,
1028 NULL },
1029 { "_am_rodc",
1030 (PyCFunction)py_dsdb_am_rodc, METH_VARARGS,
1031 NULL },
1032 { "_am_pdc",
1033 (PyCFunction)py_dsdb_am_pdc, METH_VARARGS,
1034 NULL },
1035 { "_dsdb_set_schema_from_ldif", (PyCFunction)py_dsdb_set_schema_from_ldif, METH_VARARGS,
1036 NULL },
1037 { "_dsdb_set_schema_from_ldb", (PyCFunction)py_dsdb_set_schema_from_ldb, METH_VARARGS,
1038 NULL },
1039 { "_dsdb_write_prefixes_from_schema_to_ldb", (PyCFunction)py_dsdb_write_prefixes_from_schema_to_ldb, METH_VARARGS,
1040 NULL },
1041 { "_dsdb_get_partitions_dn", (PyCFunction)py_dsdb_get_partitions_dn, METH_VARARGS, NULL },
1042 { "_dsdb_DsReplicaAttribute", (PyCFunction)py_dsdb_DsReplicaAttribute, METH_VARARGS, NULL },
1043 { "_dsdb_normalise_attributes", (PyCFunction)py_dsdb_normalise_attributes, METH_VARARGS, NULL },
1044 { NULL }
1047 void initdsdb(void)
1049 PyObject *m;
1051 m = Py_InitModule3("dsdb", py_dsdb_methods,
1052 "Python bindings for the directory service databases.");
1053 if (m == NULL)
1054 return;
1056 #define ADD_DSDB_FLAG(val) PyModule_AddObject(m, #val, PyInt_FromLong(val))
1058 /* "userAccountControl" flags */
1059 ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
1060 ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
1061 ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
1062 ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
1063 ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
1064 ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
1065 ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
1067 ADD_DSDB_FLAG(UF_SCRIPT);
1068 ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
1069 ADD_DSDB_FLAG(UF_00000004);
1070 ADD_DSDB_FLAG(UF_HOMEDIR_REQUIRED);
1071 ADD_DSDB_FLAG(UF_LOCKOUT);
1072 ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
1073 ADD_DSDB_FLAG(UF_PASSWD_CANT_CHANGE);
1074 ADD_DSDB_FLAG(UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED);
1075 ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
1076 ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
1077 ADD_DSDB_FLAG(UF_00000400);
1078 ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
1079 ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
1080 ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
1081 ADD_DSDB_FLAG(UF_00004000);
1082 ADD_DSDB_FLAG(UF_00008000);
1083 ADD_DSDB_FLAG(UF_DONT_EXPIRE_PASSWD);
1084 ADD_DSDB_FLAG(UF_MNS_LOGON_ACCOUNT);
1085 ADD_DSDB_FLAG(UF_SMARTCARD_REQUIRED);
1086 ADD_DSDB_FLAG(UF_TRUSTED_FOR_DELEGATION);
1087 ADD_DSDB_FLAG(UF_NOT_DELEGATED);
1088 ADD_DSDB_FLAG(UF_USE_DES_KEY_ONLY);
1089 ADD_DSDB_FLAG(UF_DONT_REQUIRE_PREAUTH);
1090 ADD_DSDB_FLAG(UF_PASSWORD_EXPIRED);
1091 ADD_DSDB_FLAG(UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION);
1092 ADD_DSDB_FLAG(UF_NO_AUTH_DATA_REQUIRED);
1093 ADD_DSDB_FLAG(UF_PARTIAL_SECRETS_ACCOUNT);
1095 /* groupType flags */
1096 ADD_DSDB_FLAG(GTYPE_SECURITY_BUILTIN_LOCAL_GROUP);
1097 ADD_DSDB_FLAG(GTYPE_SECURITY_GLOBAL_GROUP);
1098 ADD_DSDB_FLAG(GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1099 ADD_DSDB_FLAG(GTYPE_SECURITY_UNIVERSAL_GROUP);
1100 ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_GLOBAL_GROUP);
1101 ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP);
1102 ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_UNIVERSAL_GROUP);
1104 /* "sAMAccountType" flags */
1105 ADD_DSDB_FLAG(ATYPE_NORMAL_ACCOUNT);
1106 ADD_DSDB_FLAG(ATYPE_WORKSTATION_TRUST);
1107 ADD_DSDB_FLAG(ATYPE_INTERDOMAIN_TRUST);
1108 ADD_DSDB_FLAG(ATYPE_SECURITY_GLOBAL_GROUP);
1109 ADD_DSDB_FLAG(ATYPE_SECURITY_LOCAL_GROUP);
1110 ADD_DSDB_FLAG(ATYPE_SECURITY_UNIVERSAL_GROUP);
1111 ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_GLOBAL_GROUP);
1112 ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_LOCAL_GROUP);
1113 ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_UNIVERSAL_GROUP);
1115 /* "domainFunctionality", "forestFunctionality" flags in the rootDSE */
1116 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2000);
1117 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003_MIXED);
1118 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003);
1119 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008);
1120 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008_R2);
1122 /* nc replica flags */
1123 ADD_DSDB_FLAG(INSTANCE_TYPE_IS_NC_HEAD);
1124 ADD_DSDB_FLAG(INSTANCE_TYPE_UNINSTANT);
1125 ADD_DSDB_FLAG(INSTANCE_TYPE_WRITE);
1126 ADD_DSDB_FLAG(INSTANCE_TYPE_NC_ABOVE);
1127 ADD_DSDB_FLAG(INSTANCE_TYPE_NC_COMING);
1128 ADD_DSDB_FLAG(INSTANCE_TYPE_NC_GOING);
1130 /* "systemFlags" */
1131 ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NC);
1132 ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_DOMAIN);
1133 ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NOT_GC_REPLICATED);
1134 ADD_DSDB_FLAG(SYSTEM_FLAG_SCHEMA_BASE_OBJECT);
1135 ADD_DSDB_FLAG(SYSTEM_FLAG_ATTR_IS_RDN);
1136 ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
1137 ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE);
1138 ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME);
1139 ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE);
1140 ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_MOVE);
1141 ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_RENAME);
1142 ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_DELETE);
1144 /* Kerberos encryption type constants */
1145 ADD_DSDB_FLAG(ENC_ALL_TYPES);
1146 ADD_DSDB_FLAG(ENC_CRC32);
1147 ADD_DSDB_FLAG(ENC_RSA_MD5);
1148 ADD_DSDB_FLAG(ENC_RC4_HMAC_MD5);
1149 ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES128);
1150 ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES256);
1152 ADD_DSDB_FLAG(SEARCH_FLAG_ATTINDEX);
1153 ADD_DSDB_FLAG(SEARCH_FLAG_PDNTATTINDEX);
1154 ADD_DSDB_FLAG(SEARCH_FLAG_ANR);
1155 ADD_DSDB_FLAG(SEARCH_FLAG_PRESERVEONDELETE);
1156 ADD_DSDB_FLAG(SEARCH_FLAG_COPY);
1157 ADD_DSDB_FLAG(SEARCH_FLAG_TUPLEINDEX);
1158 ADD_DSDB_FLAG(SEARCH_FLAG_SUBTREEATTRINDEX);
1159 ADD_DSDB_FLAG(SEARCH_FLAG_CONFIDENTIAL);
1160 ADD_DSDB_FLAG(SEARCH_FLAG_NEVERVALUEAUDIT);
1161 ADD_DSDB_FLAG(SEARCH_FLAG_RODC_ATTRIBUTE);
1163 ADD_DSDB_FLAG(DS_FLAG_ATTR_NOT_REPLICATED);
1164 ADD_DSDB_FLAG(DS_FLAG_ATTR_REQ_PARTIAL_SET_MEMBER);
1165 ADD_DSDB_FLAG(DS_FLAG_ATTR_IS_CONSTRUCTED);
1167 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_AUTO_TOPOLOGY_DISABLED);
1168 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_CLEANUP_DISABLED);
1169 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_MIN_HOPS_DISABLED);
1170 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_DETECT_STALE_DISABLED);
1171 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_INTER_SITE_AUTO_TOPOLOGY_DISABLED);
1172 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_GROUP_CACHING_ENABLED);
1173 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_FORCE_KCC_WHISTLER_BEHAVIOR);
1174 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_RAND_BH_SELECTION_DISABLED);
1175 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_SCHEDULE_HASHING_ENABLED);
1176 ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_REDUNDANT_SERVER_TOPOLOGY_ENABLED);
1178 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_IS_GC);
1179 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_INBOUND_REPL);
1180 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL);
1181 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_NTDSCONN_XLATE);
1182 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_SPN_REGISTRATION);
1184 ADD_DSDB_FLAG(NTDSCONN_KCC_GC_TOPOLOGY);
1185 ADD_DSDB_FLAG(NTDSCONN_KCC_RING_TOPOLOGY);
1186 ADD_DSDB_FLAG(NTDSCONN_KCC_MINIMIZE_HOPS_TOPOLOGY);
1187 ADD_DSDB_FLAG(NTDSCONN_KCC_STALE_SERVERS_TOPOLOGY);
1188 ADD_DSDB_FLAG(NTDSCONN_KCC_OSCILLATING_CONNECTION_TOPOLOGY);
1189 ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_GC_TOPOLOGY);
1190 ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_TOPOLOGY);
1191 ADD_DSDB_FLAG(NTDSCONN_KCC_SERVER_FAILOVER_TOPOLOGY);
1192 ADD_DSDB_FLAG(NTDSCONN_KCC_SITE_FAILOVER_TOPOLOGY);
1193 ADD_DSDB_FLAG(NTDSCONN_KCC_REDUNDANT_SERVER_TOPOLOGY);
1195 ADD_DSDB_FLAG(NTDSCONN_OPT_IS_GENERATED);
1196 ADD_DSDB_FLAG(NTDSCONN_OPT_TWOWAY_SYNC);
1197 ADD_DSDB_FLAG(NTDSCONN_OPT_OVERRIDE_NOTIFY_DEFAULT);
1198 ADD_DSDB_FLAG(NTDSCONN_OPT_USE_NOTIFY);
1199 ADD_DSDB_FLAG(NTDSCONN_OPT_DISABLE_INTERSITE_COMPRESSION);
1200 ADD_DSDB_FLAG(NTDSCONN_OPT_USER_OWNED_SCHEDULE);
1201 ADD_DSDB_FLAG(NTDSCONN_OPT_RODC_TOPOLOGY);
1203 /* Site Link Object options */
1204 ADD_DSDB_FLAG(NTDSSITELINK_OPT_USE_NOTIFY);
1205 ADD_DSDB_FLAG(NTDSSITELINK_OPT_TWOWAY_SYNC);
1206 ADD_DSDB_FLAG(NTDSSITELINK_OPT_DISABLE_COMPRESSION);
1208 /* GPO policy flags */
1209 ADD_DSDB_FLAG(GPLINK_OPT_DISABLE);
1210 ADD_DSDB_FLAG(GPLINK_OPT_ENFORCE);
1211 ADD_DSDB_FLAG(GPO_FLAG_USER_DISABLE);
1212 ADD_DSDB_FLAG(GPO_FLAG_MACHINE_DISABLE);
1213 ADD_DSDB_FLAG(GPO_INHERIT);
1214 ADD_DSDB_FLAG(GPO_BLOCK_INHERITANCE);
1216 #define ADD_DSDB_STRING(val) PyModule_AddObject(m, #val, PyString_FromString(val))
1218 ADD_DSDB_STRING(DSDB_SYNTAX_BINARY_DN);
1219 ADD_DSDB_STRING(DSDB_SYNTAX_STRING_DN);
1220 ADD_DSDB_STRING(DSDB_SYNTAX_OR_NAME);
1221 ADD_DSDB_STRING(DSDB_CONTROL_DBCHECK);