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

   1 /* backglue.c - backend glue routines */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 2001-2002 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         struct berval 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 = 0;
 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         BerVarray refs;
 173         slap_callback *prevcb;
 174 } glue_state;
 175
 176 static void
 177 glue_back_response (
 178         Connection *conn,
 179         Operation *op,
 180         ber_tag_t tag,
 181         ber_int_t msgid,
 182         ber_int_t err,
 183         const char *matched,
 184         const char *text,
 185         BerVarray ref,
 186         const char *resoid,
 187         struct berval *resdata,
 188         struct berval *sasldata,
 189         LDAPControl **ctrls
 190 )
 191 {
 192         glue_state *gs = op->o_callback->sc_private;
 193
 194         if (err == LDAP_SUCCESS || gs->err != LDAP_SUCCESS)
 195                 gs->err = err;
 196         if (gs->err == LDAP_SUCCESS && gs->matched) {
 197                 free (gs->matched);
 198                 gs->matchlen = 0;
 199         }
 200         if (gs->err != LDAP_SUCCESS && matched) {
 201                 int len;
 202                 len = strlen (matched);
 203                 if (len > gs->matchlen) {
 204                         if (gs->matched)
 205                                 free (gs->matched);
 206                         gs->matched = ch_strdup (matched);
 207                         gs->matchlen = len;
 208                 }
 209         }
 210         if (ref) {
 211                 int i, j, k;
 212                 BerVarray new;
 213
 214                 for (i=0; ref[i].bv_val; i++);
 215
 216                 j = gs->nrefs;
 217                 if (!j) {
 218                         new = ch_malloc ((i+1)*sizeof(struct berval));
 219                 } else {
 220                         new = ch_realloc(gs->refs,
 221                                 (j+i+1)*sizeof(struct berval));
 222                 }
 223                 for (k=0; k<i; j++,k++) {
 224                         ber_dupbv( &new[j], &ref[k] );
 225                 }
 226                 new[j].bv_val = NULL;
 227                 gs->nrefs = j;
 228                 gs->refs = new;
 229         }
 230 }
 231
 232 static void
 233 glue_back_sresult (
 234         Connection *c,
 235         Operation *op,
 236         ber_int_t err,
 237         const char *matched,
 238         const char *text,
 239         BerVarray refs,
 240         LDAPControl **ctrls,
 241         int nentries
 242 )
 243 {
 244         glue_state *gs = op->o_callback->sc_private;
 245
 246         gs->nentries += nentries;
 247         glue_back_response (c, op, 0, 0, err, matched, text, refs,
 248                             NULL, NULL, NULL, ctrls);
 249 }
 250
 251 static int
 252 glue_back_sendentry (
 253         BackendDB *be,
 254         Connection *c,
 255         Operation *op,
 256         Entry *e,
 257         AttributeName *an,
 258         int ao,
 259         LDAPControl **ctrls
 260 )
 261 {
 262         slap_callback *tmp = op->o_callback;
 263         glue_state *gs = tmp->sc_private;
 264         int rc;
 265
 266         op->o_callback = gs->prevcb;
 267         if (op->o_callback && op->o_callback->sc_sendentry) {
 268                 rc = op->o_callback->sc_sendentry(be, c, op, e, an, ao, ctrls);
 269         } else {
 270                 rc = send_search_entry(be, c, op, e, an, ao, ctrls);
 271         }
 272         op->o_callback = tmp;
 273         return rc;
 274 }
 275
 276 static int
 277 glue_back_search (
 278         BackendDB *b0,
 279         Connection *conn,
 280         Operation *op,
 281         struct berval *dn,
 282         struct berval *ndn,
 283         int scope,
 284         int deref,
 285         int slimit,
 286         int tlimit,
 287         Filter *filter,
 288         struct berval *filterstr,
 289         AttributeName *attrs,
 290         int attrsonly
 291 )
 292 {
 293         glueinfo *gi = (glueinfo *)b0->be_private;
 294         BackendDB *be;
 295         int i, rc = 0, t2limit = 0, s2limit = 0;
 296         long stoptime = 0;
 297         struct berval bv;
 298         glue_state gs = {0};
 299         slap_callback cb;
 300
 301         cb.sc_response = glue_back_response;
 302         cb.sc_sresult = glue_back_sresult;
 303         cb.sc_sendentry = glue_back_sendentry;
 304         cb.sc_private = &gs;
 305
 306         gs.prevcb = op->o_callback;
 307
 308         if (tlimit) {
 309                 stoptime = slap_get_time () + tlimit;
 310         }
 311
 312         switch (scope) {
 313         case LDAP_SCOPE_BASE:
 314                 be = glue_back_select (b0, ndn->bv_val);
 315
 316                 if (be && be->be_search) {
 317                         rc = be->be_search (be, conn, op, dn, ndn, scope,
 318                                    deref, slimit, tlimit, filter, filterstr,
 319                                             attrs, attrsonly);
 320                 } else {
 321                         rc = LDAP_UNWILLING_TO_PERFORM;
 322                         send_ldap_result (conn, op, rc, NULL,
 323                                       "No search target found", NULL, NULL);
 324                 }
 325                 return rc;
 326
 327         case LDAP_SCOPE_ONELEVEL:
 328         case LDAP_SCOPE_SUBTREE:
 329                 op->o_callback = &cb;
 330                 rc = gs.err = LDAP_UNWILLING_TO_PERFORM;
 331
 332                 /*
 333                  * Execute in reverse order, most general first
 334                  */
 335                 for (i = gi->nodes-1; i >= 0; i--) {
 336                         if (!gi->n[i].be || !gi->n[i].be->be_search)
 337                                 continue;
 338                         if (tlimit) {
 339                                 t2limit = stoptime - slap_get_time ();
 340                                 if (t2limit <= 0) {
 341                                         rc = gs.err = LDAP_TIMELIMIT_EXCEEDED;
 342                                         break;
 343                                 }
 344                         }
 345                         if (slimit) {
 346                                 s2limit = slimit - gs.nentries;
 347                                 if (s2limit <= 0) {
 348                                         rc = gs.err = LDAP_SIZELIMIT_EXCEEDED;
 349                                         break;
 350                                 }
 351                         }
 352                         rc = 0;
 353                         /*
 354                          * check for abandon
 355                          */
 356                         if (op->o_abandon) {
 357                                 goto done;
 358                         }
 359                         be = gi->n[i].be;
 360                         if (scope == LDAP_SCOPE_ONELEVEL &&
 361                                 dn_match(&gi->n[i].pdn, ndn)) {
 362                                 rc = be->be_search (be, conn, op,
 363                                         &be->be_suffix[0], &be->be_nsuffix[0],
 364                                         LDAP_SCOPE_BASE, deref,
 365                                         s2limit, t2limit, filter, filterstr,
 366                                         attrs, attrsonly);
 367
 368                         } else if (scope == LDAP_SCOPE_SUBTREE &&
 369                                 dnIsSuffix(&be->be_nsuffix[0], ndn)) {
 370                                 rc = be->be_search (be, conn, op,
 371                                         &be->be_suffix[0], &be->be_nsuffix[0],
 372                                         scope, deref,
 373                                         s2limit, t2limit, filter, filterstr,
 374                                         attrs, attrsonly);
 375
 376                         } else if (dnIsSuffix(&bv, &be->be_nsuffix[0])) {
 377                                 rc = be->be_search (be, conn, op, dn, ndn,
 378                                         scope, deref,
 379                                         s2limit, t2limit, filter, filterstr,
 380                                         attrs, attrsonly);
 381                         }
 382                 }
 383                 break;
 384         }
 385         op->o_callback = gs.prevcb;
 386
 387         send_search_result (conn, op, gs.err, gs.matched, NULL,
 388                 gs.refs, NULL, gs.nentries);
 389
 390 done:
 391         if (gs.matched)
 392                 free (gs.matched);
 393         if (gs.refs)
 394                 ber_bvarray_free(gs.refs);
 395         return rc;
 396 }
 397
 398 static int
 399 glue_back_bind (
 400         BackendDB *b0,
 401         Connection *conn,
 402         Operation *op,
 403         struct berval *dn,
 404         struct berval *ndn,
 405         int method,
 406         struct berval *cred,
 407         struct berval *edn
 408 )
 409 {
 410         BackendDB *be;
 411         int rc;
 412
 413         be = glue_back_select (b0, ndn->bv_val);
 414
 415         if (be && be->be_bind) {
 416                 rc = be->be_bind (be, conn, op, dn, ndn, method, cred, edn);
 417
 418                 if( rc == LDAP_SUCCESS ) {
 419                         ldap_pvt_thread_mutex_lock( &conn->c_mutex );
 420                         if( conn->c_authz_backend == NULL ) {
 421                                 conn->c_authz_backend = be;
 422                         }
 423                         ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
 424                 }
 425         } else {
 426                 rc = LDAP_UNWILLING_TO_PERFORM;
 427                 send_ldap_result (conn, op, rc, NULL, "No bind target found",
 428                                   NULL, NULL);
 429         }
 430         return rc;
 431 }
 432
 433 static int
 434 glue_back_compare (
 435         BackendDB *b0,
 436         Connection *conn,
 437         Operation *op,
 438         struct berval *dn,
 439         struct berval *ndn,
 440         AttributeAssertion *ava
 441 )
 442 {
 443         BackendDB *be;
 444         int rc;
 445
 446         be = glue_back_select (b0, ndn->bv_val);
 447
 448         if (be && be->be_compare) {
 449                 rc = be->be_compare (be, conn, op, dn, ndn, ava);
 450         } else {
 451                 rc = LDAP_UNWILLING_TO_PERFORM;
 452                 send_ldap_result (conn, op, rc, NULL, "No compare target found",
 453                         NULL, NULL);
 454         }
 455         return rc;
 456 }
 457
 458 static int
 459 glue_back_modify (
 460         BackendDB *b0,
 461         Connection *conn,
 462         Operation *op,
 463         struct berval *dn,
 464         struct berval *ndn,
 465         Modifications *mod
 466 )
 467 {
 468         BackendDB *be;
 469         int rc;
 470
 471         be = glue_back_select (b0, ndn->bv_val);
 472
 473         if (be && be->be_modify) {
 474                 rc = be->be_modify (be, conn, op, dn, ndn, mod);
 475         } else {
 476                 rc = LDAP_UNWILLING_TO_PERFORM;
 477                 send_ldap_result (conn, op, rc, NULL,
 478                         "No modify target found", NULL, NULL);
 479         }
 480         return rc;
 481 }
 482
 483 static int
 484 glue_back_modrdn (
 485         BackendDB *b0,
 486         Connection *conn,
 487         Operation *op,
 488         struct berval *dn,
 489         struct berval *ndn,
 490         struct berval *newrdn,
 491         struct berval *nnewrdn,
 492         int del,
 493         struct berval *newsup,
 494         struct berval *nnewsup
 495 )
 496 {
 497         BackendDB *be;
 498         int rc;
 499
 500         be = glue_back_select (b0, ndn->bv_val);
 501
 502         if (be && be->be_modrdn) {
 503                 rc = be->be_modrdn (be, conn, op, dn, ndn,
 504                         newrdn, nnewrdn, del, newsup, nnewsup );
 505         } else {
 506                 rc = LDAP_UNWILLING_TO_PERFORM;
 507                 send_ldap_result (conn, op, rc, NULL,
 508                         "No modrdn target found", NULL, NULL);
 509         }
 510         return rc;
 511 }
 512
 513 static int
 514 glue_back_add (
 515         BackendDB *b0,
 516         Connection *conn,
 517         Operation *op,
 518         Entry *e
 519 )
 520 {
 521         BackendDB *be;
 522         int rc;
 523
 524         be = glue_back_select (b0, e->e_ndn);
 525
 526         if (be && be->be_add) {
 527                 rc = be->be_add (be, conn, op, e);
 528         } else {
 529                 rc = LDAP_UNWILLING_TO_PERFORM;
 530                 send_ldap_result (conn, op, rc, NULL, "No add target found",
 531                                   NULL, NULL);
 532         }
 533         return rc;
 534 }
 535
 536 static int
 537 glue_back_delete (
 538         BackendDB *b0,
 539         Connection *conn,
 540         Operation *op,
 541         struct berval *dn,
 542         struct berval *ndn
 543 )
 544 {
 545         BackendDB *be;
 546         int rc;
 547
 548         be = glue_back_select (b0, ndn->bv_val);
 549
 550         if (be && be->be_delete) {
 551                 rc = be->be_delete (be, conn, op, dn, ndn);
 552         } else {
 553                 rc = LDAP_UNWILLING_TO_PERFORM;
 554                 send_ldap_result (conn, op, rc, NULL, "No delete target found",
 555                                   NULL, NULL);
 556         }
 557         return rc;
 558 }
 559
 560 static int
 561 glue_back_release_rw (
 562         BackendDB *b0,
 563         Connection *conn,
 564         Operation *op,
 565         Entry *e,
 566         int rw
 567 )
 568 {
 569         BackendDB *be;
 570         int rc;
 571
 572         be = glue_back_select (b0, e->e_ndn);
 573
 574         if (be && be->be_release) {
 575                 rc = be->be_release (be, conn, op, e, rw);
 576         } else {
 577                 entry_free (e);
 578                 rc = 0;
 579         }
 580         return rc;
 581 }
 582
 583 static int
 584 glue_back_group (
 585         BackendDB *b0,
 586         Connection *conn,
 587         Operation *op,
 588         Entry *target,
 589         struct berval *ndn,
 590         struct berval *ondn,
 591         ObjectClass *oc,
 592         AttributeDescription * ad
 593 )
 594 {
 595         BackendDB *be;
 596         int rc;
 597
 598         be = glue_back_select (b0, ndn->bv_val);
 599
 600         if (be && be->be_group) {
 601                 rc = be->be_group (be, conn, op, target, ndn, ondn, oc, ad);
 602         } else {
 603                 rc = LDAP_UNWILLING_TO_PERFORM;
 604         }
 605         return rc;
 606 }
 607
 608 static int
 609 glue_back_attribute (
 610         BackendDB *b0,
 611         Connection *conn,
 612         Operation *op,
 613         Entry *target,
 614         struct berval *ndn,
 615         AttributeDescription *ad,
 616         BerVarray *vals
 617 )
 618 {
 619         BackendDB *be;
 620         int rc;
 621
 622         be = glue_back_select (b0, ndn->bv_val);
 623
 624         if (be && be->be_attribute) {
 625                 rc = be->be_attribute (be, conn, op, target, ndn, ad, vals);
 626         } else {
 627                 rc = LDAP_UNWILLING_TO_PERFORM;
 628         }
 629         return rc;
 630 }
 631
 632 static int
 633 glue_back_referrals (
 634         BackendDB *b0,
 635         Connection *conn,
 636         Operation *op,
 637         struct berval *dn,
 638         struct berval *ndn,
 639         const char **text
 640 )
 641 {
 642         BackendDB *be;
 643         int rc;
 644
 645         be = glue_back_select (b0, ndn->bv_val);
 646
 647         if (be && be->be_chk_referrals) {
 648                 rc = be->be_chk_referrals (be, conn, op, dn, ndn, text);
 649         } else {
 650                 rc = LDAP_SUCCESS;;
 651         }
 652         return rc;
 653 }
 654
 655 static int
 656 glue_tool_entry_open (
 657         BackendDB *b0,
 658         int mode
 659 )
 660 {
 661         /* We don't know which backend to talk to yet, so just
 662          * remember the mode and move on...
 663          */
 664
 665         glueMode = mode;
 666         glueBack = NULL;
 667
 668         return 0;
 669 }
 670
 671 static int
 672 glue_tool_entry_close (
 673         BackendDB *b0
 674 )
 675 {
 676         int rc = 0;
 677
 678         if (glueBack) {
 679                 if (!glueBack->be_entry_close)
 680                         return 0;
 681                 rc = glueBack->be_entry_close (glueBack);
 682         }
 683         return rc;
 684 }
 685
 686 static ID
 687 glue_tool_entry_first (
 688         BackendDB *b0
 689 )
 690 {
 691         glueinfo *gi = (glueinfo *) b0->be_private;
 692         int i;
 693
 694         /* If we're starting from scratch, start at the most general */
 695         if (!glueBack) {
 696                 for (i = gi->nodes-1; i >= 0; i--) {
 697                         if (gi->n[i].be->be_entry_open &&
 698                             gi->n[i].be->be_entry_first) {
 699                                 glueBack = gi->n[i].be;
 700                                 break;
 701                         }
 702                 }
 703
 704         }
 705         if (!glueBack || glueBack->be_entry_open (glueBack, glueMode) != 0)
 706                 return NOID;
 707
 708         return glueBack->be_entry_first (glueBack);
 709 }
 710
 711 static ID
 712 glue_tool_entry_next (
 713         BackendDB *b0
 714 )
 715 {
 716         glueinfo *gi = (glueinfo *) b0->be_private;
 717         int i;
 718         ID rc;
 719
 720         if (!glueBack || !glueBack->be_entry_next)
 721                 return NOID;
 722
 723         rc = glueBack->be_entry_next (glueBack);
 724
 725         /* If we ran out of entries in one database, move on to the next */
 726         if (rc == NOID) {
 727                 glueBack->be_entry_close (glueBack);
 728                 for (i=0; i<gi->nodes; i++) {
 729                         if (gi->n[i].be == glueBack)
 730                                 break;
 731                 }
 732                 if (i == 0) {
 733                         glueBack = NULL;
 734                         rc = NOID;
 735                 } else {
 736                         glueBack = gi->n[i-1].be;
 737                         rc = glue_tool_entry_first (b0);
 738                 }
 739         }
 740         return rc;
 741 }
 742
 743 static Entry *
 744 glue_tool_entry_get (
 745         BackendDB *b0,
 746         ID id
 747 )
 748 {
 749         if (!glueBack || !glueBack->be_entry_get)
 750                 return NULL;
 751
 752         return glueBack->be_entry_get (glueBack, id);
 753 }
 754
 755 static ID
 756 glue_tool_entry_put (
 757         BackendDB *b0,
 758         Entry *e,
 759         struct berval *text
 760 )
 761 {
 762         BackendDB *be;
 763         int rc;
 764
 765         be = glue_back_select (b0, e->e_ndn);
 766         if (!be->be_entry_put)
 767                 return NOID;
 768
 769         if (!glueBack) {
 770                 rc = be->be_entry_open (be, glueMode);
 771                 if (rc != 0)
 772                         return NOID;
 773         } else if (be != glueBack) {
 774                 /* If this entry belongs in a different branch than the
 775                  * previous one, close the current database and open the
 776                  * new one.
 777                  */
 778                 glueBack->be_entry_close (glueBack);
 779                 rc = be->be_entry_open (be, glueMode);
 780                 if (rc != 0)
 781                         return NOID;
 782         }
 783         glueBack = be;
 784         return be->be_entry_put (be, e, text);
 785 }
 786
 787 static int
 788 glue_tool_entry_reindex (
 789         BackendDB *b0,
 790         ID id
 791 )
 792 {
 793         if (!glueBack || !glueBack->be_entry_reindex)
 794                 return -1;
 795
 796         return glueBack->be_entry_reindex (glueBack, id);
 797 }
 798
 799 static int
 800 glue_tool_sync (
 801         BackendDB *b0
 802 )
 803 {
 804         glueinfo *gi = (glueinfo *) b0->be_private;
 805         int i;
 806
 807         /* just sync everyone */
 808         for (i = 0; i<gi->nodes; i++)
 809                 if (gi->n[i].be->be_sync)
 810                         gi->n[i].be->be_sync (gi->n[i].be);
 811         return 0;
 812 }
 813
 814 int
 815 glue_sub_init( )
 816 {
 817         int i, j;
 818         int cont = num_subordinates;
 819         BackendDB *b1, *be;
 820         BackendInfo *bi = NULL;
 821         glueinfo *gi;
 822
 823         /* While there are subordinate backends, search backwards through the
 824          * backends and connect them to their superior.
 825          */
 826         for (i = nBackendDB - 1, b1=&backendDB[i]; cont && i>=0; b1--,i--) {
 827                 if (b1->be_flags & SLAP_BFLAG_GLUE_SUBORDINATE) {
 828                         /* The last database cannot be a subordinate of noone */
 829                         if (i == nBackendDB - 1) {
 830                                 b1->be_flags ^= SLAP_BFLAG_GLUE_SUBORDINATE;
 831                         }
 832                         continue;
 833                 }
 834                 gi = NULL;
 835                 for (j = i-1, be=&backendDB[j]; j>=0; be--,j--) {
 836                         if (!(be->be_flags & SLAP_BFLAG_GLUE_SUBORDINATE)) {
 837                                 continue;
 838                         }
 839                         /* We will only link it once */
 840                         if (be->be_flags & SLAP_BFLAG_GLUE_LINKED) {
 841                                 continue;
 842                         }
 843                         if (!dnIsSuffix(&be->be_nsuffix[0], &b1->be_nsuffix[0])) {
 844                                 continue;
 845                         }
 846                         cont--;
 847                         be->be_flags |= SLAP_BFLAG_GLUE_LINKED;
 848                         if (gi == NULL) {
 849                                 /* We create a copy of the superior's be
 850                                  * structure, pointing to all of its original
 851                                  * information. Then we replace elements of
 852                                  * the superior's info with our own. The copy
 853                                  * is used whenever we have operations to pass
 854                                  * down to the real database.
 855                                  */
 856                                 b1->be_flags |= SLAP_BFLAG_GLUE_INSTANCE;
 857                                 gi = (glueinfo *)ch_malloc(sizeof(glueinfo));
 858                                 gi->be = (BackendDB *)ch_malloc(
 859                                         sizeof(BackendDB) + sizeof(BackendInfo));
 860                                 bi = (BackendInfo *)(gi->be+1);
 861                                 *gi->be = *b1;
 862                                 gi->nodes = 0;
 863                                 *bi = *b1->bd_info;
 864                                 bi->bi_open = glue_back_open;
 865                                 bi->bi_close = glue_back_close;
 866                                 bi->bi_db_open = glue_back_db_open;
 867                                 bi->bi_db_close = glue_back_db_close;
 868                                 bi->bi_db_destroy = glue_back_db_destroy;
 869
 870                                 bi->bi_op_bind = glue_back_bind;
 871                                 bi->bi_op_search = glue_back_search;
 872                                 bi->bi_op_compare = glue_back_compare;
 873                                 bi->bi_op_modify = glue_back_modify;
 874                                 bi->bi_op_modrdn = glue_back_modrdn;
 875                                 bi->bi_op_add = glue_back_add;
 876                                 bi->bi_op_delete = glue_back_delete;
 877
 878                                 bi->bi_entry_release_rw = glue_back_release_rw;
 879                                 bi->bi_acl_group = glue_back_group;
 880                                 bi->bi_acl_attribute = glue_back_attribute;
 881                                 bi->bi_chk_referrals = glue_back_referrals;
 882
 883                                 /*
 884                                  * hooks for slap tools
 885                                  */
 886                                 bi->bi_tool_entry_open = glue_tool_entry_open;
 887                                 bi->bi_tool_entry_close = glue_tool_entry_close;
 888                                 bi->bi_tool_entry_first = glue_tool_entry_first;
 889                                 bi->bi_tool_entry_next = glue_tool_entry_next;
 890                                 bi->bi_tool_entry_get = glue_tool_entry_get;
 891                                 bi->bi_tool_entry_put = glue_tool_entry_put;
 892                                 bi->bi_tool_entry_reindex = glue_tool_entry_reindex;
 893                                 bi->bi_tool_sync = glue_tool_sync;
 894                         } else {
 895                                 gi = (glueinfo *)ch_realloc(gi,
 896                                         sizeof(glueinfo) +
 897                                         gi->nodes * sizeof(gluenode));
 898                         }
 899                         gi->n[gi->nodes].be = be;
 900                         dnParent( &be->be_nsuffix[0], &gi->n[gi->nodes].pdn );
 901                         gi->nodes++;
 902                 }
 903                 if (gi) {
 904                         /* One more node for the master */
 905                         gi = (glueinfo *)ch_realloc(gi,
 906                                 sizeof(glueinfo) + gi->nodes * sizeof(gluenode));
 907                         gi->n[gi->nodes].be = gi->be;
 908                         dnParent( &b1->be_nsuffix[0], &gi->n[gi->nodes].pdn );
 909                         gi->nodes++;
 910                         b1->be_private = gi;
 911                         b1->bd_info = bi;
 912                 }
 913         }
 914         /* If there are any unresolved subordinates left, something is wrong */
 915         return cont;
 916 }