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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 2002-2005 The OpenLDAP Foundation.
   5  * Portions Copyright 1997,2002-2003 IBM Corporation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* ACKNOWLEDGEMENTS:
  17  * This work was initially developed by IBM Corporation for use in
  18  * IBM products and subsequently ported to OpenLDAP Software by
  19  * Steve Omrani.  Additional significant contributors include:
  20  *   Luke Howard
  21  */
  22
  23 #include "portable.h"
  24
  25 #include <ac/string.h>
  26 #include <ac/stdarg.h>
  27 #include <ac/ctype.h>
  28 #include <ac/unistd.h>
  29
  30 #include <slap.h>
  31 #include <slapi.h>
  32
  33 #include <netdb.h>
  34
  35 /*
  36  * server start time (should we use a struct timeval also in slapd?
  37  */
  38 static struct                   timeval base_time;
  39 ldap_pvt_thread_mutex_t         slapi_hn_mutex;
  40 ldap_pvt_thread_mutex_t         slapi_time_mutex;
  41
  42 struct slapi_mutex {
  43         ldap_pvt_thread_mutex_t mutex;
  44 };
  45
  46 struct slapi_condvar {
  47         ldap_pvt_thread_cond_t cond;
  48         ldap_pvt_thread_mutex_t mutex;
  49 };
  50
  51 #ifdef LDAP_SLAPI
  52 static int checkBVString(const struct berval *bv)
  53 {
  54         int i;
  55
  56         for ( i = 0; i < bv->bv_len; i++ ) {
  57                 if ( bv->bv_val[i] == '\0' )
  58                         return 0;
  59         }
  60         if ( bv->bv_val[i] != '\0' )
  61                 return 0;
  62
  63         return 1;
  64 }
  65 #endif /* LDAP_SLAPI */
  66
  67 /*
  68  * This function converts an array of pointers to berval objects to
  69  * an array of berval objects.
  70  */
  71
  72 int
  73 bvptr2obj(
  74         struct berval   **bvptr,
  75         BerVarray       *bvobj )
  76 {
  77         int             rc = LDAP_SUCCESS;
  78         int             i;
  79         BerVarray       tmpberval;
  80
  81         if ( bvptr == NULL || *bvptr == NULL ) {
  82                 return LDAP_OTHER;
  83         }
  84
  85         for ( i = 0; bvptr != NULL && bvptr[i] != NULL; i++ ) {
  86                 ; /* EMPTY */
  87         }
  88
  89         tmpberval = (BerVarray)slapi_ch_malloc( (i + 1)*sizeof(struct berval));
  90         if ( tmpberval == NULL ) {
  91                 return LDAP_NO_MEMORY;
  92         }
  93
  94         for ( i = 0; bvptr[i] != NULL; i++ ) {
  95                 tmpberval[i].bv_val = bvptr[i]->bv_val;
  96                 tmpberval[i].bv_len = bvptr[i]->bv_len;
  97         }
  98         tmpberval[i].bv_val = NULL;
  99         tmpberval[i].bv_len = 0;
 100
 101         if ( rc == LDAP_SUCCESS ) {
 102                 *bvobj = tmpberval;
 103         }
 104
 105         return rc;
 106 }
 107
 108 Slapi_Entry *
 109 slapi_str2entry(
 110         char            *s,
 111         int             flags )
 112 {
 113 #ifdef LDAP_SLAPI
 114         Slapi_Entry     *e = NULL;
 115         char            *pTmpS;
 116
 117         pTmpS = slapi_ch_strdup( s );
 118         if ( pTmpS != NULL ) {
 119                 e = str2entry( pTmpS );
 120                 slapi_ch_free( (void **)&pTmpS );
 121         }
 122
 123         return e;
 124 #else
 125         return NULL;
 126 #endif /* LDAP_SLAPI */
 127 }
 128
 129 char *
 130 slapi_entry2str(
 131         Slapi_Entry     *e,
 132         int             *len )
 133 {
 134 #ifdef LDAP_SLAPI
 135         char            *ret;
 136
 137         ldap_pvt_thread_mutex_lock( &entry2str_mutex );
 138         ret = entry2str( e, len );
 139         ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
 140
 141         return ret;
 142 #else /* LDAP_SLAPI */
 143         return NULL;
 144 #endif /* LDAP_SLAPI */
 145 }
 146
 147 char *
 148 slapi_entry_get_dn( Slapi_Entry *e )
 149 {
 150 #ifdef LDAP_SLAPI
 151         return e->e_name.bv_val;
 152 #else /* LDAP_SLAPI */
 153         return NULL;
 154 #endif /* LDAP_SLAPI */
 155 }
 156
 157 int
 158 slapi_x_entry_get_id( Slapi_Entry *e )
 159 {
 160 #ifdef LDAP_SLAPI
 161         return e->e_id;
 162 #else
 163         return NOID;
 164 #endif /* LDAP_SLAPI */
 165 }
 166
 167 void
 168 slapi_entry_set_dn(
 169         Slapi_Entry     *e,
 170         char            *ldn )
 171 {
 172 #ifdef LDAP_SLAPI
 173         struct berval   dn = BER_BVNULL;
 174
 175         dn.bv_val = ldn;
 176         dn.bv_len = strlen( ldn );
 177
 178         dnPrettyNormal( NULL, &dn, &e->e_name, &e->e_nname, NULL );
 179 #endif /* LDAP_SLAPI */
 180 }
 181
 182 Slapi_Entry *
 183 slapi_entry_dup( Slapi_Entry *e )
 184 {
 185 #ifdef LDAP_SLAPI
 186         return entry_dup( e );
 187 #else /* LDAP_SLAPI */
 188         return NULL;
 189 #endif /* LDAP_SLAPI */
 190 }
 191
 192 int
 193 slapi_entry_attr_delete(
 194         Slapi_Entry     *e,
 195         char            *type )
 196 {
 197 #ifdef LDAP_SLAPI
 198         AttributeDescription    *ad = NULL;
 199         const char              *text;
 200
 201         if ( slap_str2ad( type, &ad, &text ) != LDAP_SUCCESS ) {
 202                 return 1;       /* LDAP_NO_SUCH_ATTRIBUTE */
 203         }
 204
 205         if ( attr_delete( &e->e_attrs, ad ) == LDAP_SUCCESS ) {
 206                 return 0;       /* attribute is deleted */
 207         } else {
 208                 return -1;      /* something went wrong */
 209         }
 210 #else /* LDAP_SLAPI */
 211         return -1;
 212 #endif /* LDAP_SLAPI */
 213 }
 214
 215 Slapi_Entry *
 216 slapi_entry_alloc( void )
 217 {
 218 #ifdef LDAP_SLAPI
 219         return (Slapi_Entry *)slapi_ch_calloc( 1, sizeof(Slapi_Entry) );
 220 #else /* LDAP_SLAPI */
 221         return NULL;
 222 #endif /* LDAP_SLAPI */
 223 }
 224
 225 void
 226 slapi_entry_free( Slapi_Entry *e )
 227 {
 228 #ifdef LDAP_SLAPI
 229         entry_free( e );
 230 #endif /* LDAP_SLAPI */
 231 }
 232
 233 int
 234 slapi_entry_attr_merge(
 235         Slapi_Entry     *e,
 236         char            *type,
 237         struct berval   **vals )
 238 {
 239 #ifdef LDAP_SLAPI
 240         AttributeDescription    *ad = NULL;
 241         const char              *text;
 242         BerVarray               bv;
 243         int                     rc;
 244
 245         rc = bvptr2obj( vals, &bv );
 246         if ( rc != LDAP_SUCCESS ) {
 247                 return -1;
 248         }
 249
 250         rc = slap_str2ad( type, &ad, &text );
 251         if ( rc != LDAP_SUCCESS ) {
 252                 return -1;
 253         }
 254
 255         rc = attr_merge_normalize_one( e, ad, bv, NULL );
 256         ch_free( bv );
 257
 258         return rc;
 259 #else /* LDAP_SLAPI */
 260         return -1;
 261 #endif /* LDAP_SLAPI */
 262 }
 263
 264 int
 265 slapi_entry_attr_find(
 266         Slapi_Entry     *e,
 267         char            *type,
 268         Slapi_Attr      **attr )
 269 {
 270 #ifdef LDAP_SLAPI
 271         AttributeDescription    *ad = NULL;
 272         const char              *text;
 273         int                     rc;
 274
 275         rc = slap_str2ad( type, &ad, &text );
 276         if ( rc != LDAP_SUCCESS ) {
 277                 return -1;
 278         }
 279
 280         *attr = attr_find( e->e_attrs, ad );
 281         if ( *attr == NULL ) {
 282                 return -1;
 283         }
 284
 285         return 0;
 286 #else /* LDAP_SLAPI */
 287         return -1;
 288 #endif /* LDAP_SLAPI */
 289 }
 290
 291 char *
 292 slapi_entry_attr_get_charptr( const Slapi_Entry *e, const char *type )
 293 {
 294 #ifdef LDAP_SLAPI
 295         AttributeDescription *ad = NULL;
 296         const char *text;
 297         int rc;
 298         Attribute *attr;
 299
 300         rc = slap_str2ad( type, &ad, &text );
 301         if ( rc != LDAP_SUCCESS ) {
 302                 return NULL;
 303         }
 304
 305         attr = attr_find( e->e_attrs, ad );
 306         if ( attr == NULL ) {
 307                 return NULL;
 308         }
 309
 310         if ( attr->a_vals != NULL && attr->a_vals[0].bv_len != 0 ) {
 311                 const char *p;
 312
 313                 p = slapi_value_get_string( &attr->a_vals[0] );
 314                 if ( p != NULL ) {
 315                         return slapi_ch_strdup( (char *)p );
 316                 }
 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 long
 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 unsigned 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 unsigned long
 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_merge_normalize_one( e, ad, &bv, NULL );
 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 int
 532 slapi_entry_has_children(const Slapi_Entry *e)
 533 {
 534 #ifdef LDAP_SLAPI
 535         Connection *conn;
 536         Operation *op;
 537         int hasSubordinates = 0;
 538         int rc;
 539         Slapi_PBlock *pb;
 540         SlapReply rs = { REP_RESULT };
 541
 542         pb = slapi_pblock_new();
 543
 544         slapi_pblock_set( pb, SLAPI_TARGET_DN, slapi_entry_get_dn((Entry *)e) );
 545
 546         rc = slapi_int_init_connection( pb, &rs, LDAP_REQ_SEARCH, &conn );
 547         if ( rc != LDAP_SUCCESS ) {
 548                 slapi_pblock_destroy( pb );
 549                 return 0;
 550         }
 551
 552         op->o_bd->be_has_subordinates( op, (Entry *)e, &hasSubordinates );
 553
 554         slapi_int_connection_destroy( &conn );
 555         slapi_pblock_destroy( pb );
 556
 557         return ( hasSubordinates == LDAP_COMPARE_TRUE );
 558 #else
 559         return 0;
 560 #endif
 561 }
 562
 563 /*
 564  * Return approximate size of the entry rounded to the nearest
 565  * 1K. Only the size of the attribute values are counted in the
 566  * Sun implementation.
 567  *
 568  * http://docs.sun.com/source/816-6701-10/funcref.html#1017388
 569  */
 570 size_t slapi_entry_size(Slapi_Entry *e)
 571 {
 572 #ifdef LDAP_SLAPI
 573         size_t size;
 574         Attribute *a;
 575         int i;
 576
 577         for ( size = 0, a = e->e_attrs; a != NULL; a = a->a_next ) {
 578                 for ( i = 0; a->a_vals[i].bv_val != NULL; i++ ) {
 579                         size += a->a_vals[i].bv_len + 1;
 580                 }
 581         }
 582
 583         size += 1023;
 584         size -= (size % 1024);
 585
 586         return size;
 587 #else
 588         return 0;
 589 #endif /* LDAP_SLAPI */
 590 }
 591
 592 /*
 593  * Add values to entry.
 594  *
 595  * Returns:
 596  *      LDAP_SUCCESS                    Values added to entry
 597  *      LDAP_TYPE_OR_VALUE_EXISTS       One or more values exist in entry already
 598  *      LDAP_CONSTRAINT_VIOLATION       Any other error (odd, but it's the spec)
 599  */
 600 int
 601 slapi_entry_add_values( Slapi_Entry *e, const char *type, struct berval **vals )
 602 {
 603 #ifdef LDAP_SLAPI
 604         Modification            mod;
 605         const char              *text;
 606         int                     rc;
 607         char                    textbuf[SLAP_TEXT_BUFLEN];
 608
 609         mod.sm_op = LDAP_MOD_ADD;
 610         mod.sm_flags = 0;
 611         mod.sm_desc = NULL;
 612         mod.sm_type.bv_val = (char *)type;
 613         mod.sm_type.bv_len = strlen( type );
 614
 615         rc = slap_str2ad( type, &mod.sm_desc, &text );
 616         if ( rc != LDAP_SUCCESS ) {
 617                 return rc;
 618         }
 619
 620         if ( vals == NULL ) {
 621                 /* Apparently vals can be NULL
 622                  * FIXME: sm_values = NULL ? */
 623                 mod.sm_values = (BerVarray)ch_malloc( sizeof(struct berval) );
 624                 mod.sm_values->bv_val = NULL;
 625
 626         } else {
 627                 rc = bvptr2obj( vals, &mod.sm_values );
 628                 if ( rc != LDAP_SUCCESS ) {
 629                         return LDAP_CONSTRAINT_VIOLATION;
 630                 }
 631         }
 632         mod.sm_nvalues = NULL;
 633
 634         rc = modify_add_values( e, &mod, 0, &text, textbuf, sizeof(textbuf) );
 635
 636         ch_free( mod.sm_values );
 637
 638         return (rc == LDAP_SUCCESS) ? LDAP_SUCCESS : LDAP_CONSTRAINT_VIOLATION;
 639 #else
 640         return -1;
 641 #endif /* LDAP_SLAPI */
 642 }
 643
 644 int
 645 slapi_entry_add_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 646 {
 647 #ifdef LDAP_SLAPI
 648         return slapi_entry_add_values( e, type, vals );
 649 #else
 650         return -1;
 651 #endif /* LDAP_SLAPI */
 652 }
 653
 654 int
 655 slapi_entry_add_valueset(Slapi_Entry *e, const char *type, Slapi_ValueSet *vs)
 656 {
 657 #ifdef LDAP_SLAPI
 658         AttributeDescription    *ad = NULL;
 659         const char              *text;
 660         int                     rc;
 661
 662         rc = slap_str2ad( type, &ad, &text );
 663         if ( rc != LDAP_SUCCESS ) {
 664                 return -1;
 665         }
 666
 667         return attr_merge_normalize( e, ad, *vs, NULL );
 668 #else
 669         return -1;
 670 #endif /* LDAP_SLAPI */
 671 }
 672
 673 int
 674 slapi_entry_delete_values( Slapi_Entry *e, const char *type, struct berval **vals )
 675 {
 676 #ifdef LDAP_SLAPI
 677         Modification            mod;
 678         const char              *text;
 679         int                     rc;
 680         char                    textbuf[SLAP_TEXT_BUFLEN];
 681
 682         mod.sm_op = LDAP_MOD_DELETE;
 683         mod.sm_flags = 0;
 684         mod.sm_desc = NULL;
 685         mod.sm_type.bv_val = (char *)type;
 686         mod.sm_type.bv_len = strlen( type );
 687
 688         if ( vals == NULL ) {
 689                 /* If vals is NULL, this is a NOOP. */
 690                 return LDAP_SUCCESS;
 691         }
 692
 693         rc = slap_str2ad( type, &mod.sm_desc, &text );
 694         if ( rc != LDAP_SUCCESS ) {
 695                 return rc;
 696         }
 697
 698         if ( vals[0] == NULL ) {
 699                 /* SLAPI doco says LDAP_OPERATIONS_ERROR but LDAP_OTHER is better */
 700                 return attr_delete( &e->e_attrs, mod.sm_desc ) ? LDAP_OTHER : LDAP_SUCCESS;
 701         }
 702
 703         rc = bvptr2obj( vals, &mod.sm_values );
 704         if ( rc != LDAP_SUCCESS ) {
 705                 return LDAP_CONSTRAINT_VIOLATION;
 706         }
 707         mod.sm_nvalues = NULL;
 708
 709         rc = modify_delete_values( e, &mod, 0, &text, textbuf, sizeof(textbuf) );
 710
 711         ch_free( mod.sm_values );
 712
 713         return rc;
 714 #else
 715         return -1;
 716 #endif /* LDAP_SLAPI */
 717 }
 718
 719 int
 720 slapi_entry_delete_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 721 {
 722 #ifdef LDAP_SLAPI
 723         return slapi_entry_delete_values( e, type, vals );
 724 #else
 725         return -1;
 726 #endif /* LDAP_SLAPI */
 727 }
 728
 729 int
 730 slapi_entry_merge_values_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 731 {
 732 #ifdef LDAP_SLAPI
 733         return slapi_entry_attr_merge( e, (char *)type, vals );
 734 #else
 735         return -1;
 736 #endif /* LDAP_SLAPI */
 737 }
 738
 739 int
 740 slapi_entry_add_value(Slapi_Entry *e, const char *type, const Slapi_Value *value)
 741 {
 742 #ifdef LDAP_SLAPI
 743         AttributeDescription    *ad = NULL;
 744         int                     rc;
 745         const char              *text;
 746
 747         rc = slap_str2ad( type, &ad, &text );
 748         if ( rc != LDAP_SUCCESS ) {
 749                 return -1;
 750         }
 751
 752         rc = attr_merge_normalize_one( e, ad, (Slapi_Value *)value, NULL );
 753         if ( rc != LDAP_SUCCESS ) {
 754                 return -1;
 755         }
 756
 757         return 0;
 758 #else
 759         return -1;
 760 #endif /* LDAP_SLAPI */
 761 }
 762
 763 int
 764 slapi_entry_add_string(Slapi_Entry *e, const char *type, const char *value)
 765 {
 766 #ifdef LDAP_SLAPI
 767         Slapi_Value val;
 768
 769         val.bv_val = (char *)value;
 770         val.bv_len = strlen( value );
 771
 772         return slapi_entry_add_value( e, type, &val );
 773 #else
 774         return -1;
 775 #endif /* LDAP_SLAPI */
 776 }
 777
 778 int
 779 slapi_entry_delete_string(Slapi_Entry *e, const char *type, const char *value)
 780 {
 781 #ifdef LDAP_SLAPI
 782         Slapi_Value *vals[2];
 783         Slapi_Value val;
 784
 785         val.bv_val = (char *)value;
 786         val.bv_len = strlen( value );
 787         vals[0] = &val;
 788         vals[1] = NULL;
 789
 790         return slapi_entry_delete_values_sv( e, type, vals );
 791 #else
 792         return -1;
 793 #endif /* LDAP_SLAPI */
 794 }
 795
 796
 797 int
 798 slapi_entry_attr_merge_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 799 {
 800 #ifdef LDAP_SLAPI
 801         return slapi_entry_attr_merge( e, (char *)type, vals );
 802 #else
 803         return -1;
 804 #endif
 805 }
 806
 807 int
 808 slapi_entry_first_attr( const Slapi_Entry *e, Slapi_Attr **attr )
 809 {
 810 #ifdef LDAP_SLAPI
 811         if ( e == NULL ) {
 812                 return -1;
 813         }
 814
 815         *attr = e->e_attrs;
 816
 817         return ( *attr != NULL ) ? 0 : -1;
 818 #else
 819         return -1;
 820 #endif
 821 }
 822
 823 int
 824 slapi_entry_next_attr( const Slapi_Entry *e, Slapi_Attr *prevattr, Slapi_Attr **attr )
 825 {
 826 #ifdef LDAP_SLAPI
 827         if ( e == NULL ) {
 828                 return -1;
 829         }
 830
 831         if ( prevattr == NULL ) {
 832                 return -1;
 833         }
 834
 835         *attr = prevattr->a_next;
 836
 837         return ( *attr != NULL ) ? 0 : -1;
 838 #else
 839         return -1;
 840 #endif
 841 }
 842
 843 int
 844 slapi_entry_attr_replace_sv( Slapi_Entry *e, const char *type, Slapi_Value **vals )
 845 {
 846 #ifdef LDAP_SLAPI
 847         AttributeDescription *ad = NULL;
 848         const char *text;
 849         int rc;
 850         BerVarray bv;
 851
 852         rc = slap_str2ad( type, &ad, &text );
 853         if ( rc != LDAP_SUCCESS ) {
 854                 return 0;
 855         }
 856
 857         attr_delete( &e->e_attrs, ad );
 858
 859         rc = bvptr2obj( vals, &bv );
 860         if ( rc != LDAP_SUCCESS ) {
 861                 return -1;
 862         }
 863
 864         rc = attr_merge_normalize( e, ad, bv, NULL );
 865         slapi_ch_free( (void **)&bv );
 866         if ( rc != LDAP_SUCCESS ) {
 867                 return -1;
 868         }
 869
 870         return 0;
 871 #else
 872         return -1;
 873 #endif /* LDAP_SLAPI */
 874 }
 875
 876 /*
 877  * FIXME -- The caller must free the allocated memory.
 878  * In Netscape they do not have to.
 879  */
 880 int
 881 slapi_attr_get_values(
 882         Slapi_Attr      *attr,
 883         struct berval   ***vals )
 884 {
 885 #ifdef LDAP_SLAPI
 886         int             i, j;
 887         struct berval   **bv;
 888
 889         if ( attr == NULL ) {
 890                 return 1;
 891         }
 892
 893         for ( i = 0; attr->a_vals[i].bv_val != NULL; i++ ) {
 894                 ; /* EMPTY */
 895         }
 896
 897         bv = (struct berval **)ch_malloc( (i + 1) * sizeof(struct berval *) );
 898         for ( j = 0; j < i; j++ ) {
 899                 bv[j] = ber_dupbv( NULL, &attr->a_vals[j] );
 900         }
 901         bv[j] = NULL;
 902
 903         *vals = (struct berval **)bv;
 904
 905         return 0;
 906 #else /* LDAP_SLAPI */
 907         return -1;
 908 #endif /* LDAP_SLAPI */
 909 }
 910
 911 char *
 912 slapi_dn_normalize( char *dn )
 913 {
 914 #ifdef LDAP_SLAPI
 915         struct berval   bdn;
 916         struct berval   pdn;
 917
 918         assert( dn != NULL );
 919
 920         bdn.bv_val = dn;
 921         bdn.bv_len = strlen( dn );
 922
 923         if ( dnPretty( NULL, &bdn, &pdn, NULL ) != LDAP_SUCCESS ) {
 924                 return NULL;
 925         }
 926
 927         return pdn.bv_val;
 928 #else /* LDAP_SLAPI */
 929         return NULL;
 930 #endif /* LDAP_SLAPI */
 931 }
 932
 933 char *
 934 slapi_dn_normalize_case( char *dn )
 935 {
 936 #ifdef LDAP_SLAPI
 937         struct berval   bdn;
 938         struct berval   ndn;
 939
 940         assert( dn != NULL );
 941
 942         bdn.bv_val = dn;
 943         bdn.bv_len = strlen( dn );
 944
 945         if ( dnNormalize( 0, NULL, NULL, &bdn, &ndn, NULL ) != LDAP_SUCCESS ) {
 946                 return NULL;
 947         }
 948
 949         return ndn.bv_val;
 950 #else /* LDAP_SLAPI */
 951         return NULL;
 952 #endif /* LDAP_SLAPI */
 953 }
 954
 955 int
 956 slapi_dn_issuffix(
 957         char            *dn,
 958         char            *suffix )
 959 {
 960 #ifdef LDAP_SLAPI
 961         struct berval   bdn, ndn;
 962         struct berval   bsuffix, nsuffix;
 963         int rc;
 964
 965         assert( dn != NULL );
 966         assert( suffix != NULL );
 967
 968         bdn.bv_val = dn;
 969         bdn.bv_len = strlen( dn );
 970
 971         bsuffix.bv_val = suffix;
 972         bsuffix.bv_len = strlen( suffix );
 973
 974         if ( dnNormalize( 0, NULL, NULL, &bdn, &ndn, NULL ) != LDAP_SUCCESS ) {
 975                 return 0;
 976         }
 977
 978         if ( dnNormalize( 0, NULL, NULL, &bsuffix, &nsuffix, NULL )
 979                 != LDAP_SUCCESS )
 980         {
 981                 slapi_ch_free( (void **)&ndn.bv_val );
 982                 return 0;
 983         }
 984
 985         rc = dnIsSuffix( &ndn, &nsuffix );
 986
 987         slapi_ch_free( (void **)&ndn.bv_val );
 988         slapi_ch_free( (void **)&nsuffix.bv_val );
 989
 990         return rc;
 991 #else /* LDAP_SLAPI */
 992         return 0;
 993 #endif /* LDAP_SLAPI */
 994 }
 995
 996 int
 997 slapi_dn_isparent(
 998         const char      *parentdn,
 999         const char      *childdn )
1000 {
1001 #ifdef LDAP_SLAPI
1002         struct berval   assertedParentDN, normalizedAssertedParentDN;
1003         struct berval   childDN, normalizedChildDN;
1004         struct berval   normalizedParentDN;
1005         int             match;
1006
1007         assert( parentdn != NULL );
1008         assert( childdn != NULL );
1009
1010         assertedParentDN.bv_val = (char *)parentdn;
1011         assertedParentDN.bv_len = strlen( parentdn );
1012
1013         if ( dnNormalize( 0, NULL, NULL, &assertedParentDN,
1014                 &normalizedAssertedParentDN, NULL ) != LDAP_SUCCESS )
1015         {
1016                 return 0;
1017         }
1018
1019         childDN.bv_val = (char *)childdn;
1020         childDN.bv_len = strlen( childdn );
1021
1022         if ( dnNormalize( 0, NULL, NULL, &childDN,
1023                 &normalizedChildDN, NULL ) != LDAP_SUCCESS )
1024         {
1025                 slapi_ch_free( (void **)&normalizedAssertedParentDN.bv_val );
1026                 return 0;
1027         }
1028
1029         dnParent( &normalizedChildDN, &normalizedParentDN );
1030
1031         if ( dnMatch( &match, 0, slap_schema.si_syn_distinguishedName, NULL,
1032                 &normalizedParentDN, (void *)&normalizedAssertedParentDN ) != LDAP_SUCCESS )
1033         {
1034                 match = -1;
1035         }
1036
1037         slapi_ch_free( (void **)&normalizedAssertedParentDN.bv_val );
1038         slapi_ch_free( (void **)&normalizedChildDN.bv_val );
1039
1040         return ( match == 0 );
1041 #else
1042         return 0;
1043 #endif /* LDAP_SLAPI */
1044 }
1045
1046 /*
1047  * Returns DN of the parent entry, or NULL if the DN is
1048  * an empty string or NULL, or has no parent.
1049  */
1050 char *
1051 slapi_dn_parent( const char *_dn )
1052 {
1053 #ifdef LDAP_SLAPI
1054         struct berval   dn, prettyDN;
1055         struct berval   parentDN;
1056
1057         if ( _dn == NULL ) {
1058                 return NULL;
1059         }
1060
1061         dn.bv_val = (char *)_dn;
1062         dn.bv_len = strlen( _dn );
1063
1064         if ( dn.bv_len == 0 ) {
1065                 return NULL;
1066         }
1067
1068         if ( dnPretty( NULL, &dn, &prettyDN, NULL ) != LDAP_SUCCESS ) {
1069                 return NULL;
1070         }
1071
1072         dnParent( &prettyDN, &parentDN ); /* in-place */
1073
1074         slapi_ch_free( (void **)&prettyDN.bv_val );
1075
1076         if ( parentDN.bv_len == 0 ) {
1077                 return NULL;
1078         }
1079
1080         return slapi_ch_strdup( parentDN.bv_val );
1081 #else
1082         return NULL;
1083 #endif /* LDAP_SLAPI */
1084 }
1085
1086 /*
1087  * Returns DN of the parent entry; or NULL if the DN is
1088  * an empty string, if the DN has no parent, or if the
1089  * DN is the suffix of the backend database
1090  */
1091 char *slapi_dn_beparent( Slapi_PBlock *pb, const char *_dn )
1092 {
1093 #ifdef LDAP_SLAPI
1094         Backend         *be;
1095         struct berval   dn, prettyDN;
1096         struct berval   normalizedDN, parentDN;
1097
1098         if ( slapi_pblock_get( pb, SLAPI_BACKEND, (void **)&be ) != 0 )
1099                 be = NULL;
1100
1101         dn.bv_val = (char *)_dn;
1102         dn.bv_len = strlen( _dn );
1103
1104         if ( dnPrettyNormal( NULL, &dn, &prettyDN, &normalizedDN, NULL ) != LDAP_SUCCESS ) {
1105                 return NULL;
1106         }
1107
1108         if ( be != NULL && be_issuffix( be, &normalizedDN ) ) {
1109                 slapi_ch_free( (void **)&prettyDN.bv_val );
1110                 slapi_ch_free( (void **)&normalizedDN.bv_val );
1111                 return NULL;
1112         }
1113
1114         dnParent( &prettyDN, &parentDN );
1115
1116         slapi_ch_free( (void **)&prettyDN.bv_val );
1117         slapi_ch_free( (void **)&normalizedDN.bv_val );
1118
1119         if ( parentDN.bv_len == 0 ) {
1120                 return NULL;
1121         }
1122
1123         return slapi_ch_strdup( parentDN.bv_val );
1124 #else
1125         return NULL;
1126 #endif /* LDAP_SLAPI */
1127 }
1128
1129 char *
1130 slapi_dn_ignore_case( char *dn )
1131 {
1132 #ifdef LDAP_SLAPI
1133         return slapi_dn_normalize_case( dn );
1134 #else /* LDAP_SLAPI */
1135         return NULL;
1136 #endif /* LDAP_SLAPI */
1137 }
1138
1139 char *
1140 slapi_ch_malloc( unsigned long size )
1141 {
1142 #ifdef LDAP_SLAPI
1143         return ch_malloc( size );
1144 #else /* LDAP_SLAPI */
1145         return NULL;
1146 #endif /* LDAP_SLAPI */
1147 }
1148
1149 void
1150 slapi_ch_free( void **ptr )
1151 {
1152 #ifdef LDAP_SLAPI
1153         ch_free( *ptr );
1154         *ptr = NULL;
1155 #endif /* LDAP_SLAPI */
1156 }
1157
1158 void
1159 slapi_ch_free_string( char **ptr )
1160 {
1161 #ifdef LDAP_SLAPI
1162         slapi_ch_free( (void **)ptr );
1163 #endif /* LDAP_SLAPI */
1164 }
1165
1166 void
1167 slapi_ch_array_free( char **arrayp )
1168 {
1169 #ifdef LDAP_SLAPI
1170         char **p;
1171
1172         if ( arrayp != NULL ) {
1173                 for ( p = arrayp; *p != NULL; p++ ) {
1174                         slapi_ch_free( (void **)p );
1175                 }
1176                 slapi_ch_free( (void **)&arrayp );
1177         }
1178 #endif
1179 }
1180
1181 struct berval *
1182 slapi_ch_bvdup(const struct berval *v)
1183 {
1184 #ifdef LDAP_SLAPI
1185         struct berval *bv;
1186
1187         bv = (struct berval *) slapi_ch_malloc( sizeof(struct berval) );
1188         bv->bv_len = v->bv_len;
1189         bv->bv_val = slapi_ch_malloc( bv->bv_len );
1190         AC_MEMCPY( bv->bv_val, v->bv_val, bv->bv_len );
1191
1192         return bv;
1193 #else
1194         return NULL;
1195 #endif
1196 }
1197
1198 struct berval **
1199 slapi_ch_bvecdup(const struct berval **v)
1200 {
1201 #ifdef LDAP_SLAPI
1202         int i;
1203         struct berval **rv;
1204
1205         if ( v == NULL ) {
1206                 return NULL;
1207         }
1208
1209         for ( i = 0; v[i] != NULL; i++ )
1210                 ;
1211
1212         rv = (struct berval **) slapi_ch_malloc( (i + 1) * sizeof(struct berval *) );
1213
1214         for ( i = 0; v[i] != NULL; i++ ) {
1215                 rv[i] = slapi_ch_bvdup( v[i] );
1216         }
1217         rv[i] = NULL;
1218
1219         return rv;
1220 #else
1221         return NULL;
1222 #endif
1223 }
1224
1225 char *
1226 slapi_ch_calloc(
1227         unsigned long nelem,
1228         unsigned long size )
1229 {
1230 #ifdef LDAP_SLAPI
1231         return ch_calloc( nelem, size );
1232 #else /* LDAP_SLAPI */
1233         return NULL;
1234 #endif /* LDAP_SLAPI */
1235 }
1236
1237 char *
1238 slapi_ch_realloc(
1239         char *block,
1240         unsigned long size )
1241 {
1242 #ifdef LDAP_SLAPI
1243         return ch_realloc( block, size );
1244 #else /* LDAP_SLAPI */
1245         return NULL;
1246 #endif /* LDAP_SLAPI */
1247 }
1248
1249 char *
1250 slapi_ch_strdup( char *s )
1251 {
1252 #ifdef LDAP_SLAPI
1253         return ch_strdup( (const char *)s );
1254 #else /* LDAP_SLAPI */
1255         return NULL;
1256 #endif /* LDAP_SLAPI */
1257 }
1258
1259 size_t
1260 slapi_ch_stlen( char *s )
1261 {
1262 #ifdef LDAP_SLAPI
1263         return strlen( (const char *)s );
1264 #else /* LDAP_SLAPI */
1265         return 0;
1266 #endif /* LDAP_SLAPI */
1267 }
1268
1269 int
1270 slapi_control_present(
1271         LDAPControl     **controls,
1272         char            *oid,
1273         struct berval   **val,
1274         int             *iscritical )
1275 {
1276 #ifdef LDAP_SLAPI
1277         int             i;
1278         int             rc = 0;
1279
1280         if ( val ) {
1281                 *val = NULL;
1282         }
1283
1284         if ( iscritical ) {
1285                 *iscritical = 0;
1286         }
1287
1288         for ( i = 0; controls != NULL && controls[i] != NULL; i++ ) {
1289                 if ( strcmp( controls[i]->ldctl_oid, oid ) != 0 ) {
1290                         continue;
1291                 }
1292
1293                 rc = 1;
1294                 if ( controls[i]->ldctl_value.bv_len != 0 ) {
1295                         /*
1296                          * FIXME: according to 6.1 specification,
1297                          *    "The val output parameter is set
1298                          *    to point into the controls array.
1299                          *    A copy of the control value is
1300                          *    not made."
1301                          */
1302 #if 0
1303                         struct berval   *pTmpBval;
1304
1305                         pTmpBval = (struct berval *)slapi_ch_malloc( sizeof(struct berval));
1306                         if ( pTmpBval == NULL ) {
1307                                 rc = 0;
1308                         } else {
1309                                 pTmpBval->bv_len = controls[i]->ldctl_value.bv_len;
1310                                 pTmpBval->bv_val = controls[i]->ldctl_value.bv_val;
1311                                 if ( val ) {
1312                                         *val = pTmpBval;
1313                                 } else {
1314                                         slapi_ch_free( (void **)&pTmpBval );
1315                                         rc = 0;
1316                                 }
1317                         }
1318 #endif /* 0 */
1319                         if ( val ) {
1320                                 *val = &controls[i]->ldctl_value;
1321                         }
1322                 }
1323
1324                 if ( iscritical ) {
1325                         *iscritical = controls[i]->ldctl_iscritical;
1326                 }
1327
1328                 break;
1329         }
1330
1331         return rc;
1332 #else /* LDAP_SLAPI */
1333         return 0;
1334 #endif /* LDAP_SLAPI */
1335 }
1336
1337 #ifdef LDAP_SLAPI
1338 static void
1339 slapControlMask2SlapiControlOp(slap_mask_t slap_mask,
1340         unsigned long *slapi_mask)
1341 {
1342         *slapi_mask = SLAPI_OPERATION_NONE;
1343
1344         if ( slap_mask & SLAP_CTRL_ABANDON )
1345                 *slapi_mask |= SLAPI_OPERATION_ABANDON;
1346
1347         if ( slap_mask & SLAP_CTRL_ADD )
1348                 *slapi_mask |= SLAPI_OPERATION_ADD;
1349
1350         if ( slap_mask & SLAP_CTRL_BIND )
1351                 *slapi_mask |= SLAPI_OPERATION_BIND;
1352
1353         if ( slap_mask & SLAP_CTRL_COMPARE )
1354                 *slapi_mask |= SLAPI_OPERATION_COMPARE;
1355
1356         if ( slap_mask & SLAP_CTRL_DELETE )
1357                 *slapi_mask |= SLAPI_OPERATION_DELETE;
1358
1359         if ( slap_mask & SLAP_CTRL_MODIFY )
1360                 *slapi_mask |= SLAPI_OPERATION_MODIFY;
1361
1362         if ( slap_mask & SLAP_CTRL_RENAME )
1363                 *slapi_mask |= SLAPI_OPERATION_MODDN;
1364
1365         if ( slap_mask & SLAP_CTRL_SEARCH )
1366                 *slapi_mask |= SLAPI_OPERATION_SEARCH;
1367
1368         if ( slap_mask & SLAP_CTRL_UNBIND )
1369                 *slapi_mask |= SLAPI_OPERATION_UNBIND;
1370 }
1371
1372 static void
1373 slapiControlOp2SlapControlMask(unsigned long slapi_mask,
1374         slap_mask_t *slap_mask)
1375 {
1376         *slap_mask = 0;
1377
1378         if ( slapi_mask & SLAPI_OPERATION_BIND )
1379                 *slap_mask |= SLAP_CTRL_BIND;
1380
1381         if ( slapi_mask & SLAPI_OPERATION_UNBIND )
1382                 *slap_mask |= SLAP_CTRL_UNBIND;
1383
1384         if ( slapi_mask & SLAPI_OPERATION_SEARCH )
1385                 *slap_mask |= SLAP_CTRL_SEARCH;
1386
1387         if ( slapi_mask & SLAPI_OPERATION_MODIFY )
1388                 *slap_mask |= SLAP_CTRL_MODIFY;
1389
1390         if ( slapi_mask & SLAPI_OPERATION_ADD )
1391                 *slap_mask |= SLAP_CTRL_ADD;
1392
1393         if ( slapi_mask & SLAPI_OPERATION_DELETE )
1394                 *slap_mask |= SLAP_CTRL_DELETE;
1395
1396         if ( slapi_mask & SLAPI_OPERATION_MODDN )
1397                 *slap_mask |= SLAP_CTRL_RENAME;
1398
1399         if ( slapi_mask & SLAPI_OPERATION_COMPARE )
1400                 *slap_mask |= SLAP_CTRL_COMPARE;
1401
1402         if ( slapi_mask & SLAPI_OPERATION_ABANDON )
1403                 *slap_mask |= SLAP_CTRL_ABANDON;
1404
1405         *slap_mask |= SLAP_CTRL_GLOBAL;
1406 }
1407
1408 static int
1409 slapi_int_parse_control(
1410         Operation *op,
1411         SlapReply *rs,
1412         LDAPControl *ctrl )
1413 {
1414         /* Plugins must deal with controls themselves. */
1415
1416         return LDAP_SUCCESS;
1417 }
1418 #endif /* LDAP_SLAPI */
1419
1420 void
1421 slapi_register_supported_control(
1422         char            *controloid,
1423         unsigned long   controlops )
1424 {
1425 #ifdef LDAP_SLAPI
1426         slap_mask_t controlmask;
1427
1428         slapiControlOp2SlapControlMask( controlops, &controlmask );
1429
1430         register_supported_control( controloid, controlmask, NULL, slapi_int_parse_control, NULL );
1431 #endif /* LDAP_SLAPI */
1432 }
1433
1434 int
1435 slapi_get_supported_controls(
1436         char            ***ctrloidsp,
1437         unsigned long   **ctrlopsp )
1438 {
1439 #ifdef LDAP_SLAPI
1440         int i, rc;
1441
1442         rc = get_supported_controls( ctrloidsp, (slap_mask_t **)ctrlopsp );
1443         if ( rc != LDAP_SUCCESS ) {
1444                 return rc;
1445         }
1446
1447         for ( i = 0; (*ctrloidsp)[i] != NULL; i++ ) {
1448                 /* In place, naughty. */
1449                 slapControlMask2SlapiControlOp( (*ctrlopsp)[i], &((*ctrlopsp)[i]) );
1450         }
1451
1452         return LDAP_SUCCESS;
1453 #else /* LDAP_SLAPI */
1454         return 1;
1455 #endif /* LDAP_SLAPI */
1456 }
1457
1458 LDAPControl *
1459 slapi_dup_control( LDAPControl *ctrl )
1460 {
1461 #ifdef LDAP_SLAPI
1462         LDAPControl *ret;
1463
1464         ret = (LDAPControl *)slapi_ch_malloc( sizeof(*ret) );
1465         ret->ldctl_oid = slapi_ch_strdup( ctrl->ldctl_oid );
1466         ber_dupbv( &ret->ldctl_value, &ctrl->ldctl_value );
1467         ret->ldctl_iscritical = ctrl->ldctl_iscritical;
1468
1469         return ret;
1470 #else
1471         return NULL;
1472 #endif /* LDAP_SLAPI */
1473 }
1474
1475 void
1476 slapi_register_supported_saslmechanism( char *mechanism )
1477 {
1478 #ifdef LDAP_SLAPI
1479         /* FIXME -- can not add saslmechanism to OpenLDAP dynamically */
1480         slapi_log_error( SLAPI_LOG_FATAL, "slapi_register_supported_saslmechanism",
1481                         "OpenLDAP does not support dynamic registration of SASL mechanisms\n" );
1482 #endif /* LDAP_SLAPI */
1483 }
1484
1485 char **
1486 slapi_get_supported_saslmechanisms( void )
1487 {
1488 #ifdef LDAP_SLAPI
1489         /* FIXME -- can not get the saslmechanism without a connection. */
1490         slapi_log_error( SLAPI_LOG_FATAL, "slapi_get_supported_saslmechanisms",
1491                         "can not get the SASL mechanism list "
1492                         "without a connection\n" );
1493         return NULL;
1494 #else /* LDAP_SLAPI */
1495         return NULL;
1496 #endif /* LDAP_SLAPI */
1497 }
1498
1499 char **
1500 slapi_get_supported_extended_ops( void )
1501 {
1502 #ifdef LDAP_SLAPI
1503         int             i, j, k;
1504         char            **ppExtOpOID = NULL;
1505         int             numExtOps = 0;
1506
1507         for ( i = 0; get_supported_extop( i ) != NULL; i++ ) {
1508                 ;
1509         }
1510
1511         for ( j = 0; slapi_int_get_supported_extop( j ) != NULL; j++ ) {
1512                 ;
1513         }
1514
1515         numExtOps = i + j;
1516         if ( numExtOps == 0 ) {
1517                 return NULL;
1518         }
1519
1520         ppExtOpOID = (char **)slapi_ch_malloc( (numExtOps + 1) * sizeof(char *) );
1521         for ( k = 0; k < i; k++ ) {
1522                 struct berval   *bv;
1523
1524                 bv = get_supported_extop( k );
1525                 assert( bv != NULL );
1526
1527                 ppExtOpOID[ k ] = bv->bv_val;
1528         }
1529
1530         for ( ; k < j; k++ ) {
1531                 struct berval   *bv;
1532
1533                 bv = slapi_int_get_supported_extop( k );
1534                 assert( bv != NULL );
1535
1536                 ppExtOpOID[ i + k ] = bv->bv_val;
1537         }
1538         ppExtOpOID[ i + k ] = NULL;
1539
1540         return ppExtOpOID;
1541 #else /* LDAP_SLAPI */
1542         return NULL;
1543 #endif /* LDAP_SLAPI */
1544 }
1545
1546 void
1547 slapi_send_ldap_result(
1548         Slapi_PBlock    *pb,
1549         int             err,
1550         char            *matched,
1551         char            *text,
1552         int             nentries,
1553         struct berval   **urls )
1554 {
1555 #ifdef LDAP_SLAPI
1556         Operation       *op;
1557         char            *extOID = NULL;
1558         SlapReply       rs = { REP_RESULT };
1559
1560         slapi_pblock_get( pb, SLAPI_OPERATION, &op );
1561
1562         rs.sr_err = err;
1563         rs.sr_matched = matched;
1564         rs.sr_text = text;
1565         rs.sr_ref = NULL;
1566         rs.sr_ctrls = NULL;
1567
1568         slapi_pblock_get( pb, SLAPI_RESCONTROLS, &rs.sr_ctrls );
1569
1570         if ( err == LDAP_SASL_BIND_IN_PROGRESS ) {
1571                 slapi_pblock_get( pb, SLAPI_BIND_RET_SASLCREDS, (void *) &rs.sr_sasldata );
1572                 send_ldap_sasl( op, &rs );
1573                 return;
1574         }
1575
1576         slapi_pblock_get( pb, SLAPI_EXT_OP_RET_OID, &extOID );
1577         if ( extOID != NULL ) {
1578                 rs.sr_rspoid = extOID;
1579                 slapi_pblock_get( pb, SLAPI_EXT_OP_RET_VALUE, &rs.sr_rspdata );
1580                 send_ldap_extended( op, &rs );
1581                 return;
1582         }
1583
1584         if ( op->o_tag == LDAP_REQ_SEARCH )
1585                 rs.sr_nentries = nentries;
1586
1587         send_ldap_result( op, &rs );
1588 #endif /* LDAP_SLAPI */
1589 }
1590
1591 int
1592 slapi_send_ldap_search_entry(
1593         Slapi_PBlock    *pb,
1594         Slapi_Entry     *e,
1595         LDAPControl     **ectrls,
1596         char            **attrs,
1597         int             attrsonly )
1598 {
1599 #ifdef LDAP_SLAPI
1600         Operation       *pOp;
1601         SlapReply       rs = { REP_RESULT };
1602         int             i;
1603         AttributeName   *an = NULL;
1604         const char      *text;
1605
1606         if ( attrs != NULL ) {
1607                 for ( i = 0; attrs[ i ] != NULL; i++ ) {
1608                         ; /* empty */
1609                 }
1610         } else {
1611                 i = 0;
1612         }
1613
1614         if ( i > 0 ) {
1615                 an = (AttributeName *) ch_malloc( (i+1) * sizeof(AttributeName) );
1616                 for ( i = 0; attrs[i] != NULL; i++ ) {
1617                         an[i].an_name.bv_val = ch_strdup( attrs[i] );
1618                         an[i].an_name.bv_len = strlen( attrs[i] );
1619                         an[i].an_desc = NULL;
1620                         if( slap_bv2ad( &an[i].an_name, &an[i].an_desc, &text ) != LDAP_SUCCESS)
1621                                 return -1;
1622                 }
1623                 an[i].an_name.bv_len = 0;
1624                 an[i].an_name.bv_val = NULL;
1625         }
1626
1627         rs.sr_err = LDAP_SUCCESS;
1628         rs.sr_matched = NULL;
1629         rs.sr_text = NULL;
1630         rs.sr_ref = NULL;
1631         rs.sr_ctrls = ectrls;
1632         rs.sr_attrs = an;
1633         rs.sr_operational_attrs = NULL;
1634         rs.sr_entry = e;
1635         rs.sr_v2ref = NULL;
1636         rs.sr_flags = 0;
1637
1638         if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&pOp ) != 0 ) {
1639                 return LDAP_OTHER;
1640         }
1641
1642         return send_search_entry( pOp, &rs );
1643 #else /* LDAP_SLAPI */
1644         return -1;
1645 #endif /* LDAP_SLAPI */
1646 }
1647
1648 int
1649 slapi_send_ldap_search_reference(
1650         Slapi_PBlock    *pb,
1651         Slapi_Entry     *e,
1652         struct berval   **references,
1653         LDAPControl     **ectrls,
1654         struct berval   **v2refs
1655         )
1656 {
1657 #ifdef LDAP_SLAPI
1658         Operation       *pOp;
1659         SlapReply       rs = { REP_SEARCHREF };
1660         int             rc;
1661
1662         rs.sr_err = LDAP_SUCCESS;
1663         rs.sr_matched = NULL;
1664         rs.sr_text = NULL;
1665
1666         rc = bvptr2obj( references, &rs.sr_ref );
1667         if ( rc != LDAP_SUCCESS ) {
1668                 return rc;
1669         }
1670
1671         rs.sr_ctrls = ectrls;
1672         rs.sr_attrs = NULL;
1673         rs.sr_operational_attrs = NULL;
1674         rs.sr_entry = e;
1675
1676         if ( v2refs != NULL ) {
1677                 rc = bvptr2obj( v2refs, &rs.sr_v2ref );
1678                 if ( rc != LDAP_SUCCESS ) {
1679                         slapi_ch_free( (void **)&rs.sr_ref );
1680                         return rc;
1681                 }
1682         } else {
1683                 rs.sr_v2ref = NULL;
1684         }
1685
1686         if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&pOp ) != 0 ) {
1687                 return LDAP_OTHER;
1688         }
1689
1690         rc = send_search_reference( pOp, &rs );
1691
1692         if ( rs.sr_ref != NULL )
1693                 slapi_ch_free( (void **)&rs.sr_ref );
1694
1695         if ( rs.sr_v2ref != NULL )
1696                 slapi_ch_free( (void **)&rs.sr_v2ref );
1697
1698         return rc;
1699 #else
1700         return -1;
1701 #endif /* LDAP_SLAPI */
1702 }
1703
1704 Slapi_Filter *
1705 slapi_str2filter( char *str )
1706 {
1707 #ifdef LDAP_SLAPI
1708         return str2filter( str );
1709 #else /* LDAP_SLAPI */
1710         return NULL;
1711 #endif /* LDAP_SLAPI */
1712 }
1713
1714 void
1715 slapi_filter_free(
1716         Slapi_Filter    *f,
1717         int             recurse )
1718 {
1719 #ifdef LDAP_SLAPI
1720         filter_free( f );
1721 #endif /* LDAP_SLAPI */
1722 }
1723
1724 Slapi_Filter *
1725 slapi_filter_dup( Slapi_Filter *filter )
1726 {
1727 #ifdef LDAP_SLAPI
1728         Filter *f;
1729
1730         f = (Filter *) slapi_ch_malloc( sizeof(Filter) );
1731         f->f_next = NULL;
1732         f->f_choice = filter->f_choice;
1733
1734         switch ( f->f_choice ) {
1735         case LDAP_FILTER_AND:
1736         case LDAP_FILTER_NOT:
1737         case LDAP_FILTER_OR: {
1738                 Filter *pFilter, **ppF;
1739
1740                 for ( pFilter = filter->f_list, ppF = &f->f_list;
1741                       pFilter != NULL;
1742                       pFilter = pFilter->f_next, ppF = &f->f_next )
1743                 {
1744                         *ppF = slapi_filter_dup( pFilter );
1745                         if ( *ppF == NULL )
1746                                 break;
1747                 }
1748                 break;
1749         }
1750         case LDAP_FILTER_PRESENT:
1751                 f->f_desc = filter->f_desc;
1752                 break;
1753         case LDAP_FILTER_EQUALITY:
1754         case LDAP_FILTER_GE:
1755         case LDAP_FILTER_LE:
1756         case LDAP_FILTER_APPROX:
1757                 f->f_ava = (AttributeAssertion *)slapi_ch_malloc( sizeof(AttributeAssertion) );
1758                 f->f_ava->aa_desc = filter->f_ava->aa_desc;
1759                 ber_dupbv( &f->f_ava->aa_value, &filter->f_ava->aa_value );
1760                 break;
1761         case LDAP_FILTER_EXT:
1762                 f->f_mra = (MatchingRuleAssertion *)slapi_ch_malloc( sizeof(MatchingRuleAssertion) );
1763                 f->f_mra->ma_rule = filter->f_mra->ma_rule;
1764                 f->f_mra->ma_rule_text = filter->f_mra->ma_rule_text; /* struct copy */
1765                 f->f_mra->ma_desc = filter->f_mra->ma_desc;
1766                 f->f_mra->ma_dnattrs = filter->f_mra->ma_dnattrs;
1767                 ber_dupbv( &f->f_mra->ma_value, &filter->f_mra->ma_value );
1768                 break;
1769         case LDAP_FILTER_SUBSTRINGS: {
1770                 int i;
1771
1772                 f->f_sub = (SubstringsAssertion *)slapi_ch_malloc( sizeof(SubstringsAssertion) );
1773                 f->f_sub->sa_desc = filter->f_sub->sa_desc;
1774                 ber_dupbv( &f->f_sub_initial, &filter->f_sub_initial );
1775                 if ( filter->f_sub_any != NULL ) {
1776                         for ( i = 0; filter->f_sub_any[i].bv_val != NULL; i++ )
1777                                 ;
1778                         f->f_sub_any = (BerVarray)slapi_ch_malloc( (i + 1) * (sizeof(struct berval)) );
1779                         for ( i = 0; filter->f_sub_any[i].bv_val != NULL; i++ ) {
1780                                 ber_dupbv( &f->f_sub_any[i], &filter->f_sub_any[i] );
1781                         }
1782                         f->f_sub_any[i].bv_val = NULL;
1783                 } else {
1784                         f->f_sub_any = NULL;
1785                 }
1786                 ber_dupbv( &f->f_sub_final, &filter->f_sub_final );
1787                 break;
1788         }
1789         case SLAPD_FILTER_COMPUTED:
1790                 f->f_result = filter->f_result;
1791                 break;
1792         default:
1793                 slapi_ch_free( (void **)&f );
1794                 f = NULL;
1795                 break;
1796         }
1797
1798         return f;
1799 #else
1800         return NULL;
1801 #endif /* LDAP_SLAPI */
1802 }
1803
1804 int
1805 slapi_filter_get_choice( Slapi_Filter *f )
1806 {
1807 #ifdef LDAP_SLAPI
1808         int             rc;
1809
1810         if ( f != NULL ) {
1811                 rc = f->f_choice;
1812         } else {
1813                 rc = 0;
1814         }
1815
1816         return rc;
1817 #else /* LDAP_SLAPI */
1818         return -1;              /* invalid filter type */
1819 #endif /* LDAP_SLAPI */
1820 }
1821
1822 int
1823 slapi_filter_get_ava(
1824         Slapi_Filter    *f,
1825         char            **type,
1826         struct berval   **bval )
1827 {
1828 #ifdef LDAP_SLAPI
1829         int             ftype;
1830         int             rc = LDAP_SUCCESS;
1831
1832         assert( type != NULL );
1833         assert( bval != NULL );
1834
1835         *type = NULL;
1836         *bval = NULL;
1837
1838         ftype = f->f_choice;
1839         if ( ftype == LDAP_FILTER_EQUALITY
1840                         || ftype ==  LDAP_FILTER_GE
1841                         || ftype == LDAP_FILTER_LE
1842                         || ftype == LDAP_FILTER_APPROX ) {
1843                 /*
1844                  * According to the SLAPI Reference Manual these are
1845                  * not duplicated.
1846                  */
1847                 *type = f->f_un.f_un_ava->aa_desc->ad_cname.bv_val;
1848                 *bval = &f->f_un.f_un_ava->aa_value;
1849         } else { /* filter type not supported */
1850                 rc = -1;
1851         }
1852
1853         return rc;
1854 #else /* LDAP_SLAPI */
1855         return -1;
1856 #endif /* LDAP_SLAPI */
1857 }
1858
1859 Slapi_Filter *
1860 slapi_filter_list_first( Slapi_Filter *f )
1861 {
1862 #ifdef LDAP_SLAPI
1863         int             ftype;
1864
1865         if ( f == NULL ) {
1866                 return NULL;
1867         }
1868
1869         ftype = f->f_choice;
1870         if ( ftype == LDAP_FILTER_AND
1871                         || ftype == LDAP_FILTER_OR
1872                         || ftype == LDAP_FILTER_NOT ) {
1873                 return (Slapi_Filter *)f->f_list;
1874         } else {
1875                 return NULL;
1876         }
1877 #else /* LDAP_SLAPI */
1878         return NULL;
1879 #endif /* LDAP_SLAPI */
1880 }
1881
1882 Slapi_Filter *
1883 slapi_filter_list_next(
1884         Slapi_Filter    *f,
1885         Slapi_Filter    *fprev )
1886 {
1887 #ifdef LDAP_SLAPI
1888         int             ftype;
1889
1890         if ( f == NULL ) {
1891                 return NULL;
1892         }
1893
1894         ftype = f->f_choice;
1895         if ( ftype == LDAP_FILTER_AND
1896                         || ftype == LDAP_FILTER_OR
1897                         || ftype == LDAP_FILTER_NOT )
1898         {
1899                 return fprev->f_next;
1900         }
1901
1902         return NULL;
1903 #else /* LDAP_SLAPI */
1904         return NULL;
1905 #endif /* LDAP_SLAPI */
1906 }
1907
1908 int
1909 slapi_filter_get_attribute_type( Slapi_Filter *f, char **type )
1910 {
1911 #ifdef LDAP_SLAPI
1912         if ( f == NULL ) {
1913                 return -1;
1914         }
1915
1916         switch ( f->f_choice ) {
1917         case LDAP_FILTER_GE:
1918         case LDAP_FILTER_LE:
1919         case LDAP_FILTER_EQUALITY:
1920         case LDAP_FILTER_APPROX:
1921                 *type = f->f_av_desc->ad_cname.bv_val;
1922                 break;
1923         case LDAP_FILTER_SUBSTRINGS:
1924                 *type = f->f_sub_desc->ad_cname.bv_val;
1925                 break;
1926         case LDAP_FILTER_PRESENT:
1927                 *type = f->f_desc->ad_cname.bv_val;
1928                 break;
1929         case LDAP_FILTER_EXT:
1930                 *type = f->f_mr_desc->ad_cname.bv_val;
1931                 break;
1932         default:
1933                 /* Complex filters need not apply. */
1934                 *type = NULL;
1935                 return -1;
1936         }
1937
1938         return 0;
1939 #else
1940         return -1;
1941 #endif /* LDAP_SLAPI */
1942 }
1943
1944 int
1945 slapi_x_filter_set_attribute_type( Slapi_Filter *f, const char *type )
1946 {
1947 #ifdef LDAP_SLAPI
1948         AttributeDescription **adp, *ad = NULL;
1949         const char *text;
1950         int rc;
1951
1952         if ( f == NULL ) {
1953                 return -1;
1954         }
1955
1956         switch ( f->f_choice ) {
1957         case LDAP_FILTER_GE:
1958         case LDAP_FILTER_LE:
1959         case LDAP_FILTER_EQUALITY:
1960         case LDAP_FILTER_APPROX:
1961                 adp = &f->f_av_desc;
1962                 break;
1963         case LDAP_FILTER_SUBSTRINGS:
1964                 adp = &f->f_sub_desc;
1965                 break;
1966         case LDAP_FILTER_PRESENT:
1967                 adp = &f->f_desc;
1968                 break;
1969         case LDAP_FILTER_EXT:
1970                 adp = &f->f_mr_desc;
1971                 break;
1972         default:
1973                 /* Complex filters need not apply. */
1974                 return -1;
1975         }
1976
1977         rc = slap_str2ad( type, &ad, &text );
1978         if ( rc == LDAP_SUCCESS )
1979                 *adp = ad;
1980
1981         return ( rc == LDAP_SUCCESS ) ? 0 : -1;
1982 #else
1983         return -1;
1984 #endif /* LDAP_SLAPI */
1985 }
1986
1987 int
1988 slapi_filter_get_subfilt( Slapi_Filter *f, char **type, char **initial,
1989         char ***any, char **final )
1990 {
1991 #ifdef LDAP_SLAPI
1992         int i;
1993
1994         if ( f->f_choice != LDAP_FILTER_SUBSTRINGS ) {
1995                 return -1;
1996         }
1997
1998         /*
1999          * The caller shouldn't free but we can't return an
2000          * array of char *s from an array of bervals without
2001          * allocating memory, so we may as well be consistent.
2002          * XXX
2003          */
2004         *type = f->f_sub_desc->ad_cname.bv_val;
2005         *initial = f->f_sub_initial.bv_val ? slapi_ch_strdup(f->f_sub_initial.bv_val) : NULL;
2006         if ( f->f_sub_any != NULL ) {
2007                 for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ )
2008                         ;
2009                 *any = (char **)slapi_ch_malloc( (i + 1) * sizeof(char *) );
2010                 for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ ) {
2011                         (*any)[i] = slapi_ch_strdup(f->f_sub_any[i].bv_val);
2012                 }
2013                 (*any)[i] = NULL;
2014         } else {
2015                 *any = NULL;
2016         }
2017         *final = f->f_sub_final.bv_val ? slapi_ch_strdup(f->f_sub_final.bv_val) : NULL;
2018
2019         return 0;
2020 #else
2021         return -1;
2022 #endif /* LDAP_SLAPI */
2023 }
2024
2025 Slapi_Filter *
2026 slapi_filter_join( int ftype, Slapi_Filter *f1, Slapi_Filter *f2 )
2027 {
2028 #ifdef LDAP_SLAPI
2029         Slapi_Filter *f = NULL;
2030
2031         if ( ftype == LDAP_FILTER_AND ||
2032              ftype == LDAP_FILTER_OR ||
2033              ftype == LDAP_FILTER_NOT )
2034         {
2035                 f = (Slapi_Filter *)slapi_ch_malloc( sizeof(*f) );
2036                 f->f_choice = ftype;
2037                 f->f_list = f1;
2038                 f->f_list->f_next = f2;
2039                 f->f_next = NULL;
2040         }
2041
2042         return f;
2043 #else
2044         return NULL;
2045 #endif /* LDAP_SLAPI */
2046 }
2047
2048 int
2049 slapi_x_filter_append( int ftype,
2050         Slapi_Filter **pContainingFilter, /* NULL on first call */
2051         Slapi_Filter **pNextFilter,
2052         Slapi_Filter *filterToAppend )
2053 {
2054 #ifdef LDAP_SLAPI
2055         if ( ftype == LDAP_FILTER_AND ||
2056              ftype == LDAP_FILTER_OR ||
2057              ftype == LDAP_FILTER_NOT )
2058         {
2059                 if ( *pContainingFilter == NULL ) {
2060                         *pContainingFilter = (Slapi_Filter *)slapi_ch_malloc( sizeof(Slapi_Filter) );
2061                         (*pContainingFilter)->f_choice = ftype;
2062                         (*pContainingFilter)->f_list = filterToAppend;
2063                         (*pContainingFilter)->f_next = NULL;
2064                 } else {
2065                         if ( (*pContainingFilter)->f_choice != ftype ) {
2066                                 /* Sanity check */
2067                                 return -1;
2068                         }
2069                         (*pNextFilter)->f_next = filterToAppend;
2070                 }
2071                 *pNextFilter = filterToAppend;
2072
2073                 return 0;
2074         }
2075 #endif /* LDAP_SLAPI */
2076         return -1;
2077 }
2078
2079 int
2080 slapi_filter_test( Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Filter *f,
2081         int verify_access )
2082 {
2083 #ifdef LDAP_SLAPI
2084         Operation *op;
2085         int rc;
2086
2087         if ( f == NULL ) {
2088                 /* spec says return zero if no filter. */
2089                 return 0;
2090         }
2091
2092         if ( verify_access ) {
2093                 rc = slapi_pblock_get(pb, SLAPI_OPERATION, (void *)&op);
2094                 if ( rc != 0 ) {
2095                         return LDAP_PARAM_ERROR;
2096                 }
2097         } else {
2098                 op = NULL;
2099         }
2100         /*
2101          * According to acl.c it is safe to call test_filter() with
2102          * NULL arguments...
2103          */
2104         rc = test_filter( op, e, f );
2105         switch (rc) {
2106         case LDAP_COMPARE_TRUE:
2107                 rc = 0;
2108                 break;
2109         case LDAP_COMPARE_FALSE:
2110                 break;
2111         case SLAPD_COMPARE_UNDEFINED:
2112                 rc = LDAP_OTHER;
2113                 break;
2114         case LDAP_PROTOCOL_ERROR:
2115                 /* filter type unknown: spec says return -1 */
2116                 rc = -1;
2117                 break;
2118         }
2119
2120         return rc;
2121 #else
2122         return -1;
2123 #endif /* LDAP_SLAPI */
2124 }
2125
2126 int
2127 slapi_filter_test_simple( Slapi_Entry *e, Slapi_Filter *f)
2128 {
2129 #ifdef LDAP_SLAPI
2130         return slapi_filter_test( NULL, e, f, 0 );
2131 #else
2132         return -1;
2133 #endif
2134 }
2135
2136 int
2137 slapi_filter_apply( Slapi_Filter *f, FILTER_APPLY_FN fn, void *arg, int *error_code )
2138 {
2139 #ifdef LDAP_SLAPI
2140         switch ( f->f_choice ) {
2141         case LDAP_FILTER_AND:
2142         case LDAP_FILTER_NOT:
2143         case LDAP_FILTER_OR: {
2144                 int rc;
2145
2146                 /*
2147                  * FIXME: altering f; should we use a temporary?
2148                  */
2149                 for ( f = f->f_list; f != NULL; f = f->f_next ) {
2150                         rc = slapi_filter_apply( f, fn, arg, error_code );
2151                         if ( rc != 0 ) {
2152                                 return rc;
2153                         }
2154                         if ( *error_code == SLAPI_FILTER_SCAN_NOMORE ) {
2155                                 break;
2156                         }
2157                 }
2158                 break;
2159         }
2160         case LDAP_FILTER_EQUALITY:
2161         case LDAP_FILTER_SUBSTRINGS:
2162         case LDAP_FILTER_GE:
2163         case LDAP_FILTER_LE:
2164         case LDAP_FILTER_PRESENT:
2165         case LDAP_FILTER_APPROX:
2166         case LDAP_FILTER_EXT:
2167                 *error_code = fn( f, arg );
2168                 break;
2169         default:
2170                 *error_code = SLAPI_FILTER_UNKNOWN_FILTER_TYPE;
2171         }
2172
2173         if ( *error_code == SLAPI_FILTER_SCAN_NOMORE ||
2174              *error_code == SLAPI_FILTER_SCAN_CONTINUE ) {
2175                 return 0;
2176         }
2177
2178         return -1;
2179 #else
2180         *error_code = SLAPI_FILTER_UNKNOWN_FILTER_TYPE;
2181         return -1;
2182 #endif /* LDAP_SLAPI */
2183 }
2184
2185 int
2186 slapi_send_ldap_extended_response(
2187         Connection      *conn,
2188         Operation       *op,
2189         int             errornum,
2190         char            *respName,
2191         struct berval   *response )
2192 {
2193 #ifdef LDAP_SLAPI
2194         SlapReply       rs;
2195
2196         rs.sr_err = errornum;
2197         rs.sr_matched = NULL;
2198         rs.sr_text = NULL;
2199         rs.sr_ref = NULL;
2200         rs.sr_ctrls = NULL;
2201         rs.sr_rspoid = respName;
2202         rs.sr_rspdata = response;
2203
2204         send_ldap_extended( op, &rs );
2205
2206         return LDAP_SUCCESS;
2207 #else /* LDAP_SLAPI */
2208         return -1;
2209 #endif /* LDAP_SLAPI */
2210 }
2211
2212 int
2213 slapi_pw_find(
2214         struct berval   **vals,
2215         struct berval   *v )
2216 {
2217 #ifdef LDAP_SLAPI
2218         /*
2219          * FIXME: what's the point?
2220          */
2221         return 1;
2222 #else /* LDAP_SLAPI */
2223         return 1;
2224 #endif /* LDAP_SLAPI */
2225 }
2226
2227 #define MAX_HOSTNAME 512
2228
2229 char *
2230 slapi_get_hostname( void )
2231 {
2232 #ifdef LDAP_SLAPI
2233         char            *hn = NULL;
2234         static int      been_here = 0;
2235         static char     *static_hn = NULL;
2236
2237         ldap_pvt_thread_mutex_lock( &slapi_hn_mutex );
2238         if ( !been_here ) {
2239                 static_hn = (char *)slapi_ch_malloc( MAX_HOSTNAME );
2240                 if ( static_hn == NULL) {
2241                         slapi_log_error( SLAPI_LOG_FATAL, "slapi_get_hostname",
2242                                         "Cannot allocate memory for hostname\n" );
2243                         static_hn = NULL;
2244                         ldap_pvt_thread_mutex_unlock( &slapi_hn_mutex );
2245
2246                         return hn;
2247
2248                 } else {
2249                         if ( gethostname( static_hn, MAX_HOSTNAME ) != 0 ) {
2250                                 slapi_log_error( SLAPI_LOG_FATAL,
2251                                                 "SLAPI",
2252                                                 "can't get hostname\n" );
2253                                 slapi_ch_free( (void **)&static_hn );
2254                                 static_hn = NULL;
2255                                 ldap_pvt_thread_mutex_unlock( &slapi_hn_mutex );
2256
2257                                 return hn;
2258
2259                         } else {
2260                                 been_here = 1;
2261                         }
2262                 }
2263         }
2264         ldap_pvt_thread_mutex_unlock( &slapi_hn_mutex );
2265
2266         hn = ch_strdup( static_hn );
2267
2268         return hn;
2269 #else /* LDAP_SLAPI */
2270         return NULL;
2271 #endif /* LDAP_SLAPI */
2272 }
2273
2274 /*
2275  * FIXME: this should go in an appropriate header ...
2276  */
2277 extern int slapi_int_log_error( int level, char *subsystem, char *fmt, va_list arglist );
2278
2279 int
2280 slapi_log_error(
2281         int             severity,
2282         char            *subsystem,
2283         char            *fmt,
2284         ... )
2285 {
2286 #ifdef LDAP_SLAPI
2287         int             rc = LDAP_SUCCESS;
2288         va_list         arglist;
2289
2290         va_start( arglist, fmt );
2291         rc = slapi_int_log_error( severity, subsystem, fmt, arglist );
2292         va_end( arglist );
2293
2294         return rc;
2295 #else /* LDAP_SLAPI */
2296         return -1;
2297 #endif /* LDAP_SLAPI */
2298 }
2299
2300
2301 unsigned long
2302 slapi_timer_current_time( void )
2303 {
2304 #ifdef LDAP_SLAPI
2305         static int      first_time = 1;
2306 #if !defined (_WIN32)
2307         struct timeval  now;
2308         unsigned long   ret;
2309
2310         ldap_pvt_thread_mutex_lock( &slapi_time_mutex );
2311         if (first_time) {
2312                 first_time = 0;
2313                 gettimeofday( &base_time, NULL );
2314         }
2315         gettimeofday( &now, NULL );
2316         ret = ( now.tv_sec  - base_time.tv_sec ) * 1000000 +
2317                         (now.tv_usec - base_time.tv_usec);
2318         ldap_pvt_thread_mutex_unlock( &slapi_time_mutex );
2319
2320         return ret;
2321
2322         /*
2323          * Ain't it better?
2324         return (slap_get_time() - starttime) * 1000000;
2325          */
2326 #else /* _WIN32 */
2327         LARGE_INTEGER now;
2328
2329         if ( first_time ) {
2330                 first_time = 0;
2331                 performance_counter_present = QueryPerformanceCounter( &base_time );
2332                 QueryPerformanceFrequency( &performance_freq );
2333         }
2334
2335         if ( !performance_counter_present )
2336              return 0;
2337
2338         QueryPerformanceCounter( &now );
2339         return (1000000*(now.QuadPart-base_time.QuadPart))/performance_freq.QuadPart;
2340 #endif /* _WIN32 */
2341 #else /* LDAP_SLAPI */
2342         return 0;
2343 #endif /* LDAP_SLAPI */
2344 }
2345
2346 /*
2347  * FIXME ?
2348  */
2349 unsigned long
2350 slapi_timer_get_time( char *label )
2351 {
2352 #ifdef LDAP_SLAPI
2353         unsigned long start = slapi_timer_current_time();
2354         printf("%10ld %10d usec %s\n", start, 0, label);
2355         return start;
2356 #else /* LDAP_SLAPI */
2357         return 0;
2358 #endif /* LDAP_SLAPI */
2359 }
2360
2361 /*
2362  * FIXME ?
2363  */
2364 void
2365 slapi_timer_elapsed_time(
2366         char *label,
2367         unsigned long start )
2368 {
2369 #ifdef LDAP_SLAPI
2370         unsigned long stop = slapi_timer_current_time();
2371         printf ("%10ld %10ld usec %s\n", stop, stop - start, label);
2372 #endif /* LDAP_SLAPI */
2373 }
2374
2375 void
2376 slapi_free_search_results_internal( Slapi_PBlock *pb )
2377 {
2378 #ifdef LDAP_SLAPI
2379         Slapi_Entry     **entries;
2380         int             k = 0, nEnt = 0;
2381
2382         slapi_pblock_get( pb, SLAPI_NENTRIES, &nEnt );
2383         slapi_pblock_get( pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries );
2384         if ( nEnt == 0 ) {
2385                 return;
2386         }
2387
2388         if ( entries == NULL ) {
2389                 return;
2390         }
2391
2392         for ( k = 0; k < nEnt; k++ ) {
2393                 slapi_entry_free( entries[k] );
2394         }
2395
2396         slapi_ch_free( (void **)&entries );
2397 #endif /* LDAP_SLAPI */
2398 }
2399
2400 #ifdef LDAP_SLAPI
2401 /*
2402  * Internal API to prime a Slapi_PBlock with a Backend.
2403  */
2404 static int slapi_int_pblock_set_backend( Slapi_PBlock *pb, Backend *be )
2405 {
2406         int rc;
2407
2408         rc = slapi_pblock_set( pb, SLAPI_BACKEND, (void *)be );
2409         if ( rc != LDAP_SUCCESS )
2410                 return rc;
2411
2412         if ( be != NULL ) {
2413                 rc = slapi_pblock_set( pb, SLAPI_BE_TYPE, (void *)be->bd_info->bi_type );
2414                 if ( rc != LDAP_SUCCESS )
2415                         return rc;
2416         }
2417
2418         return LDAP_SUCCESS;
2419 }
2420
2421 /*
2422  * If oldStyle is TRUE, then a value suitable for setting to
2423  * the deprecated SLAPI_CONN_AUTHTYPE value is returned
2424  * (pointer to static storage).
2425  *
2426  * If oldStyle is FALSE, then a value suitable for setting to
2427  * the new SLAPI_CONN_AUTHMETHOD will be returned, which is
2428  * a pointer to allocated memory and will include the SASL
2429  * mechanism (if any).
2430  */
2431 static char *Authorization2AuthType( AuthorizationInformation *authz, int is_tls, int oldStyle )
2432 {
2433         size_t len;
2434         char *authType;
2435
2436         switch ( authz->sai_method ) {
2437         case LDAP_AUTH_SASL:
2438                 if ( oldStyle ) {
2439                         authType = SLAPD_AUTH_SASL;
2440                 } else {
2441                         len = sizeof(SLAPD_AUTH_SASL) + authz->sai_mech.bv_len;
2442                         authType = slapi_ch_malloc( len );
2443                         snprintf( authType, len, "%s%s", SLAPD_AUTH_SASL, authz->sai_mech.bv_val );
2444                 }
2445                 break;
2446         case LDAP_AUTH_SIMPLE:
2447                 authType = oldStyle ? SLAPD_AUTH_SIMPLE : slapi_ch_strdup( SLAPD_AUTH_SIMPLE );
2448                 break;
2449         case LDAP_AUTH_NONE:
2450                 authType = oldStyle ? SLAPD_AUTH_NONE : slapi_ch_strdup( SLAPD_AUTH_NONE );
2451                 break;
2452         default:
2453                 authType = NULL;
2454                 break;
2455         }
2456         if ( is_tls && authType == NULL ) {
2457                 authType = oldStyle ? SLAPD_AUTH_SSL : slapi_ch_strdup( SLAPD_AUTH_SSL );
2458         }
2459
2460         return authType;
2461 }
2462
2463 /*
2464  * Internal API to prime a Slapi_PBlock with a Connection.
2465  */
2466 static int slapi_int_pblock_set_connection( Slapi_PBlock *pb, Connection *conn )
2467 {
2468         char *connAuthType;
2469         int rc;
2470
2471         rc = slapi_pblock_set( pb, SLAPI_CONNECTION, (void *)conn );
2472         if ( rc != LDAP_SUCCESS ) {
2473                 return rc;
2474         }
2475
2476         if ( strncmp( conn->c_peer_name.bv_val, "IP=", 3 ) == 0 ) {
2477                 rc = slapi_pblock_set( pb, SLAPI_CONN_CLIENTIP, (void *)&conn->c_peer_name.bv_val[3] );
2478                 if ( rc != LDAP_SUCCESS )
2479                         return rc;
2480         } else if ( strncmp( conn->c_peer_name.bv_val, "PATH=", 5 ) == 0 ) {
2481                 rc = slapi_pblock_set( pb, SLAPI_X_CONN_CLIENTPATH, (void *)&conn->c_peer_name.bv_val[5] );
2482                 if ( rc != LDAP_SUCCESS )
2483                         return rc;
2484         }
2485
2486         if ( strncmp( conn->c_sock_name.bv_val, "IP=", 3 ) == 0 ) {
2487                 rc = slapi_pblock_set( pb, SLAPI_CONN_SERVERIP, (void *)&conn->c_sock_name.bv_val[3] );
2488                 if ( rc != LDAP_SUCCESS )
2489                         return rc;
2490         } else if ( strncmp( conn->c_sock_name.bv_val, "PATH=", 5 ) == 0 ) {
2491                 rc = slapi_pblock_set( pb, SLAPI_X_CONN_SERVERPATH, (void *)&conn->c_sock_name.bv_val[5] );
2492                 if ( rc != LDAP_SUCCESS )
2493                         return rc;
2494         }
2495
2496 #ifdef LDAP_CONNECTIONLESS
2497         rc = slapi_pblock_set( pb, SLAPI_X_CONN_IS_UDP, (void *)conn->c_is_udp );
2498         if ( rc != LDAP_SUCCESS )
2499                 return rc;
2500 #endif
2501
2502         rc = slapi_pblock_set( pb, SLAPI_CONN_ID, (void *)conn->c_connid );
2503         if ( rc != LDAP_SUCCESS )
2504                 return rc;
2505
2506         /* Returns pointer to static string */
2507         connAuthType = Authorization2AuthType( &conn->c_authz,
2508 #ifdef HAVE_TLS
2509                 conn->c_is_tls,
2510 #else
2511                 0,
2512 #endif
2513                 1 );
2514         if ( connAuthType != NULL ) {
2515                 rc = slapi_pblock_set(pb, SLAPI_CONN_AUTHTYPE, (void *)connAuthType);
2516                 if ( rc != LDAP_SUCCESS )
2517                         return rc;
2518         }
2519
2520         /* Returns pointer to allocated string */
2521         connAuthType = Authorization2AuthType( &conn->c_authz,
2522 #ifdef HAVE_TLS
2523                 conn->c_is_tls,
2524 #else
2525                 0,
2526 #endif
2527                 0 );
2528         if ( connAuthType != NULL ) {
2529                 rc = slapi_pblock_set(pb, SLAPI_CONN_AUTHMETHOD, (void *)connAuthType);
2530                 /* slapi_pblock_set dups this itself */
2531                 slapi_ch_free( (void **)&connAuthType );
2532                 if ( rc != LDAP_SUCCESS )
2533                         return rc;
2534         }
2535
2536         if ( conn->c_authz.sai_method != LDAP_AUTH_NONE &&
2537              conn->c_authz.sai_dn.bv_val != NULL ) {
2538                 /* slapi_pblock_set dups this itself */
2539                 rc = slapi_pblock_set(pb, SLAPI_CONN_DN, (void *)conn->c_authz.sai_dn.bv_val);
2540                 if ( rc != LDAP_SUCCESS )
2541                         return rc;
2542         }
2543
2544         rc = slapi_pblock_set(pb, SLAPI_X_CONN_SSF, (void *)conn->c_ssf);
2545         if ( rc != LDAP_SUCCESS )
2546                 return rc;
2547
2548         rc = slapi_pblock_set(pb, SLAPI_X_CONN_SASL_CONTEXT,
2549                 ( conn->c_sasl_authctx != NULL ? conn->c_sasl_authctx :
2550                                                  conn->c_sasl_sockctx ) );
2551         if ( rc != LDAP_SUCCESS )
2552                 return rc;
2553
2554         return rc;
2555 }
2556 #endif /* LDAP_SLAPI */
2557
2558 /*
2559  * Internal API to prime a Slapi_PBlock with an Operation.
2560  */
2561 int slapi_int_pblock_set_operation( Slapi_PBlock *pb, Operation *op )
2562 {
2563 #ifdef LDAP_SLAPI
2564         int isRoot = 0;
2565         int isUpdateDn = 0;
2566         int rc;
2567         char *opAuthType;
2568         void *existingOp = NULL;
2569
2570         if ( op->o_bd != NULL ) {
2571                 isRoot = be_isroot( op );
2572                 isUpdateDn = be_isupdate( op );
2573         }
2574
2575         /* This should only be called once per operation */
2576         slapi_pblock_get( pb, SLAPI_OPERATION, &existingOp );
2577         assert( existingOp == NULL );
2578
2579         rc = slapi_int_pblock_set_backend( pb, op->o_bd );
2580         if ( rc != LDAP_SUCCESS )
2581                 return rc;
2582
2583         rc = slapi_int_pblock_set_connection( pb, op->o_conn );
2584         if ( rc != LDAP_SUCCESS )
2585                 return rc;
2586
2587         rc = slapi_pblock_set( pb, SLAPI_OPERATION, (void *)op );
2588         if ( rc != LDAP_SUCCESS )
2589                 return rc;
2590
2591         rc = slapi_pblock_set( pb, SLAPI_OPINITIATED_TIME, (void *)op->o_time );
2592         if ( rc != LDAP_SUCCESS )
2593                 return rc;
2594
2595         rc = slapi_pblock_set( pb, SLAPI_OPERATION_ID, (void *)op->o_opid );
2596         if ( rc != LDAP_SUCCESS )
2597                 return rc;
2598
2599         rc = slapi_pblock_set( pb, SLAPI_OPERATION_TYPE, (void *)op->o_tag );
2600         if ( rc != LDAP_SUCCESS )
2601                 return rc;
2602
2603         rc = slapi_pblock_set( pb, SLAPI_REQUESTOR_ISROOT, (void *)isRoot );
2604         if ( rc != LDAP_SUCCESS )
2605                 return rc;
2606
2607         rc = slapi_pblock_set( pb, SLAPI_REQUESTOR_ISUPDATEDN, (void *)isUpdateDn );
2608         if ( rc != LDAP_SUCCESS )
2609                 return rc;
2610
2611         rc = slapi_pblock_set( pb, SLAPI_REQCONTROLS, (void *)op->o_ctrls );
2612         if ( rc != LDAP_SUCCESS)
2613                 return rc;
2614
2615         rc = slapi_pblock_set( pb, SLAPI_REQUESTOR_DN, (void *)op->o_ndn.bv_val );
2616         if ( rc != LDAP_SUCCESS )
2617                 return rc;
2618
2619         rc = slapi_pblock_set( pb, SLAPI_TARGET_DN, (void *)op->o_req_dn.bv_val );
2620         if ( rc != LDAP_SUCCESS )
2621                 return rc;
2622
2623         rc = slapi_pblock_set( pb, SLAPI_MANAGEDSAIT, (void *)get_manageDSAit( op ) );
2624         if ( rc != LDAP_SUCCESS )
2625                 return rc;
2626
2627         rc = slapi_pblock_get( pb, SLAPI_CONN_AUTHMETHOD, (void *)&opAuthType );
2628         if ( rc == LDAP_SUCCESS && opAuthType != NULL ) {
2629                 /* Not quite sure what the point of this is. */
2630                 rc = slapi_pblock_set( pb, SLAPI_OPERATION_AUTHTYPE, (void *)opAuthType );
2631                 if ( rc != LDAP_SUCCESS )
2632                         return rc;
2633         }
2634
2635         return LDAP_SUCCESS;
2636 #else
2637         return -1;
2638 #endif
2639 }
2640
2641 int slapi_is_connection_ssl( Slapi_PBlock *pb, int *isSSL )
2642 {
2643 #ifdef LDAP_SLAPI
2644         Connection *conn;
2645
2646         slapi_pblock_get( pb, SLAPI_CONNECTION, &conn );
2647 #ifdef HAVE_TLS
2648         *isSSL = conn->c_is_tls;
2649 #else
2650         *isSSL = 0;
2651 #endif
2652
2653         return LDAP_SUCCESS;
2654 #else
2655         return -1;
2656 #endif /* LDAP_SLAPI */
2657 }
2658
2659 /*
2660  * DS 5.x compatability API follow
2661  */
2662
2663 int slapi_attr_get_flags( const Slapi_Attr *attr, unsigned long *flags )
2664 {
2665 #ifdef LDAP_SLAPI
2666         AttributeType *at;
2667
2668         if ( attr == NULL )
2669                 return LDAP_PARAM_ERROR;
2670
2671         at = attr->a_desc->ad_type;
2672
2673         *flags = SLAPI_ATTR_FLAG_STD_ATTR;
2674
2675         if ( is_at_single_value( at ) )
2676                 *flags |= SLAPI_ATTR_FLAG_SINGLE;
2677         if ( is_at_operational( at ) )
2678                 *flags |= SLAPI_ATTR_FLAG_OPATTR;
2679         if ( is_at_obsolete( at ) )
2680                 *flags |= SLAPI_ATTR_FLAG_OBSOLETE;
2681         if ( is_at_collective( at ) )
2682                 *flags |= SLAPI_ATTR_FLAG_COLLECTIVE;
2683         if ( is_at_no_user_mod( at ) )
2684                 *flags |= SLAPI_ATTR_FLAG_NOUSERMOD;
2685
2686         return LDAP_SUCCESS;
2687 #else
2688         return -1;
2689 #endif /* LDAP_SLAPI */
2690 }
2691
2692 int slapi_attr_flag_is_set( const Slapi_Attr *attr, unsigned long flag )
2693 {
2694 #ifdef LDAP_SLAPI
2695         unsigned long flags;
2696
2697         if ( slapi_attr_get_flags( attr, &flags ) != 0 )
2698                 return 0;
2699         return (flags & flag) ? 1 : 0;
2700 #else
2701         return 0;
2702 #endif /* LDAP_SLAPI */
2703 }
2704
2705 Slapi_Attr *slapi_attr_new( void )
2706 {
2707 #ifdef LDAP_SLAPI
2708         Attribute *ad;
2709
2710         ad = (Attribute  *)slapi_ch_calloc( 1, sizeof(*ad) );
2711
2712         return ad;
2713 #else
2714         return NULL;
2715 #endif
2716 }
2717
2718 Slapi_Attr *slapi_attr_init( Slapi_Attr *a, const char *type )
2719 {
2720 #ifdef LDAP_SLAPI
2721         const char *text;
2722         AttributeDescription *ad = NULL;
2723
2724         if( slap_str2ad( type, &ad, &text ) != LDAP_SUCCESS ) {
2725                 return NULL;
2726         }
2727
2728         a->a_desc = ad;
2729         a->a_vals = NULL;
2730         a->a_nvals = NULL;
2731         a->a_next = NULL;
2732         a->a_flags = 0;
2733
2734         return a;
2735 #else
2736         return NULL;
2737 #endif
2738 }
2739
2740 void slapi_attr_free( Slapi_Attr **a )
2741 {
2742 #ifdef LDAP_SLAPI
2743         attr_free( *a );
2744         *a = NULL;
2745 #endif
2746 }
2747
2748 Slapi_Attr *slapi_attr_dup( const Slapi_Attr *attr )
2749 {
2750 #ifdef LDAP_SLAPI
2751         return attr_dup( (Slapi_Attr *)attr );
2752 #else
2753         return NULL;
2754 #endif
2755 }
2756
2757 int slapi_attr_add_value( Slapi_Attr *a, const Slapi_Value *v )
2758 {
2759 #ifdef LDAP_SLAPI
2760         struct berval nval;
2761         struct berval *nvalp;
2762         int rc;
2763         AttributeDescription *desc = a->a_desc;
2764
2765         if ( desc->ad_type->sat_equality &&
2766              desc->ad_type->sat_equality->smr_normalize ) {
2767                 rc = (*desc->ad_type->sat_equality->smr_normalize)(
2768                         SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
2769                         desc->ad_type->sat_syntax,
2770                         desc->ad_type->sat_equality,
2771                         (Slapi_Value *)v, &nval, NULL );
2772                 if ( rc != LDAP_SUCCESS ) {
2773                         return rc;
2774                 }
2775                 nvalp = &nval;
2776         } else {
2777                 nvalp = NULL;
2778         }
2779
2780         rc = value_add_one( &a->a_vals, (Slapi_Value *)v );
2781         if ( rc == 0 && nvalp != NULL ) {
2782                 rc = value_add_one( &a->a_nvals, nvalp );
2783         } else {
2784                 a->a_nvals = a->a_vals;
2785         }
2786
2787         if ( nvalp != NULL ) {
2788                 slapi_ch_free_string( &nval.bv_val );
2789         }
2790
2791         return rc;
2792 #else
2793         return -1;
2794 #endif
2795 }
2796
2797 int slapi_attr_type2plugin( const char *type, void **pi )
2798 {
2799         *pi = NULL;
2800
2801         return LDAP_OTHER;
2802 }
2803
2804 int slapi_attr_get_type( const Slapi_Attr *attr, char **type )
2805 {
2806 #ifdef LDAP_SLAPI
2807         if ( attr == NULL ) {
2808                 return LDAP_PARAM_ERROR;
2809         }
2810
2811         *type = attr->a_desc->ad_cname.bv_val;
2812
2813         return LDAP_SUCCESS;
2814 #else
2815         return -1;
2816 #endif
2817 }
2818
2819 int slapi_attr_get_oid_copy( const Slapi_Attr *attr, char **oidp )
2820 {
2821 #ifdef LDAP_SLAPI
2822         if ( attr == NULL ) {
2823                 return LDAP_PARAM_ERROR;
2824         }
2825         *oidp = attr->a_desc->ad_type->sat_oid;
2826
2827         return LDAP_SUCCESS;
2828 #else
2829         return -1;
2830 #endif
2831 }
2832
2833 int slapi_attr_value_cmp( const Slapi_Attr *a, const struct berval *v1, const struct berval *v2 )
2834 {
2835 #ifdef LDAP_SLAPI
2836         MatchingRule *mr;
2837         int ret;
2838         int rc;
2839         const char *text;
2840
2841         mr = a->a_desc->ad_type->sat_equality;
2842         rc = value_match( &ret, a->a_desc, mr,
2843                         SLAP_MR_VALUE_OF_ASSERTION_SYNTAX,
2844                 (struct berval *)v1, (void *)v2, &text );
2845         if ( rc != LDAP_SUCCESS )
2846                 return -1;
2847
2848         return ( ret == 0 ) ? 0 : -1;
2849 #else
2850         return -1;
2851 #endif
2852 }
2853
2854 int slapi_attr_value_find( const Slapi_Attr *a, struct berval *v )
2855 {
2856 #ifdef LDAP_SLAPI
2857         MatchingRule *mr;
2858         struct berval *bv;
2859         int j;
2860         const char *text;
2861         int rc;
2862         int ret;
2863
2864         if ( a ->a_vals == NULL ) {
2865                 return -1;
2866         }
2867         mr = a->a_desc->ad_type->sat_equality;
2868         for ( bv = a->a_vals, j = 0; bv->bv_val != NULL; bv++, j++ ) {
2869                 rc = value_match( &ret, a->a_desc, mr,
2870                         SLAP_MR_VALUE_OF_ASSERTION_SYNTAX, bv, v, &text );
2871                 if ( rc != LDAP_SUCCESS ) {
2872                         return -1;
2873                 }
2874                 if ( ret == 0 ) {
2875                         return 0;
2876                 }
2877         }
2878 #endif /* LDAP_SLAPI */
2879         return -1;
2880 }
2881
2882 int slapi_attr_type_cmp( const char *t1, const char *t2, int opt )
2883 {
2884 #ifdef LDAP_SLAPI
2885         AttributeDescription *a1 = NULL;
2886         AttributeDescription *a2 = NULL;
2887         const char *text;
2888         int ret;
2889
2890         if ( slap_str2ad( t1, &a1, &text ) != LDAP_SUCCESS ) {
2891                 return -1;
2892         }
2893
2894         if ( slap_str2ad( t2, &a2, &text ) != LDAP_SUCCESS ) {
2895                 return 1;
2896         }
2897
2898 #define ad_base_cmp(l,r) (((l)->ad_type->sat_cname.bv_len < (r)->ad_type->sat_cname.bv_len) \
2899         ? -1 : (((l)->ad_type->sat_cname.bv_len > (r)->ad_type->sat_cname.bv_len) \
2900                 ? 1 : strcasecmp((l)->ad_type->sat_cname.bv_val, (r)->ad_type->sat_cname.bv_val )))
2901
2902         switch ( opt ) {
2903         case SLAPI_TYPE_CMP_EXACT:
2904                 ret = ad_cmp( a1, a2 );
2905                 break;
2906         case SLAPI_TYPE_CMP_BASE:
2907                 ret = ad_base_cmp( a1, a2 );
2908                 break;
2909         case SLAPI_TYPE_CMP_SUBTYPE:
2910                 ret = is_ad_subtype( a2, a2 );
2911                 break;
2912         default:
2913                 ret = -1;
2914                 break;
2915         }
2916
2917         return ret;
2918 #else
2919         return -1;
2920 #endif
2921 }
2922
2923 int slapi_attr_types_equivalent( const char *t1, const char *t2 )
2924 {
2925 #ifdef LDAP_SLAPI
2926         return slapi_attr_type_cmp( t1, t2, SLAPI_TYPE_CMP_EXACT );
2927 #else
2928         return -1;
2929 #endif
2930 }
2931
2932 int slapi_attr_first_value( Slapi_Attr *a, Slapi_Value **v )
2933 {
2934 #ifdef LDAP_SLAPI
2935         return slapi_valueset_first_value( &a->a_vals, v );
2936 #else
2937         return -1;
2938 #endif
2939 }
2940
2941 int slapi_attr_next_value( Slapi_Attr *a, int hint, Slapi_Value **v )
2942 {
2943 #ifdef LDAP_SLAPI
2944         return slapi_valueset_next_value( &a->a_vals, hint, v );
2945 #else
2946         return -1;
2947 #endif
2948 }
2949
2950 int slapi_attr_get_numvalues( const Slapi_Attr *a, int *numValues )
2951 {
2952 #ifdef LDAP_SLAPI
2953         *numValues = slapi_valueset_count( &a->a_vals );
2954
2955         return 0;
2956 #else
2957         return -1;
2958 #endif
2959 }
2960
2961 int slapi_attr_get_valueset( const Slapi_Attr *a, Slapi_ValueSet **vs )
2962 {
2963 #ifdef LDAP_SLAPI
2964         *vs = &((Slapi_Attr *)a)->a_vals;
2965
2966         return 0;
2967 #else
2968         return -1;
2969 #endif
2970 }
2971
2972 int slapi_attr_get_bervals_copy( Slapi_Attr *a, struct berval ***vals )
2973 {
2974 #ifdef LDAP_SLAPI
2975         return slapi_attr_get_values( a, vals );
2976 #else
2977         return -1;
2978 #endif
2979 }
2980
2981 char *slapi_attr_syntax_normalize( const char *s )
2982 {
2983 #ifdef LDAP_SLAPI
2984         AttributeDescription *ad = NULL;
2985         const char *text;
2986
2987         if ( slap_str2ad( s, &ad, &text ) != LDAP_SUCCESS ) {
2988                 return NULL;
2989         }
2990
2991         return ad->ad_cname.bv_val;
2992 #else
2993         return -1;
2994 #endif
2995 }
2996
2997 Slapi_Value *slapi_value_new( void )
2998 {
2999 #ifdef LDAP_SLAPI
3000         struct berval *bv;
3001
3002         bv = (struct berval *)slapi_ch_malloc( sizeof(*bv) );
3003
3004         return bv;
3005 #else
3006         return NULL;
3007 #endif
3008 }
3009
3010 Slapi_Value *slapi_value_new_berval(const struct berval *bval)
3011 {
3012 #ifdef LDAP_SLAPI
3013         return ber_dupbv( NULL, (struct berval *)bval );
3014 #else
3015         return NULL;
3016 #endif
3017 }
3018
3019 Slapi_Value *slapi_value_new_value(const Slapi_Value *v)
3020 {
3021 #ifdef LDAP_SLAPI
3022         return slapi_value_new_berval( v );
3023 #else
3024         return NULL;
3025 #endif
3026 }
3027
3028 Slapi_Value *slapi_value_new_string(const char *s)
3029 {
3030 #ifdef LDAP_SLAPI
3031         struct berval bv;
3032
3033         bv.bv_val = (char *)s;
3034         bv.bv_len = strlen( s );
3035
3036         return slapi_value_new_berval( &bv );
3037 #else
3038         return NULL;
3039 #endif
3040 }
3041
3042 Slapi_Value *slapi_value_init(Slapi_Value *val)
3043 {
3044 #ifdef LDAP_SLAPI
3045         val->bv_val = NULL;
3046         val->bv_len = 0;
3047
3048         return val;
3049 #else
3050         return NULL;
3051 #endif
3052 }
3053
3054 Slapi_Value *slapi_value_init_berval(Slapi_Value *v, struct berval *bval)
3055 {
3056 #ifdef LDAP_SLAPI
3057         return ber_dupbv( v, bval );
3058 #else
3059         return NULL;
3060 #endif
3061 }
3062
3063 Slapi_Value *slapi_value_init_string(Slapi_Value *v, const char *s)
3064 {
3065 #ifdef LDAP_SLAPI
3066         v->bv_val = slapi_ch_strdup( (char *)s );
3067         v->bv_len = strlen( s );
3068
3069         return v;
3070 #else
3071         return NULL;
3072 #endif
3073 }
3074
3075 Slapi_Value *slapi_value_dup(const Slapi_Value *v)
3076 {
3077 #ifdef LDAP_SLAPI
3078         return slapi_value_new_value( v );
3079 #else
3080         return NULL;
3081 #endif
3082 }
3083
3084 void slapi_value_free(Slapi_Value **value)
3085 {
3086 #ifdef LDAP_SLAPI
3087         if ( value == NULL ) {
3088                 return;
3089         }
3090
3091         if ( (*value) != NULL ) {
3092                 slapi_ch_free( (void **)&(*value)->bv_val );
3093                 slapi_ch_free( (void **)value );
3094         }
3095 #endif
3096 }
3097
3098 const struct berval *slapi_value_get_berval( const Slapi_Value *value )
3099 {
3100 #ifdef LDAP_SLAPI
3101         return value;
3102 #else
3103         return NULL;
3104 #endif
3105 }
3106
3107 Slapi_Value *slapi_value_set_berval( Slapi_Value *value, const struct berval *bval )
3108 {
3109 #ifdef LDAP_SLAPI
3110         if ( value == NULL ) {
3111                 return NULL;
3112         }
3113         if ( value->bv_val != NULL ) {
3114                 slapi_ch_free( (void **)&value->bv_val );
3115         }
3116         slapi_value_init_berval( value, (struct berval *)bval );
3117
3118         return value;
3119 #else
3120         return NULL;
3121 #endif
3122 }
3123
3124 Slapi_Value *slapi_value_set_value( Slapi_Value *value, const Slapi_Value *vfrom)
3125 {
3126 #ifdef LDAP_SLAPI
3127         if ( value == NULL ) {
3128                 return NULL;
3129         }
3130         return slapi_value_set_berval( value, vfrom );
3131 #else
3132         return NULL;
3133 #endif
3134 }
3135
3136 Slapi_Value *slapi_value_set( Slapi_Value *value, void *val, unsigned long len)
3137 {
3138 #ifdef LDAP_SLAPI
3139         if ( value == NULL ) {
3140                 return NULL;
3141         }
3142         if ( value->bv_val != NULL ) {
3143                 slapi_ch_free( (void **)&value->bv_val );
3144         }
3145         value->bv_val = slapi_ch_malloc( len );
3146         value->bv_len = len;
3147         AC_MEMCPY( value->bv_val, val, len );
3148
3149         return value;
3150 #else
3151         return NULL;
3152 #endif
3153 }
3154
3155 int slapi_value_set_string(Slapi_Value *value, const char *strVal)
3156 {
3157 #ifdef LDAP_SLAPI
3158         if ( value == NULL ) {
3159                 return -1;
3160         }
3161         slapi_value_set( value, (void *)strVal, strlen( strVal ) );
3162         return 0;
3163 #else
3164         return NULL;
3165 #endif
3166 }
3167
3168 int slapi_value_set_int(Slapi_Value *value, int intVal)
3169 {
3170 #ifdef LDAP_SLAPI
3171         char buf[64];
3172
3173         snprintf( buf, sizeof( buf ), "%d", intVal );
3174
3175         return slapi_value_set_string( value, buf );
3176 #else
3177         return -1;
3178 #endif
3179 }
3180
3181 const char *slapi_value_get_string(const Slapi_Value *value)
3182 {
3183 #ifdef LDAP_SLAPI
3184         if ( value == NULL ) return NULL;
3185         if ( value->bv_val == NULL ) return NULL;
3186         if ( !checkBVString( value ) ) return NULL;
3187
3188         return value->bv_val;
3189 #else
3190         return NULL;
3191 #endif
3192 }
3193
3194 int slapi_value_get_int(const Slapi_Value *value)
3195 {
3196 #ifdef LDAP_SLAPI
3197         if ( value == NULL ) return 0;
3198         if ( value->bv_val == NULL ) return 0;
3199         if ( !checkBVString( value ) ) return 0;
3200
3201         return (int)strtol( value->bv_val, NULL, 10 );
3202 #else
3203         return NULL;
3204 #endif
3205 }
3206
3207 unsigned int slapi_value_get_uint(const Slapi_Value *value)
3208 {
3209 #ifdef LDAP_SLAPI
3210         if ( value == NULL ) return 0;
3211         if ( value->bv_val == NULL ) return 0;
3212         if ( !checkBVString( value ) ) return 0;
3213
3214         return (unsigned int)strtoul( value->bv_val, NULL, 10 );
3215 #else
3216         return NULL;
3217 #endif
3218 }
3219
3220 long slapi_value_get_long(const Slapi_Value *value)
3221 {
3222 #ifdef LDAP_SLAPI
3223         if ( value == NULL ) return 0;
3224         if ( value->bv_val == NULL ) return 0;
3225         if ( !checkBVString( value ) ) return 0;
3226
3227         return strtol( value->bv_val, NULL, 10 );
3228 #else
3229         return NULL;
3230 #endif
3231 }
3232
3233 unsigned long slapi_value_get_ulong(const Slapi_Value *value)
3234 {
3235 #ifdef LDAP_SLAPI
3236         if ( value == NULL ) return 0;
3237         if ( value->bv_val == NULL ) return 0;
3238         if ( !checkBVString( value ) ) return 0;
3239
3240         return strtoul( value->bv_val, NULL, 10 );
3241 #else
3242         return NULL;
3243 #endif
3244 }
3245
3246 size_t slapi_value_get_length(const Slapi_Value *value)
3247 {
3248 #ifdef LDAP_SLAPI
3249         if ( value == NULL )
3250                 return 0;
3251
3252         return (size_t) value->bv_len;
3253 #else
3254         return 0;
3255 #endif
3256 }
3257
3258 int slapi_value_compare(const Slapi_Attr *a, const Slapi_Value *v1, const Slapi_Value *v2)
3259 {
3260 #ifdef LDAP_SLAPI
3261         return slapi_attr_value_cmp( a, v1, v2 );
3262 #else
3263         return -1;
3264 #endif
3265 }
3266
3267 /* A ValueSet is a container for a BerVarray. */
3268 Slapi_ValueSet *slapi_valueset_new( void )
3269 {
3270 #ifdef LDAP_SLAPI
3271         Slapi_ValueSet *vs;
3272
3273         vs = (Slapi_ValueSet *)slapi_ch_malloc( sizeof( *vs ) );
3274         *vs = NULL;
3275
3276         return vs;
3277 #else
3278         return NULL;
3279 #endif
3280 }
3281
3282 void slapi_valueset_free(Slapi_ValueSet *vs)
3283 {
3284 #ifdef LDAP_SLAPI
3285         if ( vs != NULL ) {
3286                 BerVarray vp = *vs;
3287
3288                 ber_bvarray_free( vp );
3289                 slapi_ch_free( (void **)&vp );
3290
3291                 *vs = NULL;
3292         }
3293 #endif
3294 }
3295
3296 void slapi_valueset_init(Slapi_ValueSet *vs)
3297 {
3298 #ifdef LDAP_SLAPI
3299         if ( vs != NULL && *vs == NULL ) {
3300                 *vs = (Slapi_ValueSet)slapi_ch_calloc( 1, sizeof(struct berval) );
3301                 (*vs)->bv_val = NULL;
3302                 (*vs)->bv_len = 0;
3303         }
3304 #endif
3305 }
3306
3307 void slapi_valueset_done(Slapi_ValueSet *vs)
3308 {
3309 #ifdef LDAP_SLAPI
3310         BerVarray vp;
3311
3312         if ( vs == NULL )
3313                 return;
3314
3315         for ( vp = *vs; vp->bv_val != NULL; vp++ ) {
3316                 vp->bv_len = 0;
3317                 slapi_ch_free( (void **)&vp->bv_val );
3318         }
3319         /* but don't free *vs or vs */
3320 #endif
3321 }
3322
3323 void slapi_valueset_add_value(Slapi_ValueSet *vs, const Slapi_Value *addval)
3324 {
3325 #ifdef LDAP_SLAPI
3326         struct berval bv;
3327
3328         ber_dupbv( &bv, (Slapi_Value *)addval );
3329         ber_bvarray_add( vs, &bv );
3330 #endif
3331 }
3332
3333 int slapi_valueset_first_value( Slapi_ValueSet *vs, Slapi_Value **v )
3334 {
3335 #ifdef LDAP_SLAPI
3336         return slapi_valueset_next_value( vs, 0, v );
3337 #else
3338         return -1;
3339 #endif
3340 }
3341
3342 int slapi_valueset_next_value( Slapi_ValueSet *vs, int index, Slapi_Value **v)
3343 {
3344 #ifdef LDAP_SLAPI
3345         int i;
3346         BerVarray vp;
3347
3348         if ( vs == NULL )
3349                 return -1;
3350
3351         vp = *vs;
3352
3353         for ( i = 0; vp[i].bv_val != NULL; i++ ) {
3354                 if ( i == index ) {
3355                         *v = &vp[i];
3356                         return index + 1;
3357                 }
3358         }
3359 #endif
3360
3361         return -1;
3362 }
3363
3364 int slapi_valueset_count( const Slapi_ValueSet *vs )
3365 {
3366 #ifdef LDAP_SLAPI
3367         int i;
3368         BerVarray vp;
3369
3370         if ( vs == NULL )
3371                 return 0;
3372
3373         vp = *vs;
3374
3375         for ( i = 0; vp[i].bv_val != NULL; i++ )
3376                 ;
3377
3378         return i;
3379 #else
3380         return 0;
3381 #endif
3382
3383 }
3384
3385 void slapi_valueset_set_valueset(Slapi_ValueSet *vs1, const Slapi_ValueSet *vs2)
3386 {
3387 #ifdef LDAP_SLAPI
3388         BerVarray vp;
3389
3390         for ( vp = *vs2; vp->bv_val != NULL; vp++ ) {
3391                 slapi_valueset_add_value( vs1, vp );
3392         }
3393 #endif
3394 }
3395
3396 int slapi_access_allowed( Slapi_PBlock *pb, Slapi_Entry *e, char *attr,
3397         struct berval *val, int access )
3398 {
3399 #ifdef LDAP_SLAPI
3400         Backend *be;
3401         Connection *conn;
3402         Operation *op;
3403         int rc;
3404         slap_access_t slap_access;
3405         AttributeDescription *ad = NULL;
3406         const char *text;
3407
3408         rc = slap_str2ad( attr, &ad, &text );
3409         if ( rc != LDAP_SUCCESS ) {
3410                 return rc;
3411         }
3412
3413         /*
3414          * Whilst the SLAPI access types are arranged as a bitmask, the
3415          * documentation indicates that they are to be used separately.
3416          */
3417         switch ( access & SLAPI_ACL_ALL ) {
3418         case SLAPI_ACL_COMPARE:
3419                 slap_access = ACL_COMPARE;
3420                 break;
3421         case SLAPI_ACL_SEARCH:
3422                 slap_access = ACL_SEARCH;
3423                 break;
3424         case SLAPI_ACL_READ:
3425                 slap_access = ACL_READ;
3426                 break;
3427         case SLAPI_ACL_WRITE:
3428                 slap_access = ACL_WRITE;
3429                 break;
3430         case SLAPI_ACL_DELETE:
3431                 slap_access = ACL_WDEL;
3432                 break;
3433         case SLAPI_ACL_ADD:
3434                 slap_access = ACL_WADD;
3435                 break;
3436         case SLAPI_ACL_SELF:  /* not documented */
3437         case SLAPI_ACL_PROXY: /* not documented */
3438         default:
3439                 return LDAP_INSUFFICIENT_ACCESS;
3440                 break;
3441         }
3442
3443         if ( slapi_pblock_get( pb, SLAPI_BACKEND, (void *)&be ) != 0 ) {
3444                 return LDAP_PARAM_ERROR;
3445         }
3446
3447         if ( slapi_pblock_get( pb, SLAPI_CONNECTION, (void *)&conn ) != 0 ) {
3448                 return LDAP_PARAM_ERROR;
3449         }
3450
3451         if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&op ) != 0 ) {
3452                 return LDAP_PARAM_ERROR;
3453         }
3454
3455         if ( access_allowed( op, e, ad, val, slap_access, NULL ) ) {
3456                 return LDAP_SUCCESS;
3457         }
3458
3459         return LDAP_INSUFFICIENT_ACCESS;
3460 #else
3461         return LDAP_UNWILLING_TO_PERFORM;
3462 #endif
3463 }
3464
3465 int slapi_acl_check_mods(Slapi_PBlock *pb, Slapi_Entry *e, LDAPMod **mods, char **errbuf)
3466 {
3467 #ifdef LDAP_SLAPI
3468         Operation *op;
3469         int rc = LDAP_SUCCESS;
3470         Modifications *ml, *mp;
3471
3472         if ( slapi_pblock_get( pb, SLAPI_OPERATION, (void *)&op ) != 0 ) {
3473                 return LDAP_PARAM_ERROR;
3474         }
3475
3476         ml = slapi_int_ldapmods2modifications( mods );
3477         if ( ml == NULL ) {
3478                 return LDAP_OTHER;
3479         }
3480
3481         if ( rc == LDAP_SUCCESS ) {
3482                 rc = acl_check_modlist( op, e, ml ) ? LDAP_SUCCESS : LDAP_INSUFFICIENT_ACCESS;
3483         }
3484
3485         /* Careful when freeing the modlist because it has pointers into the mods array. */
3486         for ( ; ml != NULL; ml = mp ) {
3487                 mp = ml->sml_next;
3488
3489                 /* just free the containing array */
3490                 slapi_ch_free( (void **)&ml->sml_values );
3491                 slapi_ch_free( (void **)&ml );
3492         }
3493
3494         return rc;
3495 #else
3496         return LDAP_UNWILLING_TO_PERFORM;
3497 #endif
3498 }
3499
3500 /*
3501  * Synthesise an LDAPMod array from a Modifications list to pass
3502  * to SLAPI. This synthesis is destructive and as such the
3503  * Modifications list may not be used after calling this
3504  * function.
3505  *
3506  * This function must also be called before slap_mods_check().
3507  */
3508 LDAPMod **slapi_int_modifications2ldapmods(Modifications **pmodlist)
3509 {
3510 #ifdef LDAP_SLAPI
3511         Modifications *ml, *modlist;
3512         LDAPMod **mods, *modp;
3513         int i, j;
3514
3515         modlist = *pmodlist;
3516
3517         for( i = 0, ml = modlist; ml != NULL; i++, ml = ml->sml_next )
3518                 ;
3519
3520         mods = (LDAPMod **)ch_malloc( (i + 1) * sizeof(LDAPMod *) );
3521
3522         for( i = 0, ml = modlist; ml != NULL; ml = ml->sml_next ) {
3523                 mods[i] = (LDAPMod *)ch_malloc( sizeof(LDAPMod) );
3524                 modp = mods[i];
3525                 modp->mod_op = ml->sml_op | LDAP_MOD_BVALUES;
3526
3527                 /* Take ownership of original type. */
3528                 modp->mod_type = ml->sml_type.bv_val;
3529                 ml->sml_type.bv_val = NULL;
3530
3531                 if ( ml->sml_values != NULL ) {
3532                         for( j = 0; ml->sml_values[j].bv_val != NULL; j++ )
3533                                 ;
3534                         modp->mod_bvalues = (struct berval **)ch_malloc( (j + 1) *
3535                                 sizeof(struct berval *) );
3536                         for( j = 0; ml->sml_values[j].bv_val != NULL; j++ ) {
3537                                 /* Take ownership of original values. */
3538                                 modp->mod_bvalues[j] = (struct berval *)ch_malloc( sizeof(struct berval) );
3539                                 modp->mod_bvalues[j]->bv_len = ml->sml_values[j].bv_len;
3540                                 modp->mod_bvalues[j]->bv_val = ml->sml_values[j].bv_val;
3541                                 ml->sml_values[j].bv_len = 0;
3542                                 ml->sml_values[j].bv_val = NULL;
3543                         }
3544                         modp->mod_bvalues[j] = NULL;
3545                 } else {
3546                         modp->mod_bvalues = NULL;
3547                 }
3548                 i++;
3549         }
3550
3551         mods[i] = NULL;
3552
3553         slap_mods_free( modlist );
3554         *pmodlist = NULL;
3555
3556         return mods;
3557 #else
3558         return NULL;
3559 #endif
3560 }
3561
3562 /*
3563  * Convert a potentially modified array of LDAPMods back to a
3564  * Modification list.
3565  *
3566  * The returned Modification list contains pointers into the
3567  * LDAPMods array; the latter MUST be freed with
3568  * slapi_int_free_ldapmods() (see below).
3569  */
3570 Modifications *slapi_int_ldapmods2modifications (LDAPMod **mods)
3571 {
3572 #ifdef LDAP_SLAPI
3573         Modifications *modlist = NULL, **modtail;
3574         LDAPMod **modp;
3575
3576         if ( mods == NULL ) {
3577                 return NULL;
3578         }
3579
3580         modtail = &modlist;
3581
3582         for( modp = mods; *modp != NULL; modp++ ) {
3583                 Modifications *mod;
3584                 int i;
3585                 char **p;
3586                 struct berval **bvp;
3587                 const char *text;
3588                 AttributeDescription *ad = NULL;
3589
3590                 if ( slap_str2ad( (*modp)->mod_type, &ad, &text ) != LDAP_SUCCESS )
3591                         continue;
3592
3593                 mod = (Modifications *) ch_malloc( sizeof(Modifications) );
3594                 mod->sml_op = (*modp)->mod_op & (~LDAP_MOD_BVALUES);
3595                 mod->sml_flags = 0;
3596                 mod->sml_type.bv_val = (*modp)->mod_type;
3597                 mod->sml_type.bv_len = strlen( mod->sml_type.bv_val );
3598                 mod->sml_desc = ad;
3599                 mod->sml_next = NULL;
3600
3601                 if ( (*modp)->mod_op & LDAP_MOD_BVALUES ) {
3602                         for( i = 0, bvp = (*modp)->mod_bvalues; bvp != NULL && *bvp != NULL; bvp++, i++ )
3603                                 ;
3604                 } else {
3605                         for( i = 0, p = (*modp)->mod_values; p != NULL && *p != NULL; p++, i++ )
3606                                 ;
3607                 }
3608
3609                 if ( i == 0 ) {
3610                         mod->sml_values = NULL;
3611                 } else {
3612                         mod->sml_values = (BerVarray) ch_malloc( (i + 1) * sizeof(struct berval) );
3613
3614                         /* NB: This implicitly trusts a plugin to return valid modifications. */
3615                         if ( (*modp)->mod_op & LDAP_MOD_BVALUES ) {
3616                                 for( i = 0, bvp = (*modp)->mod_bvalues; bvp != NULL && *bvp != NULL; bvp++, i++ ) {
3617                                         mod->sml_values[i].bv_val = (*bvp)->bv_val;
3618                                         mod->sml_values[i].bv_len = (*bvp)->bv_len;
3619                                 }
3620                         } else {
3621                                 for( i = 0, p = (*modp)->mod_values; p != NULL && *p != NULL; p++, i++ ) {
3622                                         mod->sml_values[i].bv_val = *p;
3623                                         mod->sml_values[i].bv_len = strlen( *p );
3624                                 }
3625                         }
3626                         mod->sml_values[i].bv_val = NULL;
3627                         mod->sml_values[i].bv_len = 0;
3628                 }
3629                 mod->sml_nvalues = NULL;
3630
3631                 *modtail = mod;
3632                 modtail = &mod->sml_next;
3633         }
3634
3635         return modlist;
3636 #else
3637         return NULL;
3638 #endif
3639 }
3640
3641 /*
3642  * This function only frees the parts of the mods array that
3643  * are not shared with the Modification list that was created
3644  * by slapi_int_ldapmods2modifications().
3645  *
3646  */
3647 void slapi_int_free_ldapmods (LDAPMod **mods)
3648 {
3649 #ifdef LDAP_SLAPI
3650         int i, j;
3651
3652         if (mods == NULL)
3653                 return;
3654
3655         for ( i = 0; mods[i] != NULL; i++ ) {
3656                 /*
3657                  * Don't free values themselves; they're owned by the
3658                  * Modification list. Do free the containing array.
3659                  */
3660                 if ( mods[i]->mod_op & LDAP_MOD_BVALUES ) {
3661                         for ( j = 0; mods[i]->mod_values != NULL && mods[i]->mod_values[j] != NULL; j++ ) {
3662                                 ch_free( mods[i]->mod_values[j] );
3663                         }
3664                         ch_free( mods[i]->mod_values );
3665                 } else {
3666                         ch_free( mods[i]->mod_values );
3667                 }
3668                 /* Don't free type, for same reasons. */
3669                 ch_free( mods[i] );
3670         }
3671         ch_free( mods );
3672 #endif /* LDAP_SLAPI */
3673 }
3674
3675 /*
3676  * Sun ONE DS 5.x computed attribute support. Computed attributes
3677  * allow for dynamically generated operational attributes, a very
3678  * useful thing indeed.
3679  */
3680
3681 /*
3682  * For some reason Sun don't use the normal plugin mechanism
3683  * registration path to register an "evaluator" function (an
3684  * "evaluator" is responsible for adding computed attributes;
3685  * the nomenclature is somewhat confusing).
3686  *
3687  * As such slapi_compute_add_evaluator() registers the
3688  * function directly.
3689  */
3690 int slapi_compute_add_evaluator(slapi_compute_callback_t function)
3691 {
3692 #ifdef LDAP_SLAPI
3693         Slapi_PBlock *pPlugin = NULL;
3694         int rc;
3695
3696         pPlugin = slapi_pblock_new();
3697         if ( pPlugin == NULL ) {
3698                 rc = LDAP_NO_MEMORY;
3699                 goto done;
3700         }
3701
3702         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_TYPE, (void *)SLAPI_PLUGIN_OBJECT );
3703         if ( rc != LDAP_SUCCESS ) {
3704                 goto done;
3705         }
3706
3707         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_COMPUTE_EVALUATOR_FN, (void *)function );
3708         if ( rc != LDAP_SUCCESS ) {
3709                 goto done;
3710         }
3711
3712         rc = slapi_int_register_plugin( frontendDB, pPlugin );
3713         if ( rc != 0 ) {
3714                 rc = LDAP_OTHER;
3715                 goto done;
3716         }
3717
3718 done:
3719         if ( rc != LDAP_SUCCESS ) {
3720                 if ( pPlugin != NULL ) {
3721                         slapi_pblock_destroy( pPlugin );
3722                 }
3723                 return -1;
3724         }
3725
3726         return 0;
3727 #else
3728         return -1;
3729 #endif /* LDAP_SLAPI */
3730 }
3731
3732 /*
3733  * See notes above regarding slapi_compute_add_evaluator().
3734  */
3735 int slapi_compute_add_search_rewriter(slapi_search_rewrite_callback_t function)
3736 {
3737 #ifdef LDAP_SLAPI
3738         Slapi_PBlock *pPlugin = NULL;
3739         int rc;
3740
3741         pPlugin = slapi_pblock_new();
3742         if ( pPlugin == NULL ) {
3743                 rc = LDAP_NO_MEMORY;
3744                 goto done;
3745         }
3746
3747         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_TYPE, (void *)SLAPI_PLUGIN_OBJECT );
3748         if ( rc != LDAP_SUCCESS ) {
3749                 goto done;
3750         }
3751
3752         rc = slapi_pblock_set( pPlugin, SLAPI_PLUGIN_COMPUTE_SEARCH_REWRITER_FN, (void *)function );
3753         if ( rc != LDAP_SUCCESS ) {
3754                 goto done;
3755         }
3756
3757         rc = slapi_int_register_plugin( frontendDB, pPlugin );
3758         if ( rc != 0 ) {
3759                 rc = LDAP_OTHER;
3760                 goto done;
3761         }
3762
3763 done:
3764         if ( rc != LDAP_SUCCESS ) {
3765                 if ( pPlugin != NULL ) {
3766                         slapi_pblock_destroy( pPlugin );
3767                 }
3768                 return -1;
3769         }
3770
3771         return 0;
3772 #else
3773         return -1;
3774 #endif /* LDAP_SLAPI */
3775 }
3776
3777 /*
3778  * Call compute evaluators
3779  */
3780 int compute_evaluator(computed_attr_context *c, char *type, Slapi_Entry *e, slapi_compute_output_t outputfn)
3781 {
3782 #ifdef LDAP_SLAPI
3783         int rc = 0;
3784         slapi_compute_callback_t *pGetPlugin, *tmpPlugin;
3785
3786         rc = slapi_int_get_plugins( frontendDB, SLAPI_PLUGIN_COMPUTE_EVALUATOR_FN, (SLAPI_FUNC **)&tmpPlugin );
3787         if ( rc != LDAP_SUCCESS || tmpPlugin == NULL ) {
3788                 /* Nothing to do; front-end should ignore. */
3789                 return 0;
3790         }
3791
3792         for ( pGetPlugin = tmpPlugin; *pGetPlugin != NULL; pGetPlugin++ ) {
3793                 /*
3794                  * -1: no attribute matched requested type
3795                  *  0: one attribute matched
3796                  * >0: error happened
3797                  */
3798                 rc = (*pGetPlugin)( c, type, e, outputfn );
3799                 if ( rc > 0 ) {
3800                         break;
3801                 }
3802         }
3803
3804         slapi_ch_free( (void **)&tmpPlugin );
3805
3806         return rc;
3807 #else
3808         return 1;
3809 #endif /* LDAP_SLAPI */
3810 }
3811
3812 int compute_rewrite_search_filter(Slapi_PBlock *pb)
3813 {
3814 #ifdef LDAP_SLAPI
3815         Backend *be;
3816         int rc;
3817
3818         rc = slapi_pblock_get( pb, SLAPI_BACKEND, (void *)&be );
3819         if ( rc != 0 ) {
3820                 return rc;
3821         }
3822
3823         return slapi_int_call_plugins( be, SLAPI_PLUGIN_COMPUTE_SEARCH_REWRITER_FN, pb );
3824 #else
3825         return -1;
3826 #endif /* LDAP_SLAPI */
3827 }
3828
3829 /*
3830  * New API to provide the plugin with access to the search
3831  * pblock. Have informed Sun DS team.
3832  */
3833 int slapi_x_compute_get_pblock(computed_attr_context *c, Slapi_PBlock **pb)
3834 {
3835 #ifdef LDAP_SLAPI
3836         if ( c == NULL )
3837                 return -1;
3838
3839         if ( c->cac_pb == NULL )
3840                 return -1;
3841
3842         *pb = c->cac_pb;
3843
3844         return 0;
3845 #else
3846         return -1;
3847 #endif /* LDAP_SLAPI */
3848 }
3849
3850 Slapi_Mutex *slapi_new_mutex( void )
3851 {
3852 #ifdef LDAP_SLAPI
3853         Slapi_Mutex *m;
3854
3855         m = (Slapi_Mutex *)slapi_ch_malloc( sizeof(*m) );
3856         if ( ldap_pvt_thread_mutex_init( &m->mutex ) != 0 ) {
3857                 slapi_ch_free( (void **)&m );
3858                 return NULL;
3859         }
3860
3861         return m;
3862 #else
3863         return NULL;
3864 #endif
3865 }
3866
3867 void slapi_destroy_mutex( Slapi_Mutex *mutex )
3868 {
3869 #ifdef LDAP_SLAPI
3870         if ( mutex != NULL ) {
3871                 ldap_pvt_thread_mutex_destroy( &mutex->mutex );
3872                 slapi_ch_free( (void **)&mutex);
3873         }
3874 #endif
3875 }
3876
3877 void slapi_lock_mutex( Slapi_Mutex *mutex )
3878 {
3879 #ifdef LDAP_SLAPI
3880         ldap_pvt_thread_mutex_lock( &mutex->mutex );
3881 #endif
3882 }
3883
3884 int slapi_unlock_mutex( Slapi_Mutex *mutex )
3885 {
3886 #ifdef LDAP_SLAPI
3887         return ldap_pvt_thread_mutex_unlock( &mutex->mutex );
3888 #else
3889         return -1;
3890 #endif
3891 }
3892
3893 Slapi_CondVar *slapi_new_condvar( Slapi_Mutex *mutex )
3894 {
3895 #ifdef LDAP_SLAPI
3896         Slapi_CondVar *cv;
3897
3898         if ( mutex == NULL ) {
3899                 return NULL;
3900         }
3901
3902         cv = (Slapi_CondVar *)slapi_ch_malloc( sizeof(*cv) );
3903         if ( ldap_pvt_thread_cond_init( &cv->cond ) != 0 ) {
3904                 slapi_ch_free( (void **)&cv );
3905                 return NULL;
3906         }
3907
3908         /* XXX struct copy */
3909         cv->mutex = mutex->mutex;
3910
3911         return cv;
3912 #else
3913         return NULL;
3914 #endif
3915 }
3916
3917 void slapi_destroy_condvar( Slapi_CondVar *cvar )
3918 {
3919 #ifdef LDAP_SLAPI
3920         if ( cvar != NULL ) {
3921                 ldap_pvt_thread_cond_destroy( &cvar->cond );
3922                 slapi_ch_free( (void **)&cvar );
3923         }
3924 #endif
3925 }
3926
3927 int slapi_wait_condvar( Slapi_CondVar *cvar, struct timeval *timeout )
3928 {
3929 #ifdef LDAP_SLAPI
3930         if ( cvar == NULL ) {
3931                 return -1;
3932         }
3933
3934         return ldap_pvt_thread_cond_wait( &cvar->cond, &cvar->mutex );
3935 #else
3936         return -1;
3937 #endif
3938 }
3939
3940 int slapi_notify_condvar( Slapi_CondVar *cvar, int notify_all )
3941 {
3942 #ifdef LDAP_SLAPI
3943         if ( cvar == NULL ) {
3944                 return -1;
3945         }
3946
3947         if ( notify_all ) {
3948                 return ldap_pvt_thread_cond_broadcast( &cvar->cond );
3949         }
3950
3951         return ldap_pvt_thread_cond_signal( &cvar->cond );
3952 #else
3953         return -1;
3954 #endif
3955 }
3956
3957 int slapi_int_access_allowed( Operation *op,
3958         Entry *entry,
3959         AttributeDescription *desc,
3960         struct berval *val,
3961         slap_access_t access,
3962         AccessControlState *state )
3963 {
3964 #ifdef LDAP_SLAPI
3965         int rc, slap_access = 0;
3966         slapi_acl_callback_t *pGetPlugin, *tmpPlugin;
3967         Slapi_PBlock *pb;
3968
3969         pb = SLAPI_OPERATION_PBLOCK( op );
3970         if ( pb == NULL ) {
3971                 /* internal operation */
3972                 return 1;
3973         }
3974
3975         switch ( access ) {
3976         case ACL_COMPARE:
3977                 slap_access |= SLAPI_ACL_COMPARE;
3978                 break;
3979         case ACL_SEARCH:
3980                 slap_access |= SLAPI_ACL_SEARCH;
3981                 break;
3982         case ACL_READ:
3983                 slap_access |= SLAPI_ACL_READ;
3984                 break;
3985         case ACL_WRITE:
3986                 slap_access |= SLAPI_ACL_WRITE;
3987                 break;
3988         case ACL_WDEL:
3989                 slap_access |= SLAPI_ACL_DELETE;
3990                 break;
3991         case ACL_WADD:
3992                 slap_access |= SLAPI_ACL_ADD;
3993                 break;
3994         default:
3995                 break;
3996         }
3997
3998         rc = slapi_int_get_plugins( op->o_bd, SLAPI_PLUGIN_ACL_ALLOW_ACCESS, (SLAPI_FUNC **)&tmpPlugin );
3999         if ( rc != LDAP_SUCCESS || tmpPlugin == NULL ) {
4000                 /* nothing to do; allowed access */
4001                 return 1;
4002         }
4003
4004         rc = 1; /* default allow policy */
4005
4006         for ( pGetPlugin = tmpPlugin; *pGetPlugin != NULL; pGetPlugin++ ) {
4007                 /*
4008                  * 0    access denied
4009                  * 1    access granted
4010                  */
4011                 rc = (*pGetPlugin)( pb, entry, desc->ad_cname.bv_val,
4012                                     val, slap_access, (void *)state );
4013                 if ( rc == 0 ) {
4014                         break;
4015                 }
4016         }
4017
4018         slapi_ch_free( (void **)&tmpPlugin );
4019
4020         return rc;
4021 #else
4022         return 1;
4023 #endif /* LDAP_SLAPI */
4024 }
4025
4026 /*
4027  * There is no documentation for this.
4028  */
4029 int slapi_rdn2typeval( char *rdn, char **type, struct berval *bv )
4030 {
4031 #ifdef LDAP_SLAPI
4032         LDAPRDN lrdn;
4033         LDAPAVA *ava;
4034         int rc;
4035         char *p;
4036
4037         *type = NULL;
4038
4039         bv->bv_len = 0;
4040         bv->bv_val = NULL;
4041
4042         rc = ldap_str2rdn( rdn, &lrdn, &p, LDAP_DN_FORMAT_LDAPV3 );
4043         if ( rc != LDAP_SUCCESS ) {
4044                 return -1;
4045         }
4046
4047         if ( lrdn[1] != NULL ) {
4048                 return -1; /* not single valued */
4049         }
4050
4051         ava = lrdn[0];
4052
4053         *type = slapi_ch_strdup( ava->la_attr.bv_val );
4054         ber_dupbv( bv, &ava->la_value );
4055
4056         ldap_rdnfree(lrdn);
4057
4058         return 0;
4059 #else
4060         return -1;
4061 #endif /* LDAP_SLAPI */
4062 }
4063
4064 char *slapi_dn_plus_rdn( const char *dn, const char *rdn )
4065 {
4066 #ifdef LDAP_SLAPI
4067         struct berval new_dn, parent_dn, newrdn;
4068
4069         new_dn.bv_val = NULL;
4070
4071         parent_dn.bv_val = (char *)dn;
4072         parent_dn.bv_len = strlen( dn );
4073
4074         newrdn.bv_val = (char *)rdn;
4075         newrdn.bv_len = strlen( rdn );
4076
4077         build_new_dn( &new_dn, &parent_dn, &newrdn, NULL );
4078
4079         return new_dn.bv_val;
4080 #else
4081         return NULL;
4082 #endif /* LDAP_SLAPI */
4083 }
4084
4085 int slapi_entry_schema_check( Slapi_PBlock *pb, Slapi_Entry *e )
4086 {
4087 #ifdef LDAP_SLAPI
4088         Backend *be;
4089         const char *text;
4090         char textbuf[SLAP_TEXT_BUFLEN] = { '\0' };
4091         size_t textlen = sizeof textbuf;
4092         int rc;
4093
4094         if ( slapi_pblock_get( pb, SLAPI_BACKEND, (void **)&be ) != 0 )
4095                 return -1;
4096
4097         rc = entry_schema_check( be, e, NULL, 0,
4098                 &text, textbuf, textlen );
4099
4100         return ( rc == LDAP_SUCCESS ) ? 0 : 1;
4101 #else
4102         return -1;
4103 #endif /* LDAP_SLAPI */
4104 }
4105
4106 int slapi_entry_rdn_values_present( const Slapi_Entry *e )
4107 {
4108 #ifdef LDAP_SLAPI
4109         LDAPDN dn;
4110         int rc;
4111         int i = 0, match = 0;
4112
4113         rc = ldap_bv2dn( &((Entry *)e)->e_name, &dn, LDAP_DN_FORMAT_LDAPV3 );
4114         if ( rc != LDAP_SUCCESS ) {
4115                 return 0;
4116         }
4117
4118         if ( dn[0] != NULL ) {
4119                 LDAPRDN rdn = dn[0];
4120
4121                 for ( i = 0; rdn[i] != NULL; i++ ) {
4122                         LDAPAVA *ava = &rdn[0][i];
4123                         Slapi_Attr *a = NULL;
4124
4125                         if ( slapi_entry_attr_find( (Slapi_Entry *)e, ava->la_attr.bv_val, &a ) == 0 &&
4126                              slapi_attr_value_find( a, &ava->la_value ) == 0 )
4127                                 match++;
4128                 }
4129         }
4130
4131         ldap_dnfree( dn );
4132
4133         return ( i == match );
4134 #else
4135         return 0;
4136 #endif /* LDAP_SLAPI */
4137 }
4138
4139 int slapi_entry_add_rdn_values( Slapi_Entry *e )
4140 {
4141 #ifdef LDAP_SLAPI
4142         LDAPDN dn;
4143         int i, rc;
4144
4145         rc = ldap_bv2dn( &e->e_name, &dn, LDAP_DN_FORMAT_LDAPV3 );
4146         if ( rc != LDAP_SUCCESS ) {
4147                 return rc;
4148         }
4149
4150         if ( dn[0] != NULL ) {
4151                 LDAPRDN rdn = dn[0];
4152                 struct berval *vals[2];
4153
4154                 for ( i = 0; rdn[i] != NULL; i++ ) {
4155                         LDAPAVA *ava = &rdn[0][i];
4156                         Slapi_Attr *a = NULL;
4157
4158                         if ( slapi_entry_attr_find( e, ava->la_attr.bv_val, &a ) == 0 &&
4159                              slapi_attr_value_find( a, &ava->la_value ) == 0 )
4160                                 continue;
4161
4162                         vals[0] = &ava->la_value;
4163                         vals[1] = NULL;
4164
4165                         slapi_entry_attr_merge( e, ava->la_attr.bv_val, vals );
4166                 }
4167         }
4168
4169         ldap_dnfree( dn );
4170
4171         return LDAP_SUCCESS;
4172 #else
4173         return LDAP_OTHER;
4174 #endif /* LDAP_SLAPI */
4175 }
4176
4177 const char *slapi_entry_get_uniqueid( const Slapi_Entry *e )
4178 {
4179 #ifdef LDAP_SLAPI
4180         Attribute *attr;
4181
4182         attr = attr_find( e->e_attrs, slap_schema.si_ad_entryUUID );
4183         if ( attr == NULL ) {
4184                 return NULL;
4185         }
4186
4187         if ( attr->a_vals != NULL && attr->a_vals[0].bv_len != 0 ) {
4188                 return slapi_value_get_string( &attr->a_vals[0] );
4189         }
4190 #endif /* LDAP_SLAPI */
4191
4192         return NULL;
4193 }
4194
4195 void slapi_entry_set_uniqueid( Slapi_Entry *e, char *uniqueid )
4196 {
4197 #ifdef LDAP_SLAPI
4198         struct berval bv;
4199
4200         attr_delete ( &e->e_attrs, slap_schema.si_ad_entryUUID );
4201
4202         bv.bv_val = uniqueid;
4203         bv.bv_len = strlen( uniqueid );
4204         attr_merge_normalize_one( e, slap_schema.si_ad_entryUUID, &bv, NULL );
4205 #endif /* LDAP_SLAPI */
4206 }
4207
4208 LDAP *slapi_ldap_init( char *ldaphost, int ldapport, int secure, int shared )
4209 {
4210 #ifdef LDAP_SLAPI
4211         LDAP *ld;
4212         char *url;
4213         size_t size;
4214         int rc;
4215
4216         size = sizeof("ldap:///");
4217         if ( secure )
4218                 size++;
4219         size += strlen( ldaphost );
4220         if ( ldapport != 0 )
4221                 size += 32;
4222
4223         url = slapi_ch_malloc( size );
4224
4225         if ( ldapport != 0 ) {
4226                 sprintf( url, "ldap%s://%s:%d/", ( secure ? "s" : "" ), ldaphost, ldapport );
4227         } else {
4228                 sprintf( url, "ldap%s://%s/", ( secure ? "s" : "" ), ldaphost );
4229         }
4230
4231         rc = ldap_initialize( &ld, url );
4232
4233         slapi_ch_free_string( &url );
4234
4235         return ( rc == LDAP_SUCCESS ) ? ld : NULL;
4236 #else
4237         return NULL;
4238 #endif /* LDAP_SLAPI */
4239 }
4240
4241 void slapi_ldap_unbind( LDAP *ld )
4242 {
4243 #ifdef LDAP_SLAPI
4244         ldap_unbind( ld );
4245 #endif /* LDAP_SLAPI */
4246 }
4247
4248 int slapi_x_backend_get_flags( const Slapi_Backend *be, unsigned long *flags )
4249 {
4250 #ifdef LDAP_SLAPI
4251         if ( be == NULL )
4252                 return LDAP_PARAM_ERROR;
4253
4254         *flags = SLAP_DBFLAGS(be);
4255
4256         return LDAP_SUCCESS;
4257 #else
4258         return -1;
4259 #endif /* LDAP_SLAPI */
4260 }
4261