Headers diff for wldap32.dll between 5.2.3790.3959-Windows 5.0 and 6.0.6002.18005-Windows 6.0 versions



 winber.h (5.2.3790.3959-Windows 5.0)   winber.h (6.0.6002.18005-Windows 6.0) 
skipping to change at line 54 skipping to change at line 54
#ifndef BERAPI #ifndef BERAPI
#define BERAPI __cdecl #define BERAPI __cdecl
#endif #endif
#define LBER_ERROR 0xffffffffL #define LBER_ERROR 0xffffffffL
#define LBER_DEFAULT 0xffffffffL #define LBER_DEFAULT 0xffffffffL
typedef unsigned int ber_tag_t; /* for BER tags */ typedef unsigned int ber_tag_t; /* for BER tags */
typedef int ber_int_t; /* for BER ints, enums, and Booleans */ typedef int ber_int_t; /* for BER ints, enums, and Booleans */
typedef unsigned int ber_uint_t; /* unsigned equivalent of ber_int_t */ typedef unsigned int ber_uint_t; /* unsigned equivalent of ber_int_t */
typedef unsigned int ber_len_t; /* for BER octet strings and bit strings */
typedef int ber_slen_t; /* signed equivalent of ber_len_t */ typedef int ber_slen_t; /* signed equivalent of ber_len_t */
// //
// This constructs a new BerElement structure containing a copy of the // This constructs a new BerElement structure containing a copy of the
// data in the supplied berval structure. // data in the supplied berval structure.
// //
WINBERAPI BerElement * BERAPI ber_init( BERVAL *pBerVal ); WINBERAPI BerElement * BERAPI ber_init( BERVAL *pBerVal );
// //
skipping to change at line 137 skipping to change at line 138
// //
// This returns the tag and length of the first element in a SET, SET OF // This returns the tag and length of the first element in a SET, SET OF
// or SEQUENCE OF data value. // or SEQUENCE OF data value.
// //
// LBER_DEFAULT is returned if the constructed value is empty else, the tag // LBER_DEFAULT is returned if the constructed value is empty else, the tag
// is returned. It also returns an opaque cookie which has to be passed to // is returned. It also returns an opaque cookie which has to be passed to
// subsequent invocations of ber_next_element(). // subsequent invocations of ber_next_element().
// //
WINBERAPI ULONG BERAPI ber_first_element( BerElement *pBerElement, ULONG *pLen, CHAR **ppOpaque ); WINBERAPI ULONG BERAPI ber_first_element( BerElement *pBerElement, ULONG *pLen, __out CHAR **ppOpaque );
// //
// This positions the state at the start of the next element in the // This positions the state at the start of the next element in the
// constructed type. // constructed type.
// //
// LBER_DEFAULT is returned if the constructed value is empty else, the tag // LBER_DEFAULT is returned if the constructed value is empty else, the tag
// is returned. // is returned.
// //
WINBERAPI ULONG BERAPI ber_next_element( BerElement *pBerElement, ULONG *pLen, C HAR *opaque ); WINBERAPI ULONG BERAPI ber_next_element( BerElement *pBerElement, ULONG *pLen, _ _in CHAR *opaque );
// //
// This allocates a BerVal structure whose contents are taken from the // This allocates a BerVal structure whose contents are taken from the
// supplied BerElement structure. // supplied BerElement structure.
// //
// The return values are 0 on success and -1 on error. // The return values are 0 on success and -1 on error.
// //
WINBERAPI INT BERAPI ber_flatten( BerElement *pBerElement, PBERVAL *pBerVal ); WINBERAPI INT BERAPI ber_flatten( BerElement *pBerElement, PBERVAL *pBerVal );
skipping to change at line 238 skipping to change at line 239
'}' End sequence. No argument is needed. The 't' format modifier '}' End sequence. No argument is needed. The 't' format modifier
cannot be used with this format character. cannot be used with this format character.
'[' Begin set. No argument is needed. If this format character is '[' Begin set. No argument is needed. If this format character is
not preceded by the 't' format modifier, the tag 0x31U is used. not preceded by the 't' format modifier, the tag 0x31U is used.
']' End set. No argument is needed. The 't' format modifier cannot ']' End set. No argument is needed. The 't' format modifier cannot
be used with this format character. be used with this format character.
*/ */
WINBERAPI INT BERAPI ber_printf( BerElement *pBerElement, PCHAR fmt, ... ); WINBERAPI INT BERAPI ber_printf( BerElement *pBerElement, __in PCHAR fmt, ... );
/* /*
The ber_scanf() routine is used to decode a BER element in much the same The ber_scanf() routine is used to decode a BER element in much the same
way that sscanf() works. One important difference, though, is that some way that sscanf() works. One important difference, though, is that some
state information is kept with the ber argument so that multiple calls state information is kept with the ber argument so that multiple calls
can be made to ber_scanf() to sequentially read from the BER element. can be made to ber_scanf() to sequentially read from the BER element.
The ber argument SHOULD be a pointer to a BerElement returned by The ber argument SHOULD be a pointer to a BerElement returned by
ber_init(). ber_scanf interprets the bytes according to the format ber_init(). ber_scanf interprets the bytes according to the format
string fmt, and stores the results in its additional arguments. string fmt, and stores the results in its additional arguments.
ber_scanf() returns LBER_ERROR on error, and a different value on suc- ber_scanf() returns LBER_ERROR on error, and a different value on suc-
skipping to change at line 330 skipping to change at line 331
'}' End sequence. No argument is needed. '}' End sequence. No argument is needed.
'[' Begin set. No argument is needed. The initial set tag and '[' Begin set. No argument is needed. The initial set tag and
length are skipped. length are skipped.
']' End set. No argument is needed. ']' End set. No argument is needed.
*/ */
WINBERAPI ULONG BERAPI ber_scanf( BerElement *pBerElement, PCHAR fmt, ... ); WINBERAPI ULONG BERAPI ber_scanf( BerElement *pBerElement, __in PCHAR fmt, ... ) ;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // _WINBER_DEFINED_ #endif // _WINBER_DEFINED_
 End of changes. 5 change blocks. 
4 lines changed or deleted 5 lines changed or added


 winldap.h (5.2.3790.3959-Windows 5.0)   winldap.h (6.0.6002.18005-Windows 6.0) 
skipping to change at line 591 skipping to change at line 591
// If it returns NULL, an error occurred. Pick up error code with // If it returns NULL, an error occurred. Pick up error code with
// GetLastError(). // GetLastError().
// //
// ldap_open actually opens the connection at the time of the call, // ldap_open actually opens the connection at the time of the call,
// whereas ldap_init only opens the connection when an operation is performed // whereas ldap_init only opens the connection when an operation is performed
// that requires it. // that requires it.
// //
// multi-thread: ldap_open*, ldap_init*, and ldap_sslinit* calls are safe. // multi-thread: ldap_open*, ldap_init*, and ldap_sslinit* calls are safe.
// //
WINLDAPAPI LDAP * LDAPAPI ldap_openW( const PWCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI ldap_openW( __in const PWCHAR HostName, ULONG PortNumb er );
WINLDAPAPI LDAP * LDAPAPI ldap_openA( const PCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI ldap_openA( const PCHAR HostName, ULONG PortNumber );
WINLDAPAPI LDAP * LDAPAPI ldap_initW( const PWCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI ldap_initW( __in const PWCHAR HostName, ULONG PortNumb er );
WINLDAPAPI LDAP * LDAPAPI ldap_initA( const PCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI ldap_initA( const PCHAR HostName, ULONG PortNumber );
WINLDAPAPI LDAP * LDAPAPI ldap_sslinitW( PWCHAR HostName, ULONG PortNumber, int secure ); WINLDAPAPI LDAP * LDAPAPI ldap_sslinitW( __in PWCHAR HostName, ULONG PortNumber, int secure );
WINLDAPAPI LDAP * LDAPAPI ldap_sslinitA( PCHAR HostName, ULONG PortNumber, int s ecure ); WINLDAPAPI LDAP * LDAPAPI ldap_sslinitA( PCHAR HostName, ULONG PortNumber, int s ecure );
// //
// when calling ldap_init, you can call ldap_connect explicitly to have the // when calling ldap_init, you can call ldap_connect explicitly to have the
// library contact the server. This is useful for checking for server // library contact the server. This is useful for checking for server
// availability. This call is not required however, since the other functions // availability. This call is not required however, since the other functions
// will call it internally if it hasn't already been called. // will call it internally if it hasn't already been called.
// //
WINLDAPAPI ULONG LDAPAPI ldap_connect( LDAP *ld, WINLDAPAPI ULONG LDAPAPI ldap_connect( LDAP *ld,
skipping to change at line 619 skipping to change at line 619
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_open ldap_openW #define ldap_open ldap_openW
#define ldap_init ldap_initW #define ldap_init ldap_initW
#define ldap_sslinit ldap_sslinitW #define ldap_sslinit ldap_sslinitW
#else #else
WINLDAPAPI LDAP * LDAPAPI ldap_open( PCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI ldap_open( __in PCHAR HostName, ULONG PortNumber );
WINLDAPAPI LDAP * LDAPAPI ldap_init( PCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI ldap_init( __in PCHAR HostName, ULONG PortNumber );
WINLDAPAPI LDAP * LDAPAPI ldap_sslinit( PCHAR HostName, ULONG PortNumber, int se WINLDAPAPI LDAP * LDAPAPI ldap_sslinit( __in PCHAR HostName, ULONG PortNumber, i
cure ); nt secure );
#endif #endif
// //
// This is similar to ldap_open except it creates a connection block for // This is similar to ldap_open except it creates a connection block for
// UDP based Connectionless LDAP services. No TCP session is maintained. // UDP based Connectionless LDAP services. No TCP session is maintained.
// //
// If it returns NULL, an error occurred. Pick up error code with // If it returns NULL, an error occurred. Pick up error code with
// GetLastError(). // GetLastError().
// //
// multi-thread: cldap_open* calls are safe. // multi-thread: cldap_open* calls are safe.
// //
WINLDAPAPI LDAP * LDAPAPI cldap_openW( PWCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI cldap_openW( __in PWCHAR HostName, ULONG PortNumber );
WINLDAPAPI LDAP * LDAPAPI cldap_openA( PCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI cldap_openA( __in PCHAR HostName, ULONG PortNumber );
#if LDAP_UNICODE #if LDAP_UNICODE
#define cldap_open cldap_openW #define cldap_open cldap_openW
#else #else
WINLDAPAPI LDAP * LDAPAPI cldap_open( PCHAR HostName, ULONG PortNumber ); WINLDAPAPI LDAP * LDAPAPI cldap_open( __in PCHAR HostName, ULONG PortNumber );
#endif #endif
// //
// Call unbind when you're done with the connection, it will free all // Call unbind when you're done with the connection, it will free all
// resources associated with the connection. // resources associated with the connection.
// //
// There is no ldap_close... use ldap_unbind even if you haven't called // There is no ldap_close... use ldap_unbind even if you haven't called
// ldap_bind on the connection. // ldap_bind on the connection.
// //
skipping to change at line 833 skipping to change at line 833
// (1) switch the client into a mode where it supports simultaneous // (1) switch the client into a mode where it supports simultaneous
// simple binds on the connection, and (2) sends the extended operation // simple binds on the connection, and (2) sends the extended operation
// to the server to switch it into fast bind mode. Only simple binds // to the server to switch it into fast bind mode. Only simple binds
// are supported in this mode. // are supported in this mode.
// //
#define LDAP_OPT_FAST_CONCURRENT_BIND 0x41 #define LDAP_OPT_FAST_CONCURRENT_BIND 0x41
#define LDAP_OPT_SEND_TIMEOUT 0x42 #define LDAP_OPT_SEND_TIMEOUT 0x42
// //
// Flags to control the behavior of Schannel
//
#define LDAP_OPT_SCH_FLAGS 0x43
//
// List of local interface addresses (IPv4 or IPv6) that will be used for
// socket bind when establishing a connecting.
//
#define LDAP_OPT_SOCKET_BIND_ADDRESSES 0x44
//
// End of Microsoft only options // End of Microsoft only options
// //
#define LDAP_OPT_ON ((void *) 1) #define LDAP_OPT_ON ((void *) 1)
#define LDAP_OPT_OFF ((void *) 0) #define LDAP_OPT_OFF ((void *) 0)
// //
// For chasing referrals, we extend this a bit for LDAP_OPT_REFERRALS. If // For chasing referrals, we extend this a bit for LDAP_OPT_REFERRALS. If
// the value is not LDAP_OPT_ON or LDAP_OPT_OFF, we'll treat them as the // the value is not LDAP_OPT_ON or LDAP_OPT_OFF, we'll treat them as the
// following : // following :
skipping to change at line 864 skipping to change at line 875
#define LDAP_CHASE_EXTERNAL_REFERRALS 0x00000040 #define LDAP_CHASE_EXTERNAL_REFERRALS 0x00000040
// //
// Bind is required as the first operation to v2 servers, not so for v3 // Bind is required as the first operation to v2 servers, not so for v3
// servers. See above description of authentication methods. // servers. See above description of authentication methods.
// //
// multi-thread: bind calls are not safe in that it affects the // multi-thread: bind calls are not safe in that it affects the
// connection as a whole. beware if threads share connections // connection as a whole. beware if threads share connections
// and try to mulithread binds with other operations. // and try to mulithread binds with other operations.
WINLDAPAPI ULONG LDAPAPI ldap_simple_bindW( LDAP *ld, PWCHAR dn, PWCHAR passwd ) ; WINLDAPAPI ULONG LDAPAPI ldap_simple_bindW( LDAP *ld, __in_opt PWCHAR dn, __in_o pt PWCHAR passwd );
WINLDAPAPI ULONG LDAPAPI ldap_simple_bindA( LDAP *ld, PCHAR dn, PCHAR passwd ); WINLDAPAPI ULONG LDAPAPI ldap_simple_bindA( LDAP *ld, PCHAR dn, PCHAR passwd );
WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_sW( LDAP *ld, PWCHAR dn, PWCHAR passwd ); WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_sW( LDAP *ld, __in_opt PWCHAR dn, __in _opt PWCHAR passwd );
WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_sA( LDAP *ld, PCHAR dn, PCHAR passwd ) ; WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_sA( LDAP *ld, PCHAR dn, PCHAR passwd ) ;
WINLDAPAPI ULONG LDAPAPI ldap_bindW( LDAP *ld, PWCHAR dn, PWCHAR cred, ULONG met hod ); WINLDAPAPI ULONG LDAPAPI ldap_bindW( LDAP *ld, __in_opt PWCHAR dn, __in_opt PWCH AR cred, ULONG method );
WINLDAPAPI ULONG LDAPAPI ldap_bindA( LDAP *ld, PCHAR dn, PCHAR cred, ULONG metho d ); WINLDAPAPI ULONG LDAPAPI ldap_bindA( LDAP *ld, PCHAR dn, PCHAR cred, ULONG metho d );
WINLDAPAPI ULONG LDAPAPI ldap_bind_sW( LDAP *ld, PWCHAR dn, PWCHAR cred, ULONG m ethod ); WINLDAPAPI ULONG LDAPAPI ldap_bind_sW( LDAP *ld, __in_opt PWCHAR dn, __in_opt PW CHAR cred, ULONG method );
WINLDAPAPI ULONG LDAPAPI ldap_bind_sA( LDAP *ld, PCHAR dn, PCHAR cred, ULONG met hod ); WINLDAPAPI ULONG LDAPAPI ldap_bind_sA( LDAP *ld, PCHAR dn, PCHAR cred, ULONG met hod );
// //
// The following functions can be used to pass in any arbitrary credentials // The following functions can be used to pass in any arbitrary credentials
// to the server. The application must be ready to interpret the response // to the server. The application must be ready to interpret the response
// sent back from the server. // sent back from the server.
// //
WINLDAPAPI INT LDAPAPI ldap_sasl_bindA( WINLDAPAPI INT LDAPAPI ldap_sasl_bindA(
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistName, __in const PCHAR DistName,
const PCHAR AuthMechanism, __in const PCHAR AuthMechanism,
const BERVAL *cred, const BERVAL *cred,
PLDAPControlA *ServerCtrls, PLDAPControlA *ServerCtrls,
PLDAPControlA *ClientCtrls, PLDAPControlA *ClientCtrls,
int *MessageNumber int *MessageNumber
); );
WINLDAPAPI INT LDAPAPI ldap_sasl_bindW( WINLDAPAPI INT LDAPAPI ldap_sasl_bindW(
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PWCHAR DistName, __in const PWCHAR DistName,
const PWCHAR AuthMechanism, __in const PWCHAR AuthMechanism,
const BERVAL *cred, const BERVAL *cred,
PLDAPControlW *ServerCtrls, PLDAPControlW *ServerCtrls,
PLDAPControlW *ClientCtrls, PLDAPControlW *ClientCtrls,
int *MessageNumber int *MessageNumber
); );
WINLDAPAPI INT LDAPAPI ldap_sasl_bind_sA( WINLDAPAPI INT LDAPAPI ldap_sasl_bind_sA(
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistName, __in const PCHAR DistName,
const PCHAR AuthMechanism, __in const PCHAR AuthMechanism,
const BERVAL *cred, const BERVAL *cred,
PLDAPControlA *ServerCtrls, PLDAPControlA *ServerCtrls,
PLDAPControlA *ClientCtrls, PLDAPControlA *ClientCtrls,
PBERVAL *ServerData PBERVAL *ServerData
); );
WINLDAPAPI INT LDAPAPI ldap_sasl_bind_sW( WINLDAPAPI INT LDAPAPI ldap_sasl_bind_sW(
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PWCHAR DistName, __in const PWCHAR DistName,
const PWCHAR AuthMechanism, __in const PWCHAR AuthMechanism,
const BERVAL *cred, const BERVAL *cred,
PLDAPControlW *ServerCtrls, PLDAPControlW *ServerCtrls,
PLDAPControlW *ClientCtrls, PLDAPControlW *ClientCtrls,
PBERVAL *ServerData PBERVAL *ServerData
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_simple_bind ldap_simple_bindW #define ldap_simple_bind ldap_simple_bindW
#define ldap_simple_bind_s ldap_simple_bind_sW #define ldap_simple_bind_s ldap_simple_bind_sW
#define ldap_bind ldap_bindW #define ldap_bind ldap_bindW
#define ldap_bind_s ldap_bind_sW #define ldap_bind_s ldap_bind_sW
#define ldap_sasl_bind ldap_sasl_bindW #define ldap_sasl_bind ldap_sasl_bindW
#define ldap_sasl_bind_s ldap_sasl_bind_sW #define ldap_sasl_bind_s ldap_sasl_bind_sW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_simple_bind( LDAP *ld, const PCHAR dn, const PCHAR WINLDAPAPI ULONG LDAPAPI ldap_simple_bind( LDAP *ld, __in_opt const PCHAR dn, __
passwd ); in_opt const PCHAR passwd );
WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_s( LDAP *ld, const PCHAR dn, const PCH WINLDAPAPI ULONG LDAPAPI ldap_simple_bind_s( LDAP *ld, __in_opt const PCHAR dn,
AR passwd ); __in_opt const PCHAR passwd );
WINLDAPAPI ULONG LDAPAPI ldap_bind( LDAP *ld, const PCHAR dn, const PCHAR cred, WINLDAPAPI ULONG LDAPAPI ldap_bind( LDAP *ld, __in_opt const PCHAR dn, __in_opt
ULONG method ); const PCHAR cred, ULONG method );
WINLDAPAPI ULONG LDAPAPI ldap_bind_s( LDAP *ld, const PCHAR dn, const PCHAR cred WINLDAPAPI ULONG LDAPAPI ldap_bind_s( LDAP *ld, __in_opt const PCHAR dn, __in_op
, ULONG method ); t const PCHAR cred, ULONG method );
#define ldap_sasl_bind ldap_sasl_bindA #define ldap_sasl_bind ldap_sasl_bindA
#define ldap_sasl_bind_s ldap_sasl_bind_sA #define ldap_sasl_bind_s ldap_sasl_bind_sA
#endif #endif
// //
// Synchronous and asynch search routines. // Synchronous and asynch search routines.
// //
// filter follows RFC 1960 with the addition that '(' ')' '*' ' ' '\' and // filter follows RFC 1960 with the addition that '(' ')' '*' ' ' '\' and
skipping to change at line 969 skipping to change at line 980
// at the connection block in an error case and the return code // at the connection block in an error case and the return code
// may be overwritten by another thread inbetween. // may be overwritten by another thread inbetween.
// //
// Use ldap_search_ext instead, as these are thread safe. // Use ldap_search_ext instead, as these are thread safe.
// //
// ldap_search_s and ldap_search_ext* calls are thread safe. // ldap_search_s and ldap_search_ext* calls are thread safe.
// //
WINLDAPAPI ULONG LDAPAPI ldap_searchW( WINLDAPAPI ULONG LDAPAPI ldap_searchW(
LDAP *ld, LDAP *ld,
const PWCHAR base, // distinguished name or "" __in const PWCHAR base, // distinguished name or ""
ULONG scope, // LDAP_SCOPE_xxxx ULONG scope, // LDAP_SCOPE_xxxx
const PWCHAR filter, __in const PWCHAR filter,
PWCHAR attrs[], // pointer to an array of PCHAR attribute names __in PWCHAR attrs[], // pointer to an array of PCHAR attribute n
ames
ULONG attrsonly // boolean on whether to only return attr names ULONG attrsonly // boolean on whether to only return attr names
); );
WINLDAPAPI ULONG LDAPAPI ldap_searchA( WINLDAPAPI ULONG LDAPAPI ldap_searchA(
LDAP *ld, LDAP *ld,
const PCHAR base, // distinguished name or "" __in const PCHAR base, // distinguished name or ""
ULONG scope, // LDAP_SCOPE_xxxx ULONG scope, // LDAP_SCOPE_xxxx
const PCHAR filter, __in const PCHAR filter,
PCHAR attrs[], // pointer to an array of PCHAR attribute names __in PCHAR attrs[], // pointer to an array of PCHAR attribute n
ames
ULONG attrsonly // boolean on whether to only return attr names ULONG attrsonly // boolean on whether to only return attr names
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_sW( WINLDAPAPI ULONG LDAPAPI ldap_search_sW(
LDAP *ld, LDAP *ld,
const PWCHAR base, __in const PWCHAR base,
ULONG scope, ULONG scope,
const PWCHAR filter, __in const PWCHAR filter,
PWCHAR attrs[], __in PWCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
LDAPMessage **res LDAPMessage **res
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_sA( WINLDAPAPI ULONG LDAPAPI ldap_search_sA(
LDAP *ld, LDAP *ld,
const PCHAR base, const PCHAR base,
ULONG scope, ULONG scope,
const PCHAR filter, const PCHAR filter,
PCHAR attrs[], PCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
LDAPMessage **res LDAPMessage **res
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_stW( WINLDAPAPI ULONG LDAPAPI ldap_search_stW(
LDAP *ld, LDAP *ld,
const PWCHAR base, __in const PWCHAR base,
ULONG scope, ULONG scope,
const PWCHAR filter, __in const PWCHAR filter,
PWCHAR attrs[], __in PWCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
struct l_timeval *timeout, struct l_timeval *timeout,
LDAPMessage **res LDAPMessage **res
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_stA( WINLDAPAPI ULONG LDAPAPI ldap_search_stA(
LDAP *ld, LDAP *ld,
const PCHAR base, const PCHAR base,
ULONG scope, ULONG scope,
const PCHAR filter, const PCHAR filter,
PCHAR attrs[], PCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
struct l_timeval *timeout, struct l_timeval *timeout,
LDAPMessage **res LDAPMessage **res
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_extW( WINLDAPAPI ULONG LDAPAPI ldap_search_extW(
LDAP *ld, LDAP *ld,
const PWCHAR base, __in const PWCHAR base,
ULONG scope, ULONG scope,
const PWCHAR filter, __in const PWCHAR filter,
PWCHAR attrs[], __in PWCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG TimeLimit, ULONG TimeLimit,
ULONG SizeLimit, ULONG SizeLimit,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_extA( WINLDAPAPI ULONG LDAPAPI ldap_search_extA(
LDAP *ld, LDAP *ld,
const PCHAR base, __in const PCHAR base,
ULONG scope, ULONG scope,
const PCHAR filter, __in const PCHAR filter,
PCHAR attrs[], __in PCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG TimeLimit, ULONG TimeLimit,
ULONG SizeLimit, ULONG SizeLimit,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_ext_sW( WINLDAPAPI ULONG LDAPAPI ldap_search_ext_sW(
LDAP *ld, LDAP *ld,
const PWCHAR base, __in const PWCHAR base,
ULONG scope, __in ULONG scope,
const PWCHAR filter, __in const PWCHAR filter,
PWCHAR attrs[], __in PWCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
struct l_timeval *timeout, struct l_timeval *timeout,
ULONG SizeLimit, ULONG SizeLimit,
LDAPMessage **res LDAPMessage **res
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_ext_sA( WINLDAPAPI ULONG LDAPAPI ldap_search_ext_sA(
LDAP *ld, LDAP *ld,
const PCHAR base, __in const PCHAR base,
ULONG scope, ULONG scope,
const PCHAR filter, __in const PCHAR filter,
PCHAR attrs[], __in PCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
struct l_timeval *timeout, struct l_timeval *timeout,
ULONG SizeLimit, ULONG SizeLimit,
LDAPMessage **res LDAPMessage **res
); );
#if LDAP_UNICODE #if LDAP_UNICODE
skipping to change at line 1093 skipping to change at line 1104
#define ldap_search_s ldap_search_sW #define ldap_search_s ldap_search_sW
#define ldap_search_st ldap_search_stW #define ldap_search_st ldap_search_stW
#define ldap_search_ext ldap_search_extW #define ldap_search_ext ldap_search_extW
#define ldap_search_ext_s ldap_search_ext_sW #define ldap_search_ext_s ldap_search_ext_sW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_search( WINLDAPAPI ULONG LDAPAPI ldap_search(
LDAP *ld, LDAP *ld,
PCHAR base, // distinguished name or "" __in PCHAR base, // distinguished name or ""
ULONG scope, // LDAP_SCOPE_xxxx ULONG scope, // LDAP_SCOPE_xxxx
PCHAR filter, __in PCHAR filter,
PCHAR attrs[], // pointer to an array of PCHAR attribute names __in PCHAR attrs[], // pointer to an array of PCHAR attribute n
ames
ULONG attrsonly // boolean on whether to only return attr names ULONG attrsonly // boolean on whether to only return attr names
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_s( WINLDAPAPI ULONG LDAPAPI ldap_search_s(
LDAP *ld, LDAP *ld,
PCHAR base, __in PCHAR base,
ULONG scope, ULONG scope,
PCHAR filter, __in PCHAR filter,
PCHAR attrs[], __in PCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
LDAPMessage **res LDAPMessage **res
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_st( WINLDAPAPI ULONG LDAPAPI ldap_search_st(
LDAP *ld, LDAP *ld,
PCHAR base, __in PCHAR base,
ULONG scope, ULONG scope,
PCHAR filter, __in PCHAR filter,
PCHAR attrs[], __in PCHAR attrs[],
ULONG attrsonly, ULONG attrsonly,
struct l_timeval *timeout, struct l_timeval *timeout,
LDAPMessage **res LDAPMessage **res
); );
WINLDAPAPI ULONG LDAPAPI ldap_search_ext( WINLDAPAPI ULONG LDAPAPI ldap_search_ext(
LDAP *ld, LDAP *ld,
PCHAR base, PCHAR base,
ULONG scope, ULONG scope,
PCHAR filter, PCHAR filter,
skipping to change at line 1159 skipping to change at line 1170
#endif #endif
// //
// Extended API to check filter syntax. Returns LDAP error code if syntax // Extended API to check filter syntax. Returns LDAP error code if syntax
// is invalid or LDAP_SUCCESS if it's ok. // is invalid or LDAP_SUCCESS if it's ok.
// //
WINLDAPAPI ULONG LDAPAPI WINLDAPAPI ULONG LDAPAPI
ldap_check_filterW( ldap_check_filterW(
LDAP *ld, LDAP *ld,
PWCHAR SearchFilter __in PWCHAR SearchFilter
); );
WINLDAPAPI ULONG LDAPAPI WINLDAPAPI ULONG LDAPAPI
ldap_check_filterA( ldap_check_filterA(
LDAP *ld, LDAP *ld,
PCHAR SearchFilter __in PCHAR SearchFilter
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_check_filter ldap_check_filterW #define ldap_check_filter ldap_check_filterW
#else #else
#define ldap_check_filter ldap_check_filterA #define ldap_check_filter ldap_check_filterA
#endif #endif
// //
// modify an existing entry // modify an existing entry
skipping to change at line 1189 skipping to change at line 1200
// multi-thread: ldap_modify calls are not safe in that the message number // multi-thread: ldap_modify calls are not safe in that the message number
// is returned rather than the return code. You have to look // is returned rather than the return code. You have to look
// at the connection block in an error case and the return code // at the connection block in an error case and the return code
// may be overwritten by another thread inbetween. // may be overwritten by another thread inbetween.
// //
// Use ldap_modify_ext instead, as these are thread safe. // Use ldap_modify_ext instead, as these are thread safe.
// //
// ldap_modify_s and ldap_modify_ext* calls are thread safe. // ldap_modify_s and ldap_modify_ext* calls are thread safe.
// //
WINLDAPAPI ULONG LDAPAPI ldap_modifyW( LDAP *ld, PWCHAR dn, LDAPModW *mods[] ); WINLDAPAPI ULONG LDAPAPI ldap_modifyW( LDAP *ld, __in PWCHAR dn, LDAPModW *mods[ ] );
WINLDAPAPI ULONG LDAPAPI ldap_modifyA( LDAP *ld, PCHAR dn, LDAPModA *mods[] ); WINLDAPAPI ULONG LDAPAPI ldap_modifyA( LDAP *ld, PCHAR dn, LDAPModA *mods[] );
WINLDAPAPI ULONG LDAPAPI ldap_modify_sW( LDAP *ld, PWCHAR dn, LDAPModW *mods[] ) ; WINLDAPAPI ULONG LDAPAPI ldap_modify_sW( LDAP *ld, __in PWCHAR dn, LDAPModW *mod s[] );
WINLDAPAPI ULONG LDAPAPI ldap_modify_sA( LDAP *ld, PCHAR dn, LDAPModA *mods[] ); WINLDAPAPI ULONG LDAPAPI ldap_modify_sA( LDAP *ld, PCHAR dn, LDAPModA *mods[] );
WINLDAPAPI ULONG LDAPAPI ldap_modify_extW( WINLDAPAPI ULONG LDAPAPI ldap_modify_extW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
LDAPModW *mods[], LDAPModW *mods[],
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_modify_extA( WINLDAPAPI ULONG LDAPAPI ldap_modify_extA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
LDAPModA *mods[], LDAPModA *mods[],
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_modify_ext_sW( WINLDAPAPI ULONG LDAPAPI ldap_modify_ext_sW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
LDAPModW *mods[], LDAPModW *mods[],
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls PLDAPControlW *ClientControls
); );
WINLDAPAPI ULONG LDAPAPI ldap_modify_ext_sA( WINLDAPAPI ULONG LDAPAPI ldap_modify_ext_sA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
LDAPModA *mods[], LDAPModA *mods[],
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls PLDAPControlA *ClientControls
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_modify ldap_modifyW #define ldap_modify ldap_modifyW
#define ldap_modify_s ldap_modify_sW #define ldap_modify_s ldap_modify_sW
#define ldap_modify_ext ldap_modify_extW #define ldap_modify_ext ldap_modify_extW
#define ldap_modify_ext_s ldap_modify_ext_sW #define ldap_modify_ext_s ldap_modify_ext_sW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_modify( LDAP *ld, PCHAR dn, LDAPModA *mods[] ); WINLDAPAPI ULONG LDAPAPI ldap_modify( LDAP *ld, __in PCHAR dn, LDAPModA *mods[]
WINLDAPAPI ULONG LDAPAPI ldap_modify_s( LDAP *ld, PCHAR dn, LDAPModA *mods[] ); );
WINLDAPAPI ULONG LDAPAPI ldap_modify_s( LDAP *ld, __in PCHAR dn, LDAPModA *mods[
] );
WINLDAPAPI ULONG LDAPAPI ldap_modify_ext( WINLDAPAPI ULONG LDAPAPI ldap_modify_ext(
LDAP *ld, LDAP *ld,
const PCHAR dn, const PCHAR dn,
LDAPModA *mods[], LDAPModA *mods[],
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
skipping to change at line 1298 skipping to change at line 1309
// the message number is returned rather than the return code. // the message number is returned rather than the return code.
// You have to look at the connection block in an error case // You have to look at the connection block in an error case
// and the return code may be overwritten by another thread // and the return code may be overwritten by another thread
// inbetween. // inbetween.
// //
// Use ldap_rename_ext instead, as these are thread safe. // Use ldap_rename_ext instead, as these are thread safe.
// //
WINLDAPAPI ULONG LDAPAPI ldap_modrdn2W ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn2W (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PWCHAR DistinguishedName, __in const PWCHAR DistinguishedName,
const PWCHAR NewDistinguishedName, __in const PWCHAR NewDistinguishedName,
INT DeleteOldRdn INT DeleteOldRdn
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn2A ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn2A (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName, const PCHAR NewDistinguishedName,
INT DeleteOldRdn INT DeleteOldRdn
); );
// //
// ldap_modrdn simply calls ldap_modrdn2 with a value of 1 for DeleteOldRdn. // ldap_modrdn simply calls ldap_modrdn2 with a value of 1 for DeleteOldRdn.
// //
WINLDAPAPI ULONG LDAPAPI ldap_modrdnW ( WINLDAPAPI ULONG LDAPAPI ldap_modrdnW (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PWCHAR DistinguishedName, __in const PWCHAR DistinguishedName,
const PWCHAR NewDistinguishedName __in const PWCHAR NewDistinguishedName
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdnA ( WINLDAPAPI ULONG LDAPAPI ldap_modrdnA (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName const PCHAR NewDistinguishedName
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_sW ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_sW (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PWCHAR DistinguishedName, __in const PWCHAR DistinguishedName,
const PWCHAR NewDistinguishedName, __in const PWCHAR NewDistinguishedName,
INT DeleteOldRdn INT DeleteOldRdn
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_sA ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_sA (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName, const PCHAR NewDistinguishedName,
INT DeleteOldRdn INT DeleteOldRdn
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn_sW ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn_sW (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PWCHAR DistinguishedName, __in const PWCHAR DistinguishedName,
const PWCHAR NewDistinguishedName __in const PWCHAR NewDistinguishedName
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn_sA ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn_sA (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName const PCHAR NewDistinguishedName
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_modrdn2 ldap_modrdn2W #define ldap_modrdn2 ldap_modrdn2W
#define ldap_modrdn ldap_modrdnW #define ldap_modrdn ldap_modrdnW
#define ldap_modrdn2_s ldap_modrdn2_sW #define ldap_modrdn2_s ldap_modrdn2_sW
#define ldap_modrdn_s ldap_modrdn_sW #define ldap_modrdn_s ldap_modrdn_sW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_modrdn2 ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn2 (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, __in const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName, __in const PCHAR NewDistinguishedName,
INT DeleteOldRdn INT DeleteOldRdn
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, __in const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName __in const PCHAR NewDistinguishedName
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_s ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn2_s (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, __in const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName, __in const PCHAR NewDistinguishedName,
INT DeleteOldRdn INT DeleteOldRdn
); );
WINLDAPAPI ULONG LDAPAPI ldap_modrdn_s ( WINLDAPAPI ULONG LDAPAPI ldap_modrdn_s (
LDAP *ExternalHandle, LDAP *ExternalHandle,
const PCHAR DistinguishedName, __in const PCHAR DistinguishedName,
const PCHAR NewDistinguishedName __in const PCHAR NewDistinguishedName
); );
#endif #endif
// //
// Extended Rename operations. These take controls and separate out the // Extended Rename operations. These take controls and separate out the
// parent from the RDN, for clarity. // parent from the RDN, for clarity.
// //
WINLDAPAPI ULONG LDAPAPI ldap_rename_extW( WINLDAPAPI ULONG LDAPAPI ldap_rename_extW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
const PWCHAR NewRDN, __in const PWCHAR NewRDN,
const PWCHAR NewParent, __in_opt const PWCHAR NewParent,
INT DeleteOldRdn, INT DeleteOldRdn,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_rename_extA( WINLDAPAPI ULONG LDAPAPI ldap_rename_extA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
const PCHAR NewRDN, __in const PCHAR NewRDN,
const PCHAR NewParent, __in_opt const PCHAR NewParent,
INT DeleteOldRdn, INT DeleteOldRdn,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_rename_ext_sW( WINLDAPAPI ULONG LDAPAPI ldap_rename_ext_sW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
const PWCHAR NewRDN, __in const PWCHAR NewRDN,
const PWCHAR NewParent, __in_opt const PWCHAR NewParent,
INT DeleteOldRdn, INT DeleteOldRdn,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls PLDAPControlW *ClientControls
); );
WINLDAPAPI ULONG LDAPAPI ldap_rename_ext_sA( WINLDAPAPI ULONG LDAPAPI ldap_rename_ext_sA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
const PCHAR NewRDN, __in const PCHAR NewRDN,
const PCHAR NewParent, __in_opt const PCHAR NewParent,
INT DeleteOldRdn, INT DeleteOldRdn,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls PLDAPControlA *ClientControls
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_rename ldap_rename_extW #define ldap_rename ldap_rename_extW
#define ldap_rename_s ldap_rename_ext_sW #define ldap_rename_s ldap_rename_ext_sW
skipping to change at line 1485 skipping to change at line 1496
// multi-thread: ldap_add calls are not safe in that the message number // multi-thread: ldap_add calls are not safe in that the message number
// is returned rather than the return code. You have to look // is returned rather than the return code. You have to look
// at the connection block in an error case and the return code // at the connection block in an error case and the return code
// may be overwritten by another thread inbetween. // may be overwritten by another thread inbetween.
// //
// Use ldap_add_ext instead, as these are thread safe. // Use ldap_add_ext instead, as these are thread safe.
// //
// ldap_add_s and ldap_add_ext* calls are thread safe. // ldap_add_s and ldap_add_ext* calls are thread safe.
// //
WINLDAPAPI ULONG LDAPAPI ldap_addW( LDAP *ld, PWCHAR dn, LDAPModW *attrs[] ); WINLDAPAPI ULONG LDAPAPI ldap_addW( LDAP *ld, __in PWCHAR dn, LDAPModW *attrs[] );
WINLDAPAPI ULONG LDAPAPI ldap_addA( LDAP *ld, PCHAR dn, LDAPModA *attrs[] ); WINLDAPAPI ULONG LDAPAPI ldap_addA( LDAP *ld, PCHAR dn, LDAPModA *attrs[] );
WINLDAPAPI ULONG LDAPAPI ldap_add_sW( LDAP *ld, PWCHAR dn, LDAPModW *attrs[] ); WINLDAPAPI ULONG LDAPAPI ldap_add_sW( LDAP *ld, __in PWCHAR dn, LDAPModW *attrs[ ] );
WINLDAPAPI ULONG LDAPAPI ldap_add_sA( LDAP *ld, PCHAR dn, LDAPModA *attrs[] ); WINLDAPAPI ULONG LDAPAPI ldap_add_sA( LDAP *ld, PCHAR dn, LDAPModA *attrs[] );
WINLDAPAPI ULONG LDAPAPI ldap_add_extW( WINLDAPAPI ULONG LDAPAPI ldap_add_extW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
LDAPModW *attrs[], LDAPModW *attrs[],
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_add_extA( WINLDAPAPI ULONG LDAPAPI ldap_add_extA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
LDAPModA *attrs[], LDAPModA *attrs[],
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_add_ext_sW( WINLDAPAPI ULONG LDAPAPI ldap_add_ext_sW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
LDAPModW *attrs[], LDAPModW *attrs[],
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls PLDAPControlW *ClientControls
); );
WINLDAPAPI ULONG LDAPAPI ldap_add_ext_sA( WINLDAPAPI ULONG LDAPAPI ldap_add_ext_sA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
LDAPModA *attrs[], LDAPModA *attrs[],
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls PLDAPControlA *ClientControls
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_add ldap_addW #define ldap_add ldap_addW
#define ldap_add_s ldap_add_sW #define ldap_add_s ldap_add_sW
#define ldap_add_ext ldap_add_extW #define ldap_add_ext ldap_add_extW
#define ldap_add_ext_s ldap_add_ext_sW #define ldap_add_ext_s ldap_add_ext_sW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_add( LDAP *ld, PCHAR dn, LDAPMod *attrs[] ); WINLDAPAPI ULONG LDAPAPI ldap_add( LDAP *ld, __in PCHAR dn, LDAPMod *attrs[] );
WINLDAPAPI ULONG LDAPAPI ldap_add_s( LDAP *ld, PCHAR dn, LDAPMod *attrs[] ); WINLDAPAPI ULONG LDAPAPI ldap_add_s( LDAP *ld, __in PCHAR dn, LDAPMod *attrs[] )
;
WINLDAPAPI ULONG LDAPAPI ldap_add_ext( WINLDAPAPI ULONG LDAPAPI ldap_add_ext(
LDAP *ld, LDAP *ld,
const PCHAR dn, const PCHAR dn,
LDAPModA *attrs[], LDAPModA *attrs[],
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
skipping to change at line 1572 skipping to change at line 1583
// multi-thread: ldap_compare calls are not safe in that the message number // multi-thread: ldap_compare calls are not safe in that the message number
// is returned rather than the return code. You have to look // is returned rather than the return code. You have to look
// at the connection block in an error case and the return code // at the connection block in an error case and the return code
// may be overwritten by another thread inbetween. // may be overwritten by another thread inbetween.
// //
// Use ldap_compare_ext instead, as these are thread safe. // Use ldap_compare_ext instead, as these are thread safe.
// //
// ldap_compare_s and ldap_compare_ext* calls are thread safe. // ldap_compare_s and ldap_compare_ext* calls are thread safe.
// //
WINLDAPAPI ULONG LDAPAPI ldap_compareW( LDAP *ld, const PWCHAR dn, const PWCHAR attr, PWCHAR value ); WINLDAPAPI ULONG LDAPAPI ldap_compareW( LDAP *ld, __in const PWCHAR dn, __in con st PWCHAR attr, __in PWCHAR value );
WINLDAPAPI ULONG LDAPAPI ldap_compareA( LDAP *ld, const PCHAR dn, const PCHAR at tr, PCHAR value ); WINLDAPAPI ULONG LDAPAPI ldap_compareA( LDAP *ld, const PCHAR dn, const PCHAR at tr, PCHAR value );
WINLDAPAPI ULONG LDAPAPI ldap_compare_sW( LDAP *ld, const PWCHAR dn, const PWCHA R attr, PWCHAR value ); WINLDAPAPI ULONG LDAPAPI ldap_compare_sW( LDAP *ld, __in const PWCHAR dn, __in c onst PWCHAR attr, __in PWCHAR value );
WINLDAPAPI ULONG LDAPAPI ldap_compare_sA( LDAP *ld, const PCHAR dn, const PCHAR attr, PCHAR value ); WINLDAPAPI ULONG LDAPAPI ldap_compare_sA( LDAP *ld, const PCHAR dn, const PCHAR attr, PCHAR value );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_compare ldap_compareW #define ldap_compare ldap_compareW
#define ldap_compare_s ldap_compare_sW #define ldap_compare_s ldap_compare_sW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_compare( LDAP *ld, const PCHAR dn, const PCHAR att WINLDAPAPI ULONG LDAPAPI ldap_compare( LDAP *ld, __in const PCHAR dn, __in const
r, PCHAR value ); PCHAR attr, __in PCHAR value );
WINLDAPAPI ULONG LDAPAPI ldap_compare_s( LDAP *ld, const PCHAR dn, const PCHAR a WINLDAPAPI ULONG LDAPAPI ldap_compare_s( LDAP *ld, __in const PCHAR dn, __in con
ttr, PCHAR value ); st PCHAR attr, __in PCHAR value );
#endif #endif
// //
// Extended Compare operations. These take controls and are thread safe. // Extended Compare operations. These take controls and are thread safe.
// They also allow you to specify a bval structure for the data, so that it // They also allow you to specify a bval structure for the data, so that it
// isn't translated from Unicode or ANSI to UTF8. Allows for comparison of // isn't translated from Unicode or ANSI to UTF8. Allows for comparison of
// raw binary data. // raw binary data.
// //
// Specify either Data or Value as not NULL. If both are not NULL, the // Specify either Data or Value as not NULL. If both are not NULL, the
// berval Data will be used. // berval Data will be used.
// //
WINLDAPAPI ULONG LDAPAPI ldap_compare_extW( WINLDAPAPI ULONG LDAPAPI ldap_compare_extW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
const PWCHAR Attr, __in const PWCHAR Attr,
const PWCHAR Value, // either value or Data is not null, not b __in_opt const PWCHAR Value, // either value or Data is not nu
oth ll, not both
struct berval *Data, __in_opt struct berval *Data,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_compare_extA( WINLDAPAPI ULONG LDAPAPI ldap_compare_extA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
const PCHAR Attr, __in const PCHAR Attr,
const PCHAR Value, // either value or Data is not null, not b __in_opt const PCHAR Value, // either value or Data is not nu
oth ll, not both
struct berval *Data, __in_opt struct berval *Data,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_compare_ext_sW( WINLDAPAPI ULONG LDAPAPI ldap_compare_ext_sW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
const PWCHAR Attr, __in const PWCHAR Attr,
const PWCHAR Value, // either value or Data is not null, not b __in_opt const PWCHAR Value, // either value or Data is not nu
oth ll, not both
struct berval *Data, __in_opt struct berval *Data,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls PLDAPControlW *ClientControls
); );
WINLDAPAPI ULONG LDAPAPI ldap_compare_ext_sA( WINLDAPAPI ULONG LDAPAPI ldap_compare_ext_sA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
const PCHAR Attr, __in const PCHAR Attr,
const PCHAR Value, // either value or Data is not null, not b __in_opt const PCHAR Value, // either value or Data is not nu
oth ll, not both
struct berval *Data, __in_opt struct berval *Data,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls PLDAPControlA *ClientControls
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_compare_ext ldap_compare_extW #define ldap_compare_ext ldap_compare_extW
#define ldap_compare_ext_s ldap_compare_ext_sW #define ldap_compare_ext_s ldap_compare_ext_sW
#else #else
skipping to change at line 1686 skipping to change at line 1697
// multi-thread: ldap_delete calls are not safe in that the message number // multi-thread: ldap_delete calls are not safe in that the message number
// is returned rather than the return code. You have to look // is returned rather than the return code. You have to look
// at the connection block in an error case and the return code // at the connection block in an error case and the return code
// may be overwritten by another thread inbetween. // may be overwritten by another thread inbetween.
// //
// Use ldap_delete_ext instead, as these are thread safe. // Use ldap_delete_ext instead, as these are thread safe.
// //
// ldap_delete_s and ldap_delete_ext* calls are thread safe. // ldap_delete_s and ldap_delete_ext* calls are thread safe.
// //
WINLDAPAPI ULONG LDAPAPI ldap_deleteW( LDAP *ld, const PWCHAR dn ); WINLDAPAPI ULONG LDAPAPI ldap_deleteW( LDAP *ld, __in const PWCHAR dn );
WINLDAPAPI ULONG LDAPAPI ldap_deleteA( LDAP *ld, const PCHAR dn ); WINLDAPAPI ULONG LDAPAPI ldap_deleteA( LDAP *ld, const PCHAR dn );
WINLDAPAPI ULONG LDAPAPI ldap_delete_sW( LDAP *ld, const PWCHAR dn ); WINLDAPAPI ULONG LDAPAPI ldap_delete_sW( LDAP *ld, __in const PWCHAR dn );
WINLDAPAPI ULONG LDAPAPI ldap_delete_sA( LDAP *ld, const PCHAR dn ); WINLDAPAPI ULONG LDAPAPI ldap_delete_sA( LDAP *ld, const PCHAR dn );
WINLDAPAPI ULONG LDAPAPI ldap_delete_extW( WINLDAPAPI ULONG LDAPAPI ldap_delete_extW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_delete_extA( WINLDAPAPI ULONG LDAPAPI ldap_delete_extA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_sW( WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_sW(
LDAP *ld, LDAP *ld,
const PWCHAR dn, __in const PWCHAR dn,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls PLDAPControlW *ClientControls
); );
WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_sA( WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_sA(
LDAP *ld, LDAP *ld,
const PCHAR dn, __in const PCHAR dn,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls PLDAPControlA *ClientControls
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_delete ldap_deleteW #define ldap_delete ldap_deleteW
#define ldap_delete_ext ldap_delete_extW #define ldap_delete_ext ldap_delete_extW
#define ldap_delete_s ldap_delete_sW #define ldap_delete_s ldap_delete_sW
#define ldap_delete_ext_s ldap_delete_ext_sW #define ldap_delete_ext_s ldap_delete_ext_sW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_delete( LDAP *ld, PCHAR dn ); WINLDAPAPI ULONG LDAPAPI ldap_delete( LDAP *ld, __in PCHAR dn );
WINLDAPAPI ULONG LDAPAPI ldap_delete_s( LDAP *ld, PCHAR dn ); WINLDAPAPI ULONG LDAPAPI ldap_delete_s( LDAP *ld, __in PCHAR dn );
WINLDAPAPI ULONG LDAPAPI ldap_delete_ext( WINLDAPAPI ULONG LDAPAPI ldap_delete_ext(
LDAP *ld, LDAP *ld,
const PCHAR dn, const PCHAR dn,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_s( WINLDAPAPI ULONG LDAPAPI ldap_delete_ext_s(
skipping to change at line 1817 skipping to change at line 1828
// returns the appropriate fields. Use this one if you want to get at the // returns the appropriate fields. Use this one if you want to get at the
// referrals, matchingDNs, or server controls returned. // referrals, matchingDNs, or server controls returned.
// //
// multi-thread: ldap_parse_result call is thread safe // multi-thread: ldap_parse_result call is thread safe
WINLDAPAPI ULONG LDAPAPI ldap_parse_resultW ( WINLDAPAPI ULONG LDAPAPI ldap_parse_resultW (
LDAP *Connection, LDAP *Connection,
LDAPMessage *ResultMessage, LDAPMessage *ResultMessage,
ULONG *ReturnCode OPTIONAL, // returned by server ULONG *ReturnCode OPTIONAL, // returned by server
PWCHAR *MatchedDNs OPTIONAL, // free with ldap_memfree __deref_opt_out_opt PWCHAR *MatchedDNs OPTIONAL, // free with ld
PWCHAR *ErrorMessage OPTIONAL, // free with ldap_memfree ap_memfree
PWCHAR **Referrals OPTIONAL, // free with ldap_value_freeW __deref_opt_out_opt PWCHAR *ErrorMessage OPTIONAL, // free with ld
ap_memfree
__deref_opt_out_opt PWCHAR **Referrals OPTIONAL, // free with ld
ap_value_freeW
PLDAPControlW **ServerControls OPTIONAL, // free with ldap_free_contr olsW PLDAPControlW **ServerControls OPTIONAL, // free with ldap_free_contr olsW
BOOLEAN Freeit BOOLEAN Freeit
); );
WINLDAPAPI ULONG LDAPAPI ldap_parse_resultA ( WINLDAPAPI ULONG LDAPAPI ldap_parse_resultA (
LDAP *Connection, LDAP *Connection,
LDAPMessage *ResultMessage, LDAPMessage *ResultMessage,
ULONG *ReturnCode OPTIONAL, // returned by server ULONG *ReturnCode OPTIONAL, // returned by server
PCHAR *MatchedDNs OPTIONAL, // free with ldap_memfree __deref_opt_out_opt PCHAR *MatchedDNs OPTIONAL, // free with lda
PCHAR *ErrorMessage OPTIONAL, // free with ldap_memfree p_memfree
PCHAR **Referrals OPTIONAL, // free with ldap_value_freeA __deref_opt_out_opt PCHAR *ErrorMessage OPTIONAL, // free with lda
p_memfree
__deref_opt_out_opt PCHAR **Referrals OPTIONAL, // free with lda
p_value_freeA
PLDAPControlA **ServerControls OPTIONAL, // free with ldap_free_contr olsA PLDAPControlA **ServerControls OPTIONAL, // free with ldap_free_contr olsA
BOOLEAN Freeit BOOLEAN Freeit
); );
WINLDAPAPI ULONG LDAPAPI ldap_parse_extended_resultA ( WINLDAPAPI ULONG LDAPAPI ldap_parse_extended_resultA (
LDAP *Connection, LDAP *Connection,
LDAPMessage *ResultMessage, // returned by server LDAPMessage *ResultMessage, // returned by server
PCHAR *ResultOID, // free with ldap_memfree __deref_opt_out_opt PCHAR *ResultOID, // free with lda p_memfree
struct berval **ResultData, // free with ldap_memfree struct berval **ResultData, // free with ldap_memfree
BOOLEAN Freeit // Don't need the message anymore BOOLEAN Freeit // Don't need the message anymore
); );
WINLDAPAPI ULONG LDAPAPI ldap_parse_extended_resultW ( WINLDAPAPI ULONG LDAPAPI ldap_parse_extended_resultW (
LDAP *Connection, LDAP *Connection,
LDAPMessage *ResultMessage, // returned by server LDAPMessage *ResultMessage, // returned by server
PWCHAR *ResultOID, // free with ldap_memfree __deref_opt_out_opt PWCHAR *ResultOID, // free with lda p_memfree
struct berval **ResultData, // free with ldap_memfree struct berval **ResultData, // free with ldap_memfree
BOOLEAN Freeit // Don't need the message anymore BOOLEAN Freeit // Don't need the message anymore
); );
WINLDAPAPI ULONG LDAPAPI ldap_controls_freeA ( WINLDAPAPI ULONG LDAPAPI ldap_controls_freeA (
LDAPControlA **Controls LDAPControlA **Controls
); );
WINLDAPAPI ULONG LDAPAPI ldap_control_freeA ( WINLDAPAPI ULONG LDAPAPI ldap_control_freeA (
LDAPControlA *Controls LDAPControlA *Controls
skipping to change at line 1938 skipping to change at line 1949
#else #else
WINLDAPAPI PCHAR LDAPAPI ldap_err2string( ULONG err ); WINLDAPAPI PCHAR LDAPAPI ldap_err2string( ULONG err );
#endif #endif
// //
// ldap_perror does nothing and is here just for compatibility. // ldap_perror does nothing and is here just for compatibility.
// //
WINLDAPAPI void LDAPAPI ldap_perror( LDAP *ld, const PCHAR msg ); WINLDAPAPI void LDAPAPI ldap_perror( LDAP *ld, __in const PCHAR msg );
// //
// Return the first entry of a message. It is freed when the message is // Return the first entry of a message. It is freed when the message is
// freed so should not be freed explicitly. // freed so should not be freed explicitly.
// //
WINLDAPAPI LDAPMessage *LDAPAPI ldap_first_entry( LDAP *ld, LDAPMessage *res ); WINLDAPAPI LDAPMessage *LDAPAPI ldap_first_entry( LDAP *ld, LDAPMessage *res );
// //
// Return the next entry of a message. It is freed when the message is // Return the next entry of a message. It is freed when the message is
skipping to change at line 2048 skipping to change at line 2059
// If the values are generic octet strings and not null terminated strings, // If the values are generic octet strings and not null terminated strings,
// use ldap_get_values_len instead. // use ldap_get_values_len instead.
// //
// The returned value should be freed when your done with it by calling // The returned value should be freed when your done with it by calling
// ldap_value_free. // ldap_value_free.
// //
WINLDAPAPI PWCHAR *LDAPAPI ldap_get_valuesW( WINLDAPAPI PWCHAR *LDAPAPI ldap_get_valuesW(
LDAP *ld, LDAP *ld,
LDAPMessage *entry, LDAPMessage *entry,
const PWCHAR attr __in const PWCHAR attr
); );
WINLDAPAPI PCHAR *LDAPAPI ldap_get_valuesA( WINLDAPAPI PCHAR *LDAPAPI ldap_get_valuesA(
LDAP *ld, LDAP *ld,
LDAPMessage *entry, LDAPMessage *entry,
const PCHAR attr __in const PCHAR attr
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_get_values ldap_get_valuesW #define ldap_get_values ldap_get_valuesW
#else #else
WINLDAPAPI PCHAR *LDAPAPI ldap_get_values( WINLDAPAPI PCHAR *LDAPAPI ldap_get_values(
LDAP *ld, LDAP *ld,
LDAPMessage *entry, LDAPMessage *entry,
const PCHAR attr __in const PCHAR attr
); );
#endif #endif
// //
// Get a given attribute's list of values. This is used during parsing of // Get a given attribute's list of values. This is used during parsing of
// a search response. It returns a list of berval structures to values, // a search response. It returns a list of berval structures to values,
// the list is null terminated. // the list is null terminated.
// //
// If the values are null terminated strings, it may be easier to process them // If the values are null terminated strings, it may be easier to process them
// by calling ldap_get_values instead. // by calling ldap_get_values instead.
// //
// The returned value should be freed when your done with it by calling // The returned value should be freed when your done with it by calling
// ldap_value_free_len. // ldap_value_free_len.
// //
WINLDAPAPI struct berval **LDAPAPI ldap_get_values_lenW ( WINLDAPAPI struct berval **LDAPAPI ldap_get_values_lenW (
LDAP *ExternalHandle, LDAP *ExternalHandle,
LDAPMessage *Message, LDAPMessage *Message,
const PWCHAR attr __in const PWCHAR attr
); );
WINLDAPAPI struct berval **LDAPAPI ldap_get_values_lenA ( WINLDAPAPI struct berval **LDAPAPI ldap_get_values_lenA (
LDAP *ExternalHandle, LDAP *ExternalHandle,
LDAPMessage *Message, LDAPMessage *Message,
const PCHAR attr __in const PCHAR attr
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_get_values_len ldap_get_values_lenW #define ldap_get_values_len ldap_get_values_lenW
#else #else
WINLDAPAPI struct berval **LDAPAPI ldap_get_values_len ( WINLDAPAPI struct berval **LDAPAPI ldap_get_values_len (
LDAP *ExternalHandle, LDAP *ExternalHandle,
LDAPMessage *Message, LDAPMessage *Message,
const PCHAR attr __in const PCHAR attr
); );
#endif #endif
// //
// Return the number of values in a list returned by ldap_get_values. // Return the number of values in a list returned by ldap_get_values.
// //
WINLDAPAPI ULONG LDAPAPI ldap_count_valuesW( PWCHAR *vals ); WINLDAPAPI ULONG LDAPAPI ldap_count_valuesW( __in_opt PWCHAR *vals );
WINLDAPAPI ULONG LDAPAPI ldap_count_valuesA( PCHAR *vals ); WINLDAPAPI ULONG LDAPAPI ldap_count_valuesA( PCHAR *vals );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_count_values ldap_count_valuesW #define ldap_count_values ldap_count_valuesW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_count_values( PCHAR *vals ); WINLDAPAPI ULONG LDAPAPI ldap_count_values( __in_opt PCHAR *vals );
#endif #endif
// //
// Return the number of values in a list returned by ldap_get_values_len. // Return the number of values in a list returned by ldap_get_values_len.
// //
WINLDAPAPI ULONG LDAPAPI ldap_count_values_len( struct berval **vals ); WINLDAPAPI ULONG LDAPAPI ldap_count_values_len( struct berval **vals );
// //
// Free structures returned by ldap_get_values. // Free structures returned by ldap_get_values.
// //
WINLDAPAPI ULONG LDAPAPI ldap_value_freeW( PWCHAR *vals ); WINLDAPAPI ULONG LDAPAPI ldap_value_freeW( __in_opt PWCHAR *vals );
WINLDAPAPI ULONG LDAPAPI ldap_value_freeA( PCHAR *vals ); WINLDAPAPI ULONG LDAPAPI ldap_value_freeA( PCHAR *vals );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_value_free ldap_value_freeW #define ldap_value_free ldap_value_freeW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_value_free( PCHAR *vals ); WINLDAPAPI ULONG LDAPAPI ldap_value_free( __in_opt PCHAR *vals );
#endif #endif
// //
// Free structures returned by ldap_get_values_len. // Free structures returned by ldap_get_values_len.
// //
WINLDAPAPI ULONG LDAPAPI ldap_value_free_len( struct berval **vals ); WINLDAPAPI ULONG LDAPAPI ldap_value_free_len( struct berval **vals );
// //
skipping to change at line 2175 skipping to change at line 2186
WINLDAPAPI PCHAR LDAPAPI ldap_get_dn( LDAP *ld, LDAPMessage *entry ); WINLDAPAPI PCHAR LDAPAPI ldap_get_dn( LDAP *ld, LDAPMessage *entry );
#endif #endif
// //
// When using ldap_explode_dn, you should free the returned string by // When using ldap_explode_dn, you should free the returned string by
// calling ldap_value_free. // calling ldap_value_free.
// //
WINLDAPAPI PWCHAR *LDAPAPI ldap_explode_dnW( const PWCHAR dn, ULONG notypes ); WINLDAPAPI PWCHAR *LDAPAPI ldap_explode_dnW( __in const PWCHAR dn, ULONG notypes );
WINLDAPAPI PCHAR *LDAPAPI ldap_explode_dnA( const PCHAR dn, ULONG notypes ); WINLDAPAPI PCHAR *LDAPAPI ldap_explode_dnA( const PCHAR dn, ULONG notypes );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_explode_dn ldap_explode_dnW #define ldap_explode_dn ldap_explode_dnW
#else #else
WINLDAPAPI PCHAR *LDAPAPI ldap_explode_dn( const PCHAR dn, ULONG notypes ); WINLDAPAPI PCHAR *LDAPAPI ldap_explode_dn( __in const PCHAR dn, ULONG notypes );
#endif #endif
// //
// When calling ldap_dn2ufn, you should free the returned string by calling // When calling ldap_dn2ufn, you should free the returned string by calling
// ldap_memfree. // ldap_memfree.
// //
WINLDAPAPI PWCHAR LDAPAPI ldap_dn2ufnW( const PWCHAR dn ); WINLDAPAPI PWCHAR LDAPAPI ldap_dn2ufnW( __in const PWCHAR dn );
WINLDAPAPI PCHAR LDAPAPI ldap_dn2ufnA( const PCHAR dn ); WINLDAPAPI PCHAR LDAPAPI ldap_dn2ufnA( const PCHAR dn );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_dn2ufn ldap_dn2ufnW #define ldap_dn2ufn ldap_dn2ufnW
#else #else
WINLDAPAPI PCHAR LDAPAPI ldap_dn2ufn( const PCHAR dn ); WINLDAPAPI PCHAR LDAPAPI ldap_dn2ufn( __in const PCHAR dn );
#endif #endif
// //
// This is used to free strings back to the LDAP API heap. Don't pass in // This is used to free strings back to the LDAP API heap. Don't pass in
// values that you've gotten from ldap_open, ldap_get_values, etc. // values that you've gotten from ldap_open, ldap_get_values, etc.
// //
WINLDAPAPI VOID LDAPAPI ldap_memfreeW( PWCHAR Block ); WINLDAPAPI VOID LDAPAPI ldap_memfreeW( __in PWCHAR Block );
WINLDAPAPI VOID LDAPAPI ldap_memfreeA( PCHAR Block ); WINLDAPAPI VOID LDAPAPI ldap_memfreeA( PCHAR Block );
WINLDAPAPI VOID LDAPAPI ber_bvfree( struct berval *bv ); WINLDAPAPI VOID LDAPAPI ber_bvfree( struct berval *bv );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_memfree ldap_memfreeW #define ldap_memfree ldap_memfreeW
#else #else
WINLDAPAPI VOID LDAPAPI ldap_memfree( PCHAR Block ); WINLDAPAPI VOID LDAPAPI ldap_memfree( __in PCHAR Block );
#endif #endif
// //
// The function ldap_ufn2dn attempts to "normalize" a user specified DN // The function ldap_ufn2dn attempts to "normalize" a user specified DN
// to make it "proper". It follows RFC 1781 (add CN= if not present, // to make it "proper". It follows RFC 1781 (add CN= if not present,
// add OU= if none present, etc). If it runs into any problems at all // add OU= if none present, etc). If it runs into any problems at all
// while normalizing, it simply returns a copy of what was passed in. // while normalizing, it simply returns a copy of what was passed in.
// //
// It allocates the output string from the LDAP memory pool. If the pDn // It allocates the output string from the LDAP memory pool. If the pDn
// comes back as non-NULL, you should free it when you're done with a call // comes back as non-NULL, you should free it when you're done with a call
// to ldap_memfree. // to ldap_memfree.
// //
WINLDAPAPI ULONG LDAPAPI ldap_ufn2dnW ( WINLDAPAPI ULONG LDAPAPI ldap_ufn2dnW (
const PWCHAR ufn, __in const PWCHAR ufn,
PWCHAR *pDn __deref_out PWCHAR *pDn
); );
WINLDAPAPI ULONG LDAPAPI ldap_ufn2dnA ( WINLDAPAPI ULONG LDAPAPI ldap_ufn2dnA (
const PCHAR ufn, const PCHAR ufn,
PCHAR *pDn PCHAR *pDn
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_ufn2dn ldap_ufn2dnW #define ldap_ufn2dn ldap_ufn2dnW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_ufn2dn ( WINLDAPAPI ULONG LDAPAPI ldap_ufn2dn (
const PCHAR ufn, __in const PCHAR ufn,
PCHAR *pDn __deref_out PCHAR *pDn
); );
#endif #endif
#define LBER_USE_DER 0x01 #define LBER_USE_DER 0x01
#define LBER_USE_INDEFINITE_LEN 0x02 #define LBER_USE_INDEFINITE_LEN 0x02
#define LBER_TRANSLATE_STRINGS 0x04 #define LBER_TRANSLATE_STRINGS 0x04
// //
// Call to initialize the LDAP library. Pass in a version structure with // Call to initialize the LDAP library. Pass in a version structure with
skipping to change at line 2391 skipping to change at line 2402
// "attributetype=". // "attributetype=".
// //
// this will put out on the wire guid of binary 0x004826BF6CF000123444 // this will put out on the wire guid of binary 0x004826BF6CF000123444
// //
// Note : don't call this for attribute values that are really strings, as // Note : don't call this for attribute values that are really strings, as
// we won't do any conversion from what you passed in to UTF-8. Should only // we won't do any conversion from what you passed in to UTF-8. Should only
// be used for attributes that really are raw binary. // be used for attributes that really are raw binary.
// //
WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_elementW ( WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_elementW (
PCHAR sourceFilterElement, __in_bcount(sourceLength) PCHAR sourceFilterElement,
ULONG sourceLength, ULONG sourceLength,
PWCHAR destFilterElement, __out_bcount_opt(destLength) PWCHAR destFilterElement,
ULONG destLength ULONG destLength
); );
WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_elementA ( WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_elementA (
PCHAR sourceFilterElement, __in_bcount(sourceLength) PCHAR sourceFilterElement,
ULONG sourceLength, ULONG sourceLength,
PCHAR destFilterElement, __out_bcount_opt(destLength) PCHAR destFilterElement,
ULONG destLength ULONG destLength
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_escape_filter_element ldap_escape_filter_elementW #define ldap_escape_filter_element ldap_escape_filter_elementW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_element ( WINLDAPAPI ULONG LDAPAPI ldap_escape_filter_element (
PCHAR sourceFilterElement, __in_bcount(sourceLength) PCHAR sourceFilterElement,
ULONG sourceLength, ULONG sourceLength,
PCHAR destFilterElement, __out_bcount_opt(destLength) PCHAR destFilterElement,
ULONG destLength ULONG destLength
); );
#endif #endif
// //
// Misc extensions for additional debugging. // Misc extensions for additional debugging.
// //
// Note that these do nothing on free builds. // Note that these do nothing on free builds.
// //
WINLDAPAPI ULONG LDAPAPI ldap_set_dbg_flags( ULONG NewFlags ); WINLDAPAPI ULONG LDAPAPI ldap_set_dbg_flags( ULONG NewFlags );
typedef ULONG (_cdecl *DBGPRINT)( PCH Format, ... ); typedef ULONG (_cdecl *DBGPRINT)( PCCH Format, ... );
WINLDAPAPI VOID LDAPAPI ldap_set_dbg_routine( DBGPRINT DebugPrintRoutine ); WINLDAPAPI VOID LDAPAPI ldap_set_dbg_routine( DBGPRINT DebugPrintRoutine );
// //
// These routines are possibly useful by other modules. Note that Win95 // These routines are possibly useful by other modules. Note that Win95
// doesn't by default have the UTF-8 codepage loaded. So a good way to // doesn't by default have the UTF-8 codepage loaded. So a good way to
// convert from UTF-8 to Unicode. // convert from UTF-8 to Unicode.
// //
WINLDAPAPI int LDAPAPI WINLDAPAPI int LDAPAPI
LdapUTF8ToUnicode( LdapUTF8ToUnicode(
LPCSTR lpSrcStr, __in_ecount(cchSrc) LPCSTR lpSrcStr,
int cchSrc, int cchSrc,
LPWSTR lpDestStr, __out_ecount(cchDest) LPWSTR lpDestStr,
int cchDest int cchDest
); );
WINLDAPAPI WINLDAPAPI
int LDAPAPI int LDAPAPI
LdapUnicodeToUTF8( LdapUnicodeToUTF8(
LPCWSTR lpSrcStr, __in_ecount(cchSrc) LPCWSTR lpSrcStr,
int cchSrc, int cchSrc,
LPSTR lpDestStr, __out_ecount(cchDest) LPSTR lpDestStr,
int cchDest int cchDest
); );
// //
// LDAPv3 features : // LDAPv3 features :
// //
// Sort Keys... these are used to ask the server to sort the results // Sort Keys... these are used to ask the server to sort the results
// before sending the results back. LDAPv3 only and optional to implement // before sending the results back. LDAPv3 only and optional to implement
// on the server side. Check supportedControl for an OID of // on the server side. Check supportedControl for an OID of
// "1.2.840.113556.1.4.473" to see if the server supports it. // "1.2.840.113556.1.4.473" to see if the server supports it.
skipping to change at line 2524 skipping to change at line 2535
// //
// This API parses the sort control returned by the server. Use ldap_memfree // This API parses the sort control returned by the server. Use ldap_memfree
// to free the attribute value, if it's returned. // to free the attribute value, if it's returned.
// //
WINLDAPAPI ULONG LDAPAPI ldap_parse_sort_controlA ( WINLDAPAPI ULONG LDAPAPI ldap_parse_sort_controlA (
PLDAP ExternalHandle, PLDAP ExternalHandle,
PLDAPControlA *Control, PLDAPControlA *Control,
ULONG *Result, ULONG *Result,
PCHAR *Attribute __deref_opt_out_opt PCHAR *Attribute
); );
WINLDAPAPI ULONG LDAPAPI ldap_parse_sort_controlW ( WINLDAPAPI ULONG LDAPAPI ldap_parse_sort_controlW (
PLDAP ExternalHandle, PLDAP ExternalHandle,
PLDAPControlW *Control, PLDAPControlW *Control,
ULONG *Result, ULONG *Result,
PWCHAR *Attribute __deref_opt_out_opt PWCHAR *Attribute
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_create_sort_control ldap_create_sort_controlW #define ldap_create_sort_control ldap_create_sort_controlW
#define ldap_parse_sort_control ldap_parse_sort_controlW #define ldap_parse_sort_control ldap_parse_sort_controlW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_create_sort_control ( WINLDAPAPI ULONG LDAPAPI ldap_create_sort_control (
skipping to change at line 2689 skipping to change at line 2700
// //
// If you call ldap_get_next_page_s, you don't need to call // If you call ldap_get_next_page_s, you don't need to call
// ldap_get_paged_count. // ldap_get_paged_count.
// //
#define LDAP_PAGED_RESULT_OID_STRING "1.2.840.113556.1.4.319" #define LDAP_PAGED_RESULT_OID_STRING "1.2.840.113556.1.4.319"
#define LDAP_PAGED_RESULT_OID_STRING_W L"1.2.840.113556.1.4.319" #define LDAP_PAGED_RESULT_OID_STRING_W L"1.2.840.113556.1.4.319"
WINLDAPAPI PLDAPSearch LDAPAPI ldap_search_init_pageW( WINLDAPAPI PLDAPSearch LDAPAPI ldap_search_init_pageW(
PLDAP ExternalHandle, PLDAP ExternalHandle,
const PWCHAR DistinguishedName, __in const PWCHAR DistinguishedName,
ULONG ScopeOfSearch, ULONG ScopeOfSearch,
const PWCHAR SearchFilter, __in const PWCHAR SearchFilter,
PWCHAR AttributeList[], __in PWCHAR AttributeList[],
ULONG AttributesOnly, ULONG AttributesOnly,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG PageTimeLimit, ULONG PageTimeLimit,
ULONG TotalSizeLimit, ULONG TotalSizeLimit,
PLDAPSortKeyW *SortKeys PLDAPSortKeyW *SortKeys
); );
WINLDAPAPI PLDAPSearch LDAPAPI ldap_search_init_pageA( WINLDAPAPI PLDAPSearch LDAPAPI ldap_search_init_pageA(
PLDAP ExternalHandle, PLDAP ExternalHandle,
const PCHAR DistinguishedName, __in const PCHAR DistinguishedName,
ULONG ScopeOfSearch, ULONG ScopeOfSearch,
const PCHAR SearchFilter, __in const PCHAR SearchFilter,
PCHAR AttributeList[], __in PCHAR AttributeList[],
ULONG AttributesOnly, ULONG AttributesOnly,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG PageTimeLimit, ULONG PageTimeLimit,
ULONG TotalSizeLimit, ULONG TotalSizeLimit,
PLDAPSortKeyA *SortKeys PLDAPSortKeyA *SortKeys
); );
#if LDAP_UNICODE #if LDAP_UNICODE
skipping to change at line 2960 skipping to change at line 2971
WINLDAPAPI ULONG LDAPAPI ldap_count_references( LDAP *ld, LDAPMessage *res ); WINLDAPAPI ULONG LDAPAPI ldap_count_references( LDAP *ld, LDAPMessage *res );
// //
// We return the list of subordinate referrals in a search response message. // We return the list of subordinate referrals in a search response message.
// //
WINLDAPAPI ULONG LDAPAPI ldap_parse_referenceW ( WINLDAPAPI ULONG LDAPAPI ldap_parse_referenceW (
LDAP *Connection, LDAP *Connection,
LDAPMessage *ResultMessage, LDAPMessage *ResultMessage,
PWCHAR **Referrals // free with ldap_value_freeW __deref_out PWCHAR **Referrals // free with ldap_value _freeW
); );
WINLDAPAPI ULONG LDAPAPI ldap_parse_referenceA ( WINLDAPAPI ULONG LDAPAPI ldap_parse_referenceA (
LDAP *Connection, LDAP *Connection,
LDAPMessage *ResultMessage, LDAPMessage *ResultMessage,
PCHAR **Referrals // free with ldap_value_freeA __deref_out PCHAR **Referrals // free with ldap_value_ freeA
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_parse_reference ldap_parse_referenceW #define ldap_parse_reference ldap_parse_referenceW
#else #else
WINLDAPAPI ULONG LDAPAPI ldap_parse_reference ( WINLDAPAPI ULONG LDAPAPI ldap_parse_reference (
LDAP *Connection, LDAP *Connection,
skipping to change at line 2995 skipping to change at line 3006
// an LDAPv3 (or above) server. The functionality is fairly open... you can // an LDAPv3 (or above) server. The functionality is fairly open... you can
// send any request you'd like. Note that since we don't know if you'll // send any request you'd like. Note that since we don't know if you'll
// be receiving a single or multiple responses, you'll have to explicitly tell // be receiving a single or multiple responses, you'll have to explicitly tell
// us when you're done with the request by calling ldap_close_extended_op. // us when you're done with the request by calling ldap_close_extended_op.
// //
// These are thread safe. // These are thread safe.
// //
WINLDAPAPI ULONG LDAPAPI ldap_extended_operationW( WINLDAPAPI ULONG LDAPAPI ldap_extended_operationW(
LDAP *ld, LDAP *ld,
const PWCHAR Oid, __in const PWCHAR Oid,
struct berval *Data, struct berval *Data,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_extended_operationA( WINLDAPAPI ULONG LDAPAPI ldap_extended_operationA(
LDAP *ld, LDAP *ld,
const PCHAR Oid, __in const PCHAR Oid,
struct berval *Data, struct berval *Data,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
ULONG *MessageNumber ULONG *MessageNumber
); );
WINLDAPAPI ULONG LDAPAPI ldap_extended_operation_sA ( WINLDAPAPI ULONG LDAPAPI ldap_extended_operation_sA (
LDAP *ExternalHandle, LDAP *ExternalHandle,
PCHAR Oid, __in PCHAR Oid,
struct berval *Data, struct berval *Data,
PLDAPControlA *ServerControls, PLDAPControlA *ServerControls,
PLDAPControlA *ClientControls, PLDAPControlA *ClientControls,
PCHAR *ReturnedOid, __deref_out PCHAR *ReturnedOid,
struct berval **ReturnedData struct berval **ReturnedData
); );
WINLDAPAPI ULONG LDAPAPI ldap_extended_operation_sW ( WINLDAPAPI ULONG LDAPAPI ldap_extended_operation_sW (
LDAP *ExternalHandle, LDAP *ExternalHandle,
PWCHAR Oid, __in PWCHAR Oid,
struct berval *Data, struct berval *Data,
PLDAPControlW *ServerControls, PLDAPControlW *ServerControls,
PLDAPControlW *ClientControls, PLDAPControlW *ClientControls,
PWCHAR *ReturnedOid, __deref_out PWCHAR *ReturnedOid,
struct berval **ReturnedData struct berval **ReturnedData
); );
#if LDAP_UNICODE #if LDAP_UNICODE
#define ldap_extended_operation ldap_extended_operationW #define ldap_extended_operation ldap_extended_operationW
#define ldap_extended_operation_s ldap_extended_operation_sW #define ldap_extended_operation_s ldap_extended_operation_sW
#else #else
skipping to change at line 3204 skipping to change at line 3215
// //
// This function is called after the secure connection has been established. The // This function is called after the secure connection has been established. The
// certificate of the server is supplied for examination by the client. If the // certificate of the server is supplied for examination by the client. If the
// client approves it, it returns TRUE else, it returns false and the secure // client approves it, it returns TRUE else, it returns false and the secure
// connection is torn down. // connection is torn down.
// //
typedef BOOLEAN (_cdecl VERIFYSERVERCERT) ( typedef BOOLEAN (_cdecl VERIFYSERVERCERT) (
PLDAP Connection, PLDAP Connection,
PCCERT_CONTEXT pServerCert PCCERT_CONTEXT* pServerCert
); );
// //
// Given an LDAP message, return the connection pointer where the message // Given an LDAP message, return the connection pointer where the message
// came from. It can return NULL if the connection has already been freed. // came from. It can return NULL if the connection has already been freed.
// //
WINLDAPAPI LDAP * LDAPAPI ldap_conn_from_msg ( WINLDAPAPI LDAP * LDAPAPI ldap_conn_from_msg (
LDAP *PrimaryConn, LDAP *PrimaryConn,
LDAPMessage *res LDAPMessage *res
skipping to change at line 3229 skipping to change at line 3240
// the connection pointer back by calling ldap_conn_from_msg? // the connection pointer back by calling ldap_conn_from_msg?
// //
#define LDAP_OPT_REF_DEREF_CONN_PER_MSG 0x94 #define LDAP_OPT_REF_DEREF_CONN_PER_MSG 0x94
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // LDAP_CLIENT_DEFINED #endif // LDAP_CLIENT_DEFINED

 End of changes. 130 change blocks. 
201 lines changed or deleted 224 lines changed or added

This html diff was produced by rfcdiff 1.41.