git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/group.c

   1 /*
   2  * Copyright 1998-2003 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 #include "lutil.h"
  78
  79 /* return 0 IFF op_dn is a value in group_at (member) attribute
  80  * of entry with gr_dn AND that entry has an objectClass
  81  * value of group_oc (groupOfNames)
  82  */
  83 int
  84 meta_back_group(
  85                 Backend                 *be,
  86                 Connection              *conn,
  87                 Operation               *op,
  88                 Entry                   *target,
  89                 struct berval           *gr_ndn,
  90                 struct berval           *op_ndn,
  91                 ObjectClass             *group_oc,
  92                 AttributeDescription    *group_at
  93 )
  94 {
  95         struct metainfo *li = ( struct metainfo * )be->be_private;
  96         int rc = 1, candidate;
  97         Attribute   *attr;
  98         AttributeDescription *ad_objectClass = slap_schema.si_ad_objectClass;
  99         LDAPMessage     *result;
 100         char *gattr[ 2 ];
 101         char *filter = NULL, *ptr;
 102         LDAP *ld = NULL;
 103         struct berval mop_ndn = { 0, NULL }, mgr_ndn = { 0, NULL };
 104
 105         struct berval group_oc_name = { 0, NULL };
 106         struct berval group_at_name = group_at->ad_cname;
 107
 108         if ( group_oc->soc_names && group_oc->soc_names[ 0 ] ) {
 109                 group_oc_name.bv_val = group_oc->soc_names[ 0 ];
 110         } else {
 111                 group_oc_name.bv_val = group_oc->soc_oid;
 112         }
 113
 114         if ( group_oc_name.bv_val ) {
 115                 group_oc_name.bv_len = strlen( group_oc_name.bv_val );
 116         }
 117
 118         if ( target != NULL && dn_match( &target->e_nname, gr_ndn ) ) {
 119                 /* we already have a copy of the entry */
 120                 /* attribute and objectclass mapping has already been done */
 121
 122                 /*
 123                  * first we need to check if the objectClass attribute
 124                  * has been retrieved; otherwise we need to repeat the search
 125                  */
 126                 attr = attr_find( target->e_attrs, ad_objectClass );
 127                 if ( attr != NULL ) {
 128
 129                         /*
 130                          * Now we can check for the group objectClass value
 131                          */
 132                         if ( !is_entry_objectclass( target, group_oc, 0 ) ) {
 133                                 return 1;
 134                         }
 135
 136                         /*
 137                          * This part has been reworked: the group attr compare
 138                          * fails only if the attribute is PRESENT but the value
 139                          * is NOT PRESENT; if the attribute is NOT PRESENT, the
 140                          * search must be repeated as well.
 141                          * This may happen if a search for an entry has already
 142                          * been performed (target is not null) but the group
 143                          * attribute has not been required
 144                          */
 145                         attr = attr_find( target->e_attrs, group_at );
 146                         if ( attr != NULL ) {
 147                                 rc = value_find_ex( group_at,
 148                                         SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH,
 149                                         attr->a_vals, op_ndn );
 150                                 if ( rc != LDAP_SUCCESS ) {
 151                                         return 1;
 152                                 }
 153                                 return 0;
 154                         } /* else: repeat the search */
 155                 } /* else: repeat the search */
 156         } /* else: do the search */
 157
 158         candidate = meta_back_select_unique_candidate( li, gr_ndn );
 159         if ( candidate == -1 ) {
 160                 goto cleanup;
 161         }
 162
 163         /*
 164          * Rewrite the op ndn if needed
 165          */
 166         switch ( rewrite_session( li->targets[ candidate ]->rwinfo, "bindDn",
 167                                 op_ndn->bv_val, conn, &mop_ndn.bv_val ) ) {
 168         case REWRITE_REGEXEC_OK:
 169                 if ( mop_ndn.bv_val != NULL && mop_ndn.bv_val[ 0 ] != '\0' ) {
 170                         mop_ndn.bv_len = strlen( mop_ndn.bv_val );
 171                 } else {
 172                         mop_ndn = *op_ndn;
 173                 }
 174 #ifdef NEW_LOGGING
 175                 LDAP_LOG( BACK_META, DETAIL1,
 176                         "[rw] bindDn (op ndn in group): \"%s\" -> \"%s\"\n",
 177                         op_ndn->bv_val, mop_ndn.bv_val, 0 );
 178 #else /* !NEW_LOGGING */
 179                 Debug( LDAP_DEBUG_ARGS,
 180                                 "rw> bindDn (op ndn in group):"
 181                                 " \"%s\" -> \"%s\"\n%s",
 182                                 op_ndn->bv_val, mop_ndn.bv_val, "" );
 183 #endif /* !NEW_LOGGING */
 184                 break;
 185
 186         case REWRITE_REGEXEC_UNWILLING:
 187                 /* continues to next case */
 188
 189         case REWRITE_REGEXEC_ERR:
 190                 return 1;
 191         }
 192
 193         /*
 194          * Rewrite the gr ndn if needed
 195          */
 196         switch ( rewrite_session( li->targets[ candidate ]->rwinfo,
 197                                 "searchBase",
 198                                 gr_ndn->bv_val, conn, &mgr_ndn.bv_val ) ) {
 199         case REWRITE_REGEXEC_OK:
 200                 if ( mgr_ndn.bv_val != NULL && mgr_ndn.bv_val[ 0 ] != '\0' ) {
 201                         mgr_ndn.bv_len = strlen( mgr_ndn.bv_val );
 202                 } else {
 203                         mgr_ndn = *gr_ndn;
 204                 }
 205 #ifdef NEW_LOGGING
 206                 LDAP_LOG( BACK_META, DETAIL1,
 207                         "[rw] searchBase (gr ndn in group): \"%s\" -> \"%s\"\n",
 208                         gr_ndn->bv_val, mgr_ndn.bv_val, 0 );
 209 #else /* !NEW_LOGGING */
 210                 Debug( LDAP_DEBUG_ARGS,
 211                                 "rw> searchBase (gr ndn in group):"
 212                                 " \"%s\" -> \"%s\"\n%s",
 213                                 gr_ndn->bv_val, mgr_ndn.bv_val, "" );
 214 #endif /* !NEW_LOGGING */
 215                 break;
 216
 217         case REWRITE_REGEXEC_UNWILLING:
 218                 /* continues to next case */
 219
 220         case REWRITE_REGEXEC_ERR:
 221                 goto cleanup;
 222         }
 223
 224         ldap_back_map( &li->targets[ candidate ]->oc_map,
 225                         &group_oc_name, &group_oc_name, BACKLDAP_MAP );
 226         if ( group_oc_name.bv_val == NULL ) {
 227                 goto cleanup;
 228         }
 229         ldap_back_map( &li->targets[ candidate ]->at_map,
 230                         &group_at_name, &group_at_name, BACKLDAP_MAP );
 231         if ( group_at_name.bv_val == NULL ) {
 232                 goto cleanup;
 233         }
 234
 235         filter = ch_malloc( sizeof( "(&(objectclass=)(=))" )
 236                         + group_oc_name.bv_len
 237                         + group_at_name.bv_len
 238                         + mop_ndn.bv_len + 1 );
 239         if ( filter == NULL ) {
 240                 goto cleanup;
 241         }
 242
 243         rc = ldap_initialize( &ld, li->targets[ candidate ]->uri );
 244         if ( rc != LDAP_SUCCESS ) {
 245                 goto cleanup;
 246         }
 247
 248         rc = ldap_bind_s( ld, li->targets[ candidate ]->binddn.bv_val,
 249                         li->targets[ candidate ]->bindpw.bv_val,
 250                         LDAP_AUTH_SIMPLE );
 251         if ( rc != LDAP_SUCCESS ) {
 252                 goto cleanup;
 253         }
 254
 255         ptr = lutil_strcopy( filter, "(&(objectclass=" );
 256         ptr = lutil_strcopy( ptr , group_oc_name.bv_val );
 257         ptr = lutil_strcopy( ptr , ")(" );
 258         ptr = lutil_strcopy( ptr , group_at_name.bv_val );
 259         ptr = lutil_strcopy( ptr , "=" );
 260         ptr = lutil_strcopy( ptr , mop_ndn.bv_val );
 261         strcpy( ptr , "))" );
 262
 263         gattr[ 0 ] = "objectclass";
 264         gattr[ 1 ] = NULL;
 265         rc = 1;
 266         if ( ldap_search_ext_s( ld, mgr_ndn.bv_val, LDAP_SCOPE_BASE, filter,
 267                                 gattr, 0, NULL, NULL, LDAP_NO_LIMIT,
 268                                 LDAP_NO_LIMIT, &result ) == LDAP_SUCCESS ) {
 269                 if ( ldap_first_entry( ld, result ) != NULL ) {
 270                         rc = 0;
 271                 }
 272                 ldap_msgfree( result );
 273         }
 274
 275 cleanup:;
 276         if ( ld != NULL ) {
 277                 ldap_unbind( ld );
 278         }
 279         if ( filter != NULL ) {
 280                 ch_free( filter );
 281         }
 282         if ( mop_ndn.bv_val != op_ndn->bv_val ) {
 283                 free( mop_ndn.bv_val );
 284         }
 285         if ( mgr_ndn.bv_val != gr_ndn->bv_val ) {
 286                 free( mgr_ndn.bv_val );
 287         }
 288
 289         return rc;
 290 }
 291