winldap_private.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	berelement
struct	ldap
struct	ldapmodA
struct	ldapmodW
struct	l_timeval
struct	ldapmsg
struct	ldap_version_info
struct	WLDAP32_berval
struct	ldapcontrolA
struct	ldapcontrolW
struct	WLDAP32_ldapvlvinfo
struct	ldapsortkeyA
struct	ldapsortkeyW
struct	ldapapiinfoA
struct	ldapapiinfoW
struct	ldap_apifeature_infoA
struct	ldap_apifeature_infoW

Macros
#define	WLDAP32_LDAP_OPT_API_INFO   0x00
#define	WLDAP32_LDAP_OPT_DESC   0x01
#define	WLDAP32_LDAP_OPT_DEREF   0x02
#define	WLDAP32_LDAP_OPT_SIZELIMIT   0x03
#define	WLDAP32_LDAP_OPT_TIMELIMIT   0x04
#define	WLDAP32_LDAP_OPT_THREAD_FN_PTRS   0x05
#define	WLDAP32_LDAP_OPT_REBIND_FN   0x06
#define	WLDAP32_LDAP_OPT_REBIND_ARG   0x07
#define	WLDAP32_LDAP_OPT_REFERRALS   0x08
#define	WLDAP32_LDAP_OPT_RESTART   0x09
#define	WLDAP32_LDAP_OPT_SSL   0x0a
#define	WLDAP32_LDAP_OPT_IO_FN_PTRS   0x0b
#define	WLDAP32_LDAP_OPT_CACHE_FN_PTRS   0x0d
#define	WLDAP32_LDAP_OPT_CACHE_STRATEGY   0x0e
#define	WLDAP32_LDAP_OPT_CACHE_ENABLE   0x0f
#define	WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT   0x10
#define	WLDAP32_LDAP_OPT_VERSION   0x11
#define	WLDAP32_LDAP_OPT_PROTOCOL_VERSION   WLDAP32_LDAP_OPT_VERSION
#define	WLDAP32_LDAP_OPT_SERVER_CONTROLS   0x12
#define	WLDAP32_LDAP_OPT_API_FEATURE_INFO   0x15
#define	WLDAP32_LDAP_OPT_HOST_NAME   0x30
#define	WLDAP32_LDAP_OPT_ERROR_NUMBER   0x31
#define	WLDAP32_LDAP_OPT_ERROR_STRING   0x32
#define	WLDAP32_LDAP_OPT_SERVER_ERROR   0x33
#define	WLDAP32_LDAP_OPT_SERVER_EXT_ERROR   0x34
#define	WLDAP32_LDAP_OPT_PING_KEEP_ALIVE   0x36
#define	WLDAP32_LDAP_OPT_PING_WAIT_TIME   0x37
#define	WLDAP32_LDAP_OPT_PING_LIMIT   0x38
#define	WLDAP32_LDAP_OPT_DNSDOMAIN_NAME   0x3b
#define	WLDAP32_LDAP_OPT_GETDSNAME_FLAGS   0x3d
#define	WLDAP32_LDAP_OPT_HOST_REACHABLE   0x3e
#define	WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS   0x3f
#define	WLDAP32_LDAP_OPT_TCP_KEEPALIVE   0x40
#define	WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND   0x41
#define	WLDAP32_LDAP_OPT_SEND_TIMEOUT   0x42
#define	WLDAP32_LDAP_OPT_REFERRAL_CALLBACK   0x70
#define	WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE   0x80
#define	WLDAP32_LDAP_OPT_SERVER_CERTIFICATE   0x81
#define	WLDAP32_LDAP_OPT_AUTO_RECONNECT   0x91
#define	WLDAP32_LDAP_OPT_SSPI_FLAGS   0x92
#define	WLDAP32_LDAP_OPT_SSL_INFO   0x93
#define	WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG   0x94
#define	WLDAP32_LDAP_OPT_TLS   WLDAP32_LDAP_OPT_SSL
#define	WLDAP32_LDAP_OPT_TLS_INFO   WLDAP32_LDAP_OPT_SSL_INFO
#define	WLDAP32_LDAP_OPT_SIGN   0x95
#define	WLDAP32_LDAP_OPT_ENCRYPT   0x96
#define	WLDAP32_LDAP_OPT_SASL_METHOD   0x97
#define	WLDAP32_LDAP_OPT_AREC_EXCLUSIVE   0x98
#define	WLDAP32_LDAP_OPT_SECURITY_CONTEXT   0x99
#define	WLDAP32_LDAP_OPT_ROOTDSE_CACHE   0x9a
#define	LAPI_MAJOR_VER1   1
#define	LAPI_MINOR_VER1   1
#define	LDAP_PAGED_RESULT_OID_STRING   "1.2.840.113556.1.4.319"
#define	LDAP_SERVER_RESP_SORT_OID   "1.2.840.113556.1.4.474"
#define	LDAP_CONTROL_VLVRESPONSE   "2.16.840.1.113730.3.4.10"

Typedefs
typedef struct berelement	WLDAP32_BerElement
typedef struct ldap	WLDAP32_LDAP
typedef struct ldap *	WLDAP32_PLDAP
typedef struct ldapmodA	LDAPModA
typedef struct ldapmodA *	PLDAPModA
typedef struct ldapmodW	LDAPModW
typedef struct ldapmodW *	PLDAPModW
typedef struct l_timeval	LDAP_TIMEVAL
typedef struct l_timeval *	PLDAP_TIMEVAL
typedef struct ldapmsg	WLDAP32_LDAPMessage
typedef struct ldapmsg *	WLDAP32_PLDAPMessage
typedef struct ldap_version_info	LDAP_VERSION_INFO
typedef struct ldap_version_info *	PLDAP_VERSION_INFO
typedef struct WLDAP32_berval	LDAP_BERVAL
typedef struct WLDAP32_berval *	PLDAP_BERVAL
typedef struct WLDAP32_berval	BERVAL
typedef struct WLDAP32_berval *	PBERVAL
typedef struct WLDAP32_berval	WLDAP32_BerValue
typedef struct ldapcontrolA	LDAPControlA
typedef struct ldapcontrolA *	PLDAPControlA
typedef struct ldapcontrolW	LDAPControlW
typedef struct ldapcontrolW *	PLDAPControlW
typedef struct WLDAP32_ldapvlvinfo	WLDAP32_LDAPVLVInfo
typedef struct WLDAP32_ldapvlvinfo *	WLDAP32_PLDAPVLVInfo
typedef struct ldapsearch	LDAPSearch
typedef struct ldapsearch *	PLDAPSearch
typedef struct ldapsortkeyA	LDAPSortKeyA
typedef struct ldapsortkeyA *	PLDAPSortKeyA
typedef struct ldapsortkeyW	LDAPSortKeyW
typedef struct ldapsortkeyW *	PLDAPSortKeyW
typedef struct ldapapiinfoA	LDAPAPIInfoA
typedef struct ldapapiinfoW	LDAPAPIInfoW
typedef struct ldap_apifeature_infoA	LDAPAPIFeatureInfoA
typedef struct ldap_apifeature_infoW	LDAPAPIFeatureInfoW

Enumerations
enum	LDAP_RETCODE {   WLDAP32_LDAP_SUCCESS = 0x00 , WLDAP32_LDAP_UNWILLING_TO_PERFORM = 0x35 , WLDAP32_LDAP_SERVER_DOWN = 0x51 , WLDAP32_LDAP_LOCAL_ERROR = 0x52 ,   WLDAP32_LDAP_ENCODING_ERROR = 0x53 , WLDAP32_LDAP_DECODING_ERROR = 0x54 , WLDAP32_LDAP_TIMEOUT = 0x55 , WLDAP32_LDAP_AUTH_UNKNOWN = 0x56 ,   WLDAP32_LDAP_FILTER_ERROR = 0x57 , WLDAP32_LDAP_USER_CANCELLED = 0x58 , WLDAP32_LDAP_PARAM_ERROR = 0x59 , WLDAP32_LDAP_NO_MEMORY = 0x5a ,   WLDAP32_LDAP_CONNECT_ERROR = 0x5b , WLDAP32_LDAP_NOT_SUPPORTED = 0x5c , WLDAP32_LDAP_NO_RESULTS_RETURNED = 0x5e , WLDAP32_LDAP_CONTROL_NOT_FOUND = 0x5d ,   WLDAP32_LDAP_MORE_RESULTS_TO_RETURN = 0x5f , WLDAP32_LDAP_CLIENT_LOOP = 0x60 , WLDAP32_LDAP_REFERRAL_LIMIT_EXCEEDED = 0x61 }

Functions
WLDAP32_LDAP *CDECL	cldap_openA (PCHAR, ULONG)
WLDAP32_LDAP *CDECL	cldap_openW (PWCHAR, ULONG)
ULONG CDECL	WLDAP32_ldap_abandon (WLDAP32_LDAP *, ULONG)
ULONG CDECL	ldap_addA (WLDAP32_LDAP *, PCHAR, LDAPModA *[])
ULONG CDECL	ldap_addW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[])
ULONG CDECL	ldap_add_extA (WLDAP32_LDAP *, PCHAR, LDAPModA *[], PLDAPControlA *, PLDAPControlA *, ULONG *)
ULONG CDECL	ldap_add_extW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[], PLDAPControlW *, PLDAPControlW *, ULONG *)
ULONG CDECL	ldap_add_ext_sA (WLDAP32_LDAP *, PCHAR, LDAPModA *[], PLDAPControlA *, PLDAPControlA *)
ULONG CDECL	ldap_add_ext_sW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[], PLDAPControlW *, PLDAPControlW *)
ULONG CDECL	ldap_add_sA (WLDAP32_LDAP *, PCHAR, LDAPModA *[])
ULONG CDECL	ldap_add_sW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[])
ULONG CDECL	ldap_bindA (WLDAP32_LDAP *, PCHAR, PCHAR, ULONG)
ULONG CDECL	ldap_bindW (WLDAP32_LDAP *, PWCHAR, PWCHAR, ULONG)
ULONG CDECL	ldap_bind_sA (WLDAP32_LDAP *, PCHAR, PCHAR, ULONG)
ULONG CDECL	ldap_bind_sW (WLDAP32_LDAP *, PWCHAR, PWCHAR, ULONG)
ULONG CDECL	ldap_check_filterA (WLDAP32_LDAP *, PCHAR)
ULONG CDECL	ldap_check_filterW (WLDAP32_LDAP *, PWCHAR)
ULONG CDECL	ldap_cleanup (HANDLE)
ULONG CDECL	ldap_close_extended_op (WLDAP32_LDAP *, ULONG)
ULONG CDECL	ldap_compareA (WLDAP32_LDAP *, PCHAR, PCHAR, PCHAR)
ULONG CDECL	ldap_compareW (WLDAP32_LDAP *, PWCHAR, PWCHAR, PWCHAR)
ULONG CDECL	ldap_compare_extA (WLDAP32_LDAP *, PCHAR, PCHAR, PCHAR, struct WLDAP32_berval *, PLDAPControlA *, PLDAPControlA *, ULONG *)
ULONG CDECL	ldap_compare_extW (WLDAP32_LDAP *, PWCHAR, PWCHAR, PWCHAR, struct WLDAP32_berval *, PLDAPControlW *, PLDAPControlW *, ULONG *)
ULONG CDECL	ldap_compare_ext_sA (WLDAP32_LDAP *, PCHAR, PCHAR, PCHAR, struct WLDAP32_berval *, PLDAPControlA *, PLDAPControlA *)
ULONG CDECL	ldap_compare_ext_sW (WLDAP32_LDAP *, PWCHAR, PWCHAR, PWCHAR, struct WLDAP32_berval *, PLDAPControlW *, PLDAPControlW *)
ULONG CDECL	ldap_compare_sA (WLDAP32_LDAP *, PCHAR, PCHAR, PCHAR)
ULONG CDECL	ldap_compare_sW (WLDAP32_LDAP *, PWCHAR, PWCHAR, PWCHAR)
ULONG CDECL	ldap_connect (WLDAP32_LDAP *, LDAP_TIMEVAL *)
WLDAP32_LDAP *CDECL	ldap_conn_from_msg (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
ULONG CDECL	ldap_control_freeA (LDAPControlA *)
ULONG CDECL	ldap_control_freeW (LDAPControlW *)
ULONG CDECL	ldap_controls_freeA (LDAPControlA **)
ULONG CDECL	ldap_controls_freeW (LDAPControlW **)
ULONG CDECL	WLDAP32_ldap_count_entries (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
ULONG CDECL	WLDAP32_ldap_count_references (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
ULONG CDECL	ldap_count_valuesA (PCHAR *)
ULONG CDECL	ldap_count_valuesW (PWCHAR *)
ULONG CDECL	WLDAP32_ldap_count_values_len (PBERVAL *)
ULONG CDECL	ldap_create_page_controlA (WLDAP32_PLDAP, ULONG, struct WLDAP32_berval *, UCHAR, PLDAPControlA *)
ULONG CDECL	ldap_create_page_controlW (WLDAP32_PLDAP, ULONG, struct WLDAP32_berval *, UCHAR, PLDAPControlW *)
ULONG CDECL	ldap_create_sort_controlA (WLDAP32_PLDAP, PLDAPSortKeyA *, UCHAR, PLDAPControlA *)
ULONG CDECL	ldap_create_sort_controlW (WLDAP32_PLDAP, PLDAPSortKeyW *, UCHAR, PLDAPControlW *)
INT CDECL	ldap_create_vlv_controlA (WLDAP32_LDAP *, WLDAP32_LDAPVLVInfo *, UCHAR, LDAPControlA **)
INT CDECL	ldap_create_vlv_controlW (WLDAP32_LDAP *, WLDAP32_LDAPVLVInfo *, UCHAR, LDAPControlW **)
ULONG CDECL	ldap_deleteA (WLDAP32_LDAP *, PCHAR)
ULONG CDECL	ldap_deleteW (WLDAP32_LDAP *, PWCHAR)
ULONG CDECL	ldap_delete_extA (WLDAP32_LDAP *, PCHAR, PLDAPControlA *, PLDAPControlA *, ULONG *)
ULONG CDECL	ldap_delete_extW (WLDAP32_LDAP *, PWCHAR, PLDAPControlW *, PLDAPControlW *, ULONG *)
ULONG CDECL	ldap_delete_ext_sA (WLDAP32_LDAP *, PCHAR, PLDAPControlA *, PLDAPControlA *)
ULONG CDECL	ldap_delete_ext_sW (WLDAP32_LDAP *, PWCHAR, PLDAPControlW *, PLDAPControlW *)
ULONG CDECL	ldap_delete_sA (WLDAP32_LDAP *, PCHAR)
ULONG CDECL	ldap_delete_sW (WLDAP32_LDAP *, PWCHAR)
PCHAR CDECL	ldap_dn2ufnA (PCHAR)
PWCHAR CDECL	ldap_dn2ufnW (PWCHAR)
ULONG CDECL	ldap_encode_sort_controlA (WLDAP32_PLDAP, PLDAPSortKeyA *, PLDAPControlA, BOOLEAN)
ULONG CDECL	ldap_encode_sort_controlW (WLDAP32_PLDAP, PLDAPSortKeyW *, PLDAPControlW, BOOLEAN)
PCHAR CDECL	ldap_err2stringA (ULONG)
PWCHAR CDECL	ldap_err2stringW (ULONG)
ULONG CDECL	ldap_escape_filter_elementA (PCHAR, ULONG, PCHAR, ULONG)
ULONG CDECL	ldap_escape_filter_elementW (PCHAR, ULONG, PWCHAR, ULONG)
PCHAR *CDECL	ldap_explode_dnA (PCHAR, ULONG)
PWCHAR *CDECL	ldap_explode_dnW (PWCHAR, ULONG)
ULONG CDECL	ldap_extended_operationA (WLDAP32_LDAP *, PCHAR, struct WLDAP32_berval *, PLDAPControlA *, PLDAPControlA *, ULONG *)
ULONG CDECL	ldap_extended_operationW (WLDAP32_LDAP *, PWCHAR, struct WLDAP32_berval *, PLDAPControlW *, PLDAPControlW *, ULONG *)
ULONG CDECL	ldap_extended_operation_sA (WLDAP32_LDAP *, PCHAR, struct WLDAP32_berval *, PLDAPControlA *, PLDAPControlA *, PCHAR *, struct WLDAP32_berval **)
ULONG CDECL	ldap_extended_operation_sW (WLDAP32_LDAP *, PWCHAR, struct WLDAP32_berval *, PLDAPControlW *, PLDAPControlW *, PWCHAR *, struct WLDAP32_berval **)
PCHAR CDECL	ldap_first_attributeA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, WLDAP32_BerElement **)
PWCHAR CDECL	ldap_first_attributeW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, WLDAP32_BerElement **)
WLDAP32_LDAPMessage *CDECL	WLDAP32_ldap_first_entry (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
WLDAP32_LDAPMessage *CDECL	WLDAP32_ldap_first_reference (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
ULONG CDECL	ldap_free_controlsA (LDAPControlA **)
ULONG CDECL	ldap_free_controlsW (LDAPControlW **)
PCHAR CDECL	ldap_get_dnA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
PWCHAR CDECL	ldap_get_dnW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
ULONG CDECL	ldap_get_next_page (WLDAP32_LDAP *, PLDAPSearch, ULONG, ULONG *)
ULONG CDECL	ldap_get_next_page_s (WLDAP32_LDAP *, PLDAPSearch, struct l_timeval *, ULONG, ULONG *, WLDAP32_LDAPMessage **)
ULONG CDECL	ldap_get_optionA (WLDAP32_LDAP *, int, void *)
ULONG CDECL	ldap_get_optionW (WLDAP32_LDAP *, int, void *)
ULONG CDECL	ldap_get_paged_count (WLDAP32_LDAP *, PLDAPSearch, ULONG *, WLDAP32_LDAPMessage *)
PCHAR *CDECL	ldap_get_valuesA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PCHAR)
PWCHAR *CDECL	ldap_get_valuesW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PWCHAR)
PBERVAL *CDECL	ldap_get_values_lenA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PCHAR)
PBERVAL *CDECL	ldap_get_values_lenW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PWCHAR)
WLDAP32_LDAP *CDECL	ldap_initA (const PCHAR, ULONG)
WLDAP32_LDAP *CDECL	ldap_initW (const PWCHAR, ULONG)
void CDECL	ldap_memfreeA (PCHAR)
void CDECL	ldap_memfreeW (PWCHAR)
ULONG CDECL	ldap_modifyA (WLDAP32_LDAP *, PCHAR, LDAPModA *[])
ULONG CDECL	ldap_modifyW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[])
ULONG CDECL	ldap_modify_extA (WLDAP32_LDAP *, PCHAR, LDAPModA *[], PLDAPControlA *, PLDAPControlA *, ULONG *)
ULONG CDECL	ldap_modify_extW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[], PLDAPControlW *, PLDAPControlW *, ULONG *)
ULONG CDECL	ldap_modify_ext_sA (WLDAP32_LDAP *, PCHAR, LDAPModA *[], PLDAPControlA *, PLDAPControlA *)
ULONG CDECL	ldap_modify_ext_sW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[], PLDAPControlW *, PLDAPControlW *)
ULONG CDECL	ldap_modify_sA (WLDAP32_LDAP *, PCHAR, LDAPModA *[])
ULONG CDECL	ldap_modify_sW (WLDAP32_LDAP *, PWCHAR, LDAPModW *[])
ULONG CDECL	ldap_modrdnA (WLDAP32_LDAP *, PCHAR, PCHAR)
ULONG CDECL	ldap_modrdnW (WLDAP32_LDAP *, PWCHAR, PWCHAR)
ULONG CDECL	ldap_modrdn2A (WLDAP32_LDAP *, PCHAR, PCHAR, INT)
ULONG CDECL	ldap_modrdn2W (WLDAP32_LDAP *, PWCHAR, PWCHAR, INT)
ULONG CDECL	ldap_modrdn2_sA (WLDAP32_LDAP *, PCHAR, PCHAR, INT)
ULONG CDECL	ldap_modrdn2_sW (WLDAP32_LDAP *, PWCHAR, PWCHAR, INT)
ULONG CDECL	ldap_modrdn_sA (WLDAP32_LDAP *, PCHAR, PCHAR)
ULONG CDECL	ldap_modrdn_sW (WLDAP32_LDAP *, PWCHAR, PWCHAR)
ULONG CDECL	WLDAP32_ldap_msgfree (WLDAP32_LDAPMessage *)
PCHAR CDECL	ldap_next_attributeA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, WLDAP32_BerElement *)
PWCHAR CDECL	ldap_next_attributeW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, WLDAP32_BerElement *)
WLDAP32_LDAPMessage *CDECL	WLDAP32_ldap_next_entry (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
WLDAP32_LDAPMessage *CDECL	WLDAP32_ldap_next_reference (WLDAP32_LDAP *, WLDAP32_LDAPMessage *)
WLDAP32_LDAP *CDECL	ldap_openA (PCHAR, ULONG)
WLDAP32_LDAP *CDECL	ldap_openW (PWCHAR, ULONG)
ULONG CDECL	ldap_parse_extended_resultA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PCHAR *, struct WLDAP32_berval **, BOOLEAN)
ULONG CDECL	ldap_parse_extended_resultW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PWCHAR *, struct WLDAP32_berval **, BOOLEAN)
ULONG CDECL	ldap_parse_page_controlA (WLDAP32_LDAP *, PLDAPControlA *, ULONG *, struct WLDAP32_berval **)
ULONG CDECL	ldap_parse_page_controlW (WLDAP32_LDAP *, PLDAPControlW *, ULONG *, struct WLDAP32_berval **)
ULONG CDECL	ldap_parse_referenceA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PCHAR **)
ULONG CDECL	ldap_parse_referenceW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, PWCHAR **)
ULONG CDECL	ldap_parse_resultA (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, ULONG *, PCHAR *, PCHAR *, PCHAR **, PLDAPControlA **, BOOLEAN)
ULONG CDECL	ldap_parse_resultW (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, ULONG *, PWCHAR *, PWCHAR *, PWCHAR **, PLDAPControlW **, BOOLEAN)
ULONG CDECL	ldap_parse_sort_controlA (WLDAP32_LDAP *, PLDAPControlA *, ULONG *, PCHAR *)
ULONG CDECL	ldap_parse_sort_controlW (WLDAP32_LDAP *, PLDAPControlW *, ULONG *, PWCHAR *)
int CDECL	ldap_parse_vlv_controlA (WLDAP32_LDAP *, LDAPControlA **, ULONG *, ULONG *, struct WLDAP32_berval **, INT *)
int CDECL	ldap_parse_vlv_controlW (WLDAP32_LDAP *, LDAPControlW **, ULONG *, ULONG *, struct WLDAP32_berval **, INT *)
void CDECL	WLDAP32_ldap_perror (WLDAP32_LDAP *, const PCHAR)
ULONG CDECL	ldap_rename_extA (WLDAP32_LDAP *, PCHAR, PCHAR, PCHAR, INT, PLDAPControlA *, PLDAPControlA *, ULONG *)
ULONG CDECL	ldap_rename_extW (WLDAP32_LDAP *, PWCHAR, PWCHAR, PWCHAR, INT, PLDAPControlW *, PLDAPControlW *, ULONG *)
ULONG CDECL	ldap_rename_ext_sA (WLDAP32_LDAP *, PCHAR, PCHAR, PCHAR, INT, PLDAPControlA *, PLDAPControlA *)
ULONG CDECL	ldap_rename_ext_sW (WLDAP32_LDAP *, PWCHAR, PWCHAR, PWCHAR, INT, PLDAPControlW *, PLDAPControlW *)
ULONG CDECL	WLDAP32_ldap_result (WLDAP32_LDAP *, ULONG, ULONG, struct l_timeval *, WLDAP32_LDAPMessage **)
ULONG CDECL	WLDAP32_ldap_result2error (WLDAP32_LDAP *, WLDAP32_LDAPMessage *, ULONG)
ULONG CDECL	ldap_sasl_bindA (WLDAP32_LDAP *, const PCHAR, const PCHAR, const BERVAL *, PLDAPControlA *, PLDAPControlA *, int *)
ULONG CDECL	ldap_sasl_bindW (WLDAP32_LDAP *, const PWCHAR, const PWCHAR, const BERVAL *, PLDAPControlW *, PLDAPControlW *, int *)
ULONG CDECL	ldap_sasl_bind_sA (WLDAP32_LDAP *, const PCHAR, const PCHAR, const BERVAL *, PLDAPControlA *, PLDAPControlA *, PBERVAL *)
ULONG CDECL	ldap_sasl_bind_sW (WLDAP32_LDAP *, const PWCHAR, const PWCHAR, const BERVAL *, PLDAPControlW *, PLDAPControlW *, PBERVAL *)
ULONG CDECL	ldap_search_abandon_page (WLDAP32_PLDAP, PLDAPSearch)
ULONG CDECL	ldap_searchA (WLDAP32_LDAP *, PCHAR, ULONG, PCHAR, PCHAR[], ULONG)
ULONG CDECL	ldap_searchW (WLDAP32_LDAP *, PWCHAR, ULONG, PWCHAR, PWCHAR[], ULONG)
ULONG CDECL	ldap_search_extA (WLDAP32_LDAP *, PCHAR, ULONG, PCHAR, PCHAR[], ULONG, PLDAPControlA *, PLDAPControlA *, ULONG, ULONG, ULONG *)
ULONG CDECL	ldap_search_extW (WLDAP32_LDAP *, PWCHAR, ULONG, PWCHAR, PWCHAR[], ULONG, PLDAPControlW *, PLDAPControlW *, ULONG, ULONG, ULONG *)
ULONG CDECL	ldap_search_ext_sA (WLDAP32_LDAP *, PCHAR, ULONG, PCHAR, PCHAR[], ULONG, PLDAPControlA *, PLDAPControlA *, struct l_timeval *, ULONG, WLDAP32_LDAPMessage **)
ULONG CDECL	ldap_search_ext_sW (WLDAP32_LDAP *, PWCHAR, ULONG, PWCHAR, PWCHAR[], ULONG, PLDAPControlW *, PLDAPControlW *, struct l_timeval *, ULONG, WLDAP32_LDAPMessage **)
PLDAPSearch CDECL	ldap_search_init_pageA (WLDAP32_PLDAP, PCHAR, ULONG, PCHAR, PCHAR[], ULONG, PLDAPControlA *, PLDAPControlA *, ULONG, ULONG, PLDAPSortKeyA *)
PLDAPSearch CDECL	ldap_search_init_pageW (WLDAP32_PLDAP, PWCHAR, ULONG, PWCHAR, PWCHAR[], ULONG, PLDAPControlW *, PLDAPControlW *, ULONG, ULONG, PLDAPSortKeyW *)
ULONG CDECL	ldap_search_sA (WLDAP32_LDAP *, PCHAR, ULONG, PCHAR, PCHAR[], ULONG, WLDAP32_LDAPMessage **)
ULONG CDECL	ldap_search_sW (WLDAP32_LDAP *, PWCHAR, ULONG, PWCHAR, PWCHAR[], ULONG, WLDAP32_LDAPMessage **)
ULONG CDECL	ldap_search_stA (WLDAP32_LDAP *, const PCHAR, ULONG, const PCHAR, PCHAR[], ULONG, struct l_timeval *, WLDAP32_LDAPMessage **)
ULONG CDECL	ldap_search_stW (WLDAP32_LDAP *, const PWCHAR, ULONG, const PWCHAR, PWCHAR[], ULONG, struct l_timeval *, WLDAP32_LDAPMessage **)
ULONG CDECL	ldap_set_optionA (WLDAP32_LDAP *, int, void *)
ULONG CDECL	ldap_set_optionW (WLDAP32_LDAP *, int, void *)
ULONG CDECL	ldap_simple_bindA (WLDAP32_LDAP *, PCHAR, PCHAR)
ULONG CDECL	ldap_simple_bindW (WLDAP32_LDAP *, PWCHAR, PWCHAR)
ULONG CDECL	ldap_simple_bind_sA (WLDAP32_LDAP *, PCHAR, PCHAR)
ULONG CDECL	ldap_simple_bind_sW (WLDAP32_LDAP *, PWCHAR, PWCHAR)
WLDAP32_LDAP *CDECL	ldap_sslinitA (PCHAR, ULONG, int)
WLDAP32_LDAP *CDECL	ldap_sslinitW (PWCHAR, ULONG, int)
ULONG CDECL	ldap_start_tls_sA (WLDAP32_PLDAP, PULONG, WLDAP32_LDAPMessage **, PLDAPControlA *, PLDAPControlA *)
ULONG CDECL	ldap_start_tls_sW (WLDAP32_PLDAP, PULONG, WLDAP32_LDAPMessage **, PLDAPControlW *, PLDAPControlW *)
ULONG CDECL	ldap_startup (PLDAP_VERSION_INFO, HANDLE *)
BOOLEAN CDECL	ldap_stop_tls_s (WLDAP32_PLDAP)
ULONG CDECL	ldap_ufn2dnA (PCHAR, PCHAR *)
ULONG CDECL	ldap_ufn2dnW (PWCHAR, PWCHAR *)
ULONG CDECL	WLDAP32_ldap_unbind (WLDAP32_LDAP *)
ULONG CDECL	WLDAP32_ldap_unbind_s (WLDAP32_LDAP *)
ULONG CDECL	ldap_value_freeA (PCHAR *)
ULONG CDECL	ldap_value_freeW (PWCHAR *)
ULONG CDECL	WLDAP32_ldap_value_free_len (struct WLDAP32_berval **)
ULONG CDECL	LdapGetLastError (void)
ULONG CDECL	LdapMapErrorToWin32 (ULONG)
int CDECL	LdapUnicodeToUTF8 (LPCWSTR, int, LPSTR, int)
int CDECL	LdapUTF8ToUnicode (LPCSTR, int, LPWSTR, int)

Variables
static const WCHAR	LDAP_PAGED_RESULT_OID_STRING_W [] = {'1','.','2','.','8','4','0','.','1','1','3','5','5','6','.','1','.','4','.','3','1','9',0}
static const WCHAR	LDAP_SERVER_RESP_SORT_OID_W [] = {'1','.','2','.','8','4','0','.','1','1','3','5','5','6','.','1','.','4','.','4','7','4',0}
static const WCHAR	LDAP_CONTROL_VLVRESPONSE_W [] = {'2','.','1','6','.','8','4','0','.','1','.','1','1','3','7','3','0','.','3','.','4','.','1','0',0}

Macro Definition Documentation

LAPI_MAJOR_VER1

#define LAPI_MAJOR_VER1   1

Definition at line 177 of file winldap_private.h.

LAPI_MINOR_VER1

#define LAPI_MINOR_VER1   1

Definition at line 178 of file winldap_private.h.

LDAP_CONTROL_VLVRESPONSE

#define LDAP_CONTROL_VLVRESPONSE   "2.16.840.1.113730.3.4.10"

Definition at line 195 of file winldap_private.h.

LDAP_PAGED_RESULT_OID_STRING

#define LDAP_PAGED_RESULT_OID_STRING   "1.2.840.113556.1.4.319"

Definition at line 193 of file winldap_private.h.

LDAP_SERVER_RESP_SORT_OID

#define LDAP_SERVER_RESP_SORT_OID   "1.2.840.113556.1.4.474"

Definition at line 194 of file winldap_private.h.

WLDAP32_LDAP_OPT_API_FEATURE_INFO

#define WLDAP32_LDAP_OPT_API_FEATURE_INFO   0x15

Definition at line 74 of file winldap_private.h.

WLDAP32_LDAP_OPT_API_INFO

#define WLDAP32_LDAP_OPT_API_INFO   0x00

Definition at line 55 of file winldap_private.h.

WLDAP32_LDAP_OPT_AREC_EXCLUSIVE

#define WLDAP32_LDAP_OPT_AREC_EXCLUSIVE   0x98

Definition at line 102 of file winldap_private.h.

WLDAP32_LDAP_OPT_AUTO_RECONNECT

#define WLDAP32_LDAP_OPT_AUTO_RECONNECT   0x91

Definition at line 93 of file winldap_private.h.

WLDAP32_LDAP_OPT_CACHE_ENABLE

#define WLDAP32_LDAP_OPT_CACHE_ENABLE   0x0f

Definition at line 69 of file winldap_private.h.

WLDAP32_LDAP_OPT_CACHE_FN_PTRS

#define WLDAP32_LDAP_OPT_CACHE_FN_PTRS   0x0d

Definition at line 67 of file winldap_private.h.

WLDAP32_LDAP_OPT_CACHE_STRATEGY

#define WLDAP32_LDAP_OPT_CACHE_STRATEGY   0x0e

Definition at line 68 of file winldap_private.h.

WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE

#define WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE   0x80

Definition at line 91 of file winldap_private.h.

WLDAP32_LDAP_OPT_DEREF

#define WLDAP32_LDAP_OPT_DEREF   0x02

Definition at line 57 of file winldap_private.h.

WLDAP32_LDAP_OPT_DESC

#define WLDAP32_LDAP_OPT_DESC   0x01

Definition at line 56 of file winldap_private.h.

WLDAP32_LDAP_OPT_DNSDOMAIN_NAME

#define WLDAP32_LDAP_OPT_DNSDOMAIN_NAME   0x3b

Definition at line 83 of file winldap_private.h.

WLDAP32_LDAP_OPT_ENCRYPT

#define WLDAP32_LDAP_OPT_ENCRYPT   0x96

Definition at line 100 of file winldap_private.h.

WLDAP32_LDAP_OPT_ERROR_NUMBER

#define WLDAP32_LDAP_OPT_ERROR_NUMBER   0x31

Definition at line 76 of file winldap_private.h.

WLDAP32_LDAP_OPT_ERROR_STRING

#define WLDAP32_LDAP_OPT_ERROR_STRING   0x32

Definition at line 77 of file winldap_private.h.

WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND

#define WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND   0x41

Definition at line 88 of file winldap_private.h.

WLDAP32_LDAP_OPT_GETDSNAME_FLAGS

#define WLDAP32_LDAP_OPT_GETDSNAME_FLAGS   0x3d

Definition at line 84 of file winldap_private.h.

WLDAP32_LDAP_OPT_HOST_NAME

#define WLDAP32_LDAP_OPT_HOST_NAME   0x30

Definition at line 75 of file winldap_private.h.

WLDAP32_LDAP_OPT_HOST_REACHABLE

#define WLDAP32_LDAP_OPT_HOST_REACHABLE   0x3e

Definition at line 85 of file winldap_private.h.

WLDAP32_LDAP_OPT_IO_FN_PTRS

#define WLDAP32_LDAP_OPT_IO_FN_PTRS   0x0b

Definition at line 66 of file winldap_private.h.

WLDAP32_LDAP_OPT_PING_KEEP_ALIVE

#define WLDAP32_LDAP_OPT_PING_KEEP_ALIVE   0x36

Definition at line 80 of file winldap_private.h.

WLDAP32_LDAP_OPT_PING_LIMIT

#define WLDAP32_LDAP_OPT_PING_LIMIT   0x38

Definition at line 82 of file winldap_private.h.

WLDAP32_LDAP_OPT_PING_WAIT_TIME

#define WLDAP32_LDAP_OPT_PING_WAIT_TIME   0x37

Definition at line 81 of file winldap_private.h.

WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS

#define WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS   0x3f

Definition at line 86 of file winldap_private.h.

WLDAP32_LDAP_OPT_PROTOCOL_VERSION

#define WLDAP32_LDAP_OPT_PROTOCOL_VERSION   WLDAP32_LDAP_OPT_VERSION

Definition at line 72 of file winldap_private.h.

WLDAP32_LDAP_OPT_REBIND_ARG

#define WLDAP32_LDAP_OPT_REBIND_ARG   0x07

Definition at line 62 of file winldap_private.h.

WLDAP32_LDAP_OPT_REBIND_FN

#define WLDAP32_LDAP_OPT_REBIND_FN   0x06

Definition at line 61 of file winldap_private.h.

WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG

#define WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG   0x94

Definition at line 96 of file winldap_private.h.

WLDAP32_LDAP_OPT_REFERRAL_CALLBACK

#define WLDAP32_LDAP_OPT_REFERRAL_CALLBACK   0x70

Definition at line 90 of file winldap_private.h.

WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT

#define WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT   0x10

Definition at line 70 of file winldap_private.h.

WLDAP32_LDAP_OPT_REFERRALS

#define WLDAP32_LDAP_OPT_REFERRALS   0x08

Definition at line 63 of file winldap_private.h.

WLDAP32_LDAP_OPT_RESTART

#define WLDAP32_LDAP_OPT_RESTART   0x09

Definition at line 64 of file winldap_private.h.

WLDAP32_LDAP_OPT_ROOTDSE_CACHE

#define WLDAP32_LDAP_OPT_ROOTDSE_CACHE   0x9a

Definition at line 104 of file winldap_private.h.

WLDAP32_LDAP_OPT_SASL_METHOD

#define WLDAP32_LDAP_OPT_SASL_METHOD   0x97

Definition at line 101 of file winldap_private.h.

WLDAP32_LDAP_OPT_SECURITY_CONTEXT

#define WLDAP32_LDAP_OPT_SECURITY_CONTEXT   0x99

Definition at line 103 of file winldap_private.h.

WLDAP32_LDAP_OPT_SEND_TIMEOUT

#define WLDAP32_LDAP_OPT_SEND_TIMEOUT   0x42

Definition at line 89 of file winldap_private.h.

WLDAP32_LDAP_OPT_SERVER_CERTIFICATE

#define WLDAP32_LDAP_OPT_SERVER_CERTIFICATE   0x81

Definition at line 92 of file winldap_private.h.

WLDAP32_LDAP_OPT_SERVER_CONTROLS

#define WLDAP32_LDAP_OPT_SERVER_CONTROLS   0x12

Definition at line 73 of file winldap_private.h.

WLDAP32_LDAP_OPT_SERVER_ERROR

#define WLDAP32_LDAP_OPT_SERVER_ERROR   0x33

Definition at line 78 of file winldap_private.h.

WLDAP32_LDAP_OPT_SERVER_EXT_ERROR

#define WLDAP32_LDAP_OPT_SERVER_EXT_ERROR   0x34

Definition at line 79 of file winldap_private.h.

WLDAP32_LDAP_OPT_SIGN

#define WLDAP32_LDAP_OPT_SIGN   0x95

Definition at line 99 of file winldap_private.h.

WLDAP32_LDAP_OPT_SIZELIMIT

#define WLDAP32_LDAP_OPT_SIZELIMIT   0x03

Definition at line 58 of file winldap_private.h.

WLDAP32_LDAP_OPT_SSL

#define WLDAP32_LDAP_OPT_SSL   0x0a

Definition at line 65 of file winldap_private.h.

WLDAP32_LDAP_OPT_SSL_INFO

#define WLDAP32_LDAP_OPT_SSL_INFO   0x93

Definition at line 95 of file winldap_private.h.

WLDAP32_LDAP_OPT_SSPI_FLAGS

#define WLDAP32_LDAP_OPT_SSPI_FLAGS   0x92

Definition at line 94 of file winldap_private.h.

WLDAP32_LDAP_OPT_TCP_KEEPALIVE

#define WLDAP32_LDAP_OPT_TCP_KEEPALIVE   0x40

Definition at line 87 of file winldap_private.h.

WLDAP32_LDAP_OPT_THREAD_FN_PTRS

#define WLDAP32_LDAP_OPT_THREAD_FN_PTRS   0x05

Definition at line 60 of file winldap_private.h.

WLDAP32_LDAP_OPT_TIMELIMIT

#define WLDAP32_LDAP_OPT_TIMELIMIT   0x04

Definition at line 59 of file winldap_private.h.

WLDAP32_LDAP_OPT_TLS

#define WLDAP32_LDAP_OPT_TLS   WLDAP32_LDAP_OPT_SSL

Definition at line 97 of file winldap_private.h.

WLDAP32_LDAP_OPT_TLS_INFO

#define WLDAP32_LDAP_OPT_TLS_INFO   WLDAP32_LDAP_OPT_SSL_INFO

Definition at line 98 of file winldap_private.h.

WLDAP32_LDAP_OPT_VERSION

#define WLDAP32_LDAP_OPT_VERSION   0x11

Definition at line 71 of file winldap_private.h.

Typedef Documentation

BERVAL

typedef struct WLDAP32_berval BERVAL

LDAP_BERVAL

typedef struct WLDAP32_berval LDAP_BERVAL

LDAP_TIMEVAL

typedef struct l_timeval LDAP_TIMEVAL

LDAP_VERSION_INFO

typedef struct ldap_version_info LDAP_VERSION_INFO

LDAPAPIFeatureInfoA

typedef struct ldap_apifeature_infoA LDAPAPIFeatureInfoA

LDAPAPIFeatureInfoW

typedef struct ldap_apifeature_infoW LDAPAPIFeatureInfoW

LDAPAPIInfoA

typedef struct ldapapiinfoA LDAPAPIInfoA

LDAPAPIInfoW

typedef struct ldapapiinfoW LDAPAPIInfoW

LDAPControlA

typedef struct ldapcontrolA LDAPControlA

LDAPControlW

typedef struct ldapcontrolW LDAPControlW

LDAPModA

typedef struct ldapmodA LDAPModA

LDAPModW

typedef struct ldapmodW LDAPModW

LDAPSearch

typedef struct ldapsearch LDAPSearch

Definition at line 233 of file winldap_private.h.

LDAPSortKeyA

typedef struct ldapsortkeyA LDAPSortKeyA

LDAPSortKeyW

typedef struct ldapsortkeyW LDAPSortKeyW

PBERVAL

typedef struct WLDAP32_berval * PBERVAL

PLDAP_BERVAL

typedef struct WLDAP32_berval * PLDAP_BERVAL

PLDAP_TIMEVAL

typedef struct l_timeval * PLDAP_TIMEVAL

PLDAP_VERSION_INFO

typedef struct ldap_version_info * PLDAP_VERSION_INFO

PLDAPControlA

typedef struct ldapcontrolA * PLDAPControlA

PLDAPControlW

typedef struct ldapcontrolW * PLDAPControlW

PLDAPModA

typedef struct ldapmodA * PLDAPModA

PLDAPModW

typedef struct ldapmodW * PLDAPModW

PLDAPSearch

typedef struct ldapsearch * PLDAPSearch

Definition at line 233 of file winldap_private.h.

PLDAPSortKeyA

typedef struct ldapsortkeyA * PLDAPSortKeyA

PLDAPSortKeyW

typedef struct ldapsortkeyW * PLDAPSortKeyW

WLDAP32_BerElement

typedef struct berelement WLDAP32_BerElement

WLDAP32_BerValue

typedef struct WLDAP32_berval WLDAP32_BerValue

WLDAP32_LDAP

typedef struct ldap WLDAP32_LDAP

WLDAP32_LDAPMessage

typedef struct ldapmsg WLDAP32_LDAPMessage

WLDAP32_LDAPVLVInfo

typedef struct WLDAP32_ldapvlvinfo WLDAP32_LDAPVLVInfo

WLDAP32_PLDAP

typedef struct ldap * WLDAP32_PLDAP

WLDAP32_PLDAPMessage

typedef struct ldapmsg * WLDAP32_PLDAPMessage

WLDAP32_PLDAPVLVInfo

typedef struct WLDAP32_ldapvlvinfo * WLDAP32_PLDAPVLVInfo

Enumeration Type Documentation

LDAP_RETCODE

enum LDAP_RETCODE

Enumerator
WLDAP32_LDAP_SUCCESS
WLDAP32_LDAP_UNWILLING_TO_PERFORM
WLDAP32_LDAP_SERVER_DOWN
WLDAP32_LDAP_LOCAL_ERROR
WLDAP32_LDAP_ENCODING_ERROR
WLDAP32_LDAP_DECODING_ERROR
WLDAP32_LDAP_TIMEOUT
WLDAP32_LDAP_AUTH_UNKNOWN
WLDAP32_LDAP_FILTER_ERROR
WLDAP32_LDAP_USER_CANCELLED
WLDAP32_LDAP_PARAM_ERROR
WLDAP32_LDAP_NO_MEMORY
WLDAP32_LDAP_CONNECT_ERROR
WLDAP32_LDAP_NOT_SUPPORTED
WLDAP32_LDAP_NO_RESULTS_RETURNED
WLDAP32_LDAP_CONTROL_NOT_FOUND
WLDAP32_LDAP_MORE_RESULTS_TO_RETURN
WLDAP32_LDAP_CLIENT_LOOP
WLDAP32_LDAP_REFERRAL_LIMIT_EXCEEDED

Definition at line 27 of file winldap_private.h.

             {
    WLDAP32_LDAP_SUCCESS                 =   0x00,
    WLDAP32_LDAP_UNWILLING_TO_PERFORM    =   0x35,
    WLDAP32_LDAP_SERVER_DOWN             =   0x51,
    WLDAP32_LDAP_LOCAL_ERROR             =   0x52,
    WLDAP32_LDAP_ENCODING_ERROR          =   0x53,
    WLDAP32_LDAP_DECODING_ERROR          =   0x54,
    WLDAP32_LDAP_TIMEOUT                 =   0x55,
    WLDAP32_LDAP_AUTH_UNKNOWN            =   0x56,
    WLDAP32_LDAP_FILTER_ERROR            =   0x57,
    WLDAP32_LDAP_USER_CANCELLED          =   0x58,
    WLDAP32_LDAP_PARAM_ERROR             =   0x59,
    WLDAP32_LDAP_NO_MEMORY               =   0x5a,
    WLDAP32_LDAP_CONNECT_ERROR           =   0x5b,
    WLDAP32_LDAP_NOT_SUPPORTED           =   0x5c,
    WLDAP32_LDAP_NO_RESULTS_RETURNED     =   0x5e,
    WLDAP32_LDAP_CONTROL_NOT_FOUND       =   0x5d,
    WLDAP32_LDAP_MORE_RESULTS_TO_RETURN  =   0x5f,
 
    WLDAP32_LDAP_CLIENT_LOOP             =   0x60,
    WLDAP32_LDAP_REFERRAL_LIMIT_EXCEEDED =   0x61
} LDAP_RETCODE;

Function Documentation

cldap_openA()

WLDAP32_LDAP *CDECL cldap_openA	(	PCHAR	hostname,
		ULONG	portnumber
	)

Definition at line 223 of file init.c.

{
#ifdef HAVE_LDAP
    WLDAP32_LDAP *ld = NULL;
    WCHAR *hostnameW = NULL;
 
    TRACE( "(%s, %d)\n", debugstr_a(hostname), portnumber );
 
    if (hostname) {
        hostnameW = strAtoW( hostname );
        if (!hostnameW) goto exit;
    }
 
    ld = cldap_openW( hostnameW, portnumber );
 
exit:
    strfreeW( hostnameW );
    return ld;
 
#else
    return NULL;
#endif
}

cldap_openW()

WLDAP32_LDAP *CDECL cldap_openW	(	PWCHAR	hostname,
		ULONG	portnumber
	)

Definition at line 268 of file init.c.

{
#ifdef HAVE_LDAP
    LDAP *ld = NULL;
    char *hostnameU = NULL, *url = NULL;
 
    TRACE( "(%s, %d)\n", debugstr_w(hostname), portnumber );
 
    if (hostname) {
        hostnameU = strWtoU( hostname );
        if (!hostnameU) goto exit;
    }
    else {
        hostnameU = strWtoU( defaulthost );
        if (!hostnameU) goto exit;
    }
 
    url = urlify_hostnames( "cldap://", hostnameU, portnumber );
    if (!url) goto exit;
 
    ld = create_context( url );
 
exit:
    strfreeU( hostnameU );
    strfreeU( url );
    return ld;
 
#else
    return NULL;
#endif
}

ldap_add_ext_sA()

ULONG CDECL ldap_add_ext_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	attrs[],
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls
	)

Definition at line 263 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **attrsW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p)\n", ld, debugstr_a(dn), attrs,
           serverctrls, clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (attrs) {
        attrsW = modarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_add_ext_sW( ld, dnW, attrsW, serverctrlsW, clientctrlsW );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( attrsW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_add_ext_sW()

ULONG CDECL ldap_add_ext_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	attrs[],
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls
	)

Definition at line 329 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **attrsU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p)\n", ld, debugstr_w(dn), attrs,
           serverctrls, clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (attrs) {
        attrsU = modarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_add_ext_s( ld, dn ? dnU : "", attrs ? attrsU : nullattrs,
                                     serverctrlsU, clientctrlsU ));
 
exit:
    strfreeU( dnU );
    modarrayfreeU( attrsU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_add_extA()

ULONG CDECL ldap_add_extA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	attrs[],
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		ULONG *	message
	)

Definition at line 143 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **attrsW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn), attrs,
           serverctrls, clientctrls, message );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (attrs) {
        attrsW = modarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_add_extW( ld, dnW, attrsW, serverctrlsW, clientctrlsW, message );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( attrsW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_add_extW()

ULONG CDECL ldap_add_extW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	attrs[],
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		ULONG *	message
	)

Definition at line 211 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **attrsU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    int dummy;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn), attrs,
           serverctrls, clientctrls, message );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (attrs) {
        attrsU = modarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_add_ext( ld, dn ? dnU : "", attrs ? attrsU : nullattrs, serverctrlsU,
                                   clientctrlsU, message ? (int *)message : &dummy ));
 
exit:
    strfreeU( dnU );
    modarrayfreeU( attrsU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_add_sA()

ULONG CDECL ldap_add_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	attrs[]
	)

Definition at line 380 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **attrsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), attrs );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (attrs) {
        attrsW = modarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
 
    ret = ldap_add_sW( ld, dnW, attrsW );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( attrsW );
 
#endif
    return ret;
}

ldap_add_sW()

ULONG CDECL ldap_add_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	attrs[]
	)

Definition at line 427 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **attrsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), attrs );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (attrs) {
        attrsU = modarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
 
    ret = map_error( ldap_add_ext_s( ld, dn ? dnU : "", attrs ? attrsU : nullattrs, NULL, NULL ));
 
exit:
    strfreeU( dnU );
    modarrayfreeU( attrsU );
 
#endif
    return ret;
}

ldap_addA()

ULONG CDECL ldap_addA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	attrs[]
	)

Definition at line 48 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **attrsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), attrs );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (attrs) {
        attrsW = modarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
 
    ret = ldap_addW( ld, dnW, attrsW );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( attrsW );
 
#endif
    return ret;
}

ldap_addW()

ULONG CDECL ldap_addW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	attrs[]
	)

Definition at line 100 of file add.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **attrsU = NULL;
    int msg;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), attrs );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (attrs) {
        attrsU = modarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
 
    ret = ldap_add_ext( ld, dn ? dnU : "", attrs ? attrsU : nullattrs, NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( dnU );
    modarrayfreeU( attrsU );
 
#endif
    return ret;
}

ldap_bind_sA()

ULONG CDECL ldap_bind_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	cred,
		ULONG	method
	)

Definition at line 140 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *credW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%08x)\n", ld, debugstr_a(dn), cred, method );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (cred) {
        credW = strAtoW( cred );
        if (!credW) goto exit;
    }
 
    ret = ldap_bind_sW( ld, dnW, credW, method );
 
exit:
    strfreeW( dnW );
    strfreeW( credW );
 
#endif
    return ret;
}

ldap_bind_sW()

ULONG CDECL ldap_bind_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	cred,
		ULONG	method
	)

Definition at line 186 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *credU = NULL;
    struct berval pwd = { 0, NULL };
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%08x)\n", ld, debugstr_w(dn), cred, method );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    if (method != LDAP_AUTH_SIMPLE) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (cred) {
        credU = strWtoU( cred );
        if (!credU) goto exit;
 
        pwd.bv_len = strlen( credU );
        pwd.bv_val = credU;
    }
 
    ret = map_error( ldap_sasl_bind_s( ld, dnU, LDAP_SASL_SIMPLE, &pwd, NULL, NULL, NULL ));
 
exit:
    strfreeU( dnU );
    strfreeU( credU );
 
#endif
    return ret;
}

Referenced by ldap_bind_sA().

ldap_bindA()

ULONG CDECL ldap_bindA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	cred,
		ULONG	method
	)

Definition at line 44 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *credW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%08x)\n", ld, debugstr_a(dn), cred, method );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (cred) {
        credW = strAtoW( cred );
        if (!credW) goto exit;
    }
 
    ret = ldap_bindW( ld, dnW, credW, method );
 
exit:
    strfreeW( dnW );
    strfreeW( credW );
 
#endif
    return ret;
}

ldap_bindW()

ULONG CDECL ldap_bindW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	cred,
		ULONG	method
	)

Definition at line 93 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *credU = NULL;
    struct berval pwd = { 0, NULL };
    int msg;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%08x)\n", ld, debugstr_w(dn), cred, method );
 
    if (!ld) return ~0u;
    if (method != LDAP_AUTH_SIMPLE) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (cred) {
        credU = strWtoU( cred );
        if (!credU) goto exit;
 
        pwd.bv_len = strlen( credU );
        pwd.bv_val = credU;
    }
 
    ret = ldap_sasl_bind( ld, dnU, LDAP_SASL_SIMPLE, &pwd, NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( dnU );
    strfreeU( credU );
 
#endif
    return ret;
}

Referenced by ldap_bindA().

ldap_check_filterA()

ULONG CDECL ldap_check_filterA	(	WLDAP32_LDAP *	ld,
		PCHAR	filter
	)

Definition at line 72 of file misc.c.

{
    ULONG ret;
    WCHAR *filterW = NULL;
 
    TRACE( "(%p, %s)\n", ld, debugstr_a(filter) );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (filter) {
        filterW = strAtoW( filter );
        if (!filterW) return WLDAP32_LDAP_NO_MEMORY;
    }
 
    ret = ldap_check_filterW( ld, filterW );
 
    strfreeW( filterW );
    return ret;
}

ldap_check_filterW()

ULONG CDECL ldap_check_filterW	(	WLDAP32_LDAP *	ld,
		PWCHAR	filter
	)

Definition at line 105 of file misc.c.

{
    TRACE( "(%p, %s)\n", ld, debugstr_w(filter) );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    return WLDAP32_LDAP_SUCCESS; /* FIXME: do some checks */
}

ldap_cleanup()

ULONG CDECL ldap_cleanup

(

HANDLE

instance

)

Definition at line 116 of file misc.c.

{
    TRACE( "(%p)\n", instance );
    return WLDAP32_LDAP_SUCCESS;
}

ldap_close_extended_op()

ULONG CDECL ldap_close_extended_op	(	WLDAP32_LDAP *	ld,
		ULONG	msgid
	)

Definition at line 56 of file extended.c.

{
    TRACE( "(%p, 0x%08x)\n", ld, msgid );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    return WLDAP32_LDAP_SUCCESS;
}

ldap_compare_ext_sA()

ULONG CDECL ldap_compare_ext_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	attr,
		PCHAR	value,
		struct WLDAP32_berval *	data,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls
	)

Definition at line 288 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, %p, %p, %p)\n", ld, debugstr_a(dn),
           debugstr_a(attr), debugstr_a(value), data, serverctrls,
           clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (attr) {
        attrW = strAtoW( attr );
        if (!attrW) goto exit;
    }
    if (value) {
        valueW = strAtoW( value );
        if (!valueW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_compare_ext_sW( ld, dnW, attrW, valueW, data, serverctrlsW,
                               clientctrlsW );
 
exit:
    strfreeW( dnW );
    strfreeW( attrW );
    strfreeW( valueW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_compare_ext_sW()

ULONG CDECL ldap_compare_ext_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	attr,
		PWCHAR	value,
		struct WLDAP32_berval *	data,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls
	)

Definition at line 362 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *attrU = NULL, *valueU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    struct berval val = { 0, NULL };
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, %p, %p, %p)\n", ld, debugstr_w(dn),
           debugstr_w(attr), debugstr_w(value), data, serverctrls,
           clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (attr) {
        attrU = strWtoU( attr );
        if (!attrU) goto exit;
    }
    if (!data) {
        if (value) {
            valueU = strWtoU( value );
            if (!valueU) goto exit;
 
            val.bv_len = strlen( valueU );
            val.bv_val = valueU;
        }
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_compare_ext_s( ld, dn ? dnU : "", attr ? attrU : "",
                                         data ? (struct berval *)data : &val,
                                         serverctrlsU, clientctrlsU ));
 
exit:
    strfreeU( dnU );
    strfreeU( attrU );
    strfreeU( valueU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

Referenced by ldap_compare_ext_sA().

ldap_compare_extA()

ULONG CDECL ldap_compare_extA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	attr,
		PCHAR	value,
		struct WLDAP32_berval *	data,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		ULONG *	message
	)

Definition at line 148 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn),
           debugstr_a(attr), debugstr_a(value), data, serverctrls,
           clientctrls, message );
 
    if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (attr) {
        attrW = strAtoW( attr );
        if (!attrW) goto exit;
    }
    if (value) {
        valueW = strAtoW( value );
        if (!valueW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_compare_extW( ld, dnW, attrW, valueW, data,
                             serverctrlsW, clientctrlsW, message );
 
exit:
    strfreeW( dnW );
    strfreeW( attrW );
    strfreeW( valueW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_compare_extW()

ULONG CDECL ldap_compare_extW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	attr,
		PWCHAR	value,
		struct WLDAP32_berval *	data,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		ULONG *	message
	)

Definition at line 224 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *attrU = NULL, *valueU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    struct berval val = { 0, NULL };
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn),
           debugstr_w(attr), debugstr_w(value), data, serverctrls,
           clientctrls, message );
 
    if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
    if (!attr) return WLDAP32_LDAP_NO_MEMORY;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
 
    attrU = strWtoU( attr );
    if (!attrU) goto exit;
 
    if (!data) {
        if (value) {
            valueU = strWtoU( value );
            if (!valueU) goto exit;
 
            val.bv_len = strlen( valueU );
            val.bv_val = valueU;
        }
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_compare_ext( ld, dn ? dnU : "", attrU, data ? (struct berval *)data : &val,
                                       serverctrlsU, clientctrlsU, (int *)message ));
 
exit:
    strfreeU( dnU );
    strfreeU( attrU );
    strfreeU( valueU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

Referenced by ldap_compare_extA().

ldap_compare_sA()

ULONG CDECL ldap_compare_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	attr,
		PCHAR	value
	)

Definition at line 425 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_a(dn), debugstr_a(attr),
           debugstr_a(value) );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (attr) {
        attrW = strAtoW( attr );
        if (!attrW) goto exit;
    }
    if (value) {
        valueW = strAtoW( value );
        if (!valueW) goto exit;
    }
 
    ret = ldap_compare_sW( ld, dnW, attrW, valueW );
 
exit:
    strfreeW( dnW );
    strfreeW( attrW );
    strfreeW( valueW );
 
#endif
    return ret;
}

ldap_compare_sW()

ULONG CDECL ldap_compare_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	attr,
		PWCHAR	value
	)

Definition at line 477 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *attrU = NULL, *valueU = NULL;
    struct berval val = { 0, NULL };
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_w(dn), debugstr_w(attr),
           debugstr_w(value) );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (attr) {
        attrU = strWtoU( attr );
        if (!attrU) goto exit;
    }
    if (value) {
        valueU = strWtoU( value );
        if (!valueU) goto exit;
 
        val.bv_len = strlen( valueU );
        val.bv_val = valueU;
    }
 
    ret = map_error( ldap_compare_ext_s( ld, dn ? dnU : "", attr ? attrU : "", &val, NULL, NULL ));
 
exit:
    strfreeU( dnU );
    strfreeU( attrU );
    strfreeU( valueU );
 
#endif
    return ret;
}

ldap_compareA()

ULONG CDECL ldap_compareA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	attr,
		PCHAR	value
	)

Definition at line 44 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
 
    ret = ~0u;
 
    TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_a(dn), debugstr_a(attr),
           debugstr_a(value) );
 
    if (!ld || !attr) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
 
    attrW = strAtoW( attr );
    if (!attrW) goto exit;
 
    if (value) {
        valueW = strAtoW( value );
        if (!valueW) goto exit;
    }
 
    ret = ldap_compareW( ld, dnW, attrW, valueW );
 
exit:
    strfreeW( dnW );
    strfreeW( attrW );
    strfreeW( valueW );
 
#endif
    return ret;
}

ldap_compareW()

ULONG CDECL ldap_compareW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	attr,
		PWCHAR	value
	)

Definition at line 96 of file compare.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *attrU = NULL, *valueU = NULL;
    struct berval val = { 0, NULL };
    int msg;
 
    ret = ~0u;
 
    TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_w(dn), debugstr_w(attr),
           debugstr_w(value) );
 
    if (!ld || !attr) return ~0u;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
 
    attrU = strWtoU( attr );
    if (!attrU) goto exit;
 
    if (value) {
        valueU = strWtoU( value );
        if (!valueU) goto exit;
 
        val.bv_len = strlen( valueU );
        val.bv_val = valueU;
    }
 
    ret = ldap_compare_ext( ld, dn ? dnU : "", attrU, &val, NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( dnU );
    strfreeU( attrU );
    strfreeU( valueU );
 
#endif
    return ret;
}

ldap_conn_from_msg()

WLDAP32_LDAP *CDECL ldap_conn_from_msg	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	res
	)

Definition at line 135 of file misc.c.

{
    TRACE( "(%p, %p)\n", ld, res );
 
    if (!ld || !res) return NULL;
    return ld; /* FIXME: not always correct */
}

ldap_connect()

ULONG CDECL ldap_connect	(	WLDAP32_LDAP *	ld,
		LDAP_TIMEVAL *	timeout
	)

Definition at line 318 of file init.c.

{
    TRACE( "(%p, %p)\n", ld, timeout );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    return WLDAP32_LDAP_SUCCESS; /* FIXME: do something, e.g. ping the host */
}

ldap_control_freeA()

ULONG CDECL ldap_control_freeA

(

LDAPControlA *

control

)

Definition at line 44 of file control.c.

{
    ULONG ret = WLDAP32_LDAP_SUCCESS;
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", control );
    controlfreeA( control );
 
#endif
    return ret;
}

ldap_control_freeW()

ULONG CDECL ldap_control_freeW

(

LDAPControlW *

control

)

Definition at line 67 of file control.c.

{
    ULONG ret = WLDAP32_LDAP_SUCCESS;
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", control );
    controlfreeW( control );
 
#endif
    return ret;
}

ldap_controls_freeA()

ULONG CDECL ldap_controls_freeA

(

LDAPControlA **

controls

)

Definition at line 84 of file control.c.

{
    ULONG ret = WLDAP32_LDAP_SUCCESS;
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", controls );
    controlarrayfreeA( controls );
 
#endif
    return ret;
}

ldap_controls_freeW()

ULONG CDECL ldap_controls_freeW

(

LDAPControlW **

controls

)

Definition at line 107 of file control.c.

{
    ULONG ret = WLDAP32_LDAP_SUCCESS;
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", controls );
    controlarrayfreeW( controls );
 
#endif
    return ret;
}

ldap_count_valuesA()

ULONG CDECL ldap_count_valuesA

(

PCHAR *

vals

)

Definition at line 72 of file value.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR **valsW = NULL;
 
    TRACE( "(%p)\n", vals );
 
    if (!vals) return 0;
 
    valsW = strarrayAtoW( vals );
    if (!valsW) return WLDAP32_LDAP_NO_MEMORY;
 
    ret = ldap_count_valuesW( valsW );
    strarrayfreeW( valsW );
 
#endif
    return ret;
}

ldap_count_valuesW()

ULONG CDECL ldap_count_valuesW

(

PWCHAR *

vals

)

Definition at line 108 of file value.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR **p = vals;
 
    TRACE( "(%p)\n", vals );
 
    if (!vals) return 0;
 
    ret = 0;
    while (*p++) ret++;
 
#endif
    return ret;
}

ldap_create_page_controlA()

ULONG CDECL ldap_create_page_controlA	(	WLDAP32_PLDAP	,
		ULONG	,
		struct WLDAP32_berval *	,
		UCHAR	,
		PLDAPControlA *
	)

ldap_create_page_controlW()

ULONG CDECL ldap_create_page_controlW	(	WLDAP32_PLDAP	,
		ULONG	,
		struct WLDAP32_berval *	,
		UCHAR	,
		PLDAPControlW *
	)

ldap_create_sort_controlA()

ULONG CDECL ldap_create_sort_controlA	(	WLDAP32_PLDAP	,
		PLDAPSortKeyA *	,
		UCHAR	,
		PLDAPControlA *
	)

ldap_create_sort_controlW()

ULONG CDECL ldap_create_sort_controlW	(	WLDAP32_PLDAP	,
		PLDAPSortKeyW *	,
		UCHAR	,
		PLDAPControlW *
	)

ldap_create_vlv_controlA()

INT CDECL ldap_create_vlv_controlA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPVLVInfo *	info,
		UCHAR	critical,
		LDAPControlA **	control
	)

Definition at line 207 of file control.c.

{
    INT ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    LDAPControlW *controlW = NULL;
 
    TRACE( "(%p, %p, 0x%02x, %p)\n", ld, info, critical, control );
 
    if (!ld || !control) return ~0u;
 
    ret = ldap_create_vlv_controlW( ld, info, critical, &controlW );
 
    if (ret == WLDAP32_LDAP_SUCCESS)
    {
        *control = controlWtoA( controlW );
        if (!*control) ret = WLDAP32_LDAP_NO_MEMORY;
        ldap_control_freeW( controlW );
    }
 
#endif
    return ret;
}

ldap_create_vlv_controlW()

INT CDECL ldap_create_vlv_controlW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPVLVInfo *	info,
		UCHAR	critical,
		LDAPControlW **	control
	)

Definition at line 253 of file control.c.

{
    INT ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    LDAPControl *controlU = NULL;
 
    TRACE( "(%p, %p, 0x%02x, %p)\n", ld, info, critical, control );
 
    if (!ld || !control) return ~0u;
 
    ret = map_error( ldap_create_vlv_control( ld, (LDAPVLVInfo *)info, &controlU ));
 
    if (ret == WLDAP32_LDAP_SUCCESS)
    {
        *control = controlUtoW( controlU );
        if (!*control) ret = WLDAP32_LDAP_NO_MEMORY;
        ldap_control_free( controlU );
    }
 
#endif
    return ret;
}

Referenced by ldap_create_vlv_controlA().

ldap_delete_ext_sA()

ULONG CDECL ldap_delete_ext_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls
	)

Definition at line 224 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    TRACE( "(%p, %s, %p, %p)\n", ld, debugstr_a(dn), serverctrls,
           clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_delete_ext_sW( ld, dnW, serverctrlsW, clientctrlsW );
 
exit:
    strfreeW( dnW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_delete_ext_sW()

ULONG CDECL ldap_delete_ext_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls
	)

Definition at line 280 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    TRACE( "(%p, %s, %p, %p)\n", ld, debugstr_w(dn), serverctrls,
           clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_delete_ext_s( ld, dn ? dnU : "", serverctrlsU, clientctrlsU ));
 
exit:
    strfreeU( dnU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_delete_extA()

ULONG CDECL ldap_delete_extA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		ULONG *	message
	)

Definition at line 118 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    TRACE( "(%p, %s, %p, %p, %p)\n", ld, debugstr_a(dn), serverctrls,
           clientctrls, message );
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_delete_extW( ld, dnW, serverctrlsW, clientctrlsW, message );
 
exit:
    strfreeW( dnW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_delete_extW()

ULONG CDECL ldap_delete_extW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		ULONG *	message
	)

Definition at line 178 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    int dummy;
 
    TRACE( "(%p, %s, %p, %p, %p)\n", ld, debugstr_w(dn), serverctrls,
           clientctrls, message );
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_delete_ext( ld, dn ? dnU : "", serverctrlsU, clientctrlsU,
                                      message ? (int *)message : &dummy ));
 
exit:
    strfreeU( dnU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_delete_sA()

ULONG CDECL ldap_delete_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn
	)

Definition at line 322 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
 
    TRACE( "(%p, %s)\n", ld, debugstr_a(dn) );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) return WLDAP32_LDAP_NO_MEMORY;
    }
 
    ret = ldap_delete_sW( ld, dnW );
    strfreeW( dnW );
 
#endif
    return ret;
}

ldap_delete_sW()

ULONG CDECL ldap_delete_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn
	)

Definition at line 357 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
 
    TRACE( "(%p, %s)\n", ld, debugstr_w(dn) );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) return WLDAP32_LDAP_NO_MEMORY;
    }
 
    ret = map_error( ldap_delete_ext_s( ld, dn ? dnU : "", NULL, NULL ));
    strfreeU( dnU );
 
#endif
    return ret;
}

ldap_deleteA()

ULONG CDECL ldap_deleteA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn
	)

Definition at line 44 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
 
    TRACE( "(%p, %s)\n", ld, debugstr_a(dn) );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) return WLDAP32_LDAP_NO_MEMORY;
    }
 
    ret = ldap_deleteW( ld, dnW );
    strfreeW( dnW );
 
#endif
    return ret;
}

ldap_deleteW()

ULONG CDECL ldap_deleteW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn
	)

Definition at line 84 of file delete.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    int msg;
 
    TRACE( "(%p, %s)\n", ld, debugstr_w(dn) );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) return WLDAP32_LDAP_NO_MEMORY;
    }
 
    ret = ldap_delete_ext( ld, dn ? dnU : "", NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
    strfreeU( dnU );
 
#endif
    return ret;
}

ldap_dn2ufnA()

PCHAR CDECL ldap_dn2ufnA

(

PCHAR

dn

)

Definition at line 44 of file dn.c.

{
    PCHAR ret = NULL;
#ifdef HAVE_LDAP
    WCHAR *dnW, *retW;
 
    TRACE( "(%s)\n", debugstr_a(dn) );
 
    dnW = strAtoW( dn );
    if (!dnW) return NULL;
 
    retW = ldap_dn2ufnW( dnW );
    ret = strWtoA( retW );
 
    strfreeW( dnW );
    ldap_memfreeW( retW );
 
#endif
    return ret;
}

ldap_dn2ufnW()

PWCHAR CDECL ldap_dn2ufnW

(

PWCHAR

dn

)

Definition at line 80 of file dn.c.

{
    PWCHAR ret = NULL;
#ifdef HAVE_LDAP
    char *dnU, *retU;
 
    TRACE( "(%s)\n", debugstr_w(dn) );
 
    dnU = strWtoU( dn );
    if (!dnU) return NULL;
 
    retU = ldap_dn2ufn( dnU );
    ret = strUtoW( retU );
 
    strfreeU( dnU );
    ldap_memfree( retU );
 
#endif
    return ret;
}

ldap_encode_sort_controlA()

ULONG CDECL ldap_encode_sort_controlA	(	WLDAP32_PLDAP	,
		PLDAPSortKeyA *	,
		PLDAPControlA	,
		BOOLEAN
	)

ldap_encode_sort_controlW()

ULONG CDECL ldap_encode_sort_controlW	(	WLDAP32_PLDAP	,
		PLDAPSortKeyW *	,
		PLDAPControlW	,
		BOOLEAN
	)

ldap_err2stringA()

PCHAR CDECL ldap_err2stringA

(

ULONG

err

)

Definition at line 71 of file error.c.

{
    static char buf[256] = "";
 
    TRACE( "(0x%08x)\n", err );
 
    if (err <= WLDAP32_LDAP_REFERRAL_LIMIT_EXCEEDED)
        LoadStringA( hwldap32, err, buf, 256 );
    else
        LoadStringA( hwldap32, WLDAP32_LDAP_LOCAL_ERROR, buf, 256 );
 
    return buf;
}

ldap_err2stringW()

PWCHAR CDECL ldap_err2stringW

(

ULONG

err

)

Definition at line 101 of file error.c.

{
    static WCHAR buf[256] = { 0 };
 
    TRACE( "(0x%08x)\n", err );
 
    if (err <= WLDAP32_LDAP_REFERRAL_LIMIT_EXCEEDED)
        LoadStringW( hwldap32, err, buf, 256 );
    else
        LoadStringW( hwldap32, WLDAP32_LDAP_LOCAL_ERROR, buf, 256 );
 
    return buf;
}

ldap_escape_filter_elementA()

ULONG CDECL ldap_escape_filter_elementA	(	PCHAR	src,
		ULONG	srclen,
		PCHAR	dst,
		ULONG	dstlen
	)

Definition at line 239 of file misc.c.

{
    ULONG len;
 
    TRACE( "(%p, 0x%08x, %p, 0x%08x)\n", src, srclen, dst, dstlen );
 
    len = get_escape_size( src, srclen );
    if (!dst) return len;
 
    if (!src || dstlen < len)
        return WLDAP32_LDAP_PARAM_ERROR;
    else
    {
        escape_filter_element( src, srclen, dst );
        return WLDAP32_LDAP_SUCCESS;
    }
}

ldap_escape_filter_elementW()

ULONG CDECL ldap_escape_filter_elementW	(	PCHAR	src,
		ULONG	srclen,
		PWCHAR	dst,
		ULONG	dstlen
	)

Definition at line 272 of file misc.c.

{
    ULONG len;
 
    TRACE( "(%p, 0x%08x, %p, 0x%08x)\n", src, srclen, dst, dstlen );
 
    len = get_escape_size( src, srclen );
    if (!dst) return len;
 
    /* no matter what you throw at it, this is what native returns */
    return WLDAP32_LDAP_PARAM_ERROR;
}

ldap_explode_dnA()

PCHAR *CDECL ldap_explode_dnA	(	PCHAR	dn,
		ULONG	notypes
	)

Definition at line 106 of file dn.c.

{
    PCHAR *ret = NULL;
#ifdef HAVE_LDAP
    WCHAR *dnW, **retW;
 
    TRACE( "(%s, 0x%08x)\n", debugstr_a(dn), notypes );
 
    dnW = strAtoW( dn );
    if (!dnW) return NULL;
 
    retW = ldap_explode_dnW( dnW, notypes );
    ret = strarrayWtoA( retW );
 
    strfreeW( dnW );
    ldap_value_freeW( retW );
 
#endif
    return ret;
}

ldap_explode_dnW()

PWCHAR *CDECL ldap_explode_dnW	(	PWCHAR	dn,
		ULONG	notypes
	)

Definition at line 144 of file dn.c.

{
    PWCHAR *ret = NULL;
#ifdef HAVE_LDAP
    char *dnU, **retU;
 
    TRACE( "(%s, 0x%08x)\n", debugstr_w(dn), notypes );
 
    dnU = strWtoU( dn );
    if (!dnU) return NULL;
 
    retU = ldap_explode_dn( dnU, notypes );
    ret = strarrayUtoW( retU );
 
    strfreeU( dnU );
    ldap_memvfree( (void **)retU );
 
#endif
    return ret;
}

ldap_extended_operation_sA()

ULONG CDECL ldap_extended_operation_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	oid,
		struct WLDAP32_berval *	data,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		PCHAR *	retoid,
		struct WLDAP32_berval **	retdata
	)

Definition at line 178 of file extended.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *oidW = NULL, *retoidW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p, %p)\n", ld, debugstr_a(oid), data, serverctrls,
           clientctrls, retoid, retdata );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (oid) {
        oidW = strAtoW( oid );
        if (!oidW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_extended_operation_sW( ld, oidW, data, serverctrlsW, clientctrlsW,
                                      &retoidW, retdata );
 
    if (retoid && retoidW) {
        *retoid = strWtoA( retoidW );
        if (!*retoid) ret = WLDAP32_LDAP_NO_MEMORY;
        ldap_memfreeW( retoidW );
    }
 
exit:
    strfreeW( oidW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_extended_operation_sW()

ULONG CDECL ldap_extended_operation_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	oid,
		struct WLDAP32_berval *	data,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		PWCHAR *	retoid,
		struct WLDAP32_berval **	retdata
	)

Definition at line 249 of file extended.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *oidU = NULL, *retoidU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p, %p)\n", ld, debugstr_w(oid), data, serverctrls,
           clientctrls, retoid, retdata );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (oid) {
        oidU = strWtoU( oid );
        if (!oidU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_extended_operation_s( ld, oid ? oidU : "", (struct berval *)data, serverctrlsU,
                                                clientctrlsU, &retoidU, (struct berval **)retdata ));
 
    if (retoid && retoidU) {
        *retoid = strUtoW( retoidU );
        if (!*retoid) ret = WLDAP32_LDAP_NO_MEMORY;
        ldap_memfree( retoidU );
    }
 
exit:
    strfreeU( oidU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

Referenced by ldap_extended_operation_sA().

ldap_extended_operationA()

ULONG CDECL ldap_extended_operationA	(	WLDAP32_LDAP *	ld,
		PCHAR	oid,
		struct WLDAP32_berval *	data,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		ULONG *	message
	)

Definition at line 69 of file extended.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *oidW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p)\n", ld, debugstr_a(oid), data, serverctrls,
           clientctrls, message );
 
    if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (oid) {
        oidW = strAtoW( oid );
        if (!oidW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_extended_operationW( ld, oidW, data, serverctrlsW, clientctrlsW, message );
 
exit:
    strfreeW( oidW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_extended_operationW()

ULONG CDECL ldap_extended_operationW	(	WLDAP32_LDAP *	ld,
		PWCHAR	oid,
		struct WLDAP32_berval *	data,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		ULONG *	message
	)

Definition at line 133 of file extended.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *oidU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p)\n", ld, debugstr_w(oid), data, serverctrls,
           clientctrls, message );
 
    if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (oid) {
        oidU = strWtoU( oid );
        if (!oidU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_extended_operation( ld, oid ? oidU : "", (struct berval *)data,
                                              serverctrlsU, clientctrlsU, (int *)message ));
 
exit:
    strfreeU( oidU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

Referenced by ldap_extended_operationA().

ldap_first_attributeA()

PCHAR CDECL ldap_first_attributeA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry,
		WLDAP32_BerElement **	ptr
	)

Definition at line 290 of file misc.c.

{
    PCHAR ret = NULL;
#ifdef HAVE_LDAP
    WCHAR *retW;
 
    TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 
    if (!ld || !entry) return NULL;
    retW = ldap_first_attributeW( ld, entry, ptr );
 
    ret = strWtoA( retW );
    ldap_memfreeW( retW );
 
#endif
    return ret;
}

ldap_first_attributeW()

PWCHAR CDECL ldap_first_attributeW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry,
		WLDAP32_BerElement **	ptr
	)

Definition at line 326 of file misc.c.

{
    PWCHAR ret = NULL;
#ifdef HAVE_LDAP
    char *retU;
 
    TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 
    if (!ld || !entry) return NULL;
    retU = ldap_first_attribute( ld, entry, ptr );
 
    ret = strUtoW( retU );
    ldap_memfree( retU );
 
#endif
    return ret;
}

ldap_free_controlsA()

ULONG CDECL ldap_free_controlsA

(

LDAPControlA **

controls

)

Definition at line 352 of file control.c.

{
    return ldap_controls_freeA( controls );
}

ldap_free_controlsW()

ULONG CDECL ldap_free_controlsW

(

LDAPControlW **

controls

)

Definition at line 371 of file control.c.

{
    return ldap_controls_freeW( controls );
}

ldap_get_dnA()

PCHAR CDECL ldap_get_dnA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry
	)

Definition at line 170 of file dn.c.

{
    PCHAR ret = NULL;
#ifdef HAVE_LDAP
    PWCHAR retW;
 
    TRACE( "(%p, %p)\n", ld, entry );
 
    if (!ld || !entry) return NULL;
 
    retW = ldap_get_dnW( ld, entry );
 
    ret = strWtoA( retW );
    ldap_memfreeW( retW );
 
#endif
    return ret;
}

ldap_get_dnW()

PWCHAR CDECL ldap_get_dnW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry
	)

Definition at line 205 of file dn.c.

{
    PWCHAR ret = NULL;
#ifdef HAVE_LDAP
    char *retU;
 
    TRACE( "(%p, %p)\n", ld, entry );
 
    if (!ld || !entry) return NULL;
 
    retU = ldap_get_dn( ld, entry );
 
    ret = strUtoW( retU );
    ldap_memfree( retU );
 
#endif
    return ret;
}

ldap_get_next_page()

ULONG CDECL ldap_get_next_page	(	WLDAP32_LDAP *	ld,
		PLDAPSearch	search,
		ULONG	pagesize,
		ULONG *	message
	)

Definition at line 161 of file page.c.

{
    FIXME( "(%p, %p, 0x%08x, %p)\n", ld, search, pagesize, message );
 
    if (!ld) return ~0u;
    return WLDAP32_LDAP_NOT_SUPPORTED;
}

ldap_get_next_page_s()

ULONG CDECL ldap_get_next_page_s	(	WLDAP32_LDAP *	ld,
		PLDAPSearch	search,
		struct l_timeval *	timeout,
		ULONG	pagesize,
		ULONG *	count,
		WLDAP32_LDAPMessage **	results
	)

Definition at line 170 of file page.c.

{
    FIXME( "(%p, %p, %p, 0x%08x, %p, %p)\n", ld, search, timeout,
           pagesize, count, results );
 
    if (!ld) return ~0u;
    return WLDAP32_LDAP_NOT_SUPPORTED;
}

ldap_get_optionA()

ULONG CDECL ldap_get_optionA	(	WLDAP32_LDAP *	ld,
		int	option,
		void *	value
	)

Definition at line 44 of file option.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p, 0x%08x, %p)\n", ld, option, value );
 
    if (!ld || !value) return WLDAP32_LDAP_PARAM_ERROR;
 
    switch (option)
    {
    case WLDAP32_LDAP_OPT_API_FEATURE_INFO:
    {
        LDAPAPIFeatureInfoW featureW;
        LDAPAPIFeatureInfoA *featureA = value;
 
        if (!featureA->ldapaif_name) return WLDAP32_LDAP_PARAM_ERROR;
 
        featureW.ldapaif_info_version = featureA->ldapaif_info_version;
        featureW.ldapaif_name = strAtoW( featureA->ldapaif_name );
        featureW.ldapaif_version = 0;
 
        if (!featureW.ldapaif_name) return WLDAP32_LDAP_NO_MEMORY;
 
        ret = ldap_get_optionW( ld, option, &featureW );
 
        featureA->ldapaif_version = featureW.ldapaif_version;
        strfreeW( featureW.ldapaif_name );
        return ret;
    }
    case WLDAP32_LDAP_OPT_API_INFO:
    {
        LDAPAPIInfoW infoW;
        LDAPAPIInfoA *infoA = value;
 
        memset( &infoW, 0, sizeof(LDAPAPIInfoW) );
        infoW.ldapai_info_version = infoA->ldapai_info_version;
 
        ret = ldap_get_optionW( ld, option, &infoW );
 
        infoA->ldapai_api_version = infoW.ldapai_api_version;
        infoA->ldapai_protocol_version = infoW.ldapai_protocol_version;
 
        if (infoW.ldapai_extensions)
        {
            infoA->ldapai_extensions = strarrayWtoA( infoW.ldapai_extensions );
            if (!infoA->ldapai_extensions) return WLDAP32_LDAP_NO_MEMORY;
        }
        if (infoW.ldapai_vendor_name)
        {
            infoA->ldapai_vendor_name = strWtoA( infoW.ldapai_vendor_name );
            if (!infoA->ldapai_vendor_name)
            {
                ldap_value_freeW( infoW.ldapai_extensions );
                return WLDAP32_LDAP_NO_MEMORY;
            }
        }
        infoA->ldapai_vendor_version = infoW.ldapai_vendor_version;
 
        ldap_value_freeW( infoW.ldapai_extensions );
        ldap_memfreeW( infoW.ldapai_vendor_name );
        return ret;
    }
 
    case WLDAP32_LDAP_OPT_DEREF:
    case WLDAP32_LDAP_OPT_DESC:
    case WLDAP32_LDAP_OPT_ERROR_NUMBER:
    case WLDAP32_LDAP_OPT_PROTOCOL_VERSION:
    case WLDAP32_LDAP_OPT_REFERRALS:
    case WLDAP32_LDAP_OPT_SIZELIMIT:
    case WLDAP32_LDAP_OPT_TIMELIMIT:
        return ldap_get_optionW( ld, option, value );
 
    case WLDAP32_LDAP_OPT_CACHE_ENABLE:
    case WLDAP32_LDAP_OPT_CACHE_FN_PTRS:
    case WLDAP32_LDAP_OPT_CACHE_STRATEGY:
    case WLDAP32_LDAP_OPT_IO_FN_PTRS:
    case WLDAP32_LDAP_OPT_REBIND_ARG:
    case WLDAP32_LDAP_OPT_REBIND_FN:
    case WLDAP32_LDAP_OPT_RESTART:
    case WLDAP32_LDAP_OPT_THREAD_FN_PTRS:
        return LDAP_LOCAL_ERROR;
 
    case WLDAP32_LDAP_OPT_AREC_EXCLUSIVE:
    case WLDAP32_LDAP_OPT_AUTO_RECONNECT:
    case WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE:
    case WLDAP32_LDAP_OPT_DNSDOMAIN_NAME:
    case WLDAP32_LDAP_OPT_ENCRYPT:
    case WLDAP32_LDAP_OPT_ERROR_STRING:
    case WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND:
    case WLDAP32_LDAP_OPT_GETDSNAME_FLAGS:
    case WLDAP32_LDAP_OPT_HOST_NAME:
    case WLDAP32_LDAP_OPT_HOST_REACHABLE:
    case WLDAP32_LDAP_OPT_PING_KEEP_ALIVE:
    case WLDAP32_LDAP_OPT_PING_LIMIT:
    case WLDAP32_LDAP_OPT_PING_WAIT_TIME:
    case WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS:
    case WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG:
    case WLDAP32_LDAP_OPT_REFERRAL_CALLBACK:
    case WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT:
    case WLDAP32_LDAP_OPT_ROOTDSE_CACHE:
    case WLDAP32_LDAP_OPT_SASL_METHOD:
    case WLDAP32_LDAP_OPT_SECURITY_CONTEXT:
    case WLDAP32_LDAP_OPT_SEND_TIMEOUT:
    case WLDAP32_LDAP_OPT_SERVER_CERTIFICATE:
    case WLDAP32_LDAP_OPT_SERVER_CONTROLS:
    case WLDAP32_LDAP_OPT_SERVER_ERROR:
    case WLDAP32_LDAP_OPT_SERVER_EXT_ERROR:
    case WLDAP32_LDAP_OPT_SIGN:
    case WLDAP32_LDAP_OPT_SSL:
    case WLDAP32_LDAP_OPT_SSL_INFO:
    case WLDAP32_LDAP_OPT_SSPI_FLAGS:
    case WLDAP32_LDAP_OPT_TCP_KEEPALIVE:
        FIXME( "Unsupported option: 0x%02x\n", option );
        return WLDAP32_LDAP_NOT_SUPPORTED;
 
    default:
        FIXME( "Unknown option: 0x%02x\n", option );
        return WLDAP32_LDAP_LOCAL_ERROR;
    }
 
#endif
    return ret;
}

ldap_get_optionW()

ULONG CDECL ldap_get_optionW	(	WLDAP32_LDAP *	ld,
		int	option,
		void *	value
	)

Definition at line 183 of file option.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p, 0x%08x, %p)\n", ld, option, value );
 
    if (!ld || !value) return WLDAP32_LDAP_PARAM_ERROR;
 
    switch (option)
    {
    case WLDAP32_LDAP_OPT_API_FEATURE_INFO:
    {
        LDAPAPIFeatureInfo featureU;
        LDAPAPIFeatureInfoW *featureW = value;
 
        if (!featureW->ldapaif_name) return WLDAP32_LDAP_PARAM_ERROR;
 
        featureU.ldapaif_info_version = featureW->ldapaif_info_version;
        featureU.ldapaif_name = strWtoU( featureW->ldapaif_name );
        featureU.ldapaif_version = 0;
 
        if (!featureU.ldapaif_name) return WLDAP32_LDAP_NO_MEMORY;
 
        ret = map_error( ldap_get_option( ld, option, &featureU ));
 
        featureW->ldapaif_version = featureU.ldapaif_version;
        strfreeU( featureU.ldapaif_name );
        return ret;
    }
    case WLDAP32_LDAP_OPT_API_INFO:
    {
        LDAPAPIInfo infoU;
        LDAPAPIInfoW *infoW = value;
 
        memset( &infoU, 0, sizeof(LDAPAPIInfo) );
        infoU.ldapai_info_version = infoW->ldapai_info_version;
 
        ret = map_error( ldap_get_option( ld, option, &infoU ));
 
        infoW->ldapai_api_version = infoU.ldapai_api_version;
        infoW->ldapai_protocol_version = infoU.ldapai_protocol_version;
 
        if (infoU.ldapai_extensions)
        {
            infoW->ldapai_extensions = strarrayUtoW( infoU.ldapai_extensions );
            if (!infoW->ldapai_extensions) return WLDAP32_LDAP_NO_MEMORY;
        }
        if (infoU.ldapai_vendor_name)
        {
            infoW->ldapai_vendor_name = strUtoW( infoU.ldapai_vendor_name );
            if (!infoW->ldapai_vendor_name)
            {
                ldap_memvfree( (void **)infoU.ldapai_extensions );
                return WLDAP32_LDAP_NO_MEMORY;
            }
        }
        infoW->ldapai_vendor_version = infoU.ldapai_vendor_version;
 
        ldap_memvfree( (void **)infoU.ldapai_extensions );
        ldap_memfree( infoU.ldapai_vendor_name );
        return ret;
    }
 
    case WLDAP32_LDAP_OPT_DEREF:
    case WLDAP32_LDAP_OPT_DESC:
    case WLDAP32_LDAP_OPT_ERROR_NUMBER:
    case WLDAP32_LDAP_OPT_PROTOCOL_VERSION:
    case WLDAP32_LDAP_OPT_REFERRALS:
    case WLDAP32_LDAP_OPT_SIZELIMIT:
    case WLDAP32_LDAP_OPT_TIMELIMIT:
        return map_error( ldap_get_option( ld, option, value ));
 
    case WLDAP32_LDAP_OPT_CACHE_ENABLE:
    case WLDAP32_LDAP_OPT_CACHE_FN_PTRS:
    case WLDAP32_LDAP_OPT_CACHE_STRATEGY:
    case WLDAP32_LDAP_OPT_IO_FN_PTRS:
    case WLDAP32_LDAP_OPT_REBIND_ARG:
    case WLDAP32_LDAP_OPT_REBIND_FN:
    case WLDAP32_LDAP_OPT_RESTART:
    case WLDAP32_LDAP_OPT_THREAD_FN_PTRS:
        return WLDAP32_LDAP_LOCAL_ERROR;
 
    case WLDAP32_LDAP_OPT_AREC_EXCLUSIVE:
    case WLDAP32_LDAP_OPT_AUTO_RECONNECT:
    case WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE:
    case WLDAP32_LDAP_OPT_DNSDOMAIN_NAME:
    case WLDAP32_LDAP_OPT_ENCRYPT:
    case WLDAP32_LDAP_OPT_ERROR_STRING:
    case WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND:
    case WLDAP32_LDAP_OPT_GETDSNAME_FLAGS:
    case WLDAP32_LDAP_OPT_HOST_NAME:
    case WLDAP32_LDAP_OPT_HOST_REACHABLE:
    case WLDAP32_LDAP_OPT_PING_KEEP_ALIVE:
    case WLDAP32_LDAP_OPT_PING_LIMIT:
    case WLDAP32_LDAP_OPT_PING_WAIT_TIME:
    case WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS:
    case WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG:
    case WLDAP32_LDAP_OPT_REFERRAL_CALLBACK:
    case WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT:
    case WLDAP32_LDAP_OPT_ROOTDSE_CACHE:
    case WLDAP32_LDAP_OPT_SASL_METHOD:
    case WLDAP32_LDAP_OPT_SECURITY_CONTEXT:
    case WLDAP32_LDAP_OPT_SEND_TIMEOUT:
    case WLDAP32_LDAP_OPT_SERVER_CERTIFICATE:
    case WLDAP32_LDAP_OPT_SERVER_CONTROLS:
    case WLDAP32_LDAP_OPT_SERVER_ERROR:
    case WLDAP32_LDAP_OPT_SERVER_EXT_ERROR:
    case WLDAP32_LDAP_OPT_SIGN:
    case WLDAP32_LDAP_OPT_SSL:
    case WLDAP32_LDAP_OPT_SSL_INFO:
    case WLDAP32_LDAP_OPT_SSPI_FLAGS:
    case WLDAP32_LDAP_OPT_TCP_KEEPALIVE:
        FIXME( "Unsupported option: 0x%02x\n", option );
        return WLDAP32_LDAP_NOT_SUPPORTED;
 
    default:
        FIXME( "Unknown option: 0x%02x\n", option );
        return WLDAP32_LDAP_LOCAL_ERROR;
    }
 
#endif
    return ret;
}

ldap_get_paged_count()

ULONG CDECL ldap_get_paged_count	(	WLDAP32_LDAP *	ld,
		PLDAPSearch	search,
		ULONG *	count,
		WLDAP32_LDAPMessage *	results
	)

Definition at line 181 of file page.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    FIXME( "(%p, %p, %p, %p)\n", ld, search, count, results );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    /* FIXME: save the cookie from the server here */
 
#endif
    return ret;
}

ldap_get_values_lenA()

PBERVAL *CDECL ldap_get_values_lenA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	message,
		PCHAR	attr
	)

Definition at line 249 of file value.c.

{
#ifdef HAVE_LDAP
    WCHAR *attrW = NULL;
    struct WLDAP32_berval **ret;
 
    TRACE( "(%p, %p, %s)\n", ld, message, debugstr_a(attr) );
 
    if (!ld || !message || !attr) return NULL;
 
    attrW = strAtoW( attr );
    if (!attrW) return NULL;
 
    ret = ldap_get_values_lenW( ld, message, attrW );
 
    strfreeW( attrW );
    return ret;
 
#else
    return NULL;
#endif
}

ldap_get_values_lenW()

PBERVAL *CDECL ldap_get_values_lenW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	message,
		PWCHAR	attr
	)

Definition at line 292 of file value.c.

{
#ifdef HAVE_LDAP
    char *attrU = NULL;
    struct berval **ret;
 
    TRACE( "(%p, %p, %s)\n", ld, message, debugstr_w(attr) );
 
    if (!ld || !message || !attr) return NULL;
 
    attrU = strWtoU( attr );
    if (!attrU) return NULL;
 
    ret = ldap_get_values_len( ld, message, attrU );
 
    strfreeU( attrU );
    return (struct WLDAP32_berval **)ret;
 
#else
    return NULL;
#endif
}

ldap_get_valuesA()

PCHAR *CDECL ldap_get_valuesA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry,
		PCHAR	attr
	)

Definition at line 130 of file value.c.

{
    PCHAR *ret = NULL;
#ifdef HAVE_LDAP
    WCHAR *attrW = NULL, **retW;
 
    TRACE( "(%p, %p, %s)\n", ld, entry, debugstr_a(attr) );
 
    if (!ld || !entry || !attr) return NULL;
 
    attrW = strAtoW( attr );
    if (!attrW) return NULL;
 
    retW = ldap_get_valuesW( ld, entry, attrW );
 
    ret = strarrayWtoA( retW );
    ldap_value_freeW( retW );
    strfreeW( attrW );
 
#endif
    return ret;
}

ldap_get_valuesW()

PWCHAR *CDECL ldap_get_valuesW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry,
		PWCHAR	attr
	)

Definition at line 217 of file value.c.

{
    PWCHAR *ret = NULL;
#ifdef HAVE_LDAP
    char *attrU = NULL, **retU;
    struct berval **bv;
 
    TRACE( "(%p, %p, %s)\n", ld, entry, debugstr_w(attr) );
 
    if (!ld || !entry || !attr) return NULL;
 
    attrU = strWtoU( attr );
    if (!attrU) return NULL;
 
    bv = ldap_get_values_len( ld, entry, attrU );
 
    retU = bv2str_array( bv );
    ret = strarrayUtoW( retU );
 
    ldap_value_free_len( bv );
    strarrayfreeU( retU );
    strfreeU( attrU );
 
#endif
    return ret;
}

ldap_initA()

WLDAP32_LDAP *CDECL ldap_initA	(	const	PCHAR,
		ULONG	portnumber
	)

Definition at line 331 of file init.c.

{
#ifdef HAVE_LDAP
    WLDAP32_LDAP *ld = NULL;
    WCHAR *hostnameW = NULL;
 
    TRACE( "(%s, %d)\n", debugstr_a(hostname), portnumber );
 
    if (hostname) {
        hostnameW = strAtoW( hostname );
        if (!hostnameW) goto exit;
    }
 
    ld = ldap_initW( hostnameW, portnumber );
 
exit:
    strfreeW( hostnameW );
    return ld;
 
#else
    return NULL;
#endif
}

ldap_initW()

WLDAP32_LDAP *CDECL ldap_initW	(	const	PWCHAR,
		ULONG	portnumber
	)

Definition at line 377 of file init.c.

{
#ifdef HAVE_LDAP
    LDAP *ld = NULL;
    char *hostnameU = NULL, *url = NULL;
 
    TRACE( "(%s, %d)\n", debugstr_w(hostname), portnumber );
 
    if (hostname) {
        hostnameU = strWtoU( hostname );
        if (!hostnameU) goto exit;
    }
    else {
        hostnameU = strWtoU( defaulthost );
        if (!hostnameU) goto exit;
    }
 
    url = urlify_hostnames( "ldap://", hostnameU, portnumber );
    if (!url) goto exit;
 
    ld = create_context( url );
 
exit:
    strfreeU( hostnameU );
    strfreeU( url );
    return ld;
 
#else
    return NULL;
#endif
}

ldap_memfreeA()

void CDECL ldap_memfreeA

(

PCHAR

block

)

Definition at line 407 of file misc.c.

{
    TRACE( "(%p)\n", block );
    strfreeA( block );
}

ldap_memfreeW()

void CDECL ldap_memfreeW

(

PWCHAR

block

)

Definition at line 421 of file misc.c.

{
    TRACE( "(%p)\n", block );
    strfreeW( block );
}

ldap_modify_ext_sA()

ULONG CDECL ldap_modify_ext_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	mods[],
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls
	)

Definition at line 264 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **modsW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p)\n", ld, debugstr_a(dn), mods,
           serverctrls, clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (mods) {
        modsW = modarrayAtoW( mods );
        if (!modsW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_modify_ext_sW( ld, dnW, modsW, serverctrlsW, clientctrlsW );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( modsW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_modify_ext_sW()

ULONG CDECL ldap_modify_ext_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	mods[],
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls
	)

Definition at line 330 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **modsU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p)\n", ld, debugstr_w(dn), mods,
           serverctrls, clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (mods) {
        modsU = modarrayWtoU( mods );
        if (!modsU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_modify_ext_s( ld, dn ? dnU : "", mods ? modsU : nullmods,
                                        serverctrlsU, clientctrlsU ));
 
exit:
    strfreeU( dnU );
    modarrayfreeU( modsU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_modify_extA()

ULONG CDECL ldap_modify_extA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	mods[],
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		ULONG *	message
	)

Definition at line 144 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **modsW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn), mods,
           serverctrls, clientctrls, message );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (mods) {
        modsW = modarrayAtoW( mods );
        if (!modsW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_modify_extW( ld, dnW, modsW, serverctrlsW, clientctrlsW, message );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( modsW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_modify_extW()

ULONG CDECL ldap_modify_extW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	mods[],
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		ULONG *	message
	)

Definition at line 212 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **modsU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    int dummy;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn), mods,
           serverctrls, clientctrls, message );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (mods) {
        modsU = modarrayWtoU( mods );
        if (!modsU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_modify_ext( ld, dn ? dnU : "", mods ? modsU : nullmods, serverctrlsU,
                                      clientctrlsU, message ? (int *)message : &dummy ));
 
exit:
    strfreeU( dnU );
    modarrayfreeU( modsU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_modify_sA()

ULONG CDECL ldap_modify_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	mods[]
	)

Definition at line 381 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **modsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), mods );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (mods) {
        modsW = modarrayAtoW( mods );
        if (!modsW) goto exit;
    }
 
    ret = ldap_modify_sW( ld, dnW, modsW );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( modsW );
 
#endif
    return ret;
}

ldap_modify_sW()

ULONG CDECL ldap_modify_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	mods[]
	)

Definition at line 428 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **modsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), mods );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (mods) {
        modsU = modarrayWtoU( mods );
        if (!modsU) goto exit;
    }
 
    ret = map_error( ldap_modify_ext_s( ld, dn ? dnU : "", mods ? modsU : nullmods, NULL, NULL ));
 
exit:
    strfreeU( dnU );
    modarrayfreeU( modsU );
 
#endif
    return ret;
}

ldap_modifyA()

ULONG CDECL ldap_modifyA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		LDAPModA *	mods[]
	)

Definition at line 48 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL;
    LDAPModW **modsW = NULL;
    
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), mods );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (mods) {
        modsW = modarrayAtoW( mods );
        if (!modsW) goto exit;
    }
 
    ret = ldap_modifyW( ld, dnW, modsW );
 
exit:
    strfreeW( dnW );
    modarrayfreeW( modsW );
 
#endif
    return ret;
}

ldap_modifyW()

ULONG CDECL ldap_modifyW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		LDAPModW *	mods[]
	)

Definition at line 100 of file modify.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL;
    LDAPMod **modsU = NULL;
    int msg;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), mods );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (mods) {
        modsU = modarrayWtoU( mods );
        if (!modsU) goto exit;
    }
 
    ret = ldap_modify_ext( ld, dn ? dnU : "", mods ? modsU : nullmods,
                           NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( dnU );
    modarrayfreeU( modsU );
 
#endif
    return ret;
}

ldap_modrdn2_sA()

ULONG CDECL ldap_modrdn2_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	newdn,
		INT	delete
	)

Definition at line 225 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *newdnW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%02x)\n", ld, debugstr_a(dn), newdn, delete );
 
    if (!ld || !newdn) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
 
    newdnW = strAtoW( newdn );
    if (!newdnW) goto exit;
 
    ret = ldap_modrdn2_sW( ld, dnW, newdnW, delete );
 
exit:
    strfreeW( dnW );
    strfreeW( newdnW );
 
#endif
    return ret;
}

ldap_modrdn2_sW()

ULONG CDECL ldap_modrdn2_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	newdn,
		INT	delete
	)

Definition at line 270 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *newdnU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%02x)\n", ld, debugstr_w(dn), newdn, delete );
 
    if (!ld || !newdn) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
 
    newdnU = strWtoU( newdn );
    if (!newdnU) goto exit;
 
    ret = map_error( ldap_rename_s( ld, dn ? dnU : "", newdnU, NULL, delete, NULL, NULL ));
 
exit:
    strfreeU( dnU );
    strfreeU( newdnU );
 
#endif
    return ret;
}

ldap_modrdn2A()

ULONG CDECL ldap_modrdn2A	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	newdn,
		INT	delete
	)

Definition at line 134 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *newdnW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%02x)\n", ld, debugstr_a(dn), newdn, delete );
 
    if (!ld || !newdn) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
 
    newdnW = strAtoW( newdn );
    if (!newdnW) goto exit;
 
    ret = ldap_modrdn2W( ld, dnW, newdnW, delete );
 
exit:
    strfreeW( dnW );
    strfreeW( newdnW );
 
#endif
    return ret;
}

ldap_modrdn2W()

ULONG CDECL ldap_modrdn2W	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	newdn,
		INT	delete
	)

Definition at line 184 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *newdnU = NULL;
    int msg;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p, 0x%02x)\n", ld, debugstr_w(dn), newdn, delete );
 
    if (!ld || !newdn) return ~0u;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
 
    newdnU = strWtoU( newdn );
    if (!newdnU) goto exit;
 
    ret = ldap_rename( ld, dn ? dnU : "", newdnU, NULL, delete, NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( dnU );
    strfreeU( newdnU );
 
#endif
    return ret;
}

ldap_modrdn_sA()

ULONG CDECL ldap_modrdn_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	newdn
	)

Definition at line 305 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *newdnW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), newdn );
 
    if (!ld || !newdn) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
 
    newdnW = strAtoW( newdn );
    if (!newdnW) goto exit;
 
    ret = ldap_modrdn_sW( ld, dnW, newdnW );
 
exit:
    strfreeW( dnW );
    strfreeW( newdnW );
 
#endif
    return ret;
}

ldap_modrdn_sW()

ULONG CDECL ldap_modrdn_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	newdn
	)

Definition at line 349 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *newdnU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), newdn );
 
    if (!ld || !newdn) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
 
    newdnU = strWtoU( newdn );
    if (!newdnU) goto exit;
 
    ret = map_error( ldap_rename_s( ld, dn ? dnU : "", newdnU, NULL, 1, NULL, NULL ));
 
exit:
    strfreeU( dnU );
    strfreeU( newdnU );
 
#endif
    return ret;
}

ldap_modrdnA()

ULONG CDECL ldap_modrdnA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	newdn
	)

Definition at line 44 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *newdnW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s)\n", ld, debugstr_a(dn), debugstr_a(newdn) );
 
    if (!ld || !newdn) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
 
    newdnW = strAtoW( newdn );
    if (!newdnW) goto exit;
 
    ret = ldap_modrdnW( ld, dnW, newdnW );
 
exit:
    strfreeW( dnW );
    strfreeW( newdnW );
 
#endif
    return ret;
}

ldap_modrdnW()

ULONG CDECL ldap_modrdnW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	newdn
	)

Definition at line 93 of file modrdn.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *newdnU = NULL;
    int msg;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s)\n", ld, debugstr_w(dn), debugstr_w(newdn) );
 
    if (!ld || !newdn) return ~0u;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
 
    newdnU = strWtoU( newdn );
    if (!newdnU) goto exit;
 
    ret = ldap_rename( ld, dn ? dnU : "", newdnU, NULL, 1, NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( dnU );
    strfreeU( newdnU );
 
#endif
    return ret;
}

ldap_next_attributeA()

PCHAR CDECL ldap_next_attributeA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry,
		WLDAP32_BerElement *	ptr
	)

Definition at line 452 of file misc.c.

{
    PCHAR ret = NULL;
#ifdef HAVE_LDAP
    WCHAR *retW;
 
    TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 
    if (!ld || !entry || !ptr) return NULL;
    retW = ldap_next_attributeW( ld, entry, ptr );
 
    ret = strWtoA( retW );
    ldap_memfreeW( retW );
 
#endif
    return ret;
}

ldap_next_attributeW()

PWCHAR CDECL ldap_next_attributeW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry,
		WLDAP32_BerElement *	ptr
	)

Definition at line 489 of file misc.c.

{
    PWCHAR ret = NULL;
#ifdef HAVE_LDAP
    char *retU;
 
    TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 
    if (!ld || !entry || !ptr) return NULL;
    retU = ldap_next_attribute( ld, entry, ptr );
 
    ret = strUtoW( retU );
    ldap_memfree( retU );
 
#endif
    return ret;
}

ldap_openA()

WLDAP32_LDAP *CDECL ldap_openA	(	PCHAR	hostname,
		ULONG	portnumber
	)

Definition at line 414 of file init.c.

{
#ifdef HAVE_LDAP
    WLDAP32_LDAP *ld = NULL;
    WCHAR *hostnameW = NULL;
 
    TRACE( "(%s, %d)\n", debugstr_a(hostname), portnumber );
 
    if (hostname) {
        hostnameW = strAtoW( hostname );
        if (!hostnameW) goto exit;
    }
 
    ld = ldap_openW( hostnameW, portnumber );
 
exit:
    strfreeW( hostnameW );
    return ld;
 
#else
    return NULL;
#endif
}

ldap_openW()

WLDAP32_LDAP *CDECL ldap_openW	(	PWCHAR	hostname,
		ULONG	portnumber
	)

Definition at line 459 of file init.c.

{
#ifdef HAVE_LDAP
    LDAP *ld = NULL;
    char *hostnameU = NULL, *url = NULL;
 
    TRACE( "(%s, %d)\n", debugstr_w(hostname), portnumber );
 
    if (hostname) {
        hostnameU = strWtoU( hostname );
        if (!hostnameU) goto exit;
    }
    else {
        hostnameU = strWtoU( defaulthost );
        if (!hostnameU) goto exit;
    }
 
    url = urlify_hostnames( "ldap://", hostnameU, portnumber );
    if (!url) goto exit;
 
    ld = create_context( url );
 
exit:
    strfreeU( hostnameU );
    strfreeU( url );
    return ld;
 
#else
    return NULL;
#endif
}

ldap_parse_extended_resultA()

ULONG CDECL ldap_parse_extended_resultA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	result,
		PCHAR *	oid,
		struct WLDAP32_berval **	data,
		BOOLEAN	free
	)

Definition at line 44 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *oidW = NULL;
 
    TRACE( "(%p, %p, %p, %p, 0x%02x)\n", ld, result, oid, data, free );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    if (!result) return WLDAP32_LDAP_NO_RESULTS_RETURNED;
 
    ret = ldap_parse_extended_resultW( ld, result, &oidW, data, free );
 
    if (oid) {
        *oid = strWtoA( oidW );
        if (!*oid) ret = WLDAP32_LDAP_NO_MEMORY;
        ldap_memfreeW( oidW );
    }
 
#endif
    return ret;
}

ldap_parse_extended_resultW()

ULONG CDECL ldap_parse_extended_resultW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	result,
		PWCHAR *	oid,
		struct WLDAP32_berval **	data,
		BOOLEAN	free
	)

Definition at line 88 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *oidU = NULL;
 
    TRACE( "(%p, %p, %p, %p, 0x%02x)\n", ld, result, oid, data, free );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    if (!result) return WLDAP32_LDAP_NO_RESULTS_RETURNED;
 
    ret = map_error( ldap_parse_extended_result( ld, result, &oidU, (struct berval **)data, free ) );
 
    if (oid) {
        *oid = strUtoW( oidU );
        if (!*oid) ret = WLDAP32_LDAP_NO_MEMORY;
        ldap_memfree( oidU );
    }
 
#endif
    return ret;
}

Referenced by ldap_parse_extended_resultA().

ldap_parse_page_controlA()

ULONG CDECL ldap_parse_page_controlA	(	WLDAP32_LDAP *	ld,
		PLDAPControlA *	ctrls,
		ULONG *	count,
		struct WLDAP32_berval **	cookie
	)

Definition at line 198 of file page.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    LDAPControlW **ctrlsW = NULL;
 
    TRACE( "(%p, %p, %p, %p)\n", ld, ctrls, count, cookie );
 
    if (!ld || !ctrls || !count || !cookie)
        return WLDAP32_LDAP_PARAM_ERROR;
 
    ctrlsW = controlarrayAtoW( ctrls );
    if (!ctrlsW) return WLDAP32_LDAP_NO_MEMORY;
 
    ret = ldap_parse_page_controlW( ld, ctrlsW, count, cookie );
    controlarrayfreeW( ctrlsW );
 
#endif
    return ret;
}

ldap_parse_page_controlW()

ULONG CDECL ldap_parse_page_controlW	(	WLDAP32_LDAP *	ld,
		PLDAPControlW *	ctrls,
		ULONG *	count,
		struct WLDAP32_berval **	cookie
	)

Definition at line 223 of file page.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    LDAPControlW *control = NULL;
    BerElement *ber;
    ber_tag_t tag;
    ULONG i;
 
    TRACE( "(%p, %p, %p, %p)\n", ld, ctrls, count, cookie );
 
    if (!ld || !ctrls || !count || !cookie)
        return WLDAP32_LDAP_PARAM_ERROR;
 
    for (i = 0; ctrls[i]; i++)
    {
        if (!lstrcmpW( LDAP_PAGED_RESULT_OID_STRING_W, ctrls[i]->ldctl_oid ))
            control = ctrls[i];
    }
 
    if (!control)
        return WLDAP32_LDAP_CONTROL_NOT_FOUND; 
            
    ber = ber_init( &((LDAPControl *)control)->ldctl_value );
    if (!ber)
        return WLDAP32_LDAP_NO_MEMORY;
 
    tag = ber_scanf( ber, "{iO}", count, cookie );
    if ( tag == LBER_ERROR )
        ret = WLDAP32_LDAP_DECODING_ERROR;
    else
        ret = WLDAP32_LDAP_SUCCESS;
 
    ber_free( ber, 1 );
    
#endif
    return ret;
}

Referenced by ldap_parse_page_controlA().

ldap_parse_referenceA()

ULONG CDECL ldap_parse_referenceA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	message,
		PCHAR **	referrals
	)

Definition at line 117 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR **referralsW = NULL;
 
    TRACE( "(%p, %p, %p)\n", ld, message, referrals );
 
    if (!ld) return ~0u;
 
    ret = ldap_parse_referenceW( ld, message, &referralsW );
 
    *referrals = strarrayWtoA( referralsW );
    ldap_value_freeW( referralsW );
 
#endif 
    return ret;
}

ldap_parse_referenceW()

ULONG CDECL ldap_parse_referenceW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	message,
		PWCHAR **	referrals
	)

Definition at line 154 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP_PARSE_REFERENCE
    char **referralsU = NULL;
 
    TRACE( "(%p, %p, %p)\n", ld, message, referrals );
 
    if (!ld) return ~0u;
    
    ret = map_error( ldap_parse_reference( ld, message, &referralsU, NULL, 0 ));
 
    *referrals = strarrayUtoW( referralsU );
    ldap_memfree( referralsU );
 
#endif
    return ret;
}

ldap_parse_resultA()

ULONG CDECL ldap_parse_resultA	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	result,
		ULONG *	retcode,
		PCHAR *	matched,
		PCHAR *	error,
		PCHAR **	referrals,
		PLDAPControlA **	serverctrls,
		BOOLEAN	free
	)

Definition at line 179 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *matchedW = NULL, *errorW = NULL, **referralsW = NULL;
    LDAPControlW **serverctrlsW = NULL;
 
    TRACE( "(%p, %p, %p, %p, %p, %p, %p, 0x%02x)\n", ld, result, retcode,
           matched, error, referrals, serverctrls, free );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    ret = ldap_parse_resultW( ld, result, retcode, &matchedW, &errorW,
                              &referralsW, &serverctrlsW, free );
 
    if (matched) *matched = strWtoA( matchedW );
    if (error) *error = strWtoA( errorW );
 
    if (referrals) *referrals = strarrayWtoA( referralsW );
    if (serverctrls) *serverctrls = controlarrayWtoA( serverctrlsW );
 
    ldap_memfreeW( matchedW );
    ldap_memfreeW( errorW );
    ldap_value_freeW( referralsW );
    ldap_controls_freeW( serverctrlsW );
 
#endif
    return ret;
}

ldap_parse_resultW()

ULONG CDECL ldap_parse_resultW	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	result,
		ULONG *	retcode,
		PWCHAR *	matched,
		PWCHAR *	error,
		PWCHAR **	referrals,
		PLDAPControlW **	serverctrls,
		BOOLEAN	free
	)

Definition at line 236 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *matchedU = NULL, *errorU = NULL, **referralsU = NULL;
    LDAPControl **serverctrlsU = NULL;
 
    TRACE( "(%p, %p, %p, %p, %p, %p, %p, 0x%02x)\n", ld, result, retcode,
           matched, error, referrals, serverctrls, free );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    ret = map_error( ldap_parse_result( ld, result, (int *)retcode, &matchedU, &errorU,
                                        &referralsU, &serverctrlsU, free ));
 
    if (matched) *matched = strUtoW( matchedU );
    if (error) *error = strUtoW( errorU );
 
    if (referrals) *referrals = strarrayUtoW( referralsU );
    if (serverctrls) *serverctrls = controlarrayUtoW( serverctrlsU );
 
    ldap_memfree( matchedU );
    ldap_memfree( errorU );
    ldap_memvfree( (void **)referralsU );
    ldap_controls_free( serverctrlsU );
 
#endif
    return ret;
}

ldap_parse_sort_controlA()

ULONG CDECL ldap_parse_sort_controlA	(	WLDAP32_LDAP *	ld,
		PLDAPControlA *	control,
		ULONG *	result,
		PCHAR *	attr
	)

Definition at line 273 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *attrW = NULL;
    LDAPControlW **controlW = NULL;
 
    TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    if (!control) return WLDAP32_LDAP_CONTROL_NOT_FOUND;
 
    controlW = controlarrayAtoW( control );
    if (!controlW) return WLDAP32_LDAP_NO_MEMORY;
 
    ret = ldap_parse_sort_controlW( ld, controlW, result, &attrW );
 
    *attr = strWtoA( attrW );
    controlarrayfreeW( controlW );
 
#endif
    return ret;
}

Referenced by test_ldap_parse_sort_control().

ldap_parse_sort_controlW()

ULONG CDECL ldap_parse_sort_controlW	(	WLDAP32_LDAP *	ld,
		PLDAPControlW *	control,
		ULONG *	result,
		PWCHAR *	attr
	)

Definition at line 316 of file parse.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *attrU = NULL;
    LDAPControl **controlU = NULL;
#ifdef HAVE_LDAP_PARSE_SORT_CONTROL
    unsigned long res;
#elif defined(HAVE_LDAP_PARSE_SORTRESPONSE_CONTROL)
    ber_int_t res;
    LDAPControl *sortcontrol = NULL;
    unsigned int i;
#endif
 
    TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
    if (!control) return WLDAP32_LDAP_CONTROL_NOT_FOUND;
 
    controlU = controlarrayWtoU( control );
    if (!controlU) return WLDAP32_LDAP_NO_MEMORY;
 
#ifdef HAVE_LDAP_PARSE_SORT_CONTROL
    if (!(ret = ldap_parse_sort_control( ld, controlU, &res, &attrU )))
    {
        *result = res;
        *attr = strUtoW( attrU );
    }
#elif defined(HAVE_LDAP_PARSE_SORTRESPONSE_CONTROL)
    for (i = 0; controlU[i]; i++)
    {
        if (!strcmp( LDAP_SERVER_RESP_SORT_OID, controlU[i]->ldctl_oid ))
            sortcontrol = controlU[i];
    }
    if (!sortcontrol)
    {
        controlarrayfreeU( controlU );
        return WLDAP32_LDAP_CONTROL_NOT_FOUND;
    }
    if (!(ret = ldap_parse_sortresponse_control( ld, sortcontrol, &res, &attrU )))
    {
        *result = res;
        *attr = strUtoW( attrU );
    }
#endif
    controlarrayfreeU( controlU );
 
#endif
    return map_error( ret );
}

Referenced by ldap_parse_sort_controlA().

ldap_parse_vlv_controlA()

int CDECL ldap_parse_vlv_controlA	(	WLDAP32_LDAP *	,
		LDAPControlA **	,
		ULONG *	,
		ULONG *	,
		struct WLDAP32_berval **	,
		INT *
	)

ldap_parse_vlv_controlW()

int CDECL ldap_parse_vlv_controlW	(	WLDAP32_LDAP *	,
		LDAPControlW **	,
		ULONG *	,
		ULONG *	,
		struct WLDAP32_berval **	,
		INT *
	)

ldap_rename_ext_sA()

ULONG CDECL ldap_rename_ext_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	newrdn,
		PCHAR	newparent,
		INT	delete,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls
	)

Definition at line 177 of file rename.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *newrdnW = NULL, *newparentW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, 0x%02x, %p, %p)\n", ld, debugstr_a(dn),
           debugstr_a(newrdn), debugstr_a(newparent), delete,
           serverctrls, clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (newrdn) {
        newrdnW = strAtoW( newrdn );
        if (!newrdnW) goto exit;
    }
    if (newparent) {
        newparentW = strAtoW( newparent );
        if (!newparentW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_rename_ext_sW( ld, dnW, newrdnW, newparentW, delete,
                              serverctrlsW, clientctrlsW );
 
exit:
    strfreeW( dnW );
    strfreeW( newrdnW );
    strfreeW( newparentW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_rename_ext_sW()

ULONG CDECL ldap_rename_ext_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	newrdn,
		PWCHAR	newparent,
		INT	delete,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls
	)

Definition at line 246 of file rename.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *newrdnU = NULL, *newparentU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, 0x%02x, %p, %p)\n", ld, debugstr_w(dn),
           debugstr_w(newrdn), debugstr_w(newparent), delete,
           serverctrls, clientctrls );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (newrdn) {
        newrdnU = strWtoU( newrdn );
        if (!newrdnU) goto exit;
    }
    if (newparent) {
        newparentU = strWtoU( newparent );
        if (!newparentU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_rename_s( ld, dn ? dnU : "", newrdn ? newrdnU : "", newparentU,
                                    delete, serverctrlsU, clientctrlsU ));
 
exit:
    strfreeU( dnU );
    strfreeU( newrdnU );
    strfreeU( newparentU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_rename_extA()

ULONG CDECL ldap_rename_extA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	newrdn,
		PCHAR	newparent,
		INT	delete,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		ULONG *	message
	)

Definition at line 44 of file rename.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *newrdnW = NULL, *newparentW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, 0x%02x, %p, %p, %p)\n", ld, debugstr_a(dn),
           debugstr_a(newrdn), debugstr_a(newparent), delete,
           serverctrls, clientctrls, message );
 
    if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (newrdn) {
        newrdnW = strAtoW( newrdn );
        if (!newrdnW) goto exit;
    }
    if (newparent) {
        newparentW = strAtoW( newparent );
        if (!newparentW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_rename_extW( ld, dnW, newrdnW, newparentW, delete,
                            serverctrlsW, clientctrlsW, message );
 
exit:
    strfreeW( dnW );
    strfreeW( newrdnW );
    strfreeW( newparentW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_rename_extW()

ULONG CDECL ldap_rename_extW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	newrdn,
		PWCHAR	newparent,
		INT	delete,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		ULONG *	message
	)

Definition at line 120 of file rename.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *newrdnU = NULL, *newparentU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %s, 0x%02x, %p, %p, %p)\n", ld, debugstr_w(dn),
           debugstr_w(newrdn), debugstr_w(newparent), delete,
           serverctrls, clientctrls, message );
 
    if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (newrdn) {
        newrdnU = strWtoU( newrdn );
        if (!newrdnU) goto exit;
    }
    if (newparent) {
        newparentU = strWtoU( newparent );
        if (!newparentU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_rename( ld, dn ? dnU : "", newrdn ? newrdnU : "", newparentU,
                                  delete, serverctrlsU, clientctrlsU, (int *)message ));
 
exit:
    strfreeU( dnU );
    strfreeU( newrdnU );
    strfreeU( newparentU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_sasl_bind_sA()

ULONG CDECL ldap_sasl_bind_sA	(	WLDAP32_LDAP *	ld,
		const	PCHAR,
		const	PCHAR,
		const BERVAL *	cred,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		PBERVAL *	serverdata
	)

Definition at line 347 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW, *mechanismW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn),
           debugstr_a(mechanism), cred, serverctrls, clientctrls, serverdata );
 
    if (!ld || !dn || !mechanism || !cred || !serverdata)
        return WLDAP32_LDAP_PARAM_ERROR;
 
    dnW = strAtoW( dn );
    if (!dnW) goto exit;
 
    mechanismW = strAtoW( mechanism );
    if (!mechanismW) goto exit;
 
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_sasl_bind_sW( ld, dnW, mechanismW, cred, serverctrlsW, clientctrlsW, serverdata );
 
exit:
    strfreeW( dnW );
    strfreeW( mechanismW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_sasl_bind_sW()

ULONG CDECL ldap_sasl_bind_sW	(	WLDAP32_LDAP *	ld,
		const	PWCHAR,
		const	PWCHAR,
		const BERVAL *	cred,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		PBERVAL *	serverdata
	)

Definition at line 413 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU, *mechanismU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    struct berval credU;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn),
           debugstr_w(mechanism), cred, serverctrls, clientctrls, serverdata );
 
    if (!ld || !dn || !mechanism || !cred || !serverdata)
        return WLDAP32_LDAP_PARAM_ERROR;
 
    dnU = strWtoU( dn );
    if (!dnU) goto exit;
 
    mechanismU = strWtoU( mechanism );
    if (!mechanismU) goto exit;
 
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    credU.bv_len = cred->bv_len;
    credU.bv_val = cred->bv_val;
 
    ret = map_error( ldap_sasl_bind_s( ld, dnU, mechanismU, &credU,
                                       serverctrlsU, clientctrlsU, (struct berval **)serverdata ));
 
exit:
    strfreeU( dnU );
    strfreeU( mechanismU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_sasl_bindA()

ULONG CDECL ldap_sasl_bindA	(	WLDAP32_LDAP *	ld,
		const	PCHAR,
		const	PCHAR,
		const BERVAL *	cred,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		int *	message
	)

Definition at line 227 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW, *mechanismW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn),
           debugstr_a(mechanism), cred, serverctrls, clientctrls, message );
 
    if (!ld || !dn || !mechanism || !cred || !message)
        return WLDAP32_LDAP_PARAM_ERROR;
 
    dnW = strAtoW( dn );
    if (!dnW) goto exit;
 
    mechanismW = strAtoW( mechanism );
    if (!mechanismW) goto exit;
 
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_sasl_bindW( ld, dnW, mechanismW, cred, serverctrlsW, clientctrlsW, message );
 
exit:
    strfreeW( dnW );
    strfreeW( mechanismW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_sasl_bindW()

ULONG CDECL ldap_sasl_bindW	(	WLDAP32_LDAP *	ld,
		const	PWCHAR,
		const	PWCHAR,
		const BERVAL *	cred,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		int *	message
	)

Definition at line 293 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU, *mechanismU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    struct berval credU;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn),
           debugstr_w(mechanism), cred, serverctrls, clientctrls, message );
 
    if (!ld || !dn || !mechanism || !cred || !message)
        return WLDAP32_LDAP_PARAM_ERROR;
 
    dnU = strWtoU( dn );
    if (!dnU) goto exit;
 
    mechanismU = strWtoU( mechanism );
    if (!mechanismU) goto exit;
 
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    credU.bv_len = cred->bv_len;
    credU.bv_val = cred->bv_val;
 
    ret = map_error( ldap_sasl_bind( ld, dnU, mechanismU, &credU,
                                     serverctrlsU, clientctrlsU, message ));
 
exit:
    strfreeU( dnU );
    strfreeU( mechanismU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_search_abandon_page()

ULONG CDECL ldap_search_abandon_page	(	WLDAP32_PLDAP	,
		PLDAPSearch
	)

ldap_search_ext_sA()

ULONG CDECL ldap_search_ext_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	base,
		ULONG	scope,
		PCHAR	filter,
		PCHAR	attrs[],
		ULONG	attrsonly,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		struct l_timeval *	timeout,
		ULONG	sizelimit,
		WLDAP32_LDAPMessage **	res
	)

Definition at line 301 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, %p, 0x%08x, %p)\n",
           ld, debugstr_a(base), scope, debugstr_a(filter), attrs, attrsonly,
           serverctrls, clientctrls, timeout, sizelimit, res );
 
    if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (base) {
        baseW = strAtoW( base );
        if (!baseW) goto exit;
    }
    if (filter) {
        filterW = strAtoW( filter );
        if (!filterW) goto exit;
    }
    if (attrs) {
        attrsW = strarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_search_ext_sW( ld, baseW, scope, filterW, attrsW, attrsonly,
                              serverctrlsW, clientctrlsW, timeout, sizelimit, res );
 
exit:
    strfreeW( baseW );
    strfreeW( filterW );
    strarrayfreeW( attrsW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_search_ext_sW()

ULONG CDECL ldap_search_ext_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	base,
		ULONG	scope,
		PWCHAR	filter,
		PWCHAR	attrs[],
		ULONG	attrsonly,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		struct l_timeval *	timeout,
		ULONG	sizelimit,
		WLDAP32_LDAPMessage **	res
	)

Definition at line 379 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, %p, 0x%08x, %p)\n",
           ld, debugstr_w(base), scope, debugstr_w(filter), attrs, attrsonly,
           serverctrls, clientctrls, timeout, sizelimit, res );
 
    if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (base) {
        baseU = strWtoU( base );
        if (!baseU) goto exit;
    }
    if (filter) {
        filterU = strWtoU( filter );
        if (!filterU) goto exit;
    }
    if (attrs) {
        attrsU = strarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    ret = map_error( ldap_search_ext_s( ld, baseU, scope, filterU, attrsU, attrsonly,
                                        serverctrlsU, clientctrlsU, (struct timeval *)timeout,
                                        sizelimit, res ));
 
exit:
    strfreeU( baseU );
    strfreeU( filterU );
    strarrayfreeU( attrsU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_search_extA()

ULONG CDECL ldap_search_extA	(	WLDAP32_LDAP *	ld,
		PCHAR	base,
		ULONG	scope,
		PCHAR	filter,
		PCHAR	attrs[],
		ULONG	attrsonly,
		PLDAPControlA *	serverctrls,
		PLDAPControlA *	clientctrls,
		ULONG	timelimit,
		ULONG	sizelimit,
		ULONG *	message
	)

Definition at line 155 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
    LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, 0x%08x, 0x%08x, %p)\n",
           ld, debugstr_a(base), scope, debugstr_a(filter), attrs, attrsonly,
           serverctrls, clientctrls, timelimit, sizelimit, message );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (base) {
        baseW = strAtoW( base );
        if (!baseW) goto exit;
    }
    if (filter)
    {
        filterW = strAtoW( filter );
        if (!filterW) goto exit;
    }
    if (attrs) {
        attrsW = strarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
    if (serverctrls) {
        serverctrlsW = controlarrayAtoW( serverctrls );
        if (!serverctrlsW) goto exit;
    }
    if (clientctrls) {
        clientctrlsW = controlarrayAtoW( clientctrls );
        if (!clientctrlsW) goto exit;
    }
 
    ret = ldap_search_extW( ld, baseW, scope, filterW, attrsW, attrsonly,
                            serverctrlsW, clientctrlsW, timelimit, sizelimit, message );
 
exit:
    strfreeW( baseW );
    strfreeW( filterW );
    strarrayfreeW( attrsW );
    controlarrayfreeW( serverctrlsW );
    controlarrayfreeW( clientctrlsW );
 
#endif
    return ret;
}

ldap_search_extW()

ULONG CDECL ldap_search_extW	(	WLDAP32_LDAP *	ld,
		PWCHAR	base,
		ULONG	scope,
		PWCHAR	filter,
		PWCHAR	attrs[],
		ULONG	attrsonly,
		PLDAPControlW *	serverctrls,
		PLDAPControlW *	clientctrls,
		ULONG	timelimit,
		ULONG	sizelimit,
		ULONG *	message
	)

Definition at line 236 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
    LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
    struct timeval tv, *tvp = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, 0x%08x, 0x%08x, %p)\n",
           ld, debugstr_w(base), scope, debugstr_w(filter), attrs, attrsonly,
           serverctrls, clientctrls, timelimit, sizelimit, message );
 
    if (!ld) return ~0u;
 
    if (base) {
        baseU = strWtoU( base );
        if (!baseU) goto exit;
    }
    if (filter) {
        filterU = strWtoU( filter );
        if (!filterU) goto exit;
    }
    if (attrs) {
        attrsU = strarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
    if (serverctrls) {
        serverctrlsU = controlarrayWtoU( serverctrls );
        if (!serverctrlsU) goto exit;
    }
    if (clientctrls) {
        clientctrlsU = controlarrayWtoU( clientctrls );
        if (!clientctrlsU) goto exit;
    }
 
    if (timelimit)
    {
        tv.tv_sec = timelimit;
        tv.tv_usec = 0;
        tvp = &tv;
    }
 
    ret = map_error( ldap_search_ext( ld, baseU, scope, filterU, attrsU, attrsonly,
                                      serverctrlsU, clientctrlsU, tvp, sizelimit, (int *)message ));
 
exit:
    strfreeU( baseU );
    strfreeU( filterU );
    strarrayfreeU( attrsU );
    controlarrayfreeU( serverctrlsU );
    controlarrayfreeU( clientctrlsU );
 
#endif
    return ret;
}

ldap_search_init_pageA()

PLDAPSearch CDECL ldap_search_init_pageA	(	WLDAP32_PLDAP	,
		PCHAR	,
		ULONG	,
		PCHAR	,
		PCHAR	[],
		ULONG	,
		PLDAPControlA *	,
		PLDAPControlA *	,
		ULONG	,
		ULONG	,
		PLDAPSortKeyA *
	)

ldap_search_init_pageW()

PLDAPSearch CDECL ldap_search_init_pageW	(	WLDAP32_PLDAP	,
		PWCHAR	,
		ULONG	,
		PWCHAR	,
		PWCHAR	[],
		ULONG	,
		PLDAPControlW *	,
		PLDAPControlW *	,
		ULONG	,
		ULONG	,
		PLDAPSortKeyW *
	)

ldap_search_sA()

ULONG CDECL ldap_search_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	base,
		ULONG	scope,
		PCHAR	filter,
		PCHAR	attrs[],
		ULONG	attrsonly,
		WLDAP32_LDAPMessage **	res
	)

Definition at line 437 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p)\n", ld, debugstr_a(base),
           scope, debugstr_a(filter), attrs, attrsonly, res );
 
    if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (base) {
        baseW = strAtoW( base );
        if (!baseW) goto exit;
    }
    if (filter) {
        filterW = strAtoW( filter );
        if (!filterW) goto exit;
    }
    if (attrs) {
        attrsW = strarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
 
    ret = ldap_search_sW( ld, baseW, scope, filterW, attrsW, attrsonly, res );
 
exit:
    strfreeW( baseW );
    strfreeW( filterW );
    strarrayfreeW( attrsW );
 
#endif
    return ret;
}

ldap_search_stA()

ULONG CDECL ldap_search_stA	(	WLDAP32_LDAP *	ld,
		const	PCHAR,
		ULONG	scope,
		const	PCHAR,
		PCHAR	attrs[],
		ULONG	attrsonly,
		struct l_timeval *	timeout,
		WLDAP32_LDAPMessage **	res
	)

Definition at line 541 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p)\n", ld,
           debugstr_a(base), scope, debugstr_a(filter), attrs,
           attrsonly, timeout, res );
 
    if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (base) {
        baseW = strAtoW( base );
        if (!baseW) goto exit;
    }
    if (filter) {
        filterW = strAtoW( filter );
        if (!filterW) goto exit;
    }
    if (attrs) {
        attrsW = strarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
 
    ret = ldap_search_stW( ld, baseW, scope, filterW, attrsW, attrsonly,
                           timeout, res );
 
exit:
    strfreeW( baseW );
    strfreeW( filterW );
    strarrayfreeW( attrsW );
 
#endif
    return ret;
}

ldap_search_stW()

ULONG CDECL ldap_search_stW	(	WLDAP32_LDAP *	ld,
		const	PWCHAR,
		ULONG	scope,
		const	PWCHAR,
		PWCHAR	attrs[],
		ULONG	attrsonly,
		struct l_timeval *	timeout,
		WLDAP32_LDAPMessage **	res
	)

Definition at line 605 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p)\n", ld,
           debugstr_w(base), scope, debugstr_w(filter), attrs,
           attrsonly, timeout, res );
 
    if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (base) {
        baseU = strWtoU( base );
        if (!baseU) goto exit;
    }
    if (filter) {
        filterU = strWtoU( filter );
        if (!filterU) goto exit;
    }
    if (attrs) {
        attrsU = strarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
 
    ret = map_error( ldap_search_ext_s( ld, baseU, scope, filterU, attrsU, attrsonly,
                                        NULL, NULL, (struct timeval *)timeout, 0, res ));
 
exit:
    strfreeU( baseU );
    strfreeU( filterU );
    strarrayfreeU( attrsU );
 
#endif
    return ret;
}

ldap_search_sW()

ULONG CDECL ldap_search_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	base,
		ULONG	scope,
		PWCHAR	filter,
		PWCHAR	attrs[],
		ULONG	attrsonly,
		WLDAP32_LDAPMessage **	res
	)

Definition at line 497 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p)\n", ld, debugstr_w(base),
           scope, debugstr_w(filter), attrs, attrsonly, res );
 
    if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (base) {
        baseU = strWtoU( base );
        if (!baseU) goto exit;
    }
    if (filter) {
        filterU = strWtoU( filter );
        if (!filterU) goto exit;
    }
    if (attrs) {
        attrsU = strarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
 
    ret = map_error( ldap_search_ext_s( ld, baseU, scope, filterU, attrsU, attrsonly,
                                        NULL, NULL, NULL, 0, res ));
 
exit:
    strfreeU( baseU );
    strfreeU( filterU );
    strarrayfreeU( attrsU );
 
#endif
    return ret;
}

ldap_searchA()

ULONG CDECL ldap_searchA	(	WLDAP32_LDAP *	ld,
		PCHAR	base,
		ULONG	scope,
		PCHAR	filter,
		PCHAR	attrs[],
		ULONG	attrsonly
	)

Definition at line 44 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x)\n", ld, debugstr_a(base),
           scope, debugstr_a(filter), attrs, attrsonly );
 
    if (!ld) return ~0u;
 
    if (base) {
        baseW = strAtoW( base );
        if (!baseW) goto exit;
    }
    if (filter) {
        filterW = strAtoW( filter );
        if (!filterW) goto exit;
    }
    if (attrs) {
        attrsW = strarrayAtoW( attrs );
        if (!attrsW) goto exit;
    }
 
    ret = ldap_searchW( ld, baseW, scope, filterW, attrsW, attrsonly );
 
exit:
    strfreeW( baseW );
    strfreeW( filterW );
    strarrayfreeW( attrsW );
 
#endif
    return ret;
}

ldap_searchW()

ULONG CDECL ldap_searchW	(	WLDAP32_LDAP *	ld,
		PWCHAR	base,
		ULONG	scope,
		PWCHAR	filter,
		PWCHAR	attrs[],
		ULONG	attrsonly
	)

Definition at line 105 of file search.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
    int msg;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x)\n", ld, debugstr_w(base),
           scope, debugstr_w(filter), attrs, attrsonly );
 
    if (!ld) return ~0u;
 
    if (base) {
        baseU = strWtoU( base );
        if (!baseU) goto exit;
    }
    if (filter) {
        filterU = strWtoU( filter );
        if (!filterU) goto exit;
    }
    if (attrs) {
        attrsU = strarrayWtoU( attrs );
        if (!attrsU) goto exit;
    }
 
    ret = ldap_search_ext( ld, baseU, scope, filterU, attrsU, attrsonly,
                           NULL, NULL, NULL, 0, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( baseU );
    strfreeU( filterU );
    strarrayfreeU( attrsU );
 
#endif
    return ret;
}

ldap_set_optionA()

ULONG CDECL ldap_set_optionA	(	WLDAP32_LDAP *	ld,
		int	option,
		void *	value
	)

Definition at line 313 of file option.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p, 0x%08x, %p)\n", ld, option, value );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    switch (option)
    {
    case WLDAP32_LDAP_OPT_SERVER_CONTROLS:
    {
        LDAPControlW **ctrlsW;
 
        ctrlsW = controlarrayAtoW( value );
        if (!ctrlsW) return WLDAP32_LDAP_NO_MEMORY;
 
        ret = ldap_set_optionW( ld, option, ctrlsW );
        controlarrayfreeW( ctrlsW );
        return ret;
    }
    case WLDAP32_LDAP_OPT_DEREF:
    case WLDAP32_LDAP_OPT_DESC:
    case WLDAP32_LDAP_OPT_ERROR_NUMBER:
    case WLDAP32_LDAP_OPT_PROTOCOL_VERSION:
    case WLDAP32_LDAP_OPT_REFERRALS:
    case WLDAP32_LDAP_OPT_SIZELIMIT:
    case WLDAP32_LDAP_OPT_TIMELIMIT:
        return ldap_set_optionW( ld, option, value );
 
    case WLDAP32_LDAP_OPT_CACHE_ENABLE:
    case WLDAP32_LDAP_OPT_CACHE_FN_PTRS:
    case WLDAP32_LDAP_OPT_CACHE_STRATEGY:
    case WLDAP32_LDAP_OPT_IO_FN_PTRS:
    case WLDAP32_LDAP_OPT_REBIND_ARG:
    case WLDAP32_LDAP_OPT_REBIND_FN:
    case WLDAP32_LDAP_OPT_RESTART:
    case WLDAP32_LDAP_OPT_THREAD_FN_PTRS:
        return WLDAP32_LDAP_LOCAL_ERROR;
 
    case WLDAP32_LDAP_OPT_API_FEATURE_INFO:
    case WLDAP32_LDAP_OPT_API_INFO:
        return WLDAP32_LDAP_UNWILLING_TO_PERFORM;
 
    case WLDAP32_LDAP_OPT_AREC_EXCLUSIVE:
    case WLDAP32_LDAP_OPT_AUTO_RECONNECT:
    case WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE:
    case WLDAP32_LDAP_OPT_DNSDOMAIN_NAME:
    case WLDAP32_LDAP_OPT_ENCRYPT:
    case WLDAP32_LDAP_OPT_ERROR_STRING:
    case WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND:
    case WLDAP32_LDAP_OPT_GETDSNAME_FLAGS:
    case WLDAP32_LDAP_OPT_HOST_NAME:
    case WLDAP32_LDAP_OPT_HOST_REACHABLE:
    case WLDAP32_LDAP_OPT_PING_KEEP_ALIVE:
    case WLDAP32_LDAP_OPT_PING_LIMIT:
    case WLDAP32_LDAP_OPT_PING_WAIT_TIME:
    case WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS:
    case WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG:
    case WLDAP32_LDAP_OPT_REFERRAL_CALLBACK:
    case WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT:
    case WLDAP32_LDAP_OPT_ROOTDSE_CACHE:
    case WLDAP32_LDAP_OPT_SASL_METHOD:
    case WLDAP32_LDAP_OPT_SECURITY_CONTEXT:
    case WLDAP32_LDAP_OPT_SEND_TIMEOUT:
    case WLDAP32_LDAP_OPT_SERVER_CERTIFICATE:
    case WLDAP32_LDAP_OPT_SERVER_ERROR:
    case WLDAP32_LDAP_OPT_SERVER_EXT_ERROR:
    case WLDAP32_LDAP_OPT_SIGN:
    case WLDAP32_LDAP_OPT_SSL:
    case WLDAP32_LDAP_OPT_SSL_INFO:
    case WLDAP32_LDAP_OPT_SSPI_FLAGS:
    case WLDAP32_LDAP_OPT_TCP_KEEPALIVE:
        FIXME( "Unsupported option: 0x%02x\n", option );
        return WLDAP32_LDAP_NOT_SUPPORTED;
 
    default:
        FIXME( "Unknown option: 0x%02x\n", option );
        return WLDAP32_LDAP_LOCAL_ERROR;
    }
 
#endif
    return ret;
}

ldap_set_optionW()

ULONG CDECL ldap_set_optionW	(	WLDAP32_LDAP *	ld,
		int	option,
		void *	value
	)

Definition at line 416 of file option.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p, 0x%08x, %p)\n", ld, option, value );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    switch (option)
    {
    case WLDAP32_LDAP_OPT_SERVER_CONTROLS:
    {
        LDAPControl **ctrlsU;
 
        ctrlsU = controlarrayWtoU( value );
        if (!ctrlsU) return WLDAP32_LDAP_NO_MEMORY;
 
        ret = map_error( ldap_set_option( ld, option, ctrlsU ));
        controlarrayfreeU( ctrlsU );
        return ret;
    }
    case WLDAP32_LDAP_OPT_DEREF:
    case WLDAP32_LDAP_OPT_DESC:
    case WLDAP32_LDAP_OPT_ERROR_NUMBER:
    case WLDAP32_LDAP_OPT_PROTOCOL_VERSION:
    case WLDAP32_LDAP_OPT_REFERRALS:
    case WLDAP32_LDAP_OPT_SIZELIMIT:
    case WLDAP32_LDAP_OPT_TIMELIMIT:
        return map_error( ldap_set_option( ld, option, value ));
 
    case WLDAP32_LDAP_OPT_CACHE_ENABLE:
    case WLDAP32_LDAP_OPT_CACHE_FN_PTRS:
    case WLDAP32_LDAP_OPT_CACHE_STRATEGY:
    case WLDAP32_LDAP_OPT_IO_FN_PTRS:
    case WLDAP32_LDAP_OPT_REBIND_ARG:
    case WLDAP32_LDAP_OPT_REBIND_FN:
    case WLDAP32_LDAP_OPT_RESTART:
    case WLDAP32_LDAP_OPT_THREAD_FN_PTRS:
        return WLDAP32_LDAP_LOCAL_ERROR;
 
    case WLDAP32_LDAP_OPT_API_FEATURE_INFO:
    case WLDAP32_LDAP_OPT_API_INFO:
        return WLDAP32_LDAP_UNWILLING_TO_PERFORM;
 
    case WLDAP32_LDAP_OPT_AREC_EXCLUSIVE:
    case WLDAP32_LDAP_OPT_AUTO_RECONNECT:
    case WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE:
    case WLDAP32_LDAP_OPT_DNSDOMAIN_NAME:
    case WLDAP32_LDAP_OPT_ENCRYPT:
    case WLDAP32_LDAP_OPT_ERROR_STRING:
    case WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND:
    case WLDAP32_LDAP_OPT_GETDSNAME_FLAGS:
    case WLDAP32_LDAP_OPT_HOST_NAME:
    case WLDAP32_LDAP_OPT_HOST_REACHABLE:
    case WLDAP32_LDAP_OPT_PING_KEEP_ALIVE:
    case WLDAP32_LDAP_OPT_PING_LIMIT:
    case WLDAP32_LDAP_OPT_PING_WAIT_TIME:
    case WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS:
    case WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG:
    case WLDAP32_LDAP_OPT_REFERRAL_CALLBACK:
    case WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT:
    case WLDAP32_LDAP_OPT_ROOTDSE_CACHE:
    case WLDAP32_LDAP_OPT_SASL_METHOD:
    case WLDAP32_LDAP_OPT_SECURITY_CONTEXT:
    case WLDAP32_LDAP_OPT_SEND_TIMEOUT:
    case WLDAP32_LDAP_OPT_SERVER_CERTIFICATE:
    case WLDAP32_LDAP_OPT_SERVER_ERROR:
    case WLDAP32_LDAP_OPT_SERVER_EXT_ERROR:
    case WLDAP32_LDAP_OPT_SIGN:
    case WLDAP32_LDAP_OPT_SSL:
    case WLDAP32_LDAP_OPT_SSL_INFO:
    case WLDAP32_LDAP_OPT_SSPI_FLAGS:
    case WLDAP32_LDAP_OPT_TCP_KEEPALIVE:
        FIXME( "Unsupported option: 0x%02x\n", option );
        return WLDAP32_LDAP_NOT_SUPPORTED;
 
    default:
        FIXME( "Unknown option: 0x%02x\n", option );
        return WLDAP32_LDAP_LOCAL_ERROR;
    }
 
#endif
    return ret;
}

Referenced by ldap_set_optionA(), and test_ldap_set_optionW().

ldap_simple_bind_sA()

ULONG CDECL ldap_simple_bind_sA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	passwd
	)

Definition at line 561 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *passwdW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), passwd );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (passwd) {
        passwdW = strAtoW( passwd );
        if (!passwdW) goto exit;
    }
 
    ret = ldap_simple_bind_sW( ld, dnW, passwdW );
 
exit:
    strfreeW( dnW );
    strfreeW( passwdW );
 
#endif
    return ret;
}

ldap_simple_bind_sW()

ULONG CDECL ldap_simple_bind_sW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	passwd
	)

Definition at line 609 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *passwdU = NULL;
    struct berval pwd = { 0, NULL };
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), passwd );
 
    if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (passwd) {
        passwdU = strWtoU( passwd );
        if (!passwdU) goto exit;
 
        pwd.bv_len = strlen( passwdU );
        pwd.bv_val = passwdU;
    }
 
    ret = map_error( ldap_sasl_bind_s( ld, dnU, LDAP_SASL_SIMPLE, &pwd, NULL, NULL, NULL ));
 
exit:
    strfreeU( dnU );
    strfreeU( passwdU );
 
#endif
    return ret;
}

Referenced by ldap_simple_bind_sA().

ldap_simple_bindA()

ULONG CDECL ldap_simple_bindA	(	WLDAP32_LDAP *	ld,
		PCHAR	dn,
		PCHAR	passwd
	)

Definition at line 467 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    WCHAR *dnW = NULL, *passwdW = NULL;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), passwd );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnW = strAtoW( dn );
        if (!dnW) goto exit;
    }
    if (passwd) {
        passwdW = strAtoW( passwd );
        if (!passwdW) goto exit;
    }
 
    ret = ldap_simple_bindW( ld, dnW, passwdW );
 
exit:
    strfreeW( dnW );
    strfreeW( passwdW );
 
#endif
    return ret;
}

ldap_simple_bindW()

ULONG CDECL ldap_simple_bindW	(	WLDAP32_LDAP *	ld,
		PWCHAR	dn,
		PWCHAR	passwd
	)

Definition at line 515 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    char *dnU = NULL, *passwdU = NULL;
    struct berval pwd = { 0, NULL };
    int msg;
 
    ret = WLDAP32_LDAP_NO_MEMORY;
 
    TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), passwd );
 
    if (!ld) return ~0u;
 
    if (dn) {
        dnU = strWtoU( dn );
        if (!dnU) goto exit;
    }
    if (passwd) {
        passwdU = strWtoU( passwd );
        if (!passwdU) goto exit;
 
        pwd.bv_len = strlen( passwdU );
        pwd.bv_val = passwdU;
    }
 
    ret = ldap_sasl_bind( ld, dnU, LDAP_SASL_SIMPLE, &pwd, NULL, NULL, &msg );
 
    if (ret == LDAP_SUCCESS)
        ret = msg;
    else
        ret = ~0u;
 
exit:
    strfreeU( dnU );
    strfreeU( passwdU );
 
#endif
    return ret;
}

Referenced by ldap_simple_bindA().

ldap_sslinitA()

WLDAP32_LDAP *CDECL ldap_sslinitA	(	PCHAR	hostname,
		ULONG	portnumber,
		int	secure
	)

Definition at line 496 of file init.c.

{
#ifdef HAVE_LDAP
    WLDAP32_LDAP *ld;
    WCHAR *hostnameW = NULL;
 
    TRACE( "(%s, %d, 0x%08x)\n", debugstr_a(hostname), portnumber, secure );
 
    if (hostname) {
        hostnameW = strAtoW( hostname );
        if (!hostnameW) return NULL;
    }
 
    ld  = ldap_sslinitW( hostnameW, portnumber, secure );
 
    strfreeW( hostnameW );
    return ld;
 
#else
    return NULL;
#endif
}

ldap_sslinitW()

WLDAP32_LDAP *CDECL ldap_sslinitW	(	PWCHAR	hostname,
		ULONG	portnumber,
		int	secure
	)

Definition at line 542 of file init.c.

{
#ifdef HAVE_LDAP
    WLDAP32_LDAP *ld = NULL;
    char *hostnameU = NULL, *url = NULL;
 
    TRACE( "(%s, %d, 0x%08x)\n", debugstr_w(hostname), portnumber, secure );
 
    if (hostname) {
        hostnameU = strWtoU( hostname );
        if (!hostnameU) goto exit;
    }
    else {
        hostnameU = strWtoU( defaulthost );
        if (!hostnameU) goto exit;
    }
 
    if (secure)
        url = urlify_hostnames( "ldaps://", hostnameU, portnumber );
    else
        url = urlify_hostnames( "ldap://", hostnameU, portnumber );
 
    if (!url) goto exit;
    ldap_initialize( &ld, url );
 
exit:
    strfreeU( hostnameU );
    strfreeU( url );
    return ld;
 
#else
    return NULL;
#endif
}

ldap_start_tls_sA()

ULONG CDECL ldap_start_tls_sA	(	WLDAP32_PLDAP	,
		PULONG	,
		WLDAP32_LDAPMessage **	,
		PLDAPControlA *	,
		PLDAPControlA *
	)

ldap_start_tls_sW()

ULONG CDECL ldap_start_tls_sW	(	WLDAP32_PLDAP	,
		PULONG	,
		WLDAP32_LDAPMessage **	,
		PLDAPControlW *	,
		PLDAPControlW *
	)

ldap_startup()

ULONG CDECL ldap_startup	(	PLDAP_VERSION_INFO	version,
		HANDLE *	instance
	)

Definition at line 668 of file init.c.

{
    TRACE( "(%p, %p)\n", version, instance );
    return WLDAP32_LDAP_SUCCESS;
}

ldap_stop_tls_s()

BOOLEAN CDECL ldap_stop_tls_s

(

WLDAP32_PLDAP

)

ldap_ufn2dnA()

ULONG CDECL ldap_ufn2dnA	(	PCHAR	ufn,
		PCHAR *	dn
	)

Definition at line 229 of file dn.c.

{
    ULONG ret = WLDAP32_LDAP_SUCCESS;
#ifdef HAVE_LDAP
    PWCHAR ufnW = NULL, dnW = NULL;
 
    TRACE( "(%s, %p)\n", debugstr_a(ufn), dn );
 
    if (!dn) return WLDAP32_LDAP_PARAM_ERROR;
 
    *dn = NULL;
 
    if (ufn) {
        ufnW = strAtoW( ufn );
        if (!ufnW) return WLDAP32_LDAP_NO_MEMORY;
    }
 
    ret = ldap_ufn2dnW( ufnW, &dnW );
 
    if (dnW) {
        *dn = strWtoA( dnW );
        if (!*dn) ret = WLDAP32_LDAP_NO_MEMORY;
    }
 
    strfreeW( ufnW );
    ldap_memfreeW( dnW );
 
#endif
    return ret;
}

ldap_ufn2dnW()

ULONG CDECL ldap_ufn2dnW	(	PWCHAR	ufn,
		PWCHAR *	dn
	)

Definition at line 276 of file dn.c.

{
    ULONG ret = WLDAP32_LDAP_SUCCESS;
#ifdef HAVE_LDAP
    char *ufnU = NULL;
 
    TRACE( "(%s, %p)\n", debugstr_w(ufn), dn );
 
    if (!dn) return WLDAP32_LDAP_PARAM_ERROR;
 
    *dn = NULL;
 
    if (ufn) {
        ufnU = strWtoU( ufn );
        if (!ufnU) return WLDAP32_LDAP_NO_MEMORY;
 
        /* FIXME: do more than just a copy */
        *dn = strUtoW( ufnU );
        if (!*dn) ret = WLDAP32_LDAP_NO_MEMORY;
    }
 
    strfreeU( ufnU );
 
#endif
    return ret;
}

ldap_value_freeA()

ULONG CDECL ldap_value_freeA

(

PCHAR *

vals

)

Definition at line 344 of file value.c.

{
    TRACE( "(%p)\n", vals );
 
    strarrayfreeA( vals );
    return WLDAP32_LDAP_SUCCESS;
}

ldap_value_freeW()

ULONG CDECL ldap_value_freeW

(

PWCHAR *

vals

)

Definition at line 364 of file value.c.

{
    TRACE( "(%p)\n", vals );
 
    strarrayfreeW( vals );
    return WLDAP32_LDAP_SUCCESS;
}

LdapGetLastError()

ULONG CDECL LdapGetLastError

(

void

)

Definition at line 184 of file error.c.

{
    TRACE( "\n" );
    return GetLastError();
}

LdapMapErrorToWin32()

ULONG CDECL LdapMapErrorToWin32

(

ULONG

err

)

Definition at line 302 of file error.c.

{
    TRACE( "(0x%08x)\n", err );
 
    if (err >= ARRAY_SIZE( WLDAP32_errormap ))
        return ERROR_DS_GENERIC_ERROR;
    return WLDAP32_errormap[err];
}

LdapUnicodeToUTF8()

int CDECL LdapUnicodeToUTF8	(	LPCWSTR	src,
		int	srclen,
		LPSTR	dst,
		int	dstlen
	)

Definition at line 636 of file misc.c.

{
    return WideCharToMultiByte( CP_UTF8, 0, src, srclen, dst, dstlen, NULL, NULL );
}

LdapUTF8ToUnicode()

int CDECL LdapUTF8ToUnicode	(	LPCSTR	src,
		int	srclen,
		LPWSTR	dst,
		int	dstlen
	)

Definition at line 658 of file misc.c.

{
    return MultiByteToWideChar( CP_UTF8, 0, src, srclen, dst, dstlen );
}

WLDAP32_ldap_abandon()

ULONG CDECL WLDAP32_ldap_abandon	(	WLDAP32_LDAP *	ld,
		ULONG	msgid
	)

Definition at line 53 of file misc.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p, 0x%08x)\n", ld, msgid );
 
    if (!ld) return ~0u;
    ret = map_error( ldap_abandon_ext( ld, msgid, NULL, NULL ));
 
#endif
    return ret;
}

WLDAP32_ldap_count_entries()

ULONG CDECL WLDAP32_ldap_count_entries	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	res
	)

Definition at line 156 of file misc.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p, %p)\n", ld, res );
 
    if (!ld) return ~0u;
    ret = ldap_count_entries( ld, res );
 
#endif
    return ret;
}

WLDAP32_ldap_count_references()

ULONG CDECL WLDAP32_ldap_count_references	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	res
	)

Definition at line 183 of file misc.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP_COUNT_REFERENCES
 
    TRACE( "(%p, %p)\n", ld, res );
 
    if (!ld) return 0;
    ret = ldap_count_references( ld, res );
 
#endif
    return ret;
}

WLDAP32_ldap_count_values_len()

ULONG CDECL WLDAP32_ldap_count_values_len

(

PBERVAL *

)

WLDAP32_ldap_first_entry()

WLDAP32_LDAPMessage *CDECL WLDAP32_ldap_first_entry	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	res
	)

Definition at line 361 of file misc.c.

{
#ifdef HAVE_LDAP
 
    TRACE( "(%p, %p)\n", ld, res );
 
    if (!ld || !res) return NULL;
    return ldap_first_entry( ld, res );
 
#else
    return NULL;
#endif
}

WLDAP32_ldap_first_reference()

WLDAP32_LDAPMessage *CDECL WLDAP32_ldap_first_reference	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	res
	)

Definition at line 388 of file misc.c.

{
#ifdef HAVE_LDAP_FIRST_REFERENCE
 
    TRACE( "(%p, %p)\n", ld, res );
 
    if (!ld) return NULL;
    return ldap_first_reference( ld, res );
 
#else
    return NULL;
#endif
}

WLDAP32_ldap_msgfree()

ULONG CDECL WLDAP32_ldap_msgfree

(

WLDAP32_LDAPMessage *

res

)

Definition at line 435 of file misc.c.

{
    ULONG ret = WLDAP32_LDAP_SUCCESS;
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", res );
    ldap_msgfree( res );
 
#endif
    return ret;
}

WLDAP32_ldap_next_entry()

WLDAP32_LDAPMessage *CDECL WLDAP32_ldap_next_entry	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry
	)

Definition at line 524 of file misc.c.

{
#ifdef HAVE_LDAP
 
    TRACE( "(%p, %p)\n", ld, entry );
 
    if (!ld || !entry) return NULL;
    return ldap_next_entry( ld, entry );
 
#else
    return NULL;
#endif
}

WLDAP32_ldap_next_reference()

WLDAP32_LDAPMessage *CDECL WLDAP32_ldap_next_reference	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	entry
	)

Definition at line 554 of file misc.c.

{
#ifdef HAVE_LDAP_NEXT_REFERENCE
 
    TRACE( "(%p, %p)\n", ld, entry );
 
    if (!ld || !entry) return NULL;
    return ldap_next_reference( ld, entry );
 
#else
    return NULL;
#endif
}

WLDAP32_ldap_perror()

void CDECL WLDAP32_ldap_perror	(	WLDAP32_LDAP *	ld,
		const	PCHAR
	)

Definition at line 130 of file error.c.

{
    TRACE( "(%p, %s)\n", ld, debugstr_a(msg) );
}

WLDAP32_ldap_result()

ULONG CDECL WLDAP32_ldap_result	(	WLDAP32_LDAP *	ld,
		ULONG	msgid,
		ULONG	all,
		struct l_timeval *	timeout,
		WLDAP32_LDAPMessage **	res
	)

Definition at line 604 of file misc.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p, 0x%08x, 0x%08x, %p, %p)\n", ld, msgid, all, timeout, res );
 
    if (!ld || !res || msgid == ~0u) return ~0u;
    ret = ldap_result( ld, msgid, all, (struct timeval *)timeout, res );
 
#endif
    return ret;
}

WLDAP32_ldap_result2error()

ULONG CDECL WLDAP32_ldap_result2error	(	WLDAP32_LDAP *	ld,
		WLDAP32_LDAPMessage *	res,
		ULONG	free
	)

Definition at line 152 of file error.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
    int error;
 
    TRACE( "(%p, %p, 0x%08x)\n", ld, res, free );
 
    if (!ld || !res) return ~0u;
 
    ret = ldap_parse_result( ld, res, &error, NULL, NULL, NULL, NULL, free );
 
    if (ret == LDAP_SUCCESS)
        ret = error;
    else
        ret = ~0u;
 
#endif
    return ret;
}

WLDAP32_ldap_unbind()

ULONG CDECL WLDAP32_ldap_unbind

(

WLDAP32_LDAP *

ld

)

Definition at line 656 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", ld );
 
    if (ld)
        ret = map_error( ldap_unbind_ext( ld, NULL, NULL ));
    else
        ret = WLDAP32_LDAP_PARAM_ERROR;
 
#endif
    return ret;
}

WLDAP32_ldap_unbind_s()

ULONG CDECL WLDAP32_ldap_unbind_s

(

WLDAP32_LDAP *

ld

)

Definition at line 684 of file bind.c.

{
    ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", ld );
 
    if (ld)
        ret = map_error( ldap_unbind_ext_s( ld, NULL, NULL ));
    else
        ret = WLDAP32_LDAP_PARAM_ERROR;
 
#endif
    return ret;
}

WLDAP32_ldap_value_free_len()

ULONG CDECL WLDAP32_ldap_value_free_len

(

struct WLDAP32_berval **

vals

)

Definition at line 328 of file value.c.

{
#ifdef HAVE_LDAP
 
    TRACE( "(%p)\n", vals );
    ldap_value_free_len( (struct berval **)vals );
 
#endif
    return WLDAP32_LDAP_SUCCESS;
}

Variable Documentation

LDAP_CONTROL_VLVRESPONSE_W

const WCHAR LDAP_CONTROL_VLVRESPONSE_W[] = {'2','.','1','6','.','8','4','0','.','1','.','1','1','3','7','3','0','.','3','.','4','.','1','0',0}

static

Definition at line 204 of file winldap_private.h.

LDAP_PAGED_RESULT_OID_STRING_W

const WCHAR LDAP_PAGED_RESULT_OID_STRING_W[] = {'1','.','2','.','8','4','0','.','1','1','3','5','5','6','.','1','.','4','.','3','1','9',0}

static

Definition at line 202 of file winldap_private.h.

LDAP_SERVER_RESP_SORT_OID_W

const WCHAR LDAP_SERVER_RESP_SORT_OID_W[] = {'1','.','2','.','8','4','0','.','1','1','3','5','5','6','.','1','.','4','.','4','7','4',0}

static

Definition at line 203 of file winldap_private.h.