source4/lib/ldb/common/ldb_attributes.c

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Andrew Tridgell  2005
   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   register handlers for specific attributes and objectclass relationships
  26
  27   this allows a backend to store its schema information in any format
  28   it likes (or to not have any schema information at all) while keeping the
  29   message matching logic generic
  30 */
  31
  32 #include "includes.h"
  33 #include "ldb/include/includes.h"
  34
  35 /*
  36   add to the list of ldif handlers for this ldb context
  37 */
  38 int ldb_set_attrib_handlers(struct ldb_context *ldb,
  39                             const struct ldb_attrib_handler *handlers,
  40                             unsigned num_handlers)
  41 {
  42         int i;
  43         struct ldb_attrib_handler *h;
  44         h = talloc_realloc(ldb, ldb->schema.attrib_handlers,
  45                            struct ldb_attrib_handler,
  46                            ldb->schema.num_attrib_handlers + num_handlers);
  47         if (h == NULL) {
  48                 ldb_oom(ldb);
  49                 return -1;
  50         }
  51         ldb->schema.attrib_handlers = h;
  52         memcpy(h + ldb->schema.num_attrib_handlers,
  53                handlers, sizeof(*h) * num_handlers);
  54         for (i=0;i<num_handlers;i++) {
  55                 if (h[ldb->schema.num_attrib_handlers+i].flags & LDB_ATTR_FLAG_ALLOCATED) {
  56                         h[ldb->schema.num_attrib_handlers+i].attr = talloc_strdup(ldb->schema.attrib_handlers,
  57                                                                                   h[ldb->schema.num_attrib_handlers+i].attr);
  58                         if (h[ldb->schema.num_attrib_handlers+i].attr == NULL) {
  59                                 ldb_oom(ldb);
  60                                 return -1;
  61                         }
  62                 }
  63         }
  64         ldb->schema.num_attrib_handlers += num_handlers;
  65         return 0;
  66 }
  67
  68
  69 /*
  70   default function for read/write/canonicalise
  71 */
  72 static int ldb_default_copy(struct ldb_context *ldb,
  73                             void *mem_ctx,
  74                             const struct ldb_val *in,
  75                             struct ldb_val *out)
  76 {
  77         *out = ldb_val_dup(mem_ctx, in);
  78
  79         if (out->data == NULL && in->data != NULL) {
  80                 return -1;
  81         }
  82
  83         return 0;
  84 }
  85
  86 /*
  87   default function for comparison
  88 */
  89 static int ldb_default_cmp(struct ldb_context *ldb,
  90                             void *mem_ctx,
  91                            const struct ldb_val *v1,
  92                            const struct ldb_val *v2)
  93 {
  94         if (v1->length != v2->length) {
  95                 return v1->length - v2->length;
  96         }
  97         return memcmp(v1->data, v2->data, v1->length);
  98 }
  99
 100 /*
 101   default handler function pointers
 102 */
 103 static const struct ldb_attrib_handler ldb_default_attrib_handler = {
 104         .attr = NULL,
 105         .ldif_read_fn    = ldb_default_copy,
 106         .ldif_write_fn   = ldb_default_copy,
 107         .canonicalise_fn = ldb_default_copy,
 108         .comparison_fn   = ldb_default_cmp,
 109 };
 110
 111 /*
 112   return the attribute handlers for a given attribute
 113 */
 114 const struct ldb_attrib_handler *ldb_attrib_handler(struct ldb_context *ldb,
 115                                                     const char *attrib)
 116 {
 117         int i;
 118         const struct ldb_attrib_handler *def = &ldb_default_attrib_handler;
 119         /* TODO: should be replaced with a binary search, with a sort on add */
 120         for (i=0;i<ldb->schema.num_attrib_handlers;i++) {
 121                 if (strcmp(ldb->schema.attrib_handlers[i].attr, "*") == 0) {
 122                         def = &ldb->schema.attrib_handlers[i];
 123                 }
 124                 if (ldb_attr_cmp(attrib, ldb->schema.attrib_handlers[i].attr) == 0) {
 125                         return &ldb->schema.attrib_handlers[i];
 126                 }
 127         }
 128         return def;
 129 }
 130
 131
 132 /*
 133   add to the list of ldif handlers for this ldb context
 134 */
 135 void ldb_remove_attrib_handler(struct ldb_context *ldb, const char *attrib)
 136 {
 137         const struct ldb_attrib_handler *h;
 138         int i;
 139         h = ldb_attrib_handler(ldb, attrib);
 140         if (h == &ldb_default_attrib_handler) {
 141                 return;
 142         }
 143         if (h->flags & LDB_ATTR_FLAG_ALLOCATED) {
 144                 talloc_free(discard_const_p(char, h->attr));
 145         }
 146         i = h - ldb->schema.attrib_handlers;
 147         if (i < ldb->schema.num_attrib_handlers - 1) {
 148                 memmove(&ldb->schema.attrib_handlers[i],
 149                         h+1, sizeof(*h) * (ldb->schema.num_attrib_handlers-(i+1)));
 150         }
 151         ldb->schema.num_attrib_handlers--;
 152 }
 153
 154 /*
 155   setup a attribute handler using a standard syntax
 156 */
 157 int ldb_set_attrib_handler_syntax(struct ldb_context *ldb,
 158                                   const char *attr, const char *syntax)
 159 {
 160         const struct ldb_attrib_handler *h = ldb_attrib_handler_syntax(ldb, syntax);
 161         struct ldb_attrib_handler h2;
 162         if (h == NULL) {
 163                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Unknown syntax '%s'\n", syntax);
 164                 return -1;
 165         }
 166         h2 = *h;
 167         h2.attr = attr;
 168         return ldb_set_attrib_handlers(ldb, &h2, 1);
 169 }
 170
 171 /*
 172   setup the attribute handles for well known attributes
 173 */
 174 int ldb_setup_wellknown_attributes(struct ldb_context *ldb)
 175 {
 176         const struct {
 177                 const char *attr;
 178                 const char *syntax;
 179         } wellknown[] = {
 180                 { "dn", LDB_SYNTAX_DN },
 181                 { "distinguishedName", LDB_SYNTAX_DN },
 182                 { "cn", LDB_SYNTAX_DIRECTORY_STRING },
 183                 { "dc", LDB_SYNTAX_DIRECTORY_STRING },
 184                 { "ou", LDB_SYNTAX_DIRECTORY_STRING },
 185                 { "objectClass", LDB_SYNTAX_OBJECTCLASS }
 186         };
 187         int i;
 188         for (i=0;i<ARRAY_SIZE(wellknown);i++) {
 189                 if (ldb_set_attrib_handler_syntax(ldb, wellknown[i].attr,
 190                                                   wellknown[i].syntax) != 0) {
 191                         return -1;
 192                 }
 193         }
 194         return 0;
 195 }
 196
 197
 198 /*
 199   return the list of subclasses for a class
 200 */
 201 const char **ldb_subclass_list(struct ldb_context *ldb, const char *classname)
 202 {
 203         int i;
 204         for (i=0;i<ldb->schema.num_classes;i++) {
 205                 if (ldb_attr_cmp(classname, ldb->schema.classes[i].name) == 0) {
 206                         return (const char **)ldb->schema.classes[i].subclasses;
 207                 }
 208         }
 209         return NULL;
 210 }
 211
 212
 213 /*
 214   add a new subclass
 215 */
 216 static int ldb_subclass_new(struct ldb_context *ldb, const char *classname, const char *subclass)
 217 {
 218         struct ldb_subclass *s, *c;
 219         s = talloc_realloc(ldb, ldb->schema.classes, struct ldb_subclass, ldb->schema.num_classes+1);
 220         if (s == NULL) goto failed;
 221
 222         ldb->schema.classes = s;
 223         c = &s[ldb->schema.num_classes];
 224         c->name = talloc_strdup(s, classname);
 225         if (c->name == NULL) goto failed;
 226
 227         c->subclasses = talloc_array(s, char *, 2);
 228         if (c->subclasses == NULL) goto failed;
 229
 230         c->subclasses[0] = talloc_strdup(c->subclasses, subclass);
 231         if (c->subclasses[0] == NULL) goto failed;
 232         c->subclasses[1] = NULL;
 233
 234         ldb->schema.num_classes++;
 235
 236         return 0;
 237 failed:
 238         ldb_oom(ldb);
 239         return -1;
 240 }
 241
 242 /*
 243   add a subclass
 244 */
 245 int ldb_subclass_add(struct ldb_context *ldb, const char *classname, const char *subclass)
 246 {
 247         int i, n;
 248         struct ldb_subclass *c;
 249         char **s;
 250
 251         for (i=0;i<ldb->schema.num_classes;i++) {
 252                 if (ldb_attr_cmp(classname, ldb->schema.classes[i].name) == 0) {
 253                         break;
 254                 }
 255         }
 256         if (i == ldb->schema.num_classes) {
 257                 return ldb_subclass_new(ldb, classname, subclass);
 258         }
 259         c = &ldb->schema.classes[i];
 260
 261         for (n=0;c->subclasses[n];n++) /* noop */;
 262
 263         s = talloc_realloc(ldb->schema.classes, c->subclasses, char *, n+2);
 264         if (s == NULL) {
 265                 ldb_oom(ldb);
 266                 return -1;
 267         }
 268
 269         c->subclasses = s;
 270         s[n] = talloc_strdup(s, subclass);
 271         if (s[n] == NULL) {
 272                 ldb_oom(ldb);
 273                 return -1;
 274         }
 275         s[n+1] = NULL;
 276
 277         return 0;
 278 }
 279
 280 /*
 281   remove a set of subclasses for a class
 282 */
 283 void ldb_subclass_remove(struct ldb_context *ldb, const char *classname)
 284 {
 285         int i;
 286         struct ldb_subclass *c;
 287
 288         for (i=0;i<ldb->schema.num_classes;i++) {
 289                 if (ldb_attr_cmp(classname, ldb->schema.classes[i].name) == 0) {
 290                         break;
 291                 }
 292         }
 293         if (i == ldb->schema.num_classes) {
 294                 return;
 295         }
 296
 297         c = &ldb->schema.classes[i];
 298         talloc_free(c->name);
 299         talloc_free(c->subclasses);
 300         if (ldb->schema.num_classes-(i+1) > 0) {
 301                 memmove(c, c+1, sizeof(*c) * (ldb->schema.num_classes-(i+1)));
 302         }
 303         ldb->schema.num_classes--;
 304         if (ldb->schema.num_classes == 0) {
 305                 talloc_free(ldb->schema.classes);
 306                 ldb->schema.classes = NULL;
 307         }
 308 }