LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
-NT_DYN_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
+NT_DYN_DEFS = -DLBER_DECL=dllimport -DLDAP_DECL=dllimport
CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_DEFS)
XLIBS = -llutil -lldif -lldap -llber
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
-NT_DYN_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
+NT_DYN_DEFS = -DLBER_DECL=dllimport -DLDAP_DECL=dllimport
CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_DEFS)
XLIBS = -llutil -lldif -lldap -llber
# define sys_errlist ((char **)0)
#elif DECL_SYS_ERRLIST
/* have sys_errlist but need declaration */
- LIBC_F (int) sys_nerr;
- LIBC_F (char) *sys_errlist[];
+ LDAP_LIBC_F (int) sys_nerr;
+ LDAP_LIBC_F (char) *sys_errlist[];
#endif
#ifdef HAVE_STRERROR
# include <libutil.h>
#else
/* use lutil version */
- LIBLUTIL_F (void) (setproctitle) LDAP_P((const char *fmt, ...)) \
+ LDAP_LUTIL_F (void) (setproctitle) LDAP_P((const char *fmt, ...)) \
LDAP_GCCATTR((format(printf, 1, 2)));
- LIBLUTIL_F (int) Argc;
- LIBLUTIL_F (char) **Argv;
+ LDAP_LUTIL_F (int) Argc;
+ LDAP_LUTIL_F (char) **Argv;
#endif
#endif /* LDAP_PROCTITLE */
#if !defined( HAVE_INET_ATON ) && !defined( inet_aton )
#define inet_aton ldap_pvt_inet_aton
struct in_addr;
-LIBLDAP_F (int) ldap_pvt_inet_aton LDAP_P(( const char *, struct in_addr * ));
+LDAP_F (int) ldap_pvt_inet_aton LDAP_P(( const char *, struct in_addr * ));
#endif
#if defined(__WIN32) && defined(_ALPHA)
#endif
/* use ldap_pvt_strtok instead of strtok or strtok_r! */
-LIBLDAP_F(char *) ldap_pvt_strtok LDAP_P(( char *str, const char *delim,
+LDAP_F(char *) ldap_pvt_strtok LDAP_P(( char *str, const char *delim,
char **pos ));
#ifndef HAVE_STRDUP
# define strdup(s) ber_strdup(s)
#else
/* some systems fail to declare strdup */
- LIBC_F(char *) (strdup)();
+ LDAP_LIBC_F(char *) (strdup)();
#endif
/*
/* note: callers of crypt(3) should include <ac/crypt.h> */
#if defined(HAVE_GETPASSPHRASE)
-LIBC_F(char*)(getpassphrase)();
+LDAP_LIBC_F(char*)(getpassphrase)();
#elif defined(HAVE_GETPASS)
#define getpassphrase(p) getpass(p)
-LIBC_F(char*)(getpass)();
+LDAP_LIBC_F(char*)(getpass)();
#else
#define NEED_GETPASSPHRASE 1
#else
/* assume we need to declare these externs */
- LIBC_F (char *) optarg;
- LIBC_F (int) optind, opterr, optopt;
+ LDAP_LIBC_F (char *) optarg;
+ LDAP_LIBC_F (int) optind, opterr, optopt;
#endif
#ifndef HAVE_TEMPNAM
- LIBLUTIL_F(char *)(tempnam) LDAP_P(( const char *tmpdir,
- const char *prefix));
+ LDAP_LUTIL_F(char *)(tempnam) LDAP_P((
+ const char *tmpdir,
+ const char *prefix));
#endif
/* use lutil file locking */
typedef int (*AVL_DUP) LDAP_P((void*, void*));
typedef void (*AVL_FREE) LDAP_P((void*));
-LIBAVL_F( int )
+LDAP_AVL_F( int )
avl_free LDAP_P(( Avlnode *root, AVL_FREE dfree ));
-LIBAVL_F( int )
+LDAP_AVL_F( int )
avl_insert LDAP_P((Avlnode **, void*, AVL_CMP, AVL_DUP));
-LIBAVL_F( void* )
+LDAP_AVL_F( void* )
avl_delete LDAP_P((Avlnode **, void*, AVL_CMP));
-LIBAVL_F( void* )
+LDAP_AVL_F( void* )
avl_find LDAP_P((Avlnode *, const void*, AVL_CMP));
-LIBAVL_F( void* )
+LDAP_AVL_F( void* )
avl_find_lin LDAP_P((Avlnode *, const void*, AVL_CMP));
#ifdef AVL_NONREENTRANT
-LIBAVL_F( void* )
+LDAP_AVL_F( void* )
avl_getfirst LDAP_P((Avlnode *));
-LIBAVL_F( void* )
+LDAP_AVL_F( void* )
avl_getnext LDAP_P((void));
#endif
-LIBAVL_F( int )
+LDAP_AVL_F( int )
avl_dup_error LDAP_P((void*, void*));
-LIBAVL_F( int )
+LDAP_AVL_F( int )
avl_dup_ok LDAP_P((void*, void*));
-LIBAVL_F( int )
+LDAP_AVL_F( int )
avl_apply LDAP_P((Avlnode *, AVL_APPLY, void*, int, int));
-LIBAVL_F( int )
+LDAP_AVL_F( int )
avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int));
/* apply traversal types */
typedef int (*ldap_writeptype) LDAP_P((
void *writeparm, char *p, ber_len_t len ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_init_templates LDAP_P(( char *file, struct ldap_disptmpl **tmpllistp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_init_templates_buf LDAP_P(( char *buf,
ber_len_t buflen,
struct ldap_disptmpl **tmpllistp ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_free_templates LDAP_P(( struct ldap_disptmpl *tmpllist ));
-LIBLDAP_F( struct ldap_disptmpl * )
+LDAP_F( struct ldap_disptmpl * )
ldap_first_disptmpl LDAP_P(( struct ldap_disptmpl *tmpllist ));
-LIBLDAP_F( struct ldap_disptmpl * )
+LDAP_F( struct ldap_disptmpl * )
ldap_next_disptmpl LDAP_P(( struct ldap_disptmpl *tmpllist,
struct ldap_disptmpl *tmpl ));
-LIBLDAP_F( struct ldap_disptmpl * )
+LDAP_F( struct ldap_disptmpl * )
ldap_name2template LDAP_P(( char *name,
struct ldap_disptmpl *tmpllist ));
-LIBLDAP_F( struct ldap_disptmpl * )
+LDAP_F( struct ldap_disptmpl * )
ldap_oc2template LDAP_P(( char **oclist,
struct ldap_disptmpl *tmpllist ));
-LIBLDAP_F( char ** )
+LDAP_F( char ** )
ldap_tmplattrs LDAP_P(( struct ldap_disptmpl *tmpl,
char **includeattrs,
int exclude,
unsigned long syntaxmask ));
-LIBLDAP_F( struct ldap_tmplitem * )
+LDAP_F( struct ldap_tmplitem * )
ldap_first_tmplrow LDAP_P(( struct ldap_disptmpl *tmpl ));
-LIBLDAP_F( struct ldap_tmplitem * )
+LDAP_F( struct ldap_tmplitem * )
ldap_next_tmplrow LDAP_P(( struct ldap_disptmpl *tmpl,
struct ldap_tmplitem *row ));
-LIBLDAP_F( struct ldap_tmplitem * )
+LDAP_F( struct ldap_tmplitem * )
ldap_first_tmplcol LDAP_P(( struct ldap_disptmpl *tmpl,
struct ldap_tmplitem *row ));
-LIBLDAP_F( struct ldap_tmplitem * )
+LDAP_F( struct ldap_tmplitem * )
ldap_next_tmplcol LDAP_P(( struct ldap_disptmpl *tmpl,
struct ldap_tmplitem *row,
struct ldap_tmplitem *col ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_entry2text LDAP_P(( LDAP *ld,
char *buf, LDAPMessage *entry,
struct ldap_disptmpl *tmpl, char **defattrs, char ***defvals,
ldap_writeptype writeproc, void *writeparm, char *eol, int rdncount,
unsigned long opts ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_vals2text LDAP_P(( LDAP *ld,
char *buf, char **vals, char *label, int labelwidth,
unsigned long syntaxid, ldap_writeptype writeproc, void *writeparm,
char *eol, int rdncount ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_entry2text_search LDAP_P(( LDAP *ld,
char *dn, char *base, LDAPMessage *entry,
struct ldap_disptmpl *tmpllist, char **defattrs, char ***defvals,
ldap_writeptype writeproc, void *writeparm, char *eol, int rdncount,
unsigned long opts ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_entry2html LDAP_P(( LDAP *ld,
char *buf, LDAPMessage *entry,
struct ldap_disptmpl *tmpl, char **defattrs, char ***defvals,
ldap_writeptype writeproc, void *writeparm, char *eol, int rdncount,
unsigned long opts, char *urlprefix, char *base ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_vals2html LDAP_P(( LDAP *ld,
char *buf, char **vals, char *label, int labelwidth,
unsigned long syntaxid, ldap_writeptype writeproc, void *writeparm,
char *eol, int rdncount, char *urlprefix ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_entry2html_search LDAP_P(( LDAP
*ld, char *dn, char *base, LDAPMessage *entry,
struct ldap_disptmpl *tmpllist, char **defattrs, char ***defvals,
#define optopt lutil_optopt
#define getopt lutil_getopt
-LIBLUTIL_F (char *) optarg;
-LIBLUTIL_F (int) optind, opterr, optopt;
-
-LIBLUTIL_F (int) getopt LDAP_P(( int, char * const [], const char *));
+LDAP_LUTIL_F (char *) optarg;
+LDAP_LUTIL_F (int) optind, opterr, optopt;
+LDAP_LUTIL_F (int) getopt LDAP_P(( int, char * const [], const char *));
LDAP_END_DECL
/*
* in bprint.c:
*/
-LIBLBER_F( void )
+LBER_F( void )
ber_error_print LDAP_P((
LDAP_CONST char *data ));
-LIBLBER_F( void )
+LBER_F( void )
ber_bprint LDAP_P((
LDAP_CONST char *data, ber_len_t len ));
-LIBLBER_F( void )
+LBER_F( void )
ber_dump LDAP_P((
BerElement *ber, int inout ));
-LIBLBER_F( void )
+LBER_F( void )
ber_sos_dump LDAP_P((
Seqorset *sos ));
void *data,
int mode ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_tag LDAP_P((
BerElement *ber ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_skip_tag LDAP_P((
BerElement *ber,
ber_len_t *len ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_peek_tag LDAP_P((
BerElement *ber,
ber_len_t *len ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_int LDAP_P((
BerElement *ber,
ber_int_t *num ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_enum LDAP_P((
BerElement *ber,
ber_int_t *num ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_stringb LDAP_P((
BerElement *ber,
char *buf,
ber_len_t *len ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_stringa LDAP_P((
BerElement *ber,
char **buf ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_stringal LDAP_P((
BerElement *ber,
struct berval **bv ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_bitstringa LDAP_P((
BerElement *ber,
char **buf,
ber_len_t *len ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_null LDAP_P((
BerElement *ber ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_boolean LDAP_P((
BerElement *ber,
ber_int_t *boolval ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_first_element LDAP_P((
BerElement *ber,
ber_len_t *len,
char **last ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_next_element LDAP_P((
BerElement *ber,
ber_len_t *len,
LDAP_CONST char *last ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_scanf LDAP_P((
BerElement *ber,
LDAP_CONST char *fmt,
BerElement *ber,
void *data ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_enum LDAP_P((
BerElement *ber,
ber_int_t num,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_int LDAP_P((
BerElement *ber,
ber_int_t num,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_ostring LDAP_P((
BerElement *ber,
LDAP_CONST char *str,
ber_len_t len,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_berval LDAP_P((
BerElement *ber,
LDAP_CONST struct berval *bv,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_string LDAP_P((
BerElement *ber,
LDAP_CONST char *str,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_bitstring LDAP_P((
BerElement *ber,
LDAP_CONST char *str,
ber_len_t bitlen,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_null LDAP_P((
BerElement *ber,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_boolean LDAP_P((
BerElement *ber,
ber_int_t boolval,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_start_seq LDAP_P((
BerElement *ber,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_start_set LDAP_P((
BerElement *ber,
ber_tag_t tag ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_seq LDAP_P((
BerElement *ber ));
-LIBLBER_F( int )
+LBER_F( int )
ber_put_set LDAP_P((
BerElement *ber ));
-LIBLBER_F( int )
+LBER_F( int )
ber_printf LDAP_P((
BerElement *ber,
LDAP_CONST char *fmt,
* in io.c:
*/
-LIBLBER_F( ber_slen_t )
+LBER_F( ber_slen_t )
ber_read LDAP_P((
BerElement *ber,
char *buf,
ber_len_t len ));
-LIBLBER_F( ber_slen_t )
+LBER_F( ber_slen_t )
ber_write LDAP_P((
BerElement *ber,
LDAP_CONST char *buf,
ber_len_t len,
int nosos ));
-LIBLBER_F( void )
+LBER_F( void )
ber_free LDAP_P((
BerElement *ber,
int freebuf ));
-LIBLBER_F( int )
+LBER_F( int )
ber_flush LDAP_P((
Sockbuf *sb,
BerElement *ber,
int freeit ));
-LIBLBER_F( BerElement * )
+LBER_F( BerElement * )
ber_alloc LDAP_P(( void )); /* DEPRECATED */
-LIBLBER_F( BerElement * )
+LBER_F( BerElement * )
der_alloc LDAP_P(( void )); /* DEPRECATED */
-LIBLBER_F( BerElement * )
+LBER_F( BerElement * )
ber_alloc_t LDAP_P((
int beroptions ));
-LIBLBER_F( BerElement * )
+LBER_F( BerElement * )
ber_dup LDAP_P((
BerElement *ber ));
-LIBLBER_F( ber_tag_t )
+LBER_F( ber_tag_t )
ber_get_next LDAP_P((
Sockbuf *sb,
ber_len_t *len,
BerElement *ber ));
-LIBLBER_F( void )
+LBER_F( void )
ber_init_w_nullc LDAP_P((
BerElement *ber,
int options ));
-LIBLBER_F( void )
+LBER_F( void )
ber_reset LDAP_P((
BerElement *ber,
int was_writing ));
-LIBLBER_F( BerElement * )
+LBER_F( BerElement * )
ber_init LDAP_P((
struct berval *bv ));
-LIBLBER_F( int )
+LBER_F( int )
ber_flatten LDAP_P((
BerElement *ber,
struct berval **bvPtr ));
* LBER ber accessor functions
*/
-LIBLBER_F( int )
+LBER_F( int )
ber_get_option LDAP_P((
void *item,
int option,
void *outvalue));
-LIBLBER_F( int )
+LBER_F( int )
ber_set_option LDAP_P((
void *item,
int option,
* LBER sockbuf.c
*/
-LIBLBER_F( Sockbuf * )
+LBER_F( Sockbuf * )
ber_sockbuf_alloc LDAP_P((
void ));
-LIBLBER_F( void )
+LBER_F( void )
ber_sockbuf_free LDAP_P((
Sockbuf *sb ));
-LIBLBER_F( int )
+LBER_F( int )
ber_sockbuf_add_io LDAP_P((
Sockbuf *sb,
Sockbuf_IO *sbio,
int layer,
void *arg ));
-LIBLBER_F( int )
+LBER_F( int )
ber_sockbuf_remove_io LDAP_P((
Sockbuf *sb,
Sockbuf_IO *sbio,
int layer ));
-LIBLBER_F( int )
+LBER_F( int )
ber_sockbuf_ctrl LDAP_P((
Sockbuf *sb,
int opt,
void *arg ));
-LIBLBER_F( Sockbuf_IO ) ber_sockbuf_io_tcp;
-LIBLBER_F( Sockbuf_IO ) ber_sockbuf_io_udp;
-LIBLBER_F( Sockbuf_IO ) ber_sockbuf_io_readahead;
-LIBLBER_F( Sockbuf_IO ) ber_sockbuf_io_fd;
-LIBLBER_F( Sockbuf_IO ) ber_sockbuf_io_debug;
+LBER_F( Sockbuf_IO ) ber_sockbuf_io_tcp;
+LBER_F( Sockbuf_IO ) ber_sockbuf_io_udp;
+LBER_F( Sockbuf_IO ) ber_sockbuf_io_readahead;
+LBER_F( Sockbuf_IO ) ber_sockbuf_io_fd;
+LBER_F( Sockbuf_IO ) ber_sockbuf_io_debug;
/*
* LBER memory.c
*/
-LIBLBER_F( void * )
+LBER_F( void * )
ber_memalloc LDAP_P((
ber_len_t s ));
-LIBLBER_F( void * )
+LBER_F( void * )
ber_memrealloc LDAP_P((
void* p,
ber_len_t s ));
-LIBLBER_F( void * )
+LBER_F( void * )
ber_memcalloc LDAP_P((
ber_len_t n,
ber_len_t s ));
-LIBLBER_F( void )
+LBER_F( void )
ber_memfree LDAP_P((
void* p ));
-LIBLBER_F( void )
+LBER_F( void )
ber_memvfree LDAP_P((
void** vector ));
-LIBLBER_F( void )
+LBER_F( void )
ber_bvfree LDAP_P((
struct berval *bv ));
-LIBLBER_F( void )
+LBER_F( void )
ber_bvecfree LDAP_P((
struct berval **bv ));
-LIBLBER_F( int )
+LBER_F( int )
ber_bvecadd LDAP_P((
struct berval ***bvec,
struct berval *bv ));
-LIBLBER_F( struct berval * )
+LBER_F( struct berval * )
ber_bvdup LDAP_P((
LDAP_CONST struct berval *bv ));
-LIBLBER_F( struct berval * )
+LBER_F( struct berval * )
ber_bvstr LDAP_P((
LDAP_CONST char * ));
-LIBLBER_F( struct berval * )
+LBER_F( struct berval * )
ber_bvstrdup LDAP_P((
LDAP_CONST char * ));
-LIBLBER_F( char * )
+LBER_F( char * )
ber_strdup LDAP_P((
LDAP_CONST char * ));
/*
* error.c
*/
-LIBLBER_F( int * ) ber_errno_addr LDAP_P((void));
+LBER_F( int * ) ber_errno_addr LDAP_P((void));
#define ber_errno (*(ber_errno_addr)())
#define LBER_ERROR_NONE 0
/*
* bprint.c
*/
-LIBLBER_F( BER_LOG_PRINT_FN ) ber_pvt_log_print;
+LBER_F( BER_LOG_PRINT_FN ) ber_pvt_log_print;
-LIBLBER_F( int )
+LBER_F( int )
ber_pvt_log_printf LDAP_P((
int errlvl,
int loglvl,
/*
* sockbuf.c
*/
-LIBLBER_F( ber_slen_t )
+LBER_F( ber_slen_t )
ber_pvt_sb_do_write LDAP_P(( Sockbuf_IO_Desc *sbiod, Sockbuf_Buf *buf_out ));
-LIBLBER_F( void )
+LBER_F( void )
ber_pvt_sb_buf_init LDAP_P(( Sockbuf_Buf *buf ));
-LIBLBER_F( void )
+LBER_F( void )
ber_pvt_sb_buf_destroy LDAP_P(( Sockbuf_Buf *buf ));
-LIBLBER_F( int )
+LBER_F( int )
ber_pvt_sb_grow_buffer LDAP_P(( Sockbuf_Buf *buf, ber_len_t minsize ));
-LIBLBER_F( ber_len_t )
+LBER_F( ber_len_t )
ber_pvt_sb_copy_out LDAP_P(( Sockbuf_Buf *sbb, char *buf, ber_len_t len ));
-LIBLBER_F( int )
+LBER_F( int )
ber_pvt_socket_set_nonblock LDAP_P(( ber_socket_t sd, int nb ));
LDAP_END_DECL
/*
* in options.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_get_option LDAP_P((
LDAP *ld,
int option,
void *outvalue));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_set_option LDAP_P((
LDAP *ld,
int option,
typedef int (LDAP_REBIND_PROC) LDAP_P((
LDAP *ld, LDAP_CONST char *url, int request, ber_int_t msgid ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_set_rebind_proc LDAP_P((
LDAP *ld,
LDAP_REBIND_PROC *ldap_proc));
/*
* in controls.c:
*/
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_control_free LDAP_P((
LDAPControl *ctrl ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_controls_free LDAP_P((
LDAPControl **ctrls ));
/*
* in dnssrv.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_domain2dn LDAP_P((
LDAP_CONST char* domain,
char** dn ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_dn2domain LDAP_P((
LDAP_CONST char* dn,
char** domain ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_domain2hostlist LDAP_P((
LDAP_CONST char *domain,
char** hostlist ));
/*
* in extended.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_extended_operation LDAP_P((
LDAP *ld,
LDAP_CONST char *reqoid,
LDAPControl **clientctrls,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_extended_operation_s LDAP_P((
LDAP *ld,
LDAP_CONST char *reqoid,
char **retoidp,
struct berval **retdatap ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_parse_extended_result LDAP_P((
LDAP *ld,
LDAPMessage *res,
/*
* in abandon.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_abandon_ext LDAP_P((
LDAP *ld,
int msgid,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_abandon LDAP_P(( /* deprecated */
LDAP *ld,
int msgid ));
/*
* in add.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_add_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_add_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_add LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAPMod **attrs ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_add_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
/*
* in sasl.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_sasl_bind LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_negotiated_sasl_bind_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn, /* usually NULL */
LDAPControl **serverControls,
LDAPControl **clientControls ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_sasl_bind_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
struct berval **servercredp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_parse_sasl_bind_result LDAP_P((
LDAP *ld,
LDAPMessage *res,
* in bind.c:
* (deprecated)
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_bind LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *who,
LDAP_CONST char *passwd,
int authmethod ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_bind_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *who,
/*
* in sbind.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_simple_bind LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
LDAP_CONST char *passwd ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_simple_bind_s LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
* in kbind.c:
* (deprecated)
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_kerberos_bind_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *who ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_kerberos_bind1 LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *who ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_kerberos_bind1_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *who ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_kerberos_bind2 LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *who ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_kerberos_bind2_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *who ));
* in cache.c
* (deprecated)
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_enable_cache LDAP_P(( LDAP *ld, long timeout, ber_len_t maxmem ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_disable_cache LDAP_P(( LDAP *ld ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_set_cache_options LDAP_P(( LDAP *ld, unsigned long opts ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_destroy_cache LDAP_P(( LDAP *ld ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_flush_cache LDAP_P(( LDAP *ld ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_uncache_entry LDAP_P(( LDAP *ld, LDAP_CONST char *dn ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_uncache_request LDAP_P(( LDAP *ld, int msgid ));
/*
* in compare.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_compare_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_compare_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_compare LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *attr,
LDAP_CONST char *value ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_compare_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
/*
* in delete.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_delete_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_delete_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_delete LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_delete_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn ));
/*
* in error.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_parse_result LDAP_P((
LDAP *ld,
LDAPMessage *res,
LDAPControl ***serverctrls,
int freeit ));
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_err2string LDAP_P((
int err ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_result2error LDAP_P(( /* deprecated */
LDAP *ld,
LDAPMessage *r,
int freeit ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_perror LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *s ));
/*
* in modify.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modify_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modify_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modify LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAPMod **mods ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modify_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
/*
* in modrdn.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_rename LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **cctrls,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_rename_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **sctrls,
LDAPControl **cctrls ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_rename2 LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newSuperior,
int deleteoldrdn ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_rename2_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newSuperior,
int deleteoldrdn ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modrdn LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newrdn ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modrdn_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newrdn ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modrdn2 LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newrdn,
int deleteoldrdn ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_modrdn2_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *dn,
/*
* in open.c:
*/
-LIBLDAP_F( LDAP *)
+LDAP_F( LDAP *)
ldap_init LDAP_P((
LDAP_CONST char *host,
int port ));
-LIBLDAP_F( LDAP *)
+LDAP_F( LDAP *)
ldap_open LDAP_P(( /* deprecated */
LDAP_CONST char *host,
int port ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_create LDAP_P((
LDAP **ldp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_initialize LDAP_P((
LDAP **ldp,
LDAP_CONST char *url ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_start_tls_s LDAP_P((
LDAP *ld,
LDAPControl **serverctrls,
/*
* in messages.c:
*/
-LIBLDAP_F( LDAPMessage *)
+LDAP_F( LDAPMessage *)
ldap_first_message LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LIBLDAP_F( LDAPMessage *)
+LDAP_F( LDAPMessage *)
ldap_next_message LDAP_P((
LDAP *ld,
LDAPMessage *msg ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_count_messages LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
/*
* in references.c:
*/
-LIBLDAP_F( LDAPMessage *)
+LDAP_F( LDAPMessage *)
ldap_first_reference LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LIBLDAP_F( LDAPMessage *)
+LDAP_F( LDAPMessage *)
ldap_next_reference LDAP_P((
LDAP *ld,
LDAPMessage *ref ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_count_references LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_parse_reference LDAP_P((
LDAP *ld,
LDAPMessage *ref,
/*
* in getentry.c:
*/
-LIBLDAP_F( LDAPMessage *)
+LDAP_F( LDAPMessage *)
ldap_first_entry LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LIBLDAP_F( LDAPMessage *)
+LDAP_F( LDAPMessage *)
ldap_next_entry LDAP_P((
LDAP *ld,
LDAPMessage *entry ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_count_entries LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_get_entry_controls LDAP_P((
LDAP *ld,
LDAPMessage *entry,
/*
* in addentry.c
*/
-LIBLDAP_F( LDAPMessage *)
+LDAP_F( LDAPMessage *)
ldap_delete_result_entry LDAP_P((
LDAPMessage **list,
LDAPMessage *e ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_add_result_entry LDAP_P((
LDAPMessage **list,
LDAPMessage *e ));
/*
* in getdn.c
*/
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_get_dn LDAP_P((
LDAP *ld,
LDAPMessage *entry ));
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_dn2ufn LDAP_P((
LDAP_CONST char *dn ));
-LIBLDAP_F( char ** )
+LDAP_F( char ** )
ldap_explode_dn LDAP_P((
LDAP_CONST char *dn,
int notypes ));
-LIBLDAP_F( char ** )
+LDAP_F( char ** )
ldap_explode_rdn LDAP_P((
LDAP_CONST char *rdn,
int notypes ));
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_parent_dn LDAP_P((
LDAP_CONST char *dn ));
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_relative_dn LDAP_P((
LDAP_CONST char *dn ));
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_normalize_dn LDAP_P((
LDAP_CONST char *dn ));
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_dn2dcedn LDAP_P(( LDAP_CONST char *dn )); /* deprecated */
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_dcedn2dn LDAP_P(( LDAP_CONST char *dce )); /* deprecated */
/*
* in getattr.c
*/
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_first_attribute LDAP_P((
LDAP *ld,
LDAPMessage *entry,
BerElement **ber ));
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_next_attribute LDAP_P((
LDAP *ld,
LDAPMessage *entry,
/*
* in getvalues.c
*/
-LIBLDAP_F( char **)
+LDAP_F( char **)
ldap_get_values LDAP_P((
LDAP *ld,
LDAPMessage *entry,
LDAP_CONST char *target ));
-LIBLDAP_F( struct berval **)
+LDAP_F( struct berval **)
ldap_get_values_len LDAP_P((
LDAP *ld,
LDAPMessage *entry,
LDAP_CONST char *target ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_count_values LDAP_P((
char **vals ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_count_values_len LDAP_P((
struct berval **vals ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_value_free LDAP_P((
char **vals ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_value_free_len LDAP_P((
struct berval **vals ));
/*
* in result.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_result LDAP_P((
LDAP *ld,
int msgid,
struct timeval *timeout,
LDAPMessage **result ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_msgtype LDAP_P((
LDAPMessage *lm ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_msgid LDAP_P((
LDAPMessage *lm ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_msgfree LDAP_P((
LDAPMessage *lm ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_msgdelete LDAP_P((
LDAP *ld,
int msgid ));
/*
* in search.c:
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_search_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *base,
int sizelimit,
int *msgidp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_search_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *base,
int sizelimit,
LDAPMessage **res ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_search LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *base,
char **attrs,
int attrsonly ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_search_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *base,
int attrsonly,
LDAPMessage **res ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_search_st LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *base,
* in ufn.c
* (deprecated)
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_ufn_search_c LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *ufn,
int (*cancelproc)( void *cl ),
void *cancelparm ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_ufn_search_ct LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *ufn,
char *tag2,
char *tag3 ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_ufn_search_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *ufn,
int attrsonly,
LDAPMessage **res ));
-LIBLDAP_F( LDAPFiltDesc *)
+LDAP_F( LDAPFiltDesc *)
ldap_ufn_setfilter LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *fname ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_ufn_setprefix LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *prefix ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_ufn_timeout LDAP_P(( /* deprecated */
void *tvparam ));
/*
* in unbind.c
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_unbind LDAP_P(( /* deprecated */
LDAP *ld ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_unbind_s LDAP_P(( /* deprecated */
LDAP *ld ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_unbind_ext LDAP_P((
LDAP *ld,
LDAPControl **serverctrls,
LDAPControl **clientctrls));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_unbind_ext_s LDAP_P((
LDAP *ld,
LDAPControl **serverctrls,
* in getfilter.c
* (deprecated)
*/
-LIBLDAP_F( LDAPFiltDesc *)
+LDAP_F( LDAPFiltDesc *)
ldap_init_getfilter LDAP_P(( /* deprecated */
LDAP_CONST char *fname ));
-LIBLDAP_F( LDAPFiltDesc *)
+LDAP_F( LDAPFiltDesc *)
ldap_init_getfilter_buf LDAP_P(( /* deprecated */
/* LDAP_CONST */ char *buf,
ber_len_t buflen ));
-LIBLDAP_F( LDAPFiltInfo *)
+LDAP_F( LDAPFiltInfo *)
ldap_getfirstfilter LDAP_P(( /* deprecated */
LDAPFiltDesc *lfdp,
/* LDAP_CONST */ char *tagpat,
/* LDAP_CONST */ char *value ));
-LIBLDAP_F( LDAPFiltInfo *)
+LDAP_F( LDAPFiltInfo *)
ldap_getnextfilter LDAP_P(( /* deprecated */
LDAPFiltDesc *lfdp ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_setfilteraffixes LDAP_P(( /* deprecated */
LDAPFiltDesc *lfdp,
LDAP_CONST char *prefix,
LDAP_CONST char *suffix ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_build_filter LDAP_P(( /* deprecated */
char *buf,
ber_len_t buflen,
* in free.c
*/
-LIBLDAP_F( void * )
+LDAP_F( void * )
ldap_memalloc LDAP_P((
ber_len_t s ));
-LIBLDAP_F( void * )
+LDAP_F( void * )
ldap_memrealloc LDAP_P((
void* p,
ber_len_t s ));
-LIBLDAP_F( void * )
+LDAP_F( void * )
ldap_memcalloc LDAP_P((
ber_len_t n,
ber_len_t s ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_memfree LDAP_P((
void* p ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_memvfree LDAP_P((
void** v ));
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_strdup LDAP_P((
LDAP_CONST char * ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_getfilter_free LDAP_P((
LDAPFiltDesc *lfdp ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_mods_free LDAP_P((
LDAPMod **mods,
int freemods ));
* in friendly.c
* (deprecated)
*/
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_friendly_name LDAP_P(( /* deprecated */
LDAP_CONST char *filename,
/* LDAP_CONST */ char *uname,
LDAPFriendlyMap **map ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_free_friendlymap LDAP_P(( /* deprecated */
LDAPFriendlyMap **map ));
* in cldap.c
* (deprecated)
*/
-LIBLDAP_F( LDAP * )
+LDAP_F( LDAP * )
cldap_open LDAP_P(( /* deprecated */
LDAP_CONST char *host,
int port ));
-LIBLDAP_F( void )
+LDAP_F( void )
cldap_close LDAP_P(( /* deprecated */
LDAP *ld ));
-LIBLDAP_F( int )
+LDAP_F( int )
cldap_search_s LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *base,
LDAPMessage **res,
char *logdn ));
-LIBLDAP_F( void )
+LDAP_F( void )
cldap_setretryinfo LDAP_P(( /* deprecated */
LDAP *ld,
int tries,
LDAP_CONST void *left,
LDAP_CONST void *right ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_sort_entries LDAP_P(( LDAP *ld,
LDAPMessage **chain,
LDAP_CONST char *attr,
LDAP_SORT_AD_CMP_PROC *cmp ));
-LIBLDAP_F( int ) /* deprecated */
+LDAP_F( int ) /* deprecated */
ldap_sort_values LDAP_P((
LDAP *ld,
char **vals,
LDAP_SORT_AV_CMP_PROC *cmp ));
-LIBLDAP_F( int ) /* deprecated */
+LDAP_F( int ) /* deprecated */
ldap_sort_strcasecmp LDAP_P((
LDAP_CONST void *a,
LDAP_CONST void *b ));
*
* need _ext varients
*/
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_is_ldap_url LDAP_P((
LDAP_CONST char *url ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_is_ldaps_url LDAP_P((
LDAP_CONST char *url ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_is_ldapi_url LDAP_P((
LDAP_CONST char *url ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_url_parse LDAP_P((
LDAP_CONST char *url,
LDAPURLDesc **ludpp ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_free_urldesc LDAP_P((
LDAPURLDesc *ludp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_url_search LDAP_P((
LDAP *ld,
LDAP_CONST char *url,
int attrsonly ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_url_search_s LDAP_P((
LDAP *ld,
LDAP_CONST char *url,
int attrsonly,
LDAPMessage **res ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_url_search_st LDAP_P((
LDAP *ld,
LDAP_CONST char *url,
int reverseOrder;
} LDAPSortKey;
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_create_sort_keylist LDAP_P((
LDAPSortKey ***sortKeyList,
char *keyString ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_free_sort_keylist LDAP_P((
LDAPSortKey **sortkeylist ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_create_sort_control LDAP_P((
LDAP *ld,
LDAPSortKey **keyList,
int ctl_iscritical,
LDAPControl **ctrlp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_parse_sort_control LDAP_P((
LDAP *ld,
LDAPControl **ctrlp,
void *ldvlv_extradata;
} LDAPVLVInfo;
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_create_vlv_control LDAP_P((
LDAP *ld,
LDAPVLVInfo *ldvlistp,
LDAPControl **ctrlp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_parse_vlv_control LDAP_P((
LDAP *ld,
LDAPControl **ctrls,
# define LDAP_END_DECL /* end declarations */
#endif
-#if !defined(__NO_PROTOTYPES) && ( defined(__NEED_PROTOTYPES) || \
+#if !defined(LDAP_NO_PROTOTYPES) && ( defined(LDAP_NEED_PROTOTYPES) || \
defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus) )
/* ANSI C or C++ */
/* Support for NT dynamic libraries. */
+/* LBER library */
+#if defined(LBER_DECL) && defined(_WIN32)
+# define LBER_F(type) extern __declspec(LBER_DECL) type
+#else
+# define LBER_F(type) type
+#endif
+
+/* LDAP library */
+#if defined(LDAP_DECL) && defined(_WIN32)
+# define LDAP_F(type) extern __declspec(LDAP_DECL) type
+#else
+# define LDAP_F(type) extern type
+#endif
+
/*
* C library. Mingw32 links with the C run-time library by default,
* so the explicit definition of CSTATIC will keep dllimport from
*/
#if (defined(__MINGW32__) && !defined(CSTATIC) || \
defined(_WIN32) && defined(_DLL))
-# define LIBC_F(type) extern __declspec(dllimport) type
+# define LDAP_LIBC_F(type) extern __declspec(dllimport) type
#else
-# define LIBC_F(type) extern type
+# define LDAP_LIBC_F(type) extern type
#endif
/* AVL library */
-#if defined(LIBAVL_DECL) && defined(_WIN32)
-# define LIBAVL_F(type) extern __declspec(LIBAVL_DECL) type
+#if defined(LDAP_AVL_DECL) && defined(_WIN32)
+# define LDAP_AVL_F(type) extern __declspec(LDAP_AVL_DECL) type
#else
-# define LIBAVL_F(type) extern type
+# define LDAP_AVL_F(type) extern type
#endif
-/* LBER library */
-#if defined(LIBLBER_DECL) && defined(_WIN32)
-# define LIBLBER_F(type) extern __declspec(LIBLBER_DECL) type
-#else
-# define LIBLBER_F(type) extern type
-#endif
-
-/* LDAP library */
-#if defined(LIBLDAP_DECL) && defined(_WIN32)
-# define LIBLDAP_F(type) extern __declspec(LIBLDAP_DECL) type
+/* LDBM library */
+#if defined(LDAP_LDBM_DECL) && defined(_WIN32)
+# define LDAP_LDBM_F(type) extern __declspec(LDAP_LDBM_DECL) type
#else
-# define LIBLDAP_F(type) extern type
+# define LDAP_LDBM_F(type) extern type
#endif
-/* LDBM library */
-#if defined(LIBLDBM_DECL) && defined(_WIN32)
-# define LIBLDBM_F(type) extern __declspec(LIBLDBM_DECL) type
+/* LDIF library */
+#if defined(LDAP_LDIF_DECL) && defined(_WIN32)
+# define LDAP_LDIF_F(type) extern __declspec(LDAP_LDIF_DECL) type
#else
-# define LIBLDBM_F(type) extern type
+# define LDAP_LDIF_F(type) extern type
#endif
-/* LDIF library */
-#if defined(LIBLDIF_DECL) && defined(_WIN32)
-# define LIBLDIF_F(type) extern __declspec(LIBLDIF_DECL) type
+/* LUNICODE library */
+#if defined(LDAP_LUNICODE_DECL) && defined(_WIN32)
+# define LDAP_LUNICODE_F(type) extern __declspec(LDAP_LUNICODE_DECL) type
#else
-# define LIBLDIF_F(type) extern type
+# define LDAP_LUNICODE_F(type) extern type
#endif
/* LUTIL library */
-#if defined(LIBLUTIL_DECL) && defined(_WIN32)
-# define LIBLUTIL_F(type) extern __declspec(LIBLUTIL_DECL) type
+#if defined(LDAP_LUTIL_DECL) && defined(_WIN32)
+# define LDAP_LUTIL_F(type) extern __declspec(LDAP_LUTIL_DECL) type
#else
-# define LIBLUTIL_F(type) extern type
+# define LDAP_LUTIL_F(type) extern type
#endif
/* SLAPD (as a module exporting symbols) */
-#if defined(LIBSLAPD_DECL) && defined(_WIN32)
-# define LIBSLAPD_F(type) extern __declspec(LIBSLAPD_DECL) type
+#if defined(LDAP_SLAPD_DECL) && defined(_WIN32)
+# define LDAP_SLAPD_F(type) extern __declspec(LDAP_SLAPD_DECL) type
#else
-# define LIBSLAPD_F(type) extern type
+# define LDAP_SLAPD_F(type) extern type
#endif
#endif /* _LDAP_CDEFS_H */
LDAP_BEGIN_DECL
-LIBLDAP_F(int) ldap_int_thread_initialize LDAP_P(( void ));
-LIBLDAP_F(int) ldap_int_thread_destroy LDAP_P(( void ));
-LIBLDAP_F(int) ldap_int_thread_pool_startup ( void );
-LIBLDAP_F(int) ldap_int_thread_pool_shutdown ( void );
+LDAP_F(int) ldap_int_thread_initialize LDAP_P(( void ));
+LDAP_F(int) ldap_int_thread_destroy LDAP_P(( void ));
+LDAP_F(int) ldap_int_thread_pool_startup ( void );
+LDAP_F(int) ldap_int_thread_pool_shutdown ( void );
#ifndef LDAP_THREAD_HAVE_TPOOL
typedef struct ldap_int_thread_pool_s * ldap_int_thread_pool_t;
#define Debug( level, fmt, arg1, arg2, arg3 )
#endif /* LDAP_DEBUG */
-LIBLUTIL_F(void) lutil_debug LDAP_P((
+LDAP_LUTIL_F(void) lutil_debug LDAP_P((
int debug, int level,
const char* fmt, ... )) LDAP_GCCATTR((format(printf, 3, 4)));
#define LDAP_PROTO_UDP 2
#define LDAP_PROTO_IPC 3
-LIBLDAP_F ( int )
+LDAP_F ( int )
ldap_pvt_url_scheme2proto LDAP_P((
const char * ));
-LIBLDAP_F ( int )
+LDAP_F ( int )
ldap_pvt_url_scheme2tls LDAP_P((
const char * ));
-LIBLDAP_F ( int )
+LDAP_F ( int )
ldap_pvt_domain2dn LDAP_P((
LDAP_CONST char *domain,
char **dn ));
struct hostent; /* avoid pulling in <netdb.h> */
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_pvt_ctime LDAP_P((
const time_t *tp,
char *buf ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_gethostbyname_a LDAP_P((
const char *name,
struct hostent *resbuf,
struct hostent **result,
int *herrno_ptr ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_gethostbyaddr_a LDAP_P((
const char *addr,
int len,
/* charray.c */
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_charray_add LDAP_P((
char ***a,
char *s ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_charray_merge LDAP_P((
char ***a,
char **s ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_charray_free LDAP_P(( char **a ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_charray_inlist LDAP_P((
char **a,
char *s ));
-LIBLDAP_F( char ** )
+LDAP_F( char ** )
ldap_charray_dup LDAP_P(( char **a ));
-LIBLDAP_F( char ** )
+LDAP_F( char ** )
ldap_str2charray LDAP_P((
const char *str,
const char *brkstr ));
/* url.c */
-LIBLDAP_F (void) ldap_pvt_hex_unescape LDAP_P(( char *s ));
-LIBLDAP_F (int) ldap_pvt_unhex( int c );
+LDAP_F (void) ldap_pvt_hex_unescape LDAP_P(( char *s ));
+LDAP_F (int) ldap_pvt_unhex( int c );
/* these macros assume 'x' is an ASCII x */
#define LDAP_DNSEPARATOR(c) ((c) == ',' || (c) == ';')
#include <sasl.h>
#include <ldap.h>
-LIBLDAP_F (int) ldap_pvt_sasl_init LDAP_P(( void )); /* clientside init */
-LIBLDAP_F (int) ldap_pvt_sasl_install LDAP_P(( Sockbuf *, void * ));
-LIBLDAP_F (int) ldap_pvt_sasl_bind LDAP_P(( LDAP *, LDAP_CONST char *,
+LDAP_F (int) ldap_pvt_sasl_init LDAP_P(( void )); /* clientside init */
+LDAP_F (int) ldap_pvt_sasl_install LDAP_P(( Sockbuf *, void * ));
+LDAP_F (int) ldap_pvt_sasl_bind LDAP_P(( LDAP *, LDAP_CONST char *,
LDAP_CONST char *, LDAP_CONST sasl_callback_t *, LDAPControl **,
LDAPControl ** ));
-LIBLDAP_F (int) ldap_pvt_sasl_get_option LDAP_P(( LDAP *ld, int option,
+LDAP_F (int) ldap_pvt_sasl_get_option LDAP_P(( LDAP *ld, int option,
void *arg ));
-LIBLDAP_F (int) ldap_pvt_sasl_set_option LDAP_P(( LDAP *ld, int option,
+LDAP_F (int) ldap_pvt_sasl_set_option LDAP_P(( LDAP *ld, int option,
void *arg ));
#endif /* HAVE_CYRUS_SASL */
/* search.c */
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_pvt_find_wildcard LDAP_P(( const char *s ));
-LIBLDAP_F( ber_slen_t )
+LDAP_F( ber_slen_t )
ldap_pvt_filter_value_unescape LDAP_P(( char *filter ));
/* string.c */
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_pvt_str2upper LDAP_P(( char *str ));
-LIBLDAP_F( char * )
+LDAP_F( char * )
ldap_pvt_str2lower LDAP_P(( char *str ));
/* tls.c */
struct ldapoptions;
struct ldap;
-LIBLDAP_F (int) ldap_pvt_tls_init LDAP_P(( void ));
-LIBLDAP_F (int) ldap_pvt_tls_config LDAP_P(( struct ldapoptions *lo, int option, const char *arg ));
-LIBLDAP_F (int) ldap_pvt_tls_connect LDAP_P(( struct ldap *ld, Sockbuf *sb, void *ctx_arg ));
-LIBLDAP_F (int) ldap_pvt_tls_accept LDAP_P(( Sockbuf *sb, void *ctx_arg ));
-LIBLDAP_F (int) ldap_pvt_tls_get_option LDAP_P(( struct ldapoptions *lo, int option, void *arg ));
-LIBLDAP_F (int) ldap_pvt_tls_set_option LDAP_P(( struct ldapoptions *lo, int option, void *arg ));
-LIBLDAP_F (void *) ldap_pvt_tls_sb_handle LDAP_P(( Sockbuf *sb ));
-LIBLDAP_F (void *) ldap_pvt_tls_get_handle LDAP_P(( struct ldap *ld ));
-LIBLDAP_F (int) ldap_pvt_tls_inplace LDAP_P(( Sockbuf *sb ));
-LIBLDAP_F (int) ldap_pvt_tls_start LDAP_P(( struct ldap *ld, Sockbuf *sb, void *ctx_arg ));
+LDAP_F (int) ldap_pvt_tls_init LDAP_P(( void ));
+LDAP_F (int) ldap_pvt_tls_config LDAP_P(( struct ldapoptions *lo, int option, const char *arg ));
+LDAP_F (int) ldap_pvt_tls_connect LDAP_P(( struct ldap *ld, Sockbuf *sb, void *ctx_arg ));
+LDAP_F (int) ldap_pvt_tls_accept LDAP_P(( Sockbuf *sb, void *ctx_arg ));
+LDAP_F (int) ldap_pvt_tls_get_option LDAP_P(( struct ldapoptions *lo, int option, void *arg ));
+LDAP_F (int) ldap_pvt_tls_set_option LDAP_P(( struct ldapoptions *lo, int option, void *arg ));
+LDAP_F (void *) ldap_pvt_tls_sb_handle LDAP_P(( Sockbuf *sb ));
+LDAP_F (void *) ldap_pvt_tls_get_handle LDAP_P(( struct ldap *ld ));
+LDAP_F (int) ldap_pvt_tls_inplace LDAP_P(( Sockbuf *sb ));
+LDAP_F (int) ldap_pvt_tls_start LDAP_P(( struct ldap *ld, Sockbuf *sb, void *ctx_arg ));
/*
* UTF-8 (in utf-8.c)
typedef ldap_ucs2_t ldap_unicode_t;
/* returns the number of bytes in the UTF-8 string */
-LIBLDAP_F (ber_len_t) ldap_utf8_bytes( const char * );
+LDAP_F (ber_len_t) ldap_utf8_bytes( const char * );
/* returns the number of UTF-8 characters in the string */
-LIBLDAP_F (ber_len_t) ldap_utf8_chars( const char * );
+LDAP_F (ber_len_t) ldap_utf8_chars( const char * );
/* returns the length (in bytes) of the UTF-8 character */
-LIBLDAP_F (int) ldap_utf8_offset( const char * );
+LDAP_F (int) ldap_utf8_offset( const char * );
/* returns the length (in bytes) indicated by the UTF-8 character */
-LIBLDAP_F (int) ldap_utf8_charlen( const char * );
+LDAP_F (int) ldap_utf8_charlen( const char * );
/* copies a UTF-8 character and returning number of bytes copied */
-LIBLDAP_F (int) ldap_utf8_copy( char *, const char *);
+LDAP_F (int) ldap_utf8_copy( char *, const char *);
/* returns pointer of next UTF-8 character in string */
-LIBLDAP_F (char*) ldap_utf8_next( const char * );
+LDAP_F (char*) ldap_utf8_next( const char * );
/* returns pointer of previous UTF-8 character in string */
-LIBLDAP_F (char*) ldap_utf8_prev( const char * );
+LDAP_F (char*) ldap_utf8_prev( const char * );
/* primitive ctype routines -- not aware of non-ascii characters */
-LIBLDAP_F (int) ldap_utf8_isascii( const char * );
-LIBLDAP_F (int) ldap_utf8_isalpha( const char * );
-LIBLDAP_F (int) ldap_utf8_isalnum( const char * );
-LIBLDAP_F (int) ldap_utf8_isdigit( const char * );
-LIBLDAP_F (int) ldap_utf8_isxdigit( const char * );
-LIBLDAP_F (int) ldap_utf8_isspace( const char * );
+LDAP_F (int) ldap_utf8_isascii( const char * );
+LDAP_F (int) ldap_utf8_isalpha( const char * );
+LDAP_F (int) ldap_utf8_isalnum( const char * );
+LDAP_F (int) ldap_utf8_isdigit( const char * );
+LDAP_F (int) ldap_utf8_isxdigit( const char * );
+LDAP_F (int) ldap_utf8_isspace( const char * );
/* span characters not in set, return bytes spanned */
-LIBLDAP_F (ber_len_t) ldap_utf8_strcspn( const char* str, const char *set);
+LDAP_F (ber_len_t) ldap_utf8_strcspn( const char* str, const char *set);
/* span characters in set, return bytes spanned */
-LIBLDAP_F (ber_len_t) ldap_utf8_strspn( const char* str, const char *set);
+LDAP_F (ber_len_t) ldap_utf8_strspn( const char* str, const char *set);
/* return first occurance of character in string */
-LIBLDAP_F (char *) ldap_utf8_strchr( const char* str, const char *chr);
+LDAP_F (char *) ldap_utf8_strchr( const char* str, const char *chr);
/* return first character of set in string */
-LIBLDAP_F (char *) ldap_utf8_strpbrk( const char* str, const char *set);
+LDAP_F (char *) ldap_utf8_strpbrk( const char* str, const char *set);
/* reentrant tokenizer */
-LIBLDAP_F (char*) ldap_utf8_strtok( char* sp, const char* sep, char **last);
+LDAP_F (char*) ldap_utf8_strtok( char* sp, const char* sep, char **last);
/* Optimizations */
#define LDAP_UTF8_ISASCII(p) ( * (const unsigned char *) (p) < 0x100 )
typedef ldap_int_thread_mutex_t ldap_pvt_thread_mutex_t;
typedef ldap_int_thread_cond_t ldap_pvt_thread_cond_t;
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_initialize LDAP_P(( void ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_destroy LDAP_P(( void ));
-LIBLDAP_F( unsigned int )
+LDAP_F( unsigned int )
ldap_pvt_thread_sleep LDAP_P(( unsigned int s ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_get_concurrency LDAP_P(( void ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_set_concurrency LDAP_P(( int ));
#define LDAP_PVT_THREAD_CREATE_JOINABLE 0
#define LDAP_PVT_THREAD_CREATE_DETACHED 1
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_create LDAP_P((
ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void * ),
void *arg));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_pvt_thread_exit LDAP_P(( void *retval ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_join LDAP_P(( ldap_pvt_thread_t thread, void **status ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_kill LDAP_P(( ldap_pvt_thread_t thread, int signo ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_yield LDAP_P(( void ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_cond_init LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_cond_destroy LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_cond_signal LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_cond_broadcast LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_cond_wait LDAP_P((
ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_mutex_init LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_mutex_destroy LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_mutex_lock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_mutex_trylock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_mutex_unlock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
#ifndef LDAP_THREAD_HAVE_RDWR
typedef struct ldap_int_thread_rdwr_s * ldap_pvt_thread_rdwr_t;
#endif
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_init LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_destroy LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_rlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_rtrylock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_runlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_wlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_wtrylock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_wunlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
#ifdef LDAP_DEBUG
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_readers LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_writers LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_rdwr_active LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
#endif /* LDAP_DEBUG */
typedef ldap_int_thread_pool_t ldap_pvt_thread_pool_t;
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_pool_init LDAP_P((
ldap_pvt_thread_pool_t *pool_out,
int max_concurrency,
int max_pending ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_pool_submit LDAP_P((
ldap_pvt_thread_pool_t *pool,
void *(*start_routine)( void * ),
void *arg ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_pool_backload LDAP_P((
ldap_pvt_thread_pool_t *pool ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_pvt_thread_pool_destroy LDAP_P((
ldap_pvt_thread_pool_t *pool,
int run_pending ));
#define LDAP_SCHEMA_ALLOW_DESCR_PREFIX 0x08 /* Allow descr as OID prefix */
#define LDAP_SCHEMA_ALLOW_ALL 0x0f /* Be very liberal in parsing */
-LIBLDAP_F( LDAP_CONST char * )
+LDAP_F( LDAP_CONST char * )
ldap_syntax2name LDAP_P((
LDAP_SYNTAX * syn ));
-LIBLDAP_F( LDAP_CONST char * )
+LDAP_F( LDAP_CONST char * )
ldap_matchingrule2name LDAP_P((
LDAP_MATCHING_RULE * mr ));
-LIBLDAP_F( LDAP_CONST char * )
+LDAP_F( LDAP_CONST char * )
ldap_attributetype2name LDAP_P((
LDAP_ATTRIBUTE_TYPE * at ));
-LIBLDAP_F( LDAP_CONST char * )
+LDAP_F( LDAP_CONST char * )
ldap_objectclass2name LDAP_P((
LDAP_OBJECT_CLASS * oc ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_syntax_free LDAP_P((
LDAP_SYNTAX * syn ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_matchingrule_free LDAP_P((
LDAP_MATCHING_RULE * mr ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_attributetype_free LDAP_P((
LDAP_ATTRIBUTE_TYPE * at ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_objectclass_free LDAP_P((
LDAP_OBJECT_CLASS * oc ));
-LIBLDAP_F( LDAP_OBJECT_CLASS * )
+LDAP_F( LDAP_OBJECT_CLASS * )
ldap_str2objectclass LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp,
LDAP_CONST int flags ));
-LIBLDAP_F( LDAP_ATTRIBUTE_TYPE * )
+LDAP_F( LDAP_ATTRIBUTE_TYPE * )
ldap_str2attributetype LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp,
LDAP_CONST int flags ));
-LIBLDAP_F( LDAP_SYNTAX * )
+LDAP_F( LDAP_SYNTAX * )
ldap_str2syntax LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp,
LDAP_CONST int flags ));
-LIBLDAP_F( LDAP_MATCHING_RULE * )
+LDAP_F( LDAP_MATCHING_RULE * )
ldap_str2matchingrule LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp,
LDAP_CONST int flags ));
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_objectclass2str LDAP_P((
LDAP_CONST LDAP_OBJECT_CLASS * oc ));
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_attributetype2str LDAP_P((
LDAP_CONST LDAP_ATTRIBUTE_TYPE * at ));
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_syntax2str LDAP_P((
LDAP_CONST LDAP_SYNTAX * syn ));
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_matchingrule2str LDAP_P((
LDAP_CONST LDAP_MATCHING_RULE * mr ));
-LIBLDAP_F( char *)
+LDAP_F( char *)
ldap_scherr2str LDAP_P((
int code )) LDAP_GCCATTR((const));
LDAP_BEGIN_DECL
-LIBLDBM_F (int) ldbm_initialize( void );
-LIBLDBM_F (int) ldbm_shutdown( void );
-
-LIBLDBM_F (int) ldbm_errno( LDBM ldbm );
-LIBLDBM_F (LDBM) ldbm_open( char *name, int rw, int mode, int dbcachesize );
-LIBLDBM_F (void) ldbm_close( LDBM ldbm );
-LIBLDBM_F (void) ldbm_sync( LDBM ldbm );
-LIBLDBM_F (void) ldbm_datum_free( LDBM ldbm, Datum data );
-LIBLDBM_F (Datum) ldbm_datum_dup( LDBM ldbm, Datum data );
-LIBLDBM_F (Datum) ldbm_fetch( LDBM ldbm, Datum key );
-LIBLDBM_F (int) ldbm_store( LDBM ldbm, Datum key, Datum data, int flags );
-LIBLDBM_F (int) ldbm_delete( LDBM ldbm, Datum key );
-
-LIBLDBM_F (Datum) ldbm_firstkey( LDBM ldbm, LDBMCursor **cursor );
-LIBLDBM_F (Datum) ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *cursor );
+LDAP_LDBM_F (int) ldbm_initialize( void );
+LDAP_LDBM_F (int) ldbm_shutdown( void );
+
+LDAP_LDBM_F (int) ldbm_errno( LDBM ldbm );
+LDAP_LDBM_F (LDBM) ldbm_open( char *name, int rw, int mode, int dbcachesize );
+LDAP_LDBM_F (void) ldbm_close( LDBM ldbm );
+LDAP_LDBM_F (void) ldbm_sync( LDBM ldbm );
+LDAP_LDBM_F (void) ldbm_datum_free( LDBM ldbm, Datum data );
+LDAP_LDBM_F (Datum) ldbm_datum_dup( LDBM ldbm, Datum data );
+LDAP_LDBM_F (Datum) ldbm_fetch( LDBM ldbm, Datum key );
+LDAP_LDBM_F (int) ldbm_store( LDBM ldbm, Datum key, Datum data, int flags );
+LDAP_LDBM_F (int) ldbm_delete( LDBM ldbm, Datum key );
+
+LDAP_LDBM_F (Datum) ldbm_firstkey( LDBM ldbm, LDBMCursor **cursor );
+LDAP_LDBM_F (Datum) ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *cursor );
/* initialization of Datum structures */
#if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 2)
- LIBLDBM_F (void *) ldbm_malloc( size_t size );
+ LDAP_LDBM_F (void *) ldbm_malloc( size_t size );
# define ldbm_datum_init(d) ((void)memset(&(d), '\0', sizeof(Datum)))
#else
# define ldbm_datum_init(d) ((void)0)
LDAP_BEGIN_DECL
/* This is NOT a bogus extern declaration (unlike ldap_debug) */
-LIBLDIF_F (int) ldif_debug;
+LDAP_LDIF_F (int) ldif_debug;
#define LDIF_LINE_WIDTH 76 /* maximum length of LDIF lines */
((nlen) + 4 + LDIF_BASE64_LEN(vlen) \
+ ((LDIF_BASE64_LEN(vlen) + (nlen) + 3) / LDIF_LINE_WIDTH * 2 ))
-LIBLDIF_F( int )
+LDAP_LDIF_F( int )
ldif_parse_line LDAP_P((
LDAP_CONST char *line,
char **name,
char **value,
ber_len_t *vlen ));
-LIBLDIF_F( int )
+LDAP_LDIF_F( int )
ldif_fetch_url LDAP_P((
LDAP_CONST char *line,
char **value,
ber_len_t *vlen ));
-LIBLDIF_F( char * )
+LDAP_LDIF_F( char * )
ldif_getline LDAP_P(( char **next ));
-LIBLDIF_F( int )
+LDAP_LDIF_F( int )
ldif_read_record LDAP_P((
FILE *fp,
int *lineno,
#define LDIF_PUT_URL 0x0020 /* url */
#define LDIF_PUT_SEP 0x0040 /* separator */
-LIBLDIF_F( void )
+LDAP_LDIF_F( void )
ldif_sput LDAP_P((
char **out,
int type,
LDAP_CONST char *val,
ber_len_t vlen ));
-LIBLDIF_F( char * )
+LDAP_LDIF_F( char * )
ldif_put LDAP_P((
int type,
LDAP_CONST char *name,
LDAP_CONST char *val,
ber_len_t vlen ));
-LIBLDIF_F( int )
+LDAP_LDIF_F( int )
ldif_is_not_printable LDAP_P((
LDAP_CONST char *val,
ber_len_t vlen ));
/* ISC Base64 Routines */
/* base64.c */
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_b64_ntop LDAP_P((
unsigned char const *,
size_t,
char *,
size_t));
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_b64_pton LDAP_P((
char const *,
unsigned char *,
size_t));
/* detach.c */
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_detach LDAP_P((
int debug,
int do_close));
/* entropy.c */
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_entropy LDAP_P((
char *buf,
ber_len_t nbytes ));
/* passwd.c */
struct berval; /* avoid pulling in lber.h */
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_authpasswd LDAP_P((
const struct berval *passwd, /* stored password */
const struct berval *cred, /* user supplied value */
const char **methods ));
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_authpasswd_hash LDAP_P((
const struct berval *cred,
struct berval **passwd, /* password to store */
#if defined( SLAPD_SPASSWD ) && defined( HAVE_CYRUS_SASL )
/* cheat to avoid pulling in <sasl.h> */
-LIBLUTIL_F( struct sasl_conn * ) lutil_passwd_sasl_conn;
+LDAP_LUTIL_F( struct sasl_conn * ) lutil_passwd_sasl_conn;
#endif
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_passwd LDAP_P((
const struct berval *passwd, /* stored password */
const struct berval *cred, /* user supplied value */
const char **methods ));
-LIBLUTIL_F( struct berval * )
+LDAP_LUTIL_F( struct berval * )
lutil_passwd_generate LDAP_P(( ber_len_t ));
-LIBLUTIL_F( struct berval * )
+LDAP_LUTIL_F( struct berval * )
lutil_passwd_hash LDAP_P((
const struct berval *passwd,
const char *method ));
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_passwd_scheme LDAP_P((
const char *scheme ));
/* utils.c */
-LIBLUTIL_F( char* )
+LDAP_LUTIL_F( char* )
lutil_progname LDAP_P((
const char* name,
int argc,
char *argv[] ));
/* sockpair.c */
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_pair( LBER_SOCKET_T sd[2] );
LDAP_END_DECL
LDAP_BEGIN_DECL
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_lockf LDAP_P(( int fd ));
-LIBLUTIL_F( int )
+LDAP_LUTIL_F( int )
lutil_unlockf LDAP_P(( int fd ));
LDAP_END_DECL
unsigned char in[64];
};
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_MD5Init LDAP_P((
struct lutil_MD5Context *context));
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_MD5Update LDAP_P((
struct lutil_MD5Context *context,
unsigned char const *buf,
ber_len_t len));
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_MD5Final LDAP_P((
unsigned char digest[16],
struct lutil_MD5Context *context));
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_MD5Transform LDAP_P((
ber_uint_t buf[4],
const unsigned char in[64]));
unsigned char buffer[64];
} lutil_SHA1_CTX;
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_SHA1Transform
LDAP_P((uint32 state[5], const unsigned char buffer[64]));
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_SHA1Init
LDAP_P((lutil_SHA1_CTX *context));
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_SHA1Update
LDAP_P((lutil_SHA1_CTX *context, const unsigned char *data, uint32 len));
-LIBLUTIL_F( void )
+LDAP_LUTIL_F( void )
lutil_SHA1Final
LDAP_P((unsigned char digest[20], lutil_SHA1_CTX *context));
-LIBLUTIL_F( char * )
+LDAP_LUTIL_F( char * )
lutil_SHA1End
LDAP_P((lutil_SHA1_CTX *, char *));
-LIBLUTIL_F( char * )
+LDAP_LUTIL_F( char * )
lutil_SHA1File
LDAP_P((char *, char *));
-LIBLUTIL_F( char * )
+LDAP_LUTIL_F( char * )
lutil_SHA1Data
LDAP_P((const unsigned char *, size_t, char *));
#define LDAP_SEARCHPREF_ERR_FILE 4
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_init_searchprefs LDAP_P(( char *file,
struct ldap_searchobj **solistp ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_init_searchprefs_buf LDAP_P(( char *buf,
ber_len_t buflen,
struct ldap_searchobj **solistp ));
-LIBLDAP_F( void )
+LDAP_F( void )
ldap_free_searchprefs LDAP_P(( struct ldap_searchobj *solist ));
-LIBLDAP_F( struct ldap_searchobj * )
+LDAP_F( struct ldap_searchobj * )
ldap_first_searchobj LDAP_P(( struct ldap_searchobj *solist ));
-LIBLDAP_F( struct ldap_searchobj * )
+LDAP_F( struct ldap_searchobj * )
ldap_next_searchobj LDAP_P(( struct ldap_searchobj *sollist,
struct ldap_searchobj *so ));
LINKAGE = @LT_LIB_LINKAGE@
-NT_DYN_TEST_DEFS = -DLIBLBER_DECL=dllimport
+NT_DYN_TEST_DEFS = -DLBER_DECL=dllimport
# Extras for building the library
EXTRA_DEFS = $(@PLAT@_@LIB_LINKAGE@_LIB_DEFS)
LDAP_BEGIN_DECL
-LIBLBER_F (BER_ERRNO_FN) ber_int_errno_fn;
+LBER_F (BER_ERRNO_FN) ber_int_errno_fn;
struct lber_options {
short lbo_valid;
#define LBER_VALID_BERELEMENT 0x2
#define LBER_VALID_SOCKBUF 0x3
-LIBLBER_F (struct lber_options) ber_int_options;
+LBER_F (struct lber_options) ber_int_options;
#define ber_int_debug ber_int_options.lbo_debug
struct berelement {
*/
#define ber_log_printf ber_pvt_log_printf
-LIBLBER_F( int )
+LBER_F( int )
ber_log_bprint LDAP_P((
int errlvl,
int loglvl,
const char *data,
ber_len_t len ));
-LIBLBER_F( int )
+LBER_F( int )
ber_log_dump LDAP_P((
int errlvl,
int loglvl,
BerElement *ber,
int inout ));
-LIBLBER_F( int )
+LBER_F( int )
ber_log_sos_dump LDAP_P((
int errlvl,
int loglvl,
/* memory.c */
/* simple macros to realloc for now */
-LIBLBER_F (BerMemoryFunctions *) ber_int_memory_fns;
+LBER_F (BerMemoryFunctions *) ber_int_memory_fns;
#ifdef CSRIMALLOC
#define LBER_INT_MALLOC malloc
/* sockbuf.c */
-LIBLBER_F( int )
+LBER_F( int )
ber_int_sb_init LDAP_P(( Sockbuf *sb ));
-LIBLBER_F( int )
+LBER_F( int )
ber_int_sb_close LDAP_P(( Sockbuf *sb ));
-LIBLBER_F( int )
+LBER_F( int )
ber_int_sb_destroy LDAP_P(( Sockbuf *sb ));
-LIBLBER_F( ber_slen_t )
+LBER_F( ber_slen_t )
ber_int_sb_read LDAP_P(( Sockbuf *sb, void *buf, ber_len_t len ));
-LIBLBER_F( ber_slen_t )
+LBER_F( ber_slen_t )
ber_int_sb_write LDAP_P(( Sockbuf *sb, void *buf, ber_len_t len ));
LDAP_END_DECL
LINKAGE = @LT_LIB_LINKAGE@
NT_DYN_LIB_LIBS = -llber -llutil $(AC_LIBS)
-NT_DYN_LIB_DEFS = -DLIBLBER_DECL=dllimport
-NT_DYN_TEST_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
+NT_DYN_LIB_DEFS = -DLBER_DECL=dllimport
+NT_DYN_TEST_DEFS = -DLBER_DECL=dllimport -DLDAP_DECL=dllimport
NT_XXLIBS = $(SECURITY_LIBS)
SHOULD be freed by calling ldap_control_free() when done.
---*/
-LIBLDAP_F( int )
+int
ldap_int_create_control(
const char *requestOID,
BerElement *ber,
* in init.c
*/
-LIBLDAP_F ( struct ldapoptions ) ldap_int_global_options;
-LIBLDAP_F ( void ) ldap_int_initialize LDAP_P((struct ldapoptions *, int *));
-LIBLDAP_F ( void ) ldap_int_initialize_global_options LDAP_P((
+LDAP_F ( struct ldapoptions ) ldap_int_global_options;
+LDAP_F ( void ) ldap_int_initialize LDAP_P((struct ldapoptions *, int *));
+LDAP_F ( void ) ldap_int_initialize_global_options LDAP_P((
struct ldapoptions *, int *));
/* memory.c */
/*
* in unit-int.c
*/
-LIBLDAP_F (void) ldap_int_utils_init LDAP_P(( void ));
+LDAP_F (void) ldap_int_utils_init LDAP_P(( void ));
/*
* in print.c
*/
-LIBLDAP_F (int) ldap_log_printf LDAP_P((LDAP *ld, int level, const char *fmt, ...)) LDAP_GCCATTR((format(printf, 3, 4)));
+LDAP_F (int) ldap_log_printf LDAP_P((LDAP *ld, int level, const char *fmt, ...)) LDAP_GCCATTR((format(printf, 3, 4)));
/*
* in cache.c
*/
-LIBLDAP_F (void) ldap_add_request_to_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype,
+LDAP_F (void) ldap_add_request_to_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype,
BerElement *request ));
-LIBLDAP_F (void) ldap_add_result_to_cache LDAP_P(( LDAP *ld, LDAPMessage *result ));
-LIBLDAP_F (int) ldap_check_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype, BerElement *request ));
+LDAP_F (void) ldap_add_result_to_cache LDAP_P(( LDAP *ld, LDAPMessage *result ));
+LDAP_F (int) ldap_check_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype, BerElement *request ));
/*
* in controls.c
*/
-LIBLDAP_F (LDAPControl *) ldap_control_dup LDAP_P((
+LDAP_F (LDAPControl *) ldap_control_dup LDAP_P((
const LDAPControl *ctrl ));
-LIBLDAP_F (LDAPControl **) ldap_controls_dup LDAP_P((
+LDAP_F (LDAPControl **) ldap_controls_dup LDAP_P((
LDAPControl *const *ctrls ));
-LIBLDAP_F (int) ldap_int_get_controls LDAP_P((
+LDAP_F (int) ldap_int_get_controls LDAP_P((
BerElement *be,
LDAPControl ***ctrlsp));
-LIBLDAP_F (int) ldap_int_put_controls LDAP_P((
+LDAP_F (int) ldap_int_put_controls LDAP_P((
LDAP *ld,
LDAPControl *const *ctrls,
BerElement *ber ));
-LIBLDAP_F( int )
+LDAP_F( int )
ldap_int_create_control LDAP_P((
const char *requestOID,
BerElement *ber,
/*
* in dsparse.c
*/
-LIBLDAP_F (int) ldap_int_next_line_tokens LDAP_P(( char **bufp, ber_len_t *blenp, char ***toksp ));
+LDAP_F (int) ldap_int_next_line_tokens LDAP_P(( char **bufp, ber_len_t *blenp, char ***toksp ));
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
/*
* in kerberos.c
*/
-LIBLDAP_F (char *) ldap_get_kerberosv4_credentials LDAP_P((
+LDAP_F (char *) ldap_get_kerberosv4_credentials LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
LDAP_CONST char *service,
/*
* in open.c
*/
-LIBLDAP_F (int) ldap_open_defconn( LDAP *ld );
-LIBLDAP_F (int) open_ldap_connection( LDAP *ld, Sockbuf *sb, LDAPURLDesc *srvlist, char **krbinstancep, int async );
+LDAP_F (int) ldap_open_defconn( LDAP *ld );
+LDAP_F (int) open_ldap_connection( LDAP *ld, Sockbuf *sb, LDAPURLDesc *srvlist, char **krbinstancep, int async );
/*
* in os-ip.c
*/
-LIBLDAP_F (int) ldap_int_tblsize;
-LIBLDAP_F (int) ldap_int_timeval_dup( struct timeval **dest, const struct timeval *tm );
-LIBLDAP_F (int) ldap_connect_to_host( LDAP *ld, Sockbuf *sb, const char *host, unsigned long address, int port, int async );
+LDAP_F (int) ldap_int_tblsize;
+LDAP_F (int) ldap_int_timeval_dup( struct timeval **dest, const struct timeval *tm );
+LDAP_F (int) ldap_connect_to_host( LDAP *ld, Sockbuf *sb, const char *host, unsigned long address, int port, int async );
#if defined(LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND) || defined(HAVE_TLS) || defined(HAVE_CYRUS_SASL)
-LIBLDAP_F (char *) ldap_host_connected_to( Sockbuf *sb );
+LDAP_F (char *) ldap_host_connected_to( Sockbuf *sb );
#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND */
-LIBLDAP_F (void) ldap_int_ip_init( void );
-LIBLDAP_F (int) do_ldap_select( LDAP *ld, struct timeval *timeout );
-LIBLDAP_F (void *) ldap_new_select_info( void );
-LIBLDAP_F (void) ldap_free_select_info( void *sip );
-LIBLDAP_F (void) ldap_mark_select_write( LDAP *ld, Sockbuf *sb );
-LIBLDAP_F (void) ldap_mark_select_read( LDAP *ld, Sockbuf *sb );
-LIBLDAP_F (void) ldap_mark_select_clear( LDAP *ld, Sockbuf *sb );
-LIBLDAP_F (int) ldap_is_read_ready( LDAP *ld, Sockbuf *sb );
-LIBLDAP_F (int) ldap_is_write_ready( LDAP *ld, Sockbuf *sb );
+LDAP_F (void) ldap_int_ip_init( void );
+LDAP_F (int) do_ldap_select( LDAP *ld, struct timeval *timeout );
+LDAP_F (void *) ldap_new_select_info( void );
+LDAP_F (void) ldap_free_select_info( void *sip );
+LDAP_F (void) ldap_mark_select_write( LDAP *ld, Sockbuf *sb );
+LDAP_F (void) ldap_mark_select_read( LDAP *ld, Sockbuf *sb );
+LDAP_F (void) ldap_mark_select_clear( LDAP *ld, Sockbuf *sb );
+LDAP_F (int) ldap_is_read_ready( LDAP *ld, Sockbuf *sb );
+LDAP_F (int) ldap_is_write_ready( LDAP *ld, Sockbuf *sb );
/*
* in os-local.c
*/
#ifdef LDAP_PF_UNIX
-LIBLDAP_F (int) ldap_connect_to_path( LDAP *ld, Sockbuf *sb, const char *path, int async );
+LDAP_F (int) ldap_connect_to_path( LDAP *ld, Sockbuf *sb, const char *path, int async );
#endif /* LDAP_PF_UNIX */
/*
* in request.c
*/
-LIBLDAP_F (ber_int_t) ldap_send_initial_request( LDAP *ld, ber_tag_t msgtype,
+LDAP_F (ber_int_t) ldap_send_initial_request( LDAP *ld, ber_tag_t msgtype,
const char *dn, BerElement *ber );
-LIBLDAP_F (BerElement *) ldap_alloc_ber_with_options( LDAP *ld );
-LIBLDAP_F (void) ldap_set_ber_options( LDAP *ld, BerElement *ber );
-
-LIBLDAP_F (int) ldap_send_server_request( LDAP *ld, BerElement *ber, ber_int_t msgid, LDAPRequest *parentreq, LDAPURLDesc *srvlist, LDAPConn *lc, LDAPreqinfo *bind );
-LIBLDAP_F (LDAPConn *) ldap_new_connection( LDAP *ld, LDAPURLDesc *srvlist, int use_ldsb, int connect, LDAPreqinfo *bind );
-LIBLDAP_F (LDAPRequest *) ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid );
-LIBLDAP_F (void) ldap_free_request( LDAP *ld, LDAPRequest *lr );
-LIBLDAP_F (void) ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind );
-LIBLDAP_F (void) ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all );
-LIBLDAP_F (void) ldap_dump_requests_and_responses( LDAP *ld );
-LIBLDAP_F (int) ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp );
-LIBLDAP_F (int) ldap_chase_v3referrals( LDAP *ld, LDAPRequest *lr, char **refs, char **referralsp, int *hadrefp );
-LIBLDAP_F (int) ldap_append_referral( LDAP *ld, char **referralsp, char *s );
+LDAP_F (BerElement *) ldap_alloc_ber_with_options( LDAP *ld );
+LDAP_F (void) ldap_set_ber_options( LDAP *ld, BerElement *ber );
+
+LDAP_F (int) ldap_send_server_request( LDAP *ld, BerElement *ber, ber_int_t msgid, LDAPRequest *parentreq, LDAPURLDesc *srvlist, LDAPConn *lc, LDAPreqinfo *bind );
+LDAP_F (LDAPConn *) ldap_new_connection( LDAP *ld, LDAPURLDesc *srvlist, int use_ldsb, int connect, LDAPreqinfo *bind );
+LDAP_F (LDAPRequest *) ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid );
+LDAP_F (void) ldap_free_request( LDAP *ld, LDAPRequest *lr );
+LDAP_F (void) ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind );
+LDAP_F (void) ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all );
+LDAP_F (void) ldap_dump_requests_and_responses( LDAP *ld );
+LDAP_F (int) ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp );
+LDAP_F (int) ldap_chase_v3referrals( LDAP *ld, LDAPRequest *lr, char **refs, char **referralsp, int *hadrefp );
+LDAP_F (int) ldap_append_referral( LDAP *ld, char **referralsp, char *s );
/*
* in result.c:
*/
#ifdef LDAP_CONNECTIONLESS
-LIBLDAP_F (int) cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber );
+LDAP_F (int) cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber );
#endif
/*
* in search.c
*/
-LIBLDAP_F (BerElement *) ldap_build_search_req LDAP_P((
+LDAP_F (BerElement *) ldap_build_search_req LDAP_P((
LDAP *ld,
const char *base,
ber_int_t scope,
/*
* in unbind.c
*/
-LIBLDAP_F (int) ldap_ld_free LDAP_P((
+LDAP_F (int) ldap_ld_free LDAP_P((
LDAP *ld,
int close,
LDAPControl **sctrls,
LDAPControl **cctrls ));
-LIBLDAP_F (int) ldap_send_unbind LDAP_P((
+LDAP_F (int) ldap_send_unbind LDAP_P((
LDAP *ld,
Sockbuf *sb,
LDAPControl **sctrls,
/*
* in url.c
*/
-LIBLDAP_F (LDAPURLDesc *) ldap_url_dup LDAP_P((
+LDAP_F (LDAPURLDesc *) ldap_url_dup LDAP_P((
LDAPURLDesc *ludp ));
-LIBLDAP_F (LDAPURLDesc *) ldap_url_duplist LDAP_P((
+LDAP_F (LDAPURLDesc *) ldap_url_duplist LDAP_P((
LDAPURLDesc *ludlist ));
-LIBLDAP_F (int) ldap_url_parselist LDAP_P((
+LDAP_F (int) ldap_url_parselist LDAP_P((
LDAPURLDesc **ludlist,
const char *url ));
-LIBLDAP_F (int) ldap_url_parsehosts LDAP_P((
+LDAP_F (int) ldap_url_parsehosts LDAP_P((
LDAPURLDesc **ludlist,
const char *hosts ));
-LIBLDAP_F (char *) ldap_url_list2hosts LDAP_P((
+LDAP_F (char *) ldap_url_list2hosts LDAP_P((
LDAPURLDesc *ludlist ));
-LIBLDAP_F (char *) ldap_url_list2urls LDAP_P((
+LDAP_F (char *) ldap_url_list2urls LDAP_P((
LDAPURLDesc *ludlist ));
-LIBLDAP_F (void) ldap_free_urllist LDAP_P((
+LDAP_F (void) ldap_free_urllist LDAP_P((
LDAPURLDesc *ludlist ));
return LDAP_OPT_ERROR;
}
-LIBLDAP_F(int)
+int
ldap_set_rebind_proc( LDAP *ld, LDAP_REBIND_PROC *rebind_proc)
{
return( ldap_set_option( ld, LDAP_OPT_REBIND_PROC, (void *)rebind_proc));
*
* Return value - number of referrals followed
*/
-LIBLDAP_F(int)
+int
ldap_chase_v3referrals( LDAP *ld, LDAPRequest *lr, char **refs, char **errstrp, int *hadrefp )
{
char *unfollowed;
---------------------------------------------------------------------------*/
-LIBLDAP_F(int)
+int
ldap_create_sort_keylist ( LDAPSortKey ***sortKeyList, char *keyString )
{
int numKeys, rc, i;
keyList (IN) Points to an array of pointers to LDAPSortKey structures.
---------------------------------------------------------------------------*/
-LIBLDAP_F(void)
+void
ldap_free_sort_keylist ( LDAPSortKey **keyList )
{
int i;
---------------------------------------------------------------------------*/
-LIBLDAP_F( int )
+int
ldap_create_sort_control (
LDAP *ld,
LDAPSortKey **keyList,
attributeType [0] AttributeDescription OPTIONAL }
---------------------------------------------------------------------------*/
-LIBLDAP_F( int )
+int
ldap_parse_sort_control(
LDAP *ld,
LDAPControl **ctrls,
---*/
-LIBLDAP_F( int )
+int
ldap_create_vlv_control( LDAP *ld,
LDAPVLVInfo *vlvinfop,
LDAPControl **ctrlp )
---*/
-LIBLDAP_F( int )
+int
ldap_parse_vlv_control(
LDAP *ld,
LDAPControl **ctrls,
LINKAGE = @LT_LIB_LINKAGE@
NT_DYN_LIB_LIBS = -llber -llutil $(AC_LIBS)
-NT_DYN_LIB_DEFS = -DLIBLBER_DECL=dllimport
-NT_DYN_TEST_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
+NT_DYN_LIB_DEFS = -DLBER_DECL=dllimport
+NT_DYN_TEST_DEFS = -DLBER_DECL=dllimport -DLDAP_DECL=dllimport
NT_XXLIBS = $(SECURITY_LIBS)
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
-NT_DYN_LIB_DEFS = -DLIBLDAP_DECL=dllimport
+NT_DYN_LIB_DEFS = -DLDAP_DECL=dllimport
CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_LIB_DEFS)
XLIBS = -lldbm -lavl
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
-NT_DYN_LIB_DEFS = -DLIBLDAP_DECL=dllimport -DLIBLBER_DECL=dllimport
+NT_DYN_LIB_DEFS = -DLDAP_DECL=dllimport -DLBER_DECL=dllimport
CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_LIB_DEFS)
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
-NT_DYN_LIB_DEFS = -DLIBLDAP_DECL=dllimport
+NT_DYN_LIB_DEFS = -DLDAP_DECL=dllimport
CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_LIB_DEFS)
# These rules are for a Mingw32 build, specifically.
all-local-srv: all-cffiles
-NT_DYN_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
+NT_DYN_DEFS = -DLBER_DECL=dllimport -DLDAP_DECL=dllimport
DEFINES = $(@PLAT@_@LIB_LINKAGE@_DEFS)
BUILD_MOD = @BUILD_LDBM@
LINKAGE = @BUILD_LDBM_DYNAMIC@
-DYN_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
+DYN_DEFS = -DLBER_DECL=dllimport -DLDAP_DECL=dllimport
# TODO
#NT_mod_DYN_MODDEFS =
LDAP_BEGIN_DECL
-LIBSLAPD_F( int ) schema_init_done;
-LIBSLAPD_F( struct slap_internal_schema ) slap_schema;
+LDAP_SLAPD_F( int ) schema_init_done;
+LDAP_SLAPD_F( struct slap_internal_schema ) slap_schema;
-LIBSLAPD_F (int) slap_str2ad LDAP_P((
+LDAP_SLAPD_F (int) slap_str2ad LDAP_P((
const char *,
AttributeDescription **ad,
const char **text ));
-LIBSLAPD_F (int) slap_bv2ad LDAP_P((
+LDAP_SLAPD_F (int) slap_bv2ad LDAP_P((
struct berval *bv,
AttributeDescription **ad,
const char **text ));
-LIBSLAPD_F (AttributeDescription *) ad_dup LDAP_P((
+LDAP_SLAPD_F (AttributeDescription *) ad_dup LDAP_P((
AttributeDescription *desc ));
-LIBSLAPD_F (void) ad_free LDAP_P((
+LDAP_SLAPD_F (void) ad_free LDAP_P((
AttributeDescription *desc,
int freeit ));
#define ad_cmp(l,r) ( strcasecmp( \
(l)->ad_cname->bv_val, (r)->ad_cname->bv_val ))
-LIBSLAPD_F (int) is_ad_subtype LDAP_P((
+LDAP_SLAPD_F (int) is_ad_subtype LDAP_P((
AttributeDescription *sub,
AttributeDescription *super ));
-LIBSLAPD_F (int) ad_inlist LDAP_P((
+LDAP_SLAPD_F (int) ad_inlist LDAP_P((
AttributeDescription *desc,
char **attrs ));
* acl.c
*/
-LIBSLAPD_F (int) access_allowed LDAP_P((
+LDAP_SLAPD_F (int) access_allowed LDAP_P((
Backend *be, Connection *conn, Operation *op,
Entry *e, AttributeDescription *desc, struct berval *val,
slap_access_t access ));
-LIBSLAPD_F (int) acl_check_modlist LDAP_P((
+LDAP_SLAPD_F (int) acl_check_modlist LDAP_P((
Backend *be, Connection *conn, Operation *op,
Entry *e, Modifications *ml ));
-LIBSLAPD_F (void) acl_append( AccessControl **l, AccessControl *a );
+LDAP_SLAPD_F (void) acl_append( AccessControl **l, AccessControl *a );
/*
* aclparse.c
*/
-LIBSLAPD_F (void) parse_acl LDAP_P(( Backend *be,
+LDAP_SLAPD_F (void) parse_acl LDAP_P(( Backend *be,
const char *fname, int lineno,
int argc, char **argv ));
-LIBSLAPD_F (char *) access2str LDAP_P(( slap_access_t access ));
-LIBSLAPD_F (slap_access_t) str2access LDAP_P(( const char *str ));
+LDAP_SLAPD_F (char *) access2str LDAP_P(( slap_access_t access ));
+LDAP_SLAPD_F (slap_access_t) str2access LDAP_P(( const char *str ));
#define ACCESSMASK_MAXLEN sizeof("unknown (+wrscan)")
-LIBSLAPD_F (char *) accessmask2str LDAP_P(( slap_access_mask_t mask, char* ));
-LIBSLAPD_F (slap_access_mask_t) str2accessmask LDAP_P(( const char *str ));
+LDAP_SLAPD_F (char *) accessmask2str LDAP_P(( slap_access_mask_t mask, char* ));
+LDAP_SLAPD_F (slap_access_mask_t) str2accessmask LDAP_P(( const char *str ));
/*
* at.c
*/
-LIBSLAPD_F (void) at_config LDAP_P(( const char *fname, int lineno, int argc, char **argv ));
-LIBSLAPD_F (AttributeType *) at_find LDAP_P(( const char *name ));
-LIBSLAPD_F (int) at_find_in_list LDAP_P(( AttributeType *sat, AttributeType **list ));
-LIBSLAPD_F (int) at_append_to_list LDAP_P(( AttributeType *sat, AttributeType ***listp ));
-LIBSLAPD_F (int) at_delete_from_list LDAP_P(( int pos, AttributeType ***listp ));
-LIBSLAPD_F (int) at_schema_info LDAP_P(( Entry *e ));
-LIBSLAPD_F (int) at_add LDAP_P(( LDAP_ATTRIBUTE_TYPE *at, const char **err ));
+LDAP_SLAPD_F (void) at_config LDAP_P(( const char *fname, int lineno, int argc, char **argv ));
+LDAP_SLAPD_F (AttributeType *) at_find LDAP_P(( const char *name ));
+LDAP_SLAPD_F (int) at_find_in_list LDAP_P(( AttributeType *sat, AttributeType **list ));
+LDAP_SLAPD_F (int) at_append_to_list LDAP_P(( AttributeType *sat, AttributeType ***listp ));
+LDAP_SLAPD_F (int) at_delete_from_list LDAP_P(( int pos, AttributeType ***listp ));
+LDAP_SLAPD_F (int) at_schema_info LDAP_P(( Entry *e ));
+LDAP_SLAPD_F (int) at_add LDAP_P(( LDAP_ATTRIBUTE_TYPE *at, const char **err ));
-LIBSLAPD_F (int) is_at_subtype LDAP_P((
+LDAP_SLAPD_F (int) is_at_subtype LDAP_P((
AttributeType *sub,
AttributeType *super ));
-LIBSLAPD_F (int) is_at_syntax LDAP_P((
+LDAP_SLAPD_F (int) is_at_syntax LDAP_P((
AttributeType *at,
const char *oid ));
* attr.c
*/
-LIBSLAPD_F (void) attr_free LDAP_P(( Attribute *a ));
-LIBSLAPD_F (Attribute *) attr_dup LDAP_P(( Attribute *a ));
+LDAP_SLAPD_F (void) attr_free LDAP_P(( Attribute *a ));
+LDAP_SLAPD_F (Attribute *) attr_dup LDAP_P(( Attribute *a ));
-LIBSLAPD_F (int) attr_merge LDAP_P(( Entry *e,
+LDAP_SLAPD_F (int) attr_merge LDAP_P(( Entry *e,
AttributeDescription *desc,
struct berval **vals ));
-LIBSLAPD_F (Attribute *) attrs_find LDAP_P(( Attribute *a, AttributeDescription *desc ));
-LIBSLAPD_F (Attribute *) attr_find LDAP_P(( Attribute *a, AttributeDescription *desc ));
-LIBSLAPD_F (int) attr_delete LDAP_P(( Attribute **attrs, AttributeDescription *desc ));
+LDAP_SLAPD_F (Attribute *) attrs_find LDAP_P(( Attribute *a, AttributeDescription *desc ));
+LDAP_SLAPD_F (Attribute *) attr_find LDAP_P(( Attribute *a, AttributeDescription *desc ));
+LDAP_SLAPD_F (int) attr_delete LDAP_P(( Attribute **attrs, AttributeDescription *desc ));
-LIBSLAPD_F (void) attrs_free LDAP_P(( Attribute *a ));
-LIBSLAPD_F (Attribute *) attrs_dup LDAP_P(( Attribute *a ));
+LDAP_SLAPD_F (void) attrs_free LDAP_P(( Attribute *a ));
+LDAP_SLAPD_F (Attribute *) attrs_dup LDAP_P(( Attribute *a ));
/*
* ava.c
*/
-LIBSLAPD_F (int) get_ava LDAP_P((
+LDAP_SLAPD_F (int) get_ava LDAP_P((
BerElement *ber,
AttributeAssertion **ava,
unsigned usage,
const char **text ));
-LIBSLAPD_F (void) ava_free LDAP_P((
+LDAP_SLAPD_F (void) ava_free LDAP_P((
AttributeAssertion *ava,
int freeit ));
* backend.c
*/
-LIBSLAPD_F (int) backend_init LDAP_P((void));
-LIBSLAPD_F (int) backend_add LDAP_P((BackendInfo *aBackendInfo));
-LIBSLAPD_F (int) backend_num LDAP_P((Backend *be));
-LIBSLAPD_F (int) backend_startup LDAP_P((Backend *be));
-LIBSLAPD_F (int) backend_shutdown LDAP_P((Backend *be));
-LIBSLAPD_F (int) backend_destroy LDAP_P((void));
+LDAP_SLAPD_F (int) backend_init LDAP_P((void));
+LDAP_SLAPD_F (int) backend_add LDAP_P((BackendInfo *aBackendInfo));
+LDAP_SLAPD_F (int) backend_num LDAP_P((Backend *be));
+LDAP_SLAPD_F (int) backend_startup LDAP_P((Backend *be));
+LDAP_SLAPD_F (int) backend_shutdown LDAP_P((Backend *be));
+LDAP_SLAPD_F (int) backend_destroy LDAP_P((void));
-LIBSLAPD_F (BackendInfo *) backend_info LDAP_P(( const char *type ));
-LIBSLAPD_F (BackendDB *) backend_db_init LDAP_P(( const char *type ));
+LDAP_SLAPD_F (BackendInfo *) backend_info LDAP_P(( const char *type ));
+LDAP_SLAPD_F (BackendDB *) backend_db_init LDAP_P(( const char *type ));
-LIBSLAPD_F (BackendDB *) select_backend LDAP_P(( const char * dn ));
+LDAP_SLAPD_F (BackendDB *) select_backend LDAP_P(( const char * dn ));
-LIBSLAPD_F (int) be_issuffix LDAP_P(( Backend *be, const char *suffix ));
-LIBSLAPD_F (int) be_isroot LDAP_P(( Backend *be, const char *ndn ));
-LIBSLAPD_F (int) be_isroot_pw LDAP_P(( Backend *be, const char *ndn, struct berval *cred ));
-LIBSLAPD_F (char *) be_root_dn LDAP_P(( Backend *be ));
-LIBSLAPD_F (int) be_entry_release_rw LDAP_P(( Backend *be, Entry *e, int rw ));
+LDAP_SLAPD_F (int) be_issuffix LDAP_P(( Backend *be, const char *suffix ));
+LDAP_SLAPD_F (int) be_isroot LDAP_P(( Backend *be, const char *ndn ));
+LDAP_SLAPD_F (int) be_isroot_pw LDAP_P(( Backend *be, const char *ndn, struct berval *cred ));
+LDAP_SLAPD_F (char *) be_root_dn LDAP_P(( Backend *be ));
+LDAP_SLAPD_F (int) be_entry_release_rw LDAP_P(( Backend *be, Entry *e, int rw ));
#define be_entry_release_r( be, e ) be_entry_release_rw( be, e, 0 )
#define be_entry_release_w( be, e ) be_entry_release_rw( be, e, 1 )
-LIBSLAPD_F (int) backend_unbind LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) backend_unbind LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F( int ) backend_check_controls LDAP_P((
+LDAP_SLAPD_F( int ) backend_check_controls LDAP_P((
Backend *be,
Connection *conn,
Operation *op,
const char **text ));
-LIBSLAPD_F( int ) backend_check_referrals LDAP_P((
+LDAP_SLAPD_F( int ) backend_check_referrals LDAP_P((
Backend *be,
Connection *conn,
Operation *op,
const char *dn,
const char *ndn ));
-LIBSLAPD_F (int) backend_connection_init LDAP_P((Connection *conn));
-LIBSLAPD_F (int) backend_connection_destroy LDAP_P((Connection *conn));
+LDAP_SLAPD_F (int) backend_connection_init LDAP_P((Connection *conn));
+LDAP_SLAPD_F (int) backend_connection_destroy LDAP_P((Connection *conn));
-LIBSLAPD_F (int) backend_group LDAP_P((Backend *be,
+LDAP_SLAPD_F (int) backend_group LDAP_P((Backend *be,
Entry *target,
const char *gr_ndn,
const char *op_ndn,
AttributeDescription *group_at
));
-LIBSLAPD_F (Attribute *) backend_operational( Backend *, Entry * );
+LDAP_SLAPD_F (Attribute *) backend_operational( Backend *, Entry * );
#define ch_free free
#else
-LIBSLAPD_F (void *) ch_malloc LDAP_P(( ber_len_t size ));
-LIBSLAPD_F (void *) ch_realloc LDAP_P(( void *block, ber_len_t size ));
-LIBSLAPD_F (void *) ch_calloc LDAP_P(( ber_len_t nelem, ber_len_t size ));
-LIBSLAPD_F (char *) ch_strdup LDAP_P(( const char *string ));
-LIBSLAPD_F (void) ch_free LDAP_P(( void * ));
+LDAP_SLAPD_F (void *) ch_malloc LDAP_P(( ber_len_t size ));
+LDAP_SLAPD_F (void *) ch_realloc LDAP_P(( void *block, ber_len_t size ));
+LDAP_SLAPD_F (void *) ch_calloc LDAP_P(( ber_len_t nelem, ber_len_t size ));
+LDAP_SLAPD_F (char *) ch_strdup LDAP_P(( const char *string ));
+LDAP_SLAPD_F (void) ch_free LDAP_P(( void * ));
#ifndef CH_FREE
#undef free
* charray.c
*/
-LIBSLAPD_F (void) charray_add LDAP_P(( char ***a, const char *s ));
-LIBSLAPD_F (void) charray_merge LDAP_P(( char ***a, char **s ));
-LIBSLAPD_F (void) charray_free LDAP_P(( char **array ));
-LIBSLAPD_F (int) charray_inlist LDAP_P(( char **a, const char *s ));
-LIBSLAPD_F (char **) charray_dup LDAP_P(( char **a ));
-LIBSLAPD_F (char **) str2charray LDAP_P(( const char *str, const char *brkstr ));
+LDAP_SLAPD_F (void) charray_add LDAP_P(( char ***a, const char *s ));
+LDAP_SLAPD_F (void) charray_merge LDAP_P(( char ***a, char **s ));
+LDAP_SLAPD_F (void) charray_free LDAP_P(( char **array ));
+LDAP_SLAPD_F (int) charray_inlist LDAP_P(( char **a, const char *s ));
+LDAP_SLAPD_F (char **) charray_dup LDAP_P(( char **a ));
+LDAP_SLAPD_F (char **) str2charray LDAP_P(( const char *str, const char *brkstr ));
/*
* controls.c
*/
-LIBSLAPD_F (int) get_ctrls LDAP_P((
+LDAP_SLAPD_F (int) get_ctrls LDAP_P((
Connection *co,
Operation *op,
int senderrors ));
-LIBSLAPD_F (int) get_manageDSAit LDAP_P(( Operation *op ));
+LDAP_SLAPD_F (int) get_manageDSAit LDAP_P(( Operation *op ));
/*
* config.c
*/
-LIBSLAPD_F (int) read_config LDAP_P(( const char *fname ));
+LDAP_SLAPD_F (int) read_config LDAP_P(( const char *fname ));
/*
* index.c
*/
-LIBSLAPD_F (int) slap_index2prefix LDAP_P(( int indextype ));
-LIBSLAPD_F (int) slap_str2index LDAP_P(( const char *str, slap_index *idx ));
+LDAP_SLAPD_F (int) slap_index2prefix LDAP_P(( int indextype ));
+LDAP_SLAPD_F (int) slap_str2index LDAP_P(( const char *str, slap_index *idx ));
/*
* connection.c
*/
-LIBSLAPD_F (int) connections_init LDAP_P((void));
-LIBSLAPD_F (int) connections_shutdown LDAP_P((void));
-LIBSLAPD_F (int) connections_destroy LDAP_P((void));
-LIBSLAPD_F (int) connections_timeout_idle LDAP_P((time_t));
+LDAP_SLAPD_F (int) connections_init LDAP_P((void));
+LDAP_SLAPD_F (int) connections_shutdown LDAP_P((void));
+LDAP_SLAPD_F (int) connections_destroy LDAP_P((void));
+LDAP_SLAPD_F (int) connections_timeout_idle LDAP_P((time_t));
-LIBSLAPD_F (long) connection_init LDAP_P((
+LDAP_SLAPD_F (long) connection_init LDAP_P((
ber_socket_t s,
const char* url,
const char* dnsname,
const char* sockname,
int use_tls ));
-LIBSLAPD_F (void) connection_closing LDAP_P(( Connection *c ));
-LIBSLAPD_F (int) connection_state_closing LDAP_P(( Connection *c ));
-LIBSLAPD_F (const char *) connection_state2str LDAP_P(( int state )) LDAP_GCCATTR((const));
+LDAP_SLAPD_F (void) connection_closing LDAP_P(( Connection *c ));
+LDAP_SLAPD_F (int) connection_state_closing LDAP_P(( Connection *c ));
+LDAP_SLAPD_F (const char *) connection_state2str LDAP_P(( int state )) LDAP_GCCATTR((const));
-LIBSLAPD_F (int) connection_write LDAP_P((ber_socket_t s));
-LIBSLAPD_F (int) connection_read LDAP_P((ber_socket_t s));
+LDAP_SLAPD_F (int) connection_write LDAP_P((ber_socket_t s));
+LDAP_SLAPD_F (int) connection_read LDAP_P((ber_socket_t s));
-LIBSLAPD_F (unsigned long) connections_nextid(void);
+LDAP_SLAPD_F (unsigned long) connections_nextid(void);
-LIBSLAPD_F (Connection *) connection_first LDAP_P((ber_socket_t *));
-LIBSLAPD_F (Connection *) connection_next LDAP_P((Connection *, ber_socket_t *));
-LIBSLAPD_F (void) connection_done LDAP_P((Connection *));
+LDAP_SLAPD_F (Connection *) connection_first LDAP_P((ber_socket_t *));
+LDAP_SLAPD_F (Connection *) connection_next LDAP_P((Connection *, ber_socket_t *));
+LDAP_SLAPD_F (void) connection_done LDAP_P((Connection *));
/*
* dn.c
*/
-LIBSLAPD_F (char *) dn_validate LDAP_P(( char *dn ));
-LIBSLAPD_F (char *) dn_normalize LDAP_P(( char *dn ));
-LIBSLAPD_F (char *) dn_parent LDAP_P(( Backend *be, const char *dn ));
-LIBSLAPD_F (char **) dn_subtree LDAP_P(( Backend *be, const char *dn ));
-LIBSLAPD_F (char *) dn_rdn LDAP_P(( Backend *be, const char *dn ));
-LIBSLAPD_F (int) dn_issuffix LDAP_P(( const char *dn, const char *suffix ));
-LIBSLAPD_F (int) rdn_validate LDAP_P(( const char* str ));
-LIBSLAPD_F (char *) rdn_attr_value LDAP_P(( const char * rdn ));
-LIBSLAPD_F (char *) rdn_attr_type LDAP_P(( const char * rdn ));
+LDAP_SLAPD_F (char *) dn_validate LDAP_P(( char *dn ));
+LDAP_SLAPD_F (char *) dn_normalize LDAP_P(( char *dn ));
+LDAP_SLAPD_F (char *) dn_parent LDAP_P(( Backend *be, const char *dn ));
+LDAP_SLAPD_F (char **) dn_subtree LDAP_P(( Backend *be, const char *dn ));
+LDAP_SLAPD_F (char *) dn_rdn LDAP_P(( Backend *be, const char *dn ));
+LDAP_SLAPD_F (int) dn_issuffix LDAP_P(( const char *dn, const char *suffix ));
+LDAP_SLAPD_F (int) rdn_validate LDAP_P(( const char* str ));
+LDAP_SLAPD_F (char *) rdn_attr_value LDAP_P(( const char * rdn ));
+LDAP_SLAPD_F (char *) rdn_attr_type LDAP_P(( const char * rdn ));
-LIBSLAPD_F (void) build_new_dn LDAP_P(( char ** new_dn,
+LDAP_SLAPD_F (void) build_new_dn LDAP_P(( char ** new_dn,
const char *e_dn,
const char * p_dn,
const char * newrdn ));
* entry.c
*/
-LIBSLAPD_F (int) entry_destroy LDAP_P((void));
+LDAP_SLAPD_F (int) entry_destroy LDAP_P((void));
-LIBSLAPD_F (Entry *) str2entry LDAP_P(( char *s ));
-LIBSLAPD_F (char *) entry2str LDAP_P(( Entry *e, int *len ));
-LIBSLAPD_F (void) entry_free LDAP_P(( Entry *e ));
+LDAP_SLAPD_F (Entry *) str2entry LDAP_P(( char *s ));
+LDAP_SLAPD_F (char *) entry2str LDAP_P(( Entry *e, int *len ));
+LDAP_SLAPD_F (void) entry_free LDAP_P(( Entry *e ));
-LIBSLAPD_F (int) entry_cmp LDAP_P(( Entry *a, Entry *b ));
-LIBSLAPD_F (int) entry_dn_cmp LDAP_P(( Entry *a, Entry *b ));
-LIBSLAPD_F (int) entry_id_cmp LDAP_P(( Entry *a, Entry *b ));
+LDAP_SLAPD_F (int) entry_cmp LDAP_P(( Entry *a, Entry *b ));
+LDAP_SLAPD_F (int) entry_dn_cmp LDAP_P(( Entry *a, Entry *b ));
+LDAP_SLAPD_F (int) entry_id_cmp LDAP_P(( Entry *a, Entry *b ));
/*
* extended.c
typedef int (*SLAP_EXTOP_GETOID_FN) LDAP_P((
int index, char *oid, int blen ));
-LIBSLAPD_F (int) load_extension LDAP_P((const void *module, const char *file_name));
-LIBSLAPD_F (char *) get_supported_extension LDAP_P((int index));
+LDAP_SLAPD_F (int) load_extension LDAP_P((const void *module, const char *file_name));
+LDAP_SLAPD_F (char *) get_supported_extension LDAP_P((int index));
-LIBSLAPD_F (int) load_extop LDAP_P((
+LDAP_SLAPD_F (int) load_extop LDAP_P((
const char *ext_oid,
SLAP_EXTOP_MAIN_FN ext_main ));
-LIBSLAPD_F (int) extops_init LDAP_P(( void ));
+LDAP_SLAPD_F (int) extops_init LDAP_P(( void ));
-LIBSLAPD_F (int) extops_kill LDAP_P(( void ));
+LDAP_SLAPD_F (int) extops_kill LDAP_P(( void ));
-LIBSLAPD_F (char *) get_supported_extop LDAP_P((int index));
+LDAP_SLAPD_F (char *) get_supported_extop LDAP_P((int index));
/*
* filter.c
*/
-LIBSLAPD_F (int) get_filter LDAP_P((
+LDAP_SLAPD_F (int) get_filter LDAP_P((
Connection *conn,
BerElement *ber,
Filter **filt,
char **fstr,
const char **text ));
-LIBSLAPD_F (void) filter_free LDAP_P(( Filter *f ));
-LIBSLAPD_F (void) filter_print LDAP_P(( Filter *f ));
+LDAP_SLAPD_F (void) filter_free LDAP_P(( Filter *f ));
+LDAP_SLAPD_F (void) filter_print LDAP_P(( Filter *f ));
/*
* filterentry.c
*/
-LIBSLAPD_F (int) test_filter LDAP_P((
+LDAP_SLAPD_F (int) test_filter LDAP_P((
Backend *be, Connection *conn, Operation *op, Entry *e, Filter *f ));
/*
* lock.c
*/
-LIBSLAPD_F (FILE *) lock_fopen LDAP_P(( const char *fname, const char *type, FILE **lfp ));
-LIBSLAPD_F (int) lock_fclose LDAP_P(( FILE *fp, FILE *lfp ));
+LDAP_SLAPD_F (FILE *) lock_fopen LDAP_P(( const char *fname, const char *type, FILE **lfp ));
+LDAP_SLAPD_F (int) lock_fclose LDAP_P(( FILE *fp, FILE *lfp ));
/*
* modify.c
* should be relocated to separate file
*/
-LIBSLAPD_F( void ) slap_mod_free LDAP_P(( Modification *mod, int freeit ));
-LIBSLAPD_F( void ) slap_mods_free LDAP_P(( Modifications *mods ));
-LIBSLAPD_F( void ) slap_modlist_free LDAP_P(( LDAPModList *ml ));
+LDAP_SLAPD_F( void ) slap_mod_free LDAP_P(( Modification *mod, int freeit ));
+LDAP_SLAPD_F( void ) slap_mods_free LDAP_P(( Modifications *mods ));
+LDAP_SLAPD_F( void ) slap_modlist_free LDAP_P(( LDAPModList *ml ));
-LIBSLAPD_F( int ) slap_modlist2mods(
+LDAP_SLAPD_F( int ) slap_modlist2mods(
LDAPModList *ml,
int update,
Modifications **mods,
const char **text );
-LIBSLAPD_F( int ) slap_mods_opattrs(
+LDAP_SLAPD_F( int ) slap_mods_opattrs(
Operation *op,
Modifications **modlist,
const char **text );
#ifdef SLAPD_MODULES
-LIBSLAPD_F (int) module_init LDAP_P(( void ));
-LIBSLAPD_F (int) module_kill LDAP_P(( void ));
+LDAP_SLAPD_F (int) module_init LDAP_P(( void ));
+LDAP_SLAPD_F (int) module_kill LDAP_P(( void ));
-LIBSLAPD_F (int) load_null_module(
+LDAP_SLAPD_F (int) load_null_module(
const void *module, const char *file_name);
-LIBSLAPD_F (int) load_extop_module(
+LDAP_SLAPD_F (int) load_extop_module(
const void *module, const char *file_name);
-LIBSLAPD_F (int) module_load LDAP_P((
+LDAP_SLAPD_F (int) module_load LDAP_P((
const char* file_name,
int argc, char *argv[] ));
-LIBSLAPD_F (int) module_path LDAP_P(( const char* path ));
+LDAP_SLAPD_F (int) module_path LDAP_P(( const char* path ));
-LIBSLAPD_F (void) *module_resolve LDAP_P((
+LDAP_SLAPD_F (void) *module_resolve LDAP_P((
const void *module, const char *name));
#endif /* SLAPD_MODULES */
/*
* monitor.c
*/
-LIBSLAPD_F (char *) supportedControls[];
+LDAP_SLAPD_F (char *) supportedControls[];
-LIBSLAPD_F (int) monitor_info LDAP_P((
+LDAP_SLAPD_F (int) monitor_info LDAP_P((
Entry **entry, const char **text ));
/*
* operation.c
*/
-LIBSLAPD_F (void) slap_op_free LDAP_P(( Operation *op ));
-LIBSLAPD_F (Operation *) slap_op_alloc LDAP_P((
+LDAP_SLAPD_F (void) slap_op_free LDAP_P(( Operation *op ));
+LDAP_SLAPD_F (Operation *) slap_op_alloc LDAP_P((
BerElement *ber, ber_int_t msgid,
ber_tag_t tag, ber_int_t id ));
-LIBSLAPD_F (int) slap_op_add LDAP_P(( Operation **olist, Operation *op ));
-LIBSLAPD_F (int) slap_op_remove LDAP_P(( Operation **olist, Operation *op ));
-LIBSLAPD_F (Operation *) slap_op_pop LDAP_P(( Operation **olist ));
+LDAP_SLAPD_F (int) slap_op_add LDAP_P(( Operation **olist, Operation *op ));
+LDAP_SLAPD_F (int) slap_op_remove LDAP_P(( Operation **olist, Operation *op ));
+LDAP_SLAPD_F (Operation *) slap_op_pop LDAP_P(( Operation **olist ));
/*
* phonetic.c
*/
-LIBSLAPD_F (char *) first_word LDAP_P(( char *s ));
-LIBSLAPD_F (char *) next_word LDAP_P(( char *s ));
-LIBSLAPD_F (char *) word_dup LDAP_P(( char *w ));
-LIBSLAPD_F (char *) phonetic LDAP_P(( char *s ));
+LDAP_SLAPD_F (char *) first_word LDAP_P(( char *s ));
+LDAP_SLAPD_F (char *) next_word LDAP_P(( char *s ));
+LDAP_SLAPD_F (char *) word_dup LDAP_P(( char *w ));
+LDAP_SLAPD_F (char *) phonetic LDAP_P(( char *s ));
/*
* repl.c
*/
-LIBSLAPD_F (void) replog LDAP_P(( Backend *be, Operation *op, char *dn, void *change ));
+LDAP_SLAPD_F (void) replog LDAP_P(( Backend *be, Operation *op, char *dn, void *change ));
/*
* result.c
*/
-LIBSLAPD_F (struct berval **) get_entry_referrals LDAP_P((
+LDAP_SLAPD_F (struct berval **) get_entry_referrals LDAP_P((
Backend *be, Connection *conn, Operation *op,
Entry *e ));
-LIBSLAPD_F (void) send_ldap_result LDAP_P((
+LDAP_SLAPD_F (void) send_ldap_result LDAP_P((
Connection *conn, Operation *op,
ber_int_t err, const char *matched, const char *text,
struct berval **refs,
LDAPControl **ctrls ));
-LIBSLAPD_F (void) send_ldap_sasl LDAP_P((
+LDAP_SLAPD_F (void) send_ldap_sasl LDAP_P((
Connection *conn, Operation *op,
ber_int_t err, const char *matched,
const char *text,
LDAPControl **ctrls,
struct berval *cred ));
-LIBSLAPD_F (void) send_ldap_disconnect LDAP_P((
+LDAP_SLAPD_F (void) send_ldap_disconnect LDAP_P((
Connection *conn, Operation *op,
ber_int_t err, const char *text ));
-LIBSLAPD_F (void) send_ldap_extended LDAP_P((
+LDAP_SLAPD_F (void) send_ldap_extended LDAP_P((
Connection *conn, Operation *op,
ber_int_t err, const char *matched,
const char *text, struct berval **refs,
const char *rspoid, struct berval *rspdata,
LDAPControl **ctrls ));
-LIBSLAPD_F (void) send_ldap_partial LDAP_P((
+LDAP_SLAPD_F (void) send_ldap_partial LDAP_P((
Connection *conn, Operation *op,
const char *rspoid, struct berval *rspdata,
LDAPControl **ctrls ));
-LIBSLAPD_F (void) send_search_result LDAP_P((
+LDAP_SLAPD_F (void) send_search_result LDAP_P((
Connection *conn, Operation *op,
ber_int_t err, const char *matched, const char *text,
struct berval **refs,
LDAPControl **ctrls,
int nentries ));
-LIBSLAPD_F (int) send_search_reference LDAP_P((
+LDAP_SLAPD_F (int) send_search_reference LDAP_P((
Backend *be, Connection *conn, Operation *op,
Entry *e, struct berval **refs, int scope,
LDAPControl **ctrls,
struct berval ***v2refs ));
-LIBSLAPD_F (int) send_search_entry LDAP_P((
+LDAP_SLAPD_F (int) send_search_entry LDAP_P((
Backend *be, Connection *conn, Operation *op,
Entry *e, char **attrs, int attrsonly,
LDAPControl **ctrls ));
-LIBSLAPD_F (int) str2result LDAP_P(( char *s,
+LDAP_SLAPD_F (int) str2result LDAP_P(( char *s,
int *code, char **matched, char **info ));
/*
* sasl.c
*/
-LIBSLAPD_F (char **) supportedSASLMechanisms;
+LDAP_SLAPD_F (char **) supportedSASLMechanisms;
-LIBSLAPD_F (int) sasl_init(void);
-LIBSLAPD_F (int) sasl_destroy(void);
-LIBSLAPD_F (int) sasl_errldap LDAP_P(( int ));
-LIBSLAPD_F (int) sasl_bind LDAP_P((
+LDAP_SLAPD_F (int) sasl_init(void);
+LDAP_SLAPD_F (int) sasl_destroy(void);
+LDAP_SLAPD_F (int) sasl_errldap LDAP_P(( int ));
+LDAP_SLAPD_F (int) sasl_bind LDAP_P((
Connection *conn, Operation *op,
const char *dn, const char *ndn,
const char *mech, struct berval *cred,
char **edn ));
/* oc.c */
-LIBSLAPD_F (int) oc_schema_info( Entry *e );
+LDAP_SLAPD_F (int) oc_schema_info( Entry *e );
/* mr.c */
-LIBSLAPD_F (int) mr_schema_info( Entry *e );
+LDAP_SLAPD_F (int) mr_schema_info( Entry *e );
/* syntax.c */
-LIBSLAPD_F (int) syn_schema_info( Entry *e );
+LDAP_SLAPD_F (int) syn_schema_info( Entry *e );
/*
* schema.c
*/
-LIBSLAPD_F (ObjectClass *) oc_find LDAP_P((
+LDAP_SLAPD_F (ObjectClass *) oc_find LDAP_P((
const char *ocname));
-LIBSLAPD_F (int) oc_add LDAP_P((
+LDAP_SLAPD_F (int) oc_add LDAP_P((
LDAP_OBJECT_CLASS *oc,
const char **err));
-LIBSLAPD_F (int) is_object_subclass LDAP_P((
+LDAP_SLAPD_F (int) is_object_subclass LDAP_P((
ObjectClass *sub,
ObjectClass *sup ));
-LIBSLAPD_F (Syntax *) syn_find LDAP_P((const char *synname));
-LIBSLAPD_F (Syntax *) syn_find_desc LDAP_P((const char *syndesc, int *slen));
+LDAP_SLAPD_F (Syntax *) syn_find LDAP_P((const char *synname));
+LDAP_SLAPD_F (Syntax *) syn_find_desc LDAP_P((const char *syndesc, int *slen));
#ifdef SLAPD_BINARY_CONVERSION
-LIBSLAPD_F (int) syn_add LDAP_P((
+LDAP_SLAPD_F (int) syn_add LDAP_P((
LDAP_SYNTAX *syn,
unsigned flags,
slap_syntax_validate_func *validate,
slap_syntax_transform_func *str2ber,
const char **err));
#else
-LIBSLAPD_F (int) syn_add LDAP_P((
+LDAP_SLAPD_F (int) syn_add LDAP_P((
LDAP_SYNTAX *syn,
unsigned flags,
slap_syntax_validate_func *validate,
const char **err));
#endif
-LIBSLAPD_F (MatchingRule *) mr_find LDAP_P((const char *mrname));
-LIBSLAPD_F (int) mr_add LDAP_P((LDAP_MATCHING_RULE *mr,
+LDAP_SLAPD_F (MatchingRule *) mr_find LDAP_P((const char *mrname));
+LDAP_SLAPD_F (int) mr_add LDAP_P((LDAP_MATCHING_RULE *mr,
unsigned usage,
slap_mr_convert_func *convert,
slap_mr_normalize_func *normalize,
slap_mr_filter_func *filter,
const char **err));
-LIBSLAPD_F (int) register_syntax LDAP_P((
+LDAP_SLAPD_F (int) register_syntax LDAP_P((
char *desc,
unsigned flags,
slap_syntax_validate_func *validate,
slap_syntax_transform_func *ber2str,
slap_syntax_transform_func *str2ber ));
-LIBSLAPD_F (int) register_matching_rule LDAP_P((
+LDAP_SLAPD_F (int) register_matching_rule LDAP_P((
char * desc,
unsigned usage,
slap_mr_convert_func *convert,
slap_mr_indexer_func *indexer,
slap_mr_filter_func *filter ));
-LIBSLAPD_F (int) schema_info LDAP_P(( Entry **entry, const char **text ));
+LDAP_SLAPD_F (int) schema_info LDAP_P(( Entry **entry, const char **text ));
-LIBSLAPD_F (int) is_entry_objectclass LDAP_P((
+LDAP_SLAPD_F (int) is_entry_objectclass LDAP_P((
Entry *, ObjectClass *oc ));
#define is_entry_alias(e) is_entry_objectclass((e), slap_schema.si_oc_alias)
#define is_entry_referral(e) is_entry_objectclass((e), slap_schema.si_oc_referral)
int oc_check_allowed(
AttributeType *type,
struct berval **oclist );
-LIBSLAPD_F (int) entry_schema_check LDAP_P((
+LDAP_SLAPD_F (int) entry_schema_check LDAP_P((
Entry *e, Attribute *attrs,
const char** text ));
/*
* schema_init.c
*/
-LIBSLAPD_F (int) schema_init LDAP_P((void));
-LIBSLAPD_F (int) schema_prep LDAP_P((void));
+LDAP_SLAPD_F (int) schema_init LDAP_P((void));
+LDAP_SLAPD_F (int) schema_prep LDAP_P((void));
/*
* schemaparse.c
*/
-LIBSLAPD_F (void) parse_oc_old LDAP_P(( Backend *be, const char *fname, int lineno, int argc, char **argv ));
-LIBSLAPD_F (void) parse_oc LDAP_P(( const char *fname, int lineno, char *line, char **argv ));
-LIBSLAPD_F (void) parse_at LDAP_P(( const char *fname, int lineno, char *line, char **argv ));
-LIBSLAPD_F (void) parse_oidm LDAP_P(( const char *fname, int lineno, int argc, char **argv ));
-LIBSLAPD_F (char *) scherr2str LDAP_P((int code)) LDAP_GCCATTR((const));
-LIBSLAPD_F (int) dscompare LDAP_P(( const char *s1, const char *s2del, char delim ));
+LDAP_SLAPD_F (void) parse_oc_old LDAP_P(( Backend *be, const char *fname, int lineno, int argc, char **argv ));
+LDAP_SLAPD_F (void) parse_oc LDAP_P(( const char *fname, int lineno, char *line, char **argv ));
+LDAP_SLAPD_F (void) parse_at LDAP_P(( const char *fname, int lineno, char *line, char **argv ));
+LDAP_SLAPD_F (void) parse_oidm LDAP_P(( const char *fname, int lineno, int argc, char **argv ));
+LDAP_SLAPD_F (char *) scherr2str LDAP_P((int code)) LDAP_GCCATTR((const));
+LDAP_SLAPD_F (int) dscompare LDAP_P(( const char *s1, const char *s2del, char delim ));
/*
* starttls.c
*/
-LIBSLAPD_F (int) starttls_extop LDAP_P((
+LDAP_SLAPD_F (int) starttls_extop LDAP_P((
SLAP_EXTOP_CALLBACK_FN,
Connection *conn, Operation *op,
const char * reqoid,
* str2filter.c
*/
-LIBSLAPD_F (Filter *) str2filter LDAP_P(( const char *str ));
+LDAP_SLAPD_F (Filter *) str2filter LDAP_P(( const char *str ));
/*
* suffixalias.c
*/
-LIBSLAPD_F (char *) suffix_alias LDAP_P(( Backend *be, char *ndn ));
+LDAP_SLAPD_F (char *) suffix_alias LDAP_P(( Backend *be, char *ndn ));
/*
* value.c
*/
-LIBSLAPD_F (int) value_normalize LDAP_P((
+LDAP_SLAPD_F (int) value_normalize LDAP_P((
AttributeDescription *ad,
unsigned usage,
struct berval *in,
struct berval **out,
const char ** text ));
-LIBSLAPD_F (int) value_match LDAP_P((
+LDAP_SLAPD_F (int) value_match LDAP_P((
int *match,
AttributeDescription *ad,
MatchingRule *mr,
struct berval *v1,
void *v2,
const char ** text ));
-LIBSLAPD_F (int) value_find LDAP_P((
+LDAP_SLAPD_F (int) value_find LDAP_P((
AttributeDescription *ad,
struct berval **values,
struct berval *value ));
-LIBSLAPD_F (int) value_add LDAP_P(( struct berval ***vals, struct berval **addvals ));
+LDAP_SLAPD_F (int) value_add LDAP_P(( struct berval ***vals, struct berval **addvals ));
/*
* user.c
*/
#if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
-LIBSLAPD_F (void) slap_init_user LDAP_P(( char *username, char *groupname ));
+LDAP_SLAPD_F (void) slap_init_user LDAP_P(( char *username, char *groupname ));
#endif
/*
* passwd.c
*/
-LIBSLAPD_F (int) passwd_extop LDAP_P((
+LDAP_SLAPD_F (int) passwd_extop LDAP_P((
SLAP_EXTOP_CALLBACK_FN,
Connection *conn, Operation *op,
const char * reqoid,
const char ** text,
struct berval *** refs ));
-LIBSLAPD_F (int) slap_passwd_check(
+LDAP_SLAPD_F (int) slap_passwd_check(
Attribute *attr,
struct berval *cred );
-LIBSLAPD_F (struct berval *) slap_passwd_generate( void );
+LDAP_SLAPD_F (struct berval *) slap_passwd_generate( void );
-LIBSLAPD_F (struct berval *) slap_passwd_hash(
+LDAP_SLAPD_F (struct berval *) slap_passwd_hash(
struct berval *cred );
-LIBSLAPD_F (struct berval *) slap_passwd_return(
+LDAP_SLAPD_F (struct berval *) slap_passwd_return(
struct berval *cred );
-LIBSLAPD_F (int) slap_passwd_parse(
+LDAP_SLAPD_F (int) slap_passwd_parse(
struct berval *reqdata,
struct berval **id,
struct berval **oldpass,
*/
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
extern char *ldap_srvtab;
-LIBSLAPD_F (int) krbv4_ldap_auth();
+LDAP_SLAPD_F (int) krbv4_ldap_auth();
#endif
/*
* Other...
*/
-LIBSLAPD_F (struct berval **) default_referral;
-LIBSLAPD_F (char *) replogfile;
-LIBSLAPD_F (const char) Versionstr[];
-LIBSLAPD_F (int) defsize;
-LIBSLAPD_F (int) deftime;
-LIBSLAPD_F (int) g_argc;
-LIBSLAPD_F (slap_access_t) global_default_access;
-LIBSLAPD_F (int) global_readonly;
-LIBSLAPD_F (int) global_lastmod;
-LIBSLAPD_F (int) global_idletimeout;
-LIBSLAPD_F (int) global_schemacheck;
-LIBSLAPD_F (char) *global_realm;
-LIBSLAPD_F (char) *default_passwd_hash;
-LIBSLAPD_F (int) lber_debug;
-LIBSLAPD_F (int) ldap_syslog;
-
-LIBSLAPD_F (ldap_pvt_thread_mutex_t) num_sent_mutex;
-LIBSLAPD_F (long) num_bytes_sent;
-LIBSLAPD_F (long) num_pdu_sent;
-LIBSLAPD_F (long) num_entries_sent;
-LIBSLAPD_F (long) num_refs_sent;
-
-LIBSLAPD_F (ldap_pvt_thread_mutex_t) num_ops_mutex;
-LIBSLAPD_F (long) num_ops_completed;
-LIBSLAPD_F (long) num_ops_initiated;
-
-LIBSLAPD_F (char *) slapd_pid_file;
-LIBSLAPD_F (char *) slapd_args_file;
-LIBSLAPD_F (char) **g_argv;
-LIBSLAPD_F (time_t) starttime;
-
-LIBSLAPD_F (time_t) slap_get_time LDAP_P((void));
-
-LIBSLAPD_F (ldap_pvt_thread_pool_t) connection_pool;
-
-LIBSLAPD_F (ldap_pvt_thread_mutex_t) entry2str_mutex;
-LIBSLAPD_F (ldap_pvt_thread_mutex_t) replog_mutex;
+LDAP_SLAPD_F (struct berval **) default_referral;
+LDAP_SLAPD_F (char *) replogfile;
+LDAP_SLAPD_F (const char) Versionstr[];
+LDAP_SLAPD_F (int) defsize;
+LDAP_SLAPD_F (int) deftime;
+LDAP_SLAPD_F (int) g_argc;
+LDAP_SLAPD_F (slap_access_t) global_default_access;
+LDAP_SLAPD_F (int) global_readonly;
+LDAP_SLAPD_F (int) global_lastmod;
+LDAP_SLAPD_F (int) global_idletimeout;
+LDAP_SLAPD_F (int) global_schemacheck;
+LDAP_SLAPD_F (char) *global_realm;
+LDAP_SLAPD_F (char) *default_passwd_hash;
+LDAP_SLAPD_F (int) lber_debug;
+LDAP_SLAPD_F (int) ldap_syslog;
+
+LDAP_SLAPD_F (ldap_pvt_thread_mutex_t) num_sent_mutex;
+LDAP_SLAPD_F (long) num_bytes_sent;
+LDAP_SLAPD_F (long) num_pdu_sent;
+LDAP_SLAPD_F (long) num_entries_sent;
+LDAP_SLAPD_F (long) num_refs_sent;
+
+LDAP_SLAPD_F (ldap_pvt_thread_mutex_t) num_ops_mutex;
+LDAP_SLAPD_F (long) num_ops_completed;
+LDAP_SLAPD_F (long) num_ops_initiated;
+
+LDAP_SLAPD_F (char *) slapd_pid_file;
+LDAP_SLAPD_F (char *) slapd_args_file;
+LDAP_SLAPD_F (char) **g_argv;
+LDAP_SLAPD_F (time_t) starttime;
+
+LDAP_SLAPD_F (time_t) slap_get_time LDAP_P((void));
+
+LDAP_SLAPD_F (ldap_pvt_thread_pool_t) connection_pool;
+
+LDAP_SLAPD_F (ldap_pvt_thread_mutex_t) entry2str_mutex;
+LDAP_SLAPD_F (ldap_pvt_thread_mutex_t) replog_mutex;
#ifdef SLAPD_CRYPT
-LIBSLAPD_F (ldap_pvt_thread_mutex_t) crypt_mutex;
+LDAP_SLAPD_F (ldap_pvt_thread_mutex_t) crypt_mutex;
#endif
-LIBSLAPD_F (ldap_pvt_thread_mutex_t) gmtime_mutex;
+LDAP_SLAPD_F (ldap_pvt_thread_mutex_t) gmtime_mutex;
-LIBSLAPD_F (AccessControl *) global_acl;
+LDAP_SLAPD_F (AccessControl *) global_acl;
-LIBSLAPD_F (int) slap_init LDAP_P((int mode, const char* name));
-LIBSLAPD_F (int) slap_startup LDAP_P(( Backend *be ));
-LIBSLAPD_F (int) slap_shutdown LDAP_P(( Backend *be ));
-LIBSLAPD_F (int) slap_destroy LDAP_P((void));
+LDAP_SLAPD_F (int) slap_init LDAP_P((int mode, const char* name));
+LDAP_SLAPD_F (int) slap_startup LDAP_P(( Backend *be ));
+LDAP_SLAPD_F (int) slap_shutdown LDAP_P(( Backend *be ));
+LDAP_SLAPD_F (int) slap_destroy LDAP_P((void));
struct sockaddr_in;
-LIBSLAPD_F (int) slapd_daemon_init( const char *urls );
-LIBSLAPD_F (int) slapd_daemon_destroy(void);
-LIBSLAPD_F (int) slapd_daemon(void);
+LDAP_SLAPD_F (int) slapd_daemon_init( const char *urls );
+LDAP_SLAPD_F (int) slapd_daemon_destroy(void);
+LDAP_SLAPD_F (int) slapd_daemon(void);
-LIBSLAPD_F (void) slapd_set_write LDAP_P((ber_socket_t s, int wake));
-LIBSLAPD_F (void) slapd_clr_write LDAP_P((ber_socket_t s, int wake));
-LIBSLAPD_F (void) slapd_set_read LDAP_P((ber_socket_t s, int wake));
-LIBSLAPD_F (void) slapd_clr_read LDAP_P((ber_socket_t s, int wake));
+LDAP_SLAPD_F (void) slapd_set_write LDAP_P((ber_socket_t s, int wake));
+LDAP_SLAPD_F (void) slapd_clr_write LDAP_P((ber_socket_t s, int wake));
+LDAP_SLAPD_F (void) slapd_set_read LDAP_P((ber_socket_t s, int wake));
+LDAP_SLAPD_F (void) slapd_clr_read LDAP_P((ber_socket_t s, int wake));
-LIBSLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, int wake));
+LDAP_SLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, int wake));
-LIBSLAPD_F (RETSIGTYPE) slap_sig_shutdown LDAP_P((int sig));
-LIBSLAPD_F (RETSIGTYPE) slap_sig_wake LDAP_P((int sig));
+LDAP_SLAPD_F (RETSIGTYPE) slap_sig_shutdown LDAP_P((int sig));
+LDAP_SLAPD_F (RETSIGTYPE) slap_sig_wake LDAP_P((int sig));
-LIBSLAPD_F (int) config_info LDAP_P((
+LDAP_SLAPD_F (int) config_info LDAP_P((
Entry **e, const char **text ));
-LIBSLAPD_F (int) root_dse_info LDAP_P((
+LDAP_SLAPD_F (int) root_dse_info LDAP_P((
Entry **e, const char **text ));
-LIBSLAPD_F (int) do_abandon LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_add LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_bind LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_compare LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_delete LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_modify LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_modrdn LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_search LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_unbind LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (int) do_extended LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_abandon LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_add LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_bind LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_compare LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_delete LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_modify LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_modrdn LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_search LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_unbind LDAP_P((Connection *conn, Operation *op));
+LDAP_SLAPD_F (int) do_extended LDAP_P((Connection *conn, Operation *op));
-LIBSLAPD_F (ber_socket_t) dtblsize;
+LDAP_SLAPD_F (ber_socket_t) dtblsize;
LDAP_END_DECL
#define SLAPD_ACI_SYNTAX "1.3.6.1.4.1.4203.666.2.1"
#define SLAPD_ACI_ATTR "OpenLDAPaci"
-LIBSLAPD_F (int) slap_debug;
+LDAP_SLAPD_F (int) slap_debug;
/*
* Index types
typedef struct slap_backend_info BackendInfo; /* per backend type */
typedef struct slap_backend_db BackendDB; /* per backend database */
-LIBSLAPD_F (int) nBackendInfo;
-LIBSLAPD_F (int) nBackendDB;
-LIBSLAPD_F (BackendInfo *) backendInfo;
-LIBSLAPD_F (BackendDB *) backendDB;
+LDAP_SLAPD_F (int) nBackendInfo;
+LDAP_SLAPD_F (int) nBackendDB;
+LDAP_SLAPD_F (BackendInfo *) backendInfo;
+LDAP_SLAPD_F (BackendDB *) backendDB;
-LIBSLAPD_F (int) slapMode;
+LDAP_SLAPD_F (int) slapMode;
#define SLAP_UNDEFINED_MODE 0x0000
#define SLAP_SERVER_MODE 0x0001
#define SLAP_TOOL_MODE 0x0002
QUIPUPROGRAMS=chlog2replog edb2ldif
# CPPFLAGS will include the defines for dynamic libs in Mingw32.
-NT_DYN_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
+NT_DYN_DEFS = -DLBER_DECL=dllimport -DLDAP_DECL=dllimport
CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_DEFS)
SRCS = ldif.c mimic.c slapcommon.c slapadd.c slapcat.c slapindex.c
projects / openldap / commitdiff