mirror/openldap
2
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2025-03-01 14:15:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

More new logging (Behind NEW_LOGGING)

Browse Source
This commit is contained in:
Gary Williams 2001-01-15 19:17:29 +00:00
parent 6c2ea5ec24
commit ffcdc6d11d
31 changed files with 1895 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
servers/slapd/ava.c
View File

@ -43,7 +43,12 @@ get_ava(
rc = ber_scanf( ber, "{oo}", &type, &value );
if( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
"get_ava: ber_scanf failure\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_ava ber_scanf\n", 0, 0, 0 );
#endif
*text = "Error decoding attribute value assertion";
return SLAPD_DISCONNECT;
}

299
servers/slapd/daemon.c
View File

@ -118,11 +118,18 @@ static void slapd_add(ber_socket_t s) {
FD_SET( s, &slap_daemon.sd_actives );
FD_SET( s, &slap_daemon.sd_readers );
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
"slapd_add: added %ld%s%s\n",
(long)s,
FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ));
#else
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" : "" );
#endif
ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
}
@ -132,11 +139,18 @@ static void slapd_add(ber_socket_t s) {
void slapd_remove(ber_socket_t s, int wake) {
ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
"slapd_remove: removing %ld%s%s\n",
(long) s,
FD_ISSET(s, &slap_daemon.sd_readers) ? "r" : "",
FD_ISSET(s, &slap_daemon.sd_writers) ? "w" : "" ));
#else
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" : "" );
#endif
FD_CLR( s, &slap_daemon.sd_actives );
FD_CLR( s, &slap_daemon.sd_readers );
FD_CLR( s, &slap_daemon.sd_writers );
@ -188,8 +202,13 @@ void slapd_set_read(ber_socket_t s, int wake) {
}
static void slapd_close(ber_socket_t s) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
"slapd_close: closing %ld\n", (long)s ));
#else
Debug( LDAP_DEBUG_CONNS, "daemon: closing %ld\n",
(long) s, 0, 0 );
#endif
tcp_close(s);
}
@ -227,8 +246,14 @@ static int slap_get_listener_addresses(
hints.ai_family = AF_LOCAL;
/* host specifies a service in this case */
if (err = getaddrinfo(NULL, host, &hints, &res)) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_get_listener_addresses: getaddrinfo failed: %s\n",
AC_GAI_STRERROR(err) ));
#else
Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",
AC_GAI_STRERROR(err), 0, 0);
#endif
return -1;
}
} else
@ -239,8 +264,14 @@ static int slap_get_listener_addresses(
snprintf(serv, sizeof serv, "%d", port);
hints.ai_family = AF_UNSPEC;
if (err = getaddrinfo(host, serv, &hints, &res)) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_get_listener_addresses: getaddrinfo failed: %s\n",
AC_GAI_STRERROR(err) ));
#else
Debug( LDAP_DEBUG_ANY, "daemon: getaddrinfo failed: %s\n",
AC_GAI_STRERROR(err), 0, 0);
#endif
return -1;
}
}
@ -316,9 +347,15 @@ static int slap_get_listener_addresses(
(*sap)->sa_family = AF_LOCAL;
if ( strlen(host) >
(sizeof(((struct sockaddr_un *)*sal)->sun_path) - 1) ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_get_listener_addresses: domain socket path (%s) too long in URL\n",
host ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: domain socket path (%s) too long in URL",
host, 0, 0);
#endif
goto errexit;
}
strcpy( ((struct sockaddr_un *)*sap)->sun_path, host );
@ -333,8 +370,14 @@ static int slap_get_listener_addresses(
} else if ( !inet_aton( host, &in ) ) {
struct hostent *he = gethostbyname( host );
if( he == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_get_listener_addresses: invalid host %s\n",
host ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: invalid host %s", host, 0, 0);
#endif
return -1;
}
AC_MEMCPY( &in, he->h_addr, sizeof( in ) );
@ -381,17 +424,29 @@ static Listener * slap_open_listener(
rc = ldap_url_parse( url, &lud );
if( rc != LDAP_URL_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slap_open_listener: listen URL \"%s\" parse error %d\n",
url, rc ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: listen URL \"%s\" parse error=%d\n",
url, rc, 0 );
#endif
return NULL;
}
#ifndef HAVE_TLS
if( ldap_pvt_url_scheme2tls( lud->lud_scheme ) ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_open_listener: TLS is not supported (%s)\n",
url ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: TLS not supported (%s)\n",
url, 0, 0 );
#endif
ldap_free_urldesc( lud );
return NULL;
}
@ -418,8 +473,15 @@ static Listener * slap_open_listener(
err = slap_get_listener_addresses(lud->lud_host, 0, &sal);
}
#else
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_open_listener: URL scheme is not supported: %s\n",
url ));
#else
Debug( LDAP_DEBUG_ANY, "daemon: URL scheme not supported: %s",
url, 0, 0);
#endif
ldap_free_urldesc( lud );
return NULL;
#endif
@ -456,17 +518,29 @@ static Listener * slap_open_listener(
l.sl_sd = socket( (*sal)->sa_family, SOCK_STREAM, 0);
if ( l.sl_sd == AC_SOCKET_INVALID ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slap_open_listener: socket() failed errno=%d (%s)\n",
err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: socket() failed errno=%d (%s)\n", err,
sock_errstr(err), 0 );
#endif
sal++;
continue;
}
#ifndef HAVE_WINSOCK
if ( l.sl_sd >= dtblsize ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slap_open_listener: listener descriptor %ld is too great %ld\n",
(long)l.sl_sd, (long)dtblsize ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: listener descriptor %ld is too great %ld\n",
(long) l.sl_sd, (long) dtblsize, 0 );
#endif
tcp_close( l.sl_sd );
sal++;
continue;
@ -485,9 +559,15 @@ static Listener * slap_open_listener(
(char *) &tmp, sizeof(tmp) );
if ( rc == AC_SOCKET_ERROR ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_open_listener: setsockopt( %ld, SO_REUSEADDR ) failed errno %d (%s)\n",
(long)l.sl_sd, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY,
"slapd(%ld): setsockopt(SO_REUSEADDR) failed errno=%d (%s)\n",
(long) l.sl_sd, err, sock_errstr(err) );
#endif
}
#endif
}
@ -511,15 +591,26 @@ static Listener * slap_open_listener(
if (!bind(l.sl_sd, *sal, addrlen))
break;
err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_open_listener: bind(%ld) failed errno=%d (%s)\n",
(long)l.sl_sd, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed errno=%d (%s)\n",
(long) l.sl_sd, err, sock_errstr(err) );
#endif
tcp_close( l.sl_sd );
sal++;
} /* while ( *sal != NULL ) */
if ( *sal == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_open_listener: bind(%ld) failed.\n", (long)l.sl_sd ));
#else
Debug( LDAP_DEBUG_ANY, "daemon: bind(%ld) failed\n",
(long) l.sl_sd, 0, 0 );
#endif
slap_free_listener_addresses(psal);
return NULL;
}
@ -530,8 +621,14 @@ static Listener * slap_open_listener(
char *addr = ((struct sockaddr_un *)*sal)->sun_path;
if ( chmod( addr, S_IRWXU ) < 0 ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_open_listener: fchmod(%ld) failed errno=%d (%s)\n",
(long)l.sl_sd, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY, "daemon: fchmod(%ld) failed errno=%d (%s)",
(long) l.sl_sd, err, sock_errstr(err) );
#endif
tcp_close( l.sl_sd );
slap_free_listener_addresses(psal);
return NULL;
@ -567,8 +664,14 @@ static Listener * slap_open_listener(
#endif /* LDAP_PF_INET6 */
default:
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_open_listener: unsupported address family (%d)\n",
(int)(*sal)->sa_family ));
#else
Debug( LDAP_DEBUG_ANY, "daemon: unsupported address family (%d)\n",
(int) (*sal)->sa_family, 0, 0 );
#endif
break;
}
@ -578,9 +681,13 @@ static Listener * slap_open_listener(
li = ch_malloc( sizeof( Listener ) );
*li = l;
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_RESULTS,
"slap_open_listener: daemon initialzed %s\n", l.sl_url ));
#else
Debug( LDAP_DEBUG_TRACE, "daemon: initialized %s\n",
l.sl_url, 0, 0 );
#endif
return li;
}
@ -592,9 +699,14 @@ int slapd_daemon_init( const char *urls )
int i, rc;
char **u;
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ARGS,
"slapd_daemon_init: %s\n",
urls ? urls : "<null>" ));
#else
Debug( LDAP_DEBUG_ARGS, "daemon_init: %s\n",
urls ? urls : "<null>", 0, 0 );
#endif
if( (rc = sockinit()) != 0 ) {
return rc;
}
@ -619,8 +731,13 @@ int slapd_daemon_init( const char *urls )
* this byte arrives.
*/
if( (rc = lutil_pair( wake_sds )) < 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slap_daemon_init: lutil_pair() failed rc=%d\n", rc ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: lutil_pair() failed rc=%d\n", rc, 0, 0 );
#endif
return rc;
}
@ -634,27 +751,45 @@ int slapd_daemon_init( const char *urls )
u = str2charray( urls, " " );
if( u == NULL || u[0] == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slap_daemon_init: no urls (%s) provided.\n", urls ));
#else
Debug( LDAP_DEBUG_ANY, "daemon_init: no urls (%s) provided.\n",
urls, 0, 0 );
#endif
return -1;
}
for( i=0; u[i] != NULL; i++ ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
"slap_daemon_init: listen on %s\n.", u[i] ));
#else
Debug( LDAP_DEBUG_TRACE, "daemon_init: listen on %s\n",
u[i], 0, 0 );
#endif
}
if( i == 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_daemon_init: no listeners to open (%s)\n", urls ));
#else
Debug( LDAP_DEBUG_ANY, "daemon_init: no listeners to open (%s)\n",
urls, 0, 0 );
#endif
charray_free( u );
return -1;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slap_daemon_init: %d listeners to open...\n", i ));
#else
Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners to open...\n",
i, 0, 0 );
#endif
slap_listeners = ch_malloc( (i+1)*sizeof(Listener *) );
for(i = 0; u[i] != NULL; i++ ) {
@ -667,9 +802,13 @@ int slapd_daemon_init( const char *urls )
}
slap_listeners[i] = NULL;
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
"slap_daemon_init: %d listeners opened\n", i ));
#else
Debug( LDAP_DEBUG_TRACE, "daemon_init: %d listeners opened\n",
i, 0, 0 );
#endif
charray_free( u );
ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
return !i;
@ -702,10 +841,16 @@ slapd_daemon_task(
if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN ) == -1 ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slapd_daemon_task: listen( %s, 5 ) failed errno=%d (%s)\n",
slap_listeners[l]->sl_url, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: listen(%s, 5) failed errno=%d (%s)\n",
slap_listeners[l]->sl_url, err,
sock_errstr(err) );
#endif
return( (void*)-1 );
}
@ -799,10 +944,16 @@ slapd_daemon_task(
if ( slap_listeners[l]->sl_sd == AC_SOCKET_INVALID )
continue;
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
"slapd_daemon_task: select: listen=%d active_threads=%d tvp=%s\n",
slap_listeners[l]->sl_sd, at, tvp == NULL ? "NULL" : "zero" ));
#else
Debug( LDAP_DEBUG_CONNS,
"daemon: select: listen=%d active_threads=%d tvp=%s\n",
slap_listeners[l]->sl_sd, at,
tvp == NULL ? "NULL" : "zero" );
#endif
}
switch(ns = select( nfds, &readfds,
@ -828,10 +979,15 @@ slapd_daemon_task(
}
if( err != EINTR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slapd_daemon_task: select failed (%d): %s\n",
err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_CONNS,
"daemon: select failed (%d): %s\n",
err, sock_errstr(err), 0 );
#endif
slapd_shutdown = -1;
}
}
@ -839,8 +995,13 @@ slapd_daemon_task(
case 0: /* timeout - let threads run */
ebadf = 0;
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
"slapd_daemon_task: select timeout - yielding\n" ));
#else
Debug( LDAP_DEBUG_CONNS, "daemon: select timeout - yielding\n",
0, 0, 0 );
#endif
ldap_pvt_thread_yield();
continue;
@ -848,8 +1009,13 @@ slapd_daemon_task(
if( slapd_shutdown ) continue;
ebadf = 0;
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
"slapd_daemon_task: activity on %d descriptors\n", ns ));
#else
Debug( LDAP_DEBUG_CONNS, "daemon: activity on %d descriptors\n",
ns, 0, 0 );
#endif
/* FALL THRU */
}
@ -891,19 +1057,31 @@ slapd_daemon_task(
(struct sockaddr *) &from, &len );
if ( s == AC_SOCKET_INVALID ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slapd_daemon_task: accept(%ld) failed errno=%d (%s)\n",
(long)slap_listeners[l]->sl_sd, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: accept(%ld) failed errno=%d (%s)\n",
(long) slap_listeners[l]->sl_sd, err,
sock_errstr(err) );
#endif
continue;
}
#ifndef HAVE_WINSOCK
/* make sure descriptor number isn't too great */
if ( s >= dtblsize ) {
#ifdef NEW_LGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slapd_daemon_task: %ld beyond descriptor table size %ld\n",
(long)s, (long)dtblsize ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: %ld beyond descriptor table size %ld\n",
(long) s, (long) dtblsize, 0 );
#endif
slapd_close(s);
continue;
}
@ -935,9 +1113,15 @@ slapd_daemon_task(
(char *) &tmp, sizeof(tmp) );
if ( rc == AC_SOCKET_ERROR ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slapd_daemon_task: setsockopt( %ld, SO_KEEPALIVE) failed errno=%d (%s)\n",
(long)s, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY,
"slapd(%ld): setsockopt(SO_KEEPALIVE) failed "
"errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
#endif
}
#endif
#ifdef TCP_NODELAY
@ -947,17 +1131,27 @@ slapd_daemon_task(
(char *)&tmp, sizeof(tmp) );
if ( rc == AC_SOCKET_ERROR ) {
int err = sock_errno();
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slapd_daemon_task: setsockopt( %ld, TCP_NODELAY) failed errno=%d (%s)\n",
(long)s, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_ANY,
"slapd(%ld): setsockopt(TCP_NODELAY) failed "
"errno=%d (%s)\n", (long) s, err, sock_errstr(err) );
#endif
}
#endif
}
#endif
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL1,
"slapd_daemon_task: new connection on %ld\n", (long)s ));
#else
Debug( LDAP_DEBUG_CONNS, "daemon: new connection on %ld\n",
(long) s, 0, 0 );
#endif
switch ( from.sa_addr.sa_family ) {
# ifdef LDAP_PF_LOCAL
case AF_LOCAL:
@ -1055,11 +1249,17 @@ slapd_daemon_task(
if( authid ) ch_free(authid);
if( id < 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_INFO,
"slapd_daemon_task: connection_init(%ld, %s, %s) failed.\n",
(long)s, peername, slap_listeners[l]->sl_name ));
#else
Debug( LDAP_DEBUG_ANY,
"daemon: connection_init(%ld, %s, %s) failed.\n",
(long) s,
peername,
slap_listeners[l]->sl_name );
#endif
slapd_close(s);
continue;
}
@ -1076,16 +1276,32 @@ slapd_daemon_task(
}
#ifdef LDAP_DEBUG
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
"slapd_daemon_task: activity on " ));
#else
Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
#endif
#ifdef HAVE_WINSOCK
for ( i = 0; i < readfds.fd_count; i++ ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
" %d%s", readfs.fd_array[i], "r", 0 );
#else
Debug( LDAP_DEBUG_CONNS, " %d%s",
readfds.fd_array[i], "r", 0 );
#endif
}
for ( i = 0; i < writefds.fd_count; i++ ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
" %d%s", writefds.fd_array[i], "w" ));
#else
Debug( LDAP_DEBUG_CONNS, " %d%s",
writefds.fd_array[i], "w", 0 );
#endif
}
#else
for ( i = 0; i < nfds; i++ ) {
int r, w;
@ -1103,12 +1319,23 @@ slapd_daemon_task(
r = FD_ISSET( i, &readfds );
w = FD_ISSET( i, &writefds );
if ( r || w ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
" %d%s%s", i,
r ? "r" : "", w ? "w" : "" ));
#else
Debug( LDAP_DEBUG_CONNS, " %d%s%s", i,
r ? "r" : "", w ? "w" : "" );
#endif
}
}
#endif
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2, "\n" ));
#else
Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
#endif
#endif
/* loop through the writers */
@ -1138,10 +1365,14 @@ slapd_daemon_task(
if ( is_listener ) {
continue;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
"slapd_daemon_task: write active on %d\n", wd ));
#else
Debug( LDAP_DEBUG_CONNS,
"daemon: write active on %d\n",
wd, 0, 0 );
#endif
/*
* NOTE: it is possible that the connection was closed
* and that the stream is now inactive.
@ -1183,9 +1414,13 @@ slapd_daemon_task(
continue;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_DETAIL2,
"slapd_daemon_task: read activity on %d\n", rd ));
#else
Debug ( LDAP_DEBUG_CONNS,
"daemon: read activity on %d\n", rd, 0, 0 );
#endif
/*
* NOTE: it is possible that the connection was closed
* and that the stream is now inactive.
@ -1201,25 +1436,45 @@ slapd_daemon_task(
}
if( slapd_shutdown > 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
"slapd_daemon_task: shutdown requested and initiated.\n"));
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: shutdown requested and initiated.\n",
0, 0, 0 );
#endif
} else if ( slapd_shutdown < 0 ) {
#ifdef HAVE_NT_SERVICE_MANAGER
if (slapd_shutdown == -1)
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
"slapd_daemon_task: shutdown initiated by Service Manager.\n"));
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: shutdown initiated by Service Manager.\n",
0, 0, 0);
#endif
else
#endif
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
"slapd_daemon_task: abnormal condition, shutdown initiated.\n" ));
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: abnormal condition, shutdown initiated.\n",
0, 0, 0 );
#endif
} else {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
"slapd_daemon_task: no active streams, shutdown initiated.\n" ));
#else
Debug( LDAP_DEBUG_TRACE,
"daemon: no active streams, shutdown initiated.\n",
0, 0, 0 );
#endif
}
for ( l = 0; slap_listeners[l] != NULL; l++ ) {
@ -1234,10 +1489,15 @@ slapd_daemon_task(
}
}
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
"slapd_daemon_task: shutdown waiting for %d threads to terminate.\n",
ldap_pvt_thread_pool_backload(&connection_pool) ));
#else
Debug( LDAP_DEBUG_ANY,
"slapd shutdown: waiting for %d threads to terminate\n",
ldap_pvt_thread_pool_backload(&connection_pool), 0, 0 );
#endif
ldap_pvt_thread_pool_destroy(&connection_pool, 1);
return NULL;
@ -1260,8 +1520,13 @@ int slapd_daemon( void )
0, slapd_daemon_task, NULL );
if ( rc != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_ERR,
"slapd_daemon: listener ldap_pvt_thread_create failed (%d).\n", rc ));
#else
Debug( LDAP_DEBUG_ANY,
"listener ldap_pvt_thread_create failed (%d)\n", rc, 0, 0 );
#endif
return rc;
}
@ -1329,7 +1594,12 @@ int sockdestroy(void)
RETSIGTYPE
slap_sig_shutdown( int sig )
{
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
"slap_sig_shutdown: signal %d\n", sig ));
#else
Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: signal %d\n", sig, 0, 0);
#endif
/*
* If the NT Service Manager is controlling the server, we don't
@ -1339,8 +1609,13 @@ slap_sig_shutdown( int sig )
#if HAVE_NT_SERVICE_MANAGER && SIGBREAK
if (is_NT_Service && sig == SIGBREAK)
#ifdef NEW_LOGGING
LDAP_LOG(( "connection", LDAP_LEVEL_CRIT,
"slap_sig_shutdown: SIGBREAK ignored.\n" ));
#else
Debug(LDAP_DEBUG_TRACE, "slap_sig_shutdown: SIGBREAK ignored.\n",
0, 0, 0);
#endif
else
#endif
slapd_shutdown = sig;

25
servers/slapd/delete.c
View File

@ -37,7 +37,12 @@ do_delete(
int rc;
int manageDSAit;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"do_delete: conn %d\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_TRACE, "do_delete\n", 0, 0, 0 );
#endif
/*
* Parse the delete request. It looks like this:
@ -46,28 +51,48 @@ do_delete(
*/
if ( ber_scanf( op->o_ber, "a", &dn ) == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_delete: conn: %d ber_scanf failed\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_scanf failed\n", 0, 0, 0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "decoding error" );
return SLAPD_DISCONNECT;
}
if( ( rc = get_ctrls( conn, op, 1 ) ) != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "oepration", LDAP_LEVEL_ERR,
"do_delete: conn %d get_ctrls failed\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_ANY, "do_delete: get_ctrls failed\n", 0, 0, 0 );
#endif
goto cleanup;
}
ndn = ch_strdup( dn );
if( dn_normalize( ndn ) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_delete: conn %d invalid dn (%s).\n", conn->c_connid, dn ));
#else
Debug( LDAP_DEBUG_ANY, "do_delete: invalid dn (%s)\n", dn, 0, 0 );
#endif
send_ldap_result( conn, op, rc = LDAP_INVALID_DN_SYNTAX, NULL,
"invalid DN", NULL, NULL );
goto cleanup;
}
if( ndn == '\0' ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"do_delete: conn %d Attempt to delete root DSE.\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_ANY, "do_delete: root dse!\n", 0, 0, 0 );
#endif
/* protocolError would likely be a more appropriate error */
send_ldap_result( conn, op, rc = LDAP_UNWILLING_TO_PERFORM,
NULL, "cannot delete the root DSE", NULL, NULL );

6
servers/slapd/dn.c
View File

@ -235,8 +235,14 @@ dn_validate( char *dn_in )
default:
dn = NULL;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"dn_validate: unknown state %d for dn \"%s\".\n",
state, dn_in ));
#else
Debug( LDAP_DEBUG_ANY,
"dn_validate - unknown state %d\n", state, 0, 0 );
#endif
break;
}

119
servers/slapd/entry.c
View File

@ -58,16 +58,26 @@ str2entry( char *s )
* or newline.
*/
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"str2entry: \"%s\"\n", s ? s : "NULL" ));
#else
Debug( LDAP_DEBUG_TRACE, "=> str2entry\n",
s ? s : "NULL", 0, 0 );
#endif
/* initialize reader/writer lock */
e = (Entry *) ch_malloc( sizeof(Entry) );
if( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"str2entry: entry allocation failed.\n" ));
#else
Debug( LDAP_DEBUG_ANY,
"<= str2entry NULL (entry allocation failed)\n",
0, 0, 0 );
#endif
return( NULL );
}
@ -89,8 +99,13 @@ str2entry( char *s )
}
if ( ldif_parse_line( s, &type, &value.bv_val, &value.bv_len ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"str2entry: NULL (parse_line)\n" ));
#else
Debug( LDAP_DEBUG_TRACE,
"<= str2entry NULL (parse_line)\n", 0, 0, 0 );
#endif
continue;
}
@ -98,10 +113,16 @@ str2entry( char *s )
free( type );
if ( e->e_dn != NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"str2entry: entry %ld has multiple dns \"%s\" and \"%s\" (second ignored)\n",
e->e_id, e->e_dn, value.bv_val != NULL ? value.bv_val : "" ));
#else
Debug( LDAP_DEBUG_ANY,
"str2entry: entry %ld has multiple dns \"%s\" and \"%s\" (second ignored)\n",
e->e_id, e->e_dn,
value.bv_val != NULL ? value.bv_val : "" );
#endif
if( value.bv_val != NULL ) free( value.bv_val );
continue;
}
@ -114,10 +135,14 @@ str2entry( char *s )
rc = slap_str2ad( type, &ad, &text );
if( rc != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"str2entry: str2ad(%s): %s\n", type, text ));
#else
Debug( slapMode & SLAP_TOOL_MODE
? LDAP_DEBUG_ANY : LDAP_DEBUG_TRACE,
"<= str2entry: str2ad(%s): %s\n", type, text, 0 );
#endif
if( slapMode & SLAP_TOOL_MODE ) {
entry_free( e );
free( value.bv_val );
@ -128,9 +153,14 @@ str2entry( char *s )
rc = slap_str2undef_ad( type, &ad, &text );
if( rc != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"str2entry: str2undef_ad(%s): %s\n", type, text ));
#else
Debug( LDAP_DEBUG_ANY,
"<= str2entry: str2undef_ad(%s): %s\n",
type, text, 0 );
#endif
entry_free( e );
free( value.bv_val );
free( type );
@ -143,9 +173,15 @@ str2entry( char *s )
ad->ad_type->sat_syntax->ssyn_validate;
if( !validate ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"str2entry: no validator for syntax %s\n",
ad->ad_type->sat_syntax->ssyn_oid ));
#else
Debug( LDAP_DEBUG_ANY,
"str2entry: no validator for syntax %s\n",
ad->ad_type->sat_syntax->ssyn_oid, 0, 0 );
#endif
entry_free( e );
free( value.bv_val );
free( type );
@ -158,9 +194,15 @@ str2entry( char *s )
rc = validate( ad->ad_type->sat_syntax, &value );
if( rc != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"str2entry: invalid value for syntax %s\n",
ad->ad_type->sat_syntax->ssyn_oid ));
#else
Debug( LDAP_DEBUG_ANY,
"str2entry: invalid value for syntax %s\n",
ad->ad_type->sat_syntax->ssyn_oid, 0, 0 );
#endif
entry_free( e );
free( value.bv_val );
free( type );
@ -173,8 +215,13 @@ str2entry( char *s )
ad_free( ad, 1 );
if( rc != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"str2entry: NULL (attr_merge)\n" ));
#else
Debug( LDAP_DEBUG_ANY,
"<= str2entry NULL (attr_merge)\n", 0, 0, 0 );
#endif
entry_free( e );
free( value.bv_val );
free( type );
@ -187,8 +234,13 @@ str2entry( char *s )
/* check to make sure there was a dn: line */
if ( e->e_dn == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"str2entry: entry %ld has no dn.\n", e->e_id ));
#else
Debug( LDAP_DEBUG_ANY, "str2entry: entry %ld has no dn\n",
e->e_id, 0, 0 );
#endif
entry_free( e );
return( NULL );
}
@ -197,9 +249,13 @@ str2entry( char *s )
e->e_ndn = ch_strdup( e->e_dn );
(void) dn_normalize( e->e_ndn );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL2,
"str2entry(%s) -> 0x%lx\n", e->e_dn, (unsigned long)e ));
#else
Debug(LDAP_DEBUG_TRACE, "<= str2entry(%s) -> 0x%lx\n",
e->e_dn, (unsigned long) e, 0 );
#endif
return( e );
}
@ -343,9 +399,14 @@ int entry_decode( struct berval *bv, Entry **entry )
ber = ber_init( bv );
if( ber == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"entry_decode: ber_init failed\n" ));
#else
Debug( LDAP_DEBUG_ANY,
"<= entry_decode: ber_init failed\n",
0, 0, 0 );
#endif
return LDAP_LOCAL_ERROR;
}
@ -353,9 +414,14 @@ int entry_decode( struct berval *bv, Entry **entry )
e = (Entry *) ch_malloc( sizeof(Entry) );
if( e == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"entry_decode: entry allocation failed.\n" ));
#else
Debug( LDAP_DEBUG_ANY,
"<= entry_decode: entry allocation failed\n",
0, 0, 0 );
#endif
return LDAP_LOCAL_ERROR;
}
@ -372,10 +438,14 @@ int entry_decode( struct berval *bv, Entry **entry )
return LDAP_PROTOCOL_ERROR;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL2,
"entry_decode: \"%s\"\n", e->e_dn ));
#else
Debug( LDAP_DEBUG_TRACE,
"entry_decode: \"%s\"\n",
e->e_dn, 0, 0 );
#endif
/* get the attrs */
for ( tag = ber_first_element( ber, &len, &last );
tag != LBER_DEFAULT;
@ -389,14 +459,24 @@ int entry_decode( struct berval *bv, Entry **entry )
tag = ber_scanf( ber, "{O{V}}", &type, &vals );
if ( tag == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"entry_decode: decoding error (%s)\n", e->e_dn ));
#else
Debug( LDAP_DEBUG_ANY, "entry_decode: decoding error\n", 0, 0, 0 );
#endif
entry_free( e );
return LDAP_PROTOCOL_ERROR;
}
if ( vals == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"entry_decode: no values for type %s\n", type ));
#else
Debug( LDAP_DEBUG_ANY, "entry_decode: no values for type %s\n",
type, 0, 0 );
#endif
ber_bvfree( type );
entry_free( e );
return LDAP_PROTOCOL_ERROR;
@ -406,15 +486,24 @@ int entry_decode( struct berval *bv, Entry **entry )
rc = slap_bv2ad( type, &ad, &text );
if( rc != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"entry_decode: str2ad(%s): %s\n", type, text ));
#else
Debug( LDAP_DEBUG_TRACE,
"<= entry_decode: str2ad(%s): %s\n", type, text, 0 );
#endif
rc = slap_bv2undef_ad( type, &ad, &text );
if( rc != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"entry_decode: str2undef_ad(%s): %s\n", type, text));
#else
Debug( LDAP_DEBUG_ANY,
"<= entry_decode: str2undef_ad(%s): %s\n",
type, text, 0 );
#endif
ber_bvfree( type );
ber_bvecfree( vals );
entry_free( e );
@ -426,8 +515,13 @@ int entry_decode( struct berval *bv, Entry **entry )
ad_free( ad, 1 );
if( rc != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"entry_decode: attr_merge failed\n"));
#else
Debug( LDAP_DEBUG_ANY,
"<= entry_decode: attr_merge failed\n", 0, 0, 0 );
#endif
ber_bvfree( type );
ber_bvecfree( vals );
entry_free( e );
@ -444,8 +538,13 @@ int entry_decode( struct berval *bv, Entry **entry )
return LDAP_PROTOCOL_ERROR;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"entry_decode: %s\n", e->e_dn ));
#else
Debug(LDAP_DEBUG_TRACE, "<= entry_decode(%s)\n",
e->e_dn, 0, 0 );
#endif
*entry = e;
return LDAP_SUCCESS;
@ -459,9 +558,14 @@ int entry_encode(
Attribute *a;
BerElement *ber;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"entry_encode: id: 0x%08lx \"%s\"\n",
e->e_id, e->e_dn ));
#else
Debug( LDAP_DEBUG_TRACE, "=> entry_encode(0x%08lx): %s\n",
e->e_id, e->e_dn, 0 );
#endif
ber = ber_alloc_t( LBER_USE_DER );
if( ber == NULL ) {
goto done;
@ -491,8 +595,13 @@ int entry_encode(
done:
ber_free( ber, 1 );
if( rc ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"entry_encode: id=0x%08lx failed (%d)\n", e->e_id, rc ));
#else
Debug( LDAP_DEBUG_ANY, "=> entry_encode(0x%08lx): failed (%d)\n",
e->e_id, rc, 0 );
#endif
}
return rc;
}

40
servers/slapd/extended.c
View File

@ -93,14 +93,23 @@ do_extended(
struct berval *rspdata;
LDAPControl **rspctrls;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"do_extended: conn %s\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_TRACE, "do_extended\n", 0, 0, 0 );
#endif
reqoid = NULL;
reqdata = NULL;
if( op->o_protocol < LDAP_VERSION3 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_extended: protocol version (%d) too low.\n", op->o_protocol ));
#else
Debug( LDAP_DEBUG_ANY, "do_extended: protocol version (%d) too low\n",
op->o_protocol, 0 ,0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "requires LDAPv3" );
rc = -1;
@ -108,7 +117,12 @@ do_extended(
}
if ( ber_scanf( op->o_ber, "{a" /*}*/, &reqoid ) == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_extended: conn %d ber_scanf failed\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_ANY, "do_extended: ber_scanf failed\n", 0, 0 ,0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "decoding error" );
rc = -1;
@ -116,8 +130,14 @@ do_extended(
}
if( !(ext = find_extop(supp_ext_list, reqoid)) ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_extended: conn %d unsupported operation \"%s\"\n",
conn->c_connid, reqoid ));
#else
Debug( LDAP_DEBUG_ANY, "do_extended: unsupported operation \"%s\"\n",
reqoid, 0 ,0 );
#endif
send_ldap_result( conn, op, rc = LDAP_PROTOCOL_ERROR,
NULL, "unsupported extended operation", NULL, NULL );
goto done;
@ -127,7 +147,12 @@ do_extended(
if( ber_peek_tag( op->o_ber, &len ) == LDAP_TAG_EXOP_REQ_VALUE ) {
if( ber_scanf( op->o_ber, "O", &reqdata ) == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_extended: conn %d ber_scanf failed\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_ANY, "do_extended: ber_scanf failed\n", 0, 0 ,0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "decoding error" );
rc = -1;
@ -136,12 +161,21 @@ do_extended(
}
if( (rc = get_ctrls( conn, op, 1 )) != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_extended: conn %d get_ctrls failed\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_ANY, "do_extended: get_ctrls failed\n", 0, 0 ,0 );
#endif
return rc;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"do_extended: conn %d oid=%d\n.", conn->c_connid, reqoid ));
#else
Debug( LDAP_DEBUG_ARGS, "do_extended: oid=%s\n", reqoid, 0 ,0 );
#endif
rspoid = NULL;
rspdata = NULL;
rspctrls = NULL;
@ -243,4 +277,4 @@ find_extop( extop_list_t *list, char *oid )
return(ext);
}
return(NULL);
}
}

137
servers/slapd/filter.c
View File

@ -47,8 +47,12 @@ get_filter(
char *ftmp = NULL;
struct berval escaped;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY, "get_filter: conn %d\n",
conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "begin get_filter\n", 0, 0, 0 );
#endif
/*
* A filter looks like this coming in:
* Filter ::= CHOICE {
@ -98,8 +102,12 @@ get_filter(
switch ( f->f_choice ) {
case LDAP_FILTER_EQUALITY:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL2,
"get_filter: conn %d EQUALITY\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );
#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY, text );
if ( err != LDAP_SUCCESS ) {
break;
@ -121,13 +129,22 @@ get_filter(
break;
case LDAP_FILTER_SUBSTRINGS:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d SUBSTRINGS\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );
#endif
err = get_substring_filter( conn, ber, f, fstr, text );
break;
case LDAP_FILTER_GE:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d GE\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );
#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );
if ( err != LDAP_SUCCESS ) {
break;
@ -147,8 +164,12 @@ get_filter(
break;
case LDAP_FILTER_LE:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d LE\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );
#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );
if ( err != LDAP_SUCCESS ) {
break;
@ -171,8 +192,12 @@ get_filter(
case LDAP_FILTER_PRESENT: {
struct berval type;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d PRESENT\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 );
#endif
if ( ber_scanf( ber, "o", &type ) == LBER_ERROR ) {
err = SLAPD_DISCONNECT;
*text = "error decoding filter";
@ -197,8 +222,12 @@ get_filter(
} break;
case LDAP_FILTER_APPROX:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d APPROX\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );
#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY_APPROX, text );
if ( err != LDAP_SUCCESS ) {
break;
@ -218,7 +247,12 @@ get_filter(
break;
case LDAP_FILTER_AND:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d AND\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "AND\n", 0, 0, 0 );
#endif
err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );
if ( err != LDAP_SUCCESS ) {
break;
@ -230,7 +264,12 @@ get_filter(
break;
case LDAP_FILTER_OR:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d OR\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "OR\n", 0, 0, 0 );
#endif
err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );
if ( err != LDAP_SUCCESS ) {
break;
@ -242,7 +281,12 @@ get_filter(
break;
case LDAP_FILTER_NOT:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d NOT\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 );
#endif
(void) ber_skip_tag( ber, &len );
err = get_filter( conn, ber, &f->f_not, &ftmp, text );
if ( err != LDAP_SUCCESS ) {
@ -255,7 +299,12 @@ get_filter(
break;
case LDAP_FILTER_EXT:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_filter: conn %d EXTENSIBLE\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
#endif
err = get_mra( ber, &f->f_mra, text );
if ( err != LDAP_SUCCESS ) {
@ -283,8 +332,14 @@ get_filter(
default:
(void) ber_skip_tag( ber, &len );
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
"get_filter: conn %d unknown filter type=%lu\n",
conn->c_connid, f->f_choice ));
#else
Debug( LDAP_DEBUG_ANY, "get_filter: unknown filter type=%lu\n",
f->f_choice, 0, 0 );
#endif
f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;
*fstr = ch_strdup( "(undefined)" );
@ -313,7 +368,12 @@ get_filter(
*filt = f;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL2,
"get_filter: conn %d exit\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "end get_filter %d\n", err, 0, 0 );
#endif
return( err );
}
@ -328,8 +388,12 @@ get_filter_list( Connection *conn, BerElement *ber,
ber_len_t len;
char *last, *ftmp;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"get_filter_list: conn %d start\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "begin get_filter_list\n", 0, 0, 0 );
#endif
*fstr = NULL;
new = f;
for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;
@ -351,7 +415,12 @@ get_filter_list( Connection *conn, BerElement *ber,
}
*new = NULL;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"get_filter_list: conn %d exit\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 );
#endif
return( LDAP_SUCCESS );
}
@ -374,8 +443,12 @@ get_substring_filter(
struct berval *nvalue;
*text = "error decoding filter";
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"get_substring_filter: conn %d begin\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "begin get_substring_filter\n", 0, 0, 0 );
#endif
if ( ber_scanf( ber, "{o" /*}*/, &type ) == LBER_ERROR ) {
return SLAPD_DISCONNECT;
}
@ -438,10 +511,15 @@ get_substring_filter(
default:
rc = LDAP_PROTOCOL_ERROR;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
"get_filter_substring: conn %d unknown substring choice=%ld\n",
conn->c_connid, (long)tag ));
#else
Debug( LDAP_DEBUG_FILTER,
" unknown substring choice=%ld\n",
(long) tag, 0, 0 );
#endif
ber_bvfree( value );
goto return_error;
}
@ -459,7 +537,13 @@ get_substring_filter(
switch ( tag ) {
case LDAP_SUBSTRING_INITIAL:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_substring_filter: conn %d INITIAL\n",
conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 );
#endif
if ( f->f_sub_initial != NULL ) {
ber_bvfree( value );
goto return_error;
@ -477,7 +561,13 @@ get_substring_filter(
break;
case LDAP_SUBSTRING_ANY:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_substring_filter: conn %d ANY\n",
conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 );
#endif
if( ber_bvecadd( &f->f_sub_any, value ) < 0 ) {
ber_bvfree( value );
goto return_error;
@ -494,7 +584,13 @@ get_substring_filter(
break;
case LDAP_SUBSTRING_FINAL:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"get_substring_filter: conn %d FINAL\n",
conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 );
#endif
if ( f->f_sub_final != NULL ) {
ber_bvfree( value );
goto return_error;
@ -512,16 +608,27 @@ get_substring_filter(
break;
default:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
"get_substring_filter: conn %d unknown substring type %ld\n",
conn->c_connid, (long)tag ));
#else
Debug( LDAP_DEBUG_FILTER,
" unknown substring type=%ld\n",
(long) tag, 0, 0 );
#endif
ber_bvfree( value );
return_error:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
"get_substring_filter: conn %d error %ld\n",
conn->c_connid, (long)rc ));
#else
Debug( LDAP_DEBUG_FILTER, " error=%ld\n",
(long) rc, 0, 0 );
#endif
if( fstr ) {
free( *fstr );
*fstr = NULL;
@ -544,7 +651,12 @@ return_error:
strcat( *fstr, /*(*/ ")" );
}
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"get_substring_filter: conn %d exit\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );
#endif
return( LDAP_SUCCESS );
}
@ -593,8 +705,13 @@ filter_free( Filter *f )
break;
default:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
"filter_free: unknown filter type %lu\n", f->f_choice ));
#else
Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n",
f->f_choice, 0, 0 );
#endif
break;
}

115
servers/slapd/filterentry.c
View File

@ -55,26 +55,55 @@ test_filter(
{
int rc;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_filter: begin\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "=> test_filter\n", 0, 0, 0 );
#endif
switch ( f->f_choice ) {
case SLAPD_FILTER_COMPUTED:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: COMPUTED %s (%d)\n",
f->f_result == LDAP_COMPARE_FALSE ? "false" :
f->f_result == LDAP_COMPARE_TRUE ? "true" :
f->f_result == SLAPD_COMPARE_UNDEFINED ? "undefined" :
"error",
f->f_result ));
#else
Debug( LDAP_DEBUG_FILTER, " COMPUTED %s (%d)\n",
f->f_result == LDAP_COMPARE_FALSE ? "false" :
f->f_result == LDAP_COMPARE_TRUE ? "true" :
f->f_result == SLAPD_COMPARE_UNDEFINED ? "undefined" : "error",
f->f_result, 0 );
#endif
rc = f->f_result;
break;
case LDAP_FILTER_EQUALITY:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: EQUALITY\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " EQUALITY\n", 0, 0, 0 );
#endif
rc = test_ava_filter( be, conn, op, e, f->f_ava,
LDAP_FILTER_EQUALITY );
break;
case LDAP_FILTER_SUBSTRINGS:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter SUBSTRINGS\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " SUBSTRINGS\n", 0, 0, 0 );
#endif
rc = test_substrings_filter( be, conn, op, e, f );
break;
@ -89,28 +118,57 @@ test_filter(
break;
case LDAP_FILTER_PRESENT:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: PRESENT\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " PRESENT\n", 0, 0, 0 );
#endif
rc = test_presence_filter( be, conn, op, e, f->f_desc );
break;
case LDAP_FILTER_APPROX:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: APPROX\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " APPROX\n", 0, 0, 0 );
#endif
rc = test_ava_filter( be, conn, op, e, f->f_ava,
LDAP_FILTER_APPROX );
break;
case LDAP_FILTER_AND:
Debug( LDAP_DEBUG_FILTER, " AND\n", 0, 0, 0 );
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: AND\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " AND\n", 0, 0, 0 );
#endif
rc = test_filter_and( be, conn, op, e, f->f_and );
break;
case LDAP_FILTER_OR:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: OR\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " OR\n", 0, 0, 0 );
#endif
rc = test_filter_or( be, conn, op, e, f->f_or );
break;
case LDAP_FILTER_NOT:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: NOT\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " NOT\n", 0, 0, 0 );
#endif
rc = test_filter( be, conn, op, e, f->f_not );
switch( rc ) {
@ -125,18 +183,37 @@ test_filter(
#ifdef SLAPD_EXT_FILTERS
case LDAP_FILTER_EXT:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"test_filter: EXT\n" ));
#else
Debug( LDAP_DEBUG_FILTER, " EXT\n", 0, 0, 0 );
#endif
rc = test_mra_filter( be, conn, op, e, f->f_mra );
break;
#endif
default:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
"test_filter: unknown filter type %lu\n",
f->f_choice ));
#else
Debug( LDAP_DEBUG_ANY, " unknown filter type %lu\n",
f->f_choice, 0, 0 );
#endif
rc = LDAP_PROTOCOL_ERROR;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_filter: return=%d\n", rc ));
#else
Debug( LDAP_DEBUG_FILTER, "<= test_filter %d\n", rc, 0, 0 );
#endif
return( rc );
}
@ -262,7 +339,13 @@ test_filter_and(
Filter *f;
int rtn = LDAP_COMPARE_TRUE;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_filter_and: begin\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "=> test_filter_and\n", 0, 0, 0 );
#endif
for ( f = flist; f != NULL; f = f->f_next ) {
int rc = test_filter( be, conn, op, e, f );
@ -276,7 +359,13 @@ test_filter_and(
}
}
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_filter_and: rc=%d\n", rtn ));
#else
Debug( LDAP_DEBUG_FILTER, "<= test_filter_and %d\n", rtn, 0, 0 );
#endif
return rtn;
}
@ -292,7 +381,13 @@ test_filter_or(
Filter *f;
int rtn = LDAP_COMPARE_FALSE;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_filter_or: begin\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "=> test_filter_or\n", 0, 0, 0 );
#endif
for ( f = flist; f != NULL; f = f->f_next ) {
int rc = test_filter( be, conn, op, e, f );
@ -306,7 +401,13 @@ test_filter_or(
}
}
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_filter_or: result=%d\n", rtn ));
#else
Debug( LDAP_DEBUG_FILTER, "<= test_filter_or %d\n", rtn, 0, 0 );
#endif
return rtn;
}
@ -322,7 +423,13 @@ test_substrings_filter(
{
Attribute *a;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_substrings_filter: begin\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "begin test_substrings_filter\n", 0, 0, 0 );
#endif
if ( be != NULL && ! access_allowed( be, conn, op, e,
f->f_sub_desc, NULL, ACL_SEARCH ) )
@ -360,6 +467,12 @@ test_substrings_filter(
}
}
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"test_substrings_filter: return FALSE\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "end test_substrings_filter 1\n", 0, 0, 0 );
#endif
return LDAP_COMPARE_FALSE;
}

39
servers/slapd/init.c
View File

@ -74,9 +74,16 @@ slap_init( int mode, const char *name )
assert( mode );
if( slapMode != SLAP_UNDEFINED_MODE ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_CRIT,
"init: %s init called twice (old=%d, new=%d)\n",
name, slapMode, mode ));
#else
Debug( LDAP_DEBUG_ANY,
"%s init: init called twice (old=%d, new=%d)\n",
name, slapMode, mode );
#endif
return 1;
}
@ -85,10 +92,17 @@ slap_init( int mode, const char *name )
switch ( slapMode & SLAP_MODE ) {
case SLAP_SERVER_MODE:
case SLAP_TOOL_MODE:
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"init: %s initiation, initiated %s.\n",
name, (mode & SLAP_MODE) == SLAP_TOOL_MODE ? "tool" : "server" ));
#else
Debug( LDAP_DEBUG_TRACE,
"%s init: initiated %s.\n", name,
(mode & SLAP_MODE) == SLAP_TOOL_MODE ? "tool" : "server",
0 );
#endif
slap_name = name;
@ -115,8 +129,14 @@ slap_init( int mode, const char *name )
break;
default:
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"init: %s init, undefined mode (%d).\n", name, mode ));
#else
Debug( LDAP_DEBUG_ANY,
"%s init: undefined mode (%d).\n", name, mode, 0 );
#endif
rc = 1;
break;
}
@ -128,9 +148,15 @@ int slap_startup( Backend *be )
{
int rc;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_CRIT,
"slap_startup: %s started\n", slap_name ));
#else
Debug( LDAP_DEBUG_TRACE,
"%s startup: initiated.\n",
slap_name, 0, 0 );
#endif
rc = backend_startup( be );
@ -141,9 +167,15 @@ int slap_shutdown( Backend *be )
{
int rc;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_CRIT,
"slap_shutdown: %s shutdown initiated.\n", slap_name));
#else
Debug( LDAP_DEBUG_TRACE,
"%s shutdown: initiated\n",
slap_name, 0, 0 );
#endif
slap_sasl_destroy();
@ -157,9 +189,16 @@ int slap_destroy(void)
{
int rc;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_destroy: %s freeing system resources.\n",
slap_name ));
#else
Debug( LDAP_DEBUG_TRACE,
"%s shutdown: freeing system resources.\n",
slap_name, 0, 0 );
#endif
rc = backend_destroy();

12
servers/slapd/lock.c
View File

@ -30,7 +30,13 @@ lock_fopen( const char *fname, const char *type, FILE **lfp )
strcpy( buf, fname );
strcat( buf, ".lock" );
if ( (*lfp = fopen( buf, "w" )) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"lock_fopen: could not open lock file \"%s\".\n", buf ));
#else
Debug( LDAP_DEBUG_ANY, "could not open \"%s\"\n", buf, 0, 0 );
#endif
return( NULL );
}
@ -39,7 +45,13 @@ lock_fopen( const char *fname, const char *type, FILE **lfp )
/* open the log file */
if ( (fp = fopen( fname, type )) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"lock_fopen: could not open log file \"%s\".\n", buf ));
#else
Debug( LDAP_DEBUG_ANY, "could not open \"%s\"\n", fname, 0, 0 );
#endif
ldap_unlockf( fileno(*lfp) );
fclose( *lfp );
*lfp = NULL;

47
servers/slapd/main.c
View File

@ -175,7 +175,12 @@ int main( int argc, char **argv )
if ( i != NULL )
{
slap_debug = *i;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"main: new debug level from registry is: %d\n", slap_debug ));
#else
Debug( LDAP_DEBUG_ANY, "new debug level from registry is: %d\n", slap_debug, 0, 0 );
#endif
}
newUrls = (char *) getRegParam(regService, "Urls");
@ -185,15 +190,27 @@ int main( int argc, char **argv )
ch_free(urls);
urls = ch_strdup(newUrls);
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"main: new urls from registry: %s\n", urls ));
#else
Debug(LDAP_DEBUG_ANY, "new urls from registry: %s\n",
urls, 0, 0);
#endif
}
newConfigFile = (char*)getRegParam( regService, "ConfigFile" );
if ( newConfigFile != NULL )
{
configfile = newConfigFile;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"main: new config file from registry is: %s\n", configfile ));
#else
Debug ( LDAP_DEBUG_ANY, "new config file from registry is: %s\n", configfile, 0, 0 );
#endif
}
}
#endif
@ -283,7 +300,13 @@ int main( int argc, char **argv )
ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, &slap_debug);
ldif_debug = slap_debug;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"%s", Versionstr ));
#else
Debug( LDAP_DEBUG_TRACE, "%s", Versionstr, 0, 0 );
#endif
if( serverName == NULL ) {
if ( (serverName = strrchr( argv[0], *LDAP_DIRSEP )) == NULL ) {
@ -343,9 +366,15 @@ int main( int argc, char **argv )
}
if ( schema_init( ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_CRIT,
"main: schema initialization error\n" ));
#else
Debug( LDAP_DEBUG_ANY,
"schema initialization error\n",
0, 0, 0 );
#endif
goto destroy;
}
@ -356,9 +385,15 @@ int main( int argc, char **argv )
}
if ( schema_prep( ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_CRIT,
"main: schema prep error\n"));
#else
Debug( LDAP_DEBUG_ANY,
"schema prep error\n",
0, 0, 0 );
#endif
goto destroy;
}
@ -408,7 +443,13 @@ int main( int argc, char **argv )
{
FILE *fp;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"main: slapd starting.\n" ));
#else
Debug( LDAP_DEBUG_ANY, "slapd starting\n", 0, 0, 0 );
#endif
if (( slapd_pid_file != NULL ) &&
(( fp = fopen( slapd_pid_file, "w" )) != NULL ))
@ -461,7 +502,13 @@ stop:
LogSlapdStoppedEvent( serverName );
#endif
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_CRIT,
"main: slapd stopped.\n" ));
#else
Debug( LDAP_DEBUG_ANY, "slapd stopped.\n", 0, 0, 0 );
#endif
#ifdef HAVE_NT_SERVICE_MANAGER
ReportSlapdShutdownComplete();

71
servers/slapd/modify.c
View File

@ -47,7 +47,13 @@ do_modify(
const char *text;
int manageDSAit;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"do_modify: enter\n" ));
#else
Debug( LDAP_DEBUG_TRACE, "do_modify\n", 0, 0, 0 );
#endif
/*
* Parse the modify request. It looks like this:
@ -69,13 +75,25 @@ do_modify(
*/
if ( ber_scanf( op->o_ber, "{a" /*}*/, &dn ) == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modify: ber_scanf failed\n" ));
#else
Debug( LDAP_DEBUG_ANY, "do_modify: ber_scanf failed\n", 0, 0, 0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "decoding error" );
return SLAPD_DISCONNECT;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"do_modify: dn (%s)\n", dn ));
#else
Debug( LDAP_DEBUG_ARGS, "do_modify: dn (%s)\n", dn, 0, 0 );
#endif
/* collect modifications & save for later */
@ -100,9 +118,16 @@ do_modify(
switch( mop ) {
case LDAP_MOD_ADD:
if ( (*modtail)->ml_bvalues == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modify: modify/add operation (%ld) requires values\n",
(long)mop ));
#else
Debug( LDAP_DEBUG_ANY,
"do_modify: modify/add operation (%ld) requires values\n",
(long) mop, 0, 0 );
#endif
send_ldap_result( conn, op, LDAP_PROTOCOL_ERROR,
NULL, "modify/add operation requires values",
NULL, NULL );
@ -117,9 +142,16 @@ do_modify(
break;
default: {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modify: invalid modify operation (%ld)\n",
(long)mop ));
#else
Debug( LDAP_DEBUG_ANY,
"do_modify: invalid modify operation (%ld)\n",
(long) mop, 0, 0 );
#endif
send_ldap_result( conn, op, LDAP_PROTOCOL_ERROR,
NULL, "unrecognized modify operation", NULL, NULL );
rc = LDAP_PROTOCOL_ERROR;
@ -133,33 +165,65 @@ do_modify(
*modtail = NULL;
if( (rc = get_ctrls( conn, op, 1 )) != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modify: get_ctrls failed\n" ));
#else
Debug( LDAP_DEBUG_ANY, "do_modify: get_ctrls failed\n", 0, 0, 0 );
#endif
goto cleanup;
}
ndn = ch_strdup( dn );
if( dn_normalize( ndn ) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modify: invalid dn (%s)\n", dn ));
#else
Debug( LDAP_DEBUG_ANY, "do_modify: invalid dn (%s)\n", dn, 0, 0 );
#endif
send_ldap_result( conn, op, rc = LDAP_INVALID_DN_SYNTAX, NULL,
"invalid DN", NULL, NULL );
goto cleanup;
}
if( ndn == '\0' ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modify: attempt to modify root DSE.\n" ));
#else
Debug( LDAP_DEBUG_ANY, "do_modify: root dse!\n", 0, 0, 0 );
#endif
send_ldap_result( conn, op, rc = LDAP_UNWILLING_TO_PERFORM,
NULL, "modify upon the root DSE not supported", NULL, NULL );
goto cleanup;
}
#ifdef LDAP_DEBUG
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"do_modify: modifications:\n" ));
#else
Debug( LDAP_DEBUG_ARGS, "modifications:\n", 0, 0, 0 );
#endif
for ( tmp = modlist; tmp != NULL; tmp = tmp->ml_next ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_DETAIL1,
"\t%s: %s\n", tmp->ml_op == LDAP_MOD_ADD ?
"add" : (tmp->ml_op == LDAP_MOD_DELETE ?
"delete" : "replace"), tmp->ml_type ));
#else
Debug( LDAP_DEBUG_ARGS, "\t%s: %s\n",
tmp->ml_op == LDAP_MOD_ADD
? "add" : (tmp->ml_op == LDAP_MOD_DELETE
? "delete" : "replace"), tmp->ml_type, 0 );
#endif
}
#endif
@ -342,9 +406,16 @@ int slap_modlist2mods(
ad->ad_type->sat_syntax->ssyn_validate;
if( !validate ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"modlist2mods: no validator for syntax %S\n",
ad->ad_type->sat_syntax->ssyn_oid ));
#else
Debug( LDAP_DEBUG_TRACE,
"modlist2mods: no validator for syntax %s\n",
ad->ad_type->sat_syntax->ssyn_oid, 0, 0 );
#endif
slap_mods_free( mod );
*text = "no validator for syntax";
return LDAP_INVALID_SYNTAX;

67
servers/slapd/modrdn.c
View File

@ -56,7 +56,13 @@ do_modrdn(
const char *text;
int manageDSAit;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"do_modrdn: begin\n" ));
#else
Debug( LDAP_DEBUG_TRACE, "do_modrdn\n", 0, 0, 0 );
#endif
/*
* Parse the modrdn request. It looks like this:
@ -71,7 +77,13 @@ do_modrdn(
if ( ber_scanf( op->o_ber, "{aab", &dn, &newrdn, &deloldrdn )
== LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: ber_scanf failed\n" ));
#else
Debug( LDAP_DEBUG_ANY, "ber_scanf failed\n", 0, 0, 0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "decoding error" );
return SLAPD_DISCONNECT;
@ -84,9 +96,15 @@ do_modrdn(
/* Conection record indicates v2 but field
* newSuperior is present: report error.
*/
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: (v2) invalid field newSuperior.\n" ));
#else
Debug( LDAP_DEBUG_ANY,
"modrdn(v2): invalid field newSuperior!\n",
0, 0, 0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "newSuperior requires LDAPv3" );
rc = SLAPD_DISCONNECT;
@ -96,8 +114,14 @@ do_modrdn(
if ( ber_scanf( op->o_ber, "a", &newSuperior )
== LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: ber_scanf(\"a\") failed\n" ));
#else
Debug( LDAP_DEBUG_ANY, "ber_scanf(\"a\") failed\n",
0, 0, 0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "decoding error" );
rc = SLAPD_DISCONNECT;
@ -107,8 +131,14 @@ do_modrdn(
nnewSuperior = ch_strdup( newSuperior );
if( dn_normalize( nnewSuperior ) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: invalid new superior (%s)\n", newSuperior ));
#else
Debug( LDAP_DEBUG_ANY, "do_modrdn: invalid new superior (%s)\n",
newSuperior, 0, 0 );
#endif
send_ldap_result( conn, op, rc = LDAP_INVALID_DN_SYNTAX, NULL,
"invalid new superior DN", NULL, NULL );
goto cleanup;
@ -116,13 +146,26 @@ do_modrdn(
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"do_modrdn: dn (%s) newrdn (%s) newsuperior(%s)\n",
dn, newrdn, newSuperior != NULL ? newSuperior : "" ));
#else
Debug( LDAP_DEBUG_ARGS,
"do_modrdn: dn (%s) newrdn (%s) newsuperior (%s)\n",
dn, newrdn,
newSuperior != NULL ? newSuperior : "" );
#endif
if ( ber_scanf( op->o_ber, /*{*/ "}") == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: ber_scanf failed\n" ));
#else
Debug( LDAP_DEBUG_ANY, "do_modrdn: ber_scanf failed\n", 0, 0, 0 );
#endif
send_ldap_disconnect( conn, op,
LDAP_PROTOCOL_ERROR, "decoding error" );
rc = SLAPD_DISCONNECT;
@ -130,7 +173,13 @@ do_modrdn(
}
if( (rc = get_ctrls( conn, op, 1 )) != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: get_ctrls failed\n" ));
#else
Debug( LDAP_DEBUG_ANY, "do_modrdn: get_ctrls failed\n", 0, 0, 0 );
#endif
/* get_ctrls has sent results. Now clean up. */
goto cleanup;
}
@ -138,21 +187,39 @@ do_modrdn(
ndn = ch_strdup( dn );
if( dn_normalize( ndn ) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: invalid dn (%s)\n", dn ));
#else
Debug( LDAP_DEBUG_ANY, "do_modrdn: invalid dn (%s)\n", dn, 0, 0 );
#endif
send_ldap_result( conn, op, rc = LDAP_INVALID_DN_SYNTAX, NULL,
"invalid DN", NULL, NULL );
goto cleanup;
}
if( !rdn_validate( newrdn ) ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: invalid rdn (%s).\n", newrdn ));
#else
Debug( LDAP_DEBUG_ANY, "do_modrdn: invalid rdn (%s)\n", newrdn, 0, 0 );
#endif
send_ldap_result( conn, op, rc = LDAP_INVALID_DN_SYNTAX, NULL,
"invalid RDN", NULL, NULL );
goto cleanup;
}
if( ndn == '\0' ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"do_modrdn: attempt to modify root DSE.\n" ));
#else
Debug( LDAP_DEBUG_ANY, "do_modrdn: root dse!\n", 0, 0, 0 );
#endif
send_ldap_result( conn, op, rc = LDAP_UNWILLING_TO_PERFORM,
NULL, "cannot rename the root DSE", NULL, NULL );
goto cleanup;

64
servers/slapd/module.c
View File

@ -40,7 +40,13 @@ int module_init (void)
{
if (lt_dlinit()) {
const char *error = lt_dlerror();
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_CRIT,
"module_init: lt_ldinit failed: %s\n", error ));
#else
Debug(LDAP_DEBUG_ANY, "lt_dlinit failed: %s\n", error, 0, 0);
#endif
return -1;
}
return 0;
@ -55,7 +61,13 @@ int module_kill (void)
if (lt_dlexit()) {
const char *error = lt_dlerror();
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_CRIT,
"module_kill: lt_dlexit failed: %s\n", error ));
#else
Debug(LDAP_DEBUG_ANY, "lt_dlexit failed: %s\n", error, 0, 0);
#endif
return -1;
}
return 0;
@ -70,8 +82,14 @@ int module_load(const char* file_name, int argc, char *argv[])
module = (module_loaded_t *)ch_calloc(1, sizeof(module_loaded_t));
if (module == NULL) {
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_CRIT,
"module_load: (%s) out of memory.\n", file_name ));
#else
Debug(LDAP_DEBUG_ANY, "module_load failed: (%s) out of memory\n", file_name,
0, 0);
#endif
return -1;
}
@ -82,17 +100,37 @@ int module_load(const char* file_name, int argc, char *argv[])
*/
if ((module->lib = lt_dlopen(file_name)) == NULL) {
error = lt_dlerror();
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_CRIT,
"module_load: lt_dlopen failed: (%s) %s.\n",
file_name, error ));
#else
Debug(LDAP_DEBUG_ANY, "lt_dlopen failed: (%s) %s\n", file_name,
error, 0);
#endif
ch_free(module);
return -1;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_INFO,
"module_load: loaded module %s\n", file_name ));
#else
Debug(LDAP_DEBUG_CONFIG, "loaded module %s\n", file_name, 0, 0);
#endif
if ((initialize = lt_dlsym(module->lib, "init_module")) == NULL) {
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_ERR,
"module_load: module %s : no init_module() function found\n",
file_name ));
#else
Debug(LDAP_DEBUG_CONFIG, "module %s: no init_module() function found\n",
file_name, 0, 0);
#endif
lt_dlclose(module->lib);
ch_free(module);
return -1;
@ -115,8 +153,14 @@ int module_load(const char* file_name, int argc, char *argv[])
*/
rc = initialize(argc, argv);
if (rc == -1) {
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_ERR,
"module_load: module %s init_module() failed\n", file_name));
#else
Debug(LDAP_DEBUG_CONFIG, "module %s: init_module() failed\n",
file_name, 0, 0);
#endif
lt_dlclose(module->lib);
ch_free(module);
return rc;
@ -125,16 +169,29 @@ int module_load(const char* file_name, int argc, char *argv[])
if (rc >= (sizeof(module_regtable) / sizeof(struct module_regtable_t))
|| module_regtable[rc].proc == NULL)
{
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_ERR,
"module_load: module %s: unknown registration type (%d).\n", file_name));
#else
Debug(LDAP_DEBUG_CONFIG, "module %s: unknown registration type (%d)\n",
file_name, rc, 0);
#endif
module_unload(module);
return -1;
}
rc = (module_regtable[rc].proc)(module, file_name);
if (rc != 0) {
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_ERR,
"module_load: module %s:%s could not be registered.\n",
file_name, module_regtable[rc].type ));
#else
Debug(LDAP_DEBUG_CONFIG, "module %s: %s module could not be registered\n",
file_name, module_regtable[rc].type, 0);
#endif
module_unload(module);
return rc;
}
@ -142,8 +199,15 @@ int module_load(const char* file_name, int argc, char *argv[])
module->next = module_list;
module_list = module;
#ifdef NEW_LOGGING
LDAP_LOG(( "module", LDAP_LEVEL_INFO,
"module_load: module %s:%s registered\n", file_name,
module_regtable[rc].type ));
#else
Debug(LDAP_DEBUG_CONFIG, "module %s: %s module registered\n",
file_name, module_regtable[rc].type, 0);
#endif
return 0;
}

27
servers/slapd/mr.c
View File

@ -168,8 +168,14 @@ register_matching_rule(
const char *err;
if( usage == SLAP_MR_NONE ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"register_matching_rule: %s not usable\n", desc ));
#else
Debug( LDAP_DEBUG_ANY, "register_matching_rule: not usable %s\n",
desc, 0, 0 );
#endif
return -1;
}
@ -180,9 +186,16 @@ register_matching_rule(
/* ignore for now */
if( amr == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"register_matching_rule: could not locate associated matching rule %s for %s\n",
associated, desc ));
#else
Debug( LDAP_DEBUG_ANY, "register_matching_rule: could not locate "
"associated matching rule %s for %s\n",
associated, desc, 0 );
#endif
return -1;
}
#endif
@ -191,8 +204,15 @@ register_matching_rule(
mr = ldap_str2matchingrule( desc, &code, &err, LDAP_SCHEMA_ALLOW_ALL);
if ( !mr ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"register_matching_rule: %s before %s in %s.\n",
ldap_scherr2str(code), err, desc ));
#else
Debug( LDAP_DEBUG_ANY, "Error in register_matching_rule: %s before %s in %s\n",
ldap_scherr2str(code), err, desc );
#endif
return( -1 );
}
@ -203,8 +223,15 @@ register_matching_rule(
ldap_memfree( mr );
if ( code ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"register_matching_rule: %s for %s in %s.\n",
scherr2str(code), err, desc ));
#else
Debug( LDAP_DEBUG_ANY, "Error in register_matching_rule: %s for %s in %s\n",
scherr2str(code), err, desc );
#endif
return( -1 );
}

48
servers/slapd/mra.c
View File

@ -51,7 +51,13 @@ get_mra(
rc = ber_scanf( ber, "{t", &tag );
if( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf (\"{t\") failure\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf\n", 0, 0, 0 );
#endif
*text = "Error parsing matching rule assertion";
mra_free( ma, 1 );
return SLAPD_DISCONNECT;
@ -60,7 +66,13 @@ get_mra(
if ( tag == LDAP_FILTER_EXT_OID ) {
rc = ber_scanf( ber, "a", &ma->ma_rule_text );
if ( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf(\"a\") failure.\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf for mr\n", 0, 0, 0 );
#endif
*text = "Error parsing matching rule in matching rule assertion";
mra_free( ma, 1 );
return SLAPD_DISCONNECT;
@ -70,7 +82,13 @@ get_mra(
rc = ber_scanf( ber, "t", &tag );
if( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf (\"t\") failure\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf\n", 0, 0, 0 );
#endif
*text = "Error parsing matching rule assertion";
mra_free( ma, 1 );
return SLAPD_DISCONNECT;
@ -80,7 +98,13 @@ get_mra(
if ( tag == LDAP_FILTER_EXT_TYPE ) {
rc = ber_scanf( ber, "o", &type );
if ( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf (\"o\") failure.\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf for ad\n", 0, 0, 0 );
#endif
*text = "Error parsing attribute description in matching rule assertion";
return SLAPD_DISCONNECT;
}
@ -97,7 +121,13 @@ get_mra(
rc = ber_scanf( ber, "t", &tag );
if( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf (\"t\") failure.\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf\n", 0, 0, 0 );
#endif
*text = "Error parsing matching rule assertion";
mra_free( ma, 1 );
return SLAPD_DISCONNECT;
@ -105,7 +135,13 @@ get_mra(
}
if ( tag != LDAP_FILTER_EXT_VALUE ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf missing value\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf missing value\n", 0, 0, 0 );
#endif
*text = "Missing value in matching rule assertion";
mra_free( ma, 1 );
return SLAPD_DISCONNECT;
@ -114,7 +150,13 @@ get_mra(
rc = ber_scanf( ber, "o", &value );
if( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf (\"o\") failure.\n" ));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf\n", 0, 0, 0 );
#endif
*text = "Error decoding value in matching rule assertion";
mra_free( ma, 1 );
return SLAPD_DISCONNECT;
@ -144,7 +186,13 @@ get_mra(
}
if( rc == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"get_mra: ber_scanf failure\n"));
#else
Debug( LDAP_DEBUG_ANY, " get_mra ber_scanf\n", 0, 0, 0 );
#endif
*text = "Error decoding dnattrs matching rule assertion";
mra_free( ma, 1 );
return SLAPD_DISCONNECT;

7
servers/slapd/oc.c
View File

@ -66,10 +66,17 @@ int is_entry_objectclass(
if( attr == NULL ) {
/* no objectClass attribute */
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"is_entry_objectclass: dn(%s), oid (%s), no objectlcass attribute.\n",
e->e_dn == NULL ? "" : e->e_dn, oc->soc_oclass.oc_oid ));
#else
Debug( LDAP_DEBUG_ANY, "is_entry_objectclass(\"%s\", \"%s\") "
"no objectClass attribute\n",
e->e_dn == NULL ? "" : e->e_dn,
oc->soc_oclass.oc_oid, 0 );
#endif
return 0;
}

7
servers/slapd/operation.c
View File

@ -96,8 +96,15 @@ slap_op_remove( Operation **olist, Operation *op )
; /* NULL */
if ( *tmp == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_op_remove: can't find op %ld.\n",
(long)op->o_msgid ));
#else
Debug( LDAP_DEBUG_ANY, "op_delete: can't find op %ld\n",
(long) op->o_msgid, 0, 0 );
#endif
return -1;
}

60
servers/slapd/passwd.c
View File

@ -82,8 +82,14 @@ int slap_passwd_parse( struct berval *reqdata,
ber = ber_init( reqdata );
if( ber == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: ber_init failed\n" ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_parse: ber_init failed\n",
0, 0, 0 );
#endif
*text = "password decoding error";
return LDAP_PROTOCOL_ERROR;
}
@ -96,8 +102,14 @@ int slap_passwd_parse( struct berval *reqdata,
if( tag == LDAP_TAG_EXOP_X_MODIFY_PASSWD_ID ) {
if( id == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: ID not allowed.\n"));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_parse: ID not allowed.\n",
0, 0, 0 );
#endif
*text = "user must change own password";
rc = LDAP_UNWILLING_TO_PERFORM;
goto done;
@ -106,8 +118,14 @@ int slap_passwd_parse( struct berval *reqdata,
tag = ber_scanf( ber, "O", id );
if( tag == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: ID parse failed.\n"));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_parse: ID parse failed.\n",
0, 0, 0 );
#endif
goto decoding_error;
}
@ -116,8 +134,14 @@ int slap_passwd_parse( struct berval *reqdata,
if( tag == LDAP_TAG_EXOP_X_MODIFY_PASSWD_OLD ) {
if( oldpass == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: OLD not allowed.\n" ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_parse: OLD not allowed.\n",
0, 0, 0 );
#endif
*text = "use bind to verify old password";
rc = LDAP_UNWILLING_TO_PERFORM;
goto done;
@ -126,8 +150,14 @@ int slap_passwd_parse( struct berval *reqdata,
tag = ber_scanf( ber, "O", oldpass );
if( tag == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: ID parse failed.\n" ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_parse: ID parse failed.\n",
0, 0, 0 );
#endif
goto decoding_error;
}
@ -136,8 +166,14 @@ int slap_passwd_parse( struct berval *reqdata,
if( tag == LDAP_TAG_EXOP_X_MODIFY_PASSWD_NEW ) {
if( newpass == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: NEW not allowed.\n" ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_parse: NEW not allowed.\n",
0, 0, 0 );
#endif
*text = "user specified passwords disallowed";
rc = LDAP_UNWILLING_TO_PERFORM;
goto done;
@ -146,8 +182,14 @@ int slap_passwd_parse( struct berval *reqdata,
tag = ber_scanf( ber, "O", newpass );
if( tag == LBER_ERROR ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: OLD parse failed.\n"));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_parse: OLD parse failed.\n",
0, 0, 0 );
#endif
goto decoding_error;
}
@ -156,9 +198,15 @@ int slap_passwd_parse( struct berval *reqdata,
if( len != 0 ) {
decoding_error:
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"slap_passwd_parse: decoding error, len=%ld\n", (long)len ));
#else
Debug( LDAP_DEBUG_TRACE,
"slap_passwd_parse: decoding error, len=%ld\n",
(long) len, 0, 0 );
#endif
*text = "data decoding error";
rc = LDAP_PROTOCOL_ERROR;
@ -195,8 +243,14 @@ struct berval * slap_passwd_return(
assert( cred != NULL );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"slap_passwd_return: %ld\n",(long)cred->bv_len ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_return: %ld\n",
(long) cred->bv_len, 0, 0 );
#endif
if( ber == NULL ) return NULL;
@ -250,7 +304,13 @@ slap_passwd_check(
struct berval * slap_passwd_generate( void )
{
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"slap_passwd_generate: begin\n" ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_passwd_generate\n", 0, 0, 0 );
#endif
/*
* generate passwords of only 8 characters as some getpass(3)

274
servers/slapd/result.c
View File

@ -214,8 +214,15 @@ static long send_ldap_ber(
* it's a hard error and return.
*/
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_ldap_ber: conn %d ber_flush failed err=%d (%s)\n",
conn ? conn->c_connid : 0, err, sock_errstr(err) ));
#else
Debug( LDAP_DEBUG_CONNS, "ber_flush failed errno=%d reason=\"%s\"\n",
err, sock_errstr(err), 0 );
#endif
if ( err != EWOULDBLOCK && err != EAGAIN ) {
connection_closing( conn );
@ -265,18 +272,40 @@ send_ldap_response(
ber = ber_alloc_t( LBER_USE_DER );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_ldap_response: conn %d msgid=%ld tag=%ld err=%ld\n",
conn ? conn->c_connid : 0, (long)msgid, (long)tag, (long)err ));
#else
Debug( LDAP_DEBUG_TRACE,
"send_ldap_response: msgid=%ld tag=%ld err=%ld\n",
(long) msgid, (long) tag, (long) err );
#endif
if( ref ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"send_ldap_response: conn %d ref=\"%s\"\n",
conn ? conn->c_connid : 0,
ref[0] && ref[0]->bv_val ? ref[0]->bv_val : "NULL" ));
#else
Debug( LDAP_DEBUG_ARGS, "send_ldap_response: ref=\"%s\"\n",
ref[0] && ref[0]->bv_val ? ref[0]->bv_val : "NULL",
NULL, NULL );
#endif
}
if ( ber == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_ldap_response: conn %d ber_alloc failed\n",
conn ? conn->c_connid : 0 ));
#else
Debug( LDAP_DEBUG_ANY, "ber_alloc failed\n", 0, 0, 0 );
#endif
return;
}
@ -315,7 +344,14 @@ send_ldap_response(
}
if ( rc == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_ldap_response: conn %d ber_printf failed\n",
conn ? conn->c_connid : 0 ));
#else
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
return;
}
@ -325,9 +361,16 @@ send_ldap_response(
ber_free( ber, 1 );
if ( bytes < 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_ldap_response: conn %d ber write failed\n",
conn ? conn->c_connid : 0 ));
#else
Debug( LDAP_DEBUG_ANY,
"send_ldap_response: ber write failed\n",
0, 0, 0 );
#endif
return;
}
@ -358,9 +401,16 @@ send_ldap_disconnect(
assert( LDAP_UNSOLICITED_ERROR( err ) );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_ldap_disconnect: conn %d %d:%s\n",
conn ? conn->c_connid : 0, err, text ? text : "" ));
#else
Debug( LDAP_DEBUG_TRACE,
"send_ldap_disconnect %d:%s\n",
err, text ? text : "", NULL );
#endif
if ( op->o_protocol < LDAP_VERSION3 ) {
reqoid = NULL;
@ -400,18 +450,39 @@ send_ldap_result(
assert( !LDAP_API_ERROR( err ) );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_ldap_result : conn %ld op=%ld p=%d\n",
(long)op->o_connid, (long)op->o_opid, op->o_protocol ));
#else
Debug( LDAP_DEBUG_TRACE,
"send_ldap_result: conn=%ld op=%ld p=%d\n",
(long) op->o_connid, (long) op->o_opid, op->o_protocol );
#endif
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"send_ldap_result: conn=%ld err=%d matched=\"%s\" text=\"%s\"\n",
(long)op->o_connid, err, matched ? matched : "", text ? text : "" ));
#else
Debug( LDAP_DEBUG_ARGS,
"send_ldap_result: err=%d matched=\"%s\" text=\"%s\"\n",
err, matched ? matched : "", text ? text : "" );
#endif
if( ref ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"send_ldap_result: referral=\"%s\"\n",
ref[0] && ref[0]->bv_val ? ref[0]->bv_val : "NULL" ));
#else
Debug( LDAP_DEBUG_ARGS,
"send_ldap_result: referral=\"%s\"\n",
ref[0] && ref[0]->bv_val ? ref[0]->bv_val : "NULL",
NULL, NULL );
#endif
}
assert( err != LDAP_PARTIAL_RESULTS );
@ -466,8 +537,15 @@ send_ldap_sasl(
ber_tag_t tag;
ber_int_t msgid;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_ldap_sasl: conn %d err=%ld len=%ld\n",
op->o_connid, (long)err, cred ? cred->bv_len : -1 ));
#else
Debug( LDAP_DEBUG_TRACE, "send_ldap_sasl: err=%ld len=%ld\n",
(long) err, cred ? cred->bv_len : -1, NULL );
#endif
tag = req2res( op->o_tag );
msgid = (tag != LBER_SEQUENCE) ? op->o_msgid : 0;
@ -493,11 +571,19 @@ send_ldap_extended(
ber_tag_t tag;
ber_int_t msgid;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_ldap_extended: conn %d err=%ld oid=%s len=%ld\n",
op->o_connid, (long)err, rspoid ? rspoid : "",
rspdata != NULL ? (long)rspdata->bv_len : (long)0 ));
#else
Debug( LDAP_DEBUG_TRACE,
"send_ldap_extended err=%ld oid=%s len=%ld\n",
(long) err,
rspoid ? rspoid : "",
rspdata != NULL ? (long) rspdata->bv_len : (long) 0 );
#endif
tag = req2res( op->o_tag );
msgid = (tag != LBER_SEQUENCE) ? op->o_msgid : 0;
@ -525,9 +611,17 @@ send_search_result(
char *tmp = NULL;
assert( !LDAP_API_ERROR( err ) );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_search_result: conn %d err=%d matched=\"%s\"\n",
op->o_connid, err, matched ? matched : "",
text ? text : "" ));
#else
Debug( LDAP_DEBUG_TRACE,
"send_search_result: err=%d matched=\"%s\" text=\"%s\"\n",
err, matched ? matched : "", text ? text : "" );
#endif
assert( err != LDAP_PARTIAL_RESULTS );
@ -591,16 +685,31 @@ send_search_entry(
AttributeDescription *ad_entry = slap_schema.si_ad_entry;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_search_entry: conn %d dn=\"%s\"%s\n",
op->o_connid, e->e_dn,
attrsonly ? " (attrsOnly)" : "" ));
#else
Debug( LDAP_DEBUG_TRACE,
"=> send_search_entry: dn=\"%s\"%s\n",
e->e_dn, attrsonly ? " (attrsOnly)" : "", 0 );
#endif
if ( ! access_allowed( be, conn, op, e,
ad_entry, NULL, ACL_READ ) )
{
#ifdef NEW_LOGGING
LDAP_LOG(( "acl", LDAP_LEVEL_INFO,
"send_search_entry: conn %d access to entry (%s) not allowed\n",
op->o_connid, e->e_dn ));
#else
Debug( LDAP_DEBUG_ACL,
"send_search_entry: access to entry not allowed\n",
0, 0, 0 );
#endif
return( 1 );
}
@ -609,7 +718,14 @@ send_search_entry(
ber = ber_alloc_t( LBER_USE_DER );
if ( ber == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_alloc failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_alloc failed\n", 0, 0, 0 );
#endif
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "BER allocation error", NULL, NULL );
goto error_return;
@ -619,7 +735,14 @@ send_search_entry(
LDAP_RES_SEARCH_ENTRY, e->e_dn );
if ( rc == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encoding DN error", NULL, NULL );
@ -659,13 +782,27 @@ send_search_entry(
}
if ( ! access_allowed( be, conn, op, e, desc, NULL, ACL_READ ) ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "acl", LDAP_LEVEL_INFO,
"send_search_entry: conn %d access to attribute %s not allowed\n",
op->o_connid, desc->ad_cname->bv_val ));
#else
Debug( LDAP_DEBUG_ACL, "acl: access to attribute %s not allowed\n",
desc->ad_cname->bv_val, 0, 0 );
#endif
continue;
}
if (( rc = ber_printf( ber, "{s[" /*]}*/ , type )) == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encoding description error", NULL, NULL );
@ -677,15 +814,29 @@ send_search_entry(
if ( ! access_allowed( be, conn, op, e,
desc, a->a_vals[i], ACL_READ ) )
{
#ifdef NEW_LOGGING
LDAP_LOG(( "acl", LDAP_LEVEL_INFO,
"send_search_entry: conn %d access to attribute %s, value %d not allowed\n",
op->o_connid, desc->ad_cname->bv_val, i ));
#else
Debug( LDAP_DEBUG_ACL,
"acl: access to attribute %s, value %d not allowed\n",
desc->ad_cname->bv_val, i, 0 );
#endif
continue;
}
if (( rc = ber_printf( ber, "O", a->a_vals[i] )) == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed.\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY,
"ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encoding values error", NULL, NULL );
@ -695,7 +846,14 @@ send_search_entry(
}
if (( rc = ber_printf( ber, /*{[*/ "]N}" )) == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encode end error", NULL, NULL );
@ -731,14 +889,28 @@ send_search_entry(
}
if ( ! access_allowed( be, conn, op, e, desc, NULL, ACL_READ ) ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "acl", LDAP_LEVEL_INFO,
"send_search_entry: conn %s access to attribute %s not allowed\n",
op->o_connid, desc->ad_cname->bv_val ));
#else
Debug( LDAP_DEBUG_ACL, "acl: access to attribute %s not allowed\n",
desc->ad_cname->bv_val, 0, 0 );
#endif
continue;
}
rc = ber_printf( ber, "{s[" /*]}*/ , desc->ad_cname->bv_val );
if ( rc == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encoding description error", NULL, NULL );
@ -750,16 +922,30 @@ send_search_entry(
if ( ! access_allowed( be, conn, op, e,
desc, a->a_vals[i], ACL_READ ) )
{
#ifdef NEW_LOGGING
LDAP_LOG(( "acl", LDAP_LEVEL_INFO,
"send_search_entry: conn %d access to %s, value %d not allowed\n",
op->o_connid, desc->ad_cname->bv_val, i ));
#else
Debug( LDAP_DEBUG_ACL,
"acl: access to attribute %s, value %d not allowed\n",
desc->ad_cname->bv_val, i, 0 );
#endif
continue;
}
if (( rc = ber_printf( ber, "O", a->a_vals[i] )) == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY,
"ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encoding values error", NULL, NULL );
@ -769,7 +955,14 @@ send_search_entry(
}
if (( rc = ber_printf( ber, /*{[*/ "]N}" )) == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encode end error", NULL, NULL );
@ -782,7 +975,14 @@ send_search_entry(
rc = ber_printf( ber, /*{{{*/ "}N}N}" );
if ( rc == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_entry: conn %d ber_printf failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encode entry end error", NULL, NULL );
@ -793,9 +993,16 @@ send_search_entry(
ber_free( ber, 1 );
if ( bytes < 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_ldap_response: conn %d ber write failed.\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY,
"send_ldap_response: ber write failed\n",
0, 0, 0 );
#endif
return -1;
}
@ -808,7 +1015,14 @@ send_search_entry(
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 );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_search_entry: conn %d exit.\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_TRACE, "<= send_search_entry\n", 0, 0, 0 );
#endif
rc = 0;
@ -835,32 +1049,60 @@ send_search_reference(
AttributeDescription *ad_ref = slap_schema.si_ad_ref;
AttributeDescription *ad_entry = slap_schema.si_ad_entry;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_search_reference: conn %d dn=\"%s\"\n",
op->o_connid, e->e_dn ));
#else
Debug( LDAP_DEBUG_TRACE,
"=> send_search_reference: dn=\"%s\"\n",
e->e_dn, 0, 0 );
#endif
if ( ! access_allowed( be, conn, op, e,
ad_entry, NULL, ACL_READ ) )
{
#ifdef NEW_LOGGING
LDAP_LOG(( "acl", LDAP_LEVEL_INFO,
"send_search_reference: conn %d access to entry %s not allowed\n",
op->o_connid, e->e_dn ));
#else
Debug( LDAP_DEBUG_ACL,
"send_search_reference: access to entry not allowed\n",
0, 0, 0 );
#endif
return( 1 );
}
if ( ! access_allowed( be, conn, op, e,
ad_ref, NULL, ACL_READ ) )
{
#ifdef NEW_LOGGING
LDAP_LOG(( "acl", LDAP_LEVEL_INFO,
"send_search_reference: conn %d access to reference not allowed.\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ACL,
"send_search_reference: access to reference not allowed\n",
0, 0, 0 );
#endif
return( 1 );
}
if( refs == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_reference: null ref in (%s).\n",
op->o_connid, e->e_dn ));
#else
Debug( LDAP_DEBUG_ANY,
"send_search_reference: null ref in (%s)\n",
e->e_dn, 0, 0 );
#endif
return( 1 );
}
@ -875,8 +1117,15 @@ send_search_reference(
ber = ber_alloc_t( LBER_USE_DER );
if ( ber == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_reference: conn %d ber_alloc failed\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY,
"send_search_reference: ber_alloc failed\n", 0, 0, 0 );
#endif
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "alloc BER error", NULL, NULL );
return -1;
@ -886,8 +1135,15 @@ send_search_reference(
LDAP_RES_SEARCH_REFERENCE, refs );
if ( rc == -1 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ERR,
"send_search_reference: conn %d ber_printf failed.\n",
op->o_connid ));
#else
Debug( LDAP_DEBUG_ANY,
"send_search_reference: ber_printf failed\n", 0, 0, 0 );
#endif
ber_free( ber, 1 );
send_ldap_result( conn, op, LDAP_OTHER,
NULL, "encode DN error", NULL, NULL );
@ -906,7 +1162,13 @@ send_search_reference(
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 );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"send_search_reference: conn %d exit.\n", op->o_connid ));
#else
Debug( LDAP_DEBUG_TRACE, "<= send_search_reference\n", 0, 0, 0 );
#endif
return 0;
}
@ -928,8 +1190,14 @@ str2result(
*info = NULL;
if ( strncasecmp( s, "RESULT", 6 ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"str2result: (%s), expecting \"RESULT\"\n", s ));
#else
Debug( LDAP_DEBUG_ANY, "str2result (%s) expecting \"RESULT\"\n",
s, 0, 0 );
#endif
return( -1 );
}
@ -957,8 +1225,14 @@ str2result(
*info = c;
}
} else {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"str2result: (%s) unknown.\n", s ));
#else
Debug( LDAP_DEBUG_ANY, "str2result (%s) unknown\n",
s, 0, 0 );
#endif
rc = -1;
}
}

115
servers/slapd/sasl.c
View File

@ -59,9 +59,17 @@ slap_sasl_log(
return SASL_BADPARAM;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"SASL [conn=%d] %s: %s\n",
conn ? conn->c_connid : -1,
label, message ));
#else
Debug( level, "SASL [conn=%d] %s: %s\n",
conn ? conn->c_connid: -1,
label, message );
#endif
return SASL_OK;
}
@ -80,8 +88,16 @@ int slap_sasl_getdn( Connection *conn, char *id, char **dnptr, int flags )
sasl_conn_t *ctx;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_getdn: conn %d id=%s\n",
conn ? conn->c_connid : -1,
id ? (*id ? id : "<empty>") : "NULL" ));
#else
Debug( LDAP_DEBUG_ARGS, "slap_sasl_getdn: id=%s\n",
id?(*id?id:"<empty>"):"NULL",0,0 );
#endif
/* Blatantly anonymous ID */
len = strlen( "anonymous" );
@ -119,8 +135,14 @@ int slap_sasl_getdn( Connection *conn, char *id, char **dnptr, int flags )
/* Figure out how much data we have for the dn */
rc = sasl_getprop( ctx, SASL_REALM, (void **)&c );
if( rc != SASL_OK ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ERR,
"slap_sasl_getdn: getprop(REALM) failed.\n" ));
#else
Debug(LDAP_DEBUG_TRACE,
"getdn: getprop(REALM) failed!\n", 0,0,0);
#endif
ch_free( dn );
*dnptr = NULL;
return( LDAP_OPERATIONS_ERROR );
@ -146,7 +168,13 @@ int slap_sasl_getdn( Connection *conn, char *id, char **dnptr, int flags )
}
strcpy( dn+len, ",cn=authzid" );
len += len1;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"getdn: u:id converted to %s.\n", dn ));
#else
Debug( LDAP_DEBUG_TRACE, "getdn: u:id converted to %s\n", dn,0,0 );
#endif
}
/* DN strings that are a cn=authzid identity to run through regexp */
@ -162,7 +190,13 @@ int slap_sasl_getdn( Connection *conn, char *id, char **dnptr, int flags )
sprintf( dn, "dn:%s", c1 );
ch_free( c1 );
}
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_getdn: dn:id converted to %s.\n", dn ));
#else
Debug( LDAP_DEBUG_TRACE, "getdn: dn:id converted to %s\n", dn,0,0 );
#endif
}
}
@ -190,11 +224,20 @@ slap_sasl_authorize(
*user = NULL;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sas_authorize: conn %d authcid=\"%s\" authzid=\"%s\"\n",
conn ? conn->c_connid : -1,
authcid ? authcid : "<empty>",
authzid ? authzid : "<empty>" ));
#else
Debug( LDAP_DEBUG_ARGS, "SASL Authorize [conn=%ld]: "
"authcid=\"%s\" authzid=\"%s\"\n",
(long) (conn ? conn->c_connid : -1),
authcid ? authcid : "<empty>",
authzid ? authzid : "<empty>" );
#endif
/* Convert the identities to DN's. If no authzid was given, client will
be bound as the DN matching their username */
@ -204,8 +247,15 @@ slap_sasl_authorize(
return SASL_NOAUTHZ;
}
if( ( authzid == NULL ) || !strcmp( authcid,authzid ) ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_authorize: conn %d Using authcDN=%s\n",
conn ? conn->c_connid : -1, authcDN ));
#else
Debug( LDAP_DEBUG_TRACE, "SASL Authorize [conn=%ld]: "
"Using authcDN=%s\n", (long) (conn ? conn->c_connid : -1), authcDN,0 );
#endif
*user = authcDN;
*errstr = NULL;
return SASL_OK;
@ -219,18 +269,32 @@ slap_sasl_authorize(
rc = slap_sasl_authorized( authcDN, authzDN );
if( rc ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_INFO,
"slap_sasl_authorize: conn %ld authorization disallowed (%d)\n",
(long)(conn ? conn->c_connid : -1), rc ));
#else
Debug( LDAP_DEBUG_TRACE, "SASL Authorize [conn=%ld]: "
" authorization disallowed (%d)\n",
(long) (conn ? conn->c_connid : -1), rc, 0 );
#endif
*errstr = "not authorized";
ch_free( authcDN );
ch_free( authzDN );
return SASL_NOAUTHZ;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_authorize: conn %d authorization allowed\n",
(long)(conn ? conn->c_connid : -1 ) );
#else
Debug( LDAP_DEBUG_TRACE, "SASL Authorize [conn=%ld]: "
" authorization allowed\n",
(long) (conn ? conn->c_connid : -1), 0, 0 );
#endif
ch_free( authcDN );
*user = authzDN;
@ -303,13 +367,25 @@ int slap_sasl_init( void )
rc = sasl_server_init( server_callbacks, "slapd" );
if( rc != SASL_OK ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_INFO,
"slap_sasl_init: init failed.\n" ));
#else
Debug( LDAP_DEBUG_ANY, "sasl_server_init failed\n",
0, 0, 0 );
#endif
return -1;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_INFO,
"slap_sasl_init: initialized!\n"));
#else
Debug( LDAP_DEBUG_TRACE, "slap_sasl_init: initialized!\n",
0, 0, 0 );
#endif
/* default security properties */
memset( &sasl_secprops, '\0', sizeof(sasl_secprops) );
@ -367,8 +443,14 @@ int slap_sasl_open( Connection *conn )
session_callbacks, SASL_SECURITY_LAYER, &ctx );
if( sc != SASL_OK ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ERR,
"slap_sasl_open: sasl_server_new failed: %d\n", sc ));
#else
Debug( LDAP_DEBUG_ANY, "sasl_server_new failed: %d\n",
sc, 0, 0 );
#endif
return -1;
}
@ -379,8 +461,14 @@ int slap_sasl_open( Connection *conn )
SASL_SEC_PROPS, &sasl_secprops );
if( sc != SASL_OK ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ERR,
"slap_sasl_open: sasl_setprop failed: %d \n", sc ));
#else
Debug( LDAP_DEBUG_ANY, "sasl_setprop failed: %d\n",
sc, 0, 0 );
#endif
slap_sasl_close( conn );
return -1;
}
@ -448,8 +536,14 @@ char ** slap_sasl_mechs( Connection *conn )
&mechstr, NULL, NULL );
if( sc != SASL_OK ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ERR,
"slap_sasl_mechs: sasl_listmech failed: %d\n", sc ));
#else
Debug( LDAP_DEBUG_ANY, "slap_sasl_listmech failed: %d\n",
sc, 0, 0 );
#endif
return NULL;
}
@ -498,10 +592,19 @@ int slap_sasl_bind(
const char *errstr;
int sc;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"sasl_bind: conn %ld dn=\"%s\" mech=%s datalen=%d\n",
conn->c_connid, dn,
conn->c_sasl_bind_in_progress ? "<continuing>" : conn->c_sasl_bind_mech,
cred ? cred->bv_len : 0 ));
#else
Debug(LDAP_DEBUG_ARGS,
"==> sasl_bind: dn=\"%s\" mech=%s datalen=%d\n", dn,
conn->c_sasl_bind_in_progress ? "<continuing>":conn->c_sasl_bind_mech,
cred ? cred->bv_len : 0 );
#endif
if( ctx == NULL ) {
send_ldap_result( conn, op, LDAP_UNAVAILABLE,
@ -530,9 +633,15 @@ int slap_sasl_bind(
SASL_USERNAME, (void **)&username );
if ( sc != SASL_OK ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ERR,
"slap_sasl_bind: getprop(USERNAME) failed: %d\n", sc ));
#else
Debug(LDAP_DEBUG_TRACE,
"slap_sasl_bind: getprop(USERNAME) failed!\n",
0, 0, 0);
#endif
send_ldap_result( conn, op, rc = slap_sasl_err2ldap( sc ),
NULL, "no SASL username", NULL, NULL );
@ -580,7 +689,13 @@ int slap_sasl_bind(
NULL, errstr, NULL, NULL );
}
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_bind: rc=%d\n", rc ));
#else
Debug(LDAP_DEBUG_TRACE, "<== slap_sasl_bind: rc=%d\n", rc, 0, 0);
#endif
#else
send_ldap_result( conn, op, rc = LDAP_UNAVAILABLE,

101
servers/slapd/saslauthz.c
View File

@ -42,7 +42,13 @@ int slap_parseURI( char *uri, char **searchbase, int *scope, Filter **filter )
*scope = -1;
*filter = NULL;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_parseURI: parsing %s\n", uri ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_parseURI: parsing %s\n", uri, 0, 0 );
#endif
/* If it does not look like a URI, assume it is a DN */
if( !strncasecmp( uri, "dn:", 3 ) ) {
@ -134,9 +140,16 @@ int slap_sasl_regexp_config( const char *match, const char *replace )
/* Precompile matching pattern */
rc = regcomp( &reg->workspace, reg->match, REG_EXTENDED|REG_ICASE );
if ( rc ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ERR,
"slap_sasl_regexp_config: \"%s\" could not be compiled.\n"
reg->match ));
#else
Debug( LDAP_DEBUG_ANY,
"SASL match pattern %s could not be compiled by regexp engine\n",
reg->match, 0, 0 );
#endif
return( LDAP_OPERATIONS_ERROR );
}
@ -150,9 +163,16 @@ int slap_sasl_regexp_config( const char *match, const char *replace )
}
if ( *c == '$' ) {
if ( n == SASLREGEX_REPLACE ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ERR,
"slap_sasl_regexp_config: \"%s\" has too many $n placeholders (max %d)\n",
reg->replace, SASLREGEX_REPLACE ));
#else
Debug( LDAP_DEBUG_ANY,
"SASL replace pattern %s has too many $n placeholders (max %d)\n",
reg->replace, SASLREGEX_REPLACE, 0 );
#endif
return( LDAP_OPERATIONS_ERROR );
}
reg->offset[n] = c - reg->replace;
@ -189,8 +209,14 @@ char *slap_sasl_regexp( char *saslname )
SaslRegexp_t *reg;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_regexp: converting SASL name %s\n", saslname ));
#else
Debug( LDAP_DEBUG_TRACE, "slap_sasl_regexp: converting SASL name %s\n",
saslname, 0, 0 );
#endif
if (( saslname == NULL ) || ( nSaslRegexp == 0 ))
return( NULL );
@ -249,8 +275,14 @@ char *slap_sasl_regexp( char *saslname )
}
uri[insert] = '\0';
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_regexp: converted SASL name to %s\n", uri ));
#else
Debug( LDAP_DEBUG_TRACE,
"slap_sasl_regexp: converted SASL name to %s\n", uri, 0, 0 );
#endif
return( uri );
}
@ -278,8 +310,14 @@ char *slap_sasl2dn( char *saslname )
LDAPMessage *res=NULL, *msg;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl2dn: converting SASL name %s to DN.\n", saslname ));
#else
Debug( LDAP_DEBUG_TRACE,
"==>slap_sasl2dn: Converting SASL name %s to a DN\n", saslname, 0,0 );
#endif
/* Convert the SASL name into an LDAP URI */
uri = slap_sasl_regexp( saslname );
@ -298,9 +336,16 @@ char *slap_sasl2dn( char *saslname )
/* Must do an internal search */
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_DETAIL1,
"slap_sasl2dn: performing internal search (base=%s, scope=%s)\n",
searchbase, scope ));
#else
Debug( LDAP_DEBUG_TRACE,
"slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
searchbase, scope, 0 );
#endif
be = select_backend( searchbase, 0 );
if(( be == NULL ) || ( be->be_search == NULL))
@ -323,8 +368,14 @@ char *slap_sasl2dn( char *saslname )
/* Make sure exactly one entry was returned */
rc = ldap_count_entries( client, res );
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_DETAIL1,
"slap_sasl2dn: search DN returned %d entries\n", rc ));
#else
Debug( LDAP_DEBUG_TRACE,
"slap_sasl2dn: search DN returned %d entries\n", rc,0,0 );
#endif
if( rc != 1 )
goto FINISHED;
@ -339,8 +390,14 @@ FINISHED:
if( res ) ldap_msgfree( res );
if( client ) ldap_unbind( client );
if( DN ) dn_normalize( DN );
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl2dn: Converted SASL name to %s\n", DN ? DN : "<nothing>" ));
#else
Debug( LDAP_DEBUG_TRACE, "<==slap_sasl2dn: Converted SASL name to %s\n",
DN ? DN : "<nothing>", 0, 0 );
#endif
return( DN );
}
@ -370,8 +427,14 @@ int slap_sasl_match( char *rule, char *assertDN, char *authc )
regex_t reg;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_match: comparing DN %s to rule %s\n", assertDN, rule );
#else
Debug( LDAP_DEBUG_TRACE,
"===>slap_sasl_match: comparing DN %s to rule %s\n", assertDN, rule, 0 );
#endif
rc = slap_parseURI( rule, &searchbase, &scope, &filter );
if( rc != LDAP_SUCCESS )
@ -394,9 +457,16 @@ int slap_sasl_match( char *rule, char *assertDN, char *authc )
/* Must run an internal search. */
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_DETAIL1,
"slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
searchbase, scope ));
#else
Debug( LDAP_DEBUG_TRACE,
"slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
searchbase, scope, 0 );
#endif
be = select_backend( searchbase, 0 );
if(( be == NULL ) || ( be->be_search == NULL)) {
@ -441,8 +511,14 @@ CONCLUDED:
if( conn ) connection_internal_close( conn );
if( res ) ldap_msgfree( res );
if( client ) ldap_unbind( client );
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_match: comparison returned %d\n", rc ));
#else
Debug( LDAP_DEBUG_TRACE,
"<===slap_sasl_match: comparison returned %d\n", rc, 0, 0);
#endif
return( rc );
}
@ -468,9 +544,16 @@ slap_sasl_check_authz(char *searchDN, char *assertDN, char *attr, char *authc)
AttributeDescription *ad=NULL;
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_check_authz: does %s match %s rule in %s?\n",
assertDN, attr, searchDN ));
#else
Debug( LDAP_DEBUG_TRACE,
"==>slap_sasl_check_authz: does %s match %s rule in %s?\n",
assertDN, attr, searchDN);
#endif
rc = slap_str2ad( attr, &ad, &errmsg );
if( rc != LDAP_SUCCESS )
goto COMPLETE;
@ -491,8 +574,14 @@ COMPLETE:
if( vals ) ber_bvecfree( vals );
if( ad ) ad_free( ad, 1 );
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_check_authz: %s check returning %s\n", attr, rc ));
#else
Debug( LDAP_DEBUG_TRACE,
"<==slap_sasl_check_authz: %s check returning %d\n", attr, rc, 0);
#endif
return( rc );
}
@ -518,8 +607,14 @@ int slap_sasl_authorized( char *authcDN, char *authzDN )
goto DONE;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_authorized: can %s become %s?\n", authcDN, authzDN ));
#else
Debug( LDAP_DEBUG_TRACE,
"==>slap_sasl_authorized: can %s become %s?\n", authcDN, authzDN, 0 );
#endif
/* If person is authorizing to self, succeed */
if ( !strcmp( authcDN, authzDN ) ) {
@ -543,6 +638,12 @@ int slap_sasl_authorized( char *authcDN, char *authzDN )
rc = LDAP_INAPPROPRIATE_AUTH;
DONE:
#ifdef NEW_LOGGING
LDAP_LOG(( "sasl", LDAP_LEVEL_ENTRY,
"slap_sasl_authorized: return %s\n", rc ));
#else
Debug( LDAP_DEBUG_TRACE, "<== slap_sasl_authorized: return %d\n",rc,0,0 );
#endif
return( rc );
}

40
servers/slapd/schema_check.c
View File

@ -40,8 +40,14 @@ entry_schema_check(
/* find the object class attribute - could error out here */
if ( (aoc = attr_find( e->e_attrs, ad_objectClass )) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
"entry_schema_check: No object class for entry (%s).\n", e->e_dn ));
#else
Debug( LDAP_DEBUG_ANY, "No object class for entry (%s)\n",
e->e_dn, 0, 0 );
#endif
*text = "no objectClass attribute";
return LDAP_OBJECT_CLASS_VIOLATION;
}
@ -51,9 +57,16 @@ entry_schema_check(
/* check that the entry has required attrs for each oc */
for ( i = 0; aoc->a_vals[i] != NULL; i++ ) {
if ( (oc = oc_find( aoc->a_vals[i]->bv_val )) == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
"entry_schema_check: dn (%s), objectclass \"%s\" not recognized\n",
e->e_dn, aoc->a_vals[i]->bv_val ));
#else
Debug( LDAP_DEBUG_ANY,
"entry_check_schema(%s): objectclass \"%s\" not recognized\n",
e->e_dn, aoc->a_vals[i]->bv_val, 0 );
#endif
*text = "unrecognized object class";
return LDAP_OBJECT_CLASS_VIOLATION;
@ -61,9 +74,16 @@ entry_schema_check(
char *s = oc_check_required( e, aoc->a_vals[i] );
if (s != NULL) {
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
"entry_schema_check: dn (%s) oc \"%s\" requires att \"%s\"\n",
e->e_dn, aoc->a_vals[i]->bv_val, s ));
#else
Debug( LDAP_DEBUG_ANY,
"Entry (%s), oc \"%s\" requires attr \"%s\"\n",
e->e_dn, aoc->a_vals[i]->bv_val, s );
#endif
*text = "missing required attribute";
return LDAP_OBJECT_CLASS_VIOLATION;
}
@ -84,9 +104,16 @@ entry_schema_check(
ret = oc_check_allowed( a->a_desc->ad_type, aoc->a_vals );
if ( ret != 0 ) {
char *type = a->a_desc->ad_cname->bv_val;
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_INFO,
"entry_schema_check: Entry (%s) attr \"%s\" not allowed.\n",
e->e_dn, type ));
#else
Debug( LDAP_DEBUG_ANY,
"Entry (%s), attr \"%s\" not allowed\n",
e->e_dn, type, 0 );
#endif
*text = "attribute not allowed";
break;
}
@ -103,9 +130,16 @@ oc_check_required( Entry *e, struct berval *ocname )
int i;
Attribute *a;
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
"oc_check_required: dn (%s), objectclass \"%s\"\n",
e->e_dn, ocname->bv_val ));
#else
Debug( LDAP_DEBUG_TRACE,
"oc_check_required entry (%s), objectclass \"%s\"\n",
e->e_dn, ocname->bv_val, 0 );
#endif
/* find global oc defn. it we don't know about it assume it's ok */
if ( (oc = oc_find( ocname->bv_val )) == NULL ) {
@ -142,9 +176,15 @@ int oc_check_allowed(
ObjectClass *oc;
int i, j;
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
"oc_check_allowed: type \"%s\"\n", at->sat_cname ));
#else
Debug( LDAP_DEBUG_TRACE,
"oc_check_allowed type \"%s\"\n",
at->sat_cname, 0, 0 );
#endif
/* always allow objectclass attribute */
if ( strcasecmp( at->sat_cname, "objectclass" ) == 0 ) {

14
servers/slapd/schema_init.c
View File

@ -289,8 +289,15 @@ dnMatch(
#endif
}
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
"dnMatch: %d\n %s\n %s\n", match,
value->bv_val, asserted->bv_val ));
#else
Debug( LDAP_DEBUG_ARGS, "dnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
match, value->bv_val, asserted->bv_val );
#endif
*matchp = match;
return LDAP_SUCCESS;
@ -3735,9 +3742,16 @@ objectIdentifierFirstComponentMatch(
ch_free( stored );
}
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
"objectIdentifierFirstComponentMatch: %d\n %s\n %s\n",
match, value->bv_val, asserted->bv_val ));
#else
Debug( LDAP_DEBUG_ARGS, "objectIdentifierFirstComponentMatch "
"%d\n\t\"%s\"\n\t\"%s\"\n",
match, value->bv_val, asserted->bv_val );
#endif
if( rc == LDAP_SUCCESS ) *matchp = match;
return rc;

14
servers/slapd/schema_prep.c
View File

@ -60,8 +60,15 @@ objectClassMatch(
}
#if 0
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
"objectClassMatch(%s, %s) = %d\n",
value->bv_val, a->bv_val, *matchp ));
#else
Debug( LDAP_DEBUG_TRACE, "objectClassMatch(%s,%s) = %d\n",
value->bv_val, a->bv_val, *matchp );
#endif
#endif
return LDAP_SUCCESS;
@ -102,8 +109,15 @@ structuralObjectClassMatch(
*matchp = ( asserted != oc );
#if 0
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
"structuralObjectClassMatch( %s, %s ) = %d\n",
value->bv_val, a->bv_val, *matchp ));
#else
Debug( LDAP_DEBUG_TRACE, "structuralObjectClassMatch(%s,%s) = %d\n",
value->bv_val, a->bv_val, *matchp );
#endif
#endif
return LDAP_SUCCESS;

44
servers/slapd/search.c
View File

@ -41,9 +41,13 @@ do_search(
const char *text;
int manageDSAit;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"do_search: conn %d\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_TRACE, "do_search\n", 0, 0, 0 );
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, "conn: %d do_search\n",
conn->c_connid));
#endif
/*
* Parse the search request. It looks like this:
*
@ -109,9 +113,15 @@ do_search(
goto return_results;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"do_search \"%s\" %d %d %d %d %d\n", base, scope,
deref, sizelimit, timelimit, attrsonly ));
#else
Debug( LDAP_DEBUG_ARGS, "SRCH \"%s\" %d %d", base, scope, deref );
Debug( LDAP_DEBUG_ARGS, " %d %d %d\n", sizelimit, timelimit,
attrsonly);
#endif
/* filter - returns a "normalized" version */
rc = get_filter( conn, op->o_ber, &filter, &fstr, &text );
@ -126,7 +136,13 @@ do_search(
goto return_results;
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"do_search: conn %d filter: %s\n", conn->c_connid, fstr ));
#else
Debug( LDAP_DEBUG_ARGS, " filter: %s\n", fstr, 0, 0 );
#endif
/* attributes */
if ( ber_scanf( op->o_ber, /*{*/ "{v}}", &attrs ) == LBER_ERROR ) {
@ -137,21 +153,45 @@ do_search(
}
if( (rc = get_ctrls( conn, op, 1 )) != LDAP_SUCCESS ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"do_search: conn %d get_ctrls failed (%d)\n",
conn->c_connid, rc ));
#else
Debug( LDAP_DEBUG_ANY, "do_search: get_ctrls failed\n", 0, 0, 0 );
#endif
goto return_results;
}
rc = 0;
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"do_search: conn %d attrs:", conn->c_connid ));
#else
Debug( LDAP_DEBUG_ARGS, " attrs:", 0, 0, 0 );
#endif
if ( attrs != NULL ) {
for ( i = 0; attrs[i] != NULL; i++ ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"do_search: %s", attrs[i] ));
#else
Debug( LDAP_DEBUG_ARGS, " %s", attrs[i], 0, 0 );
#endif
}
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS, "\n" ));
#else
Debug( LDAP_DEBUG_ARGS, "\n", 0, 0, 0 );
#endif
Statslog( LDAP_DEBUG_STATS,
"conn=%ld op=%d SRCH base=\"%s\" scope=%d filter=\"%s\"\n",

54
servers/slapd/str2filter.c
View File

@ -27,7 +27,13 @@ str2filter( const char *str )
Filter *f = NULL;
char *end, *freeme;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"str2filter: \"%s\"\n", str ));
#else
Debug( LDAP_DEBUG_FILTER, "str2filter \"%s\"\n", str, 0, 0 );
#endif
if ( str == NULL || *str == '\0' ) {
return( NULL );
@ -47,32 +53,56 @@ str2filter( const char *str )
str++;
switch ( *str ) {
case '&':
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"str2filter: AND\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "str2filter: AND\n",
0, 0, 0 );
#endif
str++;
f = str2list( str, LDAP_FILTER_AND );
break;
case '|':
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"str2filter: OR\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "put_filter: OR\n",
0, 0, 0 );
#endif
str++;
f = str2list( str, LDAP_FILTER_OR );
break;
case '!':
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"str2filter: NOT\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "put_filter: NOT\n",
0, 0, 0 );
#endif
str++;
f = str2list( str, LDAP_FILTER_NOT );
break;
default:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"str2filter: simple\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "str2filter: simple\n",
0, 0, 0 );
#endif
f = str2simple( str );
break;
@ -81,8 +111,14 @@ str2filter( const char *str )
break;
default: /* assume it's a simple type=value filter */
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
"str2filter: default\n" ));
#else
Debug( LDAP_DEBUG_FILTER, "str2filter: default\n", 0, 0,
0 );
#endif
f = str2simple( str );
break;
@ -104,7 +140,13 @@ str2list( const char *str, unsigned long ftype )
char *next;
char save;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"str2list: \"%s\"\n", str ));
#else
Debug( LDAP_DEBUG_FILTER, "str2list \"%s\"\n", str, 0, 0 );
#endif
f = (Filter *) ch_calloc( 1, sizeof(Filter) );
f->f_choice = ftype;
@ -148,7 +190,13 @@ str2simple( const char *str )
int rc;
const char *text;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"str2simple: \"%s\"\n", str ));
#else
Debug( LDAP_DEBUG_FILTER, "str2simple \"%s\"\n", str, 0, 0 );
#endif
if ( (s = strchr( str, '=' )) == NULL ) {
return( NULL );
@ -240,7 +288,13 @@ str2subvals( const char *in, Filter *f )
char *nextstar, *val, *freeme;
int gotstar;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
"str2subvals: \"%s\"\n", in ));
#else
Debug( LDAP_DEBUG_FILTER, "str2subvals \"%s\"\n", in, 0, 0 );
#endif
if( in == NULL ) return 0;

7
servers/slapd/suffixalias.c
View File

@ -63,9 +63,16 @@ char *suffix_alias(
dn = ch_malloc( diff + strlen(be->be_suffixAlias[i+1]) + 1 );
strncpy( dn, oldDN, diff );
strcpy( &dn[diff], be->be_suffixAlias[i+1] );
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"suffix_alias: converted \"%s\" to \"%s\"\n",
oldDN, dn ));
#else
Debug( LDAP_DEBUG_ARGS,
"suffix_alias: converted \"%s\" to \"%s\"\n",
oldDN, dn, 0);
#endif
free (oldDN);
break;
}

21
servers/slapd/syntax.c
View File

@ -150,8 +150,15 @@ register_syntax(
syn = ldap_str2syntax( desc, &code, &err, LDAP_SCHEMA_ALLOW_ALL);
if ( !syn ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ERR,
"register_syntax: Error - %s before %s in %s.\n",
ldap_scherr2str(code), err, desc ));
#else
Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s before %s in %s\n",
ldap_scherr2str(code), err, desc );
#endif
return( -1 );
}
@ -160,8 +167,15 @@ register_syntax(
ldap_memfree( syn );
if ( code ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ERR,
"register_syntax: Error - %s %s in %s\n",
scherr2str(code), err, desc ));
#else
Debug( LDAP_DEBUG_ANY, "Error in register_syntax: %s %s in %s\n",
scherr2str(code), err, desc );
#endif
return( -1 );
}
@ -198,8 +212,15 @@ syn_schema_info( Entry *e )
}
val.bv_len = strlen( val.bv_val );
#if 0
#ifdef NEW_LOGGING
LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
"syn_schema_info: Merging syn [%ld] %s\n",
(long)val.bv_len, val.bv_val ));
#else
Debug( LDAP_DEBUG_TRACE, "Merging syn [%ld] %s\n",
(long) val.bv_len, val.bv_val, 0 );
#endif
#endif
attr_merge( e, ad_ldapSyntaxes, vals );
ldap_memfree( val.bv_val );

6
servers/slapd/unbind.c
View File

@ -33,7 +33,13 @@ do_unbind(
Operation *op
)
{
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY,
"do_unbind: conn %d\n", conn ? conn->c_connid : -1 ));
#else
Debug( LDAP_DEBUG_TRACE, "do_unbind\n", 0, 0, 0 );
#endif
/*
* Parse the unbind request. It looks like this:

43
servers/slapd/user.c
View File

@ -63,8 +63,15 @@ slap_init_user( char *user, char *group )
pwd = getpwnam( user );
did_getpw:
if ( pwd == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_init_user: No passwd entry for user %s\n",
user ));
#else
Debug( LDAP_DEBUG_ANY, "No passwd entry for user %s\n",
user, 0, 0 );
#endif
exit( EXIT_FAILURE );
}
if ( got_uid ) {
@ -96,8 +103,14 @@ slap_init_user( char *user, char *group )
gid = grp->gr_gid;
did_group:
if ( grp == NULL ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_init_user: No group entry for group %s\n", group));
#else
Debug( LDAP_DEBUG_ANY, "No group entry for group %s\n",
group, 0, 0 );
#endif
exit( EXIT_FAILURE );
}
}
@ -107,8 +120,14 @@ slap_init_user( char *user, char *group )
if ( user ) {
if ( getuid() == 0 && initgroups( user, gid ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_init_user: Could not set the group access (gid) list.\n" ));
#else
Debug( LDAP_DEBUG_ANY,
"Could not set the group access (gid) list\n", 0, 0, 0 );
#endif
exit( EXIT_FAILURE );
}
free( user );
@ -120,14 +139,26 @@ slap_init_user( char *user, char *group )
if ( got_gid ) {
if ( setgid( gid ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_init_user: could not set real group id to %d\n", (int)gid));
#else
Debug( LDAP_DEBUG_ANY, "Could not set real group id to %d\n",
(int) gid, 0, 0 );
#endif
exit( EXIT_FAILURE );
}
#ifdef HAVE_SETEGID
if ( setegid( gid ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_init_user: Could not set effective group id to %d\n",(int)gid));
#else
Debug( LDAP_DEBUG_ANY, "Could not set effective group id to %d\n",
(int) gid, 0, 0 );
#endif
exit( EXIT_FAILURE );
}
#endif
@ -135,14 +166,26 @@ slap_init_user( char *user, char *group )
if ( got_uid ) {
if ( setuid( uid ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_init_user: Could not set real user id to %d\n", (int)uid ));
#else
Debug( LDAP_DEBUG_ANY, "Could not set real user id to %d\n",
(int) uid, 0, 0 );
#endif
exit( EXIT_FAILURE );
}
#ifdef HAVE_SETEUID
if ( seteuid( uid ) != 0 ) {
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_INFO,
"slap_init_user: Could not set effective user id to %d\n", (int)uid ));
#else
Debug( LDAP_DEBUG_ANY, "Could not set effective user id to %d\n",
(int) uid, 0, 0 );
#endif
exit( EXIT_FAILURE );
}
#endif