* create a replacement and hope it works
*/
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLBER_DECL
-# define LDAP_F_PRE extern __declspec(LIBLBER_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F(void) ber_pvt_assert LDAP_P((
- const char *file, int line, const char *test ));
+LIBLBER_F (void) ber_pvt_assert LDAP_P(( const char *file, int line,
+ const char *test ));
/* Can't use LDAP_STRING(test), that'd expand to "test" */
#if defined(__STDC__) || defined(__cplusplus)
# define sys_errlist ((char **)0)
#elif DECL_SYS_ERRLIST
/* have sys_errlist but need declaration */
- extern int sys_nerr;
- extern char *sys_errlist[];
+ LIBC_F (int) sys_nerr;
+ LIBC_F (char) *sys_errlist[];
#endif
#ifdef HAVE_STRERROR
((err) > -1 && (err) < sys_nerr ? sys_errlist[(err)] : "unknown")
#endif
-extern char* strerror_r();
+LIBC_F (char *) strerror_r();
#endif /* _AC_ERRNO_H */
#if defined( HAVE_LIBUTIL_H )
# include <libutil.h>
#else
-
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
/* use lutil version */
- LDAP_F(void) (setproctitle) LDAP_P((const char *fmt, ...)) \
+ LIBLUTIL_F (void) (setproctitle) LDAP_P((const char *fmt, ...)) \
LDAP_GCCATTR((format(printf, 1, 2)));
- LDAP_F(int) Argc;
- LDAP_F(char) **Argv;
+ LIBLUTIL_F (int) Argc;
+ LIBLUTIL_F (char) **Argv;
#endif
#endif /* LDAP_PROCTITLE */
#define sock_errno() WSAGetLastError()
#define sock_errstr(e) WSAGetErrorString(e)
-extern char* WSAGetErrorString LDAP_P((int));
+LIBLUTIL_F (char *) WSAGetErrorString LDAP_P((int));
#elif MACOS
# define tcp_close( s ) tcpclose( s )
#if !defined( HAVE_INET_ATON ) && !defined( inet_aton )
#define inet_aton ldap_pvt_inet_aton
struct in_addr;
-LDAP_F( int ) ldap_pvt_inet_aton LDAP_P(( const char *, struct in_addr * ));
+LIBLDAP_F (int) ldap_pvt_inet_aton LDAP_P(( const char *, struct in_addr * ));
#endif
#if defined(__WIN32) && defined(_ALPHA)
*/
#if defined(__MINGW32__) && defined(HAVE_SNPRINTF)
-int snprintf(char *, size_t, const char *, ...);
+LIBC_F (int) snprintf(char *, size_t, const char *, ...);
#endif
#if defined(__MINGW32__) && defined(HAVE_VSNPRINTF)
-int vsnprintf(char *, size_t, const char *, va_list);
+LIBC_F (int) vsnprintf(char *, size_t, const char *, va_list);
#endif
#endif /* _AC_STDARG_H */
# endif
#endif
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDAP_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDAP_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
/* use ldap_pvt_strtok instead of strtok or strtok_r! */
-LDAP_F(char *) ldap_pvt_strtok LDAP_P((
- char *str, const char *delim, char **pos ));
+LIBLDAP_F(char *) ldap_pvt_strtok LDAP_P(( char *str, const char *delim,
+ char **pos ));
-LDAP_F(char *) ldap_pvt_strdup LDAP_P((
- const char * s ));
+LIBLDAP_F(char *) ldap_pvt_strdup LDAP_P(( const char * s ));
#ifndef HAVE_STRDUP
/* strdup() is missing, declare our own version */
# define strdup(s) ldap_pvt_strdup(s)
#else
/* some systems fail to declare strdup */
- LDAP_F(char *) (strdup)();
+ LIBC_F(char *) (strdup)();
#endif
/*
* some systems fail to declare strcasecmp() and strncasecmp()
* we need them declared so we can obtain pointers to them
*/
-LDAP_F(int) (strcasecmp)();
-LDAP_F(int) (strncasecmp)();
+
+/* In Mingw32, strcasecmp is not in the C library, so we don't LIBC_F it */
+int (strcasecmp)();
+int (strncasecmp)();
#ifndef SAFEMEMCPY
# if defined( HAVE_MEMMOVE )
/* note: callers of crypt(3) should include <ac/crypt.h> */
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
#ifndef HAVE_GETPASS
-LDAP_F(char*)(getpass) LDAP_P((const char *getpass));
+LIBLUTIL_F(char*)(getpass) LDAP_P((const char *getpass));
#else
-LDAP_F(char*)(getpass)();
+LIBC_F(char*)(getpass)();
#endif
/* getopt() defines may be in separate include file */
#else
/* assume we need to declare these externs */
- extern char *optarg;
- extern int optind, opterr, optopt;
+ LIBC_F (char *) optarg;
+ LIBC_F (int) optind, opterr, optopt;
#endif
#ifndef HAVE_TEMPNAM
- LDAP_F(char *)(tempnam) LDAP_P((
- const char *tmpdir,
- const char *prefix));
-#endif
-
-/* This is never even checked for or implemented if not present */
-#if 0
-#ifndef HAVE_MKTEMP
- LDAP_F(char *)(mktemp) LDAP_P((char *));
-#endif
+ LIBLUTIL_F(char *)(tempnam) LDAP_P(( const char *tmpdir,
+ const char *prefix));
#endif
/* use lutil file locking */
typedef int (*AVL_DUP) LDAP_P((void*, void*));
typedef void (*AVL_FREE) LDAP_P((void*));
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBAVL_DECL
-# define LDAP_F_PRE extern __declspec(LIBAVL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
+LIBAVL_F( int )
avl_free LDAP_P(( Avlnode *root, AVL_FREE dfree ));
-LDAP_F( int )
+LIBAVL_F( int )
avl_insert LDAP_P((Avlnode **, void*, AVL_CMP, AVL_DUP));
-LDAP_F( void* )
+LIBAVL_F( void* )
avl_delete LDAP_P((Avlnode **, void*, AVL_CMP));
-LDAP_F( void* )
+LIBAVL_F( void* )
avl_find LDAP_P((Avlnode *, const void*, AVL_CMP));
-LDAP_F( void* )
+LIBAVL_F( void* )
avl_find_lin LDAP_P((Avlnode *, const void*, AVL_CMP));
#ifdef AVL_NONREENTRANT
-LDAP_F( void* )
+LIBAVL_F( void* )
avl_getfirst LDAP_P((Avlnode *));
-LDAP_F( void* )
+LIBAVL_F( void* )
avl_getnext LDAP_P((void));
#endif
-LDAP_F( int )
+LIBAVL_F( int )
avl_dup_error LDAP_P((void*, void*));
-LDAP_F( int )
+LIBAVL_F( int )
avl_dup_ok LDAP_P((void*, void*));
-LDAP_F( int )
+LIBAVL_F( int )
avl_apply LDAP_P((Avlnode *, AVL_APPLY, void*, int, int));
-LDAP_F( int )
+LIBAVL_F( int )
avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int));
/* apply traversal types */
typedef int (*ldap_writeptype) LDAP_P((
void *writeparm, char *p, ber_len_t len ));
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDAP_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDAP_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_init_templates LDAP_P(( char *file, struct ldap_disptmpl **tmpllistp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_init_templates_buf LDAP_P(( char *buf,
ber_len_t buflen,
struct ldap_disptmpl **tmpllistp ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_free_templates LDAP_P(( struct ldap_disptmpl *tmpllist ));
-LDAP_F( struct ldap_disptmpl * )
+LIBLDAP_F( struct ldap_disptmpl * )
ldap_first_disptmpl LDAP_P(( struct ldap_disptmpl *tmpllist ));
-LDAP_F( struct ldap_disptmpl * )
+LIBLDAP_F( struct ldap_disptmpl * )
ldap_next_disptmpl LDAP_P(( struct ldap_disptmpl *tmpllist,
struct ldap_disptmpl *tmpl ));
-LDAP_F( struct ldap_disptmpl * )
+LIBLDAP_F( struct ldap_disptmpl * )
ldap_name2template LDAP_P(( char *name,
struct ldap_disptmpl *tmpllist ));
-LDAP_F( struct ldap_disptmpl * )
+LIBLDAP_F( struct ldap_disptmpl * )
ldap_oc2template LDAP_P(( char **oclist,
struct ldap_disptmpl *tmpllist ));
-LDAP_F( char ** )
+LIBLDAP_F( char ** )
ldap_tmplattrs LDAP_P(( struct ldap_disptmpl *tmpl,
char **includeattrs,
int exclude,
unsigned long syntaxmask ));
-LDAP_F( struct ldap_tmplitem * )
+LIBLDAP_F( struct ldap_tmplitem * )
ldap_first_tmplrow LDAP_P(( struct ldap_disptmpl *tmpl ));
-LDAP_F( struct ldap_tmplitem * )
+LIBLDAP_F( struct ldap_tmplitem * )
ldap_next_tmplrow LDAP_P(( struct ldap_disptmpl *tmpl,
struct ldap_tmplitem *row ));
-LDAP_F( struct ldap_tmplitem * )
+LIBLDAP_F( struct ldap_tmplitem * )
ldap_first_tmplcol LDAP_P(( struct ldap_disptmpl *tmpl,
struct ldap_tmplitem *row ));
-LDAP_F( struct ldap_tmplitem * )
+LIBLDAP_F( struct ldap_tmplitem * )
ldap_next_tmplcol LDAP_P(( struct ldap_disptmpl *tmpl,
struct ldap_tmplitem *row,
struct ldap_tmplitem *col ));
-LDAP_F( int )
+LIBLDAP_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 ));
-LDAP_F( int )
+LIBLDAP_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 ));
-LDAP_F( int )
+LIBLDAP_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 ));
-LDAP_F( int )
+LIBLDAP_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 ));
-LDAP_F( int )
+LIBLDAP_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 ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_entry2html_search LDAP_P(( LDAP
*ld, char *dn, char *base, LDAPMessage *entry,
struct ldap_disptmpl *tmpllist, char **defattrs, char ***defvals,
LDAP_BEGIN_DECL
-extern char *optarg;
-extern int optind, opterr, optopt;
+LIBLUTIL_F (char *) optarg;
+LIBLUTIL_F (int) optind, opterr, optopt;
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
-getopt LDAP_P((
- int,
- char * const [],
- const char *));
+LIBLUTIL_F (int) getopt LDAP_P(( int, char * const [], const char *));
LDAP_END_DECL
} BerValue;
/* this should be moved to lber-int.h */
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLBER_DECL
-# define LDAP_F_PRE extern __declspec(LIBLBER_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
/*
* in bprint.c:
*/
-LDAP_F( void )
+LIBLBER_F( void )
ber_print_error LDAP_P((
LDAP_CONST char *data ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_bprint LDAP_P((
LDAP_CONST char *data, ber_len_t len ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_dump LDAP_P((
BerElement *ber, int inout ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_sos_dump LDAP_P((
Seqorset *sos ));
void *data,
int mode ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_tag LDAP_P((
BerElement *ber ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_skip_tag LDAP_P((
BerElement *ber,
ber_len_t *len ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_peek_tag LDAP_P((
BerElement *ber,
ber_len_t *len ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_int LDAP_P((
BerElement *ber,
ber_int_t *num ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_stringb LDAP_P((
BerElement *ber,
char *buf,
ber_len_t *len ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_stringa LDAP_P((
BerElement *ber,
char **buf ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_stringal LDAP_P((
BerElement *ber,
struct berval **bv ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_bitstringa LDAP_P((
BerElement *ber,
char **buf,
ber_len_t *len ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_null LDAP_P((
BerElement *ber ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_boolean LDAP_P((
BerElement *ber,
ber_int_t *boolval ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_first_element LDAP_P((
BerElement *ber,
ber_len_t *len,
char **last ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_next_element LDAP_P((
BerElement *ber,
ber_len_t *len,
LDAP_CONST char *last ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_scanf LDAP_P((
BerElement *ber,
LDAP_CONST char *fmt,
... ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_set_string_translators LDAP_P((
BerElement *ber,
BERTranslateProc encode_proc,
BerElement *ber,
void *data ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_enum LDAP_P((
BerElement *ber,
ber_int_t num,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_int LDAP_P((
BerElement *ber,
ber_int_t num,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_ostring LDAP_P((
BerElement *ber,
LDAP_CONST char *str,
ber_len_t len,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_berval LDAP_P((
BerElement *ber,
LDAP_CONST struct berval *bv,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_string LDAP_P((
BerElement *ber,
LDAP_CONST char *str,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_bitstring LDAP_P((
BerElement *ber,
LDAP_CONST char *str,
ber_len_t bitlen,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_null LDAP_P((
BerElement *ber,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_boolean LDAP_P((
BerElement *ber,
ber_int_t boolval,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_start_seq LDAP_P((
BerElement *ber,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_start_set LDAP_P((
BerElement *ber,
ber_tag_t tag ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_seq LDAP_P((
BerElement *ber ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_put_set LDAP_P((
BerElement *ber ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_printf LDAP_P((
BerElement *ber,
LDAP_CONST char *fmt,
* in io.c:
*/
-LDAP_F( ber_slen_t )
+LIBLBER_F( ber_slen_t )
ber_read LDAP_P((
BerElement *ber,
char *buf,
ber_len_t len ));
-LDAP_F( ber_slen_t )
+LIBLBER_F( ber_slen_t )
ber_write LDAP_P((
BerElement *ber,
LDAP_CONST char *buf,
ber_len_t len,
int nosos ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_free LDAP_P((
BerElement *ber,
int freebuf ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_flush LDAP_P((
Sockbuf *sb,
BerElement *ber,
int freeit ));
-LDAP_F( BerElement * )
+LIBLBER_F( BerElement * )
ber_alloc LDAP_P(( void )); /* DEPRECATED */
-LDAP_F( BerElement * )
+LIBLBER_F( BerElement * )
der_alloc LDAP_P(( void )); /* DEPRECATED */
-LDAP_F( BerElement * )
+LIBLBER_F( BerElement * )
ber_alloc_t LDAP_P((
int beroptions ));
-LDAP_F( BerElement * )
+LIBLBER_F( BerElement * )
ber_dup LDAP_P((
BerElement *ber ));
-LDAP_F( ber_tag_t )
+LIBLBER_F( ber_tag_t )
ber_get_next LDAP_P((
Sockbuf *sb,
ber_len_t *len,
BerElement *ber ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_init_w_nullc LDAP_P((
BerElement *ber,
int options ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_reset LDAP_P((
BerElement *ber,
int was_writing ));
-LDAP_F( BerElement * )
+LIBLBER_F( BerElement * )
ber_init LDAP_P((
struct berval *bv ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_flatten LDAP_P((
BerElement *ber,
struct berval **bvPtr ));
* LBER ber accessor functions
*/
-LDAP_F( int )
+LIBLBER_F( int )
ber_get_option LDAP_P((
void *item,
int option,
void *outvalue));
-LDAP_F( int )
+LIBLBER_F( int )
ber_set_option LDAP_P((
void *item,
int option,
* LBER sockbuf.c
*/
-LDAP_F( Sockbuf * )
+LIBLBER_F( Sockbuf * )
ber_sockbuf_alloc( void );
-LDAP_F( Sockbuf * )
+LIBLBER_F( Sockbuf * )
ber_sockbuf_alloc_fd(
ber_socket_t fd );
-LDAP_F( void )
+LIBLBER_F( void )
ber_sockbuf_free(
Sockbuf *sb );
/*
* LBER memory.c
*/
-LDAP_F( void * )
+LIBLBER_F( void * )
ber_memalloc LDAP_P((
ber_len_t s ));
-LDAP_F( void * )
+LIBLBER_F( void * )
ber_memrealloc LDAP_P((
void* p,
ber_len_t s ));
-LDAP_F( void * )
+LIBLBER_F( void * )
ber_memcalloc LDAP_P((
ber_len_t n,
ber_len_t s ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_memfree LDAP_P((
void* p ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_memvfree LDAP_P((
void** vector ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_bvfree LDAP_P((
struct berval *bv ));
-LDAP_F( void )
+LIBLBER_F( void )
ber_bvecfree LDAP_P((
struct berval **bv ));
-LDAP_F( struct berval * )
+LIBLBER_F( struct berval * )
ber_bvdup LDAP_P((
LDAP_CONST struct berval *bv ));
-LDAP_F( char * )
+LIBLBER_F( char * )
ber_strdup LDAP_P((
LDAP_CONST char * ));
/*
* error.c
*/
-LDAP_F( int * ) ber_errno_addr LDAP_P((void));
+LIBLBER_F( int * ) ber_errno_addr LDAP_P((void));
#define ber_errno (*(ber_errno_addr)())
#define LBER_ERROR_NONE 0
LDAP_END_DECL
-#endif /* _LBER_H */
\ No newline at end of file
+#endif /* _LBER_H */
LDAP_BEGIN_DECL
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLBER_DECL
-# define LDAP_F_PRE extern __declspec(LIBLBER_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
/*
* bprint.c
*/
-LDAP_F( BER_LOG_PRINT_FN ) ber_pvt_log_print;
+LIBLBER_F( BER_LOG_PRINT_FN ) ber_pvt_log_print;
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_log_printf LDAP_P((
int errlvl,
int loglvl,
*/
struct timeval;
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDAP_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDAP_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
/*
* in options.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_get_option LDAP_P((
LDAP *ld,
int option,
void *outvalue));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_set_option LDAP_P((
LDAP *ld,
int option,
/*
* in controls.c:
*/
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_control_free LDAP_P((
LDAPControl *ctrl ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_controls_free LDAP_P((
LDAPControl **ctrls ));
/*
* in extended.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_extended_operation LDAP_P((
LDAP *ld,
LDAP_CONST char *reqoid,
LDAPControl **clientctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_extended_operation_s LDAP_P((
LDAP *ld,
LDAP_CONST char *reqoid,
char **retoidp,
struct berval **retdatap ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_parse_extended_result LDAP_P((
LDAP *ld,
LDAPMessage *res,
/*
* in abandon.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_abandon LDAP_P((
LDAP *ld,
int msgid ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_abandon_ext LDAP_P((
LDAP *ld,
int msgid,
/*
* in add.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_add_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_add_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_add LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPMod **attrs ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_add_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
/*
* in sasl.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_sasl_bind LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_sasl_bind_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
struct berval **servercredp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_parse_sasl_bind_result LDAP_P((
LDAP *ld,
LDAPMessage *res,
* in bind.c:
* (deprecated)
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_bind LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
LDAP_CONST char *passwd,
int authmethod ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_bind_s LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
LDAP_CONST char *cred,
int authmethod ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_set_rebind_proc LDAP_P((
LDAP *ld,
int (*rebindproc) LDAP_P((
/*
* in sbind.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_simple_bind LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
LDAP_CONST char *passwd ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_simple_bind_s LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
* in kbind.c:
* (deprecated)
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_kerberos_bind_s LDAP_P((
LDAP *ld,
LDAP_CONST char *who ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_kerberos_bind1 LDAP_P((
LDAP *ld,
LDAP_CONST char *who ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_kerberos_bind1_s LDAP_P((
LDAP *ld,
LDAP_CONST char *who ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_kerberos_bind2 LDAP_P((
LDAP *ld,
LDAP_CONST char *who ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_kerberos_bind2_s LDAP_P((
LDAP *ld,
LDAP_CONST char *who ));
* in cache.c
* (deprecated)
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_enable_cache LDAP_P(( LDAP *ld, long timeout, ber_len_t maxmem ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_disable_cache LDAP_P(( LDAP *ld ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_set_cache_options LDAP_P(( LDAP *ld, unsigned long opts ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_destroy_cache LDAP_P(( LDAP *ld ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_flush_cache LDAP_P(( LDAP *ld ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_uncache_entry LDAP_P(( LDAP *ld, LDAP_CONST char *dn ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_uncache_request LDAP_P(( LDAP *ld, int msgid ));
/*
* in compare.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_compare_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_compare_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_compare LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *attr,
LDAP_CONST char *value ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_compare_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
/*
* in delete.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_delete_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_delete_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_delete LDAP_P((
LDAP *ld,
LDAP_CONST char *dn ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_delete_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn ));
/*
* in error.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_parse_result LDAP_P((
LDAP *ld,
LDAPMessage *res,
LDAPControl ***serverctrls,
int freeit ));
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_err2string LDAP_P((
int err ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_result2error LDAP_P(( /* deprecated */
LDAP *ld,
LDAPMessage *r,
int freeit ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_perror LDAP_P(( /* deprecated */
LDAP *ld,
LDAP_CONST char *s ));
/*
* in modify.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modify_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modify_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modify LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPMod **mods ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modify_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
/*
* in modrdn.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_rename LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **cctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_rename_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **sctrls,
LDAPControl **cctrls ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_rename_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **clientctrls,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_rename_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **serverctrls,
LDAPControl **clientctrls ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_rename2 LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
int deleteoldrdn,
LDAP_CONST char *newSuperior ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_rename2_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
int deleteoldrdn,
LDAP_CONST char *newSuperior));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modrdn LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newrdn ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modrdn_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newrdn ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modrdn2 LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
LDAP_CONST char *newrdn,
int deleteoldrdn ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_modrdn2_s LDAP_P((
LDAP *ld,
LDAP_CONST char *dn,
/*
* in open.c:
*/
-LDAP_F( LDAP *)
+LIBLDAP_F( LDAP *)
ldap_open LDAP_P((
LDAP_CONST char *host,
int port ));
-LDAP_F( LDAP *)
+LIBLDAP_F( LDAP *)
ldap_init LDAP_P((
LDAP_CONST char *host,
int port ));
/*
* in messages.c:
*/
-LDAP_F( LDAPMessage *)
+LIBLDAP_F( LDAPMessage *)
ldap_first_message LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LDAP_F( LDAPMessage *)
+LIBLDAP_F( LDAPMessage *)
ldap_next_message LDAP_P((
LDAP *ld,
LDAPMessage *msg ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_count_messages LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
/*
* in references.c:
*/
-LDAP_F( LDAPMessage *)
+LIBLDAP_F( LDAPMessage *)
ldap_first_reference LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LDAP_F( LDAPMessage *)
+LIBLDAP_F( LDAPMessage *)
ldap_next_reference LDAP_P((
LDAP *ld,
LDAPMessage *ref ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_count_references LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_parse_reference LDAP_P((
LDAP *ld,
LDAPMessage *ref,
/*
* in getentry.c:
*/
-LDAP_F( LDAPMessage *)
+LIBLDAP_F( LDAPMessage *)
ldap_first_entry LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LDAP_F( LDAPMessage *)
+LIBLDAP_F( LDAPMessage *)
ldap_next_entry LDAP_P((
LDAP *ld,
LDAPMessage *entry ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_count_entries LDAP_P((
LDAP *ld,
LDAPMessage *chain ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_get_entry_controls LDAP_P((
LDAP *ld,
LDAPMessage *entry,
/*
* in addentry.c
*/
-LDAP_F( LDAPMessage *)
+LIBLDAP_F( LDAPMessage *)
ldap_delete_result_entry LDAP_P((
LDAPMessage **list,
LDAPMessage *e ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_add_result_entry LDAP_P((
LDAPMessage **list,
LDAPMessage *e ));
/*
* in getdn.c
*/
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_get_dn LDAP_P((
LDAP *ld,
LDAPMessage *entry ));
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_dn2ufn LDAP_P((
LDAP_CONST char *dn ));
-LDAP_F( char ** )
+LIBLDAP_F( char ** )
ldap_explode_dn LDAP_P((
LDAP_CONST char *dn,
int notypes ));
-LDAP_F( char ** )
+LIBLDAP_F( char ** )
ldap_explode_rdn LDAP_P((
LDAP_CONST char *rdn,
int notypes ));
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_parent_dn LDAP_P((
LDAP_CONST char *dn ));
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_relative_dn LDAP_P((
LDAP_CONST char *dn ));
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_normalize_dn LDAP_P((
LDAP_CONST char *dn ));
-LDAP_F( char ** )
+LIBLDAP_F( char ** )
ldap_explode_dns LDAP_P(( /* deprecated */
LDAP_CONST char *dn ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_is_dns_dn LDAP_P(( /* deprecated */
LDAP_CONST char *dn ));
/*
* in getattr.c
*/
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_first_attribute LDAP_P((
LDAP *ld,
LDAPMessage *entry,
BerElement **ber ));
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_next_attribute LDAP_P((
LDAP *ld,
LDAPMessage *entry,
/*
* in getvalues.c
*/
-LDAP_F( char **)
+LIBLDAP_F( char **)
ldap_get_values LDAP_P((
LDAP *ld,
LDAPMessage *entry,
LDAP_CONST char *target ));
-LDAP_F( struct berval **)
+LIBLDAP_F( struct berval **)
ldap_get_values_len LDAP_P((
LDAP *ld,
LDAPMessage *entry,
LDAP_CONST char *target ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_count_values LDAP_P((
char **vals ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_count_values_len LDAP_P((
struct berval **vals ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_value_free LDAP_P((
char **vals ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_value_free_len LDAP_P((
struct berval **vals ));
/*
* in result.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_result LDAP_P((
LDAP *ld,
int msgid,
struct timeval *timeout,
LDAPMessage **result ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_msgtype LDAP_P((
LDAPMessage *lm ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_msgid LDAP_P((
LDAPMessage *lm ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_msgfree LDAP_P((
LDAPMessage *lm ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_msgdelete LDAP_P((
LDAP *ld,
int msgid ));
/*
* in search.c:
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_search_ext LDAP_P((
LDAP *ld,
LDAP_CONST char *base,
int sizelimit,
int *msgidp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_search_ext_s LDAP_P((
LDAP *ld,
LDAP_CONST char *base,
int sizelimit,
LDAPMessage **res ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_search LDAP_P((
LDAP *ld,
LDAP_CONST char *base,
char **attrs,
int attrsonly ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_search_s LDAP_P((
LDAP *ld,
LDAP_CONST char *base,
int attrsonly,
LDAPMessage **res ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_search_st LDAP_P((
LDAP *ld,
LDAP_CONST char *base,
/*
* in ufn.c
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_ufn_search_c LDAP_P((
LDAP *ld,
LDAP_CONST char *ufn,
int (*cancelproc)( void *cl ),
void *cancelparm ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_ufn_search_ct LDAP_P((
LDAP *ld,
LDAP_CONST char *ufn,
char *tag2,
char *tag3 ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_ufn_search_s LDAP_P((
LDAP *ld,
LDAP_CONST char *ufn,
int attrsonly,
LDAPMessage **res ));
-LDAP_F( LDAPFiltDesc *)
+LIBLDAP_F( LDAPFiltDesc *)
ldap_ufn_setfilter LDAP_P((
LDAP *ld,
LDAP_CONST char *fname ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_ufn_setprefix LDAP_P((
LDAP *ld,
LDAP_CONST char *prefix ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_ufn_timeout LDAP_P((
void *tvparam ));
/*
* in unbind.c
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_unbind LDAP_P((
LDAP *ld ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_unbind_s LDAP_P((
LDAP *ld ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_unbind_ext LDAP_P((
LDAP *ld,
LDAPControl **serverctrls,
LDAPControl **clientctrls));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_unbind_ext_s LDAP_P((
LDAP *ld,
LDAPControl **serverctrls,
/*
* in getfilter.c
*/
-LDAP_F( LDAPFiltDesc *)
+LIBLDAP_F( LDAPFiltDesc *)
ldap_init_getfilter LDAP_P((
LDAP_CONST char *fname ));
-LDAP_F( LDAPFiltDesc *)
+LIBLDAP_F( LDAPFiltDesc *)
ldap_init_getfilter_buf LDAP_P((
/* LDAP_CONST */ char *buf,
ber_len_t buflen ));
-LDAP_F( LDAPFiltInfo *)
+LIBLDAP_F( LDAPFiltInfo *)
ldap_getfirstfilter LDAP_P((
LDAPFiltDesc *lfdp,
/* LDAP_CONST */ char *tagpat,
/* LDAP_CONST */ char *value ));
-LDAP_F( LDAPFiltInfo *)
+LIBLDAP_F( LDAPFiltInfo *)
ldap_getnextfilter LDAP_P((
LDAPFiltDesc *lfdp ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_setfilteraffixes LDAP_P((
LDAPFiltDesc *lfdp,
LDAP_CONST char *prefix,
LDAP_CONST char *suffix ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_build_filter LDAP_P((
char *buf,
ber_len_t buflen,
* in free.c
*/
-LDAP_F( void * )
+LIBLDAP_F( void * )
ldap_memalloc LDAP_P((
ber_len_t s ));
-LDAP_F( void * )
+LIBLDAP_F( void * )
ldap_memrealloc LDAP_P((
void* p,
ber_len_t s ));
-LDAP_F( void * )
+LIBLDAP_F( void * )
ldap_memcalloc LDAP_P((
ber_len_t n,
ber_len_t s ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_memfree LDAP_P((
void* p ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_memvfree LDAP_P((
void** v ));
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_strdup LDAP_P((
LDAP_CONST char * ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_getfilter_free LDAP_P((
LDAPFiltDesc *lfdp ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_mods_free LDAP_P((
LDAPMod **mods,
int freemods ));
/*
* in friendly.c
*/
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_friendly_name LDAP_P((
LDAP_CONST char *filename,
/* LDAP_CONST */ char *uname,
LDAPFriendlyMap **map ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_free_friendlymap LDAP_P((
LDAPFriendlyMap **map ));
/*
* in cldap.c
*/
-LDAP_F( LDAP * )
+LIBLDAP_F( LDAP * )
cldap_open LDAP_P((
LDAP_CONST char *host,
int port ));
-LDAP_F( void )
+LIBLDAP_F( void )
cldap_close LDAP_P((
LDAP *ld ));
-LDAP_F( int )
+LIBLDAP_F( int )
cldap_search_s LDAP_P(( LDAP *ld,
LDAP_CONST char *base,
int scope,
LDAPMessage **res,
char *logdn ));
-LDAP_F( void )
+LIBLDAP_F( void )
cldap_setretryinfo LDAP_P((
LDAP *ld,
int tries,
/*
* in sort.c
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_sort_entries LDAP_P(( LDAP *ld,
LDAPMessage **chain,
LDAP_CONST char *attr,
int (*cmp) (LDAP_CONST char *, LDAP_CONST char *) ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_sort_values LDAP_P((
LDAP *ld,
char **vals,
int (*cmp) (LDAP_CONST void *, LDAP_CONST void *) ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_sort_strcasecmp LDAP_P((
LDAP_CONST void *a,
LDAP_CONST void *b ));
*
* need _ext varients
*/
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_is_ldap_url LDAP_P((
LDAP_CONST char *url ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_is_ldaps_url LDAP_P((
LDAP_CONST char *url ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_url_parse LDAP_P((
LDAP_CONST char *url,
LDAPURLDesc **ludpp ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_free_urldesc LDAP_P((
LDAPURLDesc *ludp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_url_search LDAP_P((
LDAP *ld,
LDAP_CONST char *url,
int attrsonly ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_url_search_s LDAP_P((
LDAP *ld,
LDAP_CONST char *url,
int attrsonly,
LDAPMessage **res ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_url_search_st LDAP_P((
LDAP *ld,
LDAP_CONST char *url,
* in charset.c
* DEPRECATED
*/
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_set_string_translators LDAP_P((
LDAP *ld,
BERTranslateProc encode_proc,
BERTranslateProc decode_proc ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_translate_from_t61 LDAP_P((
LDAP *ld,
char **bufp,
ber_len_t *lenp,
int free_input ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_translate_to_t61 LDAP_P((
LDAP *ld,
char **bufp,
ber_len_t *lenp,
int free_input ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_enable_translation LDAP_P((
LDAP *ld,
LDAPMessage *entry,
int enable ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_t61_to_8859 LDAP_P((
char **bufp,
ber_len_t *buflenp,
int free_input ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_8859_to_t61 LDAP_P((
char **bufp,
ber_len_t *buflenp,
# define LDAP_GCCATTR(attrs)
#endif
+/* Proper support for NT dynamic libraries. */
-#endif /* _LDAP_CDEFS_H */
+/*
+ * C library. Mingw32 links with the C run-time library by default,
+ * so the explicit definition of CSTATIC will keep dllimport from
+ * being defined.
+ */
+#if (defined(__MINGW32__) && !defined(CSTATIC) || \
+ defined(_WIN32) && defined(_DLL))
+# define LIBC_F(type) extern __declspec(dllimport) type
+#else
+# define LIBC_F(type) extern type
+#endif
-/* purposely allow these to be redefined */
-#ifndef LDAP_F_PRE
-# define LDAP_F_PRE LDAP_F_IMPORT
+/* AVL library */
+#if defined(LIBAVL_DECL) && defined(_WIN32)
+# define LIBAVL_F(type) extern __declspec(LIBAVL_DECL) type
+#else
+# define LIBAVL_F(type) extern type
#endif
-#ifndef LDAP_F_POST
-# define LDAP_F_POST /* no post */
+
+/* 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
-#ifndef LDAP_F
-#define LDAP_F(type) LDAP_F_PRE type LDAP_F_POST
+
+/* LDAP library */
+#if defined(LIBLDAP_DECL) && defined(_WIN32)
+# define LIBLDAP_F(type) extern __declspec(LIBLDAP_DECL) type
+#else
+# define LIBLDAP_F(type) extern type
#endif
+/* LDBM library */
+#if defined(LIBLDBM_DECL) && defined(_WIN32)
+# define LIBLDBM_F(type) extern __declspec(LIBLDBM_DECL) type
+#else
+# define LIBLDBM_F(type) extern type
+#endif
+
+/* LDIF library */
+#if defined(LIBLDIF_DECL) && defined(_WIN32)
+# define LIBLDIF_F(type) extern __declspec(LIBLDIF_DECL) type
+#else
+# define LIBLDIF_F(type) extern type
+#endif
+
+/* LUTIL library */
+#if defined(LIBLUTIL_DECL) && defined(_WIN32)
+# define LIBLUTIL_F(type) extern __declspec(LIBLUTIL_DECL) type
+#else
+# define LIBLUTIL_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
+#else
+# define LIBSLAPD_F(type) extern type
+#endif
+
+#endif /* _LDAP_CDEFS_H */
/* debugging stuff */
#ifdef LDAP_DEBUG
+/*
+ * This is a bogus extern declaration for the compiler. No need to ensure
+ * a 'proper' dllimport.
+ */
#ifndef ldap_debug
extern int ldap_debug;
#endif /* !ldap_debug */
#define Debug( level, fmt, arg1, arg2, arg3 )
#endif /* LDAP_DEBUG */
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F(void) lutil_debug LDAP_P((
+LIBLUTIL_F(void) lutil_debug LDAP_P((
int debug, int level,
const char* fmt, ... )) LDAP_GCCATTR((format(printf, 3, 4)));
struct hostent; /* avoid pulling in <netdb.h> */
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDAP_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDAP_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_pvt_ctime LDAP_P((
const time_t *tp,
char *buf ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_gethostbyname_a LDAP_P((
const char *name,
struct hostent *resbuf,
struct hostent **result,
int *herrno_ptr ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_gethostbyaddr_a LDAP_P((
const char *addr,
int len,
/* charray.c */
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_charray_add LDAP_P((
char ***a,
char *s ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_charray_merge LDAP_P((
char ***a,
char **s ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_charray_free LDAP_P(( char **a ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_charray_inlist LDAP_P((
char **a,
char *s ));
-LDAP_F( char ** )
+LIBLDAP_F( char ** )
ldap_charray_dup LDAP_P(( char **a ));
-LDAP_F( char ** )
+LIBLDAP_F( char ** )
ldap_str2charray LDAP_P((
char *str,
char *brkstr ));
/* url.c */
-void ldap_pvt_hex_unescape LDAP_P(( char *s ));
-int ldap_pvt_unhex( int c );
+LIBLDAP_F (void) ldap_pvt_hex_unescape LDAP_P(( char *s ));
+LIBLDAP_F (int) ldap_pvt_unhex( int c );
/* these macros assume 'x' is an ASCII x */
#define LDAP_DNSEPARATOR(c) ((c) == ',' || (c) == ';')
#define LDAP_NEEDSESCAPE(c) ((c) == '\\' || (c) == '"')
/* search.c */
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_pvt_find_wildcard LDAP_P(( char *s ));
-LDAP_F( ber_slen_t )
+LIBLDAP_F( ber_slen_t )
ldap_pvt_filter_value_unescape LDAP_P(( char *filter ));
/* string.c */
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_pvt_str2upper LDAP_P(( char *str ));
-LDAP_F( char * )
+LIBLDAP_F( char * )
ldap_pvt_str2lower LDAP_P(( char *str ));
/* tls.c */
struct ldapoptions;
-int ldap_pvt_tls_init LDAP_P(( void ));
-int ldap_pvt_tls_config LDAP_P(( struct ldapoptions *lo, int option, const char *arg ));
-int ldap_pvt_tls_connect LDAP_P(( Sockbuf *sb, void *ctx_arg ));
-int ldap_pvt_tls_accept LDAP_P(( Sockbuf *sb, void *ctx_arg ));
-int ldap_pvt_tls_get_option LDAP_P(( struct ldapoptions *lo, int option, void *arg ));
-int ldap_pvt_tls_set_option LDAP_P(( struct ldapoptions *lo, int option, void *arg ));
+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(( 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 ));
LDAP_END_DECL
LDAP_BEGIN_DECL
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDAP_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDAP_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_initialize LDAP_P(( void ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_destroy LDAP_P(( void ));
-LDAP_F( unsigned int )
+LIBLDAP_F( unsigned int )
ldap_pvt_thread_sleep LDAP_P(( unsigned int s ));
#ifdef HAVE_GETCONCURRENCY
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_get_concurrency LDAP_P(( void ));
#endif
/* three concurrent threads should be enough */
# define LDAP_THREAD_CONCURRENCY 3
# endif
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_set_concurrency LDAP_P(( int ));
#endif
#define LDAP_PVT_THREAD_CREATE_JOINABLE 0
#define LDAP_PVT_THREAD_CREATE_DETACHED 1
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_create LDAP_P((
ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void * ),
void *arg));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_pvt_thread_exit LDAP_P(( void *retval ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_join LDAP_P(( ldap_pvt_thread_t thread, void **status ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_kill LDAP_P(( ldap_pvt_thread_t thread, int signo ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_yield LDAP_P(( void ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_cond_init LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_cond_destroy LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_cond_signal LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_cond_broadcast LDAP_P(( ldap_pvt_thread_cond_t *cond ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_cond_wait LDAP_P((
ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_mutex_init LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_mutex_destroy LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_mutex_lock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_mutex_trylock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_mutex_unlock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
typedef struct ldap_pvt_thread_rdwr_var {
int ltrw_w_wait;
} ldap_pvt_thread_rdwr_t;
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_init LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_destroy LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_rlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_rtrylock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_runlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_wlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_wtrylock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_wunlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
#ifdef LDAP_DEBUG
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_readers LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_writers LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_pvt_thread_rdwr_active LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
#endif /* LDAP_DEBUG */
#define LDAP_SCHEMA_STRUCTURAL 1
#define LDAP_SCHEMA_AUXILIARY 2
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDAP_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDAP_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( LDAP_CONST char * )
+LIBLDAP_F( LDAP_CONST char * )
ldap_syntax2name LDAP_P((
LDAP_SYNTAX * syn ));
-LDAP_F( LDAP_CONST char * )
+LIBLDAP_F( LDAP_CONST char * )
ldap_matchingrule2name LDAP_P((
LDAP_MATCHING_RULE * mr ));
-LDAP_F( LDAP_CONST char * )
+LIBLDAP_F( LDAP_CONST char * )
ldap_attributetype2name LDAP_P((
LDAP_ATTRIBUTE_TYPE * at ));
-LDAP_F( LDAP_CONST char * )
+LIBLDAP_F( LDAP_CONST char * )
ldap_objectclass2name LDAP_P((
LDAP_OBJECT_CLASS * oc ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_syntax_free LDAP_P((
LDAP_SYNTAX * syn ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_matchingrule_free LDAP_P((
LDAP_MATCHING_RULE * mr ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_attributetype_free LDAP_P((
LDAP_ATTRIBUTE_TYPE * at ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_objectclass_free LDAP_P((
LDAP_OBJECT_CLASS * oc ));
-LDAP_F( LDAP_OBJECT_CLASS * )
+LIBLDAP_F( LDAP_OBJECT_CLASS * )
ldap_str2objectclass LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp ));
-LDAP_F( LDAP_ATTRIBUTE_TYPE * )
+LIBLDAP_F( LDAP_ATTRIBUTE_TYPE * )
ldap_str2attributetype LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp ));
-LDAP_F( LDAP_SYNTAX * )
+LIBLDAP_F( LDAP_SYNTAX * )
ldap_str2syntax LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp ));
-LDAP_F( LDAP_MATCHING_RULE * )
+LIBLDAP_F( LDAP_MATCHING_RULE * )
ldap_str2matchingrule LDAP_P((
LDAP_CONST char * s,
int * code,
LDAP_CONST char ** errp ));
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_objectclass2str LDAP_P((
LDAP_CONST LDAP_OBJECT_CLASS * oc ));
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_attributetype2str LDAP_P((
LDAP_CONST LDAP_ATTRIBUTE_TYPE * at ));
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_syntax2str LDAP_P((
LDAP_CONST LDAP_SYNTAX * syn ));
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_matchingrule2str LDAP_P((
LDAP_CONST LDAP_MATCHING_RULE * mr ));
-LDAP_F( char *)
+LIBLDAP_F( char *)
ldap_scherr2str LDAP_P((
int code )) LDAP_GCCATTR((const));
LDAP_BEGIN_DECL
-int ldbm_initialize( void );
-int ldbm_shutdown( void );
-
-int ldbm_errno( LDBM ldbm );
-LDBM ldbm_open( char *name, int rw, int mode, int dbcachesize );
-void ldbm_close( LDBM ldbm );
-void ldbm_sync( LDBM ldbm );
-void ldbm_datum_free( LDBM ldbm, Datum data );
-Datum ldbm_datum_dup( LDBM ldbm, Datum data );
-Datum ldbm_fetch( LDBM ldbm, Datum key );
-int ldbm_store( LDBM ldbm, Datum key, Datum data, int flags );
-int ldbm_delete( LDBM ldbm, Datum key );
-
-Datum ldbm_firstkey( LDBM ldbm, LDBMCursor **cursor );
-Datum ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *cursor );
+LIBLDBM_F (int) ldbm_initialize( void );
+LIBLDBM_F (int) ldbm_shutdown( void );
+
+LIBLDBM_F (int) ldbm_errno( LDBM ldbm );
+LIBLDBM_F (LDBM) ldbm_open( char *name, int rw, int mode, int dbcachesize );
+LIBLDBM_F (void) ldbm_close( LDBM ldbm );
+LIBLDBM_F (void) ldbm_sync( LDBM ldbm );
+LIBLDBM_F (void) ldbm_datum_free( LDBM ldbm, Datum data );
+LIBLDBM_F (Datum) ldbm_datum_dup( LDBM ldbm, Datum data );
+LIBLDBM_F (Datum) ldbm_fetch( LDBM ldbm, Datum key );
+LIBLDBM_F (int) ldbm_store( LDBM ldbm, Datum key, Datum data, int flags );
+LIBLDBM_F (int) ldbm_delete( LDBM ldbm, Datum key );
+
+LIBLDBM_F (Datum) ldbm_firstkey( LDBM ldbm, LDBMCursor **cursor );
+LIBLDBM_F (Datum) ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *cursor );
/* initialization of Datum structures */
#ifdef HAVE_BERKELEY_DB2
- void *ldbm_malloc( size_t size );
+ LIBLDBM_F (void *) ldbm_malloc( size_t size );
# define ldbm_datum_init(d) ((void)memset(&(d), 0, sizeof(Datum)))
#else
# define ldbm_datum_init(d) ((void)0)
LDAP_BEGIN_DECL
-extern int ldif_debug;
+/* This is NOT a bogus extern declaration (unlike ldap_debug) */
+LIBLDIF_F (int) ldif_debug;
#define LDIF_LINE_WIDTH 76 /* maximum length of LDIF lines */
((nlen) + 4 + LDIF_BASE64_LEN(vlen) \
+ ((LDIF_BASE64_LEN(vlen) + (nlen) + 3) / LDIF_LINE_WIDTH * 2 ))
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDIF_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDIF_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
+LIBLDIF_F( int )
ldif_parse_line LDAP_P((
LDAP_CONST char *line,
char **name,
char **value,
ber_len_t *vlen ));
-LDAP_F( int )
+LIBLDIF_F( int )
ldif_fetch_url LDAP_P((
LDAP_CONST char *line,
char **value,
ber_len_t *vlen ));
-LDAP_F( char * )
+LIBLDIF_F( char * )
ldif_getline LDAP_P(( char **next ));
-LDAP_F( int )
+LIBLDIF_F( int )
ldif_read_record LDAP_P((
FILE *fp,
int *lineno,
#define LDIF_PUT_URL 0x0020 /* url */
#define LDIF_PUT_SEP 0x0040 /* separator */
-LDAP_F( void )
+LIBLDIF_F( void )
ldif_sput LDAP_P((
char **out,
int type,
LDAP_CONST char *val,
ber_len_t vlen ));
-LDAP_F( char * )
+LIBLDIF_F( char * )
ldif_put LDAP_P((
int type,
LDAP_CONST char *name,
LDAP_CONST char *val,
ber_len_t vlen ));
-LDAP_F( int )
+LIBLDIF_F( int )
ldif_is_not_printable LDAP_P((
LDAP_CONST char *val,
ber_len_t vlen ));
LDAP_BEGIN_DECL
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
/* n octets encode into ceiling(n/3) * 4 bytes */
/* Avoid floating point math by through extra padding */
/* ISC Base64 Routines */
/* base64.c */
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_b64_ntop LDAP_P((
unsigned char const *,
size_t,
char *,
size_t));
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_b64_pton LDAP_P((
char const *,
unsigned char *,
size_t));
/* detach.c */
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_detach LDAP_P((
int debug,
int do_close));
/* entropy.c */
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_entropy LDAP_P((
char *buf,
int nbytes ));
/* passwd.c */
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_passwd LDAP_P((
const char *cred,
const char *passwd,
const char **methods ));
-extern const char* lutil_passwd_schemes[];
+LIBLUTIL_F (const char *) lutil_passwd_schemes[];
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_passwd_scheme LDAP_P((char *scheme));
/* utils.c */
-LDAP_F( char* )
+LIBLUTIL_F( char* )
lutil_progname LDAP_P((
const char* name,
int argc,
char *argv[] ));
/* sockpair.c */
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_pair( LBER_SOCKET_T sd[2] );
LDAP_END_DECL
LDAP_BEGIN_DECL
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_lockf LDAP_P(( int fd ));
-LDAP_F( int )
+LIBLUTIL_F( int )
lutil_unlockf LDAP_P(( int fd ));
LDAP_END_DECL
unsigned char in[64];
};
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_MD5Init LDAP_P((
struct lutil_MD5Context *context));
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_MD5Update LDAP_P((
struct lutil_MD5Context *context,
unsigned char const *buf,
ber_len_t len));
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_MD5Final LDAP_P((
unsigned char digest[16],
struct lutil_MD5Context *context));
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_MD5Transform LDAP_P((
ber_uint_t buf[4],
const unsigned char in[64]));
unsigned char buffer[64];
} lutil_SHA1_CTX;
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLUTIL_DECL
-# define LDAP_F_PRE extern __declspec(LIBLUTIL_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_SHA1Transform
LDAP_P((uint32 state[5], const unsigned char buffer[64]));
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_SHA1Init
LDAP_P((lutil_SHA1_CTX *context));
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_SHA1Update
LDAP_P((lutil_SHA1_CTX *context, const unsigned char *data, uint32 len));
-LDAP_F( void )
+LIBLUTIL_F( void )
lutil_SHA1Final
LDAP_P((unsigned char digest[20], lutil_SHA1_CTX *context));
-LDAP_F( char * )
+LIBLUTIL_F( char * )
lutil_SHA1End
LDAP_P((lutil_SHA1_CTX *, char *));
-LDAP_F( char * )
+LIBLUTIL_F( char * )
lutil_SHA1File
LDAP_P((char *, char *));
-LDAP_F( char * )
+LIBLUTIL_F( char * )
lutil_SHA1Data
LDAP_P((const unsigned char *, size_t, char *));
#define LDAP_SEARCHPREF_ERR_FILE 4
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLDAP_DECL
-# define LDAP_F_PRE extern __declspec(LIBLDAP_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_init_searchprefs LDAP_P(( char *file,
struct ldap_searchobj **solistp ));
-LDAP_F( int )
+LIBLDAP_F( int )
ldap_init_searchprefs_buf LDAP_P(( char *buf,
ber_len_t buflen,
struct ldap_searchobj **solistp ));
-LDAP_F( void )
+LIBLDAP_F( void )
ldap_free_searchprefs LDAP_P(( struct ldap_searchobj *solist ));
-LDAP_F( struct ldap_searchobj * )
+LIBLDAP_F( struct ldap_searchobj * )
ldap_first_searchobj LDAP_P(( struct ldap_searchobj *solist ));
-LDAP_F( struct ldap_searchobj * )
+LIBLDAP_F( struct ldap_searchobj * )
ldap_next_searchobj LDAP_P(( struct ldap_searchobj *sollist,
struct ldap_searchobj *so ));
LINKAGE = @LT_LIB_LINKAGE@
-NT_DYN_LIB_DEFS = -DLIBLBER_DECL=dllexport
NT_DYN_TEST_DEFS = -DLIBLBER_DECL=dllimport
# Extras for building the library
LDAP_BEGIN_DECL
-extern BER_ERRNO_FN ber_int_errno_fn;
+LIBLBER_F (BER_ERRNO_FN) ber_int_errno_fn;
struct lber_options {
short lbo_valid;
int lbo_debug;
};
-extern struct lber_options ber_int_options;
+LIBLBER_F (struct lber_options) ber_int_options;
#define ber_int_debug ber_int_options.lbo_debug
struct berelement {
typedef struct sockbuf_sec Sockbuf_Sec;
typedef struct sockbuf_buf Sockbuf_Buf;
-LDAP_F( Sockbuf_IO ) ber_pvt_sb_io_tcp;
-LDAP_F( Sockbuf_IO ) ber_pvt_sb_io_udp;
+LIBLBER_F( Sockbuf_IO ) ber_pvt_sb_io_tcp;
+LIBLBER_F( Sockbuf_IO ) ber_pvt_sb_io_udp;
struct sockbuf {
*/
#define ber_log_printf ber_pvt_log_printf
-#ifdef __MINGW32__
-# undef LDAP_F_PRE
-# ifdef LIBLBER_DECL
-# define LDAP_F_PRE extern __declspec(LIBLBER_DECL)
-# else
-# define LDAP_F_PRE extern
-# endif
-#endif
-
-LDAP_F( int )
+LIBLBER_F( int )
ber_log_bprint LDAP_P((
int errlvl,
int loglvl,
const char *data,
ber_len_t len ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_log_dump LDAP_P((
int errlvl,
int loglvl,
BerElement *ber,
int inout ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_log_sos_dump LDAP_P((
int errlvl,
int loglvl,
/* memory.c */
/* simple macros to realloc for now */
-extern BerMemoryFunctions* ber_int_memory_fns;
+LIBLBER_F (BerMemoryFunctions *) ber_int_memory_fns;
#ifdef CSRIMALLOC
#define LBER_INT_MALLOC malloc
/* these should be ber_int*() functions */
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_init LDAP_P(( Sockbuf *sb ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_destroy LDAP_P(( Sockbuf *sb ));
#ifdef USE_SASL
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_set_sec LDAP_P(( Sockbuf *sb, Sockbuf_Sec *sec, void *arg ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_clear_sec LDAP_P(( Sockbuf *sb ));
#endif
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_set_io LDAP_P(( Sockbuf *sb, Sockbuf_IO *layer, void *arg ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_clear_io LDAP_P(( Sockbuf *sb ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_close LDAP_P((Sockbuf *sb ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_set_nonblock LDAP_P(( Sockbuf *sb, int nb ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_set_readahead LDAP_P(( Sockbuf *sb, int rh ));
-LDAP_F( ber_slen_t )
+LIBLBER_F( ber_slen_t )
ber_pvt_sb_read LDAP_P(( Sockbuf *sb, void *buf, ber_len_t len ));
-LDAP_F( ber_slen_t )
+LIBLBER_F( ber_slen_t )
ber_pvt_sb_write LDAP_P(( Sockbuf *sb, void *buf, ber_len_t len ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_sb_udp_set_dst LDAP_P((Sockbuf *sb, void *addr ));
-LDAP_F( void * )
+LIBLBER_F( void * )
ber_pvt_sb_udp_get_src LDAP_P((Sockbuf *sb ));
-LDAP_F( int )
+LIBLBER_F( int )
ber_pvt_socket_set_nonblock LDAP_P(( ber_socket_t sd, int nb ));
#endif /* _LBER_INT_H */
LINKAGE = @LT_LIB_LINKAGE@
NT_DYN_LIB_LIBS = -llber $(AC_LIBS)
-NT_DYN_LIB_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllexport
+NT_DYN_LIB_DEFS = -DLIBLBER_DECL=dllimport
NT_DYN_TEST_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
# Extras for building the library
* in init.c
*/
-LDAP_F ( struct ldapoptions ) ldap_int_global_options;
-void ldap_int_initialize LDAP_P((void));
+LIBLDAP_F ( struct ldapoptions ) ldap_int_global_options;
+LIBLDAP_F ( void ) ldap_int_initialize LDAP_P((void));
/* memory.c */
/*
* in unit-int.c
*/
-void ldap_int_utils_init LDAP_P(( void ));
+LIBLDAP_F (void) ldap_int_utils_init LDAP_P(( void ));
/*
* in print.c
*/
-int ldap_log_printf LDAP_P((LDAP *ld, int level, const char *fmt, ...))
- LDAP_GCCATTR((format(printf, 3, 4)));
+LIBLDAP_F (int) ldap_log_printf LDAP_P((LDAP *ld, int level, const char *fmt, ...)) LDAP_GCCATTR((format(printf, 3, 4)));
/*
* in cache.c
*/
-void ldap_add_request_to_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype,
+LIBLDAP_F (void) ldap_add_request_to_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype,
BerElement *request ));
-void ldap_add_result_to_cache LDAP_P(( LDAP *ld, LDAPMessage *result ));
-int ldap_check_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 ));
/*
* in controls.c
*/
-LDAPControl *ldap_control_dup LDAP_P((
+LIBLDAP_F (LDAPControl *) ldap_control_dup LDAP_P((
const LDAPControl *ctrl ));
-LDAPControl **ldap_controls_dup LDAP_P((
+LIBLDAP_F (LDAPControl **) ldap_controls_dup LDAP_P((
LDAPControl *const *ctrls ));
-int ldap_int_get_controls LDAP_P((
+LIBLDAP_F (int) ldap_int_get_controls LDAP_P((
BerElement *be,
LDAPControl ***ctrlsp));
-int ldap_int_put_controls LDAP_P((
+LIBLDAP_F (int) ldap_int_put_controls LDAP_P((
LDAP *ld,
LDAPControl *const *ctrls,
BerElement *ber ));
/*
* in dsparse.c
*/
-int next_line_tokens LDAP_P(( char **bufp, ber_len_t *blenp, char ***toksp ));
-void free_strarray LDAP_P(( char **sap ));
+LIBLDAP_F (int) next_line_tokens LDAP_P(( char **bufp, ber_len_t *blenp, char ***toksp ));
+LIBLDAP_F (void) free_strarray LDAP_P(( char **sap ));
#ifdef HAVE_KERBEROS
/*
* in kerberos.c
*/
-char *ldap_get_kerberosv4_credentials LDAP_P((
+LIBLDAP_F (char *) ldap_get_kerberosv4_credentials LDAP_P((
LDAP *ld,
LDAP_CONST char *who,
LDAP_CONST char *service,
/*
* in open.c
*/
-int ldap_open_defconn( LDAP *ld );
-int open_ldap_connection( LDAP *ld, Sockbuf *sb, const char *host, int defport,
- char **krbinstancep, int async );
+LIBLDAP_F (int) ldap_open_defconn( LDAP *ld );
+LIBLDAP_F (int) open_ldap_connection( LDAP *ld, Sockbuf *sb, const char *host, int defport, char **krbinstancep, int async );
/*
* in os-ip.c
*/
-extern int ldap_int_tblsize;
-int ldap_int_timeval_dup( struct timeval **dest, const struct timeval *tm );
-int ldap_connect_to_host( LDAP *ld, Sockbuf *sb, const char *host,
- unsigned long address, int port, int async );
+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 );
-void ldap_close_connection( Sockbuf *sb );
+LIBLDAP_F (void) ldap_close_connection( Sockbuf *sb );
#ifdef HAVE_KERBEROS
-char *ldap_host_connected_to( Sockbuf *sb );
+LIBLDAP_F (char *) ldap_host_connected_to( Sockbuf *sb );
#endif /* HAVE_KERBEROS */
-void ldap_int_ip_init( void );
-int do_ldap_select( LDAP *ld, struct timeval *timeout );
-void *ldap_new_select_info( void );
-void ldap_free_select_info( void *sip );
-void ldap_mark_select_write( LDAP *ld, Sockbuf *sb );
-void ldap_mark_select_read( LDAP *ld, Sockbuf *sb );
-void ldap_mark_select_clear( LDAP *ld, Sockbuf *sb );
-int ldap_is_read_ready( LDAP *ld, Sockbuf *sb );
-int ldap_is_write_ready( LDAP *ld, Sockbuf *sb );
+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 );
/*
* in request.c
*/
-ber_int_t ldap_send_initial_request( LDAP *ld, ber_tag_t msgtype,
+LIBLDAP_F (ber_int_t) ldap_send_initial_request( LDAP *ld, ber_tag_t msgtype,
const char *dn, BerElement *ber );
-BerElement *ldap_alloc_ber_with_options( LDAP *ld );
-void ldap_set_ber_options( LDAP *ld, BerElement *ber );
-
-int ldap_send_server_request( LDAP *ld, BerElement *ber, ber_int_t msgid,
- LDAPRequest *parentreq, LDAPServer *srvlist, LDAPConn *lc,
- int bind );
-LDAPConn *ldap_new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb,
- int connect, int bind );
-LDAPRequest *ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid );
-void ldap_free_request( LDAP *ld, LDAPRequest *lr );
-void ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind );
-void ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all );
-void ldap_dump_requests_and_responses( LDAP *ld );
-
-int ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp );
-int ldap_append_referral( LDAP *ld, char **referralsp, char *s );
+LIBLDAP_F (BerElement *) ldap_alloc_ber_with_options( LDAP *ld );
+LIBLDAP_F (void) ldap_set_ber_options( LDAP *ld, BerElement *ber );
+
+LIBLDAP_F (int) ldap_send_server_request( LDAP *ld, BerElement *ber, ber_int_t msgid, LDAPRequest *parentreq, LDAPServer *srvlist, LDAPConn *lc, int bind );
+LIBLDAP_F (LDAPConn *) ldap_new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb, int connect, int 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_append_referral( LDAP *ld, char **referralsp, char *s );
/*
* in result.c:
*/
#ifdef LDAP_CONNECTIONLESS
-int cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber );
+LIBLDAP_F (int) cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber );
#endif
/*
* in search.c
*/
-BerElement *ldap_build_search_req LDAP_P((
+LIBLDAP_F (BerElement *) ldap_build_search_req LDAP_P((
LDAP *ld,
const char *base,
ber_int_t scope,
/*
* in unbind.c
*/
-int ldap_ld_free LDAP_P((
+LIBLDAP_F (int) ldap_ld_free LDAP_P((
LDAP *ld,
int close,
LDAPControl **sctrls,
LDAPControl **cctrls ));
-int ldap_send_unbind LDAP_P((
+LIBLDAP_F (int) ldap_send_unbind LDAP_P((
LDAP *ld,
Sockbuf *sb,
LDAPControl **sctrls,
/*
* in getdxbyname.c
*/
-char **ldap_getdxbyname( const char *domain );
+LIBLDAP_F (char **) ldap_getdxbyname( const char *domain );
#endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */
#if defined( STR_TRANSLATION ) && defined( LDAP_DEFAULT_CHARSET )
* hodges@stanford.edu 5-Feb-96
*/
#if LDAP_CHARSET_8859 == LDAP_DEFAULT_CHARSET
-extern
-int ldap_t61_to_8859( char **bufp, ber_len_t *buflenp, int free_input );
-extern
-int ldap_8859_to_t61( char **bufp, ber_len_t *buflenp, int free_input );
+LIBLDAP_F (int) ldap_t61_to_8859( char **bufp, ber_len_t *buflenp, int free_input );
+LIBLDAP_F (int) ldap_8859_to_t61( char **bufp, ber_len_t *buflenp, int free_input );
#endif /* LDAP_CHARSET_8859 == LDAP_DEFAULT_CHARSET */
#endif /* STR_TRANSLATION && LDAP_DEFAULT_CHARSET */
LINKAGE = @LT_LIB_LINKAGE@
NT_DYN_LIB_LIBS = -llber $(AC_LIBS)
-NT_DYN_LIB_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllexport
+NT_DYN_LIB_DEFS = -DLIBLBER_DECL=dllimport
NT_DYN_TEST_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
# Extras for building the library
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
+NT_DYN_LIB_DEFS = -DLIBLDAP_DECL=dllimport
+CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_LIB_DEFS)
+
XLIBS = -lldbm -lavl
XXLIBS = $(LDBM_LIBS)
testldbm: libldbm.a testldbm.o
$(CC) $(LDFLAGS) -o $@ testldbm.o $(LIBS)
+
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
+NT_DYN_LIB_DEFS = -DLIBLDAP_DECL=dllimport -DLIBLBER_DECL=dllimport
+CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_LIB_DEFS)
+
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries
+NT_DYN_LIB_DEFS = -DLIBLDAP_DECL=dllimport
+CPPFLAGS = $(@PLAT@_@LIB_LINKAGE@_LIB_DEFS)
+
# These rules are for a Mingw32 build, specifically.
# It's ok for them to be here because the clean rule is harmless, and
# slapdmsg.res won't get built unless it's declared in OBJS.
all-local-srv: all-cffiles
-NT_GEN_DEFS = -DLIBLUTIL_DECL=dllexport -DLIBAVL_DECL=dllexport \
- -DLIBLDBM_DECL=dllexport -DLIBLDIF_DECL=dllexport
-
-NT_DYN_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport $(NT_GEN_DEFS)
-NT_STAT_DEFS = -DLIBLBER_DECL=dllexport -DLIBLDAP_DECL=dllexport $(NT_GEN_DEFS)
+NT_DYN_DEFS = -DLIBLBER_DECL=dllimport -DLIBLDAP_DECL=dllimport
DEFINES = $(@PLAT@_@LIB_LINKAGE@_DEFS)
struct sockaddr_in bind_addr;
/* in nt_main.c */
-extern SERVICE_STATUS SLAPDServiceStatus;
-extern SERVICE_STATUS_HANDLE hSLAPDServiceStatus;
+LIBLUTIL_F (SERVICE_STATUS) SLAPDServiceStatus;
+LIBLUTIL_F (SERVICE_STATUS_HANDLE) hSLAPDServiceStatus;
extern ldap_pvt_thread_cond_t started_event, stopped_event;
extern int is_NT_Service;
char *type;
int (*proc)(const void *module, const char *file_name);
} module_regtable[] = {
- { "null", load_null },
+ { "null", load_null },
#ifdef SLAPD_EXTERNAL_EXTENSIONS
- { "extension", load_extension },
+ { "extension", load_extension },
#endif
- { NULL, NULL }
-};
+ { NULL, NULL }
+ };
typedef struct module_loaded_t {
struct module_loaded_t *next;
/* $OpenLDAP$ */
#include "portable.h"
-
-#include <ldap.h>
+#include <stdio.h>
+#include <ac/string.h>
+#include "slap.h"
static void stubs()
{
+ ldap_abandon(NULL, 0);
ldap_add_s(NULL, NULL, NULL);
ldap_bind_s(NULL, NULL, NULL, 0);
ldap_delete_s(NULL, NULL);
#ifdef HAVE_NT_SERVICE_MANAGER
-#include <stdio.h>
-#include <ac/string.h>
-
-#include "slap.h"
-
ldap_pvt_thread_cond_t started_event, stopped_event;
ldap_pvt_thread_t start_status_tid, stop_status_tid;
* acl.c
*/
-int access_allowed LDAP_P(( Backend *be, Connection *conn,
+LIBSLAPD_F (int) access_allowed LDAP_P(( Backend *be, Connection *conn,
Operation *op, Entry *e,
char *attr, struct berval *val, slap_access_t access ));
-int acl_check_modlist LDAP_P(( Backend *be,
+LIBSLAPD_F (int) acl_check_modlist LDAP_P(( Backend *be,
Connection *conn,
Operation *op,
Entry *e,
LDAPModList *ml ));
-void acl_append( AccessControl **l, AccessControl *a );
+LIBSLAPD_F (void) acl_append( AccessControl **l, AccessControl *a );
-char *get_supported_acimech LDAP_P((int index));
+LIBSLAPD_F (char *) get_supported_acimech LDAP_P((int index));
/*
* aclparse.c
*/
-void parse_acl LDAP_P(( Backend *be,
+LIBSLAPD_F (void) parse_acl LDAP_P(( Backend *be,
const char *fname,
int lineno,
int argc, char **argv ));
-char * access2str LDAP_P(( slap_access_t access ));
-slap_access_t str2access LDAP_P(( const char *str ));
+LIBSLAPD_F (char *) access2str LDAP_P(( slap_access_t access ));
+LIBSLAPD_F (slap_access_t) str2access LDAP_P(( const char *str ));
#define ACCESSMASK_MAXLEN sizeof("unknown (+wrscan)")
-char * accessmask2str LDAP_P(( slap_access_mask_t mask, char* ));
-slap_access_mask_t str2accessmask LDAP_P(( const char *str ));
+LIBSLAPD_F (char *) accessmask2str LDAP_P(( slap_access_mask_t mask, char* ));
+LIBSLAPD_F (slap_access_mask_t) str2accessmask LDAP_P(( const char *str ));
/*
* attr.c
*/
-void attr_free LDAP_P(( Attribute *a ));
-Attribute *attr_dup LDAP_P(( Attribute *a ));
-char * attr_normalize LDAP_P(( char *s ));
-int attr_merge_fast LDAP_P(( Entry *e, char *type, struct berval **vals, int nvals,
- int naddvals, int *maxvals, Attribute ***a ));
-int attr_merge LDAP_P(( Entry *e, char *type, struct berval **vals ));
-Attribute * attr_find LDAP_P(( Attribute *a, const char *type ));
-int attr_delete LDAP_P(( Attribute **attrs, const char *type ));
-int attr_syntax LDAP_P(( char *type ));
-void attr_syntax_config LDAP_P(( const char *fname, int lineno, int argc, char **argv ));
-AttributeType * at_find LDAP_P(( const char *name ));
-int at_find_in_list LDAP_P(( AttributeType *sat, AttributeType **list ));
-int at_append_to_list LDAP_P(( AttributeType *sat, AttributeType ***listp ));
-int at_delete_from_list LDAP_P(( int pos, AttributeType ***listp ));
-int at_fake_if_needed LDAP_P(( char *name ));
-int at_schema_info LDAP_P(( Entry *e ));
-int at_add LDAP_P(( LDAP_ATTRIBUTE_TYPE *at, const char **err ));
-char * at_canonical_name LDAP_P(( char * a_type ));
-
-void attrs_free LDAP_P(( Attribute *a ));
-Attribute *attrs_dup LDAP_P(( Attribute *a ));
+LIBSLAPD_F (void) attr_free LDAP_P(( Attribute *a ));
+LIBSLAPD_F (Attribute *) attr_dup LDAP_P(( Attribute *a ));
+LIBSLAPD_F (char *) attr_normalize LDAP_P(( char *s ));
+LIBSLAPD_F (int) attr_merge_fast LDAP_P(( Entry *e, char *type, struct berval **vals, int nvals, int naddvals, int *maxvals, Attribute ***a ));
+LIBSLAPD_F (int) attr_merge LDAP_P(( Entry *e, char *type, struct berval **vals ));
+LIBSLAPD_F (Attribute *) attr_find LDAP_P(( Attribute *a, const char *type ));
+LIBSLAPD_F (int) attr_delete LDAP_P(( Attribute **attrs, const char *type ));
+LIBSLAPD_F (int) attr_syntax LDAP_P(( char *type ));
+LIBSLAPD_F (void) attr_syntax_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_fake_if_needed LDAP_P(( char *name ));
+LIBSLAPD_F (int) at_schema_info LDAP_P(( Entry *e ));
+LIBSLAPD_F (int) at_add LDAP_P(( LDAP_ATTRIBUTE_TYPE *at, const char **err ));
+LIBSLAPD_F (char *) at_canonical_name LDAP_P(( char * a_type ));
+
+LIBSLAPD_F (void) attrs_free LDAP_P(( Attribute *a ));
+LIBSLAPD_F (Attribute *) attrs_dup LDAP_P(( Attribute *a ));
/*
* ava.c
*/
-int get_ava LDAP_P(( BerElement *ber, Ava *ava ));
-void ava_free LDAP_P(( Ava *ava, int freeit ));
+LIBSLAPD_F (int) get_ava LDAP_P(( BerElement *ber, Ava *ava ));
+LIBSLAPD_F (void) ava_free LDAP_P(( Ava *ava, int freeit ));
/*
* backend.c
*/
-int backend_init LDAP_P((void));
-int backend_add LDAP_P((BackendInfo *aBackendInfo));
-int backend_num LDAP_P((Backend *be));
-int backend_startup LDAP_P((Backend *be));
-int backend_shutdown LDAP_P((Backend *be));
-int backend_destroy LDAP_P((void));
+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));
-BackendInfo * backend_info LDAP_P(( const char *type ));
-BackendDB * backend_db_init LDAP_P(( const char *type ));
+LIBSLAPD_F (BackendInfo *) backend_info LDAP_P(( const char *type ));
+LIBSLAPD_F (BackendDB *) backend_db_init LDAP_P(( const char *type ));
-BackendDB * select_backend LDAP_P(( const char * dn ));
+LIBSLAPD_F (BackendDB *) select_backend LDAP_P(( const char * dn ));
-int be_issuffix LDAP_P(( Backend *be, const char *suffix ));
-int be_isroot LDAP_P(( Backend *be, const char *ndn ));
-int be_isroot_pw LDAP_P(( Backend *be, const char *ndn, struct berval *cred ));
-char* be_root_dn LDAP_P(( Backend *be ));
-int be_entry_release_rw LDAP_P(( Backend *be, Entry *e, int rw ));
+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 ));
#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 )
-extern int backend_unbind LDAP_P((Connection *conn, Operation *op));
+LIBSLAPD_F (int) backend_unbind LDAP_P((Connection *conn, Operation *op));
-extern int backend_connection_init LDAP_P((Connection *conn));
-extern int backend_connection_destroy LDAP_P((Connection *conn));
+LIBSLAPD_F (int) backend_connection_init LDAP_P((Connection *conn));
+LIBSLAPD_F (int) backend_connection_destroy LDAP_P((Connection *conn));
-extern int backend_group LDAP_P((Backend *be,
+LIBSLAPD_F (int) backend_group LDAP_P((Backend *be,
Entry *target,
const char *gr_ndn,
const char *op_ndn,
#ifdef SLAPD_SCHEMA_DN
/* temporary extern for temporary routine*/
-extern Attribute *backend_subschemasubentry( Backend * );
+LIBSLAPD_F (Attribute *) backend_subschemasubentry( Backend * );
#endif
#define ch_free free
#else
-void * ch_malloc LDAP_P(( ber_len_t size ));
-void * ch_realloc LDAP_P(( void *block, ber_len_t size ));
-void * ch_calloc LDAP_P(( ber_len_t nelem, ber_len_t size ));
-char * ch_strdup LDAP_P(( const char *string ));
-void ch_free LDAP_P(( void * ));
+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 * ));
#ifndef CH_FREE
#undef free
* charray.c
*/
-void charray_add LDAP_P(( char ***a, const char *s ));
-void charray_merge LDAP_P(( char ***a, char **s ));
-void charray_free LDAP_P(( char **array ));
-int charray_inlist LDAP_P(( char **a, const char *s ));
-char ** charray_dup LDAP_P(( char **a ));
-char ** str2charray LDAP_P(( const char *str, const char *brkstr ));
-char * charray2str LDAP_P(( char **a ));
+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 ));
+LIBSLAPD_F (char *) charray2str LDAP_P(( char **a ));
/*
* controls.c
*/
-int get_ctrls LDAP_P((
+LIBSLAPD_F (int) get_ctrls LDAP_P((
Connection *co,
Operation *op,
int senderrors ));
-int get_manageDSAit LDAP_P(( Operation *op ));
+LIBSLAPD_F (int) get_manageDSAit LDAP_P(( Operation *op ));
/*
* config.c
*/
-int read_config LDAP_P(( const char *fname ));
+LIBSLAPD_F (int) read_config LDAP_P(( const char *fname ));
/*
* connection.c
*/
-int connections_init LDAP_P((void));
-int connections_shutdown LDAP_P((void));
-int connections_destroy LDAP_P((void));
-int connections_timeout_idle LDAP_P((time_t));
+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));
-long connection_init LDAP_P((
+LIBSLAPD_F (long) connection_init LDAP_P((
ber_socket_t s,
const char* url,
const char* dnsname,
const char* sockname,
int use_tls ));
-void connection_closing LDAP_P(( Connection *c ));
-int connection_state_closing LDAP_P(( Connection *c ));
-const char *connection_state2str LDAP_P(( int state )) LDAP_GCCATTR((const));
+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));
-int connection_write LDAP_P((ber_socket_t s));
-int connection_read LDAP_P((ber_socket_t s));
+LIBSLAPD_F (int) connection_write LDAP_P((ber_socket_t s));
+LIBSLAPD_F (int) connection_read LDAP_P((ber_socket_t s));
-unsigned long connections_nextid(void);
+LIBSLAPD_F (unsigned long) connections_nextid(void);
-Connection* connection_first LDAP_P((ber_socket_t *));
-Connection* connection_next LDAP_P((Connection *, ber_socket_t *));
-void connection_done LDAP_P((Connection *));
+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 *));
/*
* dn.c
*/
-char * dn_validate LDAP_P(( char *dn ));
-char * dn_normalize LDAP_P(( char *dn ));
-char * dn_parent LDAP_P(( Backend *be, const char *dn ));
-char ** dn_subtree LDAP_P(( Backend *be, const char *dn ));
-char * dn_rdn LDAP_P(( Backend *be, char *dn ));
-int dn_issuffix LDAP_P(( char *dn, char *suffix ));
+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, char *dn ));
+LIBSLAPD_F (int) dn_issuffix LDAP_P(( char *dn, char *suffix ));
#ifdef DNS_DN
-int dn_type LDAP_P(( char *dn ));
+LIBSLAPD_F (int) dn_type LDAP_P(( char *dn ));
#endif
-int rdn_validate LDAP_P(( const char* str ));
-char * rdn_attr_value LDAP_P(( char * rdn ));
-char * rdn_attr_type LDAP_P(( char * rdn ));
+LIBSLAPD_F (int) rdn_validate LDAP_P(( const char* str ));
+LIBSLAPD_F (char *) rdn_attr_value LDAP_P(( char * rdn ));
+LIBSLAPD_F (char *) rdn_attr_type LDAP_P(( char * rdn ));
-void build_new_dn LDAP_P(( char ** new_dn,
+LIBSLAPD_F (void) build_new_dn LDAP_P(( char ** new_dn,
const char *e_dn,
const char * p_dn,
const char * newrdn ));
* entry.c
*/
-int entry_destroy LDAP_P((void));
+LIBSLAPD_F (int) entry_destroy LDAP_P((void));
-Entry * str2entry LDAP_P(( char *s ));
-char * entry2str LDAP_P(( Entry *e, int *len ));
-void entry_free LDAP_P(( Entry *e ));
+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 ));
-int entry_cmp LDAP_P(( Entry *a, Entry *b ));
-int entry_dn_cmp LDAP_P(( Entry *a, Entry *b ));
-int entry_id_cmp LDAP_P(( Entry *a, Entry *b ));
+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 ));
/*
* extended.c
*/
-int load_extension LDAP_P((const void *module, const char *file_name));
-char *get_supported_extension LDAP_P((int index));
+LIBSLAPD_F (int) load_extension LDAP_P((const void *module, const char *file_name));
+LIBSLAPD_F (char *) get_supported_extension LDAP_P((int index));
/*
* filter.c
*/
-int get_filter LDAP_P(( Connection *conn, BerElement *ber, Filter **filt, char **fstr ));
-void filter_free LDAP_P(( Filter *f ));
-void filter_print LDAP_P(( Filter *f ));
+LIBSLAPD_F (int) get_filter LDAP_P(( Connection *conn, BerElement *ber, Filter **filt, char **fstr ));
+LIBSLAPD_F (void) filter_free LDAP_P(( Filter *f ));
+LIBSLAPD_F (void) filter_print LDAP_P(( Filter *f ));
/*
* filterentry.c
*/
-int test_filter LDAP_P(( Backend *be, Connection *conn, Operation *op, Entry *e,
- Filter *f ));
+LIBSLAPD_F (int) test_filter LDAP_P(( Backend *be, Connection *conn, Operation *op, Entry *e, Filter *f ));
/*
* lock.c
*/
-FILE * lock_fopen LDAP_P(( const char *fname, const char *type, FILE **lfp ));
-int lock_fclose LDAP_P(( FILE *fp, FILE *lfp ));
+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 ));
/*
* module.c
*/
#ifdef SLAPD_MODULES
-int module_init LDAP_P(( void ));
-int module_kill LDAP_P(( void ));
+LIBSLAPD_F (int) module_init LDAP_P(( void ));
+LIBSLAPD_F (int) module_kill LDAP_P(( void ));
-int module_load LDAP_P(( const char* file_name, int argc, char *argv[] ));
-int module_path LDAP_P(( const char* path ));
+LIBSLAPD_F (int) module_load LDAP_P(( const char* file_name, int argc, char *argv[] ));
+LIBSLAPD_F (int) module_path LDAP_P(( const char* path ));
-void *module_resolve LDAP_P((const void *module, const char *name));
+LIBSLAPD_F (void) *module_resolve LDAP_P((const void *module, const char *name));
#endif /* SLAPD_MODULES */
/*
* monitor.c
*/
-extern char *supportedControls[];
+LIBSLAPD_F (char *) supportedControls[];
-void monitor_info LDAP_P((
+LIBSLAPD_F (void) monitor_info LDAP_P((
Connection *conn,
Operation *op,
char ** attrs,
* operation.c
*/
-void slap_op_free LDAP_P(( Operation *op ));
-Operation * slap_op_alloc LDAP_P((
+LIBSLAPD_F (void) slap_op_free LDAP_P(( Operation *op ));
+LIBSLAPD_F (Operation *) slap_op_alloc LDAP_P((
BerElement *ber, ber_int_t msgid,
ber_tag_t tag, ber_int_t id ));
-int slap_op_add LDAP_P(( Operation **olist, Operation *op ));
-int slap_op_remove LDAP_P(( Operation **olist, Operation *op ));
-Operation * slap_op_pop LDAP_P(( Operation **olist ));
+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 ));
/*
* phonetic.c
*/
-char * first_word LDAP_P(( char *s ));
-char * next_word LDAP_P(( char *s ));
-char * word_dup LDAP_P(( char *w ));
-char * phonetic LDAP_P(( char *s ));
+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 ));
/*
* repl.c
*/
-void replog LDAP_P(( Backend *be, Operation *op, char *dn, void *change ));
+LIBSLAPD_F (void) replog LDAP_P(( Backend *be, Operation *op, char *dn, void *change ));
/*
* result.c
*/
-struct berval **get_entry_referrals LDAP_P((
+LIBSLAPD_F (struct berval **) get_entry_referrals LDAP_P((
Backend *be, Connection *conn, Operation *op,
Entry *e ));
-void send_ldap_result LDAP_P((
+LIBSLAPD_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 ));
-void send_ldap_disconnect LDAP_P((
+LIBSLAPD_F (void) send_ldap_disconnect LDAP_P((
Connection *conn, Operation *op,
ber_int_t err, const char *text ));
-void send_ldap_extended LDAP_P((
+LIBSLAPD_F (void) send_ldap_extended LDAP_P((
Connection *conn, Operation *op,
ber_int_t err, const char *matched,
const char *text, char *rspoid,
struct berval *rspdata ));
-void send_search_result LDAP_P((
+LIBSLAPD_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 ));
-int send_search_reference LDAP_P((
+LIBSLAPD_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 ));
-int send_search_entry LDAP_P((
+LIBSLAPD_F (int) send_search_entry LDAP_P((
Backend *be, Connection *conn, Operation *op,
Entry *e, char **attrs, int attrsonly,
LDAPControl **ctrls ));
-int str2result LDAP_P(( char *s,
+LIBSLAPD_F (int) str2result LDAP_P(( char *s,
int *code, char **matched, char **info ));
/*
* sasl.c
*/
-extern char **supportedSASLMechanisms;
+LIBSLAPD_F (char **) supportedSASLMechanisms;
-int sasl_init(void);
-int sasl_destroy(void);
+LIBSLAPD_F (int) sasl_init(void);
+LIBSLAPD_F (int) sasl_destroy(void);
/*
* schema.c
*/
-int oc_schema_check LDAP_P(( Entry *e ));
-int oc_check_operational_attr LDAP_P(( const char *type ));
-int oc_check_usermod_attr LDAP_P(( const char *type ));
-int oc_check_no_usermod_attr LDAP_P(( const char *type ));
-ObjectClass *oc_find LDAP_P((const char *ocname));
-int oc_add LDAP_P((LDAP_OBJECT_CLASS *oc, const char **err));
-Syntax *syn_find LDAP_P((const char *synname));
-Syntax *syn_find_desc LDAP_P((const char *syndesc, int *slen));
-int syn_add LDAP_P((LDAP_SYNTAX *syn, slap_syntax_check_func *check, const char **err));
-MatchingRule *mr_find LDAP_P((const char *mrname));
-int mr_add LDAP_P((LDAP_MATCHING_RULE *mr, slap_mr_normalize_func *normalize, slap_mr_compare_func *compare, const char **err));
-int case_ignore_normalize LDAP_P((struct berval *val, struct berval **normalized));
-int register_syntax LDAP_P((char *desc, slap_syntax_check_func *check ));
-int register_matching_rule LDAP_P((char * desc, slap_mr_normalize_func *normalize, slap_mr_compare_func *compare));
-void schema_info LDAP_P((Connection *conn, Operation *op, char **attrs, int attrsonly));
-int schema_init LDAP_P((void));
-
-int is_entry_objectclass LDAP_P(( Entry *, const char* objectclass ));
+LIBSLAPD_F (int) oc_schema_check LDAP_P(( Entry *e ));
+LIBSLAPD_F (int) oc_check_operational_attr LDAP_P(( const char *type ));
+LIBSLAPD_F (int) oc_check_usermod_attr LDAP_P(( const char *type ));
+LIBSLAPD_F (int) oc_check_no_usermod_attr LDAP_P(( const char *type ));
+LIBSLAPD_F (ObjectClass *) oc_find LDAP_P((const char *ocname));
+LIBSLAPD_F (int) oc_add LDAP_P((LDAP_OBJECT_CLASS *oc, const char **err));
+LIBSLAPD_F (Syntax *) syn_find LDAP_P((const char *synname));
+LIBSLAPD_F (Syntax *) syn_find_desc LDAP_P((const char *syndesc, int *slen));
+LIBSLAPD_F (int) syn_add LDAP_P((LDAP_SYNTAX *syn, slap_syntax_check_func *check, const char **err));
+LIBSLAPD_F (MatchingRule *) mr_find LDAP_P((const char *mrname));
+LIBSLAPD_F (int) mr_add LDAP_P((LDAP_MATCHING_RULE *mr, slap_mr_normalize_func *normalize, slap_mr_compare_func *compare, const char **err));
+LIBSLAPD_F (int) case_ignore_normalize LDAP_P((struct berval *val, struct berval **normalized));
+LIBSLAPD_F (int) register_syntax LDAP_P((char *desc, slap_syntax_check_func *check ));
+LIBSLAPD_F (int) register_matching_rule LDAP_P((char * desc, slap_mr_normalize_func *normalize, slap_mr_compare_func *compare));
+LIBSLAPD_F (void) schema_info LDAP_P((Connection *conn, Operation *op, char **attrs, int attrsonly));
+LIBSLAPD_F (int) schema_init LDAP_P((void));
+
+LIBSLAPD_F (int) is_entry_objectclass LDAP_P(( Entry *, const char* objectclass ));
#define is_entry_alias(e) is_entry_objectclass((e), "ALIAS")
#define is_entry_referral(e) is_entry_objectclass((e), "REFERRAL")
* schemaparse.c
*/
-void parse_oc_old LDAP_P(( Backend *be, const char *fname, int lineno, int argc, char **argv ));
-void parse_oc LDAP_P(( const char *fname, int lineno, char *line, char **argv ));
-void parse_at LDAP_P(( const char *fname, int lineno, char *line, char **argv ));
-void parse_oidm LDAP_P(( const char *fname, int lineno, int argc, char **argv ));
-char *scherr2str LDAP_P((int code)) LDAP_GCCATTR((const));
-int dscompare LDAP_P(( const char *s1, const char *s2del, char delim ));
+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 ));
/*
* str2filter.c
*/
-Filter * str2filter LDAP_P(( char *str ));
+LIBSLAPD_F (Filter *) str2filter LDAP_P(( char *str ));
/*
* suffixalias.c
*/
-char *suffix_alias LDAP_P(( Backend *be, char *ndn ));
+LIBSLAPD_F (char *) suffix_alias LDAP_P(( Backend *be, char *ndn ));
/*
* value.c
*/
-int value_add_fast LDAP_P(( struct berval ***vals, struct berval **addvals, int nvals,
- int naddvals, int *maxvals ));
-int value_add LDAP_P(( struct berval ***vals, struct berval **addvals ));
-void value_normalize LDAP_P(( char *s, int syntax ));
-int value_cmp LDAP_P(( struct berval *v1, struct berval *v2, int syntax,
- int normalize ));
-int value_find LDAP_P(( struct berval **vals, struct berval *v, int syntax,
- int normalize ));
+LIBSLAPD_F (int) value_add_fast LDAP_P(( struct berval ***vals, struct berval **addvals, int nvals, int naddvals, int *maxvals ));
+LIBSLAPD_F (int) value_add LDAP_P(( struct berval ***vals, struct berval **addvals ));
+LIBSLAPD_F (void) value_normalize LDAP_P(( char *s, int syntax ));
+LIBSLAPD_F (int) value_cmp LDAP_P(( struct berval *v1, struct berval *v2, int syntax, int normalize ));
+LIBSLAPD_F (int) value_find LDAP_P(( struct berval **vals, struct berval *v, int syntax, int normalize ));
/*
* user.c
*/
#if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
-void slap_init_user LDAP_P(( char *username, char *groupname ));
+LIBSLAPD_F (void) slap_init_user LDAP_P(( char *username, char *groupname ));
#endif
/*
* passwd.c
*/
-int slap_passwd_check(
+LIBSLAPD_F (int) slap_passwd_check(
struct berval **vals,
struct berval *v,
int syntax,
* kerberos.c
*/
#ifdef HAVE_KERBEROS
-extern int krbv4_ldap_auth();
+LIBSLAPD_F (int) krbv4_ldap_auth();
#endif
/*
* Other...
*/
-extern struct berval **default_referral;
-extern char *replogfile;
-extern const char Versionstr[];
-extern int active_threads;
-extern int defsize;
-extern int deftime;
-extern int g_argc;
-extern slap_access_t global_default_access;
-extern int global_readonly;
-extern int global_lastmod;
-extern int global_idletimeout;
-extern int global_schemacheck;
-extern char *global_realm;
-extern int lber_debug;
-extern int ldap_syslog;
-
-extern ldap_pvt_thread_mutex_t num_sent_mutex;
-extern long num_bytes_sent;
-extern long num_pdu_sent;
-extern long num_entries_sent;
-extern long num_refs_sent;
-
-extern ldap_pvt_thread_mutex_t num_ops_mutex;
-extern long num_ops_completed;
-extern long num_ops_initiated;
-
-extern char *slapd_pid_file;
-extern char *slapd_args_file;
-extern char **g_argv;
-extern time_t starttime;
-
-time_t slap_get_time LDAP_P((void));
-
-extern ldap_pvt_thread_mutex_t active_threads_mutex;
-extern ldap_pvt_thread_cond_t active_threads_cond;
-
-extern ldap_pvt_thread_mutex_t entry2str_mutex;
-extern ldap_pvt_thread_mutex_t replog_mutex;
+LIBSLAPD_F (struct berval **) default_referral;
+LIBSLAPD_F (char *) replogfile;
+LIBSLAPD_F (const char) Versionstr[];
+LIBSLAPD_F (int) active_threads;
+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 (int) lber_debug;
+LIBSLAPD_F (int) ldap_syslog;
+
+LIBSLAPD_F (ldap_pvt_thread_mutex_t) num_sent_mutex;
+LIBSLAPD_F (long) num_bytes_sent;
+LIBSLAPD_F (long) num_pdu_sent;
+LIBSLAPD_F (long) num_entries_sent;
+LIBSLAPD_F (long) num_refs_sent;
+
+LIBSLAPD_F (ldap_pvt_thread_mutex_t) num_ops_mutex;
+LIBSLAPD_F (long) num_ops_completed;
+LIBSLAPD_F (long) num_ops_initiated;
+
+LIBSLAPD_F (char *) slapd_pid_file;
+LIBSLAPD_F (char *) slapd_args_file;
+LIBSLAPD_F (char) **g_argv;
+LIBSLAPD_F (time_t) starttime;
+
+LIBSLAPD_F (time_t) slap_get_time LDAP_P((void));
+
+LIBSLAPD_F (ldap_pvt_thread_mutex_t) active_threads_mutex;
+LIBSLAPD_F (ldap_pvt_thread_cond_t) active_threads_cond;
+
+LIBSLAPD_F (ldap_pvt_thread_mutex_t) entry2str_mutex;
+LIBSLAPD_F (ldap_pvt_thread_mutex_t) replog_mutex;
#ifdef SLAPD_CRYPT
-extern ldap_pvt_thread_mutex_t crypt_mutex;
+LIBSLAPD_F (ldap_pvt_thread_mutex_t) crypt_mutex;
#endif
-extern ldap_pvt_thread_mutex_t gmtime_mutex;
+LIBSLAPD_F (ldap_pvt_thread_mutex_t) gmtime_mutex;
-extern AccessControl *global_acl;
+LIBSLAPD_F (AccessControl *) global_acl;
-int slap_init LDAP_P((int mode, char* name));
-int slap_startup LDAP_P(( Backend *be ));
-int slap_shutdown LDAP_P(( Backend *be ));
-int slap_destroy LDAP_P((void));
+LIBSLAPD_F (int) slap_init LDAP_P((int mode, 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));
struct sockaddr_in;
-extern int slapd_daemon_init( char *urls, int port, int tls_port );
-extern int slapd_daemon_destroy(void);
-extern int slapd_daemon(void);
+LIBSLAPD_F (int) slapd_daemon_init( char *urls, int port, int tls_port );
+LIBSLAPD_F (int) slapd_daemon_destroy(void);
+LIBSLAPD_F (int) slapd_daemon(void);
-extern void slapd_set_write LDAP_P((ber_socket_t s, int wake));
-extern void slapd_clr_write LDAP_P((ber_socket_t s, int wake));
-extern void slapd_set_read LDAP_P((ber_socket_t s, int wake));
-extern void slapd_clr_read LDAP_P((ber_socket_t s, int wake));
+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));
-extern void slapd_remove LDAP_P((ber_socket_t s, int wake));
+LIBSLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, int wake));
-extern RETSIGTYPE slap_sig_shutdown LDAP_P((int sig));
-extern RETSIGTYPE slap_sig_wake LDAP_P((int sig));
+LIBSLAPD_F (RETSIGTYPE) slap_sig_shutdown LDAP_P((int sig));
+LIBSLAPD_F (RETSIGTYPE) slap_sig_wake LDAP_P((int sig));
-extern void config_info LDAP_P((
+LIBSLAPD_F (void) config_info LDAP_P((
Connection *conn,
Operation *op,
char ** attrs,
int attrsonly ));
-extern void root_dse_info LDAP_P((
+LIBSLAPD_F (void) root_dse_info LDAP_P((
Connection *conn,
Operation *op,
char ** attrs,
int attrsonly ));
-extern int do_abandon LDAP_P((Connection *conn, Operation *op));
-extern int do_add LDAP_P((Connection *conn, Operation *op));
-extern int do_bind LDAP_P((Connection *conn, Operation *op));
-extern int do_compare LDAP_P((Connection *conn, Operation *op));
-extern int do_delete LDAP_P((Connection *conn, Operation *op));
-extern int do_modify LDAP_P((Connection *conn, Operation *op));
-extern int do_modrdn LDAP_P((Connection *conn, Operation *op));
-extern int do_search LDAP_P((Connection *conn, Operation *op));
-extern int do_unbind LDAP_P((Connection *conn, Operation *op));
-extern int do_extended LDAP_P((Connection *conn, Operation *op));
+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));
-extern ber_socket_t dtblsize;
+LIBSLAPD_F (ber_socket_t) dtblsize;
LDAP_END_DECL
#define SLAPD_ACI_DEFAULT_ATTR "aci"
-extern int slap_debug;
+LIBSLAPD_F (int) slap_debug;
struct slap_op;
struct slap_conn;
typedef struct slap_backend_info BackendInfo; /* per backend type */
typedef struct slap_backend_db BackendDB; /* per backend database */
-extern int nBackendInfo;
-extern int nBackendDB;
-extern BackendInfo *backendInfo;
-extern BackendDB *backendDB;
+LIBSLAPD_F (int) nBackendInfo;
+LIBSLAPD_F (int) nBackendDB;
+LIBSLAPD_F (BackendInfo *) backendInfo;
+LIBSLAPD_F (BackendDB *) backendDB;
-extern int slapMode;
+LIBSLAPD_F (int) slapMode;
#define SLAP_UNDEFINED_MODE 0x0000
#define SLAP_SERVER_MODE 0x0001
#define SLAP_TOOL_MODE 0x0002
index_change_values
index_read
is_entry_objectclass
+ldap_abandon
ldap_add_s
ldap_bind_s
ldap_delete_s
projects / openldap / commitdiff