upstream/openldap
1
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2026-01-03 13:40:37 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

ber_int_t, ber_tag_t, ber_socket_t, ber_len_t

Browse source 
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
This commit is contained in:
Kurt Zeilenga 1999-06-18 23:53:05 +00:00
parent 7e4b3bc2e7
commit 669b8f4047
86 changed files with 1414 additions and 1067 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
acconfig.h
View file

@ -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. */

2
clients/finger/main.c
View file

@ -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 );
}

2
clients/gopher/go500.c
View file

@ -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 );
}

4
clients/gopher/go500gw.c
View file

@ -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 );
}

4
clients/rcpt500/query.c
View file

@ -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 );

141
configure vendored
View file

@ -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 <<EOF
#line 10872 "configure"
#line 10886 "configure"
#include "confdefs.h"
#include <sys/types.h>
#include <sys/param.h>
@ -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 <<EOF
#line 10887 "configure"
#line 10901 "configure"
#include "confdefs.h"
#include <sys/types.h>
#include <sys/param.h>
@ -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 <<EOF
#line 10918 "configure"
#line 10932 "configure"
#include "confdefs.h"
main () {
/* Are we little or big endian? From Harbison&Steele. */
@ -10927,7 +10941,7 @@ main () {
exit (u.c[sizeof (long) - 1] == 1);
}
EOF
if { (eval echo configure:10931: \"$ac_link\") 1>&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 <<EOF
#line 10963 "configure"
#line 10977 "configure"
#include "confdefs.h"
#include <stdio.h>
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 <<EOF
#line 11002 "configure"
#line 11016 "configure"
#include "confdefs.h"
#include <stdio.h>
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 <<EOF
#line 11041 "configure"
#line 11055 "configure"
#include "confdefs.h"
#include <stdio.h>
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 <<EOF
#line 11086 "configure"
#line 11131 "configure"
#include "confdefs.h"
main()
@ -11092,7 +11137,7 @@ main()
}
EOF
if { (eval echo configure:11096: \"$ac_link\") 1>&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 <<EOF
#line 11119 "configure"
#line 11164 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char strftime(); below. */
@ -11138,7 +11183,7 @@ strftime();
; return 0; }
EOF
if { (eval echo configure:11142: \"$ac_link\") 1>&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 <<EOF
#line 11172 "configure"
#line 11217 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
@ -11179,7 +11224,7 @@ int main() {
strftime()
; return 0; }
EOF
if { (eval echo configure:11183: \"$ac_link\") 1>&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 <<EOF
#line 11216 "configure"
#line 11261 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char vprintf(); below. */
@ -11235,7 +11280,7 @@ vprintf();
; return 0; }
EOF
if { (eval echo configure:11239: \"$ac_link\") 1>&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 <<EOF
#line 11268 "configure"
#line 11313 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char _doprnt(); below. */
@ -11287,7 +11332,7 @@ _doprnt();
; return 0; }
EOF
if { (eval echo configure:11291: \"$ac_link\") 1>&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 <<EOF
#line 11325 "configure"
#line 11370 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
@ -11344,7 +11389,7 @@ $ac_func();
; return 0; }
EOF
if { (eval echo configure:11348: \"$ac_link\") 1>&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 <<EOF
#line 11422 "configure"
#line 11467 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
@ -11441,7 +11486,7 @@ $ac_func();
; return 0; }
EOF
if { (eval echo configure:11445: \"$ac_link\") 1>&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 <<EOF
#line 11478 "configure"
#line 11523 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
@ -11497,7 +11542,7 @@ $ac_func();
; return 0; }
EOF
if { (eval echo configure:11501: \"$ac_link\") 1>&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 <<EOF
#line 11537 "configure"
#line 11582 "configure"
#include "confdefs.h"
#include <stdio.h>
@ -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 <<EOF
#line 11573 "configure"
#line 11618 "configure"
#include "confdefs.h"
#include <errno.h>
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 <<EOF
@ -12159,7 +12204,7 @@ ac_eD='%g'
if test "${CONFIG_HEADERS+set}" != set; then
EOF
cat >> $CONFIG_STATUS <<EOF
CONFIG_HEADERS="include/portable.h include/ldap_features.h"
CONFIG_HEADERS="include/portable.h include/ldap_features.h include/lber_types.h"
EOF
cat >> $CONFIG_STATUS <<\EOF
fi

17
configure.in
View file

@ -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

11
include/ac/socket.h
View file

@ -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_ */

6
include/avl.h
View file

@ -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* )

5
include/disptmpl.h
View file

@ -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 )

182
include/lber.h
View file

@ -23,13 +23,30 @@
#define _LBER_H
#include <ldap_cdefs.h>
#ifndef LBER_SIZE_T_DEFINED
#include <stddef.h>
#endif
#include <lber_types.h>
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 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 0x10UL /* w/o constructed bit - broken */
#define OLD_LBER_SET 0x11UL /* w/o constructed bit - broken */
#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((

30
include/lber_types.h.in Normal file
View file

@ -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 */

43
include/lber_types.h.nt Normal file
View file

@ -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 */

235
include/ldap.h
View file

@ -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

7
include/portable.h.in
View file

@ -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

3
include/portable.h.nt
View file

@ -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()

2
include/srchpref.h
View file

@ -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 )

4
libraries/libavl/avl.c
View file

@ -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;

10
libraries/liblber/bprint.c
View file

@ -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",

208
libraries/liblber/decode.c
View file

@ -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 );
/* 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;
}
}
*num = AC_NTOHL( netnum );
if( len ) {
/* sign extend if necessary */
ber_len_t i;
ber_int_t netnum = 0x80 & buf[0] ? -1 : 0;
/* shift in the bytes */
for( i=0 ; i<len; i++ ) {
netnum = (netnum << 8 ) | buf[i];
}
*num = netnum;
} else {
*num = 0;
}
return( len );
}
unsigned long
ber_get_int( BerElement *ber, long *num )
ber_tag_t
ber_get_int(
BerElement *ber,
ber_int_t *num )
{
unsigned long tag, len;
ber_tag_t tag;
ber_len_t len;
assert( ber != NULL );
assert( BER_VALID( ber ) );
@ -203,16 +215,21 @@ ber_get_int( BerElement *ber, long *num )
if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
return( LBER_DEFAULT );
if ( (unsigned long) ber_getnint( ber, num, (int)len ) != len )
if ( (unsigned long) ber_getnint( ber, num, len ) != len )
return( LBER_DEFAULT );
else
return( tag );
}
unsigned long
ber_get_stringb( BerElement *ber, char *buf, unsigned long *len )
ber_tag_t
ber_get_stringb(
BerElement *ber,
char *buf,
ber_len_t *len )
{
unsigned long datalen, tag;
ber_len_t datalen;
ber_tag_t tag;
#ifdef STR_TRANSLATION
char *transbuf;
#endif /* STR_TRANSLATION */
@ -253,10 +270,11 @@ ber_get_stringb( BerElement *ber, char *buf, unsigned long *len )
return( tag );
}
unsigned long
ber_tag_t
ber_get_stringa( BerElement *ber, char **buf )
{
unsigned long datalen, tag;
ber_len_t datalen;
ber_tag_t tag;
assert( ber != NULL );
assert( buf != NULL );
@ -268,7 +286,7 @@ ber_get_stringa( BerElement *ber, char **buf )
return( LBER_DEFAULT );
}
if ( (*buf = (char *) LBER_MALLOC( (size_t)datalen + 1 )) == NULL )
if ( (*buf = (char *) LBER_MALLOC( datalen + 1 )) == NULL )
return( LBER_DEFAULT );
if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) {
@ -294,10 +312,11 @@ ber_get_stringa( BerElement *ber, char **buf )
return( tag );
}
unsigned long
ber_tag_t
ber_get_stringal( BerElement *ber, struct berval **bv )
{
unsigned long len, tag;
ber_len_t len;
ber_tag_t tag;
assert( ber != NULL );
assert( bv != NULL );
@ -312,13 +331,13 @@ ber_get_stringal( BerElement *ber, struct berval **bv )
if ( (*bv = (struct berval *) LBER_MALLOC( sizeof(struct berval) )) == NULL )
return( LBER_DEFAULT );
if ( ((*bv)->bv_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 */

187
libraries/liblber/encode.c
View file

@ -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 );
return( ber_write( ber, ((char *) &ntag) + sizeof(long) - taglen,
taglen, nosos ) );
rc = ber_write( ber,
((char *) &ntag) + sizeof(ber_tag_t) - 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;

95
libraries/liblber/io.c
View file

@ -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_rwptr<ber->ber_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 );

56
libraries/liblber/lber-int.h
View file

@ -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 ));

4
libraries/liblber/liblber.dsp
View file

@ -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

14
libraries/liblber/memory.c
View file

@ -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;

80
libraries/liblber/sockbuf.c
View file

@ -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 = (blen<len) ? blen : len;
ber_len_t rlen = (blen<len) ? blen : len;
memcpy( *buf, sb->sb_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 ) );

22
libraries/libldap/abandon.c
View file

@ -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;

10
libraries/libldap/add.c
View file

@ -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;

120
libraries/libldap/cache.c
View file

@ -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;

12
libraries/libldap/charset.c
View file

@ -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",

18
libraries/libldap/cldap.c
View file

@ -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 );

6
libraries/libldap/compare.c
View file

@ -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 );

23
libraries/libldap/controls.c
View file

@ -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;

7
libraries/libldap/delete.c
View file

@ -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 );

6
libraries/libldap/disptmpl.c
View file

@ -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;

8
libraries/libldap/dsparse.c
View file

@ -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;

6
libraries/libldap/error.c
View file

@ -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 )

13
libraries/libldap/extended.c
View file

@ -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 ) {

6
libraries/libldap/free.c
View file

@ -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 );
}

2
libraries/libldap/getattr.c
View file

@ -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 );
}

2
libraries/libldap/getdn.c
View file

@ -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 );
}

2
libraries/libldap/getdxbyname.c
View file

@ -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

12
libraries/libldap/getentry.c
View file

@ -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

4
libraries/libldap/getfilter.c
View file

@ -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,

8
libraries/libldap/getvalues.c
View file

@ -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 );
}

12
libraries/libldap/kbind.c
View file

@ -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;

68
libraries/libldap/ldap-int.h
View file

@ -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 */

8
libraries/libldap/messages.c
View file

@ -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 );

13
libraries/libldap/modify.c
View file

@ -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 );

13
libraries/libldap/modrdn.c
View file

@ -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 );

2
libraries/libldap/options.c
View file

@ -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:

3
libraries/libldap/os-ip.c
View file

@ -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;

12
libraries/libldap/references.c
View file

@ -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

49
libraries/libldap/request.c
View file

@ -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;

106
libraries/libldap/result.c
View file

@ -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 */

2
libraries/libldap/sbind.c
View file

@ -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 );
}

4
libraries/libldap/schema.c
View file

@ -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;

50
libraries/libldap/search.c
View file

@ -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 );

4
libraries/libldap/srchpref.c
View file

@ -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;

16
libraries/libldap/test.c
View file

@ -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" );
}

4
libraries/libldap/tmplout.c
View file

@ -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];

7
libraries/libldap/unbind.c
View file

@ -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 );

2
libraries/libldap/url.c
View file

@ -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 );
}

2
servers/slapd/abandon.c
View file

@ -25,7 +25,7 @@ do_abandon(
Operation *op
)
{
int id;
ber_int_t id;
Operation *o;
Operation **oo;

5
servers/slapd/add.c
View file

@ -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" );

4
servers/slapd/back-ldbm/back-ldbm.h
View file

@ -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_ */

4
servers/slapd/back-ldbm/external.h
View file

@ -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,

2
servers/slapd/back-ldbm/startup.c
View file

@ -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 );

9
servers/slapd/bind.c
View file

@ -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 );

37
servers/slapd/ch_malloc.c
View file

@ -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 );
}

59
servers/slapd/connection.c
View file

@ -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; i<dtblsize; i++) {
if( connections[i].c_struct_state == SLAP_C_UNINITIALIZED ) {
@ -225,18 +225,18 @@ static void connection_return( Connection *c )
}
long connection_init(
int s,
ber_socket_t s,
const char* name,
const char* addr)
{
long id;
unsigned long id;
Connection *c;
assert( connections != NULL );
if( s < 0 ) {
if( s == AC_SOCKET_INVALID ) {
Debug( LDAP_DEBUG_ANY,
"connection_init(%d): invalid.\n",
s, 0, 0 );
"connection_init(%ld): invalid.\n",
(long) s, 0, 0 );
return -1;
}
@ -252,7 +252,7 @@ long connection_init(
#else
{
int i;
unsigned int i;
c = NULL;
@ -483,9 +483,9 @@ static void connection_close( Connection *c )
connection_destroy( c );
}
long connections_nextid(void)
unsigned long connections_nextid(void)
{
long id;
unsigned long id;
assert( connections != NULL );
ldap_pvt_thread_mutex_lock( &connections_mutex );
@ -497,7 +497,7 @@ long connections_nextid(void)
return id;
}
Connection* connection_first( int *index )
Connection* connection_first( ber_socket_t *index )
{
assert( connections != NULL );
assert( index != NULL );
@ -509,7 +509,7 @@ Connection* connection_first( int *index )
return connection_next(NULL, index);
}
Connection* connection_next( Connection *c, int *index )
Connection* connection_next( Connection *c, ber_socket_t *index )
{
assert( connections != NULL );
assert( index != NULL );
@ -569,7 +569,7 @@ static void *
connection_operation( void *arg_v )
{
struct co_arg *arg = arg_v;
int tag = arg->co_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;

120
servers/slapd/daemon.c
View file

@ -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

9
servers/slapd/filter.c
View file

@ -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 );

21
servers/slapd/main.c
View file

@ -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);

9
servers/slapd/modify.c
View file

@ -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 )

8
servers/slapd/modrdn.c
View file

@ -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",

2
servers/slapd/monitor.c
View file

@ -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 );

6
servers/slapd/operation.c
View file

@ -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;

42
servers/slapd/proto-slap.h
View file

@ -3,6 +3,8 @@
#include <ldap_cdefs.h>
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 */

46
servers/slapd/result.c
View file

@ -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 );

2
servers/slapd/schema.c
View file

@ -924,8 +924,6 @@ int
schema_init( void )
{
int res;
int code;
const char *err;
int i;
static int schema_init_done = 0;

6
servers/slapd/search.c
View file

@ -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;
}

39
servers/slapd/slap.h
View file

@ -9,7 +9,6 @@
#include <ac/syslog.h>
#include <ac/regex.h>
#include <ac/socket.h>
#include <ldap_schema.h>
#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_ */

6
servers/slapd/tools/ldapsyntax.c
View file

@ -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 );
}

16
servers/slurpd/ch_malloc.c
View file

@ -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 );
}

6
servers/slurpd/proto-slurp.h
View file

@ -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 */