git.sur5r.net Git - openldap/blob - servers/slapd/backglue.c

   1 /* backglue.c - backend glue routines */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 2001 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 /*
   9  * Functions to glue a bunch of other backends into a single tree.
  10  * All of the glued backends must share a common suffix. E.g., you
  11  * can glue o=foo and ou=bar,o=foo but you can't glue o=foo and o=bar.
  12  *
  13  * This uses the backend structures and routines extensively, but is
  14  * not an actual backend of its own. To use it you must add a "subordinate"
  15  * keyword to the configuration of other backends. Subordinates will
  16  * automatically be connected to their parent backend.
  17  *
  18  * The purpose of these functions is to allow you to split a single database
  19  * into pieces (for load balancing purposes, whatever) but still be able
  20  * to treat it as a single database after it's been split. As such, each
  21  * of the glued backends should have identical rootdn and rootpw.
  22  *
  23  * If you need more elaborate configuration, you probably should be using
  24  * back-meta instead.
  25  *  -- Howard Chu
  26  */
  27
  28 #include "portable.h"
  29
  30 #include <stdio.h>
  31
  32 #include <ac/socket.h>
  33
  34 #define SLAPD_TOOLS
  35 #include "slap.h"
  36
  37 typedef struct gluenode {
  38         BackendDB *be;
  39         char *pdn;
  40 } gluenode;
  41
  42 typedef struct glueinfo {
  43         BackendDB *be;
  44         int nodes;
  45         gluenode n[1];
  46 } glueinfo;
  47
  48 static int glueMode;
  49 static BackendDB *glueBack;
  50
  51 /* Just like select_backend, but only for our backends */
  52 static BackendDB *
  53 glue_back_select (
  54         BackendDB *be,
  55         const char *dn
  56 )
  57 {
  58         glueinfo *gi = (glueinfo *) be->be_private;
  59         struct berval bv;
  60         int i;
  61
  62         bv.bv_len = strlen(dn);
  63         bv.bv_val = (char *) dn;
  64
  65         for (i = 0; i<gi->nodes; i++) {
  66                 if (dnIsSuffix(&bv, gi->n[i].be->be_nsuffix[0])) {
  67                         return gi->n[i].be;
  68                 }
  69         }
  70         return NULL;
  71 }
  72
  73 /* This function will only be called in tool mode */
  74 static int
  75 glue_back_open (
  76         BackendInfo *bi
  77 )
  78 {
  79         int rc = 0;
  80         static int glueOpened = 0;
  81
  82         if (glueOpened) return 0;
  83
  84         glueOpened = 1;
  85
  86         /* If we were invoked in tool mode, open all the underlying backends */
  87         if (slapMode & SLAP_TOOL_MODE) {
  88                 rc = backend_startup (NULL);
  89         } /* other case is impossible */
  90         return rc;
  91 }
  92
  93 /* This function will only be called in tool mode */
  94 static int
  95 glue_back_close (
  96         BackendInfo *bi
  97 )
  98 {
  99         static int glueClosed = 0;
 100         int rc;
 101
 102         if (glueClosed) return 0;
 103
 104         glueClosed = 1;
 105
 106         if (slapMode & SLAP_TOOL_MODE) {
 107                 rc = backend_shutdown (NULL);
 108         }
 109         return rc;
 110 }
 111
 112 static int
 113 glue_back_db_open (
 114         BackendDB *be
 115 )
 116 {
 117         glueinfo *gi = (glueinfo *)be->be_private;
 118         static int glueOpened = 0;
 119         int rc = 0;
 120
 121         if (glueOpened) return 0;
 122
 123         glueOpened = 1;
 124
 125         gi->be->be_acl = be->be_acl;
 126
 127         if (gi->be->bd_info->bi_db_open)
 128                 rc = gi->be->bd_info->bi_db_open(gi->be);
 129
 130         return rc;
 131 }
 132
 133 static int
 134 glue_back_db_close (
 135         BackendDB *be
 136 )
 137 {
 138         glueinfo *gi = (glueinfo *)be->be_private;
 139         static int glueClosed = 0;
 140
 141         if (glueClosed) return 0;
 142
 143         glueClosed = 1;
 144
 145         /* Close the master */
 146         if (gi->be->bd_info->bi_db_close)
 147                 gi->be->bd_info->bi_db_close( gi->be );
 148
 149         return 0;
 150 }
 151
 152 static int
 153 glue_back_db_destroy (
 154         BackendDB *be
 155 )
 156 {
 157         glueinfo *gi = (glueinfo *)be->be_private;
 158
 159         if (gi->be->bd_info->bi_db_destroy)
 160                 gi->be->bd_info->bi_db_destroy( gi->be );
 161         free (gi->be);
 162         free (gi);
 163         return 0;
 164 }
 165
 166 typedef struct glue_state {
 167         int err;
 168         int nentries;
 169         int matchlen;
 170         char *matched;
 171         int nrefs;
 172         BVarray refs;
 173 } glue_state;
 174
 175 static void
 176 glue_back_response (
 177         Connection *conn,
 178         Operation *op,
 179         ber_tag_t tag,
 180         ber_int_t msgid,
 181         ber_int_t err,
 182         const char *matched,
 183         const char *text,
 184         BVarray ref,
 185         const char *resoid,
 186         struct berval *resdata,
 187         struct berval *sasldata,
 188         LDAPControl **ctrls
 189 )
 190 {
 191         glue_state *gs = op->o_glue;
 192
 193         if (err == LDAP_SUCCESS || gs->err != LDAP_SUCCESS)
 194                 gs->err = err;
 195         if (gs->err == LDAP_SUCCESS && gs->matched) {
 196                 free (gs->matched);
 197                 gs->matchlen = 0;
 198         }
 199         if (gs->err != LDAP_SUCCESS && matched) {
 200                 int len;
 201                 len = strlen (matched);
 202                 if (len > gs->matchlen) {
 203                         if (gs->matched)
 204                                 free (gs->matched);
 205                         gs->matched = ch_strdup (matched);
 206                         gs->matchlen = len;
 207                 }
 208         }
 209         if (ref) {
 210                 int i, j, k;
 211                 BVarray new;
 212
 213                 for (i=0; ref[i].bv_val; i++);
 214
 215                 j = gs->nrefs;
 216                 if (!j) {
 217                         new = ch_malloc ((i+1)*sizeof(struct berval));
 218                 } else {
 219                         new = ch_realloc(gs->refs,
 220                                 (j+i+1)*sizeof(struct berval));
 221                 }
 222                 for (k=0; k<i; j++,k++) {
 223                         ber_dupbv( &new[j], &ref[k] );
 224                 }
 225                 new[j].bv_val = NULL;
 226                 gs->nrefs = j;
 227                 gs->refs = new;
 228         }
 229 }
 230
 231 static void
 232 glue_back_sresult (
 233         Connection *c,
 234         Operation *op,
 235         ber_int_t err,
 236         const char *matched,
 237         const char *text,
 238         BVarray refs,
 239         LDAPControl **ctrls,
 240         int nentries
 241 )
 242 {
 243         glue_state *gs = op->o_glue;
 244
 245         gs->nentries += nentries;
 246         glue_back_response (c, op, 0, 0, err, matched, text, refs,
 247                             NULL, NULL, NULL, ctrls);
 248 }
 249
 250 static int
 251 glue_back_search (
 252         BackendDB *b0,
 253         Connection *conn,
 254         Operation *op,
 255         struct berval *dn,
 256         struct berval *ndn,
 257         int scope,
 258         int deref,
 259         int slimit,
 260         int tlimit,
 261         Filter *filter,
 262         struct berval *filterstr,
 263         AttributeName *attrs,
 264         int attrsonly
 265 )
 266 {
 267         glueinfo *gi = (glueinfo *)b0->be_private;
 268         BackendDB *be;
 269         int i, rc, t2limit = 0, s2limit = 0;
 270         long stoptime = 0;
 271         glue_state gs = {0};
 272         struct berval bv;
 273
 274
 275         if (tlimit) {
 276                 stoptime = slap_get_time () + tlimit;
 277         }
 278
 279         switch (scope) {
 280         case LDAP_SCOPE_BASE:
 281                 be = glue_back_select (b0, ndn->bv_val);
 282
 283                 if (be && be->be_search) {
 284                         rc = be->be_search (be, conn, op, dn, ndn, scope,
 285                                    deref, slimit, tlimit, filter, filterstr,
 286                                             attrs, attrsonly);
 287                 } else {
 288                         rc = LDAP_UNWILLING_TO_PERFORM;
 289                         send_ldap_result (conn, op, rc, NULL,
 290                                       "No search target found", NULL, NULL);
 291                 }
 292                 return rc;
 293
 294         case LDAP_SCOPE_ONELEVEL:
 295         case LDAP_SCOPE_SUBTREE:
 296                 op->o_glue = &gs;
 297                 op->o_sresult = glue_back_sresult;
 298                 op->o_response = glue_back_response;
 299
 300                 /*
 301                  * Execute in reverse order, most general first
 302                  */
 303                 for (i = gi->nodes-1; i >= 0; i--) {
 304                         if (!gi->n[i].be || !gi->n[i].be->be_search)
 305                                 continue;
 306                         if (tlimit) {
 307                                 t2limit = stoptime - slap_get_time ();
 308                                 if (t2limit <= 0)
 309                                         break;
 310                         }
 311                         if (slimit) {
 312                                 s2limit = slimit - gs.nentries;
 313                                 if (s2limit <= 0)
 314                                         break;
 315                         }
 316                         /*
 317                          * check for abandon
 318                          */
 319                         ldap_pvt_thread_mutex_lock (&op->o_abandonmutex);
 320                         rc = op->o_abandon;
 321                         ldap_pvt_thread_mutex_unlock (&op->o_abandonmutex);
 322                         if (rc) {
 323                                 rc = 0;
 324                                 goto done;
 325                         }
 326                         be = gi->n[i].be;
 327                         if (scope == LDAP_SCOPE_ONELEVEL &&
 328                                 !strcmp (gi->n[i].pdn, ndn->bv_val)) {
 329                                 rc = be->be_search (be, conn, op,
 330                                         be->be_suffix[0], be->be_nsuffix[0],
 331                                         LDAP_SCOPE_BASE, deref,
 332                                         s2limit, t2limit, filter, filterstr,
 333                                         attrs, attrsonly);
 334
 335                         } else if (scope == LDAP_SCOPE_SUBTREE &&
 336                                 dnIsSuffix(be->be_nsuffix[0], ndn)) {
 337                                 rc = be->be_search (be, conn, op,
 338                                         be->be_suffix[0], be->be_nsuffix[0],
 339                                         scope, deref,
 340                                         s2limit, t2limit, filter, filterstr,
 341                                         attrs, attrsonly);
 342
 343                         } else if (dnIsSuffix(&bv, be->be_nsuffix[0])) {
 344                                 rc = be->be_search (be, conn, op, dn, ndn,
 345                                         scope, deref,
 346                                         s2limit, t2limit, filter, filterstr,
 347                                         attrs, attrsonly);
 348                         }
 349                 }
 350                 break;
 351         }
 352         op->o_sresult = NULL;
 353         op->o_response = NULL;
 354         op->o_glue = NULL;
 355
 356         send_search_result (conn, op, gs.err, gs.matched, NULL,
 357                 gs.refs, NULL, gs.nentries);
 358
 359 done:
 360         if (gs.matched)
 361                 free (gs.matched);
 362         if (gs.refs)
 363                 bvarray_free(gs.refs);
 364         return rc;
 365 }
 366
 367 static int
 368 glue_back_bind (
 369         BackendDB *b0,
 370         Connection *conn,
 371         Operation *op,
 372         struct berval *dn,
 373         struct berval *ndn,
 374         int method,
 375         struct berval *cred,
 376         struct berval *edn
 377 )
 378 {
 379         BackendDB *be;
 380         int rc;
 381
 382         be = glue_back_select (b0, ndn->bv_val);
 383
 384         if (be && be->be_bind) {
 385                 conn->c_authz_backend = be;
 386                 rc = be->be_bind (be, conn, op, dn, ndn, method, cred, edn);
 387         } else {
 388                 rc = LDAP_UNWILLING_TO_PERFORM;
 389                 send_ldap_result (conn, op, rc, NULL, "No bind target found",
 390                                   NULL, NULL);
 391         }
 392         return rc;
 393 }
 394
 395 static int
 396 glue_back_compare (
 397         BackendDB *b0,
 398         Connection *conn,
 399         Operation *op,
 400         struct berval *dn,
 401         struct berval *ndn,
 402         AttributeAssertion *ava
 403 )
 404 {
 405         BackendDB *be;
 406         int rc;
 407
 408         be = glue_back_select (b0, ndn->bv_val);
 409
 410         if (be && be->be_compare) {
 411                 rc = be->be_compare (be, conn, op, dn, ndn, ava);
 412         } else {
 413                 rc = LDAP_UNWILLING_TO_PERFORM;
 414                 send_ldap_result (conn, op, rc, NULL, "No compare target found",
 415                         NULL, NULL);
 416         }
 417         return rc;
 418 }
 419
 420 static int
 421 glue_back_modify (
 422         BackendDB *b0,
 423         Connection *conn,
 424         Operation *op,
 425         struct berval *dn,
 426         struct berval *ndn,
 427         Modifications *mod
 428 )
 429 {
 430         BackendDB *be;
 431         int rc;
 432
 433         be = glue_back_select (b0, ndn->bv_val);
 434
 435         if (be && be->be_modify) {
 436                 rc = be->be_modify (be, conn, op, dn, ndn, mod);
 437         } else {
 438                 rc = LDAP_UNWILLING_TO_PERFORM;
 439                 send_ldap_result (conn, op, rc, NULL,
 440                         "No modify target found", NULL, NULL);
 441         }
 442         return rc;
 443 }
 444
 445 static int
 446 glue_back_modrdn (
 447         BackendDB *b0,
 448         Connection *conn,
 449         Operation *op,
 450         struct berval *dn,
 451         struct berval *ndn,
 452         struct berval *newrdn,
 453         struct berval *nnewrdn,
 454         int del,
 455         struct berval *newsup,
 456         struct berval *nnewsup
 457 )
 458 {
 459         BackendDB *be;
 460         int rc;
 461
 462         be = glue_back_select (b0, ndn->bv_val);
 463
 464         if (be && be->be_modrdn) {
 465                 rc = be->be_modrdn (be, conn, op, dn, ndn,
 466                         newrdn, nnewrdn, del, newsup, nnewsup );
 467         } else {
 468                 rc = LDAP_UNWILLING_TO_PERFORM;
 469                 send_ldap_result (conn, op, rc, NULL,
 470                         "No modrdn target found", NULL, NULL);
 471         }
 472         return rc;
 473 }
 474
 475 static int
 476 glue_back_add (
 477         BackendDB *b0,
 478         Connection *conn,
 479         Operation *op,
 480         Entry *e
 481 )
 482 {
 483         BackendDB *be;
 484         int rc;
 485
 486         be = glue_back_select (b0, e->e_ndn);
 487
 488         if (be && be->be_add) {
 489                 rc = be->be_add (be, conn, op, e);
 490         } else {
 491                 rc = LDAP_UNWILLING_TO_PERFORM;
 492                 send_ldap_result (conn, op, rc, NULL, "No add target found",
 493                                   NULL, NULL);
 494         }
 495         return rc;
 496 }
 497
 498 static int
 499 glue_back_delete (
 500         BackendDB *b0,
 501         Connection *conn,
 502         Operation *op,
 503         struct berval *dn,
 504         struct berval *ndn
 505 )
 506 {
 507         BackendDB *be;
 508         int rc;
 509
 510         be = glue_back_select (b0, ndn->bv_val);
 511
 512         if (be && be->be_delete) {
 513                 rc = be->be_delete (be, conn, op, dn, ndn);
 514         } else {
 515                 rc = LDAP_UNWILLING_TO_PERFORM;
 516                 send_ldap_result (conn, op, rc, NULL, "No delete target found",
 517                                   NULL, NULL);
 518         }
 519         return rc;
 520 }
 521
 522 static int
 523 glue_back_release_rw (
 524         BackendDB *b0,
 525         Connection *conn,
 526         Operation *op,
 527         Entry *e,
 528         int rw
 529 )
 530 {
 531         BackendDB *be;
 532         int rc;
 533
 534         be = glue_back_select (b0, e->e_ndn);
 535
 536         if (be && be->be_release) {
 537                 rc = be->be_release (be, conn, op, e, rw);
 538         } else {
 539                 entry_free (e);
 540                 rc = 0;
 541         }
 542         return rc;
 543 }
 544
 545 static int
 546 glue_back_group (
 547         BackendDB *b0,
 548         Connection *conn,
 549         Operation *op,
 550         Entry *target,
 551         struct berval *ndn,
 552         struct berval *ondn,
 553         ObjectClass *oc,
 554         AttributeDescription * ad
 555 )
 556 {
 557         BackendDB *be;
 558         int rc;
 559
 560         be = glue_back_select (b0, ndn->bv_val);
 561
 562         if (be && be->be_group) {
 563                 rc = be->be_group (be, conn, op, target, ndn, ondn, oc, ad);
 564         } else {
 565                 rc = LDAP_UNWILLING_TO_PERFORM;
 566         }
 567         return rc;
 568 }
 569
 570 static int
 571 glue_back_attribute (
 572         BackendDB *b0,
 573         Connection *conn,
 574         Operation *op,
 575         Entry *target,
 576         struct berval *ndn,
 577         AttributeDescription *ad,
 578         BVarray *vals
 579 )
 580 {
 581         BackendDB *be;
 582         int rc;
 583
 584         be = glue_back_select (b0, ndn->bv_val);
 585
 586         if (be && be->be_attribute) {
 587                 rc = be->be_attribute (be, conn, op, target, ndn, ad, vals);
 588         } else {
 589                 rc = LDAP_UNWILLING_TO_PERFORM;
 590         }
 591         return rc;
 592 }
 593
 594 static int
 595 glue_back_referrals (
 596         BackendDB *b0,
 597         Connection *conn,
 598         Operation *op,
 599         struct berval *dn,
 600         struct berval *ndn,
 601         const char **text
 602 )
 603 {
 604         BackendDB *be;
 605         int rc;
 606
 607         be = glue_back_select (b0, ndn->bv_val);
 608
 609         if (be && be->be_chk_referrals) {
 610                 rc = be->be_chk_referrals (be, conn, op, dn, ndn, text);
 611         } else {
 612                 rc = LDAP_SUCCESS;;
 613         }
 614         return rc;
 615 }
 616
 617 static int
 618 glue_tool_entry_open (
 619         BackendDB *b0,
 620         int mode
 621 )
 622 {
 623         /* We don't know which backend to talk to yet, so just
 624          * remember the mode and move on...
 625          */
 626
 627         glueMode = mode;
 628         glueBack = NULL;
 629
 630         return 0;
 631 }
 632
 633 static int
 634 glue_tool_entry_close (
 635         BackendDB *b0
 636 )
 637 {
 638         int rc = 0;
 639
 640         if (glueBack) {
 641                 if (!glueBack->be_entry_close)
 642                         return 0;
 643                 rc = glueBack->be_entry_close (glueBack);
 644         }
 645         return rc;
 646 }
 647
 648 static ID
 649 glue_tool_entry_first (
 650         BackendDB *b0
 651 )
 652 {
 653         glueinfo *gi = (glueinfo *) b0->be_private;
 654         int i;
 655
 656         /* If we're starting from scratch, start at the most general */
 657         if (!glueBack) {
 658                 for (i = gi->nodes-1; i >= 0; i--) {
 659                         if (gi->n[i].be->be_entry_open &&
 660                             gi->n[i].be->be_entry_first) {
 661                                 glueBack = gi->n[i].be;
 662                                 break;
 663                         }
 664                 }
 665
 666         }
 667         if (!glueBack || glueBack->be_entry_open (glueBack, glueMode) != 0)
 668                 return NOID;
 669
 670         return glueBack->be_entry_first (glueBack);
 671 }
 672
 673 static ID
 674 glue_tool_entry_next (
 675         BackendDB *b0
 676 )
 677 {
 678         glueinfo *gi = (glueinfo *) b0->be_private;
 679         int i;
 680         ID rc;
 681
 682         if (!glueBack || !glueBack->be_entry_next)
 683                 return NOID;
 684
 685         rc = glueBack->be_entry_next (glueBack);
 686
 687         /* If we ran out of entries in one database, move on to the next */
 688         if (rc == NOID) {
 689                 glueBack->be_entry_close (glueBack);
 690                 for (i=0; i<gi->nodes; i++) {
 691                         if (gi->n[i].be == glueBack)
 692                                 break;
 693                 }
 694                 if (i == 0) {
 695                         glueBack = NULL;
 696                         rc = NOID;
 697                 } else {
 698                         glueBack = gi->n[i-1].be;
 699                         rc = glue_tool_entry_first (b0);
 700                 }
 701         }
 702         return rc;
 703 }
 704
 705 static Entry *
 706 glue_tool_entry_get (
 707         BackendDB *b0,
 708         ID id
 709 )
 710 {
 711         if (!glueBack || !glueBack->be_entry_get)
 712                 return NULL;
 713
 714         return glueBack->be_entry_get (glueBack, id);
 715 }
 716
 717 static ID
 718 glue_tool_entry_put (
 719         BackendDB *b0,
 720         Entry *e
 721 )
 722 {
 723         BackendDB *be;
 724         int rc;
 725
 726         be = glue_back_select (b0, e->e_ndn);
 727         if (!be->be_entry_put)
 728                 return NOID;
 729
 730         if (!glueBack) {
 731                 rc = be->be_entry_open (be, glueMode);
 732                 if (rc != 0)
 733                         return NOID;
 734         } else if (be != glueBack) {
 735                 /* If this entry belongs in a different branch than the
 736                  * previous one, close the current database and open the
 737                  * new one.
 738                  */
 739                 glueBack->be_entry_close (glueBack);
 740                 rc = be->be_entry_open (be, glueMode);
 741                 if (rc != 0)
 742                         return NOID;
 743         }
 744         glueBack = be;
 745         return be->be_entry_put (be, e);
 746 }
 747
 748 static int
 749 glue_tool_entry_reindex (
 750         BackendDB *b0,
 751         ID id
 752 )
 753 {
 754         if (!glueBack || !glueBack->be_entry_reindex)
 755                 return -1;
 756
 757         return glueBack->be_entry_reindex (glueBack, id);
 758 }
 759
 760 static int
 761 glue_tool_sync (
 762         BackendDB *b0
 763 )
 764 {
 765         glueinfo *gi = (glueinfo *) b0->be_private;
 766         int i;
 767
 768         /* just sync everyone */
 769         for (i = 0; b0->be_nsuffix[i]; i++)
 770                 if (gi->n[i].be->be_sync)
 771                         gi->n[i].be->be_sync (gi->n[i].be);
 772         return 0;
 773 }
 774
 775 int
 776 glue_sub_init( )
 777 {
 778         int i, j;
 779         int cont = num_subordinates;
 780         BackendDB *b1, *be;
 781         BackendInfo *bi;
 782         glueinfo *gi;
 783
 784         /* While there are subordinate backends, search backwards through the
 785          * backends and connect them to their superior.
 786          */
 787         for (i = nBackendDB - 1, b1=&backendDB[i]; cont && i>=0; b1--,i--) {
 788                 if (b1->be_glueflags & SLAP_GLUE_SUBORDINATE) {
 789                         /* The last database cannot be a subordinate of noone */
 790                         if (i == nBackendDB - 1)
 791                                 b1->be_glueflags ^= SLAP_GLUE_SUBORDINATE;
 792                         continue;
 793                 }
 794                 gi = NULL;
 795                 for (j = i-1, be=&backendDB[j]; j>=0; be--,j--) {
 796                         if (!(be->be_glueflags & SLAP_GLUE_SUBORDINATE))
 797                                 continue;
 798                         /* We will only link it once */
 799                         if (be->be_glueflags & SLAP_GLUE_LINKED)
 800                                 continue;
 801                         if (!dnIsSuffix(be->be_nsuffix[0],
 802                                 b1->be_nsuffix[0]))
 803                                 continue;
 804                         cont--;
 805                         be->be_glueflags |= SLAP_GLUE_LINKED;
 806                         if (gi == NULL) {
 807                                 /* We create a copy of the superior's be
 808                                  * structure, pointing to all of its original
 809                                  * information. Then we replace elements of
 810                                  * the superior's info with our own. The copy
 811                                  * is used whenever we have operations to pass
 812                                  * down to the real database.
 813                                  */
 814                                 b1->be_glueflags |= SLAP_GLUE_INSTANCE;
 815                                 gi = (glueinfo *)ch_malloc(sizeof(glueinfo));
 816                                 gi->be = (BackendDB *)ch_malloc(sizeof(BackendDB) + sizeof(BackendInfo));
 817                                 bi = (BackendInfo *)(gi->be+1);
 818                                 *gi->be = *b1;
 819                                 gi->nodes = 0;
 820                                 *bi = *b1->bd_info;
 821                                 bi->bi_open = glue_back_open;
 822                                 bi->bi_close = glue_back_close;
 823                                 bi->bi_db_open = glue_back_db_open;
 824                                 bi->bi_db_close = glue_back_db_close;
 825                                 bi->bi_db_destroy = glue_back_db_destroy;
 826
 827                                 bi->bi_op_bind = glue_back_bind;
 828                                 bi->bi_op_search = glue_back_search;
 829                                 bi->bi_op_compare = glue_back_compare;
 830                                 bi->bi_op_modify = glue_back_modify;
 831                                 bi->bi_op_modrdn = glue_back_modrdn;
 832                                 bi->bi_op_add = glue_back_add;
 833                                 bi->bi_op_delete = glue_back_delete;
 834
 835                                 bi->bi_entry_release_rw = glue_back_release_rw;
 836                                 bi->bi_acl_group = glue_back_group;
 837                                 bi->bi_acl_attribute = glue_back_attribute;
 838                                 bi->bi_chk_referrals = glue_back_referrals;
 839
 840                                 /*
 841                                  * hooks for slap tools
 842                                  */
 843                                 bi->bi_tool_entry_open = glue_tool_entry_open;
 844                                 bi->bi_tool_entry_close = glue_tool_entry_close;
 845                                 bi->bi_tool_entry_first = glue_tool_entry_first;
 846                                 bi->bi_tool_entry_next = glue_tool_entry_next;
 847                                 bi->bi_tool_entry_get = glue_tool_entry_get;
 848                                 bi->bi_tool_entry_put = glue_tool_entry_put;
 849                                 bi->bi_tool_entry_reindex = glue_tool_entry_reindex;
 850                                 bi->bi_tool_sync = glue_tool_sync;
 851                         } else {
 852                                 gi = (glueinfo *)ch_realloc(gi,
 853                                         sizeof(glueinfo) +
 854                                         gi->nodes * sizeof(gluenode));
 855                         }
 856                         gi->n[gi->nodes].be = be;
 857                         gi->n[gi->nodes].pdn = dn_parent(NULL,
 858                                 be->be_nsuffix[0]->bv_val);
 859                         gi->nodes++;
 860                 }
 861                 if (gi) {
 862                         /* One more node for the master */
 863                         gi = (glueinfo *)ch_realloc(gi,
 864                                 sizeof(glueinfo) + gi->nodes * sizeof(gluenode));
 865                         gi->n[gi->nodes].be = gi->be;
 866                         gi->n[gi->nodes].pdn = dn_parent(NULL,
 867                                 b1->be_nsuffix[0]->bv_val);
 868                         gi->nodes++;
 869                         b1->be_private = gi;
 870                         b1->bd_info = bi;
 871                 }
 872         }
 873         /* If there are any unresolved subordinates left, something is wrong */
 874         return cont;
 875 }