]> git.sur5r.net Git - openldap/blob - servers/slapd/back-ldbm/attr.c
New dn2id format with base/one/subtree indices (ldbm/bdb2)
[openldap] / servers / slapd / back-ldbm / attr.c
1 /* attr.c - backend routines for dealing with attributes */
2 /*
3  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
5  */
6
7 #include "portable.h"
8
9 #include <stdio.h>
10
11 #include <ac/socket.h>
12 #include <ac/string.h>
13
14 #include "slap.h"
15 #include "back-ldbm.h"
16
17 static int
18 ainfo_type_cmp(
19     char                *type,
20     AttrInfo    *a
21 )
22 {
23         return( strcasecmp( type, a->ai_type ) );
24 }
25
26 static int
27 ainfo_cmp(
28     AttrInfo    *a,
29     AttrInfo    *b
30 )
31 {
32         return( strcasecmp( a->ai_type, b->ai_type ) );
33 }
34
35 /*
36  * Called when a duplicate "index" line is encountered.
37  *
38  * returns 1 => original from init code, indexmask updated
39  *         2 => original not from init code, warn the user
40  */
41
42 static int
43 ainfo_dup(
44     AttrInfo    *a,
45     AttrInfo    *b
46 )
47 {
48         /*
49          * if the duplicate definition is because we initialized the attr,
50          * just add what came from the config file. otherwise, complain.
51          */
52         if ( a->ai_indexmask & INDEX_FROMINIT ) {
53                 a->ai_indexmask |= b->ai_indexmask;
54
55                 return( 1 );
56         }
57
58         return( 2 );
59 }
60
61 void
62 attr_masks(
63     struct ldbminfo     *li,
64     char                *type,
65     int                 *indexmask,
66     int                 *syntaxmask
67 )
68 {
69         AttrInfo        *a;
70
71         *indexmask = 0;
72         *syntaxmask = 0;
73         if ( (a = (AttrInfo *) avl_find( li->li_attrs, type,
74             (AVL_CMP) ainfo_type_cmp )) == NULL ) {
75                 if ( (a = (AttrInfo *) avl_find( li->li_attrs, "default",
76                     (AVL_CMP) ainfo_type_cmp )) == NULL ) {
77                         return;
78                 }
79         }
80         *indexmask = a->ai_indexmask;
81         if ( strcasecmp( a->ai_type, "default" ) == 0 ) {
82                 *syntaxmask = attr_syntax( type );
83         } else {
84                 *syntaxmask = a->ai_syntaxmask;
85         }
86 }
87
88 void
89 attr_index_config(
90     struct ldbminfo     *li,
91     char                *fname,
92     int                 lineno,
93     int                 argc,
94     char                **argv,
95     int                 init
96 )
97 {
98         int             i, j;
99         char            **attrs, **indexes;
100         AttrInfo        *a;
101
102         attrs = str2charray( argv[0], "," );
103         if ( argc > 1 ) {
104                 indexes = str2charray( argv[1], "," );
105         }
106         for ( i = 0; attrs[i] != NULL; i++ ) {
107                 a = (AttrInfo *) ch_malloc( sizeof(AttrInfo) );
108                 a->ai_type = ch_strdup( attrs[i] );
109                 a->ai_syntaxmask = attr_syntax( a->ai_type );
110                 if ( argc == 1 ) {
111                         a->ai_indexmask = (INDEX_PRESENCE | INDEX_EQUALITY |
112                             INDEX_APPROX | INDEX_SUB);
113                 } else {
114                         a->ai_indexmask = 0;
115                         for ( j = 0; indexes[j] != NULL; j++ ) {
116                                 if ( strncasecmp( indexes[j], "pres", 4 )
117                                     == 0 ) {
118                                         a->ai_indexmask |= INDEX_PRESENCE;
119                                 } else if ( strncasecmp( indexes[j], "eq", 2 )
120                                     == 0 ) {
121                                         a->ai_indexmask |= INDEX_EQUALITY;
122                                 } else if ( strncasecmp( indexes[j], "approx",
123                                     6 ) == 0 ) {
124                                         a->ai_indexmask |= INDEX_APPROX;
125                                 } else if ( strncasecmp( indexes[j], "sub", 3 )
126                                     == 0 ) {
127                                         a->ai_indexmask |= INDEX_SUB;
128                                 } else if ( strncasecmp( indexes[j], "none", 4 )
129                                     == 0 ) {
130                                         if ( a->ai_indexmask != 0 ) {
131                                                 fprintf( stderr,
132 "%s: line %d: index type \"none\" cannot be combined with other types\n",
133                                                     fname, lineno );
134                                         }
135                                         a->ai_indexmask = 0;
136                                 } else {
137                                         fprintf( stderr,
138                         "%s: line %d: unknown index type \"%s\" (ignored)\n",
139                                             fname, lineno, indexes[j] );
140                                         fprintf( stderr,
141         "valid index types are \"pres\", \"eq\", \"approx\", or \"sub\"\n" );
142                                 }
143                         }
144                 }
145                 if ( init ) {
146                         a->ai_indexmask |= INDEX_FROMINIT;
147                 }
148
149                 switch (avl_insert( &li->li_attrs, (caddr_t) a,
150                         (AVL_CMP) ainfo_cmp, (AVL_DUP) ainfo_dup ))
151                 {
152                 case 1:         /* duplicate - updating init version */
153                         free( a->ai_type );
154                         free( (char *) a );
155                         break;
156
157                 case 2:         /* user duplicate - ignore and warn */
158                         fprintf( stderr,
159     "%s: line %d: duplicate index definition for attr \"%s\" (ignored)\n",
160                             fname, lineno, a->ai_type );
161                         free( a->ai_type );
162                         free( (char *) a );
163                         break;
164
165                 default:;       /* inserted ok */
166                         /* FALL */
167                 }
168         }
169         charray_free( attrs );
170         if ( argc > 1 )
171                 charray_free( indexes );
172 }
173
174
175 #ifdef SLAP_CLEANUP
176
177 static void
178 ainfo_free( void *attr )
179 {
180         AttrInfo *ai = attr;
181         free( ai->ai_type );
182         free( ai );
183 }
184
185 void
186 attr_index_destroy( Avlnode *tree )
187 {
188         avl_free( tree, ainfo_free );
189 }
190
191 #endif /* SLAP_CLEANUP */