ldap.h

利用ldapssl封装库开发的ldap浏览工具

LDAP_API(LDAPFiltDesc *) LDAP_CALL ldap_init_getfilter( char *fname );
LDAP_API(LDAPFiltDesc *) LDAP_CALL ldap_init_getfilter_buf( char *buf, 
	long buflen );
LDAP_API(LDAPFiltInfo *) LDAP_CALL ldap_getfirstfilter( LDAPFiltDesc *lfdp,
	char *tagpat, char *value );
LDAP_API(LDAPFiltInfo *) LDAP_CALL ldap_getnextfilter( LDAPFiltDesc *lfdp );
LDAP_API(int) LDAP_CALL ldap_set_filter_additions( LDAPFiltDesc *lfdp, 
	char *prefix, char *suffix );
LDAP_API(int) LDAP_CALL ldap_create_filter( char *buf, unsigned long buflen,
	char *pattern, char *prefix, char *suffix, char *attr,
	char *value, char **valwords );
LDAP_API(void) LDAP_CALL ldap_getfilter_free( LDAPFiltDesc *lfdp );

/*
 * friendly routines
 */
LDAP_API(char *) LDAP_CALL ldap_friendly_name( char *filename, char *name,
	FriendlyMap *map );
LDAP_API(void) LDAP_CALL ldap_free_friendlymap( FriendlyMap *map );

/*
 * ldap url routines
 */
LDAP_API(int) LDAP_CALL ldap_is_ldap_url( char *url );
LDAP_API(int) LDAP_CALL ldap_url_parse( char *url, LDAPURLDesc **ludpp );
LDAP_API(void) LDAP_CALL ldap_free_urldesc( LDAPURLDesc *ludp );
LDAP_API(int) LDAP_CALL ldap_url_search( LDAP *ld, char *url, int attrsonly );
LDAP_API(int) LDAP_CALL ldap_url_search_s( LDAP *ld, char *url, int attrsonly,
	LDAPMessage **res );
LDAP_API(int) LDAP_CALL ldap_url_search_st( LDAP *ld, char *url, int attrsonly,
	struct timeval *timeout, LDAPMessage **res );

/*
 * routines for creating persistent search controls and for handling
 * "entry changed notification" controls (an LDAPv3 extension).
 */
#define LDAP_CHANGETYPE_ADD		1
#define LDAP_CHANGETYPE_DELETE		2
#define LDAP_CHANGETYPE_MODIFY		4
#define LDAP_CHANGETYPE_MODDN		8
#define LDAP_CHANGETYPE_ANY		(1|2|4|8)
LDAP_API(int) LDAP_CALL ldap_create_persistentsearch_control( LDAP *ld, 
    int changetypes, int changesonly, int return_echg_ctls,
    char ctl_iscritical, LDAPControl **ctrlp );
LDAP_API(int) LDAP_CALL ldap_parse_entrychange_control( LDAP *ld,
	LDAPControl **ctrls, int *chgtypep, char **prevdnp,
	int *chgnumpresentp, long *chgnump );


/*
 * routines for creating the Proxied Auth control
 */

LDAP_API(int) LDAP_CALL ldap_create_proxyauth_control( LDAP *ld,
    const char *dn, const char ctl_iscritical, LDAPControl **ctrlp);



typedef struct ldapmemcache  LDAPMemCache;  /* opaque in-memory cache handle */

/*
 * cacheing routines
 */
LDAP_API(int) LDAP_CALL ldap_memcache_init( unsigned long ttl,
	unsigned long size, char **baseDNs, struct ldap_thread_fns *thread_fns, 
	LDAPMemCache **cachep );
LDAP_API(int) LDAP_CALL ldap_memcache_set( LDAP *ld, LDAPMemCache *cache );
LDAP_API(int) LDAP_CALL ldap_memcache_get( LDAP *ld, LDAPMemCache **cachep );
LDAP_API(void) LDAP_CALL ldap_memcache_flush( LDAPMemCache *cache, char *dn,
	int scope );
LDAP_API(void) LDAP_CALL ldap_memcache_destroy( LDAPMemCache *cache );
LDAP_API(void) LDAP_CALL ldap_memcache_update( LDAPMemCache *cache );


/*
 * DNS resolver callbacks.  for now, we only use gethostbyname()
 */
typedef struct LDAPHostEnt {
    char	*ldaphe_name;		/* official name of host */
    char	**ldaphe_aliases;	/* alias list */
    int		ldaphe_addrtype;	/* host address type */
    int		ldaphe_length;		/* length of address */
    char	**ldaphe_addr_list;	/* list of addresses from name server */
} LDAPHostEnt;

typedef LDAPHostEnt * (LDAP_C LDAP_CALLBACK LDAP_DNSFN_GETHOSTBYNAME)(
	const char *name, LDAPHostEnt *result, char *buffer,
	int buflen, int *statusp, void *extradata );
typedef LDAPHostEnt * (LDAP_C LDAP_CALLBACK LDAP_DNSFN_GETHOSTBYADDR)(
	const char *addr, int length, int type, LDAPHostEnt *result,
	char *buffer, int buflen, int *statusp, void *extradata );

struct ldap_dns_fns {
	void				*lddnsfn_extradata;
	int				lddnsfn_bufsize;
	LDAP_DNSFN_GETHOSTBYNAME	*lddnsfn_gethostbyname;
	LDAP_DNSFN_GETHOSTBYADDR	*lddnsfn_gethostbyaddr;
};

#define LDAP_OPT_DNS_FN_PTRS		96	/* Netscape extension */

/************** the functions in this section are experimental ***************/

/*
 * libldap memory allocation callback functions.  These are global and can
 * not be set on a per-LDAP session handle basis.  Install your own
 * functions by making a call like this:
 *    ldap_set_option( NULL, LDAP_OPT_MEMALLOC_FN_PTRS, &memalloc_fns );
 *
 * look in lber.h for the function typedefs themselves.
 */
struct ldap_memalloc_fns {
	LDAP_MALLOC_CALLBACK	*ldapmem_malloc;
	LDAP_CALLOC_CALLBACK	*ldapmem_calloc;
	LDAP_REALLOC_CALLBACK	*ldapmem_realloc;
	LDAP_FREE_CALLBACK	*ldapmem_free;
};
#define LDAP_OPT_MEMALLOC_FN_PTRS	97	/* Netscape extension */

#define LDAP_OPT_RECONNECT		98	/* Netscape extension */

#define LDAP_OPT_EXTRA_THREAD_FN_PTRS  101	/* Netscape extension */

typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_MUTEX_TRYLOCK_CALLBACK)( void * );
typedef void *(LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_ALLOC_CALLBACK)( void );
typedef void (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_FREE_CALLBACK)( void * );
typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_WAIT_CALLBACK)( void * );
typedef int (LDAP_C LDAP_CALLBACK LDAP_TF_SEMA_POST_CALLBACK)( void * );
typedef void *(LDAP_C LDAP_CALLBACK LDAP_TF_THREADID_CALLBACK)(void);

struct ldap_extra_thread_fns {
        LDAP_TF_MUTEX_TRYLOCK_CALLBACK *ltf_mutex_trylock;
        LDAP_TF_SEMA_ALLOC_CALLBACK *ltf_sema_alloc;
        LDAP_TF_SEMA_FREE_CALLBACK *ltf_sema_free;
        LDAP_TF_SEMA_WAIT_CALLBACK *ltf_sema_wait;
        LDAP_TF_SEMA_POST_CALLBACK *ltf_sema_post;
	LDAP_TF_THREADID_CALLBACK *ltf_threadid_fn;
};


/*
 * this option enables completely asynchronous IO.  It works by using 
 * ioctl() on the fd, (or tlook()) 
 */

#define LDAP_OPT_ASYNC_CONNECT          99      /* Netscape extension */

#define LDAP_OPT_ASYNC_RECONNECT_FN_PTR 100     /* Netscape extension */
/* 
 * this function sets the connect status of the ld so that a client 
 * can do dns and connect, and then tell the sdk to ignore the connect phase 
 */ 

LDAP_API(int) LDAP_CALL ldap_set_connected( LDAP *ld, 
					    const int currentstatus );   

/* 
 * callback definition for reconnect request from a referral 
 */ 

typedef int( LDAP_C LDAP_CALLBACK LDAP_ASYNC_RECONNECT)( LBER_SOCKET, 
							 struct sockaddr *, 
							 int ); 

struct ldap_async_connect_fns 
{ 
    LDAP_ASYNC_RECONNECT *lac_reconnect; 
}; 


#define LDAP_OPT_DEBUG_LEVEL		110     /* Netscape extension */

 
/************************ end of experimental section ************************/


/********** the functions, etc. below are unsupported at this time ***********/
#ifdef LDAP_DNS
#define LDAP_OPT_DNS			12
#endif

#define LDAP_OPT_HOST_NAME		48	/* MSFT extension */
#define LDAP_OPT_RETURN_REFERRALS	51	/* MSFT extension */


/*
 * generalized bind
 */
LDAP_API(int) LDAP_CALL ldap_bind( LDAP *ld, const char *who, 
	const char *passwd, int authmethod );
LDAP_API(int) LDAP_CALL ldap_bind_s( LDAP *ld, const char *who, 
	const char *cred, int method );

/*
 * experimental DN format support
 */
LDAP_API(int) LDAP_CALL ldap_is_dns_dn( const char *dn );


/*
 * user friendly naming/searching routines
 */
LDAP_API(int) LDAP_CALL ldap_ufn_search_c( LDAP *ld, char *ufn,
	char **attrs, int attrsonly, LDAPMessage **res,
	LDAP_CANCELPROC_CALLBACK *cancelproc, void *cancelparm );
LDAP_API(int) LDAP_CALL ldap_ufn_search_ct( LDAP *ld, char *ufn,
	char **attrs, int attrsonly, LDAPMessage **res,
	LDAP_CANCELPROC_CALLBACK *cancelproc, void *cancelparm, 
	char *tag1, char *tag2, char *tag3 );
LDAP_API(int) LDAP_CALL ldap_ufn_search_s( LDAP *ld, char *ufn,
	char **attrs, int attrsonly, LDAPMessage **res );
LDAP_API(LDAPFiltDesc *) LDAP_CALL ldap_ufn_setfilter( LDAP *ld, char *fname );
LDAP_API(void) LDAP_CALL ldap_ufn_setprefix( LDAP *ld, char *prefix );
LDAP_API(int) LDAP_C ldap_ufn_timeout( void *tvparam );

/*
 * utility routines
 */
LDAP_API(int) LDAP_CALL ldap_charray_add( char ***a, char *s );
LDAP_API(int) LDAP_CALL ldap_charray_merge( char ***a, char **s );
LDAP_API(void) LDAP_CALL ldap_charray_free( char **array );
LDAP_API(int) LDAP_CALL ldap_charray_inlist( char **a, char *s );
LDAP_API(char **) LDAP_CALL ldap_charray_dup( char **a );
LDAP_API(char **) LDAP_CALL ldap_str2charray( char *str, char *brkstr );
LDAP_API(int) LDAP_CALL ldap_charray_position( char **a, char *s );

/*
 * UTF-8 routines (should these move into libnls?)
 */
/* number of bytes in character */
LDAP_API(int) LDAP_CALL ldap_utf8len( const char* );
/* find next character */
LDAP_API(char*) LDAP_CALL ldap_utf8next( char* );
/* find previous character */
LDAP_API(char*) LDAP_CALL ldap_utf8prev( char* );
/* copy one character */
LDAP_API(int) LDAP_CALL ldap_utf8copy( char* dst, const char* src );
/* total number of characters */
LDAP_API(size_t) LDAP_CALL ldap_utf8characters( const char* );
/* get one UCS-4 character, and move *src to the next character */
LDAP_API(unsigned long) LDAP_CALL ldap_utf8getcc( const char** src );
/* UTF-8 aware strtok_r() */
LDAP_API(char*) LDAP_CALL ldap_utf8strtok_r( char* src, const char* brk, char** next);

/* like isalnum(*s) in the C locale */
LDAP_API(int) LDAP_CALL ldap_utf8isalnum( char* s );
/* like isalpha(*s) in the C locale */
LDAP_API(int) LDAP_CALL ldap_utf8isalpha( char* s );
/* like isdigit(*s) in the C locale */
LDAP_API(int) LDAP_CALL ldap_utf8isdigit( char* s );
/* like isxdigit(*s) in the C locale */
LDAP_API(int) LDAP_CALL ldap_utf8isxdigit(char* s );
/* like isspace(*s) in the C locale */
LDAP_API(int) LDAP_CALL ldap_utf8isspace( char* s );

#define LDAP_UTF8LEN(s)  ((0x80 & *(unsigned char*)(s)) ?   ldap_utf8len (s) : 1)
#define LDAP_UTF8NEXT(s) ((0x80 & *(unsigned char*)(s)) ?   ldap_utf8next(s) : (s)+1)
#define LDAP_UTF8INC(s)  ((0x80 & *(unsigned char*)(s)) ? s=ldap_utf8next(s) : ++s)

#define LDAP_UTF8PREV(s)   ldap_utf8prev(s)
#define LDAP_UTF8DEC(s) (s=ldap_utf8prev(s))

#define LDAP_UTF8COPY(d,s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8copy(d,s) : ((*(d) = *(s)), 1))
#define LDAP_UTF8GETCC(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8getcc (&s) : *s++)
#define LDAP_UTF8GETC(s) ((0x80 & *(unsigned char*)(s)) ? ldap_utf8getcc ((const char**)&s) : *s++)

/*
 * functions that have been replaced by new improved ones
 */
/* use ldap_create_filter() instead of ldap_build_filter() */
LDAP_API(void) LDAP_CALL ldap_build_filter( char *buf, unsigned long buflen,
	char *pattern, char *prefix, char *suffix, char *attr,
	char *value, char **valwords );
/* use ldap_set_filter_additions() instead of ldap_setfilteraffixes() */
LDAP_API(void) LDAP_CALL ldap_setfilteraffixes( LDAPFiltDesc *lfdp, 
	char *prefix, char *suffix );

/* cache strategies */
#define LDAP_CACHE_CHECK                0
#define LDAP_CACHE_POPULATE             1
#define LDAP_CACHE_LOCALDB              2

typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_BIND_CALLBACK)( LDAP *, int,
	unsigned long, const char *, struct berval *, int );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_UNBIND_CALLBACK)( LDAP *, int,
	unsigned long );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_SEARCH_CALLBACK)( LDAP *,
	int, unsigned long, const char *, int, const char LDAP_CALLBACK *,
	char **, int );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_COMPARE_CALLBACK)( LDAP *, int,
	unsigned long, const char *, const char *, struct berval * );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_ADD_CALLBACK)( LDAP *, int,
	unsigned long, const char *, LDAPMod ** );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_DELETE_CALLBACK)( LDAP *, int,
	unsigned long, const char * );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_MODIFY_CALLBACK)( LDAP *, int,
	unsigned long, const char *, LDAPMod ** );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_MODRDN_CALLBACK)( LDAP *, int,
	unsigned long, const char *, const char *, int );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_RESULT_CALLBACK)( LDAP *, int,
	int, struct timeval *, LDAPMessage ** );
typedef int (LDAP_C LDAP_CALLBACK LDAP_CF_FLUSH_CALLBACK)( LDAP *,
	const char *, const char * );

struct ldap_cache_fns {
	void    *lcf_private;
	LDAP_CF_BIND_CALLBACK *lcf_bind;
	LDAP_CF_UNBIND_CALLBACK *lcf_unbind;
	LDAP_CF_SEARCH_CALLBACK *lcf_search;
	LDAP_CF_COMPARE_CALLBACK *lcf_compare;
	LDAP_CF_ADD_CALLBACK *lcf_add;
	LDAP_CF_DELETE_CALLBACK *lcf_delete;
	LDAP_CF_MODIFY_CALLBACK *lcf_modify;
	LDAP_CF_MODRDN_CALLBACK *lcf_modrdn;
	LDAP_CF_RESULT_CALLBACK *lcf_result;
	LDAP_CF_FLUSH_CALLBACK *lcf_flush;
};

LDAP_API(int) LDAP_CALL ldap_cache_flush( LDAP *ld, const char *dn,
	const char *filter );

/*********************** end of unsupported functions ************************/

#ifdef __cplusplus
}
#endif
#endif /* _LDAP_H */