git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/conn.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
  75 #define AVL_INTERNAL
  76 #include "slap.h"
  77 #include "../back-ldap/back-ldap.h"
  78 #include "back-meta.h"
  79
  80 /*
  81  * Set PRINT_CONNTREE larger than 0 to dump the connection tree (debug only)
  82  */
  83 #define PRINT_CONNTREE 0
  84
  85 /*
  86  * meta_back_conn_cmp
  87  *
  88  * compares two struct metaconn based on the value of the conn pointer;
  89  * used by avl stuff
  90  */
  91 int
  92 meta_back_conn_cmp(
  93         const void *c1,
  94         const void *c2
  95         )
  96 {
  97         struct metaconn *lc1 = ( struct metaconn * )c1;
  98         struct metaconn *lc2 = ( struct metaconn * )c2;
  99
 100         return ( ( lc1->conn < lc2->conn ) ? -1 :
 101                         ( ( lc1->conn > lc2-> conn ) ? 1 : 0 ) );
 102 }
 103
 104 /*
 105  * meta_back_conn_dup
 106  *
 107  * returns -1 in case a duplicate struct metaconn has been inserted;
 108  * used by avl stuff
 109  */
 110 int
 111 meta_back_conn_dup(
 112         void *c1,
 113         void *c2
 114         )
 115 {
 116         struct metaconn *lc1 = ( struct metaconn * )c1;
 117         struct metaconn *lc2 = ( struct metaconn * )c2;
 118
 119         return( ( lc1->conn == lc2->conn ) ? -1 : 0 );
 120 }
 121
 122 /*
 123  * Debug stuff (got it from libavl)
 124  */
 125 #if PRINT_CONNTREE > 0
 126 static void
 127 ravl_print( Avlnode *root, int depth )
 128 {
 129         int     i;
 130
 131         if ( root == 0 ) {
 132                 return;
 133         }
 134
 135         ravl_print( root->avl_right, depth+1 );
 136
 137         for ( i = 0; i < depth; i++ ) {
 138                 printf( "    " );
 139         }
 140
 141         printf( "c(%d) %d\n", ( ( struct metaconn * )root->avl_data )->conn->c_connid, root->avl_bf );
 142
 143         ravl_print( root->avl_left, depth+1 );
 144 }
 145
 146 static void
 147 myprint( Avlnode *root )
 148 {
 149         printf( "********\n" );
 150
 151         if ( root == 0 ) {
 152                 printf( "\tNULL\n" );
 153         } else {
 154                 ravl_print( root, 0 );
 155         }
 156
 157         printf( "********\n" );
 158 }
 159 #endif /* PRINT_CONNTREE */
 160 /*
 161  * End of debug stuff
 162  */
 163
 164 /*
 165  * metaconn_alloc
 166  *
 167  * Allocates a connection structure, making room for all the referenced targets
 168  */
 169 static struct metaconn *
 170 metaconn_alloc( int ntargets )
 171 {
 172         struct metaconn *lc;
 173         int i;
 174
 175         assert( ntargets > 0 );
 176
 177         lc = ch_calloc( sizeof( struct metaconn ), 1 );
 178         if ( lc == NULL ) {
 179                 return NULL;
 180         }
 181
 182         /*
 183          * make it a null-terminated array ...
 184          */
 185         lc->conns = ch_calloc( sizeof( struct metasingleconn * ), ntargets+1 );
 186         if ( lc->conns == NULL ) {
 187                 free( lc );
 188                 return NULL;
 189         }
 190
 191         for ( i = 0; i < ntargets; i++ ) {
 192                 lc->conns[ i ] =
 193                         ch_calloc( sizeof( struct metasingleconn ), 1 );
 194                 if ( lc->conns[ i ] == NULL ) {
 195                         charray_free( ( char ** )lc->conns );
 196                         free( lc->conns );
 197                         free( lc );
 198                         return NULL;
 199                 }
 200         }
 201
 202         lc->bound_target = META_BOUND_NONE;
 203
 204         return lc;
 205 }
 206
 207 /*
 208  * metaconn_free
 209  *
 210  * clears a metaconn
 211  */
 212 static void
 213 metaconn_free(
 214                 struct metaconn *lc
 215 )
 216 {
 217         if ( !lc ) {
 218                 return;
 219         }
 220
 221         if ( lc->conns ) {
 222                 int i;
 223
 224                 for ( i = 0; lc->conns[ i ] != NULL; ++i ) {
 225                         free( lc->conns[ i ] );
 226                 }
 227                 charray_free( ( char ** )lc->conns );
 228         }
 229
 230         free( lc );
 231 }
 232
 233 /*
 234  * init_one_conn
 235  *
 236  * Initializes one connection
 237  */
 238 static int
 239 init_one_conn(
 240                 Connection *conn,
 241                 Operation *op,
 242                 struct metatarget *lt,
 243                 int vers,
 244                 struct metasingleconn *lsc
 245                 )
 246 {
 247         int err;
 248
 249         /*
 250          * Already init'ed
 251          */
 252         if ( lsc->ld != NULL ) {
 253                 return LDAP_SUCCESS;
 254         }
 255
 256         /*
 257          * Attempts to initialize the connection to the target ds
 258          */
 259         err = ldap_initialize( &lsc->ld, lt->uri );
 260         if ( err != LDAP_SUCCESS ) {
 261                 return ldap_back_map_result( err );
 262         }
 263
 264         /*
 265          * Set LDAP version. This will always succeed: If the client
 266          * bound with a particular version, then so can we.
 267          */
 268         ldap_set_option( lsc->ld, LDAP_OPT_PROTOCOL_VERSION, &vers );
 269
 270         /*
 271          * Sets a cookie for the rewrite session
 272          */
 273         ( void )rewrite_session_init( lt->rwinfo, conn );
 274
 275         /*
 276          * If the connection dn is not null, an attempt to rewrite it is made
 277          */
 278         if ( conn->c_cdn != NULL && conn->c_cdn[ 0 ] != '\0' ) {
 279                 /*
 280                  * Rewrite the bind dn if needed
 281                  */
 282                 lsc->bound_dn = NULL;
 283                 switch ( rewrite_session( lt->rwinfo, "bindDn",
 284                                         conn->c_cdn, conn,
 285                                         &lsc->bound_dn ) ) {
 286                 case REWRITE_REGEXEC_OK:
 287                         if ( lsc->bound_dn == NULL ) {
 288                                 lsc->bound_dn = ch_strdup( conn->c_cdn );
 289                         }
 290 #ifdef NEW_LOGGING
 291                         LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
 292                                         "[rw] bindDn: \"%s\" -> \"%s\"\n",
 293                                         conn->c_cdn, lsc->bound_dn ));
 294 #else /* !NEW_LOGGING */
 295                         Debug( LDAP_DEBUG_ARGS,
 296                                         "rw> bindDn: \"%s\" -> \"%s\"\n%s",
 297                                         conn->c_cdn, lsc->bound_dn, "" );
 298 #endif /* !NEW_LOGGING */
 299                         break;
 300
 301                 case REWRITE_REGEXEC_UNWILLING:
 302                         send_ldap_result( conn, op,
 303                                         LDAP_UNWILLING_TO_PERFORM,
 304                                         NULL, "Unwilling to perform",
 305                                         NULL, NULL );
 306                         return LDAP_UNWILLING_TO_PERFORM;
 307
 308                 case REWRITE_REGEXEC_ERR:
 309                         send_ldap_result( conn, op,
 310                                         LDAP_OPERATIONS_ERROR,
 311                                         NULL, "Operations error",
 312                                         NULL, NULL );
 313                         return LDAP_OPERATIONS_ERROR;
 314                 }
 315         } else {
 316                 lsc->bound_dn = NULL;
 317         }
 318
 319         lsc->bound = META_UNBOUND;
 320
 321         /*
 322          * The candidate is activated
 323          */
 324         lsc->candidate = META_CANDIDATE;
 325         return LDAP_SUCCESS;
 326 }
 327
 328 /*
 329  * meta_back_getconn
 330  *
 331  * Prepares the connection structure
 332  *
 333  * FIXME: This function needs to receive some info on the type of operation
 334  * it is invoked by, so that only the correct pool of candidate targets
 335  * is initialized in case no connection was available yet.
 336  *
 337  * At present a flag that says whether the candidate target must be unique
 338  * is passed; eventually an operation agent will be used.
 339  */
 340 struct metaconn *
 341 meta_back_getconn(
 342                 struct metainfo *li,
 343                 Connection *conn,
 344                 Operation *op,
 345                 int op_type,
 346                 const char *ndn,
 347                 int *candidate
 348                 )
 349 {
 350         struct metaconn *lc, lc_curr;
 351         int vers, cached = -1, i = -1, err = LDAP_SUCCESS;
 352         int new_conn = 0;
 353
 354         /* Searches for a metaconn in the avl tree */
 355         lc_curr.conn = conn;
 356         ldap_pvt_thread_mutex_lock( &li->conn_mutex );
 357         lc = (struct metaconn *)avl_find( li->conntree,
 358                 (caddr_t)&lc_curr, meta_back_conn_cmp );
 359         ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
 360
 361         /* Looks like we didn't get a bind. Open a new session... */
 362         if ( !lc ) {
 363                 lc = metaconn_alloc( li->ntargets );
 364                 lc->conn = conn;
 365                 new_conn = 1;
 366         }
 367
 368         vers = conn->c_protocol;
 369
 370         /*
 371          * looks in cache, if any
 372          */
 373         if ( li->cache.ttl != META_DNCACHE_DISABLED ) {
 374                 cached = i = meta_dncache_get_target( &li->cache, ndn );
 375         }
 376
 377         if ( op_type == META_OP_REQUIRE_SINGLE ) {
 378
 379                 /*
 380                  * tries to get a unique candidate
 381                  * (takes care of default target
 382                  */
 383                 if ( i < 0 ) {
 384                         i = meta_back_select_unique_candidate( li, ndn );
 385                 }
 386
 387                 /*
 388                  * if any is found, inits the connection
 389                  */
 390                 if ( i < 0 ) {
 391                         if ( new_conn ) {
 392                                 metaconn_free( lc );
 393                         }
 394
 395                         send_ldap_result( conn, op, LDAP_NO_SUCH_OBJECT,
 396                                 NULL, "", NULL, NULL );
 397
 398                         return NULL;
 399                 }
 400
 401 #ifdef NEW_LOGGING
 402                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
 403                                 "meta_back_getconn: got target %d"
 404                                 " for ndn=\"%s\" from cache\n", i, ndn ));
 405 #else /* !NEW_LOGGING */
 406                 Debug( LDAP_DEBUG_CACHE,
 407         "==>meta_back_getconn: got target %d for ndn=\"%s\" from cache\n%s",
 408                                 i, ndn, "" );
 409 #endif /* !NEW_LOGGING */
 410
 411                 /*
 412                  * Clear all other candidates
 413                  */
 414                 ( void )meta_clear_unused_candidates( li, lc, i, 0 );
 415
 416                 /*
 417                  * The target is activated; if needed, it is
 418                  * also init'd. In case of error, init_one_conn
 419                  * sends the appropriate result.
 420                  */
 421                 err = init_one_conn( conn, op, li->targets[ i ],
 422                                 vers, lc->conns[ i ] );
 423                 if ( err != LDAP_SUCCESS ) {
 424
 425                         /*
 426                          * FIXME: in case one target cannot
 427                          * be init'd, should the other ones
 428                          * be tried?
 429                          */
 430                         ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
 431                         if ( new_conn ) {
 432                                 metaconn_free( lc );
 433                         }
 434                         return NULL;
 435                 }
 436
 437                 if ( candidate ) {
 438                         *candidate = i;
 439                 }
 440
 441         /*
 442          * require all connections ...
 443          */
 444         } else if (op_type == META_OP_REQUIRE_ALL) {
 445                 for ( i = 0; i < li->ntargets; i++ ) {
 446
 447                         /*
 448                          * The target is activated; if needed, it is
 449                          * also init'd
 450                          */
 451                         int lerr = init_one_conn( conn, op, li->targets[ i ],
 452                                         vers, lc->conns[ i ] );
 453                         if ( lerr != LDAP_SUCCESS ) {
 454
 455                                 /*
 456                                  * FIXME: in case one target cannot
 457                                  * be init'd, should the other ones
 458                                  * be tried?
 459                                  */
 460                                 ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
 461                                 err = lerr;
 462                                 continue;
 463                         }
 464                 }
 465
 466         /*
 467          * if no unique candidate ...
 468          */
 469         } else {
 470                 int ndnlen = strlen( ndn );
 471                 for ( i = 0; i < li->ntargets; i++ ) {
 472                         if ( i == cached
 473                 || meta_back_is_candidate( li->targets[ i ]->suffix,
 474                                         ndn, ndnlen ) ) {
 475
 476                                 /*
 477                                  * The target is activated; if needed, it is
 478                                  * also init'd
 479                                  */
 480                                 int lerr = init_one_conn( conn, op,
 481                                                 li->targets[ i ],
 482                                                 vers, lc->conns[ i ] );
 483                                 if ( lerr != LDAP_SUCCESS ) {
 484
 485                                         /*
 486                                          * FIXME: in case one target cannot
 487                                          * be init'd, should the other ones
 488                                          * be tried?
 489                                          */
 490                                         ( void )meta_clear_one_candidate( lc->conns[ i ], 1 );
 491                                         err = lerr;
 492                                         continue;
 493                                 }
 494                         }
 495                 }
 496         }
 497
 498         if ( new_conn ) {
 499
 500                 /*
 501                  * Inserts the newly created metaconn in the avl tree
 502                  */
 503                 ldap_pvt_thread_mutex_lock( &li->conn_mutex );
 504                 err = avl_insert( &li->conntree, ( caddr_t )lc,
 505                                 meta_back_conn_cmp, meta_back_conn_dup );
 506
 507 #if PRINT_CONNTREE > 0
 508                 myprint( li->conntree );
 509 #endif /* PRINT_CONNTREE */
 510
 511                 ldap_pvt_thread_mutex_unlock( &li->conn_mutex );
 512
 513 #ifdef NEW_LOGGING
 514                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
 515                                 "meta_back_getconn: conn %ld inserted\n",
 516                                 lc->conn->c_connid ));
 517 #else /* !NEW_LOGGING */
 518                 Debug( LDAP_DEBUG_TRACE,
 519                         "=>meta_back_getconn: conn %ld inserted\n%s%s",
 520                         lc->conn->c_connid, "", "" );
 521 #endif /* !NEW_LOGGING */
 522
 523                 /*
 524                  * Err could be -1 in case a duplicate metaconn is inserted
 525                  */
 526                 if ( err != 0 ) {
 527                         send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR,
 528                         NULL, "Internal server error", NULL, NULL );
 529                         metaconn_free( lc );
 530                         return NULL;
 531                 }
 532         } else {
 533 #ifdef NEW_LOGGING
 534                 LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
 535                                 "meta_back_getconn: conn %ld fetched\n",
 536                                 lc->conn->c_connid ));
 537 #else /* !NEW_LOGGING */
 538                 Debug( LDAP_DEBUG_TRACE,
 539                         "=>meta_back_getconn: conn %ld fetched\n%s%s",
 540                         lc->conn->c_connid, "", "" );
 541 #endif /* !NEW_LOGGING */
 542         }
 543
 544         return lc;
 545 }
 546