source4/dsdb/pydsdb.c

   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
  32 void initdsdb(void);
  33
  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
  40
  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);
  48
  49 static PyObject *py_ldb_get_exception(void)
  50 {
  51         PyObject *mod = PyImport_ImportModule("ldb");
  52         if (mod == NULL)
  53                 return NULL;
  54
  55         return PyObject_GetAttrString(mod, "LdbError");
  56 }
  57
  58 static void PyErr_SetLdbError(PyObject *error, int ret, struct ldb_context *ldb_ctx)
  59 {
  60         if (ret == LDB_ERR_PYTHON_EXCEPTION)
  61                 return; /* Python exception should already be set, just keep that */
  62
  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)));
  66 }
  67
  68 static PyObject *py_samdb_server_site_name(PyObject *self, PyObject *args)
  69 {
  70         PyObject *py_ldb, *result;
  71         struct ldb_context *ldb;
  72         const char *site;
  73         TALLOC_CTX *mem_ctx;
  74
  75         if (!PyArg_ParseTuple(args, "O", &py_ldb))
  76                 return NULL;
  77
  78         PyErr_LDB_OR_RAISE(py_ldb, ldb);
  79
  80         mem_ctx = talloc_new(NULL);
  81         if (mem_ctx == NULL) {
  82                 PyErr_NoMemory();
  83                 return NULL;
  84         }
  85
  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;
  91         }
  92
  93         result = PyString_FromString(site);
  94         talloc_free(mem_ctx);
  95         return result;
  96 }
  97
  98 static PyObject *py_dsdb_convert_schema_to_openldap(PyObject *self,
  99                                                     PyObject *args)
 100 {
 101         char *target_str, *mapping;
 102         PyObject *py_ldb;
 103         struct ldb_context *ldb;
 104         PyObject *ret;
 105         char *retstr;
 106
 107         if (!PyArg_ParseTuple(args, "Oss", &py_ldb, &target_str, &mapping))
 108                 return NULL;
 109
 110         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 111
 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;
 117         }
 118
 119         ret = PyString_FromString(retstr);
 120         talloc_free(retstr);
 121         return ret;
 122 }
 123
 124 static PyObject *py_samdb_set_domain_sid(PyLdbObject *self, PyObject *args)
 125 {
 126         PyObject *py_ldb, *py_sid;
 127         struct ldb_context *ldb;
 128         struct dom_sid *sid;
 129         bool ret;
 130
 131         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_sid))
 132                 return NULL;
 133
 134         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 135
 136         sid = dom_sid_parse_talloc(NULL, PyString_AsString(py_sid));
 137         if (sid == NULL) {
 138                 PyErr_NoMemory();
 139                 return NULL;
 140         }
 141
 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;
 147         }
 148         Py_RETURN_NONE;
 149 }
 150
 151 static PyObject *py_samdb_set_ntds_settings_dn(PyLdbObject *self, PyObject *args)
 152 {
 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;
 158
 159         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ntds_settings_dn))
 160                 return NULL;
 161
 162         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 163
 164         tmp_ctx = talloc_new(NULL);
 165         if (tmp_ctx == NULL) {
 166                 PyErr_NoMemory();
 167                 return NULL;
 168         }
 169
 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;
 174         }
 175
 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;
 181         }
 182         Py_RETURN_NONE;
 183 }
 184
 185 static PyObject *py_samdb_get_domain_sid(PyLdbObject *self, PyObject *args)
 186 {
 187         PyObject *py_ldb;
 188         struct ldb_context *ldb;
 189         const struct dom_sid *sid;
 190         PyObject *ret;
 191         char *retstr;
 192
 193         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 194                 return NULL;
 195
 196         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 197
 198         sid = samdb_domain_sid(ldb);
 199         if (!sid) {
 200                 PyErr_SetString(PyExc_RuntimeError, "samdb_domain_sid failed");
 201                 return NULL;
 202         }
 203
 204         retstr = dom_sid_string(NULL, sid);
 205         if (retstr == NULL) {
 206                 PyErr_NoMemory();
 207                 return NULL;
 208         }
 209         ret = PyString_FromString(retstr);
 210         talloc_free(retstr);
 211         return ret;
 212 }
 213
 214 static PyObject *py_samdb_ntds_invocation_id(PyObject *self, PyObject *args)
 215 {
 216         PyObject *py_ldb, *result;
 217         struct ldb_context *ldb;
 218         const struct GUID *guid;
 219         char *retstr;
 220
 221         if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
 222                 return NULL;
 223         }
 224
 225         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 226
 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;
 232         }
 233
 234         retstr = GUID_string(NULL, guid);
 235         if (retstr == NULL) {
 236                 PyErr_NoMemory();
 237                 return NULL;
 238         }
 239         result = PyString_FromString(retstr);
 240         talloc_free(retstr);
 241         return result;
 242 }
 243
 244 static PyObject *py_dsdb_get_oid_from_attid(PyObject *self, PyObject *args)
 245 {
 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;
 254
 255         if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid))
 256                 return NULL;
 257
 258         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 259
 260         mem_ctx = talloc_new(NULL);
 261         if (!mem_ctx) {
 262                 PyErr_NoMemory();
 263                 return NULL;
 264         }
 265
 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;
 271         }
 272
 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;
 279         }
 280
 281         ret = PyString_FromString(oid);
 282
 283         talloc_free(mem_ctx);
 284
 285         return ret;
 286 }
 287
 288
 289 static PyObject *py_dsdb_get_attid_from_lDAPDisplayName(PyObject *self, PyObject *args)
 290 {
 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;
 298
 299         if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &is_schema_nc))
 300                 return NULL;
 301
 302         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 303
 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;
 308                 }
 309                 if (is_schema_nc == Py_True) {
 310                         schema_nc = true;
 311                 }
 312         }
 313
 314         schema = dsdb_get_schema(ldb, NULL);
 315
 316         if (!schema) {
 317                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 318                 return NULL;
 319         }
 320
 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;
 325         }
 326
 327         attid = dsdb_attribute_get_attid(a, schema_nc);
 328
 329         return PyLong_FromUnsignedLong(attid);
 330 }
 331
 332 /*
 333   return the systemFlags as int from the attribute name
 334  */
 335 static PyObject *py_dsdb_get_systemFlags_from_lDAPDisplayName(PyObject *self, PyObject *args)
 336 {
 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;
 342
 343         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 344                 return NULL;
 345
 346         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 347
 348         schema = dsdb_get_schema(ldb, NULL);
 349
 350         if (!schema) {
 351                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 352                 return NULL;
 353         }
 354
 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;
 359         }
 360
 361         return PyInt_FromLong(attribute->systemFlags);
 362 }
 363
 364 /*
 365   return the linkID from the attribute name
 366  */
 367 static PyObject *py_dsdb_get_linkId_from_lDAPDisplayName(PyObject *self, PyObject *args)
 368 {
 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;
 374
 375         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 376                 return NULL;
 377
 378         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 379
 380         schema = dsdb_get_schema(ldb, NULL);
 381
 382         if (!schema) {
 383                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 384                 return NULL;
 385         }
 386
 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;
 391         }
 392
 393         return PyInt_FromLong(attribute->linkID);
 394 }
 395
 396 /*
 397   return the backlink attribute name (if any) for an attribute
 398  */
 399 static PyObject *py_dsdb_get_backlink_from_lDAPDisplayName(PyObject *self, PyObject *args)
 400 {
 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;
 406
 407         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 408                 return NULL;
 409
 410         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 411
 412         schema = dsdb_get_schema(ldb, NULL);
 413
 414         if (!schema) {
 415                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 416                 return NULL;
 417         }
 418
 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;
 423         }
 424
 425         if (attribute->linkID == 0) {
 426                 Py_RETURN_NONE;
 427         }
 428
 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;
 434         }
 435
 436         return PyString_FromString(target_attr->lDAPDisplayName);
 437 }
 438
 439
 440 static PyObject *py_dsdb_get_lDAPDisplayName_by_attid(PyObject *self, PyObject *args)
 441 {
 442         PyObject *py_ldb;
 443         struct ldb_context *ldb;
 444         struct dsdb_schema *schema;
 445         const struct dsdb_attribute *a;
 446         uint32_t attid;
 447
 448         if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid))
 449                 return NULL;
 450
 451         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 452
 453         schema = dsdb_get_schema(ldb, NULL);
 454
 455         if (!schema) {
 456                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 457                 return NULL;
 458         }
 459
 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;
 464         }
 465
 466         return PyString_FromString(a->lDAPDisplayName);
 467 }
 468
 469
 470 /*
 471   return the attribute syntax oid as a string from the attribute name
 472  */
 473 static PyObject *py_dsdb_get_syntax_oid_from_lDAPDisplayName(PyObject *self, PyObject *args)
 474 {
 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;
 480
 481         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 482                 return NULL;
 483
 484         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 485
 486         schema = dsdb_get_schema(ldb, NULL);
 487
 488         if (!schema) {
 489                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 490                 return NULL;
 491         }
 492
 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;
 497         }
 498
 499         return PyString_FromString(attribute->syntax->ldap_oid);
 500 }
 501
 502 /*
 503   convert a python string to a DRSUAPI drsuapi_DsReplicaAttribute attribute
 504  */
 505 static PyObject *py_dsdb_DsReplicaAttribute(PyObject *self, PyObject *args)
 506 {
 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;
 518
 519         if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) {
 520                 return NULL;
 521         }
 522
 523         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 524
 525         if (!PyList_Check(el_list)) {
 526                 PyErr_Format(PyExc_TypeError, "ldif_elements must be a list");
 527                 return NULL;
 528         }
 529
 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;
 534         }
 535
 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;
 540         }
 541
 542         dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
 543         syntax_ctx.is_schema_nc = false;
 544
 545         tmp_ctx = talloc_new(ldb);
 546         if (tmp_ctx == NULL) {
 547                 PyErr_NoMemory();
 548                 return NULL;
 549         }
 550
 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;
 556         }
 557
 558         el->name = ldap_display_name;
 559         el->num_values = PyList_Size(el_list);
 560
 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;
 566         }
 567
 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;
 574                 }
 575                 el->values[i].data = (uint8_t *)PyString_AsString(item);
 576                 el->values[i].length = PyString_Size(item);
 577         }
 578
 579         attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute);
 580         if (attr == NULL) {
 581                 PyErr_NoMemory();
 582                 talloc_free(tmp_ctx);
 583                 return NULL;
 584         }
 585
 586         werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr);
 587         PyErr_WERROR_IS_ERR_RAISE(werr);
 588
 589         ret = py_return_ndr_struct("samba.dcerpc.drsuapi", "DsReplicaAttribute", attr, attr);
 590
 591         talloc_free(tmp_ctx);
 592
 593         return ret;
 594 }
 595
 596
 597 /*
 598   normalise a ldb attribute list
 599  */
 600 static PyObject *py_dsdb_normalise_attributes(PyObject *self, PyObject *args)
 601 {
 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;
 613
 614         if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) {
 615                 return NULL;
 616         }
 617
 618         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 619
 620         if (!PyList_Check(el_list)) {
 621                 PyErr_Format(PyExc_TypeError, "ldif_elements must be a list");
 622                 return NULL;
 623         }
 624
 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;
 629         }
 630
 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;
 635         }
 636
 637         dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
 638         syntax_ctx.is_schema_nc = false;
 639
 640         tmp_ctx = talloc_new(ldb);
 641         if (tmp_ctx == NULL) {
 642                 PyErr_NoMemory();
 643                 return NULL;
 644         }
 645
 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;
 651         }
 652
 653         el->name = ldap_display_name;
 654         el->num_values = PyList_Size(el_list);
 655
 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;
 661         }
 662
 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;
 669                 }
 670                 el->values[i].data = (uint8_t *)PyString_AsString(item);
 671                 el->values[i].length = PyString_Size(item);
 672         }
 673
 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;
 683                 }
 684         }
 685
 686         /* first run ldb_to_drsuapi, then convert back again. This has
 687          * the effect of normalising the attributes
 688          */
 689
 690         attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute);
 691         if (attr == NULL) {
 692                 PyErr_NoMemory();
 693                 talloc_free(tmp_ctx);
 694                 return NULL;
 695         }
 696
 697         werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr);
 698         PyErr_WERROR_IS_ERR_RAISE(werr);
 699
 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);
 703
 704         ret = py_return_ndr_struct("ldb", "MessageElement", el, el);
 705
 706         talloc_free(tmp_ctx);
 707
 708         return ret;
 709 }
 710
 711
 712 static PyObject *py_dsdb_set_ntds_invocation_id(PyObject *self, PyObject *args)
 713 {
 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;
 720
 721         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 722         GUID_from_string(PyString_AsString(py_guid), &guid);
 723
 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;
 728         }
 729         Py_RETURN_NONE;
 730 }
 731
 732 static PyObject *py_samdb_ntds_objectGUID(PyObject *self, PyObject *args)
 733 {
 734         PyObject *py_ldb, *result;
 735         struct ldb_context *ldb;
 736         const struct GUID *guid;
 737         char *retstr;
 738
 739         if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
 740                 return NULL;
 741         }
 742
 743         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 744
 745         guid = samdb_ntds_objectGUID(ldb);
 746         if (guid == NULL) {
 747                 PyErr_SetString(PyExc_RuntimeError, "Failed to find NTDS GUID");
 748                 return NULL;
 749         }
 750
 751         retstr = GUID_string(NULL, guid);
 752         if (retstr == NULL) {
 753                 PyErr_NoMemory();
 754                 return NULL;
 755         }
 756         result = PyString_FromString(retstr);
 757         talloc_free(retstr);
 758         return result;
 759 }
 760
 761 static PyObject *py_dsdb_set_global_schema(PyObject *self, PyObject *args)
 762 {
 763         PyObject *py_ldb;
 764         struct ldb_context *ldb;
 765         int ret;
 766         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 767                 return NULL;
 768
 769         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 770
 771         ret = dsdb_set_global_schema(ldb);
 772         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 773
 774         Py_RETURN_NONE;
 775 }
 776
 777 static PyObject *py_dsdb_load_partition_usn(PyObject *self, PyObject *args)
 778 {
 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;
 785
 786         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_dn)) {
 787                 return NULL;
 788         }
 789
 790         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 791
 792         mem_ctx = talloc_new(NULL);
 793         if (mem_ctx == NULL) {
 794                 PyErr_NoMemory();
 795                 return NULL;
 796         }
 797
 798         if (!pyldb_Object_AsDn(mem_ctx, py_dn, ldb, &dn)) {
 799                 talloc_free(mem_ctx);
 800                 return NULL;
 801         }
 802
 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;
 811         }
 812
 813         talloc_free(mem_ctx);
 814
 815         result = PyDict_New();
 816
 817         PyDict_SetItemString(result, "uSNHighest", PyInt_FromLong((uint64_t)highest_uSN));
 818         PyDict_SetItemString(result, "uSNUrgent", PyInt_FromLong((uint64_t)urgent_uSN));
 819
 820
 821         return result;
 822 }
 823
 824 static PyObject *py_dsdb_set_am_rodc(PyObject *self, PyObject *args)
 825 {
 826         PyObject *py_ldb;
 827         bool ret;
 828         struct ldb_context *ldb;
 829         int py_val;
 830
 831         if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &py_val))
 832                 return NULL;
 833
 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;
 839         }
 840         Py_RETURN_NONE;
 841 }
 842
 843 static PyObject *py_dsdb_set_schema_from_ldif(PyObject *self, PyObject *args)
 844 {
 845         WERROR result;
 846         char *pf, *df, *dn;
 847         PyObject *py_ldb;
 848         struct ldb_context *ldb;
 849
 850         if (!PyArg_ParseTuple(args, "Osss", &py_ldb, &pf, &df, &dn))
 851                 return NULL;
 852
 853         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 854
 855         result = dsdb_set_schema_from_ldif(ldb, pf, df, dn);
 856         PyErr_WERROR_IS_ERR_RAISE(result);
 857
 858         Py_RETURN_NONE;
 859 }
 860
 861 static PyObject *py_dsdb_set_schema_from_ldb(PyObject *self, PyObject *args)
 862 {
 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;
 871
 872         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 873
 874         PyErr_LDB_OR_RAISE(py_from_ldb, from_ldb);
 875
 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;
 880         }
 881
 882         ret = dsdb_reference_schema(ldb, schema, true);
 883         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 884
 885         Py_RETURN_NONE;
 886 }
 887
 888 static PyObject *py_dsdb_write_prefixes_from_schema_to_ldb(PyObject *self, PyObject *args)
 889 {
 890         PyObject *py_ldb;
 891         struct ldb_context *ldb;
 892         WERROR result;
 893         struct dsdb_schema *schema;
 894
 895         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 896                 return NULL;
 897
 898         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 899
 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;
 904         }
 905
 906         result = dsdb_write_prefixes_from_schema_to_ldb(NULL, ldb, schema);
 907         PyErr_WERROR_IS_ERR_RAISE(result);
 908
 909         Py_RETURN_NONE;
 910 }
 911
 912
 913 static PyObject *py_dsdb_get_partitions_dn(PyObject *self, PyObject *args)
 914 {
 915         struct ldb_context *ldb;
 916         struct ldb_dn *dn;
 917         PyObject *py_ldb, *ret;
 918         PyObject *mod;
 919
 920         mod = PyImport_ImportModule("ldb");
 921
 922         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 923                 return NULL;
 924
 925         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 926
 927         dn = samdb_partitions_dn(ldb, NULL);
 928         if (dn == NULL) {
 929                 PyErr_NoMemory();
 930                 return NULL;
 931         }
 932         ret = pyldb_Dn_FromDn(dn);
 933         talloc_free(dn);
 934         return ret;
 935 }
 936
 937
 938 /*
 939   call into samdb_rodc()
 940  */
 941 static PyObject *py_dsdb_am_rodc(PyObject *self, PyObject *args)
 942 {
 943         PyObject *py_ldb;
 944         struct ldb_context *ldb;
 945         int ret;
 946         bool am_rodc;
 947
 948         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 949                 return NULL;
 950
 951         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 952
 953         ret = samdb_rodc(ldb, &am_rodc);
 954         if (ret != LDB_SUCCESS) {
 955                 PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb));
 956                 return NULL;
 957         }
 958
 959         return PyBool_FromLong(am_rodc);
 960 }
 961
 962 /*
 963   call into samdb_is_pdc()
 964  */
 965 static PyObject *py_dsdb_am_pdc(PyObject *self, PyObject *args)
 966 {
 967         PyObject *py_ldb;
 968         struct ldb_context *ldb;
 969         bool am_pdc;
 970
 971         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 972                 return NULL;
 973
 974         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 975
 976         am_pdc = samdb_is_pdc(ldb);
 977         return PyBool_FromLong(am_pdc);
 978 }
 979
 980
 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 }
1045 };
1046
1047 void initdsdb(void)
1048 {
1049         PyObject *m;
1050
1051         m = Py_InitModule3("dsdb", py_dsdb_methods,
1052                            "Python bindings for the directory service databases.");
1053         if (m == NULL)
1054                 return;
1055
1056 #define ADD_DSDB_FLAG(val)  PyModule_AddObject(m, #val, PyInt_FromLong(val))
1057
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);
1066
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);
1094
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);
1103
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);
1114
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);
1121
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);
1129
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);
1143
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);
1151
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);
1162
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);
1166
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);
1177
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);
1183
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);
1194
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);
1202
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);
1207
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);
1215
1216 #define ADD_DSDB_STRING(val)  PyModule_AddObject(m, #val, PyString_FromString(val))
1217
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);
1222 }