source: trunk/server/source4/dsdb/pydsdb.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 23.5 KB
RevLine 
[740]1/*
2 Unix SMB/CIFS implementation.
3 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007-2010
4 Copyright (C) Matthias Dieter Wallnöfer 2009
5
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.
10
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.
15
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/>.
18*/
19
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"
31
32void initdsdb(void);
33
34/* There's no Py_ssize_t in 2.4, apparently */
35#if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5
36typedef int Py_ssize_t;
37typedef inquiry lenfunc;
38typedef intargfunc ssizeargfunc;
39#endif
40
41/* FIXME: These should be in a header file somewhere, once we finish moving
42 * away from SWIG .. */
43#define PyErr_LDB_OR_RAISE(py_ldb, ldb) \
44/* if (!PyLdb_Check(py_ldb)) { \
45 PyErr_SetString(py_ldb_get_exception(), "Ldb connection object required"); \
46 return NULL; \
47 } */\
48 ldb = PyLdb_AsLdbContext(py_ldb);
49
50static PyObject *py_ldb_get_exception(void)
51{
52 PyObject *mod = PyImport_ImportModule("ldb");
53 if (mod == NULL)
54 return NULL;
55
56 return PyObject_GetAttrString(mod, "LdbError");
57}
58
59static void PyErr_SetLdbError(PyObject *error, int ret, struct ldb_context *ldb_ctx)
60{
61 if (ret == LDB_ERR_PYTHON_EXCEPTION)
62 return; /* Python exception should already be set, just keep that */
63
64 PyErr_SetObject(error,
65 Py_BuildValue(discard_const_p(char, "(i,s)"), ret,
66 ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
67}
68
69static PyObject *py_samdb_server_site_name(PyObject *self, PyObject *args)
70{
71 PyObject *py_ldb, *result;
72 struct ldb_context *ldb;
73 const char *site;
74 TALLOC_CTX *mem_ctx;
75
76 if (!PyArg_ParseTuple(args, "O", &py_ldb))
77 return NULL;
78
79 PyErr_LDB_OR_RAISE(py_ldb, ldb);
80
81 mem_ctx = talloc_new(NULL);
82 if (mem_ctx == NULL) {
83 PyErr_NoMemory();
84 return NULL;
85 }
86
87 site = samdb_server_site_name(ldb, mem_ctx);
88 if (site == NULL) {
89 PyErr_SetString(PyExc_RuntimeError, "Failed to find server site");
90 talloc_free(mem_ctx);
91 return NULL;
92 }
93
94 result = PyString_FromString(site);
95 talloc_free(mem_ctx);
96 return result;
97}
98
99static PyObject *py_dsdb_convert_schema_to_openldap(PyObject *self,
100 PyObject *args)
101{
102 char *target_str, *mapping;
103 PyObject *py_ldb;
104 struct ldb_context *ldb;
105 PyObject *ret;
106 char *retstr;
107
108 if (!PyArg_ParseTuple(args, "Oss", &py_ldb, &target_str, &mapping))
109 return NULL;
110
111 PyErr_LDB_OR_RAISE(py_ldb, ldb);
112
113 retstr = dsdb_convert_schema_to_openldap(ldb, target_str, mapping);
114 if (retstr == NULL) {
115 PyErr_SetString(PyExc_RuntimeError,
116 "dsdb_convert_schema_to_openldap failed");
117 return NULL;
118 }
119
120 ret = PyString_FromString(retstr);
121 talloc_free(retstr);
122 return ret;
123}
124
125static PyObject *py_samdb_set_domain_sid(PyLdbObject *self, PyObject *args)
126{
127 PyObject *py_ldb, *py_sid;
128 struct ldb_context *ldb;
129 struct dom_sid *sid;
130 bool ret;
131
132 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_sid))
133 return NULL;
134
135 PyErr_LDB_OR_RAISE(py_ldb, ldb);
136
137 sid = dom_sid_parse_talloc(NULL, PyString_AsString(py_sid));
138 if (sid == NULL) {
139 PyErr_NoMemory();
140 return NULL;
141 }
142
143 ret = samdb_set_domain_sid(ldb, sid);
144 talloc_free(sid);
145 if (!ret) {
146 PyErr_SetString(PyExc_RuntimeError, "set_domain_sid failed");
147 return NULL;
148 }
149 Py_RETURN_NONE;
150}
151
152static PyObject *py_samdb_set_ntds_settings_dn(PyLdbObject *self, PyObject *args)
153{
154 PyObject *py_ldb, *py_ntds_settings_dn;
155 struct ldb_context *ldb;
156 struct ldb_dn *ntds_settings_dn;
157 TALLOC_CTX *tmp_ctx;
158 bool ret;
159
160 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ntds_settings_dn))
161 return NULL;
162
163 PyErr_LDB_OR_RAISE(py_ldb, ldb);
164
165 tmp_ctx = talloc_new(NULL);
166 if (tmp_ctx == NULL) {
167 PyErr_NoMemory();
168 return NULL;
169 }
170
171 if (!PyObject_AsDn(tmp_ctx, py_ntds_settings_dn, ldb, &ntds_settings_dn)) {
172 /* exception thrown by "PyObject_AsDn" */
173 talloc_free(tmp_ctx);
174 return NULL;
175 }
176
177 ret = samdb_set_ntds_settings_dn(ldb, ntds_settings_dn);
178 talloc_free(tmp_ctx);
179 if (!ret) {
180 PyErr_SetString(PyExc_RuntimeError, "set_ntds_settings_dn failed");
181 return NULL;
182 }
183 Py_RETURN_NONE;
184}
185
186static PyObject *py_samdb_get_domain_sid(PyLdbObject *self, PyObject *args)
187{
188 PyObject *py_ldb;
189 struct ldb_context *ldb;
190 const struct dom_sid *sid;
191 PyObject *ret;
192 char *retstr;
193
194 if (!PyArg_ParseTuple(args, "O", &py_ldb))
195 return NULL;
196
197 PyErr_LDB_OR_RAISE(py_ldb, ldb);
198
199 sid = samdb_domain_sid(ldb);
200 if (!sid) {
201 PyErr_SetString(PyExc_RuntimeError, "samdb_domain_sid failed");
202 return NULL;
203 }
204
205 retstr = dom_sid_string(NULL, sid);
206 if (retstr == NULL) {
207 PyErr_NoMemory();
208 return NULL;
209 }
210 ret = PyString_FromString(retstr);
211 talloc_free(retstr);
212 return ret;
213}
214
215static PyObject *py_samdb_ntds_invocation_id(PyObject *self, PyObject *args)
216{
217 PyObject *py_ldb, *result;
218 struct ldb_context *ldb;
219 const struct GUID *guid;
220 char *retstr;
221
222 if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
223 return NULL;
224 }
225
226 PyErr_LDB_OR_RAISE(py_ldb, ldb);
227
228 guid = samdb_ntds_invocation_id(ldb);
229 if (guid == NULL) {
230 PyErr_SetString(PyExc_RuntimeError,
231 "Failed to find NTDS invocation ID");
232 return NULL;
233 }
234
235 retstr = GUID_string(NULL, guid);
236 if (retstr == NULL) {
237 PyErr_NoMemory();
238 return NULL;
239 }
240 result = PyString_FromString(retstr);
241 talloc_free(retstr);
242 return result;
243}
244
245static PyObject *py_dsdb_get_oid_from_attid(PyObject *self, PyObject *args)
246{
247 PyObject *py_ldb;
248 struct ldb_context *ldb;
249 uint32_t attid;
250 struct dsdb_schema *schema;
251 const char *oid;
252 PyObject *ret;
253 WERROR status;
254 TALLOC_CTX *mem_ctx;
255
256 if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid))
257 return NULL;
258
259 PyErr_LDB_OR_RAISE(py_ldb, ldb);
260
261 mem_ctx = talloc_new(NULL);
262 if (!mem_ctx) {
263 PyErr_NoMemory();
264 return NULL;
265 }
266
267 schema = dsdb_get_schema(ldb, mem_ctx);
268 if (!schema) {
269 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb \n");
270 talloc_free(mem_ctx);
271 return NULL;
272 }
273
274 status = dsdb_schema_pfm_oid_from_attid(schema->prefixmap, attid,
275 mem_ctx, &oid);
276 if (!W_ERROR_IS_OK(status)) {
277 PyErr_SetWERROR(status);
278 talloc_free(mem_ctx);
279 return NULL;
280 }
281
282 ret = PyString_FromString(oid);
283
284 talloc_free(mem_ctx);
285
286 return ret;
287}
288
289
290static PyObject *py_dsdb_get_attid_from_lDAPDisplayName(PyObject *self, PyObject *args)
291{
292 PyObject *py_ldb, *is_schema_nc;
293 struct ldb_context *ldb;
294 struct dsdb_schema *schema;
295 const char *ldap_display_name;
296 bool schema_nc = false;
297 const struct dsdb_attribute *a;
298 uint32_t attid;
299
300 if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &is_schema_nc))
301 return NULL;
302
303 PyErr_LDB_OR_RAISE(py_ldb, ldb);
304
305 if (is_schema_nc) {
306 if (!PyBool_Check(is_schema_nc)) {
307 PyErr_SetString(PyExc_TypeError, "Expected boolean is_schema_nc");
308 return NULL;
309 }
310 if (is_schema_nc == Py_True) {
311 schema_nc = true;
312 }
313 }
314
315 schema = dsdb_get_schema(ldb, NULL);
316
317 if (!schema) {
318 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
319 return NULL;
320 }
321
322 a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
323 if (a == NULL) {
324 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
325 return NULL;
326 }
327
328 attid = dsdb_attribute_get_attid(a, schema_nc);
329
330 return PyLong_FromUnsignedLong(attid);
331}
332
333/*
334 convert a python string to a DRSUAPI drsuapi_DsReplicaAttribute attribute
335 */
336static PyObject *py_dsdb_DsReplicaAttribute(PyObject *self, PyObject *args)
337{
338 PyObject *py_ldb, *el_list, *ret;
339 struct ldb_context *ldb;
340 char *ldap_display_name;
341 const struct dsdb_attribute *a;
342 struct dsdb_schema *schema;
343 struct dsdb_syntax_ctx syntax_ctx;
344 struct ldb_message_element *el;
345 struct drsuapi_DsReplicaAttribute *attr;
346 TALLOC_CTX *tmp_ctx;
347 WERROR werr;
348 Py_ssize_t i;
349
350 if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) {
351 return NULL;
352 }
353
354 PyErr_LDB_OR_RAISE(py_ldb, ldb);
355
356 if (!PyList_Check(el_list)) {
357 PyErr_Format(PyExc_TypeError, "ldif_elements must be a list");
358 return NULL;
359 }
360
361 schema = dsdb_get_schema(ldb, NULL);
362 if (!schema) {
363 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
364 return NULL;
365 }
366
367 a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
368 if (a == NULL) {
369 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
370 return NULL;
371 }
372
373 dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
374 syntax_ctx.is_schema_nc = false;
375
376 tmp_ctx = talloc_new(ldb);
377 if (tmp_ctx == NULL) {
378 PyErr_NoMemory();
379 return NULL;
380 }
381
382 el = talloc_zero(tmp_ctx, struct ldb_message_element);
383 if (el == NULL) {
384 PyErr_NoMemory();
385 talloc_free(tmp_ctx);
386 return NULL;
387 }
388
389 el->name = ldap_display_name;
390 el->num_values = PyList_Size(el_list);
391
392 el->values = talloc_array(el, struct ldb_val, el->num_values);
393 if (el->values == NULL) {
394 PyErr_NoMemory();
395 talloc_free(tmp_ctx);
396 return NULL;
397 }
398
399 for (i = 0; i < el->num_values; i++) {
400 PyObject *item = PyList_GetItem(el_list, i);
401 if (!PyString_Check(item)) {
402 PyErr_Format(PyExc_TypeError, "ldif_elements should be strings");
403 return NULL;
404 }
405 el->values[i].data = (uint8_t *)PyString_AsString(item);
406 el->values[i].length = PyString_Size(item);
407 }
408
409 attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute);
410 if (attr == NULL) {
411 PyErr_NoMemory();
412 talloc_free(tmp_ctx);
413 return NULL;
414 }
415
416 werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr);
417 PyErr_WERROR_IS_ERR_RAISE(werr);
418
419 ret = py_return_ndr_struct("samba.dcerpc.drsuapi", "DsReplicaAttribute", attr, attr);
420
421 talloc_free(tmp_ctx);
422
423 return ret;
424}
425
426static PyObject *py_dsdb_set_ntds_invocation_id(PyObject *self, PyObject *args)
427{
428 PyObject *py_ldb, *py_guid;
429 bool ret;
430 struct GUID guid;
431 struct ldb_context *ldb;
432 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_guid))
433 return NULL;
434
435 PyErr_LDB_OR_RAISE(py_ldb, ldb);
436 GUID_from_string(PyString_AsString(py_guid), &guid);
437
438 ret = samdb_set_ntds_invocation_id(ldb, &guid);
439 if (!ret) {
440 PyErr_SetString(PyExc_RuntimeError, "set_ntds_invocation_id failed");
441 return NULL;
442 }
443 Py_RETURN_NONE;
444}
445
446static PyObject *py_samdb_ntds_objectGUID(PyObject *self, PyObject *args)
447{
448 PyObject *py_ldb, *result;
449 struct ldb_context *ldb;
450 const struct GUID *guid;
451 char *retstr;
452
453 if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
454 return NULL;
455 }
456
457 PyErr_LDB_OR_RAISE(py_ldb, ldb);
458
459 guid = samdb_ntds_objectGUID(ldb);
460 if (guid == NULL) {
461 PyErr_SetString(PyExc_RuntimeError, "Failed to find NTDS GUID");
462 return NULL;
463 }
464
465 retstr = GUID_string(NULL, guid);
466 if (retstr == NULL) {
467 PyErr_NoMemory();
468 return NULL;
469 }
470 result = PyString_FromString(retstr);
471 talloc_free(retstr);
472 return result;
473}
474
475static PyObject *py_dsdb_set_global_schema(PyObject *self, PyObject *args)
476{
477 PyObject *py_ldb;
478 struct ldb_context *ldb;
479 int ret;
480 if (!PyArg_ParseTuple(args, "O", &py_ldb))
481 return NULL;
482
483 PyErr_LDB_OR_RAISE(py_ldb, ldb);
484
485 ret = dsdb_set_global_schema(ldb);
486 PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
487
488 Py_RETURN_NONE;
489}
490
491static PyObject *py_dsdb_load_partition_usn(PyObject *self, PyObject *args)
492{
493 PyObject *py_dn, *py_ldb, *result;
494 struct ldb_dn *dn;
495 uint64_t highest_uSN, urgent_uSN;
496 struct ldb_context *ldb;
497 TALLOC_CTX *mem_ctx;
498 int ret;
499
500 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_dn)) {
501 return NULL;
502 }
503
504 PyErr_LDB_OR_RAISE(py_ldb, ldb);
505
506 mem_ctx = talloc_new(NULL);
507 if (mem_ctx == NULL) {
508 PyErr_NoMemory();
509 return NULL;
510 }
511
512 if (!PyObject_AsDn(mem_ctx, py_dn, ldb, &dn)) {
513 talloc_free(mem_ctx);
514 return NULL;
515 }
516
517 ret = dsdb_load_partition_usn(ldb, dn, &highest_uSN, &urgent_uSN);
518 if (ret != LDB_SUCCESS) {
519 PyErr_Format(PyExc_RuntimeError,
520 "Failed to load partition [%s] uSN - %s",
521 ldb_dn_get_linearized(dn),
522 ldb_errstring(ldb));
523 talloc_free(mem_ctx);
524 return NULL;
525 }
526
527 talloc_free(mem_ctx);
528
529 result = PyDict_New();
530
531 PyDict_SetItemString(result, "uSNHighest", PyInt_FromLong((uint64_t)highest_uSN));
532 PyDict_SetItemString(result, "uSNUrgent", PyInt_FromLong((uint64_t)urgent_uSN));
533
534
535 return result;
536}
537
538static PyObject *py_dsdb_set_am_rodc(PyObject *self, PyObject *args)
539{
540 PyObject *py_ldb;
541 bool ret;
542 struct ldb_context *ldb;
543 int py_val;
544
545 if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &py_val))
546 return NULL;
547
548 PyErr_LDB_OR_RAISE(py_ldb, ldb);
549 ret = samdb_set_am_rodc(ldb, (bool)py_val);
550 if (!ret) {
551 PyErr_SetString(PyExc_RuntimeError, "set_am_rodc failed");
552 return NULL;
553 }
554 Py_RETURN_NONE;
555}
556
557static PyObject *py_dsdb_set_schema_from_ldif(PyObject *self, PyObject *args)
558{
559 WERROR result;
560 char *pf, *df;
561 PyObject *py_ldb;
562 struct ldb_context *ldb;
563
564 if (!PyArg_ParseTuple(args, "Oss", &py_ldb, &pf, &df))
565 return NULL;
566
567 PyErr_LDB_OR_RAISE(py_ldb, ldb);
568
569 result = dsdb_set_schema_from_ldif(ldb, pf, df);
570 PyErr_WERROR_IS_ERR_RAISE(result);
571
572 Py_RETURN_NONE;
573}
574
575static PyObject *py_dsdb_set_schema_from_ldb(PyObject *self, PyObject *args)
576{
577 PyObject *py_ldb;
578 struct ldb_context *ldb;
579 PyObject *py_from_ldb;
580 struct ldb_context *from_ldb;
581 struct dsdb_schema *schema;
582 int ret;
583 if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_from_ldb))
584 return NULL;
585
586 PyErr_LDB_OR_RAISE(py_ldb, ldb);
587
588 PyErr_LDB_OR_RAISE(py_from_ldb, from_ldb);
589
590 schema = dsdb_get_schema(from_ldb, NULL);
591 if (!schema) {
592 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on 'from' ldb!\n");
593 return NULL;
594 }
595
596 ret = dsdb_reference_schema(ldb, schema, true);
597 PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
598
599 Py_RETURN_NONE;
600}
601
602static PyObject *py_dsdb_write_prefixes_from_schema_to_ldb(PyObject *self, PyObject *args)
603{
604 PyObject *py_ldb;
605 struct ldb_context *ldb;
606 WERROR result;
607 struct dsdb_schema *schema;
608
609 if (!PyArg_ParseTuple(args, "O", &py_ldb))
610 return NULL;
611
612 PyErr_LDB_OR_RAISE(py_ldb, ldb);
613
614 schema = dsdb_get_schema(ldb, NULL);
615 if (!schema) {
616 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on ldb!\n");
617 return NULL;
618 }
619
620 result = dsdb_write_prefixes_from_schema_to_ldb(NULL, ldb, schema);
621 PyErr_WERROR_IS_ERR_RAISE(result);
622
623 Py_RETURN_NONE;
624}
625
626
627static PyObject *py_dsdb_get_partitions_dn(PyObject *self, PyObject *args)
628{
629 struct ldb_context *ldb;
630 struct ldb_dn *dn;
631 PyObject *py_ldb, *ret;
632 PyObject *mod;
633
634 mod = PyImport_ImportModule("ldb");
635
636 if (!PyArg_ParseTuple(args, "O", &py_ldb))
637 return NULL;
638
639 PyErr_LDB_OR_RAISE(py_ldb, ldb);
640
641 dn = samdb_partitions_dn(ldb, NULL);
642 if (dn == NULL) {
643 PyErr_NoMemory();
644 return NULL;
645 }
646 ret = PyLdbDn_FromDn(dn);
647 talloc_free(dn);
648 return ret;
649}
650
651
652/*
653 call into samdb_rodc()
654 */
655static PyObject *py_dsdb_am_rodc(PyObject *self, PyObject *args)
656{
657 PyObject *py_ldb;
658 struct ldb_context *ldb;
659 int ret;
660 bool am_rodc;
661
662 if (!PyArg_ParseTuple(args, "O", &py_ldb))
663 return NULL;
664
665 PyErr_LDB_OR_RAISE(py_ldb, ldb);
666
667 ret = samdb_rodc(ldb, &am_rodc);
668 if (ret != LDB_SUCCESS) {
669 PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb));
670 return NULL;
671 }
672
673 return PyBool_FromLong(am_rodc);
674}
675
676
677static PyMethodDef py_dsdb_methods[] = {
678 { "_samdb_server_site_name", (PyCFunction)py_samdb_server_site_name,
679 METH_VARARGS, "Get the server site name as a string"},
680 { "_dsdb_convert_schema_to_openldap",
681 (PyCFunction)py_dsdb_convert_schema_to_openldap, METH_VARARGS,
682 "dsdb_convert_schema_to_openldap(ldb, target_str, mapping) -> str\n"
683 "Create an OpenLDAP schema from a schema." },
684 { "_samdb_set_domain_sid", (PyCFunction)py_samdb_set_domain_sid,
685 METH_VARARGS,
686 "samdb_set_domain_sid(samdb, sid)\n"
687 "Set SID of domain to use." },
688 { "_samdb_get_domain_sid", (PyCFunction)py_samdb_get_domain_sid,
689 METH_VARARGS,
690 "samdb_get_domain_sid(samdb)\n"
691 "Get SID of domain in use." },
692 { "_samdb_ntds_invocation_id", (PyCFunction)py_samdb_ntds_invocation_id,
693 METH_VARARGS, "get the NTDS invocation ID GUID as a string"},
694 { "_samdb_set_ntds_settings_dn", (PyCFunction)py_samdb_set_ntds_settings_dn,
695 METH_VARARGS,
696 "samdb_set_ntds_settings_dn(samdb, ntds_settings_dn)\n"
697 "Set NTDS Settings DN for this LDB (allows it to be set before the DB fully exists)." },
698 { "_dsdb_get_oid_from_attid", (PyCFunction)py_dsdb_get_oid_from_attid,
699 METH_VARARGS, NULL },
700 { "_dsdb_get_attid_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_attid_from_lDAPDisplayName,
701 METH_VARARGS, NULL },
702 { "_dsdb_set_ntds_invocation_id",
703 (PyCFunction)py_dsdb_set_ntds_invocation_id, METH_VARARGS,
704 NULL },
705 { "_samdb_ntds_objectGUID", (PyCFunction)py_samdb_ntds_objectGUID,
706 METH_VARARGS, "get the NTDS objectGUID as a string"},
707 { "_dsdb_set_global_schema", (PyCFunction)py_dsdb_set_global_schema,
708 METH_VARARGS, NULL },
709 { "_dsdb_load_partition_usn", (PyCFunction)py_dsdb_load_partition_usn,
710 METH_VARARGS,
711 "get uSNHighest and uSNUrgent from the partition @REPLCHANGED"},
712 { "_dsdb_set_am_rodc",
713 (PyCFunction)py_dsdb_set_am_rodc, METH_VARARGS,
714 NULL },
715 { "_am_rodc",
716 (PyCFunction)py_dsdb_am_rodc, METH_VARARGS,
717 NULL },
718 { "_dsdb_set_schema_from_ldif", (PyCFunction)py_dsdb_set_schema_from_ldif, METH_VARARGS,
719 NULL },
720 { "_dsdb_set_schema_from_ldb", (PyCFunction)py_dsdb_set_schema_from_ldb, METH_VARARGS,
721 NULL },
722 { "_dsdb_write_prefixes_from_schema_to_ldb", (PyCFunction)py_dsdb_write_prefixes_from_schema_to_ldb, METH_VARARGS,
723 NULL },
724 { "_dsdb_get_partitions_dn", (PyCFunction)py_dsdb_get_partitions_dn, METH_VARARGS, NULL },
725 { "_dsdb_DsReplicaAttribute", (PyCFunction)py_dsdb_DsReplicaAttribute, METH_VARARGS, NULL },
726 { NULL }
727};
728
729void initdsdb(void)
730{
731 PyObject *m;
732
733 m = Py_InitModule3("dsdb", py_dsdb_methods,
734 "Python bindings for the directory service databases.");
735 if (m == NULL)
736 return;
737
738#define ADD_DSDB_FLAG(val) PyModule_AddObject(m, #val, PyInt_FromLong(val))
739
740 /* "userAccountControl" flags */
741 ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
742 ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
743 ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
744 ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
745 ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
746 ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
747 ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
748
749 ADD_DSDB_FLAG(UF_SCRIPT);
750 ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
751 ADD_DSDB_FLAG(UF_00000004);
752 ADD_DSDB_FLAG(UF_HOMEDIR_REQUIRED);
753 ADD_DSDB_FLAG(UF_LOCKOUT);
754 ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
755 ADD_DSDB_FLAG(UF_PASSWD_CANT_CHANGE);
756 ADD_DSDB_FLAG(UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED);
757 ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
758 ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
759 ADD_DSDB_FLAG(UF_00000400);
760 ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
761 ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
762 ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
763 ADD_DSDB_FLAG(UF_00004000);
764 ADD_DSDB_FLAG(UF_00008000);
765 ADD_DSDB_FLAG(UF_DONT_EXPIRE_PASSWD);
766 ADD_DSDB_FLAG(UF_MNS_LOGON_ACCOUNT);
767 ADD_DSDB_FLAG(UF_SMARTCARD_REQUIRED);
768 ADD_DSDB_FLAG(UF_TRUSTED_FOR_DELEGATION);
769 ADD_DSDB_FLAG(UF_NOT_DELEGATED);
770 ADD_DSDB_FLAG(UF_USE_DES_KEY_ONLY);
771 ADD_DSDB_FLAG(UF_DONT_REQUIRE_PREAUTH);
772 ADD_DSDB_FLAG(UF_PASSWORD_EXPIRED);
773 ADD_DSDB_FLAG(UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION);
774 ADD_DSDB_FLAG(UF_NO_AUTH_DATA_REQUIRED);
775 ADD_DSDB_FLAG(UF_PARTIAL_SECRETS_ACCOUNT);
776
777 /* groupType flags */
778 ADD_DSDB_FLAG(GTYPE_SECURITY_BUILTIN_LOCAL_GROUP);
779 ADD_DSDB_FLAG(GTYPE_SECURITY_GLOBAL_GROUP);
780 ADD_DSDB_FLAG(GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
781 ADD_DSDB_FLAG(GTYPE_SECURITY_UNIVERSAL_GROUP);
782 ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_GLOBAL_GROUP);
783 ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP);
784 ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_UNIVERSAL_GROUP);
785
786 /* "sAMAccountType" flags */
787 ADD_DSDB_FLAG(ATYPE_NORMAL_ACCOUNT);
788 ADD_DSDB_FLAG(ATYPE_WORKSTATION_TRUST);
789 ADD_DSDB_FLAG(ATYPE_INTERDOMAIN_TRUST);
790 ADD_DSDB_FLAG(ATYPE_SECURITY_GLOBAL_GROUP);
791 ADD_DSDB_FLAG(ATYPE_SECURITY_LOCAL_GROUP);
792 ADD_DSDB_FLAG(ATYPE_SECURITY_UNIVERSAL_GROUP);
793 ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_GLOBAL_GROUP);
794 ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_LOCAL_GROUP);
795 ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_UNIVERSAL_GROUP);
796
797 /* "domainFunctionality", "forestFunctionality" flags in the rootDSE */
798 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2000);
799 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003_MIXED);
800 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003);
801 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008);
802 ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008_R2);
803
804 /* "systemFlags" */
805 ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NC);
806 ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_DOMAIN);
807 ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NOT_GC_REPLICATED);
808 ADD_DSDB_FLAG(SYSTEM_FLAG_SCHEMA_BASE_OBJECT);
809 ADD_DSDB_FLAG(SYSTEM_FLAG_ATTR_IS_RDN);
810 ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
811 ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE);
812 ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME);
813 ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE);
814 ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_MOVE);
815 ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_RENAME);
816 ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_DELETE);
817
818 /* Kerberos encryption type constants */
819 ADD_DSDB_FLAG(ENC_ALL_TYPES);
820 ADD_DSDB_FLAG(ENC_CRC32);
821 ADD_DSDB_FLAG(ENC_RSA_MD5);
822 ADD_DSDB_FLAG(ENC_RC4_HMAC_MD5);
823 ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES128);
824 ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES256);
825
826 ADD_DSDB_FLAG(SEARCH_FLAG_ATTINDEX);
827 ADD_DSDB_FLAG(SEARCH_FLAG_PDNTATTINDEX);
828 ADD_DSDB_FLAG(SEARCH_FLAG_ANR);
829 ADD_DSDB_FLAG(SEARCH_FLAG_PRESERVEONDELETE);
830 ADD_DSDB_FLAG(SEARCH_FLAG_COPY);
831 ADD_DSDB_FLAG(SEARCH_FLAG_TUPLEINDEX);
832 ADD_DSDB_FLAG(SEARCH_FLAG_SUBTREEATTRINDEX);
833 ADD_DSDB_FLAG(SEARCH_FLAG_CONFIDENTIAL);
834 ADD_DSDB_FLAG(SEARCH_FLAG_NEVERVALUEAUDIT);
835 ADD_DSDB_FLAG(SEARCH_FLAG_RODC_ATTRIBUTE);
836
837 ADD_DSDB_FLAG(DS_FLAG_ATTR_NOT_REPLICATED);
838 ADD_DSDB_FLAG(DS_FLAG_ATTR_REQ_PARTIAL_SET_MEMBER);
839 ADD_DSDB_FLAG(DS_FLAG_ATTR_IS_CONSTRUCTED);
840
841 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_IS_GC);
842 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_INBOUND_REPL);
843 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL);
844 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_NTDSCONN_XLATE);
845 ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_SPN_REGISTRATION);
846
847 ADD_DSDB_FLAG(NTDSCONN_KCC_GC_TOPOLOGY);
848 ADD_DSDB_FLAG(NTDSCONN_KCC_RING_TOPOLOGY);
849 ADD_DSDB_FLAG(NTDSCONN_KCC_MINIMIZE_HOPS_TOPOLOGY);
850 ADD_DSDB_FLAG(NTDSCONN_KCC_STALE_SERVERS_TOPOLOGY);
851 ADD_DSDB_FLAG(NTDSCONN_KCC_OSCILLATING_CONNECTION_TOPOLOGY);
852 ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_GC_TOPOLOGY);
853 ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_TOPOLOGY);
854 ADD_DSDB_FLAG(NTDSCONN_KCC_SERVER_FAILOVER_TOPOLOGY);
855 ADD_DSDB_FLAG(NTDSCONN_KCC_SITE_FAILOVER_TOPOLOGY);
856 ADD_DSDB_FLAG(NTDSCONN_KCC_REDUNDANT_SERVER_TOPOLOGY);
857
858 /* GPO policy flags */
859 ADD_DSDB_FLAG(GPLINK_OPT_DISABLE);
860 ADD_DSDB_FLAG(GPLINK_OPT_ENFORCE);
861 ADD_DSDB_FLAG(GPO_FLAG_USER_DISABLE);
862 ADD_DSDB_FLAG(GPO_FLAG_MACHINE_DISABLE);
863 ADD_DSDB_FLAG(GPO_INHERIT);
864 ADD_DSDB_FLAG(GPO_BLOCK_INHERITANCE);
865}
Note: See TracBrowser for help on using the repository browser.