From 669b8f4047c03d4583a44ed8287d0d5920d15373 Mon Sep 17 00:00:00 2001 From: Kurt Zeilenga Date: Fri, 18 Jun 1999 23:53:05 +0000 Subject: [PATCH] ber_int_t, ber_tag_t, ber_socket_t, ber_len_t added lber_types.h.nt, lber_types.h.in removal of NULLxxx internal macros (in favor of NULL). ch_free added to slapd,slurpd/ch_malloc.c #define free ch_free (should be removed after s/free/ch_free/g) in proto-slap.h ch_malloc and friends use ber_memalloc and friends --- acconfig.h | 7 + clients/finger/main.c | 2 +- clients/gopher/go500.c | 2 +- clients/gopher/go500gw.c | 4 +- clients/rcpt500/query.c | 4 +- configure | 141 +++++++++++------ configure.in | 17 +- include/ac/socket.h | 11 +- include/avl.h | 6 +- include/disptmpl.h | 5 +- include/lber.h | 184 ++++++++++++---------- include/lber_types.h.in | 30 ++++ include/lber_types.h.nt | 43 +++++ include/ldap.h | 235 ++++++++++++++-------------- include/portable.h.in | 7 + include/portable.h.nt | 3 + include/srchpref.h | 2 +- libraries/libavl/avl.c | 4 +- libraries/liblber/bprint.c | 10 +- libraries/liblber/decode.c | 204 ++++++++++++++---------- libraries/liblber/encode.c | 187 ++++++++++++---------- libraries/liblber/io.c | 95 ++++++----- libraries/liblber/lber-int.h | 56 ++++--- libraries/liblber/liblber.dsp | 4 + libraries/liblber/memory.c | 14 +- libraries/liblber/sockbuf.c | 80 +++++----- libraries/libldap/abandon.c | 22 +-- libraries/libldap/add.c | 10 +- libraries/libldap/cache.c | 120 +++++++------- libraries/libldap/charset.c | 12 +- libraries/libldap/cldap.c | 18 ++- libraries/libldap/compare.c | 6 +- libraries/libldap/controls.c | 23 +-- libraries/libldap/delete.c | 7 +- libraries/libldap/disptmpl.c | 6 +- libraries/libldap/dsparse.c | 8 +- libraries/libldap/error.c | 6 +- libraries/libldap/extended.c | 13 +- libraries/libldap/free.c | 6 +- libraries/libldap/getattr.c | 2 +- libraries/libldap/getdn.c | 2 +- libraries/libldap/getdxbyname.c | 2 +- libraries/libldap/getentry.c | 12 +- libraries/libldap/getfilter.c | 4 +- libraries/libldap/getvalues.c | 8 +- libraries/libldap/kbind.c | 12 +- libraries/libldap/ldap-int.h | 68 ++++---- libraries/libldap/messages.c | 8 +- libraries/libldap/modify.c | 13 +- libraries/libldap/modrdn.c | 13 +- libraries/libldap/options.c | 2 +- libraries/libldap/os-ip.c | 3 +- libraries/libldap/references.c | 12 +- libraries/libldap/request.c | 49 +++--- libraries/libldap/result.c | 106 +++++++------ libraries/libldap/sbind.c | 2 +- libraries/libldap/schema.c | 4 +- libraries/libldap/search.c | 50 +++--- libraries/libldap/srchpref.c | 4 +- libraries/libldap/test.c | 16 +- libraries/libldap/tmplout.c | 4 +- libraries/libldap/unbind.c | 7 +- libraries/libldap/url.c | 2 +- servers/slapd/abandon.c | 2 +- servers/slapd/add.c | 5 +- servers/slapd/back-ldbm/back-ldbm.h | 4 +- servers/slapd/back-ldbm/external.h | 4 +- servers/slapd/back-ldbm/startup.c | 2 +- servers/slapd/bind.c | 9 +- servers/slapd/ch_malloc.c | 37 +++-- servers/slapd/connection.c | 59 +++---- servers/slapd/daemon.c | 120 +++++++------- servers/slapd/filter.c | 9 +- servers/slapd/main.c | 21 +-- servers/slapd/modify.c | 9 +- servers/slapd/modrdn.c | 8 +- servers/slapd/monitor.c | 2 +- servers/slapd/operation.c | 6 +- servers/slapd/proto-slap.h | 42 +++-- servers/slapd/result.c | 46 +++--- servers/slapd/schema.c | 2 - servers/slapd/search.c | 6 +- servers/slapd/slap.h | 39 +++-- servers/slapd/tools/ldapsyntax.c | 6 +- servers/slurpd/ch_malloc.c | 16 +- servers/slurpd/proto-slurp.h | 6 +- 86 files changed, 1413 insertions(+), 1066 deletions(-) create mode 100644 include/lber_types.h.in create mode 100644 include/lber_types.h.nt diff --git a/acconfig.h b/acconfig.h index 07127f04cb..a5c4e73038 100644 --- a/acconfig.h +++ b/acconfig.h @@ -242,6 +242,13 @@ LDAP_API_FEATURE_X_OPENLDAP_V2_DNS LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS */ +/* These are defined in lber_types.h */ +/* + LBER_INT_T + LBER_LEN_T + LBER_SOCKET_T + LBER_TAG_T +*/ /* Leave that blank line there!! Autoheader needs it. */ diff --git a/clients/finger/main.c b/clients/finger/main.c index 352c2ccd79..d172380fad 100644 --- a/clients/finger/main.c +++ b/clients/finger/main.c @@ -411,7 +411,7 @@ do_search( LDAP *ld, char *buf ) static int -entry2textwrite( void *fp, char *buf, int len ) +entry2textwrite( void *fp, char *buf, ber_len_t len ) { return( fwrite( buf, len, 1, (FILE *)fp ) == 0 ? -1 : len ); } diff --git a/clients/gopher/go500.c b/clients/gopher/go500.c index b8d148818f..323b9fbe42 100644 --- a/clients/gopher/go500.c +++ b/clients/gopher/go500.c @@ -569,7 +569,7 @@ do_search( LDAP *ld, FILE *fp, char *buf ) } static int -entry2textwrite( void *fp, char *buf, int len ) +entry2textwrite( void *fp, char *buf, ber_len_t len ) { return( fwrite( buf, len, 1, (FILE *)fp ) == 0 ? -1 : len ); } diff --git a/clients/gopher/go500gw.c b/clients/gopher/go500gw.c index 72825929a9..9f8935fcd5 100644 --- a/clients/gopher/go500gw.c +++ b/clients/gopher/go500gw.c @@ -75,7 +75,7 @@ static void do_list (LDAP *ld, FILE *fp, char *dn); static int isoc ( char **ocl, char *oc ); static int make_scope ( LDAP *ld, char *dn ); static void do_search (LDAP *ld, FILE *fp, char *query); -static int entry2textwrite( void *fp, char *buf, int len ); +static int entry2textwrite( void *fp, char *buf, ber_len_t len ); static void do_read (LDAP *ld, FILE *fp, char *dn); static void do_help (FILE *op); static void do_sizelimit(FILE *fp, char type); @@ -851,7 +851,7 @@ do_search( LDAP *ld, FILE *fp, char *query ) static int -entry2textwrite( void *fp, char *buf, int len ) +entry2textwrite( void *fp, char *buf, ber_len_t len ) { return( fwrite( buf, len, 1, (FILE *)fp ) == 0 ? -1 : len ); } diff --git a/clients/rcpt500/query.c b/clients/rcpt500/query.c index 6094e155c0..53b55729d6 100644 --- a/clients/rcpt500/query.c +++ b/clients/rcpt500/query.c @@ -30,7 +30,7 @@ static char *errpreface = "Your query failed: "; static void close_ldap(LDAP *ld); static void append_entry_list(char *rep, char *qu, LDAP *ld, LDAPMessage *msg); -static int append_text(void *reply, char *text, int len); +static int append_text(void *reply, char *text, ber_len_t len); static int do_read (LDAP *ld, char *dn, char *rep, struct ldap_disptmpl *tmp); static void report_ldap_err (LDAP *ldp, char *reply); static void remove_trailing_space (char *s); @@ -290,7 +290,7 @@ append_entry_list( char *reply, char *query, LDAP *ldp, LDAPMessage *ldmsgp ) static int -append_text( void *reply, char *text, int len ) +append_text( void *reply, char *text, ber_len_t len ) { strcat( (char *) reply, text ); return( len ); diff --git a/configure b/configure index 29cd543254..bcbd0da264 100755 --- a/configure +++ b/configure @@ -10859,16 +10859,30 @@ if test $cross_compiling = yes ; then #define CROSS_COMPILING 1 EOF + + cat >> confdefs.h <<\EOF +#define LBER_INT_T long +EOF + + cat >> confdefs.h <<\EOF +#define LBER_TAG_T long +EOF + + cat >> confdefs.h <<\EOF +#define LBER_SOCKET_T int +EOF + + else echo $ac_n "checking whether byte ordering is bigendian""... $ac_c" 1>&6 -echo "configure:10865: checking whether byte ordering is bigendian" >&5 +echo "configure:10879: checking whether byte ordering is bigendian" >&5 if eval "test \"`echo '$''{'ac_cv_c_bigendian'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else ac_cv_c_bigendian=unknown # See if sys/param.h defines the BYTE_ORDER macro. cat > conftest.$ac_ext < #include @@ -10879,11 +10893,11 @@ int main() { #endif ; return 0; } EOF -if { (eval echo configure:10883: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then +if { (eval echo configure:10897: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* # It does; now see whether it defined to BIG_ENDIAN or not. cat > conftest.$ac_ext < #include @@ -10894,7 +10908,7 @@ int main() { #endif ; return 0; } EOF -if { (eval echo configure:10898: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then +if { (eval echo configure:10912: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ac_cv_c_bigendian=yes else @@ -10914,7 +10928,7 @@ if test "$cross_compiling" = yes; then { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:10945: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_c_bigendian=no else @@ -10951,7 +10965,7 @@ EOF fi echo $ac_n "checking size of short""... $ac_c" 1>&6 -echo "configure:10955: checking size of short" >&5 +echo "configure:10969: checking size of short" >&5 if eval "test \"`echo '$''{'ac_cv_sizeof_short'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -10959,7 +10973,7 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < main() @@ -10970,7 +10984,7 @@ main() exit(0); } EOF -if { (eval echo configure:10974: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:10988: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sizeof_short=`cat conftestval` else @@ -10990,7 +11004,7 @@ EOF echo $ac_n "checking size of int""... $ac_c" 1>&6 -echo "configure:10994: checking size of int" >&5 +echo "configure:11008: checking size of int" >&5 if eval "test \"`echo '$''{'ac_cv_sizeof_int'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -10998,7 +11012,7 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < main() @@ -11009,7 +11023,7 @@ main() exit(0); } EOF -if { (eval echo configure:11013: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:11027: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sizeof_int=`cat conftestval` else @@ -11029,7 +11043,7 @@ EOF echo $ac_n "checking size of long""... $ac_c" 1>&6 -echo "configure:11033: checking size of long" >&5 +echo "configure:11047: checking size of long" >&5 if eval "test \"`echo '$''{'ac_cv_sizeof_long'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -11037,7 +11051,7 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < main() @@ -11048,7 +11062,7 @@ main() exit(0); } EOF -if { (eval echo configure:11052: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:11066: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sizeof_long=`cat conftestval` else @@ -11070,11 +11084,42 @@ EOF if test "$ac_cv_sizeof_int" -lt 4 ; then echo "configure: warning: OpenLDAP requires 'int' to be 32 bits or greater." 1>&2 + + cat >> confdefs.h <<\EOF +#define LBER_INT_T long +EOF + + cat >> confdefs.h <<\EOF +#define LBER_TAG_T long +EOF + + cat >> confdefs.h <<\EOF +#define LBER_SOCKET_T int +EOF + + else + cat >> confdefs.h <<\EOF +#define LBER_INT_T int +EOF + + cat >> confdefs.h <<\EOF +#define LBER_TAG_T long +EOF + + cat >> confdefs.h <<\EOF +#define LBER_SOCKET_T int +EOF + fi fi +cat >> confdefs.h <<\EOF +#define LBER_LEN_T long +EOF + + echo $ac_n "checking for 8-bit clean memcmp""... $ac_c" 1>&6 -echo "configure:11078: checking for 8-bit clean memcmp" >&5 +echo "configure:11123: checking for 8-bit clean memcmp" >&5 if eval "test \"`echo '$''{'ac_cv_func_memcmp_clean'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -11082,7 +11127,7 @@ else ac_cv_func_memcmp_clean=no else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:11141: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_func_memcmp_clean=yes else @@ -11110,12 +11155,12 @@ echo "$ac_t""$ac_cv_func_memcmp_clean" 1>&6 test $ac_cv_func_memcmp_clean = no && LIBOBJS="$LIBOBJS memcmp.${ac_objext}" echo $ac_n "checking for strftime""... $ac_c" 1>&6 -echo "configure:11114: checking for strftime" >&5 +echo "configure:11159: checking for strftime" >&5 if eval "test \"`echo '$''{'ac_cv_func_strftime'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11187: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_func_strftime=yes" else @@ -11160,7 +11205,7 @@ else echo "$ac_t""no" 1>&6 # strftime is in -lintl on SCO UNIX. echo $ac_n "checking for strftime in -lintl""... $ac_c" 1>&6 -echo "configure:11164: checking for strftime in -lintl" >&5 +echo "configure:11209: checking for strftime in -lintl" >&5 ac_lib_var=`echo intl'_'strftime | sed 'y%./+-%__p_%'` if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 @@ -11168,7 +11213,7 @@ else ac_save_LIBS="$LIBS" LIBS="-lintl $LIBS" cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11228: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_lib_$ac_lib_var=yes" else @@ -11207,12 +11252,12 @@ fi echo $ac_n "checking for vprintf""... $ac_c" 1>&6 -echo "configure:11211: checking for vprintf" >&5 +echo "configure:11256: checking for vprintf" >&5 if eval "test \"`echo '$''{'ac_cv_func_vprintf'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11284: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_func_vprintf=yes" else @@ -11259,12 +11304,12 @@ fi if test "$ac_cv_func_vprintf" != yes; then echo $ac_n "checking for _doprnt""... $ac_c" 1>&6 -echo "configure:11263: checking for _doprnt" >&5 +echo "configure:11308: checking for _doprnt" >&5 if eval "test \"`echo '$''{'ac_cv_func__doprnt'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11336: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_func__doprnt=yes" else @@ -11316,12 +11361,12 @@ if test $ac_cv_func_vprintf = yes ; then for ac_func in vsnprintf vsprintf do echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 -echo "configure:11320: checking for $ac_func" >&5 +echo "configure:11365: checking for $ac_func" >&5 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11393: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_func_$ac_func=yes" else @@ -11413,12 +11458,12 @@ for ac_func in \ do echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 -echo "configure:11417: checking for $ac_func" >&5 +echo "configure:11462: checking for $ac_func" >&5 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11490: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_func_$ac_func=yes" else @@ -11469,12 +11514,12 @@ done for ac_func in getopt tempnam do echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 -echo "configure:11473: checking for $ac_func" >&5 +echo "configure:11518: checking for $ac_func" >&5 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11546: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_func_$ac_func=yes" else @@ -11527,13 +11572,13 @@ done # Check Configuration echo $ac_n "checking declaration of sys_errlist""... $ac_c" 1>&6 -echo "configure:11531: checking declaration of sys_errlist" >&5 +echo "configure:11576: checking declaration of sys_errlist" >&5 if eval "test \"`echo '$''{'ol_cv_dcl_sys_errlist'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < @@ -11543,7 +11588,7 @@ int main() { char *c = (char *) *sys_errlist ; return 0; } EOF -if { (eval echo configure:11547: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then +if { (eval echo configure:11592: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ol_cv_dcl_sys_errlist=yes else @@ -11563,20 +11608,20 @@ if test $ol_cv_dcl_sys_errlist = no ; then EOF echo $ac_n "checking existence of sys_errlist""... $ac_c" 1>&6 -echo "configure:11567: checking existence of sys_errlist" >&5 +echo "configure:11612: checking existence of sys_errlist" >&5 if eval "test \"`echo '$''{'ol_cv_have_sys_errlist'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < int main() { char *c = (char *) *sys_errlist ; return 0; } EOF -if { (eval echo configure:11580: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:11625: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* ol_cv_have_sys_errlist=yes else @@ -11889,7 +11934,7 @@ tests/progs/Makefile:build/top.mk:tests/progs/Makefile.in:build/rules.mk \ contrib/Makefile:build/top.mk:contrib/Makefile.in:build/dir.mk \ contrib/saucer/Makefile:build/top.mk:contrib/saucer/Makefile.in:build/rules.mk \ contrib/web_ldap/Makefile:build/top.mk:contrib/web_ldap/Makefile.in:build/rules.mk \ - include/portable.h include/ldap_features.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15 + include/portable.h include/ldap_features.h include/lber_types.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15 EOF cat >> $CONFIG_STATUS <> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF fi diff --git a/configure.in b/configure.in index b30e485fa3..47d5db1c19 100644 --- a/configure.in +++ b/configure.in @@ -35,7 +35,7 @@ dnl We use autoconf features new to 2.13. dnl aclocal.m4 should be built using aclocal from automake 1.4 AC_PREREQ(2.13)dnl Required Autoconf version -AC_CONFIG_HEADER(include/portable.h include/ldap_features.h)dnl +AC_CONFIG_HEADER(include/portable.h include/ldap_features.h include/lber_types.h)dnl dnl dnl Start Args @@ -1621,6 +1621,11 @@ OL_C_VOLATILE if test $cross_compiling = yes ; then AC_DEFINE(CROSS_COMPILING, 1, [define if cross compiling]) + + AC_DEFINE(LBER_INT_T,long) + AC_DEFINE(LBER_TAG_T,long) + AC_DEFINE(LBER_SOCKET_T,int) + else AC_C_BIGENDIAN AC_CHECK_SIZEOF(short) @@ -1629,9 +1634,19 @@ else if test "$ac_cv_sizeof_int" -lt 4 ; then AC_MSG_WARN([OpenLDAP requires 'int' to be 32 bits or greater.]) + + AC_DEFINE(LBER_INT_T,long) + AC_DEFINE(LBER_TAG_T,long) + AC_DEFINE(LBER_SOCKET_T,int) + else + AC_DEFINE(LBER_INT_T,int) + AC_DEFINE(LBER_TAG_T,long) + AC_DEFINE(LBER_SOCKET_T,int) fi fi +AC_DEFINE(LBER_LEN_T,long) + dnl ---------------------------------------------------------------- dnl Checks for library functions. AC_FUNC_MEMCMP diff --git a/include/ac/socket.h b/include/ac/socket.h index 5901442749..45554cbd5a 100644 --- a/include/ac/socket.h +++ b/include/ac/socket.h @@ -67,6 +67,7 @@ # define tcp_close( s ) closesocket( s ); # define ioctl( s, c, a ) ioctlsocket( (s), (c), (a) ) # define ioctl_t u_long +# define AC_SOCKET_INVALID ((unsigned int) ~0) #define EWOULDBLOCK WSAEWOULDBLOCK @@ -92,12 +93,16 @@ # define ioctl_t int #endif +#ifndef AC_SOCKET_INVALID +# define AC_SOCKET_INVALID (-1) +#endif + #if defined(__WIN32) && defined(_ALPHA) /* NT on Alpha is hosed. */ #define AC_HTONL( l ) \ ((((l)&0xff)<<24) + (((l)&0xff00)<<8) + \ (((l)&0xff0000)>>8) + (((l)&0xff000000)>>24)) -#define AC_NTOHL(l) LBER_HTONL(l) +#define AC_NTOHL(l) AC_HTONL(l) #elif defined(__alpha) && !defined(VMS) /* @@ -116,5 +121,9 @@ #define AC_NTOHL( l ) ntohl( l ) #endif +/* htons()/ntohs() may be broken much like htonl()/ntohl() */ +#define AC_HTONS( s ) htons( s ) +#define AC_NTOHS( s ) ntohs( s ) + #endif /* _AC_SOCKET_H_ */ diff --git a/include/avl.h b/include/avl.h index fe90302fb3..ad2c347bf3 100644 --- a/include/avl.h +++ b/include/avl.h @@ -56,7 +56,7 @@ struct avlnode { #endif /* AVL_INTERNALS */ typedef int (*AVL_APPLY) LDAP_P((void *, void*)); -typedef int (*AVL_CMP) LDAP_P((void*, void*)); +typedef int (*AVL_CMP) LDAP_P((const void*, const void*)); typedef int (*AVL_DUP) LDAP_P((void*, void*)); typedef void (*AVL_FREE) LDAP_P((void*)); @@ -70,10 +70,10 @@ LDAP_F( void* ) avl_delete LDAP_P((Avlnode **, void*, AVL_CMP)); LDAP_F( void* ) -avl_find LDAP_P((Avlnode *, void*, AVL_CMP)); +avl_find LDAP_P((Avlnode *, const void*, AVL_CMP)); LDAP_F( void* ) -avl_find_lin LDAP_P((Avlnode *, void*, AVL_CMP)); +avl_find_lin LDAP_P((Avlnode *, const void*, AVL_CMP)); #ifdef AVL_NONREENTRANT LDAP_F( void* ) diff --git a/include/disptmpl.h b/include/disptmpl.h index 015418a510..369edf0771 100644 --- a/include/disptmpl.h +++ b/include/disptmpl.h @@ -221,14 +221,15 @@ struct ldap_disptmpl { #define LDAP_DTMPL_BUFSIZ 8192 -typedef int (*ldap_writeptype) LDAP_P(( void *writeparm, char *p, int len )); +typedef int (*ldap_writeptype) LDAP_P(( + void *writeparm, char *p, ber_len_t len )); LDAP_F( int ) ldap_init_templates LDAP_P(( char *file, struct ldap_disptmpl **tmpllistp )); LDAP_F( int ) ldap_init_templates_buf LDAP_P(( char *buf, - long buflen, + ber_len_t buflen, struct ldap_disptmpl **tmpllistp )); LDAP_F( void ) diff --git a/include/lber.h b/include/lber.h index a9d3c85d07..eb0ad06d0c 100644 --- a/include/lber.h +++ b/include/lber.h @@ -23,13 +23,30 @@ #define _LBER_H #include - -#ifndef LBER_SIZE_T_DEFINED -#include -#endif +#include LDAP_BEGIN_DECL +/* boolean, enumerations, and integers */ +typedef LBER_INT_T ber_int_t; + +/* signed and unsigned versions */ +typedef signed LBER_INT_T ber_sint_t; +typedef unsigned LBER_INT_T ber_uint_t; + +/* tags */ +typedef LBER_TAG_T ber_tag_t; + +/* "socket" descriptors */ +typedef LBER_SOCKET_T ber_socket_t; + +/* lengths */ +typedef unsigned LBER_LEN_T ber_len_t; + +/* signed lengths */ +typedef LBER_LEN_T ber_slen_t; + + /* Overview of LBER tag construction * * Bits @@ -48,41 +65,41 @@ LDAP_BEGIN_DECL */ /* BER classes and mask */ -#define LBER_CLASS_UNIVERSAL 0x00UL -#define LBER_CLASS_APPLICATION 0x40UL -#define LBER_CLASS_CONTEXT 0x80UL -#define LBER_CLASS_PRIVATE 0xc0UL -#define LBER_CLASS_MASK 0xc0UL +#define LBER_CLASS_UNIVERSAL (ber_tag_t) 0x00U +#define LBER_CLASS_APPLICATION (ber_tag_t) 0x40U +#define LBER_CLASS_CONTEXT (ber_tag_t) 0x80U +#define LBER_CLASS_PRIVATE (ber_tag_t) 0xc0U +#define LBER_CLASS_MASK (ber_tag_t) 0xc0U /* BER encoding type and mask */ -#define LBER_PRIMITIVE 0x00UL -#define LBER_CONSTRUCTED 0x20UL -#define LBER_ENCODING_MASK 0x20UL +#define LBER_PRIMITIVE (ber_tag_t) 0x00U +#define LBER_CONSTRUCTED (ber_tag_t) 0x20U +#define LBER_ENCODING_MASK (ber_tag_t) 0x20U -#define LBER_BIG_TAG_MASK 0x1fUL -#define LBER_MORE_TAG_MASK 0x80UL +#define LBER_BIG_TAG_MASK (ber_tag_t) 0x1fU +#define LBER_MORE_TAG_MASK (ber_tag_t) 0x80U /* * Note that LBER_ERROR and LBER_DEFAULT are values that can never appear * as valid BER tags, and so it is safe to use them to report errors. In * fact, any tag for which the following is true is invalid: */ -#define LBER_INVALID(tag) (((tag) & 0x00000080) && (((tag) & 0xFFFFFF00)) -#define LBER_ERROR 0xffffffffUL -#define LBER_DEFAULT 0xffffffffUL +#define LBER_INVALID(t) (((t) & 0x080) && (((t) & (ber_tag_t) ~ 0x0FF)) +#define LBER_ERROR ((ber_tag_t) ~ 0x0) +#define LBER_DEFAULT ((ber_tag_t) ~ 0x0) /* general BER types we know about */ -#define LBER_BOOLEAN 0x01UL -#define LBER_INTEGER 0x02UL -#define LBER_BITSTRING 0x03UL -#define LBER_OCTETSTRING 0x04UL -#define LBER_NULL 0x05UL -#define LBER_ENUMERATED 0x0aUL -#define LBER_SEQUENCE 0x30UL /* constructed */ -#define LBER_SET 0x31UL /* constructed */ - -#define OLD_LBER_SEQUENCE 0x10UL /* w/o constructed bit - broken */ -#define OLD_LBER_SET 0x11UL /* w/o constructed bit - broken */ +#define LBER_BOOLEAN (ber_tag_t) 0x01UL +#define LBER_INTEGER (ber_tag_t) 0x02UL +#define LBER_BITSTRING (ber_tag_t) 0x03UL +#define LBER_OCTETSTRING (ber_tag_t) 0x04UL +#define LBER_NULL (ber_tag_t) 0x05UL +#define LBER_ENUMERATED (ber_tag_t) 0x0aUL +#define LBER_SEQUENCE (ber_tag_t) 0x30UL /* constructed */ +#define LBER_SET (ber_tag_t) 0x31UL /* constructed */ + +#define OLD_LBER_SEQUENCE (ber_tag_t) 0x10UL /* w/o constructed bit - broken */ +#define OLD_LBER_SET (ber_tag_t) 0x11UL /* w/o constructed bit - broken */ typedef int (*BERTranslateProc) LDAP_P(( char **bufp, @@ -105,9 +122,9 @@ typedef int (*BERTranslateProc) LDAP_P(( typedef void (*BER_LOG_PRINT_FN) LDAP_P(( char *buf )); -typedef void* (*BER_MEMALLOC_FN) LDAP_P(( size_t size )); -typedef void* (*BER_MEMCALLOC_FN) LDAP_P(( size_t n, size_t size )); -typedef void* (*BER_MEMREALLOC_FN) LDAP_P(( void *p, size_t size )); +typedef void* (*BER_MEMALLOC_FN) LDAP_P(( ber_len_t size )); +typedef void* (*BER_MEMCALLOC_FN) LDAP_P(( ber_len_t n, ber_len_t size )); +typedef void* (*BER_MEMREALLOC_FN) LDAP_P(( void *p, ber_len_t size )); typedef void (*BER_MEMFREE_FN) LDAP_P(( void *p )); typedef struct lber_memory_fns { @@ -141,7 +158,7 @@ typedef struct seqorset Seqorset; /* structure for returning a sequence of octet strings + length */ typedef struct berval { - unsigned long bv_len; + ber_len_t bv_len; char *bv_val; } BerValue; @@ -154,7 +171,7 @@ ber_print_error LDAP_P(( LDAP_F( void ) ber_bprint LDAP_P(( - LDAP_CONST char *data, int len )); + LDAP_CONST char *data, ber_len_t len )); LDAP_F( void ) ber_dump LDAP_P(( @@ -173,68 +190,69 @@ typedef int (*BERDecodeCallback) LDAP_P(( void *data, int mode )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_tag LDAP_P(( BerElement *ber )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_skip_tag LDAP_P(( BerElement *ber, - unsigned long *len )); + ber_len_t *len )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_peek_tag LDAP_P(( LDAP_CONST BerElement *ber, - unsigned long *len )); + ber_len_t *len )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_int LDAP_P(( BerElement *ber, - long *num )); + ber_int_t *num )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_stringb LDAP_P(( BerElement *ber, char *buf, - unsigned long *len )); + ber_len_t *len )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_stringa LDAP_P(( - BerElement *ber, char **buf )); + BerElement *ber, + char **buf )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_stringal LDAP_P(( BerElement *ber, struct berval **bv )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_bitstringa LDAP_P(( BerElement *ber, char **buf, - unsigned long *len )); + ber_len_t *len )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_null LDAP_P(( BerElement *ber )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_boolean LDAP_P(( BerElement *ber, - int *boolval )); + ber_int_t *boolval )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_first_element LDAP_P(( BerElement *ber, - unsigned long *len, + ber_len_t *len, char **last )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_next_element LDAP_P(( BerElement *ber, - unsigned long *len, + ber_len_t *len, char *last )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_scanf LDAP_P(( BerElement *ber, LDAP_CONST char *fmt, @@ -256,61 +274,61 @@ typedef int (*BEREncodeCallback) LDAP_P(( LDAP_F( int ) ber_put_enum LDAP_P(( BerElement *ber, - long num, - unsigned long tag )); + ber_int_t num, + ber_tag_t tag )); LDAP_F( int ) ber_put_int LDAP_P(( BerElement *ber, - long num, - unsigned long tag )); + ber_int_t num, + ber_tag_t tag )); LDAP_F( int ) ber_put_ostring LDAP_P(( BerElement *ber, LDAP_CONST char *str, - unsigned long len, - unsigned long tag )); + ber_len_t len, + ber_tag_t tag )); LDAP_F( int ) ber_put_berval LDAP_P(( BerElement *ber, LDAP_CONST struct berval *bv, - unsigned long tag )); + ber_tag_t tag )); LDAP_F( int ) ber_put_string LDAP_P(( BerElement *ber, LDAP_CONST char *str, - unsigned long tag )); + ber_tag_t tag )); LDAP_F( int ) ber_put_bitstring LDAP_P(( BerElement *ber, LDAP_CONST char *str, - unsigned long bitlen, - unsigned long tag )); + ber_len_t bitlen, + ber_tag_t tag )); LDAP_F( int ) ber_put_null LDAP_P(( BerElement *ber, - unsigned long tag )); + ber_tag_t tag )); LDAP_F( int ) ber_put_boolean LDAP_P(( BerElement *ber, - int boolval, - unsigned long tag )); + ber_int_t boolval, + ber_tag_t tag )); LDAP_F( int ) ber_start_seq LDAP_P(( BerElement *ber, - unsigned long tag )); + ber_tag_t tag )); LDAP_F( int ) ber_start_set LDAP_P(( BerElement *ber, - unsigned long tag )); + ber_tag_t tag )); LDAP_F( int ) ber_put_seq LDAP_P(( @@ -331,17 +349,17 @@ ber_printf LDAP_P(( * in io.c: */ -LDAP_F( long ) +LDAP_F( ber_slen_t ) ber_read LDAP_P(( BerElement *ber, char *buf, - unsigned long len )); + ber_len_t len )); -LDAP_F( long ) +LDAP_F( ber_slen_t ) ber_write LDAP_P(( BerElement *ber, LDAP_CONST char *buf, - unsigned long len, + ber_len_t len, int nosos )); LDAP_F( void ) @@ -351,7 +369,9 @@ ber_free LDAP_P(( LDAP_F( int ) ber_flush LDAP_P(( - Sockbuf *sb, BerElement *ber, int freeit )); + Sockbuf *sb, + BerElement *ber, + int freeit )); LDAP_F( BerElement * ) ber_alloc LDAP_P(( void )); /* DEPRECATED */ @@ -367,10 +387,10 @@ LDAP_F( BerElement * ) ber_dup LDAP_P(( LDAP_CONST BerElement *ber )); -LDAP_F( unsigned long ) +LDAP_F( ber_tag_t ) ber_get_next LDAP_P(( Sockbuf *sb, - unsigned long *len, + ber_len_t *len, BerElement *ber )); LDAP_F( void ) @@ -417,7 +437,7 @@ ber_sockbuf_alloc( void ); LDAP_F( Sockbuf * ) ber_sockbuf_alloc_fd( - int fd ); + ber_socket_t fd ); LDAP_F( void ) ber_sockbuf_free( @@ -428,17 +448,17 @@ ber_sockbuf_free( */ LDAP_F( void * ) ber_memalloc LDAP_P(( - size_t s )); + ber_len_t s )); LDAP_F( void * ) ber_memrealloc LDAP_P(( void* p, - size_t s )); + ber_len_t s )); LDAP_F( void * ) ber_memcalloc LDAP_P(( - size_t n, - size_t s )); + ber_len_t n, + ber_len_t s )); LDAP_F( void ) ber_memfree LDAP_P(( diff --git a/include/lber_types.h.in b/include/lber_types.h.in new file mode 100644 index 0000000000..5f1bb70f39 --- /dev/null +++ b/include/lber_types.h.in @@ -0,0 +1,30 @@ +/* + * Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted only + * as authorized by the OpenLDAP Public License. A copy of this + * license is available at http://www.OpenLDAP.org/license.html or + * in file LICENSE in the top-level directory of the distribution. + */ + +/* + * LBER types + */ + +#ifndef _LBER_TYPES_H +#define _LBER_TYPES_H + +/* LBER boolean, enum, integers - 32 bits or larger*/ +#undef LBER_INT_T + +/* LBER tags - 32 bits or larger */ +#undef LBER_TAG_T + +/* LBER socket descriptor */ +#undef LBER_SOCKET_T + +/* LBER lengths - 32 bits or larger*/ +#undef LBER_LEN_T + +#endif /* _LBER_TYPES_H */ diff --git a/include/lber_types.h.nt b/include/lber_types.h.nt new file mode 100644 index 0000000000..6e26c6771f --- /dev/null +++ b/include/lber_types.h.nt @@ -0,0 +1,43 @@ +/* + * Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted only + * as authorized by the OpenLDAP Public License. A copy of this + * license is available at http://www.OpenLDAP.org/license.html or + * in file LICENSE in the top-level directory of the distribution. + */ + +/* + * LBER types for Windows NT + */ + +#ifndef _LBER_TYPES_H_NT +#define _LBER_TYPES_H_NT + +/* + * NT types: + * + * bitsof(short) == 2 + * bitsof(int) == 4 + * bitsof(long) == 4 + * + * typedef unsigned int size_t; + * typedef unsigned int SOCKET; + * + * we use native C types to avoid sucking in system headers + */ + +/* LBER boolean, enum, integers - 32 bits or larger*/ +#define LBER_INT_T int + +/* LBER tags - 32 bits or larger */ +#define LBER_TAG_T long + +/* LBER socket descriptor */ +#define LBER_SOCKET_T unsigned int + +/* LBER lengths - 32 bits or larger*/ +#define LBER_LEN_T int + +#endif /* _LBER_TYPES_H_NT */ diff --git a/include/ldap.h b/include/ldap.h index e435088e95..7258b8112d 100644 --- a/include/ldap.h +++ b/include/ldap.h @@ -42,7 +42,7 @@ LDAP_BEGIN_DECL * As such, the number will be above the old RFC but below * whatever number does finally get assigned */ -#define LDAP_API_VERSION 2002 +#define LDAP_API_VERSION 2003 #define LDAP_VENDOR_NAME "OpenLDAP" /* We'll eventually release as 200 */ #define LDAP_VENDOR_VERSION 192 @@ -175,164 +175,164 @@ typedef struct ldapcontrol { */ /* general stuff */ -#define LDAP_TAG_MESSAGE 0x30UL /* constructed + 16 */ -#define OLD_LDAP_TAG_MESSAGE 0x10UL /* forgot the constructed bit */ -#define LDAP_TAG_MSGID 0x02UL /* integer */ -#define LDAP_TAG_LDAPDN 0x04UL /* octect string */ -#define LDAP_TAG_CONTROLS 0xa0UL /* context specific + constructed + 0 */ -#define LDAP_TAG_REFERRAL 0xa3UL /* context specific + constructed + 3 */ +#define LDAP_TAG_MESSAGE (ber_tag_t) 0x30U /* constructed + 16 */ +#define OLD_LDAP_TAG_MESSAGE (ber_tag_t) 0x10U /* forgot the constructed bit */ +#define LDAP_TAG_MSGID (ber_tag_t) 0x02U /* integer */ +#define LDAP_TAG_LDAPDN (ber_tag_t) 0x04U /* octect string */ +#define LDAP_TAG_CONTROLS (ber_tag_t) 0xa0U /* context specific + constructed + 0 */ +#define LDAP_TAG_REFERRAL (ber_tag_t) 0xa3U /* context specific + constructed + 3 */ -#define LDAP_TAG_NEWSUPERIOR 0x80UL /* context-specific + primitive + 0 */ +#define LDAP_TAG_NEWSUPERIOR (ber_tag_t) 0x80U /* context-specific + primitive + 0 */ -#define LDAP_TAG_EXOP_REQ_OID 0x80UL /* context specific + primitive */ -#define LDAP_TAG_EXOP_REQ_VALUE 0x81UL /* context specific + primitive */ -#define LDAP_TAG_EXOP_RES_OID 0x8aUL /* context specific + primitive */ -#define LDAP_TAG_EXOP_RES_VALUE 0x8bUL /* context specific + primitive */ +#define LDAP_TAG_EXOP_REQ_OID (ber_tag_t) 0x80U /* context specific + primitive */ +#define LDAP_TAG_EXOP_REQ_VALUE (ber_tag_t) 0x81U /* context specific + primitive */ +#define LDAP_TAG_EXOP_RES_OID (ber_tag_t) 0x8aU /* context specific + primitive */ +#define LDAP_TAG_EXOP_RES_VALUE (ber_tag_t) 0x8bU /* context specific + primitive */ -#define LDAP_TAG_SASL_RES_CREDS 0x87UL /* context specific + primitive */ +#define LDAP_TAG_SASL_RES_CREDS (ber_tag_t) 0x87U /* context specific + primitive */ /* possible operations a client can invoke */ -#define LDAP_REQ_BIND 0x60UL /* application + constructed */ -#define LDAP_REQ_UNBIND 0x42UL /* application + primitive */ -#define LDAP_REQ_SEARCH 0x63UL /* application + constructed */ -#define LDAP_REQ_MODIFY 0x66UL /* application + constructed */ -#define LDAP_REQ_ADD 0x68UL /* application + constructed */ -#define LDAP_REQ_DELETE 0x4aUL /* application + primitive */ -#define LDAP_REQ_MODRDN 0x6cUL /* application + constructed */ +#define LDAP_REQ_BIND (ber_tag_t) 0x60U /* application + constructed */ +#define LDAP_REQ_UNBIND (ber_tag_t) 0x42U /* application + primitive */ +#define LDAP_REQ_SEARCH (ber_tag_t) 0x63U /* application + constructed */ +#define LDAP_REQ_MODIFY (ber_tag_t) 0x66U /* application + constructed */ +#define LDAP_REQ_ADD (ber_tag_t) 0x68U /* application + constructed */ +#define LDAP_REQ_DELETE (ber_tag_t) 0x4aU /* application + primitive */ +#define LDAP_REQ_MODRDN (ber_tag_t) 0x6cU /* application + constructed */ #define LDAP_REQ_MODDN LDAP_REQ_MODRDN #define LDAP_REQ_RENAME LDAP_REQ_MODRDN -#define LDAP_REQ_COMPARE 0x6eUL /* application + constructed */ -#define LDAP_REQ_ABANDON 0x50UL /* application + primitive */ -#define LDAP_REQ_EXTENDED 0x77UL /* application + constructed */ +#define LDAP_REQ_COMPARE (ber_tag_t) 0x6eU /* application + constructed */ +#define LDAP_REQ_ABANDON (ber_tag_t) 0x50U /* application + primitive */ +#define LDAP_REQ_EXTENDED (ber_tag_t) 0x77U /* application + constructed */ /* U-Mich version 3.0 compatibility stuff */ -#define LDAP_REQ_UNBIND_30 0x62UL -#define LDAP_REQ_DELETE_30 0x6aUL -#define LDAP_REQ_ABANDON_30 0x70UL +#define LDAP_REQ_UNBIND_30 (ber_tag_t) 0x62U +#define LDAP_REQ_DELETE_30 (ber_tag_t) 0x6aU +#define LDAP_REQ_ABANDON_30 (ber_tag_t) 0x70U /* * old broken stuff for backwards compatibility - forgot application tag * and constructed/primitive bit */ -#define OLD_LDAP_REQ_BIND 0x00UL -#define OLD_LDAP_REQ_UNBIND 0x02UL -#define OLD_LDAP_REQ_SEARCH 0x03UL -#define OLD_LDAP_REQ_MODIFY 0x06UL -#define OLD_LDAP_REQ_ADD 0x08UL -#define OLD_LDAP_REQ_DELETE 0x0aUL -#define OLD_LDAP_REQ_MODRDN 0x0cUL -#define OLD_LDAP_REQ_COMPARE 0x0eUL -#define OLD_LDAP_REQ_ABANDON 0x10UL +#define OLD_LDAP_REQ_BIND (ber_tag_t) 0x00U +#define OLD_LDAP_REQ_UNBIND (ber_tag_t) 0x02U +#define OLD_LDAP_REQ_SEARCH (ber_tag_t) 0x03U +#define OLD_LDAP_REQ_MODIFY (ber_tag_t) 0x06U +#define OLD_LDAP_REQ_ADD (ber_tag_t) 0x08U +#define OLD_LDAP_REQ_DELETE (ber_tag_t) 0x0aU +#define OLD_LDAP_REQ_MODRDN (ber_tag_t) 0x0cU +#define OLD_LDAP_REQ_COMPARE (ber_tag_t) 0x0eU +#define OLD_LDAP_REQ_ABANDON (ber_tag_t) 0x10U /* possible result types a server can return */ -#define LDAP_RES_BIND 0x61UL /* application + constructed */ -#define LDAP_RES_SEARCH_ENTRY 0x64UL /* application + constructed */ -#define LDAP_RES_SEARCH_REFERENCE 0x73UL /* V3: application + constructed */ -#define LDAP_RES_SEARCH_RESULT 0x65UL /* application + constructed */ -#define LDAP_RES_MODIFY 0x67UL /* application + constructed */ -#define LDAP_RES_ADD 0x69UL /* application + constructed */ -#define LDAP_RES_DELETE 0x6bUL /* application + constructed */ -#define LDAP_RES_MODRDN 0x6dUL /* application + constructed */ +#define LDAP_RES_BIND (ber_tag_t) 0x61U /* application + constructed */ +#define LDAP_RES_SEARCH_ENTRY (ber_tag_t) 0x64U /* application + constructed */ +#define LDAP_RES_SEARCH_REFERENCE (ber_tag_t) 0x73U /* V3: application + constructed */ +#define LDAP_RES_SEARCH_RESULT (ber_tag_t) 0x65U /* application + constructed */ +#define LDAP_RES_MODIFY (ber_tag_t) 0x67U /* application + constructed */ +#define LDAP_RES_ADD (ber_tag_t) 0x69U /* application + constructed */ +#define LDAP_RES_DELETE (ber_tag_t) 0x6bU /* application + constructed */ +#define LDAP_RES_MODRDN (ber_tag_t) 0x6dU /* application + constructed */ #define LDAP_RES_MODDN LDAP_RES_MODRDN /* application + constructed */ #define LDAP_RES_RENAME LDAP_RES_MODRDN /* application + constructed */ -#define LDAP_RES_COMPARE 0x6fUL /* application + constructed */ -#define LDAP_RES_EXTENDED 0x78UL /* V3: application + constructed */ -#define LDAP_RES_ANY ((unsigned long)(-1)) +#define LDAP_RES_COMPARE (ber_tag_t) 0x6fU /* application + constructed */ +#define LDAP_RES_EXTENDED (ber_tag_t) 0x78U /* V3: application + constructed */ +#define LDAP_RES_ANY ((ber_tag_t)(~0)) /* old broken stuff for backwards compatibility */ -#define OLD_LDAP_RES_BIND 0x01UL -#define OLD_LDAP_RES_SEARCH_ENTRY 0x04UL -#define OLD_LDAP_RES_SEARCH_RESULT 0x05UL -#define OLD_LDAP_RES_MODIFY 0x07UL -#define OLD_LDAP_RES_ADD 0x09UL -#define OLD_LDAP_RES_DELETE 0x0bUL -#define OLD_LDAP_RES_MODRDN 0x0dUL +#define OLD_LDAP_RES_BIND (ber_tag_t) 0x01UL +#define OLD_LDAP_RES_SEARCH_ENTRY (ber_tag_t) 0x04UL +#define OLD_LDAP_RES_SEARCH_RESULT (ber_tag_t) 0x05U +#define OLD_LDAP_RES_MODIFY (ber_tag_t) 0x07U +#define OLD_LDAP_RES_ADD (ber_tag_t) 0x09U +#define OLD_LDAP_RES_DELETE (ber_tag_t) 0x0bU +#define OLD_LDAP_RES_MODRDN (ber_tag_t) 0x0dU #define OLD_LDAP_RES_MODDN OLD_LDAP_RES_MODRDN -#define OLD_LDAP_RES_COMPARE 0x0fUL +#define OLD_LDAP_RES_COMPARE (ber_tag_t) 0x0fU /* sasl methods */ #define LDAP_SASL_SIMPLE NULL /* authentication methods available */ -#define LDAP_AUTH_NONE 0x00UL /* no authentication */ -#define LDAP_AUTH_SIMPLE 0x80UL /* context specific + primitive */ -#define LDAP_AUTH_SASL 0xa3UL /* context specific + primitive */ -#define LDAP_AUTH_KRBV4 0xffUL /* means do both of the following */ -#define LDAP_AUTH_KRBV41 0x81UL /* context specific + primitive */ -#define LDAP_AUTH_KRBV42 0x82UL /* context specific + primitive */ +#define LDAP_AUTH_NONE (ber_tag_t) 0x00U /* no authentication */ +#define LDAP_AUTH_SIMPLE (ber_tag_t) 0x80U /* context specific + primitive */ +#define LDAP_AUTH_SASL (ber_tag_t) 0xa3U /* context specific + primitive */ +#define LDAP_AUTH_KRBV4 (ber_tag_t) 0xffU /* means do both of the following */ +#define LDAP_AUTH_KRBV41 (ber_tag_t) 0x81U /* context specific + primitive */ +#define LDAP_AUTH_KRBV42 (ber_tag_t) 0x82U /* context specific + primitive */ /* U-Mich version 3.0 compatibility auth methods */ -#define LDAP_AUTH_SIMPLE_30 0xa0UL /* context specific + constructed */ -#define LDAP_AUTH_KRBV41_30 0xa1UL /* context specific + constructed */ -#define LDAP_AUTH_KRBV42_30 0xa2UL /* context specific + constructed */ +#define LDAP_AUTH_SIMPLE_30 (ber_tag_t) 0xa0U /* context specific + constructed */ +#define LDAP_AUTH_KRBV41_30 (ber_tag_t) 0xa1U /* context specific + constructed */ +#define LDAP_AUTH_KRBV42_30 (ber_tag_t) 0xa2U /* context specific + constructed */ /* old broken stuff */ -#define OLD_LDAP_AUTH_SIMPLE 0x00UL -#define OLD_LDAP_AUTH_KRBV4 0x01UL -#define OLD_LDAP_AUTH_KRBV42 0x02UL +#define OLD_LDAP_AUTH_SIMPLE (ber_tag_t) 0x00U +#define OLD_LDAP_AUTH_KRBV4 (ber_tag_t) 0x01U +#define OLD_LDAP_AUTH_KRBV42 (ber_tag_t) 0x02U /* filter types */ -#define LDAP_FILTER_AND 0xa0UL /* context specific + constructed */ -#define LDAP_FILTER_OR 0xa1UL /* context specific + constructed */ -#define LDAP_FILTER_NOT 0xa2UL /* context specific + constructed */ -#define LDAP_FILTER_EQUALITY 0xa3UL /* context specific + constructed */ -#define LDAP_FILTER_SUBSTRINGS 0xa4UL /* context specific + constructed */ -#define LDAP_FILTER_GE 0xa5UL /* context specific + constructed */ -#define LDAP_FILTER_LE 0xa6UL /* context specific + constructed */ -#define LDAP_FILTER_PRESENT 0x87UL /* context specific + primitive */ -#define LDAP_FILTER_APPROX 0xa8UL /* context specific + constructed */ -#define LDAP_FILTER_EXTENDED 0xa9UL /* context specific + constructed */ +#define LDAP_FILTER_AND (ber_tag_t) 0xa0U /* context specific + constructed */ +#define LDAP_FILTER_OR (ber_tag_t) 0xa1U /* context specific + constructed */ +#define LDAP_FILTER_NOT (ber_tag_t) 0xa2U /* context specific + constructed */ +#define LDAP_FILTER_EQUALITY (ber_tag_t) 0xa3U /* context specific + constructed */ +#define LDAP_FILTER_SUBSTRINGS (ber_tag_t) 0xa4U /* context specific + constructed */ +#define LDAP_FILTER_GE (ber_tag_t) 0xa5U /* context specific + constructed */ +#define LDAP_FILTER_LE (ber_tag_t) 0xa6U /* context specific + constructed */ +#define LDAP_FILTER_PRESENT (ber_tag_t) 0x87U /* context specific + primitive */ +#define LDAP_FILTER_APPROX (ber_tag_t) 0xa8U /* context specific + constructed */ +#define LDAP_FILTER_EXTENDED (ber_tag_t) 0xa9U /* context specific + constructed */ /* U-Mich version 3.0 compatibility filter types */ -#define LDAP_FILTER_PRESENT_30 0xa7UL /* context specific + constructed */ +#define LDAP_FILTER_PRESENT_30 (ber_tag_t) 0xa7U /* context specific + constructed */ /* old broken stuff */ -#define OLD_LDAP_FILTER_AND 0x00UL -#define OLD_LDAP_FILTER_OR 0x01UL -#define OLD_LDAP_FILTER_NOT 0x02UL -#define OLD_LDAP_FILTER_EQUALITY 0x03UL -#define OLD_LDAP_FILTER_SUBSTRINGS 0x04UL -#define OLD_LDAP_FILTER_GE 0x05UL -#define OLD_LDAP_FILTER_LE 0x06UL -#define OLD_LDAP_FILTER_PRESENT 0x07UL -#define OLD_LDAP_FILTER_APPROX 0x08UL +#define OLD_LDAP_FILTER_AND (ber_tag_t) 0x00U +#define OLD_LDAP_FILTER_OR (ber_tag_t) 0x01U +#define OLD_LDAP_FILTER_NOT (ber_tag_t) 0x02U +#define OLD_LDAP_FILTER_EQUALITY (ber_tag_t) 0x03U +#define OLD_LDAP_FILTER_SUBSTRINGS (ber_tag_t) 0x04U +#define OLD_LDAP_FILTER_GE (ber_tag_t) 0x05U +#define OLD_LDAP_FILTER_LE (ber_tag_t) 0x06U +#define OLD_LDAP_FILTER_PRESENT (ber_tag_t) 0x07U +#define OLD_LDAP_FILTER_APPROX (ber_tag_t) 0x08U /* extended filter component types */ -#define LDAP_FILTER_EXTENDED_OID 0x81UL /* context specific */ -#define LDAP_FILTER_EXTENDED_TYPE 0x82UL /* context specific */ -#define LDAP_FILTER_EXTENDED_VALUE 0x83UL /* context specific */ -#define LDAP_FILTER_EXTENDED_DNATTRS 0x84UL /* context specific */ +#define LDAP_FILTER_EXTENDED_OID (ber_tag_t) 0x81U /* context specific */ +#define LDAP_FILTER_EXTENDED_TYPE (ber_tag_t) 0x82U /* context specific */ +#define LDAP_FILTER_EXTENDED_VALUE (ber_tag_t) 0x83U /* context specific */ +#define LDAP_FILTER_EXTENDED_DNATTRS (ber_tag_t) 0x84U /* context specific */ /* substring filter component types */ -#define LDAP_SUBSTRING_INITIAL 0x80UL /* context specific */ -#define LDAP_SUBSTRING_ANY 0x81UL /* context specific */ -#define LDAP_SUBSTRING_FINAL 0x82UL /* context specific */ +#define LDAP_SUBSTRING_INITIAL (ber_tag_t) 0x80U /* context specific */ +#define LDAP_SUBSTRING_ANY (ber_tag_t) 0x81U /* context specific */ +#define LDAP_SUBSTRING_FINAL (ber_tag_t) 0x82U /* context specific */ /* U-Mich version 3.0 compatibility substring filter component types */ -#define LDAP_SUBSTRING_INITIAL_30 0xa0UL /* context specific */ -#define LDAP_SUBSTRING_ANY_30 0xa1UL /* context specific */ -#define LDAP_SUBSTRING_FINAL_30 0xa2UL /* context specific */ +#define LDAP_SUBSTRING_INITIAL_30 (ber_tag_t) 0xa0U /* context specific */ +#define LDAP_SUBSTRING_ANY_30 (ber_tag_t) 0xa1U /* context specific */ +#define LDAP_SUBSTRING_FINAL_30 (ber_tag_t) 0xa2U /* context specific */ /* old broken stuff */ -#define OLD_LDAP_SUBSTRING_INITIAL 0x00UL -#define OLD_LDAP_SUBSTRING_ANY 0x01UL -#define OLD_LDAP_SUBSTRING_FINAL 0x02UL +#define OLD_LDAP_SUBSTRING_INITIAL (ber_tag_t) 0x00U +#define OLD_LDAP_SUBSTRING_ANY (ber_tag_t) 0x01U +#define OLD_LDAP_SUBSTRING_FINAL (ber_tag_t) 0x02U /* search scopes */ -#define LDAP_SCOPE_BASE 0x0000 -#define LDAP_SCOPE_ONELEVEL 0x0001 -#define LDAP_SCOPE_SUBTREE 0x0002 +#define LDAP_SCOPE_BASE (ber_int_t) 0x0000 +#define LDAP_SCOPE_ONELEVEL (ber_int_t) 0x0001 +#define LDAP_SCOPE_SUBTREE (ber_int_t) 0x0002 /* for modifications */ typedef struct ldapmod { int mod_op; -#define LDAP_MOD_ADD 0x0000 -#define LDAP_MOD_DELETE 0x0001 -#define LDAP_MOD_REPLACE 0x0002 -#define LDAP_MOD_BVALUES 0x0080 +#define LDAP_MOD_ADD (ber_int_t) 0x0000 +#define LDAP_MOD_DELETE (ber_int_t) 0x0001 +#define LDAP_MOD_REPLACE (ber_int_t) 0x0002 +#define LDAP_MOD_BVALUES (ber_int_t) 0x0080 /* IMPORTANT: do not use code 0x1000 (or above), * it is used internally by the backends! * (see ldap/servers/slapd/slap.h) @@ -732,7 +732,7 @@ ldap_kerberos_bind2_s LDAP_P(( * (deprecated) */ LDAP_F( int ) -ldap_enable_cache LDAP_P(( LDAP *ld, long timeout, long maxmem )); +ldap_enable_cache LDAP_P(( LDAP *ld, long timeout, ber_len_t maxmem )); LDAP_F( void ) ldap_disable_cache LDAP_P(( LDAP *ld )); @@ -1311,7 +1311,7 @@ ldap_init_getfilter LDAP_P(( LDAP_F( LDAPFiltDesc *) ldap_init_getfilter_buf LDAP_P(( /* LDAP_CONST */ char *buf, - long buflen )); + ber_len_t buflen )); LDAP_F( LDAPFiltInfo *) ldap_getfirstfilter LDAP_P(( @@ -1332,7 +1332,7 @@ ldap_setfilteraffixes LDAP_P(( LDAP_F( void ) ldap_build_filter LDAP_P(( char *buf, - unsigned long buflen, + ber_len_t buflen, LDAP_CONST char *pattern, LDAP_CONST char *prefix, LDAP_CONST char *suffix, @@ -1347,17 +1347,17 @@ ldap_build_filter LDAP_P(( LDAP_F( void * ) ldap_memalloc LDAP_P(( - size_t s )); + ber_len_t s )); LDAP_F( void * ) ldap_memrealloc LDAP_P(( void* p, - size_t s )); + ber_len_t s )); LDAP_F( void * ) ldap_memcalloc LDAP_P(( - size_t n, - size_t s )); + ber_len_t n, + ber_len_t s )); LDAP_F( void ) ldap_memfree LDAP_P(( @@ -1499,14 +1499,15 @@ LDAP_F( int ) ldap_translate_from_t61 LDAP_P(( LDAP *ld, char **bufp, - unsigned long *lenp, + ber_len_t *lenp, int free_input )); LDAP_F( int ) ldap_translate_to_t61 LDAP_P(( LDAP *ld, char **bufp, - unsigned long *lenp, int free_input )); + ber_len_t *lenp, + int free_input )); LDAP_F( void ) ldap_enable_translation LDAP_P(( @@ -1517,13 +1518,13 @@ ldap_enable_translation LDAP_P(( LDAP_F( int ) ldap_t61_to_8859 LDAP_P(( char **bufp, - unsigned long *buflenp, + ber_len_t *buflenp, int free_input )); LDAP_F( int ) ldap_8859_to_t61 LDAP_P(( char **bufp, - unsigned long *buflenp, + ber_len_t *buflenp, int free_input )); LDAP_END_DECL diff --git a/include/portable.h.in b/include/portable.h.in index 7a22738a25..5dbfc517b7 100644 --- a/include/portable.h.in +++ b/include/portable.h.in @@ -216,6 +216,13 @@ LDAP_API_FEATURE_X_OPENLDAP_V2_DNS LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS */ +/* These are defined in lber_types.h */ +/* + LBER_INT_T + LBER_LEN_T + LBER_SOCKET_T + LBER_TAG_T +*/ /* The number of bytes in a int. */ #undef SIZEOF_INT diff --git a/include/portable.h.nt b/include/portable.h.nt index beee37a789..dae5950a56 100644 --- a/include/portable.h.nt +++ b/include/portable.h.nt @@ -21,6 +21,7 @@ #define OPENLDAP_PACKAGE "OpenLDAP" #define OPENLDAP_VERSION "-devel" #define EXEEXT ".exe" +#define LDAP_DIRSEP "\\" #if defined( _DEBUG ) && !defined( LDAP_DEBUG ) /* #define LDAP_MEMORY_DEBUG 1 */ @@ -48,6 +49,8 @@ /* define type for caddr_t */ typedef char * caddr_t; +#define ssize_t signed int + #define LOG_DEBUG 0 #define openlog( a, b ) #define closelog() diff --git a/include/srchpref.h b/include/srchpref.h index 9eb10cc806..4a40aa5452 100644 --- a/include/srchpref.h +++ b/include/srchpref.h @@ -83,7 +83,7 @@ ldap_init_searchprefs LDAP_P(( char *file, LDAP_F( int ) ldap_init_searchprefs_buf LDAP_P(( char *buf, - long buflen, + ber_len_t buflen, struct ldap_searchobj **solistp )); LDAP_F( void ) diff --git a/libraries/libavl/avl.c b/libraries/libavl/avl.c index e4b2b1be44..27678616ee 100644 --- a/libraries/libavl/avl.c +++ b/libraries/libavl/avl.c @@ -622,7 +622,7 @@ avl_free( Avlnode *root, AVL_FREE dfree ) */ void* -avl_find( Avlnode *root, void* data, AVL_CMP fcmp ) +avl_find( Avlnode *root, const void* data, AVL_CMP fcmp ) { int cmp; @@ -644,7 +644,7 @@ avl_find( Avlnode *root, void* data, AVL_CMP fcmp ) */ void* -avl_find_lin( Avlnode *root, void* data, AVL_CMP fcmp ) +avl_find_lin( Avlnode *root, const void* data, AVL_CMP fcmp ) { void* res; diff --git a/libraries/liblber/bprint.c b/libraries/liblber/bprint.c index 0aa69e7ffa..4a5def2586 100644 --- a/libraries/liblber/bprint.c +++ b/libraries/liblber/bprint.c @@ -105,7 +105,7 @@ int ber_log_bprint(int errlvl, int loglvl, const char *data, - int len ) + ber_len_t len ) { assert( data != NULL ); @@ -120,7 +120,7 @@ ber_log_bprint(int errlvl, void ber_bprint( LDAP_CONST char *data, - int len ) + ber_len_t len ) { static const char hexdig[] = "0123456789abcdef"; #define BPLEN 48 @@ -239,9 +239,11 @@ ber_sos_dump( (*ber_pvt_log_print)( "*** sos dump ***\n" ); - while ( sos != NULLSEQORSET ) { + while ( sos != NULL ) { sprintf( buf, "ber_sos_dump: clen %ld first 0x%lx ptr 0x%lx\n", - (long) sos->sos_clen, (long) sos->sos_first, (long) sos->sos_ptr ); + (long) sos->sos_clen, + (long) sos->sos_first, + (long) sos->sos_ptr ); (*ber_pvt_log_print)( buf ); sprintf( buf, " current len %ld contents:\n", diff --git a/libraries/liblber/decode.c b/libraries/liblber/decode.c index 7d89a1dacd..d0886582a2 100644 --- a/libraries/liblber/decode.c +++ b/libraries/liblber/decode.c @@ -30,14 +30,17 @@ #include "lber-int.h" -static int ber_getnint LDAP_P(( BerElement *ber, long *num, int len )); +static ber_tag_t ber_getnint LDAP_P(( + BerElement *ber, + ber_int_t *num, + ber_len_t len )); /* return the tag - LBER_DEFAULT returned means trouble */ -unsigned long +ber_tag_t ber_get_tag( BerElement *ber ) { unsigned char xbyte; - unsigned long tag; + ber_tag_t tag; char *tagp; unsigned int i; @@ -48,11 +51,11 @@ ber_get_tag( BerElement *ber ) return( LBER_DEFAULT ); if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK ) - return( (unsigned long) xbyte ); + return( (ber_tag_t) xbyte ); tagp = (char *) &tag; tagp[0] = xbyte; - for ( i = 1; i < sizeof(long); i++ ) { + for ( i = 1; i < sizeof(ber_tag_t); i++ ) { if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 ) return( LBER_DEFAULT ); @@ -63,21 +66,21 @@ ber_get_tag( BerElement *ber ) } /* tag too big! */ - if ( i == sizeof(long) ) + if ( i == sizeof(ber_tag_t) ) return( LBER_DEFAULT ); /* want leading, not trailing 0's */ - return( tag >> (sizeof(long) - i - 1) ); + return( tag >> (sizeof(ber_tag_t) - i - 1) ); } -unsigned long -ber_skip_tag( BerElement *ber, unsigned long *len ) +ber_tag_t +ber_skip_tag( BerElement *ber, ber_len_t *len ) { - unsigned long tag; + ber_tag_t tag; unsigned char lc; - unsigned int noctets; + ber_len_t noctets; int diff; - unsigned long netlen; + ber_len_t netlen; assert( ber != NULL ); assert( len != NULL ); @@ -112,13 +115,13 @@ ber_skip_tag( BerElement *ber, unsigned long *len ) return( LBER_DEFAULT ); if ( lc & 0x80U ) { noctets = (lc & 0x7fU); - if ( (unsigned) noctets > sizeof(unsigned long) ) + if ( noctets > sizeof(ber_len_t) ) return( LBER_DEFAULT ); - diff = sizeof(unsigned long) - noctets; + diff = sizeof(ber_len_t) - noctets; if ( (unsigned) ber_read( ber, (char *) &netlen + diff, noctets ) != noctets ) return( LBER_DEFAULT ); - *len = AC_NTOHL( netlen ); + *len = LBER_LEN_NTOH( netlen ); } else { *len = lc; } @@ -126,12 +129,12 @@ ber_skip_tag( BerElement *ber, unsigned long *len ) return( tag ); } -unsigned long +ber_tag_t ber_peek_tag( - LDAP_CONST BerElement *ber_in, /* not const per c-api-02 */ - unsigned long *len ) + LDAP_CONST BerElement *ber_in, + ber_len_t *len ) { - unsigned long tag; + ber_tag_t tag; BerElement *ber; assert( ber_in != NULL ); @@ -151,12 +154,13 @@ ber_peek_tag( return( tag ); } -static int -ber_getnint( BerElement *ber, long *num, int len ) +static ber_tag_t +ber_getnint( + BerElement *ber, + ber_int_t *num, + ber_len_t len ) { - int diff, sign, i; - long netnum; - char *p; + unsigned char buf[sizeof(ber_int_t)]; assert( ber != NULL ); assert( num != NULL ); @@ -170,32 +174,40 @@ ber_getnint( BerElement *ber, long *num, int len ) * extend after we read it in. */ - if ( (unsigned) len > sizeof(long) ) + if ( len > sizeof(ber_int_t) ) return( -1 ); - netnum = 0; - diff = sizeof(long) - len; - /* read into the low-order bytes of netnum */ - if ( ber_read( ber, ((char *) &netnum) + diff, len ) != len ) + /* read into the low-order bytes of our buffer */ + if ( (ber_len_t) ber_read( ber, buf, len ) != len ) { return( -1 ); + } + + if( len ) { + /* sign extend if necessary */ + ber_len_t i; + ber_int_t netnum = 0x80 & buf[0] ? -1 : 0; - /* sign extend if necessary */ - p = (char *) &netnum; - sign = (0x80 & *(p+diff) ); - if ( sign && ((unsigned) len < sizeof(long)) ) { - for ( i = 0; i < diff; i++ ) { - *(p+i) = (unsigned char) 0xff; + /* shift in the bytes */ + for( i=0 ; ibv_val = (char *) LBER_MALLOC( (size_t)len + 1 )) == NULL ) { + if ( ((*bv)->bv_val = (char *) LBER_MALLOC( len + 1 )) == NULL ) { LBER_FREE( *bv ); *bv = NULL; return( LBER_DEFAULT ); } - if ( (unsigned long) ber_read( ber, (*bv)->bv_val, len ) != len ) { + if ( (ber_len_t) ber_read( ber, (*bv)->bv_val, len ) != len ) { ber_bvfree( *bv ); *bv = NULL; return( LBER_DEFAULT ); @@ -343,10 +362,14 @@ ber_get_stringal( BerElement *ber, struct berval **bv ) return( tag ); } -unsigned long -ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen ) +ber_tag_t +ber_get_bitstringa( + BerElement *ber, + char **buf, + ber_len_t *blen ) { - unsigned long datalen, tag; + ber_len_t datalen; + ber_tag_t tag; unsigned char unusedbits; assert( ber != NULL ); @@ -361,7 +384,7 @@ ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen ) } --datalen; - if ( (*buf = (char *) LBER_MALLOC( (size_t)datalen )) == NULL ) + if ( (*buf = (char *) LBER_MALLOC( datalen )) == NULL ) return( LBER_DEFAULT ); if ( ber_read( ber, (char *)&unusedbits, 1 ) != 1 ) { @@ -380,10 +403,11 @@ ber_get_bitstringa( BerElement *ber, char **buf, unsigned long *blen ) return( tag ); } -unsigned long +ber_tag_t ber_get_null( BerElement *ber ) { - unsigned long len, tag; + ber_len_t len; + ber_tag_t tag; assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -397,11 +421,13 @@ ber_get_null( BerElement *ber ) return( tag ); } -unsigned long -ber_get_boolean( BerElement *ber, int *boolval ) +ber_tag_t +ber_get_boolean( + BerElement *ber, + ber_int_t *boolval ) { - long longbool; - int rc; + ber_int_t longbool; + ber_tag_t rc; assert( ber != NULL ); assert( boolval != NULL ); @@ -414,8 +440,11 @@ ber_get_boolean( BerElement *ber, int *boolval ) return( rc ); } -unsigned long -ber_first_element( BerElement *ber, unsigned long *len, char **last ) +ber_tag_t +ber_first_element( + BerElement *ber, + ber_len_t *len, + char **last ) { assert( ber != NULL ); assert( len != NULL ); @@ -436,8 +465,11 @@ ber_first_element( BerElement *ber, unsigned long *len, char **last ) return( ber_peek_tag( ber, len ) ); } -unsigned long -ber_next_element( BerElement *ber, unsigned long *len, char *last ) +ber_tag_t +ber_next_element( + BerElement *ber, + ber_len_t *len, + char *last ) { assert( ber != NULL ); assert( len != NULL ); @@ -453,7 +485,7 @@ ber_next_element( BerElement *ber, unsigned long *len, char *last ) } /* VARARGS */ -unsigned long +ber_tag_t ber_scanf #if HAVE_STDARG ( BerElement *ber, @@ -473,9 +505,12 @@ va_dcl char *last; char *s, **ss, ***sss; struct berval ***bv, **bvp, *bval; - int *i, j; - long *l; - unsigned long rc, tag, len; + ber_int_t *i; + int j; + ber_len_t *l; + ber_tag_t *t; + ber_tag_t rc, tag; + ber_len_t len; #ifdef HAVE_STDARG va_start( ap, fmt ); @@ -516,18 +551,18 @@ va_dcl break; case 'b': /* boolean */ - i = va_arg( ap, int * ); + i = va_arg( ap, ber_int_t * ); rc = ber_get_boolean( ber, i ); break; case 'e': /* enumerated */ case 'i': /* int */ - l = va_arg( ap, long * ); - rc = ber_get_int( ber, l ); + i = va_arg( ap, ber_int_t * ); + rc = ber_get_int( ber, i ); break; case 'l': /* length of next item */ - l = va_arg( ap, long * ); + l = va_arg( ap, ber_len_t * ); rc = ber_peek_tag( ber, l ); break; @@ -537,7 +572,7 @@ va_dcl case 's': /* octet string - in a buffer */ s = va_arg( ap, char * ); - l = va_arg( ap, long * ); + l = va_arg( ap, ber_len_t * ); rc = ber_get_stringb( ber, s, l ); break; @@ -554,18 +589,18 @@ va_dcl case 'B': /* bit string - allocate storage as needed */ ss = va_arg( ap, char ** ); - l = va_arg( ap, long * ); /* for length, in bits */ + l = va_arg( ap, ber_len_t * ); /* for length, in bits */ rc = ber_get_bitstringa( ber, ss, l ); break; case 't': /* tag of next item */ - l = va_arg( ap, long * ); - *l = rc = ber_peek_tag( ber, &len ); + t = va_arg( ap, ber_tag_t * ); + *t = rc = ber_peek_tag( ber, &len ); break; case 'T': /* skip tag of next item */ - l = va_arg( ap, long * ); - *l = rc = ber_skip_tag( ber, &len ); + t = va_arg( ap, ber_tag_t * ); + *t = rc = ber_skip_tag( ber, &len ); break; case 'v': /* sequence of strings */ @@ -666,20 +701,23 @@ va_dcl break; case 'b': /* boolean */ + case 'e': /* enumerated */ + case 'i': /* int */ (void) va_arg( ap, int * ); break; case 's': /* octet string - in a buffer */ (void) va_arg( ap, char * ); - (void) va_arg( ap, long * ); + (void) va_arg( ap, ber_len_t * ); break; - case 'e': /* enumerated */ - case 'i': /* int */ case 'l': /* length of next item */ + (void) va_arg( ap, ber_len_t * ); + break; + case 't': /* tag of next item */ case 'T': /* skip tag of next item */ - (void) va_arg( ap, long * ); + (void) va_arg( ap, ber_tag_t * ); break; case 'o': /* octet string in a supplied berval */ @@ -705,7 +743,7 @@ va_dcl LBER_FREE( *ss ); *ss = NULL; } - *(va_arg( ap, long * )) = 0; /* for length, in bits */ + *(va_arg( ap, ber_len_t * )) = 0; /* for length, in bits */ break; case 'v': /* sequence of strings */ diff --git a/libraries/liblber/encode.c b/libraries/liblber/encode.c index f3b5c4803b..4e5081a830 100644 --- a/libraries/liblber/encode.c +++ b/libraries/liblber/encode.c @@ -30,27 +30,32 @@ #include "lber-int.h" -static int ber_put_len LDAP_P(( BerElement *ber, - unsigned long len, int nosos )); +static int ber_put_len LDAP_P(( + BerElement *ber, + ber_len_t len, + int nosos )); -static int ber_start_seqorset LDAP_P(( BerElement *ber, - unsigned long tag )); +static int ber_start_seqorset LDAP_P(( + BerElement *ber, + ber_tag_t tag )); static int ber_put_seqorset LDAP_P(( BerElement *ber )); -static int ber_put_int_or_enum LDAP_P(( BerElement *ber, - long num, unsigned long tag )); +static int ber_put_int_or_enum LDAP_P(( + BerElement *ber, + ber_int_t num, + ber_tag_t tag )); -static int -ber_calc_taglen( unsigned long tag ) +static ber_len_t +ber_calc_taglen( ber_tag_t tag ) { int i; - unsigned long mask; + ber_tag_t mask; /* find the first non-all-zero byte in the tag */ - for ( i = sizeof(long) - 1; i > 0; i-- ) { - mask = (0xffUL << (i * 8)); + for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) { + mask = ((ber_tag_t)0xffU << (i * 8)); /* not all zero */ if ( tag & mask ) break; @@ -60,31 +65,38 @@ ber_calc_taglen( unsigned long tag ) } static int -ber_put_tag( BerElement *ber, unsigned long tag, int nosos ) +ber_put_tag( + BerElement *ber, + ber_tag_t tag, + int nosos ) { - int taglen; - unsigned long ntag; + int rc; + ber_len_t taglen; + ber_tag_t ntag; assert( ber != NULL ); assert( BER_VALID( ber ) ); taglen = ber_calc_taglen( tag ); - ntag = AC_HTONL( tag ); + ntag = LBER_TAG_HTON( tag ); + + rc = ber_write( ber, + ((char *) &ntag) + sizeof(ber_tag_t) - taglen, + taglen, nosos ); - return( ber_write( ber, ((char *) &ntag) + sizeof(long) - taglen, - taglen, nosos ) ); + return rc; } -static int -ber_calc_lenlen( unsigned long len ) +static ber_len_t +ber_calc_lenlen( ber_len_t len ) { /* * short len if it's less than 128 - one byte giving the len, * with bit 8 0. */ - if ( len <= 0x7FUL ) + if ( len <= (ber_len_t) 0x7FU ) return( 1 ); /* @@ -92,23 +104,23 @@ ber_calc_lenlen( unsigned long len ) * length of the length, followed by the length itself. */ - if ( len <= 0xffUL ) + if ( len <= (ber_len_t) 0xffU ) return( 2 ); - if ( len <= 0xffffUL ) + if ( len <= (ber_len_t) 0xffffU ) return( 3 ); - if ( len <= 0xffffffUL ) + if ( len <= (ber_len_t) 0xffffffU ) return( 4 ); return( 5 ); } static int -ber_put_len( BerElement *ber, unsigned long len, int nosos ) +ber_put_len( BerElement *ber, ber_len_t len, int nosos ) { int i; char lenlen; - unsigned long mask; - unsigned long netlen; + ber_len_t mask; + ber_len_t netlen; assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -119,7 +131,7 @@ ber_put_len( BerElement *ber, unsigned long len, int nosos ) */ if ( len <= 127 ) { - netlen = AC_HTONL( len ); + netlen = LBER_LEN_HTON( len ); return( ber_write( ber, (char *) &netlen + sizeof(long) - 1, 1, nosos ) ); } @@ -130,8 +142,8 @@ ber_put_len( BerElement *ber, unsigned long len, int nosos ) */ /* find the first non-all-zero byte */ - for ( i = sizeof(long) - 1; i > 0; i-- ) { - mask = (0xffUL << (i * 8)); + for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) { + mask = (0xffU << (i * 8)); /* not all zero */ if ( len & mask ) break; @@ -146,8 +158,8 @@ ber_put_len( BerElement *ber, unsigned long len, int nosos ) return( -1 ); /* write the length itself */ - netlen = AC_HTONL( len ); - if ( ber_write( ber, (char *) &netlen + (sizeof(long) - i), i, nosos ) + netlen = LBER_LEN_HTON( len ); + if ( ber_write( ber, (char *) &netlen + (sizeof(ber_len_t) - i), i, nosos ) != i ) return( -1 ); @@ -155,11 +167,14 @@ ber_put_len( BerElement *ber, unsigned long len, int nosos ) } static int -ber_put_int_or_enum( BerElement *ber, long num, unsigned long tag ) +ber_put_int_or_enum( + BerElement *ber, + ber_int_t num, + ber_tag_t tag ) { - int i, sign, taglen; - int len, lenlen; - long netnum, mask; + int i, sign; + ber_len_t len, lenlen, taglen; + ber_int_t netnum, mask; assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -170,8 +185,8 @@ ber_put_int_or_enum( BerElement *ber, long num, unsigned long tag ) * high bit is set - look for first non-all-one byte * high bit is clear - look for first non-all-zero byte */ - for ( i = sizeof(long) - 1; i > 0; i-- ) { - mask = (0xffUL << (i * 8)); + for ( i = sizeof(ber_int_t) - 1; i > 0; i-- ) { + mask = (0xffU << (i * 8)); if ( sign ) { /* not all ones */ @@ -188,7 +203,7 @@ ber_put_int_or_enum( BerElement *ber, long num, unsigned long tag ) * we now have the "leading byte". if the high bit on this * byte matches the sign bit, we need to "back up" a byte. */ - mask = (num & (0x80UL << (i * 8))); + mask = (num & (0x80U << (i * 8))); if ( (mask && !sign) || (sign && !mask) ) i++; @@ -200,8 +215,8 @@ ber_put_int_or_enum( BerElement *ber, long num, unsigned long tag ) if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ) return( -1 ); i++; - netnum = AC_HTONL( num ); - if ( ber_write( ber, (char *) &netnum + (sizeof(long) - i), i, 0 ) + netnum = LBER_INT_HTON( num ); + if ( ber_write( ber, (char *) &netnum + (sizeof(ber_int_t) - i), i, 0 ) != i ) return( -1 ); @@ -210,7 +225,10 @@ ber_put_int_or_enum( BerElement *ber, long num, unsigned long tag ) } int -ber_put_enum( BerElement *ber, long num, unsigned long tag ) +ber_put_enum( + BerElement *ber, + ber_int_t num, + ber_tag_t tag ) { assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -222,7 +240,10 @@ ber_put_enum( BerElement *ber, long num, unsigned long tag ) } int -ber_put_int( BerElement *ber, long num, unsigned long tag ) +ber_put_int( + BerElement *ber, + ber_int_t num, + ber_tag_t tag ) { assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -237,10 +258,11 @@ int ber_put_ostring( BerElement *ber, LDAP_CONST char *str, - unsigned long len, - unsigned long tag ) + ber_len_t len, + ber_tag_t tag ) { - int taglen, lenlen, rc; + ber_len_t taglen, lenlen; + int rc; #ifdef STR_TRANSLATION int free_str; #endif /* STR_TRANSLATION */ @@ -285,11 +307,12 @@ ber_put_ostring( return( rc ); } + int ber_put_berval( BerElement *ber, LDAP_CONST struct berval *bv, - unsigned long tag ) + ber_tag_t tag ) { assert( ber != NULL ); assert( bv != NULL ); @@ -307,7 +330,7 @@ int ber_put_string( BerElement *ber, LDAP_CONST char *str, - unsigned long tag ) + ber_tag_t tag ) { assert( ber != NULL ); assert( str != NULL ); @@ -321,10 +344,10 @@ int ber_put_bitstring( BerElement *ber, LDAP_CONST char *str, - unsigned long blen /* in bits */, - unsigned long tag ) + ber_len_t blen /* in bits */, + ber_tag_t tag ) { - int taglen, lenlen, len; + ber_len_t taglen, lenlen, len; unsigned char unusedbits; assert( ber != NULL ); @@ -346,7 +369,7 @@ ber_put_bitstring( if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 ) return( -1 ); - if ( ber_write( ber, str, len, 0 ) != len ) + if ( (ber_len_t) ber_write( ber, str, len, 0 ) != len ) return( -1 ); /* return length of tag + length + unused bit count + contents */ @@ -354,9 +377,9 @@ ber_put_bitstring( } int -ber_put_null( BerElement *ber, unsigned long tag ) +ber_put_null( BerElement *ber, ber_tag_t tag ) { - int taglen; + ber_len_t taglen; assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -374,10 +397,13 @@ ber_put_null( BerElement *ber, unsigned long tag ) } int -ber_put_boolean( BerElement *ber, int boolval, unsigned long tag ) +ber_put_boolean( + BerElement *ber, + ber_int_t boolval, + ber_tag_t tag ) { - int taglen; - unsigned char trueval = 0xffU; + ber_len_t taglen; + unsigned char trueval = 0xFFU; unsigned char falseval = 0x00U; assert( ber != NULL ); @@ -402,7 +428,9 @@ ber_put_boolean( BerElement *ber, int boolval, unsigned long tag ) #define FOUR_BYTE_LEN 5 static int -ber_start_seqorset( BerElement *ber, unsigned long tag ) +ber_start_seqorset( + BerElement *ber, + ber_tag_t tag ) { Seqorset *new; @@ -411,11 +439,11 @@ ber_start_seqorset( BerElement *ber, unsigned long tag ) new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) ); - if ( new == NULLSEQORSET ) + if ( new == NULL ) return( -1 ); new->sos_ber = ber; - if ( ber->ber_sos == NULLSEQORSET ) + if ( ber->ber_sos == NULL ) new->sos_first = ber->ber_ptr; else new->sos_first = ber->ber_sos->sos_ptr; @@ -431,7 +459,7 @@ ber_start_seqorset( BerElement *ber, unsigned long tag ) } int -ber_start_seq( BerElement *ber, unsigned long tag ) +ber_start_seq( BerElement *ber, ber_tag_t tag ) { assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -443,7 +471,7 @@ ber_start_seq( BerElement *ber, unsigned long tag ) } int -ber_start_set( BerElement *ber, unsigned long tag ) +ber_start_set( BerElement *ber, ber_tag_t tag ) { assert( ber != NULL ); assert( BER_VALID( ber ) ); @@ -457,8 +485,8 @@ ber_start_set( BerElement *ber, unsigned long tag ) static int ber_put_seqorset( BerElement *ber ) { - unsigned long len, netlen; - int taglen, lenlen; + ber_len_t len, netlen; + ber_len_t taglen, lenlen; unsigned char ltag = 0x80U + FOUR_BYTE_LEN - 1; Seqorset *next; Seqorset **sos = &ber->ber_sos; @@ -475,8 +503,8 @@ ber_put_seqorset( BerElement *ber ) */ len = (*sos)->sos_clen; - netlen = AC_HTONL( len ); - if ( sizeof(long) > 4 && len > 0xffffffffUL ) + netlen = LBER_LEN_HTON( len ); + if ( sizeof(ber_len_t) > 4 && len > 0xffffffffUL ) return( -1 ); if ( ber->ber_options & LBER_USE_DER ) { @@ -485,7 +513,7 @@ ber_put_seqorset( BerElement *ber ) lenlen = FOUR_BYTE_LEN; } - if ( (next = (*sos)->sos_next) == NULLSEQORSET ) { + if ( (next = (*sos)->sos_next) == NULL ) { /* write the tag */ if ( (taglen = ber_put_tag( ber, (*sos)->sos_tag, 1 )) == -1 ) return( -1 ); @@ -520,18 +548,18 @@ ber_put_seqorset( BerElement *ber ) /* The ber_ptr is at the set/seq start - move it to the end */ (*sos)->sos_ber->ber_ptr += len; } else { - unsigned long ntag; + ber_tag_t ntag; /* the tag */ taglen = ber_calc_taglen( (*sos)->sos_tag ); - ntag = AC_HTONL( (*sos)->sos_tag ); + ntag = LBER_TAG_HTON( (*sos)->sos_tag ); SAFEMEMCPY( (*sos)->sos_first, (char *) &ntag + - sizeof(long) - taglen, taglen ); + sizeof(ber_tag_t) - taglen, taglen ); if ( ber->ber_options & LBER_USE_DER ) { ltag = (lenlen == 1) ? (unsigned char) len - : (unsigned char) (0x80UL + (lenlen - 1)); + : (unsigned char) (0x80U + (lenlen - 1)); } /* one byte of length length */ @@ -541,7 +569,7 @@ ber_put_seqorset( BerElement *ber ) if (lenlen > 1) { /* Write the length itself */ SAFEMEMCPY( (*sos)->sos_first + 2, - (char *)&netlen + sizeof(unsigned long) - + (char *)&netlen + sizeof(ber_len_t) - (lenlen - 1), lenlen - 1 ); } @@ -558,7 +586,7 @@ ber_put_seqorset( BerElement *ber ) } else { /* the length itself */ SAFEMEMCPY( (*sos)->sos_first + taglen + 1, - (char *) &netlen + sizeof(long) - + (char *) &netlen + sizeof(ber_len_t) - (FOUR_BYTE_LEN - 1), FOUR_BYTE_LEN - 1 ); } @@ -610,8 +638,9 @@ va_dcl #endif char *s, **ss; struct berval *bv, **bvp; - int rc, i; - unsigned long len; + int rc; + ber_int_t i; + ber_len_t len; #ifdef HAVE_STDARG va_start( ap, fmt ); @@ -639,17 +668,17 @@ va_dcl } break; case 'b': /* boolean */ - i = va_arg( ap, int ); + i = va_arg( ap, ber_int_t ); rc = ber_put_boolean( ber, i, ber->ber_tag ); break; case 'i': /* int */ - i = va_arg( ap, int ); + i = va_arg( ap, ber_int_t ); rc = ber_put_int( ber, i, ber->ber_tag ); break; case 'e': /* enumeration */ - i = va_arg( ap, int ); + i = va_arg( ap, ber_int_t ); rc = ber_put_enum( ber, i, ber->ber_tag ); break; @@ -659,7 +688,7 @@ va_dcl case 'o': /* octet string (non-null terminated) */ s = va_arg( ap, char * ); - len = va_arg( ap, int ); + len = va_arg( ap, ber_len_t ); rc = ber_put_ostring( ber, s, len, ber->ber_tag ); break; @@ -681,7 +710,7 @@ va_dcl break; case 't': /* tag for the next element */ - ber->ber_tag = va_arg( ap, unsigned long ); + ber->ber_tag = va_arg( ap, ber_tag_t ); ber->ber_usertag = 1; break; diff --git a/libraries/liblber/io.c b/libraries/liblber/io.c index 607bb753b5..a29cdf54d5 100644 --- a/libraries/liblber/io.c +++ b/libraries/liblber/io.c @@ -36,8 +36,14 @@ #include "lber-int.h" -static long BerRead LDAP_P(( Sockbuf *sb, char *buf, long len )); -static int ber_realloc LDAP_P(( BerElement *ber, unsigned long len )); +static ber_slen_t BerRead LDAP_P(( + Sockbuf *sb, + char *buf, + ber_len_t len )); + +static int ber_realloc LDAP_P(( + BerElement *ber, + ber_len_t len )); #define EXBUFSIZ 1024 @@ -49,11 +55,14 @@ static int ber_realloc LDAP_P(( BerElement *ber, unsigned long len )); # define MAX_BERBUFSIZE 65535 #endif -static long -BerRead( Sockbuf *sb, char *buf, long len ) +static ber_slen_t +BerRead( + Sockbuf *sb, + char *buf, + ber_len_t len ) { - int c; - long nread = 0; + ber_slen_t c; + ber_slen_t nread = 0; assert( sb != NULL ); assert( buf != NULL ); @@ -74,10 +83,13 @@ BerRead( Sockbuf *sb, char *buf, long len ) return( nread ); } -long -ber_read( BerElement *ber, char *buf, unsigned long len ) +ber_slen_t +ber_read( + BerElement *ber, + char *buf, + ber_len_t len ) { - unsigned long actuallen, nleft; + ber_len_t actuallen, nleft; assert( ber != NULL ); assert( buf != NULL ); @@ -87,18 +99,18 @@ ber_read( BerElement *ber, char *buf, unsigned long len ) nleft = ber->ber_end - ber->ber_ptr; actuallen = nleft < len ? nleft : len; - SAFEMEMCPY( buf, ber->ber_ptr, (size_t)actuallen ); + SAFEMEMCPY( buf, ber->ber_ptr, actuallen ); ber->ber_ptr += actuallen; - return( (long)actuallen ); + return( (ber_slen_t) actuallen ); } -long +ber_slen_t ber_write( BerElement *ber, LDAP_CONST char *buf, - unsigned long len, + ber_len_t len, int nosos ) { assert( ber != NULL ); @@ -113,7 +125,8 @@ ber_write( } SAFEMEMCPY( ber->ber_ptr, buf, (size_t)len ); ber->ber_ptr += len; - return( len ); + return( (ber_slen_t) len ); + } else { if ( ber->ber_sos->sos_ptr + len > ber->ber_end ) { if ( ber_realloc( ber, len ) != 0 ) @@ -122,14 +135,14 @@ ber_write( SAFEMEMCPY( ber->ber_sos->sos_ptr, buf, (size_t)len ); ber->ber_sos->sos_ptr += len; ber->ber_sos->sos_clen += len; - return( len ); + return( (ber_slen_t) len ); } } static int -ber_realloc( BerElement *ber, unsigned long len ) +ber_realloc( BerElement *ber, ber_len_t len ) { - unsigned long need, have, total; + ber_len_t need, have, total; Seqorset *s; long off; char *oldbuf; @@ -163,7 +176,7 @@ ber_realloc( BerElement *ber, unsigned long len ) if ( ber->ber_buf != oldbuf ) { ber->ber_ptr = ber->ber_buf + (ber->ber_ptr - oldbuf); - for ( s = ber->ber_sos; s != NULLSEQORSET; s = s->sos_next ) { + for ( s = ber->ber_sos; s != NULL; s = s->sos_next ) { off = s->sos_first - oldbuf; s->sos_first = ber->ber_buf + off; @@ -200,7 +213,8 @@ ber_free( BerElement *ber, int freebuf ) int ber_flush( Sockbuf *sb, BerElement *ber, int freeit ) { - long nwritten, towrite, rc; + ber_len_t nwritten, towrite; + ber_slen_t rc; assert( sb != NULL ); assert( ber != NULL ); @@ -257,8 +271,8 @@ ber_alloc_t( int options ) ber = (BerElement *) LBER_CALLOC( 1, sizeof(BerElement) ); - if ( ber == NULLBER ) - return( NULLBER ); + if ( ber == NULL ) + return( NULL ); ber->ber_valid = LBER_VALID_BERELEMENT; ber->ber_tag = LBER_DEFAULT; @@ -336,13 +350,13 @@ ber_init( struct berval *bv ) ber = ber_alloc_t( 0 ); - if( ber == NULLBER ) { + if( ber == NULL ) { /* allocation failed */ return ( NULL ); } /* copy the data */ - if ( ( (unsigned int) ber_write ( ber, bv->bv_val, bv->bv_len, 0 )) != bv->bv_len ) { + if ( ( (ber_len_t) ber_write ( ber, bv->bv_val, bv->bv_len, 0 )) != bv->bv_len ) { /* write failed, so free and return NULL */ ber_free( ber, 1 ); return( NULL ); @@ -383,14 +397,14 @@ int ber_flatten( } else { /* copy the berval */ - ptrdiff_t len = ber->ber_ptr - ber->ber_buf; + ber_len_t len = ber->ber_ptr - ber->ber_buf; if ( (bv->bv_val = (char *) LBER_MALLOC( len + 1 )) == NULL ) { ber_bvfree( bv ); return( -1 ); } - SAFEMEMCPY( bv->bv_val, ber->ber_buf, (size_t)len ); + SAFEMEMCPY( bv->bv_val, ber->ber_buf, len ); bv->bv_val[len] = '\0'; bv->bv_len = len; } @@ -417,11 +431,11 @@ ber_reset( BerElement *ber, int was_writing ) #if 0 /* return the tag - LBER_DEFAULT returned means trouble */ -static unsigned long +static ber_tag_t get_tag( Sockbuf *sb ) { unsigned char xbyte; - unsigned long tag; + ber_tag_t tag; char *tagp; unsigned int i; @@ -432,11 +446,11 @@ get_tag( Sockbuf *sb ) return( LBER_DEFAULT ); if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK ) - return( (unsigned long) xbyte ); + return( (ber_tag_t) xbyte ); tagp = (char *) &tag; tagp[0] = xbyte; - for ( i = 1; i < sizeof(long); i++ ) { + for ( i = 1; i < sizeof(ber_tag_t); i++ ) { if ( ber_pvt_sb_read( sb, (char *) &xbyte, 1 ) != 1 ) return( LBER_DEFAULT ); @@ -447,11 +461,11 @@ get_tag( Sockbuf *sb ) } /* tag too big! */ - if ( i == sizeof(long) ) + if ( i == sizeof(ber_tag_t) ) return( LBER_DEFAULT ); /* want leading, not trailing 0's */ - return( tag >> (sizeof(long) - i - 1) ); + return( tag >> (sizeof(ber_tag_t) - i - 1) ); } #endif @@ -461,8 +475,11 @@ get_tag( Sockbuf *sb ) * a full packet is read. */ -unsigned long -ber_get_next( Sockbuf *sb, unsigned long *len, BerElement *ber ) +ber_tag_t +ber_get_next( + Sockbuf *sb, + ber_len_t *len, + BerElement *ber ) { assert( sb != NULL ); assert( len != NULL ); @@ -531,7 +548,7 @@ get_lenbyte: return LBER_DEFAULT; if (c & 0x80U) { int len = c & 0x7fU; - if ( (len==0) || ((unsigned) len>sizeof( ber->ber_len ) ) ) { + if ( (len==0) || ( len>sizeof( ber->ber_len ) ) ) { errno = ERANGE; return LBER_DEFAULT; } @@ -544,8 +561,8 @@ get_lenbyte: } } if (PTR_IN_VAR(ber->ber_rwptr, ber->ber_len)) { - int res; - int to_go; + ber_slen_t res; + ber_slen_t to_go; to_go = (char *) &ber->ber_len + sizeof( ber->ber_len ) - ber->ber_rwptr; assert( to_go > 0 ); @@ -555,7 +572,7 @@ get_lenbyte: ber->ber_rwptr += res; if (res==to_go) { /* convert length. */ - ber->ber_len = AC_NTOHL( ber->ber_len ); + ber->ber_len = LBER_LEN_NTOH( ber->ber_len ); goto fill_buffer; } else { #if defined( EWOULDBLOCK ) @@ -581,8 +598,8 @@ fill_buffer: ber->ber_end = ber->ber_buf + ber->ber_len; } if ((ber->ber_rwptr>=ber->ber_buf) && (ber->ber_rwptrber_end)) { - int res; - int to_go; + ber_slen_t res; + ber_slen_t to_go; to_go = ber->ber_end - ber->ber_rwptr; assert( to_go > 0 ); diff --git a/libraries/liblber/lber-int.h b/libraries/liblber/lber-int.h index cbe28423eb..cb68944ede 100644 --- a/libraries/liblber/lber-int.h +++ b/libraries/liblber/lber-int.h @@ -23,6 +23,15 @@ LDAP_BEGIN_DECL +/* these have to match lber types settings */ +#define LBER_INT_HTON(i) AC_HTONL(i) +#define LBER_INT_NTOH(i) AC_NTOHL(i) +#define LBER_LEN_HTON(l) AC_HTONL(l) +#define LBER_LEN_NTOH(l) AC_NTOHL(l) +#define LBER_TAG_HTON(t) AC_HTONL(t) +#define LBER_TAG_NTOH(t) AC_NTOHL(t) + + struct lber_options { short lbo_valid; #define LBER_UNINITIALIZED 0x0 @@ -43,10 +52,10 @@ struct berelement { #define ber_options ber_opts.lbo_options #define ber_debug ber_opts.lbo_debug - int ber_usertag; + ber_tag_t ber_usertag; - unsigned long ber_tag; - unsigned long ber_len; + ber_tag_t ber_tag; + ber_len_t ber_len; char *ber_buf; char *ber_ptr; @@ -58,7 +67,7 @@ struct berelement { BERTranslateProc ber_decode_translate_proc; }; #define BER_VALID(ber) ((ber)->ber_valid==LBER_VALID_BERELEMENT) -#define NULLBER ((BerElement *) 0) + #define ber_pvt_ber_bytes(ber) ((ber)->ber_ptr - (ber)->ber_buf) #define ber_pvt_ber_remaining(ber) ((ber)->ber_end - (ber)->ber_ptr) @@ -69,8 +78,8 @@ struct sockbuf_io { int (*sbi_setup)( struct sockbuf * sb, void *arg ); int (*sbi_remove)( struct sockbuf *sb ); - long (*sbi_read)( struct sockbuf *sb, void *buf, long len ); - long (*sbi_write)( struct sockbuf *sb, void *buf, long len ); + ber_slen_t (*sbi_read)( struct sockbuf *sb, void *buf, ber_len_t len ); + ber_slen_t (*sbi_write)( struct sockbuf *sb, void *buf, ber_len_t len ); int (*sbi_close)( struct sockbuf *sb ); }; @@ -85,9 +94,9 @@ struct sockbuf_sec { }; struct sockbuf_buf { - long buf_size; - long buf_ptr; - long buf_end; + ber_len_t buf_size; + ber_len_t buf_ptr; + ber_len_t buf_end; char *buf_base; }; @@ -121,12 +130,9 @@ struct sockbuf { void *sb_sdata; /* security-layer data pointer */ Sockbuf_Sec *sb_sec; #endif - -#ifndef MACOS - int sb_sd; -#else /* MACOS */ - void *sb_sd; -#endif /* MACOS */ + + ber_socket_t sb_sd; + #ifdef DEADWOOD long sb_max_incoming; #endif @@ -134,7 +140,7 @@ struct sockbuf { #ifdef LDAP_SASL Sockbuf_Buf sb_sec_buf_in; Sockbuf_Buf sb_sec_buf_out; - long sb_sec_prev_len; + ber_len_t sb_sec_prev_len; #endif }; #define SOCKBUF_VALID(ber) ((sb)->sb_valid==LBER_VALID_SOCKBUF) @@ -143,7 +149,7 @@ struct sockbuf { #define ber_pvt_sb_get_desc( sb ) ((sb)->sb_sd) #define ber_pvt_sb_set_desc( sb, val ) ((sb)->sb_sd =(val)) -#define ber_pvt_sb_in_use( sb ) ((sb)->sb_sd!=-1) +#define ber_pvt_sb_in_use( sb ) ((sb)->sb_sd != AC_SOCKET_INVALID) #ifdef USE_SASL #define ber_pvt_sb_data_ready( sb ) \ @@ -157,13 +163,13 @@ struct sockbuf { struct seqorset { BerElement *sos_ber; - unsigned long sos_clen; - unsigned long sos_tag; + ber_len_t sos_clen; + ber_tag_t sos_tag; char *sos_first; char *sos_ptr; struct seqorset *sos_next; }; -#define NULLSEQORSET ((Seqorset *) 0) + /* * bprint.c @@ -175,7 +181,7 @@ ber_log_bprint LDAP_P(( int errlvl, int loglvl, const char *data, - int len )); + ber_len_t len )); LDAP_F( int ) ber_log_dump LDAP_P(( @@ -242,11 +248,11 @@ ber_pvt_sb_set_nonblock LDAP_P(( Sockbuf *sb, int nb )); LDAP_F( int ) ber_pvt_sb_set_readahead LDAP_P(( Sockbuf *sb, int rh )); -LDAP_F( long ) -ber_pvt_sb_read LDAP_P(( Sockbuf *sb, void *buf, long len )); +LDAP_F( ber_slen_t ) +ber_pvt_sb_read LDAP_P(( Sockbuf *sb, void *buf, ber_len_t len )); -LDAP_F( long ) -ber_pvt_sb_write LDAP_P(( Sockbuf *sb, void *buf, long len )); +LDAP_F( ber_slen_t ) +ber_pvt_sb_write LDAP_P(( Sockbuf *sb, void *buf, ber_len_t len )); LDAP_F( int ) ber_pvt_sb_udp_set_dst LDAP_P((Sockbuf *sb, void *addr )); diff --git a/libraries/liblber/liblber.dsp b/libraries/liblber/liblber.dsp index cd6997d682..02b855d3e3 100644 --- a/libraries/liblber/liblber.dsp +++ b/libraries/liblber/liblber.dsp @@ -151,6 +151,10 @@ SOURCE=..\..\include\lber_pvt.h # End Source File # Begin Source File +SOURCE=..\..\include\lber_types.h +# End Source File +# Begin Source File + SOURCE=.\memory.c # End Source File # Begin Source File diff --git a/libraries/liblber/memory.c b/libraries/liblber/memory.c index 7fedad324f..cdc5549ae5 100644 --- a/libraries/liblber/memory.c +++ b/libraries/liblber/memory.c @@ -15,13 +15,17 @@ #if LDAP_MEMORY_DEBUG struct ber_mem_hdr { union bmu_align_u { + ber_len_t bmu_len_t; + ber_tag_t bmu_tag_t; + ber_int_t bmu_int_t; + size_t bmu_size_t; void * bmu_voidp; double bmu_double; long bmu_long; char bmu_char[4]; } ber_align; -#define bm_junk ber_align.bmu_size_t +#define bm_junk ber_align.bmu_len_t #define bm_data ber_align.bmu_char[1] }; #define BER_MEM_JUNK 0xddeeddeeU @@ -104,7 +108,7 @@ ber_memvfree( void **vec ) void * -ber_memalloc( size_t s ) +ber_memalloc( ber_len_t s ) { ber_int_options.lbo_valid = LBER_INITIALIZED; @@ -138,7 +142,7 @@ ber_memalloc( size_t s ) void * -ber_memcalloc( size_t n, size_t s ) +ber_memcalloc( ber_len_t n, ber_len_t s ) { ber_int_options.lbo_valid = LBER_INITIALIZED; @@ -171,7 +175,7 @@ ber_memcalloc( size_t n, size_t s ) void * -ber_memrealloc( void* p, size_t s ) +ber_memrealloc( void* p, ber_len_t s ) { ber_int_options.lbo_valid = LBER_INITIALIZED; @@ -280,7 +284,7 @@ ber_bvdup( return NULL; } - SAFEMEMCPY( new->bv_val, bv->bv_val, (size_t) bv->bv_len ); + SAFEMEMCPY( new->bv_val, bv->bv_val, bv->bv_len ); new->bv_val[bv->bv_len] = '\0'; new->bv_len = bv->bv_len; diff --git a/libraries/liblber/sockbuf.c b/libraries/liblber/sockbuf.c index 78251b361a..37b796bc72 100644 --- a/libraries/liblber/sockbuf.c +++ b/libraries/liblber/sockbuf.c @@ -45,8 +45,8 @@ #define sockbuf_io_read( sb, buf, len ) \ ((sb)->sb_io->sbi_read( (sb), (buf), (len) )) -static long have_no_read( Sockbuf *sb, void *buf, long len ); -static long have_no_write( Sockbuf *sb, void *buf, long len ); +static ber_slen_t have_no_read( Sockbuf *sb, void *buf, ber_len_t len ); +static ber_slen_t have_no_write( Sockbuf *sb, void *buf, ber_len_t len ); static int have_no_close( Sockbuf *sb ); static Sockbuf_IO sb_IO_None= @@ -103,17 +103,17 @@ status_is_ok( Sockbuf *sb ) #endif #ifdef USE_SASL -static long +static ber_len_t packet_length( char *buf ) { - long size; + ber_len_t size; assert( buf != NULL ); - size = (((unsigned long)buf[0])<<24)| - (((unsigned long)buf[1])<<16)| - (((unsigned long)buf[2])<<8)| - (((unsigned long)buf[3])); + size = (((ber_len_t)buf[0])<<24)| + (((ber_len_t)buf[1])<<16)| + (((ber_len_t)buf[2])<<8)| + (((ber_len_t)buf[3])); if ((size<0) || (size>MAX_BUF_SIZE)) { /* somebody is trying to mess me up. */ @@ -128,9 +128,9 @@ packet_length( char *buf ) #endif static int -grow_buffer( Sockbuf_Buf * buf, long minsize ) +grow_buffer( Sockbuf_Buf * buf, ber_len_t minsize ) { - long pw;; + ber_len_t pw;; assert( buf != NULL ); @@ -165,8 +165,8 @@ grow_buffer( Sockbuf_Buf * buf, long minsize ) } #ifdef USE_SASL -static long -sockbuf_sec_release( Sockbuf *sb, char *buf, long len ) +static ber_slen_t +sockbuf_sec_release( Sockbuf *sb, char *buf, ber_len_t len ) { /* when this is called: * sb->sb_sec_buf_in.buf_base points to a packet. @@ -304,10 +304,10 @@ sockbuf_sec_protect( Sockbuf *sb, char *buf, long len ) } #endif -static long -sockbuf_copy_out( Sockbuf *sb, char **buf, long len ) +static ber_len_t +sockbuf_copy_out( Sockbuf *sb, char **buf, ber_len_t len ) { - long blen = (sb->sb_buf.buf_end - sb->sb_buf.buf_ptr ); + ber_len_t blen = (sb->sb_buf.buf_end - sb->sb_buf.buf_ptr ); assert( buf != NULL ); @@ -316,7 +316,7 @@ sockbuf_copy_out( Sockbuf *sb, char **buf, long len ) assert( status_is_ok(sb) ); if (blen) { - long rlen = (blensb_buf.buf_base + sb->sb_buf.buf_ptr, rlen ); sb->sb_buf.buf_ptr+=rlen; *buf+=rlen; @@ -346,7 +346,7 @@ Sockbuf *ber_sockbuf_alloc( void ) return sb; } -Sockbuf *ber_sockbuf_alloc_fd( int fd ) +Sockbuf *ber_sockbuf_alloc_fd( ber_socket_t fd ) { Sockbuf *sb = ber_sockbuf_alloc(); @@ -365,11 +365,11 @@ void ber_sockbuf_free( Sockbuf *sb ) LBER_FREE(sb); } -long -ber_pvt_sb_read( Sockbuf *sb, void *buf_arg, long len ) +ber_slen_t +ber_pvt_sb_read( Sockbuf *sb, void *buf_arg, ber_len_t len ) { char *buf; - long ret; + ber_slen_t ret; assert( buf_arg != NULL ); assert( sb != NULL ); @@ -400,7 +400,7 @@ ber_pvt_sb_read( Sockbuf *sb, void *buf_arg, long len ) #ifdef USE_SASL if (sb->sb_sec) { - int max; + ber_slen_t max; assert( sb->sb_sec->sbs_release ); assert( sb->sb_sec_buf_in.buf_base ); if (sb->sb_read_ahead) { @@ -477,9 +477,9 @@ decode_packet: } else { #endif if (sb->sb_read_ahead) { - long max; + ber_slen_t max; max = sb->sb_buf.buf_size - sb->sb_buf.buf_end; - if (max>len) { + if (max> (ber_slen_t) len) { for(;;) { ret = sockbuf_io_read( sb, sb->sb_buf.buf_base + @@ -556,10 +556,10 @@ long sockbuf_do_write( Sockbuf *sb ) } #endif -long ber_pvt_sb_write( Sockbuf *sb, void *buf, long len_arg ) +ber_slen_t ber_pvt_sb_write( Sockbuf *sb, void *buf, ber_len_t len_arg ) { - long ret; - long len = len_arg; + ber_slen_t ret; + ber_len_t len = len_arg; assert( buf != NULL ); assert( sb != NULL ); @@ -849,8 +849,8 @@ int ber_pvt_sb_clear_io( Sockbuf *sb ) * Support for TCP */ -static long -stream_read( Sockbuf *sb, void *buf, long len ) +static ber_slen_t +stream_read( Sockbuf *sb, void *buf, ber_len_t len ) { assert( sb != NULL); assert( SOCKBUF_VALID( sb ) ); @@ -892,8 +892,8 @@ stream_read( Sockbuf *sb, void *buf, long len ) #endif } -static long -stream_write( Sockbuf *sb, void *buf, long len ) +static ber_slen_t +stream_write( Sockbuf *sb, void *buf, ber_len_t len ) { assert( sb != NULL); assert( SOCKBUF_VALID( sb ) ); @@ -994,11 +994,11 @@ dgram_release( Sockbuf *sb ) return 0; } -static long -dgram_read( Sockbuf *sb, void *buf, long len ) +static ber_slen_t +dgram_read( Sockbuf *sb, void *buf, ber_len_t len ) { #ifdef LDAP_CONNECTIONLESS - long rc; + ber_slen_t rc; int addrlen; struct dgram_data *dd; @@ -1025,11 +1025,11 @@ dgram_read( Sockbuf *sb, void *buf, long len ) # endif /* LDAP_CONNECTIONLESS */ } -static long -dgram_write( Sockbuf *sb, void *buf, long len ) +static ber_slen_t +dgram_write( Sockbuf *sb, void *buf, ber_len_t len ) { #ifdef LDAP_CONNECTIONLESS - int rc; + ber_slen_t rc; struct dgram_data *dd; assert( sb != NULL ); @@ -1106,8 +1106,8 @@ void *ber_pvt_sb_udp_get_src( Sockbuf *sb ) * break the servers. */ -static long -have_no_read( Sockbuf *sb, void *buf, long len ) +static ber_slen_t +have_no_read( Sockbuf *sb, void *buf, ber_len_t len ) { assert( sb != NULL ); assert( SOCKBUF_VALID( sb ) ); @@ -1118,8 +1118,8 @@ have_no_read( Sockbuf *sb, void *buf, long len ) return -1; } -static long -have_no_write( Sockbuf *sb, void *buf, long len ) +static ber_slen_t +have_no_write( Sockbuf *sb, void *buf, ber_len_t len ) { assert( sb != NULL ); assert( SOCKBUF_VALID( sb ) ); diff --git a/libraries/libldap/abandon.c b/libraries/libldap/abandon.c index 39ecfe157e..04066e4882 100644 --- a/libraries/libldap/abandon.c +++ b/libraries/libldap/abandon.c @@ -28,8 +28,8 @@ static int do_abandon LDAP_P(( LDAP *ld, - int origid, - int msgid, + ber_int_t origid, + ber_int_t msgid, LDAPControl **sctrls, LDAPControl **cctrls)); @@ -84,14 +84,14 @@ ldap_abandon( LDAP *ld, int msgid ) static int do_abandon( LDAP *ld, - int origid, - int msgid, + ber_int_t origid, + ber_int_t msgid, LDAPControl **sctrls, LDAPControl **cctrls) { BerElement *ber; int i, err, sendabandon; - unsigned int *old_abandon; + ber_int_t *old_abandon; Sockbuf *sb; LDAPRequest *lr; @@ -131,20 +131,20 @@ do_abandon( err = 0; if ( sendabandon ) { /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { err = -1; ld->ld_errno = LDAP_NO_MEMORY; } else { #ifdef LDAP_CONNECTIONLESS if ( ld->ld_cldapnaddr > 0 ) { - err = ber_printf( ber, "{isti", /* leave open '}' */ + err = ber_printf( ber, "{isti", /* '}' */ ++ld->ld_msgid, ld->ld_cldapdn, LDAP_REQ_ABANDON, msgid ); } else #endif /* LDAP_CONNECTIONLESS */ { - err = ber_printf( ber, "{iti", /* leave open '}' */ + err = ber_printf( ber, "{iti", /* '}' */ ++ld->ld_msgid, LDAP_REQ_ABANDON, msgid ); } @@ -162,7 +162,7 @@ do_abandon( } else { /* close '{' */ - err = ber_printf( ber, "}" ); + err = ber_printf( ber, /*{*/ "}" ); if( err == -1 ) { /* encoding error */ @@ -209,8 +209,8 @@ do_abandon( old_abandon = ld->ld_abandoned; - ld->ld_abandoned = (int *) LDAP_REALLOC( (char *) - ld->ld_abandoned, (i + 2) * sizeof(int) ); + ld->ld_abandoned = (ber_int_t *) LDAP_REALLOC( (char *) + ld->ld_abandoned, (i + 2) * sizeof(ber_int_t) ); if ( ld->ld_abandoned == NULL ) { ld->ld_abandoned = old_abandon; diff --git a/libraries/libldap/add.c b/libraries/libldap/add.c index d945988a39..748803de33 100644 --- a/libraries/libldap/add.c +++ b/libraries/libldap/add.c @@ -105,12 +105,12 @@ ldap_add_ext( assert( msgidp != NULL ); /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; return ld->ld_errno; } - rc = ber_printf( ber, "{it{s{", /* leave open '}}}' */ + rc = ber_printf( ber, "{it{s{", /* '}}}' */ ++ld->ld_msgid, LDAP_REQ_ADD, dn ); if ( rc == -1 ) { @@ -135,8 +135,7 @@ ldap_add_ext( } } - /* close '{{' */ - if ( ber_printf( ber, "}}" ) == -1 ) { + if ( ber_printf( ber, /*{{*/ "}}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); return ld->ld_errno; @@ -148,8 +147,7 @@ ldap_add_ext( return ld->ld_errno; } - /* close '{' */ - if ( ber_printf( ber, "}" ) == -1 ) { + if ( ber_printf( ber, /*{*/ "}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); return ld->ld_errno; diff --git a/libraries/libldap/cache.c b/libraries/libldap/cache.c index 4a0984b18f..020a1b81f4 100644 --- a/libraries/libldap/cache.c +++ b/libraries/libldap/cache.c @@ -27,19 +27,19 @@ static int cache_hash LDAP_P(( BerElement *ber )); static LDAPMessage *msg_dup LDAP_P(( LDAPMessage *msg )); static int request_cmp LDAP_P(( BerElement *req1, BerElement *req2 )); static int chain_contains_dn LDAP_P(( LDAPMessage *msg, LDAP_CONST char *dn )); -static long msg_size LDAP_P(( LDAPMessage *msg )); +static ber_len_t msg_size LDAP_P(( LDAPMessage *msg )); static void check_cache_memused LDAP_P(( LDAPCache *lc )); -static void uncache_entry_or_req LDAP_P(( LDAP *ld, LDAP_CONST char *dn, int msgid )); +static void uncache_entry_or_req LDAP_P(( LDAP *ld, LDAP_CONST char *dn, ber_int_t msgid )); #endif int -ldap_enable_cache( LDAP *ld, long timeout, long maxmem ) +ldap_enable_cache( LDAP *ld, long timeout, ber_len_t maxmem ) { #ifndef LDAP_NOCACHE - if ( ld->ld_cache == NULLLDCACHE ) { + if ( ld->ld_cache == NULL ) { if (( ld->ld_cache = (LDAPCache *)LDAP_MALLOC( sizeof( LDAPCache ))) - == NULLLDCACHE ) { + == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; return( -1 ); } @@ -62,7 +62,7 @@ void ldap_disable_cache( LDAP *ld ) { #ifndef LDAP_NOCACHE - if ( ld->ld_cache != NULLLDCACHE ) { + if ( ld->ld_cache != NULL ) { ld->ld_cache->lc_enabled = 0; } #endif @@ -74,7 +74,7 @@ void ldap_set_cache_options( LDAP *ld, unsigned long opts ) { #ifndef LDAP_NOCACHE - if ( ld->ld_cache != NULLLDCACHE ) { + if ( ld->ld_cache != NULL ) { ld->ld_cache->lc_options = opts; } #endif @@ -85,10 +85,10 @@ void ldap_destroy_cache( LDAP *ld ) { #ifndef LDAP_NOCACHE - if ( ld->ld_cache != NULLLDCACHE ) { + if ( ld->ld_cache != NULL ) { ldap_flush_cache( ld ); LDAP_FREE( (char *)ld->ld_cache ); - ld->ld_cache = NULLLDCACHE; + ld->ld_cache = NULL; } #endif } @@ -103,22 +103,22 @@ ldap_flush_cache( LDAP *ld ) Debug( LDAP_DEBUG_TRACE, "ldap_flush_cache\n", 0, 0, 0 ); - if ( ld->ld_cache != NULLLDCACHE ) { + if ( ld->ld_cache != NULL ) { /* delete all requests in the queue */ - for ( m = ld->ld_cache->lc_requests; m != NULLMSG; m = next ) { + for ( m = ld->ld_cache->lc_requests; m != NULL; m = next ) { next = m->lm_next; ldap_msgfree( m ); } - ld->ld_cache->lc_requests = NULLMSG; + ld->ld_cache->lc_requests = NULL; /* delete all messages in the cache */ for ( i = 0; i < LDAP_CACHE_BUCKETS; ++i ) { for ( m = ld->ld_cache->lc_buckets[ i ]; - m != NULLMSG; m = next ) { + m != NULL; m = next ) { next = m->lm_next; ldap_msgfree( m ); } - ld->ld_cache->lc_buckets[ i ] = NULLMSG; + ld->ld_cache->lc_buckets[ i ] = NULL; } ld->ld_cache->lc_memused = sizeof( LDAPCache ); } @@ -155,26 +155,26 @@ ldap_uncache_entry( LDAP *ld, LDAP_CONST char *dn ) static void uncache_entry_or_req( LDAP *ld, const char *dn, /* if non-NULL, uncache entry */ - int msgid ) /* request to uncache (if dn == NULL) */ + ber_int_t msgid ) /* request to uncache (if dn == NULL) */ { int i; LDAPMessage *m, *prev, *next; Debug( LDAP_DEBUG_TRACE, - "ldap_uncache_entry_or_req dn %s msgid %d ld_cache %lx\n", - dn, msgid, (long) ld->ld_cache ); + "ldap_uncache_entry_or_req dn %s msgid %ld ld_cache %lx\n", + dn, (long) msgid, (long) ld->ld_cache ); - if ( ld->ld_cache == NULLLDCACHE ) { + if ( ld->ld_cache == NULL ) { return; } /* first check the request queue */ - prev = NULLMSG; - for ( m = ld->ld_cache->lc_requests; m != NULLMSG; m = next ) { + prev = NULL; + for ( m = ld->ld_cache->lc_requests; m != NULL; m = next ) { next = m->lm_next; if (( dn != NULL && chain_contains_dn( m, dn )) || ( dn == NULL && m->lm_msgid == msgid )) { - if ( prev == NULLMSG ) { + if ( prev == NULL ) { ld->ld_cache->lc_requests = next; } else { prev->lm_next = next; @@ -188,13 +188,13 @@ uncache_entry_or_req( LDAP *ld, /* now check the rest of the cache */ for ( i = 0; i < LDAP_CACHE_BUCKETS; ++i ) { - prev = NULLMSG; - for ( m = ld->ld_cache->lc_buckets[ i ]; m != NULLMSG; + prev = NULL; + for ( m = ld->ld_cache->lc_buckets[ i ]; m != NULL; m = next ) { next = m->lm_next; if (( dn != NULL && chain_contains_dn( m, dn )) || ( dn == NULL && m->lm_msgid == msgid )) { - if ( prev == NULLMSG ) { + if ( prev == NULL ) { ld->ld_cache->lc_buckets[ i ] = next; } else { prev->lm_next = next; @@ -211,23 +211,23 @@ uncache_entry_or_req( LDAP *ld, #endif void -ldap_add_request_to_cache( LDAP *ld, unsigned long msgtype, BerElement *request ) +ldap_add_request_to_cache( LDAP *ld, ber_tag_t msgtype, BerElement *request ) { #ifndef LDAP_NOCACHE LDAPMessage *new; - long len; + ber_len_t len; Debug( LDAP_DEBUG_TRACE, "ldap_add_request_to_cache\n", 0, 0, 0 ); ld->ld_errno = LDAP_SUCCESS; - if ( ld->ld_cache == NULLLDCACHE || + if ( ld->ld_cache == NULL || ( ld->ld_cache->lc_enabled == 0 )) { return; } if (( new = (LDAPMessage *) LDAP_CALLOC( 1, sizeof(LDAPMessage) )) != NULL ) { - if (( new->lm_ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if (( new->lm_ber = ldap_alloc_ber_with_options( ld )) == NULL ) { LDAP_FREE( (char *)new ); return; } @@ -264,7 +264,7 @@ ldap_add_result_to_cache( LDAP *ld, LDAPMessage *result ) Debug( LDAP_DEBUG_TRACE, "ldap_add_result_to_cache: id %d, type %d\n", result->lm_msgid, result->lm_msgtype, 0 ); - if ( ld->ld_cache == NULLLDCACHE || + if ( ld->ld_cache == NULL || ( ld->ld_cache->lc_enabled == 0 )) { Debug( LDAP_DEBUG_TRACE, "artc: cache disabled\n", 0, 0, 0 ); return; @@ -287,7 +287,7 @@ ldap_add_result_to_cache( LDAP *ld, LDAPMessage *result ) * result to it. if this result completes the results for the * request, add the request/result chain to the cache proper. */ - prev = NULLMSG; + prev = NULL; for ( m = ld->ld_cache->lc_requests; m != NULL; m = m->lm_next ) { if ( m->lm_msgid == result->lm_msgid ) { break; @@ -295,12 +295,12 @@ ldap_add_result_to_cache( LDAP *ld, LDAPMessage *result ) prev = m; } - if ( m != NULLMSG ) { /* found request; add to end of chain */ + if ( m != NULL ) { /* found request; add to end of chain */ req = m; - for ( ; m->lm_chain != NULLMSG; m = m->lm_chain ) + for ( ; m->lm_chain != NULL; m = m->lm_chain ) ; - if (( new = msg_dup( result )) != NULLMSG ) { - new->lm_chain = NULLMSG; + if (( new = msg_dup( result )) != NULL ) { + new->lm_chain = NULL; m->lm_chain = new; Debug( LDAP_DEBUG_TRACE, "artc: result added to cache request chain\n", @@ -331,7 +331,7 @@ ldap_add_result_to_cache( LDAP *ld, LDAPMessage *result ) keep = 1; } - if ( prev == NULLMSG ) { + if ( prev == NULL ) { ld->ld_cache->lc_requests = req->lm_next; } else { prev->lm_next = req->lm_next; @@ -371,7 +371,7 @@ ldap_add_result_to_cache( LDAP *ld, LDAPMessage *result ) * will find them. */ int -ldap_check_cache( LDAP *ld, unsigned long msgtype, BerElement *request ) +ldap_check_cache( LDAP *ld, ber_tag_t msgtype, BerElement *request ) { #ifndef LDAP_NOCACHE LDAPMessage *m, *new, *prev, *next; @@ -381,7 +381,7 @@ ldap_check_cache( LDAP *ld, unsigned long msgtype, BerElement *request ) Debug( LDAP_DEBUG_TRACE, "ldap_check_cache\n", 0, 0, 0 ); - if ( ld->ld_cache == NULLLDCACHE || + if ( ld->ld_cache == NULL || ( ld->ld_cache->lc_enabled == 0 )) { return( -1 ); } @@ -391,9 +391,9 @@ ldap_check_cache( LDAP *ld, unsigned long msgtype, BerElement *request ) c_time = time( NULL ); - prev = NULLMSG; + prev = NULL; hash = cache_hash( &reqber ); - for ( m = ld->ld_cache->lc_buckets[ hash ]; m != NULLMSG; m = next ) { + for ( m = ld->ld_cache->lc_buckets[ hash ]; m != NULL; m = next ) { Debug( LDAP_DEBUG_TRACE,"cc: examining id %d,type %d\n", m->lm_msgid, m->lm_msgtype, 0 ); if ( difftime(c_time, m->lm_time) > ld->ld_cache->lc_timeout ) { @@ -418,7 +418,7 @@ ldap_check_cache( LDAP *ld, unsigned long msgtype, BerElement *request ) } } - if ( m == NULLMSG ) { + if ( m == NULL ) { return( -1 ); } @@ -426,13 +426,13 @@ ldap_check_cache( LDAP *ld, unsigned long msgtype, BerElement *request ) * add duplicates of responses to incoming queue */ first = 1; - for ( m = m->lm_chain; m != NULLMSG; m = m->lm_chain ) { - if (( new = msg_dup( m )) == NULLMSG ) { + for ( m = m->lm_chain; m != NULL; m = m->lm_chain ) { + if (( new = msg_dup( m )) == NULL ) { return( -1 ); } new->lm_msgid = ld->ld_msgid; - new->lm_chain = NULLMSG; + new->lm_chain = NULL; if ( first ) { new->lm_next = ld->ld_responses; ld->ld_responses = new; @@ -458,7 +458,7 @@ static int cache_hash( BerElement *ber ) { BerElement bercpy; - unsigned long len; + ber_len_t len; /* * just take the length of the packet and mod with # of buckets @@ -481,20 +481,20 @@ static LDAPMessage * msg_dup( LDAPMessage *msg ) { LDAPMessage *new; - long len; + ber_len_t len; if (( new = (LDAPMessage *)LDAP_MALLOC( sizeof(LDAPMessage))) != NULL ) { *new = *msg; /* struct copy */ - if (( new->lm_ber = ber_dup( msg->lm_ber )) == NULLBER ) { + if (( new->lm_ber = ber_dup( msg->lm_ber )) == NULL ) { LDAP_FREE( (char *)new ); - return( NULLMSG ); + return( NULL ); } len = msg->lm_ber->ber_end - msg->lm_ber->ber_buf; if (( new->lm_ber->ber_buf = (char *) ber_memalloc( (size_t)len )) == NULL ) { ber_free( new->lm_ber, 0 ); LDAP_FREE( (char *)new ); - return( NULLMSG ); + return( NULL ); } SAFEMEMCPY( new->lm_ber->ber_buf, msg->lm_ber->ber_buf, (size_t)len ); @@ -510,7 +510,7 @@ msg_dup( LDAPMessage *msg ) static int request_cmp( BerElement *req1, BerElement *req2 ) { - unsigned long len; + ber_len_t len; BerElement r1, r2; r1 = *req1; /* struct copies */ @@ -532,7 +532,7 @@ request_cmp( BerElement *req1, BerElement *req2 ) * check remaining length and bytes if necessary */ if (( len = r1.ber_end - r1.ber_ptr ) != - (unsigned long) (r2.ber_end - r2.ber_ptr) ) + (ber_len_t) (r2.ber_end - r2.ber_ptr) ) { return( -1 ); /* different lengths */ } @@ -545,7 +545,7 @@ chain_contains_dn( LDAPMessage *msg, const char *dn ) { LDAPMessage *m; BerElement ber; - long msgid; + ber_int_t msgid; char *s; int rc; @@ -554,7 +554,7 @@ chain_contains_dn( LDAPMessage *msg, const char *dn ) * first check the base or dn of the request */ ber = *msg->lm_ber; /* struct copy */ - if ( ber_scanf( &ber, "{i{a", &msgid, &s ) != LBER_ERROR ) { + if ( ber_scanf( &ber, "{i{a" /*}}*/, &msgid, &s ) != LBER_ERROR ) { rc = ( strcasecmp( dn, s ) == 0 ) ? 1 : 0; LDAP_FREE( s ); if ( rc != 0 ) { @@ -570,12 +570,12 @@ chain_contains_dn( LDAPMessage *msg, const char *dn ) * now check the dn of each search result */ rc = 0; - for ( m = msg->lm_chain; m != NULLMSG && rc == 0 ; m = m->lm_chain ) { + for ( m = msg->lm_chain; m != NULL && rc == 0 ; m = m->lm_chain ) { if ( m->lm_msgtype != LDAP_RES_SEARCH_ENTRY ) { continue; } ber = *m->lm_ber; /* struct copy */ - if ( ber_scanf( &ber, "{a", &s ) != LBER_ERROR ) { + if ( ber_scanf( &ber, "{a" /*}*/, &s ) != LBER_ERROR ) { rc = ( strcasecmp( dn, s ) == 0 ) ? 1 : 0; LDAP_FREE( s ); } @@ -585,14 +585,14 @@ chain_contains_dn( LDAPMessage *msg, const char *dn ) } -static long +static ber_len_t msg_size( LDAPMessage *msg ) { LDAPMessage *m; - long size; + ber_len_t size; size = 0; - for ( m = msg; m != NULLMSG; m = m->lm_chain ) { + for ( m = msg; m != NULL; m = m->lm_chain ) { size += ( sizeof( LDAPMessage ) + m->lm_ber->ber_end - m->lm_ber->ber_buf ); } @@ -634,12 +634,12 @@ check_cache_memused( LDAPCache *lc ) while ( lc->lc_memused > lc->lc_maxmem * SIZE_FACTOR ) { c_time = time( NULL ); for ( i = 0; i < LDAP_CACHE_BUCKETS; ++i ) { - prev = NULLMSG; - for ( m = lc->lc_buckets[ i ]; m != NULLMSG; + prev = NULL; + for ( m = lc->lc_buckets[ i ]; m != NULL; m = next ) { next = m->lm_next; if ( difftime(c_time, m->lm_time) > remove_threshold) { - if ( prev == NULLMSG ) { + if ( prev == NULL ) { lc->lc_buckets[ i ] = next; } else { prev->lm_next = next; diff --git a/libraries/libldap/charset.c b/libraries/libldap/charset.c index 8144e0335b..75c30ff9d9 100644 --- a/libraries/libldap/charset.c +++ b/libraries/libldap/charset.c @@ -54,7 +54,7 @@ ldap_enable_translation( LDAP *ld, LDAPMessage *entry, int enable ) int -ldap_translate_from_t61( LDAP *ld, char **bufp, unsigned long *lenp, +ldap_translate_from_t61( LDAP *ld, char **bufp, ber_len_t *lenp, int free_input ) { if ( ld->ld_lber_decode_translate_proc == 0 ) { @@ -66,7 +66,7 @@ ldap_translate_from_t61( LDAP *ld, char **bufp, unsigned long *lenp, int -ldap_translate_to_t61( LDAP *ld, char **bufp, unsigned long *lenp, +ldap_translate_to_t61( LDAP *ld, char **bufp, ber_len_t *lenp, int free_input ) { if ( ld->ld_lber_encode_translate_proc == 0 ) { @@ -1022,12 +1022,12 @@ c_to_cc( Byte *o, const Couple *cc, Byte c ) /* --- routine to convert from T.61 to ISO 8859-n --- */ int -ldap_t61_to_8859( char **bufp, unsigned long *buflenp, int free_input ) +ldap_t61_to_8859( char **bufp, ber_len_t *buflenp, int free_input ) { Byte *s, *oo, *o; unsigned int n; int c; - unsigned long len; + ber_len_t len; Debug( LDAP_DEBUG_TRACE, "ldap_t61_to_8859 input length: %ld\n", *buflenp, 0, 0 ); @@ -1559,11 +1559,11 @@ cc_to_t61( Byte *o, const Byte *s ) /* --- routine to convert from ISO 8859-n to T.61 --- */ int -ldap_8859_to_t61( char **bufp, unsigned long *buflenp, int free_input ) +ldap_8859_to_t61( char **bufp, ber_len_t *buflenp, int free_input ) { Byte *s, *oo, *o, *aux; int c; - unsigned long len; + ber_len_t len; const Couple *cc; Debug( LDAP_DEBUG_TRACE, "ldap_8859_to_t61 input length: %ld\n", diff --git a/libraries/libldap/cldap.c b/libraries/libldap/cldap.c index ec7ea7ee81..58a6abc904 100644 --- a/libraries/libldap/cldap.c +++ b/libraries/libldap/cldap.c @@ -279,7 +279,8 @@ cldap_result( LDAP *ld, int msgid, LDAPMessage **res, Sockbuf *sb = &ld->ld_sb; BerElement ber; char *logdn; - int ret, id, fromaddr, i; + int ret, fromaddr, i; + ber_int_t id; struct timeval tv; fromaddr = -1; @@ -406,8 +407,10 @@ static int cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, LDAPMessage **res, char *base ) { - unsigned long tag, len; - int baselen, slen, rc; + ber_tag_t tag; + ber_len_t len; + int baselen, slen; + ber_tag_t rc; char *dn, *p, *cookie; LDAPMessage *chain, *prev, *ldm; struct berval *bv; @@ -422,7 +425,7 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, tag = ber_next_element( ber, &len, cookie )) { if (( ldm = (LDAPMessage *)LDAP_CALLOC( 1, sizeof(LDAPMessage))) == NULL || ( ldm->lm_ber = ldap_alloc_ber_with_options( ld )) - == NULLBER ) { + == NULL ) { rc = LDAP_NO_MEMORY; break; /* return w/error*/ } @@ -437,8 +440,7 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, break; /* return w/error */ } - if ( ber_printf( ldm->lm_ber, "to", tag, bv->bv_val, - bv->bv_len ) == -1 ) { + if ( ber_printf( ldm->lm_ber, "tO", tag, bv ) == -1 ) { break; /* return w/error */ } ber_bvfree( bv ); @@ -446,7 +448,7 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, rc = LDAP_SUCCESS; } else if ( tag == LDAP_RES_SEARCH_ENTRY ) { - if ( ber_scanf( ber, "{aO", &dn, &bv ) == LBER_ERROR ) { + if ( ber_scanf( ber, "{aO" /*}*/, &dn, &bv ) == LBER_ERROR ) { break; /* return w/error */ } Debug( LDAP_DEBUG_TRACE, "cldap_parsemsg entry %s\n", dn, 0, 0 ); @@ -513,7 +515,7 @@ cldap_parsemsg( LDAP *ld, int msgid, BerElement *ber, /* dispose of any leftovers */ if ( ldm != NULL ) { - if ( ldm->lm_ber != NULLBER ) { + if ( ldm->lm_ber != NULL ) { ber_free( ldm->lm_ber, 1 ); } LDAP_FREE( ldm ); diff --git a/libraries/libldap/compare.c b/libraries/libldap/compare.c index 21a99aa80d..767581a6ef 100644 --- a/libraries/libldap/compare.c +++ b/libraries/libldap/compare.c @@ -61,11 +61,11 @@ ldap_compare_ext( assert( msgidp != NULL ); /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { return( LDAP_NO_MEMORY ); } - if ( ber_printf( ber, "{it{s{sO}}", /* leave open '}' */ + if ( ber_printf( ber, "{it{s{sO}}", /* '}' */ ++ld->ld_msgid, LDAP_REQ_COMPARE, dn, attr, &bvalue ) == -1 ) { @@ -80,7 +80,7 @@ ldap_compare_ext( return ld->ld_errno; } - if( ber_printf( ber, "}" ) == -1 ) { + if( ber_printf( ber, /*{*/ "}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); return( ld->ld_errno ); diff --git a/libraries/libldap/controls.c b/libraries/libldap/controls.c index 7c6249fb6c..b609b7bc56 100644 --- a/libraries/libldap/controls.c +++ b/libraries/libldap/controls.c @@ -62,13 +62,13 @@ int ldap_int_put_controls( } /* Controls are encoded as a sequence of sequences */ - if( ber_printf( ber, "t{", LDAP_TAG_CONTROLS ) == -1 ) { + if( ber_printf( ber, "t{"/*}*/, LDAP_TAG_CONTROLS ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; return ld->ld_errno; } for( c = ctrls ; *c != NULL; c++ ) { - if ( ber_printf( ber, "{s", + if ( ber_printf( ber, "{s" /*}*/, (*c)->ldctl_oid ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; @@ -77,7 +77,7 @@ int ldap_int_put_controls( if( (*c)->ldctl_iscritical /* only if true */ && ( ber_printf( ber, "b", - (*c)->ldctl_iscritical ) == -1 ) ) + (ber_int_t) (*c)->ldctl_iscritical ) == -1 ) ) { ld->ld_errno = LDAP_ENCODING_ERROR; return ld->ld_errno; @@ -92,14 +92,14 @@ int ldap_int_put_controls( } - if( ber_printf( ber, "}" ) == -1 ) { + if( ber_printf( ber, /*{*/"}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; return ld->ld_errno; } } - if( ber_printf( ber, "}" ) == -1 ) { + if( ber_printf( ber, /*{*/"}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; return ld->ld_errno; } @@ -112,7 +112,8 @@ int ldap_int_get_controls( LDAPControl ***ctrls ) { int nctrls; - unsigned long tag, len; + ber_tag_t tag; + ber_len_t len; char *opaque; assert( ber != NULL ); @@ -179,14 +180,16 @@ int ldap_int_get_controls( tctrls[nctrls++] = tctrl; tctrls[nctrls] = NULL; - tag = ber_scanf( ber, "{a", &tctrl->ldctl_oid ); + tag = ber_scanf( ber, "{a" /*}*/, &tctrl->ldctl_oid ); if( tag != LBER_ERROR ) { tag = ber_peek_tag( ber, &len ); } if( tag == LBER_BOOLEAN ) { - tag = ber_scanf( ber, "b", &tctrl->ldctl_iscritical ); + ber_int_t crit; + tag = ber_scanf( ber, "b", &crit ); + tctrl->ldctl_iscritical = crit ? (char) 0 : (char) ~0; } if( tag != LBER_ERROR ) { @@ -255,7 +258,7 @@ ldap_controls_free( LDAPControl **controls ) /* * Duplicate an array of LDAPControl */ -LDAPControl **ldap_controls_dup( const LDAPControl **controls ) +LDAPControl **ldap_controls_dup( LDAPControl **controls ) { LDAPControl **new; int i; @@ -297,7 +300,7 @@ LDAPControl **ldap_controls_dup( const LDAPControl **controls ) /* * Duplicate a LDAPControl */ -LDAPControl *ldap_control_dup( const LDAPControl *c ) +LDAPControl *ldap_control_dup( LDAPControl *c ) { LDAPControl *new; diff --git a/libraries/libldap/delete.c b/libraries/libldap/delete.c index b5602db2eb..0413c235cf 100644 --- a/libraries/libldap/delete.c +++ b/libraries/libldap/delete.c @@ -54,12 +54,12 @@ ldap_delete_ext( assert( msgidp != NULL ); /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; return( ld->ld_errno ); } - if ( ber_printf( ber, "{its", /* leave open - '}' */ + if ( ber_printf( ber, "{its", /* '}' */ ++ld->ld_msgid, LDAP_REQ_DELETE, dn ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; @@ -73,8 +73,7 @@ ldap_delete_ext( return ld->ld_errno; } - /* close '{' */ - if ( ber_printf( ber, "}" ) == -1 ) { + if ( ber_printf( ber, /*{*/ "}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); return( ld->ld_errno ); diff --git a/libraries/libldap/disptmpl.c b/libraries/libldap/disptmpl.c index 34a18a80bf..32c253d32d 100644 --- a/libraries/libldap/disptmpl.c +++ b/libraries/libldap/disptmpl.c @@ -36,7 +36,7 @@ #include "disptmpl.h" static void free_disptmpl LDAP_P(( struct ldap_disptmpl *tmpl )); -static int read_next_tmpl LDAP_P(( char **bufp, long *blenp, +static int read_next_tmpl LDAP_P(( char **bufp, ber_len_t *blenp, struct ldap_disptmpl **tmplp, int dtversion )); static const char *const tmploptions[] = { @@ -139,7 +139,7 @@ ldap_init_templates( char *file, struct ldap_disptmpl **tmpllistp ) int -ldap_init_templates_buf( char *buf, long buflen, +ldap_init_templates_buf( char *buf, ber_len_t buflen, struct ldap_disptmpl **tmpllistp ) { int rc=-1, version; @@ -441,7 +441,7 @@ ldap_tmplattrs( struct ldap_disptmpl *tmpl, char **includeattrs, static int -read_next_tmpl( char **bufp, long *blenp, struct ldap_disptmpl **tmplp, +read_next_tmpl( char **bufp, ber_len_t *blenp, struct ldap_disptmpl **tmplp, int dtversion ) { int i, j, tokcnt, samerow, adsource; diff --git a/libraries/libldap/dsparse.c b/libraries/libldap/dsparse.c index 19446e0ee4..2d7a7e0219 100644 --- a/libraries/libldap/dsparse.c +++ b/libraries/libldap/dsparse.c @@ -34,13 +34,13 @@ #include "ldap-int.h" -static int next_line LDAP_P(( char **bufp, long *blenp, char **linep )); +static int next_line LDAP_P(( char **bufp, ber_len_t *blenp, char **linep )); static char *next_token LDAP_P(( char ** sp )); int -next_line_tokens( char **bufp, long *blenp, char ***toksp ) +next_line_tokens( char **bufp, ber_len_t *blenp, char ***toksp ) { char *p, *line, *token, **toks; int rc, tokcnt; @@ -90,10 +90,10 @@ next_line_tokens( char **bufp, long *blenp, char ***toksp ) static int -next_line( char **bufp, long *blenp, char **linep ) +next_line( char **bufp, ber_len_t *blenp, char **linep ) { char *linestart, *line, *p; - long plen; + ber_slen_t plen; linestart = *bufp; p = *bufp; diff --git a/libraries/libldap/error.c b/libraries/libldap/error.c index 41147c7609..41570b6477 100644 --- a/libraries/libldap/error.c +++ b/libraries/libldap/error.c @@ -163,8 +163,8 @@ ldap_result2error( LDAP *ld, LDAPMessage *r, int freeit ) { LDAPMessage *lm; BerElement ber; - long along; - unsigned long rc; + ber_int_t along; + ber_tag_t rc; Debug( LDAP_DEBUG_TRACE, "ldap_result2error\n", 0, 0, 0 ); @@ -172,7 +172,7 @@ ldap_result2error( LDAP *ld, LDAPMessage *r, int freeit ) assert( LDAP_VALID( ld ) ); assert( r != NULL ); - if ( ld == NULL || r == NULLMSG ) + if ( ld == NULL || r == NULL ) return( LDAP_PARAM_ERROR ); for ( lm = r; lm->lm_chain != NULL; lm = lm->lm_chain ) diff --git a/libraries/libldap/extended.c b/libraries/libldap/extended.c index 31b4dd146c..e92d4d2578 100644 --- a/libraries/libldap/extended.c +++ b/libraries/libldap/extended.c @@ -60,12 +60,12 @@ ldap_extended_operation( } /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; return( ld->ld_errno ); } - if ( ber_printf( ber, "{it{tstO}", /* leave '}' for later */ + if ( ber_printf( ber, "{it{tstO}", /* '}' */ ++ld->ld_msgid, LDAP_REQ_EXTENDED, LDAP_TAG_EXOP_REQ_OID, reqoid, LDAP_TAG_EXOP_REQ_VALUE, reqdata ) == -1 ) { @@ -152,10 +152,11 @@ ldap_parse_extended_result ( int freeit ) { BerElement *ber; - int rc; - unsigned long tag, len; + ber_tag_t rc; + ber_tag_t tag; + ber_len_t len; struct berval *resdata; - long errcode; + ber_int_t errcode; char *resoid; assert( ld != NULL ); @@ -184,7 +185,7 @@ ldap_parse_extended_result ( ld->ld_matched = NULL; } - rc = ber_scanf( ber, "{iaa", &errcode, + rc = ber_scanf( ber, "{iaa" /*}*/, &errcode, &ld->ld_matched, &ld->ld_matched ); if( rc == LBER_ERROR ) { diff --git a/libraries/libldap/free.c b/libraries/libldap/free.c index f9569dd04a..ae208894d0 100644 --- a/libraries/libldap/free.c +++ b/libraries/libldap/free.c @@ -37,19 +37,19 @@ ldap_memvfree( void **v ) } void * -ldap_memalloc( size_t s ) +ldap_memalloc( ber_len_t s ) { return LDAP_MALLOC( s ); } void * -ldap_memcalloc( size_t n, size_t s ) +ldap_memcalloc( ber_len_t n, ber_len_t s ) { return LDAP_CALLOC( n, s ); } void * -ldap_memrealloc( void* p, size_t s ) +ldap_memrealloc( void* p, ber_len_t s ) { return LDAP_REALLOC( p, s ); } diff --git a/libraries/libldap/getattr.c b/libraries/libldap/getattr.c index fc4d31f56a..07e8e27a44 100644 --- a/libraries/libldap/getattr.c +++ b/libraries/libldap/getattr.c @@ -33,7 +33,7 @@ ldap_first_attribute( LDAP *ld, LDAPMessage *entry, BerElement **ber ) assert( entry != NULL ); assert( ber != NULL ); - if ( (*ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (*ber = ldap_alloc_ber_with_options( ld )) == NULL ) { *ber = NULL; return( NULL ); } diff --git a/libraries/libldap/getdn.c b/libraries/libldap/getdn.c index dfd1c2e28a..e26412af07 100644 --- a/libraries/libldap/getdn.c +++ b/libraries/libldap/getdn.c @@ -38,7 +38,7 @@ ldap_get_dn( LDAP *ld, LDAPMessage *entry ) } tmp = *entry->lm_ber; /* struct copy */ - if ( ber_scanf( &tmp, "{a", &dn ) == LBER_ERROR ) { + if ( ber_scanf( &tmp, "{a" /*}*/, &dn ) == LBER_ERROR ) { ld->ld_errno = LDAP_DECODING_ERROR; return( NULL ); } diff --git a/libraries/libldap/getdxbyname.c b/libraries/libldap/getdxbyname.c index f35f4b7727..ec6a959ced 100644 --- a/libraries/libldap/getdxbyname.c +++ b/libraries/libldap/getdxbyname.c @@ -23,7 +23,7 @@ #include "ldap-int.h" -static char ** decode_answer LDAP_P(( unsigned char *answer, int len )); +static char ** decode_answer LDAP_P(( unsigned char *answer, ber_len_t len )); #define MAX_TO_SORT 32 diff --git a/libraries/libldap/getentry.c b/libraries/libldap/getentry.c index 8724758b84..272ea304ad 100644 --- a/libraries/libldap/getentry.c +++ b/libraries/libldap/getentry.c @@ -28,8 +28,8 @@ ldap_first_entry( LDAP *ld, LDAPMessage *chain ) assert( ld != NULL ); assert( LDAP_VALID( ld ) ); - if( ld == NULL || chain == NULLMSG ) { - return NULLMSG; + if( ld == NULL || chain == NULL ) { + return NULL; } return chain->lm_msgtype == LDAP_RES_SEARCH_ENTRY @@ -43,13 +43,13 @@ ldap_next_entry( LDAP *ld, LDAPMessage *entry ) assert( ld != NULL ); assert( LDAP_VALID( ld ) ); - if ( ld == NULL || entry == NULLMSG ) { - return NULLMSG; + if ( ld == NULL || entry == NULL ) { + return NULL; } for ( entry = entry->lm_chain; - entry != NULLMSG; + entry != NULL; entry = entry->lm_chain ) { if( entry->lm_msgtype == LDAP_RES_SEARCH_ENTRY ) { @@ -57,7 +57,7 @@ ldap_next_entry( LDAP *ld, LDAPMessage *entry ) } } - return( NULLMSG ); + return( NULL ); } int diff --git a/libraries/libldap/getfilter.c b/libraries/libldap/getfilter.c index bf75521457..e3cb60fd0a 100644 --- a/libraries/libldap/getfilter.c +++ b/libraries/libldap/getfilter.c @@ -83,7 +83,7 @@ ldap_init_getfilter( LDAP_CONST char *fname ) LDAPFiltDesc * -ldap_init_getfilter_buf( char *buf, long buflen ) +ldap_init_getfilter_buf( char *buf, ber_len_t buflen ) { LDAPFiltDesc *lfdp; LDAPFiltList *flp, *nextflp; @@ -314,7 +314,7 @@ ldap_getnextfilter( LDAPFiltDesc *lfdp ) void ldap_build_filter( char *filtbuf, - unsigned long buflen, + ber_len_t buflen, LDAP_CONST char *pattern, LDAP_CONST char *prefix, LDAP_CONST char *suffix, diff --git a/libraries/libldap/getvalues.c b/libraries/libldap/getvalues.c index 2833e18f5d..f384ca9b41 100644 --- a/libraries/libldap/getvalues.c +++ b/libraries/libldap/getvalues.c @@ -35,7 +35,7 @@ ldap_get_values( LDAP *ld, LDAPMessage *entry, LDAP_CONST char *target ) ber = *entry->lm_ber; /* skip sequence, dn, sequence of, and snag the first attr */ - if ( ber_scanf( &ber, "{x{{a", &attr ) == LBER_ERROR ) { + if ( ber_scanf( &ber, "{x{{a" /*}}}*/, &attr ) == LBER_ERROR ) { ld->ld_errno = LDAP_DECODING_ERROR; return( NULL ); } @@ -48,7 +48,7 @@ ldap_get_values( LDAP *ld, LDAPMessage *entry, LDAP_CONST char *target ) LDAP_FREE(attr); attr = NULL; - if ( ber_scanf( &ber, "x}{a", &attr ) == LBER_ERROR ) { + if ( ber_scanf( &ber, /*{*/ "x}{a" /*}*/, &attr ) == LBER_ERROR ) { ld->ld_errno = LDAP_DECODING_ERROR; return( NULL ); } @@ -87,7 +87,7 @@ ldap_get_values_len( LDAP *ld, LDAPMessage *entry, LDAP_CONST char *target ) ber = *entry->lm_ber; /* skip sequence, dn, sequence of, and snag the first attr */ - if ( ber_scanf( &ber, "{x{{a", &attr ) == LBER_ERROR ) { + if ( ber_scanf( &ber, "{x{{a" /* }}} */, &attr ) == LBER_ERROR ) { ld->ld_errno = LDAP_DECODING_ERROR; return( NULL ); } @@ -100,7 +100,7 @@ ldap_get_values_len( LDAP *ld, LDAPMessage *entry, LDAP_CONST char *target ) LDAP_FREE( attr ); attr = NULL; - if ( ber_scanf( &ber, "x}{a", &attr ) == LBER_ERROR ) { + if ( ber_scanf( &ber, /*{*/ "x}{a" /*}*/, &attr ) == LBER_ERROR ) { ld->ld_errno = LDAP_DECODING_ERROR; return( NULL ); } diff --git a/libraries/libldap/kbind.c b/libraries/libldap/kbind.c index 47ab77f939..5e63698ddc 100644 --- a/libraries/libldap/kbind.c +++ b/libraries/libldap/kbind.c @@ -60,7 +60,8 @@ ldap_kerberos_bind1( LDAP *ld, LDAP_CONST char *dn ) { BerElement *ber; char *cred; - int rc, credlen; + int rc; + ber_len_t credlen; #ifdef STR_TRANSLATION int str_translation_on; #endif /* STR_TRANSLATION */ @@ -76,7 +77,7 @@ ldap_kerberos_bind1( LDAP *ld, LDAP_CONST char *dn ) } /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { LDAP_FREE( cred ); return( -1 ); } @@ -153,7 +154,8 @@ ldap_kerberos_bind2( LDAP *ld, LDAP_CONST char *dn ) { BerElement *ber; char *cred; - int rc, credlen; + int rc; + ber_len_t credlen; #ifdef STR_TRANSLATION int str_translation_on; #endif /* STR_TRANSLATION */ @@ -169,7 +171,7 @@ ldap_kerberos_bind2( LDAP *ld, LDAP_CONST char *dn ) } /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { LDAP_FREE( cred ); return( -1 ); } @@ -253,7 +255,7 @@ ldap_get_kerberosv4_credentials( LDAP *ld, LDAP_CONST char *who, LDAP_CONST char *service, - int *len ) + ber_len_t *len ) { KTEXT_ST ktxt; int err; diff --git a/libraries/libldap/ldap-int.h b/libraries/libldap/ldap-int.h index f638a581f4..3a26f42cab 100644 --- a/libraries/libldap/ldap-int.h +++ b/libraries/libldap/ldap-int.h @@ -70,14 +70,14 @@ LDAP_BEGIN_DECL */ struct ldapmsg { - int lm_msgid; /* the message id */ - int lm_msgtype; /* the message type */ + ber_int_t lm_msgid; /* the message id */ + ber_tag_t lm_msgtype; /* the message type */ BerElement *lm_ber; /* the ber encoded message contents */ struct ldapmsg *lm_chain; /* for search - next msg in the resp */ struct ldapmsg *lm_next; /* next response */ time_t lm_time; /* used to maintain cache */ }; -#define NULLMSG ((LDAPMessage *)NULL) + /* * structure representing get/set'able options * which have global defaults. @@ -90,10 +90,10 @@ struct ldapoptions { int ldo_debug; - int ldo_version; /* version to connect at */ - int ldo_deref; - int ldo_timelimit; - int ldo_sizelimit; + ber_int_t ldo_version; /* version to connect at */ + ber_int_t ldo_deref; + ber_int_t ldo_timelimit; + ber_int_t ldo_sizelimit; int ldo_defport; char* ldo_defbase; @@ -146,17 +146,17 @@ typedef struct ldap_conn { * structure used to track outstanding requests */ typedef struct ldapreq { - int lr_msgid; /* the message id */ + ber_int_t lr_msgid; /* the message id */ int lr_status; /* status of request */ #define LDAP_REQST_INPROGRESS 1 #define LDAP_REQST_CHASINGREFS 2 #define LDAP_REQST_NOTCONNECTED 3 #define LDAP_REQST_WRITING 4 int lr_outrefcnt; /* count of outstanding referrals */ - int lr_origid; /* original request's message id */ + ber_int_t lr_origid; /* original request's message id */ int lr_parentcnt; /* count of parent requests */ - int lr_res_msgtype; /* result message type */ - int lr_res_errno; /* result LDAP errno */ + ber_tag_t lr_res_msgtype; /* result message type */ + ber_int_t lr_res_errno; /* result LDAP errno */ char *lr_res_error; /* result error string */ char *lr_res_matched;/* result matched DN string */ BerElement *lr_ber; /* ber encoded request contents */ @@ -175,14 +175,13 @@ typedef struct ldapcache { LDAPMessage *lc_buckets[LDAP_CACHE_BUCKETS];/* hash table */ LDAPMessage *lc_requests; /* unfulfilled reqs */ long lc_timeout; /* request timeout */ - long lc_maxmem; /* memory to use */ - long lc_memused; /* memory in use */ + ber_len_t lc_maxmem; /* memory to use */ + ber_len_t lc_memused; /* memory in use */ int lc_enabled; /* enabled? */ unsigned long lc_options; /* options */ #define LDAP_CACHE_OPT_CACHENOERRS 0x00000001 #define LDAP_CACHE_OPT_CACHEALLERRS 0x00000002 } LDAPCache; -#define NULLLDCACHE ((LDAPCache *)NULL) /* * handy macro for checking if handle is connectionless @@ -217,7 +216,7 @@ struct ldap { #define ld_sctrls ld_options.ldo_sctrls #define ld_cctrls ld_options.ldo_cctrls - int ld_version; /* version connected at */ + ber_int_t ld_version; /* version connected at */ char *ld_host; int ld_port; @@ -226,16 +225,16 @@ struct ldap { LDAPFiltDesc *ld_filtd; /* from getfilter for ufn searches */ char *ld_ufnprefix; /* for incomplete ufn's */ - int ld_errno; + ber_int_t ld_errno; char *ld_error; char *ld_matched; - int ld_msgid; + ber_len_t ld_msgid; /* do not mess with these */ LDAPRequest *ld_requests; /* list of outstanding requests */ LDAPMessage *ld_responses; /* list of outstanding responses */ - int *ld_abandoned; /* array of abandoned requests */ + ber_int_t *ld_abandoned; /* array of abandoned requests */ LDAPCache *ld_cache; /* non-null if cache is initialized */ /* stuff used by connectionless searches. */ @@ -295,19 +294,19 @@ int ldap_log_printf LDAP_P((LDAP *ld, int level, const char *fmt, ...)); /* * in cache.c */ -void ldap_add_request_to_cache LDAP_P(( LDAP *ld, unsigned long msgtype, +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, unsigned long msgtype, BerElement *request )); +int ldap_check_cache LDAP_P(( LDAP *ld, ber_tag_t msgtype, BerElement *request )); /* * in controls.c */ LDAPControl *ldap_control_dup LDAP_P(( - const LDAPControl *ctrl )); + LDAPControl *ctrl )); LDAPControl **ldap_controls_dup LDAP_P(( - const LDAPControl **ctrls )); + LDAPControl **ctrls )); int ldap_int_get_controls LDAP_P(( BerElement *be, @@ -321,7 +320,7 @@ int ldap_int_put_controls LDAP_P(( /* * in dsparse.c */ -int next_line_tokens LDAP_P(( char **bufp, long *blenp, char ***toksp )); +int next_line_tokens LDAP_P(( char **bufp, ber_len_t *blenp, char ***toksp )); void free_strarray LDAP_P(( char **sap )); #ifdef HAVE_KERBEROS @@ -332,7 +331,7 @@ char *ldap_get_kerberosv4_credentials LDAP_P(( LDAP *ld, LDAP_CONST char *who, LDAP_CONST char *service, - int *len )); + ber_len_t *len )); #endif /* HAVE_KERBEROS */ @@ -368,17 +367,17 @@ int ldap_is_write_ready( LDAP *ld, Sockbuf *sb ); /* * in request.c */ -int ldap_send_initial_request( LDAP *ld, unsigned long msgtype, +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, int msgid, +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, int msgid ); +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 ); @@ -399,12 +398,15 @@ LDAP_F int cldap_getmsg ( LDAP *ld, struct timeval *timeout, BerElement *ber ); */ BerElement *ldap_build_search_req LDAP_P(( LDAP *ld, - const char *base, int scope, - const char *filter, char **attrs, int attrsonly, + const char *base, + ber_int_t scope, + const char *filter, + char **attrs, + ber_int_t attrsonly, LDAPControl **sctrls, LDAPControl **cctrls, - int timelimit, - int sizelimit )); + ber_int_t timelimit, + ber_int_t sizelimit )); /* * in string.c @@ -443,9 +445,9 @@ char **ldap_getdxbyname( const char *domain ); */ #if LDAP_CHARSET_8859 == LDAP_DEFAULT_CHARSET extern -int ldap_t61_to_8859( char **bufp, unsigned long *buflenp, int free_input ); +int ldap_t61_to_8859( char **bufp, ber_len_t *buflenp, int free_input ); extern -int ldap_8859_to_t61( char **bufp, unsigned long *buflenp, int free_input ); +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 */ diff --git a/libraries/libldap/messages.c b/libraries/libldap/messages.c index a67aecc860..33091da163 100644 --- a/libraries/libldap/messages.c +++ b/libraries/libldap/messages.c @@ -25,8 +25,8 @@ ldap_first_message( LDAP *ld, LDAPMessage *chain ) assert( ld != NULL ); assert( LDAP_VALID( ld ) ); - if ( ld == NULL || chain == NULLMSG ) { - return NULLMSG; + if ( ld == NULL || chain == NULL ) { + return NULL; } return chain; @@ -38,8 +38,8 @@ ldap_next_message( LDAP *ld, LDAPMessage *msg ) assert( ld != NULL ); assert( LDAP_VALID( ld ) ); - if ( ld == NULL || msg == NULLMSG || msg->lm_chain == NULL ) { - return NULLMSG; + if ( ld == NULL || msg == NULL || msg->lm_chain == NULL ) { + return NULL; } return( msg->lm_chain ); diff --git a/libraries/libldap/modify.c b/libraries/libldap/modify.c index 71abe8aba1..583f919ddb 100644 --- a/libraries/libldap/modify.c +++ b/libraries/libldap/modify.c @@ -73,11 +73,11 @@ ldap_modify_ext( LDAP *ld, Debug( LDAP_DEBUG_TRACE, "ldap_modify_ext\n", 0, 0, 0 ); /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { return( LDAP_NO_MEMORY ); } - if ( ber_printf( ber, "{it{s{", ++ld->ld_msgid, LDAP_REQ_MODIFY, dn ) + if ( ber_printf( ber, "{it{s{" /*}}}*/, ++ld->ld_msgid, LDAP_REQ_MODIFY, dn ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); @@ -88,10 +88,11 @@ ldap_modify_ext( LDAP *ld, for ( i = 0; mods[i] != NULL; i++ ) { if (( mods[i]->mod_op & LDAP_MOD_BVALUES) != 0 ) { rc = ber_printf( ber, "{e{s[V]}}", - mods[i]->mod_op & ~LDAP_MOD_BVALUES, + (ber_int_t) ( mods[i]->mod_op & ~LDAP_MOD_BVALUES ), mods[i]->mod_type, mods[i]->mod_bvalues ); } else { - rc = ber_printf( ber, "{e{s[v]}}", mods[i]->mod_op, + rc = ber_printf( ber, "{e{s[v]}}", + (ber_int_t) mods[i]->mod_op, mods[i]->mod_type, mods[i]->mod_values ); } @@ -102,7 +103,7 @@ ldap_modify_ext( LDAP *ld, } } - if ( ber_printf( ber, "}}" ) == -1 ) { + if ( ber_printf( ber, /*{{*/ "}}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); return( ld->ld_errno ); @@ -114,7 +115,7 @@ ldap_modify_ext( LDAP *ld, return ld->ld_errno; } - if ( ber_printf( ber, "}" ) == -1 ) { + if ( ber_printf( ber, /*{*/ "}" ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); return( ld->ld_errno ); diff --git a/libraries/libldap/modrdn.c b/libraries/libldap/modrdn.c index d2885bd63e..a8998b2bf8 100644 --- a/libraries/libldap/modrdn.c +++ b/libraries/libldap/modrdn.c @@ -70,7 +70,7 @@ ldap_rename( Debug( LDAP_DEBUG_TRACE, "ldap_rename\n", 0, 0, 0 ); /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { return( LDAP_NO_MEMORY ); } @@ -82,15 +82,15 @@ ldap_rename( return( ld->ld_errno ); } - rc = ber_printf( ber, "{it{ssbts}", /* leave '}' for later */ + rc = ber_printf( ber, "{it{ssbts}", /* '}' */ ++ld->ld_msgid, LDAP_REQ_MODDN, - dn, newrdn, deleteoldrdn, + dn, newrdn, (ber_int_t) deleteoldrdn, LDAP_TAG_NEWSUPERIOR, newSuperior ); } else { - rc = ber_printf( ber, "{it{ssb}", /* leave '}' for later */ + rc = ber_printf( ber, "{it{ssb}", /* '}' */ ++ld->ld_msgid, LDAP_REQ_MODDN, - dn, newrdn, deleteoldrdn ); + dn, newrdn, (ber_int_t) deleteoldrdn ); } if ( rc < 0 ) { @@ -105,8 +105,7 @@ ldap_rename( return ld->ld_errno; } - /* close the '{' */ - rc = ber_printf( ber, "}" ); + rc = ber_printf( ber, /*{*/ "}" ); if ( rc < 0 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); diff --git a/libraries/libldap/options.c b/libraries/libldap/options.c index 3e748a7848..748f9c4078 100644 --- a/libraries/libldap/options.c +++ b/libraries/libldap/options.c @@ -152,7 +152,7 @@ ldap_get_option( break; } - * (int *) outvalue = ber_pvt_sb_get_desc( &(ld->ld_sb) ); + * (ber_socket_t *) outvalue = ber_pvt_sb_get_desc( &(ld->ld_sb) ); return LDAP_OPT_SUCCESS; case LDAP_OPT_DEREF: diff --git a/libraries/libldap/os-ip.c b/libraries/libldap/os-ip.c index 9f7e7051aa..b17e71a58f 100644 --- a/libraries/libldap/os-ip.c +++ b/libraries/libldap/os-ip.c @@ -44,7 +44,8 @@ ldap_connect_to_host( Sockbuf *sb, const char *host, unsigned long address, * XXX async is not used yet! */ { - int rc, i, s = 0; + int rc, i; + ber_socket_t s = AC_SOCKET_INVALID; int connected, use_hp; struct sockaddr_in sin; struct hostent *hp = NULL; diff --git a/libraries/libldap/references.c b/libraries/libldap/references.c index 08e96b05b6..50cf0fc27c 100644 --- a/libraries/libldap/references.c +++ b/libraries/libldap/references.c @@ -26,8 +26,8 @@ ldap_first_reference( LDAP *ld, LDAPMessage *chain ) assert( ld != NULL ); assert( chain != NULL ); - if ( ld == NULL || chain == NULLMSG ) { - return NULLMSG; + if ( ld == NULL || chain == NULL ) { + return NULL; } return chain->lm_msgtype == LDAP_RES_SEARCH_REFERENCE @@ -41,13 +41,13 @@ ldap_next_reference( LDAP *ld, LDAPMessage *ref ) assert( ld != NULL ); assert( ref != NULL ); - if ( ld == NULL || ref == NULLMSG ) { - return NULLMSG; + if ( ld == NULL || ref == NULL ) { + return NULL; } for ( ref = ref->lm_chain; - ref != NULLMSG; + ref != NULL; ref = ref->lm_chain ) { if( ref->lm_msgtype == LDAP_RES_SEARCH_REFERENCE ) { @@ -55,7 +55,7 @@ ldap_next_reference( LDAP *ld, LDAPMessage *ref ) } } - return( NULLMSG ); + return( NULL ); } int diff --git a/libraries/libldap/request.c b/libraries/libldap/request.c index 133e42fd10..76aa484e90 100644 --- a/libraries/libldap/request.c +++ b/libraries/libldap/request.c @@ -32,8 +32,11 @@ static void free_servers LDAP_P(( LDAPServer *srvlist )); static LDAPServer *dn2servers LDAP_P(( LDAP *ld, char *dn )); #endif /* LDAP_API_FEATURE_X_OPENLDAP_V2_DNS */ -static BerElement *re_encode_request LDAP_P(( LDAP *ld, BerElement *origber, - int msgid, char **dnp )); +static BerElement *re_encode_request LDAP_P(( + LDAP *ld, + BerElement *origber, + ber_int_t msgid, + char **dnp )); BerElement * @@ -41,7 +44,7 @@ ldap_alloc_ber_with_options( LDAP *ld ) { BerElement *ber; - if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULLBER ) { + if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; #ifdef STR_TRANSLATION } else { @@ -67,10 +70,10 @@ ldap_set_ber_options( LDAP *ld, BerElement *ber ) } -int +ber_int_t ldap_send_initial_request( LDAP *ld, - unsigned long msgtype, + ber_tag_t msgtype, const char *dn, BerElement *ber ) { @@ -150,8 +153,14 @@ ldap_send_initial_request( int -ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest - *parentreq, LDAPServer *srvlist, LDAPConn *lc, int bind ) +ldap_send_server_request( + LDAP *ld, + BerElement *ber, + ber_int_t msgid, + LDAPRequest *parentreq, + LDAPServer *srvlist, + LDAPConn *lc, + int bind ) { LDAPRequest *lr; int incparent; @@ -505,15 +514,15 @@ ldap_dump_requests_and_responses( LDAP *ld ) } fprintf( stderr, "** Response Queue:\n" ); - if (( lm = ld->ld_responses ) == NULLMSG ) { + if (( lm = ld->ld_responses ) == NULL ) { fprintf( stderr, " Empty\n" ); } - for ( ; lm != NULLMSG; lm = lm->lm_next ) { + for ( ; lm != NULL; lm = lm->lm_next ) { fprintf( stderr, " * msgid %d, type %d\n", lm->lm_msgid, lm->lm_msgtype ); if (( l = lm->lm_chain ) != NULL ) { fprintf( stderr, " chained responses:\n" ); - for ( ; l != NULLMSG; l = l->lm_chain ) { + for ( ; l != NULL; l = l->lm_chain ) { fprintf( stderr, " * msgid %d, type %d\n", l->lm_msgid, l->lm_msgtype ); @@ -775,20 +784,22 @@ ldap_append_referral( LDAP *ld, char **referralsp, char *s ) static BerElement * -re_encode_request( LDAP *ld, BerElement *origber, int msgid, char **dnp ) +re_encode_request( LDAP *ld, BerElement *origber, ber_int_t msgid, char **dnp ) { /* * XXX this routine knows way too much about how the lber library works! */ - unsigned long along, tag; - long ver; + ber_int_t along; + ber_len_t len; + ber_tag_t tag; + ber_int_t ver; int rc; BerElement tmpber, *ber; char *orig_dn; Debug( LDAP_DEBUG_TRACE, - "re_encode_request: new msgid %d, new dn <%s>\n", - msgid, ( *dnp == NULL ) ? "NONE" : *dnp, 0 ); + "re_encode_request: new msgid %ld, new dn <%s>\n", + (long) msgid, ( *dnp == NULL ) ? "NONE" : *dnp, 0 ); tmpber = *origber; @@ -797,17 +808,17 @@ re_encode_request( LDAP *ld, BerElement *origber, int msgid, char **dnp ) * followed by a sequence that is tagged with the operation code */ if ( ber_scanf( &tmpber, "{i", /*}*/ &along ) != LDAP_TAG_MSGID || - ( tag = ber_skip_tag( &tmpber, &along )) == LBER_DEFAULT ) { + ( tag = ber_skip_tag( &tmpber, &len )) == LBER_DEFAULT ) { ld->ld_errno = LDAP_DECODING_ERROR; return( NULL ); } - if (( ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if (( ber = ldap_alloc_ber_with_options( ld )) == NULL ) { return( NULL ); } /* bind requests have a version number before the DN & other stuff */ - if ( tag == LDAP_REQ_BIND && ber_get_int( &tmpber, (long *)&ver ) == + if ( tag == LDAP_REQ_BIND && ber_get_int( &tmpber, &ver ) == LBER_DEFAULT ) { ld->ld_errno = LDAP_DECODING_ERROR; ber_free( ber, 1 ); @@ -858,7 +869,7 @@ re_encode_request( LDAP *ld, BerElement *origber, int msgid, char **dnp ) LDAPRequest * -ldap_find_request_by_msgid( LDAP *ld, int msgid ) +ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid ) { LDAPRequest *lr; diff --git a/libraries/libldap/result.c b/libraries/libldap/result.c index 5f9ff57cec..adc34d9db4 100644 --- a/libraries/libldap/result.c +++ b/libraries/libldap/result.c @@ -36,13 +36,13 @@ #include "ldap-int.h" -static int ldap_abandoned LDAP_P(( LDAP *ld, int msgid )); -static int ldap_mark_abandoned LDAP_P(( LDAP *ld, int msgid )); -static int wait4msg LDAP_P(( LDAP *ld, int msgid, int all, struct timeval *timeout, +static int ldap_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid )); +static int ldap_mark_abandoned LDAP_P(( LDAP *ld, ber_int_t msgid )); +static int wait4msg LDAP_P(( LDAP *ld, ber_int_t msgid, int all, struct timeval *timeout, LDAPMessage **result )); -static int try_read1msg LDAP_P(( LDAP *ld, int msgid, int all, Sockbuf *sb, LDAPConn *lc, - LDAPMessage **result )); -static unsigned long build_result_ber LDAP_P(( LDAP *ld, BerElement **bp, LDAPRequest *lr )); +static ber_tag_t try_read1msg LDAP_P(( LDAP *ld, ber_int_t msgid, + int all, Sockbuf *sb, LDAPConn *lc, LDAPMessage **result )); +static ber_tag_t build_result_ber LDAP_P(( LDAP *ld, BerElement **bp, LDAPRequest *lr )); static void merge_error_info LDAP_P(( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr )); @@ -87,15 +87,15 @@ ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout, * wait until it arrives or timeout occurs. */ - *result = NULLMSG; - lastlm = NULLMSG; - for ( lm = ld->ld_responses; lm != NULLMSG; lm = nextlm ) { + *result = NULL; + lastlm = NULL; + for ( lm = ld->ld_responses; lm != NULL; lm = nextlm ) { nextlm = lm->lm_next; if ( ldap_abandoned( ld, lm->lm_msgid ) ) { ldap_mark_abandoned( ld, lm->lm_msgid ); - if ( lastlm == NULLMSG ) { + if ( lastlm == NULL ) { ld->ld_responses = lm->lm_next; } else { lastlm->lm_next = nextlm; @@ -115,12 +115,12 @@ ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout, && lm->lm_msgtype != LDAP_RES_SEARCH_ENTRY) ) break; - for ( tmp = lm; tmp != NULLMSG; tmp = tmp->lm_chain ) { + for ( tmp = lm; tmp != NULL; tmp = tmp->lm_chain ) { if ( tmp->lm_msgtype == LDAP_RES_SEARCH_RESULT ) break; } - if ( tmp == NULLMSG ) { + if ( tmp == NULL ) { return( wait4msg( ld, msgid, all, timeout, result ) ); } @@ -129,20 +129,20 @@ ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout, } lastlm = lm; } - if ( lm == NULLMSG ) { + if ( lm == NULL ) { return( wait4msg( ld, msgid, all, timeout, result ) ); } - if ( lastlm == NULLMSG ) { - ld->ld_responses = (all == 0 && lm->lm_chain != NULLMSG + if ( lastlm == NULL ) { + ld->ld_responses = (all == 0 && lm->lm_chain != NULL ? lm->lm_chain : lm->lm_next); } else { - lastlm->lm_next = (all == 0 && lm->lm_chain != NULLMSG + lastlm->lm_next = (all == 0 && lm->lm_chain != NULL ? lm->lm_chain : lm->lm_next); } if ( all == 0 ) - lm->lm_chain = NULLMSG; - lm->lm_next = NULLMSG; + lm->lm_chain = NULL; + lm->lm_next = NULL; *result = lm; ld->ld_errno = LDAP_SUCCESS; @@ -150,7 +150,11 @@ ldap_result( LDAP *ld, int msgid, int all, struct timeval *timeout, } static int -wait4msg( LDAP *ld, int msgid, int all, struct timeval *timeout, +wait4msg( + LDAP *ld, + ber_int_t msgid, + int all, + struct timeval *timeout, LDAPMessage **result ) { int rc; @@ -253,26 +257,32 @@ wait4msg( LDAP *ld, int msgid, int all, struct timeval *timeout, } -static int -try_read1msg( LDAP *ld, int msgid, int all, Sockbuf *sb, - LDAPConn *lc, LDAPMessage **result ) +static ber_tag_t +try_read1msg( + LDAP *ld, + ber_int_t msgid, + int all, + Sockbuf *sb, + LDAPConn *lc, + LDAPMessage **result ) { BerElement *ber; LDAPMessage *new, *l, *prev, *tmp; - long id; - unsigned long tag, len; + ber_int_t id; + ber_tag_t tag; + ber_len_t len; int foundit = 0; LDAPRequest *lr; BerElement tmpber; int rc, refer_cnt, hadref, simple_request; - unsigned long lderr; + ber_int_t lderr; assert( ld != NULL ); assert( lc != NULL ); Debug( LDAP_DEBUG_TRACE, "read1msg\n", 0, 0, 0 ); - if ( lc->lconn_ber == NULLBER ) { + if ( lc->lconn_ber == NULL ) { lc->lconn_ber = ldap_alloc_ber_with_options(ld); if( lc->lconn_ber == NULL ) { @@ -309,7 +319,7 @@ try_read1msg( LDAP *ld, int msgid, int all, Sockbuf *sb, * We read a complete message. * The connection should no longer need this ber. */ - lc->lconn_ber = NULLBER; + lc->lconn_ber = NULL; /* message id */ if ( ber_get_int( ber, &id ) == LBER_ERROR ) { @@ -319,7 +329,7 @@ try_read1msg( LDAP *ld, int msgid, int all, Sockbuf *sb, } /* if it's been abandoned, toss it */ - if ( ldap_abandoned( ld, (int)id ) ) { + if ( ldap_abandoned( ld, id ) ) { ber_free( ber, 1 ); return( -2 ); /* continue looking */ } @@ -477,15 +487,15 @@ lr->lr_res_matched ? lr->lr_res_matched : "" ); * search response. */ - prev = NULLMSG; - for ( l = ld->ld_responses; l != NULLMSG; l = l->lm_next ) { + prev = NULL; + for ( l = ld->ld_responses; l != NULL; l = l->lm_next ) { if ( l->lm_msgid == new->lm_msgid ) break; prev = l; } /* not part of an existing search response */ - if ( l == NULLMSG ) { + if ( l == NULL ) { if ( foundit ) { *result = new; ld->ld_errno = LDAP_SUCCESS; @@ -501,7 +511,7 @@ lr->lr_res_matched ? lr->lr_res_matched : "" ); new->lm_msgid, new->lm_msgtype, 0 ); /* part of a search response - add to end of list of entries */ - for ( tmp = l; tmp->lm_chain != NULLMSG && + for ( tmp = l; tmp->lm_chain != NULL && tmp->lm_chain->lm_msgtype == LDAP_RES_SEARCH_ENTRY; tmp = tmp->lm_chain ) ; /* NULL */ @@ -509,7 +519,7 @@ lr->lr_res_matched ? lr->lr_res_matched : "" ); /* return the whole chain if that's what we were looking for */ if ( foundit ) { - if ( prev == NULLMSG ) + if ( prev == NULL ) ld->ld_responses = l->lm_next; else prev->lm_next = l->lm_next; @@ -533,11 +543,12 @@ lr->lr_res_matched ? lr->lr_res_matched : "" ); } -static unsigned long +static ber_tag_t build_result_ber( LDAP *ld, BerElement **bp, LDAPRequest *lr ) { - unsigned long len, tag; - long along; + ber_len_t len; + ber_int_t tag; + ber_int_t along; BerElement *ber; *bp = NULL; @@ -549,7 +560,7 @@ build_result_ber( LDAP *ld, BerElement **bp, LDAPRequest *lr ) } if ( ber_printf( ber, "{it{ess}}", lr->lr_msgid, - (unsigned long) lr->lr_res_msgtype, lr->lr_res_errno, + lr->lr_res_msgtype, lr->lr_res_errno, lr->lr_res_matched ? lr->lr_res_matched : "", lr->lr_res_error ? lr->lr_res_error : "" ) == -1 ) { @@ -651,7 +662,7 @@ ldap_msgfree( LDAPMessage *lm ) Debug( LDAP_DEBUG_TRACE, "ldap_msgfree\n", 0, 0, 0 ); - for ( ; lm != NULLMSG; lm = next ) { + for ( ; lm != NULL; lm = next ) { next = lm->lm_chain; type = lm->lm_msgtype; ber_free( lm->lm_ber, 1 ); @@ -675,17 +686,17 @@ ldap_msgdelete( LDAP *ld, int msgid ) Debug( LDAP_DEBUG_TRACE, "ldap_msgdelete\n", 0, 0, 0 ); - prev = NULLMSG; - for ( lm = ld->ld_responses; lm != NULLMSG; lm = lm->lm_next ) { + prev = NULL; + for ( lm = ld->ld_responses; lm != NULL; lm = lm->lm_next ) { if ( lm->lm_msgid == msgid ) break; prev = lm; } - if ( lm == NULLMSG ) + if ( lm == NULL ) return( -1 ); - if ( prev == NULLMSG ) + if ( prev == NULL ) ld->ld_responses = lm->lm_next; else prev->lm_next = lm->lm_next; @@ -701,7 +712,7 @@ ldap_msgdelete( LDAP *ld, int msgid ) * return 1 if message msgid is waiting to be abandoned, 0 otherwise */ static int -ldap_abandoned( LDAP *ld, int msgid ) +ldap_abandoned( LDAP *ld, ber_int_t msgid ) { int i; @@ -717,7 +728,7 @@ ldap_abandoned( LDAP *ld, int msgid ) static int -ldap_mark_abandoned( LDAP *ld, int msgid ) +ldap_mark_abandoned( LDAP *ld, ber_int_t msgid ) { int i; @@ -743,8 +754,9 @@ ldap_mark_abandoned( LDAP *ld, int msgid ) int cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber ) { - int rc; - unsigned long tag, len; + int rc; + ber_tag_t tag; + ber_len_t len; if ( ! ber_pvt_sb_data_ready(&ld->ld_sb) ) { rc = ldap_select1( ld, timeout ); @@ -763,6 +775,6 @@ cldap_getmsg( LDAP *ld, struct timeval *timeout, BerElement *ber ) return( -1 ); } - return( tag ); + return( 0 ); } #endif /* LDAP_CONNECTIONLESS */ diff --git a/libraries/libldap/sbind.c b/libraries/libldap/sbind.c index fd7892d5e6..8546a879bf 100644 --- a/libraries/libldap/sbind.c +++ b/libraries/libldap/sbind.c @@ -67,7 +67,7 @@ ldap_simple_bind( LDAP *ld, LDAP_CONST char *dn, LDAP_CONST char *passwd ) passwd = ""; /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { return( -1 ); } diff --git a/libraries/libldap/schema.c b/libraries/libldap/schema.c index 2a9d3ec32f..d5bc4e8bc4 100644 --- a/libraries/libldap/schema.c +++ b/libraries/libldap/schema.c @@ -29,8 +29,8 @@ typedef struct safe_string { char * val; - int size; - int pos; + ber_len_t size; + ber_len_t pos; int at_whsp; } safe_string; diff --git a/libraries/libldap/search.c b/libraries/libldap/search.c index d1afce7c0a..379aeae4b5 100644 --- a/libraries/libldap/search.c +++ b/libraries/libldap/search.c @@ -28,7 +28,7 @@ static char *find_right_paren LDAP_P(( static char *put_complex_filter LDAP_P(( BerElement *ber, char *str, - unsigned long tag, + ber_tag_t tag, int not )); static int put_filter LDAP_P(( @@ -98,7 +98,7 @@ ldap_search_ext( ber = ldap_build_search_req( ld, base, scope, filter, attrs, attrsonly, sctrls, cctrls, timelimit, sizelimit ); - if ( ber == NULLBER ) { + if ( ber == NULL ) { return ld->ld_errno; } @@ -184,7 +184,7 @@ ldap_search( ber = ldap_build_search_req( ld, base, scope, filter, attrs, attrsonly, NULL, NULL, -1, -1 ); - if ( ber == NULLBER ) { + if ( ber == NULL ) { return( -1 ); } @@ -208,14 +208,14 @@ BerElement * ldap_build_search_req( LDAP *ld, LDAP_CONST char *base_in, - int scope, + ber_int_t scope, LDAP_CONST char *filter_in, char **attrs, - int attrsonly, + ber_int_t attrsonly, LDAPControl **sctrls, LDAPControl **cctrls, - int timelimit, - int sizelimit ) + ber_int_t timelimit, + ber_int_t sizelimit ) { BerElement *ber; int err; @@ -247,8 +247,8 @@ ldap_build_search_req( */ /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { - return( NULLBER ); + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { + return( NULL ); } if ( base_in == NULL ) { @@ -273,7 +273,7 @@ ldap_build_search_req( } else { #endif /* LDAP_CONNECTIONLESS */ err = ber_printf( ber, "{it{seeiib", ++ld->ld_msgid, - LDAP_REQ_SEARCH, base, scope, ld->ld_deref, + LDAP_REQ_SEARCH, base, (ber_int_t) scope, ld->ld_deref, (sizelimit < 0) ? ld->ld_sizelimit : sizelimit, (timelimit < 0) ? ld->ld_timelimit : timelimit, attrsonly ); @@ -284,7 +284,7 @@ ldap_build_search_req( if ( err == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); - return( NULLBER ); + return( NULL ); } filter = LDAP_STRDUP( filter_in ); @@ -294,25 +294,25 @@ ldap_build_search_req( if ( err == -1 ) { ld->ld_errno = LDAP_FILTER_ERROR; ber_free( ber, 1 ); - return( NULLBER ); + return( NULL ); } - if ( ber_printf( ber, "{v}}", attrs ) == -1 ) { + if ( ber_printf( ber, /*{*/ "{v}}", attrs ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); - return( NULLBER ); + return( NULL ); } /* Put Server Controls */ if( ldap_int_put_controls( ld, sctrls, ber ) != LDAP_SUCCESS ) { ber_free( ber, 1 ); - return( NULLBER ); + return( NULL ); } - if ( ber_printf( ber, "}", attrs ) == -1 ) { + if ( ber_printf( ber, /*{*/ "}", attrs ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); - return( NULLBER ); + return( NULL ); } return( ber ); @@ -344,7 +344,7 @@ find_right_paren( char *s ) } static char * -put_complex_filter( BerElement *ber, char *str, unsigned long tag, int not ) +put_complex_filter( BerElement *ber, char *str, ber_tag_t tag, int not ) { char *next; @@ -356,7 +356,7 @@ put_complex_filter( BerElement *ber, char *str, unsigned long tag, int not ) */ /* put explicit tag */ - if ( ber_printf( ber, "t{", tag ) == -1 ) + if ( ber_printf( ber, "t{" /*}*/, tag ) == -1 ) return( NULL ); str++; @@ -369,7 +369,7 @@ put_complex_filter( BerElement *ber, char *str, unsigned long tag, int not ) *next++ = ')'; /* flush explicit tagged thang */ - if ( ber_printf( ber, "}" ) == -1 ) + if ( ber_printf( ber, /*{*/ "}" ) == -1 ) return( NULL ); return( next ); @@ -509,7 +509,7 @@ put_filter( BerElement *ber, char *str ) case ')': Debug( LDAP_DEBUG_TRACE, "put_filter: end\n", 0, 0, 0 ); - if ( ber_printf( ber, "]" ) == -1 ) + if ( ber_printf( ber, /*[*/ "]" ) == -1 ) return( -1 ); str++; parens--; @@ -590,7 +590,7 @@ put_simple_filter( { char *s; char *value, savechar; - unsigned long ftype; + ber_tag_t ftype; int rc; Debug( LDAP_DEBUG_TRACE, "put_simple_filter \"%s\"\n", str, 0, 0 ); @@ -646,12 +646,12 @@ static int put_substring_filter( BerElement *ber, char *type, char *val ) { char *nextstar, gotstar = 0; - unsigned long ftype; + ber_tag_t ftype = LDAP_FILTER_SUBSTRINGS; Debug( LDAP_DEBUG_TRACE, "put_substring_filter \"%s=%s\"\n", type, val, 0 ); - if ( ber_printf( ber, "t{s{", LDAP_FILTER_SUBSTRINGS, type ) == -1 ) + if ( ber_printf( ber, "t{s{", ftype, type ) == -1 ) return( -1 ); while ( val != NULL ) { @@ -676,7 +676,7 @@ put_substring_filter( BerElement *ber, char *type, char *val ) val = nextstar; } - if ( ber_printf( ber, "}}" ) == -1 ) + if ( ber_printf( ber, /* {{ */ "}}" ) == -1 ) return( -1 ); return( 0 ); diff --git a/libraries/libldap/srchpref.c b/libraries/libldap/srchpref.c index 11082dc668..54405e341d 100644 --- a/libraries/libldap/srchpref.c +++ b/libraries/libldap/srchpref.c @@ -99,7 +99,9 @@ ldap_init_searchprefs( char *file, struct ldap_searchobj **solistp ) int -ldap_init_searchprefs_buf( char *buf, long buflen, +ldap_init_searchprefs_buf( + char *buf, + ber_len_t buflen, struct ldap_searchobj **solistp ) { int rc = -1, version; diff --git a/libraries/libldap/test.c b/libraries/libldap/test.c index b6aab5924d..dc52cd1f6b 100644 --- a/libraries/libldap/test.c +++ b/libraries/libldap/test.c @@ -113,7 +113,7 @@ static int file_read( char *path, struct berval *bv ) { FILE *fp; - long rlen; + ber_slen_t rlen; int eof; if (( fp = fopen( path, "r" )) == NULL ) { @@ -145,7 +145,7 @@ file_read( char *path, struct berval *bv ) eof = feof( fp ); fclose( fp ); - if ( (unsigned long) rlen != bv->bv_len ) { + if ( (ber_len_t) rlen != bv->bv_len ) { perror( path ); free( bv->bv_val ); return( -1 ); @@ -575,7 +575,7 @@ main( int argc, char **argv ) printf( "\nresult: msgtype %d msgid %d\n", msgtype, res->lm_msgid ); handle_result( ld, res ); - res = NULLMSG; + res = NULL; break; case 'm': /* remove */ @@ -618,7 +618,7 @@ main( int argc, char **argv ) printf( "\nresult: msgid %d\n", res->lm_msgid ); handle_result( ld, res ); - res = NULLMSG; + res = NULL; } #endif /* LDAP_CONNECTIONLESS */ } else { @@ -663,7 +663,7 @@ main( int argc, char **argv ) else { printf( "\nresult: err %d\n", id ); handle_result( ld, res ); - res = NULLMSG; + res = NULL; } free_list( types ); break; @@ -912,7 +912,7 @@ print_search_entry( LDAP *ld, LDAPMessage *res ) { LDAPMessage *e; - for ( e = ldap_first_entry( ld, res ); e != NULLMSG; + for ( e = ldap_first_entry( ld, res ); e != NULL; e = ldap_next_entry( ld, e ) ) { BerElement *ber = NULL; @@ -945,7 +945,7 @@ print_search_entry( LDAP *ld, LDAPMessage *res ) int j, nonascii; nonascii = 0; - for ( j = 0; (unsigned long) j < vals[i]->bv_len; j++ ) + for ( j = 0; (ber_len_t) j < vals[i]->bv_len; j++ ) if ( !isascii( vals[i]->bv_val[j] ) ) { nonascii = 1; break; @@ -972,6 +972,6 @@ print_search_entry( LDAP *ld, LDAPMessage *res ) } if ( res->lm_msgtype == LDAP_RES_SEARCH_RESULT - || res->lm_chain != NULLMSG ) + || res->lm_chain != NULL ) print_ldap_result( ld, res, "search" ); } diff --git a/libraries/libldap/tmplout.c b/libraries/libldap/tmplout.c index b3b16b194b..cfa29ee2f5 100644 --- a/libraries/libldap/tmplout.c +++ b/libraries/libldap/tmplout.c @@ -426,7 +426,7 @@ do_entry2text_search( struct ldap_disptmpl *tmpl; struct timeval timeout; - if ( dn == NULL && entry == NULLMSG ) { + if ( dn == NULL && entry == NULL ) { ld->ld_errno = LDAP_PARAM_ERROR; return( ld->ld_errno ); } @@ -467,7 +467,7 @@ do_entry2text_search( if ( tmpllist != NULL ) { - ldmp = NULLMSG; + ldmp = NULL; if ( entry == NULL ) { char *ocattrs[2]; diff --git a/libraries/libldap/unbind.c b/libraries/libldap/unbind.c index b5011978d0..39b3263e4c 100644 --- a/libraries/libldap/unbind.c +++ b/libraries/libldap/unbind.c @@ -161,12 +161,12 @@ ldap_send_unbind( Debug( LDAP_DEBUG_TRACE, "ldap_send_unbind\n", 0, 0, 0 ); /* create a message to send */ - if ( (ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { + if ( (ber = ldap_alloc_ber_with_options( ld )) == NULL ) { return( ld->ld_errno ); } /* fill it in */ - if ( ber_printf( ber, "{itn", ++ld->ld_msgid, + if ( ber_printf( ber, "{itn" /*}*/, ++ld->ld_msgid, LDAP_REQ_UNBIND ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); @@ -179,8 +179,7 @@ ldap_send_unbind( return ld->ld_errno; } - if ( ber_printf( ber, "}", ++ld->ld_msgid, - LDAP_REQ_UNBIND ) == -1 ) { + if ( ber_printf( ber, /*{*/ "}", LDAP_REQ_UNBIND ) == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); return( ld->ld_errno ); diff --git a/libraries/libldap/url.c b/libraries/libldap/url.c index 7ede89a768..c5a4e0650c 100644 --- a/libraries/libldap/url.c +++ b/libraries/libldap/url.c @@ -267,7 +267,7 @@ ldap_url_search( LDAP *ld, LDAP_CONST char *url, int attrsonly ) ludp->lud_filter, ludp->lud_attrs, attrsonly, NULL, NULL, -1, -1 ); - if ( ber == NULLBER ) { + if ( ber == NULL ) { return( -1 ); } diff --git a/servers/slapd/abandon.c b/servers/slapd/abandon.c index 968c64d4cf..d6b4704d32 100644 --- a/servers/slapd/abandon.c +++ b/servers/slapd/abandon.c @@ -25,7 +25,7 @@ do_abandon( Operation *op ) { - int id; + ber_int_t id; Operation *o; Operation **oo; diff --git a/servers/slapd/add.c b/servers/slapd/add.c index 5e195c726f..6ca236a279 100644 --- a/servers/slapd/add.c +++ b/servers/slapd/add.c @@ -27,7 +27,8 @@ do_add( Connection *conn, Operation *op ) { BerElement *ber = op->o_ber; char *dn, *last; - unsigned long len, tag; + ber_len_t len; + ber_tag_t tag; Entry *e; Backend *be; @@ -46,7 +47,7 @@ do_add( Connection *conn, Operation *op ) */ /* get the name */ - if ( ber_scanf( ber, "{a", &dn ) == LBER_ERROR ) { + if ( ber_scanf( ber, "{a", /*}*/ &dn ) == LBER_ERROR ) { Debug( LDAP_DEBUG_ANY, "ber_scanf failed\n", 0, 0, 0 ); send_ldap_result( conn, op, LDAP_PROTOCOL_ERROR, NULL, "decoding error" ); diff --git a/servers/slapd/back-ldbm/back-ldbm.h b/servers/slapd/back-ldbm/back-ldbm.h index 73fc4eb902..267bbcffa6 100644 --- a/servers/slapd/back-ldbm/back-ldbm.h +++ b/servers/slapd/back-ldbm/back-ldbm.h @@ -144,8 +144,8 @@ struct ldbminfo { extern int ldbm_ignore_nextid_file; -#include "proto-back-ldbm.h" - LDAP_END_DECL +#include "proto-back-ldbm.h" + #endif /* _back_ldbm_h_ */ diff --git a/servers/slapd/back-ldbm/external.h b/servers/slapd/back-ldbm/external.h index 54741012cf..144b56c78e 100644 --- a/servers/slapd/back-ldbm/external.h +++ b/servers/slapd/back-ldbm/external.h @@ -38,7 +38,7 @@ extern int ldbm_back_modify LDAP_P(( BackendDB *bd, extern int ldbm_back_modrdn LDAP_P(( BackendDB *bd, Connection *conn, Operation *op, - char *dn, char*newrdn, int deleteoldrdn, + char *dn, char* newrdn, int deleteoldrdn, char *newSuperior )); extern int ldbm_back_add LDAP_P(( BackendDB *bd, @@ -48,7 +48,7 @@ extern int ldbm_back_delete LDAP_P(( BackendDB *bd, Connection *conn, Operation *op, char *dn )); extern int ldbm_back_abandon LDAP_P(( BackendDB *bd, - Connection *conn, Operation *op, int msgid )); + Connection *conn, Operation *op, ber_int_t msgid )); extern int ldbm_back_group LDAP_P(( BackendDB *bd, Entry *target, char* gr_ndn, char* op_ndn, diff --git a/servers/slapd/back-ldbm/startup.c b/servers/slapd/back-ldbm/startup.c index 910eb67e23..c9e8703d1f 100644 --- a/servers/slapd/back-ldbm/startup.c +++ b/servers/slapd/back-ldbm/startup.c @@ -55,7 +55,7 @@ ldbm_back_startup( char cwd[MAXPATHLEN]; (void) getcwd( cwd, MAXPATHLEN ); - sprintf( cwd, "%s%s%s", cwd, LDAP_DIRSEP, li->li_directory ); + sprintf( cwd, "%s" LDAP_DIRSEP "%s", cwd, li->li_directory ); free( li->li_directory ); li->li_directory = strdup( cwd ); diff --git a/servers/slapd/bind.c b/servers/slapd/bind.c index 8207166e73..c72368608e 100644 --- a/servers/slapd/bind.c +++ b/servers/slapd/bind.c @@ -28,10 +28,10 @@ do_bind( ) { BerElement *ber = op->o_ber; - int version; - unsigned long method; + ber_int_t version; + ber_tag_t method; char *cdn, *ndn; - unsigned long rc; + ber_tag_t rc; struct berval cred; Backend *be; @@ -59,7 +59,8 @@ do_bind( { BerElement *tber; - unsigned long tlen, ttag; + ber_len_t tlen; + ber_tag_t ttag; tber = ber_dup( op->o_ber ); ttag = ber_skip_tag( tber, &tlen ); diff --git a/servers/slapd/ch_malloc.c b/servers/slapd/ch_malloc.c index b445796970..c1ec6f0b1c 100644 --- a/servers/slapd/ch_malloc.c +++ b/servers/slapd/ch_malloc.c @@ -13,13 +13,14 @@ void * ch_malloc( - unsigned long size + ber_len_t size ) { void *new; - if ( (new = (void *) malloc( size )) == NULL ) { - Debug( LDAP_DEBUG_ANY, "malloc of %lu bytes failed\n", size, 0, 0 ); + if ( (new = (void *) ber_memalloc( size )) == NULL ) { + Debug( LDAP_DEBUG_ANY, "ch_malloc of %lu bytes failed\n", + (long) size, 0, 0 ); exit( 1 ); } @@ -29,7 +30,7 @@ ch_malloc( void * ch_realloc( void *block, - unsigned long size + ber_len_t size ) { void *new; @@ -38,8 +39,13 @@ ch_realloc( return( ch_malloc( size ) ); } - if ( (new = (void *) realloc( block, size )) == NULL ) { - Debug( LDAP_DEBUG_ANY, "realloc of %lu bytes failed\n", size, 0, 0 ); + if( size == 0 ) { + ch_free( block ); + } + + if ( (new = (void *) ber_memrealloc( block, size )) == NULL ) { + Debug( LDAP_DEBUG_ANY, "ch_realloc of %lu bytes failed\n", + (long) size, 0, 0 ); exit( 1 ); } @@ -48,15 +54,15 @@ ch_realloc( void * ch_calloc( - unsigned long nelem, - unsigned long size + ber_len_t nelem, + ber_len_t size ) { void *new; - if ( (new = (void *) calloc( nelem, size )) == NULL ) { - Debug( LDAP_DEBUG_ANY, "calloc of %lu elems of %lu bytes failed\n", - nelem, size, 0 ); + if ( (new = (void *) ber_memcalloc( nelem, size )) == NULL ) { + Debug( LDAP_DEBUG_ANY, "ch_calloc of %lu elems of %lu bytes failed\n", + (long) nelem, (long) size, 0 ); exit( 1 ); } @@ -70,11 +76,16 @@ ch_strdup( { char *new; - if ( (new = strdup( string )) == NULL ) { - Debug( LDAP_DEBUG_ANY, "strdup(%s) failed\n", string, 0, 0 ); + if ( (new = ber_strdup( string )) == NULL ) { + Debug( LDAP_DEBUG_ANY, "ch_strdup(%s) failed\n", string, 0, 0 ); exit( 1 ); } return( new ); } +void +ch_free( void *ptr ) +{ + ber_memfree( ptr ); +} \ No newline at end of file diff --git a/servers/slapd/connection.c b/servers/slapd/connection.c index ad6b96c99e..319b20396e 100644 --- a/servers/slapd/connection.c +++ b/servers/slapd/connection.c @@ -16,7 +16,7 @@ /* protected by connections_mutex */ static ldap_pvt_thread_mutex_t connections_mutex; static Connection *connections = NULL; -static long conn_nextid = 0; +static unsigned long conn_nextid = 0; /* structure state (protected by connections_mutex) */ #define SLAP_C_UNINITIALIZED 0x00 /* MUST BE ZERO (0) */ @@ -30,7 +30,7 @@ static long conn_nextid = 0; #define SLAP_C_BINDING 0x03 /* binding */ #define SLAP_C_CLOSING 0x04 /* closing */ -static Connection* connection_get( int s ); +static Connection* connection_get( ber_socket_t s ); static int connection_input( Connection *c ); static void connection_close( Connection *c ); @@ -84,7 +84,7 @@ int connections_init(void) */ int connections_destroy(void) { - int i; + ber_socket_t i; /* should check return of every call */ @@ -114,7 +114,7 @@ int connections_destroy(void) */ int connections_shutdown(void) { - int i; + ber_socket_t i; ldap_pvt_thread_mutex_lock( &connections_mutex ); @@ -137,19 +137,19 @@ int connections_shutdown(void) return 0; } -static Connection* connection_get( int s ) +static Connection* connection_get( ber_socket_t s ) { /* connections_mutex should be locked by caller */ Connection *c; Debug( LDAP_DEBUG_ARGS, - "connection_get(%d)\n", - s, 0, 0 ); + "connection_get(%ld)\n", + (long) s, 0, 0 ); assert( connections != NULL ); - if(s < 0) { + if(s == AC_SOCKET_INVALID) { return NULL; } @@ -161,7 +161,7 @@ static Connection* connection_get( int s ) #else c = NULL; { - int i; + ber_socket_t i; for(i=0; ico_op->o_tag; + ber_tag_t tag = arg->co_op->o_tag; Connection *conn = arg->co_conn; #ifdef LDAP_COUNTERS @@ -678,7 +678,7 @@ connection_operation( void *arg_v ) return NULL; } -int connection_read(int s) +int connection_read(ber_socket_t s) { int rc = 0; Connection *c; @@ -691,8 +691,8 @@ int connection_read(int s) if( c == NULL ) { Debug( LDAP_DEBUG_ANY, - "connection_read(%d): no connection!\n", - s, 0, 0 ); + "connection_read(%ld): no connection!\n", + (long) s, 0, 0 ); slapd_remove(s, 0); @@ -746,8 +746,9 @@ connection_input( ) { Operation *op; - unsigned long tag, len; - long msgid; + ber_tag_t tag; + ber_len_t len; + ber_int_t msgid; BerElement *ber; if ( conn->c_currentber == NULL && (conn->c_currentber = ber_alloc()) @@ -870,7 +871,7 @@ static int connection_op_activate( Connection *conn, Operation *op ) struct co_arg *arg; char *tmpdn; int status; - unsigned long tag = op->o_tag; + ber_tag_t tag = op->o_tag; if ( conn->c_dn != NULL ) { tmpdn = ch_strdup( conn->c_dn ); @@ -912,7 +913,7 @@ static int connection_op_activate( Connection *conn, Operation *op ) return status; } -int connection_write(int s) +int connection_write(ber_socket_t s) { Connection *c; assert( connections != NULL ); @@ -925,8 +926,8 @@ int connection_write(int s) if( c == NULL ) { Debug( LDAP_DEBUG_ANY, - "connection_write(%d): no connection!\n", - s, 0, 0 ); + "connection_write(%ld): no connection!\n", + (long) s, 0, 0 ); slapd_remove(s, 0); ldap_pvt_thread_mutex_unlock( &connections_mutex ); return -1; diff --git a/servers/slapd/daemon.c b/servers/slapd/daemon.c index ffbf9ea1c7..eb26b8fede 100644 --- a/servers/slapd/daemon.c +++ b/servers/slapd/daemon.c @@ -21,12 +21,13 @@ int deny_severity = LOG_NOTICE; #endif /* TCP Wrappers */ /* globals */ -int dtblsize; -static int tcps; +ber_socket_t dtblsize; +static ber_socket_t tcps; #ifdef HAVE_WINSOCK2 /* in nt_main.c */ extern ldap_pvt_thread_cond_t started_event; + /* forward reference */ void hit_socket(); /* In wsa_err.c */ @@ -78,7 +79,7 @@ struct slap_daemon { /* * Add a descriptor to daemon control */ -static void slapd_add(int s) { +static void slapd_add(ber_socket_t s) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); assert( !FD_ISSET( s, &slap_daemon.sd_actives )); @@ -91,10 +92,11 @@ static void slapd_add(int s) { } #endif - FD_SET( (unsigned) s, &slap_daemon.sd_actives ); - FD_SET( (unsigned) s, &slap_daemon.sd_readers ); + FD_SET( s, &slap_daemon.sd_actives ); + FD_SET( s, &slap_daemon.sd_readers ); - Debug( LDAP_DEBUG_CONNS, "daemon: added %d%s%s\n", s, + Debug( LDAP_DEBUG_CONNS, "daemon: added %ld%s%s\n", + (long) s, FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "", FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ); @@ -104,27 +106,28 @@ static void slapd_add(int s) { /* * Remove the descriptor from daemon control */ -void slapd_remove(int s, int wake) { +void slapd_remove(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); WAKE_LISTENER(wake); - Debug( LDAP_DEBUG_CONNS, "daemon: removing %d%s%s\n", s, + Debug( LDAP_DEBUG_CONNS, "daemon: removing %ld%s%s\n", + (long) s, FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "", FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ); - FD_CLR( (unsigned) s, &slap_daemon.sd_actives ); - FD_CLR( (unsigned) s, &slap_daemon.sd_readers ); - FD_CLR( (unsigned) s, &slap_daemon.sd_writers ); + FD_CLR( s, &slap_daemon.sd_actives ); + FD_CLR( s, &slap_daemon.sd_readers ); + FD_CLR( s, &slap_daemon.sd_writers ); ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); } -void slapd_clr_write(int s, int wake) { +void slapd_clr_write(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); WAKE_LISTENER(wake); - assert( FD_ISSET( (unsigned) s, &slap_daemon.sd_actives) ); - FD_CLR( (unsigned) s, &slap_daemon.sd_writers ); + assert( FD_ISSET( s, &slap_daemon.sd_actives) ); + FD_CLR( s, &slap_daemon.sd_writers ); ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); @@ -133,7 +136,7 @@ void slapd_clr_write(int s, int wake) { } } -void slapd_set_write(int s, int wake) { +void slapd_set_write(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); WAKE_LISTENER(wake); @@ -147,12 +150,12 @@ void slapd_set_write(int s, int wake) { } } -void slapd_clr_read(int s, int wake) { +void slapd_clr_read(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); WAKE_LISTENER(wake); assert( FD_ISSET( s, &slap_daemon.sd_actives) ); - FD_CLR( (unsigned) s, &slap_daemon.sd_readers ); + FD_CLR( s, &slap_daemon.sd_readers ); ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); @@ -161,12 +164,12 @@ void slapd_clr_read(int s, int wake) { } } -void slapd_set_read(int s, int wake) { +void slapd_set_read(ber_socket_t s, int wake) { ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex ); WAKE_LISTENER(wake); assert( FD_ISSET( s, &slap_daemon.sd_actives) ); - FD_SET( (unsigned) s, &slap_daemon.sd_readers ); + FD_SET( s, &slap_daemon.sd_readers ); ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex ); @@ -175,8 +178,9 @@ void slapd_set_read(int s, int wake) { } } -static void slapd_close(int s) { - Debug( LDAP_DEBUG_CONNS, "daemon: closing %d\n", s, 0, 0 ); +static void slapd_close(ber_socket_t s) { + Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n", + (long) s, 0, 0 ); tcp_close(s); } @@ -185,7 +189,8 @@ static void slapd_close(int s) { int set_socket( struct sockaddr_in *addr ) { - int tcps = -1; + ber_socket_t tcps = AC_SOCKET_INVALID; + if ( !daemon_initialized ) sockinit(); #ifdef HAVE_SYSCONF @@ -205,7 +210,7 @@ set_socket( struct sockaddr_in *addr ) if( addr != NULL ) { int tmp; - if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) { + if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID ) { #ifndef HAVE_WINSOCK int err = errno; Debug( LDAP_DEBUG_ANY, @@ -224,9 +229,9 @@ set_socket( struct sockaddr_in *addr ) #ifndef HAVE_WINSOCK if ( tcps >= dtblsize ) { Debug( LDAP_DEBUG_ANY, - "daemon: listener descriptor %d is too great\n", - tcps, dtblsize, 0 ); - return -1; + "daemon: listener descriptor %ld is too great %ld\n", + (long) tcps, (long) dtblsize, 0 ); + return( -1); } #endif @@ -237,8 +242,8 @@ set_socket( struct sockaddr_in *addr ) { int err = errno; Debug( LDAP_DEBUG_ANY, - "slapd(%d): setsockopt() failed errno %d (%s)\n", - tcps, err, + "slapd(%ld): setsockopt() failed errno %d (%s)\n", + (long) tcps, err, err > -1 && err < sys_nerr ? sys_errlist[err] : "unknown" ); } @@ -250,8 +255,8 @@ set_socket( struct sockaddr_in *addr ) { int err = errno; Debug( LDAP_DEBUG_ANY, - "slapd(%d): setsockopt(KEEPALIVE) failed errno %d (%s)\n", - tcps, err, + "slapd(%ld): setsockopt(KEEPALIVE) failed errno %d (%s)\n", + (long) tcps, err, err > -1 && err < sys_nerr ? sys_errlist[err] : "unknown" ); } @@ -260,8 +265,8 @@ set_socket( struct sockaddr_in *addr ) if ( bind( tcps, (struct sockaddr *) addr, sizeof(*addr) ) == -1 ) { int err = errno; - Debug( LDAP_DEBUG_ANY, "daemon: bind(%d) failed errno %d (%s)\n", - tcps, err, + Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno %d (%s)\n", + (long) tcps, err, err > -1 && err < sys_nerr ? sys_errlist[err] : "unknown" ); return -1; @@ -281,7 +286,6 @@ slapd_daemon_task( struct sockaddr_in *slapd_addr = args->addr; tcps = args->tcps; - /*free( ptr ); This seems to be wrong unless I hosed something */ inetd = ( slapd_addr == NULL); if ( !daemon_initialized ) sockinit(); @@ -296,8 +300,8 @@ slapd_daemon_task( if ( listen( tcps, 5 ) == -1 ) { int err = errno; Debug( LDAP_DEBUG_ANY, - "daemon: listen(%d, 5) failed errno %d (%s)\n", - tcps, err, + "daemon: listen(%ld, 5) failed errno %d (%s)\n", + (long) tcps, err, err > -1 && err < sys_nerr ? sys_errlist[err] : "unknown" ); return( (void*)-1 ); @@ -306,7 +310,7 @@ slapd_daemon_task( slapd_add( tcps ); } else { - if( connection_init( 0, NULL, NULL ) ) { + if( connection_init( (ber_socket_t) 0, NULL, NULL ) ) { Debug( LDAP_DEBUG_ANY, "connection_init(%d) failed.\n", 0, 0, 0 ); @@ -321,9 +325,11 @@ slapd_daemon_task( ldap_pvt_thread_cond_signal( &started_event ); #endif /* initialization complete. Here comes the loop. */ + while ( !slapd_shutdown ) { - unsigned int i; - int ns, nfds; + ber_socket_t i; + int ns; + ber_socket_t nfds; int ebadf = 0; #define SLAPD_EBADF_LIMIT 10 @@ -428,17 +434,17 @@ slapd_daemon_task( } if ( FD_ISSET( tcps, &readfds ) ) { - int s; + ber_int_t s; int len = sizeof(from); long id; if ( (s = accept( tcps, - (struct sockaddr *) &from, &len )) == -1 ) + (struct sockaddr *) &from, &len )) == AC_SOCKET_INVALID ) { int err = errno; Debug( LDAP_DEBUG_ANY, - "daemon: accept(%d) failed errno %d (%s)\n", err, - tcps, err >= 0 && err < sys_nerr ? + "daemon: accept(%ld) failed errno %d (%s)\n", err, + (long) tcps, err >= 0 && err < sys_nerr ? sys_errlist[err] : "unknown"); continue; } @@ -459,15 +465,15 @@ slapd_daemon_task( /* make sure descriptor number isn't too great */ if ( s >= dtblsize ) { Debug( LDAP_DEBUG_ANY, - "daemon: %d beyond descriptor table size %d\n", - s, dtblsize, 0 ); + "daemon: %ld beyond descriptor table size %ld\n", + (long) s, (long) dtblsize, 0 ); slapd_close(s); continue; } #endif - Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %d\n", - s, 0, 0 ); + Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n", + (long) s, 0, 0 ); len = sizeof(from); if ( getpeername( s, (struct sockaddr *) &from, &len ) == 0 ) { @@ -507,8 +513,8 @@ slapd_daemon_task( { /* DENY ACCESS */ Statslog( LDAP_DEBUG_ANY, - "fd=%d connection from %s (%s) denied.\n", - s, + "fd=%ld connection from %s (%s) denied.\n", + (long) s, client_name == NULL ? "unknown" : client_name, client_addr == NULL ? "unknown" : client_addr, 0, 0 ); @@ -520,8 +526,8 @@ slapd_daemon_task( if( (id = connection_init(s, client_name, client_addr)) < 0 ) { Debug( LDAP_DEBUG_ANY, - "daemon: connection_init(%d, %s, %s) failed.\n", - s, + "daemon: connection_init(%ld, %s, %s) failed.\n", + (long) s, client_name == NULL ? "unknown" : client_name, client_addr == NULL ? "unknown" : client_addr); slapd_close(s); @@ -529,8 +535,8 @@ slapd_daemon_task( } Statslog( LDAP_DEBUG_STATS, - "daemon: conn=%d fd=%d connection from %s (%s) accepted.\n", - id, s, + "daemon: conn=%d fd=%ld connection from %s (%s) accepted.\n", + id, (long) s, client_name == NULL ? "unknown" : client_name, client_addr == NULL ? "unknown" : client_addr, 0 ); @@ -570,7 +576,7 @@ slapd_daemon_task( for ( i = 0; i < nfds; i++ ) #endif { - int wd; + ber_socket_t wd; #ifdef HAVE_WINSOCK wd = writefds.fd_array[i]; @@ -607,7 +613,7 @@ slapd_daemon_task( for ( i = 0; i < nfds; i++ ) #endif { - int rd; + ber_socket_t rd; #ifdef HAVE_WINSOCK rd = readfds.fd_array[i]; @@ -747,11 +753,12 @@ void sockinit() void hit_socket() { - int s, on = 1; + ber_socket_t s; + int on = 1; extern struct sockaddr_in bind_addr; /* throw something at the socket to terminate the select() in the daemon thread. */ - if (( s = socket( AF_INET, SOCK_STREAM, 0 )) == INVALID_SOCKET ) + if (( s = socket( AF_INET, SOCK_STREAM, 0 )) == AC_SOCKET_INVALID ) Debug( LDAP_DEBUG_ANY, "slap_set_shutdown: socket failed\n\tWSAGetLastError=%d (%s)\n", WSAGetLastError(), WSAGetLastErrorString(), 0 ); @@ -784,7 +791,6 @@ void sockinit() void sockinit() { daemon_initialized = 1; - return; } #endif diff --git a/servers/slapd/filter.c b/servers/slapd/filter.c index 2a977940e1..5176842df1 100644 --- a/servers/slapd/filter.c +++ b/servers/slapd/filter.c @@ -187,7 +187,8 @@ get_filter_list( Connection *conn, BerElement *ber, Filter **f, char **fstr ) { Filter **new; int err; - unsigned long tag, len; + ber_tag_t tag; + ber_len_t len; char *last, *ftmp; Debug( LDAP_DEBUG_FILTER, "begin get_filter_list\n", 0, 0, 0 ); @@ -227,7 +228,9 @@ get_substring_filter( char **fstr ) { - unsigned long tag, len, rc; + ber_tag_t tag; + ber_len_t len; + ber_tag_t rc; char *val, *last; int syntax; @@ -238,7 +241,7 @@ get_substring_filter( (void) ber_skip_tag( ber, &len ); } #endif - if ( ber_scanf( ber, "{a", &f->f_sub_type ) == LBER_ERROR ) { + if ( ber_scanf( ber, "{a" /*}*/, &f->f_sub_type ) == LBER_ERROR ) { return( LDAP_PROTOCOL_ERROR ); } attr_normalize( f->f_sub_type ); diff --git a/servers/slapd/main.c b/servers/slapd/main.c index 23e9ce060f..8850e54a2f 100644 --- a/servers/slapd/main.c +++ b/servers/slapd/main.c @@ -13,9 +13,7 @@ #include "ldap_defaults.h" #include "slap.h" -#include "lutil.h" /* Get lutil_detach() */ - -int set_socket( struct sockaddr_in *addr ); +#include "lutil.h" #ifdef LDAP_SIGCHLD static RETSIGTYPE wait4child( int sig ); @@ -96,7 +94,7 @@ usage( char *name ) fprintf( stderr, "usage: %s [-d ?|debuglevel] [-f configfile] [-p portnumber] [-s sysloglevel]", name ); fprintf( stderr, "\n [-a bind-address] [-i] [-u]" ); #ifdef HAVE_WINSOCK - fprintf( stderr, " [-v NTserviceName]" ); + fprintf( stderr, " [-n NTserviceName]" ); #endif #if LDAP_CONNECTIONLESS fprintf( stderr, " [-c]" ); @@ -115,16 +113,14 @@ usage( char *name ) time_t starttime; struct sockaddr_in bind_addr; -int tcps; +ber_int_t tcps; #ifdef HAVE_WINSOCK void WINAPI ServiceMain( DWORD argc, LPTSTR *argv ) -{ #else int main( int argc, char **argv ) -{ #endif - +{ int i; int inetd = 0; int rc; @@ -181,7 +177,6 @@ int main( int argc, char **argv ) Debug ( LDAP_DEBUG_ANY, "new config file from registry is: %s\n", configfile, 0, 0 ); } } - #endif while ( (i = getopt( argc, argv, @@ -199,7 +194,7 @@ int main( int argc, char **argv ) "c" #endif #ifdef HAVE_WINSOCK - "v:" + "n:" #endif )) != EOF ) { switch ( i ) { @@ -308,7 +303,7 @@ int main( int argc, char **argv ) break; #endif /* SETUID && GETUID */ #ifdef HAVE_WINSOCK - case 'v': /* NT service name */ + case 'n': /* NT service name */ NTservice = ch_strdup( optarg ); break; #endif @@ -355,7 +350,6 @@ int main( int argc, char **argv ) goto destroy; } - tcps = set_socket( inetd ? NULL : &bind_addr ); if ( tcps == -1 ) goto destroy; @@ -373,7 +367,7 @@ int main( int argc, char **argv ) #ifdef LDAP_SIGCHLD (void) SIGNAL( LDAP_SIGCHLD, wait4child ); #endif -#ifdef HAVE_WINSOCK +#ifdef SIGBREAK /* SIGBREAK is generated when Ctrl-Break is pressed. */ (void) SIGNAL( SIGBREAK, slap_set_shutdown ); #endif @@ -436,7 +430,6 @@ int main( int argc, char **argv ) ldap_pvt_thread_cond_destroy( &started_event ); #endif - shutdown: /* remember an error during shutdown */ rc |= slap_shutdown(-1); diff --git a/servers/slapd/modify.c b/servers/slapd/modify.c index 53b4ac7680..345dc5f36b 100644 --- a/servers/slapd/modify.c +++ b/servers/slapd/modify.c @@ -30,7 +30,8 @@ do_modify( { char *ndn; char *last; - unsigned long tag, len; + ber_tag_t tag; + ber_len_t len; LDAPModList *modlist; LDAPModList **modtail; #ifdef LDAP_DEBUG @@ -77,9 +78,11 @@ do_modify( tag != LBER_DEFAULT; tag = ber_next_element( op->o_ber, &len, last ) ) { + ber_int_t mop; + (*modtail) = (LDAPModList *) ch_calloc( 1, sizeof(LDAPModList) ); - if ( ber_scanf( op->o_ber, "{i{a[V]}}", &(*modtail)->ml_op, + if ( ber_scanf( op->o_ber, "{i{a[V]}}", &mop, &(*modtail)->ml_type, &(*modtail)->ml_bvalues ) == LBER_ERROR ) { @@ -92,6 +95,8 @@ do_modify( return; } + (*modtail)->ml_op = mop; + if ( (*modtail)->ml_op != LDAP_MOD_ADD && (*modtail)->ml_op != LDAP_MOD_DELETE && (*modtail)->ml_op != LDAP_MOD_REPLACE ) diff --git a/servers/slapd/modrdn.c b/servers/slapd/modrdn.c index b1c5e1a551..66b7f93f78 100644 --- a/servers/slapd/modrdn.c +++ b/servers/slapd/modrdn.c @@ -39,13 +39,13 @@ do_modrdn( ) { char *ndn, *newrdn; - int deloldrdn; + ber_int_t deloldrdn; Backend *be; /* Vars for LDAP v3 newSuperior support */ char *newSuperior = NULL; char *nnewSuperior = NULL; Backend *newSuperior_be = NULL; - unsigned long length; + ber_len_t length; Debug( LDAP_DEBUG_TRACE, "do_modrdn\n", 0, 0, 0 ); @@ -100,7 +100,7 @@ do_modrdn( }/* else if ( conn->c_protocol == 0 ) */ - if ( ber_scanf( op->o_ber, "a}", &newSuperior ) + if ( ber_scanf( op->o_ber, /*{*/ "a}", &newSuperior ) == LBER_ERROR ) { Debug( LDAP_DEBUG_ANY, "ber_scanf(\"a\"}) failed\n", @@ -109,7 +109,7 @@ do_modrdn( "" ); return; - }/* if ( ber_scanf( ber, "a}", &newSuperior ) == ... ) */ + }/* if ( ber_scanf( ber, { "a}", &newSuperior ) == ... ) */ Debug( LDAP_DEBUG_ARGS, "do_modrdn: newSuperior=(%s)\n", diff --git a/servers/slapd/monitor.c b/servers/slapd/monitor.c index b2ea44db1d..eccdcbec12 100644 --- a/servers/slapd/monitor.c +++ b/servers/slapd/monitor.c @@ -129,7 +129,7 @@ monitor_info( Connection *conn, Operation *op ) val.bv_len = strlen( buf ); attr_merge( e, "totalconnections", vals ); - sprintf( buf, "%d", dtblsize ); + sprintf( buf, "%ld", (long) dtblsize ); val.bv_val = buf; val.bv_len = strlen( buf ); attr_merge( e, "dtablesize", vals ); diff --git a/servers/slapd/operation.c b/servers/slapd/operation.c index 44c821845e..6f6ab510ef 100644 --- a/servers/slapd/operation.c +++ b/servers/slapd/operation.c @@ -33,9 +33,9 @@ slap_op_free( Operation *op ) Operation * slap_op_alloc( BerElement *ber, - unsigned long msgid, - unsigned long tag, - long id + ber_int_t msgid, + ber_tag_t tag, + ber_int_t id ) { Operation *op; diff --git a/servers/slapd/proto-slap.h b/servers/slapd/proto-slap.h index 517875c2e8..dba1e5debe 100644 --- a/servers/slapd/proto-slap.h +++ b/servers/slapd/proto-slap.h @@ -3,6 +3,8 @@ #include +LDAP_BEGIN_DECL + /* * acl.c */ @@ -96,10 +98,12 @@ extern int backend_group LDAP_P((Backend *be, * ch_malloc.c */ -void * ch_malloc LDAP_P(( unsigned long size )); -void * ch_realloc LDAP_P(( void *block, unsigned long size )); -void * ch_calloc LDAP_P(( unsigned long nelem, unsigned long size )); +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 * )); +#define free ch_free /* * charray.c @@ -126,19 +130,19 @@ int connections_shutdown LDAP_P((void)); int connections_destroy LDAP_P((void)); long connection_init LDAP_P(( - int s, + ber_socket_t s, const char* name, const char* addr)); void connection_closing LDAP_P(( Connection *c )); int connection_state_closing LDAP_P(( Connection *c )); -int connection_write LDAP_P((int s)); -int connection_read LDAP_P((int s)); +int connection_write LDAP_P((ber_socket_t s)); +int connection_read LDAP_P((ber_socket_t s)); -long connections_nextid(void); +unsigned long connections_nextid(void); -Connection* connection_first LDAP_P((int *)); -Connection* connection_next LDAP_P((Connection *, int *)); +Connection* connection_first LDAP_P((ber_socket_t *)); +Connection* connection_next LDAP_P((Connection *, ber_socket_t *)); void connection_done LDAP_P((Connection *)); /* @@ -202,8 +206,8 @@ void monitor_info LDAP_P(( Connection *conn, Operation *op )); void slap_op_free LDAP_P(( Operation *op )); Operation * slap_op_alloc LDAP_P(( - BerElement *ber, unsigned long msgid, - unsigned long tag, long id )); + 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 )); @@ -344,14 +348,16 @@ struct slapd_args { struct sockaddr_in *addr; int tcps; }; + extern int slapd_daemon LDAP_P((struct slapd_args *args)); +extern int set_socket LDAP_P((struct sockaddr_in *addr)); -extern void slapd_set_write LDAP_P((int s, int wake)); -extern void slapd_clr_write LDAP_P((int s, int wake)); -extern void slapd_set_read LDAP_P((int s, int wake)); -extern void slapd_clr_read LDAP_P((int s, int wake)); +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)); -extern void slapd_remove LDAP_P((int s, int wake)); +extern void slapd_remove LDAP_P((ber_socket_t s, int wake)); extern void slap_set_shutdown LDAP_P((int sig)); extern void slap_do_nothing LDAP_P((int sig)); @@ -371,7 +377,9 @@ extern void do_unbind LDAP_P((Connection *conn, Operation *op)); extern int send_search_entry LDAP_P((Backend *be, Connection *conn, Operation *op, Entry *e, char **attrs, int attrsonly)); extern int str2result LDAP_P(( char *s, int *code, char **matched, char **info )); -extern int dtblsize; +extern ber_socket_t dtblsize; + +LDAP_END_DECL #endif /* _proto_slap */ diff --git a/servers/slapd/result.c b/servers/slapd/result.c index 1726dd3b84..901afcc012 100644 --- a/servers/slapd/result.c +++ b/servers/slapd/result.c @@ -20,7 +20,7 @@ static void send_ldap_result2( Connection *conn, Operation *op, - int err, + ber_int_t err, char *matched, char *text, int nentries @@ -28,7 +28,8 @@ send_ldap_result2( { BerElement *ber; int rc; - unsigned long tag, bytes; + ber_tag_t tag; + ber_len_t bytes; if ( err == LDAP_PARTIAL_RESULTS && (text == NULL || *text == '\0') ) err = LDAP_NO_SUCH_OBJECT; @@ -57,12 +58,11 @@ send_ldap_result2( #ifdef LDAP_COMPAT30 - if ( (ber = ber_alloc_t( conn->c_version == 30 ? 0 : LBER_USE_DER )) - == NULLBER ) + ber = ber_alloc_t( conn->c_version == 30 ? 0 : LBER_USE_DER ); #else - if ( (ber = der_alloc()) == NULLBER ) + ber = der_alloc(); #endif - { + if ( ber == NULL ) { Debug( LDAP_DEBUG_ANY, "ber_alloc failed\n", 0, 0, 0 ); return; } @@ -145,8 +145,9 @@ send_ldap_result2( ldap_pvt_thread_mutex_unlock( &num_sent_mutex ); Statslog( LDAP_DEBUG_STATS, - "conn=%d op=%d RESULT err=%d tag=%lu nentries=%d\n", conn->c_connid, - op->o_opid, err, tag, nentries ); + "conn=%ld op=%ld RESULT err=%ld tag=%lu nentries=%d\n", + (long) conn->c_connid, (long) op->o_opid, + (long) err, (long) tag, nentries ); return; } @@ -155,7 +156,7 @@ void send_ldap_result( Connection *conn, Operation *op, - int err, + ber_int_t err, char *matched, char *text ) @@ -177,7 +178,7 @@ void send_ldap_search_result( Connection *conn, Operation *op, - int err, + ber_int_t err, char *matched, char *text, int nentries @@ -215,12 +216,12 @@ send_search_entry( edn = e->e_ndn; #ifdef LDAP_COMPAT30 - if ( (ber = ber_alloc_t( conn->c_version == 30 ? 0 : LBER_USE_DER )) - == NULLBER ) + ber = ber_alloc_t( conn->c_version == 30 ? 0 : LBER_USE_DER ); #else - if ( (ber = der_alloc()) == NULLBER ) + ber = der_alloc(); #endif - { + + if ( ber == NULL ) { Debug( LDAP_DEBUG_ANY, "ber_alloc failed\n", 0, 0, 0 ); send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, NULL, "ber_alloc" ); @@ -273,7 +274,7 @@ send_search_entry( continue; } - if (( rc = ber_printf( ber, "{s[", a->a_type )) == -1 ) { + if (( rc = ber_printf( ber, "{s[" /*]}*/ , a->a_type )) == -1 ) { Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); ber_free( ber, 1 ); send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, @@ -290,10 +291,7 @@ send_search_entry( continue; } - if (( rc = ber_printf( ber, "o", - a->a_vals[i]->bv_val, - a->a_vals[i]->bv_len )) == -1 ) - { + if (( rc = ber_printf( ber, "O", a->a_vals[i] )) == -1 ) { Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); ber_free( ber, 1 ); @@ -305,7 +303,7 @@ send_search_entry( } } - if (( rc = ber_printf( ber, "]}" )) == -1 ) { + if (( rc = ber_printf( ber, /*{[*/ "]}" )) == -1 ) { Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); ber_free( ber, 1 ); send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, @@ -316,10 +314,10 @@ send_search_entry( #ifdef LDAP_COMPAT30 if ( conn->c_version == 30 ) { - rc = ber_printf( ber, "}}}}" ); + rc = ber_printf( ber, /*{{{{{*/ "}}}}" ); } else #endif - rc = ber_printf( ber, "}}}" ); + rc = ber_printf( ber, /*{{{{*/ "}}}" ); if ( rc == -1 ) { Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); @@ -387,8 +385,8 @@ send_search_entry( num_entries_sent++; ldap_pvt_thread_mutex_unlock( &num_sent_mutex ); - Statslog( LDAP_DEBUG_STATS2, "conn=%d op=%d ENTRY dn=\"%s\"\n", - conn->c_connid, op->o_opid, e->e_dn, 0, 0 ); + Statslog( LDAP_DEBUG_STATS2, "conn=%ld op=%ld ENTRY dn=\"%s\"\n", + (long) conn->c_connid, (long) op->o_opid, e->e_dn, 0, 0 ); Debug( LDAP_DEBUG_TRACE, "<= send_search_entry\n", 0, 0, 0 ); diff --git a/servers/slapd/schema.c b/servers/slapd/schema.c index 829e4f6396..97c80be9b1 100644 --- a/servers/slapd/schema.c +++ b/servers/slapd/schema.c @@ -924,8 +924,6 @@ int schema_init( void ) { int res; - int code; - const char *err; int i; static int schema_init_done = 0; diff --git a/servers/slapd/search.c b/servers/slapd/search.c index a6772d6757..584a7b8882 100644 --- a/servers/slapd/search.c +++ b/servers/slapd/search.c @@ -28,8 +28,8 @@ do_search( ) { int i, err; - int scope, deref, attrsonly; - int sizelimit, timelimit; + ber_int_t scope, deref, attrsonly; + ber_int_t sizelimit, timelimit; char *base = NULL, *fstr = NULL; Filter *filter = NULL; char **attrs = NULL; @@ -88,7 +88,7 @@ do_search( Debug( LDAP_DEBUG_ARGS, " filter: %s\n", fstr, 0, 0 ); /* attributes */ - if ( ber_scanf( op->o_ber, "{v}}", &attrs ) == LBER_ERROR ) { + if ( ber_scanf( op->o_ber, /*{*/ "{v}}", &attrs ) == LBER_ERROR ) { send_ldap_result( conn, op, LDAP_PROTOCOL_ERROR, NULL, "" ); goto return_results; } diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h index 6c5a3ce7e4..cd89c3687f 100644 --- a/servers/slapd/slap.h +++ b/servers/slapd/slap.h @@ -9,7 +9,6 @@ #include #include #include -#include #include "avl.h" @@ -23,8 +22,13 @@ #include "lber.h" #include "ldap.h" +#include "ldap_schema.h" + #include "ldap_pvt_thread.h" #include "ldif.h" + +LDAP_BEGIN_DECL + #ifdef f_next #undef f_next /* name conflict between sys/file.h on SCO and struct filter */ #endif @@ -67,8 +71,6 @@ #define SLAP_SCHERR_SYN_NOT_FOUND 11 #define SLAP_SCHERR_MR_INCOMPLETE 12 -LDAP_BEGIN_DECL - extern int slap_debug; struct slap_op; @@ -86,7 +88,7 @@ typedef struct ava { * represents a search filter */ typedef struct filter { - unsigned long f_choice; /* values taken from ldap.h */ + ber_tag_t f_choice; /* values taken from ldap.h */ union f_un_u { /* present */ @@ -147,7 +149,7 @@ typedef struct attr { * the id used in the indexes to refer to an entry */ typedef unsigned long ID; -#define NOID ((unsigned long)-1) +#define NOID ((unsigned long)~0) /* * represents an entry in core @@ -426,8 +428,10 @@ struct backend_info { struct slap_conn *c, struct slap_op *o )); int (*bi_op_search) LDAP_P((BackendDB *bd, struct slap_conn *c, struct slap_op *o, - char *base, int scope, int deref, int slimit, int tlimit, - Filter *f, char *filterstr, char **attrs, int attrsonly)); + char *base, int scope, int deref, + int slimit, int tlimit, + Filter *f, char *filterstr, char **attrs, + int attrsonly)); int (*bi_op_compare)LDAP_P((BackendDB *bd, struct slap_conn *c, struct slap_op *o, char *dn, Ava *ava)); @@ -447,7 +451,7 @@ struct backend_info { /* Bug: be_op_abandon in unused! */ int (*bi_op_abandon) LDAP_P((BackendDB *bd, struct slap_conn *c, struct slap_op *o, - int msgid)); + ber_int_t msgid)); /* Auxilary Functions */ int (*bi_entry_release_rw) LDAP_P((BackendDB *bd, Entry *e, int rw)); @@ -466,18 +470,18 @@ struct backend_info { */ typedef struct slap_op { - long o_opid; /* id of this operation */ - long o_msgid; /* msgid of the request */ + ber_int_t o_opid; /* id of this operation */ + ber_int_t o_msgid; /* msgid of the request */ ldap_pvt_thread_t o_tid; /* thread handling this op */ BerElement *o_ber; /* ber of the request */ - unsigned long o_tag; /* tag of the request */ + ber_tag_t o_tag; /* tag of the request */ time_t o_time; /* time op was initiated */ char *o_dn; /* dn bound when op was initiated */ char *o_ndn; /* normalized dn bound when op was initiated */ - int o_authtype; /* auth method used to bind dn */ + ber_tag_t o_authtype; /* auth method used to bind dn */ /* values taken from ldap.h */ /* LDAP_AUTH_* */ @@ -510,15 +514,16 @@ typedef struct slap_conn { /* only can be changed by connect_init */ time_t c_starttime; /* when the connection was opened */ time_t c_activitytime; /* when the connection was last used */ - long c_connid; /* id of this connection for stats*/ + unsigned long c_connid; /* id of this connection for stats*/ char *c_client_addr; /* address of client */ char *c_client_name; /* name of client */ /* only can be changed by binding thread */ char *c_cdn; /* DN provided by the client */ char *c_dn; /* DN bound to this conn */ - int c_protocol; /* version of the LDAP protocol used by client */ - int c_authtype; /* auth method used to bind c_dn */ + ber_int_t c_protocol; /* version of the LDAP protocol used by client */ + ber_tag_t c_authtype; /* auth method used to bind c_dn */ + #ifdef LDAP_COMPAT int c_version; /* for compatibility w/ U-Mich 2.0 & 3.0 */ #endif @@ -551,8 +556,8 @@ typedef struct slap_conn { #define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 ) #endif -#include "proto-slap.h" - LDAP_END_DECL +#include "proto-slap.h" + #endif /* _slap_h_ */ diff --git a/servers/slapd/tools/ldapsyntax.c b/servers/slapd/tools/ldapsyntax.c index 99fca405be..542792b231 100644 --- a/servers/slapd/tools/ldapsyntax.c +++ b/servers/slapd/tools/ldapsyntax.c @@ -417,8 +417,10 @@ photo2ldif( PS ps, AttributeValue av ) if (( phber = der_alloc()) == NULLBER ) { return( -1 ); } - if ( ber_printf( phber, "t{[tB]{B}}", 0xA3, 0x81, faxparamset, - 31, (char *)pe->pe_prim, len * 8 ) == -1 ) { + if ( ber_printf( phber, "t{[tB]{B}}", + (ber_tag_t) 0xA3, (ber_tag_t) 0x81, faxparamset, (ber_len_t) 31, + (char *)pe->pe_prim, (ber_len_t) (len * 8) ) == -1 ) + { ber_free( phber, 1 ); return( -1 ); } diff --git a/servers/slurpd/ch_malloc.c b/servers/slurpd/ch_malloc.c index 191a7d06c4..0adcb7bddf 100644 --- a/servers/slurpd/ch_malloc.c +++ b/servers/slurpd/ch_malloc.c @@ -31,13 +31,14 @@ */ void * ch_malloc( - unsigned long size + ber_len_t size ) { void *new; if ( (new = (void *) malloc( size )) == NULL ) { - fprintf( stderr, "malloc of %lu bytes failed\n", size ); + fprintf( stderr, "malloc of %lu bytes failed\n", + (long) size ); exit( 1 ); } @@ -54,7 +55,7 @@ ch_malloc( void * ch_realloc( void *block, - unsigned long size + ber_len_t size ) { void *new; @@ -64,7 +65,8 @@ ch_realloc( } if ( (new = (void *) realloc( block, size )) == NULL ) { - fprintf( stderr, "realloc of %lu bytes failed\n", size ); + fprintf( stderr, "realloc of %lu bytes failed\n", + (long) size ); exit( 1 ); } @@ -80,15 +82,15 @@ ch_realloc( */ void * ch_calloc( - unsigned long nelem, - unsigned long size + ber_len_t nelem, + ber_len_t size ) { void *new; if ( (new = (void *) calloc( nelem, size )) == NULL ) { fprintf( stderr, "calloc of %lu elems of %lu bytes failed\n", - nelem, size ); + (long) nelem, (long) size ); exit( 1 ); } diff --git a/servers/slurpd/proto-slurp.h b/servers/slurpd/proto-slurp.h index 56e3282902..37bcb3f85d 100644 --- a/servers/slurpd/proto-slurp.h +++ b/servers/slurpd/proto-slurp.h @@ -12,9 +12,9 @@ RETSIGTYPE do_admin LDAP_P((int sig)); int doargs LDAP_P((int argc, char **argv, struct globals *g)); /* ch_malloc.c */ -void *ch_malloc LDAP_P((unsigned long size)); -void *ch_realloc LDAP_P((void *block, unsigned long size)); -void *ch_calloc LDAP_P((unsigned long nelem, unsigned long size)); +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)); void ch_free LDAP_P((void *p)); /* config.c */ -- 2.39.5