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 3 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, see <http://www.gnu.org/licenses/>.
  22 */
  23 /*
  24   register handlers for specific attributes and objectclass relationships
  25
  26   this allows a backend to store its schema information in any format
  27   it likes (or to not have any schema information at all) while keeping the
  28   message matching logic generic
  29 */
  30
  31 #include "ldb_private.h"
  32 #include "ldb_handlers.h"
  33
  34 /*
  35   add a attribute to the ldb_schema
  36
  37   if flags contains LDB_ATTR_FLAG_ALLOCATED
  38   the attribute name string will be copied using
  39   talloc_strdup(), otherwise it needs to be a static const
  40   string at least with a lifetime longer than the ldb struct!
  41
  42   the ldb_schema_syntax structure should be a pointer
  43   to a static const struct or at least it needs to be
  44   a struct with a longer lifetime than the ldb context!
  45
  46 */
  47 int ldb_schema_attribute_add_with_syntax(struct ldb_context *ldb,
  48                                          const char *attribute,
  49                                          unsigned flags,
  50                                          const struct ldb_schema_syntax *syntax)
  51 {
  52         unsigned int i, n;
  53         struct ldb_schema_attribute *a;
  54
  55         if (!syntax) {
  56                 return LDB_ERR_OPERATIONS_ERROR;
  57         }
  58
  59         n = ldb->schema.num_attributes + 1;
  60
  61         a = talloc_realloc(ldb, ldb->schema.attributes,
  62                            struct ldb_schema_attribute, n);
  63         if (a == NULL) {
  64                 ldb_oom(ldb);
  65                 return -1;
  66         }
  67         ldb->schema.attributes = a;
  68
  69         for (i = 0; i < ldb->schema.num_attributes; i++) {
  70                 int cmp = ldb_attr_cmp(attribute, a[i].name);
  71                 if (cmp == 0) {
  72                         /* silently ignore attempts to overwrite fixed attributes */
  73                         if (a[i].flags & LDB_ATTR_FLAG_FIXED) {
  74                                 return 0;
  75                         }
  76                         if (a[i].flags & LDB_ATTR_FLAG_ALLOCATED) {
  77                                 talloc_free(discard_const_p(char, a[i].name));
  78                         }
  79                         /* To cancel out increment below */
  80                         ldb->schema.num_attributes--;
  81                         break;
  82                 } else if (cmp < 0) {
  83                         memmove(a+i+1, a+i, sizeof(*a) * (ldb->schema.num_attributes-i));
  84                         break;
  85                 }
  86         }
  87         ldb->schema.num_attributes++;
  88
  89         a[i].name       = attribute;
  90         a[i].flags      = flags;
  91         a[i].syntax     = syntax;
  92
  93         if (a[i].flags & LDB_ATTR_FLAG_ALLOCATED) {
  94                 a[i].name = talloc_strdup(a, a[i].name);
  95                 if (a[i].name == NULL) {
  96                         ldb_oom(ldb);
  97                         return -1;
  98                 }
  99         }
 100
 101         return 0;
 102 }
 103
 104 static const struct ldb_schema_syntax ldb_syntax_default = {
 105         .name            = LDB_SYNTAX_OCTET_STRING,
 106         .ldif_read_fn    = ldb_handler_copy,
 107         .ldif_write_fn   = ldb_handler_copy,
 108         .canonicalise_fn = ldb_handler_copy,
 109         .comparison_fn   = ldb_comparison_binary
 110 };
 111
 112 static const struct ldb_schema_attribute ldb_attribute_default = {
 113         .name   = NULL,
 114         .flags  = 0,
 115         .syntax = &ldb_syntax_default
 116 };
 117
 118 /*
 119   return the attribute handlers for a given attribute
 120 */
 121 static const struct ldb_schema_attribute *ldb_schema_attribute_by_name_internal(
 122         struct ldb_context *ldb,
 123         const char *name)
 124 {
 125         /* for binary search we need signed variables */
 126         int r, i, e, b = 0;
 127         unsigned int u_i;
 128         const struct ldb_schema_attribute *def = &ldb_attribute_default;
 129
 130         /* as handlers are sorted, '*' must be the first if present */
 131         if (strcmp(ldb->schema.attributes[0].name, "*") == 0) {
 132                 def = &ldb->schema.attributes[0];
 133                 b = 1;
 134         }
 135
 136         /* do a binary search on the array */
 137         e = ldb->schema.num_attributes - 1;
 138
 139         while (b <= e) {
 140                 i = (b + e) / 2;
 141
 142                 u_i = (unsigned int) i;
 143                 r = ldb_attr_cmp(name, ldb->schema.attributes[u_i].name);
 144                 if (r == 0) {
 145                         return &ldb->schema.attributes[u_i];
 146                 }
 147                 if (r < 0) {
 148                         e = i - 1;
 149                 } else {
 150                         b = i + 1;
 151                 }
 152
 153         }
 154
 155         return def;
 156 }
 157
 158 /*
 159   return the attribute handlers for a given attribute
 160 */
 161 const struct ldb_schema_attribute *ldb_schema_attribute_by_name(struct ldb_context *ldb,
 162                                                                 const char *name)
 163 {
 164         if (ldb->schema.attribute_handler_override) {
 165                 const struct ldb_schema_attribute *ret =
 166                         ldb->schema.attribute_handler_override(ldb,
 167                                                                ldb->schema.attribute_handler_override_private,
 168                                                                name);
 169                 if (ret) {
 170                         return ret;
 171                 }
 172         }
 173
 174         return ldb_schema_attribute_by_name_internal(ldb, name);
 175 }
 176
 177
 178 /*
 179   add to the list of ldif handlers for this ldb context
 180 */
 181 void ldb_schema_attribute_remove(struct ldb_context *ldb, const char *name)
 182 {
 183         const struct ldb_schema_attribute *a;
 184         ptrdiff_t i;
 185
 186         a = ldb_schema_attribute_by_name_internal(ldb, name);
 187         if (a == NULL || a->name == NULL) {
 188                 return;
 189         }
 190
 191         /* FIXED attributes are never removed */
 192         if (a->flags & LDB_ATTR_FLAG_FIXED) {
 193                 return;
 194         }
 195
 196         if (a->flags & LDB_ATTR_FLAG_ALLOCATED) {
 197                 talloc_free(discard_const_p(char, a->name));
 198         }
 199
 200         i = a - ldb->schema.attributes;
 201         if (i < ldb->schema.num_attributes - 1) {
 202                 memmove(&ldb->schema.attributes[i],
 203                         a+1, sizeof(*a) * (ldb->schema.num_attributes-(i+1)));
 204         }
 205
 206         ldb->schema.num_attributes--;
 207 }
 208
 209 /*
 210   setup a attribute handler using a standard syntax
 211 */
 212 int ldb_schema_attribute_add(struct ldb_context *ldb,
 213                              const char *attribute,
 214                              unsigned flags,
 215                              const char *syntax)
 216 {
 217         const struct ldb_schema_syntax *s = ldb_standard_syntax_by_name(ldb, syntax);
 218         return ldb_schema_attribute_add_with_syntax(ldb, attribute, flags, s);
 219 }
 220
 221 /*
 222   setup the attribute handles for well known attributes
 223 */
 224 int ldb_setup_wellknown_attributes(struct ldb_context *ldb)
 225 {
 226         const struct {
 227                 const char *attr;
 228                 const char *syntax;
 229         } wellknown[] = {
 230                 { "dn", LDB_SYNTAX_DN },
 231                 { "distinguishedName", LDB_SYNTAX_DN },
 232                 { "cn", LDB_SYNTAX_DIRECTORY_STRING },
 233                 { "dc", LDB_SYNTAX_DIRECTORY_STRING },
 234                 { "ou", LDB_SYNTAX_DIRECTORY_STRING },
 235                 { "objectClass", LDB_SYNTAX_OBJECTCLASS }
 236         };
 237         unsigned int i;
 238         int ret;
 239
 240         for (i=0;i<ARRAY_SIZE(wellknown);i++) {
 241                 ret = ldb_schema_attribute_add(ldb, wellknown[i].attr, 0,
 242                                                wellknown[i].syntax);
 243                 if (ret != LDB_SUCCESS) {
 244                         return ret;
 245                 }
 246         }
 247
 248         return LDB_SUCCESS;
 249 }
 250
 251
 252 /*
 253   add a extended dn syntax to the ldb_schema
 254 */
 255 int ldb_dn_extended_add_syntax(struct ldb_context *ldb,
 256                                unsigned flags,
 257                                const struct ldb_dn_extended_syntax *syntax)
 258 {
 259         unsigned int n;
 260         struct ldb_dn_extended_syntax *a;
 261
 262         if (!syntax) {
 263                 return LDB_ERR_OPERATIONS_ERROR;
 264         }
 265
 266         n = ldb->schema.num_dn_extended_syntax + 1;
 267
 268         a = talloc_realloc(ldb, ldb->schema.dn_extended_syntax,
 269                            struct ldb_dn_extended_syntax, n);
 270
 271         if (!a) {
 272                 return LDB_ERR_OPERATIONS_ERROR;
 273         }
 274
 275         a[ldb->schema.num_dn_extended_syntax] = *syntax;
 276         ldb->schema.dn_extended_syntax = a;
 277
 278         ldb->schema.num_dn_extended_syntax = n;
 279
 280         return LDB_SUCCESS;
 281 }
 282
 283 /*
 284   return the extended dn syntax for a given name
 285 */
 286 const struct ldb_dn_extended_syntax *ldb_dn_extended_syntax_by_name(struct ldb_context *ldb,
 287                                                                     const char *name)
 288 {
 289         unsigned int i;
 290         for (i=0; i < ldb->schema.num_dn_extended_syntax; i++) {
 291                 if (ldb_attr_cmp(ldb->schema.dn_extended_syntax[i].name, name) == 0) {
 292                         return &ldb->schema.dn_extended_syntax[i];
 293                 }
 294         }
 295         return NULL;
 296 }
 297
 298 /*
 299   set an attribute handler override function - used to delegate schema handling
 300   to external code
 301  */
 302 void ldb_schema_attribute_set_override_handler(struct ldb_context *ldb,
 303                                                ldb_attribute_handler_override_fn_t override,
 304                                                void *private_data)
 305 {
 306         ldb->schema.attribute_handler_override_private = private_data;
 307         ldb->schema.attribute_handler_override = override;
 308 }