dlls/wldap32/libldap.c

   1 /*
   2  * Unix interface for libldap
   3  *
   4  * Copyright 2021 Hans Leidekker for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #if 0
  22 #pragma makedep unix
  23 #endif
  24
  25 #include "config.h"
  26
  27 #ifdef HAVE_LDAP
  28 #include <assert.h>
  29 #include <stdarg.h>
  30 #include <sys/time.h>
  31 #ifdef HAVE_LDAP_H
  32 # include <ldap.h>
  33 #endif
  34 #ifdef HAVE_SASL_SASL_H
  35 # include <sasl/sasl.h>
  36 #endif
  37
  38 #include "ntstatus.h"
  39 #define WIN32_NO_STATUS
  40 #include "windef.h"
  41 #include "winternl.h"
  42 #include "winbase.h"
  43
  44 #include "wine/debug.h"
  45 #include "libldap.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  48
  49 C_ASSERT( sizeof(BerValueU) == sizeof(BerValue) );
  50 C_ASSERT( sizeof(LDAPModU) == sizeof(LDAPMod) );
  51 C_ASSERT( sizeof(LDAPControlU) == sizeof(LDAPControl) );
  52 C_ASSERT( sizeof(LDAPSortKeyU) == sizeof(LDAPSortKey) );
  53 C_ASSERT( sizeof(LDAPVLVInfoU) == sizeof(LDAPVLVInfo) );
  54 C_ASSERT( sizeof(LDAPAPIInfoU) == sizeof(LDAPAPIInfo) );
  55 C_ASSERT( sizeof(LDAPAPIFeatureInfoU) == sizeof(LDAPAPIFeatureInfo) );
  56 C_ASSERT( sizeof(struct timevalU) == sizeof(struct timeval) );
  57
  58 #define WLDAP32_LBER_ERROR  (~0l)
  59
  60 static LDAPMod *nullmods[] = { NULL };
  61
  62 static const struct ldap_callbacks *callbacks;
  63
  64 static void * CDECL wrap_ber_alloc_t( int options )
  65 {
  66     return ber_alloc_t( options );
  67 }
  68
  69 static void CDECL wrap_ber_bvecfree( struct bervalU **berval )
  70 {
  71     ber_bvecfree( (struct berval **)berval );
  72 }
  73
  74 static void CDECL wrap_ber_bvfree( struct bervalU *berval )
  75 {
  76     ber_bvfree( (struct berval *)berval );
  77 }
  78
  79 static unsigned int CDECL wrap_ber_first_element( void *ber, ULONG *ret_len, char **last )
  80 {
  81     ber_len_t len;
  82     ber_tag_t ret;
  83
  84     if ((ret = ber_first_element( ber, &len, last )) == LBER_ERROR) return WLDAP32_LBER_ERROR;
  85     if (ret > ~0u)
  86     {
  87         ERR( "ret too large\n" );
  88         return WLDAP32_LBER_ERROR;
  89     }
  90     if (len > ~0u)
  91     {
  92         ERR( "len too large\n" );
  93         return WLDAP32_LBER_ERROR;
  94     }
  95
  96     *ret_len = len;
  97     return ret;
  98 }
  99
 100 static int CDECL wrap_ber_flatten( void *ber, struct bervalU **berval )
 101 {
 102     return ber_flatten( ber, (struct berval **)berval );
 103 }
 104
 105 static void CDECL wrap_ber_free( void *ber, int freebuf )
 106 {
 107     ber_free( ber, freebuf );
 108 }
 109
 110 static void * CDECL wrap_ber_init( struct bervalU *berval )
 111 {
 112     return ber_init( (struct berval *)berval );
 113 }
 114
 115 static unsigned int CDECL wrap_ber_next_element( void *ber, unsigned int *ret_len, char *last )
 116 {
 117     ber_len_t len;
 118     ber_tag_t ret;
 119
 120     if ((ret = ber_next_element( ber, &len, last )) == LBER_ERROR) return WLDAP32_LBER_ERROR;
 121     if (ret > ~0u)
 122     {
 123         ERR( "ret too large\n" );
 124         return WLDAP32_LBER_ERROR;
 125     }
 126     if (len > ~0u)
 127     {
 128         ERR( "len too large\n" );
 129         return WLDAP32_LBER_ERROR;
 130     }
 131
 132     *ret_len = len;
 133     return ret;
 134 }
 135
 136 static unsigned int CDECL wrap_ber_peek_tag( void *ber, unsigned int *ret_len )
 137 {
 138     ber_len_t len;
 139     ber_tag_t ret;
 140
 141     if ((ret = ber_peek_tag( ber, &len )) == LBER_ERROR) return WLDAP32_LBER_ERROR;
 142     if (len > ~0u)
 143     {
 144         ERR( "len too large\n" );
 145         return WLDAP32_LBER_ERROR;
 146     }
 147
 148     *ret_len = len;
 149     return ret;
 150 }
 151
 152 static unsigned int CDECL wrap_ber_skip_tag( void *ber, unsigned int *ret_len )
 153 {
 154     ber_len_t len;
 155     ber_tag_t ret;
 156
 157     if ((ret = ber_skip_tag( ber, &len )) == LBER_ERROR) return WLDAP32_LBER_ERROR;
 158     if (len > ~0u)
 159     {
 160         ERR( "len too large\n" );
 161         return WLDAP32_LBER_ERROR;
 162     }
 163
 164     *ret_len = len;
 165     return ret;
 166 }
 167
 168 static int WINAPIV wrap_ber_printf( void *ber, char *fmt, ... )
 169 {
 170     int ret;
 171     __ms_va_list args;
 172
 173     assert( strlen(fmt) == 1 );
 174
 175     __ms_va_start( args, fmt );
 176     switch (fmt[0])
 177     {
 178     case 'b':
 179     case 'e':
 180     case 'i':
 181     {
 182         int i = va_arg( args, int );
 183         ret = ber_printf( ber, fmt, i );
 184         break;
 185     }
 186     case 'o':
 187     case 's':
 188     {
 189         char *str = va_arg( args, char * );
 190         ret = ber_printf( ber, fmt, str );
 191         break;
 192     }
 193     case 't':
 194     {
 195         unsigned int tag = va_arg( args, unsigned int );
 196         ret = ber_printf( ber, fmt, tag );
 197         break;
 198     }
 199     case 'v':
 200     {
 201         char **array = va_arg( args, char ** );
 202         ret = ber_printf( ber, fmt, array );
 203         break;
 204     }
 205     case 'V':
 206     {
 207         struct berval **array = va_arg( args, struct berval ** );
 208         ret = ber_printf( ber, fmt, array );
 209         break;
 210     }
 211     case 'B':
 212     {
 213         char *str = va_arg( args, char * );
 214         int len = va_arg( args, int );
 215         ret = ber_printf( ber, fmt, str, len );
 216         break;
 217     }
 218     case 'n':
 219     case '{':
 220     case '}':
 221     case '[':
 222     case ']':
 223         ret = ber_printf( ber, fmt );
 224         break;
 225
 226     default:
 227         assert( 0 );
 228     }
 229     __ms_va_end( args );
 230     return ret;
 231 }
 232
 233 static int WINAPIV wrap_ber_scanf( void *ber, char *fmt, ... )
 234 {
 235     int ret;
 236     __ms_va_list args;
 237
 238     assert( strlen(fmt) == 1 );
 239
 240     __ms_va_start( args, fmt );
 241     switch (fmt[0])
 242     {
 243     case 'a':
 244     {
 245         char **str = va_arg( args, char ** );
 246         ret = ber_scanf( ber, fmt, str );
 247         break;
 248     }
 249     case 'b':
 250     case 'e':
 251     case 'i':
 252     {
 253         int *i = va_arg( args, int * );
 254         ret = ber_scanf( ber, fmt, i );
 255         break;
 256     }
 257     case 't':
 258     {
 259         unsigned int *tag = va_arg( args, unsigned int * );
 260         ret = ber_scanf( ber, fmt, tag );
 261         break;
 262     }
 263     case 'v':
 264     {
 265         char ***array = va_arg( args, char *** );
 266         ret = ber_scanf( ber, fmt, array );
 267         break;
 268     }
 269     case 'B':
 270     {
 271         char **str = va_arg( args, char ** );
 272         int *len = va_arg( args, int * );
 273         ret = ber_scanf( ber, fmt, str, len );
 274         break;
 275     }
 276     case 'O':
 277     {
 278         struct berval **berval = va_arg( args, struct berval ** );
 279         ret = ber_scanf( ber, fmt, berval );
 280         break;
 281     }
 282     case 'V':
 283     {
 284         struct berval ***array = va_arg( args, struct berval *** );
 285         ret = ber_scanf( ber, fmt, array );
 286         break;
 287     }
 288     case 'n':
 289     case 'x':
 290     case '{':
 291     case '}':
 292     case '[':
 293     case ']':
 294         ret = ber_scanf( ber, fmt );
 295         break;
 296
 297     default:
 298         assert( 0 );
 299     }
 300     __ms_va_end( args );
 301     return ret;
 302 }
 303
 304 static int CDECL wrap_ldap_abandon_ext( void *ld, int msgid, LDAPControlU **serverctrls, LDAPControlU **clientctrls )
 305 {
 306     return ldap_abandon_ext( ld, msgid, (LDAPControl **)serverctrls, (LDAPControl **)clientctrls );
 307 }
 308
 309 static int CDECL wrap_ldap_add_ext( void *ld, const char *dn, LDAPModU **attrs, LDAPControlU **serverctrls,
 310                              LDAPControlU **clientctrls, ULONG *msg )
 311 {
 312     int dummy;
 313     return ldap_add_ext( ld, dn ? dn : "", attrs ? (LDAPMod **)attrs : nullmods, (LDAPControl **)serverctrls,
 314                          (LDAPControl **)clientctrls, msg ? (int *)msg : &dummy );
 315 }
 316
 317 static int CDECL wrap_ldap_add_ext_s( void *ld, const char *dn, LDAPModU **attrs, LDAPControlU **serverctrls,
 318                                LDAPControlU **clientctrls )
 319 {
 320     return ldap_add_ext_s( ld, dn ? dn : "", attrs ? (LDAPMod **)attrs : nullmods, (LDAPControl **)serverctrls,
 321                            (LDAPControl **)clientctrls );
 322 }
 323
 324 static int CDECL wrap_ldap_compare_ext( void *ld, const char *dn, const char *attrs, struct bervalU *value,
 325                                  LDAPControlU **serverctrls, LDAPControlU **clientctrls, ULONG *msg )
 326 {
 327     int dummy;
 328     return ldap_compare_ext( ld, dn ? dn : "", attrs ? attrs : "", (struct berval *)value,
 329                              (LDAPControl **)serverctrls, (LDAPControl **)clientctrls, msg ? (int *)msg : &dummy );
 330 }
 331
 332 static int CDECL wrap_ldap_compare_ext_s( void *ld, const char *dn, const char *attrs, struct bervalU *value,
 333                                    LDAPControlU **serverctrls, LDAPControlU **clientctrls )
 334 {
 335     return ldap_compare_ext_s( ld, dn ? dn : "", attrs ? attrs : "", (struct berval *)value,
 336                                (LDAPControl **)serverctrls, (LDAPControl **)clientctrls );
 337 }
 338
 339 static void CDECL wrap_ldap_control_free( LDAPControlU *control )
 340 {
 341     ldap_control_free( (LDAPControl *)control );
 342 }
 343
 344 static void CDECL wrap_ldap_controls_free( LDAPControlU **control )
 345 {
 346     ldap_controls_free( (LDAPControl **)control );
 347 }
 348
 349 static int CDECL wrap_ldap_count_entries( void *ld, void *chain )
 350 {
 351     return ldap_count_entries( ld, chain );
 352 }
 353
 354 static int CDECL wrap_ldap_count_references( void *ld, void *chain )
 355 {
 356     return ldap_count_references( ld, chain );
 357 }
 358
 359 static int CDECL wrap_ldap_count_values_len( struct bervalU **values )
 360 {
 361     return ldap_count_values_len( (struct berval **)values );
 362 }
 363
 364 static int CDECL wrap_ldap_create_sort_control( void *ld, LDAPSortKeyU **keylist, int critical, LDAPControlU **control )
 365 {
 366     return ldap_create_sort_control( ld, (LDAPSortKey **)keylist, critical, (LDAPControl **)control );
 367 }
 368
 369 static int CDECL wrap_ldap_create_vlv_control( void *ld, LDAPVLVInfoU *info, LDAPControlU **control )
 370 {
 371     return ldap_create_vlv_control( ld, (LDAPVLVInfo *)info, (LDAPControl **)control );
 372 }
 373
 374 static int CDECL wrap_ldap_delete_ext( void *ld, const char *dn, LDAPControlU **serverctrls, LDAPControlU **clientctrls,
 375                                 ULONG *msg )
 376 {
 377     int dummy;
 378     return ldap_delete_ext( ld, dn ? dn : "", (LDAPControl **)serverctrls, (LDAPControl **)clientctrls,
 379                             msg ? (int *)msg : &dummy );
 380 }
 381
 382 static int CDECL wrap_ldap_delete_ext_s( void *ld, const char *dn, LDAPControlU **serverctrls, LDAPControlU **clientctrls )
 383 {
 384     return ldap_delete_ext_s( ld, dn ? dn : "", (LDAPControl **)serverctrls, (LDAPControl **)clientctrls );
 385 }
 386
 387 static char * CDECL wrap_ldap_dn2ufn( const char *dn )
 388 {
 389     return ldap_dn2ufn( dn );
 390 }
 391
 392 static char ** CDECL wrap_ldap_explode_dn( const char *dn, int notypes )
 393 {
 394     return ldap_explode_dn( dn, notypes );
 395 }
 396
 397 static int CDECL wrap_ldap_extended_operation( void *ld, const char *oid, struct bervalU *data, LDAPControlU **serverctrls,
 398                                         LDAPControlU **clientctrls, ULONG *msg )
 399 {
 400     int dummy;
 401     return ldap_extended_operation( ld, oid ? oid : "", (struct berval *)data, (LDAPControl **)serverctrls,
 402                                     (LDAPControl **)clientctrls, msg ? (int *)msg : &dummy );
 403 }
 404
 405 static int CDECL wrap_ldap_extended_operation_s( void *ld, const char *oid, struct bervalU *data, LDAPControlU **serverctrls,
 406                                           LDAPControlU **clientctrls, char **retoid, struct bervalU **retdata )
 407 {
 408     return ldap_extended_operation_s( ld, oid ? oid : "", (struct berval *)data, (LDAPControl **)serverctrls,
 409                                       (LDAPControl **)clientctrls, retoid, (struct berval **)retdata );
 410 }
 411
 412 static char * CDECL wrap_ldap_get_dn( void *ld, void *entry )
 413 {
 414     return ldap_get_dn( ld, entry );
 415 }
 416
 417 static char * CDECL wrap_ldap_first_attribute( void *ld, void *entry, void **ber )
 418 {
 419     return ldap_first_attribute( ld, entry, (BerElement **)ber );
 420 }
 421
 422 static void * CDECL wrap_ldap_first_entry( void *ld, void *chain )
 423 {
 424     return ldap_first_entry( ld, chain );
 425 }
 426
 427 static void * CDECL wrap_ldap_first_reference( void *ld, void *chain )
 428 {
 429     return ldap_first_reference( ld, chain );
 430 }
 431
 432 static int CDECL wrap_ldap_get_option( void *ld, int option, void *value )
 433 {
 434     return ldap_get_option( ld, option, value );
 435 }
 436
 437 static struct bervalU ** CDECL wrap_ldap_get_values_len( void *ld, void *entry, const char *attr )
 438 {
 439     return (struct bervalU **)ldap_get_values_len( ld, entry, attr );
 440 }
 441
 442 static int CDECL wrap_ldap_initialize( void **ld, const char *url )
 443 {
 444     return ldap_initialize( (LDAP **)ld, url );
 445 }
 446
 447 static void CDECL wrap_ldap_memfree( void *ptr )
 448 {
 449     return ldap_memfree( ptr );
 450 }
 451
 452 static void CDECL wrap_ldap_memvfree( void **ptr )
 453 {
 454     ldap_memvfree( ptr );
 455 }
 456
 457 static int CDECL wrap_ldap_modify_ext( void *ld, const char *dn, LDAPModU **mods, LDAPControlU **serverctrls,
 458                                 LDAPControlU **clientctrls, ULONG *msg )
 459 {
 460     int dummy;
 461     return ldap_modify_ext( ld, dn ? dn : "", mods ? (LDAPMod **)mods : nullmods, (LDAPControl **)serverctrls,
 462                             (LDAPControl **)clientctrls, msg ? (int *)msg : &dummy );
 463 }
 464
 465 static int CDECL wrap_ldap_modify_ext_s( void *ld, const char *dn, LDAPModU **mods, LDAPControlU **serverctrls,
 466                                   LDAPControlU **clientctrls )
 467 {
 468     return ldap_modify_ext_s( ld, dn ? dn : "", mods ? (LDAPMod **)mods : nullmods, (LDAPControl **)serverctrls,
 469                               (LDAPControl **)clientctrls );
 470 }
 471
 472 static int CDECL wrap_ldap_msgfree( void *msg )
 473 {
 474     return ldap_msgfree( msg );
 475 }
 476
 477 static char * CDECL wrap_ldap_next_attribute( void *ld, void *entry, void *ber )
 478 {
 479     return ldap_next_attribute( ld, entry, ber );
 480 }
 481
 482 static void * CDECL wrap_ldap_next_entry( void *ld, void *entry )
 483 {
 484     return ldap_next_entry( ld, entry );
 485 }
 486
 487 static void * CDECL wrap_ldap_next_reference( void *ld, void *entry )
 488 {
 489     return ldap_next_reference( ld, entry );
 490 }
 491
 492 static int CDECL wrap_ldap_parse_extended_result( void *ld, void *result, char **retoid, struct bervalU **retdata, int free )
 493 {
 494     return ldap_parse_extended_result( ld, result, retoid, (struct berval **)retdata, free );
 495 }
 496
 497 static int CDECL wrap_ldap_parse_reference( void *ld, void *ref, char ***referrals, LDAPControlU ***serverctrls, int free )
 498 {
 499     return ldap_parse_reference( ld, ref, referrals, (LDAPControl ***)serverctrls, free );
 500 }
 501
 502 static int CDECL wrap_ldap_parse_result( void *ld, void *res, int *errcode, char **matcheddn, char **errmsg,
 503                                   char ***referrals, LDAPControlU ***serverctrls, int free )
 504 {
 505     return ldap_parse_result( ld, res, errcode, matcheddn, errmsg, referrals, (LDAPControl ***)serverctrls, free );
 506 }
 507
 508 static int CDECL wrap_ldap_parse_sortresponse_control( void *ld, LDAPControlU *ctrl, int *result, char **attr )
 509 {
 510     return ldap_parse_sortresponse_control( ld, (LDAPControl *)ctrl, result, attr );
 511 }
 512
 513 static int CDECL wrap_ldap_parse_vlvresponse_control( void *ld, LDAPControlU *ctrls, int *target_pos, int *list_count,
 514                                                struct bervalU **ctx, int *errcode )
 515 {
 516     return ldap_parse_vlvresponse_control( ld, (LDAPControl *)ctrls, target_pos, list_count, (struct berval **)ctx,
 517                                            errcode );
 518 }
 519
 520 static int CDECL wrap_ldap_rename( void *ld, const char *dn, const char *newrdn, const char *newparent, int delete,
 521                             LDAPControlU **clientctrls, LDAPControlU **serverctrls, ULONG *msg )
 522 {
 523     return ldap_rename( ld, dn ? dn : "", newrdn, newparent, delete, (LDAPControl **)clientctrls,
 524                         (LDAPControl **)serverctrls, (int *)msg );
 525 }
 526
 527 static int CDECL wrap_ldap_rename_s( void *ld, const char *dn, const char *newrdn, const char *newparent, int delete,
 528                               LDAPControlU **clientctrls, LDAPControlU **serverctrls )
 529 {
 530     return ldap_rename_s( ld, dn ? dn : "", newrdn, newparent, delete, (LDAPControl **)clientctrls,
 531                           (LDAPControl **)serverctrls );
 532 }
 533
 534 static int CDECL wrap_ldap_result( void *ld, int msgid, int all, struct timevalU *timeout, void **result )
 535 {
 536     return ldap_result( ld, msgid, all, (struct timeval *)timeout, (LDAPMessage **)result );
 537 }
 538
 539 static int CDECL wrap_ldap_sasl_bind( void *ld, const char *dn, const char *mech, struct bervalU *cred,
 540                                LDAPControlU **serverctrls, LDAPControlU **clientctrls, int *msgid )
 541 {
 542     return ldap_sasl_bind( ld, dn, mech, (struct berval *)cred, (LDAPControl **)serverctrls,
 543                            (LDAPControl **)clientctrls, msgid );
 544 }
 545
 546 static int CDECL wrap_ldap_sasl_bind_s( void *ld, const char *dn, const char *mech, struct bervalU *cred,
 547                                  LDAPControlU **serverctrls, LDAPControlU **clientctrls, struct bervalU **servercred )
 548 {
 549     return ldap_sasl_bind_s( ld, dn, mech, (struct berval *)cred, (LDAPControl **)serverctrls,
 550                              (LDAPControl **)clientctrls, (struct berval **)servercred );
 551 }
 552
 553 static int wrap_sasl_interact( LDAP *ld, unsigned int flags, void *defaults, void *interact )
 554 {
 555 #ifdef HAVE_SASL_SASL_H
 556     C_ASSERT( sizeof(struct sasl_interactU) == sizeof(struct sasl_interact) );
 557     return callbacks->sasl_interact( ld, flags, defaults, interact );
 558 #endif
 559     return -1;
 560 }
 561
 562 static int CDECL wrap_ldap_sasl_interactive_bind_s( void *ld, const char *dn, const char *mech, LDAPControlU **serverctrls,
 563                                              LDAPControlU **clientctrls, unsigned int flags, void *defaults )
 564 {
 565     return ldap_sasl_interactive_bind_s( ld, dn, mech, (LDAPControl **)serverctrls, (LDAPControl **)clientctrls, flags,
 566                                          wrap_sasl_interact, defaults );
 567 }
 568
 569 static int CDECL wrap_ldap_search_ext( void *ld, const char *base, int scope, const char *filter, char **attrs, int attrsonly,
 570                                 LDAPControlU **serverctrls, LDAPControlU **clientctrls, struct timevalU *timeout,
 571                                 int sizelimit, ULONG *msg )
 572 {
 573     return ldap_search_ext( ld, base, scope, filter, attrs, attrsonly, (LDAPControl **)serverctrls,
 574                             (LDAPControl **)clientctrls, (struct timeval *)timeout, sizelimit, (int *)msg );
 575 }
 576
 577 static int CDECL wrap_ldap_search_ext_s( void *ld, const char *base, int scope, const char *filter, char **attrs,
 578                                   int attrsonly, LDAPControlU **serverctrls, LDAPControlU **clientctrls,
 579                                   struct timevalU *timeout, int sizelimit, void **result )
 580 {
 581     return ldap_search_ext_s( ld, base, scope, filter, attrs, attrsonly, (LDAPControl **)serverctrls,
 582                               (LDAPControl **)clientctrls, (struct timeval *)timeout, sizelimit,
 583                               (LDAPMessage **)result );
 584 }
 585
 586 static int CDECL wrap_ldap_set_option( void *ld, int option, const void *value )
 587 {
 588     return ldap_set_option( ld, option, value );
 589 }
 590
 591 static int CDECL wrap_ldap_start_tls_s( void *ld, LDAPControlU **serverctrls, LDAPControlU **clientctrls )
 592 {
 593     return ldap_start_tls_s( ld, (LDAPControl **)serverctrls, (LDAPControl **)clientctrls );
 594 }
 595
 596 static int CDECL wrap_ldap_unbind_ext( void *ld, LDAPControlU **serverctrls, LDAPControlU **clientctrls )
 597 {
 598     return ldap_unbind_ext( ld, (LDAPControl **)serverctrls, (LDAPControl **)clientctrls );
 599 }
 600
 601 static int CDECL wrap_ldap_unbind_ext_s( void *ld, LDAPControlU **serverctrls, LDAPControlU **clientctrls )
 602 {
 603     return ldap_unbind_ext_s( ld, (LDAPControl **)serverctrls, (LDAPControl **)clientctrls );
 604 }
 605
 606 static void CDECL wrap_ldap_value_free_len( struct bervalU **values )
 607 {
 608     ldap_value_free_len( (struct berval **)values );
 609 }
 610
 611 static const struct ldap_funcs funcs =
 612 {
 613     wrap_ber_alloc_t,
 614     wrap_ber_bvecfree,
 615     wrap_ber_bvfree,
 616     wrap_ber_first_element,
 617     wrap_ber_flatten,
 618     wrap_ber_free,
 619     wrap_ber_init,
 620     wrap_ber_next_element,
 621     wrap_ber_peek_tag,
 622     wrap_ber_skip_tag,
 623     wrap_ber_printf,
 624     wrap_ber_scanf,
 625     wrap_ldap_abandon_ext,
 626     wrap_ldap_add_ext,
 627     wrap_ldap_add_ext_s,
 628     wrap_ldap_compare_ext,
 629     wrap_ldap_compare_ext_s,
 630     wrap_ldap_control_free,
 631     wrap_ldap_controls_free,
 632     wrap_ldap_count_entries,
 633     wrap_ldap_count_references,
 634     wrap_ldap_count_values_len,
 635     wrap_ldap_create_sort_control,
 636     wrap_ldap_create_vlv_control,
 637     wrap_ldap_delete_ext,
 638     wrap_ldap_delete_ext_s,
 639     wrap_ldap_dn2ufn,
 640     wrap_ldap_explode_dn,
 641     wrap_ldap_extended_operation,
 642     wrap_ldap_extended_operation_s,
 643     wrap_ldap_get_dn,
 644     wrap_ldap_get_option,
 645     wrap_ldap_get_values_len,
 646     wrap_ldap_initialize,
 647     wrap_ldap_first_attribute,
 648     wrap_ldap_first_entry,
 649     wrap_ldap_first_reference,
 650     wrap_ldap_memfree,
 651     wrap_ldap_memvfree,
 652     wrap_ldap_modify_ext,
 653     wrap_ldap_modify_ext_s,
 654     wrap_ldap_msgfree,
 655     wrap_ldap_next_attribute,
 656     wrap_ldap_next_entry,
 657     wrap_ldap_next_reference,
 658     wrap_ldap_parse_extended_result,
 659     wrap_ldap_parse_reference,
 660     wrap_ldap_parse_result,
 661     wrap_ldap_parse_sortresponse_control,
 662     wrap_ldap_parse_vlvresponse_control,
 663     wrap_ldap_rename,
 664     wrap_ldap_rename_s,
 665     wrap_ldap_result,
 666     wrap_ldap_sasl_bind,
 667     wrap_ldap_sasl_bind_s,
 668     wrap_ldap_sasl_interactive_bind_s,
 669     wrap_ldap_search_ext,
 670     wrap_ldap_search_ext_s,
 671     wrap_ldap_set_option,
 672     wrap_ldap_start_tls_s,
 673     wrap_ldap_unbind_ext,
 674     wrap_ldap_unbind_ext_s,
 675     wrap_ldap_value_free_len,
 676 };
 677
 678 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
 679 {
 680     if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
 681     callbacks = ptr_in;
 682     *(const struct ldap_funcs **)ptr_out = &funcs;
 683     return STATUS_SUCCESS;
 684 }
 685 #endif /* HAVE_LDAP */