[PATCH 4/8] wldap32: Get rid of wldap32.h.
Hans Leidekker
hans at codeweavers.com
Mon Apr 19 03:04:50 CDT 2021
Signed-off-by: Hans Leidekker <hans at codeweavers.com>
---
dlls/wldap32/winldap_private.h | 2 -
dlls/wldap32/wldap32.h | 1010 --------------------------------
2 files changed, 1012 deletions(-)
delete mode 100644 dlls/wldap32/wldap32.h
diff --git a/dlls/wldap32/winldap_private.h b/dlls/wldap32/winldap_private.h
index a59071d50dc..2f5b4dcff72 100644
--- a/dlls/wldap32/winldap_private.h
+++ b/dlls/wldap32/winldap_private.h
@@ -513,7 +513,6 @@ static inline char *strdupU( const char *src )
return dst;
}
-#ifndef HAVE_LDAP
static inline WCHAR *strdupW( const WCHAR *src )
{
WCHAR *dst;
@@ -1525,4 +1524,3 @@ static inline void vlvinfofreeU( LDAPVLVInfoU *info )
RtlFreeHeap( GetProcessHeap(), 0, info->ldvlv_context );
RtlFreeHeap( GetProcessHeap(), 0, info );
}
-#endif
diff --git a/dlls/wldap32/wldap32.h b/dlls/wldap32/wldap32.h
deleted file mode 100644
index 17132ff80c1..00000000000
--- a/dlls/wldap32/wldap32.h
+++ /dev/null
@@ -1,1010 +0,0 @@
-/*
- * WLDAP32 - LDAP support for Wine
- *
- * Copyright 2005 Hans Leidekker
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-#include <assert.h>
-#include "wine/heap.h"
-#include "wine/unicode.h"
-
-extern HINSTANCE hwldap32 DECLSPEC_HIDDEN;
-
-ULONG map_error( int ) DECLSPEC_HIDDEN;
-
-/* A set of helper functions to convert LDAP data structures
- * to and from ansi (A), wide character (W) and utf8 (U) encodings.
- */
-
-#ifdef HAVE_LDAP
-static inline WCHAR *strdupW( const WCHAR *src )
-{
- WCHAR *dst;
- if (!src) return NULL;
- if ((dst = heap_alloc( (strlenW( src ) + 1) * sizeof(WCHAR) ))) strcpyW( dst, src );
- return dst;
-}
-
-static inline LPWSTR strAtoW( LPCSTR str )
-{
- LPWSTR ret = NULL;
- if (str)
- {
- DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
- if ((ret = heap_alloc( len * sizeof(WCHAR) )))
- MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
- }
- return ret;
-}
-
-static inline LPSTR strWtoA( LPCWSTR str )
-{
- LPSTR ret = NULL;
- if (str)
- {
- DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
- if ((ret = heap_alloc( len )))
- WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
- }
- return ret;
-}
-
-static inline char *strWtoU( LPCWSTR str )
-{
- LPSTR ret = NULL;
- if (str)
- {
- DWORD len = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );
- if ((ret = heap_alloc( len )))
- WideCharToMultiByte( CP_UTF8, 0, str, -1, ret, len, NULL, NULL );
- }
- return ret;
-}
-
-static inline LPWSTR strUtoW( char *str )
-{
- LPWSTR ret = NULL;
- if (str)
- {
- DWORD len = MultiByteToWideChar( CP_UTF8, 0, str, -1, NULL, 0 );
- if ((ret = heap_alloc( len * sizeof(WCHAR) )))
- MultiByteToWideChar( CP_UTF8, 0, str, -1, ret, len );
- }
- return ret;
-}
-
-static inline LPWSTR strnAtoW( LPCSTR str, DWORD inlen, DWORD *outlen )
-{
- LPWSTR ret = NULL;
- *outlen = 0;
- if (str)
- {
- DWORD len = MultiByteToWideChar( CP_ACP, 0, str, inlen, NULL, 0 );
- if ((ret = heap_alloc( (len+1) * sizeof(WCHAR) )))
- {
- MultiByteToWideChar( CP_ACP, 0, str, inlen, ret, len );
- ret[len] = 0;
- *outlen = len;
- }
- }
- return ret;
-}
-
-static inline char *strnWtoU( LPCWSTR str, DWORD inlen, DWORD *outlen )
-{
- LPSTR ret = NULL;
- *outlen = 0;
- if (str)
- {
- DWORD len = WideCharToMultiByte( CP_UTF8, 0, str, inlen, NULL, 0, NULL, NULL );
- if ((ret = heap_alloc( len + 1 )))
- {
- WideCharToMultiByte( CP_UTF8, 0, str, inlen, ret, len, NULL, NULL );
- ret[len] = 0;
- *outlen = len;
- }
- }
- return ret;
-}
-
-static inline void strfreeA( LPSTR str )
-{
- heap_free( str );
-}
-
-static inline void strfreeW( LPWSTR str )
-{
- heap_free( str );
-}
-
-static inline void strfreeU( char *str )
-{
- heap_free( str );
-}
-
-static inline DWORD strarraylenA( LPSTR *strarray )
-{
- LPSTR *p = strarray;
- while (*p) p++;
- return p - strarray;
-}
-
-static inline DWORD strarraylenW( LPWSTR *strarray )
-{
- LPWSTR *p = strarray;
- while (*p) p++;
- return p - strarray;
-}
-
-static inline DWORD strarraylenU( char **strarray )
-{
- char **p = strarray;
- while (*p) p++;
- return p - strarray;
-}
-
-static inline LPWSTR *strarrayAtoW( LPSTR *strarray )
-{
- LPWSTR *strarrayW = NULL;
- DWORD size;
-
- if (strarray)
- {
- size = sizeof(WCHAR*) * (strarraylenA( strarray ) + 1);
- if ((strarrayW = heap_alloc( size )))
- {
- LPSTR *p = strarray;
- LPWSTR *q = strarrayW;
-
- while (*p) *q++ = strAtoW( *p++ );
- *q = NULL;
- }
- }
- return strarrayW;
-}
-
-static inline LPSTR *strarrayWtoA( LPWSTR *strarray )
-{
- LPSTR *strarrayA = NULL;
- DWORD size;
-
- if (strarray)
- {
- size = sizeof(LPSTR) * (strarraylenW( strarray ) + 1);
- if ((strarrayA = heap_alloc( size )))
- {
- LPWSTR *p = strarray;
- LPSTR *q = strarrayA;
-
- while (*p) *q++ = strWtoA( *p++ );
- *q = NULL;
- }
- }
- return strarrayA;
-}
-
-static inline char **strarrayWtoU( LPWSTR *strarray )
-{
- char **strarrayU = NULL;
- DWORD size;
-
- if (strarray)
- {
- size = sizeof(char*) * (strarraylenW( strarray ) + 1);
- if ((strarrayU = heap_alloc( size )))
- {
- LPWSTR *p = strarray;
- char **q = strarrayU;
-
- while (*p) *q++ = strWtoU( *p++ );
- *q = NULL;
- }
- }
- return strarrayU;
-}
-
-static inline LPWSTR *strarrayUtoW( char **strarray )
-{
- LPWSTR *strarrayW = NULL;
- DWORD size;
-
- if (strarray)
- {
- size = sizeof(WCHAR*) * (strarraylenU( strarray ) + 1);
- if ((strarrayW = heap_alloc( size )))
- {
- char **p = strarray;
- LPWSTR *q = strarrayW;
-
- while (*p) *q++ = strUtoW( *p++ );
- *q = NULL;
- }
- }
- return strarrayW;
-}
-
-static inline LPWSTR *strarraydupW( LPWSTR *strarray )
-{
- LPWSTR *strarrayW = NULL;
- DWORD size;
-
- if (strarray)
- {
- size = sizeof(WCHAR*) * (strarraylenW( strarray ) + 1);
- if ((strarrayW = heap_alloc( size )))
- {
- LPWSTR *p = strarray;
- LPWSTR *q = strarrayW;
-
- while (*p) *q++ = strdupW( *p++ );
- *q = NULL;
- }
- }
- return strarrayW;
-}
-
-static inline void strarrayfreeW( LPWSTR *strarray )
-{
- if (strarray)
- {
- LPWSTR *p = strarray;
- while (*p) strfreeW( *p++ );
- heap_free( strarray );
- }
-}
-
-static inline void strarrayfreeU( char **strarray )
-{
- if (strarray)
- {
- char **p = strarray;
- while (*p) strfreeU( *p++ );
- heap_free( strarray );
- }
-}
-
-static inline struct WLDAP32_berval *bervalWtoW( struct WLDAP32_berval *bv )
-{
- struct WLDAP32_berval *berval;
- DWORD size = sizeof(*berval) + bv->bv_len;
-
- if ((berval = heap_alloc( size )))
- {
- char *val = (char *)(berval + 1);
-
- berval->bv_len = bv->bv_len;
- berval->bv_val = val;
- memcpy( val, bv->bv_val, bv->bv_len );
- }
- return berval;
-}
-
-static inline void bvarrayfreeW( struct WLDAP32_berval **bv )
-{
- struct WLDAP32_berval **p = bv;
- while (*p) heap_free( *p++ );
- heap_free( bv );
-}
-#endif
-
-static inline void strarrayfreeA( LPSTR *strarray )
-{
- if (strarray)
- {
- LPSTR *p = strarray;
- while (*p) strfreeA( *p++ );
- heap_free( strarray );
- }
-}
-
-#ifdef HAVE_LDAP
-
-static inline struct berval *bervalWtoU( struct WLDAP32_berval *bv )
-{
- struct berval *berval;
- DWORD size = sizeof(*berval) + bv->bv_len;
-
- if ((berval = heap_alloc( size )))
- {
- char *val = (char *)(berval + 1);
-
- berval->bv_len = bv->bv_len;
- berval->bv_val = val;
- memcpy( val, bv->bv_val, bv->bv_len );
- }
- return berval;
-}
-
-static inline struct WLDAP32_berval *bervalUtoW( struct berval *bv )
-{
- struct WLDAP32_berval *berval;
- DWORD size = sizeof(*berval) + bv->bv_len;
-
- assert( bv->bv_len <= ~0u );
-
- if ((berval = heap_alloc( size )))
- {
- char *val = (char *)(berval + 1);
-
- berval->bv_len = bv->bv_len;
- berval->bv_val = val;
- memcpy( val, bv->bv_val, bv->bv_len );
- }
- return berval;
-}
-
-static inline DWORD bvarraylenU( struct berval **bv )
-{
- struct berval **p = bv;
- while (*p) p++;
- return p - bv;
-}
-
-static inline DWORD bvarraylenW( struct WLDAP32_berval **bv )
-{
- struct WLDAP32_berval **p = bv;
- while (*p) p++;
- return p - bv;
-}
-
-static inline struct WLDAP32_berval **bvarrayWtoW( struct WLDAP32_berval **bv )
-{
- struct WLDAP32_berval **berval = NULL;
- DWORD size;
-
- if (bv)
- {
- size = sizeof(*berval) * (bvarraylenW( bv ) + 1);
- if ((berval = heap_alloc( size )))
- {
- struct WLDAP32_berval **p = bv;
- struct WLDAP32_berval **q = berval;
-
- while (*p) *q++ = bervalWtoW( *p++ );
- *q = NULL;
- }
- }
- return berval;
-}
-
-static inline struct berval **bvarrayWtoU( struct WLDAP32_berval **bv )
-{
- struct berval **berval = NULL;
- DWORD size;
-
- if (bv)
- {
- size = sizeof(*berval) * (bvarraylenW( bv ) + 1);
- if ((berval = heap_alloc( size )))
- {
- struct WLDAP32_berval **p = bv;
- struct berval **q = berval;
-
- while (*p) *q++ = bervalWtoU( *p++ );
- *q = NULL;
- }
- }
- return berval;
-}
-
-static inline struct WLDAP32_berval **bvarrayUtoW( struct berval **bv )
-{
- struct WLDAP32_berval **berval = NULL;
- DWORD size;
-
- if (bv)
- {
- size = sizeof(*berval) * (bvarraylenU( bv ) + 1);
- if ((berval = heap_alloc( size )))
- {
- struct berval **p = bv;
- struct WLDAP32_berval **q = berval;
-
- while (*p) *q++ = bervalUtoW( *p++ );
- *q = NULL;
- }
- }
- return berval;
-}
-
-static inline void bvarrayfreeU( struct berval **bv )
-{
- struct berval **p = bv;
- while (*p) heap_free( *p++ );
- heap_free( bv );
-}
-
-static inline LDAPModW *modAtoW( LDAPModA *mod )
-{
- LDAPModW *modW;
-
- if ((modW = heap_alloc( sizeof(LDAPModW) )))
- {
- modW->mod_op = mod->mod_op;
- modW->mod_type = strAtoW( mod->mod_type );
-
- if (mod->mod_op & LDAP_MOD_BVALUES)
- modW->mod_vals.modv_bvals = bvarrayWtoW( mod->mod_vals.modv_bvals );
- else
- modW->mod_vals.modv_strvals = strarrayAtoW( mod->mod_vals.modv_strvals );
- }
- return modW;
-}
-
-static inline LDAPMod *modWtoU( LDAPModW *mod )
-{
- LDAPMod *modU;
-
- if ((modU = heap_alloc( sizeof(LDAPMod) )))
- {
- modU->mod_op = mod->mod_op;
- modU->mod_type = strWtoU( mod->mod_type );
-
- if (mod->mod_op & LDAP_MOD_BVALUES)
- modU->mod_vals.modv_bvals = bvarrayWtoU( mod->mod_vals.modv_bvals );
- else
- modU->mod_vals.modv_strvals = strarrayWtoU( mod->mod_vals.modv_strvals );
- }
- return modU;
-}
-
-static inline void modfreeW( LDAPModW *mod )
-{
- if (mod->mod_op & LDAP_MOD_BVALUES)
- bvarrayfreeW( mod->mod_vals.modv_bvals );
- else
- strarrayfreeW( mod->mod_vals.modv_strvals );
- heap_free( mod );
-}
-
-static inline void modfreeU( LDAPMod *mod )
-{
- if (mod->mod_op & LDAP_MOD_BVALUES)
- bvarrayfreeU( mod->mod_vals.modv_bvals );
- else
- strarrayfreeU( mod->mod_vals.modv_strvals );
- heap_free( mod );
-}
-
-static inline DWORD modarraylenA( LDAPModA **modarray )
-{
- LDAPModA **p = modarray;
- while (*p) p++;
- return p - modarray;
-}
-
-static inline DWORD modarraylenW( LDAPModW **modarray )
-{
- LDAPModW **p = modarray;
- while (*p) p++;
- return p - modarray;
-}
-
-static inline LDAPModW **modarrayAtoW( LDAPModA **modarray )
-{
- LDAPModW **modarrayW = NULL;
- DWORD size;
-
- if (modarray)
- {
- size = sizeof(LDAPModW*) * (modarraylenA( modarray ) + 1);
- if ((modarrayW = heap_alloc( size )))
- {
- LDAPModA **p = modarray;
- LDAPModW **q = modarrayW;
-
- while (*p) *q++ = modAtoW( *p++ );
- *q = NULL;
- }
- }
- return modarrayW;
-}
-
-static inline LDAPMod **modarrayWtoU( LDAPModW **modarray )
-{
- LDAPMod **modarrayU = NULL;
- DWORD size;
-
- if (modarray)
- {
- size = sizeof(LDAPMod*) * (modarraylenW( modarray ) + 1);
- if ((modarrayU = heap_alloc( size )))
- {
- LDAPModW **p = modarray;
- LDAPMod **q = modarrayU;
-
- while (*p) *q++ = modWtoU( *p++ );
- *q = NULL;
- }
- }
- return modarrayU;
-}
-
-static inline void modarrayfreeW( LDAPModW **modarray )
-{
- if (modarray)
- {
- LDAPModW **p = modarray;
- while (*p) modfreeW( *p++ );
- heap_free( modarray );
- }
-}
-
-static inline void modarrayfreeU( LDAPMod **modarray )
-{
- if (modarray)
- {
- LDAPMod **p = modarray;
- while (*p) modfreeU( *p++ );
- heap_free( modarray );
- }
-}
-
-static inline LDAPControlW *controlAtoW( LDAPControlA *control )
-{
- LDAPControlW *controlW;
- DWORD len = control->ldctl_value.bv_len;
- char *val = NULL;
-
- if (control->ldctl_value.bv_val)
- {
- if (!(val = heap_alloc( len ))) return NULL;
- memcpy( val, control->ldctl_value.bv_val, len );
- }
-
- if (!(controlW = heap_alloc( sizeof(LDAPControlW) )))
- {
- heap_free( val );
- return NULL;
- }
-
- controlW->ldctl_oid = strAtoW( control->ldctl_oid );
- controlW->ldctl_value.bv_len = len;
- controlW->ldctl_value.bv_val = val;
- controlW->ldctl_iscritical = control->ldctl_iscritical;
-
- return controlW;
-}
-
-static inline LDAPControlA *controlWtoA( LDAPControlW *control )
-{
- LDAPControlA *controlA;
- DWORD len = control->ldctl_value.bv_len;
- char *val = NULL;
-
- if (control->ldctl_value.bv_val)
- {
- if (!(val = heap_alloc( len ))) return NULL;
- memcpy( val, control->ldctl_value.bv_val, len );
- }
-
- if (!(controlA = heap_alloc( sizeof(LDAPControlA) )))
- {
- heap_free( val );
- return NULL;
- }
-
- controlA->ldctl_oid = strWtoA( control->ldctl_oid );
- controlA->ldctl_value.bv_len = len;
- controlA->ldctl_value.bv_val = val;
- controlA->ldctl_iscritical = control->ldctl_iscritical;
-
- return controlA;
-}
-
-static inline LDAPControl *controlWtoU( LDAPControlW *control )
-{
- LDAPControl *controlU;
- DWORD len = control->ldctl_value.bv_len;
- char *val = NULL;
-
- if (control->ldctl_value.bv_val)
- {
- if (!(val = heap_alloc( len ))) return NULL;
- memcpy( val, control->ldctl_value.bv_val, len );
- }
-
- if (!(controlU = heap_alloc( sizeof(LDAPControl) )))
- {
- heap_free( val );
- return NULL;
- }
-
- controlU->ldctl_oid = strWtoU( control->ldctl_oid );
- controlU->ldctl_value.bv_len = len;
- controlU->ldctl_value.bv_val = val;
- controlU->ldctl_iscritical = control->ldctl_iscritical;
-
- return controlU;
-}
-
-static inline LDAPControlW *controlUtoW( LDAPControl *control )
-{
- LDAPControlW *controlW;
- DWORD len = control->ldctl_value.bv_len;
- char *val = NULL;
-
- if (control->ldctl_value.bv_val)
- {
- if (!(val = heap_alloc( len ))) return NULL;
- memcpy( val, control->ldctl_value.bv_val, len );
- }
-
- if (!(controlW = heap_alloc( sizeof(LDAPControlW) )))
- {
- heap_free( val );
- return NULL;
- }
-
- controlW->ldctl_oid = strUtoW( control->ldctl_oid );
- controlW->ldctl_value.bv_len = len;
- controlW->ldctl_value.bv_val = val;
- controlW->ldctl_iscritical = control->ldctl_iscritical;
-
- return controlW;
-}
-
-static inline LDAPControlW *controldupW( LDAPControlW *control )
-{
- LDAPControlW *controlW;
- DWORD len = control->ldctl_value.bv_len;
- char *val = NULL;
-
- if (control->ldctl_value.bv_val)
- {
- if (!(val = heap_alloc( len ))) return NULL;
- memcpy( val, control->ldctl_value.bv_val, len );
- }
-
- if (!(controlW = heap_alloc( sizeof(LDAPControlW) )))
- {
- heap_free( val );
- return NULL;
- }
-
- controlW->ldctl_oid = strdupW( control->ldctl_oid );
- controlW->ldctl_value.bv_len = len;
- controlW->ldctl_value.bv_val = val;
- controlW->ldctl_iscritical = control->ldctl_iscritical;
-
- return controlW;
-}
-
-static inline void controlfreeA( LDAPControlA *control )
-{
- if (control)
- {
- strfreeA( control->ldctl_oid );
- heap_free( control->ldctl_value.bv_val );
- heap_free( control );
- }
-}
-
-static inline void controlfreeW( LDAPControlW *control )
-{
- if (control)
- {
- strfreeW( control->ldctl_oid );
- heap_free( control->ldctl_value.bv_val );
- heap_free( control );
- }
-}
-
-static inline void controlfreeU( LDAPControl *control )
-{
- if (control)
- {
- strfreeU( control->ldctl_oid );
- heap_free( control->ldctl_value.bv_val );
- heap_free( control );
- }
-}
-
-static inline DWORD controlarraylenA( LDAPControlA **controlarray )
-{
- LDAPControlA **p = controlarray;
- while (*p) p++;
- return p - controlarray;
-}
-
-static inline DWORD controlarraylenW( LDAPControlW **controlarray )
-{
- LDAPControlW **p = controlarray;
- while (*p) p++;
- return p - controlarray;
-}
-
-static inline DWORD controlarraylenU( LDAPControl **controlarray )
-{
- LDAPControl **p = controlarray;
- while (*p) p++;
- return p - controlarray;
-}
-
-static inline LDAPControlW **controlarrayAtoW( LDAPControlA **controlarray )
-{
- LDAPControlW **controlarrayW = NULL;
- DWORD size;
-
- if (controlarray)
- {
- size = sizeof(LDAPControlW*) * (controlarraylenA( controlarray ) + 1);
- if ((controlarrayW = heap_alloc( size )))
- {
- LDAPControlA **p = controlarray;
- LDAPControlW **q = controlarrayW;
-
- while (*p) *q++ = controlAtoW( *p++ );
- *q = NULL;
- }
- }
- return controlarrayW;
-}
-
-static inline LDAPControlA **controlarrayWtoA( LDAPControlW **controlarray )
-{
- LDAPControlA **controlarrayA = NULL;
- DWORD size;
-
- if (controlarray)
- {
- size = sizeof(LDAPControl*) * (controlarraylenW( controlarray ) + 1);
- if ((controlarrayA = heap_alloc( size )))
- {
- LDAPControlW **p = controlarray;
- LDAPControlA **q = controlarrayA;
-
- while (*p) *q++ = controlWtoA( *p++ );
- *q = NULL;
- }
- }
- return controlarrayA;
-}
-
-static inline LDAPControl **controlarrayWtoU( LDAPControlW **controlarray )
-{
- LDAPControl **controlarrayU = NULL;
- DWORD size;
-
- if (controlarray)
- {
- size = sizeof(LDAPControl*) * (controlarraylenW( controlarray ) + 1);
- if ((controlarrayU = heap_alloc( size )))
- {
- LDAPControlW **p = controlarray;
- LDAPControl **q = controlarrayU;
-
- while (*p) *q++ = controlWtoU( *p++ );
- *q = NULL;
- }
- }
- return controlarrayU;
-}
-
-static inline LDAPControlW **controlarrayUtoW( LDAPControl **controlarray )
-{
- LDAPControlW **controlarrayW = NULL;
- DWORD size;
-
- if (controlarray)
- {
- size = sizeof(LDAPControlW*) * (controlarraylenU( controlarray ) + 1);
- if ((controlarrayW = heap_alloc( size )))
- {
- LDAPControl **p = controlarray;
- LDAPControlW **q = controlarrayW;
-
- while (*p) *q++ = controlUtoW( *p++ );
- *q = NULL;
- }
- }
- return controlarrayW;
-}
-
-static inline LDAPControlW **controlarraydupW( LDAPControlW **controlarray )
-{
- LDAPControlW **controlarrayW = NULL;
- DWORD size;
-
- if (controlarray)
- {
- size = sizeof(LDAPControlW*) * (controlarraylenW( controlarray ) + 1);
- if ((controlarrayW = heap_alloc( size )))
- {
- LDAPControlW **p = controlarray;
- LDAPControlW **q = controlarrayW;
-
- while (*p) *q++ = controldupW( *p++ );
- *q = NULL;
- }
- }
- return controlarrayW;
-}
-
-static inline void controlarrayfreeA( LDAPControlA **controlarray )
-{
- if (controlarray)
- {
- LDAPControlA **p = controlarray;
- while (*p) controlfreeA( *p++ );
- heap_free( controlarray );
- }
-}
-
-static inline void controlarrayfreeW( LDAPControlW **controlarray )
-{
- if (controlarray)
- {
- LDAPControlW **p = controlarray;
- while (*p) controlfreeW( *p++ );
- heap_free( controlarray );
- }
-}
-
-static inline void controlarrayfreeU( LDAPControl **controlarray )
-{
- if (controlarray)
- {
- LDAPControl **p = controlarray;
- while (*p) controlfreeU( *p++ );
- heap_free( controlarray );
- }
-}
-
-static inline LDAPSortKeyW *sortkeyAtoW( LDAPSortKeyA *sortkey )
-{
- LDAPSortKeyW *sortkeyW;
-
- if ((sortkeyW = heap_alloc( sizeof(LDAPSortKeyW) )))
- {
- sortkeyW->sk_attrtype = strAtoW( sortkey->sk_attrtype );
- sortkeyW->sk_matchruleoid = strAtoW( sortkey->sk_matchruleoid );
- sortkeyW->sk_reverseorder = sortkey->sk_reverseorder;
- }
- return sortkeyW;
-}
-
-static inline LDAPSortKeyA *sortkeyWtoA( LDAPSortKeyW *sortkey )
-{
- LDAPSortKeyA *sortkeyA;
-
- if ((sortkeyA = heap_alloc( sizeof(LDAPSortKeyA) )))
- {
- sortkeyA->sk_attrtype = strWtoA( sortkey->sk_attrtype );
- sortkeyA->sk_matchruleoid = strWtoA( sortkey->sk_matchruleoid );
- sortkeyA->sk_reverseorder = sortkey->sk_reverseorder;
- }
- return sortkeyA;
-}
-
-static inline LDAPSortKey *sortkeyWtoU( LDAPSortKeyW *sortkey )
-{
- LDAPSortKey *sortkeyU;
-
- if ((sortkeyU = heap_alloc( sizeof(LDAPSortKey) )))
- {
- sortkeyU->attributeType = strWtoU( sortkey->sk_attrtype );
- sortkeyU->orderingRule = strWtoU( sortkey->sk_matchruleoid );
- sortkeyU->reverseOrder = sortkey->sk_reverseorder;
- }
- return sortkeyU;
-}
-
-static inline void sortkeyfreeA( LDAPSortKeyA *sortkey )
-{
- if (sortkey)
- {
- strfreeA( sortkey->sk_attrtype );
- strfreeA( sortkey->sk_matchruleoid );
- heap_free( sortkey );
- }
-}
-
-static inline void sortkeyfreeW( LDAPSortKeyW *sortkey )
-{
- if (sortkey)
- {
- strfreeW( sortkey->sk_attrtype );
- strfreeW( sortkey->sk_matchruleoid );
- heap_free( sortkey );
- }
-}
-
-static inline void sortkeyfreeU( LDAPSortKey *sortkey )
-{
- if (sortkey)
- {
- strfreeU( sortkey->attributeType );
- strfreeU( sortkey->orderingRule );
- heap_free( sortkey );
- }
-}
-
-static inline DWORD sortkeyarraylenA( LDAPSortKeyA **sortkeyarray )
-{
- LDAPSortKeyA **p = sortkeyarray;
- while (*p) p++;
- return p - sortkeyarray;
-}
-
-static inline DWORD sortkeyarraylenW( LDAPSortKeyW **sortkeyarray )
-{
- LDAPSortKeyW **p = sortkeyarray;
- while (*p) p++;
- return p - sortkeyarray;
-}
-
-static inline LDAPSortKeyW **sortkeyarrayAtoW( LDAPSortKeyA **sortkeyarray )
-{
- LDAPSortKeyW **sortkeyarrayW = NULL;
- DWORD size;
-
- if (sortkeyarray)
- {
- size = sizeof(LDAPSortKeyW*) * (sortkeyarraylenA( sortkeyarray ) + 1);
- if ((sortkeyarrayW = heap_alloc( size )))
- {
- LDAPSortKeyA **p = sortkeyarray;
- LDAPSortKeyW **q = sortkeyarrayW;
-
- while (*p) *q++ = sortkeyAtoW( *p++ );
- *q = NULL;
- }
- }
- return sortkeyarrayW;
-}
-
-static inline LDAPSortKey **sortkeyarrayWtoU( LDAPSortKeyW **sortkeyarray )
-{
- LDAPSortKey **sortkeyarrayU = NULL;
- DWORD size;
-
- if (sortkeyarray)
- {
- size = sizeof(LDAPSortKey*) * (sortkeyarraylenW( sortkeyarray ) + 1);
- if ((sortkeyarrayU = heap_alloc( size )))
- {
- LDAPSortKeyW **p = sortkeyarray;
- LDAPSortKey **q = sortkeyarrayU;
-
- while (*p) *q++ = sortkeyWtoU( *p++ );
- *q = NULL;
- }
- }
- return sortkeyarrayU;
-}
-
-static inline void sortkeyarrayfreeW( LDAPSortKeyW **sortkeyarray )
-{
- if (sortkeyarray)
- {
- LDAPSortKeyW **p = sortkeyarray;
- while (*p) sortkeyfreeW( *p++ );
- heap_free( sortkeyarray );
- }
-}
-
-static inline void sortkeyarrayfreeU( LDAPSortKey **sortkeyarray )
-{
- if (sortkeyarray)
- {
- LDAPSortKey **p = sortkeyarray;
- while (*p) sortkeyfreeU( *p++ );
- heap_free( sortkeyarray );
- }
-}
-#endif /* HAVE_LDAP */
--
2.30.2
More information about the wine-devel
mailing list