/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
static ber_socket_t wake_sds[2];
static int emfile;
-static int waking;
+static volatile int waking;
#define WAKE_LISTENER(w) do { \
- if ((w) && waking < 5) { \
- waking++; \
+ if ((w) && ++waking < 5) { \
tcp_write( wake_sds[1], "0", 1 ); \
} \
} while(0)
static struct slap_daemon {
ldap_pvt_thread_mutex_t sd_mutex;
+#ifdef HAVE_TCPD
+ ldap_pvt_thread_mutex_t tcpd_mutex;
+#endif
ber_socket_t sd_nactives;
int sd_nwriters;
# define SLAP_EVENT_IS_READ(i) SLAP_CHK_EVENT((i), EPOLLIN)
# define SLAP_EVENT_IS_WRITE(i) SLAP_CHK_EVENT((i), EPOLLOUT)
# define SLAP_EVENT_IS_LISTENER(i) SLAP_EV_LISTENER(revents[(i)].data.ptr)
-# define SLAP_EVENT_LISTENER(i) (revents[(i)].data.ptr)
+# define SLAP_EVENT_LISTENER(i) ((Listener *)(revents[(i)].data.ptr))
# define SLAP_EVENT_FD(i) SLAP_EV_PTRFD(revents[(i)].data.ptr)
if (!SLAP_SOCK_IS_WRITE(fd)) { FD_SET((fd), &slap_daemon.sd_writers); } \
} while(0)
-# define SLAP_ADDTEST(s) do { } while 0
+# define SLAP_ADDTEST(s)
# define SLAP_EVENT_MAX dtblsize
# else
# define SLAP_SOCK_SET_READ(fd) FD_SET((fd), &slap_daemon.sd_readers)
#endif
}
+void slapd_sd_lock()
+{
+ ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+}
+
+void slapd_sd_unlock()
+{
+ ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
+}
+
/*
* Remove the descriptor from daemon control
*/
void slapd_remove(
ber_socket_t s,
int wasactive,
- int wake )
+ int wake,
+ int locked )
{
int waswriter;
int wasreader;
- ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+ if ( !locked )
+ ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
+
+ assert( SLAP_SOCK_IS_ACTIVE( s ));
if ( wasactive ) slap_daemon.sd_nactives--;
WAKE_LISTENER(wake);
}
-void slapd_clr_read(ber_socket_t s, int wake) {
+int slapd_clr_read(ber_socket_t s, int wake) {
+ int rc = 1;
ldap_pvt_thread_mutex_lock( &slap_daemon.sd_mutex );
- assert( SLAP_SOCK_IS_ACTIVE( s ));
- SLAP_SOCK_CLR_READ( s );
-
+ if ( SLAP_SOCK_IS_ACTIVE( s )) {
+ SLAP_SOCK_CLR_READ( s );
+ rc = 0;
+ }
ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
- WAKE_LISTENER(wake);
+ if ( !rc )
+ WAKE_LISTENER(wake);
+ return rc;
}
void slapd_set_read(ber_socket_t s, int wake) {
return -1;
}
-#ifdef LDAP_CONNECTIONLESS
- if( l.sl_is_udp ) {
- long id = connection_init( l.sl_sd, &l, "", "", CONN_IS_UDP,
- (slap_ssf_t) 0, NULL );
-
- if( id < 0 ) {
- Debug( LDAP_DEBUG_TRACE,
- "slap_open_listener: connectionless init failed on %s (%d)\n",
- url, l.sl_sd, 0 );
- return -1;
- }
- l.sl_is_udp++;
- }
-#endif
-
Debug( LDAP_DEBUG_TRACE, "daemon: listener initialized %s\n",
l.sl_url.bv_val, 0, 0 );
return 0;
ldap_charray_free( u );
ldap_pvt_thread_mutex_init( &slap_daemon.sd_mutex );
+#ifdef HAVE_TCPD
+ ldap_pvt_thread_mutex_init( &slap_daemon.tcpd_mutex );
+#endif
+
return !i;
}
}
#endif
+#ifdef HAVE_TCPD
+ ldap_pvt_thread_mutex_destroy( &slap_daemon.tcpd_mutex );
+#endif
+
+ ldap_pvt_thread_mutex_destroy( &slap_daemon.sd_mutex );
return 0;
}
Listener *lr = slap_listeners[l];
if ( lr->sl_sd != AC_SOCKET_INVALID ) {
- if ( remove ) slapd_remove( lr->sl_sd, 0, 0 );
+ if ( remove ) slapd_remove( lr->sl_sd, 0, 0, 0 );
#ifdef LDAP_PF_LOCAL
if ( lr->sl_sa.sa_addr.sa_family == AF_LOCAL ) {
#endif /* SLAPD_RLOOKUPS */
#ifdef HAVE_TCPD
- if ( !hosts_ctl("slapd",
- dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
- peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
- SLAP_STRING_UNKNOWN ))
{
- /* DENY ACCESS */
- Statslog( LDAP_DEBUG_STATS,
- "fd=%ld DENIED from %s (%s)\n",
- (long) s,
+ int rc;
+ ldap_pvt_thread_mutex_lock( &slap_daemon.tcpd_mutex );
+ rc = hosts_ctl("slapd",
dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
- 0, 0 );
- slapd_close(s);
- return 0;
+ SLAP_STRING_UNKNOWN );
+ ldap_pvt_thread_mutex_unlock( &slap_daemon.tcpd_mutex );
+ if ( !rc ) {
+ /* DENY ACCESS */
+ Statslog( LDAP_DEBUG_STATS,
+ "fd=%ld DENIED from %s (%s)\n",
+ (long) s,
+ dnsname != NULL ? dnsname : SLAP_STRING_UNKNOWN,
+ peeraddr != NULL ? peeraddr : SLAP_STRING_UNKNOWN,
+ 0, 0 );
+ slapd_close(s);
+ return 0;
+ }
}
#endif /* HAVE_TCPD */
}
id, (long) s, peername, sl->sl_name.bv_val,
0 );
- slapd_add( s, 1, NULL );
return 0;
}
* listening port. The listen() and accept() calls
* are unnecessary.
*/
- if ( slap_listeners[l]->sl_is_udp ) {
- slapd_add( slap_listeners[l]->sl_sd, 1, slap_listeners[l] );
+ if ( slap_listeners[l]->sl_is_udp )
continue;
- }
#endif
if ( listen( slap_listeners[l]->sl_sd, SLAPD_LISTEN_BACKLOG ) == -1 ) {
}
#ifdef HAVE_NT_SERVICE_MANAGER
- if ( started_event != NULL ) }
+ if ( started_event != NULL ) {
ldap_pvt_thread_cond_signal( &started_event );
}
#endif
ber_socket_t active;
if( slapd_gentle_shutdown == 1 ) {
+ BackendDB *be;
Debug( LDAP_DEBUG_ANY, "slapd gentle shutdown\n", 0, 0, 0 );
close_listeners( 1 );
frontendDB->be_restrictops |= SLAP_RESTRICT_OP_WRITES;
+ LDAP_STAILQ_FOREACH(be, &backendDB, be_next) {
+ be->be_restrictops |= SLAP_RESTRICT_OP_WRITES;
+ }
slapd_gentle_shutdown = 2;
}
active = slap_daemon.sd_nactives;
ldap_pvt_thread_mutex_unlock( &slap_daemon.sd_mutex );
if( active == 0 ) {
- slapd_shutdown = 2;
+ slapd_shutdown = 1;
break;
}
}
if ( lr->sl_sd == AC_SOCKET_INVALID ) continue;
- if ( lr->sl_mute || lr->sl_busy ) {
+#ifdef SLAP_LIGHTWEIGHT_DISPATCHER
+ if ( lr->sl_mute || lr->sl_busy )
+#else
+ if ( lr->sl_mute )
+#endif
+ {
SLAP_SOCK_CLR_READ( lr->sl_sd );
} else {
SLAP_SOCK_SET_READ( lr->sl_sd );
continue;
}
+#ifdef SLAP_LIGHTWEIGHT_DISPATCHER
if ( lr->sl_busy ) {
Debug( LDAP_DEBUG_CONNS,
"daemon: select: listen=%d busy\n",
lr->sl_sd, 0, 0 );
continue;
}
+#endif
Debug( LDAP_DEBUG_CONNS,
"daemon: select: listen=%d active_threads=%d tvp=%s\n",
#if SLAP_EVENTS_ARE_INDEXED
if ( SLAP_EVENT_IS_READ( wake_sds[0] )) {
+ char c[BUFSIZ];
SLAP_EVENT_CLR_READ( wake_sds[0] );
- ns--;
- {
- char c[BUFSIZ];
- tcp_read( wake_sds[0], c, sizeof(c) );
- }
- Debug( LDAP_DEBUG_CONNS, "daemon: waked\n", 0, 0, 0 );
waking = 0;
+ tcp_read( wake_sds[0], c, sizeof(c) );
+ Debug( LDAP_DEBUG_CONNS, "daemon: waked\n", 0, 0, 0 );
continue;
}
* an event, so we could use pointers to the listener structure
* instead of just the file descriptor. For /dev/poll we have to
* search the listeners array for a matching descriptor.
+ *
+ * We now handle wake events when we see them; they are not given
+ * higher priority.
*/
- /* if waking is set and we woke up, we'll read whatever
- * we can.
- */
- if ( waking ) {
- char c[BUFSIZ];
- tcp_read( wake_sds[0], c, sizeof(c) );
- waking = 0;
- ns--;
- continue;
- }
-
#ifdef LDAP_DEBUG
Debug( LDAP_DEBUG_CONNS, "daemon: activity on:", 0, 0, 0 );
r ? "r" : "", w ? "w" : "" );
}
}
+ Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
#endif
for (i=0; i<ns; i++) {
if ( rc ) {
fd = SLAP_EVENT_FD( i );
- /* Ignore wake events, they were handled above */
- if ( fd == wake_sds[0] ) continue;
+ /* Handle wake events */
+ if ( fd == wake_sds[0] ) {
+ char c[BUFSIZ];
+ waking = 0;
+ tcp_read( wake_sds[0], c, sizeof(c) );
+ break;
+ }
if( SLAP_EVENT_IS_WRITE( i ) ) {
Debug( LDAP_DEBUG_CONNS,
}
+#ifdef LDAP_CONNECTIONLESS
+static int connectionless_init(void)
+{
+ int l;
+
+ for ( l = 0; slap_listeners[l] != NULL; l++ ) {
+ Listener *lr = slap_listeners[l];
+ long id;
+
+ if( !lr->sl_is_udp ) {
+ continue;
+ }
+
+ id = connection_init( lr->sl_sd, lr, "", "", CONN_IS_UDP, (slap_ssf_t) 0, NULL );
+
+ if( id < 0 ) {
+ Debug( LDAP_DEBUG_TRACE,
+ "connectionless_init: failed on %s (%d)\n", lr->sl_url, lr->sl_sd, 0 );
+ return -1;
+ }
+ lr->sl_is_udp++;
+ }
+
+ return 0;
+}
+#endif /* LDAP_CONNECTIONLESS */
+
int slapd_daemon( void )
{
int rc;
connections_init();
+#ifdef LDAP_CONNECTIONLESS
+ connectionless_init();
+#endif
#define SLAPD_LISTENER_THREAD 1
#if defined( SLAPD_LISTENER_THREAD )
projects / openldap / blobdiff