This graph shows which files directly or indirectly include 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.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ LAPI_MAJOR_VER1

◆ LAPI_MINOR_VER1

◆ LDAP_CONTROL_VLVRESPONSE

◆ LDAP_PAGED_RESULT_OID_STRING

◆ LDAP_SERVER_RESP_SORT_OID

◆ WLDAP32_LDAP_OPT_API_FEATURE_INFO

◆ WLDAP32_LDAP_OPT_API_INFO

◆ WLDAP32_LDAP_OPT_AREC_EXCLUSIVE

◆ WLDAP32_LDAP_OPT_AUTO_RECONNECT

◆ WLDAP32_LDAP_OPT_CACHE_ENABLE

◆ WLDAP32_LDAP_OPT_CACHE_FN_PTRS

◆ WLDAP32_LDAP_OPT_CACHE_STRATEGY

◆ WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE

◆ WLDAP32_LDAP_OPT_DEREF

◆ WLDAP32_LDAP_OPT_DESC

◆ WLDAP32_LDAP_OPT_DNSDOMAIN_NAME

◆ WLDAP32_LDAP_OPT_ENCRYPT

◆ WLDAP32_LDAP_OPT_ERROR_NUMBER

◆ WLDAP32_LDAP_OPT_ERROR_STRING

◆ WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND

◆ WLDAP32_LDAP_OPT_GETDSNAME_FLAGS

◆ WLDAP32_LDAP_OPT_HOST_NAME

◆ WLDAP32_LDAP_OPT_HOST_REACHABLE

◆ WLDAP32_LDAP_OPT_IO_FN_PTRS

◆ WLDAP32_LDAP_OPT_PING_KEEP_ALIVE

◆ WLDAP32_LDAP_OPT_PING_LIMIT

◆ WLDAP32_LDAP_OPT_PING_WAIT_TIME

◆ WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS

◆ WLDAP32_LDAP_OPT_PROTOCOL_VERSION

◆ WLDAP32_LDAP_OPT_REBIND_ARG

◆ WLDAP32_LDAP_OPT_REBIND_FN

◆ WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG

◆ WLDAP32_LDAP_OPT_REFERRAL_CALLBACK

◆ WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT

◆ WLDAP32_LDAP_OPT_REFERRALS

◆ WLDAP32_LDAP_OPT_RESTART

◆ WLDAP32_LDAP_OPT_ROOTDSE_CACHE

◆ WLDAP32_LDAP_OPT_SASL_METHOD

◆ WLDAP32_LDAP_OPT_SECURITY_CONTEXT

◆ WLDAP32_LDAP_OPT_SEND_TIMEOUT

◆ WLDAP32_LDAP_OPT_SERVER_CERTIFICATE

◆ WLDAP32_LDAP_OPT_SERVER_CONTROLS

◆ WLDAP32_LDAP_OPT_SERVER_ERROR

◆ WLDAP32_LDAP_OPT_SERVER_EXT_ERROR

◆ WLDAP32_LDAP_OPT_SIGN

◆ WLDAP32_LDAP_OPT_SIZELIMIT

◆ WLDAP32_LDAP_OPT_SSL

◆ WLDAP32_LDAP_OPT_SSL_INFO

◆ WLDAP32_LDAP_OPT_SSPI_FLAGS

◆ WLDAP32_LDAP_OPT_TCP_KEEPALIVE

◆ WLDAP32_LDAP_OPT_THREAD_FN_PTRS

◆ WLDAP32_LDAP_OPT_TIMELIMIT

◆ WLDAP32_LDAP_OPT_TLS

◆ WLDAP32_LDAP_OPT_TLS_INFO

◆ WLDAP32_LDAP_OPT_VERSION

Typedef Documentation

◆ BERVAL

◆ LDAP_BERVAL

◆ LDAP_TIMEVAL

◆ LDAP_VERSION_INFO

◆ LDAPAPIFeatureInfoA

◆ LDAPAPIFeatureInfoW

◆ LDAPAPIInfoA

◆ LDAPAPIInfoW

◆ LDAPControlA

◆ LDAPControlW

◆ LDAPModA

◆ LDAPModW

◆ LDAPSearch

◆ LDAPSortKeyA

◆ LDAPSortKeyW

◆ PBERVAL

◆ PLDAP_BERVAL