git.sur5r.net Git - openldap/blob - 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                 struct berval           *ndn,
  93                 AttributeDescription    *entry_at,
  94                 BVarray                 *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         BVarray abv, v;
 101         char **vs;
 102         struct berval   mapped;
 103         LDAPMessage     *result, *e;
 104         char *gattr[ 2 ];
 105         LDAP *ld;
 106
 107         *vals = NULL;
 108         if ( target != NULL && target->e_nname.bv_len == ndn->bv_len
 109                         && strcmp( target->e_ndn, ndn->bv_val ) == 0 ) {
 110                 /* we already have a copy of the entry */
 111                 /* attribute and objectclass mapping has already been done */
 112                 attr = attr_find( target->e_attrs, entry_at );
 113                 if ( attr == NULL ) {
 114                         return 1;
 115                 }
 116
 117                 for ( count = 0; attr->a_vals[ count ].bv_val != NULL; count++ )
 118                         ;
 119                 v = ( BVarray )ch_calloc( ( count + 1 ), sizeof( struct berval ) );
 120                 if ( v == NULL ) {
 121                         return 1;
 122                 }
 123
 124                 for ( j = 0, abv = attr->a_vals; --count >= 0; abv++ ) {
 125                         if ( abv->bv_len > 0 ) {
 126                                 ber_dupbv( &v[ j ], abv );
 127                                 if ( v[ j ].bv_val == NULL ) {
 128                                         break;
 129                                 }
 130                         }
 131                 }
 132                 v[ j ].bv_val = NULL;
 133                 *vals = v;
 134
 135                 return 0;
 136         } /* else */
 137
 138         candidate = meta_back_select_unique_candidate( li, ndn );
 139         if ( candidate == -1 ) {
 140                 return 1;
 141         }
 142
 143         ldap_back_map( &li->targets[ candidate ]->at_map,
 144                         &entry_at->ad_cname, &mapped, 0 );
 145         if ( mapped.bv_val == NULL )
 146                 return 1;
 147
 148         rc =  ldap_initialize( &ld, li->targets[ candidate ]->uri );
 149         if ( rc != LDAP_SUCCESS ) {
 150                 return 1;
 151         }
 152
 153         rc = ldap_bind_s( ld, li->targets[ candidate ]->binddn.bv_val,
 154                         li->targets[ candidate ]->bindpw.bv_val, LDAP_AUTH_SIMPLE );
 155         if ( rc != LDAP_SUCCESS) {
 156                 return 1;
 157         }
 158
 159         gattr[ 0 ] = mapped.bv_val;
 160         gattr[ 1 ] = NULL;
 161         if ( ldap_search_ext_s( ld, ndn->bv_val, LDAP_SCOPE_BASE,
 162                                 "(objectClass=*)",
 163                                 gattr, 0, NULL, NULL, LDAP_NO_LIMIT,
 164                                 LDAP_NO_LIMIT, &result) == LDAP_SUCCESS) {
 165                 if ( ( e = ldap_first_entry( ld, result ) ) != NULL ) {
 166                         vs = ldap_get_values( ld, e, mapped.bv_val );
 167                         if ( vs != NULL ) {
 168                                 for ( count = 0; vs[ count ] != NULL;
 169                                                 count++ ) { }
 170                                 v = ( BVarray )ch_calloc( ( count + 1 ),
 171                                                 sizeof( struct berval ) );
 172                                 if ( v == NULL ) {
 173                                         ldap_value_free( vs );
 174                                 } else {
 175                                         is_oc = ( strcasecmp( "objectclass", mapped.bv_val ) == 0 );
 176                                         for ( i = 0, j = 0; i < count; i++ ) {
 177                                                 ber_str2bv( vs[ i ], 0, 0, &v[ j ] );
 178                                                 if ( !is_oc ) {
 179                                                         if ( v[ j ].bv_val == NULL ) {
 180                                                                 ch_free( vs[ i ] );
 181                                                         } else {
 182                                                                 j++;
 183                                                         }
 184                                                 } else {
 185                                                         ldap_back_map( &li->targets[ candidate ]->oc_map, &v[ j ], &mapped, 1 );
 186                                                         if ( mapped.bv_val ) {
 187                                                                 ber_dupbv( &v[ j ], &mapped );
 188                                                                 if ( v[ j ].bv_val ) {
 189                                                                         j++;
 190                                                                 }
 191                                                         }
 192                                                         ch_free( vs[ i ] );
 193                                                 }
 194                                         }
 195                                         v[ j ].bv_val = NULL;
 196                                         *vals = v;
 197                                         rc = 0;
 198                                         ch_free( vs );
 199                                 }
 200                         }
 201                 }
 202                 ldap_msgfree( result );
 203         }
 204         ldap_unbind( ld );
 205
 206         return(rc);
 207 }
 208