]> git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/attribute.c
Fixup bdb_entry_release now that entry_decode uses two memory blocks
[openldap] / servers / slapd / back-meta / attribute.c
1 /*
2  * Copyright 1998-2001 The OpenLDAP Foundation, All Rights Reserved.
3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
4  *
5  * Copyright 2001, Pierangelo Masarati, All rights reserved. <ando@sys-net.it>
6  *
7  * This work has been developed to fulfill the requirements
8  * of SysNet s.n.c. <http:www.sys-net.it> and it has been donated
9  * to the OpenLDAP Foundation in the hope that it may be useful
10  * to the Open Source community, but WITHOUT ANY WARRANTY.
11  *
12  * Permission is granted to anyone to use this software for any purpose
13  * on any computer system, and to alter it and redistribute it, subject
14  * to the following restrictions:
15  * 
16  * 1. The author and SysNet s.n.c. are not responsible for the consequences
17  *    of use of this software, no matter how awful, even if they arise from 
18  *    flaws in it.
19  *
20  * 2. The origin of this software must not be misrepresented, either by
21  *    explicit claim or by omission.  Since few users ever read sources,
22  *    credits should appear in the documentation.
23  *
24  * 3. Altered versions must be plainly marked as such, and must not be
25  *    misrepresented as being the original software.  Since few users
26  *    ever read sources, credits should appear in the documentation.
27  *    SysNet s.n.c. cannot be responsible for the consequences of the
28  *    alterations.
29  *
30  * 4. This notice may not be removed or altered.
31  * 
32  * 
33  * This software is based on the backend back-ldap, implemented
34  * by Howard Chu <hyc@highlandsun.com>, and modified by Mark Valence
35  * <kurash@sassafras.com>, Pierangelo Masarati <ando@sys-net.it> and other
36  * contributors. The contribution of the original software to the present
37  * implementation is acknowledged in this copyright statement.
38  * 
39  * A special acknowledgement goes to Howard for the overall architecture
40  * (and for borrowing large pieces of code), and to Mark, who implemented
41  * from scratch the attribute/objectclass mapping.
42  * 
43  * The original copyright statement follows.
44  *
45  * Copyright 1999, Howard Chu, All rights reserved. <hyc@highlandsun.com>
46  *
47  * Permission is granted to anyone to use this software for any purpose
48  * on any computer system, and to alter it and redistribute it, subject
49  * to the following restrictions:
50  *
51  * 1. The author is not responsible for the consequences of use of this
52  *    software, no matter how awful, even if they arise from flaws in it.
53  *
54  * 2. The origin of this software must not be misrepresented, either by
55  *    explicit claim or by omission.  Since few users ever read sources,
56  *    credits should appear in the documentation.
57  *
58  * 3. Altered versions must be plainly marked as such, and must not be
59  *    misrepresented as being the original software.  Since few users
60  *    ever read sources, credits should appear in the
61  *    documentation.
62  *
63  * 4. This notice may not be removed or altered.
64  *
65  */
66
67 #include "portable.h"
68
69 #include <stdio.h>
70
71 #include <ac/socket.h>
72 #include <ac/string.h>
73
74 #include "slap.h"
75 #include "../back-ldap/back-ldap.h"
76 #include "back-meta.h"
77
78
79 /* return 0 IFF we can retrieve the attributes
80  * of entry with e_ndn
81  */
82
83 /*
84  * FIXME: I never testd this function; I know it compiles ... :)
85  */
86 int
87 meta_back_attribute(
88                 Backend                 *be,
89                 Connection              *conn,
90                 Operation               *op,
91                 Entry                   *target,
92                 const char              *e_ndn,
93                 AttributeDescription    *entry_at,
94                 struct berval           ***vals
95 )
96 {
97         struct metainfo *li = ( struct metainfo * )be->be_private;    
98         int rc = 1, i, j, count, is_oc, candidate;
99         Attribute *attr;
100         struct berval **abv, **v;
101         char **vs, *mapped;
102         LDAPMessage     *result, *e;
103         char *gattr[ 2 ];
104         LDAP *ld;
105
106         *vals = NULL;
107         if ( target != NULL && strcmp( target->e_ndn, e_ndn ) == 0 ) {
108                 /* we already have a copy of the entry */
109                 /* attribute and objectclass mapping has already been done */
110                 attr = attr_find( target->e_attrs, entry_at );
111                 if ( attr == NULL ) {
112                         return 1;
113                 }
114
115                 for ( count = 0; attr->a_vals[ count ] != NULL; count++ )
116                         ;
117                 v = ch_calloc( ( count + 1 ), sizeof( struct berval * ) );
118                 if ( v != NULL ) {
119                         for ( j = 0, abv = attr->a_vals; --count >= 0; abv++ ) {
120                                 if ( ( *abv )->bv_len > 0 ) {
121                                         v[ j ] = ber_bvdup( *abv );
122                                         if ( v[ j ] == NULL ) {
123                                                 break;
124                                         }
125                                 }
126                         }
127                         v[ j ] = NULL;
128                         *vals = v;
129                         rc = 0;
130                 }
131
132                 return rc;
133         } /* else */
134
135         candidate = meta_back_select_unique_candidate( li, e_ndn );
136         if ( candidate == -1 ) {
137                 return 1;
138         }
139
140         mapped = ldap_back_map( &li->targets[ candidate ]->at_map,
141                         entry_at->ad_cname.bv_val, 0 );
142         if ( mapped == NULL )
143                 return 1;
144
145         rc =  ldap_initialize( &ld, li->targets[ candidate ]->uri );
146         if ( rc != LDAP_SUCCESS ) {
147                 return 1;
148         }
149
150         rc = ldap_bind_s( ld, li->targets[ candidate ]->binddn,
151                         li->targets[ candidate ]->bindpw, LDAP_AUTH_SIMPLE );
152         if ( rc != LDAP_SUCCESS) {
153                 return 1;
154         }
155
156         gattr[ 0 ] = mapped;
157         gattr[ 1 ] = NULL;
158         if ( ldap_search_ext_s( ld, e_ndn, LDAP_SCOPE_BASE, "(objectclass=*)",
159                                 gattr, 0, NULL, NULL, LDAP_NO_LIMIT,
160                                 LDAP_NO_LIMIT, &result) == LDAP_SUCCESS) {
161                 if ( ( e = ldap_first_entry( ld, result ) ) != NULL ) {
162                         vs = ldap_get_values( ld, e, mapped );
163                         if ( vs != NULL ) {
164                                 for ( count = 0; vs[ count ] != NULL;
165                                                 count++ ) { }
166                                 v = ch_calloc( ( count + 1 ),
167                                                 sizeof( struct berval * ) );
168                                 if ( v == NULL ) {
169                                         ldap_value_free( vs );
170                                 } else {
171                                         is_oc = ( strcasecmp( "objectclass", mapped ) == 0 );
172                                         for ( i = 0, j = 0; i < count; i++ ) {
173                                                 if ( !is_oc ) {
174                                                         v[ j ] = ber_bvstr( vs[ i ] );
175                                                         if ( v[ j ] == NULL ) {
176                                                                 ch_free( vs[ i ] );
177                                                         } else {
178                                                                 j++;
179                                                         }
180                                                 } else {
181                                                         mapped = ldap_back_map( &li->targets[ candidate ]->oc_map, vs[ i ], 1 );
182                                                         if ( mapped ) {
183                                                                 mapped = ch_strdup( mapped );
184                                                                 if ( mapped ) {
185                                                                         v[ j ] = ber_bvstr( mapped );
186                                                                         if ( v[ j ] ) {
187                                                                                 j++;
188                                                                         }
189                                                                 }
190                                                         }
191                                                         ch_free( vs[ i ] );
192                                                 }
193                                         }
194                                         v[ j ] = NULL;
195                                         *vals = v;
196                                         rc = 0;
197                                         ch_free( vs );
198                                 }
199                         }
200                 }
201                 ldap_msgfree( result );
202         }
203         ldap_unbind(ld);
204
205         return(rc);
206 }
207