source/lib/ldb/modules/schema.c

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Simo Sorce  2004
   5
   6      ** NOTE! The following LGPL license applies to the ldb
   7      ** library. This does NOT imply that all of Samba is released
   8      ** under the LGPL
   9
  10    This library is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU Lesser General Public
  12    License as published by the Free Software Foundation; either
  13    version 2 of the License, or (at your option) any later version.
  14
  15    This library is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    Lesser General Public License for more details.
  19
  20    You should have received a copy of the GNU Lesser General Public
  21    License along with this library; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23 */
  24
  25 /*
  26  *  Name: ldb
  27  *
  28  *  Component: ldb schema module
  29  *
  30  *  Description: add schema check functionality
  31  *
  32  *  Author: Simo Sorce
  33  */
  34
  35 #include "includes.h"
  36 #include "ldb/include/ldb.h"
  37 #include "ldb/include/ldb_private.h"
  38
  39 #define SCHEMA_FLAG_RESET       0
  40 #define SCHEMA_FLAG_MOD_MASK    0x003
  41 #define SCHEMA_FLAG_MOD_ADD     0x001
  42 #define SCHEMA_FLAG_MOD_REPLACE 0x002
  43 #define SCHEMA_FLAG_MOD_DELETE  0x003
  44 #define SCHEMA_FLAG_AUXILIARY   0x010
  45 #define SCHEMA_FLAG_ABSTRACT    0x020
  46 #define SCHEMA_FLAG_STRUCTURAL  0x040
  47 #define SCHEMA_FLAG_CHECKED     0x100
  48
  49
  50 /* TODO: check attributes syntaxes
  51          check there's only one structrual class (or a chain of structural classes)
  52 */
  53
  54 struct private_data {
  55         const char *error_string;
  56 };
  57
  58 struct schema_attribute {
  59         int flags;
  60         char *name;
  61 };
  62
  63 struct schema_attribute_list {
  64         struct schema_attribute *attr;
  65         int num;
  66 };
  67
  68 struct schema_structures {
  69         struct schema_attribute_list entry_attrs;
  70         struct schema_attribute_list objectclasses;
  71         struct schema_attribute_list required_attrs;
  72         struct schema_attribute_list optional_attrs;
  73 };
  74
  75 /* This function embedds the knowledge of aliased names.
  76    Currently it handles only dn vs distinguishedNAme as a special case as AD
  77    only have this special alias case, in future we should read the schema
  78    to find out which names have an alias and check for them */
  79 static int schema_attr_cmp(const char *attr1, const char *attr2)
  80 {
  81         int ret;
  82
  83         ret = ldb_attr_cmp(attr1, attr2);
  84         if (ret != 0) {
  85                 if ((ldb_attr_cmp("dn", attr1) == 0) &&
  86                     (ldb_attr_cmp("distinguishedName", attr2) == 0)) {
  87                         return 0;
  88                 }
  89                 if ((ldb_attr_cmp("dn", attr2) == 0) &&
  90                     (ldb_attr_cmp("distinguishedName", attr1) == 0)) {
  91                         return 0;
  92                 }
  93         }
  94         return ret;
  95 }
  96
  97 static struct schema_attribute *schema_find_attribute(struct schema_attribute_list *list, const char *attr_name)
  98 {
  99         unsigned int i;
 100         for (i = 0; i < list->num; i++) {
 101                 if (ldb_attr_cmp(list->attr[i].name, attr_name) == 0) {
 102                         return &(list->attr[i]);
 103                 }
 104         }
 105         return NULL;
 106 }
 107
 108 /* get all the attributes and objectclasses found in msg and put them in schema_structure
 109    attributes go in the entry_attrs structure for later checking
 110    objectclasses go in the objectclasses structure */
 111 static int get_msg_attributes(struct schema_structures *ss, const struct ldb_message *msg, int flag_mask)
 112 {
 113         int i, j, k, l;
 114
 115         ss->entry_attrs.attr = talloc_realloc(ss, ss->entry_attrs.attr,
 116                                               struct schema_attribute,
 117                                               ss->entry_attrs.num + msg->num_elements);
 118         if (ss->entry_attrs.attr == NULL) {
 119                 return -1;
 120         }
 121
 122         for (i = 0, j = ss->entry_attrs.num; i < msg->num_elements; i++) {
 123
 124                 if (schema_attr_cmp(msg->elements[i].name, "objectclass") == 0) {
 125
 126                         ss->objectclasses.attr = talloc_realloc(ss, ss->objectclasses.attr,
 127                                                                 struct schema_attribute,
 128                                                                 ss->objectclasses.num + msg->elements[i].num_values);
 129                         if (ss->objectclasses.attr == NULL) {
 130                                 return -1;
 131                         }
 132
 133                         for (k = 0, l = ss->objectclasses.num; k < msg->elements[i].num_values; k++) {
 134                                 ss->objectclasses.attr[l].name = msg->elements[i].values[k].data;
 135                                 ss->objectclasses.attr[l].flags = msg->elements[i].flags & flag_mask;
 136                                 l++;
 137                         }
 138                         ss->objectclasses.num += msg->elements[i].num_values;
 139                 }
 140
 141                 ss->entry_attrs.attr[j].flags = msg->elements[i].flags & flag_mask;
 142                 ss->entry_attrs.attr[j].name = talloc_reference(ss->entry_attrs.attr,
 143                                                             msg->elements[i].name);
 144                 if (ss->entry_attrs.attr[j].name == NULL) {
 145                         return -1;
 146                 }
 147                 j++;
 148         }
 149         ss->entry_attrs.num += msg->num_elements;
 150
 151         return 0;
 152 }
 153
 154 static int get_entry_attributes(struct ldb_context *ldb, const char *dn, struct schema_structures *ss)
 155 {
 156         char *filter = talloc_asprintf(ss, "dn=%s", dn);
 157         struct ldb_message **srch;
 158         int ret;
 159
 160         ret = ldb_search(ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &srch);
 161         if (ret != 1) {
 162                 return ret;
 163         }
 164         talloc_steal(ss, srch);
 165
 166         /* set flags to 0 as flags on search have undefined values */
 167         ret = get_msg_attributes(ss, *srch, 0);
 168         if (ret != 0) {
 169                 talloc_free(srch);
 170                 return ret;
 171         }
 172
 173         return 0;
 174 }
 175
 176 /* add all attributes in el avoiding duplicates in schema_attribute_list */
 177 static int add_attribute_uniq(void *mem_ctx, struct schema_attribute_list *list, int flags, struct ldb_message_element *el)
 178 {
 179         int i, j, vals;
 180
 181         vals = el->num_values;
 182         list->attr = talloc_realloc(mem_ctx, list->attr, struct schema_attribute, list->num + vals);
 183         if (list->attr == NULL) {
 184                 return -1;
 185         }
 186         for (i = 0, j = 0; i < vals; i++) {
 187                 int c, found, len;
 188
 189                 found = 0;
 190                 for (c = 0; c < list->num; c++) {
 191                         len = strlen(list->attr[c].name);
 192                         if (len == el->values[i].length) {
 193                                 if (schema_attr_cmp(list->attr[c].name, el->values[i].data) == 0) {
 194                                         found = 1;
 195                                         break;
 196                                 }
 197                         }
 198                 }
 199                 if (!found) {
 200                         list->attr[j + list->num].name = el->values[i].data;
 201                         list->attr[j + list->num].flags = flags;
 202                         j++;
 203                 }
 204         }
 205         list->num += j;
 206
 207         return 0;
 208 }
 209
 210
 211 /* we need to get all attributes referenced by the entry objectclasses,
 212    recursively get parent objectlasses attributes */
 213 static int get_attr_list_recursive(struct ldb_module *module, struct schema_structures *schema_struct)
 214 {
 215         struct private_data *data = (struct private_data *)module->private_data;
 216         struct ldb_message **srch;
 217         int i, j;
 218         int ret;
 219
 220         for (i = 0; i < schema_struct->objectclasses.num; i++) {
 221                 char *filter;
 222
 223                 if ((schema_struct->objectclasses.attr[i].flags & SCHEMA_FLAG_MOD_MASK) == SCHEMA_FLAG_MOD_DELETE) {
 224                         continue;
 225                 }
 226                 filter = talloc_asprintf(schema_struct, "lDAPDisplayName=%s", schema_struct->objectclasses.attr[i].name);
 227                 if (filter == NULL) {
 228                         return -1;
 229                 }
 230
 231                 ret = ldb_search(module->ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &srch);
 232                 if (ret != 1) {
 233                         return ret;
 234                 }
 235                 talloc_steal(schema_struct, srch);
 236
 237                 if (ret <= 0) {
 238                         /* Schema DB Error: Error occurred retrieving Object Class Description */
 239                         ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Error retrieving Objectclass %s.\n", schema_struct->objectclasses.attr[i].name);
 240                         data->error_string = "Internal error. Error retrieving schema objectclass";
 241                         return -1;
 242                 }
 243                 if (ret > 1) {
 244                         /* Schema DB Error: Too Many Records */
 245                         ldb_debug(module->ldb, LDB_DEBUG_ERROR, "Too many records found retrieving Objectclass %s.\n", schema_struct->objectclasses.attr[i].name);
 246                         data->error_string = "Internal error. Too many records searching for schema objectclass";
 247                         return -1;
 248                 }
 249
 250                 /* Add inherited classes eliminating duplicates */
 251                 /* fill in required_attrs and optional_attrs attribute lists */
 252                 for (j = 0; j < (*srch)->num_elements; j++) {
 253                         int is_aux, is_class;
 254
 255                         is_aux = 0;
 256                         is_class = 0;
 257                         if (schema_attr_cmp((*srch)->elements[j].name, "systemAuxiliaryclass") == 0) {
 258                                 is_aux = SCHEMA_FLAG_AUXILIARY;
 259                                 is_class = 1;
 260                         }
 261                         if (schema_attr_cmp((*srch)->elements[j].name, "subClassOf") == 0) {
 262                                 is_class = 1;
 263                         }
 264
 265                         if (is_class) {
 266                                 if (add_attribute_uniq(schema_struct,
 267                                                         &schema_struct->objectclasses,
 268                                                         is_aux,
 269                                                         &(*srch)->elements[j]) != 0) {
 270                                         return -1;
 271                                 }
 272                         } else {
 273
 274                                 if (schema_attr_cmp((*srch)->elements[j].name, "mustContain") == 0 ||
 275                                         schema_attr_cmp((*srch)->elements[j].name, "SystemMustContain") == 0) {
 276                                         if (add_attribute_uniq(schema_struct,
 277                                                                 &schema_struct->required_attrs,
 278                                                                 SCHEMA_FLAG_RESET,
 279                                                                 &(*srch)->elements[j]) != 0) {
 280                                                 return -1;
 281                                         }
 282                                 }
 283
 284                                 if (schema_attr_cmp((*srch)->elements[j].name, "mayContain") == 0 ||
 285                                     schema_attr_cmp((*srch)->elements[j].name, "SystemMayContain") == 0) {
 286
 287                                         if (add_attribute_uniq(schema_struct,
 288                                                                 &schema_struct->optional_attrs,
 289                                                                 SCHEMA_FLAG_RESET,
 290                                                                 &(*srch)->elements[j]) != 0) {
 291                                                 return -1;
 292                                         }
 293                                 }
 294                         }
 295                 }
 296         }
 297
 298         return 0;
 299 }
 300
 301 /* search */
 302 static int schema_search(struct ldb_module *module, const char *base,
 303                        enum ldb_scope scope, const char *expression,
 304                        const char * const *attrs, struct ldb_message ***res)
 305 {
 306         return ldb_next_search(module, base, scope, expression, attrs, res);
 307 }
 308
 309 /* add_record */
 310 static int schema_add_record(struct ldb_module *module, const struct ldb_message *msg)
 311 {
 312         struct private_data *data = (struct private_data *)module->private_data;
 313         struct schema_structures *entry_structs;
 314         unsigned int i;
 315         int ret;
 316
 317         /* First implementation:
 318                 Build up a list of required_attrs and optional_attrs attributes from each objectclass
 319                 Check all the required_attrs attributes are present and all the other attributes
 320                 are optional_attrs attributes
 321                 Throw an error in case a check fail
 322                 Free all structures and commit the change
 323         */
 324
 325         if (msg->dn[0] == '@') { /* do not check on our control entries */
 326                 return ldb_next_add_record(module, msg);
 327         }
 328
 329         entry_structs = talloc_zero(module, struct schema_structures);
 330         if (!entry_structs) {
 331                 return -1;
 332         }
 333
 334         ret = get_msg_attributes(entry_structs, msg, SCHEMA_FLAG_MOD_MASK);
 335         if (ret != 0) {
 336                 talloc_free(entry_structs);
 337                 return ret;
 338         }
 339
 340         ret = get_attr_list_recursive(module, entry_structs);
 341         if (ret != 0) {
 342                 talloc_free(entry_structs);
 343                 return ret;
 344         }
 345
 346         /* now check all required_attrs attributes are present */
 347         for (i = 0; i < entry_structs->required_attrs.num; i++) {
 348                 struct schema_attribute *attr;
 349
 350                 attr = schema_find_attribute(&entry_structs->entry_attrs,
 351                                              entry_structs->required_attrs.attr[i].name);
 352
 353                 if (attr == NULL) { /* not found */
 354                         ldb_debug(module->ldb, LDB_DEBUG_ERROR,
 355                                   "The required_attrs attribute %s is missing.\n",
 356                                   entry_structs->required_attrs.attr[i].name);
 357
 358                         data->error_string = "Objectclass violation, a required attribute is missing";
 359                         talloc_free(entry_structs);
 360                         return -1;
 361                 }
 362
 363                 /* mark the attribute as checked */
 364                 attr->flags = SCHEMA_FLAG_CHECKED;
 365         }
 366
 367         /* now check all others atribs are at least optional_attrs */
 368         for (i = 0; i < entry_structs->entry_attrs.num; i++) {
 369
 370                 if (entry_structs->entry_attrs.attr[i].flags != SCHEMA_FLAG_CHECKED) {
 371                         struct schema_attribute *attr;
 372
 373                         attr = schema_find_attribute(&entry_structs->optional_attrs,
 374                                                      entry_structs->entry_attrs.attr[i].name);
 375
 376                         if (attr == NULL) { /* not found */
 377                                 ldb_debug(module->ldb, LDB_DEBUG_ERROR,
 378                                           "The attribute %s is not referenced by any objectclass.\n",
 379                                           entry_structs->entry_attrs.attr[i].name);
 380
 381                                 data->error_string = "Objectclass violation, an invalid attribute name was found";
 382                                 talloc_free(entry_structs);
 383                                 return -1;
 384                         }
 385                 }
 386         }
 387
 388         talloc_free(entry_structs);
 389
 390         return ldb_next_add_record(module, msg);
 391 }
 392
 393 /* modify_record */
 394 static int schema_modify_record(struct ldb_module *module, const struct ldb_message *msg)
 395 {
 396         struct private_data *data = (struct private_data *)module->private_data;
 397         struct schema_structures *entry_structs;
 398         unsigned int i;
 399         int ret;
 400
 401         /* First implementation:
 402                 Retrieve the ldap entry and get the objectclasses,
 403                 add msg contained objectclasses if any.
 404                 Build up a list of required_attrs and optional_attrs attributes from each objectclass
 405                 Check all the attributes are optional_attrs or required_attrs.
 406                 Throw an error in case a check fail.
 407                 Free all structures and commit the change.
 408         */
 409
 410         if (msg->dn[0] == '@') { /* do not check on our control entries */
 411                 return ldb_next_modify_record(module, msg);
 412         }
 413
 414         /* allocate object structs */
 415         entry_structs = talloc_zero(module, struct schema_structures);
 416         if (!entry_structs) {
 417                 return -1;
 418         }
 419
 420         /* now search for the stored entry objectclasses and attributes*/
 421         ret = get_entry_attributes(module->ldb, msg->dn, entry_structs);
 422         if (ret != 0) {
 423                 talloc_free(entry_structs);
 424                 return ret;
 425         }
 426
 427         /* get list of values to modify */
 428         ret = get_msg_attributes(entry_structs, msg, SCHEMA_FLAG_MOD_MASK);
 429         if (ret != 0) {
 430                 talloc_free(entry_structs);
 431                 return ret;
 432         }
 433
 434         ret = get_attr_list_recursive(module, entry_structs);
 435         if (ret != 0) {
 436                 talloc_free(entry_structs);
 437                 return ret;
 438         }
 439
 440         /* now check all required_attrs attributes are present */
 441         for (i = 0; i < entry_structs->required_attrs.num; i++) {
 442                 struct schema_attribute *attr;
 443
 444                 attr = schema_find_attribute(&entry_structs->entry_attrs,
 445                                              entry_structs->required_attrs.attr[i].name);
 446
 447                 if (attr == NULL) { /* not found */
 448                         ldb_debug(module->ldb, LDB_DEBUG_ERROR,
 449                                   "The required_attrs attribute %s is missing.\n",
 450                                   entry_structs->required_attrs.attr[i].name);
 451
 452                         data->error_string = "Objectclass violation, a required attribute is missing";
 453                         talloc_free(entry_structs);
 454                         return -1;
 455                 }
 456
 457                 /* check we are not trying to delete a required attribute */
 458                 /* TODO: consider multivalued attrs */
 459                 if ((attr->flags & SCHEMA_FLAG_MOD_DELETE) != 0) {
 460                         ldb_debug(module->ldb, LDB_DEBUG_ERROR,
 461                                   "Trying to delete the required attribute %s.\n",
 462                                   attr->name);
 463
 464                         data->error_string = "Objectclass violation, a required attribute cannot be removed";
 465                         talloc_free(entry_structs);
 466                         return -1;
 467                 }
 468
 469                 /* mark the attribute as checked */
 470                 attr->flags = SCHEMA_FLAG_CHECKED;
 471         }
 472
 473         /* now check all others atribs are at least optional_attrs */
 474         for (i = 0; i < entry_structs->entry_attrs.num; i++) {
 475
 476                 if (entry_structs->entry_attrs.attr[i].flags != SCHEMA_FLAG_CHECKED) {
 477                         struct schema_attribute *attr;
 478
 479                         attr = schema_find_attribute(&entry_structs->optional_attrs,
 480                                                      entry_structs->entry_attrs.attr[i].name);
 481
 482                         if (attr == NULL) { /* not found */
 483                                 ldb_debug(module->ldb, LDB_DEBUG_ERROR,
 484                                           "The attribute %s is not referenced by any objectclass.\n",
 485                                           entry_structs->entry_attrs.attr[i].name);
 486
 487                                 data->error_string = "Objectclass violation, an invalid attribute name was found";
 488                                 talloc_free(entry_structs);
 489                                 return -1;
 490                         }
 491                 }
 492         }
 493
 494         talloc_free(entry_structs);
 495
 496         return ldb_next_modify_record(module, msg);
 497 }
 498
 499 /* delete_record */
 500 static int schema_delete_record(struct ldb_module *module, const char *dn)
 501 {
 502 /*      struct private_data *data = (struct private_data *)module->private_data; */
 503         return ldb_next_delete_record(module, dn);
 504 }
 505
 506 /* rename_record */
 507 static int schema_rename_record(struct ldb_module *module, const char *olddn, const char *newdn)
 508 {
 509         return ldb_next_rename_record(module, olddn, newdn);
 510 }
 511
 512 static int schema_named_lock(struct ldb_module *module, const char *name) {
 513         return ldb_next_named_lock(module, name);
 514 }
 515
 516 static int schema_named_unlock(struct ldb_module *module, const char *name) {
 517         return ldb_next_named_unlock(module, name);
 518 }
 519
 520 /* return extended error information */
 521 static const char *schema_errstring(struct ldb_module *module)
 522 {
 523         struct private_data *data = (struct private_data *)module->private_data;
 524
 525         if (data->error_string) {
 526                 const char *error;
 527
 528                 error = data->error_string;
 529                 data->error_string = NULL;
 530                 return error;
 531         }
 532
 533         return ldb_next_errstring(module);
 534 }
 535
 536 static int schema_destructor(void *module_ctx)
 537 {
 538 /*      struct ldb_module *ctx = module_ctx; */
 539         /* put your clean-up functions here */
 540         return 0;
 541 }
 542
 543 static const struct ldb_module_ops schema_ops = {
 544         "schema",
 545         schema_search,
 546         schema_add_record,
 547         schema_modify_record,
 548         schema_delete_record,
 549         schema_rename_record,
 550         schema_named_lock,
 551         schema_named_unlock,
 552         schema_errstring,
 553 };
 554
 555 #ifdef HAVE_DLOPEN_DISABLED
 556 struct ldb_module *init_module(struct ldb_context *ldb, const char *options[])
 557 #else
 558 struct ldb_module *schema_module_init(struct ldb_context *ldb, const char *options[])
 559 #endif
 560 {
 561         struct ldb_module *ctx;
 562         struct private_data *data;
 563
 564         ctx = talloc(ldb, struct ldb_module);
 565         if (!ctx) {
 566                 return NULL;
 567         }
 568
 569         data = talloc(ctx, struct private_data);
 570         if (data == NULL) {
 571                 talloc_free(ctx);
 572                 return NULL;
 573         }
 574
 575         data->error_string = NULL;
 576         ctx->private_data = data;
 577         ctx->ldb = ldb;
 578         ctx->prev = ctx->next = NULL;
 579         ctx->ops = &schema_ops;
 580
 581         talloc_set_destructor (ctx, schema_destructor);
 582
 583         return ctx;
 584 }