Signed-off-by: Hans Leidekker hans@codeweavers.com --- dlls/wldap32/ber.c | 348 ++++++++++++++------------------- dlls/wldap32/libldap.c | 260 ++++++++++++++++++++++++ dlls/wldap32/libldap.h | 28 +++ dlls/wldap32/misc.c | 28 ++- dlls/wldap32/winldap_private.h | 22 +++ include/winber.h | 6 + 6 files changed, 477 insertions(+), 215 deletions(-)
diff --git a/dlls/wldap32/ber.c b/dlls/wldap32/ber.c index 7f39b9cfe17..ae5e9292e04 100644 --- a/dlls/wldap32/ber.c +++ b/dlls/wldap32/ber.c @@ -18,24 +18,16 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "config.h" - #include <stdarg.h> -#ifdef HAVE_LDAP_H -#include <ldap.h> -#endif - #include "windef.h" #include "winbase.h" -#include "winldap_private.h" -#include "wldap32.h" +#include "winnls.h" + #include "wine/debug.h" +#include "wine/heap.h" +#include "winldap_private.h"
-#ifdef HAVE_LDAP WINE_DEFAULT_DEBUG_CHANNEL(wldap32); -#endif - -#define WLDAP32_LBER_ERROR (~0U)
/*********************************************************************** * ber_alloc_t (WLDAP32.@) @@ -52,13 +44,17 @@ WINE_DEFAULT_DEBUG_CHANNEL(wldap32); * NOTES * Free the berelement structure with ber_free. */ -WLDAP32_BerElement * CDECL WLDAP32_ber_alloc_t( INT options ) +WLDAP32_BerElement * CDECL WLDAP32_ber_alloc_t( int options ) { -#ifdef HAVE_LDAP - return ber_alloc_t( options ); -#else - return NULL; -#endif + WLDAP32_BerElement *ret; + + if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL; + if (!(ret->opaque = ldap_funcs->ber_alloc_t( options ))) + { + heap_free( ret ); + return NULL; + } + return ret; }
@@ -98,7 +94,7 @@ BERVAL * CDECL WLDAP32_ber_bvdup( BERVAL *berval ) * Use this function only to free an array of berval structures * returned by a call to ber_scanf with a 'V' in the format string. */ -void CDECL WLDAP32_ber_bvecfree( PBERVAL *berval ) +void CDECL WLDAP32_ber_bvecfree( BERVAL **berval ) { bvarrayfreeW( berval ); } @@ -142,26 +138,9 @@ void CDECL WLDAP32_ber_bvfree( BERVAL *berval ) * NOTES * len and cookie should be passed to ber_next_element. */ -ULONG CDECL WLDAP32_ber_first_element( WLDAP32_BerElement *berelement, ULONG *ret_len, CHAR **opaque ) +ULONG CDECL WLDAP32_ber_first_element( WLDAP32_BerElement *ber, ULONG *len, char **opaque ) { -#ifdef HAVE_LDAP - ber_len_t len; - ber_tag_t ret; - - if ((ret = ber_first_element( berelement, &len, opaque )) != LBER_ERROR) - { - if (len > ~0u) - { - ERR( "len too large\n" ); - return WLDAP32_LBER_ERROR; - } - *ret_len = len; - } - return ret; - -#else - return WLDAP32_LBER_ERROR; -#endif + return ldap_funcs->ber_first_element( ber->opaque, len, opaque ); }
@@ -181,23 +160,18 @@ ULONG CDECL WLDAP32_ber_first_element( WLDAP32_BerElement *berelement, ULONG *re * NOTES * Free the berval structure with ber_bvfree. */ -INT CDECL WLDAP32_ber_flatten( WLDAP32_BerElement *berelement, PBERVAL *berval ) +int CDECL WLDAP32_ber_flatten( WLDAP32_BerElement *ber, BERVAL **berval ) { -#ifdef HAVE_LDAP - struct berval *bervalU; + struct bervalU *bervalU; struct WLDAP32_berval *bervalW;
- if (ber_flatten( berelement, &bervalU )) return WLDAP32_LBER_ERROR; + if (ldap_funcs->ber_flatten( ber->opaque, &bervalU )) return WLDAP32_LBER_ERROR;
- bervalW = bervalUtoW( bervalU ); - ber_bvfree( bervalU ); + if (!(bervalW = bervalUtoW( bervalU ))) return WLDAP32_LBER_ERROR; + ldap_funcs->ber_bvfree( bervalU ); if (!bervalW) return WLDAP32_LBER_ERROR; *berval = bervalW; return 0; - -#else - return WLDAP32_LBER_ERROR; -#endif }
@@ -217,11 +191,10 @@ INT CDECL WLDAP32_ber_flatten( WLDAP32_BerElement *berelement, PBERVAL *berval ) * Set buf to 0 if the berelement was allocated with ldap_first_attribute * or ldap_next_attribute, otherwise set it to 1. */ -void CDECL WLDAP32_ber_free( WLDAP32_BerElement *berelement, INT buf ) +void CDECL WLDAP32_ber_free( WLDAP32_BerElement *ber, int freebuf ) { -#ifdef HAVE_LDAP - ber_free( berelement, buf ); -#endif + ldap_funcs->ber_free( ber->opaque, freebuf ); + heap_free( ber ); }
@@ -242,17 +215,22 @@ void CDECL WLDAP32_ber_free( WLDAP32_BerElement *berelement, INT buf ) */ WLDAP32_BerElement * CDECL WLDAP32_ber_init( BERVAL *berval ) { -#ifdef HAVE_LDAP - struct berval *bervalU; + struct bervalU *bervalU; WLDAP32_BerElement *ret;
- if (!(bervalU = bervalWtoU( berval ))) return NULL; - ret = ber_init( bervalU ); + if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL; + if (!(bervalU = bervalWtoU( berval ))) + { + heap_free( ret ); + return NULL; + } + if (!(ret->opaque = ldap_funcs->ber_init( bervalU ))) + { + heap_free( ret ); + ret = NULL; + } heap_free( bervalU ); return ret; -#else - return NULL; -#endif }
@@ -274,26 +252,9 @@ WLDAP32_BerElement * CDECL WLDAP32_ber_init( BERVAL *berval ) * len and cookie are initialized by ber_first_element and should * be passed on in subsequent calls to ber_next_element. */ -ULONG CDECL WLDAP32_ber_next_element( WLDAP32_BerElement *berelement, ULONG *ret_len, CHAR *opaque ) +ULONG CDECL WLDAP32_ber_next_element( WLDAP32_BerElement *ber, ULONG *len, char *opaque ) { -#ifdef HAVE_LDAP - ber_len_t len; - ber_tag_t ret; - - if ((ret = ber_next_element( berelement, &len, opaque )) != LBER_ERROR) - { - if (len > ~0u) - { - ERR( "len too large\n" ); - return WLDAP32_LBER_ERROR; - } - *ret_len = len; - } - return ret; - -#else - return WLDAP32_LBER_ERROR; -#endif + return ldap_funcs->ber_next_element( ber->opaque, len, opaque ); }
@@ -310,26 +271,9 @@ ULONG CDECL WLDAP32_ber_next_element( WLDAP32_BerElement *berelement, ULONG *ret * Success: Tag of the next element. * Failure: LBER_DEFAULT (no more data). */ -ULONG CDECL WLDAP32_ber_peek_tag( WLDAP32_BerElement *berelement, ULONG *ret_len ) +ULONG CDECL WLDAP32_ber_peek_tag( WLDAP32_BerElement *ber, ULONG *len ) { -#ifdef HAVE_LDAP - ber_len_t len; - ber_tag_t ret; - - if ((ret = ber_peek_tag( berelement, &len )) != LBER_ERROR) - { - if (len > ~0u) - { - ERR( "len too large\n" ); - return WLDAP32_LBER_ERROR; - } - *ret_len = len; - } - return ret; - -#else - return WLDAP32_LBER_ERROR; -#endif + return ldap_funcs->ber_peek_tag( ber->opaque, len ); }
@@ -346,26 +290,9 @@ ULONG CDECL WLDAP32_ber_peek_tag( WLDAP32_BerElement *berelement, ULONG *ret_len * Success: Tag of the next element. * Failure: LBER_DEFAULT (no more data). */ -ULONG CDECL WLDAP32_ber_skip_tag( WLDAP32_BerElement *berelement, ULONG *ret_len ) +ULONG CDECL WLDAP32_ber_skip_tag( WLDAP32_BerElement *ber, ULONG *len ) { -#ifdef HAVE_LDAP - ber_len_t len; - ber_tag_t ret; - - if ((ret = ber_skip_tag( berelement, &len )) != LBER_ERROR) - { - if (len > ~0u) - { - ERR( "len too large\n" ); - return WLDAP32_LBER_ERROR; - } - *ret_len = len; - } - return ret; - -#else - return WLDAP32_LBER_ERROR; -#endif + return ldap_funcs->ber_skip_tag( ber->opaque, len ); }
@@ -380,16 +307,15 @@ ULONG CDECL WLDAP32_ber_skip_tag( WLDAP32_BerElement *berelement, ULONG *ret_len * ... [I] Values to encode. * * RETURNS - * Success: Non-negative number. + * Success: Non-negative number. * Failure: LBER_ERROR * * NOTES * berelement must have been allocated with ber_alloc_t. This function * can be called multiple times to append data. */ -INT WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *berelement, PCHAR fmt, ... ) +int WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *ber, char *fmt, ... ) { -#ifdef HAVE_LDAP __ms_va_list list; int ret = 0; char new_fmt[2]; @@ -399,63 +325,64 @@ INT WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *berelement, PCHAR fmt, ... ) while (*fmt) { new_fmt[0] = *fmt++; - switch(new_fmt[0]) + switch (new_fmt[0]) { case 'b': case 'e': case 'i': - { - int i = va_arg( list, int ); - ret = ber_printf( berelement, new_fmt, i ); - break; - } + { + int i = va_arg( list, int ); + ret = ldap_funcs->ber_printf( ber->opaque, new_fmt, i ); + break; + } case 'o': case 's': - { - char *str = va_arg( list, char * ); - ret = ber_printf( berelement, new_fmt, str ); - break; - } + { + char *str = va_arg( list, char * ); + ret = ldap_funcs->ber_printf( ber->opaque, new_fmt, str ); + break; + } case 't': - { - unsigned int tag = va_arg( list, unsigned int ); - ret = ber_printf( berelement, new_fmt, tag ); - break; - } + { + unsigned int tag = va_arg( list, unsigned int ); + ret = ldap_funcs->ber_printf( ber->opaque, new_fmt, tag ); + break; + } case 'v': - { - char **array = va_arg( list, char ** ); - ret = ber_printf( berelement, new_fmt, array ); - break; - } + { + char **array = va_arg( list, char ** ); + ret = ldap_funcs->ber_printf( ber->opaque, new_fmt, array ); + break; + } case 'V': + { + struct WLDAP32_berval **array = va_arg( list, struct WLDAP32_berval ** ); + struct bervalU **arrayU; + if (!(arrayU = bvarrayWtoU( array ))) { - struct WLDAP32_berval **array = va_arg( list, struct WLDAP32_berval ** ); - struct berval **arrayU; - if (!(arrayU = bvarrayWtoU( array ))) - { - ret = -1; - break; - } - ret = ber_printf( berelement, new_fmt, arrayU ); - bvarrayfreeU( arrayU ); + ret = -1; break; } + ret = ldap_funcs->ber_printf( ber->opaque, new_fmt, arrayU ); + bvarrayfreeU( arrayU ); + break; + } case 'X': - { - char *str = va_arg( list, char * ); - int len = va_arg( list, int ); - new_fmt[0] = 'B'; /* 'X' is deprecated */ - ret = ber_printf( berelement, new_fmt, str, len ); - break; - } + { + char *str = va_arg( list, char * ); + int len = va_arg( list, int ); + new_fmt[0] = 'B'; /* 'X' is deprecated */ + ret = ldap_funcs->ber_printf( ber->opaque, new_fmt, str, len ); + break; + } case 'n': case '{': case '}': case '[': case ']': - ret = ber_printf( berelement, new_fmt ); + ret = ldap_funcs->ber_printf( ber->opaque, new_fmt ); break; + default: FIXME( "Unknown format '%c'\n", new_fmt[0] ); ret = -1; @@ -465,9 +392,6 @@ INT WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *berelement, PCHAR fmt, ... ) } __ms_va_end( list ); return ret; -#else - return WLDAP32_LBER_ERROR; -#endif }
@@ -482,16 +406,15 @@ INT WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *berelement, PCHAR fmt, ... ) * ... [I] Pointers to values to be decoded. * * RETURNS - * Success: Non-negative number. + * Success: Non-negative number. * Failure: LBER_ERROR * * NOTES * berelement must have been allocated with ber_init. This function * can be called multiple times to decode data. */ -INT WINAPIV WLDAP32_ber_scanf( WLDAP32_BerElement *berelement, PCHAR fmt, ... ) +int WINAPIV WLDAP32_ber_scanf( WLDAP32_BerElement *ber, char *fmt, ... ) { -#ifdef HAVE_LDAP __ms_va_list list; int ret = 0; char new_fmt[2]; @@ -501,65 +424,81 @@ INT WINAPIV WLDAP32_ber_scanf( WLDAP32_BerElement *berelement, PCHAR fmt, ... ) while (*fmt) { new_fmt[0] = *fmt++; - switch(new_fmt[0]) + switch (new_fmt[0]) { case 'a': - { - char **ptr = va_arg( list, char ** ); - ret = ber_scanf( berelement, new_fmt, ptr ); - break; - } + { + char *str, **ptr = va_arg( list, char ** ); + if ((ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt, &str )) == -1) break; + *ptr = strdupU( str ); + ldap_funcs->ldap_memfree( str ); + break; + } case 'b': case 'e': case 'i': - { - int *i = va_arg( list, int * ); - ret = ber_scanf( berelement, new_fmt, i ); - break; - } + { + int *i = va_arg( list, int * ); + ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt, i ); + break; + } case 't': - { - unsigned int *tag = va_arg( list, unsigned int * ); - ret = ber_scanf( berelement, new_fmt, tag ); - break; - } + { + unsigned int *tag = va_arg( list, unsigned int * ); + ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt, tag ); + break; + } case 'v': + { + char *str, **arrayU, **ptr, ***array = va_arg( list, char *** ); + if ((ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt, &arrayU )) == -1) break; + *array = strarrayUtoU( arrayU ); + ptr = arrayU; + while ((str = *ptr)) { - char ***array = va_arg( list, char *** ); - ret = ber_scanf( berelement, new_fmt, array ); - break; + ldap_funcs->ldap_memfree( str ); + ptr++; } + ldap_funcs->ldap_memfree( arrayU ); + break; + } case 'B': - { - char **str = va_arg( list, char ** ); - int *len = va_arg( list, int * ); - ret = ber_scanf( berelement, new_fmt, str, len ); - break; - } + { + char *strU, **str = va_arg( list, char ** ); + int *len = va_arg( list, int * ); + if ((ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt, &strU, len )) == -1) break; + *str = heap_alloc( *len ); + memcpy( *str, strU, *len ); + ldap_funcs->ldap_memfree( strU ); + break; + } case 'O': - { - struct berval **ptr = va_arg( list, struct berval ** ); - ret = ber_scanf( berelement, new_fmt, ptr ); - break; - } + { + struct WLDAP32_berval **berval = va_arg( list, struct WLDAP32_berval ** ); + struct bervalU *bervalU; + if ((ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt, &bervalU )) == -1) break; + *berval = bervalUtoW( bervalU ); + ldap_funcs->ber_bvfree( bervalU ); + break; + } case 'V': - { - struct WLDAP32_berval **arrayW, ***array = va_arg( list, struct WLDAP32_berval *** ); - struct berval **arrayU; - if ((ret = ber_scanf( berelement, new_fmt, &arrayU )) == -1) break; - if ((arrayW = bvarrayUtoW( arrayU ))) *array = arrayW; - else ret = -1; - bvarrayfreeU( arrayU ); - break; - } + { + struct WLDAP32_berval ***array = va_arg( list, struct WLDAP32_berval *** ); + struct bervalU **arrayU; + if ((ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt, &arrayU )) == -1) break; + *array = bvarrayUtoW( arrayU ); + ldap_funcs->ber_bvecfree( arrayU ); + break; + } case 'n': case 'x': case '{': case '}': case '[': case ']': - ret = ber_scanf( berelement, new_fmt ); + ret = ldap_funcs->ber_scanf( ber->opaque, new_fmt ); break; + default: FIXME( "Unknown format '%c'\n", new_fmt[0] ); ret = -1; @@ -569,7 +508,4 @@ INT WINAPIV WLDAP32_ber_scanf( WLDAP32_BerElement *berelement, PCHAR fmt, ... ) } __ms_va_end( list ); return ret; -#else - return WLDAP32_LBER_ERROR; -#endif } diff --git a/dlls/wldap32/libldap.c b/dlls/wldap32/libldap.c index 0372206062a..3436cffc4a1 100644 --- a/dlls/wldap32/libldap.c +++ b/dlls/wldap32/libldap.c @@ -42,6 +42,8 @@ #include "wine/debug.h" #include "winldap_private.h"
+WINE_DEFAULT_DEBUG_CHANNEL(wldap32); + C_ASSERT( sizeof(BerValueU) == sizeof(BerValue) ); C_ASSERT( sizeof(LDAPModU) == sizeof(LDAPMod) ); C_ASSERT( sizeof(LDAPControlU) == sizeof(LDAPControl) ); @@ -50,6 +52,246 @@ C_ASSERT( sizeof(LDAPVLVInfoU) == sizeof(LDAPVLVInfo) );
static LDAPMod *nullattrs[] = { NULL };
+void * CDECL wrap_ber_alloc_t( int options ) +{ + return ber_alloc_t( options ); +} + +void CDECL wrap_ber_bvecfree( struct bervalU **berval ) +{ + ber_bvecfree( (struct berval **)berval ); +} + +void CDECL wrap_ber_bvfree( struct bervalU *berval ) +{ + ber_bvfree( (struct berval *)berval ); +} + +unsigned int CDECL wrap_ber_first_element( void *ber, ULONG *ret_len, char **last ) +{ + ber_len_t len; + ber_tag_t ret; + + if ((ret = ber_first_element( ber, &len, last )) == LBER_ERROR) return WLDAP32_LBER_ERROR; + if (ret > ~0u) + { + ERR( "ret too large\n" ); + return WLDAP32_LBER_ERROR; + } + if (len > ~0u) + { + ERR( "len too large\n" ); + return WLDAP32_LBER_ERROR; + } + + *ret_len = len; + return ret; +} + +int CDECL wrap_ber_flatten( void *ber, struct bervalU **berval ) +{ + return ber_flatten( ber, (struct berval **)berval ); +} + +void CDECL wrap_ber_free( void *ber, int freebuf ) +{ + ber_free( ber, freebuf ); +} + +void * CDECL wrap_ber_init( struct bervalU *berval ) +{ + return ber_init( (struct berval *)berval ); +} + +unsigned int CDECL wrap_ber_next_element( void *ber, unsigned int *ret_len, char *last ) +{ + ber_len_t len; + ber_tag_t ret; + + if ((ret = ber_next_element( ber, &len, last )) == LBER_ERROR) return WLDAP32_LBER_ERROR; + if (ret > ~0u) + { + ERR( "ret too large\n" ); + return WLDAP32_LBER_ERROR; + } + if (len > ~0u) + { + ERR( "len too large\n" ); + return WLDAP32_LBER_ERROR; + } + + *ret_len = len; + return ret; +} + +unsigned int CDECL wrap_ber_peek_tag( void *ber, unsigned int *ret_len ) +{ + ber_len_t len; + ber_tag_t ret; + + if ((ret = ber_peek_tag( ber, &len )) == LBER_ERROR) return WLDAP32_LBER_ERROR; + if (len > ~0u) + { + ERR( "len too large\n" ); + return WLDAP32_LBER_ERROR; + } + + *ret_len = len; + return ret; +} + +unsigned int CDECL wrap_ber_skip_tag( void *ber, unsigned int *ret_len ) +{ + ber_len_t len; + ber_tag_t ret; + + if ((ret = ber_skip_tag( ber, &len )) == LBER_ERROR) return WLDAP32_LBER_ERROR; + if (len > ~0u) + { + ERR( "len too large\n" ); + return WLDAP32_LBER_ERROR; + } + + *ret_len = len; + return ret; +} + +int WINAPIV wrap_ber_printf( void *ber, char *fmt, ... ) +{ + int ret; + __ms_va_list args; + + assert( strlen(fmt) == 1 ); + + __ms_va_start( args, fmt ); + switch (fmt[0]) + { + case 'b': + case 'e': + case 'i': + { + int i = va_arg( args, int ); + ret = ber_printf( ber, fmt, i ); + break; + } + case 'o': + case 's': + { + char *str = va_arg( args, char * ); + ret = ber_printf( ber, fmt, str ); + break; + } + case 't': + { + unsigned int tag = va_arg( args, unsigned int ); + ret = ber_printf( ber, fmt, tag ); + break; + } + case 'v': + { + char **array = va_arg( args, char ** ); + ret = ber_printf( ber, fmt, array ); + break; + } + case 'V': + { + struct berval **array = va_arg( args, struct berval ** ); + ret = ber_printf( ber, fmt, array ); + break; + } + case 'B': + { + char *str = va_arg( args, char * ); + int len = va_arg( args, int ); + ret = ber_printf( ber, fmt, str, len ); + break; + } + case 'n': + case '{': + case '}': + case '[': + case ']': + ret = ber_printf( ber, fmt ); + break; + + default: + assert( 0 ); + } + __ms_va_end( args ); + return ret; +} + +int WINAPIV wrap_ber_scanf( void *ber, char *fmt, ... ) +{ + int ret; + __ms_va_list args; + + assert( strlen(fmt) == 1 ); + + __ms_va_start( args, fmt ); + switch (fmt[0]) + { + case 'a': + { + char **str = va_arg( args, char ** ); + ret = ber_scanf( ber, fmt, str ); + break; + } + case 'b': + case 'e': + case 'i': + { + int *i = va_arg( args, int * ); + ret = ber_scanf( ber, fmt, i ); + break; + } + case 't': + { + unsigned int *tag = va_arg( args, unsigned int * ); + ret = ber_scanf( ber, fmt, tag ); + break; + } + case 'v': + { + char ***array = va_arg( args, char *** ); + ret = ber_scanf( ber, fmt, array ); + break; + } + case 'B': + { + char **str = va_arg( args, char ** ); + int *len = va_arg( args, int * ); + ret = ber_scanf( ber, fmt, str, len ); + break; + } + case 'O': + { + struct berval **berval = va_arg( args, struct berval ** ); + ret = ber_scanf( ber, fmt, berval ); + break; + } + case 'V': + { + struct berval ***array = va_arg( args, struct berval *** ); + ret = ber_scanf( ber, fmt, array ); + break; + } + case 'n': + case 'x': + case '{': + case '}': + case '[': + case ']': + ret = ber_scanf( ber, fmt ); + break; + + default: + assert( 0 ); + } + __ms_va_end( args ); + return ret; +} + int CDECL wrap_ldap_add_ext( void *ld, char *dn, LDAPModU **attrs, LDAPControlU **serverctrls, LDAPControlU **clientctrls, ULONG *msg ) { @@ -65,10 +307,28 @@ int CDECL wrap_ldap_add_ext_s( void *ld, char *dn, LDAPModU **attrs, LDAPControl (LDAPControl **)clientctrls ); }
+void CDECL wrap_ldap_memfree( void *ptr ) +{ + return ldap_memfree( ptr ); +} + static const struct ldap_funcs funcs = { + wrap_ber_alloc_t, + wrap_ber_bvecfree, + wrap_ber_bvfree, + wrap_ber_first_element, + wrap_ber_flatten, + wrap_ber_free, + wrap_ber_init, + wrap_ber_next_element, + wrap_ber_peek_tag, + wrap_ber_skip_tag, + wrap_ber_printf, + wrap_ber_scanf, wrap_ldap_add_ext, wrap_ldap_add_ext_s, + wrap_ldap_memfree, };
NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out ) diff --git a/dlls/wldap32/libldap.h b/dlls/wldap32/libldap.h index d9d833cdcb8..4ca90d298a0 100644 --- a/dlls/wldap32/libldap.h +++ b/dlls/wldap32/libldap.h @@ -60,13 +60,41 @@ typedef struct void *ldvlv_extradata; } LDAPVLVInfoU;
+extern void * CDECL wrap_ber_alloc_t(int) DECLSPEC_HIDDEN; +extern void CDECL wrap_ber_bvecfree(struct bervalU **) DECLSPEC_HIDDEN; +extern void CDECL wrap_ber_bvfree(struct bervalU *) DECLSPEC_HIDDEN; +extern unsigned int CDECL wrap_ber_first_element(void *, unsigned int *, char **) DECLSPEC_HIDDEN; +extern int CDECL wrap_ber_flatten(void *, struct bervalU **) DECLSPEC_HIDDEN; +extern void CDECL wrap_ber_free(void *, int) DECLSPEC_HIDDEN; +extern void * CDECL wrap_ber_init(struct bervalU *) DECLSPEC_HIDDEN; +extern unsigned int CDECL wrap_ber_next_element(void *, unsigned int *, char *) DECLSPEC_HIDDEN; +extern unsigned int CDECL wrap_ber_peek_tag(void *, unsigned int *) DECLSPEC_HIDDEN; +extern unsigned int CDECL wrap_ber_skip_tag(void *, unsigned int *) DECLSPEC_HIDDEN; +extern int WINAPIV wrap_ber_printf(void *, char *, ...) DECLSPEC_HIDDEN; +extern int WINAPIV wrap_ber_scanf(void *, char *, ...) DECLSPEC_HIDDEN; + extern int CDECL wrap_ldap_add_ext(void *, char *, LDAPModU **, LDAPControlU **, LDAPControlU **, ULONG *) DECLSPEC_HIDDEN; extern int CDECL wrap_ldap_add_ext_s(void *, char *, LDAPModU **, LDAPControlU **, LDAPControlU **) DECLSPEC_HIDDEN; +extern void CDECL wrap_ldap_memfree(void *) DECLSPEC_HIDDEN;
struct ldap_funcs { + void * (CDECL *ber_alloc_t)(int); + void (CDECL *ber_bvecfree)(struct bervalU **); + void (CDECL *ber_bvfree)(struct bervalU *); + unsigned int (CDECL *ber_first_element)(void *, unsigned int *, char **); + int (CDECL *ber_flatten)(void *, struct bervalU **); + void (CDECL *ber_free)(void *, int); + void * (CDECL *ber_init)(struct bervalU *); + unsigned int (CDECL *ber_next_element)(void *, unsigned int *, char *); + unsigned int (CDECL *ber_peek_tag)(void *, unsigned int *); + unsigned int (CDECL *ber_skip_tag)(void *, unsigned int *); + int (WINAPIV *ber_printf)(void *, char *, ...); + int (WINAPIV *ber_scanf)(void *, char *, ...); + int (CDECL *ldap_add_ext)(void *, char *, LDAPModU **, LDAPControlU **, LDAPControlU **, ULONG *); int (CDECL *ldap_add_ext_s)(void *, char *, LDAPModU **, LDAPControlU **, LDAPControlU **); + void (CDECL *ldap_memfree)(void *); };
extern const struct ldap_funcs *ldap_funcs; diff --git a/dlls/wldap32/misc.c b/dlls/wldap32/misc.c index 39642960955..dd1a1ef3f12 100644 --- a/dlls/wldap32/misc.c +++ b/dlls/wldap32/misc.c @@ -328,15 +328,22 @@ PWCHAR CDECL ldap_first_attributeW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry { PWCHAR ret = NULL; #ifdef HAVE_LDAP + BerElement *berU; char *retU;
TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
if (!ld || !entry) return NULL; - retU = ldap_first_attribute( ld->ld, entry, ptr );
- ret = strUtoW( retU ); - ldap_memfree( retU ); + retU = ldap_first_attribute( ld->ld, entry, &berU ); + if (retU) + { + WLDAP32_BerElement *ber = heap_alloc( sizeof(*ber) ); + ber->opaque = (char *)berU; + *ptr = ber; + ret = strUtoW( retU ); + ldap_memfree( retU ); + }
#endif return ret; @@ -487,19 +494,22 @@ PCHAR CDECL ldap_next_attributeA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry, * When done iterating and when ptr != NULL, call ber_free( ptr, 0 ). */ PWCHAR CDECL ldap_next_attributeW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry, - WLDAP32_BerElement *ptr ) + WLDAP32_BerElement *ber ) { PWCHAR ret = NULL; #ifdef HAVE_LDAP char *retU;
- TRACE( "(%p, %p, %p)\n", ld, entry, ptr ); + TRACE( "(%p, %p, %p)\n", ld, entry, ber );
- if (!ld || !entry || !ptr) return NULL; - retU = ldap_next_attribute( ld->ld, entry, ptr ); + if (!ld || !entry) return NULL;
- ret = strUtoW( retU ); - ldap_memfree( retU ); + retU = ldap_next_attribute( ld->ld, entry, (BerElement *)ber->opaque ); + if (retU) + { + ret = strUtoW( retU ); + ldap_memfree( retU ); + }
#endif return ret; diff --git a/dlls/wldap32/winldap_private.h b/dlls/wldap32/winldap_private.h index d0583c61f50..22e981cb26d 100644 --- a/dlls/wldap32/winldap_private.h +++ b/dlls/wldap32/winldap_private.h @@ -27,6 +27,8 @@ #include "winnls.h" #include "libldap.h"
+#define WLDAP32_LBER_ERROR (~0L) + typedef enum { WLDAP32_LDAP_SUCCESS = 0x00, WLDAP32_LDAP_UNWILLING_TO_PERFORM = 0x35, @@ -1187,6 +1189,26 @@ static inline WCHAR **strarrayUtoW( char **strarray ) return strarrayW; }
+static inline char **strarrayUtoU( char **strarray ) +{ + char **strarrayU = NULL; + DWORD size; + + if (strarray) + { + size = sizeof(char *) * (strarraylenU( strarray ) + 1); + if ((strarrayU = RtlAllocateHeap( GetProcessHeap(), 0, size ))) + { + char **p = strarray; + char **q = strarrayU; + + while (*p) *q++ = strdupU( *p++ ); + *q = NULL; + } + } + return strarrayU; +} + static inline LDAPControlW *controlUtoW( const LDAPControlU *control ) { LDAPControlW *controlW; diff --git a/include/winber.h b/include/winber.h index 40ab0f40ed8..372cc321269 100644 --- a/include/winber.h +++ b/include/winber.h @@ -27,11 +27,17 @@ typedef unsigned int ber_tag_t; typedef unsigned int ber_len_t;
BerElement * CDECL ber_alloc_t( int ); +BERVAL * CDECL ber_bvdup( BERVAL * ); +void CDECL ber_bvecfree( BERVAL ** ); void CDECL ber_bvfree( BERVAL * ); +ULONG CDECL ber_first_element( BerElement *, ULONG *, char ** ); int CDECL ber_flatten( BerElement *, BERVAL ** ); void CDECL ber_free( BerElement *, int ); BerElement * CDECL ber_init( BERVAL * ); +ULONG CDECL ber_next_element( BerElement *, ULONG *, char ** ); +ULONG CDECL ber_peek_tag( BerElement *, ULONG * ); int WINAPIV ber_printf( BerElement *, char *, ... ); ULONG WINAPIV ber_scanf( BerElement *, char *, ... ); +ULONG CDECL ber_skip_tag( BerElement *, ULONG * );
#endif /* __WINE_WINBER_H */