]> git.sur5r.net Git - openldap/blob - servers/slapd/backglue.c
669f8525f1c92a219b32476b8bf7453e3a86bc11
[openldap] / servers / slapd / backglue.c
1 /* backglue.c - backend glue routines */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 2001-2004 The OpenLDAP Foundation.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted only as authorized by the OpenLDAP
10  * Public License.
11  *
12  * A copy of this license is available in the file LICENSE in the
13  * top-level directory of the distribution or, alternatively, at
14  * <http://www.OpenLDAP.org/license.html>.
15  */
16
17 /*
18  * Functions to glue a bunch of other backends into a single tree.
19  * All of the glued backends must share a common suffix. E.g., you
20  * can glue o=foo and ou=bar,o=foo but you can't glue o=foo and o=bar.
21  *
22  * This uses the backend structures and routines extensively, but is
23  * not an actual backend of its own. To use it you must add a "subordinate"
24  * keyword to the configuration of other backends. Subordinates will
25  * automatically be connected to their parent backend.
26  *
27  * The purpose of these functions is to allow you to split a single database
28  * into pieces (for load balancing purposes, whatever) but still be able
29  * to treat it as a single database after it's been split. As such, each
30  * of the glued backends should have identical rootdn and rootpw.
31  *
32  * If you need more elaborate configuration, you probably should be using
33  * back-meta instead.
34  *  -- Howard Chu
35  */
36
37 #include "portable.h"
38
39 #include <stdio.h>
40
41 #include <ac/string.h>
42 #include <ac/socket.h>
43
44 #define SLAPD_TOOLS
45 #include "slap.h"
46
47 typedef struct gluenode {
48         BackendDB *be;
49         struct berval pdn;
50 } gluenode;
51
52 typedef struct glueinfo {
53         BackendInfo bi;
54         BackendDB bd;
55         int nodes;
56         gluenode n[1];
57 } glueinfo;
58
59 static int glueMode;
60 static BackendDB *glueBack;
61
62 static slap_response glue_back_response;
63
64 /* Just like select_backend, but only for our backends */
65 static BackendDB *
66 glue_back_select (
67         BackendDB *be,
68         const char *dn
69 )
70 {
71         glueinfo *gi = (glueinfo *) be->bd_info;
72         struct berval bv;
73         int i;
74
75         bv.bv_len = strlen(dn);
76         bv.bv_val = (char *) dn;
77
78         for (i = 0; i<gi->nodes; i++) {
79                 assert( gi->n[i].be->be_nsuffix );
80
81                 if (dnIsSuffix(&bv, &gi->n[i].be->be_nsuffix[0])) {
82                         return gi->n[i].be;
83                 }
84         }
85         return NULL;
86 }
87
88 /* This function will only be called in tool mode */
89 static int
90 glue_back_open (
91         BackendInfo *bi
92 )
93 {
94         int rc = 0;
95         static int glueOpened = 0;
96
97         if (glueOpened) return 0;
98
99         glueOpened = 1;
100
101         /* If we were invoked in tool mode, open all the underlying backends */
102         if (slapMode & SLAP_TOOL_MODE) {
103                 rc = backend_startup (NULL);
104         } /* other case is impossible */
105         return rc;
106 }
107
108 /* This function will only be called in tool mode */
109 static int
110 glue_back_close (
111         BackendInfo *bi
112 )
113 {
114         static int glueClosed = 0;
115         int rc = 0;
116
117         if (glueClosed) return 0;
118
119         glueClosed = 1;
120
121         if (slapMode & SLAP_TOOL_MODE) {
122                 rc = backend_shutdown (NULL);
123         }
124         return rc;
125 }
126
127 static int
128 glue_back_db_open (
129         BackendDB *be
130 )
131 {
132         glueinfo *gi = (glueinfo *) be->bd_info;
133         static int glueOpened = 0;
134         int rc = 0;
135
136         if (glueOpened) return 0;
137
138         glueOpened = 1;
139
140         gi->bd.be_acl = be->be_acl;
141
142         if (gi->bd.bd_info->bi_db_open)
143                 rc = gi->bd.bd_info->bi_db_open(&gi->bd);
144
145         return rc;
146 }
147
148 static int
149 glue_back_db_close (
150         BackendDB *be
151 )
152 {
153         glueinfo *gi = (glueinfo *) be->bd_info;
154         static int glueClosed = 0;
155
156         if (glueClosed) return 0;
157
158         glueClosed = 1;
159
160         /* Close the master */
161         if (gi->bd.bd_info->bi_db_close)
162                 gi->bd.bd_info->bi_db_close( &gi->bd );
163
164         return 0;
165 }
166
167 static int
168 glue_back_db_destroy (
169         BackendDB *be
170 )
171 {
172         glueinfo *gi = (glueinfo *) be->bd_info;
173
174         if (gi->bd.bd_info->bi_db_destroy)
175                 gi->bd.bd_info->bi_db_destroy( &gi->bd );
176         free (gi);
177         return 0;
178 }
179
180 typedef struct glue_state {
181         int err;
182         int slimit;
183         int matchlen;
184         char *matched;
185         int nrefs;
186         BerVarray refs;
187 } glue_state;
188
189 static int
190 glue_back_response ( Operation *op, SlapReply *rs )
191 {
192         glue_state *gs = op->o_callback->sc_private;
193
194         switch(rs->sr_type) {
195         case REP_SEARCH:
196                 if ( gs->slimit && rs->sr_nentries >= gs->slimit ) {
197                         rs->sr_err = gs->err = LDAP_SIZELIMIT_EXCEEDED;
198                         return -1;
199                 }
200                 /* fallthru */
201         case REP_SEARCHREF:
202                 return SLAP_CB_CONTINUE;
203
204         default:
205                 if (rs->sr_err == LDAP_SUCCESS ||
206                         rs->sr_err == LDAP_SIZELIMIT_EXCEEDED ||
207                         rs->sr_err == LDAP_TIMELIMIT_EXCEEDED ||
208                         rs->sr_err == LDAP_ADMINLIMIT_EXCEEDED ||
209                                 gs->err != LDAP_SUCCESS)
210                         gs->err = rs->sr_err;
211                 if (gs->err == LDAP_SUCCESS && gs->matched) {
212                         ch_free (gs->matched);
213                         gs->matched = NULL;
214                         gs->matchlen = 0;
215                 }
216                 if (gs->err != LDAP_SUCCESS && rs->sr_matched) {
217                         int len;
218                         len = strlen (rs->sr_matched);
219                         if (len > gs->matchlen) {
220                                 if (gs->matched)
221                                         ch_free (gs->matched);
222                                 gs->matched = ch_strdup (rs->sr_matched);
223                                 gs->matchlen = len;
224                         }
225                 }
226                 if (rs->sr_ref) {
227                         int i, j, k;
228                         BerVarray new;
229
230                         for (i=0; rs->sr_ref[i].bv_val; i++);
231
232                         j = gs->nrefs;
233                         if (!j) {
234                                 new = ch_malloc ((i+1)*sizeof(struct berval));
235                         } else {
236                                 new = ch_realloc(gs->refs,
237                                         (j+i+1)*sizeof(struct berval));
238                         }
239                         for (k=0; k<i; j++,k++) {
240                                 ber_dupbv( &new[j], &rs->sr_ref[k] );
241                         }
242                         new[j].bv_val = NULL;
243                         gs->nrefs = j;
244                         gs->refs = new;
245                 }
246         }
247         return 0;
248 }
249
250 static int
251 glue_back_search ( Operation *op, SlapReply *rs )
252 {
253         BackendDB *b0 = op->o_bd;
254         glueinfo *gi = (glueinfo *) b0->bd_info;
255         int i;
256         long stoptime = 0;
257         glue_state gs = {0, 0, 0, NULL, 0, NULL};
258         slap_callback cb = { NULL, glue_back_response, NULL, NULL };
259         int scope0, slimit0, tlimit0;
260         struct berval dn, ndn;
261
262         cb.sc_private = &gs;
263
264         cb.sc_next = op->o_callback;
265
266         if (op->ors_tlimit) {
267                 stoptime = slap_get_time () + op->ors_tlimit;
268         }
269
270         switch (op->ors_scope) {
271         case LDAP_SCOPE_BASE:
272                 op->o_bd = glue_back_select (b0, op->o_req_ndn.bv_val);
273
274                 if (op->o_bd && op->o_bd->be_search) {
275                         rs->sr_err = op->o_bd->be_search( op, rs );
276                 } else {
277                         send_ldap_error(op, rs, LDAP_UNWILLING_TO_PERFORM,
278                                       "No search target found");
279                 }
280                 return rs->sr_err;
281
282         case LDAP_SCOPE_ONELEVEL:
283         case LDAP_SCOPE_SUBTREE:
284         case LDAP_SCOPE_SUBORDINATE: /* FIXME */
285                 op->o_callback = &cb;
286                 rs->sr_err = gs.err = LDAP_UNWILLING_TO_PERFORM;
287                 scope0 = op->ors_scope;
288                 slimit0 = gs.slimit = op->ors_slimit;
289                 tlimit0 = op->ors_tlimit;
290                 dn = op->o_req_dn;
291                 ndn = op->o_req_ndn;
292
293                 /*
294                  * Execute in reverse order, most general first 
295                  */
296                 for (i = gi->nodes-1; i >= 0; i--) {
297                         if (!gi->n[i].be || !gi->n[i].be->be_search)
298                                 continue;
299                         if (tlimit0) {
300                                 op->ors_tlimit = stoptime - slap_get_time ();
301                                 if (op->ors_tlimit <= 0) {
302                                         rs->sr_err = gs.err = LDAP_TIMELIMIT_EXCEEDED;
303                                         break;
304                                 }
305                         }
306                         if (slimit0) {
307                                 op->ors_slimit = slimit0 - rs->sr_nentries;
308                                 if (op->ors_slimit < 0) {
309                                         rs->sr_err = gs.err = LDAP_SIZELIMIT_EXCEEDED;
310                                         break;
311                                 }
312                         }
313                         rs->sr_err = 0;
314                         /*
315                          * check for abandon 
316                          */
317                         if (op->o_abandon) {
318                                 goto done;
319                         }
320                         op->o_bd = gi->n[i].be;
321
322                         assert( op->o_bd->be_suffix );
323                         assert( op->o_bd->be_nsuffix );
324                         
325                         if (scope0 == LDAP_SCOPE_ONELEVEL && 
326                                 dn_match(&gi->n[i].pdn, &ndn))
327                         {
328                                 op->ors_scope = LDAP_SCOPE_BASE;
329                                 op->o_req_dn = op->o_bd->be_suffix[0];
330                                 op->o_req_ndn = op->o_bd->be_nsuffix[0];
331                                 rs->sr_err = op->o_bd->be_search(op, rs);
332
333                         } else if (scope0 == LDAP_SCOPE_SUBTREE &&
334                                 dnIsSuffix(&op->o_bd->be_nsuffix[0], &ndn))
335                         {
336                                 op->o_req_dn = op->o_bd->be_suffix[0];
337                                 op->o_req_ndn = op->o_bd->be_nsuffix[0];
338                                 rs->sr_err = op->o_bd->be_search( op, rs );
339
340                         } else if (dnIsSuffix(&ndn, &op->o_bd->be_nsuffix[0])) {
341                                 rs->sr_err = op->o_bd->be_search( op, rs );
342                         }
343
344                         switch ( gs.err ) {
345
346                         /*
347                          * Add errors that should result in dropping
348                          * the search
349                          */
350                         case LDAP_SIZELIMIT_EXCEEDED:
351                         case LDAP_TIMELIMIT_EXCEEDED:
352                         case LDAP_ADMINLIMIT_EXCEEDED:
353                                 goto end_of_loop;
354                         
355                         default:
356                                 break;
357                         }
358                 }
359 end_of_loop:;
360                 op->ors_scope = scope0;
361                 op->ors_slimit = slimit0;
362                 op->ors_tlimit = tlimit0;
363                 op->o_req_dn = dn;
364                 op->o_req_ndn = ndn;
365
366                 break;
367         }
368         op->o_callback = cb.sc_next;
369         rs->sr_err = gs.err;
370         rs->sr_matched = gs.matched;
371         rs->sr_ref = gs.refs;
372
373         send_ldap_result( op, rs );
374
375 done:
376         op->o_bd = b0;
377         if (gs.matched)
378                 free (gs.matched);
379         if (gs.refs)
380                 ber_bvarray_free(gs.refs);
381         return rs->sr_err;
382 }
383
384
385 static int
386 glue_tool_entry_open (
387         BackendDB *b0,
388         int mode
389 )
390 {
391         /* We don't know which backend to talk to yet, so just
392          * remember the mode and move on...
393          */
394
395         glueMode = mode;
396         glueBack = NULL;
397
398         return 0;
399 }
400
401 static int
402 glue_tool_entry_close (
403         BackendDB *b0
404 )
405 {
406         int rc = 0;
407
408         if (glueBack) {
409                 if (!glueBack->be_entry_close)
410                         return 0;
411                 rc = glueBack->be_entry_close (glueBack);
412         }
413         return rc;
414 }
415
416 static ID
417 glue_tool_entry_first (
418         BackendDB *b0
419 )
420 {
421         glueinfo *gi = (glueinfo *) b0->bd_info;
422         int i;
423
424         /* If we're starting from scratch, start at the most general */
425         if (!glueBack) {
426                 for (i = gi->nodes-1; i >= 0; i--) {
427                         if (gi->n[i].be->be_entry_open &&
428                             gi->n[i].be->be_entry_first) {
429                                 glueBack = gi->n[i].be;
430                                 break;
431                         }
432                 }
433
434         }
435         if (!glueBack || !glueBack->be_entry_open || !glueBack->be_entry_first ||
436                 glueBack->be_entry_open (glueBack, glueMode) != 0)
437                 return NOID;
438
439         return glueBack->be_entry_first (glueBack);
440 }
441
442 static ID
443 glue_tool_entry_next (
444         BackendDB *b0
445 )
446 {
447         glueinfo *gi = (glueinfo *) b0->bd_info;
448         int i;
449         ID rc;
450
451         if (!glueBack || !glueBack->be_entry_next)
452                 return NOID;
453
454         rc = glueBack->be_entry_next (glueBack);
455
456         /* If we ran out of entries in one database, move on to the next */
457         while (rc == NOID) {
458                 if ( glueBack && glueBack->be_entry_close )
459                         glueBack->be_entry_close (glueBack);
460                 for (i=0; i<gi->nodes; i++) {
461                         if (gi->n[i].be == glueBack)
462                                 break;
463                 }
464                 if (i == 0) {
465                         glueBack = NULL;
466                         break;
467                 } else {
468                         glueBack = gi->n[i-1].be;
469                         rc = glue_tool_entry_first (b0);
470                 }
471         }
472         return rc;
473 }
474
475 static Entry *
476 glue_tool_entry_get (
477         BackendDB *b0,
478         ID id
479 )
480 {
481         if (!glueBack || !glueBack->be_entry_get)
482                 return NULL;
483
484         return glueBack->be_entry_get (glueBack, id);
485 }
486
487 static ID
488 glue_tool_entry_put (
489         BackendDB *b0,
490         Entry *e,
491         struct berval *text
492 )
493 {
494         BackendDB *be;
495         int rc;
496
497         be = glue_back_select (b0, e->e_ndn);
498         if (!be->be_entry_put)
499                 return NOID;
500
501         if (!glueBack) {
502                 rc = be->be_entry_open (be, glueMode);
503                 if (rc != 0)
504                         return NOID;
505         } else if (be != glueBack) {
506                 /* If this entry belongs in a different branch than the
507                  * previous one, close the current database and open the
508                  * new one.
509                  */
510                 glueBack->be_entry_close (glueBack);
511                 rc = be->be_entry_open (be, glueMode);
512                 if (rc != 0)
513                         return NOID;
514         }
515         glueBack = be;
516         return be->be_entry_put (be, e, text);
517 }
518
519 static int
520 glue_tool_entry_reindex (
521         BackendDB *b0,
522         ID id
523 )
524 {
525         if (!glueBack || !glueBack->be_entry_reindex)
526                 return -1;
527
528         return glueBack->be_entry_reindex (glueBack, id);
529 }
530
531 static int
532 glue_tool_sync (
533         BackendDB *b0
534 )
535 {
536         glueinfo *gi = (glueinfo *) b0->bd_info;
537         int i;
538
539         /* just sync everyone */
540         for (i = 0; i<gi->nodes; i++)
541                 if (gi->n[i].be->be_sync)
542                         gi->n[i].be->be_sync (gi->n[i].be);
543         return 0;
544 }
545
546 int
547 glue_sub_init( )
548 {
549         int i, j;
550         int cont = num_subordinates;
551         BackendDB *b1, *be;
552         BackendInfo *bi = NULL;
553         glueinfo *gi;
554
555         /* While there are subordinate backends, search backwards through the
556          * backends and connect them to their superior.
557          */
558         for (i = nBackendDB - 1, b1=&backendDB[i]; cont && i>=0; b1--,i--) {
559                 if (SLAP_GLUE_SUBORDINATE ( b1 ) ) {
560                         /* The last database cannot be a subordinate of noone */
561                         if (i == nBackendDB - 1) {
562                                 b1->be_flags ^= SLAP_BFLAG_GLUE_SUBORDINATE;
563                         }
564                         continue;
565                 }
566                 gi = NULL;
567                 for (j = i-1, be=&backendDB[j]; j>=0; be--,j--) {
568                         if ( ! SLAP_GLUE_SUBORDINATE( be ) ) {
569                                 continue;
570                         }
571                         /* We will only link it once */
572                         if ( SLAP_GLUE_LINKED( be ) ) {
573                                 continue;
574                         }
575                         assert( be->be_nsuffix );
576                         assert( b1->be_nsuffix );
577                         if (!dnIsSuffix(&be->be_nsuffix[0], &b1->be_nsuffix[0])) {
578                                 continue;
579                         }
580                         cont--;
581                         be->be_flags |= SLAP_BFLAG_GLUE_LINKED;
582                         if (gi == NULL) {
583                                 /* We create a copy of the superior's be
584                                  * structure, pointing to all of its original
585                                  * information. Then we replace elements of
586                                  * the superior's info with our own. The copy
587                                  * is used whenever we have operations to pass
588                                  * down to the real database.
589                                  */
590                                 b1->be_flags |= SLAP_BFLAG_GLUE_INSTANCE;
591                                 gi = (glueinfo *)ch_malloc(sizeof(glueinfo));
592                                 gi->nodes = 0;
593                                 gi->bd = *b1;
594                                 gi->bi = *b1->bd_info;
595                                 bi = (BackendInfo *)gi;
596                                 bi->bi_open = glue_back_open;
597                                 bi->bi_close = glue_back_close;
598                                 bi->bi_db_open = glue_back_db_open;
599                                 bi->bi_db_close = glue_back_db_close;
600                                 bi->bi_db_destroy = glue_back_db_destroy;
601
602                                 bi->bi_op_search = glue_back_search;
603
604                                 /*
605                                  * hooks for slap tools
606                                  */
607                                 bi->bi_tool_entry_open = glue_tool_entry_open;
608                                 bi->bi_tool_entry_close = glue_tool_entry_close;
609                                 bi->bi_tool_entry_first = glue_tool_entry_first;
610                                 bi->bi_tool_entry_next = glue_tool_entry_next;
611                                 bi->bi_tool_entry_get = glue_tool_entry_get;
612                                 bi->bi_tool_entry_put = glue_tool_entry_put;
613                                 bi->bi_tool_entry_reindex = glue_tool_entry_reindex;
614                                 bi->bi_tool_sync = glue_tool_sync;
615                                 /* FIXME : will support later */
616                                 bi->bi_tool_dn2id_get = 0;
617                                 bi->bi_tool_id2entry_get = 0;
618                                 bi->bi_tool_entry_modify = 0;
619                         } else {
620                                 gi = (glueinfo *)ch_realloc(gi,
621                                         sizeof(glueinfo) +
622                                         gi->nodes * sizeof(gluenode));
623                         }
624                         gi->n[gi->nodes].be = be;
625                         dnParent( &be->be_nsuffix[0], &gi->n[gi->nodes].pdn ); 
626                         gi->nodes++;
627                 }
628                 if (gi) {
629                         /* One more node for the master */
630                         gi = (glueinfo *)ch_realloc(gi,
631                                 sizeof(glueinfo) + gi->nodes * sizeof(gluenode));
632                         gi->n[gi->nodes].be = &gi->bd;
633                         dnParent( &b1->be_nsuffix[0], &gi->n[gi->nodes].pdn );
634                         gi->nodes++;
635                         b1->bd_info = (BackendInfo *)gi;
636                 }
637         }
638         /* If there are any unresolved subordinates left, something is wrong */
639         return cont;
640 }