source4/dsdb/schema/schema_init.c

   1 /*
   2    Unix SMB/CIFS mplementation.
   3    DSDB schema header
   4
   5    Copyright (C) Stefan Metzmacher <metze@samba.org> 2006
   6    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 */
  22
  23 #include "includes.h"
  24 #include "dsdb/samdb/samdb.h"
  25 #include "lib/ldb/include/ldb_errors.h"
  26 #include "lib/util/dlinklist.h"
  27 #include "librpc/gen_ndr/ndr_misc.h"
  28 #include "librpc/gen_ndr/ndr_drsuapi.h"
  29 #include "librpc/gen_ndr/ndr_drsblobs.h"
  30 #include "param/param.h"
  31
  32 WERROR dsdb_load_oid_mappings_drsuapi(struct dsdb_schema *schema, const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr)
  33 {
  34         uint32_t i,j;
  35
  36         schema->prefixes = talloc_array(schema, struct dsdb_schema_oid_prefix, ctr->num_mappings);
  37         W_ERROR_HAVE_NO_MEMORY(schema->prefixes);
  38
  39         for (i=0, j=0; i < ctr->num_mappings; i++) {
  40                 if (ctr->mappings[i].oid.oid == NULL) {
  41                         return WERR_INVALID_PARAM;
  42                 }
  43
  44                 if (strncasecmp(ctr->mappings[i].oid.oid, "ff", 2) == 0) {
  45                         if (ctr->mappings[i].id_prefix != 0) {
  46                                 return WERR_INVALID_PARAM;
  47                         }
  48
  49                         /* the magic value should be in the last array member */
  50                         if (i != (ctr->num_mappings - 1)) {
  51                                 return WERR_INVALID_PARAM;
  52                         }
  53
  54                         if (ctr->mappings[i].oid.__ndr_size != 21) {
  55                                 return WERR_INVALID_PARAM;
  56                         }
  57
  58                         schema->schema_info = talloc_strdup(schema, ctr->mappings[i].oid.oid);
  59                         W_ERROR_HAVE_NO_MEMORY(schema->schema_info);
  60                 } else {
  61                         /* the last array member should contain the magic value not a oid */
  62                         if (i == (ctr->num_mappings - 1)) {
  63                                 return WERR_INVALID_PARAM;
  64                         }
  65
  66                         schema->prefixes[j].id  = ctr->mappings[i].id_prefix<<16;
  67                         schema->prefixes[j].oid = talloc_asprintf(schema->prefixes, "%s.",
  68                                                                   ctr->mappings[i].oid.oid);
  69                         W_ERROR_HAVE_NO_MEMORY(schema->prefixes[j].oid);
  70                         schema->prefixes[j].oid_len = strlen(schema->prefixes[j].oid);
  71                         j++;
  72                 }
  73         }
  74
  75         schema->num_prefixes = j;
  76         return WERR_OK;
  77 }
  78
  79 WERROR dsdb_load_oid_mappings_ldb(struct dsdb_schema *schema,
  80                                   const struct ldb_val *prefixMap,
  81                                   const struct ldb_val *schemaInfo)
  82 {
  83         WERROR status;
  84         enum ndr_err_code ndr_err;
  85         struct prefixMapBlob pfm;
  86         char *schema_info;
  87
  88         TALLOC_CTX *mem_ctx = talloc_new(schema);
  89         W_ERROR_HAVE_NO_MEMORY(mem_ctx);
  90
  91         ndr_err = ndr_pull_struct_blob(prefixMap, mem_ctx, lp_iconv_convenience(global_loadparm), &pfm,
  92                                        (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
  93         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  94                 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
  95                 talloc_free(mem_ctx);
  96                 return ntstatus_to_werror(nt_status);
  97         }
  98
  99         if (pfm.version != PREFIX_MAP_VERSION_DSDB) {
 100                 talloc_free(mem_ctx);
 101                 return WERR_FOOBAR;
 102         }
 103
 104         if (schemaInfo->length != 21 && schemaInfo->data[0] == 0xFF) {
 105                 talloc_free(mem_ctx);
 106                 return WERR_FOOBAR;
 107         }
 108
 109         /* append the schema info as last element */
 110         pfm.ctr.dsdb.num_mappings++;
 111         pfm.ctr.dsdb.mappings = talloc_realloc(mem_ctx, pfm.ctr.dsdb.mappings,
 112                                                struct drsuapi_DsReplicaOIDMapping,
 113                                                pfm.ctr.dsdb.num_mappings);
 114         W_ERROR_HAVE_NO_MEMORY(pfm.ctr.dsdb.mappings);
 115
 116         schema_info = data_blob_hex_string(pfm.ctr.dsdb.mappings, schemaInfo);
 117         W_ERROR_HAVE_NO_MEMORY(schema_info);
 118
 119         pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].id_prefix          = 0;
 120         pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.__ndr_size     = schemaInfo->length;
 121         pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.oid            = schema_info;
 122
 123         /* call the drsuapi version */
 124         status = dsdb_load_oid_mappings_drsuapi(schema, &pfm.ctr.dsdb);
 125         talloc_free(mem_ctx);
 126
 127         W_ERROR_NOT_OK_RETURN(status);
 128
 129         return WERR_OK;
 130 }
 131
 132 WERROR dsdb_get_oid_mappings_drsuapi(const struct dsdb_schema *schema,
 133                                      bool include_schema_info,
 134                                      TALLOC_CTX *mem_ctx,
 135                                      struct drsuapi_DsReplicaOIDMapping_Ctr **_ctr)
 136 {
 137         struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
 138         uint32_t i;
 139
 140         ctr = talloc(mem_ctx, struct drsuapi_DsReplicaOIDMapping_Ctr);
 141         W_ERROR_HAVE_NO_MEMORY(ctr);
 142
 143         ctr->num_mappings       = schema->num_prefixes;
 144         if (include_schema_info) ctr->num_mappings++;
 145         ctr->mappings = talloc_array(schema, struct drsuapi_DsReplicaOIDMapping, ctr->num_mappings);
 146         W_ERROR_HAVE_NO_MEMORY(ctr->mappings);
 147
 148         for (i=0; i < schema->num_prefixes; i++) {
 149                 ctr->mappings[i].id_prefix      = schema->prefixes[i].id>>16;
 150                 ctr->mappings[i].oid.oid        = talloc_strndup(ctr->mappings,
 151                                                                  schema->prefixes[i].oid,
 152                                                                  schema->prefixes[i].oid_len - 1);
 153                 W_ERROR_HAVE_NO_MEMORY(ctr->mappings[i].oid.oid);
 154         }
 155
 156         if (include_schema_info) {
 157                 ctr->mappings[i].id_prefix      = 0;
 158                 ctr->mappings[i].oid.oid        = talloc_strdup(ctr->mappings,
 159                                                                 schema->schema_info);
 160                 W_ERROR_HAVE_NO_MEMORY(ctr->mappings[i].oid.oid);
 161         }
 162
 163         *_ctr = ctr;
 164         return WERR_OK;
 165 }
 166
 167 WERROR dsdb_get_oid_mappings_ldb(const struct dsdb_schema *schema,
 168                                  TALLOC_CTX *mem_ctx,
 169                                  struct ldb_val *prefixMap,
 170                                  struct ldb_val *schemaInfo)
 171 {
 172         WERROR status;
 173         enum ndr_err_code ndr_err;
 174         struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
 175         struct prefixMapBlob pfm;
 176
 177         status = dsdb_get_oid_mappings_drsuapi(schema, false, mem_ctx, &ctr);
 178         W_ERROR_NOT_OK_RETURN(status);
 179
 180         pfm.version     = PREFIX_MAP_VERSION_DSDB;
 181         pfm.reserved    = 0;
 182         pfm.ctr.dsdb    = *ctr;
 183
 184         ndr_err = ndr_push_struct_blob(prefixMap, mem_ctx, lp_iconv_convenience(global_loadparm), &pfm,
 185                                        (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
 186         talloc_free(ctr);
 187         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 188                 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
 189                 return ntstatus_to_werror(nt_status);
 190         }
 191
 192         *schemaInfo = strhex_to_data_blob(schema->schema_info);
 193         W_ERROR_HAVE_NO_MEMORY(schemaInfo->data);
 194         talloc_steal(mem_ctx, schemaInfo->data);
 195
 196         return WERR_OK;
 197 }
 198
 199 WERROR dsdb_verify_oid_mappings_drsuapi(const struct dsdb_schema *schema, const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr)
 200 {
 201         uint32_t i,j;
 202
 203         for (i=0; i < ctr->num_mappings; i++) {
 204                 if (ctr->mappings[i].oid.oid == NULL) {
 205                         return WERR_INVALID_PARAM;
 206                 }
 207
 208                 if (strncasecmp(ctr->mappings[i].oid.oid, "ff", 2) == 0) {
 209                         if (ctr->mappings[i].id_prefix != 0) {
 210                                 return WERR_INVALID_PARAM;
 211                         }
 212
 213                         /* the magic value should be in the last array member */
 214                         if (i != (ctr->num_mappings - 1)) {
 215                                 return WERR_INVALID_PARAM;
 216                         }
 217
 218                         if (ctr->mappings[i].oid.__ndr_size != 21) {
 219                                 return WERR_INVALID_PARAM;
 220                         }
 221
 222                         if (strcasecmp(schema->schema_info, ctr->mappings[i].oid.oid) != 0) {
 223                                 return WERR_DS_DRA_SCHEMA_MISMATCH;
 224                         }
 225                 } else {
 226                         /* the last array member should contain the magic value not a oid */
 227                         if (i == (ctr->num_mappings - 1)) {
 228                                 return WERR_INVALID_PARAM;
 229                         }
 230
 231                         for (j=0; j < schema->num_prefixes; j++) {
 232                                 size_t oid_len;
 233                                 if (schema->prefixes[j].id != (ctr->mappings[i].id_prefix<<16)) {
 234                                         continue;
 235                                 }
 236
 237                                 oid_len = strlen(ctr->mappings[i].oid.oid);
 238
 239                                 if (oid_len != (schema->prefixes[j].oid_len - 1)) {
 240                                         return WERR_DS_DRA_SCHEMA_MISMATCH;
 241                                 }
 242
 243                                 if (strncmp(ctr->mappings[i].oid.oid, schema->prefixes[j].oid, oid_len) != 0) {
 244                                         return WERR_DS_DRA_SCHEMA_MISMATCH;
 245                                 }
 246
 247                                 break;
 248                         }
 249
 250                         if (j == schema->num_prefixes) {
 251                                 return WERR_DS_DRA_SCHEMA_MISMATCH;
 252                         }
 253                 }
 254         }
 255
 256         return WERR_OK;
 257 }
 258
 259 WERROR dsdb_map_oid2int(const struct dsdb_schema *schema, const char *in, uint32_t *out)
 260 {
 261         uint32_t i;
 262
 263         for (i=0; i < schema->num_prefixes; i++) {
 264                 const char *val_str;
 265                 char *end_str;
 266                 unsigned val;
 267
 268                 if (strncmp(schema->prefixes[i].oid, in, schema->prefixes[i].oid_len) != 0) {
 269                         continue;
 270                 }
 271
 272                 val_str = in + schema->prefixes[i].oid_len;
 273                 end_str = NULL;
 274                 errno = 0;
 275
 276                 if (val_str[0] == '\0') {
 277                         return WERR_INVALID_PARAM;
 278                 }
 279
 280                 /* two '.' chars are invalid */
 281                 if (val_str[0] == '.') {
 282                         return WERR_INVALID_PARAM;
 283                 }
 284
 285                 val = strtoul(val_str, &end_str, 10);
 286                 if (end_str[0] == '.' && end_str[1] != '\0') {
 287                         /*
 288                          * if it's a '.' and not the last char
 289                          * then maybe an other mapping apply
 290                          */
 291                         continue;
 292                 } else if (end_str[0] != '\0') {
 293                         return WERR_INVALID_PARAM;
 294                 } else if (val > 0xFFFF) {
 295                         return WERR_INVALID_PARAM;
 296                 }
 297
 298                 *out = schema->prefixes[i].id | val;
 299                 return WERR_OK;
 300         }
 301
 302         return WERR_DS_NO_MSDS_INTID;
 303 }
 304
 305 WERROR dsdb_map_int2oid(const struct dsdb_schema *schema, uint32_t in, TALLOC_CTX *mem_ctx, const char **out)
 306 {
 307         uint32_t i;
 308
 309         for (i=0; i < schema->num_prefixes; i++) {
 310                 const char *val;
 311                 if (schema->prefixes[i].id != (in & 0xFFFF0000)) {
 312                         continue;
 313                 }
 314
 315                 val = talloc_asprintf(mem_ctx, "%s%u",
 316                                       schema->prefixes[i].oid,
 317                                       in & 0xFFFF);
 318                 W_ERROR_HAVE_NO_MEMORY(val);
 319
 320                 *out = val;
 321                 return WERR_OK;
 322         }
 323
 324         return WERR_DS_NO_MSDS_INTID;
 325 }
 326
 327 #define GET_STRING_LDB(msg, attr, mem_ctx, p, elem, strict) do { \
 328         (p)->elem = samdb_result_string(msg, attr, NULL);\
 329         if (strict && (p)->elem == NULL) { \
 330                 d_printf("%s: %s == NULL\n", __location__, attr); \
 331                 return WERR_INVALID_PARAM; \
 332         } \
 333         talloc_steal(mem_ctx, (p)->elem); \
 334 } while (0)
 335
 336 #define GET_STRING_LIST_LDB(msg, attr, mem_ctx, p, elem, strict) do {   \
 337         int get_string_list_counter;                                    \
 338         struct ldb_message_element *get_string_list_el = ldb_msg_find_element(msg, attr); \
 339         if (get_string_list_el == NULL) {                               \
 340                 if (strict) {                                           \
 341                         d_printf("%s: %s == NULL\n", __location__, attr); \
 342                         return WERR_INVALID_PARAM;                      \
 343                 } else {                                                \
 344                         (p)->elem = NULL;                               \
 345                         break;                                          \
 346                 }                                                       \
 347         }                                                               \
 348         (p)->elem = talloc_array(mem_ctx, const char *, get_string_list_el->num_values + 1); \
 349         for (get_string_list_counter=0;                                 \
 350              get_string_list_counter < get_string_list_el->num_values;  \
 351              get_string_list_counter++) {                               \
 352                 (p)->elem[get_string_list_counter] = talloc_strndup((p)->elem, \
 353                                                                     (const char *)get_string_list_el->values[get_string_list_counter].data, \
 354                                                                     get_string_list_el->values[get_string_list_counter].length); \
 355                 if (!(p)->elem[get_string_list_counter]) {              \
 356                         d_printf("%s: talloc_strndup failed for %s\n", __location__, attr); \
 357                         return WERR_NOMEM;                              \
 358                 }                                                       \
 359                 (p)->elem[get_string_list_counter+1] = NULL;            \
 360         }                                                               \
 361         talloc_steal(mem_ctx, (p)->elem);                               \
 362 } while (0)
 363
 364 #define GET_BOOL_LDB(msg, attr, p, elem, strict) do { \
 365         const char *str; \
 366         str = samdb_result_string(msg, attr, NULL);\
 367         if (str == NULL) { \
 368                 if (strict) { \
 369                         d_printf("%s: %s == NULL\n", __location__, attr); \
 370                         return WERR_INVALID_PARAM; \
 371                 } else { \
 372                         (p)->elem = false; \
 373                 } \
 374         } else if (strcasecmp("TRUE", str) == 0) { \
 375                 (p)->elem = true; \
 376         } else if (strcasecmp("FALSE", str) == 0) { \
 377                 (p)->elem = false; \
 378         } else { \
 379                 d_printf("%s: %s == %s\n", __location__, attr, str); \
 380                 return WERR_INVALID_PARAM; \
 381         } \
 382 } while (0)
 383
 384 #define GET_UINT32_LDB(msg, attr, p, elem) do { \
 385         (p)->elem = samdb_result_uint(msg, attr, 0);\
 386 } while (0)
 387
 388 #define GET_GUID_LDB(msg, attr, p, elem) do { \
 389         (p)->elem = samdb_result_guid(msg, attr);\
 390 } while (0)
 391
 392 #define GET_BLOB_LDB(msg, attr, mem_ctx, p, elem) do { \
 393         const struct ldb_val *_val;\
 394         _val = ldb_msg_find_ldb_val(msg, attr);\
 395         if (_val) {\
 396                 (p)->elem = *_val;\
 397                 talloc_steal(mem_ctx, (p)->elem.data);\
 398         } else {\
 399                 ZERO_STRUCT((p)->elem);\
 400         }\
 401 } while (0)
 402
 403 WERROR dsdb_attribute_from_ldb(const struct dsdb_schema *schema,
 404                                struct ldb_message *msg,
 405                                TALLOC_CTX *mem_ctx,
 406                                struct dsdb_attribute *attr)
 407 {
 408         WERROR status;
 409
 410         GET_STRING_LDB(msg, "cn", mem_ctx, attr, cn, false);
 411         GET_STRING_LDB(msg, "lDAPDisplayName", mem_ctx, attr, lDAPDisplayName, true);
 412         GET_STRING_LDB(msg, "attributeID", mem_ctx, attr, attributeID_oid, true);
 413         if (schema->num_prefixes == 0) {
 414                 /* set an invalid value */
 415                 attr->attributeID_id = 0xFFFFFFFF;
 416         } else {
 417                 status = dsdb_map_oid2int(schema, attr->attributeID_oid, &attr->attributeID_id);
 418                 if (!W_ERROR_IS_OK(status)) {
 419                         DEBUG(0,("%s: '%s': unable to map attributeID %s: %s\n",
 420                                 __location__, attr->lDAPDisplayName, attr->attributeID_oid,
 421                                 win_errstr(status)));
 422                         return status;
 423                 }
 424         }
 425         GET_GUID_LDB(msg, "schemaIDGUID", attr, schemaIDGUID);
 426         GET_UINT32_LDB(msg, "mAPIID", attr, mAPIID);
 427
 428         GET_GUID_LDB(msg, "attributeSecurityGUID", attr, attributeSecurityGUID);
 429
 430         GET_UINT32_LDB(msg, "searchFlags", attr, searchFlags);
 431         GET_UINT32_LDB(msg, "systemFlags", attr, systemFlags);
 432         GET_BOOL_LDB(msg, "isMemberOfPartialAttributeSet", attr, isMemberOfPartialAttributeSet, false);
 433         GET_UINT32_LDB(msg, "linkID", attr, linkID);
 434
 435         GET_STRING_LDB(msg, "attributeSyntax", mem_ctx, attr, attributeSyntax_oid, true);
 436         if (schema->num_prefixes == 0) {
 437                 /* set an invalid value */
 438                 attr->attributeSyntax_id = 0xFFFFFFFF;
 439         } else {
 440                 status = dsdb_map_oid2int(schema, attr->attributeSyntax_oid, &attr->attributeSyntax_id);
 441                 if (!W_ERROR_IS_OK(status)) {
 442                         DEBUG(0,("%s: '%s': unable to map attributeSyntax_ %s: %s\n",
 443                                 __location__, attr->lDAPDisplayName, attr->attributeSyntax_oid,
 444                                 win_errstr(status)));
 445                         return status;
 446                 }
 447         }
 448         GET_UINT32_LDB(msg, "oMSyntax", attr, oMSyntax);
 449         GET_BLOB_LDB(msg, "oMObjectClass", mem_ctx, attr, oMObjectClass);
 450
 451         GET_BOOL_LDB(msg, "isSingleValued", attr, isSingleValued, true);
 452         GET_UINT32_LDB(msg, "rangeLower", attr, rangeLower);
 453         GET_UINT32_LDB(msg, "rangeUpper", attr, rangeUpper);
 454         GET_BOOL_LDB(msg, "extendedCharsAllowed", attr, extendedCharsAllowed, false);
 455
 456         GET_UINT32_LDB(msg, "schemaFlagsEx", attr, schemaFlagsEx);
 457         GET_BLOB_LDB(msg, "msDs-Schema-Extensions", mem_ctx, attr, msDs_Schema_Extensions);
 458
 459         GET_BOOL_LDB(msg, "showInAdvancedViewOnly", attr, showInAdvancedViewOnly, false);
 460         GET_STRING_LDB(msg, "adminDisplayName", mem_ctx, attr, adminDisplayName, false);
 461         GET_STRING_LDB(msg, "adminDescription", mem_ctx, attr, adminDescription, false);
 462         GET_STRING_LDB(msg, "classDisplayName", mem_ctx, attr, classDisplayName, false);
 463         GET_BOOL_LDB(msg, "isEphemeral", attr, isEphemeral, false);
 464         GET_BOOL_LDB(msg, "isDefunct", attr, isDefunct, false);
 465         GET_BOOL_LDB(msg, "systemOnly", attr, systemOnly, false);
 466
 467         attr->syntax = dsdb_syntax_for_attribute(attr);
 468         if (!attr->syntax) {
 469                 return WERR_DS_ATT_SCHEMA_REQ_SYNTAX;
 470         }
 471
 472         return WERR_OK;
 473 }
 474
 475 WERROR dsdb_class_from_ldb(const struct dsdb_schema *schema,
 476                            struct ldb_message *msg,
 477                            TALLOC_CTX *mem_ctx,
 478                            struct dsdb_class *obj)
 479 {
 480         WERROR status;
 481
 482         GET_STRING_LDB(msg, "cn", mem_ctx, obj, cn, false);
 483         GET_STRING_LDB(msg, "lDAPDisplayName", mem_ctx, obj, lDAPDisplayName, true);
 484         GET_STRING_LDB(msg, "governsID", mem_ctx, obj, governsID_oid, true);
 485         if (schema->num_prefixes == 0) {
 486                 /* set an invalid value */
 487                 obj->governsID_id = 0xFFFFFFFF;
 488         } else {
 489                 status = dsdb_map_oid2int(schema, obj->governsID_oid, &obj->governsID_id);
 490                 if (!W_ERROR_IS_OK(status)) {
 491                         DEBUG(0,("%s: '%s': unable to map governsID %s: %s\n",
 492                                 __location__, obj->lDAPDisplayName, obj->governsID_oid,
 493                                 win_errstr(status)));
 494                         return status;
 495                 }
 496         }
 497         GET_GUID_LDB(msg, "schemaIDGUID", obj, schemaIDGUID);
 498
 499         GET_UINT32_LDB(msg, "objectClassCategory", obj, objectClassCategory);
 500         GET_STRING_LDB(msg, "rDNAttID", mem_ctx, obj, rDNAttID, false);
 501         GET_STRING_LDB(msg, "defaultObjectCategory", mem_ctx, obj, defaultObjectCategory, true);
 502
 503         GET_STRING_LDB(msg, "subClassOf", mem_ctx, obj, subClassOf, true);
 504
 505         obj->systemAuxiliaryClass       = NULL;
 506
 507         obj->auxiliaryClass             = NULL;
 508
 509         GET_STRING_LIST_LDB(msg, "systemMustContain", mem_ctx, obj, systemMustContain, false);
 510         GET_STRING_LIST_LDB(msg, "systemMayContain", mem_ctx, obj, systemMayContain, false);
 511         GET_STRING_LIST_LDB(msg, "mustContain", mem_ctx, obj, mustContain, false);
 512         GET_STRING_LIST_LDB(msg, "mayContain", mem_ctx, obj, mayContain, false);
 513
 514         GET_STRING_LIST_LDB(msg, "systemPossSuperiors", mem_ctx, obj, systemPossSuperiors, false);
 515         GET_STRING_LIST_LDB(msg, "possSuperiors", mem_ctx, obj, possSuperiors, false);
 516         GET_STRING_LIST_LDB(msg, "possibleInferiors", mem_ctx, obj, possibleInferiors, false);
 517
 518         GET_STRING_LDB(msg, "defaultSecurityDescriptor", mem_ctx, obj, defaultSecurityDescriptor, false);
 519
 520         GET_UINT32_LDB(msg, "schemaFlagsEx", obj, schemaFlagsEx);
 521         GET_BLOB_LDB(msg, "msDs-Schema-Extensions", mem_ctx, obj, msDs_Schema_Extensions);
 522
 523         GET_BOOL_LDB(msg, "showInAdvancedViewOnly", obj, showInAdvancedViewOnly, false);
 524         GET_STRING_LDB(msg, "adminDisplayName", mem_ctx, obj, adminDisplayName, false);
 525         GET_STRING_LDB(msg, "adminDescription", mem_ctx, obj, adminDescription, false);
 526         GET_STRING_LDB(msg, "classDisplayName", mem_ctx, obj, classDisplayName, false);
 527         GET_BOOL_LDB(msg, "defaultHidingValue", obj, defaultHidingValue, false);
 528         GET_BOOL_LDB(msg, "isDefunct", obj, isDefunct, false);
 529         GET_BOOL_LDB(msg, "systemOnly", obj, systemOnly, false);
 530
 531         return WERR_OK;
 532 }
 533
 534 static const struct {
 535         const char *name;
 536         const char *oid;
 537 } name_mappings[] = {
 538         { "cn",                                 "2.5.4.3" },
 539         { "name",                               "1.2.840.113556.1.4.1" },
 540         { "lDAPDisplayName",                    "1.2.840.113556.1.2.460" },
 541         { "attributeID",                        "1.2.840.113556.1.2.30" },
 542         { "schemaIDGUID",                       "1.2.840.113556.1.4.148" },
 543         { "mAPIID",                             "1.2.840.113556.1.2.49" },
 544         { "attributeSecurityGUID",              "1.2.840.113556.1.4.149" },
 545         { "searchFlags",                        "1.2.840.113556.1.2.334" },
 546         { "systemFlags",                        "1.2.840.113556.1.4.375" },
 547         { "isMemberOfPartialAttributeSet",      "1.2.840.113556.1.4.639" },
 548         { "linkID",                             "1.2.840.113556.1.2.50" },
 549         { "attributeSyntax",                    "1.2.840.113556.1.2.32" },
 550         { "oMSyntax",                           "1.2.840.113556.1.2.231" },
 551         { "oMObjectClass",                      "1.2.840.113556.1.2.218" },
 552         { "isSingleValued",                     "1.2.840.113556.1.2.33" },
 553         { "rangeLower",                         "1.2.840.113556.1.2.34" },
 554         { "rangeUpper",                         "1.2.840.113556.1.2.35" },
 555         { "extendedCharsAllowed",               "1.2.840.113556.1.2.380" },
 556         { "schemaFlagsEx",                      "1.2.840.113556.1.4.120" },
 557         { "msDs-Schema-Extensions",             "1.2.840.113556.1.4.1440" },
 558         { "showInAdvancedViewOnly",             "1.2.840.113556.1.2.169" },
 559         { "adminDisplayName",                   "1.2.840.113556.1.2.194" },
 560         { "adminDescription",                   "1.2.840.113556.1.2.226" },
 561         { "classDisplayName",                   "1.2.840.113556.1.4.610" },
 562         { "isEphemeral",                        "1.2.840.113556.1.4.1212" },
 563         { "isDefunct",                          "1.2.840.113556.1.4.661" },
 564         { "systemOnly",                         "1.2.840.113556.1.4.170" },
 565         { "governsID",                          "1.2.840.113556.1.2.22" },
 566         { "objectClassCategory",                "1.2.840.113556.1.2.370" },
 567         { "rDNAttID",                           "1.2.840.113556.1.2.26" },
 568         { "defaultObjectCategory",              "1.2.840.113556.1.4.783" },
 569         { "subClassOf",                         "1.2.840.113556.1.2.21" },
 570         { "systemAuxiliaryClass",               "1.2.840.113556.1.4.198" },
 571         { "systemPossSuperiors",                "1.2.840.113556.1.4.195" },
 572         { "systemMustContain",                  "1.2.840.113556.1.4.197" },
 573         { "systemMayContain",                   "1.2.840.113556.1.4.196" },
 574         { "auxiliaryClass",                     "1.2.840.113556.1.2.351" },
 575         { "possSuperiors",                      "1.2.840.113556.1.2.8" },
 576         { "mustContain",                        "1.2.840.113556.1.2.24" },
 577         { "mayContain",                         "1.2.840.113556.1.2.25" },
 578         { "defaultSecurityDescriptor",          "1.2.840.113556.1.4.224" },
 579         { "defaultHidingValue",                 "1.2.840.113556.1.4.518" },
 580 };
 581
 582 static struct drsuapi_DsReplicaAttribute *dsdb_find_object_attr_name(struct dsdb_schema *schema,
 583                                                                      struct drsuapi_DsReplicaObject *obj,
 584                                                                      const char *name,
 585                                                                      uint32_t *idx)
 586 {
 587         WERROR status;
 588         uint32_t i, id;
 589         const char *oid = NULL;
 590
 591         for(i=0; i < ARRAY_SIZE(name_mappings); i++) {
 592                 if (strcmp(name_mappings[i].name, name) != 0) continue;
 593
 594                 oid = name_mappings[i].oid;
 595                 break;
 596         }
 597
 598         if (!oid) {
 599                 return NULL;
 600         }
 601
 602         status = dsdb_map_oid2int(schema, oid, &id);
 603         if (!W_ERROR_IS_OK(status)) {
 604                 return NULL;
 605         }
 606
 607         for (i=0; i < obj->attribute_ctr.num_attributes; i++) {
 608                 if (obj->attribute_ctr.attributes[i].attid != id) continue;
 609
 610                 if (idx) *idx = i;
 611                 return &obj->attribute_ctr.attributes[i];
 612         }
 613
 614         return NULL;
 615 }
 616
 617 #define GET_STRING_DS(s, r, attr, mem_ctx, p, elem, strict) do { \
 618         struct drsuapi_DsReplicaAttribute *_a; \
 619         _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
 620         if (strict && !_a) { \
 621                 d_printf("%s: %s == NULL\n", __location__, attr); \
 622                 return WERR_INVALID_PARAM; \
 623         } \
 624         if (strict && _a->value_ctr.num_values != 1) { \
 625                 d_printf("%s: %s num_values == %u\n", __location__, attr, \
 626                         _a->value_ctr.num_values); \
 627                 return WERR_INVALID_PARAM; \
 628         } \
 629         if (_a && _a->value_ctr.num_values >= 1) { \
 630                 ssize_t _ret; \
 631                 _ret = convert_string_talloc(mem_ctx, lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UNIX, \
 632                                              _a->value_ctr.values[0].blob->data, \
 633                                              _a->value_ctr.values[0].blob->length, \
 634                                              (void **)discard_const(&(p)->elem)); \
 635                 if (_ret == -1) { \
 636                         DEBUG(0,("%s: invalid data!\n", attr)); \
 637                         dump_data(0, \
 638                                      _a->value_ctr.values[0].blob->data, \
 639                                      _a->value_ctr.values[0].blob->length); \
 640                         return WERR_FOOBAR; \
 641                 } \
 642         } else { \
 643                 (p)->elem = NULL; \
 644         } \
 645 } while (0)
 646
 647 #define GET_DN_DS(s, r, attr, mem_ctx, p, elem, strict) do { \
 648         struct drsuapi_DsReplicaAttribute *_a; \
 649         _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
 650         if (strict && !_a) { \
 651                 d_printf("%s: %s == NULL\n", __location__, attr); \
 652                 return WERR_INVALID_PARAM; \
 653         } \
 654         if (strict && _a->value_ctr.num_values != 1) { \
 655                 d_printf("%s: %s num_values == %u\n", __location__, attr, \
 656                         _a->value_ctr.num_values); \
 657                 return WERR_INVALID_PARAM; \
 658         } \
 659         if (strict && !_a->value_ctr.values[0].blob) { \
 660                 d_printf("%s: %s data == NULL\n", __location__, attr); \
 661                 return WERR_INVALID_PARAM; \
 662         } \
 663         if (_a && _a->value_ctr.num_values >= 1 \
 664             && _a->value_ctr.values[0].blob) { \
 665                 struct drsuapi_DsReplicaObjectIdentifier3 _id3; \
 666                 enum ndr_err_code _ndr_err; \
 667                 _ndr_err = ndr_pull_struct_blob_all(_a->value_ctr.values[0].blob, \
 668                                                       mem_ctx, lp_iconv_convenience(global_loadparm), &_id3,\
 669                                                       (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);\
 670                 if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
 671                         NTSTATUS _nt_status = ndr_map_error2ntstatus(_ndr_err); \
 672                         return ntstatus_to_werror(_nt_status); \
 673                 } \
 674                 (p)->elem = _id3.dn; \
 675         } else { \
 676                 (p)->elem = NULL; \
 677         } \
 678 } while (0)
 679
 680 #define GET_BOOL_DS(s, r, attr, p, elem, strict) do { \
 681         struct drsuapi_DsReplicaAttribute *_a; \
 682         _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
 683         if (strict && !_a) { \
 684                 d_printf("%s: %s == NULL\n", __location__, attr); \
 685                 return WERR_INVALID_PARAM; \
 686         } \
 687         if (strict && _a->value_ctr.num_values != 1) { \
 688                 d_printf("%s: %s num_values == %u\n", __location__, attr, \
 689                          (unsigned int)_a->value_ctr.num_values);       \
 690                 return WERR_INVALID_PARAM; \
 691         } \
 692         if (strict && !_a->value_ctr.values[0].blob) { \
 693                 d_printf("%s: %s data == NULL\n", __location__, attr); \
 694                 return WERR_INVALID_PARAM; \
 695         } \
 696         if (strict && _a->value_ctr.values[0].blob->length != 4) { \
 697                 d_printf("%s: %s length == %u\n", __location__, attr, \
 698                          (unsigned int)_a->value_ctr.values[0].blob->length); \
 699                 return WERR_INVALID_PARAM; \
 700         } \
 701         if (_a && _a->value_ctr.num_values >= 1 \
 702             && _a->value_ctr.values[0].blob \
 703             && _a->value_ctr.values[0].blob->length == 4) { \
 704                 (p)->elem = (IVAL(_a->value_ctr.values[0].blob->data,0)?true:false);\
 705         } else { \
 706                 (p)->elem = false; \
 707         } \
 708 } while (0)
 709
 710 #define GET_UINT32_DS(s, r, attr, p, elem) do { \
 711         struct drsuapi_DsReplicaAttribute *_a; \
 712         _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
 713         if (_a && _a->value_ctr.num_values >= 1 \
 714             && _a->value_ctr.values[0].blob \
 715             && _a->value_ctr.values[0].blob->length == 4) { \
 716                 (p)->elem = IVAL(_a->value_ctr.values[0].blob->data,0);\
 717         } else { \
 718                 (p)->elem = 0; \
 719         } \
 720 } while (0)
 721
 722 #define GET_GUID_DS(s, r, attr, mem_ctx, p, elem) do { \
 723         struct drsuapi_DsReplicaAttribute *_a; \
 724         _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
 725         if (_a && _a->value_ctr.num_values >= 1 \
 726             && _a->value_ctr.values[0].blob \
 727             && _a->value_ctr.values[0].blob->length == 16) { \
 728                 enum ndr_err_code _ndr_err; \
 729                 _ndr_err = ndr_pull_struct_blob_all(_a->value_ctr.values[0].blob, \
 730                                                       mem_ctx, lp_iconv_convenience(global_loadparm), &(p)->elem, \
 731                                                       (ndr_pull_flags_fn_t)ndr_pull_GUID); \
 732                 if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
 733                         NTSTATUS _nt_status = ndr_map_error2ntstatus(_ndr_err); \
 734                         return ntstatus_to_werror(_nt_status); \
 735                 } \
 736         } else { \
 737                 ZERO_STRUCT((p)->elem);\
 738         } \
 739 } while (0)
 740
 741 #define GET_BLOB_DS(s, r, attr, mem_ctx, p, elem) do { \
 742         struct drsuapi_DsReplicaAttribute *_a; \
 743         _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
 744         if (_a && _a->value_ctr.num_values >= 1 \
 745             && _a->value_ctr.values[0].blob) { \
 746                 (p)->elem = *_a->value_ctr.values[0].blob;\
 747                 talloc_steal(mem_ctx, (p)->elem.data); \
 748         } else { \
 749                 ZERO_STRUCT((p)->elem);\
 750         }\
 751 } while (0)
 752
 753 WERROR dsdb_attribute_from_drsuapi(struct dsdb_schema *schema,
 754                                    struct drsuapi_DsReplicaObject *r,
 755                                    TALLOC_CTX *mem_ctx,
 756                                    struct dsdb_attribute *attr)
 757 {
 758         WERROR status;
 759
 760         GET_STRING_DS(schema, r, "name", mem_ctx, attr, cn, true);
 761         GET_STRING_DS(schema, r, "lDAPDisplayName", mem_ctx, attr, lDAPDisplayName, true);
 762         GET_UINT32_DS(schema, r, "attributeID", attr, attributeID_id);
 763         status = dsdb_map_int2oid(schema, attr->attributeID_id, mem_ctx, &attr->attributeID_oid);
 764         if (!W_ERROR_IS_OK(status)) {
 765                 DEBUG(0,("%s: '%s': unable to map attributeID 0x%08X: %s\n",
 766                         __location__, attr->lDAPDisplayName, attr->attributeID_id,
 767                         win_errstr(status)));
 768                 return status;
 769         }
 770         GET_GUID_DS(schema, r, "schemaIDGUID", mem_ctx, attr, schemaIDGUID);
 771         GET_UINT32_DS(schema, r, "mAPIID", attr, mAPIID);
 772
 773         GET_GUID_DS(schema, r, "attributeSecurityGUID", mem_ctx, attr, attributeSecurityGUID);
 774
 775         GET_UINT32_DS(schema, r, "searchFlags", attr, searchFlags);
 776         GET_UINT32_DS(schema, r, "systemFlags", attr, systemFlags);
 777         GET_BOOL_DS(schema, r, "isMemberOfPartialAttributeSet", attr, isMemberOfPartialAttributeSet, false);
 778         GET_UINT32_DS(schema, r, "linkID", attr, linkID);
 779
 780         GET_UINT32_DS(schema, r, "attributeSyntax", attr, attributeSyntax_id);
 781         status = dsdb_map_int2oid(schema, attr->attributeSyntax_id, mem_ctx, &attr->attributeSyntax_oid);
 782         if (!W_ERROR_IS_OK(status)) {
 783                 DEBUG(0,("%s: '%s': unable to map attributeSyntax 0x%08X: %s\n",
 784                         __location__, attr->lDAPDisplayName, attr->attributeSyntax_id,
 785                         win_errstr(status)));
 786                 return status;
 787         }
 788         GET_UINT32_DS(schema, r, "oMSyntax", attr, oMSyntax);
 789         GET_BLOB_DS(schema, r, "oMObjectClass", mem_ctx, attr, oMObjectClass);
 790
 791         GET_BOOL_DS(schema, r, "isSingleValued", attr, isSingleValued, true);
 792         GET_UINT32_DS(schema, r, "rangeLower", attr, rangeLower);
 793         GET_UINT32_DS(schema, r, "rangeUpper", attr, rangeUpper);
 794         GET_BOOL_DS(schema, r, "extendedCharsAllowed", attr, extendedCharsAllowed, false);
 795
 796         GET_UINT32_DS(schema, r, "schemaFlagsEx", attr, schemaFlagsEx);
 797         GET_BLOB_DS(schema, r, "msDs-Schema-Extensions", mem_ctx, attr, msDs_Schema_Extensions);
 798
 799         GET_BOOL_DS(schema, r, "showInAdvancedViewOnly", attr, showInAdvancedViewOnly, false);
 800         GET_STRING_DS(schema, r, "adminDisplayName", mem_ctx, attr, adminDisplayName, false);
 801         GET_STRING_DS(schema, r, "adminDescription", mem_ctx, attr, adminDescription, false);
 802         GET_STRING_DS(schema, r, "classDisplayName", mem_ctx, attr, classDisplayName, false);
 803         GET_BOOL_DS(schema, r, "isEphemeral", attr, isEphemeral, false);
 804         GET_BOOL_DS(schema, r, "isDefunct", attr, isDefunct, false);
 805         GET_BOOL_DS(schema, r, "systemOnly", attr, systemOnly, false);
 806
 807         attr->syntax = dsdb_syntax_for_attribute(attr);
 808         if (!attr->syntax) {
 809                 return WERR_DS_ATT_SCHEMA_REQ_SYNTAX;
 810         }
 811
 812         return WERR_OK;
 813 }
 814
 815 WERROR dsdb_class_from_drsuapi(struct dsdb_schema *schema,
 816                                struct drsuapi_DsReplicaObject *r,
 817                                TALLOC_CTX *mem_ctx,
 818                                struct dsdb_class *obj)
 819 {
 820         WERROR status;
 821
 822         GET_STRING_DS(schema, r, "name", mem_ctx, obj, cn, true);
 823         GET_STRING_DS(schema, r, "lDAPDisplayName", mem_ctx, obj, lDAPDisplayName, true);
 824         GET_UINT32_DS(schema, r, "governsID", obj, governsID_id);
 825         status = dsdb_map_int2oid(schema, obj->governsID_id, mem_ctx, &obj->governsID_oid);
 826         if (!W_ERROR_IS_OK(status)) {
 827                 DEBUG(0,("%s: '%s': unable to map governsID 0x%08X: %s\n",
 828                         __location__, obj->lDAPDisplayName, obj->governsID_id,
 829                         win_errstr(status)));
 830                 return status;
 831         }
 832         GET_GUID_DS(schema, r, "schemaIDGUID", mem_ctx, obj, schemaIDGUID);
 833
 834         GET_UINT32_DS(schema, r, "objectClassCategory", obj, objectClassCategory);
 835         GET_STRING_DS(schema, r, "rDNAttID", mem_ctx, obj, rDNAttID, false);
 836         GET_DN_DS(schema, r, "defaultObjectCategory", mem_ctx, obj, defaultObjectCategory, true);
 837
 838         GET_STRING_DS(schema, r, "subClassOf", mem_ctx, obj, subClassOf, true);
 839
 840         obj->systemAuxiliaryClass       = NULL;
 841         obj->systemPossSuperiors        = NULL;
 842         obj->systemMustContain          = NULL;
 843         obj->systemMayContain           = NULL;
 844
 845         obj->auxiliaryClass             = NULL;
 846         obj->possSuperiors              = NULL;
 847         obj->mustContain                = NULL;
 848         obj->mayContain                 = NULL;
 849
 850         obj->possibleInferiors          = NULL;
 851
 852         GET_STRING_DS(schema, r, "defaultSecurityDescriptor", mem_ctx, obj, defaultSecurityDescriptor, false);
 853
 854         GET_UINT32_DS(schema, r, "schemaFlagsEx", obj, schemaFlagsEx);
 855         GET_BLOB_DS(schema, r, "msDs-Schema-Extensions", mem_ctx, obj, msDs_Schema_Extensions);
 856
 857         GET_BOOL_DS(schema, r, "showInAdvancedViewOnly", obj, showInAdvancedViewOnly, false);
 858         GET_STRING_DS(schema, r, "adminDisplayName", mem_ctx, obj, adminDisplayName, false);
 859         GET_STRING_DS(schema, r, "adminDescription", mem_ctx, obj, adminDescription, false);
 860         GET_STRING_DS(schema, r, "classDisplayName", mem_ctx, obj, classDisplayName, false);
 861         GET_BOOL_DS(schema, r, "defaultHidingValue", obj, defaultHidingValue, false);
 862         GET_BOOL_DS(schema, r, "isDefunct", obj, isDefunct, false);
 863         GET_BOOL_DS(schema, r, "systemOnly", obj, systemOnly, false);
 864
 865         return WERR_OK;
 866 }
 867
 868 const struct dsdb_attribute *dsdb_attribute_by_attributeID_id(const struct dsdb_schema *schema,
 869                                                               uint32_t id)
 870 {
 871         struct dsdb_attribute *cur;
 872
 873         /*
 874          * 0xFFFFFFFF is used as value when no mapping table is available,
 875          * so don't try to match with it
 876          */
 877         if (id == 0xFFFFFFFF) return NULL;
 878
 879         /* TODO: add binary search */
 880         for (cur = schema->attributes; cur; cur = cur->next) {
 881                 if (cur->attributeID_id != id) continue;
 882
 883                 return cur;
 884         }
 885
 886         return NULL;
 887 }
 888
 889 const struct dsdb_attribute *dsdb_attribute_by_attributeID_oid(const struct dsdb_schema *schema,
 890                                                                const char *oid)
 891 {
 892         struct dsdb_attribute *cur;
 893
 894         if (!oid) return NULL;
 895
 896         /* TODO: add binary search */
 897         for (cur = schema->attributes; cur; cur = cur->next) {
 898                 if (strcmp(cur->attributeID_oid, oid) != 0) continue;
 899
 900                 return cur;
 901         }
 902
 903         return NULL;
 904 }
 905
 906 const struct dsdb_attribute *dsdb_attribute_by_lDAPDisplayName(const struct dsdb_schema *schema,
 907                                                                const char *name)
 908 {
 909         struct dsdb_attribute *cur;
 910
 911         if (!name) return NULL;
 912
 913         /* TODO: add binary search */
 914         for (cur = schema->attributes; cur; cur = cur->next) {
 915                 if (strcasecmp(cur->lDAPDisplayName, name) != 0) continue;
 916
 917                 return cur;
 918         }
 919
 920         return NULL;
 921 }
 922
 923 const struct dsdb_attribute *dsdb_attribute_by_linkID(const struct dsdb_schema *schema,
 924                                                       int linkID)
 925 {
 926         struct dsdb_attribute *cur;
 927
 928         /* TODO: add binary search */
 929         for (cur = schema->attributes; cur; cur = cur->next) {
 930                 if (cur->linkID != linkID) continue;
 931
 932                 return cur;
 933         }
 934
 935         return NULL;
 936 }
 937
 938 const struct dsdb_class *dsdb_class_by_governsID_id(const struct dsdb_schema *schema,
 939                                                     uint32_t id)
 940 {
 941         struct dsdb_class *cur;
 942
 943         /*
 944          * 0xFFFFFFFF is used as value when no mapping table is available,
 945          * so don't try to match with it
 946          */
 947         if (id == 0xFFFFFFFF) return NULL;
 948
 949         /* TODO: add binary search */
 950         for (cur = schema->classes; cur; cur = cur->next) {
 951                 if (cur->governsID_id != id) continue;
 952
 953                 return cur;
 954         }
 955
 956         return NULL;
 957 }
 958
 959 const struct dsdb_class *dsdb_class_by_governsID_oid(const struct dsdb_schema *schema,
 960                                                      const char *oid)
 961 {
 962         struct dsdb_class *cur;
 963
 964         if (!oid) return NULL;
 965
 966         /* TODO: add binary search */
 967         for (cur = schema->classes; cur; cur = cur->next) {
 968                 if (strcmp(cur->governsID_oid, oid) != 0) continue;
 969
 970                 return cur;
 971         }
 972
 973         return NULL;
 974 }
 975
 976 const struct dsdb_class *dsdb_class_by_lDAPDisplayName(const struct dsdb_schema *schema,
 977                                                        const char *name)
 978 {
 979         struct dsdb_class *cur;
 980
 981         if (!name) return NULL;
 982
 983         /* TODO: add binary search */
 984         for (cur = schema->classes; cur; cur = cur->next) {
 985                 if (strcasecmp(cur->lDAPDisplayName, name) != 0) continue;
 986
 987                 return cur;
 988         }
 989
 990         return NULL;
 991 }
 992
 993 const struct dsdb_class *dsdb_class_by_cn(const struct dsdb_schema *schema,
 994                                           const char *cn)
 995 {
 996         struct dsdb_class *cur;
 997
 998         if (!cn) return NULL;
 999
1000         /* TODO: add binary search */
1001         for (cur = schema->classes; cur; cur = cur->next) {
1002                 if (strcasecmp(cur->cn, cn) != 0) continue;
1003
1004                 return cur;
1005         }
1006
1007         return NULL;
1008 }
1009
1010 const char *dsdb_lDAPDisplayName_by_id(const struct dsdb_schema *schema,
1011                                        uint32_t id)
1012 {
1013         const struct dsdb_attribute *a;
1014         const struct dsdb_class *c;
1015
1016         /* TODO: add binary search */
1017         a = dsdb_attribute_by_attributeID_id(schema, id);
1018         if (a) {
1019                 return a->lDAPDisplayName;
1020         }
1021
1022         c = dsdb_class_by_governsID_id(schema, id);
1023         if (c) {
1024                 return c->lDAPDisplayName;
1025         }
1026
1027         return NULL;
1028 }
1029
1030 WERROR dsdb_linked_attribute_lDAPDisplayName_list(const struct dsdb_schema *schema, TALLOC_CTX *mem_ctx, const char ***attr_list_ret)
1031 {
1032         const char **attr_list = NULL;
1033         struct dsdb_attribute *cur;
1034         int i = 0;
1035         for (cur = schema->attributes; cur; cur = cur->next) {
1036                 if (cur->linkID == 0) continue;
1037
1038                 attr_list = talloc_realloc(mem_ctx, attr_list, const char *, i+2);
1039                 if (!attr_list) {
1040                         return WERR_NOMEM;
1041                 }
1042                 attr_list[i] = cur->lDAPDisplayName;
1043                 i++;
1044         }
1045         attr_list[i] = NULL;
1046         *attr_list_ret = attr_list;
1047         return WERR_OK;
1048 }
1049
1050 /**
1051  * Attach the schema to an opaque pointer on the ldb, so ldb modules
1052  * can find it
1053  */
1054
1055 int dsdb_set_schema(struct ldb_context *ldb, struct dsdb_schema *schema)
1056 {
1057         int ret;
1058
1059         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
1060         if (ret != LDB_SUCCESS) {
1061                 return ret;
1062         }
1063
1064         talloc_steal(ldb, schema);
1065
1066         return LDB_SUCCESS;
1067 }
1068
1069 /**
1070  * Global variable to hold one copy of the schema, used to avoid memory bloat
1071  */
1072 static struct dsdb_schema *global_schema;
1073
1074 /**
1075  * Make this ldb use the 'global' schema, setup to avoid having multiple copies in this process
1076  */
1077 int dsdb_set_global_schema(struct ldb_context *ldb)
1078 {
1079         int ret;
1080         if (!global_schema) {
1081                 return LDB_SUCCESS;
1082         }
1083         ret = ldb_set_opaque(ldb, "dsdb_schema", global_schema);
1084         if (ret != LDB_SUCCESS) {
1085                 return ret;
1086         }
1087
1088         return LDB_SUCCESS;
1089 }
1090
1091 /**
1092  * Find the schema object for this ldb
1093  */
1094
1095 struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb)
1096 {
1097         const void *p;
1098         struct dsdb_schema *schema;
1099
1100         /* see if we have a cached copy */
1101         p = ldb_get_opaque(ldb, "dsdb_schema");
1102         if (!p) {
1103                 return NULL;
1104         }
1105
1106         schema = talloc_get_type(p, struct dsdb_schema);
1107         if (!schema) {
1108                 return NULL;
1109         }
1110
1111         return schema;
1112 }
1113
1114 /**
1115  * Make the schema found on this ldb the 'global' schema
1116  */
1117
1118 void dsdb_make_schema_global(struct ldb_context *ldb)
1119 {
1120         struct dsdb_schema *schema = dsdb_get_schema(ldb);
1121         if (!schema) {
1122                 return;
1123         }
1124
1125         talloc_steal(talloc_autofree_context(), schema);
1126         global_schema = schema;
1127
1128         dsdb_set_global_schema(ldb);
1129 }
1130
1131
1132 /**
1133  * Rather than read a schema from the LDB itself, read it from an ldif
1134  * file.  This allows schema to be loaded and used while adding the
1135  * schema itself to the directory.
1136  */
1137
1138 WERROR dsdb_attach_schema_from_ldif_file(struct ldb_context *ldb, const char *pf, const char *df)
1139 {
1140         struct ldb_ldif *ldif;
1141         struct ldb_message *msg;
1142         TALLOC_CTX *mem_ctx;
1143         WERROR status;
1144         int ret;
1145         struct dsdb_schema *schema;
1146         const struct ldb_val *prefix_val;
1147         const struct ldb_val *info_val;
1148         struct ldb_val info_val_default;
1149
1150         mem_ctx = talloc_new(ldb);
1151         if (!mem_ctx) {
1152                 goto nomem;
1153         }
1154
1155         schema = talloc_zero(mem_ctx, struct dsdb_schema);
1156         if (!schema) {
1157                 goto nomem;
1158         }
1159
1160         /*
1161          * load the prefixMap attribute from pf
1162          */
1163         ldif = ldb_ldif_read_string(ldb, &pf);
1164         if (!ldif) {
1165                 status = WERR_INVALID_PARAM;
1166                 goto failed;
1167         }
1168         talloc_steal(mem_ctx, ldif);
1169
1170         msg = ldb_msg_canonicalize(ldb, ldif->msg);
1171         if (!msg) {
1172                 goto nomem;
1173         }
1174         talloc_steal(mem_ctx, msg);
1175         talloc_free(ldif);
1176
1177         prefix_val = ldb_msg_find_ldb_val(msg, "prefixMap");
1178         if (!prefix_val) {
1179                 status = WERR_INVALID_PARAM;
1180                 goto failed;
1181         }
1182
1183         info_val = ldb_msg_find_ldb_val(msg, "schemaInfo");
1184         if (!info_val) {
1185                 info_val_default = strhex_to_data_blob("FF0000000000000000000000000000000000000000");
1186                 if (!info_val_default.data) {
1187                         goto nomem;
1188                 }
1189                 talloc_steal(mem_ctx, info_val_default.data);
1190                 info_val = &info_val_default;
1191         }
1192
1193         status = dsdb_load_oid_mappings_ldb(schema, prefix_val, info_val);
1194         if (!W_ERROR_IS_OK(status)) {
1195                 goto failed;
1196         }
1197
1198         /*
1199          * load the attribute and class definitions outof df
1200          */
1201         while ((ldif = ldb_ldif_read_string(ldb, &df))) {
1202                 bool is_sa;
1203                 bool is_sc;
1204
1205                 talloc_steal(mem_ctx, ldif);
1206
1207                 msg = ldb_msg_canonicalize(ldb, ldif->msg);
1208                 if (!msg) {
1209                         goto nomem;
1210                 }
1211
1212                 talloc_steal(mem_ctx, msg);
1213                 talloc_free(ldif);
1214
1215                 is_sa = ldb_msg_check_string_attribute(msg, "objectClass", "attributeSchema");
1216                 is_sc = ldb_msg_check_string_attribute(msg, "objectClass", "classSchema");
1217
1218                 if (is_sa) {
1219                         struct dsdb_attribute *sa;
1220
1221                         sa = talloc_zero(schema, struct dsdb_attribute);
1222                         if (!sa) {
1223                                 goto nomem;
1224                         }
1225
1226                         status = dsdb_attribute_from_ldb(schema, msg, sa, sa);
1227                         if (!W_ERROR_IS_OK(status)) {
1228                                 goto failed;
1229                         }
1230
1231                         DLIST_ADD_END(schema->attributes, sa, struct dsdb_attribute *);
1232                 } else if (is_sc) {
1233                         struct dsdb_class *sc;
1234
1235                         sc = talloc_zero(schema, struct dsdb_class);
1236                         if (!sc) {
1237                                 goto nomem;
1238                         }
1239
1240                         status = dsdb_class_from_ldb(schema, msg, sc, sc);
1241                         if (!W_ERROR_IS_OK(status)) {
1242                                 goto failed;
1243                         }
1244
1245                         DLIST_ADD_END(schema->classes, sc, struct dsdb_class *);
1246                 }
1247         }
1248
1249         ret = dsdb_set_schema(ldb, schema);
1250         if (ret != LDB_SUCCESS) {
1251                 status = WERR_FOOBAR;
1252                 goto failed;
1253         }
1254
1255         goto done;
1256
1257 nomem:
1258         status = WERR_NOMEM;
1259 failed:
1260 done:
1261         talloc_free(mem_ctx);
1262         return status;
1263 }