source4/lib/ldb/ldb_ldap/ldb_ldap.c

   1 /*
   2    ldb database library
   3
   4    Copyright (C) Andrew Tridgell  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 ldap backend
  29  *
  30  *  Description: core files for LDAP backend
  31  *
  32  *  Author: Andrew Tridgell
  33  */
  34
  35 #include "includes.h"
  36 #if HAVE_LDAP
  37 #include "ldb_ldap.h"
  38
  39 #if 0
  40 /*
  41   we don't need this right now, but will once we add some backend
  42   options
  43 */
  44
  45 /*
  46   find an option in an option list (a null terminated list of strings)
  47
  48   this assumes the list is short. If it ever gets long then we really
  49   should do this in some smarter way
  50  */
  51 static const char *lldb_option_find(const struct lldb_private *lldb, const char *name)
  52 {
  53         int i;
  54         size_t len = strlen(name);
  55
  56         if (!lldb->options) return NULL;
  57
  58         for (i=0;lldb->options[i];i++) {
  59                 if (strncmp(lldb->options[i], name, len) == 0 &&
  60                     lldb->options[i][len] == '=') {
  61                         return &lldb->options[i][len+1];
  62                 }
  63         }
  64
  65         return NULL;
  66 }
  67 #endif
  68
  69 /*
  70   close/free the connection
  71 */
  72 static int lldb_close(struct ldb_context *ldb)
  73 {
  74         int i, ret = 0;
  75         struct lldb_private *lldb = ldb->private;
  76
  77         if (ldap_unbind(lldb->ldap) != LDAP_SUCCESS) {
  78                 ret = -1;
  79         }
  80
  81         if (lldb->options) {
  82                 for (i=0;lldb->options[i];i++) {
  83                         free(lldb->options[i]);
  84                 }
  85                 free(lldb->options);
  86         }
  87         free(lldb);
  88         free(ldb);
  89
  90         return ret;
  91 }
  92
  93 /*
  94   delete a record
  95 */
  96 static int lldb_delete(struct ldb_context *ldb, const char *dn)
  97 {
  98         struct lldb_private *lldb = ldb->private;
  99         int ret = 0;
 100
 101         lldb->last_rc = ldap_delete_s(lldb->ldap, dn);
 102         if (lldb->last_rc != LDAP_SUCCESS) {
 103                 ret = -1;
 104         }
 105
 106         return ret;
 107 }
 108
 109 /*
 110   free a search message
 111 */
 112 static int lldb_msg_free(struct ldb_context *ldb, struct ldb_message *msg)
 113 {
 114         int i, j;
 115         free(msg->dn);
 116         for (i=0;i<msg->num_elements;i++) {
 117                 free(msg->elements[i].name);
 118                 for (j=0;j<msg->elements[i].num_values;j++) {
 119                         if (msg->elements[i].values[j].data) {
 120                                 free(msg->elements[i].values[j].data);
 121                         }
 122                 }
 123                 free(msg->elements[i].values);
 124         }
 125         if (msg->elements) free(msg->elements);
 126         free(msg);
 127         return 0;
 128 }
 129
 130 /*
 131   free a search result
 132 */
 133 static int lldb_search_free(struct ldb_context *ldb, struct ldb_message **res)
 134 {
 135         int i;
 136         for (i=0;res[i];i++) {
 137                 if (lldb_msg_free(ldb, res[i]) != 0) {
 138                         return -1;
 139                 }
 140         }
 141         free(res);
 142         return 0;
 143 }
 144
 145
 146 /*
 147   add a single set of ldap message values to a ldb_message
 148 */
 149 static int lldb_add_msg_attr(struct ldb_message *msg,
 150                              const char *attr, struct berval **bval)
 151 {
 152         int count, i;
 153         struct ldb_message_element *el;
 154
 155         count = ldap_count_values_len(bval);
 156
 157         if (count <= 0) {
 158                 return -1;
 159         }
 160
 161         el = realloc_p(msg->elements, struct ldb_message_element,
 162                        msg->num_elements + 1);
 163         if (!el) {
 164                 errno = ENOMEM;
 165                 return -1;
 166         }
 167
 168         msg->elements = el;
 169
 170         el = &msg->elements[msg->num_elements];
 171
 172         el->name = strdup(attr);
 173         if (!el->name) {
 174                 errno = ENOMEM;
 175                 return -1;
 176         }
 177         el->flags = 0;
 178
 179         el->num_values = 0;
 180         el->values = malloc_array_p(struct ldb_val, count);
 181         if (!el->values) {
 182                 errno = ENOMEM;
 183                 return -1;
 184         }
 185
 186         for (i=0;i<count;i++) {
 187                 el->values[i].data = malloc(bval[i]->bv_len);
 188                 if (!el->values[i].data) {
 189                         return -1;
 190                 }
 191                 memcpy(el->values[i].data, bval[i]->bv_val, bval[i]->bv_len);
 192                 el->values[i].length = bval[i]->bv_len;
 193                 el->num_values++;
 194         }
 195
 196         msg->num_elements++;
 197
 198         return 0;
 199 }
 200
 201 /*
 202   search for matching records
 203 */
 204 static int lldb_search(struct ldb_context *ldb, const char *base,
 205                        enum ldb_scope scope, const char *expression,
 206                        const char **attrs, struct ldb_message ***res)
 207 {
 208         struct lldb_private *lldb = ldb->private;
 209         int count, msg_count;
 210         LDAPMessage *ldapres, *msg;
 211
 212         lldb->last_rc = ldap_search_s(lldb->ldap, base, (int)scope,
 213                                       expression, attrs, 0, &ldapres);
 214         if (lldb->last_rc != LDAP_SUCCESS) {
 215                 return -1;
 216         }
 217
 218         count = ldap_count_entries(lldb->ldap, ldapres);
 219         if (count == -1 || count == 0) {
 220                 ldap_msgfree(ldapres);
 221                 return count;
 222         }
 223
 224         (*res) = malloc_array_p(struct ldb_message *, count+1);
 225         if (! *res) {
 226                 ldap_msgfree(ldapres);
 227                 errno = ENOMEM;
 228                 return -1;
 229         }
 230
 231         (*res)[0] = NULL;
 232
 233         msg_count = 0;
 234
 235         /* loop over all messages */
 236         for (msg=ldap_first_entry(lldb->ldap, ldapres);
 237              msg;
 238              msg=ldap_next_entry(lldb->ldap, msg)) {
 239                 BerElement *berptr = NULL;
 240                 char *attr, *dn;
 241
 242                 if (msg_count == count) {
 243                         /* hmm, got too many? */
 244                         fprintf(stderr,"Too many messages?!\n");
 245                         break;
 246                 }
 247
 248                 (*res)[msg_count] = malloc_p(struct ldb_message);
 249                 if (!(*res)[msg_count]) {
 250                         goto failed;
 251                 }
 252                 (*res)[msg_count+1] = NULL;
 253
 254                 dn = ldap_get_dn(lldb->ldap, msg);
 255                 if (!dn) {
 256                         goto failed;
 257                 }
 258
 259                 (*res)[msg_count]->dn = strdup(dn);
 260                 ldap_memfree(dn);
 261                 if (!(*res)[msg_count]->dn) {
 262                         goto failed;
 263                 }
 264
 265
 266                 (*res)[msg_count]->num_elements = 0;
 267                 (*res)[msg_count]->elements = NULL;
 268                 (*res)[msg_count]->private = NULL;
 269
 270                 /* loop over all attributes */
 271                 for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
 272                      attr;
 273                      attr=ldap_next_attribute(lldb->ldap, msg, berptr)) {
 274                         struct berval **bval;
 275                         bval = ldap_get_values_len(lldb->ldap, msg, attr);
 276
 277                         if (bval) {
 278                                 lldb_add_msg_attr((*res)[msg_count], attr, bval);
 279                                 ldap_value_free_len(bval);
 280                         }
 281
 282                         ldap_memfree(attr);
 283                 }
 284                 if (berptr) ber_free(berptr, 0);
 285
 286                 msg_count++;
 287         }
 288
 289         ldap_msgfree(ldapres);
 290
 291         return msg_count;
 292
 293 failed:
 294         if (*res) lldb_search_free(ldb, *res);
 295         return -1;
 296 }
 297
 298
 299 /*
 300   free a set of mods from lldb_msg_to_mods()
 301 */
 302 static void lldb_mods_free(LDAPMod **mods)
 303 {
 304         int i, j;
 305
 306         if (!mods) return;
 307
 308         for (i=0;mods[i];i++) {
 309                 if (mods[i]->mod_vals.modv_bvals) {
 310                         for (j=0;mods[i]->mod_vals.modv_bvals[j];j++) {
 311                                 free(mods[i]->mod_vals.modv_bvals[j]);
 312                         }
 313                         free(mods[i]->mod_vals.modv_bvals);
 314                 }
 315                 free(mods[i]);
 316         }
 317         free(mods);
 318 }
 319
 320
 321 /*
 322   convert a ldb_message structure to a list of LDAPMod structures
 323   ready for ldap_add() or ldap_modify()
 324 */
 325 static LDAPMod **lldb_msg_to_mods(const struct ldb_message *msg, int use_flags)
 326 {
 327         LDAPMod **mods;
 328         int i, j, num_mods = 0;
 329
 330         /* allocate maximum number of elements needed */
 331         mods = malloc_array_p(LDAPMod *, msg->num_elements+1);
 332         if (!mods) {
 333                 errno = ENOMEM;
 334                 return NULL;
 335         }
 336         mods[0] = NULL;
 337
 338         for (i=0;i<msg->num_elements;i++) {
 339                 const struct ldb_message_element *el = &msg->elements[i];
 340
 341                 mods[num_mods] = malloc_p(LDAPMod);
 342                 if (!mods[num_mods]) {
 343                         goto failed;
 344                 }
 345                 mods[num_mods+1] = NULL;
 346                 mods[num_mods]->mod_op = LDAP_MOD_BVALUES;
 347                 if (use_flags) {
 348                         switch (el->flags & LDB_FLAG_MOD_MASK) {
 349                         case LDB_FLAG_MOD_ADD:
 350                                 mods[num_mods]->mod_op |= LDAP_MOD_ADD;
 351                                 break;
 352                         case LDB_FLAG_MOD_DELETE:
 353                                 mods[num_mods]->mod_op |= LDAP_MOD_DELETE;
 354                                 break;
 355                         case LDB_FLAG_MOD_REPLACE:
 356                                 mods[num_mods]->mod_op |= LDAP_MOD_REPLACE;
 357                                 break;
 358                         }
 359                 }
 360                 mods[num_mods]->mod_type = el->name;
 361                 mods[num_mods]->mod_vals.modv_bvals = malloc_array_p(struct berval *,
 362                                                                      1+el->num_values);
 363                 if (!mods[num_mods]->mod_vals.modv_bvals) {
 364                         goto failed;
 365                 }
 366
 367                 for (j=0;j<el->num_values;j++) {
 368                         mods[num_mods]->mod_vals.modv_bvals[j] = malloc_p(struct berval);
 369                         if (!mods[num_mods]->mod_vals.modv_bvals[j]) {
 370                                 goto failed;
 371                         }
 372                         mods[num_mods]->mod_vals.modv_bvals[j]->bv_val = el->values[j].data;
 373                         mods[num_mods]->mod_vals.modv_bvals[j]->bv_len = el->values[j].length;
 374                 }
 375                 mods[num_mods]->mod_vals.modv_bvals[j] = NULL;
 376                 num_mods++;
 377         }
 378
 379         return mods;
 380
 381 failed:
 382         lldb_mods_free(mods);
 383         return NULL;
 384 }
 385
 386
 387 /*
 388   add a record
 389 */
 390 static int lldb_add(struct ldb_context *ldb, const struct ldb_message *msg)
 391 {
 392         struct lldb_private *lldb = ldb->private;
 393         LDAPMod **mods;
 394         int ret = 0;
 395
 396         mods = lldb_msg_to_mods(msg, 0);
 397
 398         lldb->last_rc = ldap_add_s(lldb->ldap, msg->dn, mods);
 399         if (lldb->last_rc != LDAP_SUCCESS) {
 400                 ret = -1;
 401         }
 402
 403         lldb_mods_free(mods);
 404
 405         return ret;
 406 }
 407
 408
 409 /*
 410   modify a record
 411 */
 412 static int lldb_modify(struct ldb_context *ldb, const struct ldb_message *msg)
 413 {
 414         struct lldb_private *lldb = ldb->private;
 415         LDAPMod **mods;
 416         int ret = 0;
 417
 418         mods = lldb_msg_to_mods(msg, 1);
 419
 420         lldb->last_rc = ldap_modify_s(lldb->ldap, msg->dn, mods);
 421         if (lldb->last_rc != LDAP_SUCCESS) {
 422                 ret = -1;
 423         }
 424
 425         lldb_mods_free(mods);
 426
 427         return ret;
 428 }
 429
 430
 431 /*
 432   return extended error information
 433 */
 434 static const char *lldb_errstring(struct ldb_context *ldb)
 435 {
 436         struct lldb_private *lldb = ldb->private;
 437         return ldap_err2string(lldb->last_rc);
 438 }
 439
 440
 441 static const struct ldb_backend_ops lldb_ops = {
 442         lldb_close,
 443         lldb_search,
 444         lldb_search_free,
 445         lldb_add,
 446         lldb_modify,
 447         lldb_delete,
 448         lldb_errstring
 449 };
 450
 451
 452 /*
 453   connect to the database
 454 */
 455 struct ldb_context *lldb_connect(const char *url,
 456                                  unsigned int flags,
 457                                  const char *options[])
 458 {
 459         struct ldb_context *ldb = NULL;
 460         struct lldb_private *lldb = NULL;
 461         int i;
 462
 463         ldb = malloc_p(struct ldb_context);
 464         if (!ldb) {
 465                 errno = ENOMEM;
 466                 goto failed;
 467         }
 468
 469         lldb = malloc_p(struct lldb_private);
 470         if (!lldb) {
 471                 free(ldb);
 472                 errno = ENOMEM;
 473                 goto failed;
 474         }
 475
 476         lldb->ldap = NULL;
 477         lldb->options = NULL;
 478
 479         lldb->last_rc = ldap_initialize(&lldb->ldap, url);
 480         if (lldb->last_rc != LDAP_SUCCESS) {
 481                 goto failed;
 482         }
 483
 484         ldb->ops = &lldb_ops;
 485         ldb->private = lldb;
 486
 487         if (options) {
 488                 /* take a copy of the options array, so we don't have to rely
 489                    on the caller keeping it around (it might be dynamic) */
 490                 for (i=0;options[i];i++) ;
 491
 492                 lldb->options = malloc_array_p(char *, i+1);
 493                 if (!lldb->options) {
 494                         goto failed;
 495                 }
 496
 497                 for (i=0;options[i];i++) {
 498                         lldb->options[i+1] = NULL;
 499                         lldb->options[i] = strdup(options[i]);
 500                         if (!lldb->options[i]) {
 501                                 goto failed;
 502                         }
 503                 }
 504         }
 505
 506         return ldb;
 507
 508 failed:
 509         if (lldb && lldb->options) {
 510                 for (i=0;lldb->options[i];i++) {
 511                         free(lldb->options[i]);
 512                 }
 513                 free(lldb->options);
 514         }
 515         if (lldb && lldb->ldap) {
 516                 ldap_unbind(lldb->ldap);
 517         }
 518         if (lldb) free(lldb);
 519         if (ldb) free(ldb);
 520         return NULL;
 521 }
 522 #endif /*HAVE_LDAP*/