]> git.sur5r.net Git - openldap/blob - servers/slapd/cr.c
Merge remote-tracking branch 'origin/mdb.master' into OPENLDAP_REL_ENG_2_5
[openldap] / servers / slapd / cr.c
1 /* cr.c - content rule routines */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 1998-2014 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 #include "portable.h"
18
19 #include <stdio.h>
20
21 #include <ac/ctype.h>
22 #include <ac/string.h>
23 #include <ac/socket.h>
24
25 #include "slap.h"
26
27 struct cindexrec {
28         struct berval   cir_name;
29         ContentRule     *cir_cr;
30 };
31
32 static Avlnode  *cr_index = NULL;
33 static LDAP_STAILQ_HEAD(CRList, ContentRule) cr_list
34         = LDAP_STAILQ_HEAD_INITIALIZER(cr_list);
35
36 static int
37 cr_index_cmp(
38     const void  *v_cir1,
39     const void  *v_cir2 )
40 {
41         const struct cindexrec  *cir1 = v_cir1;
42         const struct cindexrec  *cir2 = v_cir2;
43         int i = cir1->cir_name.bv_len - cir2->cir_name.bv_len;
44         if (i) return i;
45         return strcasecmp( cir1->cir_name.bv_val, cir2->cir_name.bv_val );
46 }
47
48 static int
49 cr_index_name_cmp(
50     const void  *v_name,
51     const void  *v_cir )
52 {
53         const struct berval    *name = v_name;
54         const struct cindexrec *cir  = v_cir;
55         int i = name->bv_len - cir->cir_name.bv_len;
56         if (i) return i;
57         return strncasecmp( name->bv_val, cir->cir_name.bv_val, name->bv_len );
58 }
59
60 ContentRule *
61 cr_find( const char *crname )
62 {
63         struct berval bv;
64
65         bv.bv_val = (char *)crname;
66         bv.bv_len = strlen( crname );
67
68         return( cr_bvfind( &bv ) );
69 }
70
71 ContentRule *
72 cr_bvfind( struct berval *crname )
73 {
74         struct cindexrec        *cir;
75
76         cir = avl_find( cr_index, crname, cr_index_name_cmp );
77
78         if ( cir != NULL ) {
79                 return( cir->cir_cr );
80         }
81
82         return( NULL );
83 }
84
85 static int
86 cr_destroy_one( ContentRule *c )
87 {
88         assert( c != NULL );
89
90         if (c->scr_auxiliaries) ldap_memfree(c->scr_auxiliaries);
91         if (c->scr_required) ldap_memfree(c->scr_required);
92         if (c->scr_allowed) ldap_memfree(c->scr_allowed);
93         if (c->scr_precluded) ldap_memfree(c->scr_precluded);
94         ldap_contentrule_free((LDAPContentRule *)c);
95
96         return 0;
97 }
98
99 void
100 cr_destroy( void )
101 {
102         ContentRule *c;
103
104         avl_free(cr_index, ldap_memfree);
105
106         while( !LDAP_STAILQ_EMPTY(&cr_list) ) {
107                 c = LDAP_STAILQ_FIRST(&cr_list);
108                 LDAP_STAILQ_REMOVE_HEAD(&cr_list, scr_next);
109
110                 cr_destroy_one( c );
111         }
112 }
113
114 static int
115 cr_insert(
116     ContentRule         *scr,
117     const char          **err
118 )
119 {
120         struct cindexrec        *cir;
121         char                    **names;
122
123         assert( scr != NULL );
124
125         if ( scr->scr_oid ) {
126                 cir = (struct cindexrec *)
127                         ch_calloc( 1, sizeof(struct cindexrec) );
128                 cir->cir_name.bv_val = scr->scr_oid;
129                 cir->cir_name.bv_len = strlen( scr->scr_oid );
130                 cir->cir_cr = scr;
131
132                 if ( avl_insert( &cr_index, (caddr_t) cir,
133                                  cr_index_cmp, avl_dup_error ) )
134                 {
135                         *err = scr->scr_oid;
136                         ldap_memfree(cir);
137                         return SLAP_SCHERR_CR_DUP;
138                 }
139
140                 /* FIX: temporal consistency check */
141                 assert( cr_bvfind(&cir->cir_name) != NULL );
142         }
143
144         if ( (names = scr->scr_names) ) {
145                 while ( *names ) {
146                         cir = (struct cindexrec *)
147                                 ch_calloc( 1, sizeof(struct cindexrec) );
148                         cir->cir_name.bv_val = *names;
149                         cir->cir_name.bv_len = strlen( *names );
150                         cir->cir_cr = scr;
151
152                         if ( avl_insert( &cr_index, (caddr_t) cir,
153                                          cr_index_cmp, avl_dup_error ) )
154                         {
155                                 *err = *names;
156                                 ldap_memfree(cir);
157                                 return SLAP_SCHERR_CR_DUP;
158                         }
159
160                         /* FIX: temporal consistency check */
161                         assert( cr_bvfind(&cir->cir_name) != NULL );
162
163                         names++;
164                 }
165         }
166
167         LDAP_STAILQ_INSERT_TAIL(&cr_list, scr, scr_next);
168
169         return 0;
170 }
171
172 static int
173 cr_add_auxiliaries(
174     ContentRule         *scr,
175         int                     *op,
176     const char          **err )
177 {
178         int naux;
179
180         if( scr->scr_oc_oids_aux == NULL ) return 0;
181         
182         for( naux=0; scr->scr_oc_oids_aux[naux]; naux++ ) {
183                 /* count them */ ;
184         }
185
186         scr->scr_auxiliaries = ch_calloc( naux+1, sizeof(ObjectClass *));
187
188         for( naux=0; scr->scr_oc_oids_aux[naux]; naux++ ) {
189                 ObjectClass *soc = scr->scr_auxiliaries[naux]
190                         = oc_find(scr->scr_oc_oids_aux[naux]);
191                 if ( !soc ) {
192                         *err = scr->scr_oc_oids_aux[naux];
193                         return SLAP_SCHERR_CLASS_NOT_FOUND;
194                 }
195
196                 if( soc->soc_flags & SLAP_OC_OPERATIONAL &&
197                         soc != slap_schema.si_oc_extensibleObject )
198                 {
199                         (*op)++;
200                 }
201
202                 if( soc->soc_kind != LDAP_SCHEMA_AUXILIARY ) {
203                         *err = scr->scr_oc_oids_aux[naux];
204                         return SLAP_SCHERR_CR_BAD_AUX;
205                 }
206         }
207
208         scr->scr_auxiliaries[naux] = NULL;
209         return 0;
210 }
211
212 static int
213 cr_create_required(
214     ContentRule         *scr,
215         int                     *op,
216     const char          **err )
217 {
218     char                **attrs = scr->scr_at_oids_must;
219         char            **attrs1;
220         AttributeType   *sat;
221
222         if ( attrs ) {
223                 attrs1 = attrs;
224                 while ( *attrs1 ) {
225                         sat = at_find(*attrs1);
226                         if ( !sat ) {
227                                 *err = *attrs1;
228                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
229                         }
230
231                         if( is_at_operational( sat )) (*op)++;
232
233                         if ( at_find_in_list(sat, scr->scr_required) < 0) {
234                                 if ( at_append_to_list(sat, &scr->scr_required) ) {
235                                         *err = *attrs1;
236                                         return SLAP_SCHERR_OUTOFMEM;
237                                 }
238                         } else {
239                                 *err = *attrs1;
240                                 return SLAP_SCHERR_CR_BAD_AT;
241                         }
242                         attrs1++;
243                 }
244         }
245         return 0;
246 }
247
248 static int
249 cr_create_allowed(
250     ContentRule         *scr,
251         int                     *op,
252     const char          **err )
253 {
254     char                **attrs = scr->scr_at_oids_may;
255         char            **attrs1;
256         AttributeType   *sat;
257
258         if ( attrs ) {
259                 attrs1 = attrs;
260                 while ( *attrs1 ) {
261                         sat = at_find(*attrs1);
262                         if ( !sat ) {
263                                 *err = *attrs1;
264                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
265                         }
266
267                         if( is_at_operational( sat )) (*op)++;
268
269                         if ( at_find_in_list(sat, scr->scr_required) < 0 &&
270                                 at_find_in_list(sat, scr->scr_allowed) < 0 )
271                         {
272                                 if ( at_append_to_list(sat, &scr->scr_allowed) ) {
273                                         *err = *attrs1;
274                                         return SLAP_SCHERR_OUTOFMEM;
275                                 }
276                         } else {
277                                 *err = *attrs1;
278                                 return SLAP_SCHERR_CR_BAD_AT;
279                         }
280                         attrs1++;
281                 }
282         }
283         return 0;
284 }
285
286 static int
287 cr_create_precluded(
288     ContentRule         *scr,
289         int                     *op,
290     const char          **err )
291 {
292     char                **attrs = scr->scr_at_oids_not;
293         char            **attrs1;
294         AttributeType   *sat;
295
296         if ( attrs ) {
297                 attrs1 = attrs;
298                 while ( *attrs1 ) {
299                         sat = at_find(*attrs1);
300                         if ( !sat ) {
301                                 *err = *attrs1;
302                                 return SLAP_SCHERR_ATTR_NOT_FOUND;
303                         }
304
305                         if( is_at_operational( sat )) (*op)++;
306
307                         /* FIXME: should also make sure attribute type is not
308                                 a required attribute of the structural class or
309                                 any auxiliary class */
310                         if ( at_find_in_list(sat, scr->scr_required) < 0 &&
311                                 at_find_in_list(sat, scr->scr_allowed) < 0 &&
312                                 at_find_in_list(sat, scr->scr_precluded) < 0 )
313                         {
314                                 if ( at_append_to_list(sat, &scr->scr_precluded) ) {
315                                         *err = *attrs1;
316                                         return SLAP_SCHERR_OUTOFMEM;
317                                 }
318                         } else {
319                                 *err = *attrs1;
320                                 return SLAP_SCHERR_CR_BAD_AT;
321                         }
322                         attrs1++;
323                 }
324         }
325         return 0;
326 }
327
328 int
329 cr_add(
330     LDAPContentRule     *cr,
331         int user,
332         ContentRule **rscr,
333     const char          **err
334 )
335 {
336         ContentRule     *scr;
337         int             code;
338         int             op = 0;
339         char    *oidm = NULL;
340
341         if ( cr->cr_names != NULL ) {
342                 int i;
343
344                 for( i=0; cr->cr_names[i]; i++ ) {
345                         if( !slap_valid_descr( cr->cr_names[i] ) ) {
346                                 return SLAP_SCHERR_BAD_DESCR;
347                         }
348                 }
349         }
350
351         if ( !OID_LEADCHAR( cr->cr_oid[0] )) {
352                 /* Expand OID macros */
353                 char *oid = oidm_find( cr->cr_oid );
354                 if ( !oid ) {
355                         *err = cr->cr_oid;
356                         return SLAP_SCHERR_OIDM;
357                 }
358                 if ( oid != cr->cr_oid ) {
359                         oidm = cr->cr_oid;
360                         cr->cr_oid = oid;
361                 }
362         }
363
364         scr = (ContentRule *) ch_calloc( 1, sizeof(ContentRule) );
365         AC_MEMCPY( &scr->scr_crule, cr, sizeof(LDAPContentRule) );
366
367         scr->scr_oidmacro = oidm;
368         scr->scr_sclass = oc_find(cr->cr_oid);
369         if ( !scr->scr_sclass ) {
370                 *err = cr->cr_oid;
371                 code = SLAP_SCHERR_CLASS_NOT_FOUND;
372                 goto fail;
373         }
374
375         /* check object class usage */
376         if( scr->scr_sclass->soc_kind != LDAP_SCHEMA_STRUCTURAL )
377         {
378                 *err = cr->cr_oid;
379                 code = SLAP_SCHERR_CR_BAD_STRUCT;
380                 goto fail;
381         }
382
383         if( scr->scr_sclass->soc_flags & SLAP_OC_OPERATIONAL ) op++;
384
385         code = cr_add_auxiliaries( scr, &op, err );
386         if ( code != 0 ) goto fail;
387
388         code = cr_create_required( scr, &op, err );
389         if ( code != 0 ) goto fail;
390
391         code = cr_create_allowed( scr, &op, err );
392         if ( code != 0 ) goto fail;
393
394         code = cr_create_precluded( scr, &op, err );
395         if ( code != 0 ) goto fail;
396
397         if( user && op ) {
398                 code = SLAP_SCHERR_CR_BAD_AUX;
399                 goto fail;
400         }
401
402         code = cr_insert(scr,err);
403         if ( code == 0 && rscr )
404                 *rscr = scr;
405         return code;
406 fail:
407         ch_free( scr );
408         return code;
409 }
410
411 void
412 cr_unparse( BerVarray *res, ContentRule *start, ContentRule *end, int sys )
413 {
414         ContentRule *cr;
415         int i, num;
416         struct berval bv, *bva = NULL, idx;
417         char ibuf[32];
418
419         if ( !start )
420                 start = LDAP_STAILQ_FIRST( &cr_list );
421
422         /* count the result size */
423         i = 0;
424         for ( cr=start; cr; cr=LDAP_STAILQ_NEXT(cr, scr_next)) {
425                 if ( sys && !(cr->scr_flags & SLAP_CR_HARDCODE)) continue;
426                 i++;
427                 if ( cr == end ) break;
428         }
429         if (!i) return;
430
431         num = i;
432         bva = ch_malloc( (num+1) * sizeof(struct berval) );
433         BER_BVZERO( bva );
434         idx.bv_val = ibuf;
435         if ( sys ) {
436                 idx.bv_len = 0;
437                 ibuf[0] = '\0';
438         }
439         i = 0;
440         for ( cr=start; cr; cr=LDAP_STAILQ_NEXT(cr, scr_next)) {
441                 LDAPContentRule lcr, *lcrp;
442                 if ( sys && !(cr->scr_flags & SLAP_CR_HARDCODE)) continue;
443                 if ( cr->scr_oidmacro ) {
444                         lcr = cr->scr_crule;
445                         lcr.cr_oid = cr->scr_oidmacro;
446                         lcrp = &lcr;
447                 } else {
448                         lcrp = &cr->scr_crule;
449                 }
450                 if ( ldap_contentrule2bv( lcrp, &bv ) == NULL ) {
451                         ber_bvarray_free( bva );
452                 }
453                 if ( !sys ) {
454                         idx.bv_len = sprintf(idx.bv_val, "{%d}", i);
455                 }
456                 bva[i].bv_len = idx.bv_len + bv.bv_len;
457                 bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 );
458                 strcpy( bva[i].bv_val, ibuf );
459                 strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val );
460                 i++;
461                 bva[i].bv_val = NULL;
462                 ldap_memfree( bv.bv_val );
463                 if ( cr == end ) break;
464         }
465         *res = bva;
466 }
467
468 int
469 cr_schema_info( Entry *e )
470 {
471         AttributeDescription *ad_ditContentRules
472                 = slap_schema.si_ad_ditContentRules;
473         ContentRule     *cr;
474
475         struct berval   val;
476         struct berval   nval;
477
478         LDAP_STAILQ_FOREACH(cr, &cr_list, scr_next) {
479                 if ( ldap_contentrule2bv( &cr->scr_crule, &val ) == NULL ) {
480                         return -1;
481                 }
482
483 #if 0
484                 if( cr->scr_flags & SLAP_CR_HIDE ) continue;
485 #endif
486 #if 0
487                 Debug( LDAP_DEBUG_TRACE, "Merging cr [%ld] %s\n",
488                (long) val.bv_len, val.bv_val, 0 );
489 #endif
490
491                 nval.bv_val = cr->scr_oid;
492                 nval.bv_len = strlen(cr->scr_oid);
493
494                 if( attr_merge_one( e, ad_ditContentRules, &val, &nval ) )
495                 {
496                         return -1;
497                 }
498                 ldap_memfree( val.bv_val );
499         }
500         return 0;
501 }