Round one of LDAP_F() macro changes. In this round we rename

macros into our namespace and limit use to headers.  A subsequent
round will add macros to separately handle forward declarations
of variables from declaration of function prototypes.  The last
round will add additional macros for declaring actual variables and
functions.
This commit is contained in:
Kurt Zeilenga 2000-06-18 19:48:07 +00:00
parent a8144d55ed
commit 9ef1a740c2
44 changed files with 826 additions and 819 deletions

View File

@ -8,7 +8,7 @@ OBJS = ldapsearch.o ldapmodify.o ldapdelete.o ldapmodrdn.o ldappasswd.o
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

View File

@ -11,7 +11,7 @@ PROGRAMS= ud
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

View File

@ -25,8 +25,8 @@
# 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

View File

@ -19,10 +19,10 @@
# 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 */

View File

@ -148,7 +148,7 @@ LIBLBER_F (char *) ber_pvt_wsa_err2string LDAP_P((int));
#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)

View File

@ -43,7 +43,7 @@
#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
@ -52,7 +52,7 @@ LIBLDAP_F(char *) ldap_pvt_strtok LDAP_P(( char *str, const char *delim,
# define strdup(s) ber_strdup(s)
#else
/* some systems fail to declare strdup */
LIBC_F(char *) (strdup)();
LDAP_LIBC_F(char *) (strdup)();
#endif
/*

View File

@ -28,11 +28,11 @@
/* 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
@ -50,13 +50,14 @@ LIBLUTIL_F(char*)(lutil_getpass) LDAP_P((const char *getpass));
#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 */

View File

@ -61,39 +61,39 @@ typedef int (*AVL_CMP) LDAP_P((const void*, const void*));
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 */

View File

@ -225,88 +225,88 @@ struct ldap_disptmpl {
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,

View File

@ -25,10 +25,9 @@ LDAP_BEGIN_DECL
#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

View File

@ -202,19 +202,19 @@ typedef struct berval {
/*
* 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 ));
@ -227,74 +227,74 @@ typedef int (*BERDecodeCallback) LDAP_P((
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,
@ -307,74 +307,74 @@ typedef int (*BEREncodeCallback) LDAP_P((
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,
@ -385,65 +385,65 @@ ber_printf LDAP_P((
* 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 ));
@ -452,13 +452,13 @@ ber_flatten LDAP_P((
* 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,
@ -468,97 +468,97 @@ ber_set_option LDAP_P((
* 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

View File

@ -30,9 +30,9 @@ typedef struct sockbuf_buf {
/*
* 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,
@ -42,22 +42,22 @@ ber_pvt_log_printf LDAP_P((
/*
* 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

File diff suppressed because it is too large Load Diff

View File

@ -21,7 +21,7 @@
# 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++ */
@ -57,6 +57,20 @@
/* 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
@ -64,58 +78,51 @@
*/
#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
#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
#else
# define LIBLDAP_F(type) extern type
# define LDAP_AVL_F(type) extern type
#endif
/* LDBM library */
#if defined(LIBLDBM_DECL) && defined(_WIN32)
# define LIBLDBM_F(type) extern __declspec(LIBLDBM_DECL) type
#if defined(LDAP_LDBM_DECL) && defined(_WIN32)
# define LDAP_LDBM_F(type) extern __declspec(LDAP_LDBM_DECL) type
#else
# define LIBLDBM_F(type) extern type
# define LDAP_LDBM_F(type) extern type
#endif
/* LDIF library */
#if defined(LIBLDIF_DECL) && defined(_WIN32)
# define LIBLDIF_F(type) extern __declspec(LIBLDIF_DECL) type
#if defined(LDAP_LDIF_DECL) && defined(_WIN32)
# define LDAP_LDIF_F(type) extern __declspec(LDAP_LDIF_DECL) type
#else
# define LIBLDIF_F(type) extern type
# define LDAP_LDIF_F(type) extern type
#endif
/* LUNICODE library */
#if defined(LDAP_LUNICODE_DECL) && defined(_WIN32)
# define LDAP_LUNICODE_F(type) extern __declspec(LDAP_LUNICODE_DECL) type
#else
# 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 */

View File

@ -187,10 +187,10 @@ LDAP_END_DECL
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;

View File

@ -78,7 +78,7 @@ extern int ldap_syslog_level;
#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)));

View File

@ -25,27 +25,27 @@ LDAP_BEGIN_DECL
#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,
@ -53,7 +53,7 @@ ldap_pvt_gethostbyname_a LDAP_P((
struct hostent **result,
int *herrno_ptr ));
LIBLDAP_F( int )
LDAP_F( int )
ldap_pvt_gethostbyaddr_a LDAP_P((
const char *addr,
int len,
@ -66,35 +66,35 @@ ldap_pvt_gethostbyaddr_a LDAP_P((
/* 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) == ';')
@ -123,45 +123,45 @@ LIBLDAP_F (int) ldap_pvt_unhex( int 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)
@ -172,39 +172,39 @@ typedef short ldap_ucs2_t;
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 )

View File

@ -22,111 +22,111 @@ typedef ldap_int_thread_t ldap_pvt_thread_t;
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 */
@ -135,23 +135,23 @@ ldap_pvt_thread_rdwr_active LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
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 ));

View File

@ -107,83 +107,83 @@ typedef struct ldap_objectclass {
#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));

View File

@ -236,25 +236,25 @@ LDAP_END_DECL
LDAP_BEGIN_DECL
LIBLDBM_F (int) ldbm_initialize( void );
LIBLDBM_F (int) ldbm_shutdown( void );
LDAP_LDBM_F (int) ldbm_initialize( void );
LDAP_LDBM_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 );
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 );
LIBLDBM_F (Datum) ldbm_firstkey( LDBM ldbm, LDBMCursor **cursor );
LIBLDBM_F (Datum) ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *cursor );
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)

View File

@ -28,7 +28,7 @@
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 */
@ -49,23 +49,23 @@ LIBLDIF_F (int) ldif_debug;
((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,
@ -83,7 +83,7 @@ ldif_read_record LDAP_P((
#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,
@ -91,14 +91,14 @@ ldif_sput LDAP_P((
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 ));

View File

@ -30,27 +30,27 @@ LDAP_BEGIN_DECL
/* 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 ));
@ -58,13 +58,13 @@ lutil_entropy LDAP_P((
/* 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 */
@ -73,36 +73,36 @@ lutil_authpasswd_hash LDAP_P((
#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

View File

@ -19,10 +19,10 @@
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

View File

@ -32,22 +32,22 @@ struct lutil_MD5Context {
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]));

View File

@ -35,31 +35,31 @@ typedef struct {
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 *));

View File

@ -78,22 +78,22 @@ struct ldap_searchobj {
#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 ));

View File

@ -27,7 +27,7 @@ XXLIBS =
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)

View File

@ -24,7 +24,7 @@
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;
@ -37,7 +37,7 @@ struct lber_options {
#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 {
@ -100,21 +100,21 @@ int ber_realloc LDAP_P((
*/
#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,
@ -123,7 +123,7 @@ ber_log_sos_dump LDAP_P((
/* 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
@ -158,19 +158,19 @@ LIBLBER_F (BerMemoryFunctions *) ber_int_memory_fns;
/* 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

View File

@ -39,8 +39,8 @@ XXLIBS = $(SECURITY_LIBS) $(TLS_LIBS)
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)

View File

@ -401,7 +401,7 @@ ldap_control_dup( const LDAPControl *c )
SHOULD be freed by calling ldap_control_free() when done.
---*/
LIBLDAP_F( int )
int
ldap_int_create_control(
const char *requestOID,
BerElement *ber,

View File

@ -316,9 +316,9 @@ extern ldap_pvt_thread_mutex_t ldap_int_resolv_mutex;
* 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 */
@ -340,41 +340,41 @@ LIBLDAP_F ( void ) ldap_int_initialize_global_options LDAP_P((
/*
* 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,
@ -384,13 +384,13 @@ ldap_int_create_control LDAP_P((
/*
* 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,
@ -402,67 +402,67 @@ LIBLDAP_F (char *) ldap_get_kerberosv4_credentials LDAP_P((
/*
* 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 );
LDAP_F (BerElement *) ldap_alloc_ber_with_options( LDAP *ld );
LDAP_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 (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,
@ -482,13 +482,13 @@ LIBLDAP_F (BerElement *) ldap_build_search_req LDAP_P((
/*
* 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,
@ -497,27 +497,27 @@ LIBLDAP_F (int) ldap_send_unbind LDAP_P((
/*
* 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 ));

View File

@ -591,7 +591,7 @@ ldap_set_option(
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));

View File

@ -578,7 +578,7 @@ ldap_free_request( LDAP *ld, LDAPRequest *lr )
*
* 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;

View File

@ -171,7 +171,7 @@ static int readNextKey( char **pNextKey, LDAPSortKey **key)
---------------------------------------------------------------------------*/
LIBLDAP_F(int)
int
ldap_create_sort_keylist ( LDAPSortKey ***sortKeyList, char *keyString )
{
int numKeys, rc, i;
@ -221,7 +221,7 @@ ldap_create_sort_keylist ( LDAPSortKey ***sortKeyList, char *keyString )
keyList (IN) Points to an array of pointers to LDAPSortKey structures.
---------------------------------------------------------------------------*/
LIBLDAP_F(void)
void
ldap_free_sort_keylist ( LDAPSortKey **keyList )
{
int i;
@ -276,7 +276,7 @@ ldap_free_sort_keylist ( LDAPSortKey **keyList )
---------------------------------------------------------------------------*/
LIBLDAP_F( int )
int
ldap_create_sort_control (
LDAP *ld,
LDAPSortKey **keyList,
@ -391,7 +391,7 @@ exit:
attributeType [0] AttributeDescription OPTIONAL }
---------------------------------------------------------------------------*/
LIBLDAP_F( int )
int
ldap_parse_sort_control(
LDAP *ld,
LDAPControl **ctrls,

View File

@ -72,7 +72,7 @@
---*/
LIBLDAP_F( int )
int
ldap_create_vlv_control( LDAP *ld,
LDAPVLVInfo *vlvinfop,
LDAPControl **ctrlp )
@ -188,7 +188,7 @@ exit:
---*/
LIBLDAP_F( int )
int
ldap_parse_vlv_control(
LDAP *ld,
LDAPControl **ctrls,

View File

@ -48,8 +48,8 @@ XXXLIBS = $(LTHREAD_LIBS)
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)

View File

@ -13,7 +13,7 @@ OBJS = ldbm.o
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

View File

@ -12,6 +12,6 @@ OBJS = line64.o fetch.o
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)

View File

@ -24,7 +24,7 @@ OBJS = base64.o debug.o entropy.o \
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.

View File

@ -52,7 +52,7 @@ BUILD_SRV = @BUILD_SLAPD@
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)

View File

@ -18,7 +18,7 @@ BUILD_OPT = "--enable-ldbm"
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 =

View File

@ -10,34 +10,34 @@
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 ));
@ -45,48 +45,48 @@ LIBSLAPD_F (int) ad_inlist LDAP_P((
* 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 ));
@ -97,29 +97,29 @@ LIBSLAPD_F (int) is_at_syntax LDAP_P((
* 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 ));
@ -127,45 +127,45 @@ LIBSLAPD_F (void) ava_free LDAP_P((
* 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,
@ -173,7 +173,7 @@ LIBSLAPD_F (int) backend_group LDAP_P((Backend *be,
AttributeDescription *group_at
));
LIBSLAPD_F (Attribute *) backend_operational( Backend *, Entry * );
LDAP_SLAPD_F (Attribute *) backend_operational( Backend *, Entry * );
@ -189,11 +189,11 @@ LIBSLAPD_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
@ -205,45 +205,45 @@ LIBSLAPD_F (void) ch_free LDAP_P(( void * ));
* 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,
@ -251,34 +251,34 @@ LIBSLAPD_F (long) connection_init LDAP_P((
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 ));
@ -286,15 +286,15 @@ LIBSLAPD_F (void) build_new_dn LDAP_P(( char ** new_dn,
* 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
@ -324,63 +324,63 @@ typedef int (*SLAP_EXTOP_MAIN_FN) LDAP_P((
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 );
@ -391,20 +391,20 @@ LIBSLAPD_F( int ) slap_mods_opattrs(
#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 */
@ -412,54 +412,54 @@ LIBSLAPD_F (void) *module_resolve LDAP_P((
/*
* 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,
@ -467,86 +467,86 @@ LIBSLAPD_F (void) send_ldap_sasl LDAP_P((
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,
@ -556,7 +556,7 @@ LIBSLAPD_F (int) syn_add LDAP_P((
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,
@ -565,8 +565,8 @@ LIBSLAPD_F (int) syn_add LDAP_P((
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,
@ -575,14 +575,14 @@ LIBSLAPD_F (int) mr_add LDAP_P((LDAP_MATCHING_RULE *mr,
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,
@ -591,9 +591,9 @@ LIBSLAPD_F (int) register_matching_rule LDAP_P((
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)
@ -605,7 +605,7 @@ LIBSLAPD_F (int) is_entry_objectclass LDAP_P((
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 ));
@ -613,27 +613,27 @@ LIBSLAPD_F (int) entry_schema_check LDAP_P((
/*
* 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,
@ -649,46 +649,46 @@ LIBSLAPD_F (int) starttls_extop LDAP_P((
* 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,
@ -699,19 +699,19 @@ LIBSLAPD_F (int) passwd_extop LDAP_P((
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,
@ -723,98 +723,98 @@ LIBSLAPD_F (int) slap_passwd_parse(
*/
#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;
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;
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;
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;
LIBSLAPD_F (ldap_pvt_thread_mutex_t) num_ops_mutex;
LIBSLAPD_F (long) num_ops_completed;
LIBSLAPD_F (long) num_ops_initiated;
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;
LIBSLAPD_F (char *) slapd_pid_file;
LIBSLAPD_F (char *) slapd_args_file;
LIBSLAPD_F (char) **g_argv;
LIBSLAPD_F (time_t) starttime;
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;
LIBSLAPD_F (time_t) slap_get_time LDAP_P((void));
LDAP_SLAPD_F (time_t) slap_get_time LDAP_P((void));
LIBSLAPD_F (ldap_pvt_thread_pool_t) connection_pool;
LDAP_SLAPD_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 (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

View File

@ -103,7 +103,7 @@ LDAP_BEGIN_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
@ -706,12 +706,12 @@ struct replog_moddn {
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

View File

@ -37,7 +37,7 @@ LDBMPROGRAMS=centipede sizecount
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