git.sur5r.net Git - openldap/blob - servers/slapd/slapi/slapi_utils.c

   1 /*
   2  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5 /*
   6  * (C) Copyright IBM Corp. 1997,2002
   7  * Redistribution and use in source and binary forms are permitted
   8  * provided that this notice is preserved and that due credit is
   9  * given to IBM Corporation. This software is provided ``as is''
  10  * without express or implied warranty.
  11  */
  12 /*
  13  * Portions (C) Copyright PADL Software Pty Ltd. 2003
  14  * Redistribution and use in source and binary forms are permitted
  15  * provided that this notice is preserved and that due credit is
  16  * given to PADL Software Pty Ltd. This software is provided ``as is''
  17  * without express or implied warranty.
  18  */
  19
  20 #include "portable.h"
  21
  22 #include <ac/string.h>
  23 #include <ac/stdarg.h>
  24 #include <ac/ctype.h>
  25 #include <ac/unistd.h>
  26 #include <ldap_pvt.h>
  27
  28 #include <slap.h>
  29 #include <slapi.h>
  30
  31 #ifdef _SPARC
  32 #include <sys/systeminfo.h>
  33 #endif
  34
  35 #include <netdb.h>
  36
  37 /*
  38  * server start time (should we use a struct timeval also in slapd?
  39  */
  40 static struct                   timeval base_time;
  41 ldap_pvt_thread_mutex_t         slapi_hn_mutex;
  42 ldap_pvt_thread_mutex_t         slapi_time_mutex;
  43
  44 struct slapi_mutex {
  45         ldap_pvt_thread_mutex_t mutex;
  46 };
  47
  48 struct slapi_condvar {
  49         ldap_pvt_thread_cond_t cond;
  50         ldap_pvt_thread_mutex_t mutex;
  51 };
  52
  53 /*
  54  * This function converts an array of pointers to berval objects to
  55  * an array of berval objects.
  56  */
  57
  58 int
  59 bvptr2obj(
  60         struct berval   **bvptr,
  61         BerVarray       *bvobj )
  62 {
  63         int             rc = LDAP_SUCCESS;
  64         int             i;
  65         BerVarray       tmpberval;
  66
  67         if ( bvptr == NULL || *bvptr == NULL ) {
  68                 return LDAP_OTHER;
  69         }
  70
  71         for ( i = 0; bvptr != NULL && bvptr[i] != NULL; i++ ) {
  72                 ; /* EMPTY */
  73         }
  74
  75         tmpberval = (BerVarray)slapi_ch_malloc( (i + 1)*sizeof(struct berval));
  76         if ( tmpberval == NULL ) {
  77                 return LDAP_NO_MEMORY;
  78         }
  79
  80         for ( i = 0; bvptr[i] != NULL; i++ ) {
  81                 tmpberval[i].bv_val = bvptr[i]->bv_val;
  82                 tmpberval[i].bv_len = bvptr[i]->bv_len;
  83         }
  84         tmpberval[i].bv_val = NULL;
  85         tmpberval[i].bv_len = 0;
  86
  87         if ( rc == LDAP_SUCCESS ) {
  88                 *bvobj = tmpberval;
  89         }
  90
  91         return rc;
  92 }
  93
  94 Slapi_Entry *
  95 slapi_str2entry(
  96         char            *s,
  97         int             check_dup )
  98 {
  99 #ifdef LDAP_SLAPI
 100         Slapi_Entry     *e = NULL;
 101         char            *pTmpS;
 102
 103         pTmpS = slapi_ch_strdup( s );
 104         if ( pTmpS != NULL ) {
 105                 e = str2entry( pTmpS );
 106                 slapi_ch_free( (void **)&pTmpS );
 107         }
 108
 109         return e;
 110 #else
 111         return NULL;
 112 #endif /* LDAP_SLAPI */
 113 }
 114
 115 char *
 116 slapi_entry2str(
 117         Slapi_Entry     *e,
 118         int             *len )
 119 {
 120 #ifdef LDAP_SLAPI
 121         char            *ret;
 122
 123         ldap_pvt_thread_mutex_lock( &entry2str_mutex );
 124         ret = entry2str( e, len );
 125         ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
 126
 127         return ret;
 128 #else /* LDAP_SLAPI */
 129         return NULL;
 130 #endif /* LDAP_SLAPI */
 131 }
 132
 133 char *
 134 slapi_entry_get_dn( Slapi_Entry *e )
 135 {
 136 #ifdef LDAP_SLAPI
 137         return e->e_name.bv_val;
 138 #else /* LDAP_SLAPI */
 139         return NULL;
 140 #endif /* LDAP_SLAPI */
 141 }
 142
 143 int
 144 slapi_x_entry_get_id( Slapi_Entry *e )
 145 {
 146 #ifdef LDAP_SLAPI
 147         return e->e_id;
 148 #else
 149         return NOID;
 150 #endif /* LDAP_SLAPI */
 151 }
 152
 153 void
 154 slapi_entry_set_dn(
 155         Slapi_Entry     *e,
 156         char            *ldn )
 157 {
 158 #ifdef LDAP_SLAPI
 159         struct berval   dn = { 0, NULL };
 160
 161         dn.bv_val = ldn;
 162         dn.bv_len = strlen( ldn );
 163
 164         dnPrettyNormal( NULL, &dn, &e->e_name, &e->e_nname );
 165 #endif /* LDAP_SLAPI */
 166 }
 167
 168 Slapi_Entry *
 169 slapi_entry_dup( Slapi_Entry *e )
 170 {
 171 #ifdef LDAP_SLAPI
 172         char            *tmp = NULL;
 173         Slapi_Entry     *tmpEnt;
 174         int             len = 0;
 175
 176         tmp = slapi_entry2str( e, &len );
 177         if ( tmp == NULL ) {
 178                 return (Slapi_Entry *)NULL;
 179         }
 180
 181         tmpEnt = (Slapi_Entry *)str2entry( tmp );
 182         if ( tmpEnt == NULL ) {
 183                 slapi_ch_free( (void **)&tmp );
 184                 return (Slapi_Entry *)NULL;
 185         }
 186
 187         if (tmp != NULL) {
 188                 slapi_ch_free( (void **)&tmp );
 189         }
 190
 191         return tmpEnt;
 192 #else /* LDAP_SLAPI */
 193         return NULL;
 194 #endif /* LDAP_SLAPI */
 195 }
 196
 197 int
 198 slapi_entry_attr_delete(
 199         Slapi_Entry     *e,
 200         char            *type )
 201 {
 202 #ifdef LDAP_SLAPI
 203         AttributeDescription    *ad = NULL;
 204         const char              *text;
 205
 206         if ( slap_str2ad( type, &ad, &text ) != LDAP_SUCCESS ) {
 207                 return 1;       /* LDAP_NO_SUCH_ATTRIBUTE */
 208         }
 209
 210         if ( attr_delete( &e->e_attrs, ad ) == LDAP_SUCCESS ) {
 211                 return 0;       /* attribute is deleted */
 212         } else {
 213                 return -1;      /* something went wrong */
 214         }
 215 #else /* LDAP_SLAPI */
 216         return -1;
 217 #endif /* LDAP_SLAPI */
 218 }
 219
 220 Slapi_Entry *
 221 slapi_entry_alloc( void )
 222 {
 223 #ifdef LDAP_SLAPI
 224         return (Slapi_Entry *)slapi_ch_calloc( 1, sizeof(Slapi_Entry) );
 225 #else /* LDAP_SLAPI */
 226         return NULL;
 227 #endif /* LDAP_SLAPI */
 228 }
 229
 230 void
 231 slapi_entry_free( Slapi_Entry *e )
 232 {
 233 #ifdef LDAP_SLAPI
 234         entry_free( e );
 235 #endif /* LDAP_SLAPI */
 236 }
 237
 238 int
 239 slapi_entry_attr_merge(
 240         Slapi_Entry     *e,
 241         char            *type,
 242         struct berval   **vals )
 243 {
 244 #ifdef LDAP_SLAPI
 245         AttributeDescription    *ad = NULL;
 246         const char              *text;
 247         BerVarray               bv;
 248         int                     rc;
 249
 250         rc = bvptr2obj( vals, &bv );
 251         if ( rc != LDAP_SUCCESS ) {
 252                 return -1;
 253         }
 254
 255         rc = slap_str2ad( type, &ad, &text );
 256         if ( rc != LDAP_SUCCESS ) {
 257                 return -1;
 258         }
 259
 260         rc = attr_mergeit( e, ad, bv );
 261         ch_free( bv );
 262
 263         return rc;
 264 #else /* LDAP_SLAPI */
 265         return -1;
 266 #endif /* LDAP_SLAPI */
 267 }
 268
 269 int
 270 slapi_entry_attr_find(
 271         Slapi_Entry     *e,
 272         char            *type,
 273         Slapi_Attr      **attr )
 274 {
 275 #ifdef LDAP_SLAPI
 276         AttributeDescription    *ad = NULL;
 277         const char              *text;
 278         int                     rc;
 279
 280         rc = slap_str2ad( type, &ad, &text );
 281         if ( rc != LDAP_SUCCESS ) {
 282                 return -1;
 283         }
 284
 285         *attr = attr_find( e->e_attrs, ad );
 286         if ( *attr == NULL ) {
 287                 return -1;
 288         }
 289
 290         return 0;
 291 #else /* LDAP_SLAPI */
 292         return -1;
 293 #endif /* LDAP_SLAPI */
 294 }
 295
 296 char *
 297 slapi_entry_attr_get_charptr( const Slapi_Entry *e, const char *type )
 298 {
 299 #ifdef LDAP_SLAPI
 300         AttributeDescription *ad = NULL;
 301         const char *text;
 302         int rc;
 303         Attribute *attr;
 304
 305         rc = slap_str2ad( type, &ad, &text );
 306         if ( rc != LDAP_SUCCESS ) {
 307                 return NULL;
 308         }
 309
 310         attr = attr_find( e->e_attrs, ad );
 311         if ( attr == NULL ) {
 312                 return NULL;
 313         }
 314
 315         if ( attr->a_vals != NULL && attr->a_vals[0].bv_val != NULL ) {
 316                 return slapi_ch_strdup( attr->a_vals[0].bv_val );
 317         }
 318
 319         return NULL;
 320 #else
 321         return -1;
 322 #endif
 323 }
 324
 325 int
 326 slapi_entry_attr_get_int( const Slapi_Entry *e, const char *type )
 327 {
 328 #ifdef LDAP_SLAPI
 329         AttributeDescription *ad = NULL;
 330         const char *text;
 331         int rc;
 332         Attribute *attr;
 333
 334         rc = slap_str2ad( type, &ad, &text );
 335         if ( rc != LDAP_SUCCESS ) {
 336                 return 0;
 337         }
 338
 339         attr = attr_find( e->e_attrs, ad );
 340         if ( attr == NULL ) {
 341                 return 0;
 342         }
 343
 344         return slapi_value_get_int( attr->a_vals );
 345 #else
 346         return 0;
 347 #endif
 348 }
 349
 350 int
 351 slapi_entry_attr_get_long( const Slapi_Entry *e, const char *type )
 352 {
 353 #ifdef LDAP_SLAPI
 354         AttributeDescription *ad = NULL;
 355         const char *text;
 356         int rc;
 357         Attribute *attr;
 358
 359         rc = slap_str2ad( type, &ad, &text );
 360         if ( rc != LDAP_SUCCESS ) {
 361                 return 0;
 362         }
 363
 364         attr = attr_find( e->e_attrs, ad );
 365         if ( attr == NULL ) {
 366                 return 0;
 367         }
 368
 369         return slapi_value_get_long( attr->a_vals );
 370 #else
 371         return 0;
 372 #endif
 373 }
 374
 375 int
 376 slapi_entry_attr_get_uint( const Slapi_Entry *e, const char *type )
 377 {
 378 #ifdef LDAP_SLAPI
 379         AttributeDescription *ad = NULL;
 380         const char *text;
 381         int rc;
 382         Attribute *attr;
 383
 384         rc = slap_str2ad( type, &ad, &text );
 385         if ( rc != LDAP_SUCCESS ) {
 386                 return 0;
 387         }
 388
 389         attr = attr_find( e->e_attrs, ad );
 390         if ( attr == NULL ) {
 391                 return 0;
 392         }
 393
 394         return slapi_value_get_uint( attr->a_vals );
 395 #else
 396         return 0;
 397 #endif
 398 }
 399
 400 int
 401 slapi_entry_attr_get_ulong( const Slapi_Entry *e, const char *type )
 402 {
 403 #ifdef LDAP_SLAPI
 404         AttributeDescription *ad = NULL;
 405         const char *text;
 406         int rc;
 407         Attribute *attr;
 408
 409         rc = slap_str2ad( type, &ad, &text );
 410         if ( rc != LDAP_SUCCESS ) {
 411                 return 0;
 412         }
 413
 414         attr = attr_find( e->e_attrs, ad );
 415         if ( attr == NULL ) {
 416                 return 0;
 417         }
 418
 419         return slapi_value_get_ulong( attr->a_vals );
 420 #else
 421         return 0;
 422 #endif
 423 }
 424
 425 int
 426 slapi_entry_attr_hasvalue( Slapi_Entry *e, const char *type, const char *value )
 427 {
 428 #ifdef LDAP_SLAPI
 429         struct berval bv;
 430         AttributeDescription *ad = NULL;
 431         const char *text;
 432         int rc;
 433         Attribute *attr;
 434
 435         rc = slap_str2ad( type, &ad, &text );
 436         if ( rc != LDAP_SUCCESS ) {
 437                 return 0;
 438         }
 439
 440         attr = attr_find( e->e_attrs, ad );
 441         if ( attr == NULL ) {
 442                 return 0;
 443         }
 444
 445         bv.bv_val = (char *)value;
 446         bv.bv_len = strlen( value );
 447
 448         return ( slapi_attr_value_find( attr, &bv ) != -1 );
 449 #else
 450         return 0;
 451 #endif
 452 }
 453
 454 void
 455 slapi_entry_attr_set_charptr(Slapi_Entry* e, const char *type, const char *value)
 456 {
 457 #ifdef LDAP_SLAPI
 458         AttributeDescription    *ad = NULL;
 459         const char              *text;
 460         int                     rc;
 461         struct berval           bv;
 462
 463         rc = slap_str2ad( type, &ad, &text );
 464         if ( rc != LDAP_SUCCESS ) {
 465                 return;
 466         }
 467
 468         attr_delete ( &e->e_attrs, ad );
 469         if ( value != NULL ) {
 470                 bv.bv_val = (char *)value;
 471                 bv.bv_len = strlen(value);
 472                 attr_mergeit_one( e, ad, &bv );
 473         }
 474 #endif /* LDAP_SLAPI */
 475 }
 476
 477 void
 478 slapi_entry_attr_set_int( Slapi_Entry* e, const char *type, int l)
 479 {
 480 #ifdef LDAP_SLAPI
 481         char buf[64];
 482
 483         snprintf( buf, sizeof( buf ), "%d", l );
 484         slapi_entry_attr_set_charptr( e, type, buf );
 485 #endif /* LDAP_SLAPI */
 486 }
 487
 488 void
 489 slapi_entry_attr_set_uint( Slapi_Entry* e, const char *type, unsigned int l)
 490 {
 491 #ifdef LDAP_SLAPI
 492         char buf[64];
 493
 494         snprintf( buf, sizeof( buf ), "%u", l );
 495         slapi_entry_attr_set_charptr( e, type, buf );
 496 #endif /* LDAP_SLAPI */
 497 }
 498
 499 void
 500 slapi_entry_attr_set_long(Slapi_Entry* e, const char *type, long l)
 501 {
 502 #ifdef LDAP_SLAPI
 503         char buf[64];
 504
 505         snprintf( buf, sizeof( buf ), "%ld", l );
 506         slapi_entry_attr_set_charptr( e, type, buf );
 507 #endif /* LDAP_SLAPI */
 508 }
 509
 510 void
 511 slapi_entry_attr_set_ulong(Slapi_Entry* e, const char *type, unsigned long l)
 512 {
 513 #ifdef LDAP_SLAPI
 514         char buf[64];
 515
 516         snprintf( buf, sizeof( buf ), "%lu", l );
 517         slapi_entry_attr_set_charptr( e, type, buf );
 518 #endif /* LDAP_SLAPI */
 519 }
 520
 521 int
 522 slapi_is_rootdse( const char *dn )
 523 {
 524 #ifdef LDAP_SLAPI
 525         return ( dn == NULL || dn[0] == '\0' );
 526 #else
 527         return 0;
 528 #endif
 529 }
 530
 531 /*
 532  * Add values to entry.
 533  *
 534  * Returns:
 535  *      LDAP_SUCCESS                    Values added to entry
 536  *      LDAP_TYPE_OR_VALUE_EXISTS       One or more values exist in entry already
 537  *      LDAP_CONSTRAINT_VIOLATION       Any other error (odd, but it's the spec)
 538  */
 539 int
 540 slapi_entry_add_values( Slapi_Entry *e, const char *type, struct berval **vals )
 541 {
 542 #ifdef LDAP_SLAPI
 543         Modification            mod;
 544         const char              *text;
 545         int                     rc;
 546         char                    textbuf[SLAP_TEXT_BUFLEN];
 547
 548         mod.sm_op = LDAP_MOD_ADD;
 549         mod.sm_desc = NULL;
 550         mod.sm_type.bv_val = (char *)type;
 551         mod.sm_type.bv_len = strlen( type );
 552
 553         rc = slap_str2ad( type, &mod.sm_desc, &text );
 554         if ( rc != LDAP_SUCCESS ) {
 555                 return rc;
 556         }
 557
 558         if ( vals == NULL ) {
 559                 /* Apparently vals can be NULL
 560                  * FIXME: sm_bvalues = NULL ? */
 561                 mod.sm_bvalues = (BerVarray)ch_malloc( sizeof(struct berval) );
 562                 mod.sm_bvalues->bv_val = NULL;
 563
 564         } else {
 565                 rc = bvptr2obj( vals, &mod.sm_bvalues );
 566                 if ( rc != LDAP_SUCCESS ) {
 567                         return LDAP_CONSTRAINT_VIOLATION;
 568                 }
 569         }
 570 #ifdef SLAP_NVALUES
 571         mod.sm_nvalues = NULL;
 572 #endif
 573
 574         rc = modify_add_values( e, &mod, 0, &text, textbuf, sizeof(textbuf) );
 575
 576         ch_free( mod.sm_bvalues );
 577
 578         return (rc == LDAP_SUCCESS) ? LDAP_SUCCESS : LDAP_CONSTRAINT_VIOLATION;
 579 #else
 580         return -1;
 581 #endif /* LDAP_SLAPI */
 582 }
 583
 584 int
 585 slapi_entry_add_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 586 {
 587 #ifdef LDAP_SLAPI
 588         return slapi_entry_add_values( e, type, vals );
 589 #else
 590         return -1;
 591 #endif /* LDAP_SLAPI */
 592 }
 593
 594 int
 595 slapi_entry_add_valueset(Slapi_Entry *e, const char *type, Slapi_ValueSet *vs)
 596 {
 597 #ifdef LDAP_SLAPI
 598         AttributeDescription    *ad = NULL;
 599         const char              *text;
 600         int                     rc;
 601
 602         rc = slap_str2ad( type, &ad, &text );
 603         if ( rc != LDAP_SUCCESS ) {
 604                 return -1;
 605         }
 606
 607         return attr_mergeit( e, ad, *vs );
 608 #else
 609         return -1;
 610 #endif /* LDAP_SLAPI */
 611 }
 612
 613 int
 614 slapi_entry_delete_values( Slapi_Entry *e, const char *type, struct berval **vals )
 615 {
 616 #ifdef LDAP_SLAPI
 617         Modification            mod;
 618         const char              *text;
 619         int                     rc;
 620         char                    textbuf[SLAP_TEXT_BUFLEN];
 621
 622         mod.sm_op = LDAP_MOD_DELETE;
 623         mod.sm_desc = NULL;
 624         mod.sm_type.bv_val = (char *)type;
 625         mod.sm_type.bv_len = strlen( type );
 626
 627         if ( vals == NULL ) {
 628                 /* If vals is NULL, this is a NOOP. */
 629                 return LDAP_SUCCESS;
 630         }
 631
 632         rc = slap_str2ad( type, &mod.sm_desc, &text );
 633         if ( rc != LDAP_SUCCESS ) {
 634                 return rc;
 635         }
 636
 637         if ( vals[0] == NULL ) {
 638                 /* SLAPI doco says LDAP_OPERATIONS_ERROR but LDAP_OTHER is better */
 639                 return attr_delete( &e->e_attrs, mod.sm_desc ) ? LDAP_OTHER : LDAP_SUCCESS;
 640         }
 641
 642         rc = bvptr2obj( vals, &mod.sm_bvalues );
 643         if ( rc != LDAP_SUCCESS ) {
 644                 return LDAP_CONSTRAINT_VIOLATION;
 645         }
 646 #if SLAP_NVALUES
 647         mod.sm_nvalues = NULL;
 648 #endif
 649
 650         rc = modify_delete_values( e, &mod, 0, &text, textbuf, sizeof(textbuf) );
 651
 652         ch_free( mod.sm_bvalues );
 653
 654         return rc;
 655 #else
 656         return -1;
 657 #endif /* LDAP_SLAPI */
 658 }
 659
 660 int
 661 slapi_entry_delete_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 662 {
 663 #ifdef LDAP_SLAPI
 664         return slapi_entry_delete_values( e, type, vals );
 665 #else
 666         return -1;
 667 #endif /* LDAP_SLAPI */
 668 }
 669
 670 int
 671 slapi_entry_merge_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 672 {
 673 #ifdef LDAP_SLAPI
 674         return slapi_entry_attr_merge( e, (char *)type, vals );
 675 #else
 676         return -1;
 677 #endif /* LDAP_SLAPI */
 678 }
 679
 680 int
 681 slapi_entry_add_value(Slapi_Entry *e, const char *type, const Slapi_Value *value)
 682 {
 683 #ifdef LDAP_SLAPI
 684         AttributeDescription    *ad = NULL;
 685         int                     rc;
 686         const char              *text;
 687
 688         rc = slap_str2ad( type, &ad, &text );
 689         if ( rc != LDAP_SUCCESS ) {
 690                 return -1;
 691         }
 692
 693         rc = attr_mergeit_one( e, ad, (Slapi_Value *)value );
 694         if ( rc != LDAP_SUCCESS ) {
 695                 return -1;
 696         }
 697
 698         return 0;
 699 #else
 700         return -1;
 701 #endif /* LDAP_SLAPI */
 702 }
 703
 704 int
 705 slapi_entry_add_string(Slapi_Entry *e, const char *type, const char *value)
 706 {
 707 #ifdef LDAP_SLAPI
 708         Slapi_Value val;
 709
 710         val.bv_val = (char *)value;
 711         val.bv_len = strlen( value );
 712
 713         return slapi_entry_add_value( e, type, &val );
 714 #else
 715         return -1;
 716 #endif /* LDAP_SLAPI */
 717 }
 718
 719 int
 720 slapi_entry_delete_string(Slapi_Entry *e, const char *type, const char *value)
 721 {
 722 #ifdef LDAP_SLAPI
 723         Slapi_Value *vals[2];
 724         Slapi_Value val;
 725
 726         val.bv_val = (char *)value;
 727         val.bv_len = strlen( value );
 728         vals[0] = &val;
 729         vals[1] = NULL;
 730
 731         return slapi_entry_delete_values_sv( e, type, vals );
 732 #else
 733         return -1;
 734 #endif /* LDAP_SLAPI */
 735 }
 736
 737
 738 int
 739 slapi_entry_attr_merge_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 740 {
 741 #ifdef LDAP_SLAPI
 742         return slapi_entry_attr_merge( e, (char *)type, vals );
 743 #else
 744         return -1;
 745 #endif
 746 }
 747
 748 int
 749 slapi_entry_first_attr( const Slapi_Entry *e, Slapi_Attr **attr )
 750 {
 751 #ifdef LDAP_SLAPI
 752         if ( e == NULL ) {
 753                 return -1;
 754         }
 755
 756         *attr = e->e_attrs;
 757
 758         return ( *attr != NULL ) ? 0 : -1;
 759 #else
 760         return -1;
 761 #endif
 762 }
 763
 764 int
 765 slapi_entry_next_attr( const Slapi_Entry *e, Slapi_Attr *prevattr, Slapi_Attr **attr )
 766 {
 767 #ifdef LDAP_SLAPI
 768         if ( e == NULL ) {
 769                 return -1;
 770         }
 771
 772         if ( prevattr == NULL ) {
 773                 return -1;
 774         }
 775
 776         *attr = prevattr->a_next;
 777
 778         return ( *attr != NULL ) ? 0 : -1;
 779 #else
 780         return -1;
 781 #endif
 782 }
 783
 784 int
 785 slapi_entry_attr_replace_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 786 {
 787 #ifdef LDAP_SLAPI
 788         AttributeDescription *ad = NULL;
 789         const char *text;
 790         int rc;
 791         BerVarray bv;
 792
 793         rc = slap_str2ad( type, &ad, &text );
 794         if ( rc != LDAP_SUCCESS ) {
 795                 return 0;
 796         }
 797
 798         attr_delete( &e->e_attrs, ad );
 799
 800         rc = bvptr2obj( vals, &bv );
 801         if ( rc != LDAP_SUCCESS ) {
 802                 return -1;
 803         }
 804
 805         rc = attr_mergeit( e, ad, bv );
 806         slapi_ch_free( (void **)&bv );
 807         if ( rc != LDAP_SUCCESS ) {
 808                 return -1;
 809         }
 810
 811         return 0;
 812 #else
 813         return -1;
 814 #endif /* LDAP_SLAPI */
 815 }
 816
 817 /*
 818  * FIXME -- The caller must free the allocated memory.
 819  * In Netscape they do not have to.
 820  */
 821 int
 822 slapi_attr_get_values(
 823         Slapi_Attr      *attr,
 824         struct berval   ***vals )
 825 {
 826 #ifdef LDAP_SLAPI
 827         int             i, j;
 828         struct berval   **bv;
 829
 830         if ( attr == NULL ) {
 831                 return 1;
 832         }
 833
 834         for ( i = 0; attr->a_vals[i].bv_val != NULL; i++ ) {
 835                 ; /* EMPTY */
 836         }
 837
 838         bv = (struct berval **)ch_malloc( (i + 1) * sizeof(struct berval *) );
 839         for ( j = 0; j < i; j++ ) {
 840                 bv[j] = ber_dupbv( NULL, &attr->a_vals[j] );
 841         }
 842         bv[j] = NULL;
 843
 844         *vals = (struct berval **)bv;
 845
 846         return 0;
 847 #else /* LDAP_SLAPI */
 848         return -1;
 849 #endif /* LDAP_SLAPI */
 850 }
 851
 852 char *
 853 slapi_dn_normalize( char *dn )
 854 {
 855 #ifdef LDAP_SLAPI
 856         struct berval   bdn;
 857         struct berval   ndn;
 858
 859         assert( dn != NULL );
 860
 861         bdn.bv_val = dn;
 862         bdn.bv_len = strlen( dn );
 863
 864         dnNormalize2( NULL, &bdn, &ndn );
 865
 866         /*
 867          * FIXME: ain't it safe to set dn = ndn.bv_val ?
 868          */
 869         dn = ch_strdup( ndn.bv_val );
 870         ch_free( ndn.bv_val );
 871
 872         return dn;
 873 #else /* LDAP_SLAPI */
 874         return NULL;
 875 #endif /* LDAP_SLAPI */
 876 }
 877
 878 /*
 879  * FIXME: this function is dangerous and should be deprecated;
 880  * DN normalization is a lot more than lower-casing, and BTW
 881  * OpenLDAP's DN normalization for case insensitive attributes
 882  * is already lower case
 883  */
 884 char *
 885 slapi_dn_normalize_case( char *dn )
 886 {
 887 #ifdef LDAP_SLAPI
 888         slapi_dn_normalize( dn );
 889         ldap_pvt_str2lower( dn );
 890
 891         return dn;
 892 #else /* LDAP_SLAPI */
 893         return NULL;
 894 #endif /* LDAP_SLAPI */
 895 }
 896
 897 int
 898 slapi_dn_issuffix(
 899         char            *dn,
 900         char            *suffix )
 901 {
 902 #ifdef LDAP_SLAPI
 903         struct berval   bdn, ndn;
 904         struct berval   bsuffix, nsuffix;
 905         int rc;
 906
 907         assert( dn != NULL );
 908         assert( suffix != NULL );
 909
 910         bdn.bv_val = dn;
 911         bdn.bv_len = strlen( dn );
 912
 913         bsuffix.bv_val = suffix;
 914         bsuffix.bv_len = strlen( suffix );
 915
 916         if ( dnNormalize2( NULL, &bdn, &ndn ) != LDAP_SUCCESS ) {
 917                 return 0;
 918         }
 919
 920         if ( dnNormalize2( NULL, &bsuffix, &nsuffix ) != LDAP_SUCCESS ) {
 921                 slapi_ch_free( (void **)&ndn.bv_val );
 922                 return 0;
 923         }
 924
 925         rc = dnIsSuffix( &ndn, &nsuffix );
 926
 927         slapi_ch_free( (void **)&ndn.bv_val );
 928         slapi_ch_free( (void **)&nsuffix.bv_val );
 929
 930         return rc;
 931 #else /* LDAP_SLAPI */
 932         return 0;
 933 #endif /* LDAP_SLAPI */
 934 }
 935
 936 char *
 937 slapi_dn_ignore_case( char *dn )
 938 {
 939 #ifdef LDAP_SLAPI
 940         return slapi_dn_normalize_case( dn );
 941 #else /* LDAP_SLAPI */
 942         return NULL;
 943 #endif /* LDAP_SLAPI */
 944 }
 945
 946 char *
 947 slapi_ch_malloc( unsigned long size )
 948 {
 949 #ifdef LDAP_SLAPI
 950         return ch_malloc( size );
 951 #else /* LDAP_SLAPI */
 952         return NULL;
 953 #endif /* LDAP_SLAPI */
 954 }
 955
 956 void
 957 slapi_ch_free( void **ptr )
 958 {
 959 #ifdef LDAP_SLAPI
 960         ch_free( *ptr );
 961         *ptr = NULL;
 962 #endif /* LDAP_SLAPI */
 963 }
 964
 965 void
 966 slapi_ch_free_string( char **ptr )
 967 {
 968 #ifdef LDAP_SLAPI
 969         slapi_ch_free( (void **)ptr );
 970 #endif /* LDAP_SLAPI */
 971 }
 972
 973 void
 974 slapi_ch_array_free( char **arrayp )
 975 {
 976 #ifdef LDAP_SLAPI
 977         char **p;
 978
 979         if ( arrayp != NULL ) {
 980                 for ( p = arrayp; *p != NULL; p++ ) {
 981                         slapi_ch_free( (void **)p );
 982                 }
 983                 slapi_ch_free( (void **)&arrayp );
 984         }
 985 #endif
 986 }
 987
 988 struct berval *
 989 slapi_ch_bvdup(const struct berval *v)
 990 {
 991 #ifdef LDAP_SLAPI
 992         struct berval *bv;
 993
 994         bv = (struct berval *) slapi_ch_malloc( sizeof(struct berval) );
 995         bv->bv_len = v->bv_len;
 996         bv->bv_val = slapi_ch_malloc( bv->bv_len );
 997         AC_MEMCPY( bv->bv_val, v->bv_val, bv->bv_len );
 998
 999         return bv;
1000 #else
1001         return NULL;
1002 #endif
1003 }
1004
1005 struct berval **
1006 slapi_ch_bvecdup(const struct berval **v)
1007 {
1008 #ifdef LDAP_SLAPI
1009         int i;
1010         struct berval **rv;
1011
1012         if ( v == NULL ) {
1013                 return NULL;
1014         }
1015
1016         for ( i = 0; v[i] != NULL; i++ )
1017                 ;
1018
1019         rv = (struct berval **) slapi_ch_malloc( (i + 1) * sizeof(struct berval *) );
1020
1021         for ( i = 0; v[i] != NULL; i++ ) {
1022                 rv[i] = slapi_ch_bvdup( v[i] );
1023         }
1024         rv[i] = NULL;
1025
1026         return rv;
1027 #else
1028         return NULL;
1029 #endif
1030 }
1031
1032 char *
1033 slapi_ch_calloc(
1034         unsigned long nelem,
1035         unsigned long size )
1036 {
1037 #ifdef LDAP_SLAPI
1038         return ch_calloc( nelem, size );
1039 #else /* LDAP_SLAPI */
1040         return NULL;
1041 #endif /* LDAP_SLAPI */
1042 }
1043
1044 char *
1045 slapi_ch_realloc(
1046         char *block,
1047         unsigned long size )
1048 {
1049 #ifdef LDAP_SLAPI
1050         return ch_realloc( block, size );
1051 #else /* LDAP_SLAPI */
1052         return NULL;
1053 #endif /* LDAP_SLAPI */
1054 }
1055
1056 char *
1057 slapi_ch_strdup( char *s )
1058 {
1059 #ifdef LDAP_SLAPI
1060         return ch_strdup( (const char *)s );
1061 #else /* LDAP_SLAPI */
1062         return NULL;
1063 #endif /* LDAP_SLAPI */
1064 }
1065
1066 size_t
1067 slapi_ch_stlen( char *s )
1068 {
1069 #ifdef LDAP_SLAPI
1070         return strlen( (const char *)s );
1071 #else /* LDAP_SLAPI */
1072         return 0;
1073 #endif /* LDAP_SLAPI */
1074 }
1075
1076 int
1077 slapi_control_present(
1078         LDAPControl     **controls,
1079         char            *oid,
1080         struct berval   **val,
1081         int             *iscritical )
1082 {
1083 #ifdef LDAP_SLAPI
1084         int             i;
1085         int             rc = 0;
1086
1087         if ( val ) {
1088                 *val = NULL;
1089         }
1090
1091         if ( iscritical ) {
1092                 *iscritical = 0;
1093         }
1094
1095         for ( i = 0; controls != NULL && controls[i] != NULL; i++ ) {
1096                 if ( strcmp( controls[i]->ldctl_oid, oid ) != 0 ) {
1097                         continue;
1098                 }
1099
1100                 rc = 1;
1101                 if ( controls[i]->ldctl_value.bv_len != 0 ) {
1102                         /*
1103                          * FIXME: according to 6.1 specification,
1104                          *    "The val output parameter is set
1105                          *    to point into the controls array.
1106                          *    A copy of the control value is
1107                          *    not made."
1108                          */
1109 #if 0
1110                         struct berval   *pTmpBval;
1111
1112                         pTmpBval = (struct berval *)slapi_ch_malloc( sizeof(struct berval));
1113                         if ( pTmpBval == NULL ) {
1114                                 rc = 0;
1115                         } else {
1116                                 pTmpBval->bv_len = controls[i]->ldctl_value.bv_len;
1117                                 pTmpBval->bv_val = controls[i]->ldctl_value.bv_val;
1118                                 if ( val ) {
1119                                         *val = pTmpBval;
1120                                 } else {
1121                                         slapi_ch_free( (void **)&pTmpBval );
1122                                         rc = 0;
1123                                 }
1124                         }
1125 #endif /* 0 */
1126                         if ( val ) {
1127                                 *val = &controls[i]->ldctl_value;
1128                         }
1129                 }
1130
1131                 if ( iscritical ) {
1132                         *iscritical = controls[i]->ldctl_iscritical;
1133                 }
1134
1135                 break;
1136         }
1137
1138         return rc;
1139 #else /* LDAP_SLAPI */
1140         return 0;
1141 #endif /* LDAP_SLAPI */
1142 }
1143
1144 #ifdef LDAP_SLAPI
1145 static void
1146 slapControlMask2SlapiControlOp(slap_mask_t slap_mask,
1147         unsigned long *slapi_mask)
1148 {
1149         *slapi_mask = SLAPI_OPERATION_NONE;
1150
1151         if ( slap_mask & SLAP_CTRL_ABANDON )
1152                 *slapi_mask |= SLAPI_OPERATION_ABANDON;
1153
1154         if ( slap_mask & SLAP_CTRL_ADD )
1155                 *slapi_mask |= SLAPI_OPERATION_ADD;
1156
1157         if ( slap_mask & SLAP_CTRL_BIND )
1158                 *slapi_mask |= SLAPI_OPERATION_BIND;
1159
1160         if ( slap_mask & SLAP_CTRL_COMPARE )
1161                 *slapi_mask |= SLAPI_OPERATION_COMPARE;
1162
1163         if ( slap_mask & SLAP_CTRL_DELETE )
1164                 *slapi_mask |= SLAPI_OPERATION_DELETE;
1165
1166         if ( slap_mask & SLAP_CTRL_MODIFY )
1167                 *slapi_mask |= SLAPI_OPERATION_MODIFY;
1168
1169         if ( slap_mask & SLAP_CTRL_RENAME )
1170                 *slapi_mask |= SLAPI_OPERATION_MODDN;
1171
1172         if ( slap_mask & SLAP_CTRL_SEARCH )
1173                 *slapi_mask |= SLAPI_OPERATION_SEARCH;
1174
1175         if ( slap_mask & SLAP_CTRL_UNBIND )
1176                 *slapi_mask |= SLAPI_OPERATION_UNBIND;
1177 }
1178
1179 static void
1180 slapiControlOp2SlapControlMask(unsigned long slapi_mask,
1181         slap_mask_t *slap_mask)
1182 {
1183         *slap_mask = 0;
1184
1185         if ( slapi_mask & SLAPI_OPERATION_BIND )
1186                 *slap_mask |= SLAP_CTRL_BIND;
1187
1188         if ( slapi_mask & SLAPI_OPERATION_UNBIND )
1189                 *slap_mask |= SLAP_CTRL_UNBIND;
1190
1191         if ( slapi_mask & SLAPI_OPERATION_SEARCH )
1192                 *slap_mask |= SLAP_CTRL_SEARCH;
1193
1194         if ( slapi_mask & SLAPI_OPERATION_MODIFY )
1195                 *slap_mask |= SLAP_CTRL_MODIFY;
1196
1197         if ( slapi_mask & SLAPI_OPERATION_ADD )
1198                 *slap_mask |= SLAP_CTRL_ADD;
1199
1200         if ( slapi_mask & SLAPI_OPERATION_DELETE )
1201                 *slap_mask |= SLAP_CTRL_DELETE;
1202
1203         if ( slapi_mask & SLAPI_OPERATION_MODDN )
1204                 *slap_mask |= SLAP_CTRL_RENAME;
1205
1206         if ( slapi_mask & SLAPI_OPERATION_COMPARE )
1207                 *slap_mask |= SLAP_CTRL_COMPARE;
1208
1209         if ( slapi_mask & SLAPI_OPERATION_ABANDON )
1210                 *slap_mask |= SLAP_CTRL_ABANDON;
1211
1212         *slap_mask |= SLAP_CTRL_FRONTEND;
1213 }
1214
1215 static int
1216 parseSlapiControl(
1217         Operation *op,
1218         SlapReply *rs,
1219         LDAPControl *ctrl )
1220 {
1221         /* Plugins must deal with controls themselves. */
1222
1223         return LDAP_SUCCESS;
1224 }
1225 #endif /* LDAP_SLAPI */
1226
1227 void
1228 slapi_register_supported_control(
1229         char            *controloid,
1230         unsigned long   controlops )
1231 {
1232 #ifdef LDAP_SLAPI
1233         slap_mask_t controlmask;
1234
1235         slapiControlOp2SlapControlMask( controlops, &controlmask );
1236
1237         register_supported_control( controloid, controlmask, NULL, parseSlapiControl );
1238 #endif /* LDAP_SLAPI */
1239 }
1240
1241 int
1242 slapi_get_supported_controls(
1243         char            ***ctrloidsp,
1244         unsigned long   **ctrlopsp )
1245 {
1246 #ifdef LDAP_SLAPI
1247         int i, rc;
1248
1249         rc = get_supported_controls( ctrloidsp, (slap_mask_t **)ctrlopsp );
1250         if ( rc != LDAP_SUCCESS ) {
1251                 return rc;
1252         }
1253
1254         for ( i = 0; (*ctrloidsp)[i] != NULL; i++ ) {
1255                 /* In place, naughty. */
1256                 slapControlMask2SlapiControlOp( (*ctrlopsp)[i], &((*ctrlopsp)[i]) );
1257         }
1258
1259         return LDAP_SUCCESS;
1260 #else /* LDAP_SLAPI */
1261         return 1;
1262 #endif /* LDAP_SLAPI */
1263 }
1264
1265 LDAPControl *
1266 slapi_dup_control( LDAPControl *ctrl )
1267 {
1268 #ifdef LDAP_SLAPI
1269         LDAPControl *ret;
1270
1271         ret = (LDAPControl *)slapi_ch_malloc( sizeof(*ret) );
1272         ret->ldctl_oid = slapi_ch_strdup( ctrl->ldctl_oid );
1273         ber_dupbv( &ret->ldctl_value, &ctrl->ldctl_value );
1274         ret->ldctl_iscritical = ctrl->ldctl_iscritical;
1275
1276         return ret;
1277 #else
1278         return NULL;
1279 #endif /* LDAP_SLAPI */
1280 }
1281
1282 void
1283 slapi_register_supported_saslmechanism( char *mechanism )
1284 {
1285 #ifdef LDAP_SLAPI
1286         /* FIXME -- can not add saslmechanism to OpenLDAP dynamically */
1287         slapi_log_error( SLAPI_LOG_FATAL, "SLAPI_SASL",
1288                         "OpenLDAP does not support dynamic registration of SASL mechanisms\n" );
1289 #endif /* LDAP_SLAPI */
1290 }
1291
1292 char **
1293 slapi_get_supported_saslmechanisms( void )
1294 {
1295 #ifdef LDAP_SLAPI
1296         /* FIXME -- can not get the saslmechanism without a connection. */
1297         slapi_log_error( SLAPI_LOG_FATAL, "SLAPI_SASL",
1298                         "can not get the SASL mechanism list "
1299                         "without a connection\n" );
1300         return NULL;
1301 #else /* LDAP_SLAPI */
1302         return NULL;
1303 #endif /* LDAP_SLAPI */
1304 }
1305
1306 char **
1307 slapi_get_supported_extended_ops( void )
1308 {
1309 #ifdef LDAP_SLAPI
1310         int             i, j, k;
1311         char            **ppExtOpOID = NULL;
1312         int             numExtOps = 0;
1313
1314         for ( i = 0; get_supported_extop( i ) != NULL; i++ ) {
1315                 ;
1316         }
1317
1318         for ( j = 0; ns_get_supported_extop( j ) != NULL; j++ ) {
1319                 ;
1320         }
1321
1322         numExtOps = i + j;
1323         if ( numExtOps == 0 ) {
1324                 return NULL;
1325         }
1326
1327         ppExtOpOID = (char **)slapi_ch_malloc( (numExtOps + 1) * sizeof(char *) );
1328         for ( k = 0; k < i; k++ ) {
1329                 struct berval   *bv;
1330
1331                 bv = get_supported_extop( k );
1332                 assert( bv != NULL );
1333
1334                 ppExtOpOID[ k ] = bv->bv_val;
1335         }
1336
1337         for ( ; k < j; k++ ) {
1338                 struct berval   *bv;
1339
1340                 bv = ns_get_supported_extop( k );
1341                 assert( bv != NULL );
1342
1343                 ppExtOpOID[ i + k ] = bv->bv_val;
1344         }
1345         ppExtOpOID[ i + k ] = NULL;
1346
1347         return ppExtOpOID;
1348 #else /* LDAP_SLAPI */
1349         return NULL;
1350 #endif /* LDAP_SLAPI */
1351 }
1352
1353 void
1354 slapi_send_ldap_result(
1355         Slapi_PBlock    *pb,
1356         int             err,
1357         char            *matched,
1358         char            *text,
1359         int             nentries,
1360         struct berval   **urls )
1361 {
1362 #ifdef LDAP_SLAPI
1363         Operation       *op;
1364         struct berval   *s;
1365         char            *extOID = NULL;
1366         struct berval   *extValue = NULL;
1367         int             rc;
1368         SlapReply       rs = { REP_RESULT };
1369
1370         slapi_pblock_get( pb, SLAPI_OPERATION, &op );
1371
1372         rs.sr_err = err;
1373         rs.sr_matched = matched;
1374         rs.sr_text = text;
1375         rs.sr_ref = NULL;
1376         rs.sr_ctrls = NULL;
1377
1378         slapi_pblock_get( pb, SLAPI_RESCONTROLS, &rs.sr_ctrls );
1379
1380         if ( err == LDAP_SASL_BIND_IN_PROGRESS ) {
1381                 slapi_pblock_get( pb, SLAPI_BIND_RET_SASLCREDS, (void *) &rs.sr_sasldata );
1382                 send_ldap_sasl( op, &rs );
1383                 return;
1384         }
1385
1386         slapi_pblock_get( pb, SLAPI_EXT_OP_RET_OID, &extOID );
1387         if ( extOID != NULL ) {
1388                 rs.sr_rspoid = extOID;
1389                 slapi_pblock_get( pb, SLAPI_EXT_OP_RET_VALUE, &rs.sr_rspdata );
1390                 send_ldap_extended( op, &rs );
1391                 return;
1392         }
1393
1394         if (op->o_tag == LDAP_REQ_SEARCH)
1395                 rs.sr_nentries = nentries;
1396
1397         send_ldap_result( op, &rs );
1398 #endif /* LDAP_SLAPI */
1399 }
1400
1401 int
1402 slapi_send_ldap_search_entry(
1403         Slapi_PBlock    *pb,
1404         Slapi_Entry     *e,
1405         LDAPControl     **ectrls,
1406         char            **attrs,
1407         int             attrsonly )
1408 {
1409 #ifdef LDAP_SLAPI
1410         Operation       *pOp;
1411         SlapReply       rs = { REP_RESULT };
1412         int             i;
1413         AttributeName   *an = NULL;
1414         const char      *text;
1415
1416         for ( i = 0; attrs[ i ] != NULL; i++ ) {
1417                 ; /* empty */
1418         }
1419
1420         if ( i > 0 ) {
1421                 an = (AttributeName *) ch_malloc( (i+1) * sizeof(AttributeName) );
1422                 for ( i = 0; attrs[i] != NULL; i++ ) {
1423                         an[i].an_name.bv_val = ch_strdup( attrs[i] );
1424                         an[i].an_name.bv_len = strlen( attrs[i] );
1425                         an[i].an_desc = NULL;
1426                         if( slap_bv2ad( &an[i].an_name, &an[i].an_desc, &text ) != LDAP_SUCCESS)
1427                                 return -1;
1428                 }
1429                 an[i].an_name.bv_len = 0;
1430                 an[i].an_name.bv_val = NULL;
1431         }
1432
1433         rs.sr_err = LDAP_SUCCESS;
1434         rs.sr_matched = NULL;
1435         rs.sr_text = NULL;
1436         rs.sr_ref = NULL;
1437         rs.sr_ctrls = ectrls;
1438         rs.sr_attrs = an;
1439         rs.sr_entry = e;
1440         rs.sr_v2ref = NULL;
1441
1442         if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&pOp ) != 0 ) {
1443                 return LDAP_OTHER;
1444         }
1445
1446         return send_search_entry( pOp, &rs );
1447 #else /* LDAP_SLAPI */
1448         return -1;
1449 #endif /* LDAP_SLAPI */
1450 }
1451
1452
1453 Slapi_Filter *
1454 slapi_str2filter( char *str )
1455 {
1456 #ifdef LDAP_SLAPI
1457         return str2filter( str );
1458 #else /* LDAP_SLAPI */
1459         return NULL;
1460 #endif /* LDAP_SLAPI */
1461 }
1462
1463 void
1464 slapi_filter_free(
1465         Slapi_Filter    *f,
1466         int             recurse )
1467 {
1468 #ifdef LDAP_SLAPI
1469         filter_free( f );
1470 #endif /* LDAP_SLAPI */
1471 }
1472
1473 Slapi_Filter *
1474 slapi_filter_dup( Slapi_Filter *filter )
1475 {
1476 #ifdef LDAP_SLAPI
1477         Filter *f;
1478
1479         f = (Filter *) slapi_ch_malloc( sizeof(Filter) );
1480         f->f_next = NULL;
1481         f->f_choice = filter->f_choice;
1482
1483         switch ( f->f_choice ) {
1484         case LDAP_FILTER_AND:
1485         case LDAP_FILTER_NOT:
1486         case LDAP_FILTER_OR: {
1487                 Filter *pFilter, **ppF;
1488
1489                 for ( pFilter = filter->f_list, ppF = &f->f_list;
1490                       pFilter != NULL;
1491                       pFilter = pFilter->f_next, ppF = &f->f_next )
1492                 {
1493                         *ppF = slapi_filter_dup( pFilter );
1494                         if ( *ppF == NULL )
1495                                 break;
1496                 }
1497                 break;
1498         }
1499         case LDAP_FILTER_PRESENT:
1500                 f->f_desc = filter->f_desc;
1501                 break;
1502         case LDAP_FILTER_EQUALITY:
1503         case LDAP_FILTER_GE:
1504         case LDAP_FILTER_LE:
1505         case LDAP_FILTER_APPROX:
1506                 f->f_ava = (AttributeAssertion *)slapi_ch_malloc( sizeof(AttributeAssertion) );
1507                 f->f_ava->aa_desc = filter->f_ava->aa_desc;
1508                 ber_dupbv( &f->f_ava->aa_value, &filter->f_ava->aa_value );
1509                 break;
1510         case LDAP_FILTER_EXT:
1511                 f->f_mra = (MatchingRuleAssertion *)slapi_ch_malloc( sizeof(MatchingRuleAssertion) );
1512                 f->f_mra->ma_rule = filter->f_mra->ma_rule;
1513                 f->f_mra->ma_rule_text = filter->f_mra->ma_rule_text; /* struct copy */
1514                 f->f_mra->ma_desc = filter->f_mra->ma_desc;
1515                 f->f_mra->ma_dnattrs = filter->f_mra->ma_dnattrs;
1516                 ber_dupbv( &f->f_mra->ma_value, &filter->f_mra->ma_value );
1517         case LDAP_FILTER_SUBSTRINGS: {
1518                 int i;
1519
1520                 f->f_sub = (SubstringsAssertion *)slapi_ch_malloc( sizeof(SubstringsAssertion) );
1521                 ber_dupbv( &f->f_sub_initial, &filter->f_sub_initial );
1522                 for ( i = 0; filter->f_sub_any[i].bv_val != NULL; i++ )
1523                         ;
1524                 f->f_sub_any = (BerVarray)slapi_ch_malloc( (i + 1) * (sizeof(struct berval)) );
1525                 for ( i = 0; filter->f_sub_any[i].bv_val != NULL; i++ ) {
1526                         ber_dupbv( &f->f_sub_any[i], &filter->f_sub_any[i] );
1527                 }
1528                 f->f_sub_any[i].bv_val = NULL;
1529                 ber_dupbv( &f->f_sub_final, &filter->f_sub_final );
1530                 break;
1531         }
1532         case SLAPD_FILTER_COMPUTED:
1533                 f->f_result = filter->f_result;
1534                 break;
1535         default:
1536                 slapi_ch_free( (void **)&f );
1537                 f = NULL;
1538                 break;
1539         }
1540
1541         return f;
1542 #else
1543         return NULL;
1544 #endif /* LDAP_SLAPI */
1545 }
1546
1547 int
1548 slapi_filter_get_choice( Slapi_Filter *f )
1549 {
1550 #ifdef LDAP_SLAPI
1551         int             rc;
1552
1553         if ( f != NULL ) {
1554                 rc = f->f_choice;
1555         } else {
1556                 rc = 0;
1557         }
1558
1559         return rc;
1560 #else /* LDAP_SLAPI */
1561         return -1;              /* invalid filter type */
1562 #endif /* LDAP_SLAPI */
1563 }
1564
1565 int
1566 slapi_filter_get_ava(
1567         Slapi_Filter    *f,
1568         char            **type,
1569         struct berval   **bval )
1570 {
1571 #ifdef LDAP_SLAPI
1572         int             ftype;
1573         int             rc = LDAP_SUCCESS;
1574
1575         assert( type != NULL );
1576         assert( bval != NULL );
1577
1578         *type = NULL;
1579         *bval = NULL;
1580
1581         ftype = f->f_choice;
1582         if ( ftype == LDAP_FILTER_EQUALITY
1583                         || ftype ==  LDAP_FILTER_GE
1584                         || ftype == LDAP_FILTER_LE
1585                         || ftype == LDAP_FILTER_APPROX ) {
1586                 /*
1587                  * According to the SLAPI Reference Manual these are
1588                  * not duplicated.
1589                  */
1590                 *type = f->f_un.f_un_ava->aa_desc->ad_cname.bv_val;
1591                 *bval = &f->f_un.f_un_ava->aa_value;
1592         } else { /* filter type not supported */
1593                 rc = -1;
1594         }
1595
1596         return rc;
1597 #else /* LDAP_SLAPI */
1598         return -1;
1599 #endif /* LDAP_SLAPI */
1600 }
1601
1602 Slapi_Filter *
1603 slapi_filter_list_first( Slapi_Filter *f )
1604 {
1605 #ifdef LDAP_SLAPI
1606         int             ftype;
1607
1608         if ( f == NULL ) {
1609                 return NULL;
1610         }
1611
1612         ftype = f->f_choice;
1613         if ( ftype == LDAP_FILTER_AND
1614                         || ftype == LDAP_FILTER_OR
1615                         || ftype == LDAP_FILTER_NOT ) {
1616                 return (Slapi_Filter *)f->f_and;
1617         } else {
1618                 return NULL;
1619         }
1620 #else /* LDAP_SLAPI */
1621         return NULL;
1622 #endif /* LDAP_SLAPI */
1623 }
1624
1625 Slapi_Filter *
1626 slapi_filter_list_next(
1627         Slapi_Filter    *f,
1628         Slapi_Filter    *fprev )
1629 {
1630 #ifdef LDAP_SLAPI
1631         int             ftype;
1632
1633         if ( f == NULL ) {
1634                 return NULL;
1635         }
1636
1637         ftype = f->f_choice;
1638         if ( ftype == LDAP_FILTER_AND
1639                         || ftype == LDAP_FILTER_OR
1640                         || ftype == LDAP_FILTER_NOT )
1641         {
1642                 return fprev->f_next;
1643         }
1644
1645         return NULL;
1646 #else /* LDAP_SLAPI */
1647         return NULL;
1648 #endif /* LDAP_SLAPI */
1649 }
1650
1651 int
1652 slapi_filter_get_attribute_type( Slapi_Filter *f, char **type )
1653 {
1654 #ifdef LDAP_SLAPI
1655         if ( f == NULL ) {
1656                 return -1;
1657         }
1658
1659         switch ( f->f_choice ) {
1660         case LDAP_FILTER_GE:
1661         case LDAP_FILTER_LE:
1662         case LDAP_FILTER_EQUALITY:
1663         case LDAP_FILTER_APPROX:
1664                 *type = f->f_av_desc->ad_cname.bv_val;
1665                 break;
1666         case LDAP_FILTER_SUBSTRINGS:
1667                 *type = f->f_sub_desc->ad_cname.bv_val;
1668                 break;
1669         case LDAP_FILTER_PRESENT:
1670                 *type = f->f_desc->ad_cname.bv_val;
1671                 break;
1672         case LDAP_FILTER_EXT:
1673                 *type = f->f_mr_desc->ad_cname.bv_val;
1674                 break;
1675         default:
1676                 /* Complex filters need not apply. */
1677                 *type = NULL;
1678                 return -1;
1679         }
1680
1681         return 0;
1682 #else
1683         return -1;
1684 #endif /* LDAP_SLAPI */
1685 }
1686
1687 int
1688 slapi_filter_get_subfilt( Slapi_Filter *f, char **type, char **initial,
1689         char ***any, char **final )
1690 {
1691 #ifdef LDAP_SLAPI
1692         int i;
1693
1694         if ( f->f_choice != LDAP_FILTER_SUBSTRINGS ) {
1695                 return -1;
1696         }
1697
1698         /*
1699          * The caller shouldn't free but we can't return an
1700          * array of char *s from an array of bervals without
1701          * allocating memory, so we may as well be consistent.
1702          * XXX
1703          */
1704         *type = f->f_sub_desc->ad_cname.bv_val;
1705         *initial = f->f_sub_initial.bv_val ? slapi_ch_strdup(f->f_sub_initial.bv_val) : NULL;
1706         for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ )
1707                 ;
1708         *any = (char **)slapi_ch_malloc( (i + 1) * sizeof(char *) );
1709         for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ ) {
1710                 (*any)[i] = slapi_ch_strdup(f->f_sub_any[i].bv_val);
1711         }
1712         (*any)[i] = NULL;
1713         *final = f->f_sub_final.bv_val ? slapi_ch_strdup(f->f_sub_final.bv_val) : NULL;
1714
1715         return 0;
1716 #else
1717         return -1;
1718 #endif /* LDAP_SLAPI */
1719 }
1720
1721 Slapi_Filter *
1722 slapi_filter_join( int ftype, Slapi_Filter *f1, Slapi_Filter *f2)
1723 {
1724 #ifdef LDAP_SLAPI
1725         Slapi_Filter *f = NULL;
1726
1727         if ( ftype == LDAP_FILTER_AND ||
1728              ftype == LDAP_FILTER_OR ||
1729              ftype == LDAP_FILTER_NOT )
1730         {
1731                 f = (Slapi_Filter *)slapi_ch_malloc( sizeof(*f) );
1732                 f->f_choice = ftype;
1733                 f->f_list = f1;
1734                 f->f_next = f2;
1735         }
1736
1737         return f;
1738 #else
1739         return NULL;
1740 #endif /* LDAP_SLAPI */
1741 }
1742
1743 int
1744 slapi_filter_test( Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Filter *f,
1745         int verify_access )
1746 {
1747 #ifdef LDAP_SLAPI
1748         Backend *be = NULL;
1749         Connection *conn;
1750         Operation *op;
1751         int rc;
1752
1753         if ( f == NULL ) {
1754                 /* spec says return zero if no filter. */
1755                 return 0;
1756         }
1757
1758         if ( verify_access ) {
1759                 (void) slapi_pblock_get(pb, SLAPI_BACKEND, (void *)&be);
1760                 rc = slapi_pblock_get(pb, SLAPI_CONNECTION, (void *)&conn);
1761                 if ( rc != 0 ) {
1762                         return LDAP_PARAM_ERROR;
1763                 }
1764                 rc = slapi_pblock_get(pb, SLAPI_OPERATION, (void *)&op);
1765                 if ( rc != 0 ) {
1766                         return LDAP_PARAM_ERROR;
1767                 }
1768         } else {
1769                 conn = NULL;
1770                 op = NULL;
1771         }
1772         /*
1773          * According to acl.c it is safe to call test_filter() with
1774          * NULL arguments...
1775          */
1776         rc = test_filter( op, e, f );
1777         switch (rc) {
1778         case LDAP_COMPARE_TRUE:
1779                 rc = 0;
1780                 break;
1781         case LDAP_COMPARE_FALSE:
1782                 break;
1783         case SLAPD_COMPARE_UNDEFINED:
1784                 rc = LDAP_OTHER;
1785                 break;
1786         case LDAP_PROTOCOL_ERROR:
1787                 /* filter type unknown: spec says return -1 */
1788                 rc = -1;
1789                 break;
1790         }
1791
1792         return rc;
1793 #else
1794         return -1;
1795 #endif /* LDAP_SLAPI */
1796 }
1797
1798 int
1799 slapi_filter_test_simple( Slapi_Entry *e, Slapi_Filter *f)
1800 {
1801 #ifdef LDAP_SLAPI
1802         return slapi_filter_test( NULL, e, f, 0 );
1803 #else
1804         return -1;
1805 #endif
1806 }
1807
1808 int
1809 slapi_filter_apply( Slapi_Filter *f, FILTER_APPLY_FN fn, void *arg, int *error_code )
1810 {
1811 #ifdef LDAP_SLAPI
1812         switch ( f->f_choice ) {
1813         case LDAP_FILTER_AND:
1814         case LDAP_FILTER_NOT:
1815         case LDAP_FILTER_OR: {
1816                 int rc;
1817
1818                 /*
1819                  * FIXME: altering f; should we use a temporary?
1820                  */
1821                 for ( f = f->f_list; f != NULL; f = f->f_next ) {
1822                         rc = slapi_filter_apply( f, fn, arg, error_code );
1823                         if ( rc != 0 ) {
1824                                 return rc;
1825                         }
1826                         if ( *error_code == SLAPI_FILTER_SCAN_NOMORE ) {
1827                                 break;
1828                         }
1829                 }
1830                 break;
1831         }
1832         case LDAP_FILTER_EQUALITY:
1833         case LDAP_FILTER_SUBSTRINGS:
1834         case LDAP_FILTER_GE:
1835         case LDAP_FILTER_LE:
1836         case LDAP_FILTER_PRESENT:
1837         case LDAP_FILTER_APPROX:
1838         case LDAP_FILTER_EXT:
1839                 *error_code = fn( f, arg );
1840                 break;
1841         default:
1842                 *error_code = SLAPI_FILTER_UNKNOWN_FILTER_TYPE;
1843         }
1844
1845         if ( *error_code == SLAPI_FILTER_SCAN_NOMORE ||
1846              *error_code == SLAPI_FILTER_SCAN_CONTINUE ) {
1847                 return 0;
1848         }
1849
1850         return -1;
1851 #else
1852         *error_code = SLAPI_FILTER_UNKNOWN_FILTER_TYPE;
1853         return -1;
1854 #endif /* LDAP_SLAPI */
1855 }
1856
1857 int
1858 slapi_send_ldap_extended_response(
1859         Connection      *conn,
1860         Operation       *op,
1861         int             errornum,
1862         char            *respName,
1863         struct berval   *response )
1864 {
1865 #ifdef LDAP_SLAPI
1866         SlapReply       rs;
1867
1868         rs.sr_err = errornum;
1869         rs.sr_matched = NULL;
1870         rs.sr_text = NULL;
1871         rs.sr_ref = NULL;
1872         rs.sr_ctrls = NULL;
1873         rs.sr_rspoid = respName;
1874         rs.sr_rspdata = response;
1875
1876         send_ldap_extended( op, &rs );
1877
1878         return LDAP_SUCCESS;
1879 #else /* LDAP_SLAPI */
1880         return -1;
1881 #endif /* LDAP_SLAPI */
1882 }
1883
1884 int
1885 slapi_pw_find(
1886         struct berval   **vals,
1887         struct berval   *v )
1888 {
1889 #ifdef LDAP_SLAPI
1890         /*
1891          * FIXME: what's the point?
1892          */
1893         return 1;
1894 #else /* LDAP_SLAPI */
1895         return 1;
1896 #endif /* LDAP_SLAPI */
1897 }
1898
1899 #define MAX_HOSTNAME 512
1900
1901 char *
1902 slapi_get_hostname( void )
1903 {
1904 #ifdef LDAP_SLAPI
1905         char            *hn = NULL;
1906
1907         /*
1908          * FIXME: I'd prefer a different check ...
1909          */
1910 #if defined _SPARC
1911         hn = (char *)slapi_ch_malloc( MAX_HOSTNAME );
1912         if ( hn == NULL) {
1913                 slapi_log_error( SLAPI_LOG_FATAL, "SLAPI_SYSINFO",
1914                                 "can't malloc memory for hostname\n" );
1915                 hn = NULL;
1916
1917         } else if ( sysinfo( SI_HOSTNAME, hn, MAX_HOSTNAME ) < 0 ) {
1918                 slapi_log_error( SLAPI_LOG_FATAL, "SLAPI_SYSINFO",
1919                                 "can't get hostname\n" );
1920                 slapi_ch_free( (void **)&hn );
1921                 hn = NULL;
1922         }
1923 #else /* !_SPARC */
1924         static int      been_here = 0;
1925         static char     *static_hn = NULL;
1926
1927         ldap_pvt_thread_mutex_lock( &slapi_hn_mutex );
1928         if ( !been_here ) {
1929                 static_hn = (char *)slapi_ch_malloc( MAX_HOSTNAME );
1930                 if ( static_hn == NULL) {
1931                         slapi_log_error( SLAPI_LOG_FATAL, "SLAPI_SYSINFO",
1932                                         "can't malloc memory for hostname\n" );
1933                         static_hn = NULL;
1934                         ldap_pvt_thread_mutex_unlock( &slapi_hn_mutex );
1935
1936                         return hn;
1937
1938                 } else {
1939                         if ( gethostname( static_hn, MAX_HOSTNAME ) != 0 ) {
1940                                 slapi_log_error( SLAPI_LOG_FATAL,
1941                                                 "SLAPI_SYSINFO",
1942                                                 "can't get hostname\n" );
1943                                 slapi_ch_free( (void **)&static_hn );
1944                                 static_hn = NULL;
1945                                 ldap_pvt_thread_mutex_unlock( &slapi_hn_mutex );
1946
1947                                 return hn;
1948
1949                         } else {
1950                                 been_here = 1;
1951                         }
1952                 }
1953         }
1954         ldap_pvt_thread_mutex_unlock( &slapi_hn_mutex );
1955
1956         hn = ch_strdup( static_hn );
1957 #endif /* !_SPARC */
1958
1959         return hn;
1960 #else /* LDAP_SLAPI */
1961         return NULL;
1962 #endif /* LDAP_SLAPI */
1963 }
1964
1965 /*
1966  * FIXME: this should go in an appropriate header ...
1967  */
1968 extern int vLogError( int level, char *subsystem, char *fmt, va_list arglist );
1969
1970 int
1971 slapi_log_error(
1972         int             severity,
1973         char            *subsystem,
1974         char            *fmt,
1975         ... )
1976 {
1977 #ifdef LDAP_SLAPI
1978         int             rc = LDAP_SUCCESS;
1979         va_list         arglist;
1980
1981         va_start( arglist, fmt );
1982         rc = vLogError( severity, subsystem, fmt, arglist );
1983         va_end( arglist );
1984
1985         return rc;
1986 #else /* LDAP_SLAPI */
1987         return -1;
1988 #endif /* LDAP_SLAPI */
1989 }
1990
1991
1992 unsigned long
1993 slapi_timer_current_time( void )
1994 {
1995 #ifdef LDAP_SLAPI
1996         static int      first_time = 1;
1997 #if !defined (_WIN32)
1998         struct timeval  now;
1999         unsigned long   ret;
2000
2001         ldap_pvt_thread_mutex_lock( &slapi_time_mutex );
2002         if (first_time) {
2003                 first_time = 0;
2004                 gettimeofday( &base_time, NULL );
2005         }
2006         gettimeofday( &now, NULL );
2007         ret = ( now.tv_sec  - base_time.tv_sec ) * 1000000 +
2008                         (now.tv_usec - base_time.tv_usec);
2009         ldap_pvt_thread_mutex_unlock( &slapi_time_mutex );
2010
2011         return ret;
2012
2013         /*
2014          * Ain't it better?
2015         return (slap_get_time() - starttime) * 1000000;
2016          */
2017 #else /* _WIN32 */
2018         LARGE_INTEGER now;
2019
2020         if ( first_time ) {
2021                 first_time = 0;
2022                 performance_counter_present = QueryPerformanceCounter( &base_time );
2023                 QueryPerformanceFrequency( &performance_freq );
2024         }
2025
2026         if ( !performance_counter_present )
2027              return 0;
2028
2029         QueryPerformanceCounter( &now );
2030         return (1000000*(now.QuadPart-base_time.QuadPart))/performance_freq.QuadPart;
2031 #endif /* _WIN32 */
2032 #else /* LDAP_SLAPI */
2033         return 0;
2034 #endif /* LDAP_SLAPI */
2035 }
2036
2037 /*
2038  * FIXME ?
2039  */
2040 unsigned long
2041 slapi_timer_get_time( char *label )
2042 {
2043 #ifdef LDAP_SLAPI
2044         unsigned long start = slapi_timer_current_time();
2045         printf("%10ld %10ld usec %s\n", start, 0, label);
2046         return start;
2047 #else /* LDAP_SLAPI */
2048         return 0;
2049 #endif /* LDAP_SLAPI */
2050 }
2051
2052 /*
2053  * FIXME ?
2054  */
2055 void
2056 slapi_timer_elapsed_time(
2057         char *label,
2058         unsigned long start )
2059 {
2060 #ifdef LDAP_SLAPI
2061         unsigned long stop = slapi_timer_current_time();
2062         printf ("%10ld %10ld usec %s\n", stop, stop - start, label);
2063 #endif /* LDAP_SLAPI */
2064 }
2065
2066 void
2067 slapi_free_search_results_internal( Slapi_PBlock *pb )
2068 {
2069 #ifdef LDAP_SLAPI
2070         Slapi_Entry     **entries;
2071         int             k = 0, nEnt = 0;
2072
2073         slapi_pblock_get( pb, SLAPI_NENTRIES, &nEnt );
2074         slapi_pblock_get( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries );
2075         if ( nEnt == 0 ) {
2076                 return;
2077         }
2078
2079         if ( entries == NULL ) {
2080                 return;
2081         }
2082
2083         for ( k = 0; k < nEnt; k++ ) {
2084                 slapi_entry_free( entries[k] );
2085         }
2086
2087         slapi_ch_free( (void **)&entries );
2088 #endif /* LDAP_SLAPI */
2089 }
2090
2091 #ifdef LDAP_SLAPI
2092 /*
2093  * Internal API to prime a Slapi_PBlock with a Backend.
2094  */
2095 static int initBackendPB( Slapi_PBlock *pb, Backend *be )
2096 {
2097         int rc;
2098
2099         rc = slapi_pblock_set( pb, SLAPI_BACKEND, (void *)be );
2100         if ( rc != LDAP_SUCCESS )
2101                 return rc;
2102
2103         if ( be != NULL ) {
2104                 rc = slapi_pblock_set( pb, SLAPI_BE_TYPE, (void *)be->bd_info->bi_type );
2105                 if ( rc != LDAP_SUCCESS )
2106                         return rc;
2107         }
2108
2109         return LDAP_SUCCESS;
2110 }
2111
2112 /*
2113  * If oldStyle is TRUE, then a value suitable for setting to
2114  * the deprecated SLAPI_CONN_AUTHTYPE value is returned
2115  * (pointer to static storage).
2116  *
2117  * If oldStyle is FALSE, then a value suitable for setting to
2118  * the new SLAPI_CONN_AUTHMETHOD will be returned, which is
2119  * a pointer to allocated memory and will include the SASL
2120  * mechanism (if any).
2121  */
2122 static char *Authorization2AuthType( AuthorizationInformation *authz, int is_tls, int oldStyle )
2123 {
2124         size_t len;
2125         char *authType;
2126
2127         switch ( authz->sai_method ) {
2128         case LDAP_AUTH_SASL:
2129                 if ( oldStyle ) {
2130                         authType = SLAPD_AUTH_SASL;
2131                 } else {
2132                         len = sizeof(SLAPD_AUTH_SASL) + authz->sai_mech.bv_len;
2133                         authType = slapi_ch_malloc( len );
2134                         snprintf( authType, len, "%s%s", SLAPD_AUTH_SASL, authz->sai_mech.bv_val );
2135                 }
2136                 break;
2137         case LDAP_AUTH_SIMPLE:
2138                 authType = oldStyle ? SLAPD_AUTH_SIMPLE : slapi_ch_strdup( SLAPD_AUTH_SIMPLE );
2139                 break;
2140         case LDAP_AUTH_NONE:
2141                 authType = oldStyle ? SLAPD_AUTH_NONE : slapi_ch_strdup( SLAPD_AUTH_NONE );
2142                 break;
2143         default:
2144                 authType = NULL;
2145                 break;
2146         }
2147         if ( is_tls && authType == NULL ) {
2148                 authType = oldStyle ? SLAPD_AUTH_SSL : slapi_ch_strdup( SLAPD_AUTH_SSL );
2149         }
2150
2151         return authType;
2152 }
2153
2154 /*
2155  * Internal API to prime a Slapi_PBlock with a Connection.
2156  */
2157 static int initConnectionPB( Slapi_PBlock *pb, Connection *conn )
2158 {
2159         char *connAuthType;
2160         int rc;
2161
2162         rc = slapi_pblock_set( pb, SLAPI_CONNECTION, (void *)conn );
2163         if ( rc != LDAP_SUCCESS )
2164                 return rc;
2165
2166         if ( strncmp( conn->c_peer_name.bv_val, "IP=", 3 ) == 0 ) {
2167                 rc = slapi_pblock_set( pb, SLAPI_CONN_CLIENTIP, (void *)&conn->c_peer_name.bv_val[3] );
2168                 if ( rc != LDAP_SUCCESS )
2169                         return rc;
2170         } else if ( strncmp( conn->c_peer_name.bv_val, "PATH=", 5 ) == 0 ) {
2171                 rc = slapi_pblock_set( pb, SLAPI_X_CONN_CLIENTPATH, (void *)&conn->c_peer_name.bv_val[5] );
2172                 if ( rc != LDAP_SUCCESS )
2173                         return rc;
2174         }
2175
2176         if ( strncmp( conn->c_sock_name.bv_val, "IP=", 3 ) == 0 ) {
2177                 rc = slapi_pblock_set( pb, SLAPI_CONN_SERVERIP, (void *)&conn->c_sock_name.bv_val[3] );
2178                 if ( rc != LDAP_SUCCESS )
2179                         return rc;
2180         } else if ( strncmp( conn->c_sock_name.bv_val, "PATH=", 5 ) == 0 ) {
2181                 rc = slapi_pblock_set( pb, SLAPI_X_CONN_SERVERPATH, (void *)&conn->c_sock_name.bv_val[5] );
2182                 if ( rc != LDAP_SUCCESS )
2183                         return rc;
2184         }
2185
2186 #ifdef LDAP_CONNECTIONLESS
2187         rc = slapi_pblock_set( pb, SLAPI_X_CONN_IS_UDP, (void *)conn->c_is_udp );
2188         if ( rc != LDAP_SUCCESS )
2189                 return rc;
2190 #endif
2191
2192         rc = slapi_pblock_set( pb, SLAPI_CONN_ID, (void *)conn->c_connid );
2193         if ( rc != LDAP_SUCCESS )
2194                 return rc;
2195
2196         /* Returns pointer to static string */
2197         connAuthType = Authorization2AuthType( &conn->c_authz, conn->c_is_tls, 1 );
2198         if ( connAuthType != NULL ) {
2199                 rc = slapi_pblock_set(pb, SLAPI_CONN_AUTHTYPE, (void *)connAuthType);
2200                 if ( rc != LDAP_SUCCESS )
2201                         return rc;
2202         }
2203
2204         /* Returns pointer to allocated string */
2205         connAuthType = Authorization2AuthType( &conn->c_authz, conn->c_is_tls, 0 );
2206         if ( connAuthType != NULL ) {
2207                 rc = slapi_pblock_set(pb, SLAPI_CONN_AUTHMETHOD, (void *)connAuthType);
2208                 if ( rc != LDAP_SUCCESS )
2209                         return rc;
2210         }
2211
2212         if ( conn->c_authz.sai_dn.bv_val != NULL ) {
2213                 char *connDn = slapi_ch_strdup(conn->c_authz.sai_dn.bv_val);
2214                 rc = slapi_pblock_set(pb, SLAPI_CONN_DN, (void *)connDn);
2215                 if ( rc != LDAP_SUCCESS )
2216                         return rc;
2217         }
2218
2219         return rc;
2220 }
2221 #endif /* LDAP_SLAPI */
2222
2223 /*
2224  * Internal API to prime a Slapi_PBlock with an Operation.
2225  */
2226 int slapi_x_pblock_set_operation( Slapi_PBlock *pb, Operation *op )
2227 {
2228 #ifdef LDAP_SLAPI
2229         int isRoot = 0;
2230         int isUpdateDn = 0;
2231         int rc;
2232         char *opAuthType;
2233
2234         if ( op->o_bd != NULL ) {
2235                 isRoot = be_isroot( op->o_bd, &op->o_ndn );
2236                 isUpdateDn = be_isupdate( op->o_bd, &op->o_ndn );
2237         }
2238
2239         rc = initBackendPB( pb, op->o_bd );
2240         if ( rc != LDAP_SUCCESS )
2241                 return rc;
2242
2243         rc = initConnectionPB( pb, op->o_conn );
2244         if ( rc != LDAP_SUCCESS )
2245                 return rc;
2246
2247         rc = slapi_pblock_set( pb, SLAPI_OPERATION, (void *)op );
2248         if ( rc != LDAP_SUCCESS )
2249                 return rc;
2250
2251         rc = slapi_pblock_set( pb, SLAPI_OPINITIATED_TIME, (void *)op->o_time );
2252         if ( rc != LDAP_SUCCESS )
2253                 return rc;
2254
2255         rc = slapi_pblock_set( pb, SLAPI_OPERATION_ID, (void *)op->o_opid );
2256         if ( rc != LDAP_SUCCESS )
2257                 return rc;
2258
2259         rc = slapi_pblock_set( pb, SLAPI_OPERATION_TYPE, (void *)op->o_tag );
2260         if ( rc != LDAP_SUCCESS )
2261                 return rc;
2262
2263         rc = slapi_pblock_set( pb, SLAPI_REQUESTOR_ISROOT, (void *)isRoot );
2264         if ( rc != LDAP_SUCCESS )
2265                 return rc;
2266
2267         rc = slapi_pblock_set( pb, SLAPI_REQUESTOR_ISUPDATEDN, (void *)isUpdateDn );
2268         if ( rc != LDAP_SUCCESS )
2269                 return rc;
2270
2271         rc = slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)op->o_ctrls );
2272         if ( rc != LDAP_SUCCESS)
2273                 return rc;
2274
2275         rc = slapi_pblock_set( pb, SLAPI_REQUESTOR_DN, (void *)op->o_ndn.bv_val );
2276         if ( rc != LDAP_SUCCESS )
2277                 return rc;
2278
2279         rc = slapi_pblock_get( pb, SLAPI_CONN_AUTHMETHOD, (void *)&opAuthType );
2280         if ( rc == LDAP_SUCCESS && opAuthType != NULL ) {
2281                 /* Not quite sure what the point of this is. */
2282                 rc = slapi_pblock_set( pb, SLAPI_OPERATION_AUTHTYPE, (void *)opAuthType );
2283                 if ( rc != LDAP_SUCCESS )
2284                         return rc;
2285         }
2286
2287         return LDAP_SUCCESS;
2288 #else
2289         return -1;
2290 #endif
2291 }
2292
2293 int slapi_is_connection_ssl( Slapi_PBlock *pb, int *isSSL )
2294 {
2295 #ifdef LDAP_SLAPI
2296         Connection *conn;
2297
2298         slapi_pblock_get( pb, SLAPI_CONNECTION, &conn );
2299         *isSSL = conn->c_is_tls;
2300
2301         return LDAP_SUCCESS;
2302 #else
2303         return -1;
2304 #endif /* LDAP_SLAPI */
2305 }
2306
2307 /*
2308  * DS 5.x compatability API follow
2309  */
2310
2311 int slapi_attr_get_flags( const Slapi_Attr *attr, unsigned long *flags )
2312 {
2313 #ifdef LDAP_SLAPI
2314         AttributeType *at;
2315
2316         if ( attr == NULL )
2317                 return LDAP_PARAM_ERROR;
2318
2319         at = attr->a_desc->ad_type;
2320
2321         *flags = SLAPI_ATTR_FLAG_STD_ATTR;
2322
2323         if ( is_at_single_value( at ) )
2324                 *flags |= SLAPI_ATTR_FLAG_SINGLE;
2325         if ( is_at_operational( at ) )
2326                 *flags |= SLAPI_ATTR_FLAG_OPATTR;
2327         if ( is_at_obsolete( at ) )
2328                 *flags |= SLAPI_ATTR_FLAG_OBSOLETE;
2329         if ( is_at_collective( at ) )
2330                 *flags |= SLAPI_ATTR_FLAG_COLLECTIVE;
2331         if ( is_at_no_user_mod( at ) )
2332                 *flags |= SLAPI_ATTR_FLAG_NOUSERMOD;
2333
2334         return LDAP_SUCCESS;
2335 #else
2336         return -1;
2337 #endif /* LDAP_SLAPI */
2338 }
2339
2340 int slapi_attr_flag_is_set( const Slapi_Attr *attr, unsigned long flag )
2341 {
2342 #ifdef LDAP_SLAPI
2343         unsigned long flags;
2344
2345         if ( slapi_attr_get_flags( attr, &flags ) != 0 )
2346                 return 0;
2347         return (flags & flag) ? 1 : 0;
2348 #else
2349         return 0;
2350 #endif /* LDAP_SLAPI */
2351 }
2352
2353 Slapi_Attr *slapi_attr_new( void )
2354 {
2355 #ifdef LDAP_SLAPI
2356         Attribute *ad;
2357
2358         ad = (Attribute  *)slapi_ch_calloc( 1, sizeof(*ad) );
2359
2360         return ad;
2361 #else
2362         return NULL;
2363 #endif
2364 }
2365
2366 Slapi_Attr *slapi_attr_init( Slapi_Attr *a, const char *type )
2367 {
2368 #ifdef LDAP_SLAPI
2369         const char *text;
2370         AttributeDescription *ad = NULL;
2371
2372         if( slap_str2ad( type, &ad, &text ) != LDAP_SUCCESS ) {
2373                 return NULL;
2374         }
2375
2376         a->a_desc = ad;
2377         a->a_vals = NULL;
2378 #ifdef SLAP_NVALUES
2379         a->a_nvals = NULL;
2380 #endif
2381         a->a_next = NULL;
2382         a->a_flags = 0;
2383
2384         return a;
2385 #else
2386         return NULL;
2387 #endif
2388 }
2389
2390 void slapi_attr_free( Slapi_Attr **a )
2391 {
2392 #ifdef LDAP_SLAPI
2393         attr_free( *a );
2394         *a = NULL;
2395 #endif
2396 }
2397
2398 Slapi_Attr *slapi_attr_dup( const Slapi_Attr *attr )
2399 {
2400 #ifdef LDAP_SLAPI
2401         return attr_dup( (Slapi_Attr *)attr );
2402 #else
2403         return NULL;
2404 #endif
2405 }
2406
2407 int slapi_attr_add_value( Slapi_Attr *a, const Slapi_Value *v )
2408 {
2409 #ifdef LDAP_SLAPI
2410 #ifdef SLAP_NVALUES
2411         /*
2412          * FIXME: here we may lose alignment between a_vals/a_nvals
2413          */
2414 #endif
2415         return value_add_one( &a->a_vals, (Slapi_Value *)v );
2416 #else
2417         return -1;
2418 #endif
2419 }
2420
2421 int slapi_attr_type2plugin( const char *type, void **pi )
2422 {
2423         *pi = NULL;
2424
2425         return LDAP_OTHER;
2426 }
2427
2428 int slapi_attr_get_type( const Slapi_Attr *attr, char **type )
2429 {
2430 #ifdef LDAP_SLAPI
2431         if ( attr == NULL ) {
2432                 return LDAP_PARAM_ERROR;
2433         }
2434
2435         *type = attr->a_desc->ad_cname.bv_val;
2436
2437         return LDAP_SUCCESS;
2438 #else
2439         return -1;
2440 #endif
2441 }
2442
2443 int slapi_attr_get_oid_copy( const Slapi_Attr *attr, char **oidp )
2444 {
2445 #ifdef LDAP_SLAPI
2446         if ( attr == NULL ) {
2447                 return LDAP_PARAM_ERROR;
2448         }
2449         *oidp = attr->a_desc->ad_type->sat_oid;
2450
2451         return LDAP_SUCCESS;
2452 #else
2453         return -1;
2454 #endif
2455 }
2456
2457 int slapi_attr_value_cmp( const Slapi_Attr *a, const struct berval *v1, const struct berval *v2 )
2458 {
2459 #ifdef LDAP_SLAPI
2460         MatchingRule *mr;
2461         int ret;
2462         int rc;
2463         const char *text;
2464
2465         mr = a->a_desc->ad_type->sat_equality;
2466 #ifdef SLAP_NVALUES
2467         rc = value_match( &ret, a->a_desc, mr,
2468                         SLAP_MR_VALUE_OF_ASSERTION_SYNTAX,
2469                 (struct berval *)v1, (void *)v2, &text );
2470 #else
2471         rc = value_match( &ret, a->a_desc, mr, SLAP_MR_ASSERTION_SYNTAX_MATCH,
2472                 (struct berval *)v1, (void *)v2, &text );
2473 #endif
2474         if ( rc != LDAP_SUCCESS )
2475                 return -1;
2476
2477         return ( ret == 0 ) ? 0 : -1;
2478 #else
2479         return -1;
2480 #endif
2481 }
2482
2483 int slapi_attr_value_find( const Slapi_Attr *a, struct berval *v )
2484 {
2485 #ifdef LDAP_SLAPI
2486         MatchingRule *mr;
2487         struct berval *bv;
2488         int j;
2489         const char *text;
2490         int rc;
2491         int ret;
2492
2493         mr = a->a_desc->ad_type->sat_equality;
2494         for ( bv = a->a_vals, j = 0; bv->bv_val != NULL; bv++, j++ ) {
2495 #ifdef SLAP_NVALUES
2496                 rc = value_match( &ret, a->a_desc, mr,
2497                         SLAP_MR_VALUE_OF_ASSERTION_SYNTAX, bv, v, &text );
2498 #else
2499                 rc = value_match( &ret, a->a_desc, mr,
2500                         SLAP_MR_ASSERTION_SYNTAX_MATCH, bv, v, &text );
2501 #endif
2502                 if ( rc != LDAP_SUCCESS ) {
2503                         return -1;
2504                 }
2505                 if ( ret == 0 ) {
2506                         return 0;
2507                 }
2508         }
2509 #endif
2510         return -1;
2511 }
2512
2513 int slapi_attr_type_cmp( const char *t1, const char *t2, int opt )
2514 {
2515 #ifdef LDAP_SLAPI
2516         AttributeDescription *a1 = NULL;
2517         AttributeDescription *a2 = NULL;
2518         const char *text;
2519         int ret;
2520
2521         if ( slap_str2ad( t1, &a1, &text ) != LDAP_SUCCESS ) {
2522                 return -1;
2523         }
2524
2525         if ( slap_str2ad( t2, &a2, &text ) != LDAP_SUCCESS ) {
2526                 return 1;
2527         }
2528
2529 #define ad_base_cmp(l,r) (((l)->ad_type->sat_cname.bv_len < (r)->ad_type->sat_cname.bv_len) \
2530         ? -1 : (((l)->ad_type->sat_cname.bv_len > (r)->ad_type->sat_cname.bv_len) \
2531                 ? 1 : strcasecmp((l)->ad_type->sat_cname.bv_val, (r)->ad_type->sat_cname.bv_val )))
2532
2533         switch ( opt ) {
2534         case SLAPI_TYPE_CMP_EXACT:
2535                 ret = ad_cmp( a1, a2 );
2536                 break;
2537         case SLAPI_TYPE_CMP_BASE:
2538                 ret = ad_base_cmp( a1, a2 );
2539                 break;
2540         case SLAPI_TYPE_CMP_SUBTYPE:
2541                 ret = is_ad_subtype( a2, a2 );
2542                 break;
2543         default:
2544                 ret = -1;
2545                 break;
2546         }
2547
2548         return ret;
2549 #else
2550         return -1;
2551 #endif
2552 }
2553
2554 int slapi_attr_types_equivalent( const char *t1, const char *t2 )
2555 {
2556 #ifdef LDAP_SLAPI
2557         return slapi_attr_type_cmp( t1, t2, SLAPI_TYPE_CMP_EXACT );
2558 #else
2559         return -1;
2560 #endif
2561 }
2562
2563 int slapi_attr_first_value( Slapi_Attr *a, Slapi_Value **v )
2564 {
2565 #ifdef LDAP_SLAPI
2566         return slapi_valueset_first_value( &a->a_vals, v );
2567 #else
2568         return -1;
2569 #endif
2570 }
2571
2572 int slapi_attr_next_value( Slapi_Attr *a, int hint, Slapi_Value **v )
2573 {
2574 #ifdef LDAP_SLAPI
2575         return slapi_valueset_next_value( &a->a_vals, hint, v );
2576 #else
2577         return -1;
2578 #endif
2579 }
2580
2581 int slapi_attr_get_numvalues( const Slapi_Attr *a, int *numValues )
2582 {
2583 #ifdef LDAP_SLAPI
2584         *numValues = slapi_valueset_count( &a->a_vals );
2585
2586         return 0;
2587 #else
2588         return -1;
2589 #endif
2590 }
2591
2592 int slapi_attr_get_valueset( const Slapi_Attr *a, Slapi_ValueSet **vs )
2593 {
2594 #ifdef LDAP_SLAPI
2595         *vs = &((Slapi_Attr *)a)->a_vals;
2596
2597         return 0;
2598 #else
2599         return -1;
2600 #endif
2601 }
2602
2603 int slapi_attr_get_bervals_copy( Slapi_Attr *a, struct berval ***vals )
2604 {
2605 #ifdef LDAP_SLAPI
2606         return slapi_attr_get_values( a, vals );
2607 #else
2608         return -1;
2609 #endif
2610 }
2611
2612 char *slapi_attr_syntax_normalize( const char *s )
2613 {
2614 #ifdef LDAP_SLAPI
2615         AttributeDescription *ad = NULL;
2616         const char *text;
2617
2618         if ( slap_str2ad( s, &ad, &text ) != LDAP_SUCCESS ) {
2619                 return NULL;
2620         }
2621
2622         return ad->ad_cname.bv_val;
2623 #else
2624         return -1;
2625 #endif
2626 }
2627
2628 Slapi_Value *slapi_value_new( void )
2629 {
2630 #ifdef LDAP_SLAPI
2631         struct berval *bv;
2632
2633         bv = (struct berval *)slapi_ch_malloc( sizeof(*bv) );
2634
2635         return bv;
2636 #else
2637         return NULL;
2638 #endif
2639 }
2640
2641 Slapi_Value *slapi_value_new_berval(const struct berval *bval)
2642 {
2643 #ifdef LDAP_SLAPI
2644         return ber_dupbv( NULL, (struct berval *)bval );
2645 #else
2646         return NULL;
2647 #endif
2648 }
2649
2650 Slapi_Value *slapi_value_new_value(const Slapi_Value *v)
2651 {
2652 #ifdef LDAP_SLAPI
2653         return slapi_value_new_berval( v );
2654 #else
2655         return NULL;
2656 #endif
2657 }
2658
2659 Slapi_Value *slapi_value_new_string(const char *s)
2660 {
2661 #ifdef LDAP_SLAPI
2662         struct berval bv;
2663
2664         bv.bv_val = (char *)s;
2665         bv.bv_len = strlen( s );
2666
2667         return slapi_value_new_berval( &bv );
2668 #else
2669         return NULL;
2670 #endif
2671 }
2672
2673 Slapi_Value *slapi_value_init(Slapi_Value *val)
2674 {
2675 #ifdef LDAP_SLAPI
2676         val->bv_val = NULL;
2677         val->bv_len = 0;
2678
2679         return val;
2680 #else
2681         return NULL;
2682 #endif
2683 }
2684
2685 Slapi_Value *slapi_value_init_berval(Slapi_Value *v, struct berval *bval)
2686 {
2687 #ifdef LDAP_SLAPI
2688         return ber_dupbv( v, bval );
2689 #else
2690         return NULL;
2691 #endif
2692 }
2693
2694 Slapi_Value *slapi_value_init_string(Slapi_Value *v, const char *s)
2695 {
2696 #ifdef LDAP_SLAPI
2697         v->bv_val = slapi_ch_strdup( (char *)s );
2698         v->bv_len = strlen( s );
2699
2700         return v;
2701 #else
2702         return NULL;
2703 #endif
2704 }
2705
2706 Slapi_Value *slapi_value_dup(const Slapi_Value *v)
2707 {
2708 #ifdef LDAP_SLAPI
2709         return slapi_value_new_value( v );
2710 #else
2711         return NULL;
2712 #endif
2713 }
2714
2715 void slapi_value_free(Slapi_Value **value)
2716 {
2717 #ifdef LDAP_SLAPI
2718         if ( value == NULL ) {
2719                 return;
2720         }
2721
2722         if ( (*value) != NULL ) {
2723                 slapi_ch_free( (void **)&(*value)->bv_val );
2724                 slapi_ch_free( (void **)value );
2725         }
2726 #endif
2727 }
2728
2729 const struct berval *slapi_value_get_berval( const Slapi_Value *value )
2730 {
2731 #ifdef LDAP_SLAPI
2732         return value;
2733 #else
2734         return NULL;
2735 #endif
2736 }
2737
2738 Slapi_Value *slapi_value_set_berval( Slapi_Value *value, const struct berval *bval )
2739 {
2740 #ifdef LDAP_SLAPI
2741         if ( value == NULL ) {
2742                 return NULL;
2743         }
2744         if ( value->bv_val != NULL ) {
2745                 slapi_ch_free( (void **)&value->bv_val );
2746         }
2747         slapi_value_init_berval( value, (struct berval *)bval );
2748
2749         return value;
2750 #else
2751         return NULL;
2752 #endif
2753 }
2754
2755 Slapi_Value *slapi_value_set_value( Slapi_Value *value, const Slapi_Value *vfrom)
2756 {
2757 #ifdef LDAP_SLAPI
2758         if ( value == NULL ) {
2759                 return NULL;
2760         }
2761         return slapi_value_set_berval( value, vfrom );
2762 #else
2763         return NULL;
2764 #endif
2765 }
2766
2767 Slapi_Value *slapi_value_set( Slapi_Value *value, void *val, unsigned long len)
2768 {
2769 #ifdef LDAP_SLAPI
2770         if ( value == NULL ) {
2771                 return NULL;
2772         }
2773         if ( value->bv_val != NULL ) {
2774                 slapi_ch_free( (void **)&value->bv_val );
2775         }
2776         value->bv_val = slapi_ch_malloc( len );
2777         value->bv_len = len;
2778         AC_MEMCPY( value->bv_val, val, len );
2779
2780         return value;
2781 #else
2782         return NULL;
2783 #endif
2784 }
2785
2786 int slapi_value_set_string(Slapi_Value *value, const char *strVal)
2787 {
2788 #ifdef LDAP_SLAPI
2789         if ( value == NULL ) {
2790                 return -1;
2791         }
2792         slapi_value_set( value, (void *)strVal, strlen( strVal ) );
2793         return 0;
2794 #else
2795         return NULL;
2796 #endif
2797 }
2798
2799 int slapi_value_set_int(Slapi_Value *value, int intVal)
2800 {
2801 #ifdef LDAP_SLAPI
2802         char buf[64];
2803
2804         snprintf( buf, sizeof( buf ), "%d", intVal );
2805
2806         return slapi_value_set_string( value, buf );
2807 #else
2808         return -1;
2809 #endif
2810 }
2811
2812 const char *slapi_value_get_string(const Slapi_Value *value)
2813 {
2814 #ifdef LDAP_SLAPI
2815         if ( value == NULL ) {
2816                 return NULL;
2817         }
2818         return value->bv_val;
2819 #else
2820         return NULL;
2821 #endif
2822 }
2823
2824 #ifdef LDAP_SLAPI
2825 static int checkBVString(const struct berval *bv)
2826 {
2827         int i;
2828
2829         for ( i = 0; i < bv->bv_len; i++ ) {
2830                 if ( bv->bv_val[i] == '\0' )
2831                         return 0;
2832         }
2833         if ( bv->bv_val[i] != '\0' )
2834                 return 0;
2835
2836         return 1;
2837 }
2838 #endif
2839
2840 int slapi_value_get_int(const Slapi_Value *value)
2841 {
2842 #ifdef LDAP_SLAPI
2843         if ( value == NULL ) return 0;
2844         if ( value->bv_val == NULL ) return 0;
2845         if ( !checkBVString( value ) ) return 0;
2846
2847         return (int)strtol( value->bv_val, NULL, 10 );
2848 #else
2849         return NULL;
2850 #endif
2851 }
2852
2853 unsigned int slapi_value_get_uint(const Slapi_Value *value)
2854 {
2855 #ifdef LDAP_SLAPI
2856         if ( value == NULL ) return 0;
2857         if ( value->bv_val == NULL ) return 0;
2858         if ( !checkBVString( value ) ) return 0;
2859
2860         return (unsigned int)strtoul( value->bv_val, NULL, 10 );
2861 #else
2862         return NULL;
2863 #endif
2864 }
2865
2866 long slapi_value_get_long(const Slapi_Value *value)
2867 {
2868 #ifdef LDAP_SLAPI
2869         if ( value == NULL ) return 0;
2870         if ( value->bv_val == NULL ) return 0;
2871         if ( !checkBVString( value ) ) return 0;
2872
2873         return strtol( value->bv_val, NULL, 10 );
2874 #else
2875         return NULL;
2876 #endif
2877 }
2878
2879 unsigned long slapi_value_get_ulong(const Slapi_Value *value)
2880 {
2881 #ifdef LDAP_SLAPI
2882         if ( value == NULL ) return 0;
2883         if ( value->bv_val == NULL ) return 0;
2884         if ( !checkBVString( value ) ) return 0;
2885
2886         return strtoul( value->bv_val, NULL, 10 );
2887 #else
2888         return NULL;
2889 #endif
2890 }
2891
2892 size_t slapi_value_get_length(const Slapi_Value *value)
2893 {
2894 #ifdef LDAP_SLAPI
2895         if ( value == NULL )
2896                 return 0;
2897
2898         return (size_t) value->bv_len;
2899 #else
2900         return 0;
2901 #endif
2902 }
2903
2904 int slapi_value_compare(const Slapi_Attr *a, const Slapi_Value *v1, const Slapi_Value *v2)
2905 {
2906 #ifdef LDAP_SLAPI
2907         return slapi_attr_value_cmp( a, v1, v2 );
2908 #else
2909         return -1;
2910 #endif
2911 }
2912
2913 /* A ValueSet is a container for a BerVarray. */
2914 Slapi_ValueSet *slapi_valueset_new( void )
2915 {
2916 #ifdef LDAP_SLAPI
2917         Slapi_ValueSet *vs;
2918
2919         vs = (Slapi_ValueSet *)slapi_ch_malloc( sizeof( *vs ) );
2920         *vs = NULL;
2921
2922         return vs;
2923 #else
2924         return NULL;
2925 #endif
2926 }
2927
2928 void slapi_valueset_free(Slapi_ValueSet *vs)
2929 {
2930 #ifdef LDAP_SLAPI
2931         if ( vs != NULL ) {
2932                 BerVarray vp = *vs;
2933
2934                 ber_bvarray_free( vp );
2935                 slapi_ch_free( (void **)&vp );
2936
2937                 *vs = NULL;
2938         }
2939 #endif
2940 }
2941
2942 void slapi_valueset_init(Slapi_ValueSet *vs)
2943 {
2944 #ifdef LDAP_SLAPI
2945         if ( vs != NULL && *vs == NULL ) {
2946                 *vs = (Slapi_ValueSet)slapi_ch_calloc( 1, sizeof(struct berval) );
2947                 (*vs)->bv_val = NULL;
2948                 (*vs)->bv_len = 0;
2949         }
2950 #endif
2951 }
2952
2953 void slapi_valueset_done(Slapi_ValueSet *vs)
2954 {
2955 #ifdef LDAP_SLAPI
2956         BerVarray vp;
2957
2958         if ( vs == NULL )
2959                 return;
2960
2961         for ( vp = *vs; vp->bv_val != NULL; vp++ ) {
2962                 vp->bv_len = 0;
2963                 slapi_ch_free( (void **)&vp->bv_val );
2964         }
2965         /* but don't free *vs or vs */
2966 #endif
2967 }
2968
2969 void slapi_valueset_add_value(Slapi_ValueSet *vs, const Slapi_Value *addval)
2970 {
2971 #ifdef LDAP_SLAPI
2972         struct berval bv;
2973
2974         ber_dupbv( &bv, (Slapi_Value *)addval );
2975         ber_bvarray_add( vs, &bv );
2976 #endif
2977 }
2978
2979 int slapi_valueset_first_value( Slapi_ValueSet *vs, Slapi_Value **v )
2980 {
2981 #ifdef LDAP_SLAPI
2982         return slapi_valueset_next_value( vs, 0, v );
2983 #else
2984         return -1;
2985 #endif
2986 }
2987
2988 int slapi_valueset_next_value( Slapi_ValueSet *vs, int index, Slapi_Value **v)
2989 {
2990 #ifdef LDAP_SLAPI
2991         int i;
2992         BerVarray vp;
2993
2994         if ( vs == NULL )
2995                 return -1;
2996
2997         vp = *vs;
2998
2999         for ( i = 0; vp[i].bv_val != NULL; i++ ) {
3000                 if ( i == index ) {
3001                         *v = &vp[i];
3002                         return index + 1;
3003                 }
3004         }
3005 #endif
3006
3007         return -1;
3008 }
3009
3010 int slapi_valueset_count( const Slapi_ValueSet *vs )
3011 {
3012 #ifdef LDAP_SLAPI
3013         int i;
3014         BerVarray vp;
3015
3016         if ( vs == NULL )
3017                 return 0;
3018
3019         vp = *vs;
3020
3021         for ( i = 0; vp[i].bv_val != NULL; i++ )
3022                 ;
3023
3024         return i;
3025 #else
3026         return 0;
3027 #endif
3028
3029 }
3030
3031 void slapi_valueset_set_valueset(Slapi_ValueSet *vs1, const Slapi_ValueSet *vs2)
3032 {
3033 #ifdef LDAP_SLAPI
3034         BerVarray vp;
3035
3036         for ( vp = *vs2; vp->bv_val != NULL; vp++ ) {
3037                 slapi_valueset_add_value( vs1, vp );
3038         }
3039 #endif
3040 }
3041
3042 int slapi_access_allowed( Slapi_PBlock *pb, Slapi_Entry *e, char *attr,
3043         struct berval *val, int access )
3044 {
3045 #ifdef LDAPI_SLAPI
3046         Backend *be;
3047         Connection *conn;
3048         Operation *op;
3049         int ret;
3050         slap_access_t slap_access;
3051         AttributeDescription *ad = NULL;
3052         char *text;
3053
3054         ret = slap_str2ad( attr, &ad, &text );
3055         if ( ret != LDAP_SUCCESS ) {
3056                 return ret;
3057         }
3058
3059         switch ( access & SLAPI_ACL_ALL ) {
3060         case SLAPI_ACL_COMPARE:
3061                 slap_access = ACL_COMPARE;
3062                 break;
3063         case SLAPI_ACL_SEARCH:
3064                 slap_access = ACL_SEARCH;
3065                 break;
3066         case SLAPI_ACL_READ:
3067                 slap_access = ACL_READ;
3068                 break;
3069         case SLAPI_ACL_WRITE:
3070         case SLAPI_ACL_DELETE:
3071         case SLAPI_ACL_ADD:
3072         case SLAPI_ACL_SELF:
3073                 slap_access = ACL_WRITE;
3074                 break;
3075         default:
3076                 return LDAP_INSUFFICIENT_ACCESS;
3077                 break;
3078         }
3079
3080         if ( slapi_pblock_get( pb, SLAPI_BACKEND, (void *)&be ) != 0 ) {
3081                 return LDAP_PARAM_ERROR;
3082         }
3083
3084         if ( slapi_pblock_get( pb, SLAPI_CONNECTION, (void *)&conn ) != 0 ) {
3085                 return LDAP_PARAM_ERROR;
3086         }
3087
3088         if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&op ) != 0 ) {
3089                 return LDAP_PARAM_ERROR;
3090         }
3091
3092         ret = access_allowed( be, conn, op, e, desc, val, slap_access, NULL );
3093
3094         return ret ? LDAP_SUCCESS : LDAP_INSUFFICIENT_ACCESS;
3095 #else
3096         return LDAP_UNWILLING_TO_PERFORM;
3097 #endif
3098 }
3099
3100 int slapi_acl_check_mods(Slapi_PBlock *pb, Slapi_Entry *e, LDAPMod **mods, char **errbuf)
3101 {
3102 #ifdef LDAP_SLAPI
3103         Operation *op;
3104         int ret;
3105         Modifications *ml;
3106         Modifications *next;
3107
3108         if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&op ) != 0 ) {
3109                 return LDAP_PARAM_ERROR;
3110         }
3111
3112         ml = slapi_x_ldapmods2modifications( mods );
3113         if ( ml == NULL ) {
3114                 return LDAP_OTHER;
3115         }
3116
3117         ret = acl_check_modlist( op, e, ml );
3118
3119         /* Careful when freeing the modlist because it has pointers into the mods array. */
3120         for ( ; ml != NULL; ml = next ) {
3121                 next = ml->sml_next;
3122
3123                 /* just free the containing array */
3124                 slapi_ch_free( (void **)&ml->sml_bvalues );
3125                 slapi_ch_free( (void **)&ml );
3126         }
3127
3128         return ret ? LDAP_SUCCESS : LDAP_INSUFFICIENT_ACCESS;
3129 #else
3130         return LDAP_UNWILLING_TO_PERFORM;
3131 #endif
3132 }
3133
3134 /*
3135  * Synthesise an LDAPMod array from a Modifications list to pass
3136  * to SLAPI. This synthesis is destructive and as such the
3137  * Modifications list may not be used after calling this
3138  * function.
3139  *
3140  * This function must also be called before slap_mods_check().
3141  */
3142 LDAPMod **slapi_x_modifications2ldapmods(Modifications **pmodlist)
3143 {
3144 #ifdef LDAP_SLAPI
3145         Modifications *ml, *modlist;
3146         LDAPMod **mods, *modp;
3147         int i, j;
3148
3149         modlist = *pmodlist;
3150
3151         for( i = 0, ml = modlist; ml != NULL; i++, ml = ml->sml_next )
3152                 ;
3153
3154         mods = (LDAPMod **)ch_malloc( (i + 1) * sizeof(LDAPMod *) );
3155
3156         for( i = 0, ml = modlist; ml != NULL; ml = ml->sml_next ) {
3157                 mods[i] = (LDAPMod *)ch_malloc( sizeof(LDAPMod) );
3158                 modp = mods[i];
3159                 modp->mod_op = ml->sml_op | LDAP_MOD_BVALUES;
3160
3161                 /* Take ownership of original type. */
3162                 modp->mod_type = ml->sml_type.bv_val;
3163                 ml->sml_type.bv_val = NULL;
3164
3165                 if ( ml->sml_bvalues != NULL ) {
3166                         for( j = 0; ml->sml_bvalues[j].bv_val != NULL; j++ )
3167                                 ;
3168                         modp->mod_bvalues = (struct berval **)ch_malloc( (j + 1) *
3169                                 sizeof(struct berval *) );
3170                         for( j = 0; ml->sml_bvalues[j].bv_val != NULL; j++ ) {
3171                                 /* Take ownership of original values. */
3172                                 modp->mod_bvalues[j] = (struct berval *)ch_malloc( sizeof(struct berval) );
3173                                 modp->mod_bvalues[j]->bv_len = ml->sml_bvalues[j].bv_len;
3174                                 modp->mod_bvalues[j]->bv_val = ml->sml_bvalues[j].bv_val;
3175                                 ml->sml_bvalues[j].bv_len = 0;
3176                                 ml->sml_bvalues[j].bv_val = NULL;
3177                         }
3178                         modp->mod_bvalues[j] = NULL;
3179                 } else {
3180                         modp->mod_bvalues = NULL;
3181                 }
3182                 i++;
3183         }
3184
3185         mods[i] = NULL;
3186
3187         slap_mods_free( modlist );
3188         *pmodlist = NULL;
3189
3190         return mods;
3191 #else
3192         return NULL;
3193 #endif
3194 }
3195
3196 /*
3197  * Convert a potentially modified array of LDAPMods back to a
3198  * Modification list.
3199  *
3200  * The returned Modification list contains pointers into the
3201  * LDAPMods array; the latter MUST be freed with
3202  * slapi_x_free_ldapmods() (see below).
3203  */
3204 Modifications *slapi_x_ldapmods2modifications (LDAPMod **mods)
3205 {
3206 #ifdef LDAP_SLAPI
3207         Modifications *modlist = NULL, **modtail;
3208         LDAPMod **modp;
3209
3210         modtail = &modlist;
3211
3212         for( modp = mods; *modp != NULL; modp++ ) {
3213                 Modifications *mod;
3214                 int i;
3215                 char **p;
3216                 struct berval **bvp;
3217
3218                 mod = (Modifications *) ch_malloc( sizeof(Modifications) );
3219                 mod->sml_op = (*modp)->mod_op & (~LDAP_MOD_BVALUES);
3220                 mod->sml_type.bv_val = (*modp)->mod_type;
3221                 mod->sml_type.bv_len = strlen( mod->sml_type.bv_val );
3222                 mod->sml_desc = NULL;
3223                 mod->sml_next = NULL;
3224
3225                 if ( (*modp)->mod_op & LDAP_MOD_BVALUES ) {
3226                         for( i = 0, bvp = (*modp)->mod_bvalues; bvp != NULL && *bvp != NULL; bvp++, i++ )
3227                                 ;
3228                 } else {
3229                         for( i = 0, p = (*modp)->mod_values; p != NULL && *p != NULL; p++, i++ )
3230                                 ;
3231                 }
3232
3233                 if ( i == 0 ) {
3234                          mod->sml_bvalues = NULL;
3235                 } else {
3236                         mod->sml_bvalues = (BerVarray) ch_malloc( (i + 1) * sizeof(struct berval) );
3237
3238                         /* NB: This implicitly trusts a plugin to return valid modifications. */
3239                         if ( (*modp)->mod_op & LDAP_MOD_BVALUES ) {
3240                                 for( i = 0, bvp = (*modp)->mod_bvalues; bvp != NULL && *bvp != NULL; bvp++, i++ ) {
3241                                         mod->sml_bvalues[i].bv_val = (*bvp)->bv_val;
3242                                         mod->sml_bvalues[i].bv_len = (*bvp)->bv_len;
3243                                 }
3244                         } else {
3245                                 for( i = 0, p = (*modp)->mod_values; p != NULL && *p != NULL; p++, i++ ) {
3246                                         mod->sml_bvalues[i].bv_val = *p;
3247                                         mod->sml_bvalues[i].bv_len = strlen( *p );
3248                                 }
3249                         }
3250                         mod->sml_bvalues[i].bv_val = NULL;
3251                 }
3252 #ifdef SLAP_NVALUES
3253                 mod->sml_nvalues = NULL;
3254 #endif
3255
3256                 *modtail = mod;
3257                 modtail = &mod->sml_next;
3258         }
3259
3260         return modlist;
3261 #else
3262         return NULL;
3263 #endif
3264 }
3265
3266 /*
3267  * This function only frees the parts of the mods array that
3268  * are not shared with the Modification list that was created
3269  * by slapi_x_ldapmods2modifications().
3270  *
3271  */
3272 void slapi_x_free_ldapmods (LDAPMod **mods)
3273 {
3274 #ifdef LDAP_SLAPI
3275         int i, j;
3276
3277         if (mods == NULL)
3278                 return;
3279
3280         for ( i = 0; mods[i] != NULL; i++ ) {
3281                 /*
3282                  * Don't free values themselves; they're owned by the
3283                  * Modification list. Do free the containing array.
3284                  */
3285                 if ( mods[i]->mod_op & LDAP_MOD_BVALUES ) {
3286                         for ( j = 0; mods[i]->mod_bvalues != NULL && mods[i]->mod_bvalues[j] != NULL; j++ ) {
3287                                 ch_free( mods[i]->mod_bvalues[j] );
3288                         }
3289                         ch_free( mods[i]->mod_bvalues );
3290                 } else {
3291                         ch_free( mods[i]->mod_values );
3292                 }
3293                 /* Don't free type, for same reasons. */
3294                 ch_free( mods[i] );
3295         }
3296         ch_free( mods );
3297 #endif /* LDAP_SLAPI */
3298 }
3299
3300 /*
3301  * Sun ONE DS 5.x computed attribute support. Computed attributes
3302  * allow for dynamically generated operational attributes, a very
3303  * useful thing indeed.
3304  */
3305
3306 /*
3307  * Write the computed attribute to a BerElement. Complementary
3308  * functions need to be defined for anything that replaces
3309  * op->o_callback->sc_sendentry, if you wish to make computed
3310  * attributes available to it.
3311  */
3312 int slapi_x_compute_output_ber(computed_attr_context *c, Slapi_Attr *a, Slapi_Entry *e)
3313 {
3314 #ifdef LDAP_SLAPI
3315         Operation *op = NULL;
3316         BerElement *ber;
3317         AttributeDescription *desc = NULL;
3318         int rc;
3319         int i;
3320
3321         if ( c == NULL ) {
3322                 return 1;
3323         }
3324
3325         if ( a == NULL ) {
3326                 return 1;
3327         }
3328
3329         if ( e == NULL ) {
3330                 return 1;
3331         }
3332
3333         rc = slapi_pblock_get( c->cac_pb, SLAPI_OPERATION, (void *)&op );
3334         if ( rc != 0 || op == NULL ) {
3335                 return rc;
3336         }
3337
3338         ber = (BerElement *)c->cac_private;
3339         desc = a->a_desc;
3340
3341         if ( c->cac_attrs == NULL ) {
3342                 /* All attrs request, skip operational attributes */
3343                 if ( is_at_operational( desc->ad_type ) ) {
3344                         return 0;
3345                 }
3346         } else {
3347                 /* Specific attrs requested */
3348                 if ( is_at_operational( desc->ad_type ) ) {
3349                         if ( !c->cac_opattrs && !ad_inlist( desc, c->cac_attrs ) ) {
3350                                 return 0;
3351                         }
3352                 } else {
3353                         if ( !c->cac_userattrs && !ad_inlist( desc, c->cac_attrs ) ) {
3354                                 return 0;
3355                         }
3356                 }
3357         }
3358
3359         if ( !access_allowed( op, e, desc, NULL, ACL_READ, &c->cac_acl_state) ) {
3360                 slapi_log_error( SLAPI_LOG_ACL, "SLAPI_COMPUTE",
3361                         "acl: access to attribute %s not allowed\n",
3362                         desc->ad_cname.bv_val );
3363                 return 0;
3364         }
3365
3366         rc = ber_printf( ber, "{O[" /*]}*/ , &desc->ad_cname );
3367         if (rc == -1 ) {
3368                 slapi_log_error( SLAPI_LOG_BER, "SLAPI_COMPUTE",
3369                         "ber_printf failed\n");
3370                 return 1;
3371         }
3372
3373         if ( !c->cac_attrsonly ) {
3374                 for ( i = 0; a->a_vals[i].bv_val != NULL; i++ ) {
3375                         if ( !access_allowed( op, e,
3376                                 desc, &a->a_vals[i], ACL_READ, &c->cac_acl_state)) {
3377                                 slapi_log_error( SLAPI_LOG_ACL, "SLAPI_COMPUTE",
3378                                         "slapi_x_compute_output_ber: conn %lu "
3379                                         "acl: access to %s, value %d not allowed\n",
3380                                         op->o_connid, desc->ad_cname.bv_val, i  );
3381                                 continue;
3382                         }
3383
3384                         if (( rc = ber_printf( ber, "O", &a->a_vals[i] )) == -1 ) {
3385                                 slapi_log_error( SLAPI_LOG_BER, "SLAPI_COMPUTE",
3386                                         "ber_printf failed\n");
3387                                 return 1;
3388                         }
3389                 }
3390         }
3391
3392         if (( rc = ber_printf( ber, /*{[*/ "]N}" )) == -1 ) {
3393                 slapi_log_error( SLAPI_LOG_BER, "SLAPI_COMPUTE",
3394                         "ber_printf failed\n" );
3395                 return 1;
3396         }
3397
3398         return 0;
3399 #else
3400         return 1;
3401 #endif
3402 }
3403
3404 /*
3405  * For some reason Sun don't use the normal plugin mechanism
3406  * registration path to register an "evaluator" function (an
3407  * "evaluator" is responsible for adding computed attributes;
3408  * the nomenclature is somewhat confusing).
3409  *
3410  * As such slapi_compute_add_evaluator() registers the
3411  * function directly.
3412  */
3413 int slapi_compute_add_evaluator(slapi_compute_callback_t function)
3414 {
3415 #ifdef LDAP_SLAPI
3416         Slapi_PBlock *pPlugin = NULL;
3417         int rc;
3418
3419         pPlugin = slapi_pblock_new();
3420         if ( pPlugin == NULL ) {
3421                 rc = LDAP_NO_MEMORY;
3422                 goto done;
3423         }
3424
3425         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_TYPE, (void *)SLAPI_PLUGIN_OBJECT );
3426         if ( rc != LDAP_SUCCESS ) {
3427                 goto done;
3428         }
3429
3430         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_COMPUTE_EVALUATOR_FN, (void *)function );
3431         if ( rc != LDAP_SUCCESS ) {
3432                 goto done;
3433         }
3434
3435         rc = insertPlugin( NULL, pPlugin );
3436         if ( rc != 0 ) {
3437                 rc = LDAP_OTHER;
3438                 goto done;
3439         }
3440
3441 done:
3442         if ( rc != LDAP_SUCCESS ) {
3443                 if ( pPlugin != NULL ) {
3444                         slapi_pblock_destroy( pPlugin );
3445                 }
3446                 return -1;
3447         }
3448
3449         return 0;
3450 #else
3451         return -1;
3452 #endif /* LDAP_SLAPI */
3453 }
3454
3455 /*
3456  * See notes above regarding slapi_compute_add_evaluator().
3457  */
3458 int slapi_compute_add_search_rewriter(slapi_search_rewrite_callback_t function)
3459 {
3460 #ifdef LDAP_SLAPI
3461         Slapi_PBlock *pPlugin = NULL;
3462         int rc;
3463
3464         pPlugin = slapi_pblock_new();
3465         if ( pPlugin == NULL ) {
3466                 rc = LDAP_NO_MEMORY;
3467                 goto done;
3468         }
3469
3470         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_TYPE, (void *)SLAPI_PLUGIN_OBJECT );
3471         if ( rc != LDAP_SUCCESS ) {
3472                 goto done;
3473         }
3474
3475         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_COMPUTE_SEARCH_REWRITER_FN, (void *)function );
3476         if ( rc != LDAP_SUCCESS ) {
3477                 goto done;
3478         }
3479
3480         rc = insertPlugin( NULL, pPlugin );
3481         if ( rc != 0 ) {
3482                 rc = LDAP_OTHER;
3483                 goto done;
3484         }
3485
3486 done:
3487         if ( rc != LDAP_SUCCESS ) {
3488                 if ( pPlugin != NULL ) {
3489                         slapi_pblock_destroy( pPlugin );
3490                 }
3491                 return -1;
3492         }
3493
3494         return 0;
3495 #else
3496         return -1;
3497 #endif /* LDAP_SLAPI */
3498 }
3499
3500 /*
3501  * Call compute evaluators
3502  */
3503 int compute_evaluator(computed_attr_context *c, char *type, Slapi_Entry *e, slapi_compute_output_t outputfn)
3504 {
3505 #ifdef LDAP_SLAPI
3506         int rc = 0;
3507         slapi_compute_callback_t *pGetPlugin, *tmpPlugin;
3508
3509         rc = getAllPluginFuncs( NULL, SLAPI_PLUGIN_COMPUTE_EVALUATOR_FN, (SLAPI_FUNC **)&tmpPlugin );
3510         if ( rc != LDAP_SUCCESS || tmpPlugin == NULL ) {
3511                 /* Nothing to do; front-end should ignore. */
3512                 return 0;
3513         }
3514
3515         for ( pGetPlugin = tmpPlugin; *pGetPlugin != NULL; pGetPlugin++ ) {
3516                 /*
3517                  * -1: no attribute matched requested type
3518                  *  0: one attribute matched
3519                  * >0: error happened
3520                  */
3521                 rc = (*pGetPlugin)( c, type, e, outputfn );
3522                 if ( rc > 0 ) {
3523                         break;
3524                 }
3525         }
3526
3527         slapi_ch_free( (void **)&tmpPlugin );
3528
3529         return rc;
3530 #else
3531         return 1;
3532 #endif /* LDAP_SLAPI */
3533 }
3534
3535 int compute_rewrite_search_filter(Slapi_PBlock *pb)
3536 {
3537 #ifdef LDAP_SLAPI
3538         Backend *be;
3539         int rc;
3540
3541         rc = slapi_pblock_get( pb, SLAPI_BACKEND, (void *)&be );
3542         if ( rc != 0 ) {
3543                 return rc;
3544         }
3545
3546         return doPluginFNs( be, SLAPI_PLUGIN_COMPUTE_SEARCH_REWRITER_FN, pb );
3547 #else
3548         return -1;
3549 #endif /* LDAP_SLAPI */
3550 }
3551
3552 /*
3553  * New API to provide the plugin with access to the search
3554  * pblock. Have informed Sun DS team.
3555  */
3556 int slapi_x_compute_get_pblock(computed_attr_context *c, Slapi_PBlock **pb)
3557 {
3558 #ifdef LDAP_SLAPI
3559         if ( c == NULL )
3560                 return -1;
3561
3562         if ( c->cac_pb == NULL )
3563                 return -1;
3564
3565         *pb = c->cac_pb;
3566
3567         return 0;
3568 #else
3569         return -1;
3570 #endif /* LDAP_SLAPI */
3571 }
3572
3573 Slapi_Mutex *slapi_new_mutex( void )
3574 {
3575 #ifdef LDAP_SLAPI
3576         Slapi_Mutex *m;
3577
3578         m = (Slapi_Mutex *)slapi_ch_malloc( sizeof(*m) );
3579         if ( ldap_pvt_thread_mutex_init( &m->mutex ) != 0 ) {
3580                 slapi_ch_free( (void **)&m );
3581                 return NULL;
3582         }
3583
3584         return m;
3585 #else
3586         return NULL;
3587 #endif
3588 }
3589
3590 void slapi_destroy_mutex( Slapi_Mutex *mutex )
3591 {
3592 #ifdef LDAP_SLAPI
3593         if ( mutex != NULL ) {
3594                 ldap_pvt_thread_mutex_destroy( &mutex->mutex );
3595                 slapi_ch_free( (void **)&mutex);
3596         }
3597 #endif
3598 }
3599
3600 void slapi_lock_mutex( Slapi_Mutex *mutex )
3601 {
3602 #ifdef LDAP_SLAPI
3603         ldap_pvt_thread_mutex_lock( &mutex->mutex );
3604 #endif
3605 }
3606
3607 int slapi_unlock_mutex( Slapi_Mutex *mutex )
3608 {
3609 #ifdef LDAP_SLAPI
3610         return ldap_pvt_thread_mutex_unlock( &mutex->mutex );
3611 #else
3612         return -1;
3613 #endif
3614 }
3615
3616 Slapi_CondVar *slapi_new_condvar( Slapi_Mutex *mutex )
3617 {
3618 #ifdef LDAP_SLAPI
3619         Slapi_CondVar *cv;
3620
3621         if ( mutex == NULL ) {
3622                 return NULL;
3623         }
3624
3625         cv = (Slapi_CondVar *)slapi_ch_malloc( sizeof(*cv) );
3626         if ( ldap_pvt_thread_cond_init( &cv->cond ) != 0 ) {
3627                 slapi_ch_free( (void **)&cv );
3628                 return NULL;
3629         }
3630
3631         /* XXX struct copy */
3632         cv->mutex = mutex->mutex;
3633
3634         return cv;
3635 #else
3636         return NULL;
3637 #endif
3638 }
3639
3640 void slapi_destroy_condvar( Slapi_CondVar *cvar )
3641 {
3642 #ifdef LDAP_SLAPI
3643         if ( cvar != NULL ) {
3644                 ldap_pvt_thread_cond_destroy( &cvar->cond );
3645                 slapi_ch_free( (void **)&cvar );
3646         }
3647 #endif
3648 }
3649
3650 int slapi_wait_condvar( Slapi_CondVar *cvar, struct timeval *timeout )
3651 {
3652 #ifdef LDAP_SLAPI
3653         if ( cvar == NULL ) {
3654                 return -1;
3655         }
3656
3657         return ldap_pvt_thread_cond_wait( &cvar->cond, &cvar->mutex );
3658 #else
3659         return -1;
3660 #endif
3661 }
3662
3663 int slapi_notify_condvar( Slapi_CondVar *cvar, int notify_all )
3664 {
3665 #ifdef LDAP_SLAPI
3666         if ( cvar == NULL ) {
3667                 return -1;
3668         }
3669
3670         if ( notify_all ) {
3671                 return ldap_pvt_thread_cond_broadcast( &cvar->cond );
3672         }
3673
3674         return ldap_pvt_thread_cond_signal( &cvar->cond );
3675 #else
3676         return -1;
3677 #endif
3678 }
3679