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_KeyError, "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_KeyError, "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_KeyError, "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_KeyError, "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_KeyError, "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_KeyError, "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_KeyError, "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_KeyError, "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         if (GUID_all_zero(&guid)) {
 731                 PyErr_SetString(PyExc_RuntimeError, "set_ntds_invocation_id rejected due to all-zero invocation ID");
 732                 return NULL;
 733         }
 734
 735         ret = samdb_set_ntds_invocation_id(ldb, &guid);
 736         if (!ret) {
 737                 PyErr_SetString(PyExc_RuntimeError, "set_ntds_invocation_id failed");
 738                 return NULL;
 739         }
 740         Py_RETURN_NONE;
 741 }
 742
 743 static PyObject *py_samdb_ntds_objectGUID(PyObject *self, PyObject *args)
 744 {
 745         PyObject *py_ldb, *result;
 746         struct ldb_context *ldb;
 747         const struct GUID *guid;
 748         char *retstr;
 749
 750         if (!PyArg_ParseTuple(args, "O", &py_ldb)) {
 751                 return NULL;
 752         }
 753
 754         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 755
 756         guid = samdb_ntds_objectGUID(ldb);
 757         if (guid == NULL) {
 758                 PyErr_SetString(PyExc_RuntimeError, "Failed to find NTDS GUID");
 759                 return NULL;
 760         }
 761
 762         retstr = GUID_string(NULL, guid);
 763         if (retstr == NULL) {
 764                 PyErr_NoMemory();
 765                 return NULL;
 766         }
 767         result = PyString_FromString(retstr);
 768         talloc_free(retstr);
 769         return result;
 770 }
 771
 772 static PyObject *py_dsdb_set_global_schema(PyObject *self, PyObject *args)
 773 {
 774         PyObject *py_ldb;
 775         struct ldb_context *ldb;
 776         int ret;
 777         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 778                 return NULL;
 779
 780         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 781
 782         ret = dsdb_set_global_schema(ldb);
 783         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 784
 785         Py_RETURN_NONE;
 786 }
 787
 788 static PyObject *py_dsdb_load_partition_usn(PyObject *self, PyObject *args)
 789 {
 790         PyObject *py_dn, *py_ldb, *result;
 791         struct ldb_dn *dn;
 792         uint64_t highest_uSN, urgent_uSN;
 793         struct ldb_context *ldb;
 794         TALLOC_CTX *mem_ctx;
 795         int ret;
 796
 797         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_dn)) {
 798                 return NULL;
 799         }
 800
 801         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 802
 803         mem_ctx = talloc_new(NULL);
 804         if (mem_ctx == NULL) {
 805                 PyErr_NoMemory();
 806                 return NULL;
 807         }
 808
 809         if (!pyldb_Object_AsDn(mem_ctx, py_dn, ldb, &dn)) {
 810                 talloc_free(mem_ctx);
 811                 return NULL;
 812         }
 813
 814         ret = dsdb_load_partition_usn(ldb, dn, &highest_uSN, &urgent_uSN);
 815         if (ret != LDB_SUCCESS) {
 816            PyErr_Format(PyExc_RuntimeError,
 817                         "Failed to load partition [%s] uSN - %s",
 818                         ldb_dn_get_linearized(dn),
 819                         ldb_errstring(ldb));
 820            talloc_free(mem_ctx);
 821            return NULL;
 822         }
 823
 824         talloc_free(mem_ctx);
 825
 826         result = PyDict_New();
 827
 828         PyDict_SetItemString(result, "uSNHighest", PyInt_FromLong((uint64_t)highest_uSN));
 829         PyDict_SetItemString(result, "uSNUrgent", PyInt_FromLong((uint64_t)urgent_uSN));
 830
 831
 832         return result;
 833 }
 834
 835 static PyObject *py_dsdb_set_am_rodc(PyObject *self, PyObject *args)
 836 {
 837         PyObject *py_ldb;
 838         bool ret;
 839         struct ldb_context *ldb;
 840         int py_val;
 841
 842         if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &py_val))
 843                 return NULL;
 844
 845         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 846         ret = samdb_set_am_rodc(ldb, (bool)py_val);
 847         if (!ret) {
 848                 PyErr_SetString(PyExc_RuntimeError, "set_am_rodc failed");
 849                 return NULL;
 850         }
 851         Py_RETURN_NONE;
 852 }
 853
 854 static PyObject *py_dsdb_set_schema_from_ldif(PyObject *self, PyObject *args)
 855 {
 856         WERROR result;
 857         char *pf, *df, *dn;
 858         PyObject *py_ldb;
 859         struct ldb_context *ldb;
 860
 861         if (!PyArg_ParseTuple(args, "Osss", &py_ldb, &pf, &df, &dn))
 862                 return NULL;
 863
 864         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 865
 866         result = dsdb_set_schema_from_ldif(ldb, pf, df, dn);
 867         PyErr_WERROR_NOT_OK_RAISE(result);
 868
 869         Py_RETURN_NONE;
 870 }
 871
 872 static PyObject *py_dsdb_set_schema_from_ldb(PyObject *self, PyObject *args)
 873 {
 874         PyObject *py_ldb;
 875         struct ldb_context *ldb;
 876         PyObject *py_from_ldb;
 877         struct ldb_context *from_ldb;
 878         struct dsdb_schema *schema;
 879         int ret;
 880         char write_indices_and_attributes = true;
 881         if (!PyArg_ParseTuple(args, "OO|b",
 882                               &py_ldb, &py_from_ldb, &write_indices_and_attributes))
 883                 return NULL;
 884
 885         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 886
 887         PyErr_LDB_OR_RAISE(py_from_ldb, from_ldb);
 888
 889         schema = dsdb_get_schema(from_ldb, NULL);
 890         if (!schema) {
 891                 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on 'from' ldb!\n");
 892                 return NULL;
 893         }
 894
 895         ret = dsdb_reference_schema(ldb, schema, write_indices_and_attributes);
 896         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 897
 898         Py_RETURN_NONE;
 899 }
 900
 901 static PyObject *py_dsdb_write_prefixes_from_schema_to_ldb(PyObject *self, PyObject *args)
 902 {
 903         PyObject *py_ldb;
 904         struct ldb_context *ldb;
 905         WERROR result;
 906         struct dsdb_schema *schema;
 907
 908         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 909                 return NULL;
 910
 911         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 912
 913         schema = dsdb_get_schema(ldb, NULL);
 914         if (!schema) {
 915                 PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on ldb!\n");
 916                 return NULL;
 917         }
 918
 919         result = dsdb_write_prefixes_from_schema_to_ldb(NULL, ldb, schema);
 920         PyErr_WERROR_NOT_OK_RAISE(result);
 921
 922         Py_RETURN_NONE;
 923 }
 924
 925
 926 static PyObject *py_dsdb_get_partitions_dn(PyObject *self, PyObject *args)
 927 {
 928         struct ldb_context *ldb;
 929         struct ldb_dn *dn;
 930         PyObject *py_ldb, *ret;
 931
 932         if (!PyArg_ParseTuple(args, "O", &py_ldb))
 933                 return NULL;
 934
 935         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 936
 937         dn = samdb_partitions_dn(ldb, NULL);
 938         if (dn == NULL) {
 939                 PyErr_NoMemory();
 940                 return NULL;
 941         }
 942         ret = pyldb_Dn_FromDn(dn);
 943         talloc_free(dn);
 944         return ret;
 945 }
 946
 947
 948 static PyObject *py_dsdb_get_nc_root(PyObject *self, PyObject *args)
 949 {
 950         struct ldb_context *ldb;
 951         struct ldb_dn *dn, *nc_root;
 952         PyObject *py_ldb, *py_ldb_dn, *py_nc_root;
 953         int ret;
 954
 955         if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ldb_dn))
 956                 return NULL;
 957
 958         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 959         PyErr_LDB_DN_OR_RAISE(py_ldb_dn, dn);
 960
 961         ret = dsdb_find_nc_root(ldb, ldb, dn, &nc_root);
 962         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 963
 964         py_nc_root = pyldb_Dn_FromDn(nc_root);
 965         talloc_unlink(ldb, nc_root);
 966         return py_nc_root;
 967 }
 968
 969 static PyObject *py_dsdb_get_wellknown_dn(PyObject *self, PyObject *args)
 970 {
 971         struct ldb_context *ldb;
 972         struct ldb_dn *nc_dn, *wk_dn;
 973         char *wkguid;
 974         PyObject *py_ldb, *py_nc_dn, *py_wk_dn;
 975         int ret;
 976
 977         if (!PyArg_ParseTuple(args, "OOs", &py_ldb, &py_nc_dn, &wkguid))
 978                 return NULL;
 979
 980         PyErr_LDB_OR_RAISE(py_ldb, ldb);
 981         PyErr_LDB_DN_OR_RAISE(py_nc_dn, nc_dn);
 982
 983         ret = dsdb_wellknown_dn(ldb, ldb, nc_dn, wkguid, &wk_dn);
 984         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 985                 PyErr_Format(PyExc_KeyError, "Failed to find well known DN for GUID %s", wkguid);
 986                 return NULL;
 987         }
 988
 989         PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb);
 990
 991         py_wk_dn = pyldb_Dn_FromDn(wk_dn);
 992         talloc_unlink(ldb, wk_dn);
 993         return py_wk_dn;
 994 }
 995
 996
 997 /*
 998   call into samdb_rodc()
 999  */
1000 static PyObject *py_dsdb_am_rodc(PyObject *self, PyObject *args)
1001 {
1002         PyObject *py_ldb;
1003         struct ldb_context *ldb;
1004         int ret;
1005         bool am_rodc;
1006
1007         if (!PyArg_ParseTuple(args, "O", &py_ldb))
1008                 return NULL;
1009
1010         PyErr_LDB_OR_RAISE(py_ldb, ldb);
1011
1012         ret = samdb_rodc(ldb, &am_rodc);
1013         if (ret != LDB_SUCCESS) {
1014                 PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb));
1015                 return NULL;
1016         }
1017
1018         return PyBool_FromLong(am_rodc);
1019 }
1020
1021 /*
1022   call into samdb_is_pdc()
1023  */
1024 static PyObject *py_dsdb_am_pdc(PyObject *self, PyObject *args)
1025 {
1026         PyObject *py_ldb;
1027         struct ldb_context *ldb;
1028         bool am_pdc;
1029
1030         if (!PyArg_ParseTuple(args, "O", &py_ldb))
1031                 return NULL;
1032
1033         PyErr_LDB_OR_RAISE(py_ldb, ldb);
1034
1035         am_pdc = samdb_is_pdc(ldb);
1036         return PyBool_FromLong(am_pdc);
1037 }
1038
1039
1040 static PyMethodDef py_dsdb_methods[] = {
1041         { "_samdb_server_site_name", (PyCFunction)py_samdb_server_site_name,
1042                 METH_VARARGS, "Get the server site name as a string"},
1043         { "_dsdb_convert_schema_to_openldap",
1044                 (PyCFunction)py_dsdb_convert_schema_to_openldap, METH_VARARGS,
1045                 "dsdb_convert_schema_to_openldap(ldb, target_str, mapping) -> str\n"
1046                 "Create an OpenLDAP schema from a schema." },
1047         { "_samdb_set_domain_sid", (PyCFunction)py_samdb_set_domain_sid,
1048                 METH_VARARGS,
1049                 "samdb_set_domain_sid(samdb, sid)\n"
1050                 "Set SID of domain to use." },
1051         { "_samdb_get_domain_sid", (PyCFunction)py_samdb_get_domain_sid,
1052                 METH_VARARGS,
1053                 "samdb_get_domain_sid(samdb)\n"
1054                 "Get SID of domain in use." },
1055         { "_samdb_ntds_invocation_id", (PyCFunction)py_samdb_ntds_invocation_id,
1056                 METH_VARARGS, "get the NTDS invocation ID GUID as a string"},
1057         { "_samdb_set_ntds_settings_dn", (PyCFunction)py_samdb_set_ntds_settings_dn,
1058                 METH_VARARGS,
1059                 "samdb_set_ntds_settings_dn(samdb, ntds_settings_dn)\n"
1060                 "Set NTDS Settings DN for this LDB (allows it to be set before the DB fully exists)." },
1061         { "_dsdb_get_oid_from_attid", (PyCFunction)py_dsdb_get_oid_from_attid,
1062                 METH_VARARGS, NULL },
1063         { "_dsdb_get_attid_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_attid_from_lDAPDisplayName,
1064                 METH_VARARGS, NULL },
1065         { "_dsdb_get_syntax_oid_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_syntax_oid_from_lDAPDisplayName,
1066                 METH_VARARGS, NULL },
1067         { "_dsdb_get_systemFlags_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_systemFlags_from_lDAPDisplayName,
1068                 METH_VARARGS, NULL },
1069         { "_dsdb_get_linkId_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_linkId_from_lDAPDisplayName,
1070                 METH_VARARGS, NULL },
1071         { "_dsdb_get_lDAPDisplayName_by_attid", (PyCFunction)py_dsdb_get_lDAPDisplayName_by_attid,
1072                 METH_VARARGS, NULL },
1073         { "_dsdb_get_backlink_from_lDAPDisplayName", (PyCFunction)py_dsdb_get_backlink_from_lDAPDisplayName,
1074                 METH_VARARGS, NULL },
1075         { "_dsdb_set_ntds_invocation_id",
1076                 (PyCFunction)py_dsdb_set_ntds_invocation_id, METH_VARARGS,
1077                 NULL },
1078         { "_samdb_ntds_objectGUID", (PyCFunction)py_samdb_ntds_objectGUID,
1079                 METH_VARARGS, "get the NTDS objectGUID as a string"},
1080         { "_dsdb_set_global_schema", (PyCFunction)py_dsdb_set_global_schema,
1081                 METH_VARARGS, NULL },
1082         { "_dsdb_load_partition_usn", (PyCFunction)py_dsdb_load_partition_usn,
1083                 METH_VARARGS,
1084                 "get uSNHighest and uSNUrgent from the partition @REPLCHANGED"},
1085         { "_dsdb_set_am_rodc",
1086                 (PyCFunction)py_dsdb_set_am_rodc, METH_VARARGS,
1087                 NULL },
1088         { "_am_rodc",
1089                 (PyCFunction)py_dsdb_am_rodc, METH_VARARGS,
1090                 NULL },
1091         { "_am_pdc",
1092                 (PyCFunction)py_dsdb_am_pdc, METH_VARARGS,
1093                 NULL },
1094         { "_dsdb_set_schema_from_ldif", (PyCFunction)py_dsdb_set_schema_from_ldif, METH_VARARGS,
1095                 NULL },
1096         { "_dsdb_set_schema_from_ldb", (PyCFunction)py_dsdb_set_schema_from_ldb, METH_VARARGS,
1097                 NULL },
1098         { "_dsdb_write_prefixes_from_schema_to_ldb", (PyCFunction)py_dsdb_write_prefixes_from_schema_to_ldb, METH_VARARGS,
1099                 NULL },
1100         { "_dsdb_get_partitions_dn", (PyCFunction)py_dsdb_get_partitions_dn, METH_VARARGS, NULL },
1101         { "_dsdb_get_nc_root", (PyCFunction)py_dsdb_get_nc_root, METH_VARARGS, NULL },
1102         { "_dsdb_get_wellknown_dn", (PyCFunction)py_dsdb_get_wellknown_dn, METH_VARARGS, NULL },
1103         { "_dsdb_DsReplicaAttribute", (PyCFunction)py_dsdb_DsReplicaAttribute, METH_VARARGS, NULL },
1104         { "_dsdb_normalise_attributes", (PyCFunction)py_dsdb_normalise_attributes, METH_VARARGS, NULL },
1105         { NULL }
1106 };
1107
1108 void initdsdb(void)
1109 {
1110         PyObject *m;
1111
1112         m = Py_InitModule3("dsdb", py_dsdb_methods,
1113                            "Python bindings for the directory service databases.");
1114         if (m == NULL)
1115                 return;
1116
1117 #define ADD_DSDB_FLAG(val)  PyModule_AddObject(m, #val, PyInt_FromLong(val))
1118
1119         /* "userAccountControl" flags */
1120         ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
1121         ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
1122         ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
1123         ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
1124         ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
1125         ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
1126         ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
1127
1128         ADD_DSDB_FLAG(UF_SCRIPT);
1129         ADD_DSDB_FLAG(UF_ACCOUNTDISABLE);
1130         ADD_DSDB_FLAG(UF_00000004);
1131         ADD_DSDB_FLAG(UF_HOMEDIR_REQUIRED);
1132         ADD_DSDB_FLAG(UF_LOCKOUT);
1133         ADD_DSDB_FLAG(UF_PASSWD_NOTREQD);
1134         ADD_DSDB_FLAG(UF_PASSWD_CANT_CHANGE);
1135         ADD_DSDB_FLAG(UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED);
1136         ADD_DSDB_FLAG(UF_TEMP_DUPLICATE_ACCOUNT);
1137         ADD_DSDB_FLAG(UF_NORMAL_ACCOUNT);
1138         ADD_DSDB_FLAG(UF_00000400);
1139         ADD_DSDB_FLAG(UF_INTERDOMAIN_TRUST_ACCOUNT);
1140         ADD_DSDB_FLAG(UF_WORKSTATION_TRUST_ACCOUNT);
1141         ADD_DSDB_FLAG(UF_SERVER_TRUST_ACCOUNT);
1142         ADD_DSDB_FLAG(UF_00004000);
1143         ADD_DSDB_FLAG(UF_00008000);
1144         ADD_DSDB_FLAG(UF_DONT_EXPIRE_PASSWD);
1145         ADD_DSDB_FLAG(UF_MNS_LOGON_ACCOUNT);
1146         ADD_DSDB_FLAG(UF_SMARTCARD_REQUIRED);
1147         ADD_DSDB_FLAG(UF_TRUSTED_FOR_DELEGATION);
1148         ADD_DSDB_FLAG(UF_NOT_DELEGATED);
1149         ADD_DSDB_FLAG(UF_USE_DES_KEY_ONLY);
1150         ADD_DSDB_FLAG(UF_DONT_REQUIRE_PREAUTH);
1151         ADD_DSDB_FLAG(UF_PASSWORD_EXPIRED);
1152         ADD_DSDB_FLAG(UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION);
1153         ADD_DSDB_FLAG(UF_NO_AUTH_DATA_REQUIRED);
1154         ADD_DSDB_FLAG(UF_PARTIAL_SECRETS_ACCOUNT);
1155
1156         /* groupType flags */
1157         ADD_DSDB_FLAG(GTYPE_SECURITY_BUILTIN_LOCAL_GROUP);
1158         ADD_DSDB_FLAG(GTYPE_SECURITY_GLOBAL_GROUP);
1159         ADD_DSDB_FLAG(GTYPE_SECURITY_DOMAIN_LOCAL_GROUP);
1160         ADD_DSDB_FLAG(GTYPE_SECURITY_UNIVERSAL_GROUP);
1161         ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_GLOBAL_GROUP);
1162         ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP);
1163         ADD_DSDB_FLAG(GTYPE_DISTRIBUTION_UNIVERSAL_GROUP);
1164
1165         /* "sAMAccountType" flags */
1166         ADD_DSDB_FLAG(ATYPE_NORMAL_ACCOUNT);
1167         ADD_DSDB_FLAG(ATYPE_WORKSTATION_TRUST);
1168         ADD_DSDB_FLAG(ATYPE_INTERDOMAIN_TRUST);
1169         ADD_DSDB_FLAG(ATYPE_SECURITY_GLOBAL_GROUP);
1170         ADD_DSDB_FLAG(ATYPE_SECURITY_LOCAL_GROUP);
1171         ADD_DSDB_FLAG(ATYPE_SECURITY_UNIVERSAL_GROUP);
1172         ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_GLOBAL_GROUP);
1173         ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_LOCAL_GROUP);
1174         ADD_DSDB_FLAG(ATYPE_DISTRIBUTION_UNIVERSAL_GROUP);
1175
1176         /* "domainFunctionality", "forestFunctionality" flags in the rootDSE */
1177         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2000);
1178         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003_MIXED);
1179         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2003);
1180         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008);
1181         ADD_DSDB_FLAG(DS_DOMAIN_FUNCTION_2008_R2);
1182
1183         /* nc replica flags */
1184         ADD_DSDB_FLAG(INSTANCE_TYPE_IS_NC_HEAD);
1185         ADD_DSDB_FLAG(INSTANCE_TYPE_UNINSTANT);
1186         ADD_DSDB_FLAG(INSTANCE_TYPE_WRITE);
1187         ADD_DSDB_FLAG(INSTANCE_TYPE_NC_ABOVE);
1188         ADD_DSDB_FLAG(INSTANCE_TYPE_NC_COMING);
1189         ADD_DSDB_FLAG(INSTANCE_TYPE_NC_GOING);
1190
1191         /* "systemFlags" */
1192         ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NC);
1193         ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_DOMAIN);
1194         ADD_DSDB_FLAG(SYSTEM_FLAG_CR_NTDS_NOT_GC_REPLICATED);
1195         ADD_DSDB_FLAG(SYSTEM_FLAG_SCHEMA_BASE_OBJECT);
1196         ADD_DSDB_FLAG(SYSTEM_FLAG_ATTR_IS_RDN);
1197         ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
1198         ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE);
1199         ADD_DSDB_FLAG(SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME);
1200         ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE);
1201         ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_MOVE);
1202         ADD_DSDB_FLAG(SYSTEM_FLAG_CONFIG_ALLOW_RENAME);
1203         ADD_DSDB_FLAG(SYSTEM_FLAG_DISALLOW_DELETE);
1204
1205         /* Kerberos encryption type constants */
1206         ADD_DSDB_FLAG(ENC_ALL_TYPES);
1207         ADD_DSDB_FLAG(ENC_CRC32);
1208         ADD_DSDB_FLAG(ENC_RSA_MD5);
1209         ADD_DSDB_FLAG(ENC_RC4_HMAC_MD5);
1210         ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES128);
1211         ADD_DSDB_FLAG(ENC_HMAC_SHA1_96_AES256);
1212
1213         ADD_DSDB_FLAG(SEARCH_FLAG_ATTINDEX);
1214         ADD_DSDB_FLAG(SEARCH_FLAG_PDNTATTINDEX);
1215         ADD_DSDB_FLAG(SEARCH_FLAG_ANR);
1216         ADD_DSDB_FLAG(SEARCH_FLAG_PRESERVEONDELETE);
1217         ADD_DSDB_FLAG(SEARCH_FLAG_COPY);
1218         ADD_DSDB_FLAG(SEARCH_FLAG_TUPLEINDEX);
1219         ADD_DSDB_FLAG(SEARCH_FLAG_SUBTREEATTRINDEX);
1220         ADD_DSDB_FLAG(SEARCH_FLAG_CONFIDENTIAL);
1221         ADD_DSDB_FLAG(SEARCH_FLAG_NEVERVALUEAUDIT);
1222         ADD_DSDB_FLAG(SEARCH_FLAG_RODC_ATTRIBUTE);
1223
1224         ADD_DSDB_FLAG(DS_FLAG_ATTR_NOT_REPLICATED);
1225         ADD_DSDB_FLAG(DS_FLAG_ATTR_REQ_PARTIAL_SET_MEMBER);
1226         ADD_DSDB_FLAG(DS_FLAG_ATTR_IS_CONSTRUCTED);
1227
1228         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_AUTO_TOPOLOGY_DISABLED);
1229         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_CLEANUP_DISABLED);
1230         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_MIN_HOPS_DISABLED);
1231         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_TOPL_DETECT_STALE_DISABLED);
1232         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_INTER_SITE_AUTO_TOPOLOGY_DISABLED);
1233         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_GROUP_CACHING_ENABLED);
1234         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_FORCE_KCC_WHISTLER_BEHAVIOR);
1235         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_RAND_BH_SELECTION_DISABLED);
1236         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_SCHEDULE_HASHING_ENABLED);
1237         ADD_DSDB_FLAG(DS_NTDSSETTINGS_OPT_IS_REDUNDANT_SERVER_TOPOLOGY_ENABLED);
1238
1239         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_IS_GC);
1240         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_INBOUND_REPL);
1241         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL);
1242         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_NTDSCONN_XLATE);
1243         ADD_DSDB_FLAG(DS_NTDSDSA_OPT_DISABLE_SPN_REGISTRATION);
1244
1245         ADD_DSDB_FLAG(NTDSCONN_KCC_GC_TOPOLOGY);
1246         ADD_DSDB_FLAG(NTDSCONN_KCC_RING_TOPOLOGY);
1247         ADD_DSDB_FLAG(NTDSCONN_KCC_MINIMIZE_HOPS_TOPOLOGY);
1248         ADD_DSDB_FLAG(NTDSCONN_KCC_STALE_SERVERS_TOPOLOGY);
1249         ADD_DSDB_FLAG(NTDSCONN_KCC_OSCILLATING_CONNECTION_TOPOLOGY);
1250         ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_GC_TOPOLOGY);
1251         ADD_DSDB_FLAG(NTDSCONN_KCC_INTERSITE_TOPOLOGY);
1252         ADD_DSDB_FLAG(NTDSCONN_KCC_SERVER_FAILOVER_TOPOLOGY);
1253         ADD_DSDB_FLAG(NTDSCONN_KCC_SITE_FAILOVER_TOPOLOGY);
1254         ADD_DSDB_FLAG(NTDSCONN_KCC_REDUNDANT_SERVER_TOPOLOGY);
1255
1256         ADD_DSDB_FLAG(NTDSCONN_OPT_IS_GENERATED);
1257         ADD_DSDB_FLAG(NTDSCONN_OPT_TWOWAY_SYNC);
1258         ADD_DSDB_FLAG(NTDSCONN_OPT_OVERRIDE_NOTIFY_DEFAULT);
1259         ADD_DSDB_FLAG(NTDSCONN_OPT_USE_NOTIFY);
1260         ADD_DSDB_FLAG(NTDSCONN_OPT_DISABLE_INTERSITE_COMPRESSION);
1261         ADD_DSDB_FLAG(NTDSCONN_OPT_USER_OWNED_SCHEDULE);
1262         ADD_DSDB_FLAG(NTDSCONN_OPT_RODC_TOPOLOGY);
1263
1264         /* Site Link Object options */
1265         ADD_DSDB_FLAG(NTDSSITELINK_OPT_USE_NOTIFY);
1266         ADD_DSDB_FLAG(NTDSSITELINK_OPT_TWOWAY_SYNC);
1267         ADD_DSDB_FLAG(NTDSSITELINK_OPT_DISABLE_COMPRESSION);
1268
1269         /* GPO policy flags */
1270         ADD_DSDB_FLAG(GPLINK_OPT_DISABLE);
1271         ADD_DSDB_FLAG(GPLINK_OPT_ENFORCE);
1272         ADD_DSDB_FLAG(GPO_FLAG_USER_DISABLE);
1273         ADD_DSDB_FLAG(GPO_FLAG_MACHINE_DISABLE);
1274         ADD_DSDB_FLAG(GPO_INHERIT);
1275         ADD_DSDB_FLAG(GPO_BLOCK_INHERITANCE);
1276
1277 #define ADD_DSDB_STRING(val)  PyModule_AddObject(m, #val, PyString_FromString(val))
1278
1279         ADD_DSDB_STRING(DSDB_SYNTAX_BINARY_DN);
1280         ADD_DSDB_STRING(DSDB_SYNTAX_STRING_DN);
1281         ADD_DSDB_STRING(DSDB_SYNTAX_OR_NAME);
1282         ADD_DSDB_STRING(DSDB_CONTROL_DBCHECK);
1283         ADD_DSDB_STRING(DSDB_CONTROL_DBCHECK_MODIFY_RO_REPLICA);
1284
1285         ADD_DSDB_STRING(DS_GUID_COMPUTERS_CONTAINER);
1286         ADD_DSDB_STRING(DS_GUID_DELETED_OBJECTS_CONTAINER);
1287         ADD_DSDB_STRING(DS_GUID_DOMAIN_CONTROLLERS_CONTAINER);
1288         ADD_DSDB_STRING(DS_GUID_FOREIGNSECURITYPRINCIPALS_CONTAINER);
1289         ADD_DSDB_STRING(DS_GUID_INFRASTRUCTURE_CONTAINER);
1290         ADD_DSDB_STRING(DS_GUID_LOSTANDFOUND_CONTAINER);
1291         ADD_DSDB_STRING(DS_GUID_MICROSOFT_PROGRAM_DATA_CONTAINER);
1292         ADD_DSDB_STRING(DS_GUID_NTDS_QUOTAS_CONTAINER);
1293         ADD_DSDB_STRING(DS_GUID_PROGRAM_DATA_CONTAINER);
1294         ADD_DSDB_STRING(DS_GUID_SYSTEMS_CONTAINER);
1295         ADD_DSDB_STRING(DS_GUID_USERS_CONTAINER);
1296 }