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 (!py_check_dcerpc_type(py_ldb, "ldb", "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 #define PyErr_LDB_DN_OR_RAISE(py_ldb_dn, dn) \
  50         if (!py_check_dcerpc_type(py_ldb_dn, "ldb", "Dn")) { \
  51                 PyErr_SetString(py_ldb_get_exception(), "ldb Dn object required"); \
  52                 return NULL; \
  53         } \
  54         dn = pyldb_Dn_AsDn(py_ldb_dn);
  55
  56 static PyObject *py_ldb_get_exception(void)
  57 {
  58         PyObject *mod = PyImport_ImportModule("ldb");
  59         if (mod == NULL)
  60                 return NULL;
  61
  62         return PyObject_GetAttrString(mod, "LdbError");
  63 }
  64
  65 static void PyErr_SetLdbError(PyObject *error, int ret, struct ldb_context *ldb_ctx)
  66 {
  67         if (ret == LDB_ERR_PYTHON_EXCEPTION)
  68                 return; /* Python exception should already be set, just keep that */
  69
  70         PyErr_SetObject(error,
  71                         Py_BuildValue(discard_const_p(char, "(i,s)"), ret,
  72                         ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
  73 }
  74
  75 static PyObject *py_samdb_server_site_name(PyObject *self, PyObject *args)
  76 {
  77         PyObject *py_ldb, *result;
  78         struct ldb_context *ldb;
  79         const char *site;
  80         TALLOC_CTX *mem_ctx;
  81
  82         if (!PyArg_ParseTuple(args, "O", &py_ldb))
  83                 return NULL;
  84
  85         PyErr_LDB_OR_RAISE(py_ldb, ldb);
  86
  87         mem_ctx = talloc_new(NULL);
  88         if (mem_ctx == NULL) {
  89                 PyErr_NoMemory();
  90                 return NULL;
  91         }
  92
  93         site = samdb_server_site_name(ldb, mem_ctx);
  94         if (site == NULL) {
  95                 PyErr_SetString(PyExc_RuntimeError, "Failed to find server site");
  96                 talloc_free(mem_ctx);
  97                 return NULL;
  98         }
  99
 100         result = PyString_FromString(site);
 101         talloc_free(mem_ctx);
 102         return result;
 103 }
 104
 105 static PyObject *py_dsdb_convert_schema_to_openldap(PyObject *self,
 106                                                     PyObject *args)
 107 {
 108         char *target_str, *mapping;
 109         PyObject *py_ldb;
 110         struct ldb_context *ldb;
 111         PyObject *ret;
 112         char *retstr;
 113
 114         if (!PyArg_ParseTuple(args, "Oss", &py_ldb, &target_str, &mapping))
 115                 return NULL;
 116
 117         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 118
 119         retstr = dsdb_convert_schema_to_openldap(ldb, target_str, mapping);
 120         if (retstr == NULL) {
 121                 PyErr_SetString(PyExc_RuntimeError,
 122                                                 "dsdb_convert_schema_to_openldap failed");
 123                 return NULL;
 124         }
 125
 126         ret = PyString_FromString(retstr);
 127         talloc_free(retstr);
 128         return ret;
 129 }
 130
 131 static PyObject *py_samdb_set_domain_sid(PyLdbObject *self, PyObject *args)
 132 {
 133         PyObject *py_ldb, *py_sid;
 134         struct ldb_context *ldb;
 135         struct dom_sid *sid;
 136         bool ret;
 137
 138         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_sid))
 139                 return NULL;
 140
 141         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 142
 143         sid = dom_sid_parse_talloc(NULL, PyString_AsString(py_sid));
 144         if (sid == NULL) {
 145                 PyErr_NoMemory();
 146                 return NULL;
 147         }
 148
 149         ret = samdb_set_domain_sid(ldb, sid);
 150         talloc_free(sid);
 151         if (!ret) {
 152                 PyErr_SetString(PyExc_RuntimeError, "set_domain_sid failed");
 153                 return NULL;
 154         }
 155         Py_RETURN_NONE;
 156 }
 157
 158 static PyObject *py_samdb_set_ntds_settings_dn(PyLdbObject *self, PyObject *args)
 159 {
 160         PyObject *py_ldb, *py_ntds_settings_dn;
 161         struct ldb_context *ldb;
 162         struct ldb_dn *ntds_settings_dn;
 163         TALLOC_CTX *tmp_ctx;
 164         bool ret;
 165
 166         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ntds_settings_dn))
 167                 return NULL;
 168
 169         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 170
 171         tmp_ctx = talloc_new(NULL);
 172         if (tmp_ctx == NULL) {
 173                 PyErr_NoMemory();
 174                 return NULL;
 175         }
 176
 177         if (!pyldb_Object_AsDn(tmp_ctx, py_ntds_settings_dn, ldb, &ntds_settings_dn)) {
 178                 /* exception thrown by "pyldb_Object_AsDn" */
 179                 talloc_free(tmp_ctx);
 180                 return NULL;
 181         }
 182
 183         ret = samdb_set_ntds_settings_dn(ldb, ntds_settings_dn);
 184         talloc_free(tmp_ctx);
 185         if (!ret) {
 186                 PyErr_SetString(PyExc_RuntimeError, "set_ntds_settings_dn failed");
 187                 return NULL;
 188         }
 189         Py_RETURN_NONE;
 190 }
 191
 192 static PyObject *py_samdb_get_domain_sid(PyLdbObject *self, PyObject *args)
 193 {
 194         PyObject *py_ldb;
 195         struct ldb_context *ldb;
 196         const struct dom_sid *sid;
 197         PyObject *ret;
 198         char *retstr;
 199
 200         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 201                 return NULL;
 202
 203         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 204
 205         sid = samdb_domain_sid(ldb);
 206         if (!sid) {
 207                 PyErr_SetString(PyExc_RuntimeError, "samdb_domain_sid failed");
 208                 return NULL;
 209         }
 210
 211         retstr = dom_sid_string(NULL, sid);
 212         if (retstr == NULL) {
 213                 PyErr_NoMemory();
 214                 return NULL;
 215         }
 216         ret = PyString_FromString(retstr);
 217         talloc_free(retstr);
 218         return ret;
 219 }
 220
 221 static PyObject *py_samdb_ntds_invocation_id(PyObject *self, PyObject *args)
 222 {
 223         PyObject *py_ldb, *result;
 224         struct ldb_context *ldb;
 225         const struct GUID *guid;
 226         char *retstr;
 227
 228         if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
 229                 return NULL;
 230         }
 231
 232         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 233
 234         guid = samdb_ntds_invocation_id(ldb);
 235         if (guid == NULL) {
 236                 PyErr_SetString(PyExc_RuntimeError,
 237                                                 "Failed to find NTDS invocation ID");
 238                 return NULL;
 239         }
 240
 241         retstr = GUID_string(NULL, guid);
 242         if (retstr == NULL) {
 243                 PyErr_NoMemory();
 244                 return NULL;
 245         }
 246         result = PyString_FromString(retstr);
 247         talloc_free(retstr);
 248         return result;
 249 }
 250
 251 static PyObject *py_dsdb_get_oid_from_attid(PyObject *self, PyObject *args)
 252 {
 253         PyObject *py_ldb;
 254         struct ldb_context *ldb;
 255         uint32_t attid;
 256         struct dsdb_schema *schema;
 257         const char *oid;
 258         PyObject *ret;
 259         WERROR status;
 260         TALLOC_CTX *mem_ctx;
 261
 262         if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid))
 263                 return NULL;
 264
 265         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 266
 267         mem_ctx = talloc_new(NULL);
 268         if (!mem_ctx) {
 269                 PyErr_NoMemory();
 270                 return NULL;
 271         }
 272
 273         schema = dsdb_get_schema(ldb, mem_ctx);
 274         if (!schema) {
 275                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb \n");
 276                 talloc_free(mem_ctx);
 277                 return NULL;
 278         }
 279
 280         status = dsdb_schema_pfm_oid_from_attid(schema->prefixmap, attid,
 281                                                 mem_ctx, &oid);
 282         if (!W_ERROR_IS_OK(status)) {
 283                 PyErr_SetWERROR(status);
 284                 talloc_free(mem_ctx);
 285                 return NULL;
 286         }
 287
 288         ret = PyString_FromString(oid);
 289
 290         talloc_free(mem_ctx);
 291
 292         return ret;
 293 }
 294
 295
 296 static PyObject *py_dsdb_get_attid_from_lDAPDisplayName(PyObject *self, PyObject *args)
 297 {
 298         PyObject *py_ldb, *is_schema_nc;
 299         struct ldb_context *ldb;
 300         struct dsdb_schema *schema;
 301         const char *ldap_display_name;
 302         bool schema_nc = false;
 303         const struct dsdb_attribute *a;
 304         uint32_t attid;
 305
 306         if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &is_schema_nc))
 307                 return NULL;
 308
 309         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 310
 311         if (is_schema_nc) {
 312                 if (!PyBool_Check(is_schema_nc)) {
 313                         PyErr_SetString(PyExc_TypeError, "Expected boolean is_schema_nc");
 314                         return NULL;
 315                 }
 316                 if (is_schema_nc == Py_True) {
 317                         schema_nc = true;
 318                 }
 319         }
 320
 321         schema = dsdb_get_schema(ldb, NULL);
 322
 323         if (!schema) {
 324                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 325                 return NULL;
 326         }
 327
 328         a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
 329         if (a == NULL) {
 330                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
 331                 return NULL;
 332         }
 333
 334         attid = dsdb_attribute_get_attid(a, schema_nc);
 335
 336         return PyLong_FromUnsignedLong(attid);
 337 }
 338
 339 /*
 340   return the systemFlags as int from the attribute name
 341  */
 342 static PyObject *py_dsdb_get_systemFlags_from_lDAPDisplayName(PyObject *self, PyObject *args)
 343 {
 344         PyObject *py_ldb;
 345         struct ldb_context *ldb;
 346         struct dsdb_schema *schema;
 347         const char *ldap_display_name;
 348         const struct dsdb_attribute *attribute;
 349
 350         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 351                 return NULL;
 352
 353         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 354
 355         schema = dsdb_get_schema(ldb, NULL);
 356
 357         if (!schema) {
 358                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 359                 return NULL;
 360         }
 361
 362         attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
 363         if (attribute == NULL) {
 364                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
 365                 return NULL;
 366         }
 367
 368         return PyInt_FromLong(attribute->systemFlags);
 369 }
 370
 371 /*
 372   return the linkID from the attribute name
 373  */
 374 static PyObject *py_dsdb_get_linkId_from_lDAPDisplayName(PyObject *self, PyObject *args)
 375 {
 376         PyObject *py_ldb;
 377         struct ldb_context *ldb;
 378         struct dsdb_schema *schema;
 379         const char *ldap_display_name;
 380         const struct dsdb_attribute *attribute;
 381
 382         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 383                 return NULL;
 384
 385         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 386
 387         schema = dsdb_get_schema(ldb, NULL);
 388
 389         if (!schema) {
 390                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 391                 return NULL;
 392         }
 393
 394         attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
 395         if (attribute == NULL) {
 396                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
 397                 return NULL;
 398         }
 399
 400         return PyInt_FromLong(attribute->linkID);
 401 }
 402
 403 /*
 404   return the backlink attribute name (if any) for an attribute
 405  */
 406 static PyObject *py_dsdb_get_backlink_from_lDAPDisplayName(PyObject *self, PyObject *args)
 407 {
 408         PyObject *py_ldb;
 409         struct ldb_context *ldb;
 410         struct dsdb_schema *schema;
 411         const char *ldap_display_name;
 412         const struct dsdb_attribute *attribute, *target_attr;
 413
 414         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 415                 return NULL;
 416
 417         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 418
 419         schema = dsdb_get_schema(ldb, NULL);
 420
 421         if (!schema) {
 422                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 423                 return NULL;
 424         }
 425
 426         attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
 427         if (attribute == NULL) {
 428                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
 429                 return NULL;
 430         }
 431
 432         if (attribute->linkID == 0) {
 433                 Py_RETURN_NONE;
 434         }
 435
 436         target_attr = dsdb_attribute_by_linkID(schema, attribute->linkID ^ 1);
 437         if (target_attr == NULL) {
 438                 /* when we add pseudo-backlinks we'll need to handle
 439                    them here */
 440                 Py_RETURN_NONE;
 441         }
 442
 443         return PyString_FromString(target_attr->lDAPDisplayName);
 444 }
 445
 446
 447 static PyObject *py_dsdb_get_lDAPDisplayName_by_attid(PyObject *self, PyObject *args)
 448 {
 449         PyObject *py_ldb;
 450         struct ldb_context *ldb;
 451         struct dsdb_schema *schema;
 452         const struct dsdb_attribute *a;
 453         uint32_t attid;
 454
 455         if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid))
 456                 return NULL;
 457
 458         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 459
 460         schema = dsdb_get_schema(ldb, NULL);
 461
 462         if (!schema) {
 463                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 464                 return NULL;
 465         }
 466
 467         a = dsdb_attribute_by_attributeID_id(schema, attid);
 468         if (a == NULL) {
 469                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '0x%08x'", attid);
 470                 return NULL;
 471         }
 472
 473         return PyString_FromString(a->lDAPDisplayName);
 474 }
 475
 476
 477 /*
 478   return the attribute syntax oid as a string from the attribute name
 479  */
 480 static PyObject *py_dsdb_get_syntax_oid_from_lDAPDisplayName(PyObject *self, PyObject *args)
 481 {
 482         PyObject *py_ldb;
 483         struct ldb_context *ldb;
 484         struct dsdb_schema *schema;
 485         const char *ldap_display_name;
 486         const struct dsdb_attribute *attribute;
 487
 488         if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name))
 489                 return NULL;
 490
 491         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 492
 493         schema = dsdb_get_schema(ldb, NULL);
 494
 495         if (!schema) {
 496                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 497                 return NULL;
 498         }
 499
 500         attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
 501         if (attribute == NULL) {
 502                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
 503                 return NULL;
 504         }
 505
 506         return PyString_FromString(attribute->syntax->ldap_oid);
 507 }
 508
 509 /*
 510   convert a python string to a DRSUAPI drsuapi_DsReplicaAttribute attribute
 511  */
 512 static PyObject *py_dsdb_DsReplicaAttribute(PyObject *self, PyObject *args)
 513 {
 514         PyObject *py_ldb, *el_list, *ret;
 515         struct ldb_context *ldb;
 516         char *ldap_display_name;
 517         const struct dsdb_attribute *a;
 518         struct dsdb_schema *schema;
 519         struct dsdb_syntax_ctx syntax_ctx;
 520         struct ldb_message_element *el;
 521         struct drsuapi_DsReplicaAttribute *attr;
 522         TALLOC_CTX *tmp_ctx;
 523         WERROR werr;
 524         Py_ssize_t i;
 525
 526         if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) {
 527                 return NULL;
 528         }
 529
 530         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 531
 532         if (!PyList_Check(el_list)) {
 533                 PyErr_Format(PyExc_TypeError, "ldif_elements must be a list");
 534                 return NULL;
 535         }
 536
 537         schema = dsdb_get_schema(ldb, NULL);
 538         if (!schema) {
 539                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 540                 return NULL;
 541         }
 542
 543         a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
 544         if (a == NULL) {
 545                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
 546                 return NULL;
 547         }
 548
 549         dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
 550         syntax_ctx.is_schema_nc = false;
 551
 552         tmp_ctx = talloc_new(ldb);
 553         if (tmp_ctx == NULL) {
 554                 PyErr_NoMemory();
 555                 return NULL;
 556         }
 557
 558         el = talloc_zero(tmp_ctx, struct ldb_message_element);
 559         if (el == NULL) {
 560                 PyErr_NoMemory();
 561                 talloc_free(tmp_ctx);
 562                 return NULL;
 563         }
 564
 565         el->name = ldap_display_name;
 566         el->num_values = PyList_Size(el_list);
 567
 568         el->values = talloc_array(el, struct ldb_val, el->num_values);
 569         if (el->values == NULL) {
 570                 PyErr_NoMemory();
 571                 talloc_free(tmp_ctx);
 572                 return NULL;
 573         }
 574
 575         for (i = 0; i < el->num_values; i++) {
 576                 PyObject *item = PyList_GetItem(el_list, i);
 577                 if (!PyString_Check(item)) {
 578                         PyErr_Format(PyExc_TypeError, "ldif_elements should be strings");
 579                         talloc_free(tmp_ctx);
 580                         return NULL;
 581                 }
 582                 el->values[i].data = (uint8_t *)PyString_AsString(item);
 583                 el->values[i].length = PyString_Size(item);
 584         }
 585
 586         attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute);
 587         if (attr == NULL) {
 588                 PyErr_NoMemory();
 589                 talloc_free(tmp_ctx);
 590                 return NULL;
 591         }
 592
 593         werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr);
 594         PyErr_WERROR_NOT_OK_RAISE(werr);
 595
 596         ret = py_return_ndr_struct("samba.dcerpc.drsuapi", "DsReplicaAttribute", attr, attr);
 597
 598         talloc_free(tmp_ctx);
 599
 600         return ret;
 601 }
 602
 603
 604 /*
 605   normalise a ldb attribute list
 606  */
 607 static PyObject *py_dsdb_normalise_attributes(PyObject *self, PyObject *args)
 608 {
 609         PyObject *py_ldb, *el_list, *ret;
 610         struct ldb_context *ldb;
 611         char *ldap_display_name;
 612         const struct dsdb_attribute *a;
 613         struct dsdb_schema *schema;
 614         struct dsdb_syntax_ctx syntax_ctx;
 615         struct ldb_message_element *el;
 616         struct drsuapi_DsReplicaAttribute *attr;
 617         TALLOC_CTX *tmp_ctx;
 618         WERROR werr;
 619         Py_ssize_t i;
 620
 621         if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) {
 622                 return NULL;
 623         }
 624
 625         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 626
 627         if (!PyList_Check(el_list)) {
 628                 PyErr_Format(PyExc_TypeError, "ldif_elements must be a list");
 629                 return NULL;
 630         }
 631
 632         schema = dsdb_get_schema(ldb, NULL);
 633         if (!schema) {
 634                 PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb");
 635                 return NULL;
 636         }
 637
 638         a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name);
 639         if (a == NULL) {
 640                 PyErr_Format(PyExc_RuntimeError, "Failed to find attribute '%s'", ldap_display_name);
 641                 return NULL;
 642         }
 643
 644         dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
 645         syntax_ctx.is_schema_nc = false;
 646
 647         tmp_ctx = talloc_new(ldb);
 648         if (tmp_ctx == NULL) {
 649                 PyErr_NoMemory();
 650                 return NULL;
 651         }
 652
 653         el = talloc_zero(tmp_ctx, struct ldb_message_element);
 654         if (el == NULL) {
 655                 PyErr_NoMemory();
 656                 talloc_free(tmp_ctx);
 657                 return NULL;
 658         }
 659
 660         el->name = ldap_display_name;
 661         el->num_values = PyList_Size(el_list);
 662
 663         el->values = talloc_array(el, struct ldb_val, el->num_values);
 664         if (el->values == NULL) {
 665                 PyErr_NoMemory();
 666                 talloc_free(tmp_ctx);
 667                 return NULL;
 668         }
 669
 670         for (i = 0; i < el->num_values; i++) {
 671                 PyObject *item = PyList_GetItem(el_list, i);
 672                 if (!PyString_Check(item)) {
 673                         PyErr_Format(PyExc_TypeError, "ldif_elements should be strings");
 674                         talloc_free(tmp_ctx);
 675                         return NULL;
 676                 }
 677                 el->values[i].data = (uint8_t *)PyString_AsString(item);
 678                 el->values[i].length = PyString_Size(item);
 679         }
 680
 681         /* Normalise "objectClass" attribute if needed */
 682         if (ldb_attr_cmp(a->lDAPDisplayName, "objectClass") == 0) {
 683                 int iret;
 684                 iret = dsdb_sort_objectClass_attr(ldb, schema, el, tmp_ctx, el);
 685                 if (iret != LDB_SUCCESS) {
 686                         PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb));
 687                         talloc_free(tmp_ctx);
 688                         return NULL;
 689                 }
 690         }
 691
 692         /* first run ldb_to_drsuapi, then convert back again. This has
 693          * the effect of normalising the attributes
 694          */
 695
 696         attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute);
 697         if (attr == NULL) {
 698                 PyErr_NoMemory();
 699                 talloc_free(tmp_ctx);
 700                 return NULL;
 701         }
 702
 703         werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr);
 704         PyErr_WERROR_NOT_OK_RAISE(werr);
 705
 706         /* now convert back again */
 707         werr = a->syntax->drsuapi_to_ldb(&syntax_ctx, a, attr, el, el);
 708         PyErr_WERROR_NOT_OK_RAISE(werr);
 709
 710         ret = py_return_ndr_struct("ldb", "MessageElement", el, el);
 711
 712         talloc_free(tmp_ctx);
 713
 714         return ret;
 715 }
 716
 717
 718 static PyObject *py_dsdb_set_ntds_invocation_id(PyObject *self, PyObject *args)
 719 {
 720         PyObject *py_ldb, *py_guid;
 721         bool ret;
 722         struct GUID guid;
 723         struct ldb_context *ldb;
 724         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_guid))
 725                 return NULL;
 726
 727         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 728         GUID_from_string(PyString_AsString(py_guid), &guid);
 729
 730         ret = samdb_set_ntds_invocation_id(ldb, &guid);
 731         if (!ret) {
 732                 PyErr_SetString(PyExc_RuntimeError, "set_ntds_invocation_id failed");
 733                 return NULL;
 734         }
 735         Py_RETURN_NONE;
 736 }
 737
 738 static PyObject *py_samdb_ntds_objectGUID(PyObject *self, PyObject *args)
 739 {
 740         PyObject *py_ldb, *result;
 741         struct ldb_context *ldb;
 742         const struct GUID *guid;
 743         char *retstr;
 744
 745         if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
 746                 return NULL;
 747         }
 748
 749         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 750
 751         guid = samdb_ntds_objectGUID(ldb);
 752         if (guid == NULL) {
 753                 PyErr_SetString(PyExc_RuntimeError, "Failed to find NTDS GUID");
 754                 return NULL;
 755         }
 756
 757         retstr = GUID_string(NULL, guid);
 758         if (retstr == NULL) {
 759                 PyErr_NoMemory();
 760                 return NULL;
 761         }
 762         result = PyString_FromString(retstr);
 763         talloc_free(retstr);
 764         return result;
 765 }
 766
 767 static PyObject *py_dsdb_set_global_schema(PyObject *self, PyObject *args)
 768 {
 769         PyObject *py_ldb;
 770         struct ldb_context *ldb;
 771         int ret;
 772         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 773                 return NULL;
 774
 775         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 776
 777         ret = dsdb_set_global_schema(ldb);
 778         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 779
 780         Py_RETURN_NONE;
 781 }
 782
 783 static PyObject *py_dsdb_load_partition_usn(PyObject *self, PyObject *args)
 784 {
 785         PyObject *py_dn, *py_ldb, *result;
 786         struct ldb_dn *dn;
 787         uint64_t highest_uSN, urgent_uSN;
 788         struct ldb_context *ldb;
 789         TALLOC_CTX *mem_ctx;
 790         int ret;
 791
 792         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_dn)) {
 793                 return NULL;
 794         }
 795
 796         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 797
 798         mem_ctx = talloc_new(NULL);
 799         if (mem_ctx == NULL) {
 800                 PyErr_NoMemory();
 801                 return NULL;
 802         }
 803
 804         if (!pyldb_Object_AsDn(mem_ctx, py_dn, ldb, &dn)) {
 805                 talloc_free(mem_ctx);
 806                 return NULL;
 807         }
 808
 809         ret = dsdb_load_partition_usn(ldb, dn, &highest_uSN, &urgent_uSN);
 810         if (ret != LDB_SUCCESS) {
 811            PyErr_Format(PyExc_RuntimeError,
 812                         "Failed to load partition [%s] uSN - %s",
 813                         ldb_dn_get_linearized(dn),
 814                         ldb_errstring(ldb));
 815            talloc_free(mem_ctx);
 816            return NULL;
 817         }
 818
 819         talloc_free(mem_ctx);
 820
 821         result = PyDict_New();
 822
 823         PyDict_SetItemString(result, "uSNHighest", PyInt_FromLong((uint64_t)highest_uSN));
 824         PyDict_SetItemString(result, "uSNUrgent", PyInt_FromLong((uint64_t)urgent_uSN));
 825
 826
 827         return result;
 828 }
 829
 830 static PyObject *py_dsdb_set_am_rodc(PyObject *self, PyObject *args)
 831 {
 832         PyObject *py_ldb;
 833         bool ret;
 834         struct ldb_context *ldb;
 835         int py_val;
 836
 837         if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &py_val))
 838                 return NULL;
 839
 840         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 841         ret = samdb_set_am_rodc(ldb, (bool)py_val);
 842         if (!ret) {
 843                 PyErr_SetString(PyExc_RuntimeError, "set_am_rodc failed");
 844                 return NULL;
 845         }
 846         Py_RETURN_NONE;
 847 }
 848
 849 static PyObject *py_dsdb_set_schema_from_ldif(PyObject *self, PyObject *args)
 850 {
 851         WERROR result;
 852         char *pf, *df, *dn;
 853         PyObject *py_ldb;
 854         struct ldb_context *ldb;
 855
 856         if (!PyArg_ParseTuple(args, "Osss", &py_ldb, &pf, &df, &dn))
 857                 return NULL;
 858
 859         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 860
 861         result = dsdb_set_schema_from_ldif(ldb, pf, df, dn);
 862         PyErr_WERROR_NOT_OK_RAISE(result);
 863
 864         Py_RETURN_NONE;
 865 }
 866
 867 static PyObject *py_dsdb_set_schema_from_ldb(PyObject *self, PyObject *args)
 868 {
 869         PyObject *py_ldb;
 870         struct ldb_context *ldb;
 871         PyObject *py_from_ldb;
 872         struct ldb_context *from_ldb;
 873         struct dsdb_schema *schema;
 874         int ret;
 875         char write_indices_and_attributes = true;
 876         if (!PyArg_ParseTuple(args, "OO|b",
 877                               &py_ldb, &py_from_ldb, &write_indices_and_attributes))
 878                 return NULL;
 879
 880         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 881
 882         PyErr_LDB_OR_RAISE(py_from_ldb, from_ldb);
 883
 884         schema = dsdb_get_schema(from_ldb, NULL);
 885         if (!schema) {
 886                 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on 'from' ldb!\n");
 887                 return NULL;
 888         }
 889
 890         ret = dsdb_reference_schema(ldb, schema, write_indices_and_attributes);
 891         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 892
 893         Py_RETURN_NONE;
 894 }
 895
 896 static PyObject *py_dsdb_write_prefixes_from_schema_to_ldb(PyObject *self, PyObject *args)
 897 {
 898         PyObject *py_ldb;
 899         struct ldb_context *ldb;
 900         WERROR result;
 901         struct dsdb_schema *schema;
 902
 903         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 904                 return NULL;
 905
 906         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 907
 908         schema = dsdb_get_schema(ldb, NULL);
 909         if (!schema) {
 910                 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on ldb!\n");
 911                 return NULL;
 912         }
 913
 914         result = dsdb_write_prefixes_from_schema_to_ldb(NULL, ldb, schema);
 915         PyErr_WERROR_NOT_OK_RAISE(result);
 916
 917         Py_RETURN_NONE;
 918 }
 919
 920
 921 static PyObject *py_dsdb_get_partitions_dn(PyObject *self, PyObject *args)
 922 {
 923         struct ldb_context *ldb;
 924         struct ldb_dn *dn;
 925         PyObject *py_ldb, *ret;
 926
 927         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 928                 return NULL;
 929
 930         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 931
 932         dn = samdb_partitions_dn(ldb, NULL);
 933         if (dn == NULL) {
 934                 PyErr_NoMemory();
 935                 return NULL;
 936         }
 937         ret = pyldb_Dn_FromDn(dn);
 938         talloc_free(dn);
 939         return ret;
 940 }
 941
 942
 943 static PyObject *py_dsdb_get_nc_root(PyObject *self, PyObject *args)
 944 {
 945         struct ldb_context *ldb;
 946         struct ldb_dn *dn, *nc_root;
 947         PyObject *py_ldb, *py_ldb_dn, *py_nc_root;
 948         int ret;
 949
 950         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ldb_dn))
 951                 return NULL;
 952
 953         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 954         PyErr_LDB_DN_OR_RAISE(py_ldb_dn, dn);
 955
 956         ret = dsdb_find_nc_root(ldb, ldb, dn, &nc_root);
 957         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 958
 959         py_nc_root = pyldb_Dn_FromDn(nc_root);
 960         talloc_unlink(ldb, nc_root);
 961         return py_nc_root;
 962 }
 963
 964 static PyObject *py_dsdb_get_wellknown_dn(PyObject *self, PyObject *args)
 965 {
 966         struct ldb_context *ldb;
 967         struct ldb_dn *nc_dn, *wk_dn;
 968         char *wkguid;
 969         PyObject *py_ldb, *py_nc_dn, *py_wk_dn;
 970         int ret;
 971
 972         if (!PyArg_ParseTuple(args, "OOs", &py_ldb, &py_nc_dn, &wkguid))
 973                 return NULL;
 974
 975         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 976         PyErr_LDB_DN_OR_RAISE(py_nc_dn, nc_dn);
 977
 978         ret = dsdb_wellknown_dn(ldb, ldb, nc_dn, wkguid, &wk_dn);
 979         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 980
 981         py_wk_dn = pyldb_Dn_FromDn(wk_dn);
 982         talloc_unlink(ldb, wk_dn);
 983         return py_wk_dn;
 984 }
 985
 986
 987 /*
 988   call into samdb_rodc()
 989  */
 990 static PyObject *py_dsdb_am_rodc(PyObject *self, PyObject *args)
 991 {
 992         PyObject *py_ldb;
 993         struct ldb_context *ldb;
 994         int ret;
 995         bool am_rodc;
 996
 997         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 998                 return NULL;
 999
1000         PyErr_LDB_OR_RAISE(py_ldb, ldb);
1001
1002         ret = samdb_rodc(ldb, &am_rodc);
1003         if (ret != LDB_SUCCESS) {
1004                 PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb));
1005                 return NULL;
1006         }
1007
1008         return PyBool_FromLong(am_rodc);
1009 }
1010
1011 /*
1012   call into samdb_is_pdc()
1013  */
1014 static PyObject *py_dsdb_am_pdc(PyObject *self, PyObject *args)
1015 {
1016         PyObject *py_ldb;
1017         struct ldb_context *ldb;
1018         bool am_pdc;
1019
1020         if (!PyArg_ParseTuple(args, "O", &py_ldb))
1021                 return NULL;
1022
1023         PyErr_LDB_OR_RAISE(py_ldb, ldb);
1024
1025         am_pdc = samdb_is_pdc(ldb);
1026         return PyBool_FromLong(am_pdc);
1027 }
1028
1029
1030 static PyMethodDef py_dsdb_methods[] = {
1031         { "_samdb_server_site_name", (PyCFunction)py_samdb_server_site_name,
1032                 METH_VARARGS, "Get the server site name as a string"},
1033         { "_dsdb_convert_schema_to_openldap",
1034                 (PyCFunction)py_dsdb_convert_schema_to_openldap, METH_VARARGS,
1035                 "dsdb_convert_schema_to_openldap(ldb, target_str, mapping) -> str\n"
1036                 "Create an OpenLDAP schema from a schema." },
1037         { "_samdb_set_domain_sid", (PyCFunction)py_samdb_set_domain_sid,
1038                 METH_VARARGS,
1039                 "samdb_set_domain_sid(samdb, sid)\n"
1040                 "Set SID of domain to use." },
1041         { "_samdb_get_domain_sid", (PyCFunction)py_samdb_get_domain_sid,
1042                 METH_VARARGS,
1043                 "samdb_get_domain_sid(samdb)\n"
1044                 "Get SID of domain in use." },
1045         { "_samdb_ntds_invocation_id", (PyCFunction)py_samdb_ntds_invocation_id,
1046                 METH_VARARGS, "get the NTDS invocation ID GUID as a string"},
1047         { "_samdb_set_ntds_settings_dn", (PyCFunction)py_samdb_set_ntds_settings_dn,
1048                 METH_VARARGS,
1049                 "samdb_set_ntds_settings_dn(samdb, ntds_settings_dn)\n"
1050                 "Set NTDS Settings DN for this LDB (allows it to be set before the DB fully exists)." },
1051         { "_dsdb_get_oid_from_attid", (PyCFunction)py_dsdb_get_oid_from_attid,
1052                 METH_VARARGS, NULL },
1053         { "_dsdb_get_attid_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_attid_from_lDAPDisplayName,
1054                 METH_VARARGS, NULL },
1055         { "_dsdb_get_syntax_oid_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_syntax_oid_from_lDAPDisplayName,
1056                 METH_VARARGS, NULL },
1057         { "_dsdb_get_systemFlags_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_systemFlags_from_lDAPDisplayName,
1058                 METH_VARARGS, NULL },
1059         { "_dsdb_get_linkId_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_linkId_from_lDAPDisplayName,
1060                 METH_VARARGS, NULL },
1061         { "_dsdb_get_lDAPDisplayName_by_attid", (PyCFunction)py_dsdb_get_lDAPDisplayName_by_attid,
1062                 METH_VARARGS, NULL },
1063         { "_dsdb_get_backlink_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_backlink_from_lDAPDisplayName,
1064                 METH_VARARGS, NULL },
1065         { "_dsdb_set_ntds_invocation_id",
1066                 (PyCFunction)py_dsdb_set_ntds_invocation_id, METH_VARARGS,
1067                 NULL },
1068         { "_samdb_ntds_objectGUID", (PyCFunction)py_samdb_ntds_objectGUID,
1069                 METH_VARARGS, "get the NTDS objectGUID as a string"},
1070         { "_dsdb_set_global_schema", (PyCFunction)py_dsdb_set_global_schema,
1071                 METH_VARARGS, NULL },
1072         { "_dsdb_load_partition_usn", (PyCFunction)py_dsdb_load_partition_usn,
1073                 METH_VARARGS,
1074                 "get uSNHighest and uSNUrgent from the partition @REPLCHANGED"},
1075         { "_dsdb_set_am_rodc",
1076                 (PyCFunction)py_dsdb_set_am_rodc, METH_VARARGS,
1077                 NULL },
1078         { "_am_rodc",
1079                 (PyCFunction)py_dsdb_am_rodc, METH_VARARGS,
1080                 NULL },
1081         { "_am_pdc",
1082                 (PyCFunction)py_dsdb_am_pdc, METH_VARARGS,
1083                 NULL },
1084         { "_dsdb_set_schema_from_ldif", (PyCFunction)py_dsdb_set_schema_from_ldif, METH_VARARGS,
1085                 NULL },
1086         { "_dsdb_set_schema_from_ldb", (PyCFunction)py_dsdb_set_schema_from_ldb, METH_VARARGS,
1087                 NULL },
1088         { "_dsdb_write_prefixes_from_schema_to_ldb", (PyCFunction)py_dsdb_write_prefixes_from_schema_to_ldb, METH_VARARGS,
1089                 NULL },
1090         { "_dsdb_get_partitions_dn", (PyCFunction)py_dsdb_get_partitions_dn, METH_VARARGS, NULL },
1091         { "_dsdb_get_nc_root", (PyCFunction)py_dsdb_get_nc_root, METH_VARARGS, NULL },
1092         { "_dsdb_get_wellknown_dn", (PyCFunction)py_dsdb_get_wellknown_dn, METH_VARARGS, NULL },
1093         { "_dsdb_DsReplicaAttribute", (PyCFunction)py_dsdb_DsReplicaAttribute, METH_VARARGS, NULL },
1094         { "_dsdb_normalise_attributes", (PyCFunction)py_dsdb_normalise_attributes, METH_VARARGS, NULL },
1095         { NULL }
1096 };
1097
1098 void initdsdb(void)
1099 {
1100         PyObject *m;
1101
1102         m = Py_InitModule3("dsdb", py_dsdb_methods,
1103                            "Python bindings for the directory service databases.");
1104         if (m == NULL)
1105                 return;
1106
1107 #define ADD_DSDB_FLAG(val)  PyModule_AddObject(m, #val, PyInt_FromLong(val))
1108
1109         /* "userAccountControl" flags */
1110         ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
1111         ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
1112         ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
1113         ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
1114         ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
1115         ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
1116         ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
1117
1118         ADD_DSDB_FLAG(UF_SCRIPT);
1119         ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
1120         ADD_DSDB_FLAG(UF_00000004);
1121         ADD_DSDB_FLAG(UF_HOMEDIR_REQUIRED);
1122         ADD_DSDB_FLAG(UF_LOCKOUT);
1123         ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
1124         ADD_DSDB_FLAG(UF_PASSWD_CANT_CHANGE);
1125         ADD_DSDB_FLAG(UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED);
1126         ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
1127         ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
1128         ADD_DSDB_FLAG(UF_00000400);
1129         ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
1130         ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
1131         ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
1132         ADD_DSDB_FLAG(UF_00004000);
1133         ADD_DSDB_FLAG(UF_00008000);
1134         ADD_DSDB_FLAG(UF_DONT_EXPIRE_PASSWD);
1135         ADD_DSDB_FLAG(UF_MNS_LOGON_ACCOUNT);
1136         ADD_DSDB_FLAG(UF_SMARTCARD_REQUIRED);
1137         ADD_DSDB_FLAG(UF_TRUSTED_FOR_DELEGATION);
1138         ADD_DSDB_FLAG(UF_NOT_DELEGATED);
1139         ADD_DSDB_FLAG(UF_USE_DES_KEY_ONLY);
1140         ADD_DSDB_FLAG(UF_DONT_REQUIRE_PREAUTH);
1141         ADD_DSDB_FLAG(UF_PASSWORD_EXPIRED);
1142         ADD_DSDB_FLAG(UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION);
1143         ADD_DSDB_FLAG(UF_NO_AUTH_DATA_REQUIRED);
1144         ADD_DSDB_FLAG(UF_PARTIAL_SECRETS_ACCOUNT);
1145
1146         /* groupType flags */
1147         ADD_DSDB_FLAG(GTYPE_SECURITY_BUILTIN_LOCAL_GROUP);
1148         ADD_DSDB_FLAG(GTYPE_SECURITY_GLOBAL_GROUP);
1149         ADD_DSDB_FLAG(GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1150         ADD_DSDB_FLAG(GTYPE_SECURITY_UNIVERSAL_GROUP);
1151         ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_GLOBAL_GROUP);
1152         ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP);
1153         ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_UNIVERSAL_GROUP);
1154
1155         /* "sAMAccountType" flags */
1156         ADD_DSDB_FLAG(ATYPE_NORMAL_ACCOUNT);
1157         ADD_DSDB_FLAG(ATYPE_WORKSTATION_TRUST);
1158         ADD_DSDB_FLAG(ATYPE_INTERDOMAIN_TRUST);
1159         ADD_DSDB_FLAG(ATYPE_SECURITY_GLOBAL_GROUP);
1160         ADD_DSDB_FLAG(ATYPE_SECURITY_LOCAL_GROUP);
1161         ADD_DSDB_FLAG(ATYPE_SECURITY_UNIVERSAL_GROUP);
1162         ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_GLOBAL_GROUP);
1163         ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_LOCAL_GROUP);
1164         ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_UNIVERSAL_GROUP);
1165
1166         /* "domainFunctionality", "forestFunctionality" flags in the rootDSE */
1167         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2000);
1168         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003_MIXED);
1169         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003);
1170         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008);
1171         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008_R2);
1172
1173         /* nc replica flags */
1174         ADD_DSDB_FLAG(INSTANCE_TYPE_IS_NC_HEAD);
1175         ADD_DSDB_FLAG(INSTANCE_TYPE_UNINSTANT);
1176         ADD_DSDB_FLAG(INSTANCE_TYPE_WRITE);
1177         ADD_DSDB_FLAG(INSTANCE_TYPE_NC_ABOVE);
1178         ADD_DSDB_FLAG(INSTANCE_TYPE_NC_COMING);
1179         ADD_DSDB_FLAG(INSTANCE_TYPE_NC_GOING);
1180
1181         /* "systemFlags" */
1182         ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NC);
1183         ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_DOMAIN);
1184         ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NOT_GC_REPLICATED);
1185         ADD_DSDB_FLAG(SYSTEM_FLAG_SCHEMA_BASE_OBJECT);
1186         ADD_DSDB_FLAG(SYSTEM_FLAG_ATTR_IS_RDN);
1187         ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
1188         ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE);
1189         ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME);
1190         ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE);
1191         ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_MOVE);
1192         ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_RENAME);
1193         ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_DELETE);
1194
1195         /* Kerberos encryption type constants */
1196         ADD_DSDB_FLAG(ENC_ALL_TYPES);
1197         ADD_DSDB_FLAG(ENC_CRC32);
1198         ADD_DSDB_FLAG(ENC_RSA_MD5);
1199         ADD_DSDB_FLAG(ENC_RC4_HMAC_MD5);
1200         ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES128);
1201         ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES256);
1202
1203         ADD_DSDB_FLAG(SEARCH_FLAG_ATTINDEX);
1204         ADD_DSDB_FLAG(SEARCH_FLAG_PDNTATTINDEX);
1205         ADD_DSDB_FLAG(SEARCH_FLAG_ANR);
1206         ADD_DSDB_FLAG(SEARCH_FLAG_PRESERVEONDELETE);
1207         ADD_DSDB_FLAG(SEARCH_FLAG_COPY);
1208         ADD_DSDB_FLAG(SEARCH_FLAG_TUPLEINDEX);
1209         ADD_DSDB_FLAG(SEARCH_FLAG_SUBTREEATTRINDEX);
1210         ADD_DSDB_FLAG(SEARCH_FLAG_CONFIDENTIAL);
1211         ADD_DSDB_FLAG(SEARCH_FLAG_NEVERVALUEAUDIT);
1212         ADD_DSDB_FLAG(SEARCH_FLAG_RODC_ATTRIBUTE);
1213
1214         ADD_DSDB_FLAG(DS_FLAG_ATTR_NOT_REPLICATED);
1215         ADD_DSDB_FLAG(DS_FLAG_ATTR_REQ_PARTIAL_SET_MEMBER);
1216         ADD_DSDB_FLAG(DS_FLAG_ATTR_IS_CONSTRUCTED);
1217
1218         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_AUTO_TOPOLOGY_DISABLED);
1219         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_CLEANUP_DISABLED);
1220         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_MIN_HOPS_DISABLED);
1221         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_DETECT_STALE_DISABLED);
1222         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_INTER_SITE_AUTO_TOPOLOGY_DISABLED);
1223         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_GROUP_CACHING_ENABLED);
1224         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_FORCE_KCC_WHISTLER_BEHAVIOR);
1225         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_RAND_BH_SELECTION_DISABLED);
1226         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_SCHEDULE_HASHING_ENABLED);
1227         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_REDUNDANT_SERVER_TOPOLOGY_ENABLED);
1228
1229         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_IS_GC);
1230         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_INBOUND_REPL);
1231         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL);
1232         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_NTDSCONN_XLATE);
1233         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_SPN_REGISTRATION);
1234
1235         ADD_DSDB_FLAG(NTDSCONN_KCC_GC_TOPOLOGY);
1236         ADD_DSDB_FLAG(NTDSCONN_KCC_RING_TOPOLOGY);
1237         ADD_DSDB_FLAG(NTDSCONN_KCC_MINIMIZE_HOPS_TOPOLOGY);
1238         ADD_DSDB_FLAG(NTDSCONN_KCC_STALE_SERVERS_TOPOLOGY);
1239         ADD_DSDB_FLAG(NTDSCONN_KCC_OSCILLATING_CONNECTION_TOPOLOGY);
1240         ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_GC_TOPOLOGY);
1241         ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_TOPOLOGY);
1242         ADD_DSDB_FLAG(NTDSCONN_KCC_SERVER_FAILOVER_TOPOLOGY);
1243         ADD_DSDB_FLAG(NTDSCONN_KCC_SITE_FAILOVER_TOPOLOGY);
1244         ADD_DSDB_FLAG(NTDSCONN_KCC_REDUNDANT_SERVER_TOPOLOGY);
1245
1246         ADD_DSDB_FLAG(NTDSCONN_OPT_IS_GENERATED);
1247         ADD_DSDB_FLAG(NTDSCONN_OPT_TWOWAY_SYNC);
1248         ADD_DSDB_FLAG(NTDSCONN_OPT_OVERRIDE_NOTIFY_DEFAULT);
1249         ADD_DSDB_FLAG(NTDSCONN_OPT_USE_NOTIFY);
1250         ADD_DSDB_FLAG(NTDSCONN_OPT_DISABLE_INTERSITE_COMPRESSION);
1251         ADD_DSDB_FLAG(NTDSCONN_OPT_USER_OWNED_SCHEDULE);
1252         ADD_DSDB_FLAG(NTDSCONN_OPT_RODC_TOPOLOGY);
1253
1254         /* Site Link Object options */
1255         ADD_DSDB_FLAG(NTDSSITELINK_OPT_USE_NOTIFY);
1256         ADD_DSDB_FLAG(NTDSSITELINK_OPT_TWOWAY_SYNC);
1257         ADD_DSDB_FLAG(NTDSSITELINK_OPT_DISABLE_COMPRESSION);
1258
1259         /* GPO policy flags */
1260         ADD_DSDB_FLAG(GPLINK_OPT_DISABLE);
1261         ADD_DSDB_FLAG(GPLINK_OPT_ENFORCE);
1262         ADD_DSDB_FLAG(GPO_FLAG_USER_DISABLE);
1263         ADD_DSDB_FLAG(GPO_FLAG_MACHINE_DISABLE);
1264         ADD_DSDB_FLAG(GPO_INHERIT);
1265         ADD_DSDB_FLAG(GPO_BLOCK_INHERITANCE);
1266
1267 #define ADD_DSDB_STRING(val)  PyModule_AddObject(m, #val, PyString_FromString(val))
1268
1269         ADD_DSDB_STRING(DSDB_SYNTAX_BINARY_DN);
1270         ADD_DSDB_STRING(DSDB_SYNTAX_STRING_DN);
1271         ADD_DSDB_STRING(DSDB_SYNTAX_OR_NAME);
1272         ADD_DSDB_STRING(DSDB_CONTROL_DBCHECK);
1273         ADD_DSDB_STRING(DSDB_CONTROL_DBCHECK_MODIFY_RO_REPLICA);
1274
1275         ADD_DSDB_STRING(DS_GUID_COMPUTERS_CONTAINER);
1276         ADD_DSDB_STRING(DS_GUID_DELETED_OBJECTS_CONTAINER);
1277         ADD_DSDB_STRING(DS_GUID_DOMAIN_CONTROLLERS_CONTAINER);
1278         ADD_DSDB_STRING(DS_GUID_FOREIGNSECURITYPRINCIPALS_CONTAINER);
1279         ADD_DSDB_STRING(DS_GUID_INFRASTRUCTURE_CONTAINER);
1280         ADD_DSDB_STRING(DS_GUID_LOSTANDFOUND_CONTAINER);
1281         ADD_DSDB_STRING(DS_GUID_MICROSOFT_PROGRAM_DATA_CONTAINER);
1282         ADD_DSDB_STRING(DS_GUID_NTDS_QUOTAS_CONTAINER);
1283         ADD_DSDB_STRING(DS_GUID_PROGRAM_DATA_CONTAINER);
1284         ADD_DSDB_STRING(DS_GUID_SYSTEMS_CONTAINER);
1285         ADD_DSDB_STRING(DS_GUID_USERS_CONTAINER);
1286 }